2.c++面向对象(二)
一.类的6个默认成员函数
二.构造函数
1.构造函数概念
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(2022, 7, 5);d1.Print();Date d2;d2.Init(2022, 7, 6);d2.Print();return 0;
}对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置 信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
2.特性
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。(不需要写void)
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
class Date
{
public:// 1.无参构造函数Date(){}// 2.带参构造函数Date(int year, int month, int day){_year = year;_month = month;_day = day;}Date(int year = 1,int month = 1,int day = 1){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};void TestDate()
{//Date d1(); //无参的不能这么写,无法和函数声明区分开Date d1; // 调用无参构造函数Date d2(2015, 1, 1); // 调用带参的构造函数// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d3();
}我们还可以在构造函数中进行写我们自己的内容
我们一般可以写多个构造函数如上:(有无参的构造函数和三个参数的构造函数)
我们一般推荐写一个全缺省的构造函数(但是全缺省和无参的不能同时存在,存在调用歧义)
缺省参数声明和定义分离的时候,一般是在声明的时候给,定义的时候不给
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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再// 生成无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用Date d1;return 0;
}不写会自己生成,默认生成的会执行以下的操作:
对于内置类型/基本类型 int/char/double... (不做处理,看编译器)
对于自定义类型 class/struct.... (调用无参构造,没有无参构造就会报错)
所以我们不能保有侥幸心理
自动生成的构造函数意义何在？
下面不写构造函数,但是会进行初始化(会调用我们自己写的Stack的构造函数)
// 两个栈实现一个队列
class MyQueue
{
private:Stack _pushst;Stack _popst;
};7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为 是默认构造函数。(不传参数就能调用的就叫默认构造参数)
以上三个默认构造函数,理论上而言只能存在一个
如果不想写构造函数,编译器生成构造函数还是不放心,我们还可以给缺省值,如下:
缺省值的优先级还是没有我们手动传参高
三.析构函数
1.概念
通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
2.特性
析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
typedef int DataType;class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");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 s;s.Push(1);s.Push(2);
}析构函数和构造函数基本上是同理的
5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器 生成的默认析构函数，对自定类型成员调用它的析构函数。
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()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,
_day三个是
// 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对
象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：
main函数
// 中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date
类的析构函
// 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部
调用Time
// 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
// main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析
构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数
析构函数可以进行自己调用,但是这样就会调用两次(有要析构的资源,一定要进行判断,不然的话,该资源会析构两次)
总结:自己malloc或者new或者fopen出来的,一定要进行析构防止内存泄漏
这里提醒,内存泄漏是不会进行报错了(但是就相当于是慢性病,发现的时候就是严重的病了)
自定义类型会自己调用自己的析构函数
四.拷贝构造函数
1.概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。
2.特征
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。
拷贝构造：用同类型的对象拷贝初始化
我们将一个简单的列子:
不是&的情况如下:
这里传参会调用拷贝构造,用 d2 去初始化 d ,调用拷贝构造的时候,要先传参,传参就要进行拷贝构造.... 这样就陷入了无限的循环了
是&的情况如下:
这里传参会调用拷贝构造,用 d2 去初始化 d ,调用拷贝构造的时候,直接用&就相当于是取别名了(不用拷贝了)
当然指针也是可以的(但是c++更喜欢用引用,而且指针不算拷贝构造,编译器还会生成值拷贝构造)
这里编译器做了强制检查,所以我们不需要太过担心
这里要拷贝别人,结果被别人改了
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
这里的值拷贝将 st1._array 的值直接赋值给 st2._array 了
浅拷贝(值)的危害:
1. st1在push数据的时候,st2数据有,但是_size和_capacity是不会改变的
2. 对一块_array空间之间析构了两次,会导致直接奔溃
这里Stack进行拷贝的时候,我们应该使用深拷贝,确保程序的正确
深拷贝如下:
自己开空间,然后进行内容的拷贝
如Date是不用自己写拷贝构造的,但是Stack是要自己进行写拷贝的(有自己申请的资源,就要进行深拷贝)
深拷贝代码实现如下:
// Stack st2 = st1;Stack(const Stack& st){_array = (DataType*)malloc(sizeof(DataType) * st._capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}memcpy(_array, st._array, sizeof(DataType) * st._size);_size = st._size;_capacity = st._capacity;}
对于st2进行添加元素和删除元素等,对于st1没有影响
五.运算符重载
比较大小的运算符重载如下
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 = 1;int _month = 1;int _day = 1;
};// // 大于
//bool DateGreater(const Date& dt1, const Date& dt2)
bool operator>(const Date& dt1, const Date& dt2)
{if (dt1._year > dt2._year){return true;}else if (dt1._year == dt2._year){if (dt1._month > dt2._month){return true;}else if (dt1._month == dt2._month){return dt1._day > dt2._day;}}return false;
}// // 小于
//bool DateLess(const Date& dt1, const Date& dt2)
bool operator<(const Date& dt1, const Date& dt2)
{if (dt1._year < dt2._year){return true;}else if (dt1._year == dt2._year){if (dt1._month < dt2._month){return true;}else if (dt1._month == dt2._month){return dt1._day < dt2._day;}}return false;
}int main()
{Date d1(2024, 4, 12);Date d2(2024, 4, 10);/*cout << DateGreater(d1, d2) << endl;cout << DateLess(d1, d2) << endl;*/cout << operator>(d1, d2) << endl;cout << (d1 > d2) << endl;cout << (d1 < d2) << endl;Date d3(2020, 2, 5);//int n = d1 - d3;return 0;
}我们下节进行讲解