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

Question

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

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

我的问题是：在以下某些情况下（写在评论中）在运行时间动态向下转换 returns 0。我想知道这是否是一种正确的行为（使用 C++11），还有为什么，以及我该怎么做才能让它发挥作用。显然，Templated 和 A::A_templated 被视为不同的 classes，尽管使用别名 "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 with Templated_alias 这一事实非常令人沮丧。我想知道是否存在编译选项，它可以通过模板别名强制类型解析。

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 的把戏，经过一番努力 nose-bleeding，我设法找到了某种解决方案。这个想法是建立一个 class 负责 'filtering' 模板 classes 的潜在别名。每个模板需要一个规范 class 需要 'filtered'。该方法的主要缺点是过滤因此需要在所有地方使用模板 classes 作为模板参数以保持一致。

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

使用上述技巧后。我运行陷入了不同的问题。不能绝对确定它是相关的，但很有可能。编译器似乎很难正确构建 'dynamic table'。我在 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> 根据 [14.5.7p2] 相当于 Templated<int>:

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 的不同特化，因此强制转换return 空指针这样做是正确的。

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

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

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

就 "making it work" 而言，在不知道您的实际需求是什么的情况下很难给出解决方案，但我会尝试使 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 更改为您需要的任何内容） .如果你想让它更通用，你还可以在特征的参数列表中包含模板需要实例化的类型，就像这样：

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>

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

C++ dynamic downcasting to class template having template template parameter being a class template or an alias template

c++

templates

c++11

dynamic-cast

template-aliases