【C++】类的默认成员函数（上）

文章目录

• 1.类的默认成员函数
• 2.构造函数
• 3.析构函数
• • 3.1括号匹配问题

1.类的默认成员函数

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

一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下即可。

C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。

默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

• 第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。

• 第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

2.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧，创建时空间就开好了)，而是对象实例化时初始化对象。

构造函数的本质是要替代Stack类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。

构造函数的特点：

1.函数名与类名相同

2.无返回值，也不需要写void

3.对象实例化时系统会自动调用对应的构造函数

4.构造函数可以重载

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

6.++无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数++ ，都叫做默认构造函数 ，这三种都不传实参。

但是这三个函数有且只有一个存在 ，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。

7.编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的（看编译器），可以当做不处理

++对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化++。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决。

说明：C++把类型分成内置类型 (基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

#include<iostream>
using namespace std;
class Date
{
public:
 // 1.无参构造函数
     Date()
     {
         _year = 1;
         _month = 1;
         _day = 1;
     }
 // 2.带参构造函数
     Date(int year, int month, int day)
     {
         _year = year;
         _month = month
         _day = day;
     }
     // 3.全缺省构造函数
     /*
     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; // 调用默认构造函数
     Date d2(2025, 1, 1); // 调用带参的构造函数
    
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象
     // warning C4930: "Date d3(void)": 未调用原型函数(是否是有意用变量定义的?)
     //Date d3();
    
     d1.Print();
     d2.Print();
     return 0;
}

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
     Stack(int n = 4)
     {
         _a = (STDataType*)malloc(sizeof(STDataType) * n);
         if (nullptr == _a)
         {
             perror("malloc申请空间失败");
             return;
         }
         _capacity = n;
         _top = 0;
     }
 // ...
private:
     STDataType* _a;
     size_t _capacity;
     size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
private:
     Stack Pushst;
     Stack Popst;
};
int main()
{
     MyQueue mq;
     return 0;
}

上面这个例子中，因为Pushst和Popst都是自定义类型，编译器调用了Stack的构造函数，完成了对Pushst和Popst的初始化

3.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，因为局部对象是存在栈帧的，函数结束栈帧销毁，它就释放了，不需要主动去销毁。

C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，去销毁需要销毁的资源（例如malloc出来的空间），而像Date没有Destroy，就没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

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

2.无参数无返回值。 (这里跟构造类似，也不需要加void)

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

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

5.跟构造函数类似，++编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用它的析构函数++。

6.还需要注意的是我们显式写析构函数，对于自定义类型成员也会调用它的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。

7.如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显式写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。

8.一个局部域的多个对象，C++规定后定义的先析构。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
    {
        perror("malloc申请空间失败");
        return;
    }
    _capacity = n;
    _top = 0;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
    //编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源
    // 显示写析构，也会自动调用Stack的析构
    /*~MyQueue()
    {}*/
private:
    Stack pushst;
    Stack popst;
};
int main()
{
    Stack st;
    MyQueue mq;
    return 0;
}

3.1括号匹配问题

对比一下用C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数后，不会再忘记调⽤Init和Destory函数了，确实方便了很多

#include<iostream>
using namespace std;
// 用最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s) 
{
    Stack st;
    while (*s)
    {
        if (*s == '[' || *s == '(' || *s == '{')
         {
             st.Push(*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();
}
// 用之前C版本Stack实现
bool isValid(const char* s) {
     ST st;
     STInit(&st);
     while (*s)
     {
         // 左括号入栈
         if (*s == '(' || *s == '[' || *s == '{')
         {
             STPush(&st, *s);
         }
         else // 右括号取栈顶左括号尝试匹配
         {
             if (STEmpty(&st))
             {
                 STDestroy(&st);//这步很重要，可能会忘记
                 return false;
             }
             char top = STTop(&st);
             STPop(&st);
             // 不匹配
             if ((top == '(' && *s != ')')
             || (top == '{' && *s != '}')
             || (top == '[' && *s != ']'))
             {
                 STDestroy(&st);//这步很重要，可能会忘记
                 return false;
             }
         }
         ++s;
     }
     // 栈不为空，说明左括号比右括号多，数量不匹配
     bool ret = STEmpty(&st);
     STDestroy(&st);
     return ret;
}
int main()
{
     cout << isValid("[()][]") << endl;
     cout << isValid("[(])[]") << endl;
     return 0;
}