运算符重载

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

1.加号运算符重载

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

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

总结2: 不要滥用运算符重载

using namespace std;

#include <iostream>

#include <string>

class Person {

public :

int m_A;

int m_B;

//成员函数重载 +号

/*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;

}*/

};

//全局函数重载 +号

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 test001() {

Person p1;

p1.m_A = 10;

p1.m_B = 10;

Person p2;

p2.m_A = 11;

p2.m_B = 11;

//成员函数重载本质调用

//Person p3 = pl.operator+(p2);

//全局函数重载本质调用

// Person p3 = operator+(p1，p2):

Person p3 = p1 + p2;

//运算符重载 也可以发生函数重载

Person p4 = p1 + 11;

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() {

test001();

system("pause");

return 0;

}

2.左移运算符重载

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

总结: 重载左移运算符配合友无可以实现输出自定义数据类型

class Person {

friend ostream& operator<<(ostream &cout, Person &p);

public :

Person(int a, int b) {

m_A = a;

m_B = b;

}

private:

int m_A;

int m_B;

//成员函数重载 +号

//利用成员函数重载左移运算符p.operator<<(cout) 简化版本 p<< cout

//不会利用成员函数重载 << 运算符，因为无法实现cout在左侧

//void operator<<(cout)

//{

//}

};

// 只能利用全局函数重载左移运算符

ostream& operator<<( ostream &cout,Person &p) //本质operator<< (cout ,p) 简化 cout << p

{

cout << " m_a= " << p.m_A << " m_b= " << p.m_B << endl;

return cout;

}

void test003() {

Person p1(10,10);

cout << p1 << endl;

}

int main() {

test003();

system("pause");

return 0;

}

3.递增运算符重载

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

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 test004() {

MyInteger myint;

cout << ++myint << endl;

cout << myint << endl;

}

void test006() {

MyInteger myint;

cout << myint++ << endl;

cout << myint << endl;

}

int main() {

test004();

test006();

system("pause");

return 0;

}

4.赋值运算符重载

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

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 test007() {

Person p1(18);

Person p2(20);

Person p3(20);

p3 = p2 = p1; //赋值运算

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

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

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

}

5.关系运算符重载

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

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;

}

return false;

}

//重载 !=

bool operator!=(Person &p) {

if (this->m_Name == p.m_Name&&this->m_Age == p.m_Age) {

return false;

}

return true;

}

string m_Name;

int m_Age;

};

void test008()

{

Person p1("logn", 22);

Person p2("logn", 22);

if (p1 == p2) {

cout << "p1等于p2" << endl;

}

else {

cout << "p1不等于p2" << endl;

}

}

6.函数调用运算符重载

·函数调用运算符()也可以重载

·由于重载后使用的方式非常像函数的调用，因此称为仿函数

·仿函数没有固定写法，非常灵活

class MyPrint {

public :

//重载函数调用运算符

void operator()(string test) {

cout << test << endl;

}

};

class MyAdd{

public:

//重载函数调用运算符

int operator()(int num1,int num2) {

return num1 + num2;

}

};

void test009() {

MyPrint myPrint;;//由于使用起来非常类似于函数调用，因此称为仿函数

myPrint("you are so ");

MyAdd myAdd;

int sum=myAdd(1, 3);

cout << "sum ="<<sum << endl;

//匿名函数对象

cout << MyAdd()(100,100) << endl;

}

//仿函数非常灵活，没有固定的写法