Question

我希望标题有意义。我可能会错过词汇表来正确表达它。

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

问题在于：在以下某些情况下，动态向下转换在运行时返回0（写在注释中）。我想知道它是否是正确的行为（使用C ++ 11），也是为什么，以及如何使其发挥作用。显然，Templated和A :: A_templated被视为不同的类，尽管通过使用别名＆＃34;使用＆＃34;来定义为相同的。对于简单的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
}

感谢波格丹的伎俩，经过一些小小的流血，我设法找到了某种解决方案。我们的想法是建立一个负责“过滤”的课程。模板类的潜在别名。每个模板类需要一个规范才能被过滤＆＃39;。该方法的主要缺点是，因此需要在模板类用作模板参数的任何地方使用过滤，以保持一致。

//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

使用上述技巧后。我遇到了不同的问题。不能完全确定它的相关性，但它很有可能。编译器似乎很难正确构建动态表＆＃39;。我在C++ what can make type_info::hash_code differs for two (supposedly) same objects问了这个问题可能是我的坏事，但是现在我不推荐使用Clang 3.1的技巧。

Answer 1

Clang的行为是正确的。

根据标准中的[7.1.3p1]，

A::A_Type相当于int：

[...]在其声明的范围内， typedef-name 在语法上相当于一个关键字，并命名与该关联的类型标识符以第8章中描述的方式描述。 typedef-name 因此是a 另一种类型的同义词。 typedef-name 不会引入新类型类声明（9.1）或枚举声明的方式。

根据[14.5.7p2]，

A::A_Templated<int>相当于Templated<int>：

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

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

[...]别名模板的名称是模板名称。

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

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

无论如何，我认为关键是要尝试使用专业化等同的事实。

好的，基于您的最新更新，这是解决第二个代码示例中的问题的黑客攻击：将显式特化B<Templated>更改为仅在给定生成与{相同的特化的模板的情况下匹配的部分特化{1}}在使用某个参数进行实例化时（假设此示例为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;

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

1 个答案: