【C++】类与对象（中篇：类的六个默认成员函数）

古城微笑少年丶 2022-11-29 12:47 127阅读 0赞

### 文章目录 ###

*  1.类的六个默认成员函数
 *  2.构造函数
 *  3.析构函数
 *  4.拷贝构造函数
 *  5.赋值运算符重载
 *  6.const修饰类的成员函数
 *  7.取地址及const取地址操作符重载

# 1.类的六个默认成员函数 #

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。

class Date{
        };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70_pic_center]

# 2.构造函数 #

**2.1 概念**  
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。  
**2.2 特性**  
构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。  
1.函数名与类名相同  
2.无返回值  
3.对象实例化时编译器自动调用对应的构造函数  
4.构造函数可以重载

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(2020, 8, 21);//调用带参的构造函数
    }

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

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

class Date
    {
        
    public:
    	//无参构造函数
    	Date()
    	{
        
    		_year = 2020;
    		_month = 8;
    		_day = 21;
    	}
    	//全缺省构造函数
    	Date(int year = 2020, int month = 8, int day = 21)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    void Test()
    {
        
    	//不能通过编译，因为默认构造函数只能有一个
    	Date d1;
    }

此时有一个疑问：我们没有写构造函数，对象就会调用编译器生成的默认构造函数，成员变量依旧是随机值，看起来默认构造函数并没有什么用处？  
解答：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;
    }

# 3.析构函数 #

**3.1 概念**  
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。  
**3.2 特性**  
析构函数是特殊的成员函数。  
1.析构函数名是在类名前加上字符~  
2.无参数无返回值  
3.一个类有且只有一个析构函数，若未显示定义，系统会自动生成默认的析构函数  
4.对象生命周期结束时，C++编译系统自动调用析构函数

typedef int DataType;
    class SeqList
    {
        
    public:
    	SeqList(int capacity = 10)
    	{
        
    		_pData = (DataType*)malloc(capacity*sizeof(DataType));
    		assert(_pData);
    		_size = 0;
    		_capacity = 0;
    	}
    	~SeqList()
    	{
        
    		if (_pData)
    		{
        
    			free(_pData);
    			_pData = NULL;
    			_capacity = 0;
    			_size = 0;
    		}
    	}
    private:
    	int* _pData;
    	size_t _size;
    	size_t _capacity;
    };

下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

class String
    {
        
    public:
    	String(const char* str = "jack")
    	{
        
    		_str = (char*)malloc(strlen(str) + 1);
    		strcpy(_str, str);
    	}
    	~String()
    	{
        
    		cout << "~String()" << endl;
    		free(_str);
    	}
    private:
    	char* _str;
    };
    class Person
    {
        
    private:
    	String _name;
    	int _age;
    };
    int main()
    {
        
    	Person p;
    	return 0;
    }

# 4.拷贝构造函数 #

**4.1 概念**  
构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。  
**4.2 特征**  
1.拷贝构造函数是构造函数的一个重载形式。  
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
    {
        
    public:
    	Date(int year = 2020, int month = 8, int day = 1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	//引用，避免引发无穷递归调用
    	Date(const Date& d)
    	{
        
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        
    	Date d1;
    	Date d2(d1);
    	return 0;
    }

**注意**：若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。其它情况会用到，用深拷贝去解决。

# 5.赋值运算符重载 #

**5.1 运算符重载**  
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。  
函数名字为：关键字operator后面接需要重载的运算符符号。  
**注意**：  
1.不能通过连接其他符号来创建新的操作符：比如operator@  
2.重载操作符必须有一个类类型或者枚举类型的操作数  
3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义  
4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参  
5. .\* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载

class Date
    {
        
    public:
    	Date(int year, int month, int day)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	Date(const Date& d)
    	{
        
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    	bool operator==(const Date& d)
    	{
        
    		return _year == d._year&&
    			_month == d._month&&
    			_day == d._day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        
    	Date d1(2020, 8, 21);
    	Date d2(d1);
    	if (d1 == d2)
    		cout << "d1 == d2" << endl;
    	return 0;
    }

**5.2 赋值运算符重载**

class Date
    {
        
    public:
    	Date(int year=1900, int month=1, int day=1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	//这里用引用Date&，在传参期间少创建一个临时对象，效率变高了
    	Date& operator=(const Date& d)
    	{
        
    		//避免给自己赋值
    		if (this != &d)
    		{
        
    			_year = d._year;
    			_month = d._month;
    			_day = d._day;
    		}
    		return *this;//注意：必须有返回值，返回*this，目的是为了支持连续赋值
    	}
    	void PrintDate()
    	{
        
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        
    	Date d1;
    	Date d2(2020, 8, 21);
    	d2 = d1;
    	d2.PrintDate();
    	return 0;
    }

**注意**：一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

# 6.const修饰类的成员函数 #

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70_pic_center 1]

class Date
    {
        
    public:
    	void Display()
    	{
        
    		cout << "Display()" << endl;
    		cout << _year << endl;
    		cout << _month << endl;
    		cout << _day << endl;
    	}
    	void Display()const
    	{
        
    		cout << "Display()const" << endl;
    		cout << _year << endl;
    		cout << _month << endl;
    		cout << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        
    	Date d1;
    	d1.Display();
    
    	const Date d2;
    	d2.Display();
    	return 0;
    }

根据以上代码有如下结论：  
1.非const类型的对象对于普通成员函数和const类型的成员函数都可以进行调用  
2.const类型的对象只能调用const类型的成员函数，不能调用普通类型的成员函数  
3.普通成员函数中可以调用const成员函数  
4.const成员函数中不能调用普通类型的成员函数

# 7.取地址及const取地址操作符重载 #

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
    {
        
    public:
    	Date* operator&()
    	{
        
    		return this;
    	}
    	const Date* operator&()const
    	{
        
    		return this;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/7b17d31f184344f6a0946b9bb3bcd5b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/79db0105131a4b85b0749cc50c373904.png