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 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

对象成员变量多为私有的，要对它们进行初始化，必须用一个公有函数来进行，这便产生了构造函数。构造函数是一个特殊的公有成员函数(在特殊用途中构造函数的访问限定可以定义成私有或保护) ,名字与类名相同, 创建类类型对象时，由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

构造函数的用途有很多：（1）创建对象（2）初始化对象中的成员变量（3）类型转换。

2.2 特性（重点）

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

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

构造函数的作用——类型转换

class Int
{
  private:
    int value;
    public:
    Int(int x=0):value(x)
    {
        value=x;
    }
    ~Int(){}
};

int main()
{
    Int a(10);
    int x=100;
    a=x;         此时的a=x，是内置类型给类类型赋值，编译器直接调用赋值运算符重载函数。
    return 0;
}
```

三、析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？当定义一个对象时，C++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C++也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数。

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。先创建的后析构！满足先进后出的特点，符合栈的特点。思考一下为什么？这就是函数调用的时候会创建栈帧，然后先创建s1对象，再创建s2对象！注意：在主函数外部定义的全局对象（数据区），会先被创建然后才会进入主函数创建局部对象（栈区），因为主函数是逻辑上的程序入口地址，而真正的入口地址会有另一个函数先完成数据区和堆区的初始化，然后才会进入主函数运行代码！全局变量/对象与代码的位置无关！！！
Stack s0;
void TestStack()
{
    Stack s1;    //再析构这个
    Stack s2    //先析构这个
    s1.Push(1);
    s2.Push(2);
}

Stack s3;

构造顺序：先创建s0对象，再创建s3对象，然后进入主函数创建s1对象，最后创建s2对象！
析构顺序：先析构s2对象，再析构s1对象，然后析构s3对象，最后析构s0对象！
面试题：
Stack s0;
void TestStack()
{
    Stack s1;    //再析构这个
    Stack s2    //先析构这个
    s1.Push(1);
    s2.Push(2);

    s0.Push(0);   //编译可以通过
    s3.Push(3);   //编译无法通过！未声明的标识符！变量（对象）的作用域/可见性！
}

Stack s3;

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类生成的默认析构函数

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

四、对象的作用域和生命周期

4.1 对象的作用域

我们知道C++是兼容C语言的，C语言中变量的作用域分为局部作用域、全局作用域、块作用域，并且全局作用域与局部作用域有相同名称的变量时，会使用局部作用域的变量，这称之为同名隐藏，那么，如何解决呢？加一个作用域解析符即可：：那么在C++中又引入了类作用域，又当如何呢？某个类的成员函数中定义了与该类同名的成员变量，那么在该类的成员函数中使用的是局部作用域的变量，如果想要使用该对象的成员变量，加this指针即可！


Class  Int
{
   private: 
        int  val;
   public:
        Int(int x): val(x)
        {
        }

        void print()
        {
           int val=200;       //与成员变量名相同，与类作用域构成隐藏关系
           cout<<val<<endl;   //打印200
        }
};

int main()
{
   Int a(100);
   a.print();        //这里打印的是200而不是100，这就是类的作用域与函数内部局部作用域构成了隐藏
   return 0;
}


//如何解决？

cout<<this->val<<endl;   //打印100, 加入this指针，指定使用对象的成员变量
cout<<Int::val<<endl;    //指定类作用域也可以！