C++ 在变形设计中使用数组

我刚刚开始真正理解多态性，但这对我来说仍然是一个新的话题。 所以这就是我的问题：我必须去上课，去对付敌人和银行抢劫犯。然而，银行劫匪继承自 敌人。我试着组成一个由10名银行劫匪组成的阵列。然后一个全局函数应该使用数组的所有成员来做一些事情，我想这是一个毫无价值的描述，下面是代码：

void UpdateEnemies(Enemy * p_Enemy, int counter) { 
    for(unsigned int i = 0;i < counter;i++) { 
        p_Enemy[i].Update(); 
    } 
}

int main(void) { 
    BankRobber EnemyArray[10]; 
    Enemy * p_Enemy = new BankRobber(13,1); 
    UpdateEnemies(EnemyArray,10); 
    system("PAUSE"); 
};   

void UpdateEnemies（敌人*p_敌人，int计数器）{
对于（无符号整数i=0；i

我为任何语言错误道歉。我不是以英语为母语的人

---

我的实际问题是：这段代码只是为了练习，所以目的只是为了在控制台上看到数组中每个成员的10次更新。因此函数updatenemys应该调用所有的敌方.update函数。类型转换的方法不是我想要的，因为它不再是动态的，因为以后会有更多的敌人。不仅仅是银行劫匪。

事实上，你没有说问题出在哪里

您是否尝试在代码内部强制转换？比如：

void UpdateEnemies(Enemy * p_Enemy, int counter) { 
    BankRobber *pRobber = (BankRobber*)p_Enemy;
    for(unsigned int i = 0;i < counter;i++) { 
        pRobber[i].Update(); 
    } 
}

void UpdateEnemies（敌人*p_敌人，int计数器）{
银行劫匪*pRobber=（银行劫匪*）p_敌人；
对于（无符号整数i=0；i

事实上，您没有确切说明问题所在

您是否尝试在代码内部强制转换？比如：

void UpdateEnemies(Enemy * p_Enemy, int counter) { 
    BankRobber *pRobber = (BankRobber*)p_Enemy;
    for(unsigned int i = 0;i < counter;i++) { 
        pRobber[i].Update(); 
    } 
}

void UpdateEnemies（敌人*p_敌人，int计数器）{
银行劫匪*pRobber=（银行劫匪*）p_敌人；
对于（无符号整数i=0；i

像这样声明一组银行劫匪

BankRobber EnemyArray[10];

Enemy * p_Enemy;    
p_Enemy[i].Update();

而不是像这样通过基类指针访问它们

BankRobber EnemyArray[10];

Enemy * p_Enemy;    
p_Enemy[i].Update();

不起作用。这是因为将使用offcet

sizeof（敌方）

但是，

sizeof（bankrober）

可能比

sizeof（敌人）

大，所以p_敌人[i]会在错误的地方结束

您应该使用指针向量，例如

std::vector<Enemy*>

std:：vector

---

这样，如果将指向不同对象的指针添加到向量中，也可以使用多态性。而且你不需要通过丑陋的

int计数器

到处

宣布这样一个银行劫匪阵列

BankRobber EnemyArray[10];

Enemy * p_Enemy;    
p_Enemy[i].Update();

而不是像这样通过基类指针访问它们

BankRobber EnemyArray[10];

Enemy * p_Enemy;    
p_Enemy[i].Update();

不起作用。这是因为将使用offcet

sizeof（敌方）

但是，

sizeof（bankrober）

可能比

sizeof（敌人）

大，所以p_敌人[i]会在错误的地方结束

您应该使用指针向量，例如

std::vector<Enemy*>

std:：vector

---

这样，如果将指向不同对象的指针添加到向量中，也可以使用多态性。您不需要传递丑陋的

int计数器

左右

多态性只对单个对象有效，通过引用或指向基类的指针访问。它不适用于对象数组：要访问数组元素，元素大小必须是已知的，如果有指向基类的指针，则情况并非如此

您需要一个额外的间接层：一个指向单个对象的指针数组，沿着

void UpdateEnemies(Enemy ** p_Enemy, int counter) { 
    for(unsigned int i = 0;i < counter;i++) { 
        p_Enemy[i]->Update(); 
    } 
}

int main() {
    // An array of Enemy base-class pointers
    Enemy * EnemyArray[10]; 

    // Populate with pointers to concrete Enemy types
    for (unsigned i = 0; i < 9; ++i) {
         EnemyArray[i] = new BankRobber;
    }

    // Of course, the array can contain pointers to different Enemy types
    EnemyArray[9] = new Dragon;

    // The function can act polymorphically on these
    UpdateEnemies(EnemyArray,10);

    // Don't forget to delete them. Enemy must have a virtual destructor.
    for (unsigned i = 0; i < 10; ++i) {
         delete EnemyArray[i];
    }
}

void UpdateEnemies（敌人**p_敌人，int计数器）{
对于（无符号整数i=0；i更新（）；
} 
}
int main（）{
//敌人的基类指针数组
敌人*敌人阵阵[10]；
//用指向具体敌人类型的指针填充
for（无符号i=0；i<9；++i）{
EnemyArray[i]=新的银行劫匪；
}
//当然，数组可以包含指向不同敌人类型的指针
EnemyArray[9]=新龙；
//该函数可以多态地作用于这些对象
更新emies（EnemyArray，10）；
//别忘了删除它们。敌人必须有一个虚拟的析构函数。
for（无符号i=0；i<10；++i）{
删除EnemyArray[i]；
}
}

---

您还应该考虑使用诸如容器和智能指针之类的类型来管理这些动态资源；但这超出了这个问题的范围。

多态性只适用于单个对象，通过引用或指向基类的指针访问。它不适用于对象数组：要访问数组元素，元素大小必须是已知的，如果有指向基类的指针，则情况并非如此

您需要一个额外的间接层：一个指向单个对象的指针数组，沿着

void UpdateEnemies(Enemy ** p_Enemy, int counter) { 
    for(unsigned int i = 0;i < counter;i++) { 
        p_Enemy[i]->Update(); 
    } 
}

int main() {
    // An array of Enemy base-class pointers
    Enemy * EnemyArray[10]; 

    // Populate with pointers to concrete Enemy types
    for (unsigned i = 0; i < 9; ++i) {
         EnemyArray[i] = new BankRobber;
    }

    // Of course, the array can contain pointers to different Enemy types
    EnemyArray[9] = new Dragon;

    // The function can act polymorphically on these
    UpdateEnemies(EnemyArray,10);

    // Don't forget to delete them. Enemy must have a virtual destructor.
    for (unsigned i = 0; i < 10; ++i) {
         delete EnemyArray[i];
    }
}

void UpdateEnemies（敌人**p_敌人，int计数器）{
对于（无符号整数i=0；i更新（）；
} 
}
int main（）{
//敌人的基类指针数组
敌人*敌人阵阵[10]；
//用指向具体敌人类型的指针填充
for（无符号i=0；i<9；++i）{
EnemyArray[i]=新的银行劫匪；
}
//当然，数组可以包含指向不同敌人类型的指针
EnemyArray[9]=新龙；
//该函数可以多态地作用于这些对象
更新emies（EnemyArray，10）；
//别忘了删除它们。敌人必须有一个虚拟的析构函数。
for（无符号i=0；i<10；++i）{
删除EnemyArray[i]；
}
}

---

您还应该考虑使用诸如容器和智能指针之类的类型来管理这些动态资源；但是这超出了这个问题的范围。

我对这一评论感到非常抱歉，但我无法让突出显示发挥作用。void UpdateEnemies（敌人*p_敌人，int counter）{for（unsigned int I=0；I