2

祝大家有美好的一天...

我正在我的公司从事一个复杂的项目，我在项目中使用了一些扭曲的工厂设计模式。省略细节；我有一些只能由“读者”创建的类（我称它们为“设备”）：

class DeviceBase // this is a virtual base class
{
  public:
   //some stuff
   friend class ReaderBase; // this is OK and necessary I guess?
  private:
   DeviceBase(); // cannot create a device directly
   //some more stuff
}

class Device1: public DeviceBase // some extended device
{
  public:
   //some stuff 
  private:
   //some more stuff
}

class Device2: public DeviceBase  // some other extended device
{
  public:
   //some stuff

  private:
   //some more stuff
}

现在是“阅读器”，它恰好是设备的工厂：

class ReaderBase
{
  private:
    DeviceBase[] _devices; // to keep track of devices currently "latched"
  public:
    // some other methods, getters-setters etc ...

    // this method will create the "Devices" :
    virtual bool PollforDevice ( DeviceType, timeout) = 0; 

}

现在，这是我的工厂课程；但它（如您所见）是纯虚拟的。我有特殊的读者继承自这个：

 class InternalReader: public ReaderBase
 {
   public:
     // define other inherited methods by specifics of this reader
     bool PollforDevice( DeviceType dt, timeout ms)
     {
         switch(dt)
         {
           case Device1: { /* create new device1 and attach to this reader */ } break;
           case Device2: { /* create new device2 and attach to this reader */ } break;
         }
         // show goes on and on...
     }
 }

 class ExternalReader: public Reader
 {
   public:
     // define other inherited methods by specifics of this reader
     bool PollforDevice( DeviceType dt, timeout ms)
     {
         switch(dt)
         {
           case Device1: { /* create new device1 and attach to this reader */ } break;
           case Device2: { /* create new device2 and attach to this reader */ } break;
         }
         // show goes on and on...
     }
 }

我使用这种模式的原因是：我正在为一个可以同时连接多个“阅读器”的系统编写代码，并且我必须同时使用它们。

还有这些“设备”：我也可以公开他们的构造函数，大家都会开心；但我想确保它们不是由代码编写者自己创建的（以确保它的其他编码者）

现在的问题：

  1. 我应该在每个“设备”中明确声明 ReaderBase 是朋友吗？或者仅仅在基础上声明“DeviceBase”就足够了？
  2. 我应该明确放入从“ReaderBase”继承的“Readers”也是这些设备的朋友的每个“Device”，还是只放入 ReaderBase 就足够了？
  3. 除了让整个“ReaderBase”类成为朋友之外，我可以（并且应该）让成员方法“PollforDevice”成为朋友吗？知道它是一个纯虚拟方法，那是否也会使继承的副本成为朋友？

很抱歉这个问题很长，但我只想说清楚。

提前致谢...

4

2 回答 2

2

为什么要关心纯抽象基类的可构造性DeviceBase呢？如果它是一个设计合理的契约或抽象基类，无论如何都不能构造它。除非您必须适应某种您未提及的框架，否则只需与隐藏相反，例如：

struct DeviceBase {
    virtual void Foo() = 0;
    virtual void Bar() = 0;
    virtual ~DeviceBase() = default;
};

顺便说一句，声明构造函数或析构函数private将非常有效地使您的类“密封”。如果由于某种原因DeviceBase不是抽象的（在我看来这是一个严重的设计缺陷），那么构造函数protected就不是private. 您需要打扰的是具体Device类的构造函数可访问性。假设您要“发布”这些实现类（即，您的库的用户可以访问它们的定义）并且您希望强调禁止直接构造，请使用“访问习语”（我为此发明的名称）：

namespace impl_detail {
    class DeviceAccess;
}

class ConcreteDevice1 : public DeviceBase {
    friend class impl_detail::DeviceAccess;
    // implementation of DeviceBase and all other stuff go 
    // into the "private" section
};

namespace impl_detail {
    class DeviceAccess {
        template< class TDevice >
        static DeviceBase* Create()
        {
            return new TDevice;
        }
    };
};

在您的Reader类中用于impl_detail::DeviceAccess::Create构造Device实例，例如：

// Your ExternalReader::PollForDevice...
switch (dt) {
    case Device1:
        return impl_detail::DeviceAccess::Create<ConcreteDevice1>();
    case Device2: 
        // etc...
}

长话短说，最好的解决方案是根本不发布具体的实现类，其次是某种限制构建的“心理障碍”，例如上述那种......

于 2013-01-16T10:04:17.370 回答
1
  1. 我应该在每个“设备”中明确声明 ReaderBase 是朋友吗？或者仅仅在基础上声明“DeviceBase”就足够了？
  2. 我应该明确放入从“ReaderBase”继承的“Readers”也是这些设备的朋友的每个“Device”，还是只放入 ReaderBase 就足够了？

由于友谊不是继承的（在友谊关系的任何一方），您的方案唯一可行的方法是在每个派生设备中声明每个派生阅读器的友谊。这会在 Reader 类和 Device 类之间产生紧密耦合，这不是一个好的设计。

3) 除了让整个“ReaderBase”类成为朋友之外，我可以（而且应该）让成员方法“PollforDevice”成为朋友吗？知道它是一个纯虚拟方法，那是否也会使继承的副本成为朋友？

您可以结交ReaderX::PollforDevice朋友而不是整个ReaderX班级，但这对您没有多大帮助，只会为难以解决循环依赖关系打开大门。

实际上，很难创建一种设计，其中层次 X 的类只能由层次 Y 的类创建，而不能由其他层次创建，而不会在两个层次中的类之间创建紧密耦合。我的方法是

  1. 首先，教育你的同事，如果他们想要 a DeviceX，那么他们可以从 a 获得它，ReaderY并且没有其他方式。确保在代码审查中强制执行此操作。所有其他步骤只是损害控制。
  2. 确保只有BaseDevice类暴露于 Reader 实现之外的代码。
  3. 使所有设备类的析构函数受到保护。这确保了 Device 类只能由派生类或友元清理（并自动排除非友元的堆栈分配）。如果他们不小心尝试直接使用 Device 类，应该让他们三思而后行。
  4. ReaderBase交友DeviceBase并提供功能来对ReaderBase设备进行实际清理。这是确保可以清理设备所必需的。
于 2013-01-16T08:41:41.213 回答