Вычисление класса наследуемого объекта

Question

У меня есть связанный список Foo объектов. Foo - это базовый класс, который наследует от него несколько классов. Скажем, классы A, B, and C.

Я еду через этот связанный список и вызывая метод some_method, который имеет 3 определения; один для каждого дочернего класса:

some_method(A a); 
some_method(B b); 
some_method(C c); 

Связанный список является общим, поэтому он имеет тип Foo, как это имеет ассортимент A, B и C объектов.

Когда я еду через связанный список по адресу current_element, позвонив по телефону some_method(current_element);, как я могу заставить его вызвать правильный метод? Компилятор жаловался, пока не написал некоторый метод, который принял общий Foo, и он вызывает только этот метод.

Answer 1

В зависимости от ваших требований, вы можете захотеть использовать полиморфизм. Чтобы сделать это, добавьте чистый виртуальный метод в свой базовый класс узла и переместите соответствующие методы в производные классы.

class Foo 
{ 
public: 
    virtual void some_method() = 0; 
}; 

class A : Foo 
{ 
public 
    virtual void some_method() 
    { 
    // move the body of some_method(A a) here 
    } 
}; 

Для этой работы, ваш связанный список потребуется Foo*, вместо Foo.

class Node 
{ 
public: 
    Foo* foo; 
    Node* next; 
}; 

// ... 

Node* someNode = GetNode(); 
// Calls correct method - A::some_method, B::some_method, or C::some_method 
someNode->foo->some_method(); 

Если вы не можете положить some_method в Foo/A/B/C, то вы можете посмотреть в шаблон дизайна для посетителей:

http://en.wikipedia.org/wiki/Visitor_pattern

Answer 2

RTTI Ваш друг здесь. Ниже приведен пример, приведенный в ссылке

Answer 3

Вы можете вызвать метод для дочернего класса как метод-член. Например, A a = new A(); a.some_method() должен вызвать правильный метод. Внутри some_method() вы можете ссылаться на объект, используя ключевое слово this.

Answer 4

двумя способами:

1) лучший способ:

Обратный дизайн, чтобы someMethod был виртуальным методом базового класса Foo и переопределял его в производных классах. Как:

class Foo { 
    public: 
     virtual void someMethod() = 0; 
}; 

class A { 
    public: 
     void someMethod() { /* implementation specific to A here */ }; 
}; 

class B { 
    public: 
     void someMethod() { /* implementation specific to B here */ }; 
}; 

class C { 
    public: 
     void someMethod() { /* implementation specific to C here */ }; 
}; 

Затем вызов SomeMethod на указатель Foo будет автоматически вызывать метод из соответствующего класса. Если это невозможно сделать, потому что someMethod не может быть реализован как часть Foo или его производных (например, ему нужен доступ к закрытым членам класса, в котором он находится в вашем дизайне), тогда вы можете попытаться разделить эту функциональность на подзадачи, которые могут быть введены в виртуальные методы этих классов ABC.

2) "У меня нет выбора" путь:

Использование RTTI (Run-Time Type Identification), он включен в C++. Это требует, чтобы ваш базовый класс Foo имел хотя бы один виртуальный метод.Вам нужно #include <typeinfo>, затем используйте указатель typeid(), он вернет объект type_info, и вы можете сравнить его результат name() с именами классов AB и C. Это не очень хороший подход, потому что он имеет больше накладных расходов и нарушает принципы проектирования ООП. Но если это единственный вариант, все в порядке.

Answer 5

Это проблема с «двойной отправкой». Вы можете использовать шаблон посетителя. Обычно посетитель является базовым классом, поэтому вы можете повторно использовать этот проект для множества проблем.

#include <iostream> 
class FooVisitor; 

class Foo 
{ 
public: 
    virtual void some_method() = 0; 
    virtual void visit(FooVisitor* v) = 0; 
}; 

class A; 
class B; 
class FooVisitor 
{ 
public: 
    virtual void visit(A* a){ std::cout << "A" << std::endl;} 
    virtual void visit(B* b){std::cout << "B" << std::endl;} 
}; 

class A : public Foo 
{ 
public: 
     virtual void some_method() 
    { 
     // move the body of some_method(A a) here 
    } 
    virtual void visit(FooVisitor* v) { v->visit(this);} 
}; 

class B : public Foo 
{ 
public: 
     virtual void some_method() 
    { 
     // move the body of some_method(A a) here 
    } 
    virtual void visit(FooVisitor* v) { v->visit(this);} 
}; 

int main() 
{ 
    FooVisitor fv; 
    Foo* f1 = new A; 
    f1->visit(&fv); 
    Foo* f2 = new B; 
    f2->visit(&fv); 
    getchar(); 
}