如何在声明变量时评估表达式（在表达式模板中）

Question

我正在尝试探索 C++ 中的表达式模板。我正在尝试为 3D 向量（基本上是大小为 3 的向量）创建一个 class，用于存储坐标、space 向量、力等，它们基本上具有三个分量。

到目前为止，我只实现了 class 来执行两个向量的求和。如果我写 vector3d z; z = x + y;，代码工作正常。 IE。如果我先声明 z 变量然后执行加法。但是，当我尝试用一个句子写 vector3d z = x + y; 时出现错误。我得到 error: conversion from 'const ExprSum<vector3d, vector3d>' to non-scalar type 'vector3d' requested vector3d z_new = x + y ;

我应该如何实现才能在变量声明期间使用 =？

下面是我的完整代码：

#include <iostream>
#include <vector>
#include <cassert>

using namespace std;

/** @brief The base expression class */

template <class A>
class Expr{
public:
  typedef std::vector<double>                  container_type;
  typedef typename container_type::size_type   size_type;
  typedef typename container_type::value_type  value_type;
  typedef typename container_type::reference   reference;

  size_type size() const  {return static_cast<A const&>(*this).size(); }
  value_type operator [] (size_t i) const {return static_cast<A const&> (*this)[i];}
  operator A&()             { return static_cast<      A&>(*this); }
  operator A const&() const { return static_cast<const A&>(*this); }
};


/** @brief The vector3d class : The vector<double> with 3 elements */

class vector3d : public Expr<vector3d> {
private:
  container_type _data;
public:
  vector3d():_data(3){}
  vector3d(const vector3d& _rhs){
      *this = _rhs;
  }

  size_type  size() const { return _data.size(); } // should return 3.

  reference operator [] (size_type i){
    assert(i < _data.size());
    return _data[i];
  }

  value_type operator [] (size_type i) const {
    assert(i < _data.size());
    return _data[i];
  }

  template <class A>
  void operator = (const Expr<A>& _rhs){
    _data.resize(_rhs.size());
    for(size_t i = 0; i < _data.size(); i++){
      _data[i] = _rhs[i];
    }
  }

};

/** @brief class for summation of vectors  */

template <class A, class B>
class ExprSum : public Expr <ExprSum<A,B> >{
private:
  A _u;
  B _v;
public:

  typedef vector3d::value_type value_type;

  ExprSum(const Expr<A>& a, const Expr<B>& b): _u(a), _v(b) {}

  value_type operator [] (size_t i) const { return (_u[i] + _v[i]); }

  size_t size() const { return _u.size(); }
};


/** @brief wrapper function of ExprSum class */
template <class A, class B>
ExprSum <A,B> const operator + (Expr<A> const& u, Expr<B> const& v){
  return ExprSum <A,B> (u,v);
}


int main()
{
    vector3d x,y;

    x[0] = 1;
    x[1] = 2;
    x[2] = 3;

    y[0] = 5;
    y[1] = 4;
    y[2] = 0;

    // works fine
    vector3d z;
    z = x + y;

    vector3d z_new = x + y ; // get error

    return 0;
}

Answer 1

这是因为您定义的 operator + 会产生一个 Expr<ExprSum<A,B>>，它只能转换为 ExprSum<A,B>。 vector3d 的构造函数期望 const vector3d &.

与 vector3d 中的 operator = 一样，您需要定义一个类似的 vector3d(const Expr<T> &) 构造函数。

如何在声明变量时评估表达式（在表达式模板中）

how to evaluate expression while declaring variable (in expression templates)

c++

templates

expression-templates