运算符重载
#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;
}