构造函数和析构函数

目录

构造函数

析构函数

---

class Date {};

上面是空类，空类中什么都没有吗？

并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

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

构造函数

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

其特征如下：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。（有多种初始化方式）

5.在整个对象的生命周期内只调用一次。

 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); // 调用带参的构造函数

       // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明      

       

              Date d3();//该代码是错误的

}

6.如果类中没有显式定义构造函数，则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()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
        // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
        // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
        Date d1;//d1需要调用无参的构造函数，但是上述被屏蔽的代码是有参数的构造函数，所以会报错
    return 0;
}

自定义构造函数可以给缺省值

class Date
{
public:
    
    Date(int year=2001, 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;
    return 0;
}

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

编译器默认生成的构造函数对内类型不做处理，对于自定义类型调用自定义类型的构造函数。

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;
};
int main()
{
 Date d;
 return 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;
}

8.无参的构造函数和全缺省的构造函数都称为默认构造函数（默认构造就是不用传参数就可以调用的函数），并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。析构函数完成对象中资源的清理工作。后定义的先析构。

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

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 s;
 s.Push(1);
 s.Push(2);
}

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

class Time
{
    public:
     ~Time()
    {
         cout << "~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 d;
 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类生成的默认析构函数。

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