C++重载（未完）

C++重载操作
什么是运算符的重载?                   
重载后，原来的符号还可以用吗？
运算符与类结合，产生新的含义。 
为什么要引入运算符重载？
作用：实现类与类之间的数据或者方法操作。

代码+、-
class Point    
{    
private:    
    int x;   
public:    
    Point(int x1)  
    {   x=x1;}    
    Point(Point& p)     
    {   x=p.x;}  
    const Point operator+(const Point& p);//使用成员函数重载加号运算符  
    friend const Point operator-(const Point& p1,const Point& p2);//使用友元函数重载减号运算符  
};    

const Point Point::operator+(const Point& p)  
{  
    return Point(x+p.x);  
}  

Point const operator-(const Point& p1,const Point& p2)  
{  
    return Point(p1.x-p2.x);  
}  

调用:
Point a(1);    
Point b(2);  
a+b;  //正确，调用成员函数  
a-b;  //正确，调用友元函数  
a+1;  //正确，先调用类型转换函数，把1变成对象，之后调用成员函数  
a-1;  //正确，先调用类型转换函数，把1变成对象，之后调用友元函数  
1+a;  //错误，调用成员函数时，第一个操作数必须是对象，因为第一个操作数还有调用成员函数的功能  
1-a;  //正确，先类型转换 后调用友元函数  

代码++、--
class Point    
{    
private:    
    int x;   
public:    
    Point(int x1)  
    {   x=x1;}    
    Point operator++();//成员函数定义自增  
    const Point operator++(int x); //后缀可以返回一个const类型的值  
    friend Point operator--(Point& p);//友元函数定义--  
    friend const Point operator--(Point& p,int x);//后缀可以返回一个const类型的值  
};    

Point Point::operator++()//++obj  
{  
    x++;  
    return *this;  
}  
const Point Point::operator++(int x)//obj++  
{  
    Point temp = *this;  
    this->x++;  
    return temp;  
}  
Point operator--(Point& p)//--obj  
{  
    p.x--;  
    return p;  
         //前缀形式(--obj)重载的时候没有虚参,通过引用返回*this 或 自身引用,也就是返回变化之后的数值  
}  
const Point operator--(Point& p,int x)//obj--  
{  
    Point temp = p;  
    p.x--;  
    return temp;  
         // 后缀形式obj--重载的时候有一个int类型的虚参, 返回原状态的拷贝  
}  
调用
Point a(1);  
Point b(2);  
a++;//隐式调用成员函数operator++(0),后缀表达式  
++a;//隐式调用成员函数operator++(),前缀表达式  
b--;//隐式调用友元函数operator--(0),后缀表达式  
--b;//隐式调用友元函数operator--(),前缀表达式  
cout<<a.operator ++(2);//显式调用成员函数operator ++(2)，后缀表达式  
cout<<a.operator ++();//显式调用成员函数operator ++()，前缀表达式  
cout<<operator --(b,2);//显式调用友元函数operator --(2)，后缀表达式  
cout<<operator --(b);//显式调用友元函数operator --()，前缀表达式 </pre>  

代码[]重载方式：只能使用成员函数重载
class Point    
{    
private:    
    int x[5];   
public:    
    Point()  
    {  
        for (int i=0;i<5;i++)  
        {  
            x[i]=i;  
        }  
    }   
    int& operator[](int y);  
};    
int& Point::operator[](int y)  
{  
    static int t=0;  
    if (y<5)  
    {  
        return x[y];  
    }  
    else  
    {  
        cout<<"下标出界";  
        return t;  
    }     
}  
调用：
[cpp] view plain copy
Point a;  
for (int i=0;i<10;i++)  
{  
         cout<<a[i]<<endl;//无论i下标是否越界，每当使用a[i]时，都会调用[]的重载  
}  
a[0]=10;  

代码（）重载方式：只能使用成员函数重载
class Point    
{    
private:    
    int x;   
public:    
    Point(int x1)  
    {   x=x1;}    
    const int operator()(const Point& p);  
};    

const int Point::operator()(const Point& p)  
{  
    return (x+p.x);  
}  
[cpp] view plain copy
调用：  
Point a(1);  
Point b(2);  
cout<<a(b);  

代码<<\>>重载方式：只能使用友元函数重载 且 使用三个引用&
class Point    
{    
private:    
    int x;   
public:    
    Point(int x1)  
    {   x=x1;}   
    friend ostream& operator<<(ostream& cout,const Point& p);//使用友元函数重载<<输出运算符  
    friend istream& operator>>(istream& cin,Point& p);//使用友元函数重载>>输出运算符  
};    
ostream& operator<<(ostream& cout,const Point& p)  
{  
    cout<<p.x<<endl;  
    return cout;  
}  
istream& operator>>(istream& cin,Point& p)  
{  
    cin>>p.x;  
    return cin;  
}  

调用：  
Point a(1);  
Point b(2);  
cin>>a>>b;  
cout<<a<<b<<endl;  

参考：
http://blog.youkuaiyun.com/insistgogo/article/details/6626952