Связывание виртуальных функций

Question

Привет, ребята, вопрос о привязке виртуальных функций не знает, есть ли такая вещь, поэтому я хочу спросить об этом.

У меня есть машина для игры в состояние. Класс GameState является основным классом для всех государственных объектов, GameStateFirstPhase - это класс для сущности только для этих трех классов (StartUp, SelectServer, ConnectServer).

Итак, что я хочу сделать, это разделить функцию рисования и нарисовать всю сущность этих трех классов внутри класса GameStateFirstPhase, и эти 3 класса имеют свою собственную функцию рисования только для определенных вещей, которые для этого класса, например Класс GameStateSelectServer должен был бы нарисовать панель управления + пользовательский интерфейс для всех классов, который является классом GameStateFirstPhase.

Вот как я хочу привязать функцию DrawStateFirstFhase Draw с помощью функции GameStateFirstPhase Draw. У моего игрового объекта есть указатель на CurrentState и называет его функцией CurrentState Draw.

Я попытался вызвать функцию класса Жеребьевка Entity внутри CurrentState Draw функции, как это:

GameStateFirstPhase::Draw(gfx); 

, но я думаю, что это незаконно, чтобы сделать. Надеюсь, вы получите то, что я пытаюсь сделать, и это имеет смысл. Я также даю изображение, которое я все объясняю.

Вопрос в том, можно ли связать GameStateFirstPhase Draw функции с одним из этих состояний Draw функции (StartUp, SelectServer, ConnectSeerver состояния) связываю я имею в виду, чтобы получить, что родительское поведение и добавить ребенок рисовать, а

Answer 1

«... bind, я имею в виду, чтобы получить поведение этого родителя и добавить рисование ребенка».

Если вы столкнулись с вопросом о полиморфизме, «bind» не является приемлемым термином. Исследование «virtual», это модификатор метода.

Нет, поведение базового класса (родителя) (называть его «foo()») не задействовано при вызове производного foo(). Полученный foo() не добавляется к родительскому 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 

Извините, это так тривиально ... Я надеюсь, что это помогает привести вас в исследование виртуального, чистого виртуального и т. д.