C++学习笔记之运算符重载呢

运算符重载：
1.运算符重载，把运算符重新定义新的规则（例：之前运算符+的作用为加但通过运算符重载的时候，就会把加变为减或者其他意思，之后再调用‘+’号的时候，就会行使指定的意思）
2.几乎所有的运算符都可以被重载，除以下：::,?:,sizeof这些是不能被重载的
3.运算符重载基本上出现在类中和结构中。
4.运算符重载完后要满足原来的运算规则
5.运算符其实也相当于函数的重载（就是调用函数名）

运算符重载：operator<需要重载的符号>
运算符重载：以下程序中重载了运算符前++和后++
还有重载了-号和+号

#include
using namespace std;
class Person
{
	public:
	int a;
	Person(int x)
	{
		a=x;
	}
	int fun(Person &p);
	{
		return this->a+p.a;
	}
	int operator+(const Person &p)//加const的原因是因为为了不改变参与对象的值
	{	
		return this->a+p.a;		
	}
	int operator-(const Person &p)
	{
		return this->a-p.a;
	}
	//加&，是为了不调用拷贝构造，当前调用者并没有消失，不需要拷贝
	//前加加
	Person &operator++()
	{
		this->a++;
		return *this;//把当前的对象返回出去
	}
	//后加加
	Person &operator++(int)
	{
		Person temp=*this;
		this->a++;//当前对象的值自增
		return temp;//把之前的值返回出去
	}
};
//用于对象和对象之间的操作的
int main()
{
	Person p1(10);
	Person p2(20);
	cout<<p1<<"\t"<p2<<endl;
	int c=p1+p2;//加法运算重载
	c=p2-p1;//减号运算重载
	++p1;//前加加运算重载
	//或者直接用+号就可以了
	++p1;
	cout<<c<<endl;
	cout<<p1.a<<endl;
	system("pause");
	return 0;
}

等号的运算符重载
什莫时候用到等号重载呢？
就是对象需要申请内存的写的时候就需要等号重载
因为一般的等号在由于对象给对象赋值的时候会报错，因为这里涉及到了有指针指向同一地址的错误，一旦上一个对象用过后调用析构函数将内存释放掉，那么被赋值的对象会不知道指向哪里，因此会导致错误的存在。

#include
using namespace std;
class Person
{
	char *p;
public:
	Person()
	{
		p=NULL;
	}
	Person(char *str)
	{
		p=new char[strlen(str)+1];
		strcpy(p,str);
	}
	void fun()
	{
		cout<<p<<endl;
	}
	~Person()
	{
		if(p!=NULL)
		{
			delete[]p;
			p=NULL;
		}
	}
	Person &operator=(const Person&x)
	{
		//要赋值的对象里面的指针是否有申请内存，有就释放
		if(this->p!=NULL)
		{
			delete[]this->p;
			this->p=NULL; 
		}
		this->p=new char[strlen(x.p)+1];
		strcpy(this->p,x.p);
		return *this;
	}
};
void text()
{
	Person p1("lijiamin");
	Person p2;
	p2=p1;
	p1.fun();
	p2.fun();
}
int main()
{
	text();
	system("pause");
	return 0;
}

括号重载

#include
using namespace std;
class Person()
{
public:
	void operator()(int a,int b)
	{
		cout<<"who l am"<<endl;
	}
};
int main()
{
	Person p1;
	p1(1,2);
	system("pause");
	return 0;
}

智能指针：用于托管new出来的对象，让这个对象自动释放内存,就是这个对象有着智能指针的作用。

#include
using namespace std;
class Person
{
	int id;
public:
	Person(int x)
	{
		id=x;
	}
	~Person(){cout<<"析构了"<<endl;}
	void getID()
	{
		cout<<id<<endl;
	}
};
class smartPointer
{
	Person *p;//用于托管的指针
public：
	smartPointer(Person *x)
	{
		p=x;
	}	
	~smartPointer()
	{
		if(p!=NULL)
		{
			delete p;
			p=NULL;
		}
	}
	//重载->
	Person *operator->()
	{
		return this->p;
	}
	//重载*
	Person& operator*()
	{
		return *this->p;
	}
};
void text()
{
	//智能指针像指针一样去使用，即SP->,以及（*SP)解引用
	smartPointer sp(new Person(100));
	sp->getId();
	(*sp).getId();
} 
int main()
{
	text();
	system("pause");
	return 0;
}

本节内容之所以会有，原因是因为对象和对象之间不能直接像变量一样进行运算
因此，需要将运算符进行重载，将运算符的内容重新设计一下，从而能达到对象应用不出错的程度。