文章目录
写在前面
上一节我们知道了类和对象的基本概念，这一节我们详细说说类的6个默认成员函数。
类的6个默认成员函数
如果一个类中什么都没有，我们称之为空类。空类中真的什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。
注意：取地址重载对应的两个默认成员函数不重要，所以说接下来我们主要说上面四个默认成员函数，包括构造函数、析构函数、拷贝构造函数以及赋值重载。
构造函数
概念
对于以下的日期类：
class Date
{
public:
void SetDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Display()
{
cout << _year << " " << _month << " " << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1, d2;
d1.SetDate(2022, 8, 25);
d1.Display();
d2.SetDate(2022, 9, 3);
d2.Display();
return 0;
}
对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就直接将信息设置进去呢？
构造函数是一个特殊的成员函数，名字和类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。
特性
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名字叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
- 函数名与类名相同；
- 无返回值；
- 对象实例化时编译器自动调用对应的构造函数；
- 构造函数可以重载。
class Date
{
public:
//1.无参构造函数
Date()
{}
//2.带参构造函数(与上面的无参构造函数形成重载)
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;//调用无参构造函数
Date d2(2022, 8, 25);//调用带参的构造函数
//注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就变成了函数声明
//以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
//Date d3();这样写是错误的
return 0;
}
- 如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义，编译器将不再自动生成。
class Date
{
public:
如果用户显示定义了构造函数，编译器将不再生成
//Date(int year, int month, int day)
//{
// _year = year;
// _month = month;
// _day = day;
//}
private:
int _year;
int _month;
int _day;
};
int main()
{
//没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器自动生成的默认构造函数
Date d;
return 0;
}
但是通过监视窗口发现，d对象中的成员变量依旧是随机值，这是为什么呢，别着急老铁，后面会详细说明哦。
- 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器自动生成的构造函数，都可以认为是默认成员函数（不传参就可以直接调用的）。
class Date
{
public:
/*Date()
{
_year = 2022;
_month = 8;
_day = 25;
}*/
Date(int year = 2022, int month = 8, int day = 25)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d;
return 0;
}
- 关于编译器默认生成的成员函数，很多老铁都会有疑问：在我们不实现构造函数的情况下，编译器会自动生成默认的构造函数。但是看起来默认生成的构造函数又没什么用，因为d对象调用了编译器自动生成的默认构造函数，但是d对象的成员变量_year/_month/_day，依旧是随机值，也就是说，这里的编译期自动生成的默认构造函数并没有什么用？
解答：C++把类型分为内置类型（基本类型）和自定义类型。内置类型就是语法已经定义好的类型，如char, int…；自定义类型就是我们使用class/struct/union自己定义的类型。看看下面一段程序，你会发现编译器生成默认的构造函数会对自定义类型成员 _t 调用它的默认成员函数。
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
从中就可以看出，编译器默认生成的构造函数对内置类型不做处理，对于自定义类型会调用它的默认构造函数处理。 这句话很重要，请细品！
再看下面一段代码：
class Stack
{
public:
Stack()
{
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
class myQueue
{
public:
void Push(int x)
{}
int pop()
{}
private:
//全是自定义类型，编译器默认生成的构造函数就够用了
Stack st1;
Stack st2;
};
总结：
如果一个类中的成员全是自定义类型，并且这些成员都提供了默认成员函数，我们就可以用编译器默认生成的构造函数，如果有内置类型的成员，或者需要显示传参初始化，那都需要自己实现构造函数。（一般情况下，C++类都需要自己实现构造函数）
当然，C++11关于编译器自己生成的默认构造函数对内置类型不作处理，其实打了补丁，不过需要支持C++11的编译器才能用，打的补丁是这样的：
class myQueue
{
public:
void Push(int x)
{}
int pop()
{}
private:
//C++11打的补丁，针对编译器自己生成的默认构造函数对内置类型不作处理的问题
//这里的0给的是缺省值，留给编译器自己生成的默认构造函数用
//大家了解一下即可
int _size = 0;
Stack st1;
Stack st2;
};
- 成员变量的命名风格
//看看下面的写法是不是很僵硬？
class Date
{
public:
Date(int year)
{
//这里的year到底是成员变量，还是函数形参？
year = year;
}
private:
int year;
};
//所以一般我们建议下面这种写法：
class Date
{
public:
Date(int year)
{
_year = year;
}
private:
int _year;
};
//或者是这样的写法：
class Date
{
public:
Date(int year)
{
m_year = year;
}
private:
int m_year;
};
其他的方式也是可以的，主要看公司要求，一般都是在成员变量前面加个前缀或者后缀标识符区分就行。
析构函数
概念
前面通过构造函数的学习，我们知道了一个对象是怎么来的，那一个对象又是怎么没的呢？
析构函数：与构造函数相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
特性
析构函数是特殊的成员函数。
其特征如下：
- 析构函数名是在类名前加上字符~；
- 无参数无返回值；
- 一个类有且只有一个析构函数，若未显示定义，编译器会自动生成默认的析构函数，对于内置类型不作处理，自定义类型会调用它自己的析构函数；
- 对象生命周期结束时，C++编译器自动调用析构函数。
//拿之前的顺序表为例：
class SeqList
{
public:
SeqList(int capacity = 10)
{
_a = (int*)malloc(capacity * sizeof(int));
assert(_a);
_size = 0;
_capacity = capacity;
}
~SeqList()
{
if (_a)
{
free(_a);//释放堆上的空间
_a = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
int* _a;
size_t _size;
size_t _capacity;
};
还有一点需要注意的是，在栈里面定义对象，析构顺序和构造顺序是相反的，而且自定义类型先析构。不信，你调试下面代码即可发现：
class Stack
{
public:
Stack(int capacity = 10)
{
_a = (int*)malloc(capacity * sizeof(int));
assert(_a);
_top = 0;
_capacity = capacity;
}
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
//在栈里面定义对象，析构顺序和构造顺序是相反的
Stack st1(1);
Stack st2(2);
return 0;
}
- 关于编译器自动生成的析构函数，能否完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，会对自定义类型成员调用它的析构函数。
class String
{
public:
String(const char* str = "sl")
{
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);
}
~String()
{
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};
class Person
{
private:
String _name;
int _age;
};
拷贝构造函数
拷贝构造函数是特殊的构造函数。
概念
在现实生活中，可能存在与你十分相像的人，我们称之为双胞胎。
那我们在创建对象的时候，能否创建一个与另一个对象一模一样的对象呢？
这就要谈谈拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。
特性
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式；
- 拷贝构造函数的参数只有一个而且必须使用引用传参，如果使用传值方式会引发无穷递归调用；
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 25)
{
_year = year;
_month = month;
_day = day;
}
//之所以加上const，是为了保护d
Date(const Date& d)//注意必须是引用传参
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
为什么说拷贝构造函数一定要使用引用传参呢？请继续往下看：
//同类型的对象传值传参是会调用拷贝构造的
void Func(Date d)
{}
int main()
{
Date d1(2022, 8, 25);
Func(d1);//调用拷贝构造
}
内置类型是直接拷贝，自定义类型调用拷贝构造。自定义类型对象，拷贝初始化规定要调用拷贝构造完成。
加上引用就不会出现上述情况了，因为成了别名。
3.若未显示定义，编译器生成默认的拷贝构造函数。默认生成的拷贝构造函数对象按内存存储字节序完成拷贝，这种拷贝我们叫浅拷贝，或者值拷贝。（这点与编译器默认生成的构造函数和析构函数不同，这二者对于内置类型是不作处理的）
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 25)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
//这里d2调用默认拷贝构造函数完成拷贝，d2和d1的值也是一样的
Date d2(d1);
return 0;
}
我们不写编译器会默认生成一个拷贝构造函数：
- 内置类型的成员会完成值拷贝，浅拷贝；
- 自定义类型的成员，去调用这个成员的拷贝构造函数。
结论：
一般的类，自己生成的拷贝构造函数就可以用了，只有像Stack这样的类，自己直接管理资源吗，需要自己实现深拷贝，这个我们后面说。
- 那么编译器默认生成的拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像Date这样的类是没有必要的，那下面的类的？我们来验证一下：
class String
{
public:
String(const char* str = "sl")
{
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);
}
~String()
{
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2(s1);
return 0;
}
上面的代码，如果将自己实现的拷贝构造函数注释掉，采用编译器默认生成的拷贝构造的话，我们发现程序会崩溃，这就需要我们以后讲的深拷贝去解决。
这里还以之前的Stack作为例子，实现拷贝构造如下：
class Stack
{
public:
Stack(int capacity = 10)
{
_a = (int*)malloc(capacity * sizeof(int));
assert(_a);
_top = 0;
_capacity = capacity;
}
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
//实现成值拷贝，这里是错误的
Stack(const Stack& st)
{
_a = st._a;
_top = st._top;
_capacity = st._capacity;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}
注意：上面的_a是int*，属于整型指针类型，拷贝的是指针本身，而指针又是地址，所以是将这个地址拷贝给它，故而二者指向的是同一块地址。但是如果_a类型是数组类型，比如int _a[10]这样是可以的，因为数组也被认为是内置类型。可能你没听明白，没关系，请继续看：
总结浅拷贝的问题：
- 指向同一块空间，修改数据会相互影响；
- 这块空间析构时会释放两次，程序会崩溃。
解决方案：
要自己实现拷贝构造，完成深拷贝。
赋值运算符重载
运算符重载
C++为了增强代码的可读性引入了运算符重载（因为内置类型可以直接使用各种运算符，而自定义类型却不能直接使用各种运算符，所以为了自定义类型像内置类型一样可以直接使用各种运算符，C++便引入了运算符重载规则）。运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，而且其返回值类型和参数列表与普通的函数类似。
函数名：operator运算符（关键字operator后面接需要重载的运算符符号）
参数：运算符操作数
返回值：运算符运算后的结果
函数原型：返回值类型 operator操作符（参数列表）
注意：
- 不能通过连接其他符号来创建新的操作符，比如operator@；
- 重载运算符必须有一个类类型或者枚举类型的操作数；
- 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义；
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；
- .* :: sizeof ?: . 注意以上5个运算符不能重载。（这个经常在笔试选择题中出现）
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 27)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
//如果将运算符重载成全局的，就需要成员变量是共有的，这样的话封装性如何保证呢？
//可以用后面学的友元解决，或者干脆重载成成员函数
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year
&& d1._month == d2._month
&& d1._day == d2._day;
}
正确写法如下：
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 27)
{
_year = year;
_month = month;
_day = day;
}
//这里需要注意的是成员函数第一个形参是this指针(左操作数是this指向的调用函数的对象)
bool operator==(const Date& d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);
//if(d1 == d2)编译器会自动处理成对应的重载运算符调用if(d1.operator==(&d1,d2))
if (d1 == d2)
cout << "d1 == d2" << endl;
return 0;
}
赋值运算符重载
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 27)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//如果返回的对象没有在函数结束时被销毁就返回其引用
Date& operator=(const Date& d)
{
if (this != &d)//注意这里是原生指针的比较
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
赋值运算符主要有5点：
- 参数类型：const T&，传递引用可以提高传参效率；
- 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值；
- 检测是否自己给自己赋值，提高效率；
- 返回*this；
- 一个类如果没有显示定义赋值运算符重载，编译器也会自动生成一个，完成对象按照字节序的值拷贝。
class Date
{
public:
Date(int year = 2022, int month = 8, int day = 27)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(2022, 10, 1);
Date d3(d1);//拷贝构造，一个已存在的对象去初始化另一个要创建的对象
d1 = d2;//赋值重载/复制拷贝，两个已经存在的对象之间的赋值
}
注意：
拷贝构造和赋值重载的区别在于拷贝构造是一个已存在的对象去初始化另一个要创建的对象，而赋值重载是两个已存在的对象之间的赋值。
还有一个问题是：编译器默认生成的赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的是没有必要的，那么下面的类呢？
//发现程序崩溃了，需要我们以后讲的深拷贝去处理
class String
{
public:
String(const char* str = "sl")
{
_str = (char*)malloc(sizeof(str) + 1);
strcpy(_str, str);
}
~String()
{
free(_str);
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2("cplusplus");
s1 = s2;
return 0;
}
大厂面试真题
1、下列关于构造函数的描述正确的是( )
A.构造函数可以声明返回类型
B.构造函数不可以用private修饰
C.构造函数必须与类名相同
D.构造函数不能带参数
解析：构造函数不能有返回值，包括void类型也不行；构造函数可以是私有的，只是这样之后就不能直接实例化对象；构造函数不光可以带参数，还可以有多个构造函数构成重载。
2、在函数F中，本地变量a和b的构造函数(constructor)和析构函数(destructor)的调用顺序是: ( )
;
Class B;
void F()
{
A a;
B b;
}
解析：构造顺序是按照语句的顺序进行构造，析构是按照构造的相反顺序进行析构。
3、设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（ ）
;
int main()
{
A a;
B b;
static D d;
return 0；
}
解析：
- 类的析构函数调用一般按照构造函数调用的相反顺序进行的，但是要注意static对象的存在， 因为static改变了对象的生生命周期，需要等待程序结束时才会析构释放对象；
- 全局对象先于局部对象进行构造；
- 局部对象按照出现的顺序进行构造，无论是否为static；
- 所以构造的顺序为 c a b d；
- 析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生命周期之后，会放在局部对象之后进行析构；
- 因此析构顺序为B A D C。
