【C++】类和对象（二）

曾经终败给现在 2024-03-25 13:59 81阅读 0赞

## 类和对象（二） ##

### 类中有六个默认成员函数： ###

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

class Date {
        };

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PXhmGDgv-1678794062412)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311153324321.png)\]][img-PXhmGDgv-1678794062412_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311153324321.png]

默认成员函数， 我们如果不写，编译器就会自动生成一个

但是如果我们实现了任意一个成员函数，编译器就不会会生成了

### 构造函数： ###

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

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

1.  函数名与类名相同。
2.  无返回值。
3.  对象实例化时编译器自动调用对应的构造函数。
4.  构造函数可以重载。
5.  如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦  
    用户显式定义编译器将不再生成。

using namespace std;
    class Stack
    {
        
    public:
    	//构造函数
    	Stack()
    	{
        
    		_a= nullptr;
    		_size = _capacity = 0;
    	}
        private:
    	// 成员变量
    	int* _a;
    	int _size;
    	int _capacity;
    }

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

#### 有参构造函数和无参构造函数: ####

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

Stack st;//无参的时候需要这么写，不可以Stack st（）这个是报错
    Stack st(4);//有参和无参的写法区别

**为什么这里无参构造函数，调用时加括号：Stack st（）会报错？**

> 编译器不清楚你到底要定义出一个对象还是定义个函数出来

这里我们写两个构造函数太过于麻烦了，可以利用全缺省来优化

Date(int year=2023, int month=3, int day=11)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zh8FZbDM-1678794062413)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311155255296.png)\]][img-Zh8FZbDM-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311155255296.png]

**下面这两个函数，是否可以同时存在？**

Date()
    	{
        
    		_year = 2023;
    		_month = 3;
    		_day = 11;
    	}
    	Date(int year=2023, int month=3, int day=11)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}

> 从语法上，是可以同时存在，因为这两个完全符合重载函数的定义
> 
> 实际上，这里是不可以同时存在的，因为编译器说他重载函数的调用不明确

![> \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ETAOM7dJ-1678794062413)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311155810692.png)\]][_img-ETAOM7dJ-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311155810692.png]

#### 默认构造函数的问题： ####

*  默认生成构造数，内置类型成员不做处理，
 *  自定义类型的成员，会去调用它的默认构造（这里指的默认构造是指不用传参数的构造函数）

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O47xkkM7-1678794062413)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311161445220.png)\]][img-O47xkkM7-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311161445220.png]

因为默认生成构造函数不会对内置类型进行处理，因此才有下面这个情况

![(img-5IOzchOo-1678794062414)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311162332054.png)\]][img-5IOzchOo-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311162332054.png]

**生成默认的构造函但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默**  
**认构造函数，但是d对象\_year/\_month/\_day，依旧是随机值。也就说在这里编译器生成的  
默认构造函数并没有什么用？？**

![> 解答：C++把类型分成内置类型(基本类型)和自定义类型。\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5IOzchOo-1678794062414)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311162332054.png)\]][_C_img-5IOzchOo-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311162332054.png]

> 内置类型就是语言提供的数据类型，如：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 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在  
> 类中声明时可以给默认值。
> 
> 在声明的时候给缺省值：
> 
>     private:
>     	//内置类型
>     	//在声明位置给缺省值
>     	int _year=1;
>     	int _month=1;//这里是声明不是初始化
>     	int _day=1;
> 
> 当成员变量同时有自定义类型和内置类型时：
> 
> 默认构造函数，只给自定义类型赋值，内置类型没有初始化

> 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。  
> 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为  
> 是默认构造函数。
> 
> 因为调用是，会存在歧义。
> 
> 一般建议，每个类都提供一个默认的构造函数

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

> 因为调用是，会存在歧义。
> 
> 一般建议，每个类都提供一个默认的构造函数

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bl0PbDZt-1678794062414)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311172038425.png)\]][img-Bl0PbDZt-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311172038425.png]

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

### 析构函数： ###

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

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

1.  析构函数名是在类名前加上字符 ~。
2.  无参数无返回值类型。
3.  一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构  
    函数不能重载
4.  对象生命周期结束时，C++编译系统系统自动调用析构函数。

class Stack
    {
        
    public:
    	//构造函数
    	Stack()
    	{
        
    		_a = nullptr;
    		_size = _capacity = 0;
    	}
    	Stack(int n)//构造函数可以进行函数重载
    	{
        
    		_a = (int*)malloc(sizeof(int) * n);
    		if (nullptr == _a)
    		{
        
    			perror("malloc申请空间失败");
    			return;
    		}
    		_capacity = n;
    		_size = 0;
    	}
    	~Stack()//析构函数不可以重载
    	{
        //析构函数
    		free(_a);
    		_a = NULL;
    	}
    	//成员函数
       /*void Init(int n)
       {
    	   _a = (int*)malloc(sizeof(int) * n);
    	   if (nullptr == _a)
    	   {
    		   perror("malloc申请空间失败");
    		   return;
    	   }
    
    	   _capacity = n;
    	   _size = 0;
       }*/
    
    	void Push(int x)
    	{
        
    		//...
    		_a[_size++] = x;
    	}
    
    	...
    
    private:
    	// 成员变量
    	int* _a;
    	int _size;
    	int _capacity;
    };
    
    int main()
    {
        
    	Stack st;//无参的时候需要这么写，不可以Stack st（）这个是报错
    	Stack st(4);//有参和无参的写法区别
    
    	st.Push(1);
    	//析构函数不需要调用，它会自动调用
    	return 0;
    }

析构函数不可以重载，并且它会自动调用，不需要你去调用它

class Date
    {
        
    public:
    	Date()
    	{
        
    		_year = 2023;
    		_month = 3;
    		_day = 11;
    	}
    	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 d1;
    	d1.print();
    	Date d2(2023,3,12);
    	d2.print();
    	return 0;
    }

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Srj9O30s-1678794062414)(C:\\Users\\小卢\\AppData\\Roaming\\Typora\\typora-user-images\\image-20230311154946314.png)\]][img-Srj9O30s-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311154946314.png]

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器  
生成的默认析构函数，对自定类型成员调用它的析构函数。

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类对象，所以编译器会调用Dat类的析构函
    // 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time
    // 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
    // main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
    // 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

[img-PXhmGDgv-1678794062412_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311153324321.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dc285932f8104a9d874e4142b0242fb1.png
[img-Zh8FZbDM-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311155255296.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/be7d3e6580f845e29d08c6cef916a8f7.png
[_img-ETAOM7dJ-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311155810692.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/24f9481d5b834c3f90040e13c641863d.png
[img-O47xkkM7-1678794062413_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311161445220.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4f3da96a9c9f495fa4137a38ad522e0b.png
[img-5IOzchOo-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311162332054.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/85308122d7cc4e3090016cdcf10178f9.png
[_C_img-5IOzchOo-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311162332054.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3de64926e5694509ad08f732110c64db.png
[img-Bl0PbDZt-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311172038425.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ef98dff4f8654a85aae3e254ab053ad0.png
[img-Srj9O30s-1678794062414_C_Users_AppData_Roaming_Typora_typora-user-images_image-20230311154946314.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/60793d7a5e5a472b9b402c85929e5389.png