devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ 构造函数和析构函数 详解_c构造函数和析构函数

作者：盐析白兔 | 2024-04-11 14:30:40

赞

踩

c构造函数和析构函数

目录

概述

C++中用构造函数和析构函数来初始化和清理对象，这两个函数将会被编译器自动调用。对象的初始化和清理是非常重要的，如果我们不提供构造函数与析构函数，编译器会自动提供两个函数的空实现。

构造函数：主要作用于创建函数时对对象成员的属性赋值。
析构函数：主要作用于在对象销毁前，执行一些清理工作（如释放new开辟在堆区的空间）。

主要特点：
构造函数语法：类名(){}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法： ~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号 ~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

其余特点：

  • 构造函数和析构函数是一种特殊的公有成员函数，每一个类都有一个默认的构造函数和析构函数；
  • 构造函数在类定义时由系统自动调用，析构函数在类被销毁时由系统自动调用；
  • 构造函数的名称和类名相同，一个类可以有多个构造函数，只能有一个析构函数。不同的构造函数之间通过参数个数和参数类型来区分；
  • 我们可以在构造函数中给类分配资源，在类的析构函数中释放对应的资源。
  • 如果程序员没有提供构造和析构，系统会默认提供，空实现
  • 构造函数 和 析构函数，必须定义在public里面，才可以调用

简单示例：

#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "调用构造函数" << endl;
	}
	~Person()//对象销毁前，自动调用
	{
		cout << "析构函数的调用" << endl;
	}
};
void test()
{
	//创建对象
	Person  p;//这是一个局部变量，test执行完毕后会释放该对象 进而调用析构函数
}
int main()
{
	Person  p1;//如果在main函数创建对象，析构函数会在按任意键后再调用
	test();
	system("pause");
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

运行结果：
在这里插入图片描述
可以看到该程序先调用对象p1的构造函数，再调用对象p的构造函数和析构函数，而p1的析构函数要在按任意键后再显示，因为p1是main函数的局部变量，将在退出main函数时释放，释放时就会调用p1的析构函数。

构造函数的分类

两种分类方式：

  • 按参数分为： 有参构造和无参构造

  • 按类型分为： 普通构造和拷贝构造

三种调用方式：

  • 括号法（最为常用）

  • 显式法

  • 隐式转换法

对于有参，无参，拷贝三种构造函数对应三种调用方式示例(无参只有一种调用写法)：

#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "调用无参（默认）构造函数" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "调用有参构造函数" << endl;
	}
	//拷贝构造函数用于拷贝传入的类到自身类上 
	//除了拷贝构造函数外都是普通构造函数
	Person(const Person &p)//传入的类不希望被改变所以加const 传入引用用p指向该类
	{
		age = p.age;
		cout << "调用拷贝构造函数" << endl;
	}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
	int age;

};
void test()
{
    //调用
    //1.括号法
	//注意：调用无参构造时不要输入()
	//Person p();会被编译器认为是函数的声明
	Person p;//调用无参构造函数
	Person p1(10);//调用有参函数构造
	Person p2(p1);//调用拷贝构造函数
	cout <<"p1的年龄"<< p1.age << endl;
	cout <<"p2的年龄"<< p2.age << endl;
	
	//2.显式法
	Person p3;//调用无参构造函数
	Person p4=Person (10);//调用有参函数构造
	Person p5=Person (p1);//调用拷贝构造函数
	//Person(10)为匿名对象 等号左侧就是它的名 
	//特点：当前行结束时，系统会立即回收掉匿名对象 即它的析构函数会在该行结束后就调用而不是test函数结束
	
	//3.隐式转换法
	Person p6 = 10; //调用有参函数构造 相当于Person p6=Person(10);  假如有两个参数就是 Person p6 = (10,9);
	Person p7 = p1;//调用拷贝构造函数 相当于Person p7=Person(p1);
}
int main()
{
	test();
	system("pause");
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

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;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

注意创建对象时是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;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

在这里插入图片描述

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;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

在这里插入图片描述

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 p1(18, 175);
	cout << "p1的年龄是： " << p1.m_Age << endl;
	cout << "p1的身高是： " << *(p1.m_Height) << endl;
	Person p2(p1);//将对象p1复制给p2。注意复制和赋值的概念不同 
	cout << "p2的年龄是： " << p2.m_Age << endl;
	cout << "p2的身高是： " << *(p2.m_Height) << endl;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

在这里插入图片描述

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

【思考】
复制(拷贝)构造函数的参数不用const行不行？const起了什么作用
最好是加const，常量左值引用可以接受左值、右值、常量左值、常量右值，而左值引用只能接受左值。
需要拷贝临时对象的时候，比如Integer a(Integer(100)); 没有const的拷贝构造函数将报错。

可参考 https://blog.csdn.net/jiaojinlin/article/details/124744513

5. 移动构造函数

该部分介绍篇幅不小，请移步另一篇文章有详细介绍：C++ 移动构造函数详解

构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#include<iostream>
using namespace std;
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;
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

析构函数

析构函数是用于在对象被删除之前的清理工作，在对象生命周期即将结束时被自动调用。(析构函数可以清理对象并且释放内存)
析构函数 ~加上类名() 进行操作，目的时清空数据，释放内存。
下面举一个示例：创建一个默认构造函数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;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

在这里插入图片描述
【参考鸣谢】
https://blog.csdn.net/qq_44768163/article/details/114661958
https://blog.csdn.net/hbbfvv1h/article/details/115371496
https://blog.csdn.net/m0_61973596/article/details/123458069 【优质】
https://blog.csdn.net/qqyuanhao163/article/details/101396233
https://blog.csdn.net/weixin_39270987/article/details/116306065

https://blog.csdn.net/zyq11223/article/details/48766515#
https://blog.csdn.net/u014201706/article/details/103032246
https://blog.csdn.net/qq_34170700/article/details/107214554
https://blog.csdn.net/yi_chengyu/article/details/120775215

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/405518
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号