1.构造函数
构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个成员函数都初始值，并且在对象的整个生命周期内只调用一次。
特性
构造函数是特殊的成员函数，需要注意的是，构造虽然名称叫做构造，但是构造函数的主要任务并不是开空间创造对象，而是初始化对象。
key：开空间是函数栈帧的事情，调用函数开辟空间。
- 函数名必须与类名想同
- 无返回值（void也不用写）
- 对象实例化时自动调用对应的构造函数
- 构造函数可以重载
class Time { public: //无参的构造函数 Time() { cout << "None Pram" << endl; } //带参数的构造函数 Time (int hour, int minute, int second) { _hour = hour; _minute = minute; _second = second; cout << _hour << ":" << _minute << ":" << _second << endl; } private: int _hour; int _minute; int _second; }; int main() { Time t1; //调用无参的构造函数 Time t2(9, 19, 30); //调用带参的构造函数 Time t3(); //该方法调用无参构造函数会报错，该种写法是写一个返回值为Time类型函数的写法。 }
- 如果类中没有显示的定义构造函数，C++编译器会默认生成一个无参的默认构造函数，一旦用户显式定义编译器将不再自动生成。
class Time { public: 带参数的构造函数 //Time(int hour, int minute, int second) //{ // _hour = hour; // _minute = minute; // _second = second; // cout << _hour << ":" << _minute << ":" << _second << endl; //} private: int _hour; int _minute; int _second; }; int main() { //1.将显示定义的构造函数屏蔽以后，编译器会默认自动生成一个 //无参的默认构造函数，因此不会报错。 //2.如果将显示定义的构造函数展开，编译器不在生成，因为用户定义了一个。 //此时如果还这样声明变量，就会报错，要以自己定义的方式传参。 Time t1; }
编译器生成的默认构造函数对内置类型（int/char/double/指针）不做处理，对自定义类型（struct,class,union）等，会去调用它们自己的默认构造函数。（对内置类型不处理是C++的缺陷）。c++11又增加了一个特性，弥补了缺陷，即内置类型的成员变量在类中声明时可以给默认值
无参的构造函数、全缺省的构造函数和没写编译器生成的构造函数，都可以认为是默认构造函数，默认构造函数有且只能有一个。
2.析构函数
与构造函数的功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时自动调用析构函数，完成对象中资源清理工作。对象生命周期到了会自动销毁。
特性
- 析构函数名是在类名前加上字符~
- 无参数无返回值类型
- 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
- 对象在生命周期结束时，C++编译器系统自动调用析构函数
class Stack { public: Stack(int capacity=3) { _arr = (int*)malloc(sizeof(int) * capacity); if (_arr == nullptr) { printf("malloc failed"); } _capacity = capacity; _size = 0; printf("malloc success\n"); } ~Stack() { if (_arr) { free(_arr); _capacity = 0; _size = 0; } cout << "~stcak" << endl; } private: int* _arr; int _capacity; int _size; }; int main() { Stack s1; return 0; }
- 当没有显示定义析构函数时，编译器会自动默认生成析构函数，它对内置类型不作处理，对自定义类型去调用它自己的析构函数。
- 如果类中没有申请资源，可以不写析构函数，直接使用编译器默认生成的。否则会造成资源泄露。
3.拷贝构造函数
在创建对象时，可以创建一个与已存在对象一摸一样的新对象。该函数只有单个形参，该形参是本类类型对象的引用（常用const修饰）。
特性
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类型对象的引用，使用传值方法会引起无穷调用，因为每一次传值调用，传过去的值都是一次拷贝构造（传值都会临时拷贝一份给形参传过去），这样会引发无穷递归。
class Time { public: //全缺省的构造函数 Time(int hour=0, int minute=0, int second=0) { _hour = hour; _minute = minute; _second = second; cout << _hour << ":" << _minute << ":" << _second << endl; } //复制本应该有两个形参，为什么只写了一个？ //因为还隐含了一个this指针。 //使用const是防止传进来的d被修改 Time(const Time& d) { this->_hour = d._hour; _minute = d._minute; _second = d._second; } private: int _hour; int _minute; int _second; }; int main() { Time t1; Time t2(t1); //拷贝构造的语法，获得一个以t1完全一样的t2 return 0; }
问题1：为什么不用=符号完成拷贝构造呢？
虽然d2、d3都能完成拷贝构造的任务，然而d1并不直观、不明确，容易让人误以为是赋值。
问题2：指针也能完成拷贝构造的任务，为什么要用引用呢？
d4传地址有点冗余麻烦，把d1的地址赋值给d5是什么意思？显然对比d2、d4、d5，发现使用引用是最符合正常人的逻辑的。
- 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝或值拷贝
class TestCls { public: TestCls() { cout << "TestCls()" <<endl; p = new int; } TestCls(const TestCls& d) { cout << "TestCls(const TestCls& testCls)" << endl; a = d.a; //p = testCls.p; //如果是编译器默认生成的，会直接把指针的地址赋给p p = new int; *p = *(d.p); //为拷贝类的p指针分配空间，实现深度拷贝 } ~TestCls() { delete p; std::cout << "~TestCls()" << std::endl; } private: int a; int* p; }; int main() { TestCls t1; TestCls t2(t1); return 0; }
上面的例子也可以看出，像内置函数类型（简单的赋值操作），一般默认是深拷贝，但是涉及到指针的问题，涉及到自定义类的问题，我们在写构造函数时，一定要注意深浅拷贝的问题。
class Time { public: Time() { _hour = 1; _minute = 1; _second = 1; } Time(const Time& t) { _hour = t._hour; _minute = t._minute; _second = t._second; cout << "Time::Time(const Time&)" << endl; } private: int _hour; int _minute; int _second; }; class Date { private: // 基本类型(内置类型) int _year = 1970; int _month = 1; int _day = 1; // 自定义类型 Time _t; }; int main() { Date d1; return 0; }
注意这段代码，d1的成员变量和_t的成员变量内存中是挨着的。
- 类中如果没有涉及到资源申请时，拷贝构造函数写不写都可以；一旦涉及到资源申请时，必须写拷贝构造函数，否则就是浅拷贝（只赋给指针）
- 拷贝构造典型场景
使用已存在对象创建新对象；函数参数类型为类类型对象；函数返回值为类类型对象。
class Date { public: Date(int year, int minute, int day) { cout << "Date(int,int,int):" << this << endl; } Date(const Date& d) { cout << "Date(const Date& d):" << this << endl; } ~Date() { cout << "~Date():" << this << endl; } private: int _year; int _month; int _day; }; Date Test(Date d) { Date temp(d); return temp; } int main() { Date d1(2022,1,13); Test(d1); return 0; }
因此，为了提高效率，一般对象传参时，尽量使用引用类型；返回时，根据实际场景，能用引用尽量使用引用。
4.赋值重载函数
运算符重载
C++为了增强代码的可读性引入运算符重载，运算符重载是具有特殊函数名的函数。
内置类型可以直接使用运算符运算，编译器知道如何运算；自定义类型无法直接使用运算符，编译器不知道如何运算，因此需要自己实现运算符重载。
函数定义语法：
返回值类型 operator操作符（参数列表）
不能创建新的操作符，如:operator@
重载操作符必须有一个类类型参数
用作内置类型的运算符，其含义不能改变，例如：内置类型+,不能改变其含义。
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。
- .*（见的很少） ::（域作用限定符） sizeof ?:（三目运算符） .（函数调用符号）注意以上5个符号不能进行函数重载
class Date { public: //构造函数 Date(int year = 1970, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // 运算符重载 //相当于bool operator==(Date* const this, const Date& d); //注意：这里左操作数是this，右操作数是d。 bool operator==(const Date& d) { return _year == d._year && _month == d._month && _day == d._day; } private: int _year; int _month; int _day; }; int main() { Date d1(2023, 8, 3); Date d2(d1); Date d3(1, 1, 1); //相当于 //cout<<d1.operator==(&d1, d2)<<endl; cout << (d1 == d2) << endl; //结果为1 cout << (d1 == d3) << endl; //结果为0 return 0; }
赋值运算符重载
即给一个已经存在的对象赋值（已经存在），拷贝构造（给一个新对象赋值）。
- 参数类型：const T&，传递引用可以提高效率
- 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
- 检测是否自己给自己赋值
- 返回*this：保证连续赋值不出错。
// 赋值运算符重载 //参数加引用和const，传参更快，防止参数修改 //返回引用，防止拷贝构造。 Date& operator=(const Date& d) { //防止 d1 = d1; if(this != &d) { _year = d._year; _month = d._month; _day = d._day; } return *this; } //可以这样调用 d2 = d1; // d2.operator=(&d2, d1) 第一个参数是地址，第二个参数是传引用 d3 = d2 = d1;
- 赋值运算符只能重载成类的成员函数，不能重载成全局函数
因为赋值运算符重载如果用户不显示的定义在类里面，编译器就在类里面自动生成一个。此时如果再在全局声明一个，就和类里面的冲突了。
- 用户没有显示的实现时，编译器会默认生成一个默认赋值运算符重载，以值的方式逐字节拷贝。内置类型成员变量直接赋值，自定义类需调用自己实现的。
const成员函数
使用const修饰的成员函数
取地址运算符重载
//写在类里面 //取地址运算符重载 Date* operator&() { return this; } //通过这样设置可以保证，类外面的成员只能访问地址，不能修改地址。 const Date* operator&()const { return this; }
正常情况下，如果我们不写这个成员函数，编译器会自动生成。所以一般不需要我们自己去写。
那我们什么时候应该写这个成员函数呢？
比如当你不想让别人取到这个类型对象的地址的时候，你可以return nullptr ，这样就永远无法获得这个对象的地址了。
