友元 + 运算符重载
纯粹记录敲代码的过程，1.5倍速，后续遇到bug会回来检索
目录
友元
全局函数做友元
类做友元
成员函数做友元
运算符重载
加号运算符重载
左移运算符重载
递增运算符重载
赋值运算符重载
关系运算符重载
函数调用运算符重载
总结
友元
全局函数做友元
客厅(Public), 卧室(private), 陌生人只能进客厅，但是闺蜜(友元)可以进卧室
私有属性为了让类外的函数或类访问，需要用到友元
友元关键字：friend
三种实现：
1，全局函数
2，类
3，成员函数
注意这行
//goodGay全局函数是Building的好朋友, 可以访问Building中私有成员(卧室)
friend void goodGay(Building *building);#include
using namespace std;
//建筑物类
class Building
{
//goodGay全局函数是Building的好朋友, 可以访问Building中私有成员(卧室)
friend void goodGay(Building *building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
public: //公共字符串属性
string m_SittingRoom; //客厅
private: //私有字符串属性
string m_BedRoom; //卧室
};
//全局函数
void goodGay(Building *building)
{ //访问公共属性m_SittingRoom
cout<<"好基友 全局 正在访问: "<m_SittingRoom<m_BedRoom< 好基友 全局 正在访问: 客厅
好基友 全局 正在访问: 卧室
请按任意键继续. . .类做友元
注意这行
//GoodGay类是本类的好朋友, 可以访问类中私有成员
friend class GoodGay;#include
using namespace std;
//类做友元
class Building;
class GoodGay
{
public:
GoodGay();
void visit(); //参观函数 访问Building中属性
Building *building; //内部维护一个指针
};
class Building
{
//GoodGay类是本类的好朋友, 可以访问类中私有成员
friend class GoodGay;
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
//类外写成员函数
Building::Building() //Building作用域下成员函数
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
//创建一个建筑物对象
building = new Building; //new在堆区创建一个对象, building指针指向这个对象
}
void GoodGay::visit()
{
cout<<"好基友 访问: "<m_SittingRoom<m_BedRoom< 好基友 访问: 客厅
好基友 访问: 卧室
请按任意键继续. . .成员函数做友元
看这行
//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友
friend void GoodGay::visit();#include
using namespace std;
class Building;
class GoodGay
{
public:
GoodGay();
void visit(); //visit函数访问Building中私有成员
void visit2(); //visit2不可访问Building中私有
Building *building;
};
class Building
{
//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友
friend void GoodGay::visit();
public:
Building(); //构造函数声明
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
//类外实现成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
building = new Building; //在堆区创建一个Building对象, 并用building指针维护
}
void GoodGay::visit()
{
cout<<"visit 函数 访问 "<m_SittingRoom<m_BedRoom<m_SittingRoom<m_BedRoom< visit 函数 访问 客厅
visit 函数 访问 卧室
visit2 函数 访问 客厅
请按任意键继续. . .运算符重载
运算符重载：
重新定义已有的运算符，赋予新的功能，以适应不同数据类型
加号运算符重载
加号：
实现两个自定义数据类型的相加运算
#include
using namespace std;
//加号运算符重载
class Person
{
public:
int m_A;
int m_B;
// //1，成员函数重载+号
// 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;
// }
};
//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;
} //全局函数重载 放在test01()之前
//函数重载的版本
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 = 30, p1.m_B = 10;
Person p2;
p2.m_A = 5, p2.m_B = 10;
//成员 函数重载的本质 调用
//Person p3 = p1.operator+(p2);
//全局 函数重载的本质 调用
//Person p3 = operator+(p1, p2);
Person p3 = p1 + p2;
//运算符重载 也可以发生函数重载(复用函数名)
Person p4 = p1 + 100;
cout<<"p3.m_A = "< p3.m_A = 35
p3.m_B = 20
p4.m_A = 130
p4.m_B = 110
请按任意键继续. . .总结1：内置的数据类型(int, double, float...)的表达式运算符，不可更改
总结2：不要滥用运算符重载(比如写了operator+，但是函数里是-)
左移运算符重载
重载左移运算符配合友元，可输出自定义数据类型
#include
using namespace std;
//左移运算符重载
class Person
{
//使全局函数作为Person类的好朋友, 可以访问Person类私有数据
friend ostream & operator<<(ostream &cout, Person &p);
public:
Person(int a, int b)
{
m_A = a, m_B = b;
}
private:
//利用成员函数重载 左移运算符
//p.operator<<(cout) 简化版本 p< m_A = 10 m_B = 7
hello world
请按任意键继续. . .递增运算符重载
通过重载递增运算符，实现自己的整型数据
#include
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< 0
1
请按任意键继续. . .上面写了前置和后置++，视频里要求自己重头写一遍--，来加深印象，下面是自己写的--
#include
using namespace std;
class MyInteger
{
//全局函数做友元, 访问MyInteger类私有数据
friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
MyInteger()
{
m_Num = 0;
}
//重载前置-- 返回引用
MyInteger& operator--()
{
//先--
m_Num--;
//再返回自身
return *this; //解引用
}
//重载后置-- 返回值
MyInteger operator--(int) //int代表占位参数 表示后置
{
//先 记录当时结果
MyInteger temp = *this;
//再 递减
m_Num--;
//最后 将记录结果返回
return temp;
}
private:
int m_Num;
};
//重载左移运算符
//operator<<(cout, myint)本质是 cout< 赋值运算符重载
C++编译器给一个类添加4个函数
1，默认（无参，函数体空）
2，析构（无参，函数体空）
3，拷贝（对属性值拷贝）
4，赋值运算符 operator=，对属性值拷贝如果类中属性指向堆区，做赋值操作就会出现深浅拷贝问题
关于代码第36行的GPT解释
//深拷贝操作
m_Age = new int(*p.m_Age);在 C++ 中，赋值运算符
=的默认实现是浅拷贝。对于类中含有指针成员的情况，这就会产生问题。浅拷贝只是简单地将指针从源对象复制到目标对象，使得两个对象的指针成员指向同一块内存地址，也就是说，如果堆区中的数据被释放了，两个对象的数据都被释放了，就会产生异常。因此，在定义类中含有指针成员的情况下，需要通过重载赋值运算符
=实现深拷贝，即为目标对象开辟新的内存地址，把源对象中的数据拷贝进去。具体来讲，你所提供的代码中，在重载的赋值运算符函数
operator=中，首先判断m_Age指针是否为空，如果不为空，则释放该段内存，再通过new int重新开辟内存，将源对象的年龄数据拷贝到新的内存中，从而实现了深拷贝操作。总之，深拷贝会分配一个新的内存块，并将源对象的信息复制到新的内存块中，两个对象之间没有任何关系。相反，浅拷贝只是复制指针，它们指向相同的内存块，而不是两块不同的内存。这就是为什么在类中含有指针成员时，需要明确指定拷贝构造函数和赋值运算符的实现方式，来避免指针之间的未知行为
#include
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) //传Person对象进来
{
//编译器提供浅拷贝
//m_Age = p.m_Age;
//先判断是否有属性在堆区 有的话先释放干净 再深拷贝
if(m_Age != NULL) {
delete m_Age;
m_Age = NULL;
}
//深拷贝操作
m_Age = new int(*p.m_Age);
//返回对象本身
return *this; //返回对象本题, *解引用, this是指针
//返回自身, 实现连等的操作
}
int *m_Age; //m_Age指针去维护堆区数据
};
test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1;
p2 = p1; //赋值操作
cout<<"p1年龄: "<<*p1.m_Age< 关系运算符重载
关系运算符重载：让两个自定义类型对象进行对比操作
#include
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;
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;
};
test01()
{
Person p1("Jerry", 18);
Person p2("Jerry", 18);
if(p1 == p2)
cout<<"p1 == p2"< p1 == p2
p1 == p2
请按任意键继续. . .函数调用运算符重载
函数调用运算符()也可以重载
由于重载后使用方式非常像函数的调用，称为仿函数
仿函数没有固定写法，非常灵活
仿函数就是重载了函数调用运算符()的类
代码中MyPrint和MyAdd分别是打印输出类和加法类的仿函数，它们重载了函数调用运算符()，并可以像函数一样调用
#include
using namespace std;
//函数调用运算符重载
//打印输出类
class MyPrint
{
public:
//重载函数调用运算符
void operator()(string test) //第一个()表示重载的运算符, 第二个()是形参列表
{
cout< ret = 220
230
请按任意键继续. . .总结
跟着敲一遍，不懂就百度 + gpt，确实增加了对C++的理解，同时自己补充大量注释，辅助理解，，，每天2个视频，坚持3个月，就能看完了，真的好难