请教大牛一个模板的问题

AD8018

1. 
   
2. template<class T1>
   
3. void test(T1 *p1)
   
4. {
   
5. }
   
6. 
   
7. struct B1
   
8. {
   
9.         virtual void func() = 0;
   
10. };
    
11. 
    
12. struct C1 : public B1
    
13. {
    
14.         virtual void func()
    
15.         {
    
16.                 test(this);
    
17.         }
    
18. }
    
19. 
    
20. int main()
    
21. {
    
22.         C1 c1;
    
23.         B1 *b1 = &c1;
    
24.         b1->func();                //此处将调用 test<C1>(&c1);
    
25.        
    
26. }
    

复制代码

以上为一个简单的虚函数调用，从基类得到了继承类的指针。

现在想将借助虚函数，得到两个继承类的指针，能做到吗？

1. 
   
2. template<class T1, class T2>
   
3. void test(T1 *p1, T2 *p2)
   
4. {
   
5. }
   
6. 
   
7. struct B1
   
8. {
   
9.         //....
   
10. };
    
11. 
    
12. struct C1 : public B1
    
13. {
    
14.         //....       
    
15. }
    
16. 
    
17. struct B2
    
18. {
    
19.         //....
    
20. };
    
21. 
    
22. struct C2 : public B2
    
23. {
    
24.         //....
    
25. }
    
26. 
    
27. int main()
    
28. {
    
29.         C1 c1;
    
30.         C2 c2;       
    
31.         B1 *b1 = &c1;
    
32.         B2 *b2 = &c2;       
    
33.                        
    
34.         //之前通过虚函数b1->func()，达到了调用 test<C1>(&c1) 的效果，
    
35.         //想推广到两个基类，
    
36.         //如何通过b1, b2，达到调用 test<C1,C2>(&c1, &c2) 的效果
    
37.         //只能通过基类实现，不能写出C1或C2，不晓得有办法没？
    
38. }
    

复制代码

OwnWaterloo

与模板无关，需要的是多分派的能力。 BS有提议过，不过没被采纳……

貌似语法是这样：

1. 
   
2. void f(virtual B1* b1, virtual B2* b2) { ... }
   
3. void f(B1* b1, C2* c2) { ... }
   
4. void f(C1* c1, B2* b2) { ... }
   
5. void f(C1* c1, C2* c2) { ... }
   
6. 
   
7. C1 c1;
   
8. C2 c2;
   
9. B1* b1 = &c1;
   
10. B2* b2 = &c2;
    
11. f(b1, b2);
    

复制代码

根据多个多态参数分派到f(C1*,C2*)，f(C1*,C2*)里就取回真实类型，test什么的就是小事了。

OwnWaterloo

回复 1# AD8018

不过直到C++11都不支持的……
只能人肉实现，比如dynamic_cast…… 或者vistor pattern……

lz你到底是想干嘛……  这虚函数与模板的结合有点诡异……

AD8018

OwnWaterloo果然厉害，就是要这个多分派的能力。

我想给 boost::any 加个any_dynamic_cast
想来想去，只要能多分派就能实现。

如果模板函数可以支持虚函数，也能实现。但现实不那么美好。

struct C1 : public B
{
   ...
};

struct C2 : public B
{
   ...
};

C1 c1;
C2 c2;
boost::any arr[2];
arr[0] = c1;
arr[1] = c2;

for(i = 0; i < 2; ++i)
{
     B *p = any_dynamic_cast<B *>(&arr[i]);
}

walleeee

boost，笑而不语