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 !


}

---

我提出另一种看问题的方式，这样可能更清楚。在试图避免上面的例子之后，我正面临着它。以下示例基本上说明了 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
}

---

多亏了 Bogdan 的把戏，在流鼻血之后，我设法找到了某种解决方案。这个想法是建立一个负责“过滤”模板类的潜在别名的类。每个需要“过滤”的模板类都需要一个规范。该方法的主要缺点是过滤因此需要在所有使用模板类作为模板参数的地方使用以保持一致。

//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++ what can make type_info::hash_code differs for two (supposedly) same objects 询问了这个问题可能是我的问题，但现在我不建议在 Clang 3.1 中使用该技巧。

Answer 1

Clang 的行为是正确的。

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

[...] Within the scope of its declaration, a typedef-name is syntactically equivalent to a keyword and names the type associated with the identifier in the way described in Clause 8. A typedef-name is thus a synonym for another type. A typedef-name does not introduce a new type the way a class declaration (9.1) or enum declaration does.

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

When a template-id refers to the specialization of an alias template, it is equivalent to the associated type obtained by substitution of its template-arguments for the template-parameters in the type-id of the alias template.

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

[...] The name of the alias template is a 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。

请注意，有一个关于此行为的活跃核心工作组问题 - Issue 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

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

---

好的，根据您的最新更新，这里有一个 hack 可以解决您第二个代码示例中的问题:更改显式特化 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 更改为您需要的任何内容)。如果你想让它更通用，你还可以在 trait 的参数列表中包含模板需要实例化的类型，如下所示:

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>