[c++primer][14]重载操作符与转换

item1 += item2; // expression based "call"
item1.operator+=(item2); // equivalent call to member operator function

ostream&
operator<<(ostream& out, const Sales_item& s)
{
　　out << s.isbn << "\t" << s.units_sold << "\t"
　　　　<< s.revenue << "\t" << s.avg_price();
　　return out;
}//注意：IO操作符必须为非成员函数

istream&
operator>>(istream& in, Sales_item& s)
{
　　double price;
　　in >> s.isbn >> s.units_sold >> price;
　　// check that the inputs succeeded
　　if (in)
　　　　s.revenue = s.units_sold * price;
　　else
　　　　s = Sales_item(); // input failed: reset object to default state
　　return in;
}

// assumes that both objects refer to the same isbn
Sales_item
operator+(const Sales_item& lhs, const Sales_item& rhs)
{
　　Sales_item ret(lhs); // copy lhs into a local object that we‘ll return
　　ret += rhs; // add in the contents of rhs
　　return ret; // return ret by value
}　

inline bool
operator==(const Sales_item &lhs, const Sales_item &rhs)
{
　　// must be made a friend of Sales_item
　　return lhs.units_sold == rhs.units_sold &&
　　lhs.revenue == rhs.revenue &&
　　lhs.same_isbn(rhs);
}

inline bool
operator!=(const Sales_item &lhs, const Sales_item &rhs)
{
　　return !(lhs == rhs); // != defined in terms of operator==
}

class Foo {
public:
　　int &operator[] (const size_t);
　　const int &operator[] (const size_t) const;
　　// other interface members
private:
　　vector<int> data;
　　// other member data and private utility functions
};　

class ScreenPtr {
public:
　　// constructor and copy control members as before
　　Screen &operator*() { return *ptr->sp; }
　　Screen *operator->() { return ptr->sp; }
　　const Screen &operator*() const { return *ptr->sp; }
　　const Screen *operator->() const { return ptr->sp; }
private:
　　ScrPtr *ptr; // points to use-counted ScrPtr class
};　

/*
* smart pointer: Checks access to elements throws an out_of_range
* exception if attempt to access a nonexistent element
* users allocate and free the array
*/
class CheckedPtr {
public:
// no default constructor; CheckedPtrs must be bound to an object
CheckedPtr(int *b, int *e): beg(b), end(e), curr(b) { }
// dereference and increment operations
private:
int* beg; // pointer to beginning of the array
int* end; // one past the end of the array
int* curr; // current position within the array
};

class CheckedPtr {
public:
　　CheckedPtr& operator++(); // prefix operators
　　CheckedPtr& operator--();
　　// other members as before
};

// prefix: return reference to incremented/decremented object
CheckedPtr& CheckedPtr::operator++()
{
　　if (curr == end)
　　　　throw out_of_range
　　　　　　("increment past the end of CheckedPtr");
　　++curr; // advance current state
　　return *this;
}

CheckedPtr& CheckedPtr::operator--()
{
　　if (curr == beg)
　　　　throw out_of_range
　　　　　　("decrement past the beginning of CheckedPtr");
　　--curr; // move current state back one element
　　return *this;
}　

class CheckedPtr {
public:
　　// increment and decrement
　　CheckedPtr operator++(int); // postfix operators
　　CheckedPtr operator--(int);
　　// other members as before
};

// postfix: increment/decrement object but return unchanged value
CheckedPtr CheckedPtr::operator++(int)
{
　　// no check needed here, the call to prefix increment will do the check
　　CheckedPtr ret(*this); // save current value
　　++*this; // advance one element, checking the increment
　　return ret; // return saved state
}

CheckedPtr CheckedPtr::operator--(int)
{
　　// no check needed here, the call to prefix decrement will do the check
　　CheckedPtr ret(*this); // save current value
　　--*this; // move backward one element and check
　　return ret; // return saved state
}

CheckedPtr parr(ia, ia + size); // iapoints to an array of ints
parr.operator++(0); // call postfix operator++
parr.operator++(); // call prefix operator++

struct absInt {
　　int operator() (int val) {
　　　　return val < 0 ? -val : val;
　　}
};

int i = -42;
absInt absObj; // object that defines function call operator
unsigned int ui = absObj(i); // calls absInt::operator(int)

// determine whether a length of a given word is 6 or more
bool GT6(const string &s)
{
　　return s.size() >= 6;
}

vector<string>::size_type wc =
count_if(words.begin(), words.end(), GT6);

// determine whether a length of a given word is longer than a stored bound
class GT_cls {
public:
　　GT_cls(size_t val = 0): bound(val) { }
　　bool operator()(const string &s)
　　{ return s.size() >= bound; }
private:
　　std::string::size_type bound;
};


cout << count_if(words.begin(), words.end(), GT_cls(6))
　　　<< " words 6 characters or longer" << endl;

plus<int> intAdd; // function object that can add two int values
negate<int> intNegate; // function object that can negate an int value
// uses intAdd::operator(int, int) to add 10 and 20
int sum = intAdd(10, 20); // sum = 30
// uses intNegate::operator(int) to generate -10 as second parameter
// to intAdd::operator(int, int)
sum = intAdd(10, intNegate(10)); // sum = 0

// passes temporary function object that applies > operator to two strings
sort(svec.begin(), svec.end(), greater<string>());

count_if(vec.begin(), vec.end(), bind2nd(less_equal<int>(), 10));

count_if(vec.begin(), vec.end(), not1(bind2nd(less_equal<int>(), 10)));