停止不断增加的无限递归模板实例化，这是不需要的

Question

我正在实现一个图形类，每个顶点都有一个不一定相同类型的标签。我希望用户能够提供任何标签（在编译时），而不需要 Graph 或 Vertex 知道类型是什么。为此，我使用了隐藏在 Label 类中的模板化多态性，以使 Labels 具有值语义。它就像一个魅力，相关代码是这样的（暂时忽略注释部分）：

//Label.hpp:
#include <memory>

class Label {
public:
    template<class T> Label(const T& name) : m_pName(new Name<T>(name)) {}
    Label(const Label& other) : m_pName(other.m_pName->copy()) {}
//  Label(const Label& other, size_t extraInfo) : m_pName(other.m_pName->copyAndAddInfo(extraInfo)) {}
    bool operator==(const Label& other) const { return *m_pName == *other.m_pName; }
private:
    struct NameBase {
    public:
        virtual ~NameBase() = default;
        virtual NameBase* copy() const = 0;
//      virtual NameBase* copyAndAddInfo(size_t info) const = 0;
        virtual bool operator==(const NameBase&  other) const = 0;
    };

    template<class T> struct Name : NameBase {
    public:
        Name(T name) : m_name(std::move(name)) {}
        NameBase* copy() const override { return new Name<T>(m_name); }
//      NameBase* copyAndAddInfo(size_t info) const override {
//          return new Name<std::pair<T, size_t>>(std::make_pair(m_name, info));
//      }
        bool operator==(const NameBase& other) const override {
            const auto pOtherCasted = dynamic_cast<const Name<T>*>(&other);
            if(pOtherCasted == nullptr) return false;
            return m_name == pOtherCasted->m_name;
        }
    private:
        T m_name;
    };

    std::unique_ptr<NameBase> m_pName;
};

用户（又名我）的一个要求是能够创建图的不相交并集（他已经能够创建双图，图的并集（具有相同标签的顶点映射到相同的顶点） ， ETC。）。希望新图的标签是旧标签和某个整数的对，表示标签来自哪个图（这也确保新标签都是不同的）。为此，我认为我可以使用 Label 类的注释部分，但是我的 g++17 编译器存在的问题是，当我用某种类型 T 定义第一个 Label 时，它会尝试实例化所有可以使用：

Name<T>, Name<std::pair<T, size_t>>, Name<std::pair<std::pair<T, size_t>, size_t>>, ...

尝试例如编译这个（只是一个例子，否则可以工作）：

// testLabel.cpp:
#include "Label.hpp"
#include <vector>
#include <iostream>

int main() {
    std::vector<Label> labels;
    labels.emplace_back(5);
    labels.emplace_back(2.1);
    labels.emplace_back(std::make_pair(true, 2));
    Label testLabel(std::make_pair(true, 2));
    for(const auto& label : labels)
        std::cout<<(label == testLabel)<<std::endl;
    return 0;
}

编译只是冻结。 （我没有看到其他人收到的消息“超出了最大模板递归容量”，但它显然试图实例化所有内容）。我尝试将函数分离到另一个类中并仅显式初始化所需的模板，以欺骗编译器，但没有任何效果。

期望的行为（我不知道是否可能）是实例化使用的模板类（连同成员函数声明），但延迟定义成员函数，即只有当它们真正被调用时。比如我调用Label(3)，应该有一个类Name<int>，但是函数

NameBase* Name<int>::copyAndAddInfo(size_t info) const;

只有在我调用它的时候才会被定义。 （因此，Name<std::pair<int, size_t>> 只会按需实例化）

感觉应该是可行的，因为编译器已经按需定义了模板函数。

一个想法应该是完全改变实现并使用变体，但是

1. 我不想手动跟踪用户需要的类型，并且
2. 我非常喜欢这种实现方法，并希望在更改之前先看看它的局限性。

有人对我如何解决这个问题有任何提示吗？

Answer 1

为了直接回答您的问题，虚拟和模板组合使编译器无法懒惰地实现主体 copyAndAddInfo。虚拟基类型指针隐藏了类型信息，所以当编译器看到other.m_pName->copyAndAddInfo时，它不知道它需要延迟实现什么类型。

编辑：

好的，因此根据您使用模板的基本原理，您似乎只想接受不同类型的标签，并且实际上可能并不关心不相交的联合信息是否是该类型的一部分。如果是这种情况，您可以将其从名称移至标签，并使其成为运行时信息：

class Label {
public:
    template<class T> Label(const T& name) : m_pName(new Name<T>(name)) {}
    Label(const Label& other) : m_pName(other.m_pName->copy()), m_extraInfo(other.m_extraInfo) { }
    Label(const Label& other, size_t extraInfo) : m_pName(other.m_pName->copy()), m_extraInfo(other.m_extraInfo) {
        m_extraInfo.push_back(extraInfo);
    }
    bool operator==(const Label& other) const { 
        return *m_pName == *other.m_pName && std::equal(
            m_extraInfo.begin(), m_extraInfo.end(), 
            other.m_extraInfo.begin(), other.m_extraInfo.end()); }
private:
    struct NameBase { /* same as before */ };

    std::vector<size_t> m_extraInfo;
    std::unique_ptr<NameBase> m_pName;
};

如果作为类型的一部分的不相交的联合信息很重要，那么请在下面享受我原来的讽刺回答。

原始答案：

也就是说，如果您愿意为递归设置一个上限，我有一个邪恶的解决方案适用于最多 N 层嵌套：使用模板技巧来计算嵌套层数。然后使用 SFINAE 在 N 级后抛出错误，而不是永远递归。

首先，计算嵌套层数：

template <typename T, size_t Level>
struct CountNestedPairsImpl
{
    static constexpr size_t value = Level;
};

template <typename T, size_t Level>
struct CountNestedPairsImpl<std::pair<T, size_t>, Level> : CountNestedPairsImpl<T, Level + 1>
{
    using CountNestedPairsImpl<T, Level + 1>::value;
};

template <typename T>
using CountNestedPairs = CountNestedPairsImpl<T, 0>;

然后，使用std::enable_if<>根据嵌套级别生成不同的body：

constexpr size_t NESTING_LIMIT = 4;
NameBase* copyAndAddInfo(size_t info) const override {
    return copyAndAddInfoImpl(info);
}
template <typename U = T, typename std::enable_if<CountNestedPairs<U>::value < NESTING_LIMIT, nullptr_t>::type = nullptr>
NameBase* copyAndAddInfoImpl(size_t info) const {
    return new Name<std::pair<T, size_t>>(std::make_pair(m_name, info));
}
template <typename U = T, typename std::enable_if<CountNestedPairs<U>::value >= NESTING_LIMIT, nullptr_t>::type = nullptr>
NameBase* copyAndAddInfoImpl(size_t info) const {
    throw std::runtime_error("too much disjoint union nesting");
}

为什么我称它为邪恶？它将生成所有可能的嵌套级别，因此如果您使用NESTING_LIMIT=20，它将为每种标签类型生成 20 个类。但是，嘿，至少它可以编译！

https://godbolt.org/z/eaQTzB