【一、构造函数与析构函数】深度解析C++类的构造函数与析构函数调用机制

已于 2022-02-24 21:16:12 修改
阅读量1.3k 收藏 6
点赞数 3
分类专栏： C++与STL 文章标签： c++ 面向对象编程 类 后端 开发语言
于 2022-02-19 15:48:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43471489/article/details/123018837
版权
本文详细介绍了构造函数（包括无参、有参和拷贝构造函数）的概念、特点、调用机制，重点讲解了拷贝构造函数的三种调用场景以及深拷贝与浅拷贝的区别。同时涵盖了析构函数的工作原理和构造函数的初始化列表在实践中的应用。
摘要由CSDN通过智能技术生成

文章目录

一、构造函数与析构函数

1.构造函数定义

构造函数是一种特殊的成员函数，它不需要用户手动调用（在某些情况下需要手动调用），而是在创建对象的的时候自动调用，构造函数的作用是初始化对象中的数据成员。

2.构造函数特点

①构造函数的名称必须与类名相同；
②构造函数没有返回值类型；
③构造函数可以重载（无参构造函数、有参构造函数、拷贝构造函数）；

3.析构函数定义

析构函数是清理对象资源的一类特殊成员函数，析构函数的名称是类名前加~号，它在对象释放前自动调用，无参数（因为没有参数，所以无法重载—函数重载的判断依据是参数类型、参数顺序、参数个数）、无返回值类型且析构函数种禁止使用return语句。

二、构造函数分类与调用机制

1.无参构造函数

如果类中没有定义任何构造函数，编译器会提供一个默认无参构造函数（和默认拷贝构造函数）；若类中定义了任意一个构造函数，编译器不会提供默认无参构造函数。下面结合代码详细分析无参构造函数的调用机制，代码如下：

#include <iostream>
using namespace std;

class MyClassA
{
public:
    MyClassA()
    {
        my_a = 1;
        my_b = 2;
        cout << "无参构造函数调用" << endl;
    }

    ~MyClassA()
    {
        cout << "析构函数调用" << endl;
    }

public:
    void PrintData()
    {
        cout << "my_a = " << my_a << " my_b = " << my_b << endl;
    }

private:
    int my_a;
    int my_b;
};

void ClassTest1()
{
    MyClassA A1; //创建对象的时候调用构造函数，默认无参构造函数
    A1.PrintData();
} //在对象的生命周期结束的时候调用析构函数

void ClassTest2()
{
	MyClassA A1, A2; //先调用A1构造函数，后调用A2构造函数//先定义先构造
} //先析构A2，后析构A1//后定义先析构

int main()
{
    ClassTest1(); //加断点单步调试来观察构造函数与析构函数的调用机制
    ClassTest2();

    std::cout << "Hello World!\n";
    system("pause");
    return 0;
}

2.有参构造函数

有参构造函数有三种调用场景，现结合代码分析，代码如下：

#include <iostream>
using namespace std;

class MyClassA
{
public:
    MyClassA(int a)
    {
        my_a = a;
        my_b = a;
        cout << "一个参数的有参构造函数调用" << endl;
    }

    MyClassA(int a, int b)
    {
        my_a = a;
        my_b = b;
        cout << "两个参数的有参构造函数调用" << endl;
    }

    ~MyClassA()
    {
        my_a = 0;
        my_b = 0;
        cout << "析构函数调用" << endl;
    }

public:
    void PrintData()
    {
        cout << "my_a = " << my_a << " my_b = " << my_b << endl;
    }

private:
    int my_a;
    int my_b;
};

void ClassTest1()
{
    //MyClassA A1; //因为已经自己定义了有参构造函数，不再提供默认无参构造函数
    			   //错误	C2512	“MyClassA” : 没有合适的默认构造函数可用
    //A1.PrintData();
}

void ClassTest2()
{
    //有参构造函数的第一种调用场景
	MyClassA A1(1, 2);
	A1.PrintData();

    //有参构造函数的第二种调用场景//这里调用的是一个参数的构造函数！！！
    						 //(3, 4)逗号表达式，值为4
    MyClassA A2 = (3, 4);
    A2.PrintData();
	MyClassA A22 = 4; //与A2的定义等价
	A22.PrintData();

    //有参构造函数的第三种调用场景
    MyClassA A3 = MyClassA(5, 6);
    A3.PrintData();
}

int main()
{
    //ClassTest1();
    ClassTest2(); //加断点单步调试来观察构造函数与析构函数的调用机制

    std::cout << "Hello World!\n";
    system("pause");
    return 0;
}

3.拷贝构造函数

如果类中没有定义任何构造函数，编译器会提供一个默认拷贝构造函数；如果类中没有定义拷贝构造函数，编译器会提供一个默认拷贝构造函数，并执行浅拷贝操作。

(1)拷贝构造函数的三种调用场景

#include <iostream>
using namespace std;

class MyClassA
{
public:
    MyClassA()
    {
        my_a = 0;
        my_b = 0;
        cout << "无参构造函数" << endl;
    }

    MyClassA(int a, int b)
    {
        my_a = a;
        my_b = b;
        cout << "有参构造函数调用" << endl;
    }

    MyClassA(const MyClassA& A)
    {
        my_a = A.my_a;
        my_b = A.my_b;
        cout << "拷贝构造函数调用" << endl;
    }

    ~MyClassA()
    {
        my_a = 0;
        my_b = 0;
        cout << "析构函数调用" << endl;
    }

public:
    void PrintData()
    {
        cout << "my_a = " << my_a << " my_b = " << my_b << endl;
    }

private:
    int my_a;
    int my_b;
};

//第一种调用场景：用一个对象初始化另一个对象
void ClassTest1()
{
    MyClassA A1(1, 2); //调用有参构造函数

    MyClassA A2(A1); //括号法初始化调用拷贝构造函数
    A2.PrintData();

    MyClassA A3 = A1; //等号法初始化调用拷贝构造函数
    A3.PrintData();

    MyClassA A4; //调用了无参构造函数
    A4 = A1; //这里是等号赋值！！！和等号法初始化是两个概念
             //不调用构造函数，而是执行赋值操作，把A1的数据赋值给A4（默认=浅拷贝，将在后面介绍）
    A4.PrintData();


}

void ParaFuncTest1(MyClassA A)
{
    A.PrintData();
}

void ParaFuncTest2(MyClassA& A)
{
	A.PrintData();
}

void ParaFuncTest3(MyClassA* A)
{
	A->PrintData();
}

//第二种调用场景：类定义对象做函数参数
void ClassTest2()
{
    MyClassA A1(1, 2);

    ParaFuncTest1(A1); //实参A1初始化形参A对象元素的时候，会调用拷贝构造函数
    ParaFuncTest2(A1); //不会调用拷贝构造函数，因为引用是变量别名，引用传递并没有出现新对象，
    				   //只是给现有对象起个别名进行传递
    ParaFuncTest3(&A1); //不会调用拷贝构造函数，因为传递的是对象A1的地址，并没有新的对象元素出现
}

MyClassA RetuFuncTest1()
{
    MyClassA A(1, 2);
    return A; //创建一个匿名对象，并把匿名对象返回出去，此时调用拷贝构造函数
} //而A的生命周期到此结束，被析构

//MyClassA& RetuFuncTest2()
//MyClassA* RetuFuncTest3()
//{
//	MyClassA A(1, 2);
//	return &A; //A是局部变量，不能返回它的地址
//}

//第三种调用场景：函数返回类型为类定义的元素
void ClassTest3()
{
    RetuFuncTest1(); //如果不用变量来接这个函数，那么会在 RetuFuncTest1() 函数的 return A;
                     //语句处调用拷贝构造函数，并立即执行析构函数
                     //这是因为，函数返回一个对象元素，而局部变量A的生命周期只在函数体内，
                     //不能返回出来，所以会在return时创建一个匿名对象，主调函数种若没有
                     //对象元素来接，那么会立即调用析构函数把匿名对象析构
    //RetuFuncTest2();
    //RetuFuncTest3();

    MyClassA A1 = RetuFuncTest1(); //这里不会再次调用拷贝构造函数，
    							   //因为编译器会把函数RetuFuncTest1()
                                   //返回出来的匿名对象直接转化为A1,因此匿名对象不会被析构，
                                   //在RetuFuncTest1()函数结束时只调用一次析构函数来析构局部变量A
                                   //匿名对象已经分配好了资源，并直接转化为A1，
    							   //所以A1初始化不需要再次调用拷贝构造函数
    A1.PrintData();

    MyClassA A2; //调用无参构造函数
    A2 = RetuFuncTest1(); //这是等号赋值操作！！！此时匿名对象也不会立即析构，而是在执行完这句话，
                          //对A2赋值完之后，执行析构函数，析构匿名对象
    					  //（区别于匿名对象初始化A1，匿名对象转为A1，不会析构）
    A2.PrintData();
} //生命周期结束，析构所有局部变量 A1(匿名对象) A2

int main()
{
    ClassTest1(); //加断点单步调试来观察构造函数与析构函数的调用机制
    ClassTest2();
    ClassTest3();

    std::cout << "Hello World!\n";
    system("pause");
    return 0;
}

(2)拷贝构造函数中的深拷贝与浅拷贝

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

class MyClassB
{
public:
    MyClassB(const char* p)
	{
		my_len = strlen(p);
		my_str = (char*)malloc(my_len + 1);
		strcpy(my_str, p);
		cout << "无参构造函数" << endl;
	}

	~MyClassB()
	{
		if (my_str != NULL)
		{
			free(my_str);
			my_str = NULL; //避免野指针
		}
		my_len = 0;
		cout << "析构函数调用" << endl;
	}

public:
	void PrintData()
	{
		cout << "my_len = " << my_len << endl;
		cout << "my_str = " << my_str << endl;
	}

private:
	int     my_len;
	char*   my_str;
};

void ClassTestB()
{
	MyClassB B1("hello C++ word!");
	B1.PrintData();

	MyClassB B2 = B1; //调用默认拷贝构造函数
	B2.PrintData();
} //程序会在此挂掉，原因分析 --- 默认拷贝构造函数的浅拷贝问题
  //类B中没有定义拷贝构造函数，会使用编译器提供的默认拷贝构造函数
  //默认拷贝构造函数只是简单的数值赋值，当类中含有指针时
  //只是单纯的把B1.my_str指针的值赋给了B2.my_str，而没有给B2.my_str分配内存，
  //这时两个指针指向同一个内存块，当函数执行完，在调用B2析构函数时，把B2.my_str
  //所指向的空间析构掉了，B1.my_str也指向这块内存，而内存已经被释放了，
  //这时，B1.my_str变成了野指针，当调用B1的析构函数析构B1.my_str指向的内存时，程序挂掉

class MyClassA
{
public:
    MyClassA()
    {
        ; //MyClassA A3; 需要无参构造函数
    }

    MyClassA(const char* p)
    {
        my_len = strlen(p);
        my_str = (char*)malloc(my_len + 1);
        strcpy(my_str, p);
        cout << "无参构造函数" << endl;
    }

    //自定义拷贝构造函数，实现深拷贝
    MyClassA(const MyClassA& A)
    {
        my_len = A.my_len;
        my_str = (char*)malloc(my_len + 1);
        strcpy(my_str, A.my_str);
    }

    ~MyClassA()
    {
        if (my_str != NULL)
        {
            free(my_str);
            my_str = NULL; //避免野指针
        }
        my_len = 0;
        cout << "析构函数调用" << endl;
    }

public:
    void PrintData()
    {
        cout << "my_len = " << my_len << endl;
        cout << "my_str = " << my_str << endl;
    }

private:
    int     my_len;
    char*   my_str;
};

void ClassTestA()
{
    MyClassA A1("hello C++ word!");
    A1.PrintData();

    MyClassA A2 = A1;
    A2.PrintData();

   // MyClassA A3; 
   // A3 = A1; //默认等号也是浅拷贝
   // A3.PrintData();
}

int main()
{
    //ClassTestB();
    ClassTestA(); //加断点单步调试来观察构造函数与析构函数的调用机制

    std::cout << "Hello World!\n";
    system("pause");
    return 0;
}

4.总结

只有当类中没有定义任何构造函数时，才会生成默认无参构造函数，但凡类中有定义的任何一个构造函数，都不会生成默认无参构造函数。
只要类中没有定义拷贝构造函数，就会默认生成一个拷贝构造函数，执行浅拷贝，只要定义了一个拷贝构造函数，就不会在生成默认拷贝构造函数。

三、构造函数的初始化列表

应优先使用初始化列表来对数据成员进行初始化，因为就算不显示使用初始化列表，程序也会在执行构造函数的函数体之前将所有数据成员通过默认方式初始化，使用初始化列表可以避免二次赋值。

#include <iostream>
using namespace std;

class MyClassA
{
public:
	MyClassA(int a) //前提是类A中必须含有相应的有参构造函数
	{
		this->a = a;
		cout << "构造函数调用" << endl;
	}

	~MyClassA()
	{
		cout << "析构函数调用" << endl;
	}

private:
	int a;
};

//必须使用构造函数参数初始化列表的两种情况
class MyClassB
{
public:
	MyClassB(int b, int m, int n, int k) : a1(m), a2(n), c(k)
	{
		this->b = b;
		cout << "构造函数调用" << endl;
	}

	~MyClassB()
	{
		cout << "析构函数调用" << endl;
	}

private:
	int b;
    //1.一个类的成员中含有另一个类对象，需使用初始化列表来给成员类初始化
	MyClassA a1, a2;
    //2.const类型的变量必须使用初始化参数列表来初始化
	const int c;
};

void ClassTest()
{
	MyClassB B1(1, 2, 3, 4);
}

class MyClassA2
{
public:
	MyClassA2()
	{
		cout << "构造函数调用" << endl;
	}

	~MyClassA2()
	{
		cout << "析构函数调用" << endl;
	}

private:
	int a;
};

class MyClassA3
{
public:
	MyClassA3(int a1, int a2)
	{
        this->a1 = a1;
        this->a2 = a2;
		cout << "构造函数调用" << endl;
	}

	~MyClassA3()
	{
		cout << "析构函数调用" << endl;
	}

private:
	int a1;
    int a2;
};

class MyClassB2
{
public:
    //错误(活动)	E0289	没有与参数列表匹配的构造函数
    //因为MyClassA2 MyClassA3中均没有一个参数的构造函数，所以报错，没有匹配的构造函数
	MyClassB2(int b, int m, int n) : a2(m), a3(n) 
	{
        this->b = b;
		cout << "构造函数调用" << endl;
	}
    
    //正确做法，根据MyClassA2 MyClassA3定义的构造函数来设置MyClassB2的初始化列表
    /*
    MyClassB2(int b, int m, int n) : a2(), a3(m, n)
	{
		this->b = b;
		cout << "构造函数调用" << endl;
	}
    */

	~MyClassB2()
	{
		cout << "析构函数调用" << endl;
	}

private:
	int b;
    MyClassA2 a2;
    MyClassA3 a3;
};

void ClassTest2()
{
    MyClassB2(1, 2, 3);
}

int main()
{
	ClassTest(); //加断点单步调试来观察构造函数与析构函数的调用机制
    ClassTest2();

	std::cout << "Hello World!\n";
	system("pause");
	return 0;
}

总结

学习C++构造函数与析构函数的调用时机、调用顺序、参数匹配，对象生命周期等，最好的方法就是在代码中进行调试实验，通过断点单步调试，一步步观察程序的执行。

系列文章

二、new/delete详解

Mindtechnist
关注
专栏目录
深入内存模型和函数调用机制，理解析构函数的执行顺序
hnxijie的博客
06-03 1076
原文地址 http://tianchengming.com/post-229.html 为什么析构函数的执行顺序是相反的。 要搞清楚这个问题，首先要明白C++内存模型，也就是C++的代码和数据在内存中是如何存储的。C++内存模型和C语言类似（有部分细节不同），你可以参照C语言内存模型来理解。  在内存模型中有一块区域叫做栈区，它是由系统维护的（程序员无法操作）
C++构造函数、析构函数及其调用顺序详解
weixin_42528661的博客
03-15 1975
构造函数： 定义：是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。 特点： 函数名与类名相同。 无返回值。 对象实
C++类机制
魔筝炼药师
03-28 658
简介C++类机制涉及的概念 面向对象三大特点：封装、继承、多态。封装为了信息隐藏，继承（is-a）为了代码复用，多态则是为了接口复用，即一个接口，多种实现。有继承，就会有派生。类定义时，代码实现者一般会根据实际需要定义好各个成员的访问权限，继承体系也有明确的权限控制。 继承，根据父类的个数和继承层次体系可分为单一继承、多重继承、菱形继承等，多重继承可能会遇到二义性问题，问题表现形式是明明代码中定义类编译通过，一运行就报错ambiguous，解决方法就是使用域运算符或者虚继承。根据继承方式可分为虚继承、.
C++1类和对象 对象特性1 构造函数与析构函数 构造函数的调用与分类 调用时机以及构造函数的调用规则
weixin_44176501的博客
04-08 230
一、构造函数与析构函数 1.C++利用构造函数和析构函数去做两件事，他们分别是： <1>构造函数：主要作用是在创建对象的时候为对象的成员属性进行赋值，构造函数由编译器自动调用，无需我们手动调用。 <2>析构函数:析构函数是在系统运行结束前，对对象进行销毁工作也就是释放地址空间。 2.构造函数的语法 <1>函数无返回值，无需写void <2>函数名称与类名相同 <3>可以含参数，实现函数重载 <4>程序在调用对象的时候会自动调用构造，无需
C++中构造函数与析构函数的调用顺序详解
12-31
在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。 简单来说，其构造函数...
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
在C++编程中，正确地管理类的构造函数、拷贝构造函数、析构函数和赋值函数是创建健壮、无内存泄漏程序的关键。接下来将详细介绍如何为自定义的String类编写这些函数，并通过实例来加深理解。 首先，我们定义一个...
深入C++中构造函数、拷贝构造函数、赋值操作符、析构函数的调用过程总结
01-01
而当调用函数中有一个接受对象时，就将返回对象赋值给接收对象，这个返回对象在调用函数结束时调用析构函数。3. 当类有一个带有一个参数的构造函数时，可以用这个参数同类型的数据初始化这个对象，默认会调用这个...
头歌Educoder实验：C++ 面向对象 - 构造函数与析构函数
最新发布
m0_64262556的博客
12-21 8594
静态变量的初始化不能在类的定义中，但是可以在类的外部通过使用范围解析运算符。
头歌：C++ 面向对象 - 构造函数与析构函数
qq_65628600的博客
05-22 5923
第一题： #include<iostream> #include<string> using namespace std; class Student { public: int SID; string Name; Student();//无参的构造函数：Student()，在函数中将学号初始化为0，姓名初始化为王小明 Student(int sid,string name); ~Student(
C++析构函数的自动调用（用于父类指针指向子类对象，内存泄漏问题）(转)
dragoo1的专栏
09-03 747
转自：https://www.cnblogs.com/xuaidongstdudyrecording/p/6016036.html class A { public: A() { printf("A \n"); } ~A() { printf(" ~A \n"); }// 这里不管写不写virtual，删除B对象的时候，都会被执行。因为这个例子是B*指针指向B对象，不是A*指针指向B对象。 }; class B : public A { public: B() { printf("B \n"); } .
构造函数与析构函数
bareheadedman的博客
08-20 306
在C++中对象的初始化与清理工作分别由两个特殊的函数来完成，他们就是构造函数与析构函数。 构造函数： 构造函数是在对象被创建时利用特定的值构造对象，并将对象初始化为一个特定的状态。 构造函数的函数名与类名相同，并且它没有返回值，而且构造函数一般被声明为公有函数。 如果类中没有写构造函数，编译器会自动生成一个隐含的默认构造函数，该构造函数的参数列表和函数体皆为空。但是如果类中声明了构造函数（无论有没...
析构函数与构造函数的调用
奇点的博客
12-18 344
阅读程序写结果： #include <iostream> using namespace std; class A { public: A(); A(int i,int j); ~A(); void print(); private: int a,b; }; A::A() { a=b=0; cout<<"C"<...
方法重载和构造器
qq_33458487的博客
08-29 150
方法重载 行为：代表该对象可以去做什么事情，或者说它具备某种能力。 重载：相同行为，不同的实现，根据不同的参数列表来进行区分。 特点：参数的个数可能不一样，参数的类型可能不一样，参数的顺序也可能不一样。 特点：方法名一样。 疑问：方法参数都一样，返回类型不一样，不是重载。 Boolean类型的属性，切莫写成了isgender，否则会找不调用方法。 构造器 作用：产生对象 语法特点...
【C++面向对象核心】构造函数、析构函数及其功能
weixin_45403888的博客
02-07 401
一、构造函数 构造函数在创建对象时调用，它与类同名且不返回任何值，是类成员变量初始化的理想场所。下面记录几个要点： 1.构造函数可以重载 代码如下（示例）： class Human { private: int age; string name; public: // 默认构造函数 Human() { age = 0; } // 重载构造函数 Human(string humanName) { name = humanName; age = 0; } }; 2.没有默认构造函数
【C++入门】(拷贝)构造函数和析构函数
weixin_42031299的博客
10-06 1846
(1)：字面意思就是构造对象的函数，当我们定义类的对象时调用，可以帮我们完成对象的初始化；(2)：可以看做是构造函数的逆过程，当销毁类的时候调用，做一些收尾的工作；比如：定义类的对象时构造函数申请了动态内存，那在销毁对象时调研员的析构函数中就要释放申请的动态内存，否则就会造成内存泄漏；(3)。程序员可以在定义类时使用默认的构造/析构函数，或者自己定义构造/析构函数，但是构造/析构函数的调用却不是程序员主动去调用，而是C++语言自动帮我们调用。
类的使用：构造函数和析构函数
qq_63775204的博客
04-14 88
类的使用：构造函数和析构函数
17_C++_面向对象_构造函数_析构函数
m0_48948682的博客
08-04 686
C++面向对象的构造函数和析构函数
实训11_复杂类的实现_LinkedList类的实现
Junds0的博客
12-12 4432
第1关：构造函数与析构函数的实现 LinkedList类是一个比较复杂的类，首先需要实现其构造函数。要求用户为LinkedList类提供4种构造函数。分别是： 默认构造函数 使用该函数构造出的数组对象，逻辑上是空的 拷贝构造函数 使用该函数构造出的输出对象，逻辑上的内容应与参数一模一样 原生输出构造函数 给定一个C++的原生数组，构造出内容一模一样的数组对象 填充构造函数 给定参数n与value，构造出一个数组对象，其内容是n个value /********** BEGIN **********/ #inc
C++构造与析构函数深度解析
"高级语言C++程序设计-c++构造函数与析构函数ppt" 在C++编程语言中，构造函数和析构函数是类的重要组成部分，它们分别负责对象的初始化和清理工作。本讲座主要探讨了这两类特殊成员函数在C++中的应用和作用。 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mindtechnist

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值