当前位置： 首页 > news >正文

【C++】类和对象（中）构造函数、析构函数

news 2025/7/25 20:23:55

一. 类的 6 个默认成员函数

默认成员函数：我们不写，编译器会自己生成

C语言用栈时：1. 有时会忘记初始化、销毁（内存泄漏）         2. 有些地方写起来很繁琐
C++进化到可以自动初始化、销毁

以前的 C++ 栈：

typedef int DataType;class Stack
{
public:void Init(int capacity = 4){_a = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){CheckCapacity();_a[_size] = data;_size++;}void Pop(){if (Empty())return;_size--;}DataType Top() { return _a[_size - 1]; }int Empty() { return 0 == _size; }int Size() { return _size; }void Destroy(){if (_a){free(_a);_a = nullptr;_capacity = 0;_size = 0;}}private:void CheckCapacity(){if (_size == _capacity){int newcapacity = _capacity * 2;DataType* temp = (DataType*)realloc(_a, newcapacity *sizeof(DataType));if (temp == nullptr){perror("realloc申请空间失败!!!");return;}_a = temp;_capacity = newcapacity;}}private:DataType* _a;int _capacity;int _size;
};

不 Init，不 Destroy

int main()
{Stack s;// s.Init();s.Push(1);s.Push(2);s.Push(3);s.Push(4);printf("%d\n", s.Top());printf("%d\n", s.Size());s.Pop();s.Pop();printf("%d\n", s.Top());printf("%d\n", s.Size());// s.Destroy();return 0;
}

报错，程序异常退出

二. 构造函数

构造函数是特殊的成员函数。不是开空间创建对象，而是初始化对象，在对象整个生命周期内只调用一次

对象不需要某个函数创建。因为对象在栈里面，栈里面的变量是自动创建的（跟着栈帧走的）。函数调用，给局部变量开空间；函数结束，变量随栈帧销毁，空间也就销毁了

特征1. 函数名与类名相同

特征2. 无返回值，也不写 void

特征3. 对象实例化时 编译器 自动调用 对应的构造函数

现在的 C++ 栈：

class Stack
{
public:Stack(int capacity = 4) // 构造函数，功能：替代Init{cout << "Stack(int capacity = 4)" << endl;_a = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}/*void Init(int capacity = 4){_a = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}*/void Push(DataType data){ }void Pop(){ }DataType Top() { return _a[_size - 1]; }int Empty() { return 0 == _size; }int Size() { return _size; }void Destroy(){if (_a){free(_a);_a = nullptr;_capacity = 0;_size = 0;}}private:void CheckCapacity(){ }private:DataType* _a;int _capacity;int _size;
};

不 Init，不 Destroy

C++祖师爷规定了，对象实例化的时候，自动调用构造函数。从此不需要 Init( )

现在程序还存在内存泄漏，因为我们没有调 Destroy。先看：三. 析构函数

特征 4：构造函数可以重载

为什么构造函数支持重载？        因为有多种初始化方式

eg：一上来有一组数据作为默认初始化

class Stack
{
public:Stack(DataType* a, int n){cout << "Stack(DataType* a, int n)" << endl;_a = (DataType*)malloc(sizeof(DataType) * n);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}memcpy(_a, a, sizeof(DataType) * n);_capacity = n;_size = n;}Stack(int capacity = 4) // 构造函数，功能：替代Init{cout << "Stack(int capacity = 4)" << endl;_a = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}......~Stack(){cout << "~Stack()" << endl;if (_a){free(_a);_a = nullptr;_capacity = 0;_size = 0;}}private:void CheckCapacity(){ }private:DataType* _a;int _capacity;int _size;
};

特征 5：自动生成

如果类中没有显式定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

class Date
{
public:/* // 如果用户显式定义了构造函数，编译器将不再生成Date(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;d1.Print();return 0;
}

一堆随机值，自动生成的构造函数好像啥也没干（编译器会干，只是我们看不见）。而且我咋知道有没有生成构造函数？

这是祖师爷的失误，这里应该初始化为0                C++标准没有规定要初始化

特征 6：

C++ 把类型分为2类：
1. 内置 / 基本类型：语言本身定义的基础类型 int / char / double / 指针 ……
2. 自定义类型： struct / class 等类型

我们不写，编译器默认生成的构造函数：
内置类型不做处理（有些编译器会处理，但我们当做不处理）、自定义类型会去调用他们的默认构造

结论：
        1. 一般情况，要自己写构造函数
        2. 用编译器自动生成的就可以：
                a. 内置类型成员都有缺省值，且初始化符合我们的要求
                b. 全是自定义类型的构造，且这些类型都定义了默认构造（用栈实现队列，定义2个栈）

2. a. 1

C++ 11发布时，打了补丁：成员声明时，可以给缺省值（主要针对内置类型）

class Date
{
public:void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 内置类型// C++11支持，这里不是初始化，因为这里只是声明，没有开空间// 这里给的是默认的缺省值，给编译器生成的默认构造函数用int _year = 1;int _month = 2;int _day = 3;
};int main()
{Date d1;d1.Print();return 0;
}

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year = 1;int _month = 2;int _day = 3;
};int main()
{Date d1(2025, 6, 1); // 在这显式初始化了，不会用缺省值d1.Print();return 0;
}

此时必须自己写构造函数，否则：

补充：构造函数的调用问题

构造函数的定义很特殊：同名、无返回值、自动调用                构造函数的调用也很特殊

class Date
{
public: // 写2个构造函数，构造函数可以重载。有多种初始化方式Date() // 可以无参{_year = 2025;_month = 6;_day = 1;}Date(int year, int month, int day) // 可以带参{_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 内置类型// C++11支持，这里不是初始化，因为这里只是声明，没有开空间// 这里给的是默认的缺省值，给编译器生成的默认构造函数用int _year = 1;int _month = 2;int _day = 3;
};
int main()
{Date d1(2025, 6, 1); // 构造函数的调用1：对象 + 参数列表Date d2; // 构造函数的调用2：对象不加列表d1.Print(); // 普通函数的调用：函数名 + 参数列表d2.Print();Date d3(); // 报警告// 原因：与函数声明冲突，编译器不好识别。// 这么写编译器可以看做构造函数的调用；也可以看做一个函数的声明// Date d1(2025, 6, 1); 这一看就不是函数声明。函数声明()里不是变量对象，是类型return 0;
}

// 有人认为祖师爷脑子不清楚，下面这样写就没上面那么多事：对象调函数，变成正常的函数调用
int main()
{Date d1;    // 对象调函数。对象.函数名d1.Date(); // 实事是：报错：类型名称“Data”不能出现在类成员访问表达式的右侧Date d2;d2.Date(2025, 6, 1); // 实事是：报错return 0;
}// 能这么写，为什么不这样写?: 
int main()
{Date d1;d1.Init(); // 实事是：报错		叫 Init 不是更香吗，为什么还搞 Data出来?Date d2;d2.Init(2025, 6, 1); // 实事是：报错return 0;
} // 回去了。对象实例化时，自动调用怎么办?

2. a. 2

struct TreeNode
{TreeNode* _left;TreeNode* _right;int _val;
};class Tree
{
private:TreeNode* _root; // 定义一棵树，最开始要有根节点// 能不能不写它的构造函数?	可以！// 直接不写肯定不行，默认生成的构造函数对内置类型不初始化
};int main()
{Tree t1;return 0;
}

class Tree
{
private:TreeNode* _root = nullptr;
};

灵活应变：

struct TreeNode
{TreeNode* _left;TreeNode* _right;int _val;TreeNode(int val = 0) // 这里推荐自己写默认构造{_left = nullptr;_right = nullptr;_val = val;}
};class Tree
{
private:TreeNode* _root = nullptr; // 定义一棵树，最开始要有根节点
};int main()
{Tree t1;TreeNode n0;TreeNode n1(1);TreeNode n2(8);return 0;
}

2. b.

class Stack
{
public:Stack(int capacity = 4) // 这些类型（Stack）都定义了默认构造{cout << "Stack(int capacity = 4)" << endl;_a = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}~Stack(){ }private:DataType* _a = nullptr;int _capacity;int _size = 0;
};class MyQueue
{
private: // 自定义类型（Stack）成员Stack _pushst;Stack _popst;
};int main()
{MyQueue q;return 0;
}

特征 7：默认构造函数

无参的构造函数 和 全缺省的构造函数 都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是 默认构造函数

总结：不传参就可以调用的就是默认构造函数

构造函数虽可重载，但写全缺省最香：

class Date
{
public:Date() // 无参{_year = 2025;_month = 6;_day = 1;}Date(int year = 1, int month = 1, int day = 1) // 全缺省{_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 内置类型// C++11支持，这里不是初始化，因为这里只是声明，没有开空间// 这里给的是默认的缺省值，给编译器生成的默认构造函数用int _year = 1;int _month = 2;int _day = 3;
};

无参、全缺省语法上可同时存在，因为构成函数重载                但无参调用存在歧义，所以现实中不会同时存在

class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 内置类型// C++11支持，这里不是初始化，因为这里只是声明，没有开空间// 这里给的是默认的缺省值，给编译器生成的默认构造函数用int _year = 1;int _month = 2;int _day = 3;
};int main()
{Date d1(2022);d1.Print();Date d2(2025, 6);d2.Print();return 0;
}

class Date
{
public:Date(int year, int month = 1, int day = 1) // 不写成全缺省（没有默认构造）{_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 内置类型// C++11支持，这里不是初始化，因为这里只是声明，没有开空间// 这里给的是默认的缺省值，给编译器生成的默认构造函数用int _year = 1;int _month = 2;int _day = 3;
};int main()
{Date d1; // 不传参数：报错：“Data”: 没有合适的默认构造函数可用// 可以不传参的是默认构造，这里必须传参数d1.Print(); return 0;
}

三. 析构函数

析构函数是特殊的成员函数，不是完成对象本身的销毁（不是销空间）。局部对象（在栈帧里，由系统完成）销毁工作是由编译器完成的

特征 1：析构函数名：~类名

特征 2：无参数（析构函数不能重载），无返回值

特征 3：对象生命周期结束（销毁）时，自动调用，完成对象中资源清理工作

class Stack
{
public:Stack(int capacity = 4) // 构造函数{	}~Stack() // 析构函数{cout << "~Stack()" << endl;if (_a){free(_a);_a = nullptr;_capacity = 0;_size = 0;}}/*void Destroy(){if (_a){free(_a);_a = nullptr;_capacity = 0;_size = 0;}}*/private:void CheckCapacity(){ }private:DataType* _a;int _capacity;int _size;
};

        Stack 有了构造、析构，就不怕忘记写 初始化、清理函数 了，也简化了

特征 4：自动生成

一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数

1、内置类型成员不做处理                2、自定义类型会去调用它的析构函数

所以，上面的代码，不写自己写析构，编译器默认生成的析构，不会释放 _a指向的空间，内存泄漏

class Stack
{
public:Stack(int capacity = 4) // 构造函数，功能：替代Init{	}private:DataType _a[100];int _capacity;int _size;
};

写的是静态的会不会释放？
析构函数是释放 动态申请（堆）的资源。这种 静态的资源（栈）不用手动释放，出了作用域会自动销毁
只有堆上的要手动释放

总结

1、一般情况下，有动态申请资源，就需要显式写析构函数，来释放资源
2、没有动态申请的资源，不需要写析构
3、需要释放资源的成员都是自定义类型，不需要写析构，前提：类型都定义了析构函数

// 1、栈是经典的需要写析构
~Stack()
{cout << "~Stack()" << endl;free(_a);_a = nullptr;_capacity = _size = 0;
}// 2、日期类没有析构可写，没有申请资源
class Data
{
private:int _year;int _month;int _day;
};// 3、默认生成的析构会自动调用析构
class MyQueue
{
private:Stack _pushst;Stack _popst;
};

本篇的分享就到这里了，感谢观看，如果对你有帮助，别忘了点赞+收藏+关注。
小编会以自己学习过程中遇到的问题为素材，持续为您推送文章

http://www.lryc.cn/news/597020.html

相关文章：

  • nrm指南
  • 二级建造师学习笔记-2025
  • 2025 成都航空装备展供需发布：精准匹配，高效成交
  • 货车手机远程启动功能的详细使用步骤及注意事项
  • C#值类型属性的典型问题
  • 基于.Net Core开源的库存订单管理系统
  • 【NLP舆情分析】基于python微博舆情分析可视化系统(flask+pandas+echarts) 视频教程 - 主页-微博点赞量Top6实现
  • 粗大误差智能滤除：基于格拉布斯准则与机器学习的数据清洗体系​
  • 深入理解 TCP 协议：Linux 网络传输的可靠基石
  • 【Node.js】使用ts-node运行ts文件时报错： TypeError: Unknown file extension “.ts“ for ts 文件
  • Node.js 倒计时图片服务部署与 Nginx 反向代理实战总结
  • The History of Computers
  • 用 Phi-3 Mini 4K Instruct 实现轻量级模型量化与加载
  • WWDC 25 给自定义 SwiftUI 视图穿上“玻璃外衣”：最新 Liquid Glass 皮肤详解
  • 漫画机器学习播客对话图文版
  • OpenHarmony BUILD.gn中执行脚本
  • 趣玩-Ollama-Llm-Chatrbot
  • 第四章 Freertos物联网实战DHT11温湿度模块
  • 利用aruco标定板标定相机
  • EDoF-ToF: extended depth of field time-of-flight imaging解读, OE 2021
  • C Primer Plus 第6版 编程练习——第10章(上)
  • 2025暑期—05神经网络-BP网络
  • 深入解析预训练语言模型在文本生成中的革命性应用：技术全景与未来挑战
  • 工业微控制器的启动过程以及安全设计所面临的挑战
  • TODAY()-WEEKDAY(TODAY(),2)+1
  • 数据结构系列之二叉搜索树
  • 关于针对 DT_REG 出现红色波浪线的问题（编译错误/IDE警告），以下是 精准解决方案，保持你的代码功能完全不变：
  • LeetCode11~20题解
  • 动态递归之正则表达式
  • 西安电子科技大学金融学431考研经历分享