类和对象（中）

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

空类：一个类中什么成员都没有，我们称为空类

那么空类中是真的什么都没有么？实际上，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

2.构造函数

如果我们在创建对象之后都要进行自己手动初始化非常麻烦，于是便有了构造函数的概念。

2.1概念

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

2.2 特性

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

其特征如下：

1. 函数名与类名相同。

2. 无返回值。

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函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();
 }

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

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

lass Date
{
public:
    /*Date()      //无参
    {
        _year = 1;
        _month = 1;
        _day = 0;
    }
    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;
    }
    void Print()
    {
        cout << _year << "." << _month << "." << _day <<  endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date D1;
    D1.Print();
    Date D2(2023, 9, 22);
    D2.Print();
    return 0;
}

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...任意类型指针，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

默认生成构造函数：

（1）内置类型成员不做处理

（2）自定义类型的成员，会去调用它的默认构造（不用传参数的构造）

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。要注意，这里不是初始化，是给缺省值

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

3.析构函数

3.1 概念

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

3.2 特性 

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

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

2. 无参数无返回值类型。

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

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

5.默认生成的析构函数，对于自定义类型成员，会调用它的析构函数，对于内置类型成员不做处理。

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

这里的重点是有没有资源申请，就是没有资源申请，无论是自定义还是内置写不写都行，有资源申请就都得写析构

4. 拷贝构造函数

4.1 概念

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

不加const有两大坏处：

1.防止人失误写反了

2.如果你传进去的类型本身就是const，不加const就会权限放大

4.2 特征

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

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

2. 语法限制拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // Date(Date d)   // 错误写法：编译报错，会引发无穷递归
    Date(const Date& d)   // 正确写法，加const的原因是害怕人将下面写反
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(d1);     //拷贝构造
 Date d3 = d1;   //拷贝构造的第二种写法
 return 0;
}

如果不是语法强制限制， Date(Date d) 这样的写法会发生无穷递归，因为在调用d2的时候要传参，传参就要调用拷贝构造，然后拷贝构造要传参，传值传参就要调用拷贝构造，依次循环，就发生了无穷递归 。传引用的化d就是d1的别名

内置类型编译器可以直接拷贝，自定义类型需要调用拷贝构造，假设自定义里类型是栈，拷贝是按字节拷贝，如果把_a拷贝过去，两个结构体，指向的都是同一块空间，接下来调用析构函数的时候，同一块空间不能析构两次，这时候就要用深拷贝拷贝构造。

如果你要是传指针完成拷贝的话不叫拷贝构造，就只是普通的拷贝函数，虽然完成的功能是一样的，但是传指针比较麻烦

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
     Time()
     {
         _hour = 1;
         _minute = 1;
         _second = 1;
     }
     Time(const Time& t)
     {
         _hour = t._hour;
         _minute = t._minute;
         _second = t._second;
         cout << "Time::Time(const 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 d1; 
     // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
     Date d2(d1);
     return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。（一定要好好理解这句话）

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

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
     Stack(size_t capacity = 10)
     {
         _array = (DataType*)malloc(capacity * sizeof(DataType));
         if (nullptr == _array)
         {
             perror("malloc申请空间失败");
             return;
         }
     _size = 0;
     _capacity = capacity;
     }
     void Push(const DataType& data)
     {
         // CheckCapacity();
         _array[_size] = data;
         _size++;
     }
     ~Stack()
     {
         if (_array)
         {
             free(_array);
             _array = nullptr;
             _capacity = 0;
             _size = 0;
         }
     }
private:
     DataType *_array;
     size_t _size;
     size_t _capacity;
};
int main()
{
     Stack s1;
     s1.Push(1);
     s1.Push(2);
     s1.Push(3);
     s1.Push(4);
     Stack s2(s1);
     return 0;
}

这里面有个成员很特殊_array它是一个指针，指向了一块空间，如果用值拷贝拷贝过去，就会发生两个对象指向同一块空间，可能会出现两个问题

1.插入删除数据会相互影响比如，当给你给里面push数据的时候，会互相覆盖，因为push的时候，是按照size的位置去走的

2.后续析构的时候，会析构两次，程序就会崩溃，s1和s2谁先析构呢，s2先析构，因为在栈区，先进栈的要先出栈，当你把s2的指针置空之后，s1的指针不会变成空。你把那块空间释放了s1就是野指针了。

面对这种情况我们应该如何去拷贝呢，我们就应该用深拷贝。就是在拷贝构造里面申请一块空间，然后把再用memcpy把空间里面的值拷贝进去。

什么情况需要些拷贝构造呢？

如果自己实现了析构函数释放空间，就需要实现拷贝构造。不能单单拿指针来衡量。

5. 拷贝构造函数典型调用场景：

使用已存在对象创建新对象

函数参数类型为类类型对象

函数返回值类型为类类型对象

class Date
{
public:
 Date(int year, int minute, int day)
 {
 cout << "Date(int,int,int):" << this << endl;
 }
 Date(const Date& d)
 {
 cout << "Date(const Date& d):" << this << endl;
 }
 ~Date()
 {
 cout << "~Date():" << this << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
Date Test(Date d)
{
 Date temp(d);
 return temp;
}
int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}

为了提高程序效率，如果没有返回值，一般对象传参时，尽量使用引用类型，有返回值时根据实际场景，能用引用尽量使用引用。

5.赋值运算符重载

5.1 运算符重载

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

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

注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• .*  ::  sizeof  ?:  . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
• 第一个操作数必须是左操作数，第二个操作数必须是右操作数，顺序不能换

比如我想对==进行运算符重载

bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
        && d1._month == d2._month
        && d1._day == d2.day;
}
//这么写在类外面成员变量必须是公有的才能用，否则不能用 
int main
{
    Date d1(2023, 2, 4);
    Date d2(2023, 2, 4);
    cout << operator==(d1 , d2) << endl;
    //cout << d1 == d2 << endl; 
    //这种写法就会报错因为会出现运算符优先级的问题，<<的优先级比==高，他会先算cout << d1 然后返回值再算== 但是他们之间根本就不能计算所以会报错
    cout << (d1 == d2) << endl;
    //d1 == d2在运行的时候，编译器会看它是什么类型，如果是自定义类型就会转换成call 地址，去调用operator==的函数
    return 0;
}

上面这种写法是因为将成员变量设置为了公有，所以我们才能使用，如果成员变量在类里面是私有，那我们该如何访问呢？

1.提供一些公有的函数，如getyear，getmonth，用函数来获取他们的值

2.我们可以将这个函数放在类里面来实现，要注意类里面有一个隐含的操作数this，所以我们在传参数的时候就传d2就可以了

下面是一些常见的运算符重载

class Date
{
public:
    bool operator==(const Date& d2)
    {
        return _year == d2._year
            && _month == d2._month
            && _day == d2._day;
    }
bool operator<(const Date& d2)
    {
        return _year < d2._year
            || _year == d2._year && _month < d2._month
            || _year == d2._year && _month == d2._month && _day < d2._day;
    }
    bool operator>(const Date& d2)   //直接复用前面的逻辑就可以了
    {
        return !(*this < d2) && !(*this == d2);
    }
    bool operator<=(const Date& d2)
    {
        return !(*this > d2);
    }
    bool operator>=(const Date& d2)
    {
        return !(*this < d2);
    }
 bool operator!=(const Date& d2)
    {
        return !(*this == d2);
    }
 Date& Date::operator+=(int day)
{
    if (day < 0)
    {
        *this -= -day;
    }
    else
    {
        _day += day;
        while (_day > GetMonthDay(_year, _month))
        {
            _day -= GetMonthDay(_year, _month);
            ++_month;
            if (_month == 13)
            {
                ++_year;
                _month = 1;
            }
        }
    }
    return *this;
}
Date Date::operator+(int day)
{
    Date tmp = *this;
    tmp += day;
    /*tmp._day += day;
    while (tmp._day > GetMonthDay(tmp._year, tmp._month))
    {
        tmp._day -= GetMonthDay(tmp._year, tmp. _month);
        ++tmp._month;
        if (tmp._month == 13)
        {
            ++tmp._year;
            tmp._month = 1;
        }
    }*/
    return tmp;
}
Date& Date::operator-=(int day)
{
    if (day < 0)
    {
        *this += -day;

    }
    else
    {
        _day -= day;
        while (_day <= 0)
        {

            --_month;
            if (_month == 0)
            {
                --_year;
                _month = 12;
            }
            _day += GetMonthDay(_year, _month);
        }
    }    
    return *this;
}
Date Date::operator-(int day)
{
    Date tmp(*this);
    tmp -= day;
    return tmp;
}
private:
    int _year;
    int _month;
    int _day;
};

int main
{
    Date d1(2023, 2, 4);
    Date d2(2023, 2, 4);
    cout << d1.operator(d2) << endl; 
      return 0;
}

5.2 赋值运算符重载

1. 赋值运算符重载格式

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

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

检测是否自己给自己赋值

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

Date& operator=(const Date& d2)
    {
         if（ this != &d2）//判断一下是不是自己给自己赋值，自己给自己赋值直接返回
         {                                 
        _year = d2._year;
        _month = d2._month;
        _day = d2._day;
         }
        return *this;

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必

须要实现。

5.3 前置++和后置++重载

// 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
Date& Date::operator++()
{
     *this += 1;
     return *this;
}
//后置++
Date Date::operator++(int)
{
    Date tmp(*this);
     *this += 1;
     return tmp;
}
  
Date& Date::operator--()
{
     *this -= 1;
     return *this;
}
Date Date::operator--(int)
{
    Date tmp(*this);
      *this -= 1;
       return tmp;
}

前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载

C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。只能是int类型，其他类型不行。

注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1，而temp是临时对象，因此只能以值的方式返回，不能返回引用

我们自定义类型建议多用前置++，因为前置++是传引用返回。

5.4 -的函数重载

之前我们写的逻辑是日期-天数算的是日期之间的天数是几号，那么日期 - 日期也是有意义，它算的是两个日期之间隔了多少天

int Date::operator-(const Date& d)
{
     Date max = *this;
     Date min = d;
     int flag = 1;
    
     if (*this < d)
     {
         max = d;
         min = *this;
         flag = -1;
     }

     int n = 0;
     while (min != max)
     {
        ++min;
        ++n;
     }
     return n * flag; 
}

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

流插入

现在我们在回过头来看，> 能自动识别类型，实际上就是运算符重载 和 函数重载，cout 和cin 是类对象，cout是一个ostream类型的全局对象，cerr和clog我们很少用，ostream对内置类型都进行了支持，所以他能自动识别类型，那么自定义类型的流插入和流提取就需要我们自己来写

void Date::operator<<(ostream& out)
{
    out << _year << "年" << _month << "月" << _day << "日" << endl;
}

如果我们这样写的化，根据第一个参数必须是左操作数，第二个参数必须是右操作数。我们在使用的时候就必须d1<<cout;这样使用。如果这样使用，就不符合我们的逻辑了。

如果我们把运算符重载定义在类里面，那么第一个参数默认就是this指针。但是我们并没有说过运算符重载必须定义在类里面，我们把成员函数放在类里面的原因是因为我们想访问私有，我们可以把他作为全局函数。这样我们就能把ostream放到第一个参数去。

我们可以用写一个公有的函数来获取私有的值。我们也可以使用友元函数，这里我们使用友元函数，把他写在类里面，意思就是这函数是我的朋友可以使用我的私有。

friend ostream& operator<<(ostream& out, const Date& d);

为了满足可以连续流插入（cout << d1 << d2 << endl;)，因为这个运算符是从左开始算，所以我们最后要返回cout。

ostream& operator<<(ostream& out,const Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    return out;  // out是cout的别名
}

c++为什么要支持流插入，因为用printf只能打印内置类型，对于自定义类型，我们不能打印，所以我们可以自己设计自定义类型的规则。

流插入相比c语言是要低效一点点的，因为他有大量的函数调用，其次是为了兼容c语言。print和cout没有用同样的缓冲区，要和c语言同步。cout和printf混着使用也能保证正常的顺序。如果要把同步关掉，性能也能提升不少。实际上性能也没差多少。

流提取

friend istream& operator>>(istream& in, Date& d);

istream& operator>>(istream& in, Date& d)
{
    in >> d._year >> d._month >> d._day;
    return in;
}

想这种短小的函数也可以直接搞成内联，如果在类里面直接声明和定义编译器会默认内联函数。

只有声明没有定义，就要去链接， 声明和定义都有就不用去链接了。

6.const成员函数

class A
{
public:
    void Print()
    {
        cout << _a << endl;
    }
private:
    int _a = 10;
};
int main()
{
       const A aa;
    aa.Print();
     return 0;
}

此时，如果这样调用aa的话会报错。其实是权限的放大问题。这样&aa的类型是 const A*，他指向的内容不能被修改，而this指针的类型是A*，我自己都不能改变，我传给你之后，你还可以改变了，就造成了权限的放大问题。如何去改变this指针类型的，实际上我们无法显示的 改变this指针的类型，他是隐含的参数，所以我们只能用间接的方式，在函数后面加上const

const 修饰*this ，this 的类型编程const A*，只有这种办法

class A
{
public:
    void Print() const   //语法规定：const修饰*this
    {
        cout << _a << endl;
    }
private:
    int _a = 10;
};
int main()
{
    const A aa;
    aa.Print();
    return 0;
}

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

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

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

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