Question

在C ++中，我有一个指向Player对象的指针数组，并希望用Fickle对象填充它，其中Fickle是一个派生自Player的类。这是因为我想要一个通用的Player数组，我可以用来自不同类的不同对象来填充所有来自Player类的对象。

我该怎么做？

我创建了一个指向Player对象的指针数组

Player ** playerArray;

然后将数组初始化为特定大小

playerArray = new Player *[numPlayersIn];

但是由于某种原因，以下内容无效：

playerArray[i] = new Fickle(0);

如何用Fickle对象填充playerArray（Fickel是一个派生自Player的类）？

感谢。

更新：

我收到错误消息（在Eclipse IDE中）：

expected ';' before 'Fickle'

我认为这可能与Fickle的定义有关。

Fickle.hpp文件包含：

#pragma once
#include "player.hpp";

class Fickle: public Player {
public:
    // constructor
    Fickle(int initChoice){
        choice = initChoice;
    }
}

这样可以，还是有问题？

Player类头文件包含：

class Player {
private:

public:
    int getChoice();
int choice; // whether 0 or 1
virtual void receive(int otherChoice); // virtual means it can be overridden in subclases
};

接收方法将在Fickle和从Player类派生的其他类中重写

更新2：

好的我认为错误实际上是由于代码的不同部分造成的。

Player定义了一个方法receive：

virtual void receive(int otherChoice);

这应该被子类Fickle覆盖，但是Fickle中的定义：

void Fickle::receive(int otherChoice) {}

给出错误：

no 'void Fickle::receive(int)' member function declared in class 'Fickle'

但我不知道为什么这是因为接收是在Player类中定义的？

Answer 1

虽然您可能应该使用向量，但动态分配的数组无法工作并不是真正的原因。这是一些有用的演示代码：

#include <iostream>

class Player {
public:
    virtual void show() { std::cout << "Player\n"; }
};

class Fickle : public Player {
public:
    virtual void show() { std::cout << "Fickle\n"; }
};

int main() {
    Player **p = new Player *[2];
    p[0] = new Player;
    p[1] = new Fickle;

    for (int i=0; i<2; i++)
        p[i]->show();

    for (int i=0; i<2; i++)
        delete p[i];
    delete [] p;
    return 0;
}

Answer 2

看起来你在Fickle课程结束时忘记了一个分号：

class Fickle: public Player {
    // ...
}; // <---- this semicolon

也许在其他地方。

更新2：当你在派生类中覆盖虚函数时，你也必须在那里声明它。

Answer 3

如果它没有正确编译，那么您可能没有#include在您拥有该代码的同一源文件中定义Fickle的标头。通常这样的错误意味着编译器不知道Fickle是什么。

Answer 4

Fickle是否有一个接受int或指针类型的构造函数？它是私人派生自Player吗？否则它看起来应该有效。

C ++填充数组，其中包含从数组类型派生的对象

4 个答案: