C++函子使用，避免代码重复

C++ functors usage, code duplication avoidance

本文关键字：代码 C++      更新时间：2023-10-16

好的，所以我不确定它是否与函子有关，但据我所知是这样 问题是： 假设我有下一堂课：

class Matrix{
public:
Matrix(int, int);                       // constructor
Matrix(const Matrix&);                  // copy constructor
Matrix& operator+= (const Matrix&);
Matrix& operator-= (const Matrix&);
int* operator[] (int) const;
private:
int rows;
int cols;
int** Mat_p;
};

我想重载 Matrix 类中的 += 和 -= 运算符.now，
为了对 2 个矩阵求和或减去，我们需要迭代两个矩阵的每个值并加或减，所以它会像这样：

Matrix& Matrix::operator+= (const Matrix& M){
for (int indexR = 0; indexR < rows; ++indexR)
for (int indexC = 0; indexC < cols; ++indexC)
Mat_p[indexR][indexC] += M[indexR][indexC];
}
Matrix& Matrix::operator-= (const Matrix& M){
for (int indexR = 0; indexR < rows; ++indexR)
for (int indexC = 0; indexC < cols; ++indexC)
Mat_p[indexR][indexC] -= M[indexR][indexC];
}

如您所见，运算符"+="和"-="具有相同的结构"给予或接受"，因此所谓的基本"规则"之一是避免代码重复。
所以问的问题是我们如何避免这种重复并保持代码有效？

您可以实现单个模板化函数并对其进行两次调用。

template<typename T>
Matrix& add_or_sub (const Matrix& M, const T &op){
for (int indexR = 0; indexR < rows; ++indexR)
for (int indexC = 0; indexC < cols; ++indexC)
Mat_p[indexR][indexC] = op(Mat_p[indexR][indexC], M[indexR][indexC]);
return *this;
}
Matrix& Matrix::operator+= (const Matrix& M){
return add_or_sub(M, std::plus());
}
Matrix& Matrix::operator-= (const Matrix& M){
return add_or_sub(M, std::minus());
}

我有点晚了，但我想这个例子更完整。我建议编写一个分段函子应用器，它使用底层标量作为操作数，并返回相同的类型，并使用它实现运算符。

举个例子：

#include <iostream>
#include <functional>
using namespace std;
template <int Rows, int Cols, typename Scalar = int>
class Matrix {
public:
void piecewise_apply(const Matrix& other, std::function<Scalar(Scalar,Scalar)> f) {
for (int indexR = 0; indexR < Rows; ++indexR)
for (int indexC = 0; indexC < Cols; ++indexC)
data[indexR][indexC] = f(data[indexR][indexC], other.data[indexR][indexC]);
}
Matrix<Rows,Cols,Scalar>& operator+=(const Matrix<Rows,Cols,Scalar>& rhs) {
piecewise_apply(rhs, std::plus<Scalar>());
return *this;
}
Matrix<Rows,Cols,Scalar>& operator-=(const Matrix<Rows,Cols,Scalar>& rhs) {
piecewise_apply(rhs, std::minus<Scalar>());
return *this;
}
private:
Scalar data[Rows][Cols];
};
int main() {
Matrix<5,5> a;
Matrix<5,5> b;
a.piecewise_apply(b, [](int a, int b){return a*b;});
a -= b;
return 0;
}

该示例不完整，因为它缺少初始化。&rhs == this时也没有保护(一个有趣的优化地方)，可能还有更多，但它显示了这个想法。至于代码效率..好吧，您应该依靠编译器

。这种方法的一个优点是，即使默认版本有点慢，您也可以尝试编写使用更复杂的优化技术(如阻塞或并行化等)的piecewise_apply，并在各个地方获得加速。

对于简单版本，如您的示例所示，复制粘贴版本更短，更易于理解，因此可能是更好的选择。

相关文章：