Bootstrap

C++ >> 封装 >> 运算符重载

时间:2019年8月22日21:24:39
编译器:vs2017

1.加号运算符重载
2. 递增运算符重载
3. 左移运算符重载
4. 赋值运算符重载
5. 关系运算符重载
6. 函数调用运算符重载

加号运算符重载

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

//运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型

// 加号运算符重载

class Person
{
public:

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


	int m_A;
	int m_B;
};

// 2、全局函数重载+号
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;
}

// 函数重载版本
Person operator+(Person &p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}



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

	Person p2;
	p2.m_A = 20;
	p2.m_B = 20;

	Person p3;
	p3 = p1 + p2;       //开始的报错是因为编译器不知道这种运算规则 
	// 1、成员函数重载本质调用:Person p3 = p1.operator + (p2);

	// 2、全局函数的调用本质:Person p3 = operator+(p1, p2);

	Person p4 = p1 + 100;		//Person + int



	cout << " p3.m_A = " << p3.m_A << endl;
	cout << " p3.m_B = " << p3.m_B << endl;

	cout << " p4.m_A = " << p4.m_A << endl;
	cout << " p4.m_B = " << p4.m_B << endl;
}


int main()
{
	test01();

	system("pause");
	return 0;
}

递增运算符重载

#include <iostream>
using namespace std;

// 重载递增运算符


//自定义类型
class MyInteger
{
	friend ostream & operator<<(ostream& cout, MyInteger myint);
public:

	MyInteger()
	{
		m_Num = 0;
	}

	// 重载前置++运算符
	MyInteger& operator++()   //前置递增返回引用
	{
		// 先进行++运算符
		m_Num++;
		// 再将自身做返回
		return  *this;
	}


	// 重载后置++运算符
	//void operator++(int)  int 代表占位参数, 可以用于区分前置和后置递增
	MyInteger operator++(int)     //后置递增返回值
	{
		// 先 记录当时的结果
		MyInteger temp = *this;
		
		// 后递增
		m_Num++;
		
		//最后将记录结果做返回
		return temp;
	}


private:
	int m_Num;
};

// 重载 << 运算符
ostream & operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

void test01()
{
	MyInteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}

int main()
{
	test01();
	test02();

	system(" pause ");
	return 0;
}

左移运算符重载

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

// 左移运算符重载

class Person
{
public:

	//利用成员函数重载   左移运算符  p.operator<<(cout) 简化版 p << cout
	//不会利用成员函数重载<<运算符, 因为无法实现 cout在左侧
	//void operator<<( cout )
	//{
	//	
	//}


	int m_A;
	int m_B;
};

//只能利用全局函数重载左移运算符
ostream &operator<<(ostream &cout, Person &p)     //本质  operator<< (cout, p)  简化 cout << p
{
	cout << " m_A = " << p.m_A << " m_B =  " << p.m_B;
	return cout;
}
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p << " 里昂 " << endl;
}


int main()
{
	
	test01();

	system("pause");
	return 0;
}

赋值运算符重载

#include <iostream>
using namespace std;
/*
	1. 默认构造函数(无参,函数体为空)
	2. 默认析构函数(无参,函数体为空)
	3. 默认拷贝构造函数,对属性进行值拷贝
	4. 赋值运算符 operator=, 对属性进行值拷贝
*/

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 = p2 = p1;  //赋值操作

	p1 = p2;    //赋值操作

	cout << " p1 = " << *p1.m_Age << endl;
	cout << " p2 = " << *p2.m_Age << endl;

	cout << " p3 = " << *p3.m_Age << endl;
}

int main()
{
	//test01();

	system("pause");
	return 0;
}

关系运算符重载

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

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;
	}

private:
	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1(" 里昂 ", 22);
	Person p2(" 花生 ", 22);
	
	if (p1 == p2)
	{
		cout << " p1 和 p2  是相等的!" << endl;
	}
	else
		cout << " p1 和 p2  是不相等的!" << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

函数调用运算符重载

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

/*
   * 函数调用运算符 () 也可以重载
   * 由于重载后使用的方式非常像函数的调用,因此称为仿函数
   * 仿函数没有固定写法,非常灵活
*/

class MyPrint
{
public:


   // 重载函数调用运算符
   void operator()(string test)
   {
   	cout << test << endl;
   }


};

void MyPrint02(string test)
{
   cout << test << endl;
}

void test01()
{
   MyPrint myPrint;
   
   myPrint(" leno ");       // 由于使用起来非常类似于函数调用, 因此称为仿函数

   MyPrint02(" peanute ");    //函数调用
}

// 仿函数没有固定写法,非常灵活
// 加法类

class MyAdd
{
public:

   int operator()(int num1, int num2)
   {
   	return num1 + num2;
   }
};

void test02()
{
   MyAdd add;
   add(1, 2);
   cout << add(1, 2) << endl;

   //匿名函数对象
   cout << MyAdd()(1, 2) << endl;
}


int main()
{
   test02();

   system("pause");
   return 0;
}

;