C++ ist die Erstellung einer Kind-Klasse von einer Übergeordneten Klasse, die bereits initialisiert wurden

Die Idee mit Polymorphismus ist, dass, wenn Sie haben einige Klasse:

class Batter : public Player

Dann jeden Teig ist auch ein Spieler. So, zum Beispiel, wenn Sie hatte ein Teig namens dave, Sie würde in der Lage sein zu verwenden dave wo ein Spieler zu erwarten war. Sie könnten zum Beispiel:

int FunctionThatDoesSomething(Player &p, string some_parameter, ...);

...

FunctionThatDoesSomething(dave, "foo", ...);

Seien Sie vorsichtig, zu vermeiden Sie schneiden, das ist, wenn Sie aus versehen eine Basisklasse Exemplar einer Unterklasse (dieser nicht erhalten Unterklasse bestimmten Zustand. Wenn Sie brauchen, um passieren dave herum, stellen Sie sicher, dass Sie nur finden zu dave, nicht kopieren dave. dave mag es nicht, kopiert zu werden.)

Wie genau bauen Sie Ihre Spieler und Teige ist bis zu Ihnen. Zum Beispiel, Ihre möglicherweise Konstruktoren mit diesen Unterschriften:

Player::Player(string name, string role, int vFFDefense);
Batter::Batter(Player &p, int vTouch, int moreStats);

Unter gewissen Umständen mag dies bequem sein, aber es ist nicht besonders effizient, weil Sie haben zu erstellen und kopieren Sie die Basis-Klasse (nicht, dass Effizienz eine große Sache für kleine Klassen wie diese, aber es gibt keinen Punkt in versuchen, Dinge zu tun, die dumme Art und Weise). Sie wäre besser dran, einen Konstruktor, alles, was es braucht, und verwendet Unterobjekt Initialisierung:

Batter::Batter(string name, string role, int vFFDefense, int moreBaseStats, int vTouch, int moreStats) : Player(name, role, vFFDefense, moreBaseStats)
{
    ...

Aber Ihre Umsetzung ist letztlich Ihnen überlassen.

InformationsquelleAutor Wug

Es wirklich hängt davon ab, wie Sie eigentlich wollen, dass Ihr code einkalkuliert.
Werden von einem bestimmten Player immer alles andere als eine Batter? Wenn Sie können, dann ist es wahrscheinlich am besten, um die Verwendung der aggregation (in ähnlicher Weise, wie Sie jetzt tun).

Wenn Sie aggregieren dann vielleicht mit einer anderen Klasse, um die Daten aufzunehmen. Sie könnten eine PlayerInfo Klasse oder Struktur und Aggregat:

struct PlayerInfo
{
    string role_;
    int ff_defence_;
    ...
};

class Player 
{
public:
    Player(PlayerInfo const& info)
        : info_(info)
    {}
    virtual ~Player() = 0;
    virtual void doSomething();

    PlayerInfo const& getPlayerInfo() const { return info_; }
private:
    PlayerInfo info_;
};

class Batter : public Player
{
public:
    Batter(PlayerInfo const& info)
        : Player(info)
    {}
    virtual void doSomething();
};

Wenn Sie wirklich wollen, die erbschaft, die dann andere Antworten hier erzählen Sie, was Sie tun müssen - erstellen Sie eine Instanz der Batter auf und übergeben Sie dem Konstruktor Argumente, um einen Konstruktor der Klasse abgeleitet (z.B. Batter) zu initialisieren.

Denken Sie sorgfältig über das, was Sie auszudrücken versuchen in Ihrem code.

Dem Grund, die Sie haben wollen Batter abgeleitet von Player ist, wenn Sie virtuelle Funktionen in Player implementiert werden, in Batter und tun Sie etwas anders, je nachdem, ob oder nicht es ist ein Player oder eine Batter.

Nebenbei, seine besten zu halten Basisklassen abstrakte, wenn möglich, so Player würde nie direkt instanziert werden und würde immer abgeleitet werden müssen. Ich würde empfehlen, das Lesen von Scott Meyers " More effective C++', um zu verstehen, warum das so ist. Es gibt einen Abschnitt in der es gewidmet. In der Tat, einige der feineren Punkte des erbschaft-und OO-design im Allgemeinen sind schön erklärt.

Was können Sie eigentlich wollen, ist etwas anders, je nachdem, wo Sie glauben, Ihr Modell zu ändern, und zusätzlich wo Sie Sie brauchen, um das dynamische Verhalten durch die Verwendung von virtuellen Funktionen?

Haben, könnten Sie einen Player Klasse, die alle Ihre player-spezifische details. Dann könnten Sie eine PlayerBehaviour Klasse, die, was der Spieler tut:

class Player;

class PlayerBehaviour
{
public:
    virtual ~PlayerBehaviour() = 0;
    virtual void doSomething(Player* player) = 0;
};
inline PlayerBehaviour::~PlayerBehaviour() {}

class BatterBehaviour : public PlayerBehaviour
{
public:
    virtual void doSomething(Player* player) {
        if (player->isAngry()) {
            throwBatOnFloor();
        }
    }
    void throwBatOnFloor();
};

class Player {
public:
    Player(...stuff...);

    void doSomething() {
        if (behaviour_.get()) {
            behaviour_->doSomething(this);
        }
    }
private:
    auto_ptr<PlayerBehaviour> behaviour_;
    //Due to the auto_ptr, the default copy and assignment operators are
    //dangerous.  You could use a smart pointer or implement 
    //these by having a clone() function in the behaviour class.
    //Therefore copy/assign are private to prevent accidental misuse.
    Player(Player const&);
    Player& operator=(Player const&);
}; 

So, Erben Batter aus Player Modelle, die situation als Batter ist-ein Player.
Mit einem Behaviour Modelle, die situation als Player hat-ein Behaviour wie ein Batter.

InformationsquelleAutor Pete