Добрый день!
Передо мной встала такая задача (или по-крайней мере у меня сложился такой путь её решения):
Есть базовый класс.
Известно, что у его наследников будут функции с определёнными (одинаковыми) сигнатурами, но неизвестно сколько их будет и как они будут называться. Т.е. в базовый класс их не пропишешь ни под каким видом.
В то же время, код, использующий объекты производных классов, ни о чём кроме базового класса не знает.
Я объявил typedef с указателем на функцию-член БАЗОВОГО класса (с нужной мне сигнатурой - в примере void).
А затем, получая указатели на функции-члены ПРОИЗВОДНЫХ классов и применяя их к указателям на объекты ПРОИЗВОДНЫХ классов - вызываю функции этих производных классов.
Погонял код и так, и сяк. И с виртуальными функциями и с наследованием следующего уровня - вроде бы всё работает как задумано.
В рабочей версии производные классы будут лежать в shared library, грубо говоря - вызывающий код будет получать всё: и указатель на объект и указатель на функцию - имея "на руках" только строки с названиями *.so (*.dll) и функций.
Вопросы:
1. Это у меня случайно работает или всё соответствует стандартам языка и будет работать и на других платформах, на других компиляторах?
2. Вообще задумка здравая или по фен-шую правильнее было бы решать эту задачу как-то по-другому?
| Код |
#include <iostream>
class A
{
public:
virtual ~A () {};
virtual void func () { std::cout << "A::" << __func__ << std::endl; };
};
typedef void (A::* Afunction) ();
class B: public A
{
public:
B (): i (10) {};
// void func () { std::cout << "B::" << __func__ << std::endl; };
virtual void func1 () { std::cout << "B::" << __func__ << ", i=" << i++ << std::endl; };
virtual void func2 () { std::cout << "B::" << __func__ << ", i=" << i++ << std::endl; };
private:
int i;
};
class BB: public B
{
public:
BB (): j (100) {};
virtual void func () { std::cout << "BB::" << __func__ << ", j=" << j++ << std::endl; };
virtual void func1 () { std::cout << "BB::" << __func__ << ", j=" << j++ << std::endl; };
virtual void func2 () { std::cout << "BB::" << __func__ << ", j=" << j++ << std::endl; };
private:
int j;
};
class C: public A
{
public:
C (): f (1.1) {};
virtual void func () { std::cout << "C::" << __func__ << ", f=" << f++ << std::endl; };
virtual void func1 () { std::cout << "C::" << __func__ << ", f=" << f++ << std::endl; };
virtual void func2 () { std::cout << "C::" << __func__ << ", f=" << f++ << std::endl; };
private:
float f;
};
class CC: public A
{
public:
CC (): d (-1.1) {};
virtual void func () { std::cout << "CC::" << __func__ << ", d=" << d-- << std::endl; };
virtual void func1 () { std::cout << "CC::" << __func__ << ", d=" << d-- << std::endl; };
virtual void func2 () { std::cout << "CC::" << __func__ << ", d=" << d-- << std::endl; };
private:
float d;
};
int
main ()
{
A* a = new B();
Afunction af = static_cast<Afunction>(&B::func);
(a->*af)();
af = static_cast<Afunction>(&B::func1);
(a->*af)();
af = static_cast<Afunction>(&B::func2);
(a->*af)();
delete a;
a = new BB();
af = static_cast<Afunction>(&BB::func);
(a->*af)();
af = static_cast<Afunction>(&BB::func1);
(a->*af)();
af = static_cast<Afunction>(&BB::func2);
(a->*af)();
delete a;
a = new C();
af = static_cast<Afunction>(&C::func);
(a->*af)();
af = static_cast<Afunction>(&C::func1);
(a->*af)();
af = static_cast<Afunction>(&C::func2);
(a->*af)();
delete a;
a = new CC();
af = static_cast<Afunction>(&CC::func);
(a->*af)();
af = static_cast<Afunction>(&CC::func1);
(a->*af)();
af = static_cast<Afunction>(&CC::func2);
(a->*af)();
delete a;
return 0;
};
|
Выводит (как я и задумывал) следующее:
| Код |
A::func
B::func1, i=10
B::func2, i=11
BB::func, j=100
BB::func1, j=101
BB::func2, j=102
C::func, f=1.1
C::func1, f=2.1
C::func2, f=3.1
CC::func, d=-1.1
CC::func1, d=-2.1
CC::func2, d=-3.1
|
|
)