chap12 operator overload

 

两种方式

(1)friend function

//xxx.h
class Integer {
 long i;
public:
 Integer(long ll = 0) : i(ll) {}

 friend const Integer operator+(const Integer& left,const Integer& right);
 //对于输入输出只能用这种方式
 friend ostream& operator<<(ostream& os, const Integer& in);
};

//xxx.cpp
const Integer operator+(const Integer& left,const Integer& right)
{
 return Integer(left.i + right.i);
}

ostream& operator<<(ostream& os, const Integer& in)
{
 os<<in.i<<endl;
 return os;
}

(2)member function
//xxx.h
class Integer {
 long i;
public:
 Integer(long ll = 0) : i(ll) {}

 const Integer operator+(const Integer& right)
 {
return Integer(i + right.i):
 }
};

推荐：

Operator               Recommended use
-------------------------------------------------------------------------
All unary operators                  member
-------------------------------------------------------------------------
= ( ) [ ] –> –>*               must be member
-------------------------------------------------------------------------
+= –= /= *= ^=
&= |= %= >>= <<=                      member
-------------------------------------------------------------------------
All other binary operators                  non-member
-------------------------------------------------------------------------



参数和返回值设定

As with any function argument, if you only need to read from the argument and not change
it, default to passing it as a const reference. Ordinary arithmetic operations (like +
and –, etc.) and Booleans will not change their arguments, so pass by const reference is
predominantly what you’ll use. When the function is a class member, this translates to
making it a const member function. Only with the operator-assignments (like +=) and the
operator=, which change the left-hand argument, is the left argument not a constant, but

it’s still passed in as an address because it will be changed.
The type of return value you should select depends on the expected meaning of the operator.
(Again, you can do anything you want with the arguments and return values.) If the effect
of the operator is to produce a new value, you will need to generate a new object as the
return value. For example, Integer: :operator+ must produce an Integer object that is the
sum of the operands. This object is returned by value as a const, so the result cannot be
modified as an lvalue.

All the assignment operators modify the lvalue. To allow the result of the assignment to
be used in chained expressions, like a=b=c, it’s expected that you will return a reference
to that same lvalue that was just modified. But should this reference be a const or
nonconst? Although you read a=b=c from left to right, the compiler parses it from right to
left, so you’re not forced to return a nonconst to support assignment chaining. However,
people do sometimes expect to be able to perform an operation on the thing that was just
assigned to, such as (a=b).func( ); to call func( ) on a after assigning b to it. Thus,
the return value for all of the assignment operators should be a nonconst reference to the
lvalue.

For the logical operators, everyone expects to get at worst an int back, and at best a bool.
(Libraries developed before most compilers supported C++’s built-in bool will use int or
an equivalent typedef.)


返回值的优化

(1)return Integer(left.i + right.i)
(2)Integer tmp(left.i + right.i);
  return tmp;
第二种方式下，先调用构造函数得到对象tmp，然后调用拷贝构造函数，将tmp拷贝改返回值，最后调用
析构函数销毁tmp，而第一种方式下，直接调用构造函数得到返回值，效率高了很多！

In contrast, the “returning a temporary” approach works quite differently. When the
compiler sees you do this, it knows that you have no other need for the object it’s
creating than to return it. The compiler takes advantage of this by building the object
directly into the location of the outside return value. This requires only a single
ordinary constructor call (no copy-constructor is necessary) and there’s no destructor
call because you never actually create a local object. Thus, while it doesn’t cost
anything but programmer awareness, it’s significantly more efficient. This is often
called the return value optimization.


赋值与拷贝构造函数

MyType b;
MyType a = b;//调用copy ctor
a = b;//调用operator=

区分：如果一个对象没有初始化，那么调用copy ctor，如果已经初始化了，则调用operator=



Reflexivity

One of the most convenient reasons to use global overloaded operators instead of member
operators is that in the global versions, automatic type conversion may be applied to
either operand, whereas with member objects, the left-hand operand must already be the
proper type. If you want both operands to be converted, the global versions can save a lot
of coding. Here’s a small example:


//: C12:ReflexivityInOverloading.cpp
class Number {
 int i;
public:
 Number(int ii = 0) : i(ii) {}
 const Number
 operator+(const Number& n) const {
   return Number(i + n.i);
 }
 friend const Number
   operator-(const Number&, const Number&);
};

const Number
 operator-(const Number& n1,
           const Number& n2) {
   return Number(n1.i - n2.i);
}

int main() {
 Number a(47), b(11);
 a + b; // OK
 a + 1; // 2nd arg converted to Number
//! 1 + a; // Wrong! 1st arg not of type Number
 a - b; // OK
 a - 1; // 2nd arg converted to Number
 1 - a; // 1st arg converted to Number
} ///:~
Class Number has both a member operator+ and a friend operator–. Because there’s a
constructor that takes a single int argument, an int can be automatically converted to a
Number, but only under the right conditions. In main( ), you can see that adding a Number
to another Number works fine because it’s an exact match to the overloaded operator. Also,
when the compiler sees a Number followed by a + and an int, it can match to the member
function Number: :operator+ and convert the int argument to a Number using the constructor.
But when it sees an int, a +, and a Number, it doesn’t know what to do because all it has
is Number: :operator+, which requires that the left operand already be a Number object. Thus,
the compiler issues an error.


With the friend operator–, things are different. The compiler needs to fill in both its
arguments however it can; it isn’t restricted to having a Number as the left-hand argument.
Thus, if it sees

1 – a
it can convert the first argument to a Number using the constructor.