在此示例中，如何避免代码重复？

Question

我有一个简单的库（我们称其为Library #1 ），它可以处理某些数据矢量（例如时间序列）。 我想创建一个新的库（ Library #2 ），它实际上具有大多数（但不是全部）相同的功能，但仅作用于该向量中的单个数据点。 我想像一种解决方案，它是现有库的一个瘦包装，可以最大程度地减少代码重复。

这是简单的Library #1 ：

class Foo {
private: 
   std::vector<double> data;

public:
   // Some constructors

   double get_data_at_timepoint(int timepoint) const;

   // Some other methods
}

get_data_at_timepoint仅返回数据矢量的适当元素（假设它存在）。 Bar库中的另一个类有一个Foo容器，并以某种方式对其进行操作-特别是，它可以do_something ，并且您还可以得到一个Foo ：

class Bar {
private:
    std::vector<Foo> foos;

public:
    // Some constructors

    Foo get_this_foo(int idx) const;

    void do_something();

    // Some other methods
}

在哪里（ 重要 ） do_something以某种方式调用get_data_at_timepoint ：

void Bar::do_something() {
   // ...
   double x = foos[some_idx].get_data_at_timepoint(some_timepoint);
   // ...
};

我还想拥有的Library #2是在单个时间点上的 Library #1 。 就像是：

class Foo2 {
private:
    double data;

public:
    double get_data() const;

    // All those other methods of Foo
}

class Bar2 {
private:
    std::vector<Foo2> foos;

public:
    Foo2 get_this_foo_2(int idx) const;
    void do_something();
    // All those other methods of Bar
}

现在在哪里：

void Bar2::do_something() {
   // ...
   double x = foos[some_idx].get_data();
   // ...
};

显然， Foo2基本上只是Foo ，但是只有一个数据条目。 我可以重写Foo所有内容，但随后必须重复所有方法。 我要改为定义长度为1（单个数据点）的Foo的薄包装。

对于Foo2 ，有两个选项：（1）子类Foo ，或（2）让Foo2成为Foo唯一ptr的包装。 我认为（2）更好，因为用户不应访问基类Foo时间点。

我也想避免为Bar编写额外的代码。 当然，需要在Bar2稍微修改功能do_something ，但总体而言，这两个看起来是如此并行。 Bar中的许多其他方法也相同。

如何避免Foo2和Bar2代码重复？

Answer 1

做这个：

template <typename FooType>
class BarBase {
private:
    std::vector<FooType> foos;
protected:
    virtual double get_data_from_foo(unsigned int, void*) = 0;
public:
    void do_something();
    // all other methods that used to be in Bar
};

class Bar : public BarBase<Foo> {
protected:
    virtual void get_data_from_foo(unsigned int id, void* time_ptr) {
        return foos[id].get_data_at_timepoint(*(timepoint_t*)time_ptr);
    }
};

class Bar2 : public BarBase<Foo2> {
protected:
    virtual void get_data_from_foo(unsigned int id, void* dummy) {
        return foos[id].get_data();
    }
};

您必须在BarBase :: do_something（）中调用get_data_from_foo（）。 您还必须计算时间点并将其传递给该函数，而不管是否需要它。

或者，如果您不介意do_something（）内部的代码重复，则删除get_data_from_foo（）并向Bar和Bar2中的每个添加do_something（）成员函数，分别定义它们。

Answer 2

这就是为什么在许多c ++库中，类本身仅具有少量的成员函数，而这些成员函数仅限于描述类型的实际需要。 使用免费功能可以解决所有其他问题，这使您可以对代码进行模块化并以更好的方式重用功能。

因此，仅使用成员函数来隐藏类的数据结构的实现细节，或者如果需要使用virtual，则对于大多数其他情况，您大多数时候都想使用自由函数。

一个实现可能看起来像这样（这只是概念证明代码，以说明自由函数的用法）：

#include <iostream>
#include <vector>

class Foo {
private: 
   std::vector<double> data = {1,2,3};
public:
   std::vector<double>::const_iterator begin() const {
      return data.begin();
   }

   std::vector<double>::const_iterator end() const {
      return data.end();
   }

   double first() const {
     return *begin();
   }
};

class Foo2 {
private: 
   double data = 42;

public:
   const double * begin() const {
      return &data;
   }

    const double * end() const {
      return &data + 1;
   }

   double first() const {
     return *begin();
   }
};

template<typename T>
double get_data_at_timepoint(const T &obj, size_t index) {
    auto it = obj.begin()+index;
    return *it;
}

template<typename T>
double get_data(const T &obj) {
    return obj.first();
}


int main()
{
    Foo f;
    Foo2 f2;

    double d = get_data_at_timepoint(f, 2);
    double d2 = get_data_at_timepoint(f2, 0);


    double d3 = get_data(f);
    double d4 = get_data(f2);
   // double d2 = get_data_at_timepoint(f2, 0);
    std::cout << "get_data_at_timepoint " << d << " " << d2 << std::endl;
    std::cout << "get_data " << d3 << " " << d4 << std::endl;
}

现在，您可以将get_data_at_timepoint与支持double类型的迭代器的任何数据类型一起使用，并且它并不局限于您对Foo的定义。

如果get_data_at_timepoint对于这些类之一来说是特殊的，则可以为该类创建专门的版本：

template<>
double get_data_at_timepoint<Foo>(const Foo &obj, size_t index) {
    // Foo related implementation
}