A game class design question

[Catfish]

Hello everybody. This is a hypothetical question.

Let's say I have two classes, a Car and the player's HeadsUpDisplay.
The HeadsUpDisplay display certain things it gets from Car, like speed_ and fuel_.
The HeadsUpDisplay should also be able to "switch" Cars.

Thinking about this I reached the conclusion that I could have a const Car *car_; inside the HeadsUpDisplay class, and when everything is done I'd just set car_ = NULL;.

There would also be a HeadsUpDisplay::set_car(const Car &car) {car_ = &car;}.

My questions are, how would you do this yourself, and is my method flawed?

Thank you for reading.

[firedraco]

Sounds fine to me. I'd probably make the HUD class part of the car though (but that's just me).

[zb0S216C]

If the HUD is the same for all the cars (graphically), then you should only refer to one instance of the HUD class/struct. If they're different, then you could do a few things:

1) Create a vector (or something similar) that contains the HUD for each vehicle. Each HUD has an attached identifier. The identifier is used to link the HUD to the vehicle that has the same identifier (be careful! don't give two or more HUDs the same identifier).

2) Make the HUD part of the base vehicle class (like what Firedraco said).

_Wazzak

[Catfish]

Making the HUD part of the Car makes a lot of sense for different HUDs.

If I go that way, should the HUD be a friend class of the Car, and then pass the Car's this to the HUD constructor?

I assumed that by "being a part of" you meant being an instantiated object.

[m4ster r0shi]

Catfish wrote:

[...] should the HUD be a friend class of the Car [...] ?

If you make HUD a nested class you don't have to make it a friend.
A nested class is a  member  of the enclosing class and, as such, it
can freely access  the  enclosing  class's other  (private)  members.

#include <iostream>

class Outer
{
    class Inner
    {
        Outer * owner;

    public:

        Inner(Outer * owner_): owner(owner_) {}

        void DoIt()
        {
            std::cout
                << owner->data
                << std::endl;
        }
    };

    int data;
    Inner inner;

public:

    Outer(int n): data(n), inner(this) {}

    void DoIt() { inner.DoIt(); }
};

int main()
{
    Outer outer(10);

    outer.DoIt();
}

You might also want to google 'observer pattern'.

[Catfish]

Thanks r0shi, I didn't know about nested classes.
But can nested classes contain virtual members to be overridden?

I'm also thinking that the Car class could become the superclass for say a Ferrari class which indeed can have its own HUD, but that doesn't feel right.

[m4ster r0shi]

Catfish wrote:

But can nested classes contain virtual members to be overridden?

Sure.

Catfish wrote:

I'm also thinking that the Car class could become the superclass
for say a Ferrari class which indeed can have its own HUD

I guess you could do something like this:

#include <iostream>

class Car
{
protected:

    class HUD
    {
        Car * owner;

    public:

        HUD(Car * owner_): owner(owner_) {}

        virtual ~HUD() {}
    };

    HUD * hud;

public:

    Car() {}

    virtual ~Car() {}
};

class Ferrari : public Car
{
    class FerrariHUD : public Car::HUD
    {

    public:

        FerrariHUD(Car * owner_): Car::HUD(owner_) {}

        ~FerrariHUD()
        {
            std::cout
                << "~FerrariHUD"
                << std::endl;
        }
    };

public:

    Ferrari() { hud = new FerrariHUD(this); }

    ~Ferrari() { delete hud; }
};

class Lamborghini : public Car
{
    class LamborghiniHUD : public Car::HUD
    {

    public:

        LamborghiniHUD(Car * owner_): Car::HUD(owner_) {}

        ~LamborghiniHUD()
        {
            std::cout
                << "~LamborghiniHUD"
                << std::endl;
        }
    };

public:

    Lamborghini() { hud = new LamborghiniHUD(this); }

    ~Lamborghini() { delete hud; }
};

int main()
{
    Car * car1 = new Ferrari;
    Car * car2 = new Lamborghini;

    delete car1;
    delete car2;

    return 0;
}

I'm not sure if this is the best way to do it though...