数据类型类和读取器/解析器之间的耦合

Coupling between data type class and reader/parser

本文关键字：之间 耦合 读取 数据类型      更新时间：2023-10-16

>假设我有一个图像类

class Image {
private:
  unsigned char* data;
  int sizex;
  int sizey;
public:
  Image(std::string filename);
};

以及从磁盘读取图像的类：

class JpegReader;

在通过文件名构造函数读取图像时，如何设计这些类？我想减少耦合并避免循环依赖。

一种选择是引导 JpegReader 成为图像类结束的朋友，让它写入成员变量：

class JpegReader {
public:
  static void read(std::string filename, Image& image);
};
Image::Image(std::string filename) {
  JpegReader::read(filename, *this);
}
void JpegReader::read(std::string filename, Image& image) {
  image.data = readdata();
  image.sizex = readsizex();
  image.sizey = readsizey();
}

另一种选择是使用一个将所有成员变量作为参数的构造函数：

Image(unsigned char* aData, int aSizex, int aSizey) : data(aData),
                                                      sizex(aSizex),
                                                      sizey(aSizey) {}
void JpegReader::read(std::string filename, Image& image) {
  Image tmp(readdata(), readsizex(), readsizey());
  std::swap(tmp, image);
}

或者让 read（） 返回一个 Image，并让 Image 构造函数进行交换： 

class JpegReader {
public:
  static Image read(std::string filename);
};
Image::Image(std::string filename) {
  Image tmp = JpegReader::read(filename);
  std::swap(*this, tmp);
}
Image JpegReader::read(std::string filename) {
  Image tmp(readdata(), readsizex(), readsizey());
  return tmp;
}

你会如何设计它？

我可能会这样设计它：

class Image {
public:
  Image(unsigned char* aData, int aSizex, int aSizey) { ... }
}

图像阅读器的抽象基类（允许您在对它们一无所知的情况下传递读者）：

class ImageReader {
public:
  virtual Image read(const std::string& filename) = 0;
};

具体读取器（除了通过公共构造函数外，没有耦合到Image）：

class JpegReader: public ImageReader {
public:
  virtual Image read(const std::string& filename) {
    return Image(readdata(), readsizex(), readsizey());
  }
};
相关文章：