Item item1 ,item2;
item1 + item2;		// call method 1
operator+(item1,item2)	// call method 2
// if + is operator of class
item1 + item2;
item1.operator+(item2);

2 重载操作符的谨记

// output.h
#pragma once
#include <iostream>
using namespace std;
class Input
{
public:
Input(void);
~Input(void);
ostream& operator <<(ostream& out);
private:
string str;
int fun;
};


// output.cpp
#include "Input.h"
Input::Input(void)
{
str = "keep move on";
fun = 1001;
}
Input::~Input(void)
{
}
ostream& Input::operator<<(ostream& out)
{
out<<"persist on"<<fun<<endl;
return out;
}


//main.cpp
#include "Input.h"
void main()
{
Input in;
in<<cout<<"I'll always find you"<<endl;
}

#pragma once
#include <vector>
using namespace std;
class XB
{
public:
XB(void);
~XB(void);
int& operator [](const size_t index);
const int& operator [](const size_t index)const;
private:
vector<int> data;
};


//XB.cpp
#include "XB.h"
XB::XB(void)
{
data = http://www.mamicode.com/vector(5,2);>
10 解引用操作符‘*‘和箭头操作符‘->‘
这两个操作符经常用在智能指针上面，就是把一些类对象给它赋予指针的功能。智能指针除了要操作的类外，另外包含两个类，一个类用来存放类对象的指针，以及使用计数。另一个类用来操作使用计数，并根据使用计数的大小来确定是否释放对象。下面的例子中Tv类是要操作类，TvPtr是包含使用技术和操作类的类。
#include <iostream>
using namespace std;
class Tv
{
public:
Tv(void):m_height(100),m_width(390){};
~Tv(void){};
int func(){return m_height * m_width;}
private:
int m_height;
int m_width;
};


class TvPtr
{
friend class TvPtrCnt;
Tv* sp;
size_t use;
TvPtr(Tv* p):sp(p),use(1){}
~TvPtr(){delete sp;}
};


class TvPtrCnt
{
public:
TvPtrCnt(Tv* p):ptr(new TvPtr(p)){}
TvPtrCnt(const TvPtrCnt& orig):ptr(orig.ptr){++ptr->use;};
TvPtrCnt& operator =(const TvPtrCnt &orig){++ptr->use;}
~TvPtrCnt(){if(--ptr->use ==0) delete ptr;}


Tv& operator*(){return *ptr->sp;}
Tv* operator->(){return ptr->sp;}
const Tv& operator*()const{return *ptr->sp;}
const Tv* operator->()const{return ptr->sp;}
private:
TvPtr* ptr;
};
void main()
{
Tv *p = new Tv();
TvPtrCnt zp(p);
std::cout<<(*zp).func()<<std::endl;
std::cout<<zp->func()<<std::endl;

system("pause");
}

注意：这里说的是箭头操作符‘->’它不同于一般的操作符，就那point->action来讲：
<1>如果point是指针，指向具有action成员的对象，那么编译器将代码编译为调用该对象的action的成员
<2>如果action是定义了‘->’操作符的类的一个成员，那么point->action与point.operation->()->action等同
<3>否则，代码错误

总结：使用箭头‘->’操作符，必须返回一个指针类型或者自定义了‘->’的类对象。
解引用操作符和箭头操作符赋予了类对象看似指针的行为功能。


11 自增操作符，自减操作符
这些操作符又分为前自增(prefix)，后自增（postfix),前自减(prefix)，后自减(postfix)
<1>prefix
XXX& operator++();
XXX& operator--();
<2>postfix
为了区分前和后的区别，在后自增，后自减的函数中增加了一个int的参数，编译器提供0做位实参值
XXX operator++(int);
XXX operator--(int);
注意：后自增，后自减的返回值不是引用，因为返回的是一个临时的变量
<3> 显式的调用前缀后缀操作符
XXX.operator++(); //prefix
XXX.operator++(0); //postfix

12 调用操作符和函数对象
<1>
类重载函数调用操作符‘()‘，这样通过控制通过在对象后面加括弧，加参数，可以把类对象当做函数一样使用，我们把定义了调用操作符的类，器对象成为函数对象。
#include <iostream>
using namespace std;
class Abs
{
public:
Abs(){}
~Abs(){}
int operator ()(int val){return val <0 ? -val : val;}
};
void main()
{
Abs XX;
cout<<XX(-108)<<endl;
system("pause");
}

<2>函数对象用于标准库算法
标准库中有很多函数，需要提供函数指针或者函数对象作为参数，例如count_if()函数
<3>标准卡中还有很多定义的函数对象
plus<Type>,minus<Type>,multiplies<Type>,greater<Type>...
很多函数对象都是存在<functional>头文件中的函数对象
plus<int> Add;
cout<<Add(100,-23)<<endl;
C++primer读书笔记8重载操作符