C++之构造函数与析构函数

最新推荐文章于 2024-04-12 09:01:59 发布
最新推荐文章于 2024-04-12 09:01:59 发布
阅读量317 收藏
点赞数
分类专栏： Java、C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H_A666/article/details/117391510
版权

构造函数

所谓构造函数就是跟类名相同的函数，可以带有参数也可以不带参数。可以通过参数的不用，来区分调用哪个构造函数

类的构造方法的概念和作用：

  • 构造方法负责对象初始化工作，为对象属性赋合适的初始值
  • 创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行

构造方法的语法规则：

  • 构造函数名和类名一致
  • 没有返回类型
  • 方式实现主要为字段赋值

demo

#include <iostream>

using namespace std;

class Person{
	char *name;
	int age;
	char *work;

public:
	Person(){
		cout<<"Person()"<<endl;
	}

	Person(char* name, int age, char* work = "none"){
		cout<<"Person(char*, int)"<<endl;
		this->name = name;
		this->age = age;
		this->work = work;
	}

	void printfInfo(){
		cout<<"work = "<<work<<" name = "<<name<<" age = "<<age<<endl;
	}
};

int main(int argv, char** argc)
{
	Person per("zhangsan",18);
	Person per1;	//这是调用没有参数的构造体
	Person per2();	//这是定义一个函数，Person型的函数，相当于int fun();
	per.printfInfo();
}

程序结果

Person(char*, int)
Person()
work = none name = zhangsan age = 18

在C++中，可以通过指针实例化类，程序结束后，指针会被自动释放。如果你想要手动释放的话，可以使用delete命令。

demo

#include <iostream>

using namespace std;

class Person{
	char *name;
	int age;
	char *work;

public:
	Person(){
		cout<<"Person()"<<endl;
	}

	Person(char* name, int age, char* work = NULL){
		cout<<"Person(char*, int)"<<endl;
		this->name = name;
		this->age = age;
	}

	void printfInfo(){
		cout<<"work = "<<work<<" name = "<<name<<" age = "<<age<<endl;
	}
};

int main(int argv, char** argc)
{
	Person per("zhangsan",18);
	Person per1;	//这是定义没有参数的构造体
	Person per2();	//这是定义一个函数，Person型的函数

	/*通过指针实例化类*/

	/*以下两种实例方法是等同的，都是调用没有参数的构造体*/
	Person *per3 = new Person;
	Person *per4 = new Person();

	Person *per5 = new Person[2];//也可以定义成数组

	Person *per6 = new Person("lisi", 16, "student");//也可以添加参数

	/*程序结束后，指针会被自动释放，如果像手动释放的话用以下方法*/

	delete per3;
	delete []per5;//释放数组的方法

	per6->printfInfo();
	
	per.printfInfo();
}

程序结果：

Person(char*, int)
Person()
Person()
Person()
Person()
Person()
Person(char*, int)

在main函数中用new函数开辟的空间，会自动释放内存。但是在构造函数中利用new函数开辟了一个堆空间和子程序中的开辟空间需要我们自己释放。如果不释放则会占用我们的内存。

demo

#include <iostream>
#include <string.h>
#include <unistd.h>


using namespace std;

class Person{
	char *name;
	int age;
	char *work;

public:
	Person(){
		cout<<"Person()"<<endl;
	}

	Person(char* name){
		//cout<<"Person(char*, int)"<<endl;
		
		/*在构造函数中利用new函数开辟了一个堆空间需要我们自己释放*/
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);//将参数名字放入开辟的空间之内

		this->work = NULL;//没有work这个参数，要赋值一个null给他，否则析构函数中会出现段错误
	}

	Person(char* name, int age, char* work = "none"){
	//	cout<<"Person(char*, int)"<<endl;
		
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);
		
		this->work = new char[strlen(work)+1];
		strcpy(this->work,work);
		
		this->age = age;
	}
 
	void printfInfo(){
		cout<<" name = "<<name<<" age = "<<age<<endl;
	}
};

int testFun()
{
	Person per("zhangsan",18);

	Person *per6 = new Person("lisi", 16, "student");//子程序中的空间需要我们自己释放
	delete per6;
}

int main()
{
	int i;
	for(i = 0; i < 100000; i++)
		testFun();//在执行该函数的时候一直在消耗空间内存，并没有去释放构造函数中new出来的空间
	sleep(10);
	return 0;
}

可以通过free命令查看当前空闲内存空间的大小。

free -m #-m是指输出的信息以兆为单位；

从以下可以看出，在运行过程中会占用内存空间。

book@100ask:~$ free -m//运行前
              total        used        free      shared  buff/cache   available
Mem:           1959        1129         350          15         479         642
Swap:          8581         171        8410
book@100ask:~$ free -m//运行时
              total        used        free      shared  buff/cache   available
Mem:           1959        1144         335          15         479         627
Swap:          8581         171        8410
book@100ask:~$ free -m//运行后
              total        used        free      shared  buff/cache   available
Mem:           1959        1129         350          15         479         642
Swap:          8581         171        8410
book@100ask:~$

那怎么去释放构造函数中的内存空间呢？有两种方法：

第一种方法就是在引入一个人free函数去释放空间，在free函数中去delete掉开辟的空间，然后再在子程序中调用free函数就可以了。但是这种方法非常麻烦，看起来也不高级。

第二种方法就是引入析构函数，那么什么是析构函数呢？

析构函数

析构函数：是一个特殊的成员函数，它的作用与构造函数相反，它的名字是类名的前面加一个“～”符号。

析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作，使这部分内存可以被程序分配给新对象使用。程序设计者事先设计好析构函数，以完成所需的功能，只要对象的生命期结束，程序就自动执行析构函数来完成这些工作。

注意：析构函数不返回任何值，没有函数类型，也没有函数参数。因此它不能被重载。一个类可以有多个构造函数，但只能有一个析构函数。

demo

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person{
 	char *name;
 	int age;
	char *work;

public:
	Person(){
		cout<<"Person()"<<endl;
	}

	Person(char* name){
		cout<<"Person(char*)"<<endl;
		
		/*开辟一个空间储存名字，但是子程序中的空间需要我们自己释放*/
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);//将参数名字放入开辟的空间之内

		this->work = NULL;//没有work这个参数，要赋值一个null给他，否则析构函数中会出现段错误
	}

	Person(char* name, int age, char* work = "none"){
		cout<<"Person(char*, int)"<<endl;
		
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);
		
		this->work = new char[strlen(work)+1];
		strcpy(this->work,work);
		
		this->age = age;
	}

	~Person(){//析构函数，有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
		if(this->name){
			cout<<"name ="<<name<<endl;
			delete this->name;
		}
		if(this->work){
			cout<<"work ="<<work<<endl;
			delete this->work;
		}
	}

	void printfInfo(){
		cout<<" name = "<<name<<" age = "<<age<<endl;
	}
};

int testFun()
{
	Person per("zhangsan",18);
	Person *per6 = new Person("lisi", 16, "student");//也可以添加参数
	delete per6;//手动释放空间
}

int main()
{
	testFun();
	sleep(10);
	return 0;
}

程序结果：从结果可以看出，当testFun()函数执行完之后，系统会自动调用析构函数，释放内存空间。而在testFun()利用new实例化的对象则需要手动调用delete释放空间，否则testFun()函数执行完成之后也不会调用析构函数释放该空间，只能等到程序结束之后系统来释放。

Person(char*, int)
Person(char*, int)
~Person()
name =lisi
work =student
~Person()
name =zhangsan
work =none

内存空闲空间可以看出，调用析构函数之后，就没有占用内存空间了。

book@100ask:~$ free -m  #运行前
              total        used        free      shared  buff/cache   available
Mem:           1959        1126         370          15         461         645
Swap:          8581         171        8410
book@100ask:~$ free -m  #运行中
              total        used        free      shared  buff/cache   available
Mem:           1959        1126         370          15         462         645
Swap:          8581         171        8410
book@100ask:~$ free -m  #运行后
              total        used        free      shared  buff/cache   available
Mem:           1959        1126         371          15         462         646
Swap:          8581         171        8410
book@100ask:~$

具体地说如果出现以下几种情况，程序就会执行析构函数：

①如果在一个函数中定义了一个对象(它是自动局部对象)，当这个函数被调用结束时，对象应该释放，在对象释放前自动执行析构函数。
②static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。
③如果定义了一个全局对象，则在程序的流程离开其作用域时(如main函数结束或调用exit函数) 时，调用该全局对象的析构函数。
④如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。

拷贝函数

Person per("zhangsan", 18, "teacher");

/*打印的与per内容一致，会调用默认的拷贝函数*/
Person per1(per);//值拷贝，有一个隐患，会对同一个空间释放两次，不建议默认调用拷贝构造函数
//可以利用引用拷贝，解决该隐患

可以使用拷贝函数解决一个空间被释放两次的隐患。

拷贝函数原型：

Person(Person &per){//拷贝函数,这样就不.会对同一个地址析构两次
		cout<<"Person(Person &)"<<endl;
		
		this->name = new char[strlen(per.name)+1];
		strcpy(this->name,per.name);
		
		this->work = new char[strlen(per.work)+1];
		strcpy(this->work,per.work);
		
		this->age = per.age;
	}

构造函数被调用的顺序

demo

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person{
	char *name;
	int age;
	char *work;

public:
	Person(){
		name = NULL;
		work = NULL;
	}

	Person(char* name){
		/*开辟一个空间储存名字，但是子程序中的空间需要我们自己释放*/
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);//将参数名字放入开辟的空间之内

		this->work = NULL;//没有work这个参数，要赋值一个null给他，否则析构函数中会出现段错误
	}

	Person(char* name, int age, char* work = "none"){
		cout<<"Person(char*, int)"<<endl;
		
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);
		
		this->work = new char[strlen(work)+1];
		strcpy(this->work,work);
		
		this->age = age;

		printfInfo();
	}

	Person(Person &per){//拷贝函数
		cout<<"Person(Person &)"<<endl;
		
		this->name = new char[strlen(per.name)+1];
		strcpy(this->name,per.name);
		
		this->work = new char[strlen(per.work)+1];
		strcpy(this->work,per.work);
		
		this->age = per.age;
	}

	~Person(){//析构函数，有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
		cout<<"~Person()"<<endl;
		if(this->name){
			cout<<"name ="<<name<<endl;
			delete this->name;
		}
		if(this->work){
			cout<<"work ="<<work<<endl;
			delete this->work;
		}
	}
	
	void printfInfo(){
		cout<<" name = "<<name<<" age = "<<age<<"work = "<<work<<endl;
	}
};

Person per_g("per_g",10); 

void per_func()
{
	Person per_func("per_func",11);
	static Person per_func_s("per_func_s",12);
}

int main(int argc, char** argv)
{
	Person per_main("per_main", 13);
	static Person per_main_s("per_main_s", 14);
	
	for(int i=0; i<2; i++){
		per_func();
		Person per_for("per_for",i);
	}
	return 0;
}

程序结果：
析构函数不会销毁static类型的实例化对象开辟的空间。所以static类型的实例化对象只会被调用一次。
构造顺序：按运行中定义对象的顺序调用构造函数 ，全局对象在main函数执行前被调用。

Person(char*, int)
 name = per_g age = 10work = none
Person(char*, int)
 name = per_main age = 13work = none
Person(char*, int)
 name = per_main_s age = 14work = none
Person(char*, int)
 name = per_func age = 11work = none
Person(char*, int)
 name = per_func_s age = 12work = none
~Person()
name =per_func
work =none
Person(char*, int)
 name = per_for age = 0work = none
~Person()
name =per_for
work =none
Person(char*, int)
 name = per_func age = 11work = none
~Person()
name =per_func
work =none
Person(char*, int)
 name = per_for age = 1work = none
~Person()
name =per_for
work =none
~Person()
name =per_main
work =none
~Person()
name =per_func_s
work =none
~Person()
name =per_main_s
work =none
~Person()
name =per_g
work =none

在一个类中调用另一个类

要调用对象成员的其他构造函数，可以这样写：

class Student{
private:
    person id;
public:        
    Student（int sid）:id(sid){}
}

构造函数的“{}”前加上“：”，加上成员的初始化代码。
对象成员：定义时的构造顺序与上述初始化顺序无关。

demo

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person{
	char *name;
	int age;
	char *work;

public:
	Person(){
		name = NULL;
		work = NULL;
	}

	Person(char* name){
		/*开辟一个空间储存名字，但是子程序中的空间需要我们自己释放*/
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);//将参数名字放入开辟的空间之内

		this->work = NULL;//没有work这个参数，要赋值一个null给他，否则析构函数中会出现段错误
	}

	Person(char* name, int age, char* work = "none"){
		cout<<"Person(char*, int)"<<endl;
		
		this->name = new char[strlen(name)+1];
		strcpy(this->name,name);
		
		this->work = new char[strlen(work)+1];
		strcpy(this->work,work);
		
		this->age = age;

		printfInfo();
	}

	Person(Person &per){//拷贝函数
		cout<<"Person(Person &)"<<endl;
		
		this->name = new char[strlen(per.name)+1];
		strcpy(this->name,per.name);
		
		this->work = new char[strlen(per.work)+1];
		strcpy(this->work,per.work);
		
		this->age = per.age;
	}

	~Person(){//析构函数，有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
		cout<<"~Person()"<<endl;
		if(this->name){
			cout<<"name ="<<name<<endl;
			delete this->name;
		}
		if(this->work){
			cout<<"work ="<<work<<endl;
			delete this->work;
		}
	}
	

	void printfInfo(){
		cout<<" name = "<<name<<" age = "<<age<<"work = "<<work<<endl;
	}
};

class Student{
private:
	Person father;
	Person mother;
	int student_id;

public:

	Student(){//当你提供了一个有参数的构造函数时，默认的无参构造函数就会消失，必须设置一个无参数的构造函数，这样才不会报错
		
	}
	
	Student(int id, char* father, char* mother, int father_age = 40, int mother_age = 39) : father(father,father_age), mother(mother,mother_age)
	{
		cout<<"Studen(int id, char* father, char* mother, int father_age = 40, int mother_age = 39)"<<endl;
	}

	~Student(){//析构函数的执行顺序与构造函数执行顺序相反
		cout<<"~Student()"<<endl;
	}
};

int main(int argc, char** argv)
{
	Student s(100, "bill", "lily");//调用构造函数
}

程序结果：由程序结果可以得出，调用构造函数的顺序与实例化对象的顺序有关。析构函数的执行顺序与构造函数执行顺序相反。

Person(char*, int)
 name = bill age = 40work = none
Person(char*, int)
 name = lily age = 39work = none
Studen(int id, char* father, char* mother, int father_age = 40, int mother_age = 39)
~Student()
~Person()
name =lily
work =none
~Person()
name =bill
work =none
你笑一笑嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中构造函数与析构函数的调用顺序详解
12-31
在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。 简单来说，其构造函数...
C++内存管理
itxiaobaiiii的博客
05-27 181
内存分布 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共 享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下） 堆用于程序运行时动态内存分配，堆是可以上增长的。 数据段–存储全局数据和静态数据。 代码段–可执行的代码/只读常量。 使用realloc对malloc创建的空间进行扩展时会自动把malloc申请的空间释放掉，只需要释放realloc申请的空间。 calloc在申
面试题之C++理论
ccsu_deer
06-20 1031
1、static与const的区别 1、Const修饰函数的参数时，在这个函数内这个参数不可修改 2Const定义的变量，不可修改 3、static在类中修饰的变量时，实例化这个类时这个变量只会被实例化一次，多个对象共用一个这个变量地址，对类的所有对象只有一份拷贝 4、static修饰的函数内只能调用static修饰的变量，不接受this指针 5、在一个.c文件内static定义的全局变量，在其他.c文件内就会被隐藏， 6、声明常量指针和指针常量(不可指向其他地址)，const在前不改地址内容
函数内部new申请的内存需要手动释放
最新发布
potential_lion的博客
04-12 181
内存泄漏是指程序在运行过程中不断分配内存而不释放，最终导致系统的可用内存不断减少，直至耗尽。函数结束时，函数内部的局部变量会被销毁，但如果这些局部变量指向动态分配的内存，并没有被释放，那么内存就会泄漏。在实际应用中，如果内存泄漏问题严重，可能会导致程序运行速度变慢，资源消耗增加，甚至使得系统无法正常工作。C++中的内存管理是由程序员负责的，如果在函数内部使用。分配的内存，也需要在适当的时候手动释放，否则就会导致内存泄漏问题。这个不是在函数内部new的吗，函数结束后不会自动释放吗。
C++如果new 一片内存空间但是不释放的话会怎么样呢？
m0_56350559的博客
05-17 1064
RAII，内存泄漏，new和delete
C++ 智能指针
qq_41902325的博客
06-27 354
一 什么是智能指针 由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏，智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。 例如在函数中new申请空间之后，会调用dele
c++多态性，指针释放new的空间
燃犀的博客
07-07 1639
父类释放子类new的空间
c++基础语法:构造函数与析构函数
09-05
构造函数用来构造一个对象，主要完成一些初始化工作，如果类中不提供构造函数，编译器会默认的提供一个默认构造函数(参数为空的构造函数就是默认...析构函数是隐式调用的，delete对象时候会自动调用完成对象的清理工作
C++的全局构造与析构函数
01-20
即C++ 的全局对象构造函数在main 函数之前执行，而C++ 全局对象的析构函数在main函数之后被执行。 　Linux系统中，一般程序的入口是“ _start ， 这个函数是Linux系统库(Glibc)的一部分。当我们的程序与Glibc库链接...
C++语法详解之封装、构造函数、析构函数
12-20
大家先了解下什么是构造函数，什么是析构函数，作用是什么？...下面在通过具体例子看下C++语法详解之封装、构造函数、析构函数。 成员变量私有化，提供公共的getter和setter给外界去访问成员变量 c
c++构造函数和析构函数
weixin_39270987的博客
04-30 9648
一、构造函数和析构函数的特点 构造函数和析构函数是一种特殊的公有成员函数，每一个类都有一个默认的构造函数和析构函数； 构造函数在类定义时由系统自动调用，析构函数在类被销毁时由系统自动调用； 构造函数的名称和类名相同，一个类可以有多个构造函数，只能有一个析构函数。不同的构造函数之间通过参数个数和参数类型来区分； 我们可以在构造函数中给类分配资源，在类的析构函数中释放对应的资源。 二、不带参数的构造函数 C++类在创建时，系统会默认创建一个不带参数的构造函数，我们可以重新定义这个构造函数。默认构造函数在类被
c++ 构造函数与析构函数(详解)
2201_75964502的博客
10-27 585
超详解c++构造函数与析构函数(含图片与代码)
C++ 构造函数与析构函数
2201_75772333的博客
05-03 1205
这可能会导致问题，例如，当一个对象被删除时，其析构函数可能会删除共享的内存，从而使另一个对象的指针变为悬挂指针。但是，如果类有指向动态分配内存的指针成员，或者包含需要特殊处理的资源（如文件句柄，网络连接等），那么通常需要提供自定义的拷贝构造函数以执行深拷贝。：当我们执行深拷贝时，不仅复制对象的所有非静态成员变量，还会为每个动态内存分配的指针成员创建新的内存复制，确保新对象获得的是原始对象数据的全新副本，而不是引用同一内存。在 C++ 中，构造函数是一种特殊的成员函数，它会在创建类的新对象时自动被调用。
C++构造函数和析构函数
qq_63976098的博客
12-24 838
C++构造函数，析构函数；复制构造函数；拷贝构造函数；构造，析构的先后顺序
对象的动态建立和释放
weixin_33725515的博客
09-06 524
我们知道可以用new运算符可以动态的分配内存，用delete运算符可以释放这些内存。 当我们使用new运算符动态的分配一个内存之后，会自动返回一个该内存段的起始地址，也就是指针。 =============下面先给出一个new和delete基本应用的例子，回顾一下它的基本用法============ #include<iostream> using namespace...
C++篇----构造函数和析构函数
m0_67768006的博客
04-27 2573
构造函数和析构函数
【C++】构造函数与析构函数
明朗晨光的专栏
11-01 4241
C++构造函数和析构函数
在C++中构造函数与析构函数的知识点
06-03
3. 如果没有定义析构函数，编译器会自动生成一个默认的析构函数。默认析构函数不执行任何操作，只是释放对象占用的内存空间。 4. 析构函数可以进行一些清理操作，如关闭文件，释放内存等。 5. 在类中定义了构造...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值