0

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

当我想为 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
};
4

3 回答 3

1

如果所有差异都受限于图像的保存方式（分配与否），您可以使用策略模型。

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

例如，而不是写

delete image;

你会写：

policy.del(image);

根据策略的实际类型（符合图像要求），可以在哪里policy.del委托或禁止操作delete

于 2012-05-01T12:04:56.180 回答
0

为什么有这么多种类？如果差异仅在于分配，那么只需创建多个构造函数，一个接受指向预分配数据持有者的指针，一个不接受并在内部进行分配。您还可以使用依赖注入来获取行为/功能的变化。

于 2012-05-01T12:15:18.263 回答
0

我有一个类似的案例。

让我们澄清一下。您的类层次结构不是基于是否分配了图像，但是，每个类都会有一些特性。

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

下面的例子解释了用另一个类包装一个类的想法，来自相同的继承，这似乎适用于您的问题。

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

// 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

建议：

  1. 有一个没有参数的构造函数是个好主意，特别是如果你正在设计一个类层次结构，而不是一个单一的类。

  2. 我知道这是一个简单的示例，但是，您可能希望将所有代码移动到正文文件。

干杯。

于 2012-05-01T17:22:28.257 回答