运算符重载，友元函数；

运算符重载

#include<iostream>

using namespace std;
class CInt
{
friend ostream& operator<<(ostream& out,const CInt & timp);
private:
    int i;
public:
    CInt (int d)
    {
        i=d;
    };
    CInt(const CInt &timp)
    {
        i=timp.i;
    }
public:
    CInt operator+(const CInt &timp)const //CInt add(const CInt &timp)const
    {
        return(i+timp.i);
    }
    CInt add(const CInt &timp)const
    {
        return(i+timp.i);
    }
    CInt operator+(const int d) const
    {
        return(i+d);
    }
/**public:
    CInt operator*(const CInt &timp);
    CInt operator+=(const CInt &timp);
    CInt operator&(const CInt &timp);
    CInt operator>(const CInt &timp);
    CInt operator%(const CInt &timp);
    //等等。。。。。可以重载各种符号；
    //但是对 ？ . .* :: sizeof 这五个运算符不能重载
**/
public:
    CInt& operator++()//返回this所以可以引用返回
    {
        i++;
        return *this;
    }
    CInt operator++(int )//不能理解，就当做规定吧，区分前加加，和后加加
    {
        CInt timp(i);
        i++;         //给i++，但是下一步返回原来的那个，就达成了先使用后加加的效果；
        return timp;
    }

};

ostream& operator<<(ostream& out,const CInt & timp)
{
    out <<"这是一个整型"<<timp.i<<endl;
    return out;
}
int main()
{
    CInt a(2);
    CInt b=3;

    a=a+b;              //左边是调用函数的类，右边是函数的参数
    cout <<a;
    a=a.operator+(b);  //加号重载函数调用的本质（opertor+相当与一个正常的函数名）
    a=a.add(b);         //和一个普通函数类比，发现其实原理都一样

    cout <<a;
    cout <<a++;
    cout <<++a;

    a=a+10;//将10通过构造函数，构造为一个无名临时对象，然后执行对象的加法函数；


    cout<<a;
    //只靠函数的重载还有许多的东西无法实现，要通过友元函数
    //比如上面的输出符号的重载
    //还有，如果我有一个数字加一个对象，就不能 数字+对象，因为重载符号左面是调用他的对象
    //所以要实现他们就要借助友元函数
}

友元函数

#include <iostream>

using namespace std;
/**
成员函数
1.可以访问对象的私有部分；
2.函数必须位于类里面声明，作用域必须在类里面
3.调用函数时，必须由对象去调用

友元函数
1.可以访问对象的私有部分；
2.作用域取决于函数自己；
3.不需要该对象调用；

其实就是一个正常的函数，他不属于类A，但是只要声明为类A的友元函数，他就可以直接访问类A的私有成员，其他的就和该函数的原来的性质一样的；
**/
class CBool
{
    bool i;
public :
    CBool add()
    {
        return *this;
    }
};
class CInt
{
friend CBool;//CBool作为CInt的友元类，那么CBool里面的每个函数，都是CInt的友元函数，即CBool的函数可以访问CInt的私有部分；
private:
    int i;

friend void show (const CInt &timp);
/**
在类里面声明一个友元函数
友元函数不区分私有公有；
也可以讲函数定义也写在这里，但是他的作用域不是这个类这个一定要区分；
**/
//可以用友元函数补充运算符完不成的任务
friend ostream & operator<<(ostream &out,const CInt & timp);//将输符号重定义，并把他作为友元函数；
friend CInt operator+(const int &b,const CInt &timp);//实现一个整形加对象；
public :
    CInt(int d=0)
    {
        i=d;
    }
    CInt(const CInt & timp)
    {
        i=timp.i;
    }
public:
    ostream &operator<<(ostream &out )//如果我们把<<重载为成员函数
    {
        out<<"这是一个整数"<<i<<endl;
        return out ;
    }

};
void show (const CInt & timp)
{
    cout<<timp.i<<endl;
}
ostream &operator<<(ostream &out ,const CInt & timp)//重载<<,也可以重载>>.
{
    out<<"这是一个整数"<<timp.i<<endl;
    return out ;
}
CInt operator+(const int &b,const CInt &timp)
{
    return b+timp.i;
}
int main()
{
    CInt a=2;
    a=4+a;/**
    operator+(4,a);
    区别与成员函数的重载
    a=a+4; ==> a.operator+(4);  ==>operator+(this,4);
    **/
    cout << a << endl;//重载为友元函数调用
    a<<cout;//重载为成员函数,由a.operator+（cout）;
    return 0;
}