运算符重载

运算符重载：

运算符重载的概念：对已有的运算符重新定义赋予其另一种功能，以适应不同的数据类型。

1.加号运算符重载

作用：实现两个自定义数据类型相加的运算。

注意：运算符重载也可以发生函数重载（只需要改变参数类型）

对于内置的数据类型的表达式的运算符是不可能改变的。

#include<iostream>
using namespace std;

class Person
{
public:

 Person operator+(Person& p)//成员函数重载+运算符
 {
  Person temp;
  temp.m_A = this->m_A + p.m_A;
  temp.m_B = this->m_B + p.m_B;
  return temp;
 }

 int m_A;
 int m_B;
};
Person operator+(Person& p1, Person& p2)//全局函数重载+运算符
{
 Person temp;
 temp.m_A = p1.m_A + p2.m_A;
 temp.m_B = p1.m_B + p2.m_B;
 return temp;
}
void test01()
{
 Person p1;
 p1.m_A = 10;
 p1.m_B = 10;
 Person p2;
 p2.m_A = 10;
 p2.m_B = 10;

 Person p3 = p1 + p2;
 cout << "p3.m_A=: " << p3.m_A << endl;
 cout << "p3.m_B=: " << p3.m_B << endl;
}

int main()
{
 test01();
}

2.左移运算符重载

作用：可输出自定义数据类型

#include<iostream>
using namespace std;

//左移运算符重载技术
class Person
{
//friend ostream& operator<<(ostream&cout,Person p);
public:

	//利用成员函数重载 左移运算符
	//void operator<<(cout)即p<<cout，所以我们不会用成员函数重载<<运算符，无法实现cout在左侧
	int m_A;
	int m_B;

};

//只能用全局函数重载左移运算符
ostream& operator<<(ostream&cout,Person p)//本质cout<<p;//且cout可换成其他的
{
	cout << "m_A=" << p.m_A << " m_B=" << p.m_B << endl;

}
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;

	cout << p << endl;
}

int main()
{
	test01();

	return 0;
}

3.递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

#include<iostream>
using namespace std;

//重载递增运算符
//自定义整型
class MyIntger
{
	friend ostream operator<<(ostream& cout, MyIntger myint);
public:
	MyIntger()
	{
		m_Num = 0;
	}
	//重载前置++运算符   返回引用是为了一直对一个数据进行递增操作
	 MyIntger&operator++()
	{
		 m_Num++;//先做++运算
		 return *this;//再将自身做返回
	}
	//重载后置++运算符
	 //int代表的是占位参数，可用于区分前置和后置递增
	 MyIntger operator++(int)
	 {

		 //先 记录当时结果
		 MyIntger temp = *this;
		 //后 递增
		 m_Num++;
		 //最后将记录结果做返回
		 return temp;
	 }

private:
	int m_Num;
};

//重载左移运算符
ostream operator<<(ostream& cout, MyIntger myint)
{
	cout << myint.m_Num;
	cout << myint << endl;
}

void test01()
{
	MyIntger myint;
	cout << ++(++myint) << endl;//2
	cout << ++myint << endl;//1  如果是返回值，这里的输出结果是2
}


void test02()
{
	MyIntger myint;
	cout << myint++ << endl;//输出0
	cout << myint << endl;//输出1
}
int main()
{
	test01();
    test02();

	return 0;
}

总结：前置递增返回引用，后置递增返回值

4.赋值运算符重载

C++编译器至少给一个类添加4个函数

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性进行值拷贝

4.赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

#include<iostream>
using namespace std;

//赋值运算符重载
class Person
{

public:
	Person(int age)
	{
		m_Age = new int(age);//将数据创建在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//重载 赋值运算符
	Person& operator=(Person& p)
	{
		//编译器是提供浅拷贝
		//m_Age=p.m_Age;

		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		return *this;
	}
	int* m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);
	p3=p2 = p1;//赋值操作

	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main()
{
	test01();
	return 0;
}

5.关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

#include<iostream>
#include<string>
using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}

	 bool operator==(Person& p)
	{
		 if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		 {
			 return true;
		 }
		 else return false;
	}
	 /*bool operator!=(person& p)
	 {
		 if (this->m_name == p.m_name && this->m_age == p.m_age)
		 {
			 return false;
		 }
		 else return true;
	 }*/
	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2)
	{
		cout << "p1和p2是相等的！" << endl;
	}
	else
	{
		cout << "p1和p2不相等！" << endl;
	}
}

int main()
{
	test01();
	return 0;
}

6.函数调用运算符重载

• 函数调用运算符（）也可以重载
• 由于重载之后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

  #include<iostream>
  #include<string>
  using namespace std;
  
  
  
  class MyPrint
  {
  public:
  	void operator()(string test)
  	{
  		cout << test << endl;
  	}
  
  
  };
  
  
  void MyPrint02(string test)
  {
  	cout << test << endl;
  }
  void test01()
  {
  	MyPrint myprint;
  	myprint("hello world");
  }
  
  //仿函数非常灵活，没有固定写法
  //加法类
  class MyAdd
  {
  public:
  	int operator()(int num1, int num2)
  	{
  		return num1 + num2;
  	}
  };
  
  void test02()
  {
  	MyAdd myadd;
  	int ret = myadd(100, 100);
  	cout << "ret=" << ret << endl;
  
  	//匿名函数对象  类型+（）创建匿名对象  特点：当前行执行完了，立即被释放
  	//后面的（）是在使用重载的运算符
  	cout << MyAdd()(100, 100) << endl;
  }
  int main()
  {
  	test01();
  	test02();
  	return 0;
  }