『C++成长记』构造函数和析构函数

『C++成长记』构造函数和析构函数_第1张图片

博客主页:小王又困了

系列专栏:C++

人之为学,不日近则日退 

❤️感谢大家点赞收藏⭐评论✍️


目录

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

1.1认识默认成员函数 

二、构造函数

2.1为什么要有构造函数

2.2构造函数的概念

2.3构造函数的特性

2.4编译器生成的构造函数 

2.5编译器生成构造函数的作用 

2.6默认构造函数

三、析构函数

3.1析构函数的概念

3.2析构函数的特性

3.3编译器生成析构函数的作用


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

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

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

1.1认识默认成员函数 

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

『C++成长记』构造函数和析构函数_第2张图片

  • 构造函数:完成初始化工作。
  • 析构函数:完成对空间的清理工作。
  • 拷贝构造:使用同类对象初始化创建对象。
  • 赋值重载:把一个对象赋值给另外一个对象。
  • 取地址重载:普通对象和const对象取地址,这两个很少自己实现。

二、构造函数

2.1为什么要有构造函数

class Date
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Init(2022, 7, 5);//调用初始化函数
    return 0;
}

     以前我们创建对象后,都要自己调用初始化函数,这样的操作十分麻烦,而且当对象增多时,有些对象我们可能会忘记初始化,这时程序就会出现错误。那么能否在创建对象的时候,就自动对它初始化。于是,就有了构造函数。

2.2构造函数的概念

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

class Date
{
public:
    //构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
 };
  
void TestDate()
{
   Date d1(2015, 1, 1); // 自己调用构造函数
}

2.3构造函数的特性

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

特性:

  •  函数名与类名相同。
  •  无返回值。
  •  对象实例化时编译器自动调用对应的构造函数。
  •  构造函数可以重载。
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();//错误写法
}

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

2.4编译器生成的构造函数 

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

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数,编译器将不再生成
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    */
 
 private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
	Date d1;
	return 0;
}

     将Date类中构造函数屏蔽后,代码可以通过编译,因为编译器生成了一个无参的默认构造函数。 将Date类中构造函数放开,代码编译失败,因为一旦显式定义任何构造函数,编译器将不再 生成默认构造函数,Date d1; 没有可以调用的无参构造函数,所以会失败。 

2.5编译器生成构造函数的作用 

 

      d1对象调用了编译器生成的默认构造函数,但是对象_year_month_day,是随机值。那这里编译器生成的默认构造函数有什么用呢?

解答:C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型,如:intchar...,自定义类型就是我们使用classstructunion等自己定义的类型。(所有类型的指针都属于内置类型)。编译器生成的默认构造函数,对内置类型不做处理,对自定义类型,会去调用它的默认构造函数。

//先定义一个时间类
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++成长记』构造函数和析构函数_第3张图片

     如上代码 ,定义了一个日期类Date,有四个成员变量,其中_year、_month、_day都是内置类型,_t 是自定义类型,它是一个时间类Time,Time类中写了一个构造函数。运行程序,自定义类型调用了自己的默认构造函数,对值进行了初始化。这意味着,在创建对象的时候,会去使用编译器生成的无参默认构造函数。

     C++11 中针对内置类型成员不初始化的缺陷,又打了补丁,即:内置类型成员变量在类中声明时可以给默认值。 

示例: 

class Date
{
private:
    int _year = 2023;
    int _month = 11;
    int _day = 16;
};
 
int main()
{
	Date d1;
	return 0;
}

2.6默认构造函数

     编译器自动生成的构造函数无参构造函数全缺省构造函数,这三种都叫做默认构造函数,它们都有一个共同的特点:可以不用传参。默认构造函数只能有一个,后面俩,在语法上可以构成函数重载,但是在无参调用的时候,会发生歧义,出现调用不明确。

『C++成长记』构造函数和析构函数_第4张图片

//无参构造函数
Date()
{
    _year = 2023;
    _month = 11;
    _day = 16;
}

//全缺省构造函数
Date(int year = 2023, int month = 11, int day = 16)
{
    _year = year;
    _month = month;
    _day = day;
}

注意:要把默认构造函数和默认成员函数区分清楚,默认成员函数是我们不写编译器会自动生成的默认构造函数是不需要传参的构造函数编译器生成的构造函数,既是默认构造函数,同时也是默认成员函数。 

三、析构函数

3.1析构函数的概念

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

3.2析构函数的特性

特性:

  •  析构函数名是在类名前加上字符 ~
  •  无参数无返回值类型。
  •  一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。
  •  对象生命周期结束时,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);
}

      Stack中的成员变量_array是在堆区上申请的空间,这块空间在程序结束后不会自动还给操作系统,当_array清理后,就找不到动态申请的那块空间,会造成内存泄漏,因此在对象销毁前,要通过析构函数去释放成员变量_array指向的空间,这就是析构函数的作用。

注意:析构函数不能重载

3.3编译器生成析构函数的作用

     编译器会自动生成的析构函数,对内置类型不做处理,对自定义类型会去调用它的析构函数

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

『C++成长记』构造函数和析构函数_第5张图片

     main函数中创建了 Date对象d,而d中包含4个成员变量,其中_year, _month, _day三个是内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而_t是Time类对象,所以在 d 销毁时,要将其内部包含的Time类的_t对象销毁,所以要调用Time类的析构函数。但是: main函数中不能直接调用Time类的析构函数,实际要释放的是Date类对象,所以编译器会调用Date类的析构函数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部调用Time类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁。

总结:

    一般情况下,有动态申请资源,就需要显式的写析构函数来释放资源,比如Stack类。没有动态申请的资源,可以不写析构函数,直接使用编译器生成的默认析构函数,比如 Date类。需要释放资源的成员都是自定义类型,也不需要写析构函数。


结语: 

     本次的内容到这里就结束啦。希望大家阅读完可以有所收获,同时也感谢各位读者三连支持。文章有问题可以在评论区留言,博主一定认真认真修改,以后写出更好的文章。你们的支持就是博主最大的动力。

你可能感兴趣的:(C++,c++,开发语言,算法,jvm,java)