Question

我需要一些Image类层次结构的设计建议目前，我有2种类型的图像（一种是标准图像，第二种不包含标准图像数据）。有时我希望对象为图像数据分配内存，有时我只想让它指向它。

当我想给TypeA图像特定的功能时，就会出现问题如果TypeA图像继承自Image，我将不得不复制Allocated与非Allocated Image的功能。

我确信有更好的方法可以做到这一点，我记得在大学期间使用mixins的一些优雅的解决方案，但是在这里找不到使用它的方法。

我目前的设计如下：

class Image
{
public:
Image(int width, int height, int bpp);
virtual ~Image() {};
    // getters

    template <typename T>                                  
    T* ptr() { return reinterpret_cast<T*>(m_imageData); } // T depends on bpp

 protected:
    // metadata
    char* m_imageData;
};

class AllocImage : public Image
{
public:
    AllocImage(int width, int height, int bpp, DataType dataType) :
        Image(width, height, bpp, dataType)
    {
        m_imageData = new char[m_dataSize];
    }

    ~AllocImage()
    {
        delete m_imageData;
    }
};

class ImageHolder : public Image
{
public:
    ImageHolder(int width, int height, int bpp, DataType m_dataType);

    void setPtr(const void* ptr);
};

class AllocatedImageTypeA : public AllocImage
{
public:
    // Type A specific methods
};

class NonAllocatedImageTypeA : public ImageHolder
{
public:
    // duplicated Type A specific methods
};

Answer 1

如果所有差异都受限于图像的保存方式（分配与否），则可以使用policy model。

简短的解释是，您可以将策略对象传递给图像，其中策略描述您是否需要取消分配图像，如何访问图像等，基本上是与产生的差异相关的任何内容。如何保持图像数据（分配与指向）。然后，您对图像的所有访问都将通过该策略进行。

例如，而不是写

delete image;

你会写：

policy.del(image);

policy.del可以是delete或无操作的委托，具体取决于政策的实际类型（符合图片要求）

Answer 2

为什么这么多类型？如果区别仅在于分配，那么只需创建多个构造函数，一个构建器获取指向预先分配的数据持有者的指针，一个不指向并在内部进行分配的构造函数。您还可以使用dependency injection来获取行为/功能的变化。

Answer 3

我有类似的情况。

让我们说清楚一点。

，如果分配了图像，您的类层次结构不是基于，而是每个类都有一些功能。

您可能希望有一个非常专业的类来分配图像，另一个引用该类，并将该类与具有相似特征的另一个相同层次结构进行扭曲。

以下示例解释了使用另一个类封装一个类的想法，从同样的继承，这似乎适用于你的问题。

免责声明：请忽略，一些小错误或不相关的语法错误：

// generic base class for my image library:
/* abstract */ class GenericImage
{
public:
   int width;
   int height;

public:
    /* constructor */ GenericImage() ;
    /* destructor */ ~GenericImage() ;

    /* constructor */ GenericImage(int newwidth, int newheight);
}; // class GenericImage

// in charge of allocating or deallocating an image
class AllocatedImage: GenericImage
{
public:
    /* constructor */ AllocatedImage() ;
    /* destructor */ ~AllocatedImage() ;

    /* constructor */ AllocatedImage(int newwidth, int newheight);
    /* constructor */ AllocatedImage(char* filename);
}; // class AllocatedImage

// access an image, but doesn't allocate or deallocate
class ContainedImage: GenericImage
{
public:
    /* constructor */ ContainedImage() ;
    /* destructor */ ~ContainedImage() ;

    /* constructor */ ContainedImage(int newwidth, int newheight);
}; // class AllocatedImage

// real working class, will allocate other objects,
// of same hierarchy
class WrapperImage: GenericImage
{
public:
   GenericImage* RealImage;

public:
    /* constructor */ GenericImage() ;
    /* destructor */ ~GenericImage() ;

   void AllocateImage(AllocatedImage* newimage);
   void HoldImage(ContainedImage* newimage);
}; // class AllocatedImage

建议：

最好有一个没有参数的构造函数，特别是如果你正在设计一个类层次结构，而不是一个类。
我知道它是一个快速示例，但是，您可能希望将所有代码移动到正文文件中。

干杯。

设计Image类层次结构的建议

3 个答案: