C++基础（六）：类和对象（中-1）-CSDN博客

本文链接：https://blog.csdn.net/weixin_47040031/article/details/140185124

上一篇博客，我们进入了面向对象的学习，知道了如何设计类，如何创建使用对象，这一篇博客我们再一次深入学习，这一节是类和对象的重点，其中的逻辑比较强，我们要深刻理解，消化，C++的难点就在于编译器底层帮我们做了很多，我们表面看不到的工作，因此，我们需要理清楚底层的逻辑，只有理解了，才会运用它！加油吧，耐心点。

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

如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。 默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

拷贝构造和赋值重载的区别：

赋值重载d1=d2：两个对象（d1和d2）都已经存在且初始化好了，现在我想把d2赋值（拷贝）给d1;
拷贝构造Date d3(d1) : 对象d3还不存在，创建d3对象时用d1去初始化d3对象。

注意：这个Date d4 = d1 是拷贝构造，而不是赋值重载，因为d4还不存在！与上面写法等价

二、构造函数

2.1 概念

对于以下Date类：

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.2 特性（重点）

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

1、函数名与类名相同。

2、构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写，也不可写void。实际上构造函数有返回值，返回的就是构造函数所创建的对象。

3、在程序运行时，当新的对象被实例化，该对象所属的类构造函数自动被编译器调用，在该对象生存期中也只调用这一次。

4、构造函数可以重载。严格地讲, 类中可以定多个构造函数, 它们由不同的参数表区分，系统，在自动调用时按一般函数重载的规则选一个执行。

5、构造函数可以在类中定义，也可以在类中声明，在类外定义。

class Date
 {
  public:
      // 1.无参构造函数
      Date()
      {
          _year  = 0;
          _month = 0;
          _day   = 0;
      }
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;
          _month = month;
          _day = day;
     }

  private:
      int _year;
      int _month;
      int _day;
 };

int main()
{
     Date d1;                 // 调用无参构造函数
     Date d2(2015, 1, 1);    // 调用带参的构造函数
     Date d3{2017, 1 3};    //C++11的初始化方法

     Date d4=Date(2016, 1 ,2);
     


     Date d5();   //这是错误的！！！！  // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
  
注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
上面代码的函数：声明了d5函数，该函数无参，返回一个日期类型的对象
    

     

}

总结：

一个类中可以定义两个构造函数（一个无参适合初始化为固定值，另一个为带参构造函数初始化为需要初始化的值），形成构造函数的重载。如果想要使用带参的构造函数初始化对象，只需要在对象创建时的后面加一个圆括号，里面写上初始化的值，这样，创建对象后，编译器会将对应的实参，传递给相应的对象进行初始化。注意：如果想要使用无参的构造函数，就不要加圆括号了，否则，编译器会认为：这是函数的声明而不是创建对象初始化对象！！！

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()
 {
 1、将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数

 2、将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用！

     Date d1;   //调用无参构造函数
     return 0;
 }

6、关于编译器生成的默认成员函数，很多人会有疑惑：不实现构造函数的情况下，编译器会生成默认无参的构造函数。但是看起来默认无参构造函数又没什么用？因为d对象调用了编译器生成的默认无参构造函数，但是d对象里面的成员变量：_year、_month、_day依旧是随机值。也就说在这里编译器生成的默认无参构造函数并没有对对象的成员变量进行初始化，那这里编译器生成的默认无参构造函数发挥的作用是什么呢？？？？没有用？？？

其实，并不是这样的！！！这也是C++难学的原因，“坑”比较多！原因如下：

请看如下代码：

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;   //由Time实例化对象（这是我们自己创建的数据类型，叫做自定义数据类型）
};

int main()
{
      Date d;  
      return 0;
}

程序运行完，对象d中的_year、_month、_day依旧是随机值，但是_hour 、_minute 、_second都被初始化为0。

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。请看如下代码：

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 = 1970;   内置类型成员变量在类中声明时可以给默认值。
       int _month = 1;     内置类型成员变量在类中声明时可以给默认值。
       int _day = 1;       内置类型成员变量在类中声明时可以给默认值。


      // 自定义类型
      Time _t;
};

int main()
{
    Date d;
    return 0;
}

7、无参的构造函数和全缺省（每个参数都给一个默认值）的构造函数都称为默认构造函数， 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数，并且默认构造函数只能有一个！！！其实，这是函数重载带来的结果，因为：如果都写得化话，编译器不知道该调用哪个构造函数去进行初始化，当然会报错了！！！

默认构造函数的特点:不需要我们传参数!

请看如下代码：

class Date
{
    public:

      Date()
      {
        _year = 1900;
        _month = 1;
        _day = 1;
      }

      Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
         _day = day;
     }

   private:
         int _year;
         int _month;
         int _day;
};

以下测试函数能通过编译吗？不能！！无参构造函数和全缺省构造函数都存在！！！！违背唯一性
void Test()
{

    Date d1;
    return 0;
}

第一种方式：

class Date
{
    public:

      //无参构造函数：直接写死
      Date()
      {
        _year = 1900;
        _month = 1;
        _day = 1;
      }


      //带参构造函数：创建对象时传入
      Date(int year, int month , int day )
     {
         _year = year;
         _month = month;
         _day = day;
     }

   private:
         int _year;
         int _month;
         int _day;
};


void Test()
{

    Date d1;           //调用无参构造函数
    Date d2(2024,7,4);//调用带参构造函数
    return 0;
}

第二种方式，这种方式更好，因为你既可以传入指定的参数初始化，也可以不传参数，使用默认值进行初始化，而且只需要实现构造函数，更加简便！

class Date
{
    public:

      //全缺省默认构造函数
      Date(int year=2024, int month=7 , int day =14)
     {
         _year = year;
         _month = month;
         _day = day;
     }

   private:
         int _year;
         int _month;
         int _day;
};


void Test()
{

    Date d1;           //调用全缺省默认构造函数
    Date d2(2024,5,20);
    return 0;
}

三、析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

3.1 概念

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

3.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 s1;    //再析构这个
    Stack s2    //先析构这个
    s1.Push(1);
    s2.Push(2);
}

注意：创建对象的时候，先创建s1，再创建s2，析构的时候，先析构s2，再析构s1。满足先进后出的特点。

5、关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

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

class Time
{
   public:
      //析构函数
      ~Time()
      {
         cout<<"~Time()"<<endl;
      }
}





class Date
{
    public:

      //全缺省默认构造函数
      Date(int year=2024, int month=7 , int day =14)
     {
         _year = year;
         _month = month;
         _day = day;
        cout<<"Date()"<<this<<endl;
     }

     //可以不写，因为Date类中没有什么资源需要清理，他会自动生成一个默认的析构函数
     /*
        ~Date()
        {
            cout<<"~Date()"<<this<<endl;
        }
     */


   private:
         //内置类型/基本类型  int/char
         int _year;
         int _month;
         int _day;

         //自定义类型
         Time  _t;
};


void Test()
{

    Date d1;           //调用全缺省默认构造函数
    Date d2(2024,5,20);
    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类生成的默认析构函数

注意:创建哪个类的对象则调用该类的构造函数，销毁哪个类的对象则调用该类的析构函数！

四、对象的生命周期

1.对于局部定义的对象，每当程序控制流到达该对象定义处时，调用构造函数。当程序控制走出该局部域时，则调用析构函数。
2.对于静态局部定义的对象，在程序控制首次到达该对象定义处时，调用构造函数。当整个程序结束时调用析构函数。
3.对全局定义的对象，当程序进入入口函数main之前对象就已经定义,这时要调用构造函数。整个程序结束时调用析构函数。
4.动态创建的对象,使用new创建对象, delete释放对象。

五、拷贝构造函数

5.1 概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一模一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用/别名(一般常用const修饰，只可通过引用读取数据，不可修改原对象的数据)，再用已存在的类类型对象创建新对象时由编译器自动调用。拷贝构造函数实质上也是构造函数。

5.2 特征

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

1. 拷贝构造函数是构造函数的一个重载形式（实质上也是一个构造函数）

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

class Date
{
   public:
     Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
  
     下面这个写法是错误的:直接传递对象，编译报错，会引发无穷递归！！！创建很多个对象
    //Date(const Date  d)   

    Date(const Date& d)  正确写法：传递对象的引用/别名，等价于 Date& d =d1;
（是同一个实体，他不会创建另一个对象），引用的类型是类（因为对象的类型是类）
    {
       _year = d._year;
       _month = d._month;
       _day = d._day;
    }
   private:
       int _year;
       int _month;
       int _day;
};

int main()
{
    Date d1;
    Date d2(d1);调用拷贝构造函数，它也是一个构造函数，调用之前先传参，把d1传给d（由d1这个对象               创建另一个d对象）,它又是一次调用拷贝构造函数，如此循环往复.......
                   记住：这里的传参就是一次调用拷贝构造函数！！！
    Date d3=d1;  //这种写法方式和上面等价
   
    return 0;
}

对于内置类型，如果传值的话，那就只是一次简单的赋值，
但这是对象的传参，就是由一个对象去构造一个相同的对象，那就是调用拷贝构造函数！！！

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

class Date
{
    public:
       
        //默认全缺省构造函数
      Time(int year = 1970, 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(2024, 5,20);
    Date d3(d1);   //这里是拷贝构造
    Date d4 = d1;  //这里也是拷贝构造
用已经存在的d1拷贝构造d3，此处会调用Date类的拷贝构造函数，
但Date类并没有显式定义拷贝构造函数，
则编译器会给Date类生成一个默认的拷贝构造函数

    d3.Print();
    d4.Print();

    return 0;
}

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

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

这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
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;
}

上述的程序在运行时会崩溃掉！！！这就是默认构造函数的浅拷贝问题！！！！

解决的办法：这个时候，我们就必须要去实现深拷贝的默认构造函数！而不是使用编译器默认生成的！

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

5.3 拷贝构造函数典型调用场景

这里要讲的是什么时候，会调用拷贝构造函数。

使用已存在对象创建新对象
函数参数类型为类类型对象（参数不是引用，而是对象）
函数返回值类型为类类型对象（返回值不是引用，而是对象）

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(const Date d)   //函数的参数和返回值都是对象
{
         Date temp(d);    
         return temp;
}


int main()
{
          Date d1(2022,1,13);
          Test(d1);
          return 0;
}

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

六、运算符重载（重点）

6.1 运算符重载概念理解

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。自定义类型不可以直接使用运算符，要想使用就必须实现运算符的重载（比较的规则），用的时候就等价于调用运算符重载函数。

函数名字为：关键字 operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)；
运算符的重载实际是一种特殊的函数重载，必须定义一个函数,并告诉C+ +编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数,通常为类的成员函数。

注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this指针。
C++中只有极少数的运算符不允许重载。

实现==运算符重载方式1：类外实现运算符重载函数，缺点：发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？

运算符重载:具有特殊函数名的函数，让自定义类型也可以使用运算符

#include <iostream>
using namespace std;

class Date
{
public:

    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    Date(const Date& d)  //拷贝构造函数参数用常类对象引用
    {
        _year = d._day;
        _month = d._month;
        _day = d._day;
    }


    void Print()
    {
        cout << _year << _month << _day << endl;
    }

// private:
    int _year;
    int _month;
    int _day;
};


//bool IsDateEqual(const Date& d1, const Date& d2)  //自己封装函数实现对象的比较规则
//{
//    //比较的规则
//}


==运算符重载函数：
//运算符有几个操作数，operator重载的函数就有几个参数，如果是两个，第一个是左操作数，第二个是右操作数//


//上述存在问题编译无法通过：对象的成员变量_year、 _month、_day是私有的，类外无法访问！
解决办法1：成员变量改成公有的！
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(2024, 5, 30);
    Date d2(2024, 5, 30);
    //比如Date的对象想比较是否相等？
    //d1 == d2;    //自定义类型不能这样直接比较，因为编译器无法知道自己定义的类型的比较规则，而内置类型编译器已知的！
    /*解决办法1：自己封装函数IsDateEqual()实现对象的比较规则,但是如果比较规则比较复杂，单纯看函数名有时候不容易清楚其实现功能*/
    //IsDateEqual(d1, d2);


    /*解决办法2：运算符重载*/
    d1 == d2;   // 程序运行到这里，会自动地调用运算符重载函数，即编译器会进行转换==> operator==(d1,d2);所以这里就是一个函数调用
    operator==(d1, d2); //直接这样调用也可以,但是我们一般不会这样写，因为这样可读性不好
   

    return 0;
}

实现==运算符重载方式1：直接将==运算符重载函数作为成员函数放在类内。

#include <iostream>
using namespace std;

class Date
{
public:

    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    Date(const Date& d)  //拷贝构造函数参数用常类对象引用
    {
        _year = d._day;
        _month = d._month;
        _day = d._day;
    }



解决办法2：直接将运算符重载函数改成成员函数，这时即使成员变量是私有的，我在类内仍然可以访问！
    //bool   operator==(const Date& d1, const Date& d2) 这样是不对的！！参数过多
   
    //d1 == d2      编译器底层的过程（调用d1的成员函数，将d1对象的指针传给this指针，d2作为引用的实参传递过来）d1.operator==(&d1,d2)
    bool   operator==(const Date& d)   //注意：这里有一个隐含的this指针就是第一个参数 bool  operator==(Date* this, const Date& d)，指向调用这个成员方法的对象（谁调用它，它就指向谁）
    {
        return this->_year == d._day&& _month == d._month&& _day == d._day;
    }


    void Print()
    {
        cout << _year << _month << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};



int main()
{
    Date d1(2024, 5, 30);
    Date d2(2024, 5, 30);
  
    /*解决办法2：直接将运算符重载函数改成成员函数，这时即使成员变量是私有的，我在类内仍然可以访问！*/
    d1 == d2;   // 程序运行到这里，会自动地调用运算符重载成员函数，即编译器会进行转换，d1.operator==(d2); 注意：this指针不允许显示的传参即：d1.operator==(&d1,d2);是错误的
    

    return 0;
}

练习：实现>(大于运算符)的重载：

#include <iostream>
using namespace std;

class Date
{
public:

    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    Date(const Date& d)  //拷贝构造函数参数用常类对象引用
    {
        _year = d._day;
        _month = d._month;
        _day = d._day;
    }



  
    //>大于运算符重载成员函数：
    bool   operator>(const Date& d)   
    {
        if (_year > d._year)
        {
            return true;
        }
        else if (_year == d._year&& _month > d._month)
        {
            return true;
        }
        else if (_year == d._year && _month == d._month && _day > d._day)
        {
            return true;
        }
        return false;
        
    }



    void Print()
    {
        cout << _year << _month << _day << endl;
    }


private:
    int _year;
    int _month;
    int _day;
};



int main()
{
    Date d1(2024, 5, 25);
    Date d2(2024, 5, 30);
  
    cout << (d1 > d2) << endl;
    
    return 0;
}

6.2 赋值运算符重载

赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率，这样不会调用拷贝构造，占用空间；
返回值类型：T&，出了作用域，对象并未销毁！因此可以返回引用，其次，并且有返回值可以支持连续赋值；
检测是否自己给自己赋值；
返回*this ：要复合连续赋值的含义，this指针解引用得到的就是调用的对象；

class Date
{ 
   public :
      Date(int year = 1900, int month = 1, int day = 1)
      {
          _year = year;
          _month = month;
          _day = day;
      }
 
     Date (const Date& d)
     {
        _year = d._year;
        _month = d._month;
        _day = d._day;
     }
 
     //赋值运算符重载的第一种写法，存在缺点：不可以像基本数据类型那样支持连续赋值，如：i=j=k;
     void operator=(const Date& d)
     {
         if(this != &d)   //针对自己给自己赋值的判断检查  d3 = d3
         {
             _year = d._year;
             _month = d._month;
             _day = d._day;
         }
        
        
 }

private:
     int _year ;
     int _month ;
     int _day ;
};


int main()
{
   Date d1;
   Date d2(2024,5,14);
   Date d3;
   d3=d2;
   d3.print();

   d3=d2=d1;  //这里不支持！！！
 
 
}

上述的方式，存在一个缺点就是，不支持连续赋值，如何理解：d3=d2=d1; 首先，先执行右边的d2=d1调用赋值运算符重载函数，但是它没有返回值 ! void不能赋值给d1! ,因此要想保证正确！先执行右边的d2=d1调用赋值运算符重载函数后，必须返回d2！这样才可以赋值给d3！（同类型的对象赋值）如何解决呢？？很简单！那我加个返回值，返回引用（对象的别名，谁调用我，我就给你返回谁），不就好了！这样不就解决了连续赋值问题！！！

因此，在自定义类型数据，函数设计在传参数和返回值时，尽量使用引用，这样可以减少拷贝构造！

代码如下：

class Date
{ 
public :
 Date(int year = 1900, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }
 
 Date (const Date& d)
   {
        _year = d._year;
        _month = d._month;
        _day = d._day;
   }
 
 //d3=d2=d1;    d2=d1 表达式的返回值是d2，才能支持连续赋值
 Date& operator=(const Date& d)
 {
 if(this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;    //this就是d2的地址，*this就是d2
 }
private:
      int _year ;
      int _month ;
      int _day ;
};


int main()
{
   Date d1;
   Date d2(2024,5,14);
   Date d3;
   d3=d2;
   d3.print();

   d3=d2=d1;  //这里支持连续赋值！！！
 
 
}

注意：对于出了作用域还存在的对象，我们不论返回对象本身，还是返回对象的引用都是可以的！区别在于：出了作用域还存在的对象，如果返回的是一个对象，它不会直接返回这个对象，而是返回这个对象的拷贝，出了作用域还存在的对象，如果返回的是对象的引用，它直接返回这个对象，因此，以引用的方式返回可以减少一次拷贝！如下：


//方式1：返回的是拷贝后的对象（传值返回）
 Date operator=(const Date& d)
 {
      if(this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
      return *this;   
这里会去执行拷贝构造函数，拷贝一份，然后在返回！以一个新的实体对象进行返回！
 }



//方式2：返回的是对象本身（传引用返回）
 Date& operator=(const Date& d)
 {
     if(this != &d)
     {
            _year = d._year;
            _month = d._month;
            _day = d._day;
     }
        
     return *this;
这里会不会去执行拷贝构造函数，拷贝一份，然后在返回，它是以一个原来的实体（引用）对象进行返回！
 }

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

class Date
{
    public:
       
        //默认构造函数
      Time(int year = 1970, 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(2024, 5,20);
    Date d2(2024, 5,21);
    d1=d2;   //这里是赋值重载
    d1.Print();
    d2.Print();


    Date d3(d1);   //这里是拷贝构造
    Date d4 = d1;  //这里也是拷贝构造
    d3.Print();
    d4.Print();


    d1==d2    //这个就不可以，因为他不是默认成员函数
    return 0;
}

上面的程序运行出来，无论是拷贝构造还是赋值重载都可以成功！！！这就是底层的默认的运算符重载帮我们做的事！！！

从上面我们可以知道：有些类，我们是不需要去实现赋值运算符重载的，因为编译器默认生成的就可以使用！！！比如：日期类。

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？是不是就没有意义了？？？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

这里会发现下面的程序会崩溃掉，为什么？？？这里就需要我们以后讲的深拷贝去解决。
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;
      s2 = s1;   //赋值运算符重载
      return 0;
}

上述的程序在运行时会崩溃掉！！！这就是默认赋值运算符重载的浅拷贝问题！！！！

解决的办法：这个时候，我们就必须要去实现深拷贝的赋值运算符重载！而不是使用编译器默认生成的！

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

class Date
{
   public:
     Date(int year = 1900, int month = 1, int day = 1)
    {
       _year = year;
       _month = month;
       _day = day;
 }
     int _year;
     int _month;
     int _day;
};

// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
    if (&left != &right)
    {
       left._year = right._year;
       left._month = right._month;
       left._day = right._day;
 }

 return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

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

6.3 前置++和后置++重载

class Date
{
    public:
         Date(int year = 1900, int month = 1, int day = 1)
         {
          _year = year;
          _month = month;
          _day = day;
         }

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

 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

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

 Date operator++(int)
 {
     Date temp(*this);
     _day += 1;
      return temp;
 }

private:
      int _year;
      int _month;
      int _day;
};

6.4 总结类设计

对于类的设计，思想如下：

1、一般类的成员变量设计成私有的
2、构造函数，我们一般需要自己实现，必须要写，常用的是：全缺省的默认构造函数
3、析构函数，需不需要实现，取决于我们是否需要有资源清理，没有资源清理，就不需要写，有资源清理（动态内存），就必须写！
4、拷贝构造函数和赋值重载运算符，需不需要实现也是看情况，因为它存在浅拷贝的问题，类中如果没有涉及资源申请/资源管理时，是否写都可以；一旦涉及到资源申请/资源管理
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

七、日期类的实现（经典）

这里通过一个简单的日期类来复习巩固前面所学的内容。

/*******************************运算符重载:具有特殊函数名的函数，让自定义类型也可以使用运算符***************************/
//自定义类型不可以直接使用运算符，要想使用就必须实现运算符的重载（比较的规则），用的时候就等价于调用运算符重载函数。

#include <iostream>
using namespace std;

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 = 0, int month = 1, int day = 1)   //year=0代表公元前
    {
        if (year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= GetMonthDay(year, month))
        {
            _year = year;
            _month = month;
            _day = day;
        }
        else
        {
            cout << "非法日期" << endl;
        }
    }



    //拷贝构造函数
    Date(const Date& d)
    {
        _year = d._day;
        _month = d._month;
        _day = d._day;
    }




    // =赋值运算符重载
    // d2 = d3 => d2.operator=(&d2, d3)
    Date&  operator=(const Date& d)          //void operator=(Date* this, const Date& d)
    {
        if (this != &d)         //不影响正确性，针对自己对自己赋值的一个判断检查   d3 = d3 
        {
            _year = d._day;
            _month = d._month;
            _day = d._day;
        }

        return *this;     
    }




/******************************第一部分：基本关系运算符（>、<、>=、<=、==、!=）重载*****************************************************************/
    //小于运算符重载函数
    //d1<d2     编译器底层：d1.operator<(&d1,d2);
    bool operator<(const Date& d)    //  bool operator<(Date* this,const Date& d)
    {
        if (_year < d._year)
        {
            return true;
        }
        else if (_year == d._year && _month < d._month)
        {
            return true;
        }
        else if (_year == d._year && _month == d._month && _day < d._day)
        {
            return true;
        }

        return false;
    }



    //等于==运算符重载成员函数：
    //d1==d2     编译器底层：d1.operator==(&d1,d2);
    bool   operator==(const Date& d)   // bool   operator==(Date* this, const Date& d)
    {
        if (_year == d._year && _month == d._month && _day == d._day)
        {
            return true;
        }
        return false;

    }



  
    //<=小于等于运算符重载成员函数, 方式1：
    //d1<=d2     编译器底层：d1.operator<=(&d1,d2);
    //bool   operator<=(const Date& d)   // bool   operator<=(Date* this, const Date& d) 
    //{
    //    if (_year < d._year)
    //    {
    //        return true;
    //    }
    //    else if (_year == d._year && _month < d._month)
    //    {
    //        return true;
    //    }
    //    else if (_year == d._year && _month == d._month && _day <= d._day)
    //    {
    //        return true;
    //    }

    //    return false;
    //    
    //}



    //<=小于等于运算符重载成员函数, 方式2：复用上面的<和=来实现
    //d1 <= d2;   也就是d1 < d2 || d1 == d2;  编译器底层操作：d1.operator<=(&d1,d2)
    bool   operator<=(const Date& d)      //bool   operator<=(Date* this,const Date& d)
    {
        return *this < d || *this == d;            //内部对this指针解引用就是它所指的对象,内部还是调用上面实现的运算符重载函数


    }


    //>大于运算符重载函数实现：
    //d1 > d2; <==> !(d1<=d2) 

    bool   operator>(const Date& d)      //bool   operator<=(Date* this,const Date& d)
    {
        return !(*this <= d);            //内部对this指针解引用就是它所指的对象,内部还是调用上面实现的<=运算符重载函数


    }



    //>=大于等于运算符重载成员函数:
     //d1 >= d2; <==> !(d1==d2) 

    bool   operator>=(const Date& d)      //bool   operator<=(Date* this,const Date& d)
    {
        return !(*this < d);            //内部对this指针解引用就是它所指的对象,内部还是调用上面实现的<运算符重载函数


    }

    //!=不等于运算符重载成员函数:
    //d1 == d2; <==> !(d1!=d2) 

    bool   operator!=(const Date& d)      //bool   operator<=(Date* this,const Date& d)
    {
        return !(*this == d);            //内部对this指针解引用就是它所指的对象,内部还是调用上面实现的==运算符重载函数

    }
/***************************第二部分：算术运算符及复合算术关系运算符（+、+=、-、-=、）重载**********************************************/
/*是否要重载一个运算符，看的是这个运算符是否对这个类的对象有意义！这里日期对象* 、 / 、 % 就没有意义！*/



    //+运算符重载函数,  日期+天数（存在天数越界，进位问题），返回值仍是一个日期对象     
    //d1 + 10;  注意：这里不会改变d1对象本身,所以返回的是另外一个对象
    Date operator+(int day)
    {
        Date ret(*this);     //用d1拷贝构造一个ret 等价于Date ret = *this;
        ret._day += day;
        while (ret._day > GetMonthDay(ret._year, ret._month))
        {
            //如果加完之后的日期的天数不合法/越界,就需要往月进位
            ret._day -= GetMonthDay(ret._year, ret._month);
            ret._month++;

            if (ret._month == 13)   //如果加完之后的月数不合法/越界,就需要往年进位
            {
                ret._year++;
                ret._month = 1;     //进位后，把月置成1月
            }
        }

        return ret;
    注意：这里返回的是临时的局部对象ret，出了这块的作用域，它就会被销毁，因此，返回值不可以用引用（别名：同一个实体，占用相同的内存空间！)（相比+=多一次拷贝构造）
    }


    //+=运算符重载函数,  日期+天数（存在天数越界，进位问题） 
    //d1 += 10;  注意：这里会改变d1对象本身，因此，它的返回值是自身的引用/别名，返回值是一个日期对象的引用

    Date&  operator+=(int day)
    {
        if (day < 0)
        {
            return *this -= -day;//防止出现  d1 +=-100;
        }


        _day += day;
        while (_day > GetMonthDay(_year, _month))
        {
            //如果加完之后的日期的天数不合法/越界,就需要往月进位
            _day -= GetMonthDay(_year, _month);
            ++_month;

            if (_month == 13)   //如果加完之后的月数不合法/越界,就需要往年进位
            {
                ++_year;
                _month = 1;     //进位后，把月置成1月
            }
        }

        return *this;          //注意这里返回的对象本身
    注意：这里返回的是主函数里面创建的对象本身，出了这块的作用域，它仍然存在，因此，它的返回值可以用引用（别名：同一个实体，占用相同的内存空间），当然也可以用对象（但是他会调用拷贝构造函数）！
    }

 /**************************************************************************************************************************************/

    //-运算符重载函数,  日期-天数（存在天数越界，借位问题），返回值仍是一个日期对象    
      //d1 - 10; ==>d1.operator-(&d1,10); 注意：这里不会改变d1对象本身,所以返回的是另外一个对象（返回值只能是对象而不能是引用！！）
    Date operator-(int day)                   //Date operator-(Date* this, int day)
    {
        Date ret(*this);     //用d1拷贝构造一个ret 等价于Date ret = *this;
        ret._day -= day;
        while (ret._day <= 0)   //天数减下来是负数，说明越界不合法，需要借位处理
        {
            --ret._month;
            if (ret._month == 0)
            {
                --ret._year;    //变成上一年
                ret._month = 12;   //置成12月
            }

            ret._day += GetMonthDay(ret._year, ret._month);
        }
        return ret;
注意：这里返回的是临时的局部对象ret，出了这块的作用域，它就会被销毁，因此，返回值不可以返回引用（别名：同一个实体，占用相同的内存空间！)（相比-=多一次拷贝构造）
    }



    //-=运算符重载函数,  日期-天数（存在天数越界，借位问题） 
    // 注意：这里会改变d1对象本身，因此，它的返回值是自身的引用/别名，返回值是一个日期对象的引用
    //d1 -= 10; ==>d1.operator-=(&d1,10);
    Date& operator-=(int day)                     //Date& operator-=(Date* this, int day)
    {
        
        if (day < 0)
        {
            return *this += -day;  //防止出现 d1 -= -100;
        }


        _day -= day;
        while (_day <= 0)   //天数减下来是负数，说明越界不合法，需要借位处理
        {
            --_month;
            if (_month == 0)
            {
                --_year;    //变成上一年
                _month = 12;   //置成12月
            }

            _day += GetMonthDay(_year, _month);

        }

        return *this;

注意：这里返回的是主函数里面创建的对象本身，出了这块的作用域，它仍然存在，因此，它的返回值可以用引用（别名：同一个实体，占用相同的内存空间），当然也可以用对象（但是他会调用拷贝构造函数）！
    }


/********************************************对上述实现进行优化：达到代码复用***********************************************************/

//+运算符重载复用+=运算符重载
Date operator+(int day)
{
    Date ret(*this);
    ret += day;    //ret.operator+=(Date* this, int day);

    return ret;
}



//-运算符重载复用-=运算符重载
Date operator-(int day)
{
    Date ret(*this);
    ret -= day;    //ret.operator-=(Date* this, int day);

    return ret;
}

/******************************************前置++运算符重载：返回是加加后的值，自己也要改变************************************************************/


//++d1，单目运算符，直接传给this指针，因此不需要其他参数

//++d1 =>编译器会去调用d1.operator++(&d1);
Date& operator++()
{
    *this += 1;
    return *this;     //返回加之后的值

}


/******************************************后置++运算符重载:返回是加加之前的值************************************************************/

/*后置和前置的区别：
      前置和后置都要进行++，但是前置++返回的是加完之后的值，而后置返回的是加之前的值！
*/

//d1++ 单目运算符，直接传给this指针，因此不需要其他参数

//d1++ =>编译器会去调用d1.operator++(&d1,0);
Date operator++(int)   //为了构成重载，在里面形参中加了int 代表后置++
{
    Date tmp(*this);  //拷贝构造一份加之前的对象
    *this += 1;

    return tmp;   //返回加之前的对象
}





/******************************************前置--运算符重载*************************************************************/

//--d1
Date& operator--()
{
    *this -= 1;
    return *this;     //返回减之后的值
}



/******************************************后置--运算符重载************************************************************/


Date operator--(int)
{
    Date tmp(*this);  //拷贝构造一份减之前的对象
    *this -= 1;

    return tmp;   //返回减之前的对象
}

/*****************************************-运算符重载************************************************************************/

// 日期-日期 返回天数
int operator-(const Date& d)
{
    int flag = 1;

    Date max = *this;       //拷贝构造函数
    Date min = d;

    if (*this < d)       //运算符重载
    {
             max = d;
             min = *this;
            flag = -1;
    }

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

    return n*flag;
}



/*******************************************************************************************************************************/


    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }


private:
    int _year;
    int _month;
    int _day;
};


/******************************************************************************************************************/



int main()
{
    Date d1;
    d1.Print();

    Date d2(2020, 2, 29);
    d2.Print();

    Date d3(2021, 4, 31);
    d3.Print();
  
    cout << (d1 < d2) << endl;   //编译器底层调用：d1.operator<(&d1,&d2);
    cout << (d1 > d2) << endl;
    cout << (d1 == d2) << endl;
    cout << (d1 != d2) << endl;
    cout << (d1 <= d2) << endl;
    cout << (d1 >= d2) << endl;
 
    return 0;


}

至此，C++面向对象中的第一部分全部内容就学习完毕，这一节内容比较重要，建议多看几遍，认真复习消化，熟练使用，C++相对来说较为复杂，我们应该时刻理清自己的思路，耐下心来，一点点积累，星光不问赶路人，加油吧，感谢阅读，如果对此专栏感兴趣，点赞加关注！