Question

我正在尝试用C ++探索表达式模板。我正在尝试创建一个用于存储坐标，空间矢量，力等的3D矢量（基本上是3号矢量）的类，它基本上有三个组件。

到目前为止，我只实现了类来执行两个向量的求和。如果我写vector3d z; z = x + y;，代码工作正常。即如果我首先声明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 &。

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

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

1 个答案: