在这种情况下，有没有办法在单个解决方案中替换两个类似的函数？

问题描述 投票：1回答：1

有一个名为PlotCurve的类。它将图表描述为点的集合和操作。 PlotCurve的数据来自班级RVDataProvider。重要的是RVDataProvider提供的点数量可能很大（超过1kk），因此RVDataProvider返回一个只读指针指向Y数据（X数据可以通过指针的索引计算）以改善性能。

主要问题是RVDataProvider有两种不同的方法：

class RVDataProvider : public QObject, public IRVImmutableProvider
{
public:
    // ...
    ReadonlyPointer<float>  getSignalDataFloat(int signalIndex, quint64 start, quint64 count) override;
 ReadonlyPointer<double> getSignalDataDouble(int signalIndex, quint64 start, quint64 count) override;
    // ...
}

ReadonlyPointer<T>只是C风格指针的只读包装器。

为了获得曲线的值范围（寻找最小 - 最大值，在画布上绘制它们等）我应该声明不同的函数。

class PlotCurve : public QObject
{
public:
    // ...` 
    virtual ReadonlyPointer<float> getFloatPointer(quint64 begin, quint64 length) const;
    virtual ReadonlyPointer<double> getDoublePointer(quint64 begin, quint64 length) const;  
    // ...
}

如果添加了新的可用数据类型，则会导致在客户端代码中使用switch语句及其更改。

switch (dataType())
{
    case RVSignalInfo::DataType::Float: {
        auto pointer = getFloatPointer(begin, length);
        Q_ASSERT(!(pointer).isNull()); \
        for (quint64 i = 0; i < (length); ++i) { \
            auto y = (pointer)[i]; \
            if (y < (minY)) { (minY) = y; continue; } \
            if (y > (maxY)) { (maxY) = y; } \
        }
    } break;

    case RVSignalInfo::DataType::Double: {
        auto pointer = getDoublePointer(begin, length);
        Q_ASSERT(!(pointer).isNull()); \
        for (quint64 i = 0; i < (length); ++i) { \
            auto y = (pointer)[i]; \
            if (y < (minY)) { (minY) = y; continue; } \
            if (y > (maxY)) { (maxY) = y; } \
        }
    } break;

    // ...
}

有没有办法摆脱客户端代码的依赖？我想到了三件事：

1）创建Iterator类型，它将是ReadonlyPointer的包装器。 Nope - 由于迭代器的虚函数，性能降低了10倍以上。

2）创建一个遍历方法，该方法将对某个范围内的每个值执行某些功能。再一次 - 使用函数指针的最优化版本比客户端代码中的switch语句慢两倍。

3）制作类PlotCurve模板。这样我就不能像现在这样向一个容器添加不同的PlotCurves。

c++ pointers templates iterator software-design
1个回答
1
投票

不幸的是，我没有看到OPs问题可以做多少。

最好的情况是，案件的相似部分可以移动到

  1. 一个宏
  2. 功能模板

防止代码重复。

为了演示，我使用以下示例代码类似于OPs问题：

enum DataType { Float, Double };

struct Data {
  std::vector<float> dataFloat;
  std::vector<double> dataDouble;
  DataType type;

  Data(const std::vector<float> &data): dataFloat(data), type(Float) { }
  Data(const std::vector<double> &data): dataDouble(data), type(Double) { }
};

使用函数模板，处理可能如下所示：

namespace {

// helper function template for process()
template <typename T>
std::pair<double, double> getMinMax(const std::vector<T> &values)
{
  assert(values.size());
  double min = values[0], max = values[0];
  for (const T &value : values) {
    if (min > value) min = value;
    else if (max < value) max = value;
  }
  return std::make_pair(min, max);
}

} // namespace

void process(const Data &data)
{
  std::pair<double, double> minMax;
  switch (data.type) {
    case Float: minMax = getMinMax(data.dataFloat); break;
    case Double: minMax = getMinMax(data.dataDouble); break;
  }
  std::cout << "range: " << minMax.first << ", " << minMax.second << '\n';
}

Live Demo on coliru

使用宏它会显得更紧凑：

void process(const Data &data)
{
  std::pair<double, double> minMax;
  switch (data.type) {
#define CASE(TYPE) \
    case TYPE: { \
      assert(data.data##TYPE.size()); \
      minMax.first = minMax.second = data.data##TYPE[0]; \
      for (const double value : data.data##TYPE) { \
        if (minMax.first > value) minMax.first = value; \
        else if (minMax.second < value) minMax.second = value; \
      } \
    } break
    CASE(Float);
    CASE(Double);
#undef CASE
  }
  std::cout << "range: " << minMax.first << ", " << minMax.second << '\n';
}

Live Demo on coliru

许多人（包括我在内）认为C ++中的宏是危险的。与其他所有内容相反，宏不受命名空间或范围的影响。如果任何标识符意外地成为预处理的主题，这可能会导致混淆。在最坏的情况下，意外修改的代码会传递编译器并导致运行时出现意外行为。 （我的悲伤经历。）

但是，在这种情况下不会出现这种情况（假设代码是源文件的一部分）。

我宁愿选择第三种方法，将重复的代码放在process()中。一个lambda出现在我的脑海中，但lambdas不能（还）被模板化：SO: Can lambda functions be templated?。

本地模板（仿函数）不是替代方案。它也被禁止：SO: Why can't templates be declared in a function?。

在OP的反馈之后，关于X macros的一个注释：它是C中用来防止数据冗余的古老技术。

定义“数据表”，其中每一行是包含所有特征的（这里未定义的）宏X的“调用”。

要使用数据表：

  1. 定义一个宏X，它只使用个案中需要的参数（并忽略其余的）
  2. #include数据表
  3. #undef X。

样本再次：

void process(const Data &data)
{
  std::pair<double, double> minMax;
  switch (data.type) {
#define X(TYPE_ID, TYPE) \
    case TYPE_ID: { \
      assert(data.data##TYPE_ID.size()); \
      minMax.first = minMax.second = data.data##TYPE_ID[0]; \
      for (const double value : data.data##TYPE_ID) { \
        if (minMax.first > value) minMax.first = value; \
        else if (minMax.second < value) minMax.second = value; \
      } \
    } break;
#include "Data.inc"
#undef X
  }
  std::cout << "range: " << minMax.first << ", " << minMax.second << '\n';
}

其中Data.inc是：

X(Float, float)
X(Double, double)
X(Int, int)

Live Demon on coliru

虽然，这种宏观技巧有点吓人 - 这在维护方面非常方便。如果必须添加新的数据类型，X()中的新Data.inc行（当然，还有重新编译）就是必要的。 （编译器/构建链有望考虑来自Data.inc的所有源的依赖关系。我们在Visual Studio中从未遇到过这方面的问题。）

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.