基类中派生类的组成

Question

for example. We have class A and its derived class; class B . Is it possible to instantiate a pointer of type B in class A ?

#ifndef WARRIOR_H
#define WARRIOR_H

#include "CharacterPlayer.h"
class Warrior: public CharacterPlayer
{
public:
    virtual void printCharacterName();
};
#endif

however, when i try to instantiate a Warrior pointer or try to include "Warrior.h", it gives me a number of syntax errors.

#ifndef CHARACTERPLAYER_H
    #define CHARACTERPLAYER_H
    #include "Warrior.h"
    class CharacterPlayer
    {
    public:
        Warrior *warriorPntr = nullptr;
        virtual void printCharacterName();

    };
    #endif

Answer 1

You have a circular dependency among your headers: "CharacterPlayer.h" includes "Warrior.h" , and "Warrior.h" includes "CharacterPlayer.h" . This cannot compile, because the "sentinel" will stop inclusion.

The trick is to forward-declare the Warrior class in the CharacterPlayer instead of including a header:

#ifndef CHARACTERPLAYER_H
#define CHARACTERPLAYER_H
class Warrior; // <<== Here
class CharacterPlayer
{
public:
    Warrior *warriorPntr = nullptr;
    virtual void printCharacterName();

};
#endif

This is good enough to declare pointers and references to Warrior , but not enough to call methods or instantiate the class.

You need to eventually include the header for Warrior in the cpp file CharacterPlayer.cpp , but that would not lead to any issues, because there is no circular dependency among your headers.

Answer 2

You can, but it's not a good idea.

To do it, simply remove the "#include "Warrior.h" from your second header, and replace it with a declaration of the form "class Warrior;"

As to why it is a bad idea: making a base class contain a pointer to (or an instance of) a derived class is one way (of several) that ensures implementation of the base class depends on implementation of the derived class. Generally speaking, the definition of derived class should depend on the base class, not the reverse, in order to avoid circular dependencies, to allow the base class to be used polymorphically (look up "Liskov Substitution Principle), etc etc.

This means, although it can be done, your design is fundamentally flawed. It would prevent you doing other useful things in future.