构造函数必备知识：
如何理解构造函数：
构造函数是c++类必不可少的一个部分，要理解构造函数,首先需要理解对象的建立过程。为此先来看看一个基本变量类型的初始化过程：每一个变量在程序运行时的都要占据一定的内存空间，在声明一个变量时对变量进行初始化,就意味着在为变量分配内存单元的同时,在其中写入了变量的初始值。这样的初始化在C++源程序中看似很简单,但是编译器却需要根据变量的类型自动产生一些代码来完成初始化过程。
对象的建立过程也是类似的:在程序执行过程中,当遇到对象声明语句时,程序会向操作系统申请一定的内存空间用于存放新建的对象。我们希望程序能像对待普通变量一样,在分配内存空间的同时将数据成员的初始值写入。但是不幸得很,做到这一点不那么容易,因为与普通变量相比,类的对象毕竟太复杂了,编译器不知道如何产生代码来实现初始化。因此如果需要进行对象初始化,程序员要编写初始化程序。如果程序员没有自己编写初始化程序,却在声明对象时贸然指定对象初始值,不仅不能实现初始化,还会引起编译时的语法错误。这就是为什么本书中此前的例题都没有进行对象初始化。
尽管如此,C++编译系统在对象初始化的问题上还是替我们做了很多工作。C++中
第二部分 严格规定了初始化程序的接口形式,并有一套自动的调用机制。这里所说的初始化程序，便是构造函数。
构造函数的作用就是在对象被创建时利用特定的值构造对象,将对象初始化为一个 特定的状态。构造函数也是类的一个成员函数,除了具有一般成员函数的特征之外,还有一些特殊的性质:构造函数的函数名与类名相同,而且没有返回值;构造函数通常被声明为公有函数。只要类中有了构造函数,编译器就会在建立新对象的地方自动插入对构造函数调用的代码。因此我们通常说构造函数在对象被创建的时候将被自动调用。
构造函数语法：
类名(){}
-
构造函数，没有返回值也不写void
-
函数名称与类名相同
-
构造函数可以有参数，因此可以发生重载
-
程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
class Person
{
public:
//构造函数
Person()
{
cout << "Person的构造函数调用" << endl;
}
};
void test01()
{
Person p;
}
int main() {
test01();
system("pause");
return 0;
}构造函数的分类及调用
两种分类方式：
按参数分为： 有参构造和无参构造
按类型分为： 普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
//1、构造函数分类
// 按照参数分类分为 有参和无参构造 无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
//2.1 括号法，常用
Person p1(10);
//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
//test02();
system("pause");
return 0;
}拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况
-
使用一个已经创建完毕的对象来初始化一个新对象
-
值传递的方式给函数参数传值
-
以值方式返回局部对象
示例：
class Person {
public:
Person() {
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person(int age) {
cout << "有参构造函数!" << endl;
mAge = age;
}
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
//析构函数在释放内存之前调用
~Person() {
cout << "析构函数!" << endl;
}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person man(100); //p对象已经创建完毕
Person newman(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
//Person newman3;
//newman3 = man; //不是调用拷贝构造函数，赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
Person p; //无参构造函数
doWork(p);
}
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}深拷贝与浅拷贝
深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
示例：
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age ,int height) {
cout << "有参构造函数!" << endl;
m_age = age;
m_height = new int(height);
}
//拷贝构造函数
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
m_age = p.m_age;
m_height = new int(*p.m_height);
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
if (m_height != NULL)
{
delete m_height;
}
}
public:
int m_age;
int* m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
-
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
-
如果用户定义拷贝构造函数，c++不会再提供其他构造函数
示例：
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
void test01()
{
Person p1(18);
//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为： " << p2.age << endl;
}
void test02()
{
//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造，会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供
//如果用户提供拷贝构造，编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造，会出错
Person p5(10); //此时如果用户自己没有提供有参，会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main() {
test01();
system("pause");
return 0;
}初始化列表
作用：
C++提供了初始化列表语法，用来初始化属性
语法：构造函数()：属性1(值1),属性2（值2）... {}
示例：
class Person {
public:
传统方式初始化
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表方式初始化
Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
void PrintPerson() {
cout << "mA:" << m_A << endl;
cout << "mB:" << m_B << endl;
cout << "mC:" << m_C << endl;
}
private:
int m_A;
int m_B;
int m_C;
};
int main() {
Person p(1, 2, 3);
p.PrintPerson();
system("pause");
return 0;
}构造函数常考面经：
C++有哪几种的构造函数
C++
中的构造函数可以分为
4
类：
- 默认构造函数
- 初始化构造函数（有参数）
- 拷贝构造函数
- 移动构造函数（move和右值引用）
- 委托构造函数
- 转换构造函数
默认构造函数和初始化构造函数在定义类的对象，完成对象的初始化工作
复制构造函数用于复制本类的对象
转换构造函数用于将其他类型的变量，隐式转换为本类对象
#include <iostream>
using namespace std;
class Student{
public:
Student(){//默认构造函数，没有参数
this->age = 20;
this->num = 1000;
};
Student(int a, int n):age(a), num(n){}; //初始化构造函数，有参数和参数列表
Student(const Student& s){//拷贝构造函数，这里与编译器生成的一致
this->age = s.age;
this->num = s.num;
};
Student(int r){ //转换构造函数,形参是其他类型变量，且只有一个形参
this->age = r;
this->num = 1002;
};
~Student(){}
public:
int age;
int num;
};
int main(){
Student s1;
Student s2(18,1001);
int a = 10;
Student s3(a);
Student s4(s3);
printf("s1 age:%d, num:%d\n", s1.age, s1.num);
printf("s2 age:%d, num:%d\n", s2.age, s2.num);
printf("s3 age:%d, num:%d\n", s3.age, s3.num);
printf("s2 age:%d, num:%d\n", s4.age, s4.num);
return 0;
}
//运行结果
//s1 age:20, num:1000
//s2 age:18, num:1001
//s3 age:10, num:1002
//s2 age:10, num:1002什么情况下会调用拷贝构造函数
- 用类的一个实例化对象去初始化另一个对象的时候
- 函数的参数是类的对象时（非引用传递）
- 函数的返回值是函数体内局部对象的类的对象时 ,此时虽然发生（Named return Value优化）NRV优 化，但是由于返回方式是值传递，所以会在返回值的地方调用拷贝构造函数
另：第三种情况在
Linux g++
下则不会发生拷贝构造函数，不仅如此即使返回局部对象的引用，依然不
会发生拷贝构造函数。
总结就是：即使发生
NRV
优化的情况下，
Linux+ g++
的环境是不管值返回方式还是引用方式返回的方式
都不会发生拷贝构造函数，而
Windows + VS2019
在值返回的情况下发生拷贝构造函数，引用返回方式
则不发生拷贝构造函数
。
在
c++
编译器发生
NRV
优化，如果是引用返回的形式则不会调用拷贝构造函数，如果是值传递的方式依然会发生拷贝构造函数。
类成员初始化方式？构造函数的执行顺序 ？为什么用成员初始化列表会快一些？
1)
- 赋值初始化，通过在函数体内进行赋值初始化；
- 列表初始化，在冒号后使用初始化列表进行初始化。
这两种方式的主要区别在于：
对于在函数体中初始化,
是在所有的数据成员被分配内存空间后才进行的。
列表初始化是给数据成员分配内存空间时就进行初始化,就是说分配一个数据成员只要冒号后有此数据成员的赋值表达式(
此表达式必须是括号赋值表达式
),
那么分配了内存空间后在进入函数体之前给数据成员赋值，就是说初始化这个数据成员此时函数体还未执行。
2)
一个派生类构造函数的执行顺序如下：
①
虚拟基类的构造函数（多个虚拟基类则按照继承的顺序执行构造函数）。
②
基类的构造函数（多个普通基类也按照继承的顺序执行构造函数）。
③
类类型的成员对象的构造函数（按照初始化顺序）
④
派生类自己的构造函数。
3)
方法一是在构造函数当中做赋值的操作，而方法二是做纯粹的初始化操作。我们都知道，
C++
的赋值操作是会产生临时对象的。临时对象的出现会降低程序的效率。
说说移动构造函数
1)
我们用对象
a
初始化对象
b
，后对象
a
我们就不在使用了，但是对象
a
的空间还在呀（在析构之前），既然拷贝构造函数，实际上就是把a
对象的内容复制一份到
b
中，那么为什么我们不能直接使用
a
的空间呢？这样就避免了新的空间的分配，大大降低了构造的成本。这就是移动构造函数设计的初衷；
2)
拷贝构造函数中，对于指针，我们一定要采用深层复制，而移动构造函数中，对于指针，我们采用浅层复制。浅层复制之所以危险，是因为两个指针共同指向一片内存空间，若第一个指针将其释放，另一个指针的指向就不合法了。
所以我们只要避免第一个指针释放空间就可以了。避免的方法就是将第一个指针（比如a->value
）置为NULL，这样在调用析构函数的时候，由于有判断是否为
NULL
的语句，所以析构
a
的时候并不会回收
a->value指向的空间；
3)
移动构造函数的参数和拷贝构造函数不同，拷贝构造函数的参数是一个左值引用，但是移动构造函数的初值是一个右值引用。意味着，移动构造函数的参数是一个右值或者将亡值的引用。也就是说，只用用一个右值，或者将亡值初始化另一个对象的时候，才会调用移动构造函数。而那个move
语句，就是将一个左值变成一个将亡值。
如何禁止程序自动生成拷贝构造函数？
1)
为了阻止编译器默认生成拷贝构造函数和拷贝赋值函数，我们需要手动去重写这两个函数，某些情况下，为了避免调用拷贝构造函数和拷贝赋值函数，我们需要将他们设置成private，防止被调用。
2)
类的成员函数和
friend
函数还是可以调用
private
函数，如果这个
private
函数只声明不定义，则会产生一个连接错误；
3)
针对上述两种情况，我们可以定一个
base
类，在
base
类中将拷贝构造函数和拷贝赋值函数设置成private,那么派生类中编译器将不会自动生成这两个函数，且由于
base
类中该函数是私有的，因此，派生类将阻止编译器执行相关的操作。
构造函数、析构函数的执行顺序？构造函数和拷贝构造的内部都干了啥？
1)
构造函数顺序
①
基类构造函数。如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是
它们在成员初始化表中的顺序。
②
成员类对象构造函数。如果有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序，
而不是它们出现在成员初始化表中的顺序。
③
派生类构造函数。
2)
析构函数顺序
①
调用派生类的析构函数；
②
调用成员类对象的析构函数；
③
调用基类的析构函数。
构造函数析构函数可否抛出异常
1) C++
只会析构已经完成的对象，对象只有在其构造函数执行完毕才算是完全构造妥当。在构造函数中发生异常，控制权转出构造函数之外。因此，在对象b
的构造函数中发生异常，对象
b
的析构函数不会被调用。因此会造成内存泄漏。
2)
用
auto_ptr
对象来取代指针类成员，便对构造函数做了强化，免除了抛出异常时发生资源泄漏的危机，不再需要在析构函数中手动释放资源；
3)
如果控制权基于异常的因素离开析构函数，而此时正有另一个异常处于作用状态，
C++
会调用
terminate
函数让程序结束；
4)
如果异常从析构函数抛出，而且没有在当地进行捕捉，那个析构函数便是执行不全的。如果析构函数执行不全，就是没有完成他应该执行的每一件事情。
构造函数、拷贝构造函数和赋值操作符的区别
构造函数
对象不存在，没用别的对象初始化，在创建一个新的对象时调用构造函数
拷贝构造函数
对象不存在，但是使用别的已经存在的对象来进行初始化
赋值运算符
对象存在，用别的对象给它赋值，这属于重载
“=”
号运算符的范畴，
“=”
号两侧的对象都是已存在的
举个例子：
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout << "我是构造函数" << endl;
}
A(const A& a)
{
cout << "我是拷贝构造函数" << endl;
}
A& operator = (A& a)
{
cout << "我是赋值操作符" << endl;
return *this;
}
~A() {};
};
int main()
{
A a1; //调用构造函数
A a2 = a1; //调用拷贝构造函数
a2 = a1; //调用赋值操作符
return 0;
}
//输出结果
//我是构造函数
//我是拷贝构造函数
//我是赋值操作符
拷贝构造函数和赋值运算符重载的区别？
- 拷贝构造函数是函数，赋值运算符是运算符重载。
- 拷贝构造函数会生成新的类对象，赋值运算符不能。
- 拷贝构造函数是直接构造一个新的类对象，所以在初始化对象前不需要检查源对象和新建对象是否相 同；赋值运算符需要上述操作并提供两套不同的复制策略，另外赋值运算符中如果原来的对象有内存 分配则需要先把内存释放掉。
- 形参传递是调用拷贝构造函数（调用的被赋值对象的拷贝构造函数），但并不是所有出现"="的地方都是使用赋值运算符，如下：
Student s; Student s1 = s; // 调用拷贝构造函数 Student s2; s2 = s; // 赋值运算符操作
什么情况会自动生成默认构造函数？
1)
带有默认构造函数的类成员对象，如果一个类没有任何构造函数，但它含有一个成员对象，而后者有默认构造函数，那么编译器就为该类合成出一个默认构造函数。
不过这个合成操作只有在构造函数真正被需要的时候才会发生；
如果一个类A
含有多个成员类对象的话，那么类
A
的每一个构造函数必须调用每一个成员对象的默认构造函数而且必须按照类对象在类A
中的声明顺序进行；
2)
带有默认构造函数的基类，如果一个没有任务构造函数的派生类派生自一个带有默认构造函数基类，那么该派生类会合成一个构造函数调用上一层基类的默认构造函数；
3)
带有一个虚函数的类
4)
带有一个虚基类的类
5)
合成的默认构造函数中，只有基类子对象和成员类对象会被初始化。所有其他的非静态数据成员都不会被初始化。
扫一扫
8552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
