c++ - 运算符重载中的 C++ 语法不清晰

Question

我对 C++ 还是个新手，正在尝试理解表达式模板。我在 Wikipedia 上看到了一个示例代码.我了解大部分程序及其工作原理，但我不清楚编译器如何解释这些行:

 operator A&()             { return static_cast<      A&>(*this); }
 operator A const&() const { return static_cast<const A&>(*this); }

来自下面的基本表达式模板类。通常运算符重载的语法是 return_datatype operator+ (args){body} (例如 for + operator)但是这会产生错误并且函数中的那些编译没有任何错误。谁能解释一下这两行？运算符之前的 A& 和 A const& 是做什么的？为什么 A& operator() (){} 和 A const& operator() (){} 不起作用？它给出了错误:

no matching function for call to 'Vec::Vec(const Expr<Vec>&)'
   ExprSum(const Expr<A>& a, const Expr<B>& b): _u(a), _v(b) {}

-普拉纳夫

完整代码:

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

using namespace std;


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); }
};


class Vec : public Expr<Vec> {
private:
  container_type x;
public:
  Vec(){}
  Vec(size_type length) :x(length) {}
  size_type  size() const { return x.size(); }

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

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

};


template <class A, class B>
class ExprSum : public Expr <ExprSum <A,B> >{
private:
  A _u;
  B _v;
public:
  typedef Vec::size_type size_type;
  typedef Vec::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_type size() const { return _u.size(); }
};


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(){

  size_t n = 10;
  Vec x(n);
  Vec y(n);
  Vec z;

  for(size_t i = 0; i < n; i++){
    x[i] = i;
    y[i] = 2*i;
  }

  z = x + y;

  cout << z[7] << endl;

  cout << "Hello world!" << endl;
  return 0;
}

Answer 1

这是一个 conversion operator .它看起来类似于普通的重载运算符，但它没有指定的返回类型，并且在运算符符号的位置有转换目标类型。