学习目标:
学习内容:
运算符重载:对已有的运算符重新进行定义,赋予其另外一种能力,用来适应不同的数据类型。编辑器提供通用名operator
来完成运算符的重载,
1. 加号运算符重载
作用:实现两个自定义数据类型相加的运算。有两种方式来重载:
- 成员函数重载+号
- 全局函数重载+号
1.1 成员函数重载+号
描述:
实现两个类中相同属性的相加
//1.成员函数重载+号
#include<iostream>
#include<string>
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;
};
void test1()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3 = p1 + p2;
//Person p3 = p1.operator+(p2); //本质上调用!!!!!!!
cout << "p3.m_A: " << p3.m_A << endl;
cout << "p3.m_B: " << p3.m_B << endl;
}
int main()
{
test1();
system("pause");
return 0;
}
1.2 全局函数重载+号
//1.全局函数重载+号
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
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 test()
{
person p1;
p1.m_a = 10;
p1.m_b = 20;
person p2;
p2.m_a = 10;
p2.m_b = 20;
person p3;
p3 = operator+(p1, p2);
//p3 = p1 + p2;
cout << "p3.m_a = " << p3.m_a << endl;
cout << "p3.m_b = " << p3.m_b << endl;
}
int main()
{
test();
system("pause");
return 0;
}
1.3 函数发生重载
描述:
实现成员属性与整型相加
//函数也可以发生重载
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
int m_a;
};
person operator+(person& p1, int num)
{
person temp;
temp.m_a = p1.m_a + num;
return temp;
}
void test()
{
person p1;
p1.m_a = 10;
person p = p1 + 90;
cout << "p.m_a = " << p.m_a << endl;
}
int main()
{
test();
system("pause");
return 0;
}
2. 左移运算符重载
直接输入对象,就可以输出对象的属性;
//左移运算符
#include<iostream>
using namespace std;
class Person
{
public:
int m_A = 15;
int m_B = 30;
};
ostream& operator<<(ostream& cout, Person& p)
{
cout << "m_A = " << p.m_A << ", m_B = " << p.m_B << endl;
return cout;
}
void test()
{
Person p;
//cout << p << endl;
operator<<(cout, p);
}
int main()
{
test();
system("pause");
return 0;
}
3. 赋值运算符重载
C++编译器至少给一个类添加4个函数:
- 默认构造函数(无参,函数体为空);
- 默认析构函数(无参,函数体为空);
- 默认拷贝构造函数,对属性进行值拷贝;
- 赋值运算符operator=,对属性进行值拷贝;
当类中有属性指向堆区,做赋值操作时会出现深浅拷贝问题
//赋值运算符重载
#include<iostream>
#include<string>
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)
{
//编译器默认提供的是浅拷贝
//应该先判断是否有属性在堆区,如果有就先释放干净,然后在深拷贝
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//深拷贝
m_Age = new int(*p.m_Age);
//返回对象本身
return *this;
}
int *m_Age;
};
void test()
{
Person p1(18);
Person p2(20);
p2 = p1;//赋值操作
cout << "p1的年龄为:" << *p1.m_Age << endl;
cout << "p2的年龄为:" << *p2.m_Age << endl;
}
int main()
{
test();
system("pause");
return 0;
}
4. 关系运算符重载
作用:重载关系运算符,可以让两个自定义类型数据进行对比操作。
//关系运算符重载
#include<iostream>
using namespace std;
class Person
{
public:
Person(int age)
{
this->m_Age = age;
}
bool operator==(Person& p)
{
if (this->m_Age == p.m_Age)
{
return true;
}
else
{
return false;
}
}
int m_Age;
};
void test()
{
Person p1(10);
Person p2(10);
if (p1 == p2)
{
cout << "二者相等!!!!!" << endl;
}
else
{
cout << "二者不相等!!!!" << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}
5. 函数调用运算符重载
函数调用运算符()也可发生重载;
由于重载之后使用的方式和函数调用非常相似,因此称为仿函数(在stl中比较常见)。仿函数形式灵活。
//函数调用运算符重载
#include<iostream>
#include<string>
using namespace std;
//打印输出类
class MyPrint
{
public:
//重载函数调用运算符
void operator()(string test)
{
cout << test << endl;
}
};
void test()
{
MyPrint myprint;
myprint("hello world!");
}
int main()
{
test();
system("pause");
return 0;
}