"TargetClass"

Hi there /prog/

Is something like this possible?

For example, let's say that I have two classes:

class MyWorld
{
    public:
        MyWorld();
        void setup();
        void draw();
    //
};
...
class OtherWorld
{
    public:
        OtherWorld();
        void setup();
        void draw();
    //
};

Then, I'd like to have a "TargetWorld" class, where for example:


TargetWorld targetWorld;

targetWorld = myWorld;
...
targetWorld = otherWorld;

Then, I'd like to be able to call

targetWorld.draw();
targetWorld.setup();

And that would call the initial class's method.  I was thinking about using templates or class inheritance and virtual methods, but I'm not sure if that's the right path.

Is this really a question?
http://www.google.com.br/search?q=thinking+in+c%2B%2B


class TargetWorld {
public:
  virtual void setup ();
  virtual void draw () /* const? */;
};

Please explain what is a World. I have the feeling you're overcomplicating things in a typical OOP fashion.

virtual methods. how do they work
they are bad for your health however

>>5
your
Yor "British grammar" is incorrect and deprecated.

the right path is using roles

>>5
Holy shit, thank you!  I was honestly surprised that there weren't any issues compiling.  It looks like this:


#ifndef TARGETWORLD_H
#define TARGETWORLD_H
class TargetWorld
{
    public:
        TargetWorld();
        virtual void setup();
    //
};
#endif

#ifndef MAINMENUWORLD_H
#define MAINMENUWORLD_H
#include "TargetWorld.h"

class MainMenuWorld : public TargetWorld
{
    public:
        MainMenuWorld();
        void setup();
    //
};
#endif
...
#include "MainMenuWorld.h"
#include <iostream>

MainMenuWorld::MainMenuWorld()
{
    //
}

void MainMenuWorld::setup()
{
    std::cout << "Reached me!" << std::endl;
}

Setting targetWorld = mainMenuWorld; and calling targetWorld.setup(); doesn't call MainMenuWorld.setup();

How could I accomplish this?

>>8
not sure about your problem but initialize your virtual function as 0.
#include <iostream>

class TargetWorld
{
    public:
        TargetWorld();
        virtual void setup() = 0;
    //
};


TargetWorld::TargetWorld()
{
    //
}

class MainMenuWorld : public TargetWorld
{
    public:
        MainMenuWorld();
        void setup();
    //
};

MainMenuWorld::MainMenuWorld()
{
    //
}

void MainMenuWorld::setup()
{
    std::cout << "Reached me!" << std::endl;
}

int main(){
  TargetWorld *tw = new MainMenuWorld();
  tw->setup();
  return 0;
}

>>9
Thank you!  That's just what I was looking for, works great.  Is this faster than having lots of switch statements to determine render, input, and drawing?  Before, it looked like:

Input thread:

switch (CurrentWorld)
{
    case Worlds::MainMenu:
        mainMenuWorld.input(event);
    break;
    case Worlds::Level:
        levelWorld.input(event);
    break;
}

Main game loop:

//gameTime computation
{
    switch (CurrentWorld)
    {
        case Worlds::MainMenu:
            mainMenuWorld.update();
        break;
        case Worlds::Level:
            levelWorld.update();
        break;
    }
}

//Drawing logic:
switch (CurrentWorld)
{
    case Worlds::MainMenu:
        mainMenuWorld.draw();
    break;
    case Worlds::Level:
        levelWorld.draw();
    break;
}

I assume using the virtual methods are a lot faster then having many switch statements.

>>10
It probably isn't faster, but it probably isn't slower unless the compiler knows the type at compile time.

>>10

Smart compilers try to unroll polymorphic methods.

>>12

otherwise polymorphic methods are just function pointers.

If it ain't Lisp, it's crap.