Thread: Help with inheritance and virtual functions

You should declare the destructor of the base class to be virtual, and also define it, e.g.,

Code:

class Actor
{
    public:
        // ...
        virtual ~Actor() {}
        // ...
};

Then remember to delete what you new.

Incidentally, you are overriding the virtual functions to do the same thing as the original, so that's not very useful, but I guess you're just trying to get it to compile and run correctly for now.

Originally Posted by CH1156

Ok so i changed that and deleted my object, but when its called, it just says "Default_Actor" instead of giving the name of the dinosaur.

That's because in the constructor for Actor, you always set the hardcoded default values instead of forwarding the values provided by the invocation of the constructor. If you want default values, one option is to use default arguments, though then you should declare the constructor to be explicit unless you want implicit conversions, e.g., if this does not make sense:

Code:

Actor actor = 20;

Originally Posted by CH1156

How should i do it?

For example, perhaps a special characteristic of the velociraptor is that when it is badly injured, its effective attack power is doubled from the base value. In that case, perhaps you might do something like this:

Code:

#include <iostream>
#include <string>

class Actor
{
public:
    explicit Actor(float actorHealth=100, std::string actorName="Default_Actor", float actorAttackPower=0):
        actorHealth(actorHealth), actorName(actorName), actorAttackPower(actorAttackPower) {}

    virtual ~Actor() {}

    virtual std::string GetName() const
    {
        return actorName;
    }

    virtual float GetHealth() const
    {
        return actorHealth;
    }

    virtual float GetAttackPower() const
    {
        return actorAttackPower;
    }
protected:
    float actorHealth;
    std::string actorName;
    float actorAttackPower;
};

class Velociraptor : public Actor
{
public:
    Velociraptor(float actorHealth, float actorAttackPower):
        Actor(actorHealth, "Velociraptor", actorAttackPower) {}

    float GetAttackPower() const
    {
        return (actorHealth < 20) ? (actorAttackPower * 2) : actorAttackPower;
    }
};

class TRex : public Actor
{
public:
    TRex(float actorHealth, float actorAttackPower):
        Actor(actorHealth, "T-Rex", actorAttackPower) {}
};

void print(const Actor& actor)
{
    std::cout << actor.GetName() << " has " << actor.GetHealth()
        << " health and will attack you for " << actor.GetAttackPower()
        << " points of damage!\n";
}

int main()
{
    Velociraptor healthyVelociraptor(100, 40);
    print(healthyVelociraptor);
    Velociraptor injuredVelociraptor(15, 40);
    print(injuredVelociraptor);

    TRex injuredTrex(15, 90);
    print(injuredTrex);
}

Notice that I declared the getter functions to be const since they do not modify the logical/observable state of the object. I simplified by not using new or delete; polymorphism comes into play in the print function instead.

Originally Posted by CH1156

I want to back up to just inheritance for a moment.

Inheritance usually goes together with polymorphism. It doesn't have to, but then that means you're probably inheriting to inherit implementation, which can be fine, but often also can be done in other ways, e.g., perhaps composition would be better, or perhaps you should do private inheritance to inherit implementation because there isn't really an is-a relationship.

Originally Posted by CH1156

Is this the correct way to do inheritance?

Sure, but if you think about it, you only need the KActor class. For example:

Code:

#include <iostream>
#include <string>
#include <vector>

class KActor // Killable Actor, only applies to living beings.
{
public:
    void SetActorWeight(float KAct_wgt);
    float GetActorWeight()const {return actorWeight;}

    void SetActorName(std::string KAct_actrNme);
    std::string GetActorName()const {return actorName;}
private:
    float actorWeight;
    std::string actorName;
};

int main()
{
    KActor Velociraptor;

    Velociraptor.SetActorName("Velociraptor");
    Velociraptor.SetActorWeight(210);

    std::cout << "Dinosaur Info: \n" << std::endl;

    std::cout << "Name: " << Velociraptor.GetActorName() << std::endl;
    std::cout << "Weight: " << Velociraptor.GetActorWeight() << " LBS." << std::endl;

    KActor player;

    player.SetActorName("Dino Slayer");
    player.SetActorWeight(260);

    std::cout << "Player Info: \n" << std::endl;

    std::cout << "Player Name: " << player.GetActorName() << std::endl;
    std::cout << "Player Weight: " << player.GetActorWeight() << std::endl;
}

That is, inheritance added no value at all to your code, and in fact worsened it by adding unnecessary code that needed to be written and read for no good reason.

Originally Posted by CH1156

I'm unsure what would really be specific to a dinosaur that wouldnt work for all of them.

Basically, you have a solution looking for a problem :P

I suggest that you start by reading these articles, in PDF format:
The Open-Closed Principle
The Liskov Substitution Principle
The Dependency Inversion Principle
The Interface Segregation Principle
They should give you an idea of some ways by which inheritance and polymorphism might be used.