Question

好吧，我正在编写一个游戏，其中包含一个辅助类（敌人）的向量，这些游戏将充满子类（goomba，koopa，boss1），当我调用更新它时我需要这样做调用子类各自的更新。我设法创建了一个问题的例子。

#include <stdio.h>
class A{
    public:
        virtual void print(){printf("Hello from A");}
};

class B : public A{
    public:
        void print(){printf("Hello from B");}
};


int main(){
    A ab = B();
    ab.print();
    while(true){}
}

输出需要：“你好B” 输出得到：“你好，来自A”

如何调用B的打印功能？

Answer 1

多态性仅适用于指针和引用。如果您将B分配给A，则会变为 A，并且您将丢失所有B特定信息，包括方法覆盖。这称为“切片”;当B部分被分配给父类的对象时，B*部分被“切片”。

另一方面，如果您将A*分配给A*，则看起来像<{1}} ，但仍然指向B {1}}，因此B特定信息仍然存在，并且将使用B的虚拟覆盖。

尝试：

int main(){
    A* ab = new B();
    ab->print();
    delete ab;
    while(true){}
}

同样适用于将B分配给A&（引用至A），例如

int main(){
    B b;
    A& ab = b;
    ab.print();
    while(true){}
}

Answer 2

您的虚拟关键字已正确放置，但您需要使用指针或引用。

Answer 3

您需要在后代类进行任何处理之前调用父级的update方法：

struct Base_Class
{
  virtual void update(void)
  {
    cout << "Updating Base_Class.\n";
  }
};

struct Goomba : public Base_Class
{
  void update(void)
  {
     // Invoke the parent method first.
     Base_Class::update();

     // Perform Descendant operations
     cout << "Updating Goomba\n";
  }
};

以下是实施：

#include <iostream>
using std::cout;

void Update_Player(Base_Class& b)
{
  b.update();
  return;
}

int main(void)
{
   Goomba g;
   g.update();

   Goomba g2;
   std::vector<Base_Class *> container;
   container.push_back(&g);
   container.push_back(&g2);

   std::vector<Goomba>::iterator iter;
   for (iter =  container.begin();
        iter != container.end();
        ++iter)
   {
       Update_Player(*(*iter));
   }

   return 0;
}

问题覆盖虚函数

3 个答案: