C++构造和析构

最新推荐文章于 2025-03-16 23:15:19 发布
最新推荐文章于 2025-03-16 23:15:19 发布
阅读量675 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言 visualstudio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_59969777/article/details/125873580
版权
本文详细介绍了C++中的构造函数、析构函数、拷贝构造函数和深浅拷贝问题。强调了构造函数在对象初始化中的作用，析构函数在释放动态内存时的必要性，以及如何处理深浅拷贝可能导致的问题。同时，文章还讨论了构造委托以避免无参构造时的数据未初始化，以及匿名对象的构造和析构顺序。通过对实例的分析，读者可以更好地理解C++中对象生命周期的管理及其对内存的影响。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

C++构造和析构

构造函数

  • 名字和类名相同
  • 没有返回值
  • 构造函数是用来构造对象，构造对象时候必定调用构造函数
  • 不写构造函数，存在一个默认的构造函数，默认的构造函数是无参，所以可以构造无参对象
  • 默认的构造函数可以删掉，通过delete删除默认的构造函数
  • 显示使用默认的构造函数, 通过default做显示调用
  • 通常情况构造函数是public属性
  • 自己写了构造函数，默认的构造函数就不存在了
  • 构造函数决定对象的长相(构造函数无参，对象无参，构造有一个，对象必须也要一个参数)
  • 构造函数通常做的事情，就是给数据成员初始化
  • 构造函数也是函数，所以也可以重载，也可以缺省
    。通过重载和缺省，实现构造不同长相对象
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
	//MM() = default;		//显式使用默认的构造函数
	//MM() = delete;			//删掉默认的构造函数
	MM(string name, int age)
	{
		m_name = name;
		m_age = age;
		cout << "两个参数的构造函数" << endl;
	}
	MM() = default;   //默认无参构造函数，据说速度更快
	void printMM() 
	{
		cout << m_name << "\t" << m_age << endl;
	}
protected:
	string m_name;
	int m_age;
};
//MM::MM() 
//{
//	cout << "调用无参构造函数" << endl;
//}
struct Boy 
{
	string name;
	int age;
	int num;
    //一旦C++结构体中写了构造函数，必须当做类去操作，不能用C语言的那种方式使用
	Boy() {}
	Boy(string bname, int bage) 
	{
		name = bname;
		age = bage;
	}
};
void testStruct() 
{
	//Boy boy = { "string",18,1001};   //错误
	//这个地方也是创建对象过程，所以数据也需要和构造函数
	Boy boy = { "string",18};  //这里数据必须和构造函数的一致
	Boy boy2;
	Boy array[3];
}
int main() 
{
	//MM mm;				//因为构造函数有两个参数，对象也必须带有两参数
	MM mm("对象", 18);		//这步创建对象的过程就是调用构造函数构造函数的过程
	mm.printMM();
	MM empty;				//调用无参构造函数

	//new一个对象
	MM* p = new MM;					//调用无参的构造函数
	MM* p2 = new MM("对象", 29);		//调用有参的构造函数


	return 0;
}

构造委托

构造委托可以叫做委托构造，允许一个构造函数调用另一个构造函数，主要是为了避免无参构造时候数据未初始化

只能采用初始化参数列表方式调用另一个构造函数。

#include <string>
#include <iostream>
using namespace std;
class MM 
{
public:
	//构造委托
	MM():MM("mm",18) {}
	MM(string name, int age) :name(name), age(age) 
	{
	}
	void print() 
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main() 
{
	MM mm;
	mm.print();
	return 0;
}

析构函数

  • ~类名 当做析构函数名字
  • 没有参数
  • 释放数据成员new的内存
    。在对象死亡前自动调用
    。通常如果数据成员没有做new操作，就可以不写析构函数
  • 不写析构函数，存在一个默认的析构函数
#include <iostream>
#include <cstring>
using namespace std;
class MM 
{
public:
	MM(const char* str="ILoveyou")        //缺省 相当于存在两个构造函数，一个是无参的，一个是有参
	{
		int length = strlen(str) + 1;
		name = new char[length];
		strcpy_s(name, length, str);
	}
	~MM();
protected:
	char* name;
};
MM::~MM() 
{
	if (name != nullptr) 
	{
		delete[] name;
		name = nullptr;
	}
	cout << "析构函数....\n" << endl;
}
int main() 
{
	{
		MM mm;
		MM* p = new MM;
		cout << "1......" << endl;
		delete p;			//立刻调用析构函数
		p = nullptr;
		cout << "2......." << endl;
	}
	{
		MM beauty("Continue");
	}
	cout << "对象死亡" << endl;
	return 0;
}

拷贝构造函数

  • 拷贝构造函数也是构造函数
  • 拷贝构造函数参数是固定的:对对象的引用
  • 拷贝构造函数不写会存在一个默认的拷贝构造函数
  • 拷贝构造函数作用： 通过一个对象产生另一个对象
    。关键点：一定是有一个新的对象产生
#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM() {}
	MM(string name, int age) 
	{
		m_name = name;
		m_age = age;
	}
	MM(MM& object);
	void printMM() 
	{
		cout << m_name << "\t" << m_age << endl;
	}
protected:
	string m_name;
	int m_age;
};
//拷贝构造函数
//通过传入对象属性确定创建对象的属性
MM::MM(MM& object)
{
	m_name = object.m_name;
	m_age = object.m_age;
	cout << "调用自己写的拷贝构造函数" << endl;
}

//函数传参也可以隐式调用
void print(MM object)		//MM object=girl
{
	object.printMM();
}
//C++中传参能用引用就用，效率搞
void printData(MM& object) //引用就是别名，没有产生新的对象
{
	object.printMM();
}
int main() 
{
	MM mm("C神", 18);
	//产生一个对象
	MM beauty = mm;			//隐式调用拷贝构造函数
	MM girl(beauty);		//显式调用拷贝构造函数
	print(girl);			//调用拷贝构造函数
	printData(girl);
	MM boy;
	//对象先有了，才赋值，不调用拷贝
	boy = girl;				//不调用拷贝构造函数-->默认重载=运算符(后续会讲)

	return 0;
}

深浅拷贝问题

浅拷贝

  • 没有在拷贝构造函数中给数据成员做new操作
  • 默认拷贝构造函数都是浅拷贝

深拷贝

  • 在拷贝构造函数中做了new操作

浅拷贝导致内存释放问题

浅拷贝会导致同一段内存重复释放问题

#include <iostream>
#include <cstring>
using namespace std;
class MM 
{
public:
	MM() {}
	MM(const char* str) 
	{
		int length = strlen(str) + 1;
		name = new char[length];
		strcpy_s(name, length, str);
	}
	~MM() 
	{
		if (name != nullptr) 
		{
			delete[] name;
			name = nullptr;
		}
	}
private:
	char* name;
};
int main() 
{
	{
		MM girl("girl");
		MM mm = girl;			//调用拷贝构造函数
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述

深拷贝解决方案

#include <iostream>
#include <cstring>
using namespace std;
class MM 
{
public:
	MM() {}
	MM(const char* str) 
	{
		int length = strlen(str) + 1;
		name = new char[length];
		strcpy_s(name, length, str);
	}
	MM(MM& object) 
	{
		//name = object.name;
		int length = strlen(object.name) + 1;
		name = new char[length];
		strcpy_s(name, length, object.name);
	}
	~MM() 
	{
		if (name != nullptr) 
		{
			delete[] name;
			name = nullptr;
		}
	}
private:
	char* name;
};
int main() 
{
	{
		MM girl("girl");
		MM mm = girl;			//调用拷贝构造函数
	}
	return 0;
}

在这里插入图片描述
综上： 一旦类中有指针，做了内存申请，并且要对对象做拷贝操作，就必须使用深拷贝

匿名对象

匿名对象就是无名对象，匿名对象只能充当右值，所以匿名对象拷贝必须存在移动拷贝，或者准备一个ecosnt限定普通拷贝构造函数。

#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM() {};
	MM(string name, int age) 
	{
		m_name = name;
		m_age = age;
	}
	void printMM() 
	{
		cout << m_name << "\t" << m_age << endl;
	}
	MM(MM& object) 
	{
		m_name = object.m_name;
		m_age = object.m_age;
	}
	//移动构造--->新标准的
	MM(MM&& object)					
	{
		m_name = object.m_name;
		m_age = object.m_age;
		cout << "调用移动构造" << endl;
	}
	~MM() 
	{
		cout << "析构打印name:" << m_name << endl;
	}
private:
	string m_name;
	int m_age;
};
MM returnMM(string name, int age) 
{
	return MM(name, age);   //构造一个匿名对象当做函数返回值
}
int main() 
{

	{
		MM girl("girl", 19);
		//匿名对象是一个右值
		MM mm=MM("mm", 29);  //匿名对象  --->匿名对象转正 ，mm接管所有权
		cout << "匿名对象已死亡" << endl;
	}
	MM beauty = returnMM("返回值", 18);
	beauty.printMM();

	return 0;
}

构造和析构顺序问题

  • 一般情况构造顺序和析构是相反的
  • 静态的和全局的是最后释放的
  • delete 立刻调用析构函数
#include <iostream>
#include <string>
using namespace std;
class Test 
{
public:
	Test(string data="A")
	{
		m_data = data;
		cout << m_data;
	}
	~Test() 
	{
		cout << m_data;
	}
protected:
	string m_data;
};

int main() 
{
	{
		Test t1;					//A
		static Test t2("B");		//B
		Test array[3];				//AAA   //数组就是多个无参
		Test* p = new Test("C");	//C
		delete p;					//C
		p = nullptr;
	}
	//ABAAACCAAAAB
	return 0;
}

小试牛刀

//用构造函数的方式实现单链表
//构造函数创建节点
//构造函数做表头法插入
//加个遍历链表的操作即可
#include <iostream>
using namespace std;
struct Node
{
	int data;
	Node* next;
	Node() :next(nullptr) {}
	Node(int data) :data(data), next(nullptr) {}
	Node(int data, Node* next) :data(data), next(next) {}
};
class List
{
public:
	List();
	void insertData(int data);
	void printList() 
	{
		Node* pmove = headNode->next;
		while (pmove != nullptr)
		{
			cout << pmove->data << " ";
			pmove = pmove->next;
		}
		cout << endl;
	}
private:
	Node* headNode;

};
List::List() 
{
	headNode = new Node;
}
void List::insertData(int data)
{
	headNode->next = new Node(data, headNode->next);
}

int main() 
{
	List list;
	list.insertData(1);
	list.insertData(2);
	list.insertData(3);
	list.printList();
	return 0;
}
C++构造和析构函数的执行顺序
DplaAnaconda的博客
09-20 354
构造函数按照基类构造函数、成员对象构造函数和派生类构造函数的顺序执行，而析构函数按照派生类析构函数、成员对象析构函数和基类析构函数的顺序执行。C++构造函数与析构函数的执行顺序。构造函数按照基类构造函数、成员对象构造函数和派生类构造函数的顺序执行，而析构函数按照派生类析构函数、成员对象析构函数和基类析构函数的顺序执行。从输出结果可以看出，先执行基类的构造函数，然后是成员对象的构造函数，最后执行派生类的构造函数。从输出结果可以看出，先执行基类的构造函数，然后是成员对象的构造函数，最后执行派生类的构造函数。
C++构造和析构函数知识点总结
Kroner的博客
10-20 719
前言：创建一个对象时，常常需要作某些初始化的工作，例如对数据成员赋初值。注意，类的数据成员是不能在声明类时初始化的。 为了解决这个问题，C++编译器提供了构造函数(constructor)来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。 ...
C++ 构造和析构
小喇叭儿滴滴的吹
08-04 646
啥是构造和析构，下面我们还是从C语言的角度来学习C++，简述构造和析构语法的设计由来。 先看如下代码： struct Test { int a; int b; }; int main() { Test test; test.a = 5; test.b = 7; printf("%d %d",test.a,test.b); return...
C++构造和析构函数
qq_54492880的博客
11-20 1636
一、构造函数 1.构造函数的样子 (1).函数名和类名相同 (2).没有返回值 class Person { public: Person(){}//构造函数--->没有返回值 protected: string name; int age; }; 注：如果不写构造函数，任何类中都存在一个默认构造函数 2.默认构造函数的特点 (1).默认...
C++|构造函数和析构函数
最新发布
duxinran的博客
03-16 1299
在C++11中允许在类定义时对成员变量初始化。class Apublic:A(){ }private://类定义时初始化int m_b;//没有初始化int main()A a;a.show();return 0;如果在构造函数中也有赋值,以赋值的为准,这个就和普通变量一样,初始化的值会被后面的赋值覆盖。
C/C++中结构Struct是不是也有构造函数和析构函数，那它与类的区别是什么？
Jeff_的博客
11-16 6368
C里面没有，C++里面有 C++里根本就没有结构,仅仅为了兼容c才有结构这种东西,实际上除了名字以外,C++的结构就是类!! 如果从空间分配上来看，struct变量放在栈上，而class变量放在堆上，因此struct变量会自动释放，而class变量需要手动释放。 c不是面向对象的语言，没有继承等概念。 在C++中，struct和class没啥两样，只是struct默认是public，cla......
c++构造与析构
uGamemaster的博客
03-06 324
一、构造函数： c++类所定义的对象初始化方式：构造函数： 实现方式：在类中定义构造函数， 形式： 类名(){对类中成员变量的初始化内容} 其中： （1）构造函数可以既可以给予形参也可以无形参。例：** class A{ public: A(){a = 8;}; void show(){cout<<a<<endl;}; private: int a; }; //或者可...
如何写出合格的C++构造和析构函数
hebhljdx的博客
07-03 963
笔者曾经在团队中发现有人在构造函数中读取文件配置，导致界面创建速度降低了一个数量级。由此引发笔者想讨论如何写一个合格的构造和析构函数文章的想法。
C++构造和析构的多态
02-16
### C++构造和析构中的多态实现 在C++编程语言中，多态是一种重要的特性，它允许程序员编写能够处理不同数据类型的代码。多态的实现通常依赖于虚函数和虚函数表（vtable）。然而，在构造函数和析构函数中调用虚函数...
C++构造函数和析构函数
曾梦想仗剑走天涯
12-26 2668
（1）构造函数、析构函数与赋值函数构造函数、析构函数与赋值函数是每个类最基本的函数。它们太普通以致让人容易麻痹大意，其实这些貌似简单的函数就象没有顶盖的下水道那样危险。每个类只有一个析构函数和一个赋值函数，但可以有多个构造函数（包含一个拷贝构造函数，其它的称为普通构造函数）。对于任意一个类A，如果不想编写上述函数，C++编译器将自动为A 产生四个缺省的函数，例如：A(void);
C++ 构造与析构
good good study, day day up!
07-27 821
C++中的构造与析构、构造函数、析构函数、拷贝构造、explicit关键字、显示调用、隐式调用
浅析c++中的结构体struct
qq_45952745的博客
02-27 2135
在表示某些结构化数据时，我们通常会使用数组来解决问题。可是由于信息比较松散、容易重名、数据存取不方便等原因，当所用数据过多时，那么使用数组解决问题便不是那么的方便了。此时，最好有一种新的数据类型，直接表示该问题的所有属性，结构体便应需而生。 什么是结构体？ 由一系列具有相同类型或不同类型的数据构成的数据集合，叫做结构体(struct)。 结构由数目固定的成员构成； 各成员可以具有不同的数据类型； ...
原来C++中struct也有构造函数与析构函数，也可以有访问类型控制
aqns80581的博客
10-13 329
原来C++中struct也有构造函数与析构函数，也可以有访问类型控制，可以用private关键字。如下所示： #include<iostream> #include<ostream> struct point { public: point():x_(0.0),y_(0.0) { std::cout<<"d...
C++——构造析构
新手的博客
04-19 207
通过学习构造析构函数来完成对对象数据成员进行初始化和清理工作 一、构造函数 1.知识点介绍 构造函数：它是一种特殊的函数，主要用来创建对象时初始化对象，即为对象的成员变量赋初始值。 2.构造函数的定义 构造函数名和类名相同 构造函数没有返回值类型和返回值 构造函数可以重载 class student { public: student(){}//无参(默认)构造 student(int a){}//有参(带参)构造 } 3.构造函数的调用时机 在创建一个新的对象时会调用构造函数 调用无参数构造
C++的构造、析构函数
H_armony的专栏
04-17 702
构造、析构函数的由来： 由于C++类是许多成员函数和成员变量的集合，在实例化一个类时肯定需要将其内部变量初始化，而这个工作如果由程序员在创建对象后显示调用初始化函数完成，恐怕难免会有疏漏，所以C++之父发挥程序员“”懒惰“的特性，规定了两个函数分别是构造和析构函数，来完成初始化和清理工作，而这两个函数很重要的一点是，他们是在对象创建和消亡时自动执行的。 特别的是，如果程序员没有定义构造
C++之构造析构函数
CoderL
08-06 483
来总结一下C++中的构造函数 析构函数，强化一下记忆： 构造函数： 构造函数一种特殊的成员函数，名字与类名相同，没有返回值，可以有参数。 构造函数的作用是在创在对象时，对对象内的成员进行赋初值操作。 构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。 构造函数没有返回值，因为没有变量来接收返...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

兴趣使然的Qsiri

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

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

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

打赏作者

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

抵扣说明：

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

余额充值