虚函数绑定

Question

大家好有关于虚函数绑定的问题，不知道是否有这样的事情，所以我想问一下这个问题。

所以我有一个Game State机器。 GameState类是所有状态实体的主类，GameStateFirstPhase是仅用于其他3个类（StartUp，SelectServer，ConnectServer）的实体类。

那么我想要做的是分割一个绘制函数并在GameStateFirstPhase类中绘制这三个类的所有实体，并且这3个类只有针对该类的特定事物有自己的绘制函数，如GameStateSelectServer class必须绘制一个UI选择服务器面板+所有类的实体，即GameStateFirstPhase类。

这就是我想要将CurrentState绘制函数与GameStateFirstPhase Draw函数绑定的方式：我的游戏对象有一个指向CurrentState的指针并将其称为CurrentState Draw函数。

我试图在CurrentState Draw函数中调用Entity类绘制函数，如下所示：

GameStateFirstPhase::Draw(gfx); 

但我觉得这样做是违法的。我希望你得到我想做的事情，这是有道理的。我也给出了我解释一切的图像。

问题是，是否可以将GameStateFirstPhase Draw函数与其中一个状态绑定Draw函数（StartUp，SelectServer，ConnectSeerver状态）绑定我的意思是获取父行为并添加子绘图

Answer 1

＆＃34; ...绑定我的意思是获得父行为并添加子绘图。＆＃34;

如果你开始询问多态性，那么就会绑定＆＃39;不是可用的术语。研究＆＃39;虚拟＆＃39;，这是关于方法的修饰语。

不，当调用派生的foo（）时，不涉及基类（父）行为（称之为＆＃39; foo（）＆＃39;）。衍生的foo（）未被添加＆＃39;在一系列方法调用的意义上，对于父foo（）。

但是，派生的foo（）可以在执行的任何时刻调用基本的foo（）。

更新 - 添加小型示例基础/派生/使用虚拟

#include <iostream>
#include <vector>


 // base class
 class Foo
 {
 public:
    Foo() { std::cout << "Foo::Foo() " << std::endl; }

    virtual
    ~Foo() { std::cout << "Foo::~Foo() " << std::endl; }

    virtual void foo();
 };

 class Bar : public Foo
 {
 public:
    Bar() : Foo()
       { std::cout << "Bar::Bar() " << std::endl; }

    virtual
    ~Bar() { std::cout << "Bar::~Bar() " << std::endl; }

    virtual void foo();
 };

 void Foo::foo()  // virtual method
 {
    std::cout << " -- foo() in Foo " << std::endl;
 }

 void Bar::foo()  // also virtual method
 {
    Foo::foo();
    std::cout << " -- foo() in Bar " << std::endl;
    Foo::foo();
    std::cout << " -- foo() in Bar " << std::endl;
    Foo::foo();
 }


int testFoo(void)  // invoke from main
{
   std::cout << "\nsizeof(Foo): " << sizeof(Foo) << std::endl;
   std::cout << "sizeof(Foo*): " << sizeof(Foo*) << std::endl;

   std::cout << "\n";
   Foo* f = new Foo();   // ctor Foo one time

   std::cout << "\n";
   Bar* b = new Bar();   // ctor Foo + ctor Bar

   std::cout << "\n-----------------\n";
   f->foo();             // foo() in Foo

   std::cout << "\n";
   b->foo();             // foo() in xxx (5 lines)
   std::cout << "\n-----------------";

   // create a polymorphic vector
   std::vector<Foo*> fooVec;

   fooVec.push_back(f);  // Foo* added
   fooVec.push_back(b);  // Bar* added - accepted because "is-a" Foo
   // maybe 100's of different derived methods, added in arbitrary order

   for (auto x : fooVec )  // invoke foo() on ALL elements
   {
      std::cout << "\n";
      x->foo();
   }

   return(0);
}

输出

sizeof(Foo): 8
sizeof(Foo*): 8

Foo::Foo() 

Foo::Foo() 
Bar::Bar() 

----------------- 
 -- foo() in Foo 

 -- foo() in Foo 
 -- foo() in Bar 
 -- foo() in Foo 
 -- foo() in Bar 
 -- foo() in Foo 

-----------------
 -- foo() in Foo 

 -- foo() in Foo 
 -- foo() in Bar 
 -- foo() in Foo 
 -- foo() in Bar 
 -- foo() in Foo 

对不起，这太微不足道了......我希望它可以帮助你进入虚拟，纯虚拟等方面的研究。