💞💞欢迎来到 Claffic 的博客💞💞
👉 专栏:《是C++,不是C艹》👈
前言:
在完成类与对象的认识后,我们接着学习类与对象的第二部分:默认成员函数,它包括构造函数,析构函数,拷贝构造,赋值重载,普通对象取地址和const对象取地址重载,放心,这一期不会都讲给你的,让我们来慢慢研究构造函数和析构函数:
注:
你最好是学完了C语言,并学过一些初阶的数据结构。
(没有目录) ヽ( ̄ω ̄( ̄ω ̄〃)ゝ
Part1:默认成员函数
上一次我们提到了空类,里面没有成员,编译器给了它一个字节表示它存在,
class Date {};
❓那空类中真的什么也没有吗?
并不是的,编译器可是让你省心的存在:
类为空时,编译器会自动生成6个默认成员函数。
❓生成是会生成,那它们有什么用呢?
🌰有个例子:
上次我们提到了 Stack 的实现,其中有初始化函数 StackInit 和销毁函数 StackDestroy
现在告诉你个好事:构造函数可以代替 StackInit ,析构函数可以代替 StackDestroy 。
📢重点:它们都是编译器自动生成的,也就是说 像这种初始化函数和销毁函数不需要自己造了
当然不止这些,还有拷贝赋值和取地址重载等,大大方便了我们。
那么接下来,就由“构造函数”讲起:
Part2:构造函数
1.一个引子
🪄为了更方便地讲解,我们先定义一个 Date 类:
#include<iostream>
using namespace std;
class Date
{
public:
void SetDate(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;
d1.SetDate(2023, 6, 1);
d1.Print();
Date d2;
d2.SetDate(2023, 6, 4);
d2.Print();
return 0;
}
对于 Date 类来说,我每次要初始化设置信息,就要调用一次 SetDate 函数,那岂不是很烦?
❓那有没有一种办法,自动将我要传递的数值传递进去呢?
❗还真有,那就是构造函数,让我们有请构造函数登场!!!
2.构造函数的概念
构造函数 是一个 特殊的成员函数,名字与类名相同 ,创建类类型对象时由编译器自动调用
能保证每个数据成员都有一个合适的初始值,并且在对象整个生命周期内只调用一次。
🗡️构造函数的意义在于初始化对象,而不是给对象开辟空间(虽然名字叫做构造)
3.构造函数的特性
📝构造函数是特殊的成员函数,其特性如下:
① 函数名与类名相同;
② 没有返回值;
③ 构造函数可以重载;
④ 对象实例化时编译器自动调用对应的构造函数:
如上方代码中的 Date d1
构造函数就在这个时候被调用了
👀让我们康康它具体是怎么使用的:
#include<iostream>
using namespace std;
class Date
{
public:
Date() // 无参构造函数
{
_year = 1;
_month = 0;
_day = 0;
}
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; // 调用无参构造函数
d1.Print();
Date d2(2023, 6, 4); // 调用带参构造函数
d2.Print();
return 0;
}
👁️🗨️输出结果:
🪄不给参数就调用无参构造,给参数就调用带参构造
你以为你会了?其实有很多需要注意的地方:
🚨注意:
Ⅰ构造函数是特殊的函数,不是普通的成员函数,所以不可以这样调用
#include<iostream>
using namespace std;
class Date
{
public:
Date()
{
_year = 1;
_month = 0;
_day = 0;
}
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;
d1.Date; // 不可以这样调用
d1.Print();
return 0;
}
👁️🗨️输出结果:
Ⅱ无参构造对象,对象后面不用跟括号,否则就成了函数的声明
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 0, int day = 0)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 6, 5); // 带参就这样,括号加参数
d1.Print();
Date d2(); // 调用不带参构造函数,不要加括号
d2.Print(); // 实际上这个类没有创建出来
return 0;
}
报错:
Ⅲ 带参构造,该传递多少参数就传递多少参数
🚨如上三点要注意!
4.默认构造函数
我们聊完了构造函数,就要说说默认构造函数了:
如果你没有在类中定义构造函数(类中未显式定义),那么C++编译器就会自动生成一个无参的默认构造函数。
#include<iostream>
using namespace std;
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; // 调用默认构造函数
d1.Print();
return 0;
}
👁️🗨️输出结果:
🪄没有定义构造函数,也会成功创建对象,只不过用随机值来进行初始化
❓你是否和我有着同样的困惑:既然构造函数是用来初始化的,调用默认构造函数之后,确实是把类的成员参数初始化了,but 是用随机值初始化的,有一种没有初始化的赶脚... ... 🫠🫠🫠
默认构造函数没卵用吗?
这里我不说,等到后面再解答(哎呦,不就是想要骗你把文章读完嘛~)(狗头
继续回到默认构造函数:
无参构造函数、全缺省构造函数都被称为默认构造函数。
并且默认构造函数只能有一个!
class Date
{
public:
// 全缺省的默认构造函数
Date(int year = 2023, int month = 6, int day = 5)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
🚨注意:
① 无参构造函数、全缺省构造函数、什么没写时编译器默认生成的构造函数,都可以认为是默认构造函数(并不只有编译器默认生成的构造函数才叫做默认构造函数)
② 无参构造和全缺省构造同时存在时会引发歧义:
#include<iostream>
using namespace std;
class Date
{
public:
// 无参的默认构造函数
Date()
{
_year = 2023;
_month = 6;
_day = 5;
}
// 全缺省的默认构造函数
Date(int year = 2023, int month = 6, int day = 5)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1; // 这里报错
d1.Print();
return 0;
}
👁️🗨️输出结果:(报错)
🪄存在两个默认构造函数:无参的和全缺省的,但默认构造函数只能有一个,当类 d1 创建好后,编译器不知道用哪个构造函数来初始化。
![【是C++,不是C艹】 类与对象 | 默认成员函数 | 构造函数 | 析构函数](https://imgs.yssmx.com/Uploads/2023/06/483831-11.png)
这种全缺省/半缺省的格外好用:
#include<iostream>
using namespace std;
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:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Print();
Date d2(2023, 7, 14);
d2.Print();
Date d3(2023, 7);
d3.Print();
Date d4(2023);
d4.Print();
return 0;
}
👁️🗨️输出结果:
5.进一步探讨构造函数
这一部分主要解决上面留下的一个疑问:
如果你没有在类中定义构造函数(类中未显式定义),那么C++编译器就会自动生成一个无参的默认构造函数。
#include<iostream>
using namespace std;
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; // 调用默认构造函数
d1.Print();
return 0;
}
👁️🗨️输出结果:
🪄没有定义构造函数,也会成功创建对象,只不过用随机值来进行初始化
❓你是否和我有着同样的困惑:既然构造函数是用来初始化的,调用默认构造函数之后,确实是把类的成员参数初始化了,but 是用随机值初始化的,有一种没有初始化的赶脚... ... 🫠🫠🫠
默认构造函数没卵用吗?
🪄解答:
C++把类型分成内置类型(基本类型)和自定义类型。
内置类型:语言本身提供的数据类型,如 int / char / float ;
自定义类型:我们使用 class / struct / union 等自己定义的类型。
我们一起来看看下面的程序:
#include<iostream>
using namespace std;
class Time
{
public:
Time()
{
cout << "Time()被调用" << endl; // 调用就会打印
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
// 这里没有显式定义构造函数
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
👁️🗨️输出结果:
🗡️我们可以看出,编译器生成的 Date 默认构造函数会对自定义 Time 类型成员 _t 调用它的默认成员函数。
编译器默认生成构造函数:
对于内置类型的成员变量,会用随机值进行“处理”。
对于自定义类型的成员变量,会去调用它的默认构造函数(不用参数就可以调的)初始化。
❓随机值果然很挫,有没有一种办法,即能用到编译器默认生成的构造函数,又能使内置类型不是随机值?
这里提供一种方法:就是在定义内置类型的时候就给一个初始值(C++11 内置类型成员变量在类中声明时可以给默认值)
#include<iostream>
using namespace std;
class Time
{
public:
Time()
{
cout << "Time()被调用" << endl; // 调用就会打印
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
// 这里没显式构造函数
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
// 基本类型(内置类型) 给初始值
int _year = 1;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
d.Print();
return 0;
}
👁️🗨️输出结果:
是不是爽歪歪?
Part3:析构函数
1.一个引子
❓在前面构造函数的学习之后,我们知道了一个对象是怎么来的,那么一个对象是怎么没的呢?
构造函数的使命是初始化,那么谁来做清理工作?
❗那就是 -- 析构函数
2.析构函数的概念
对象在销毁时会调用析构函数,完成对象中资源的清理工作
🚨注意:析构函数不是完成对象本身的销毁,局部对象销毁工作是由编译器完成的
3.析构函数的特性
📝析构函数也是特殊的成员函数,其特征如下:
① 析构函数名是在类名前加上字符 ~
② 无返回类型,也无参数
③ 一个类只能有一个析构函数,若无显式定义,系统会自动生成默认的析构函数。
注意:析构函数不能重载
④ 对象的声明周期结束时,C++编译系统自动调用析构函数:
为了演示自动调用,就让析构函数被调用时 “仙逝” 一波 ~
#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()
{
cout << "~Date() 仙逝~ " << endl; // 测试一波
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(2023, 6, 5);
return 0;
}
👁️🗨️输出结果:
🪄因为创建了两个 Date 类 d1 , d2 ,所以都会自动销毁
析构函数的魅力不止,为了更好的演示,下面就采用 Stack :
之前实现 Stack ,最后需要 StackDestroy 来清理栈中的数据,
现在可以让析构函数来干这个活,泰爽辣:
#include <iostream>
#include <cstdlib>
using namespace std;
typedef int DataType;
class Stack
{
public:
// 构造函数 默认容量为4
Stack(size_t capacity = 4)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc failed");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 析构函数 清理开辟的空间,防止内存泄露
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
void TestStack()
{
Stack s1; // 默认容量为4
Stack s2(10); // 设置初始容量为10
}
🪄缺省了一个初始容量,也可以自己定义 另外不需要手动调用析构函数,都交给编译器。
继续回到析构函数的特性:
⑤ 编译器默认生成的析构函数,对自定义类型成员调用它的析构函数:
这一点与构造函数相同,下面来测试
#include <iostream>
using namespace std;
class Time
{
public:
~Time()
{
cout << "~Time() 仙逝~" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
👁️🗨️输出结果:
❓明明没有创建 Time 类的对象,为什么最后会调用 Time 类的析构函数?
🪄解释:
编译器默认生成了 Date 类的析构函数,Date 类中含有自定义类型 Time ,于是 Date 类的析构函数调用了 Time 类的析构函数,做到当 Date 对象销毁时,保证其内部每个对象都正确销毁。
🚨注意:创建哪个类的对象则调用该类的析构函数,销毁哪个类的对象则调用该类的析构函数
⑥ 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,如 Date 类;
如果有资源申请,一定要写,否则会造成内存泄漏,如 Stack 类,其中含有动态内存申请,所 以一定要写。
4.进一步探讨析构函数
我们知道了如果你不写析构函数,编译器会自动生成一个默认析构函数,这个默认析构函数会做些什么呢?
📝先来串联一下过来的知识:
如果你不写构造函数,编译器会自动生成,这个自动生成的 默认构造函数:
• "内置类型" 成员变量:不会做初始化处理
• "自定义类型" 成员变量:会调用它的默认构造函数初始化
对应的,析构函数也是这样:
如果你不写析构函数,编译器会自动生成,这个自动生成的 默认析构函数:
• "内置类型" 的成员变量:不作处理,也不需要处理,系统将其内存回收
• "自定义类型" 的成员变量:会调用它对应的析构函数
就如特性⑤所提到的:
编译器默认生成的析构函数,对自定义类型成员调用它的析构函数:
#include <iostream>
using namespace std;
class Time
{
public:
~Time()
{
cout << "~Time() 仙逝~" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
👁️🗨️输出结果:
总结:
这篇带大家认识了6个默认成员函数,再给大家详细讲解了构造函数和析构函数,思维不要停留在C语言阶段啦,C++编译器可以帮你做很多事情的!
码文不易 文章来源:https://www.toymoban.com/news/detail-483831.html
如果你觉得这篇文章还不错并且对你有帮助,不妨支持一波哦 💗💗💗文章来源地址https://www.toymoban.com/news/detail-483831.html
到了这里,关于【是C++,不是C艹】 类与对象 | 默认成员函数 | 构造函数 | 析构函数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!