C++模版類如何動態獲取類型？

我用C++寫一個小工具的時候發現不知道如何處理模版類型。B類和C類都繼承於A類，D類是一個封裝了類成員函數指針功能的模板類。

在A類中有一個C類的對象，但是這個模板對象C所需要的類型如何動態獲得？我主要是想在A類中調用B類和C類傳入的類成員函數。

因為B類和C類中各有一個不是從A類繼承得來的函數，如果直接把類型寫A的話就不能通過C類的類成員函數指針調用B類或C類的那個獨立的函數了，模板類型該如何動態獲取？或者還有什麼更好的設計方式？

代碼：

class A{
private:
D&<這裡怎麼寫&> d;

public:

A(){

}

void setD(D d){
this-&>d = d;
}

void run(){
this-&>d.go();
}

};

class B : A{

public:

B(A* a){
a-&>setD(D&(this, B::bbb));
}

void bbb(){

}

};

class C : A{

public:

C(A* a){
a-&>setD(D&(this, C::ccc));
}

void ccc(){

}

};

template&
class D{
private:
T* object;
typedef void (T::*Function)(void);
Function function;

public:

D(T* object, Function function) : object(object), function(function){

}

void go(){
(this-&>object-&>*(function))();
}
};

int main(){
A* a = new A();

B* b = new B(a);
a-&>run();

C* c = new C(a);
a-&>run();

return 0;
}


題主更新問題了，答案也是一個簡單的技巧。說來搞這麼複雜幹什麼呢，用lambda表達式然後轉成function&不行嗎？

class Fuck
{
public:
virtual ~Fuck() = default;
virtual void go();
};

void go() override{
(this-&>object-&>*(function))();
}
};


==================================

不知道題主想問什麼，但是我猜多半可能是WTL的那種技巧：論如何不用虛表模擬虛函數

過度優化前：

class Bitch
{
public:
virtual void Eat(Shit shit) = 0;

void EatTwice(Shit shit)
{
Eat(shit);
Eat(shit);
}
};
class TrueBitch : public Bitch ...;
class FalseBitch : public Bitch ...;


過度優化後：

template&
class Bitch
{
public:
TBitch* TheRealMe()
{
return static_cast&(this);
}

class FalseBitch : public Bitch&
{
public:
void Eat(Shit shit) { ... }
};


如果你只是想實現針對BC，同一個函數能有不同的執行，那虛函數不就是為此而生的嘛，都用C++了何苦折騰函數指針。
如果兩個函數參數有不同，拿現成的function、lambda包一下不就好了，你的D類不就是為了實現這種功能嗎？（而function實質是構建了一個匿名類並重載()，而不是用模版類）

而如果你要通過A去調用只有C里有的方法呢？這就在設計說不通了啊。
就像人和貓都繼承於動物，你卻想讓一個動物去「膜」，很明顯貓是做不到的啊。

如果你就是想要效率，或者就是要自己操作函數指針，那麼就不要想著「動態獲取類的信息」或者「保存類的信息」了，直接擦去類型信息，通通強制轉換成類似A::func的指針好了，反正是建立在thiscall的基礎上，函數返回值/參數也相同。

大家都貼代碼，那我也貼一段吧

class A;
typedef void (A::*func)();

int main()
{
A *b = new B();
A *c = new C();
b-&>go();
c-&>go();
getchar();
}


另外誰能告訴我為什麼輪子哥的縮進是4格，我的卻成了8格？我本地也是4空格的tab啊。

在 @XZiar 的回答的幫助下，參考了代碼解決了這個問題。

想要的是c++的委託方式吧

class A {
std::function& _x;
public:
void set(std::function& x) { _x = x; }
void run(){ if (_x) _x(); }
};
class B {
void Do(){
//do some thing;
printf("do B job.
");
}
public:
B(A a){ a.set([this](){this-&>Do();});}
};
class C {
void Do(){
//do some thing;
printf("do C job.
");
}
public:
C(A a){ a.set([this](){this-&>Do();});}
};
int main(){
A a;
B b(a);
a.run();
C c(a);
c.run();
return 0;
}


我覺得題主你對模版理解有些偏差，在運行時，A中的d應當是類型確定的。

感覺你想做的應當是在運行時，由B類型的對象通知A的對象：「把我的方法綁到你身上吧，你需要使用我的方法來run()」, 所以我覺得使用綁定更合適：

#include &
#include &
#include &

system("pause");
return 0;
}


使用C++ 11的std::bind和std::function來實現。

類D不需要是模板：

class A;

int main(){
A* a = new A();
B* b = new B(a);
a-&>run();
C* c = new C(a);
a-&>run();
return 0;
}