类和对象（中）

一、类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面 6个默认成员函数 。

class Date
{
}；

默认成员函数： 就是用户没有显示实现该成员函数，编译器会替用户实现一份，没有显示定义就是没有自己实现。

二、构造函数

1、构造函数的概念

名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

例如，以下日期类中的成员函数Date就是一个构造函数。当你用该日期类创建一个对象时，编译器会自动调用该构造函数对新创建的变量进行初始化。
代码如下：

class Date
{
public:Date(int year = 0, 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;
};

2、构造函数的特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
   代码如下:

#include<iostream>
class Date
{
public:Date()                              //无参构造函数{}Date(int year, int month, int day) //带参构造函数{_year = year;_month = month;_day = day;}void Display(){std::cout << _year << ":" << _month << ":" << _day << std::endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;               //调用无参构造函数d1.Display();Date d2(2021, 5, 30);  //调用带参构造函数d2.Display();Date d3();            //此时并没有调用构造函数，对象并没有实例化出来，不知道是函数的声明,还是构造函数。return 0;
}

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

class Date
{
public:/*// 如果用户显式定义了构造函数，编译器将不再生成Date (int year, int month, int day){_year = year;_month = month;_day = day;}*/
private:int _year;int _month;int _day;
};
void Test()
{// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数Date d;
}

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

#include<iostream>
class Date
{
public:Date()                                             //1.无参构造函数{_year = 1000;_month = 1;_day = 1;}Date(int year = 1000, int month = 1, int day = 1)  //2.全缺省构造函数{_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
int main()
{Date d1; //对象实例化时自动调用构造函数，所以这里不能调用两个构造函数。return 0;
}

7. 关于编译器生成的默认成员函数，会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？

解答： C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…；自定义类型就是我们使用自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数,自定义类型——》class/struct/union。

#include<iostream>
class Time
{
public:Time(){std::cout << "Time()" << std::endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};
/
class Date
{
public:void print(){std::cout << _year << ":" << _month << ":" << _day << std::endl;}
private://类置内型不初始化int _year;int _month;int _day;//自定义类型初始化Time _t;
};
int main()
{Date d;d.print();return 0;
}

三、析构函数

1、析构函数的概念

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

2、析构函数特性

析构函数是特殊的成员函数。
其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 先构造的后析构，后构造的先析构。
   
   代码如下：

#include<iostream>
#include<assert.h>
typedef int DataType;
class SeqList
{
public:SeqList(int capacity = 10){_pData = (DataType*)malloc(sizeof(DataType)*capacity);assert(_pData);_size = 0;_capacity = capacity;}~SeqList()                 //析构函数完成对类的资源清理{free(_pData);_pData = NULL;_size = _capacity = 0;}
private:DataType* _pData;int _size;int _capacity;
};

四、拷贝构造函数

1、拷贝构造函数的概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用从const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。

#include<iostream>
class Date
{
public:Date(int year = 2021, int month = 5, int day = 31)  //构造函数{_year = year;_month = month;_day = day;}Date(const Date& d2){_year = d2._year;_month = d2._month;_day = d2._day;}void Display(){std::cout << _year << ":" << _month << ":" << _day << std::endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Display();Date d2(d1);  //把d1拷贝给d2d2.Display();
}

2、拷贝构造函数的特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
   
   

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

#include<iostream>
class Date
{
public:Date(int year = 2021, int month = 06, int day = 01){_year = year;_month = month;_day = day;}void Display(){std::cout << _year << ":" << _month << ":" << _day << std::endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Display();Date d2(d1);  //调用默认拷贝构造函数d2.Display();return 0;
}

4. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:String(const char* str = "jack"){_str = (char*)malloc(strlen(str) + 1);strcpy(_str, str);}~String(){std::cout << "~String()" << std::endl;free(_str);}
private:char* _str;
};
int main()
{String s1("hello");String s2(s1);
}

因为调用析构函数时候,调用的浅拷贝，拷贝出来的两个指针指向同一个地址，然后析构时这块空间被释放了两次，第二次free时候对一个已经为空的空间进行释放会发生崩溃，对一个对象插入、删除数据都会导致另一个对象的改变。

总结：

1. 像Date这样的类，需要的就是浅拷贝，那么编译器自动生成的拷贝构造函数就够用了，我们不需要自己写。
2. 像Stack这样的类，浅拷贝会导致析构两次、程序崩溃等问题，需要我们自己写对应的拷贝构造函数。
   

五、运算符重载

1、运算符重载的概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。函数原型：返回值类型 operator操作符(参数列表)。

2、运算重载的特性

注意：

1. 不能通过连接其他符号来创建新的操作符：比如operator@。
2. 重载操作符必须有一个类类型或者枚举类型的操作数。
3. 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
4. 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
5. 操作符有一个默认的形参this，限定为第一个形参。
   .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

1）、例

这里以重载 == 运算符作为例子：
 我们可以将该运算符重载函数作为类的一个成员函数，此时该函数的第一个形参默认为this指针。

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "年" << _month << "月" << _day << "日" << endl;}bool operator==(const Date& d)// 运算符重载函数{return _year == d._year&&_month == d._month&&_day == d._day;}
private:int _year;int _month;int _day;
};

我们也可以将该运算符重载函数放在类外面，但此时外部无法访问类中的成员变量，这时我们可以将类中的成员变量设置为共有(public)，这样外部就可以访问该类的成员变量了（也可以用友元函数解决该问题）。并且在类外没有this指针，所以此时函数的形参我们必须显示的设置两个。

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "年" << _month << "月" << _day << "日" << endl;}int _year;int _month;int _day;
};
bool operator==(const Date& d1, const Date& d2)// 运算符重载函数
{return d1._year == d2._year&&d1._month == d2._month&&d1._day == d2._day;
}

赋值运算符重载
这里以重载 = 运算符作为例子：

class Date
{
public:Date(int year = 0, int month = 1, int day = 1)// 构造函数{_year = year;_month = month;_day = day;}Date& operator=(const Date& d)// 赋值运算符重载函数{if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}void Print()// 打印函数{cout << _year << "年" << _month << "月" << _day << "日" << endl;}
private:int _year;int _month;int _day;
};

赋值运算符主要有五点：

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
   
   这里一个三句代码，我们现在都知道第二句代码调用的是拷贝构造函数，那么第三句代码呢？调用的是哪一个函数？是赋值运算符重载函数吗？

其实第三句代码调用的也是拷贝构造函数，注意区分拷贝构造函数和赋值运算符重载函数的使用场景：
 
 **拷贝构造函数：**用一个已经存在的对象去构造初始化另一个即将创建的对象。
 **赋值运算符重载函数：**在两个对象都已经存在的情况下，将一个对象赋值给另一个对象。

六、const成员函数

1、cont修饰类的成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

2、const修饰类的对象和成员函数

思考下面几个问题（经典面试题）：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其他的非const成员函数吗？
4.非cosnt成员函数内可以调用其他的cosnt成员函数吗？

答案是：不可以、可以、不可以、可以
解释如下：

1. 非const成员函数，即成员函数的this指针没有被const所修饰，我们传入一个被const修饰的对象，用没有被const修饰的this指针进行接收，属于权限的放大，函数调用失败。
2. const成员函数，即成员函数的this指针被const所修饰，我们传入一个没有被const修饰的对象，用被const修饰的this指针进行接收，属于权限的缩小，函数调用成功。
3. 在一个被const所修饰的成员函数中调用其他没有被const所修饰的成员函数，也就是将一个被const修饰的this指针的值赋值给一个没有被const修饰的this指针，属于权限的放大，函数调用失败。
4. 在一个没有被const所修饰的成员函数中调用其他被const所修饰的成员函数，也就是将一个没有被const修饰的this指针的值赋值给一个被const修饰的this指针，属于权限的缩小，函数调用成功。

七、取地址及const取地址操作符重载

取地址操作符重载和const取地址操作符重载，这两个默认成员函数一般不用自己重新定义，使用编译器自动生成的就行了：

class Date
{
public:Date* operator&()// 取地址操作符重载{return this;}const Date* operator&()const// const取地址操作符重载{return this;}
private:int _year;int _month;int _day;
};

扩展

更过关于const成员和运算符重载例子请戳