编译时纯虚函数

Question

我试着实现了一个列表容器，并决定将一些通用函数如< code>sum()移到基类，这样我就可以在其他容器中重用它们。

所有的基本支持类需要的是三个方法 empty（）、head（） 和 tail。我不能使这些纯粹的虚拟，因为支持类永远不会被实例化。但它仍然必须使用这些方法来实现自己的方法，如 sum（）。

我试过这样的东西:

#include <iostream>
using namespace std;

template<typename T>
class StatsSupport {
public:
    T sum(void) const {
        if (empty()) {
            return T(0);
        } else {
            return head() + tail()->sum;
        }
    }

    // other methods
};

template<typename T>
class List : public StatsSupport<T> {
public:
    // constructors etc.

    bool empty(void) const {return head_ != NULL;}
    const T& head(void) const {return *head_;}
    const List<T>& tail(void) const {return *tail_;}

    // other methods
private:
    T* head_;
    List<T> *tail_;
};

但是尝试使用< code>sum()会导致编译错误

prog.cpp:8:13: error: there are no arguments to 'empty' that depend on a template parameter, so a declaration of 'empty' must be available [-fpermissive]
   if (empty()) {
             ^

对于空（）、head（）和尾（）中的每一个。

有什么建议吗？

Answer 1

我可能会错过问题的重点，但无论如何都会给我5美分：）

我下面展示的解决方案背后的理由是，通常新接触OOP(在C中)的人认为他们必须使用继承来完成事情。

但特别是在C语言中，这只是实现合成的一种方式，通常不是最好的方式。

虽然在大多数情况下，虚拟函数的开销成本并不重要，但下面的代码显示了一种在不使用继承和不使用虚函数的情况下产生容器扩展的方法。该方法的弱点是“容器函数合约”只是隐式可见的。

template <class _X>
class ContainerTypeA < _X >
{
public:
    typedef _X value_type;
    typedef ContainerTypeA<_X> container_type;

    const _X & Head() const
    {
        // return head of this containers content.
    }
    container_type Tail() const
    {
        // return the tail (all elements after the first element in a new instance.
    }
    bool IsEmpty() const
    {
        return true; // return whether or not this container is empty.
    }
};

template <class _X>
class ContainerTypeB < _X >
{
public:
    typedef _X value_type;
    typedef ContainerTypeB<_X> container_type;

    const _X & Head() const
    {
        // return head of this containers content.
    }
    container_type Tail() const
    {
        // return the tail (all elements after the first element) in a new instance.
    }
    bool IsEmpty() const
    {
        return true; // return whether or not this container is empty.
    }
};

// Note: In stead of the class with static member functions, this could 
// as well be a namespace with template-functions inside.
template < class _ContainerT >
class ContainerStats<_ContainerT>
{
    static _ContainerT::value_type Sum(const _ContainerT & container)
    {
        // Implement sum - possibly in the recursive way you did in your question.
    }
    // more expansion functions...
};

Answer 2

这是一个严重的设计问题:您的< code>StatSupport定义了一些通用函数，但是依赖于它的子类的细节。

所以当 StatSupport 被编译时，它甚至不知道有一些 head（） 和 tail（）。这就是您收到错误消息的原因

现在想象一下，有一天你想要定义从< code>StatSupport继承的其他容器，例如你自己的Vector或Map，或者数据库。这些数据结构没有头和尾。

基本上有两个主要方向：

• 在 StatSupport 中定义一些用于迭代数据结构的虚拟函数。
• 或者更好的是，在数据结构中使用一些迭代器（就像它们存在于标准容器中一样），并定义一些使用迭代器浏览容器的模板函数（总和、平均值等）。

在后一种情况下，您不需要继承来受益于泛型函数。

Answer 3

问题是 StatsSupport 找不到空函数、head 等函数，因为这些函数既不存在于其范围内，也不存在于全局范围内。StatsSupport 不知道派生类中存在的函数。

基本上有两种方法可以解决这个问题:

• 运行时多态性，您将虚拟析构函数添加到 StatsSupport，并为空、头等添加纯虚拟声明。
如
• 注释中所述，通过使用 CRTP 编译时多态性。我将着重谈后者。

所以基本上，StatsSupport需要获得访问派生类函数的方法。这可以通过将派生类的类型添加为模板参数来实现，该模板参数称为CRTP：

template<class Derived, typename T>
class StatsSupport {
public:
    T sum(void) const {
        if (derived()->empty()) {
            return T(0);
        } else {
            return derived()->head() + derived()->tail()->sum;
        }
    }

    // other methods
    private:
        Derived *derived()
        {
            return static_cast<Derived*>(this);
        }
        const Derived *derived() const
        {
            return static_cast<const Derived*>(this);
        }
};

template<typename T>
class List : public StatsSupport<List<T>, T> { // with some changes could be simplified to StatsSupport<List<T>> but this it ouf of scope of this question

我使用派生的函数而不是成员来保持类const正确。

当然，另一种选择是依赖算法的不同设计。在这里，您将< code>sum和< code>StatsSupport的所有其他函数移动到全局名称空间中，然后像< code > sum(my _ container _ instance)一样访问它们。更像STL的方法是使用迭代器。然后，您可以使用< code>std::accumulate进行求和。