c++中的构造函数和析构函数

已于 2022-03-13 23:09:23 修改
阅读量1.9k 收藏 18
点赞数 7
分类专栏： c/c++相关 文章标签： c++ 开发语言
于 2022-03-13 15:24:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61973596/article/details/123458069
版权

类和对象中，包括构造函数和析构函数，比较重要，通过学习总结一下，以便以后可以回顾！

目录

构造函数

1.默认构造函数

2.有参构造函数

 3.委托构造函数

4.复制(拷贝)构造函数

5.移动构造函数

左值引用与右值引用

析构函数

析构函数

构造函数

构造函数，就是在对象创建的时候，把类中的属性进行一个初始化，而且创建对象时候会自动调用并且只调用一次。(就比如我们买一个手机，最开始它会有相应的系统设置(这个就有点类似构造函数)，后面可以修改其设置，也就相当于类中函数对属性修改。)

下面介绍几个常用的构造函数...

1.默认构造函数

不含参数的构造函数，举个例子，创建一个Person类，包括年龄和身高两个属性，年龄(整形),身高(整形指针)，默认构造初始画年龄是0，身高0。如果我们不写的话系统会默认空实现

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	int m_Age;
	int* m_Height;
};
//初始化年龄和身高
Person::Person() 
{
	cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
int main()
{
	Person p;
	cout << "此人的年龄是： " << p.m_Age << endl;
	cout << "此人的身高是： " << *(p.m_Height) << endl;
	return 0;
}

显然我们在创建函数的同时，把属性进行了初始化，测试把属性输出，另外注意一点的是创建对象时是Person p; 如果我们这样写Person p(); 编译器会认为是创建了一个函数p 返回值类型Person,形参为空  {}空实现  这个一定注意。

2.有参构造函数

下面介绍一下有参构造，还是接着用上面的例子进行添加，继续，如果我们想创建一个指定年龄和身高的对象，这时候就要用到有参构造了，例子

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	int m_Age;
	int* m_Height;
};
//默认构造
Person::Person() 
{
    cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age,int height)
{
    cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
int main()
{
	Person p(18,175);
	cout << "此人的年龄是： " << p.m_Age << endl;
	cout << "此人的身高是： " << *(p.m_Height) << endl;
	return 0;
}

 现在创建一个对象p(18,175)，创建时可以直接赋值，实现对对象的初始化。

 3.委托构造函数

顾名思义，委托构造函数就是把自己构造的事情，交给其他的构造函数顺带完成，例如我把默认构造函数修改一下，

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	//拷贝构造
	Person(const Person& p);
	int m_Age;
	int* m_Height;
};
默认构造
Person::Person() :Person(0, 0)
{
	cout << "委托构造函数的调用！" << endl;
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age, int height)
{
	cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
//拷贝构造函数调用
Person::Person(const Person& p)
{
	cout << "拷贝构造函数的调用！" << endl;
	this->m_Age = p.m_Age;
	this->m_Height = new int(*p.m_Height);
}
int main()
{
	Person p;
	cout << "p的年龄是： " << p.m_Age << endl;
	cout << "p的身高是： " << *(p.m_Height) << endl;
	return 0;
}

这里默认构造用： 把构造交给有参构造顺带完成！所以先会调用有参构造，其次委托构造，输出年龄和身高验证一下：

4.复制(拷贝)构造函数

上面都是开始是给出属性的值进行初始化，而拷贝构造函数在开始是传递一个对象，把对象的个属性拷贝到此对象中，进行对象的初始化(可以把传去的参数，看成一只羊，拷贝构造后克隆了一只新的羊，两只羊的属性一样)根据这样可以实现对象的创建。

这里为了方便把委托构造函数还原成默认构造函数了，如下

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	//拷贝构造
	Person(const Person& p);
	int m_Age;
	int* m_Height;
};
//默认构造
Person::Person()
{
	cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age, int height)
{
	cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
//拷贝构造函数调用
Person::Person(const Person& p)
{
	cout << "拷贝构造函数的调用！" << endl;
	this->m_Age = p.m_Age;
	this->m_Height = new int(*p.m_Height);
}
int main()
{
	Person p(18, 175);
	cout << "p的年龄是： " << p.m_Age << endl;
	cout << "p的身高是： " << *(p.m_Height) << endl;
	Person p2(p);
	cout << "p2的年龄是： " << p2.m_Age << endl;
	cout << "p2的身高是： " << *(p2.m_Height) << endl;
	return 0;
}

 这里我用了深拷贝构造，这样可以防止堆区的内存重复被析构函数释放，保证代码的安全。深浅拷贝以后有时间我再整理一下，拷贝前面加入const限定可以防止修改成员属性保证完全一致。这个用了引用左值，进行一个赋值，进行理解，上面为左值参数的引用拷贝。

5.移动构造函数

左值引用与右值引用

   首先要了解左值和右值的引用，左值是位于赋值左侧的对象变量(依附于对象)；右值是赋值语句在右侧的值(不依附于对象)。简单可以理解为能用&取地址的就是左值，否则是右值。

int age=20;//左值
int Func()
{
 return 100;
}
int ret=Func();//ret是左值,Func()右值
int x=2*2;//x左值，2*2右值

接下来进行右值引用的移动构造函数，即要创建一个右值，然后调用，为了方便输出展示信息，我添加了一个成员函数ShowPerson()展示信息

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	//拷贝构造
	Person(const Person& p);
	//移动构造函数
	Person(Person&& p);
	//展示信息
	void ShowPerson();
	int m_Age;
	int* m_Height;
};
//默认构造
Person::Person()
{
	cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age, int height)
{
	cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
//拷贝构造函数调用
Person::Person(const Person& p):m_Age(p.m_Age),m_Height(new int (*p.m_Height))
{
	cout << "拷贝构造函数的调用！" << endl;
	/*this->m_Age = p.m_Age;
	this->m_Height = new int(*p.m_Height);*/
}
//移动构造函数
Person::Person(Person&& p)
{
	cout << "移动构造函数的调用！" << endl;
	this->m_Age = p.m_Age;
	this->m_Height = p.m_Height;
	p.m_Height = NULL;
}
//展示信息
void Person::ShowPerson()
{
	cout << "年龄是： " << this->m_Age << endl;
    cout << "身高是： " << *(this->m_Height) << endl;
}
//返回一个右值的对象
Person GetPerson()
{
	Person p;
	return p;
}
int main()
{
	GetPerson().ShowPerson();
	return 0;
}

分析：在主函数中先调用GetPerson()函数创建一个右值对象，调用时创建了一个Person p,所以会先输出调用默认构造，其次调用了右值移动构造，这里进行了深拷贝，防止堆区数据重复释放！右值对象属于无法取地址的对象所以很快就会被清除，用移动构造处理

 这里借用：一枚小码农介绍中的一张图，对于普通数据可以直接赋值，但对于指针类型，要把原本的指向赋值为空，然后进行销毁内存！

接下来整理析构函数的时候简单介绍下浅拷贝对指针信息的影响。

析构函数

析构函数是用于在对象被删除之前的清理工作，在对象生命周期即将结束时被自动调用。(有始有终，什么都会生死，析构函数可以清理对象并且释放内存)

析构函数

在上面的介绍没有介绍到析构函数，可能不会没有问题。析构函数~加上类名()进行操作，目的时清空数据，释放内存。

现在加上析构函数再次测试调用并且进行思考，例如最简单的，创建一个默认构造函数p，进行默认构造，然后调用展示信息函数输出信息，最后析构函数，释放内容，防止内存泄漏！

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	//拷贝构造
	Person(const Person& p);
	//移动构造函数
	Person(Person&& p);
	//析构函数
	~Person();
	//展示信息
	void ShowPerson();
	int m_Age;
	int* m_Height;
};
//默认构造
Person::Person()
{
	cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age, int height)
{
	cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
//拷贝构造函数调用
Person::Person(const Person& p):m_Age(p.m_Age),m_Height(new int (*p.m_Height))
{
	cout << "拷贝构造函数的调用！" << endl;
	/*this->m_Age = p.m_Age;
	this->m_Height = new int(*p.m_Height);*/
}
//移动构造函数
Person::Person(Person&& p)
{
	cout << "移动构造函数的调用！" << endl;
	this->m_Age = p.m_Age;
	this->m_Height = p.m_Height;
	p.m_Height = NULL;
}
//展示信息
void Person::ShowPerson()
{
	cout << "年龄是： " << this->m_Age << endl;
    cout << "身高是： " << *(this->m_Height) << endl;
}
Person::~Person()
{
	cout << "析构函数的掉用！" << endl;
	if (this->m_Height != NULL)
	{
		delete this->m_Height;
	}	
}
//返回一个右值的对象
Person GetPerson()
{
	Person p;
	return p;
}
int main()
{
	Person p;
	p.ShowPerson();
	return 0;
}

发现打错字了，懒得改了！后面有时间总结一下深浅拷贝，虚函数，虚析构等等，到时候再总结吧！以上就是我总结的内容，欢迎大佬指正，谢谢！

移动构造的测试解释 std::move函数可以把左值改成右值，所以测试其代码

#include<iostream>
using namespace std;
class Person
{
public:
	//默认构造函数
	Person();
	//有参构造
	Person(int age, int height);
	//拷贝构造
	Person(const Person& p);
	//移动构造函数
	Person(Person&& p);
	//析构函数
	~Person();
	重载运算符=
	//Person& operator=(Person p);
	//展示信息
	void ShowPerson();
	int m_Age;
	int* m_Height;
};
//默认构造
Person::Person()
{
	cout << "默认构造函数的调用！" << endl;
	this->m_Age = 0;
	this->m_Height = new int(0);
}
//有参构造，把age赋值给m_Age,身高用m_Height指向
Person::Person(int age, int height)
{
	cout << "有参构造函数的调用！" << endl;
	this->m_Age = age;
	this->m_Height = new int(height);
}
//拷贝构造函数调用
Person::Person(const Person& p):m_Age(p.m_Age),m_Height(new int (*p.m_Height))
{
	cout << "拷贝构造函数的调用！" << endl;
	/*this->m_Age = p.m_Age;
	this->m_Height = new int(*p.m_Height);*/
}
//移动构造函数
Person::Person(Person&& p)
{
	cout << "移动构造函数的调用！" << endl;
	this->m_Age = p.m_Age;
	this->m_Height = p.m_Height;
	//delete p.m_Height;
	p.m_Height = nullptr;
}
//重载运算符=
//Person& Person::operator=(Person p)
//{
//	this->m_Age = p.m_Age;
//	this->m_Height = new int(*p.m_Height);
//	return *this;
//}
//展示信息
void Person::ShowPerson()
{
	cout << "年龄是： " << this->m_Age << endl;
    cout << "身高是： " << *(this->m_Height) << endl;
}
Person::~Person()
{
	if (this->m_Height != NULL)
	{
		cout << "析构函数的调用！" << endl;
		delete this->m_Height;
	}	
}
int main()
{
	Person p(18, 180);
	Person p2(move(p));
	return 0;
}

是不是感觉觉得有问题，首先p有参构造，然后move把p变成右值，后调用移动构造函数，在移动构造函数中把p的*m_Height指向空，所以就看不到析构这个的提示了，但是它确实发生了析构，他会有生命周期的结束,就比如把移动构造的NULL用new出一个，它还是会发生析构。这个就不展开了。

 这里查阅了一些资料，主体是学习B站上黑马程序员C++的讲解例子，进行自己总结，并且借鉴了一些csdn大佬上面的一些内容，继续学习，Keep energetic！加油 

东来梁蕴秀
关注
  • 7
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++全局构造与析构底层实现
修炼中的kongkong
07-11 1173
*前一阵儿，被施老师问到C++全局变量是如何构造和析构的。。。？之前看书的时候好像忽略了这个点。。现在补上。。。→_→*
C++构造函数和析构函数的使用与讲解
01-20
构造函数(constructor) 1.构造函数是种特殊的类成员函数，遵循如下规则：      a.函数名与类名必须相同。      b.没有返回值 例如： class Obj { ... public: Obj() { ... } }; 2.构造函数可以带参数，也可以重载 class Obj { ... public: Obj() { ... } Obj(int x, int y) { ... } }; 3.构造函数和普通成员函数不一样，一般不显示调用。在创建一个对象时，构造函数自动调用(编译器来完成
C++ - 带参构造函数，拷贝构造函数
weixin_49303682的博客
08-05 1164
1.带有参数的构造函数 -> 构造函数可以根据需要定义参数。 -> 一个类中可以存在多个重载的构造函数。 -> 构造函数的重载遵循C++重载的规则。 #include <stdio.h> class Test { public: Test() { printf("Test()\n"); } Test(int v) { printf("Test(int v), v = %d\n", v..
C++构造函数与析构函数
weixin_64603510的博客
08-15 929
C++构造函数与析构函数
C++第四次上机实验（构造函数与析构函数）
Desire365的博客
11-16 1547
实验内容： 创建一个Score类，完成一下功能： 连续输入多个学生的float成绩（成绩=科目A成绩+科目B成绩+科目C成绩）； 学生数目可以由用户自定义（默认为2个，最多为100个）； 显示每位同学的每科成绩和平均分； 显示每门科目的平均成绩； 对每门成绩进行排序并由高到低显示； 对整个文件进行打包。 ...
c++ 析构函数定义与实现
gonaYet的博客
07-23 1061
a.h class A {  public: ~A(); }; c.cpp A::~A() { ... }
C++之构造函数与析构函数的使用
共同进步！
11-19 2314
定义一个学生类 Student，学生类中有 3 个私有数据成员：name(姓名)、cls(班级)、grade(年级)；3 个公有成员函数；Student(构造函数)、display、~Student(析构函数)。使用构造函数为 Student 类的对象赋值(name 使用动态内存分配空间)，display 负责显示学生的基本信息，在析构函数中释放动态分配的内存。 在做这题的时候，其中题目要求使用name 使用动态内存分配空间，new运算符使用的一般格式为 new 类型 【初值】;,因为new string(
C++中的有参构造函数
最新发布
qq_41317716的博客
10-22 583
C++中的有参构造函数
深入解析C++中的构造函数和析构函数
12-31
调用构造函数和析构函数的顺序：先构造的后析构，后构造的先折构。它相当于一个栈，先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
C++构造函数和析构函数顺序
12-22
如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是它们在成员初始化表中的顺序。 　2.成员类对象构造函数。如果有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序，而不是...
C++中构造函数和析构函数
09-17
该视频更好介绍C++的构造函数和析构函数
c 语言中析构函数,详解C++编程中的析构函数
weixin_30323179的博客
05-20 1163
C++析构函数创建对象时系统会自动调用构造函数进行初始化工作，同样，销毁对象时系统也会自动调用一个函数来进行清理工作(例如回收创建对象时消耗的各种资源)，这个函数被称为析构函数。析构函数(Destructor)也是一种特殊的成员函数，没有返回值，不需要用户调用，而是在销毁对象时自动执行。与构造函数不同的是，析构函数的名字是在类名前面加一个”~“符号。注意：析构函数没有参数，不能被重载，因此一个类只...
c++的构造函数为什么不能是虚函数，而基类的析构函数必须是虚函数？
热门推荐
gochenguowei的博客
03-24 1万+
构造函数为什么不能是虚函数呢？     首先需要了解 vptr指针和虚函数表的概念，以及这两者的关联。     vptr指针指向虚函数表，执行虚函数的时候，会调用vptr指针指向的虚函数的地址。     当定义一个对象的时候，首先会分配对象内存空间，然后调用构造函数来初始化对象。vptr变量是在构造函数中进行初始化的。又因为执行虚函数需要通过vptr指针来调用。如果可以定义构造函数为虚函数，...
析构函数
爱锻炼的程序员
08-03 567
析构函数
C++ 析构函数
Rp的博客
01-15 1669
C++ 析构函数 析构函数例子1 \qquad 析构函数的主要功能是在创建对象时对对象进行初始化操作。与构造函数不同的是，析构函数一般在程序结束前完成对对象的销毁工作。 \qquad 若一个对象中含有指针数据成员，该指针数据成员指向某一个内存块。通常需要在析构函数中将该指针指向的内存块释放，然后销毁对象。 \qquad 如果程序中的内存在使用完后没有得到释放，就很容易造成内存泄露，会导致应用程序运...
C++ 析构函数
XHumble的博客
04-28 351
析构函数的概念 于构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作 析构函数的作用 清理对象中的资源（从堆上申请的资源，打开的文件） 析构函数的使用 在对象的生命周期结束时，C++编译器会自动调用析构函数，若用户没有显式定义析构函数，则编译器会自动生成默认析构函数，一般情况下在类中不涉及资源的管...
【c++总结-类】一个例子知道类的创建，对象，函数实现，构造函数，析构函数
沸沸腾的专栏
05-14 1032
例子：#include <iostream> using namespace std;class Person { public://类函数和成员函数都是public的，供外界调用 Person();//无参构造函数，如果没有构造函数会自动创建一个无参构造函数 Person(string name, int age);//有参构造函数 ~Person();//析构函数，释放内
C++ 底层分析 2.构造-析构，继承
Mikasys的博客
04-27 249
析构函数（初始） 可以没有，有了必须按照规则用 作用：初始化对象用的，创造对象的时候调用 特点：3个 重载：函数名字一样 参数个数或者类型不一样 析构函数（清理）
C++构造函数基础小结
weixin_43804370的博客
04-06 851
摘要：c++拷贝构造函数的分类整理，以及调用场景
C++中构造函数和析构函数的区别
06-01
构造函数和析构函数是C++中的两个特殊的成员函数，它们在对象的生命周期中分别被调用。 构造函数是在对象创建时被调用，用于初始化对象的数据成员和执行其他必要的操作。它的名称必须与类名相同，没有返回类型，并且可以被重载。 析构函数是在对象销毁时被调用，用于清理对象的资源。它的名称必须与类名相同，并在名称前加上一个波浪号（~），没有返回类型，也不能被重载。 区别在于：构造函数用于对象的初始化，而析构函数用于对象的清理。构造函数在对象创建时自动调用，而析构函数在对象销毁时自动调用。此外，一个类可以有多个构造函数，但只能有一个析构函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值