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;

覆盖基类调用的函数？

1 个答案: