浅喜似苍狗
深爱如长风
目录
契子✨
如果一个类中什么成员都没有，简称为空类
空类中真的什么都没有吗？
并不是，任何类在什么都不写时，编译器会自动生成以下 6 个默认成员函数
我们今天主要来讲讲 构造函数 与 析构函数 的那些事
构造函数
不知道大家在写简单代码的时候，代码模块都正确而就在这时测试的时候忘记初始化了导致出错
这个时候是不是挺尴尬的？而且初始化又容易忘记，怎么办呢？
那就不写，让系统自动帮我们初始化！！！
这个时候就需要我们今天所学的内容 --- 构造函数
概念
⭐构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次
特性
⭐构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象
运用
我们写个日期类 Date 来感受一下吧
自行初始化的写法
#include<iostream> #include<cstdlib> using std::cout; using std::endl; class Date { public: void Init(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.Init(2024, 4, 8); d1.Print(); Date d2; d2.Init(2024, 4, 9); d2.Print(); system("pause"); return 0; }
这个时候我们初始化调用了，但是为了避免我们忘记初始化出错我们尽量用构造函数初始化
构造函数的特征
| ⭐函数名与类名相同，这意味着构造函数的名称与它所创建的类的名称相同 |
| ⭐无返回值，构造函数没有返回类型，这与类的其他成员函数不同 |
| ⭐对象实例化时编译器自动调用对应的构造函数 |
| ⭐构造函数可以重载，一个类可以有多个构造函数，每个构造函数可以有不同数目或类型的形参，以满足不同的初始化需求 |
方法一：无参构造函数
#include<iostream> #include<cstdlib> using std::cout; using std::endl; class Date { public: Date() { _year = 2024; _month = 4; _day = 10; } void Print(); private: int _year; int _month; int _day; }; void Date::Print() { cout << _year << "-" << _month << "-" << _day << endl; } int main() { Date d1; d1.Print(); system("pause"); return 0; }
这个时候我们发现，编译器帮忙初始化了呢
✨如果我们的构造函数里面没有指定初始化，那会发生什么呢？
class Date { public: Date() { } void Print(); private: int _year; int _month; int _day; };
我们发现我们在什么都不做的情况下，编译器依旧会帮我们初始化，只不过是随机值
注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
我们这里声明了d2函数，该函数无参，返回一个日期类型的对象
方法二：有参构造函数
#include<iostream> #include<cstdlib> using std::cout; using std::endl; class Date { public: Date(int year , int month, int day); void Print(); private: int _year; int _month; int _day; }; Date::Date(int year,int month, int day) { _year = year; _month = month; _day = day; } void Date::Print() { cout << _year << "-" << _month << "-" << _day << endl; } int main() { Date d2(2024, 4, 9); d2.Print(); system("pause"); return 0; }
这里其实更初始化调用差不多，需要手动调用
编译器自动生成的构造函数
✨注意1： 如果我们没有显示定义构造函数，那么编译器会自动生成一个无参的默认构造函数
#include<iostream>
#include<cstdlib>
using std::cout;
using std::endl;
class Date
{
public:
void Print();
private:
int _year;
int _month;
int _day;
};
void Date::Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
int main()
{
Date d3;
d3.Print();
system("pause");
return 0;
}
像以上这种情况，我们没有初始化也没有定义构造函数，那么系统会自动调用一个无参的构造函数
✨注意2：如果我们之前定义了构造函数则系统不会在生成
默认构造函数
概念
无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函，并且默认构造函数只能有一个。
总结来说就是：我们不传参就可以调用的就是默认构造函数
我们以上已经讲了两种构造函数（无参、编译器默认生成构造函数），接下来我将讲一下构造函数最实用的 全缺省构造函数
全缺省构造函数
#include<iostream> #include<cstdlib> using std::cout; using std::endl; class Date { public: Date(int year = 2024, int month = 4, int day = 10) { _year = year; _month = month; _day = day; } void Print(); private: int _year; int _month; int _day; }; void Date::Print() { cout << _year << "-" << _month << "-" << _day << endl; } int main() { Date d1; d1.Print(); Date d2(2024, 4, 11); d2.Print(); Date d3(2024, 5); d3.Print(); system("pause"); return 0; }
我们这里采用了全缺省，如果我们不传参系统就会默认初始化我们的缺省值，如果我们传参编译器也会根据我们所传的值进行初始化
这样是不是很方便？即使忘记初始化运行程序时也不会出现初始化随机值更不会报错
大家看看一下的例子，为什么会报错呢？
#include<iostream>
#include<cstdlib>
using std::cout;
using std::endl;
class Date
{
public:
Date()
{
}
Date(int year = 2024, int month = 4, int day = 10)
{
_year = year;
_month = month;
_day = day;
}
void Print();
private:
int _year;
int _month;
int _day;
};
void Date::Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
int main()
{
Date d1;
d1.Print();
return 0;
}
注意：这里不是函数重载的错误哦，而是调用歧义，两个构造函数都可以调用，编译器不知道调哪个，所以报了一个错误
内置类型和自定义类型
关于编译器生成的默认成员函数，很多老铁会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？对象调用了编译器生成的默认构造函数，但是对象 _year/_month/_day ，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？
答：
C++把类型分成内置类型和自定义类型
🌤️内置类型 内置类型就是语言提供的数据类型，如 int char double 等基础数据类型 🌤️自定义类型 自定义类型就是我们使用 class struct union 等自己定义的类型
编译器自动生成的构造函数不会处理内置类型，它们是随机值
然而自动生成的构造会处理自定义类型它会去调用自定义类型的默认构造
#include<iostream>
#include<cstdlib>
using std::cout;
using std::endl;
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 d1;
return 0;
}举个栗子~
<1>Date类没有显示写构造函数所以编译器会自动生成一个构造函数此构造函数不会处理内置类型
所以成员变量 _year _month _day 都是随机值
<2>然而此构造函数会处理自定义类型它会去调用Time类的默认构造函数将成员变量 _t 初始化
若将上面的栗子的 Time 默认构造函数改成这样：
class Time
{
public:
Time()
{
}
private:
int _hour;
int _minute;
int _second;
};
猜猜会发生什么呢？
我们发现 _t 的值也变成随机值了，因为 _t 是自定义类型而找类中的默认构造函数，而我们没有任何的初始化，所以编译器依旧给我们赋了随机值，相当于套娃
C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值
class Date { public: void Print(); private: int _year = 2024; int _month = 4; int _day = 10; };
int _year = 2024; 这里是声明哦不是定义，相当于给缺省值
也让就是说内置类型我们可以在声明的时候给缺省值，然后让编译器自动调用，完美~
总结：
| 💞一般情况下构造函数都需要我们显示的去实现 |
| 💞只有在少数情况才可以让编译器自动生成构造函数 |
析构函数
契子✨
我们再写数据结构比如说 -- 栈的时候，我们一般都是动态的用 malloc 或者 new 开辟的存储空间
最后都会写一个销毁栈的模块来回收空间~（避免内存泄漏）
void StackDestory(STK* ps)
{
assert(ps);
free(ps->data);
ps->data = NULL;
ps->capacity = ps->top = 0;
}但是每次写栈都要写 StackDestory 释放操作真的太麻烦了，那能不能不写呢？
当然可以，学会了析构函数编译器会帮你自动释放的！！！
概念
⭐与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
特性
析构函数名是在类名前加上字符 ~ 无参数无返回值类型 一个类只能有一个析构函数 若未显式定义，系统会自动生成默认的析构函数，析构函数不能重载 注意：对象生命周期结束时，编译系统会自动调用析构函数，不需要进行手动调用，并且只调用一次
来看一下我们之前写过的栈🌤️
#include<iostream>
#include<assert.h>
#include<cstdlib>
using std::cout;
using std::endl;
using StackDataUsing = int;
class Stack
{
public:
Stack(int n);
~Stack();
void push(StackDataUsing x);
StackDataUsing Top();
void Pop();
bool Empty();
private:
StackDataUsing* data;
int top;
int capacity;
};
Stack::Stack(int n = 4)
{
StackDataUsing* newNode = new StackDataUsing[n];
if (newNode == nullptr)
{
perror("new1");
exit(-1);
}
data = newNode;
capacity = n;
top = 0;
}
Stack::~Stack()
{
cout << "~Stack()" << endl;
if (data)
{
free(data);
data = nullptr;
top = capacity = 0;
}
}
void Stack::push(StackDataUsing x)
{
if (capacity == top)
{
StackDataUsing* newNode = new StackDataUsing[2 * capacity];
if (newNode == NULL)
{
perror("new2");
exit(-1);
}
data = newNode;
capacity *= 2;
}
data[top++] = x;
}
StackDataUsing Stack::Top()
{
return data[top - 1];
}
void Stack::Pop()
{
assert(top > 0);
top--;
}
bool Stack::Empty()
{
return top == 0;
}
int main()
{
Stack st;
st.~Stack();
return 0;
}
我们发现在对象销毁时编译器自动调用了，不需要进行手动调用
这样是不是很方便，接下来我们讲一讲析构函数的细节问题：
析构函数的显示调用
以上我们显示调用了一次栈的析构函数，然后编译器自动调用一次
默认析构函数的作用
关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器 生成的默认析构函数
<1>对内置类型不做处理 <2>对自定类型成员调用它的析构函数
因为默认析构对内置类型不做处理，所以我们在内置类型开辟动态空间的时候还需要手写析构
class Stack
{
public:
Stack(int n);
~Stack();
void push(StackDataUsing x);
StackDataUsing Top();
void Pop();
bool Empty();
private:
StackDataUsing* data;
int top;
int capacity;
};如刚刚写的栈，因为我们 malloc 开辟的空间在内置类型编译器不会处理，所以我们自己写了析构
以下是需要写析构与否的实践总结：
<1>有资源需要显示清理，就需要写析构，如：Stack
| <2>有两种场景不需要显示写析构，默认生成就可以了： |
| （1）没有资源需要清理没有用 malloc 或者 new 开辟动态内存 |
| （2）内置类型成员没有资源需要清理，剩下都是自定义类型 |
不需要写析构的情况：
#include<iostream>
using std::cout;
using std::endl;
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 _t1;
Time _t2;
};
int main()
{
Date d;
return 0;
}
在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
答：
🌤️main方法中创建了Date对象d，而d中包含5个成员变量，其中_year，_month， _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而 _t1、_t2 是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t1、_t2对象销毁，所以要调用Time类的析构函数。
🌤️main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁。
这样情况合理下，就可以不写析构了~（又可以偷偷摸鱼了）
先介绍到这里啦~
有不对的地方请指出💞
扫一扫
1199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
