【C++初阶】第三站:类和对象(中) -- 类的6个默认成员函数-1-阿里云开发者社区

前言

有时候我们写好了一个栈，头脑中第一件事情就会先去，Push压栈，各种操作，经常会忘掉一件事情--初始化，当忘记初始化栈的时候，那就会引发程序的崩溃：

还有还可能忘记释放之前申请的空间，引发内存泄露问题。那C++中有没有新的语法，可以帮助我们自动调用函数呢？引出我们的构造函数。

类的6个默认成员函数

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

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

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

构造函数

概念

对于以下Date类：

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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之后，需要调用这个初始化函数对d1对象进行初始化
        d1 . Print ();
     
        Date d2 ;
        d2 . Init ( 2022 , 7 , 6 );//这样未免有点太麻烦了
        d2 . Print ();
        return 0 ;
}

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

特性

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

1. 函数名与类名相同。
2. 无返回值。
        解析:函数名前面无数据类型，不需要写void,
3. 对象实例化时编译器自动调用对应的构造函数。
        解析:当创建一个对象的时候，编译器会自动调用该类的构造函数对新创建的变量进行初始化
4. 构造函数可以重载
        解析:本质就是我们写多个构造函数，提供多种初始化方式
5.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意，并不是我们不写，编译器默认生成的构造函数才被叫做默认构造函数，
以下三种都可以称为默认构造函数：
         1.无参构造函数
        2.全缺省构造函数
        3.我们没写编译器默认生成的构造函数
6. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

解释特性3：对象实例化时编译器自动调用对应的构造函数。

代码示例：

根据函数缺省的知识，可以将上面的无参构造和带参构造的写法合并，写成全缺省构造函数：

还要注意的是构造函数不能写成这样:

这样写的话，编译器不知道是定义对象，还是声明一个函数

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

解释特性4：构造函数可以重载

在面向对象编程中，一个类可以根据实际需要定义多个构造函数，这些构造函数的名称都与类名相同，但参数列表不同（参数的数量、类型或顺序各异）。这样设计的好处在于，创建该类的对象时，可以根据实际提供的参数来选择调用哪个构造函数进行初始化。

所以构造函数建议写成全缺省的构造函数，这样的话，无论传参个数的多少，都能适用。

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

还有另一种情况是将全缺省改成半缺省：

测试代码

class Date
{
public:
  //情况1，(以下没有注释)如果用户显式定义了构造函数，编译器将不再生成
  Date(int year, int month, int day)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  //情况2，全缺省改成半缺省
  Date(int year , int month = 1, int day = 1)
  {
  cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
  _year = year;
  _month = month;
  _day = day;
  }
  void Print()
  {
  cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
  Date d1;
  d1.Print();
  return 0;
}

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

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

内置类型就是语言提供的数据类型，如：int/char...

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

看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

以上是对于日期类的情况，对于栈类，也是同样道理，自定义类型的成员才会处理，会去调用这个成员的默认构造函数

栈的构造函数的应用，用C++实现栈：

class Stack
{
public:
  //Stack()
  //{
  //  a = nullptr;
  //  top = capacity = 0;//栈顶元素的下一个位置
  //}
//优化后的构造函数
  Stack(size_t n = 4)//优化的写法
  {
  if (n == 0)
  {
    a = nullptr;
    top = capacity = 0;
  }
  else
  {
    a = (int*)malloc(sizeof(int) * n);
    if (a == nullptr)
    {
    perror("realloc fail");
    exit(-1);
    }
    top = 0;
    capacity = n;
  }
  }
  //void Init()
  //{
  //  a = nullptr;
  //  top = capacity = 0;
  //}
  void Push(int x)
  {
  if (top == capacity)
  {
    size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
    int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
    //tmp 会指向新的内存区域（如果发生迁移），否则它仍指向原内存区域（如果没有迁移）。
    ///无论是否发生迁移，原有的指针 a 应该被 tmp 替代，
    //以确保后续操作使用的都是正确且可能已改变的内存地址：
    if (tmp == nullptr)
    {
    perror("realloc fail");
    exit(-1);//以异常的方式退出
    }
    if (tmp == a)
    {
    cout << capacity << "原地扩容" << endl;
    }
    else
    {
    cout << capacity << "异地扩容" << endl;
    }
    a = tmp;
    capacity = newcapacity;
  }
  a[top++] = x;
  }
  int Top()
  {
  return a[top - 1];
  }
  void Pop()
  {
  assert(top > 0);
  --top;
  }
  void Destroy()
  {
  free(a);
  a = nullptr;
  top = capacity = 0;
  }
  bool Empty()
  {
  return top == 0;
  }
private:
  //成员变量 
  int* a;//指针都是内置类型
  int top;
  int capacity;
};
int main()
{
  Stack st1;//使用栈的构造函数的默认初始值
  //st1.Init();
  st1.Push(1);
  st1.Push(2);
  st1.Push(3);
  st1.Push(4);
  while (!st1.Empty())
  {
  cout << st1.Top() << " ";
  st1.Pop();
  }
  cout << endl;
  st1.Destroy();
//直接写这种 -- 优化的写法
    Stack st2(0);//可以自定义初始化栈的数据 
  for (size_t i = 0; i < 1000; i++)
  {
  st2.Push(i);
  }
  while (!st2.Empty())
  {
  cout << st2.Top() << " ";
  st2.Pop();
  }
  cout << endl;
  st2.Destroy();
}

C++11中，声明支持给缺省值，如果声明有缺省值，才会处理，但一般的内置类型的成员不会处理

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在

类中声明时可以给默认值。

演示：

/
class Date
{
public:
//以下Date构造函数注释掉
  /*Date(int year=1 , int month = 1, int day = 1)
  {
  cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
  _year = year;
  _month = month;
  _day = day;
  }*/
  void Print()
  {
  cout << _year << "/" << _month << "/" << _day;
  }
private:
  int _year =1;//这里给值是声明，不是初始化，因为初始化的特征是开空间，这里并没有开空间
  int _month ;
  int _day ;
};
int main()
{
  Date d1;//我们没写，编译器自动调用默认生成的构造函数，我们在声明的_year处给了初始值，所以    只有这个地方是赋值的，其他地方都是随机数
  d1.Print();
}

解释特性6：无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数（特点:不传参就可以调用的构造就是默认构造）。

刚刚我们提到，对于日期类，多个构造函数(无参的、有参的)并存会存在调用二义性，所以三个默认的构造函数中，只能存在一个：

并且如果构造函数是有参的，则不能缺任何一个初始化的形参值，比如：

对于栈类实例化对象来说，不对n初始化，虽然这里给了值，但不视为全缺省参数，又因为我们实现了这个Stack类的构造函数，所以说，不能视为无参构造函数和编译器默认生成的构造函数。

总结:

一般情况都需要我们自己写构造函数，决定初始化方式

如果成员变量全是自定义类型，可以考虑不写构造函数

构造函数的应用：

之前我们写过的一个有效的括号的题目:有效的括号--c语言实现

现在经过了C++改良后，栈的初始化以及销毁部分就通通有编译器实现了：

代码实现(栈的实现在上文构造函数的应用)：

bool isValid(const char* s) {
  Stack st;
  while (*s)
  {
  if (*s == '[' || *s == '(' || *s == '{')
  {
    st.Push(*s);
    ++s;
  }
  else
  {
    // 不匹配
    if (st.Empty())
    return false;
    char top = st.Top();
    st.Pop();
    // 不匹配
    if ((*s == ']' && top != '[')
    || (*s == ')' && top != '(')
    || (*s == '}' && top == '{'))
    {
    return false;
    }
  
    ++s;
  }
  }
  return st.Empty();
}
int main()
{
  cout << isValid("[[]]()()") << endl;
  cout << isValid("[[]]]") << endl;
  return 0;
}

析构函数

概念

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由

编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

特性

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

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

#日期类的构造函数和析构函数
class Date
{
public:
  Date()//构造函数
  {}
  ~Date()//析构函数
  {}
private:
  int _year ;
  int _month ;
  int _day ;
};
#栈类的构造函数和析构函数
class Stack
{
public:
  Stack()
  {}
  ~Stack()
  {}
private:
  int* a;
  int top;
  int capacity;
};

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

函数名(跟类名相同)前不用写返回值(意味着void不用写)，不用传入参数

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

在C++中，每个类对象都有一个生命周期。当对象的生命周期到达终点（如离开作用域或动态分配的对象被删除时），C++编译系统会自动调用该对象的析构函数。析构函数是一个特殊成员函数，它的主要职责是在对象销毁前进行必要的清理工作，如释放内存、关闭文件或解除其他系统资源的占用，以确保程序运行的健壮性和资源的有效管理。

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

编译器自动生成的析构函数机制:

对于日期类，成员变量是_year、_month、_day(内置类型)，是属于d1对象的，这个对象在栈帧里面，栈帧出了作用域自动就销毁了，所以是不需要销毁的，日期类都不用写析构函数
        对于栈类(自定义类型)，是需要写析构函数的，但不用写Destroy()函数了,因为有析构函数就行了，它的作用就是清理资源，何为资源：malloc、fopen(动态)等

5.编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Stack
{
public:
    Stack(size_t n=10)
    {
  if (n == 0)
     {
      a = nullptr;
    top = capacity = 0;
  }
  else
  {
    a = (int*)malloc(sizeof(int) * n);
    if (a == nullptr)
    {
    perror("realloc fail");
    exit(-1);
    }
  top = 0;
  capacity = n;
      }
  }
  ~Stack()
  {
  cout << "~Stack()" << endl;
  free(a);
  a = nullptr;
  top = capacity = 0;
  }
private:
  //成员变量 
  int* a;
  int top;
  int capacity;
};
class MyQueue
{
private:
  Stack _pushst;
  Stack _popst;
};
int main()
{
  MyQueue mq;
}