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;
}
-
对于编译器生成的默认构造函数，实际上并没有对Time类的成员变量初始化，它究竟有什么用呢？
编译器生成的默认构造函数对内置类型（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 ，这样就永远无法获得这个对象的地址了。