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