我希望标题有意义。我可能想念正确表达它的词汇。
好吧，一个例子可能会更清楚。
对我来说问题是：在以下某些情况下（写在注释中），动态向下转换在运行时返回 0。我想知道这是否是正确的行为（使用 C++11），还有为什么，以及我能做些什么来使它工作。显然，Templated 和 A::A_templated 被视为不同的类，尽管使用别名“using”定义为相同。简单的 typedef 别名不会出现问题。
template <class T>
class Templated {};
class A {
public :
typedef int A_Type;
template <class T>
using A_Templated = Templated<T>;
};
class Test_base {
public :
Test_base() {}
virtual void foo()=0;
};
template <class T>
class Test_Type : public Test_base {
public :
Test_Type() {}
void foo() {}
};
template < template <class T> class TT >
class Test_Templated : public Test_base {
public :
Test_Templated() {}
void foo() {}
};
int main() {
Test_base* test;
test = new Test_Type<int>;
std::cout << dynamic_cast< Test_Type<int>* >(test) << std::endl;//-->ok
std::cout << dynamic_cast< Test_Type<A::A_Type>* >(test) << std::endl;//-->ok
test = new Test_Templated<Templated>;
std::cout << dynamic_cast< Test_Templated<Templated>* >(test) << std::endl;//-->ok
std::cout << dynamic_cast< Test_Templated<A::A_Templated>* >(test) << std::endl;//--> returns 0 !
test = new Test_Templated<A::A_Templated>;
std::cout << dynamic_cast< Test_Templated<A::A_Templated>* >(test) << std::endl;//-->ok
std::cout << dynamic_cast< Test_Templated<Templated>* >(test) << std::endl;//--> returns 0 !
}
我提出另一种看待问题的方法，这可能更清楚。在试图避免上面的例子之后，我正面临着它。以下示例基本上说明了 Bogdan 指出的内容。我发现编译器无法使用 Templated_alias 解析 Templated 非常令人沮丧。我想知道是否存在编译选项，它可以通过模板别名强制类型解析。
template <class T>
class Templated {};
template <class T>
using Templated_alias = Templated<T>;
template < template <class T> class TT >
class B;
template <>
class B<Templated> {
public :
void foo(Templated<int> _arg) {}
};
int main() {
B<Templated> b1;
b1.foo(Templated<int>());
b1.foo(Templated_alias<int>());//compiles => Templated_alias<int> is equivalent to Templated<int>
B<Templated_alias> b2;//Compilation error: Implicit instantiation of undefined template B<Templated_alias>
//which means: Templated_alias is not equivalent to Templated
}
多亏了波格丹的诡计，在流了一些鼻血之后，我设法找到了某种解决方案。这个想法是建立一个负责“过滤”模板类的潜在别名的类。每个需要“过滤”的模板类都需要一个规范。该方法的主要缺点是过滤因此需要在模板类用作模板参数的任何地方使用以保持一致。
//Classes to be dealt with
template <class T>
class Templated {};
template <class T>
class Templated2 {};
template <class T>
using Templated_alias = Templated<T>;
class A_base {
virtual void foo()=0;
};
template <template <class T> class TT>
class A : public A_base {
void foo() {}
};
//Here starts the trick definition
template<template<class> class TT1, template<class> class TT2>
using is_same_template_t = typename std::is_same<TT1<int>, TT2<int> >::type;
//Template Template aliasing
template < template <class T> class TT >
class TT_aliasing {
public :
template <class T>
using Class_T = TT<T>;
};
//Template Template Alias Filtering
template < template <class T> class TT, class = std::true_type>
class TT_AF {
public :
template <class T>
using Class_T = TT<T>;
};
template < template <class T> class TT >
class TT_AF<TT, is_same_template_t<TT, Templated> > : public TT_aliasing<Templated> {};
int main() {
A_base* a;
a = new A< TT_AF<Templated>::Class_T >();
std::cout << dynamic_cast< A< TT_AF<Templated>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated_alias>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated2>::Class_T >* >(a) << std::endl;
std::cout << "---------------" << std::endl;
a = new A< TT_AF<Templated_alias>::Class_T >();
std::cout << dynamic_cast< A< TT_AF<Templated>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated_alias>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated2>::Class_T >* >(a) << std::endl;
std::cout << "---------------" << std::endl;
a = new A< TT_AF<Templated2>::Class_T >();
std::cout << dynamic_cast< A< TT_AF<Templated>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated_alias>::Class_T >* >(a) << std::endl;
std::cout << dynamic_cast< A< TT_AF<Templated2>::Class_T >* >(a) << std::endl;
A< TT_AF<Templated>::Class_T > a1;
A< TT_AF<Templated_alias>::Class_T > a2;
a1 = a2;
A< TT_AF<Templated2>::Class_T > a3;
//a1 = a3;//no viable overloaded '='
}
输出给出：
0x600000014ba0
0x600000014ba0
0x0
---------------
0x600000014bb0
0x600000014bb0
0x0
---------------
0x0
0x0
0x600000014bc0
使用上述技巧后。我遇到了不同的问题。不能绝对确定它是否相关，但很有可能。编译器似乎很难正确构建“动态表”。我在 C++ 中询问了这个问题，什么可以使 type_info::hash_code 对于两个（据说）相同的对象有所不同 可能是我的坏事，但现在我不建议使用 Clang 3.1 的技巧。