C++类和对象：构造/析构/拷贝函数

你好，这里是新人 Sunfor

这篇是我最近对于C++类和对象：构造/析构/拷贝函数的学习心得和错题整理
有任何错误欢迎指正，欢迎交流！
会持续更新，希望对你有所帮助，我们一起学习，一起进步

前言

“在C++的世界里，对象的生与死不是偶然，而是一场精心设计的仪式”
构造函数、析构函数和拷贝函数构成了C++对象生命周期的三大支柱，他们不仅决定了对象如何诞生、生存和消亡，更是资源管理的核心战场，让我们一起理解隐藏在语法糖衣下的底层逻辑

一、构造函数 ---- 对象的诞生仪式

1.1 构造函数的定义

“构造函数是对象的基因编码，决定了每个对象出场时的初始状态”
构造函数时特殊的成员函数，需要注意的是，构造函数虽然名称为构造，但是 构造函数不是开空间创建对象 我们常使用的局部对象是栈帧创建的，这个在之间函数栈帧（点击可跳转复习）也有提到
构造函数实质上是要替代我们以前Stack和Data类中写的Init(初始化)函数的功能，构造函数自动调用的特点完美的替代了Init

1.2 构造函数的特点

  • 函数名与类名相同
  • 无返回值
  • 对象实例化时系统会自动调用对应的构造函数
  • 构造函数可以重载
  • 如果类中没有显示定义构造函数，C++编译器会自动生成一个 无参的默认构造函数，一旦用户显示定义，编译器将不再生成

默认构造函数：
无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数
这三个函数有且只有一个存在 不能同时存在
总结来说：不传实参就可以调用的构造就叫默认构造

其中： 我们不写构造时编译器默认生成的构造函数 对内置类型成员函数的初始化没有要求，是否初始化是不确定的，对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化

内置类型 : 语言提供的原生数据类型：int、char、double、指针…
自定义类型 : 使用class、struct等关键字自己定义的类型

代码演示

#include<iostream>
using namespace std;

class Date
{
public:
	//1.无参构造
	Data()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	//2.有参构造
	Data(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	Date d2(2025, 3, 19);

	Date d3();

	d1.Print();
	d2.Print();
	return 0;
}

常用功能体现：两个Stack 实现队列

#include<iostream>
#include<stack>
using namespace std;

class MyQueue
{
private:
	stack<int> s1;
	stack<int> s2;

	void transfer()
	{
		if (s2.empty())
		{
			while (!s1.empty())
			{
				s2.push(s1.top());
				s1.pop();
			}
		}
	}
public:
	void enqueue(int x)
	{
		s1.push(x);
	}

	int dequeue()
	{
		transfer();
		if (s2.empty())
		{
			cout << "Queue is empty!" << endl;
			return -1;
		}
		int front = s2.top();
		s2.pop();
		return front;
		 
	}

	int front() {
		transfer();
		if (s2.empty()) {
			cout << "Queue is empty!" << endl;
			return -1;
		}
		return s2.top();
	}

	bool isEmpty()
	{
		return s1.empty() && s2.empty();
	}

};

二、析构函数 ---- 对象的临终遗言

2.1 析构函数的定义

“析构函数是对象的自我救赎，负责清理自己存在的痕迹”
析构函数与构造函数的功能相反，析构函数不是完成对对象本身的销毁，
局部对象是存在栈帧的，函数结束栈帧就销毁，不需要我们处理
析构函数主要完成对象中资源的清理释放工作，类似于之前Stack实现的Destory功能

2.2 析构函数的特点

  • 析构函数名是在类名前加上字符 ~
  • 无参数无返回值
  • 一个类只能有一个析构函数 若未显示定义，系统会自动生成默认的析构函数
  • 对象生命周期结束时，系统会自动调用析构函数
  • 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用他的析构函数

我们显示写析构函数，对于自定义类型成员也会调用他的析构，无论什么情况都会自动调用析构函数

  • 如果类中没有申请资源时，析构函数可以不写，直接使用编译器默认生成的默认析构函数,如 Date
  • 如果默认生成的析构就可以用，也就不需要显示写析构，如 MyQueue
  • 有资源申请时，一定要自己写析构，否则会导致资源泄露，如 Stack
  • 一个局部域的多个对象，C++规定后定义的先析构

2.3 代码演示

#include<iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc fail!");
			return;
		}

		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

class MyQueue
{
public:
	//编译器默认生成MyQueue的析构函数 调用了Stack的析构
	//显示写析构，也会自动调用Stack的析构


private:
	Stack pushst;
	Stack popst;
};

int main()
{
	Stack st;

	MyQueue mq;

	return 0;
}

常用功能体现：用C++实现Stack更加方便

#include<iostream>
using namespace std;

bool isValid(const char* s)
{
	Stack st;

	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			if (st.Empty())
			{
				return false;
			}

			char top = st.Top();
			st.Pop();

			if ((*s == ']' && top != '[')
				|| (*s == ')' && top != '(')
				|| (*s == '}' && top != '{'))
			{
				return false;
			}
		}

		++s;
	}

	return st.Empty();
}

三、拷贝构造函数 ---- 对象克隆技术

3.1 拷贝构造的定义

“拷贝构造是对象的DNA复制，决定了克隆体与原体的相似程度”
拷贝构造是一个特殊的构造函数
如果一个构造函数的 第一个参数是自身类类型的引用，且 任何额度的参数都有默认值，则此构造函数也叫做拷贝构造函数

class String
{
public:
	String(const String & other)
	{
		size = other.size;
		data = new char[size + 1];//深拷贝
		strcpy(data, other.data);
	}
private:
	char* data;
	int size;
}

3.2 拷贝构造的特点

  • 拷贝构造函数是一个构造函数的重载
  • 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报 (会造成无穷递归)

拷贝构造函数也可以多个参数，但是 第一个参数必须是类类型对象的引用，后面参数必须有缺省值

  • C+规定自定义类型对象进行拷贝行为必须调用拷贝构造
    所以这里的自定义类型传值传参和传值返回都会调用拷贝构造完成
  • 未显示定义拷贝构造，编译器会生成自动生成拷贝构造函数 自动生成的拷贝构造对内置类成员变量会完成浅拷贝，对自定义类型成员变量会调用他的拷贝构造
  • Data这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，因此不需要我们显示实现拷贝构造
  • Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝

深拷贝需要我们将指向的资源也进行拷贝

  • MyQueue 这样的类型内部主要是自定义类型Stack成员，编译器会自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现拷贝构造
    tips: 如果一个类显示实现了析构并释放了资源，那么他就需要显示写拷贝构造，否则不需要
  • 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没 有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

3.3 代码举例

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	Date(Date* d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

void Func1(Date d)
{
	cout << &d << endl;
	d.Print();
}

Date& Func2()
{
	Date tmp(2024, 7, 5);
	tmp.Print();

	return tmp;
}


int main()
{
	Date d1(2024, 7, 5);
	//C++规定自定义类型对象进行拷贝行为必须调用拷贝构造 所以传值传参要调用拷贝构造
	//所以这里的d1传值传参给d要调用拷贝构造完成拷贝，传引用传参可以较少这里的构造

	Func1(d1);

	cout << &d1 << endl;

	//这里可以完成拷贝 但不是拷贝构造 只是一个普通的构造
	Date d2(&d1);
	d1.Print();
	d2.Print();

	//这才是拷贝构造 通过同类型的对象初始化构造 而不是指针
	Date d3(d1);
	d2.Print();

	//这也是拷贝构造
	Date d4 = d1;
	d2.Print();

	Date ret = Func2();
	ret.Print();

	return 0;

}

浅拷贝和深拷贝的对比
在这里插入图片描述
在这里插入图片描述

四、深度避坑指南

1.临时对象陷阱

class TempTrap {
public:
    TempTrap() { cout << "Construct"; }
    ~TempTrap() { cout << "Destruct"; }
};

void Demo() {
    TempTrap();  // 立即构造并析构！
    // 输出：ConstructDestruct
}

2.异常安全构造

class SafeConstructor {
public:
    SafeConstructor() 
        : res1(new Resource),  // 可能抛出异常
          res2(new Resource) { 
        // 若res2分配失败，res1泄漏！
        // 正确做法：使用智能指针或try-catch块
    }
};

3.拷贝构造的N种死法

class CopyCatastrophe {
public:
    CopyCatastrophe(const CopyCatastrophe& other) {
        // 错误1：忘记拷贝数据
        // 错误2：浅拷贝指针
        // 错误3：未检查other合法性
    }
};

在这里插入图片描述

后记

在探索构造函数、析构函数和拷贝构造函数的旅程中，我们不仅掌握了C++的语法规则，更触及了面向对象编程的核心哲学：
“对象的生命周期管理，本质是程序员对资源的责任承诺。”
每一个new/delete的选择，每一次拷贝策略的权衡，都在无声地定义着程序的健壮性边界。
关于这个方面，我们后续还会有更加深入的解读和理解，欢迎大家持续关注~

# c++ # java # jvm
Logo
松山湖开发者村综合服务平台

助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台

更多推荐

cover

路由器、交换机、防火墙、服务器、负载均衡在网络中作用

avatar 松山湖开发者村综合服务平台
cover

网络安全工程师逆元计算 网络安全逆向

avatar 松山湖开发者村综合服务平台
cover

Wireshark网络抓包分析使用详解

avatar 松山湖开发者村综合服务平台