运算符重载

Ines ·

更新时间:2024-11-14

· 873 次阅读

加法运算符重载+
乘法运算符与其相似这里就不举例子了
加法运算符的例子：

#include
using namespace std;
class A{
  public:
  A operator+(A &p)
  {
  	 A t;
	 t.a=this->a+p.a;
	 return t;
   } 
   	int a;
}; 
int main()
{
	A a;
	A b;
	A c;
	a.a=1;
	b.a=2;
	c=a+b;
	cout<<c.a<<endl;
	return  0;
}

接下来重载左移运算符<<
假如一个类的对象p,想要用cout<<p,直接把p中的所有数据输出出来。
如果乘法运算符和加法一样是类成员函数的做法只能是p<<cout;
例子如下：

#include
using namespace std;
class A{
	public:
	ostream& operator<<(ostream &cout)
	{
		cout<a<<endl<b<<endl;
		return cout;
	}
	int a;
	int b;
};
int main()
{
	A p;
	p.a=12;
	p.b=23;
     p<<cout<<p.a;
}

cout的类型是ostream，由于全局只能有一个cout,所以不管是传参还是返回cout都要用引用；
所以如果想要用cout<<p;
那么就只能用全局函数，例子如下

‘#include
using namespace std;
class person{
 friend	ostream& operator<<(ostream &cout,person p);//不是友元函数不能访问私有成员；
	public:
	person(int a1,int b1)
	{
		a=a1;
		b=b1;
	} 
	private:
	int a;
	int b;
}; 
ostream& operator<<(ostream &cout,person p)
{
	cout<<p.a<<endl<<p.b<<endl;
	return cout;
}
int main()
{
	person p(12,55);
	cout<<p<<endl;
	return 0;
}

接下来是++运算符重载

++运算符的目的是当某一个对象如对象p,使用++p或者p++时对象里边的数据成员都会+1；
举个例子++p：
#include
using namespace std;
class person
{
	public: 
	person()
	{
		this->a=0; 
	} 
	int& operator++()//想要对里边的值进行操作必须用引用，要不然它会创建一个临时的对象进行返回，返回的不是你所自加的那个数
	{
		++a; 
		return a;
	}
	private:
	int a;
};
int main()
{
	person p;
	cout<<++p;
	return 0;
}

当然后置++

#include
using namespace std;
class person
{	
 friend ostream& operator<a=0; 
	} 
	person& operator++(int)//加上int可区分++是前置还是后置
	{
		a++; 
		return *this;//返回自身；
	}
	private:
	int a;
};
ostream& operator<<(ostream& cout,person p)
{
	cout<<p.a<<endl; 
}
int main()
{
	person p;
	cout<<p++<<endl;
	return 0;
}

接下来是=运算符重载

#include
using namespace std;
class person{
	public:
	person(int age1)
	{
		age=new int(age1);//堆区开辟空间
	}
	person& operator=(person &p)//这里都要引用，都要对已存在的对象进行操作；
	{
		if(age!=NULL)//是赋值运算符,那么自己的age就不用了，手动释放
		{
			delete age;
			age=NULL;
		}
		age=new int(*p.age);//这里存在和浅拷贝一样的问题，就是当调用析构函数时释放两遍相同的内存，所以要重新为自己在堆区开辟空间
		return *this;//返回自身的对象才能进行连等
	 }
	 ~person()//析构处理在堆区开辟的空间；
	 {
	 	if(age!=NULL)
	 	{
	 		delete age;
	 		age=NULL;
		}
	  } 
	  int *age;//将在堆区开辟空间给age赋值；
};
void text()
{
	person p1(188);
	person p2(20);
	person p3(30);
	p2=p3=p1;
	cout<<*p1.age<<endl<<*p2.age<<endl;
}
int main()
{
	text();
	return 0;

当对象有在堆区开辟的数据，对象直接相等的话那么会带来和浅拷贝一样的问题，所以需要用等于运算符重载，在其中释放掉自己在堆区开辟的数据，再在堆区开辟一块新的内存接收另外一个对象给自己的数据；
关系运算符

#include
#include
using namespace std;
class person{
	public:
	person(string name1,int a1)
   {
   	a=a1;
   	name=name1;
   }
  bool operator==(person& p)//注意时布尔类型；
  {
  	if((this->a==p.a)&&(this->name==p.name))
  	 return true;
  	 else
  	 return false;
  }
	string name;
	int a;
};
int main()
{
	person p1("111",12);
	person  p2("111",12) ;
	if(p1==p2)
	{
		cout<<"他俩相等"<<endl; 
	}
	else
	cout<<"他俩不等"<<endl;
	return 0; 
}

函数运算符重载（其实就是小括号重载)

	#include
	#include
	using namespace std;
	class person{
		public:
		operator()(string name)
		{
			cout<<name<<endl;
		}
	};
	void text()
	{
		person p;
		p("231");
	 } 
	 void text1()
	{
		person()("231412");//这个是匿名函数对象
	}
	 int main()
	 {
	 	text();
	 	text1();
	 	return 0;
	 }

由于他的调用和函数类似，所以又被称为仿函数；

作者：陌路逢君唯图一笑

重载运算符运算符重载

1024 个赞