前言
类和对象相关博客：【C++】类和对象
我们前面一个内容已经讲了关于类好对象的初步的一些知识，下面我们来进阶的讲一讲如何使用类和对象。
类的六个默认成员函数
上一节我们介绍类对象大小的时候，就有介绍过空类，空类的大小是一个字节
class A {}; //空类的形式
我们所看到的空类，类体中为空，那空类中就什么都不存在吗？
事实并不是这样的。
任何类在什么都不写时，编译器会自动生成6个默认成员函数。
默认成员函数：用户没有显示实现时，编译器会生成的成员函数称为默认成员函数。
6个默认成员函数如下：
- 构造函数（主要完成初始化操作）
- 析构函数（主要完成清理操作）
- 拷贝构造（使用同类对象初始化创建对象）
- 赋值重载（把一个对象赋值给另一个对象）
- 取地址重载
- const取地址操作符重载
本节我们将会介绍一下构造函数和析构函数这两个最为重要的默认成员函数。
构造函数
1.构造函数的概念
构造函数是一种特殊的成员函数，它可以用来处理对象的初始化，且不需要用户来调用，而是在建立对象时自动执行，且在对象生命周期内只调用一次。
构造函数虽然起名叫构造，但是构造函数的主要内容不是开空间，而是给对象初始化，就像栈所需要使用的Init函数（用Init函数初始化栈）。
2.构造函数的特性
构造函数是一种特殊的成员函数，所以它有一些独特的特性。
- 函数名与类名相同
- 无返回值（不用写void）
class Time //定义Time类
{
public:
//void Time() 错误写法
Time()//定义构造成员函数，函数名与类名相同
{ //利用构造函数对对象中的数据成员赋值
_hour = 0;
_minute = 0;
_sec = 0;
}
private:
int _hour;//时
int _minute;//分
int _sec;//秒
}
- 对象实例化时编译器会自动调用对应的构造函数
//接上段代码
int main()
{
Time t1;
//Time类实例化了一个对象t1，同时调用构造函数t1.Time()
}
构造函数不需要用户调用，也不能被用户调用。
这种用法是错误的。
ti.Time(); //企图调用一般成员函数的方法来调用构造函数
- 构造函数可以重载
我们可以在类里面写多个构造函数，可以有多种初始化方式，这些构造函数就构成函数重载。例如：
#include<iostream>
using namespace std;
class Time //定义Time类
{
public:
//无参构造函数
Time()
{
_hour = 0;
_minute = 0;
_sec = 0;
}
//带参构造函数
Time(int hour, int minute, int sec)
{
_hour = hour;
_minute = minute;
_sec = sec;
}
void Print()
{
cout<<_hour<<":"<<_minute<<":"<<_sec<<endl;
}
private:
int _hour;//时
int _minute;//分
int _sec;//秒
};
int main()
{
Time t1;//调用无参构造函数
Time t2(10,30,55);//调用带参的构造函数
t1.Print();
t2.Print();
return 0;
}
运行结果如下：
上述代码只定义了两个同名的构造函数，根据重载函数的性质，还可以写出更多构造函数，如：
Time(int hour, int minute); //有两个参数的构造函数
Time(int hour); //有一个参数的构造函数
在建立对象时给出参数个数，系统就会自动调用对应的构造函数。
需要注意的是：
我们在调用无参构造函数时不能写成：Time t1(); //错误的调用无参构造函数写法是因为它无法和函数声明区分开来。
这行代码就变成了：声明一个t1函数，该函数无参，且返回一个时间类型的对象。
当然，细心的朋友也发现了，它和我们平常调用函数的方式不太一样，正常调用时的方式是：函数名(参数列表)。而调用构造函数时变成了：对象名(参数列表)。
- 如果类中没有定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义，编译器将不再生成。如：
class Time //定义Time类
{
public:
/* Time(int hour, int minute, int sec)
{
_hour = hour;
_minute = minute;
_sec = sec;
}*/
void Print()
{
cout<<_hour<<":"<<_minute<<":"<<_sec<<endl;
}
private:
int _hour;//时
int _minute;//分
int _sec;//秒
};
int main()
{
Time t1;//调用无参构造函数
t1.Print();
return 0;
}
通过运行结果我们发现，我们将带参的构造函数屏蔽掉了，但是依然能够正常运行出来，虽然结果是随机值，是因为编译器自动生成了一个无参的默认构造函数，且将其初始化为了随机值，即：
Time()
{} //这就是编译器默认生成的无参构造函数
如果将Time类中的构造函数放开，代码会编译失败，因为我们显示定义了构造函数后，编译器便不再生成。报错如下：
- C++把类型分为了内置类型和自定义类型，编译器自动生成的构造函数，对
内置类型没有规定要不要处理（看编译器，有些编译器不做处理则初始化为随机值，有些则初始化为0），对自定义类型成员变量才会调用它的无参构造。
内置类型就是语言提供的数据类型，如int/char/double……指针等
自定义类型就是我们用class/struct/union等自己定义的类型
class Date
{
public:
Date()
{
_year = 2024;
_month = 6;
_day = 1;
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
class Time //定义Time类
{
public:
void Print()
{
cout << _hour << ":" << _minute << ":" << _sec << endl;
}
private:
//内置类型
int _hour;//时
int _minute;//分
int _sec;//秒
//自定义类型
Date _d1;
};
int main()
{
Time t1;//调用无参构造函数
t1.Print();
return 0;
}
结果如下：
可以发现，编译器生成的构造函数对内置类型不做处理，生成随机值，对自定义类型调用它的默认构造函数。
注意：如果我们没有对自定义类型显示写构造函数，那么编译器在调用它的默认构造函数时也会和内置类型一样生成随机值。
如果自定义类型没有默认构造函数，则编译器会报错。
注意：C++11中对内置类型不初始化的缺陷给打了补丁，即：内置类型成员在类中声明时可以给默认值。如下：
class Date
{
public:
Date()
{
_year = 2024;
_month = 6;
_day = 1;
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
class Time //定义Time类
{
public:
void Print()
{
cout << _hour << ":" << _minute << ":" << _sec << endl;
}
private:
//内置类型
int _hour = 12;//时
int _minute = 10;//分
int _sec = 30;//秒
//自定义类型
Date _d1;
};
int main()
{
Time t1;//调用无参构造函数
t1.Print();
return 0;
}
结果如下：
对内置类型声明的过程中，给一个缺省值，编译器就可以用缺省值来初始化。
- 默认构造函数包括：无参构造函数、全缺省构造函数、我们没有写编译器默认生成的构造函数。并且默认构造函数
只能有一个。
简单点说就是不传参数就可以调用的就是默认构造函数。
class Time //定义Time类
{
public:
//无参构造函数
/*Time()
{
_hour = 0;
_minute = 0;
_sec = 0;
}*/
//全缺省构造函数
Time(int hour = 0, int minute = 0, int sec = 0)
{
_hour = hour;
_minute = minute;
_sec = sec;
}
void Print()
{
cout << _hour << ":" << _minute << ":" << _sec << endl;
}
private:
int _hour;//时
int _minute;//分
int _sec;//秒
};
int main()
{
Time t1;
t1.Print();
return 0;
}
无参构造函数和全缺省构造函数只能存在一个，否则会报错
初始化列表
1.构造函数整体赋值
在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
class Time //定义Time类
{
public:
Time(int hour, int minute, int sec)
{
_hour = hour;
_minute = minute;
_sec = sec;
}
private:
int _hour;//时
int _minute;//分
int _sec;//秒
};
但是上述代码并不能将其称为成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化，因为初始化只能初始化一次，而构造函数体内可以多次赋值。如：
Time(int hour, int minute, int sec)
{
_hour = hour;
_minute = minute;
_sec = sec;
_sec = 11;
}
上述代码就对sec这个成员变量进行了两次赋值，则不能称为初始化。
2.初始化列表
初始化列表本质上可以理解为每个对象中成员变量定义的地方。
格式为：以一个冒号开始，接着以一个逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或者是表达式。
即：
构造函数名([参数表])
:[成员初始化表]
{
[构造函数体]
} //其中，方括号[]中的内容可有可无
则Time类用初始化列表形式如下：
class Time //定义Time类
{
public:
Time(int hour, int minute, int sec)
:_hour(hour)
,_minute(minute)
,_sec(sec)
{}
private:
int _hour;//时
int _minute;//分 //成员变量的声明
int _sec;//秒
};
使用初始化列表时有以下几个需要注意的点：
- 每个成员变量在初始化表中只能出现一次（初始化只能初始化一次）
- 类中包括以下成员的，必须要在初始化列表初始化：
- 引用成员变量
- const成员变量
- 自定义类型成员（且该类没有默认构造函数时）
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int x, int y, int z)
:_x(x)
,_y(y)
,_z(z)
{}
private:
int& _x; //引用
const int _y; //const
A _z; //自定义类型没有默认构造函数
};
- 如果数据成员时数组，则应该在构造函数的函数体中用语句对其赋值，而不能在初始参数列表初始化。 如：
class Student
{
public:
Student(int num, char sex, const char name[])
:_num(num)
,_sex(sex)
{
strcpy_s(_name, name);
}
private:
int _num; //序号
char _sex; //性别
char _name[20]; //姓名
};
- 对于初始化列表，不管你写不写(如果不写，编译器会自动生成)，对于自定义类型成员，一定会先试用初始化列表初始化。
- 成员变量在类中声明次序就是在其初始化列表中的初始化顺序，与其在初始化列表的先后次序无关。如：
class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Print()
{
cout << "_a1 = " << _a1 << " _a2 = " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A a(10);
a.Print();
return 0;
}
运行结果如下：
我们发现，_a2是一个随机值，是因为_a2先声明，则它先初始化，它是用_a1进行初始化的，但是_a1并没有初始化，所以_a2是一个随机值，然后是_a1的声明，将1给了_a1进行初始化（类型转换，将整型转化为自定义类型），所以就得出_a1是1，_a2是随机值的结果。
所以，我们在进行初始化时尽量按照先声明先定义的原则去进行初始化。
析构函数
1.析构函数的概念
析构函数的作用与构造函数相反，但是析构函数并不是完成对对象本身的销毁，局部对象出了作用域会自行销毁。但是对象在销毁的时候会自动调用析构函数，完成对象中资源清理的工作。
2.析构函数的特性
析构函数同样是特殊的成员函数，所以它也有一些独特的特性
- 析构函数名是在类名前面加上字符~。
- 无参数无返回值类型
- 一个类只能有一个析构函数，若未显示定义，编译器会自动生成默认的析构函数。注意：析构函数不能重载。
- 对象生命周期结束时，C++编译系统会自动调用析构函数。
如：
class Time
{
public:
Time()
{
cout << "Time()" << endl;
}
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _sec;
};
int main()
{
Time t1;
return 0;
}
我们显示定义了一个构造函数和一个析构函数，但是我们并没有调用它，编译器会自动调用。
- 编译器自动生成的析构函数，对内置类型不做处理，对自定义类型调用它的析构函数。如：
class Date
{
public:
~Date()
{
cout << "~Date()" << endl;//证明调用了析构函数
}
private:
int _year;
int _month;
int _day;
};
class Time //定义Time类
{
private:
//内置类型
int _hour = 12;//时
int _minute = 10;//分
int _sec = 30;//秒
//自定义类型
Date _d1;
};
int main()
{
Time t1;//调用无参构造函数
return 0;
}
要注意的是，虽然我们区分了编译器对两种类型的处理方式，但实际上，我们不需要担心内置类型是否被处理了，是因为内置类型在生命周期结束时会自动销毁，没有资源需要清理，但自定义类型则需要担心，因为它可能是malloc，new，open出来的，此时就必须要写析构函数去清理。如栈：
typedef int DataType;
class Stack
{
public:
Stack(int n = 4)
{
_arr = (DataType*)malloc(n * sizeof(DataType));
if (_arr == nullptr)
{
perror("malloc fail");
return;
}
_top = 0;
_capacity = 4;
}
void Push(DataType a)
{
_arr[_top++] = a;
}
DataType Top()
{
return _arr[_top-1];
}
//...
~Stack()
{
free(_arr);
_arr = nullptr;
_top = 0;
_capacity = 0;
cout << "~Stack()" << endl;
}
private:
DataType* _arr;
int _top;
int _capacity;
};
int main()
{
Stack st;
st.Push(1);
cout << st.Top() << endl;
return 0;
}
栈在初始化的时候要malloc一块空间，所以以前我们在写栈的时候需要手动给它destroy，但是我们往往会忽视这一个小细节，如果不把这些需要清理的东西清理掉，则会导致内存泄漏。而有了析构函数，我们不需要去调用，编译器也可以自行调用清理。但是，这需要我们显示定义才可以。
总的来说：
- 有资源需要清理的就要写析构，如：Stack，List。
- 有两种场景
不需要写析构，编译器默认生成就可以了：
a.没有资源需要处理，如Time类，Date类
b.内置类型成员没有资源需要处理，剩下全是自定义类型，如MyQueue（两个栈实现一个队列）。
今天的内容到此结束啦，感谢大家观看，如果大家喜欢，希望大家一键三连支持一下，如有表述不正确，也欢迎大家批评指正。
1054
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
