[C++知识库]【C过渡到C++】-- 类和对象（中）-- 类的默认成员函数

目录

1、类的6个默认成员函数

2、构造函数

特性

编译器生成的默认构造函数

默认构造函数（不用传参数就可以调用）

内置类型成员不做处理

自定义类型成员会去调用他的默认构造函数

编译器生成的默认构造函数处理实验

C11对内置类型成员不做处理补丁

3、析构函数

编译器默认生成的析构函数

4、拷贝构造函数

特性：

Date(const Date d) -- 编译报错，会引发无穷递归

编译器默认生成的析构函数

5、运算符重载

运算符重载

特性

将运算符重载函数写在类外（便于理解）

6、赋值运算符重载

返回值T&目的是为了支持连续赋值

两个操作数赋值

三个操作数赋值

参数类型：const T&，返回值类型：T&，提高效率。

参数类型：const T，返回值类型：T，时：

参数类型：const T&，返回值类型：T&，时：

赋值运算符只能重载成类的成员函数不能重载成全局函数

用户没有显式实现时，编译器会生成一个默认赋值运算符重载?

7、const成员

8、取地址及const取地址操作符重载

特殊情况：不想使用者能提取到地址

私有化

更改返回值

1、类的6个默认成员函数

????????类，会自动生成下面6个默认成员函数：

2、构造函数

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

特性

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

Note：其特征如下：

1. 函数名与类名相同。
2. 无返回值。（返回值不是void（void是空返回值））
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

????????结构函数并不会开辟空间。因为其是局部变量，编译器编译的时候会建立栈帧，编译器提前就通过内存对齐的规则算好了它的大小，然后，提前就在栈帧里开好空间了。

class Date
{
public:
	// 1.无参构造函数
	Date()
	{}

	// 2.带参构造函数(全缺省)
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Note: 1与2不可共存，都是无传参调用，所以会调用矛盾
	//----------------------------------------

	// 3.带参构造函数(半缺省)
	Date(int year, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// 4.带参构造函数(无缺省)
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

• 调用

int main()
{
    //调用特殊的构造函数，是与普通的函数调用的方式不同的
    Date d1; // 调用无参构造函数 -- 不用显示的调用初始化，它会自动的调用初始化。能保证一定初始化（对象实例化，一定要调用构造函数）
    Date d2(2015, 1, 1); // 调用带参的构造函数

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

编译器生成的默认构造函数

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

• 默认构造函数（不用传参数就可以调用）

1. 无参的构造函数。
2. 全缺省的额构造函数。
3. 编译器自行生成的构造函数。

class Date
{
public:
	// 如果用户未定义构造函数，编译器将自动生成。

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d; //调用编译器所自动形成的默认构造函数
	return 0;
}

? ? ? ? ?但是我们会发现，类中的内置类型还是随机值，那编译器自动生成的默认构造函数执行了什么？

? ? ? ? ?其实这就是C++的缺陷。

Note：C++类别分类：

• 内置类型/基本类型：int / double / char 等等（编译器所自带的类型）。
• 自定义类型：struct / class。

Note：默认生成的构造函数特点：

1. 内置类型成员不做处理。
2. 自定义类型成员会去调用他的构造函数。

设计是C++早期设计的一个缺陷，默认生成构造函数，本来应该内置类型也一并处理。

• ?内置类型成员不做处理

class Date
{
public:
	// 如果用户未定义构造函数，编译器将自动生成。

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d; //调用编译器所自动形成的默认构造函数
	return 0;
}

• ?自定义类型成员会去调用他的默认构造函数

class Stack
{
public:
	Stack(size_t capacity = 3) //全缺省函数（默认构造函数）
	{
		int* _array = (int*)malloc(sizeof(int) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 10;
	}
	//……

private:
	int* _array;
	int _capacity;
	int _size;
};

class MyQueue {
public:

private:
	Stack _st1; //自定义类型成员会去调用他的默认构造函数
	Stack _st2; //自定义类型成员会去调用他的默认构造函数
};

int main()
{
	MyQueue q; //自定义类型成员会去调用他的默认构造函数

	return 0;
}

? ? ? ? MyQueue q；因为是自定义类型，所以会调用默认构造函数。由于q中没有显示写默认构造函数，所以编译器会自动生成一个默认构造函数，而q中的Stack _st1 与 Stack _st2 也是自定义类型，所以会调用默认构造函数，而这次我们已经显示写默认构造函数，所以会对内置类型进行初始化。

? ? ? ? 如果我们显示写了构造函数，而且显示写的并不是默认构造函数，那么会报error。我们使用的是定义自定义类型，并且未传参，那么就是编译器自行调用默认构造函数，而已有显示构造函数，那么无法自动生成生成，即无默认构造函数。

class Stack
{
public:
	//以显示写构造函数，编译器无法自动生成构造函数。
	Stack(size_t capacity) //半缺省函数（不是默认构造函数）
	{
		int* _array = (int*)malloc(sizeof(int) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}
	//……

private:
	int* _array;
	int _capacity;
	int _size;
};

class MyQueue {
public:

private:
	Stack _st1; //自定义类型成员会去调用他的默认构造函数
	Stack _st2; //自定义类型成员会去调用他的默认构造函数
};

int main()
{
	MyQueue q; //自定义类型成员会去调用他的默认构造函数

	return 0;
}

• 编译器生成的默认构造函数处理实验

class Date
{
public:
    //无参构造函数（默认构造函数）
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

private:
	int _year;
	int _month;
	int _day;
};

class A {
public:

private:
	size_t size;
	Date _d1; //自定义类型成员会去调用他的默认构造函数
	Date _d2; //自定义类型成员会去调用他的默认构造函数
};

int main()
{
	A q; //自定义类型成员会去调用他的默认构造函数
	return 0;
}

• C11对内置类型成员不做处理补丁

? ? ? ? 在内置类型的声明后加上缺省数。

class Date
{
public:
	// 如果用户未定义构造函数，编译器将自动生成。

private:
	//是缺省（针对编译器生成的默认构造函数） -- 不是赋值（这是声明，所也不可能是赋值）
	int _year = 1;
	int _month = 1;
	int _day = 1;
};
int main()
{
	Date d; //调用编译器所自动形成的默认构造函数
	return 0;
}

3、析构函数

? ? ? ? 析构函数和构造函数很像，最大的区别就是：一个是清理工作，一个是初始化工作，一个没有参数，一个可以有参数。

????????析构函数（析构函数是特殊的成员函数）：与构造函数功能相反，析构函数不是完成对对象本身的销毁（对象的生命周期到了会自动销毁），局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

Note：其特征如下：

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

//编译器会自动调用析构函数
class Date
{
public:
	~Date()
	{
		//~Date()没有什么需要清理 -- 因为Date的成员变量都存储在栈帧中，程序结束就会销毁
		cout << "~Date()" << endl;
	}

private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

int main()
{
	Date d;
	return 0;
}

写析构函数的意义：

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		int* _array = (int*)malloc(sizeof(int) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	~Stack()
	{
		//_array:是由malloc开辟的空间，在程序结束的时候，是并不销毁（归还）的，这就需要我们使用析构函数free掉。
		free(_array); 
	}

private:
	int* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st;
	return 0;
}

编译器默认生成的析构函数

Note：编译器默认生成的析构函数特点

1. 内置类型成员不做处理。
2. 自定义类型成员会去调用他的析构函数。

4、拷贝构造函数

特性：

Note：其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
	Date(int year = 2022, int month = 8, int day = 26)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// Date(const Date d) // 错误写法：编译报错，会引发无穷递归
	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;
}

• Date(const Date d) -- 编译报错，会引发无穷递归

? ? ? ? 我们将d1传递给const Date?d，就等价于：const Date d(d1)，然后又是一个拷贝构造，继续调用拷贝构造，开始往复，一直做重复的事，所以使用引用是至关重要的！

编译器默认生成的析构函数

????????若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

//编译器自行生成的只能进行浅拷贝
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;
	}

	~Stack()
	{
		cout << "~Stack()->" << _array << endl;
		free(_array);
		_capacity = _size = 0;
		_array = nullptr;
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

????????程序出现了崩溃，很明显这个错误，就是free发生的错误，通过调试可以发现：

? ? ? ? ?他们的地址是一样的！就是因为拷贝构造，它进行的是浅拷贝，其在内存存储按字节序完成拷贝的方式下，是拷贝了_array这个地址，并未拷贝其中的数据（就是深拷贝）。

? ? ? ? 因此，浅拷贝导致：一个对象修改会影响另一个对象，会析构两次，程序崩溃。解决方式：自己实现深拷贝。

5、运算符重载

运算符重载

????????C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

特性

• 函数名字为：关键字operator后面接需要重载的运算符符号。
• 函数原型：返回值类型?operator操作符(参数列表)

Note：其特征如下：

1. 不能通过连接其他符号来创建新的操作符：如，operator@
2. 如果是内置类型，直接转换为其对应的指令，如果不是内置内省，就会去找有没有其对应的运算符重载。
3. 重载操作符必须有一个类类型参数。
4. 用于内置类型的运算符，其含义不能改变。如，‘赋值（=）就是赋值’
5. （.*? ? ::? ? ?sizeof? ? ??:? ? ?.）以上5个运算符不能重载。
6. 有几个操作数就有操作数数目-1（因为成员函数的第一个参数为隐藏的this）左操作数先，右操作数后。

• 将运算符重载函数写在类外（便于理解）

? ? ? ? 以重载 == 为例，有 d1 == d2 ，左操作数是第一个参数，右操作数是第二个参数。

// 类外的operator==
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:  --  让成员变量共有，使得类外可以访问
	int _year;
	int _month;
	int _day;
};

bool operator==(const Date& d1, const Date& d2) 
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}

int main()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl; //流优先级高
  //cout << operator==(d1, d2) << endl; -- 底层变化
	return 0;
}

• 将运算符重载函数写在类里

?????? ?然而，将写在类里的赋值运算符重载函数放入类中会报以下错误。

? ? ? ? 这是因为，类中成员函数区别于类外函数，其会有一个隐藏的形参（this指针），而赋值运算符重载函数的形参变量个数要与操作数相同。所以：

// 类里的operator==
class Date
{
public:
    //构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = 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(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl; //流优先级高
  //cout << d1.operator==(&d1, d2); -- 底层变化
	return 0;
}

? ? ? ? 所以，可以说写在类里的赋值运算符重载函数的形参个数是：等于操作数，但是实际上我们所需要写的形参个数是：操作数数目-1。

6、赋值运算符重载

Note： 赋值运算符重载格式

• 参数类型：const T&，传递引用可以提高传参效率
• 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this ：要复合连续赋值的含义

返回值T&目的是为了支持连续赋值

• 两个操作数赋值

class Date
{
public:
    //构造函数
	Date(int year = 2022, int month = 8, int day = 27)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    //赋值运算符重载函数的错误写法 -- 只适用于两个操作数
	void operator=(const Date& d) //返回值为void是可以满足的，d1 = d2无需返回值
	{
		if (this != &d)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022, 8, 28);
	d2 = d1;
  //d2.operator=(&d2, d1); -- 底层
	return 0;
}

d2 = d1;? 一底层一>? d2.operator=(&d2, d1);

（类中的赋值运算符重载是隐藏着this指针的，this == &d）

• 三个操作数赋值

????????此处就凸显了赋值运算符重载函数返回值为T&的目的：

? ? ? ? 所以针对于多操作数赋值，按照可以实现两个操作数赋值的赋值运算符重载函数：

class Date
{
public:
    //……

    //赋值运算符重载函数的错误写法 -- 只适用于两个操作数
	void operator=(const Date& d) //返回值为void是可以满足的，d1 = d2无需返回值
	{
		if (this != &d)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
	}
private:
    /……
};

? ? ? ? 以void为返回值，将无法执行，所以我们需要将this指针所指向的d2返回：

class Date
{
public:
    //……
    
    //赋值运算符重载函数
	Date& operator=(const Date& d) //返回值为void是可以满足的，d1 = d2无需返回值
	{
		if (this != &d)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
        return *this;
	}
private:
    /……
};

参数类型：const T&，返回值类型：T&，提高效率。

? ? ? ??参数类型：const T&，返回值类型：T&，是为了减少多余的拷贝构造函数的调用。

• 参数类型：const T，返回值类型：T，时：

class Date
{
public:
    //构造函数
	Date(int year = 2022, int month = 8, int day = 27)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    //拷贝构造函数
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl; //用于显示拷贝构造的调用次数
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

    //赋值运算符重载函数
	Date operator=(const Date d) //返回值为void是可以满足的，d1 = d2无需返回值
	{
		if (this != &d)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
        return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022, 8, 28);
	Date d3(1, 1, 1);
	d3 = d2 = d1;
	return 0;
}

• 参数类型：const T&，返回值类型：T&，时：

class Date
{
public:
    //构造函数
	Date(int year = 2022, int month = 8, int day = 27)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    //拷贝构造函数
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl; //用于显示拷贝构造的调用次数
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

    //赋值运算符重载函数
	Date& operator=(const Date& d) //返回值为void是可以满足的，d1 = d2无需返回值
	{
		if (this != &d)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
        return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022, 8, 28);
	Date d3(1, 1, 1);
	d3 = d2 = d1;
	return 0;
}

赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:

//private:
	int _year;
	int _month;
	int _day;
};

Date& operator=(const Date& d1, const Date& d2) //返回值为void是可以满足的，d1 = d2无需返回值
{
	if (&d1 != &d2)	//用于防止d = d此类的情况，没有错误，但是赋值没有意义
	{
		d1._year = d2._year;
		d1. _month = d2._month;
		d1._day = d2._day;
	}
	return d1;
}

???????? 原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载?

????????编译器默认生成的赋值运算符重载，以值的方式逐字节拷贝。

Note：其特征如下：（可以说是和拷贝构造函数一摸一样的）

1. 内置类型成员变量是直接赋值的（进行的时：值拷贝）。
2. 自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

? ? ? ? 与编译器生成的拷贝构造函数一样，只会将地址进行赋值，那么就会导致，对于malloc之类的在堆上开辟空间形式，会在析构函数中在一个地址上free两次，导致程序崩溃。?

7、const成员

? ? ? ? 此时Date*类型的&d1走两个函数都是可以的。?

8、取地址及const取地址操作符重载

????????作为类的默认成员函数，同样它也是可以由编译器自动生成。所以对于此成员函数，除特殊情况，我们是根本不用书写的。

特殊情况：不想使用者能提取到地址

• 私有化

class Date
{
	//class默认是私有
	//取地址及const取地址操作符重载
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
public:
	// ……
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

• 更改返回值

class Date
{
public:
	//取地址及const取地址操作符重载
	Date* operator&()
	{
		return nullptr;
	}
	const Date* operator&()const
	{
		return nullptr;
	}

private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};