C++ 动态向下转换为类模板，模板模板参数是类模板或别名模板

Question

我希望标题有意义。我可能缺少正确表达它的词汇。

嗯，举个例子可能会更清楚。

我的问题是：在以下某些情况下（写在注释中），动态向下转换在运行时返回 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 !


}

---

我提出另一种看待问题的方式，这可能更清楚。在试图避免上面的例子之后，我面临着这个问题。下面的例子基本上说明了博格丹所指出的内容。我发现编译器无法使用 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 的技巧。

Answer 1

Clang的行为是正确的。

A::A_Type相当于int标准中的[7.1.3p1]：

[...] 在其声明范围内，typedef-name在语法上等同于关键字，并以第 8 条中描述的方式命名与标识符关联的类型。因此， typedef-name是另一种类型的同义词。typedef -name不会像类声明 (9.1) 或枚举声明那样引入新类型。

A::A_Templated<int>相当于Templated<int>根据[14.5.7p2]：

当template-id引用别名模板的特化时，它相当于通过用其template-arguments替换别名模板的type-id中的template-parameters获得的关联类型。

然而，根据[14.5.7p1]，A::A_Templated不等于：Templated

[...] 别名模板的名称是template-name。

这意味着A::A_Templated和Templated是两个不同的模板，因此Test_Templated<A::A_Templated>和Test_Templated<Templated>是 的不同特化Test_Templated，因此返回空指针的强制转换是正确的。

GCC 5.1.0 不能正确处理这个问题。Clang 3.6.0 和 MSVC 14 RC 正确处理它。

所有参考文献均参考工作草案 N4431。

请注意，有一个关于此行为的活跃核心工作组问题 -问题 1286。作者表示，其目的是引入标准措辞，使此类情况按照您期望的方式工作，即使别名模板与 type -id中引用的模板等效。里面有2015年5月的注释，表明这个问题正在受到关注，但还没有。

就“使其工作”而言，在不知道您的实际需求是什么的情况下很难给出解决方案，但我会尝试依赖Test_Templated于 的专业化Templated，而不是模板本身，也就是说，将其声明为

template<class T>
class Test_Templated : public Test_base { /* ... */ };

并像这样使用它

test = new Test_Templated<Templated<int>>;
std::cout << dynamic_cast< Test_Templated<Templated<int>>* >(test) << std::endl; //ok
std::cout << dynamic_cast< Test_Templated<A::A_Templated<int>>* >(test) << std::endl; //also ok

您可以通过添加间接级别来包装它，如果这有任何帮助的话：

template<template<class> class TT, class T> using Make_Test_Templated = Test_Templated<TT<T>>;

然后像这样使用它：

test = new Make_Test_Templated<A::A_Templated, long>;
std::cout << dynamic_cast< Make_Test_Templated<A::A_Templated, long>* >(test) << std::endl; //ok
std::cout << dynamic_cast< Make_Test_Templated<Templated, long>* >(test) << std::endl; //also ok

无论如何，我认为关键是要尝试利用专业是等效的这一事实。

好吧，根据您的最新更新，这里有一个解决第二个代码示例中问题的方法：将显式专业化更改B<Templated>为部分专业化，仅在给定模板时匹配，该模板生成与Templated使用特定参数实例化时相同的专业化（比方说）int对于这个例子）。

这是一个令人困惑的句子，怎么样？对不起。以下是经过上述更改后您的代码示例：

#include <iostream>
#include <type_traits>

template<class> class Templated { };
template<class T> using Templated_alias = Templated<T>;
template<class> class Templated2 { };

// Helper trait
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<class> class, class = std::true_type> class B;
template<template<class> class TT> class B<TT, is_same_template_t<TT, Templated>>
{
public:
   void foo(Templated<int>) { std::cout << "B<Templated>::foo\n"; }
};

int main() {
   B<Templated> b1;
   b1.foo(Templated<int>());
   b1.foo(Templated_alias<int>());
   B<Templated_alias> b2; // Works fine now, and so do the next two lines.
   b2.foo(Templated<int>());
   b2.foo(Templated_alias<int>());
   // B<Templated2> b22; // Error trying to instantiate the primary template B.
}

请注意，您必须确保is_same_template_t仅用于检查可以使用参数实例化的模板（当然，int更改为您需要的任何内容）。int如果你想让它更通用，你还可以在特征的参数列表中包含需要实例化模板的类型，如下所示：

template<template<class> class TT1, template<class> class TT2, class T>
using is_same_template_t = typename std::is_same<TT1<T>, TT2<T>>::type;

并像这样使用它：

is_same_template_t<TT, Templated, int>