class Player
{
public:
Player();
~Player();
void displayPlayer(); //Display the player
};
class Attacker : public Player
{
public:
Attacker();
~Attacker();
void checkPositionType();
};
Player* attacker = new Attacker
attacker->displayPlayer();
attacker->checkPositionType();
class Actor {public: // Interface function void draw() { draw_it(); } virtual int get_hp() = 0; // This is "pure virtual," define it in child classes};class Player : public Actor {public: virtual int get_hp() { return max_hp - damage; }};class Attacker : public Actor {public: virtual int get_hp() { return hp_level[level] - damage; }};bool is_dead( Actor* a ) { // Return true if hp is less than 0 return a->get_hp() < 0;}Quote:Original post by ToohrVyk
Does it make sense for you to get get the position type of a player?
If it does, then give the player class a getPositionType function.
If it doesn't, then don't call getPositionType on a pointer-to-a-player, precisely because it doesn't make sense.
After all, your pointer may well be pointing to a non-attacker object, at which point calling the function simply cannot work. Of course, if you know that the object you are handling is an attacker, then why do you have a pointer-to-a-player instead of a pointer-to-an-attacker?
Quote:Original post by John Matrix
Then depending on which type it points to (which I will have worked out) I need to call approriate functions which are specific to the type of class which is being pointed to.
Quote:Original post by UziMonkey
You've declared a pointer to a Player. At compile time, the compiler only knows the method names of the Player methods. Any child class methods are unavailable the way you've done it.
What I would do is define some sort of interface. Make an Actor class, a base class that both Player and Attacker inherit from. This class doesn't so anything itself, but it does define the interface that all objects of this type must implement. You can also put any code common to all of the types directly in this class.
*** Source Snippet Removed ***
Now, you can do things like this:
*** Source Snippet Removed ***
Quote:Original post by John Matrix
Now I beleive I can get around this by putting the 'checkPositionType()' function that is in the derived Attacker class in the base Player class as a virtual function so that it gets overwritten but is there a way I can avoid doing this and only have the function in the derived class yet still call it using a Player pointer?
Quote:Original post by stonemetal
Yes you can cast the player pointer to an attacker with dynamic_cast.
Quote:Original post by ToohrVykQuote:Original post by John Matrix
Then depending on which type it points to (which I will have worked out) I need to call approriate functions which are specific to the type of class which is being pointed to.
In short, you have a function which, depending on the type the pointer points to, will do different things. This is the textbook definition of a virtual function.
Which brings me to my next question: why do you make the effort, in that function, to determine the type of the object and then try to cast it back to the correct type in order to call its member functions, when you could wrap all that behavior into a single virtual function which needs no type-determination or type-casting to do its work?
Quote:Original post by John Matrix
But I don't think these are functions which depending on the type the pointer points to will do different things. I'm dealing with functions that are specific to each derived class, that is a function that an attacker needs but a defender does not need.
It was my understanding that I would use a virtual function when the function in the base class is used in BOTH the derived classes. So a generic function like 'updatePlayer()' is needed in both the attacker AND the defender class so I make this virtual in the base class and overwrite it in each of the base classes.
Quote:
But ONLY an attacker will make an action like 'shootToGoal()', a defender doesn't need this function as it is only concerned with preventing a shot. So to include it in the base class as a virtual function would be useless as the defender doesn't need it. I hope I understood your question and I'm not barking up the wrong tree here.
