C++ 中的高效向量运算符 / 对临时对象的引用

Question

我正在尝试编写一个 C++ 矢量类，它存储数据数组并允许逐个元素执行数学运算。我想以这样一种方式实现这一点，即表达式 a = b + c + d 应该只遍历所有元素一次，并直接将和 b[i] + c[i] + d[i] 写入 a[i] 而不创建中间向量。

我写的是这样的：

template<class T, int N>
class VectorExpression {
  public:
    virtual T operator[] (int i) const = 0;

    virtual ~VectorExpression() {}
}

template<class T, int N>
class MyVector : public VectorExpression<T, N> {
    T data[N];

  public:
    T& operator[] (int i) { return data[i]; }
    T& const operator[] (int i) const { return data[i]; }

    MyVector<T,N>& operator=(const VectorExpression<T,N> &rhs) {
      for (int i = 0; i < N; ++i)
        data[i] = rhs[i];

      return *this;
    }
}

template<class T, int N>
class VectorSum : public VectorExpression<T, N> {
    VectorExpression<T,N> &a, &b;

  public:
    VectorSum(VectorExpression<T,N> &aa, VectorExpression<T,N> &bb)
    : a(aa), b(bb) {}

    T operator[] (int i) const { return a[i] + b[i]; }
}

template<class T, int N>
VectorSum<T,N> operator+(const VectorExpression<T,N> &a, 
        const VectorExpression<T,N> &b) 
{
  return VectorSum<T,N>(a, b);
}

int main() {
  MyVector<double,10> a, b, c, d;

  // Initialize b, c, d here

  a = b + c + d;

  return 0;
}

这个功能可能是由 valarray 类提供的，但那是因为我试图将它简化为一个最小的示例。

我将operator[] 设为虚拟，因为这允许嵌套所有类型的表达式（例如a = !(-b*c + d)），前提是我将定义所有类似于VectorSum 的运算符和相应的类。

我使用引用是因为普通变量不是多态的，并且指针不适用于运算符重载。

现在我的问题是：

• 在a = b + c + d;语句中，会创建两个临时的VectorSum<double,10>对象，分别存储b + c和(b+c) + d。它们的寿命是否足以使多态行为发挥作用？更具体地说，(b+c) + d 将存储对b + c 的引用，但是当调用operator= 时该对象是否仍然存在？根据this post，所有临时对象都应该存在，直到operator= 返回，但这是否也适用于旧版本的C++？

• 如果不是，那么这是如何完成的？我看到的唯一选择是使用new 分配VectorSum 对象，通过引用返回它们，然后在operator= 函数中删除它们，但这似乎有点麻烦，而且效率可能低得多。我也不确定它是否总是安全的。

• （小问题）可以在MyVector中用T& const覆盖VectorExpression::operator[]的返回类型T吗？

编辑

我在 operator+ 中有错误的参数类型：将它们从 VectorSum 更改为 VectorExpression。

Answer 1

这就是我想出的：

#include <iostream>
#include <initializer_list>
#include <algorithm>


template<class T, int N>
class VectorExpression {
public:
    virtual T operator[] (int i) = 0;
    virtual const T operator[] (int i) const = 0;

    virtual ~VectorExpression() {}
};


template<class T, int N>
class MyVector : public VectorExpression<T, N> {
  T data[N];

public:
  MyVector() {
    // initialize zero
    std::fill(std::begin(data), std::end(data), T());
  }

  MyVector(const std::initializer_list<T>& values) {
    // initialize from array initializer_list
    std::copy(std::begin(values), std::end(values), data);
  }

  MyVector(const VectorExpression<T,N>& rhs) { 
    for (int i = 0; i < N; ++i)
      data[i] = rhs[i];
  }

  MyVector<T,N>& operator=(const VectorExpression<T,N>& rhs) {
    for (int i = 0; i < N; ++i)
      data[i] = rhs[i];

    return *this;
  }

  T operator[] (int i) { return data[i]; }
  const T operator[] (int i) const { return data[i]; }

  friend std::ostream& operator<<(std::ostream& stream, MyVector& obj) { 
    stream << "[";
    for (int i = 0; i < N; ++i) { 
      stream << obj.data[i] << ", ";
    }
    stream << "]";

    return stream;
  }
};

template<class T, int N>
class VectorSum : public VectorExpression<T, N> {
  const MyVector<T,N> &a, &b;

public:
  VectorSum(const MyVector<T,N>& aa, const MyVector<T,N>& bb):
    a(aa), b(bb) {
  }

  T operator[] (int i) { return return a[i] + b[i]; }

  const T operator[] (int i) const { return a[i] + b[i]; }
};


template<class T, int N>
MyVector<T,N> operator+(const MyVector<T,N>& a, const MyVector<T,N>& b) {
  return VectorSum<T,N>(a, b);
}


int main() {
  MyVector<double,3> a, b({1,2,3}), c({3,4,5}), d({4,5,6});

  a = b + c + d; 

  std::cout << b << std::endl;
  std::cout << c << std::endl;
  std::cout << d << std::endl;
  std::cout << "Result:\n" << a << std::endl;

  return 0;
}

输出：

[1, 2, 3, ]
[3, 4, 5, ]
[4, 5, 6, ]
Result:
[8, 11, 14, ]

我添加了一个 initializer_list (C++11) 构造函数和 ostream 运算符，纯粹是为了方便/说明。

由于您已将 operator[] 定义为按值返回，因此我无法在数据数组中设置项目以进行测试（因为错误：需要左值作为赋值的左操作数）；通常这个运算符应该是通过引用 - 但是，在你的情况下， VectorSum::operator[] 将不起作用，因为这会因为返回对临时的引用而导致编译失败。

我还添加了一个复制构造函数，因为 ...

// this calls MyVector's copy constructor when assigned to 'main::a'
template<class T, int N>
MyVector<T,N> operator+(const MyVector<T,N>& a, const MyVector<T,N>& b) {
  return VectorSum<T,N>(a, b);   // implicit MyVector::copy constructor 
}

// this also calls MyVector's copy constructor (unless the copy constructor is defined explicit)
template<class T, int N>
MyVector<T,N> operator+(const MyVector<T,N>& a, const MyVector<T,N>& b) {
  MyVector<T,N> res = VectorSum<T,N>(a, b);
  return res;
}

// but this would call MyVector's assignment operator
template<class T, int N>
MyVector<T,N> operator+(const MyVector<T,N>& a, const MyVector<T,N>& b) {
  MyVector<T,N> res;
  res = VectorSum<T,N>(a, b);
  return res;
}

回答您的问题：

1. 是的 - 如果您明确定义变量并且 退回那个？临时工的行为是一样的，除了那里 是没有变量声明；
2. 不适用
3. 我在上面提到过 - 你不能 由于“返回临时引用”错误而使用引用； 但是，您没有理由将 T& operator[] 添加到 MyVector（即不覆盖）。

编辑：对 cme​​ts 的回答：

1. 重写时函数规范必须相同，包括返回类型。由于您已在 VectorExpression 中定义了按值返回，因此它必须在 MyVector 中按值返回。如果您尝试将其更改为子类中的引用，您将收到编译错误：指定的返回类型冲突。所以不，你不能用返回 const T& 而不是 T 的版本覆盖 operator const。此外，它 必须 按值返回，因为 MyVectorSum 返回 { a[i] + b[i] } 这将是一个临时的，你不能返回对临时的引用。

2. 对不起，我的错误，上面已修复。

3. 因为：

   • MyVector 不是 VectorSum 的子类型 - 编译错误“MyVector”不是从“const VectorSum”派生的
   • 我也尝试过 VectorExpression，但编译错误：'无法分配抽象类型的对象' - 因为它试图按值返回
   • 我选择了 MyVector，因为这是您预期的结果类型。是的，它完成了所有那些 for 循环，但我看不出有什么办法：有三个不同的数组“数据”变量，每个变量都需要迭代才能累积。在代码中的某个时刻，您将不得不执行 for 循环。

4. 明白，是的，我很困惑。从帖子中删除。

Answer 2

一开始我并没有想到这一点，但是拥有一个虚拟的 operator[] 方法可能会通过避免 3 个 for 循环和向量大小的临时对象的中间存储来降低我试图实现的效率。将方法设为虚拟可防止它被内联，这意味着它需要作为函数实际调用每次访问元素时。

根据我从对我的问题发表评论的人和 Google 那里获得的链接，我最终得到了以下解决方案，它避免了需要任何虚拟方法。

template<class T, int N, class V>
class VectorExpressionBase {
    V ref;

protected:
    explicit VectorExpressionBase(const V *ref) 
    : ref(const_cast<V*>(ref)) {}

public:
    T  operator[] (int i) const { return ref[i]; }
    T& operator[] (int i)       { return ref[i]; }
}

template<class T, int N>
class VectorExpressionBase<T,N,void> {
    T data[N];

protected:
    explicit VectorExpressionBase(const void*) {
        // Argument is unused but accepted to have uniform
        // calling syntax
    }

public:
    T  operator[] (int i) const { return data[i]; }
    T& operator[] (int i)       { return data[i]; }
}

template<class T, int N, class V>
class VectorExpression : public VectorExpressionBase<T,N,V> {
public:
    template<class V1>
    VectorExpression<T,N,V>& operator= (
        const VectorExpression<T,N,V1> &rhs) 
    {
        for (int i = 0; i < N; ++i)
            data[i] = rhs[i];

        return *this;
    }

    explicit VectorExpression(const V *ref = 0) 
    : VectorExpressionBase<T,N,V>(ref) {}

    // Can define all kinds of operators and functions here such as
    // +=, *=, unary + and -, max(), min(), sin(), cos(), ...
    // They would automatically apply to MyVector objects and to the
    // results of other operators and functions
};

template<class T, int N>
class MyVector : public VectorExpression<T,N,void> {
}

template<class T, int N, class VA, class VB>
class VectorSum {
    VectorExpression<T,N,VA> &a;
    VectorExpression<T,N,VB> &b;

  public:
    VectorSum(VectorExpression<T,N,VA> &aa, VectorExpression<T,N,VB> &bb)
    : a(aa), b(bb) {}

    T operator[] (int i) const { return a[i] + b[i]; }
}

template<class T, int N, class VA, class VB>
VectorExpression<T,N,VectorSum<T,N,VA,VB> >
operator+(const VectorExpression<T,N,VA> &a, 
          const VectorExpression<T,N,VB> &b) 
{
    VectorSum<T,N,VA,VB> sum(a, b);
    return VectorExpression<T,N,VectorSum<T,N,VA,VB> >(sum);
}

VectorExpression 类现在只包装完成工作的类（在本例中为VectorSum。这允许仅为VectorExpression 定义各种函数和运算符，而不必为VectorSum 重载它们， VectorProduct等

MyVector 派生自 VectorExpression 的特例，它有一个专门的基类；这并不是真正必要的，但它很好，因为它使为VectorExpression 定义的所有函数和运算符也可用于MyVector。通过使用仅处理存储的简单基类VectorExpressionBase 和[] 运算符，所有其他运算符和方法都不需要在V = void 的特化中重复。

如果用户想要定义额外的函数和操作符，他们只需要知道类MyVector<T,N>（用于存储数据）和可能的VectorExpression<T,N,V>。 VectorExpressionBase 和 VectorSum 这样的类不需要对外界可见。

我发现我最初的解决方案在概念上更加清晰，因为每个类的含义更清晰，并且不需要模板参数V，但是这个更有效，因为它不需要任何虚函数，在某些情况下，这可能会产生很大的不同。

感谢您为我指出正确的链接！

附：当然，大多数/所有这些都不是新的，但我认为总结和解释一下会很好。我希望它可以帮助其他人。

编辑

我将数据成员VectorExpressionBase<T,N,V>::ref 的类型从V& 更改为V。这是必需的，因为在评估 VectorExpression 时，引用指向的临时 V 对象可能不再存在。例如，当operator+函数返回时，临时的VectorSum对象不存在，使得返回的VectorExpression对象无用。

我还用一些构造函数完成了代码并更正了operator+ 函数。