C++ 在不同的类中使用别名模板声明

Question

我得到了三个模板类 (Code in C++ Shell) 和一个别名模板 using AType = A<T1,T2> 在 A 中定义。我想在使用 A 对象的文件中使用别名。

所以在B而不是写：

C<A<T1,T2>> c_object;

我希望能够写出类似的东西：

C<typename AType> c_object;

使用A中声明的别名。

// A.h
template<typename T1, typename T2>
class A{
    A();
};
template<typename T1, typename T2>
using AType = A<T1,T2>;

// C.h
template<typename H>
// H = A<T1,T2>
class C{
    C();
};

// B.h
#include "A.h"
template<typename T1, typename T2>
class B{
    B();
    // const C<A<T1,T2>>& GetC() const;
    const C<typename AType>& GetC() const;
private:
    C<typename AType> c_object;
};

注意模板参数的关系。

如果B 只有一个模板参数G 像：

template<typename G>
class B{};

我可以这样做：

C<typename G::AType> c_object;

但由于B 实际上有两个，我无法弄清楚这将如何解决。还是整个问题通常以不同的方式解决？

Answer 1

您应该为您的C 类型添加一个using 到B：

#include "A.h"
template<class T1, class T2>
struct B{
    using C_type =  A<T1, T2>;
    B();
    // const C_type& GetC() const;
    const C_type& GetC() const;
private:
    C_type c_object;
};

或者可以将A 注入B 的模板参数中，这将让调用者有选择地更改它：

#include "A.h"
template<class T1, class T2, template<class, class> class C_T = A<T1, T2>>
struct B{
    B();
    // const C_T& GetC() const;
    const C_T& GetC() const;
private:
    C_T c_object;
}

---

您误解了模板别名的用途。它们只是使引用其他模板变得更容易；它们不会隐式绑定要传递的模板参数（T1 和 T2 不会在您的 OP 中隐式传递给 A；必须指定 A 的模板参数）。

您可以使用模板别名简化为A 编写模板的C 类型：

template<class T1, class T2>
using C_A = C<A<T1, T2>>;

然后你可以在B 中使用C_A<T1, T2>。如果您需要在多个位置以A 为模板的C，这可能会更加灵活。但是，我上面写的可能更可取；这仅用于演示目的。

Answer 2

问题是AType 不是类型；它是一个模板模板类型。

如果你写C，你的代码编译如下

template <template <typename...> class>
class C 
 { C(); };

并以这种方式传递AType

template <typename T1, typename T2>
class B
 {
      B();
      const C<AType>& GetC() const;
   private:
      C<AType> c_object;
 };

但我不明白你想用C 和AType 做什么

-- 编辑--

克劳斯说

在您发布的代码中，您编写的 C<AType> c_objectwhich 是无效的，因为使用 AType = A;`。我看不到您将任何类型放入别名模板 AType 的位置。因此，您发布的代码没有意义，因为 T1 和 T2 未使用。

我的回答：我认为我发布的代码“没有意义，因为 T1 和 T2 未被使用”，因为我不理解原始代码的含义。

但你说我的代码“无效”。

以下是我使用C<AType> c_objectwhich 和using AType = A<T1,T2>; 的代码。请告诉我哪里是无效的以及你在编译时遇到了什么错误。

template <typename, typename>
class A { A(); };

template <typename T1, typename T2>
using AType = A<T1,T2>;

template <template <typename...> class>
class C { C (); };

template <typename, typename>
class B
 {
      B();

      const C<AType> & GetC () const;
   private:

      C<AType> c_object;
 };

int main()
 { }


template <typename, typename>
class A { A(); };

template <typename T1, typename T2>
using AType = A<T1,T2>;

template <template <typename...> class>
class C { C (); };

template <typename, typename>
class B
 {
      B();

      const C<AType> & GetC () const;
   private:

      C<AType> c_object;
 };

int main()
 { }