第三节 类和对象（中）

1. 类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中什么都没有吗？

并不是的，任何一个类在我们不写的情 况下，都会自动生成6个默认成员函数。

分别是构造函数，析构函数，拷贝构造，赋值重载，还有普通对象和const对象取地址（这俩了解即可，不重要）

总结：

构造函数：

1. 大部分的类都需要自己写构造函数

2. 只有像MyQueue这样类不需要显示写构造函数

3. 每个类最好都要提供默认构造函数

析构函数：

1. 一些类需要显示写析构函数，例如，Stack，Queue...

2. 一些类不需要显示写析构函数，比如Date类，没有资源需要清理，还有MyQueue也可以不写，默认生成的就可以

拷贝构造函数：

1. 一些类需要显示写拷贝和赋值，例如：Stack，Queue...

2. 一些类不需要显示写拷贝和赋值，比如Data类，默认生成的就会完成值拷贝/浅拷贝，又比如MyQueue这样的类，默认生成就会调用他的自定义类型成员Stack的拷贝和赋值

2. 构造函数

2.1 概念

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

2.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 ;
 }
private :
 int _year ;
 int _month ;
 int _day ;
};
void TestDate()
{
 Date d1; // 调用无参构造函数
 Date d2 (2015, 1, 1); // 调用带参的构造函数
 
 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
 Date d3(); 
}

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;
}

7. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成 默认的构造函数。但是看起来默认构造函数又没什么用？

d对象调用了编译器生成的默认构造函数，但 是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵 用？？

解答：C++把类型分成内置类型(基本类型)和自定义类型。

内置类型就是语法已经定义好的类型：如 int/char和各种指针（Time* t也算指针）

自定义类型就是我们使用class/struct/union自己定义的类型

看看下面的程序，就会发现默认生成的构造函数，内置类型成员不做处理，自定义类型成员回去调用它的默认构造函数

8.无参构造函数和全缺省构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意，无参构造函数，全缺省构造函数，我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

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;
}

从上述发现，这个设计时C++早期一个缺陷，默认生成构造函数，本来应该内置类型一并处理，所以C++后期打了一个补丁,注意这里并不是初始化，是给缺省值，因为这里是声明

private：
    int _year = 1;
    int _month = 1;
    int _day = 1;

总结：
1. 一般的类不会让编译器默认生成构造函数，都会自己写。显示写一个全缺省，非常好用

2. 特殊情况才会默认生成

8. 成员变量的命名风格

单词和单词之间首字母大写间隔 -- 驼峰法  GetYear

单词全部小写，单词之间_分隔       get_year

函数名，类名等 所有单词首字母大写 DateMgr

变量 首字母小写，后面单词首字母大写  dateMgr

成员变量，首字母前面加_   _dateMgr

3. 析构函数

3.1 概念

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

3.2 特性

析构函数是特殊的成员函数。

其特征如下：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值。

3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数（不能重载）

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class SeqList
{ 
public :
 SeqList (int capacity = 10)
 {
 _pData = (DataType*)malloc(capacity * sizeof(DataType));
 assert(_pData);
 
 _size = 0;
 _capacity = capacity;
}
 
 ~SeqList()
 {
 if (_pData)
 {
 free(_pData ); // 释放堆上的空间
 _pData = NULL; // 将指针置为空
 _capacity = 0;
 _size = 0;
 }
 }
 
private :
 int* _pData ;
 size_t _size;
 size_t _capacity;
};

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？

下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

class String
{
public:
 String(const char* str = "jack")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }
private:
 char* _str;
};
class Person
{
private:
 String _name;
 int _age;
};
int main()
{
 Person p;
 return 0;
}

总结： 动态开辟资源例如malloc开辟堆空间，需要手动释放以及C++队列，链表，二叉树等需要写析构函数

3.3 构造和析构函数调用顺序

这里给出几个例子

 结论：

顺序：先定义后析构，后定义后析构（对象的创建和销毁时栈帧负责的，栈帧与栈里面的对象都要符合后进先出，也就是后定义先销毁/析构）

 

4. 拷贝构造函数

4.1 概念

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

4.2 特性

拷贝构造函数也是特殊的成员函数

其特征如下：

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

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

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

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝函数完成拷贝的

4. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。有些类还是需要的，如果用浅拷贝，一个对象会影响另一个对象，会析构两次，程序崩溃。后面讲深拷贝去解决。

5.赋值运算符重载

5.1 运算符重载

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

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型或者枚举类型的操作数，用于内置类型的操作符其含义不能改变，例如：内置的整型+，不能改变其含义

作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的，操作符有一个默认的形参this，限定为第一个形参

.*  、 ::  、 sizeof  、?:   、.   注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

补充：

流插入和流提取运算符的重载

1. 库里面写好了运算符重载

2.自动识别类型，构成函数重载

5.2 赋值运算符重载

赋值运算符主要有五点：

1. 参数类型：const T& ，传递引用可以提高传参效率

2. 返回值类型：T&，返回引用可以提高返回效率，有返回值的目的是为了支持连续赋值

3. 检测是否自己给自己赋值

4. 返回*this：要复合连续赋值的含义

5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，以值的方式逐字节拷贝，涉及到深拷贝需要自己写（内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符完成赋值）

6. 日期类的实现

6.1被 频繁调用函数的使用

// 获取某年某月的天数
 int GetMonthDay(int year, int month)
 {
 static int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 int day = days[month];
 if (month == 2
 &&((year % 4 == 0 && year % 100 != 0) || (year%400 == 0)))
 {
 day += 1;
 }
 return day;
 }

上述代码有两点注意：

1. 需要写在类里面，因为需要频繁调用

2. 用static，定义局部静态，不用次次创建

若以后写遇到需要频繁调用的函数和变量都可以参考，可以提高运行效率

6.2 前后置++的区分

// 前置++

Date& operator++();

// 后置++

Date operator++(int);

 这俩直接按特性重载，无法区分

所以特殊处理，使用重载区分，后置++重载增加一个int参数构成函数重载进行区分

任何一个类，只需要写一个 >  ==或者< == 重载，剩下比较运算符重载复用即可

6.3 日期类模板

class Date
{
public:
 // 获取某年某月的天数
 int GetMonthDay(int year, int month)
 {
 static int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 int day = days[month];
 if (month == 2
 &&((year % 4 == 0 && year % 100 != 0) || (year%400 == 0)))
 {
 day += 1;
 }
 return day;
 }
 
 // 全缺省的构造函数
 Date(int year = 1900, int month = 1, int day = 1);
 // 拷贝构造函数
 // d2(d1)
 Date(const Date& d);
 
 // 赋值运算符重载
 // d2 = d3 -> d2.operator=(&d2, d3)
 Date& operator=(const Date& d);
 // 析构函数
 ~Date();
 // 日期+=天数
 Date& operator+=(int day);
 // 日期+天数
 Date operator+(int day);
 // 日期-天数
 Date operator-(int day);
// 日期-=天数
 Date& operator-=(int day);
 // 前置++
 Date& operator++();
 // 后置++
 Date operator++(int);
 // 后置--
 Date operator--(int);
 // 前置--
 Date& operator--();
 
 // >运算符重载
 bool operator>(const Date& d);
 // ==运算符重载
 bool operator==(const Date& d);
 // >=运算符重载
 inline bool operator >= (const Date& d);
 
 // <运算符重载
 bool operator < (const Date& d);
 // <=运算符重载
 bool operator <= (const Date& d);
 // !=运算符重载
 bool operator != (const Date& d);
 // 日期-日期 返回天数
 int operator-(const Date& d);
private:
 int _year;
 int _month;
 int _day;
};

注：重载操作符必须有一个类类型参数，不能全是int之类的内置

7. const成员

7.1 const修饰类的成员函数

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

 

//void Date::Print(const Date* const this)

void Date::Print() const

//修饰的this指向的内容，也就是保证了成员函数内部不会修改成员变量

//const对象和非const对象都可以调用这个成员函数

class Date
{ 
public :
 void Display ()
 {
 cout<<"Display ()" <<endl;
 cout<<"year:" <<_year<< endl;
 cout<<"month:" <<_month<< endl;
 cout<<"day:" <<_day<< endl<<endl ;
 }
 void Display () const
 {
 cout<<"Display () const" <<endl;
 cout<<"year:" <<_year<< endl;
 cout<<"month:" <<_month<< endl;
 cout<<"day:" <<_day<< endl<<endl;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};
void Test ()
{
 Date d1 ;
 d1.Display ();
 
 const Date d2;
 d2.Display ();
}

1. const对象可以调用非const成员函数吗？

不能，权限放大。

2. 非const对象可以调用const成员函数吗？

可以，权限的缩小。

总结：

1、const对象只能调用const成员函数、不能调用非const成员函数；
2、非const对象可以调用const成员函数。

8. 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
{ 
public :
 Date* operator&()
 {
 return this ;
 }
 
 const Date* operator&()const
 {
 return this ;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！