c++ - 存储指向同一模板类的模板类型的指针

Question

假设我们有以下内容:

template<typename A, typename B>
class Foo {
private:
    A m_a;
    B m_b;
    Foo<A,B>* m_pFoo;

public:
    Foo( A a, B b, Foo<A,B>* pFoo = nullptr );
};

有了这个类，我可以将任何 pFoo 保存到 m_pFoo 中，只要实例化 类型匹配如下:

 int main() {
     Foo<int, int> foo1( 3, 5 );
     Foo<int, int> foo2( 2, 4, &foo1 ); // This Works
     Foo<int, int> foo3( 5, 7, &foo2 ); // This Still Works 

     Foo<double, int> foo4( 2.4, 5 );
     Foo<double, int> foo5( 7.5, 2, &foo4 ); // This Works
     Foo<double, int> foo6( 9.2, 6, &foo5 ); // This Still Works

     // Compiler Error - Can not deduce template arguments
     Foo<double, int> foo7( 3.7, 2, &foo1 ); // Doesn't Work

     return 0;
 }

在上一个问题中，我演示了一个与此类似的问题，我最初的问题是如何将指向类模板类型的指针传递到同一个类模板构造函数中，但是我收到的关于这个的回复之一是传递指针不是问题，但存储是。因此，在这篇文章中，我的新问题变成了:

我如何才能拥有与上述相同或相似构造函数的相同类模板，其中每种类型:

Foo<short, short>           ssFoo;
Foo<short, int>             siFoo;
Foo<short, int64_t>         si64Foo;
Foo<short, unsigned>        suFoo;
Foo<short, float>           sfFoo;
Foo<short, double>          sdFoo;
Foo<short, long>            slFoo;
Foo<short, long long>       sllFoo;

Foo<int, short>             isFoo;
Foo<int, int>               iiFoo;
Foo<int, int64_t>           ii64Foo;
Foo<int, unsigned>          iuFoo;
Foo<int, float>             ifFoo;
Foo<int, double>            idFoo;
Foo<int, long>              ilFoo;
Foo<int, long long>         illFoo;

Foo<int64_t, short>        i64sFoo;
Foo<int64_t, int>          i64iFoo;
Foo<int64_t, int64_t>      i64i64Foo;
Foo<int64_t, unsigned>     i64uFoo;
Foo<int64_t, float>        i64fFoo;
Foo<int64_t, double>       i64dFoo;
Foo<int64_t, long>         i64lFoo;
Foo<int64_t, long long>    i64llFoo;

Foo<unsigned, short>        usFoo;
Foo<unsigned, int>          uiFoo;
Foo<unsigned, int64_t>      ui64Foo;
Foo<unsigned, unsigned>     uuFoo;
Foo<unsigned, float>        ufFoo;
Foo<unsigned, double>       udFoo;
Foo<unsigned, long>         ulFoo;
Foo<unsigned, long long>    ullFoo;

Foo<float, short>           fsFoo;
Foo<float, int>             fiFoo;
Foo<float, int64_t>         fi64Foo;
Foo<float, unsigned>        fuFoo;
Foo<float, float>           ffFoo;
Foo<float, double>          fdFoo;
Foo<float, long>            flFoo;
Foo<float, long long>       fllFoo;

Foo<double, short>          dsFoo;
Foo<double, int>            diFoo;
Foo<double, int64_t>        di64Foo;
Foo<double, unsigned>       duFoo;
Foo<double, float>          dfFoo;
Foo<double, double>         ddFoo;
Foo<double, long>           dlFoo;
Foo<double, long long>      dllFoo;

Foo<long, short>            lsFoo;
Foo<long, int>              liFoo;
Foo<long, int64_t>          li64Foo;
Foo<long, unsigned>         luFoo;
Foo<long, float>            lfFoo;
Foo<long, double>           ldFoo;
Foo<long, long>             llFoo;
Foo<long, long long>        l_llFoo;

Foo<long long, short>       llsFoo;
Foo<long long, int>         lliFoo;
Foo<long long, int64_t>     lli64Foo;
Foo<long long, unsigned>    lluFoo;
Foo<long long, float>       llfFoo;
Foo<long long, double>      lldFoo;
Foo<long long, long>        ll_lFoo;
Foo<long long, long long>   ll_llFoo;

在将前一个实例的地址传递到新实例的构造函数中的构造函数中，是否所有有效类型都存储在类模板中？还;我怎样才能阻止此类接受任何自定义或用户定义的对象或字符、字符串类型、枚举和 bool 类型？我希望将 typenames 作为数字类型传递到类模板参数列表中。

Answer 1

模板的实例是一种完全不同的类型，与所有其他类型和模板的其他实例分开。

Foo<short, short>

和

Foo<int, int>

是两个不同的类，它们之间的区别就像

Foo1;

和

Foo2;

彼此不同。

这些是不同的类。它遵循:

Foo<short, short> *m_pFoo;

和

Foo<int, int> *m_pFoo;

彼此也一样不同

Foo1 *m_pFoo;

和

Foo2 *m_pFoo;

是。 C++ 不能这样工作。 m_pFoo模板的成员只能指向一个类。你必须选择它是哪一个。它可以是与其自身类相同的类型，这是一种选择。或者，它可以指向某个其他类的实例。但它只能是一个类。

当然，除非你把它变成

void *m_pFoo;

但是，您当然会失去类型安全和类型检查，走那条路。

正如评论中提到的，您可以从父类(super class)派生模板，并存储指向父类(super class)的指针:

class FooBase {

// ...

};

template<typename A, typename B> class Foo : public FooBase {

    A m_a;
    B m_b;
    FooBase* m_pFoo;

public:
    Foo( A a, B b, FooBase* pFoo = nullptr );
};

因此，您将能够传递指向任何 Foo<A, B> 的指针到构造函数，它将自动转换为父类(super class)，并且只会存储指向父类(super class)的指针。

当然，这种方法还有许多其他含义，但这是我能想到的最干净、类型最安全的方法——至少到目前为止是这样。