C++ C++；：复杂类上的2个模板与1个模板专门化

我有一个自定义的相当复杂的数据结构，使用此表单：

class Root;

class Tree {

public:
    ... // lots of members here, child access etc
    ExactBar *bar() { return mBar; }
    ExactQux *qux() { return mQux; } 
private:
    ... // lots of members here
    ExactBar *mBar;
    ExactQux *mQux;
};

class Root : public Tree { // root manages the memory for all tree nodes!
    ...
private:
    MemorySpace<Tree> mNodes;
    MemorySpace<ExactBar> mBars;
    MemorySpace<ExactBar> mQuxs;
};

然而，这个定义似乎有点尴尬。我的意思是，我知道我永远不会使用

树。这是坏习惯吗？当然，您也可以使用typedef解决长名称，但仍然可以。我想到的另一个解决方案是：

template <typename Exactness> class Tree;

template <> class Tree<Exact> {

public:
    ... // lots of members here, child access etc
    ExactBar *bar() { return mBar; }
    ExactQux *qux() { return mQux; } 
private:
    ... // lots of members here
    ExactBar *mBar;
    ExactQux *mQux;
};
// ... similar for Inexact

模板类树；
模板类树{
公众：
…//这里有很多成员，儿童访问等
ExactBar*bar（）{return mBar；}
ExactQux*qux（）{return mQux；}
私人：
…//这里有很多会员
精确巴*毫巴；
ExactQux*mQux；
};
// ... 类似于不精确

哪种方法更可取，是否有任何模式或反模式或涟漪效应这样做，我应该知道？谢谢
 这里还有另一个选项，可以最大限度地减少模板参数的数量和重复代码的数量：

struct Exact
{
    typedef ExactBar BarType;
    typedef ExactQux QuxType;
};

struct Inexact
{
    typedef InexactBar BarType;
    typedef InexactQux QuxType;
};

template <typename Exactness> class Tree {

public:
    typedef typename Exactness::BarType Bar;
    typedef typename Exactness::QuxType Qux;

    ... // lots of members here, child access etc
    Bar *bar() { return mBar; }
    Qux *qux() { return mQux; } 
private:
    ... // lots of members here
    Bar *mBar;
    Qux *mQux;
};

下面是另一个选项，它可以最大限度地减少模板参数的数量和重复代码的数量：

struct Exact
{
    typedef ExactBar BarType;
    typedef ExactQux QuxType;
};

struct Inexact
{
    typedef InexactBar BarType;
    typedef InexactQux QuxType;
};

template <typename Exactness> class Tree {

public:
    typedef typename Exactness::BarType Bar;
    typedef typename Exactness::QuxType Qux;

    ... // lots of members here, child access etc
    Bar *bar() { return mBar; }
    Qux *qux() { return mQux; } 
private:
    ... // lots of members here
    Bar *mBar;
    Qux *mQux;
};

下面是另一个选项，它可以最大限度地减少模板参数的数量和重复代码的数量：

struct Exact
{
    typedef ExactBar BarType;
    typedef ExactQux QuxType;
};

struct Inexact
{
    typedef InexactBar BarType;
    typedef InexactQux QuxType;
};

template <typename Exactness> class Tree {

public:
    typedef typename Exactness::BarType Bar;
    typedef typename Exactness::QuxType Qux;

    ... // lots of members here, child access etc
    Bar *bar() { return mBar; }
    Qux *qux() { return mQux; } 
private:
    ... // lots of members here
    Bar *mBar;
    Qux *mQux;
};

下面是另一个选项，它可以最大限度地减少模板参数的数量和重复代码的数量：

struct Exact
{
    typedef ExactBar BarType;
    typedef ExactQux QuxType;
};

struct Inexact
{
    typedef InexactBar BarType;
    typedef InexactQux QuxType;
};

template <typename Exactness> class Tree {

public:
    typedef typename Exactness::BarType Bar;
    typedef typename Exactness::QuxType Qux;

    ... // lots of members here, child access etc
    Bar *bar() { return mBar; }
    Qux *qux() { return mQux; } 
private:
    ... // lots of members here
    Bar *mBar;
    Qux *mQux;
};

除了@John之外的另一个选项是对模板进行修改。也就是说，不要将模板代码包含在标题中，而是将其包含在单独的
.cpp
中，并在其中添加一行明确的代码，说明您实例化的类型：

template class Tree<ExactBar, ExactQux>;
template class Tree<InexactBar, InexactQux>;

模板类树；
模板类树；

这样，编译器将不会使用任何其他实例化链接任何代码

如果您非常确定这些是您所需要的唯一实例化，那么这还有一个额外的优点，即缩短了编译时间。但是，这使得扩展代码更加困难：如果要添加新的实例化，则必须修改相同的
.cpp
。这就是为什么我建议您仅在非常确定您将完全控制可能的实例化并且该实例化的数量不会太多的情况下使用此选项。
除了@John之外的另一个选项是使用您的模板。也就是说，不要将模板代码包含在标题中，而是将其包含在单独的
.cpp
中，并在其中添加一行明确的代码，说明您实例化的类型：

template class Tree<ExactBar, ExactQux>;
template class Tree<InexactBar, InexactQux>;

模板类树；
模板类树；

这样，编译器将不会使用任何其他实例化链接任何代码

如果您非常确定这些是您所需要的唯一实例化，那么这还有一个额外的优点，即缩短了编译时间。但是，这使得扩展代码更加困难：如果要添加新的实例化，则必须修改相同的
.cpp
。这就是为什么我建议您仅在非常确定您将完全控制可能的实例化并且该实例化的数量不会太多的情况下使用此选项。
除了@John之外的另一个选项是使用您的模板。也就是说，不要将模板代码包含在标题中，而是将其包含在单独的
.cpp
中，并在其中添加一行明确的代码，说明您实例化的类型：

template class Tree<ExactBar, ExactQux>;
template class Tree<InexactBar, InexactQux>;

模板类树；
模板类树；

这样，编译器将不会使用任何其他实例化链接任何代码

如果您非常确定这些是您所需要的唯一实例化，那么这还有一个额外的优点，即缩短了编译时间。但是，这使得扩展代码更加困难：如果要添加新的实例化，则必须修改相同的
.cpp
。这就是为什么我建议您仅在非常确定您将完全控制可能的实例化并且该实例化的数量不会太多的情况下使用此选项。
除了@John之外的另一个选项是使用您的模板。也就是说，不要将模板代码包含在标题中，而是将其包含在单独的
.cpp
中，并在其中添加一行明确的代码，说明您实例化的类型：

template class Tree<ExactBar, ExactQux>;
template class Tree<InexactBar, InexactQux>;

模板类树；
模板类树；

这样，编译器将不会使用任何其他实例化链接任何代码

如果您非常确定这些是您所需要的唯一实例化，那么这还有一个额外的优点，即缩短了编译时间。但是，这使得扩展代码更加困难：如果要添加新的实例化，则必须修改相同的
.cpp
。这就是为什么我建议您仅当您非常确定您将完全控制可能的实例化，并且此实例化的数量不会很大时才使用此方法。
因此，您希望模板在两个
精确的
，或者在两个
不精确的
上实例化，而不是在其他任何情况下实例化？这是仅有的两对，还是（可能在将来）会出现其他一些对（
半精确
，或
notexacttal
）。我95%确定只有这两对可以出现，并且在将来是必需的。因此，您希望模板在两个
精确
上都实例化，或者在两个
不精确
上都实例化，而不是其他任何东西？这是仅有的两对，还是（可能在将来）会出现其他一些对（
半精确
，或
notexacttal
）。我95%确定只有这两对可以出现，并且在将来是必需的。因此，您希望模板在两个
精确
上都实例化，或者在两个
不精确
上都实例化，而不是其他任何东西？这是仅有的两对，还是（可能在将来）会出现其他一些对（
半精确
，或
notexacttal
）。我95%确信只有这两对可以出现，并且在将来是必需的