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

Question

我正在实现一个图形类，每个顶点都有一个不一定相同类型的标签。我希望用户能够提供任何标签(在编译时)，而无需图形或顶点知道类型是什么。为此，我使用了模板化多态性，我将其隐藏在 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 ，它不知道它需要懒惰地实现什么类型。

编辑:

好的，根据您使用模板的理由，您似乎只想接受不同类型的标签，实际上可能并不关心不相交的 union 信息是否属于该类型。如果是这种情况，您可以将其从名称移至标签，并使其成为运行时信息:

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;
};

如果不相交的 union 信息是类型的一部分很重要，那么请欣赏我下面的原始讽刺回答。

原始答案:

也就是说，如果您愿意限制递归，我为您提供了一个适用于最多 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<>根据嵌套级别生成不同的主体:

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