C++---类和对象(二)
一、类的默认成员函数
1、概念
默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数
2、问题
①我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
②编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？
二、构造函数
1、基本特点
①函数名与类名相同。
②⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
③对象实例化时系统会⾃动调⽤对应的构造函数。
④构造函数可以重载。
#include<iostream>
using namespace std;
class Data
{
public://无参构造函数Data(){_year = 1;_month = 1;_day = 1;}//带参构造函数Data(int year, int month, int day){_year = year;_month = month;_day = day;}//全缺省构造函数Data(int year = 2, int month = 2, int day = 2){_year = year;_month = month;_day = day;}void Print(){cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;};int main()
{Data d1;d1.Print();Data d2(2025, 4, 20);d2.Print();Data d3(2024);d3.Print();
}注意：全缺省构造函数最好不要和其他构造函数一起使用，容易出错
2、进阶特点
①如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成
②默认构造：不传实参就可以调用的构造。⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数，这三个相互之间不能同时存在
③我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决
3、总结
构造函数大多是情况需要我们手动实现，少数情况下自动实现
三、析构函数
1、概念
析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的
2、特点
①析构函数名是在类名前加上字符~。
②⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)
③ ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
④ 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
⑤ 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。
⑥ 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数
⑦如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如 果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。
⑧ ⼀个局部域的多个对象，C++规定后定义的先析构。
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:Stack(int n = 4){_a = (STDataType*)malloc(sizeof(STDataType) * n);if (nullptr == _a){perror("malloc申请空间失败");return;}_capacity = n;_top = 0;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}
private:STDataType* _a;size_t _capacity;size_t _top;
};
// 两个Stack实现队列class MyQueue
{
public://编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源// 显⽰写析构，也会⾃动调⽤Stack的析构/*~MyQueue(){}*/
private:Stack pushst;Stack popst;
};
int main()
{Stack st;MyQueue mq;return 0;
}四、拷贝构造函数
1、定义
如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数 也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数
2、拷贝构造函数的特点
①拷贝构造函数是构造函数的重载，也就是拷贝构造函数与构造函数同名，就是类名
②拷贝构造函数的第一个参数必须是类类型对象的引用，后边的参数必须有缺省值
③c++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成
④不写拷贝构造，编译器会自动生成，自动生成的拷贝构造队内置类型会完成值拷贝(浅拷贝)，对自定义类型成员调用他的拷贝构造
⑤像Data类这样的没有申请资源，编译器会自己生成拷贝构造；像Stack这样的类，需要手动申请空间，编译器拷贝会将地址一起拷贝过去，销毁时就销毁两次从而出现错误，这时就需要手动写深拷贝
class Stack
{
public:Stack(int n = 4){//手动申请空间_a = (int*)malloc(sizeof(int) * n);if (nullptr == _a){perror("malloc fail");return;}_top = 0;_capacity = n;}
private:int* _a;int _top;int _capacity;
};
int main()
{Stack s1(10);//拷贝构造Stack s2 = s1;return 0;
}s1和s2指向同一块空间，析构会析构两次，所以需要我们手动进行深拷贝
深拷贝
//d是s1，也就是被拷贝对象
Stack(const Stack& d)
{_a = (int*)malloc(sizeof(int) * d._capacity);{if (nullptr == _a){perror("malloc fail");return;}}memcpy(_a, d._a, sizeof(int) * d._top);_top = d._top;_capacity = d._capacity;
}
int main()
{Data d1;Data d2 = d1;步骤：先为d2开空间，然后将d1中的数据memcpy到d2，其他数据分别相等
⑥函数返回局部变量不能使用引用返回
3、基本用法实现
class Data
{
public:Data(int year = 2, int month = 2, int day = 2){_year = year;_month = month;_day = day;}//不写也行Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;
};int main()
{Data d1(2025, 4, 22);d1.Print();//Data d2(d1);Data d2 = d1;d2.Print();
}五、赋值运算符重载
1、运算符重载
①基本概念
运算符重载的本质是函数重载，它通过定义一个特殊的成员函数或友元函数来实现。重载的运算符函数名由关键字 operator 后接要重载的运算符符号组成。
②作用：使自定义类型(如Data类)可以像内置类型一样进行比较、加减等运算
③重载运算符函数的参数个数与改运算符作用的运算对象一样多
④如果⼀个重载运算符函数是成员函数(在类里边)，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。
⑤不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。
⑥ .* :: sizeof ?: . 这五个运算符不能重载
⑦前置++和后置++重载区别：后置++形参多个int，只是为了区分
前置
Data operator++()
{++count;return *this;
}
后置
Data operator++(int)
{count++;return *this;
}基本代码实现
运算符重载
class Data
{
public:Data(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "/" << _month << "/" << _day << endl;}bool operator==(const Data& d2){return _year == d2._year&& _month == d2._month&& _day == d2._day;}int GetMonthDay(int year,int month){int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,31,31};if (month == 2 && year % 4 == 0 && year % 100 != 0 || year % 400 == 0){return 29;}return arr[month];}void operator+=(int x){_day += x;while (_day > GetMonthDay(_year, _month)){_day -= GetMonthDay(_year, _month);_month++;if (_month == 13){_year++;_month = 1;}}}
private:int _year;int _month;int _day;
};
int main()
{//Data d1(2025, 4, 22);//d1.Print();//Data d2(2025, 4, 22);//d1.Print();//if (d1 == d2)// printf("hehe");//else// printf("zhzha");Data d3(2025, 4, 22);d3.Print();d3 += 100;d3.Print();
}2、赋值运算符重载
①概念：赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟 拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。
②有返回值，建议使用引用返回提高效率
③不写的时候编译器会自动生成一个默认赋值运算符重载，和拷贝构造函数类似，对内置 成员完成值拷贝(浅拷贝)，对自定义类型成员变量调用他的赋值重载函数
④开了空间的就需要写，不开不用谢
⑤基本用法代码展示
class Data
{
public:Data(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//拷贝构造Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}//赋值运算符重载//传引用减少拷贝//d1 = d2 这里的d是d2Data& operator=(const Data& d){//if (this != &d){_year = d._year;_month = d._month;_day = d._day;}//返回d1return *this;}void Print(){cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Data d1(2025, 4, 22);//拷贝构造Data d2(d1);Data d3(2024, 4, 22);d1 = d3;//赋值重载，因为d1和d2都已经存在Data d4 = d1;//拷贝构造
}六、取地址运算符重载
1、const成员函数
①将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后 ⾯。
②•const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。 const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为const Date* const this
③代码示例
class Date
{
public://构造函数Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//函数后加const，this指针由Date* const this 变成 const Date* const thisvoid Print() const{cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;
};④注意：像日期类中的运算符重载(operator+=)这种需要改变this指针的值的不能使用const成员函数
2、取地址运算符重载
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动 ⽣成的就可以够我们⽤了，不需要去显⽰实现。除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址。
class Date
{
public:Date* operator&(){return this;//return nullptr(随便返回一个地址)}const Date* operator&() const{return this;//return nullptr(随便返回一个地址)}
};