在我的 C++ 库代码中，我使用抽象基类作为所有不同类型的 I/O 对象的接口(interface)。目前看起来像这样:

// All-purpose interface for any kind of object that can do I/O
class IDataIO
{
public:
   // basic I/O calls
   virtual ssize_t Read(void * buffer, size_t size) = 0;
   virtual ssize_t Write(const void * buffer, size_t size) = 0;

   // Seeking calls (implemented to return error codes
   // for I/O objects that can't actually seek)
   virtual result_t Seek(ssize_t offset, int whence) = 0;
   virtual ssize_t GetCurrentSeekPosition() const = 0;
   virtual ssize_t GetStreamLength() const = 0;

   // Packet-specific calls (implemented to do nothing
   // for I/O objects that aren't packet-oriented)
   virtual const IPAddressAndPort & GetSourceOfLastReadPacket() const = 0;
   virtual result_t SetPacketSendDestination(const IPAddressAndPort & iap) = 0;
};

这工作得很好——我有各种具体的 TCP、UDP、文件、内存缓冲区、SSL、RS232、stdin/stdout 等子类，而且我能够编写与 I/O 无关的例程可以与它们中的任何一个结合使用。

我还有各种decorator拥有现有 IDataIO 对象的所有权并充当该对象的行为修改前端的类。这些装饰器类很有用，因为单个装饰器类可用于修改/增强任何类型的 IDataIO 对象的行为。这是一个简单的(玩具)示例:

/** Example decorator class:  This object wraps any given
  * child IDataIO object, such that all data going out is
  * obfuscated by applying an XOR transformation to the bytes,
  * and any data coming in is de-obfuscated the same way.
  */
class XorDataIO : public IDataIO
{
public:
   XorDataIO(IDataIO * child) : _child(child) {/* empty */}
   virtual ~XorDataIO() {delete _child;}

   virtual ssize_t Read(void * buffer, size_t size)
   {
      ssize_t ret = _child->Read(buffer, size);
      if (ret > 0) XorData(buffer, ret);
      return ret;
   }

   virtual ssize_t Write(const void * buffer, size_t size)
   {
      XorData(buffer, size);   // const-violation here, but you get the idea
      return _child->Write(buffer, size);
   }

   virtual result_t Seek(ssize_t offset, int whence) {return _child->Seek(offset, whence);}
   virtual ssize_t GetCurrentSeekPosition() const    {return _child->GetCurrentSeekPosition();}
   virtual ssize_t GetStreamLength() const           {return _child->GetStreamLength();}

   virtual const IPAddressAndPort & GetSourceOfLastReadPacket() const      {return _child->GetSourceOfLastReadPacket();}
   virtual result_t SetPacketSendDestination(const IPAddressAndPort & iap) {return _child->SetPacketSendDestination(iap);}

private:
   IDataIO * _child;
};

这一切都很好，但让我困扰的是我的 IDataIO 类看起来像一个 fat interface 的例子。 -- 例如，UDPSocketDataIO 类将永远无法实现 Seek()、GetCurrentSeekPosition() 和 GetStreamLength( ) 方法，而 FileDataIO 类将永远无法实现 GetSourceOfLastReadPacket() 和 SetPacketSendDestination() 方法。因此，这两个类都被迫将这些方法实现为 stub ，它们什么也不做并返回错误代码——这有效，但很丑陋。

为了解决这个问题，我想将 IDataIO 接口(interface)分解成单独的 block ，如下所示:

// The bare-minimum interface for any object that we can
// read bytes from, or write bytes to (e.g. TCP or RS232)
class IDataIO
{
public:
   virtual ssize_t Read(void * buffer, size_t size) = 0;
   virtual ssize_t Write(const void * buffer, size_t size) = 0;
};

// A slightly extended interface for objects (e.g. files
// or memory-buffers) that also allows us to seek to a
// specified offset within the data-stream.
class ISeekableDataIO : public IDataIO
{
public:
   virtual result_t Seek(ssize_t offset, int whence) = 0;
   virtual ssize_t GetCurrentSeekPosition() const = 0;
   virtual ssize_t GetStreamLength() const = 0;
};

// A slightly extended interface for packet-oriented
// objects (e.g. UDP sockets)
class IPacketDataIO : public IDataIO
{
public:
   virtual const IPAddressAndPort & GetSourceOfLastReadPacket() const = 0;
   virtual result_t SetPacketSendDestination(const IPAddressAndPort & iap) = 0;
};

.... 所以现在我可以从 IPacketDataIO 子接口(interface)继承 UDPSocketDataIO，从 ISeekableDataIO 继承 FileDataIO 接口(interface)，而 TCPSocketDataIO 仍然可以直接从 IDataIO 继承，等等。这样一来，每种类型的 I/O 对象只为它实际支持的功能提供接口(interface)，没有人必须实现与其所做的无关的方法的无操作/ stub 版本。

到目前为止一切顺利，但此时出现的问题是装饰器类——在这种情况下，我的 XorDataIO 子类应该继承哪个接口(interface)？我想我可以写一个XorDataIO、一个XorSeekableDataIO和一个XorPacketDataIO，这样所有三种类型的接口(interface)都可以被完全修饰，但是我我真的不想——这似乎有很多冗余/开销，特别是如果我已经有多个不同的适配器类并且我不想将它们的数量进一步增加三倍。

有没有一些众所周知的聪明/优雅的方法来解决这个问题，这样我就可以吃蛋糕了？

最佳答案

我不知道这是否是解决此问题的最聪明/优雅的方法，但经过更多思考后，我得出以下结论:

1)对两个扩展接口(interface)使用“虚拟继承”:

class ISeekableDataIO : public virtual IDataIO {...}
class IPacketDataIO   : public virtual IDataIO {...}

2) 创建一个继承自这两个接口(interface)的 DecoratorDataIO 类，如果可能的话，将所有方法调用传递给子 IDataIO 对象上的适当方法:

class DecoratorDataIO : public IPacketDataIO, public ISeekableDataIO
{
public:
   DecoratorDataIO(const IDataIO * childIO)
      : _childIO(childIO)
      , _seekableChildIO(dynamic_cast<ISeekableDataIO *>(childIO))
      , _packetChildIO(dynamic_cast<IPacketDataIO *>(childIO))
   {
      // empty
   }

   virtual ~DecoratorDataIO() {delete _childIO;}

   // IDataIO interface implementation
   virtual ssize_t Read(void * buffer, size_t size) {return _childIO() ? _childIO()->Read(buffer, size) : -1;}
   virtual ssize_t Write(const void * buffer, size_t size) {return _childIO() ? _childIO()->Write(buffer, size) : -1;}

   // ISeekableDataIO interface implementation
   virtual result_t Seek(ssize_t offset, int whence) {return _seekableChildIO ? _seekableChildIO->Seek(offset, whence) : B_ERROR;}
   virtual ssize_t GetCurrentSeekPosition() const {return _seekableChildIO ? _seekableChildIO->GetCurrentSeekPosition() : -1;}
   virtual ssize_t GetStreamLength() const {return _seekableChildIO ? _seekableChildIO->GetStreamLength() : -1;}

   // IPacketDataIO interface implementation
   virtual const IPAddressAndPort & GetSourceOfLastReadPacket() const {return _packetChildIO ? _packetChildIO->GetSourceOfLastReadPacket() : GetDefaultObjectForType<IPAddressAndPort>();}
   virtual const IPAddressAndPort & GetPacketSendDestination() const  {return _packetChildIO ? _packetChildIO->GetPacketSendDestination()  : GetDefaultObjectForType<IPAddressAndPort>();}

private:
   IDataIO * _childIO;
   ISeekableDataIO * _seekableChildIO;
   IPacketDataIO   * _packetChildIO;
};

3) 现在我的装饰器类可以继承 DecoratorDataIO 并覆盖他们选择的任何方法(根据需要调用该方法的父类(super class)实现):

class XorDataIO : public DecoratorDataIO
{  
public:
   XorDataIO(IDataIO * child) : DecoratorDataIO(child) {/* empty */}

   virtual ssize_t Read(void * buffer, size_t size)
   {  
      ssize_t ret = DecoratorDataIO::Read(buffer, size);
      if (ret > 0) XorData(buffer, ret);
      return ret;
   }

   virtual ssize_t Write(const void * buffer, size_t size)
   {  
      XorData(buffer, size);   // const-violation here, but you get the idea
      return DecoratorDataIO::Write(buffer, size);
   }
};

这种方法实现了我的目标，如果有一些丑陋之处(即 dynamic_cast<>)，至少它包含在 DecoratorDataIO 类中，而不是暴露给所有装饰器子类。

关于c++ - 如何在不破坏 Decorator 模式的情况下精简 Fat Interface？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44555394/