c++ - 覆盖基类调用的函数？

Question

我有一个设计为通用的类，可以在任何地方使用，看起来有点像这样:

class FixedByteStream {
public:
  FixedByteStream(const char* source)
  {
    size = strlen(source);
    copy(source);
  }

  /* Many more constructors here */

protected:
  void copy(const char* source)
  {
    address = allocate();
    //...
  }

  /* Plus other functions that call allocate() */

  char* FixedByteStream::allocate()
  {
    return (char*)malloc(size);
  }
}

然后我扩展了这个类，以便它可以使用项目特定的内存池。

class PooledByteStream : public FixedByteStream {
public:
  PooledByteStream::PooledByteStream() : FixedByteStream() {}

protected:
  char* PooledByteStream::allocate()
  {
    return (char*)PooledByteStream::pool.allocate(size);
  }
}

PooledByteStream 应该与 FixedByteStream 相同，具有所有相同的函数和构造函数，除了调用 allocate() 时，它应该从内存池中检索指针。

但是，PooledByteStream::allocate() 从未被调用。不是来自继承的构造函数，也不是来自其他继承的函数(调用继承的 copy())。从基类继承的任何东西都完全没有注意到 allocate() 现在应该做一些完全不同的事情。

问题是，我该如何解决这个问题？如何让继承的函数调用重写的函数，而不是基类的函数？从基类复制粘贴所有必要的函数会抹杀继承点，所以我假设这不是这里的答案。

注意:我不是在寻求有关内存管理或其他达到相同最终结果的方法的建议。这只是一个例子!

Answer 1

您需要将 allocate() 声明为虚拟的才能覆盖它。但是，基类构造函数不能调用派生类的重写，因为派生类还没有构造，基类析构函数不能调用派生类的重写，因为派生类已经被析构。

如果你必须在基类构造函数中调用allocate()，你可以使用模板来绕过限制，例如:

template<typename Derived>
class FixedByteStreamBase
{
public:
  FixedByteStreamBase(const char* source)
  {
    size = strlen(source);
    copy(source);
  }

  /* Many more constructors here */

protected:
  void copy(const char* source)
  {
    address = Derived::allocate();
    //...
  }

  /* Plus other functions that call allocate() */
};

class FixedByteStream : public FixedByteStreamBase<FixedByteStream>
{
public:
    static char* allocate()
    {
        return (char*)malloc(size);
    }
};

class PooledByteStream : public FixedByteStreamBase<PooledByteStream>
{
public:
    static char* allocate()
    {
        return (char*)pool.malloc(size);
    }
};

或者:

struct MallocAllocator
{
    static char* allocate()
    {
        return (char*)malloc(size);
    }
};

struct PoolAllocator
{
    static char* allocate()
    {
        return (char*)pool.allocate(size);
    }
};

template<typename Allocator>
class FixedByteStreamBase {
public:
  FixedByteStreamBase(const char* source)
  {
    size = strlen(source);
    copy(source);
  }

  /* Many more constructors here */

protected:
  void copy(const char* source)
  {
    address = Allocator::allocate();
    //...
  }

  /* Plus other functions that call allocate() */
};

typedef FixedByteStreamBase<MallocAllocator> FixedByteStream;
typedef FixedByteStreamBase<PoolAllocator> PooledByteStream;