C ++将父指针传递给父类构造函数

Question

I am currently developing a game in C++. Now I am a beginner in C++ and am just trying to get used to the concept of multiple inheritance. My game has a player class. That player class inherits from Positionable(gives the player x and y coords) and Moveable(allows the player to move around). The problem is that Moveable has to know the player coords to move him around adequately. Here's basic pseudo(ish) code of what I am trying to accomplish:

class Movable
{

private:
    Positionable *positionable;

public:
    Movable(Positionable *positionable)
        : positionable(positionable)
    { }

    void Translate(float x, float y)
    {
        positionable->setX(positionable->getX() + x);
        positionable->setY(positionable->getY() + y);
    }
}

class Positionable
{
private: 
    float x, y;
public:
    Positionable(float x, float y)
        : x(x),
        y(y)

    float getX() { return this->x; }
    float getY() { return this->y; }
    float setX(float val) { this->x = val; }
    float setY(float val) { this->y = val; }
}

class Player : public Positionable, public Movable
{
    Player(float x, float y)
        : Positionable(x, y)
        : Movable((Positionable) this)
    { }
}

...

Player player;
player.Translate(50, 50)

My question is is there a better way to pass Positionable to the constuctor of Movable, because if Moveable depended on 3 classes I would have to write something like Movable((FirstClass) this, (SecondClass) this, (ThirdClass) this) . This looks bad. Is there some way I can solve this problem better?

Answer 1

As @BandiKishore suggested in the comments, a better way is to inherit Movable from Positionable (and inherit Player from Movable only). Movable needs access to coordinates to do its moving work, and the name Movable suggests that it should move itself ( this ), not some other object (in which case it would be Mover or MovingHelper or smth. like that), so inheritance is more logical than delegation.

Player would have to invoke only one base constructor:

class Movable : public Positionable
{
public:
    Movable(float x, float y) : Positionable(x, y)
    { }
}

class Player : public Movable
{
    Player(float x, float y) : Movable(x, y)
    { }
}

Answer 2

I would turn your IPositionable class into a struct if you are only using it to hold/access X and Y values.

If you haven't used structs before, here is a brief overview: http://www.cplusplus.com/doc/tutorial/structures/

Now as far as your IMoveable class, I would put an IPositionable member in the class as you did but intialize it in your IMoveable contstructor. Here is a really rough example of what I mean:

    class IMovable
    {

     private:
        IPositionable *positionable;

     public:
        IMovable(int x, int y)
        { 
            positionable->setX(x);
            positionable->setY(y);
        }

        void Translate(float x, float y)
        {
            positionable->setX(positionable->getX() + x);
            positionable->setY(positionable->getY() + y);
        }
    }

then you'll have:

    class Player
    {
        private IMoveable moveable;
        Player(float x, float y)
            : moveable(x, y)
        { }
    }

    ...

    Player player(100, 100);
    player.Translate(50, 50);

This is merely building from your code example. I did not run this example locally.

Basically, you do not need to use multiple inheritance to accomplish this task. I would suggest not even using inheritance for this task as it is not needed and you should try not to use inheritance if you are not required to! It is something to be very cautious about.