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 succeededif (in)s.revenue = s.units_sold * price;elses = Sales_item(); // input failed: reset object to default statereturn 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 returnret += rhs; // add in the contents of rhsreturn ret; // return ret by value
}　

inline bool
operator==(const Sales_item &lhs, const Sales_item &rhs)
{// must be made a friend of Sales_itemreturn 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 beforeScreen &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 objectCheckedPtr(int *b, int *e): beg(b), end(e), curr(b) { }// dereference and increment operations
private:int* beg; // pointer to beginning of the arrayint* end; // one past the end of the arrayint* curr; // current position within the array
};

class CheckedPtr {
public:CheckedPtr& operator++(); // prefix operatorsCheckedPtr& 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 statereturn *this;
}CheckedPtr& CheckedPtr::operator--()
{if (curr == beg)throw out_of_range("decrement past the beginning of CheckedPtr");--curr; // move current state back one elementreturn *this;
}　

class CheckedPtr {
public:// increment and decrementCheckedPtr operator++(int); // postfix operatorsCheckedPtr 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 checkCheckedPtr ret(*this); // save current value++*this; // advance one element, checking the incrementreturn ret; // return saved state
}
CheckedPtr CheckedPtr::operator--(int)
{// no check needed here, the call to prefix decrement will do the checkCheckedPtr ret(*this); // save current value--*this; // move backward one element and checkreturn 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(), word.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)));