Operator overloading outside class

This question already has an answer here:

  • What are the basic rules and idioms for operator overloading? 7 answers

  • The basic question is "Do you want conversions to be performed on the left-hand side parameter of an operator?" . If yes, use a free function. If no, use a class member.

    For example, for operator+() for strings, we want conversions to be performed so we can say things like:

    string a = "bar";
    string b = "foo" + a;
    

    where a conversion is performed to turn the char * "foo" into an std::string . So, we make operator+() for strings into a free function.


    First: the two different ways are really "overload as a member" and "overload as a non-member", and the latter has two different ways to write it (as-friend-inside class definition and outside class definition). Calling them "inside class" and "outside class" is going to confuse you.


    Overloads for +=, +, -=, -, etc. have a special pattern:

    struct Vector2 {
      float x, y;
      Vector2& operator+=(Vector2 const& other) {
        x += other.x;
        y += other.y;
        return *this;
      }
      Vector2& operator-=(Vector2 const& other) {
        x -= other.x;
        y -= other.y;
        return *this;
      }
    };
    Vector2 operator+(Vector2 a, Vector2 const& b) {
      // note 'a' is passed by value and thus copied
      a += b;
      return a;
    }
    Vector2 operator-(Vector2 a, Vector2 const& b) { return a -= b; } // compact
    

    This pattern allows the conversions mentioned in the other answers for the LHS argument while simplifying the implementation considerably. (Either member or non-member allows conversions for the RHS when it's passed either as a const& or by value, as it should be.) Of course, this only applies when you do actually want to overload both += and +, -= and -, etc., but that is still common.


    Additionally, you sometimes want to declare your non-member op+, etc. as friends within the class definition using the Barton-Nackman trick, because due to quirks of templates and overloading, it may not be found otherwise.


    在Meyer的Effective C ++中有一个很好的关于这个问题的讨论:第24项是“当类型转换应用于所有参数时声明非成员函数”,而第46项是“在需要类型转换时定义模板内部的非成员函数”。

    链接地址: http://www.djcxy.com/p/12694.html

    上一篇: 运算符++的返回值

    下一篇: 操作员在课外超载