将虚方法作为接收迭代器的模板

Question

我知道不能在 C++ 中使用虚拟方法的模板（反之亦然），例如这里和这里讨论的。不幸的是，在我的情况下，我不确定如何处理该限制。

我们有一个包含方法模板的类模板：

template <class T>
class BeliefSet : public Belief<T>
{
private:
    std::vector<T> m_Facts;

public:
    template <class Iter>
    void SetFacts(Iter IterBegin, Iter IterEnd, bool Append = false)
    {
        if(!Append)
        {
            m_Facts.clear();
        }
        m_Facts.insert(m_Facts.end(), IterBegin, IterEnd);
    }
};

该方法SetFacts()应该能够为 STL 容器接收两个输入迭代器，这就是我们在这里使用方法模板的原因。

现在我想让这个方法成为SetFacts()虚拟的，这在 C++ 中是不可能的，目前编写这段代码的方式。那么处理这种情况的典型方法是什么？

Answer 1

基于 CRTP 惯用法和一些 sfinae 的东西可能可以解决它：

template <class D, class T>
class BeliefSet : public Belief<T>
{
private:
    std::vector<T> m_Facts;

    template <class Iter>
    void SetFactsInternal(char, Iter IterBegin, Iter IterEnd, bool Append = false)
    {
        if(!Append)
        {
            m_Facts.clear();
        }
        m_Facts.insert(m_Facts.end(), IterBegin, IterEnd);
    }

    template <class Iter, typename U = D>
    auto SetFactsInternal(int, Iter IterBegin, Iter IterEnd, bool Append = false)
    -> decltype(static_cast<U*>(this)->OverloadedSetFacts(IterBegin, IterEnd, Append), void())
    {
        static_cast<U*>(this)->OverloadedSetFacts(IterBegin, IterEnd, Append);
    }

public:
    template <typename... Args>
    void SetFacts(Args&&... args)
    {
        SetFactsInternal(0, std::forward<Args>(args)...);
    }
};

您的派生类可以实现OverloadedSetFacts成员函数来重载 SetFacts。
此外，您的派生类必须继承BeliefSet如下：

struct Derived: BeliefSet<Derived, MyTType>
{
    //...
};

毕竟，这就是 CRTP 习语背后的关键概念。

它遵循一个最小的工作示例（为了简单起见，使用 C++14）：

#include<iostream>

template <class D>
class Base {
private:
    template <class C>
    auto internal(char, C) {
        std::cout << "internal" << std::endl;
    }

    template <class C, typename U = D>
    auto internal(int, C c)
    -> decltype(static_cast<U*>(this)->overloaded(c), void()) {
        static_cast<U*>(this)->overloaded(c);
    }

public:
    template <typename... Args>
    auto base(Args&&... args) {
        internal(0, std::forward<Args>(args)...);
    }
};

struct Overloaded: Base<Overloaded> {
    template<typename T>
    auto overloaded(T) {
        std::cout << "overloaded" << std::endl;
    }
};

struct Derived: Base<Derived> {};

int main() {
    Overloaded over;
    over.base(0);
    Derived der;
    der.base(0);
}

正如您所看到的，您可以在基类中提供默认实现，并根据需要在派生类中重写它。

在wandbox上查看。