目录
一、类的默认成员函数
如果一个类中什么成员也没有，那么它就是一个空类。
但是空类中并非什么也没有，在C++中，当我们定义一个类时，编译器会自动为该类生成一些默认的成员函数，除非显式地定义或删除它们。以下是C++类的六个默认成员函数：
二、构造函数
在C++中，构造函数是一种特殊的成员函数，用于在创建对象时进行初始化操作。
例如我们在类和对象（一）中的Date类中的Date(int year = 2023, int month = 9, int day = 12);
构造函数的特性：
- 构造函数的名称必须与类名相同，没有返回类型（包括void），可以有参数，也可以没有参数。
- 构造函数在以下情况下会被自动调用：
使用对象声明时：当我们使用类定义创建对象时，构造函数会被调用。例如：ClassName obj;。
使用new运算符动态创建对象时：当我们使用new运算符来动态分配内存并创建对象时，构造函数会被调用。(在类和对象（三）中详细介绍)
作为函数参数传递对象时：当我们将对象作为参数传递给函数时，构造函数会被调用。例如：void func(ClassName obj);- 构造函数可以有多个重载版本：根据参数的不同，我们可以定义多个具有不同参数列表的构造函数。编译器会根据传递的参数来选择合适的构造函数进行调用。
- 如果没有显式定义任何构造函数，编译器会自动生成一个无参的默认构造函数。一旦用户显式定义，编译器将不再生成。
- 编译器默认生成的构造函数、用户定义的无参构造函数和全缺省构造函数都称为默认构造函数，并且默认构造函数只能有一个。（默认构造函数：不传参编译器自动调用的）
- C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在 类中声明时可以给默认值。(实际上这些值是构造函数初始化时的缺省值，类和对象三中会讲到)
class Date
{
public:
//特性1：名称必须与类名相同，没有返回类型
//特性4：显式定义构造函数，编译器将不再生成无参的默认构造函数。
//特性5：默认构造函数只有一个
Date(int year = 2023, int month = 9, int day = 12)
{
_year = year;
_month = month;
_day = day;
cout << "Date(int year, int month, int day)" << endl;
}
//特性3：构造函数可以有多个重载版本
Date(int year, int month, int day, int flag)
{
if (flag != 0)
{
_year = year;
_month = month;
_day = day;
}
else
{
_year = 0;
_month = 0;
_day = 0;
}
cout << "Date(int year, int month, int day, int flag)" << endl;
}
void Print()
{
cout << "Date: " << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
// int _year = 1949;//特性6
// int _month = 10;
// int _day = 1;
};
int main()
{
Date d1;//特性2：当我们使用类定义创建对象时，构造函数会被调用
//Date d2();//报错，编译器分不清是函数声明还是定义对象
Date d3(1, 2, 3, -1);
return 0;
}
- 如果在类中定义以下构造函数则会出错
原因：特性5，默认构造函数只能有一个，无参构造函数和全缺省构造函数都是默认构造函数- Date(){
_year = 1;
_month = 1;
_day = 1;
}
三、编译器生成的默认构造函数
在不实现构造函数的情况下，编译器会生成默认的构造函数。但是这个默认构造函数有什么用呢？
class Time
{
public:
void Print()
{
_date.Print();
cout << "Current time-> " << _hour << ":" << _minute << endl;
}
private:
Date _date;
int hour;
int minute;
};
int main()
{
Time t1;
t1.Print();
return 0;
}
在Time类中没有显示定义构造函数，声明对象t1时调用了编译器生成的默认构造函数，但是d对象_hour/_minute依旧是随机值。 这是为什么呢？
原来，C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类 型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看上面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_date调用的它的默认构造 函数，而对内置类型的成员则不做处理。
编译器生成的默认构造函数的特点：
- 特性4、5。
- 内置类型默认不处理，但是有些编译器会处理，如VS2019。
- 自定义类型的成员才会处理，回去调用这个成员的默认构造函数。
注：一般情况下需要写构造函数决定初始化方式，如果成员变量全是自定义类型，可以考虑不写构造函数，因为对象声明编译器会自动调用成员变量的构造参数。
四 、析构函数
与构造函数功能相反，析构函数用于在对象销毁时进行清理操作，例如释放动态分配的内存等。如果没有显式定义析构函数，编译器会生成一个默认的析构函数。
析构函数的特征：
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载
- 对象生命周期结束时，C++编译系统系统自动调用析构函数(例如return之后)
- 与构造函数类似，编译器生成的默认析构函数，对自定类型成员调用它的析构函数，内置类型成员不会处理。
- 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。
例如在上面的Date类中定义析构函数~Date()，Time类中定义析构函数~Time()
// Date类中
~Date()
{
cout << "~Date()" << endl;
}// Time类中
~Time()
{
cout << "~Time()" << endl;_date.~Date();
}
那么main函数的结果就是
如果没有Time类中没有定义析构函数，编译器会给Time类生成一个默认的析构函数，并且自动调用类中自定义成员_date的析构函数。
五、拷贝构造函数
拷贝构造函数也是特殊的成员函数，用于在创建对象时，使用另一个同类型对象进行初始化。
拷贝构造函数的特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。
- 如果没有显式定义拷贝构造函数，编译器会生成一个默认的拷贝构造函数。
- 编译器生成的拷贝构造函数按照字节序逐个执行成员变量的值拷贝（浅拷贝），如果有资源申请时，需要用户自己写深拷贝的拷贝构造， 使用默认生成的会出问题。
- 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象- 为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。
class Date
{
public:
//...
Date(Date& d1) //此处不能写出Date(Date d1)
{
_year = d1._year;
_month = d1._month;
_day = d1._day;
cout << "Date(Date& d1)" << endl;
}
//...
private:
int _year;
int _month;
int _day;
};这里的拷贝构造函数不用写也没事，因为Date类中成员变量全都是内置类型，编译器自动生成的拷贝构造可以满足使用。
但是如果有自定义类型的成员或涉及内存资源申请时，就需要用户自己写深拷贝的拷贝构造，例如下面的Stack类。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
if (capacity == 0)
{
_arr = nullptr;
_size = 0;
_capacity = 0;
return;
}
_arr = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
//需要自己写拷贝构造，否则_arr只是地址拷贝。
//当被拷贝的对象s1析构时，原来s1._arr地址指向的空间被释放
//现在的对象s2析构时又会对同一块地址再次释放，直接报错
Stack(const Stack& other)
{
_arr = (DataType*)malloc(other._capacity * sizeof(DataType));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
memcpy(_arr, other._arr, sizeof(DataType) * other._size);
_size = other._size;
_capacity = other._capacity;
}
void Push(const DataType& data)
{
CheckCapacity();
_arr[_size] = data;
_size++;
}
void CheckCapacity()
{
if (_size == _capacity)
{
size_t cp = _capacity == 0 ? 4 : _capacity * 2;
DataType* tmp = (DataType*)realloc(_arr, sizeof(DataType) * cp);
if (nullptr == tmp)
{
perror("realloc error!");
return;
}
if (_arr && tmp != _arr)
{
free(_arr);
}
_arr = tmp;
_capacity = cp;
}
}
~Stack()
{
if (_arr)
{
free(_arr);
_arr = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _arr;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
s1.Push(5);
Stack s2(s1);
return 0;
}六、赋值运算符重载
C++中的赋值重载运算符（Assignment Operator）用于定义对象之间的赋值操作。赋值重载运算符被定义为类的成员函数，通常使用如下的语法形式：
class MyClass
{
public:
MyClass& operator=(const MyClass& other) {
// 赋值操作的实现
// 将 other 对象的值赋给当前对象
return *this;
}
};
在上面的代码中，MyClass 是一个自定义类，operator= 是赋值重载运算符的函数名。它的参数是一个 const MyClass& 类型的引用，表示被赋值的对象。
赋值运算符重载的特性如下：
- 参数类型：const Myclass&，传递引用可以提高传参效率。如果不用const修饰参数则会报错，有时参数是经过计算形成的临时变量，而临时变量具有常性，所以参数也要具有常性。（保持权限不被放大）
- 返回值类型：Myclass&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值。
- 需要检测是否自己给自己赋值。
- 返回*this ：要复合连续赋值的含义
- 赋值运算符只能重载成类的成员函数不能重载成全局函数，因为赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，所以赋值运算符重载只能是类的成员函数。
- 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。如果涉及到内存资源分配，就需要用户显示定义赋值运算符重载。
class Stack
{
public:
//...
Stack& operator=(const Stack& other)
{
DataType* tmp = (DataType*)malloc(other._capacity * sizeof(DataType));
if (nullptr == tmp)
{
perror("malloc申请空间失败");
return;
}
if (_arr && tmp != _arr)
{
free(_arr);
}
_arr = tmp;
memcpy(_arr, other._arr, sizeof(DataType) * other._size);
_size = other._size;
_capacity = other._capacity;
return *this;
}
//...
private:
//...
};
int main()
{
Stack s1(0);
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
s1.Push(5);
Stack s2(s1);
//Stack s2 = s1;//与Stack s2(s1);效果相同，都是拷贝构造
Stack s3;
s3 = s1;//赋值运算符重载
return 0;
}注：
- 拷贝构造用于一个已实例化的对象初始化另一个正在实例化的同类型对象，
所以Stack s2 = s1;与Stack s2(s1);效果相同，s1已实例化，s2正在实例化，都是拷贝构造。- 赋值运算符重载用于一个已存在的对象被赋予另一个同类型对象的值时，这个同类型对象可以是临时变量。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
