C++类和对象（中）

系列文章目录

C++入门

C++类和对象（上）

C++类和对象（中）

C++类和对象（下）

---

---

前言

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

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

---

一、构造函数

我们之前定义过一个日期类：

class Date{
public:
 void SetDate(int year, int month, int day)
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
 
 void Display()
 {
	 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
private:
	 int _year;
	 int _month;
	 int _day;
};
}
int main()
{
	 Date d1,d2;
	 d1.SetDate(2018,5,1);
	 d1.Display();
 
	 Date d2;
	 d2.SetDate(2018,7,1);
	 d2.Display();
	 return 0;
}

对于这个类而言，当我们要初始化对象或者给对象设置内容时可以通过调用SetDate的公有方法给对象设置内容。但是有时候，我们可能会忘记初始化对象，又或者说，这样每次创建时都用此方法设置对象内容未免有些麻烦了。那能否在对象创建时，就将内容设置进去呢？

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

构造函数特点：

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(2022, 4, 7);
}

注意：调用无参构造函数时不用加上()，否则就成了一个函数声明。

5. 如果类中没有显示的定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义了，编译器就不再生成。
6. 无参构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

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(2022, 4, 7);
}

这里Date d1就会出问题，因为没有默认构造函数！

class Date
{
public:
	1.无参构造函数
	Date()
	{}
	//2.带参构造函数
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};

而上面代码也有问题。因为有多个默认构造函数。

注意：无参构造函数，全缺省的构造函数和我们没写编译器自动生成的构造函数，都是默认成员函数。

既然编译器会给默认构造函数，那我们是不是就可以不用写了呢？

class Date
{
public:
	1.无参构造函数
	//Date()
	//{}
	//2.带参构造函数
	//Date(int year = 2000, int month = 1, int day = 1)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	void PrintDate()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};
void TestDate()
{
	Date d1;
	d1.PrintDate();
}

这里我们没有写默认构造函数，编译器会自动生成默认构造函数，来让我看看一下结果：

好像全部都是随机值啊，编译器貌似什么也没做呀！

其实，C++把类型分为内置类型（基本类型）和自定义类型。内置类型就是语法已经定义好的类型，如：int、char、double等，自定义类型就是我们使用class、struct、union等自己定义的类型，而对于自定义类型，编译器就会调用其默认构造函数。

class Date
{
public:
	1.无参构造函数
	//Date()
	//{}
	//2.带参构造函数
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};

class Time
{
public:
	//Time()
	//{
	//	cout << "Time()" << endl;
	//	_hour = 0;
	//	_minute = 0;
	//	_second = 0;
	//}
	void PrintTime()
	{
		cout << _hour << ':' << _minute << ':' << _second << endl;
		d.PrintDate();
	}
private:
	int _hour;
	int _minute;
	int _second;
	Date d;
};
void TestDate()
{
	Time t;
	t.PrintTime();
}

结果如下：

二、析构函数

析构函数与构造函数功能相反，析构函数并不是完成对象的销毁，对象销毁工作由编译器完成，而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

析构函数的特征：

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

代码如下：

#include<assert.h>
typedef int DataType;

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

在SeqList对象生命周期结束时，编译器就会自动的调用~SeqList这个析构函数。

和构造函数类似，对于自定义类型，编译器会自动调用其析构函数。

三、拷贝构造函数

对于内置类型，我们可以用相同类型的变量来为其初始化。那么对于自定义类型，能否这样做呢？答案是可以的：

拷贝构造函数就能提供这样一种功能：只有单个形参，该形参对本类型对象的引用，一般用const修饰，在用已存在类类型对象创建新对象时由编译器自动调用。

拷贝构造函数的特征：

1. 拷贝构造函数是构造函数的一种重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷的递归调用。

因为实参的值传递给形参就会调用拷贝构造，而拷贝构造又要传参，传参呢又要调用拷贝构造…

class Date
{
public:
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 10, 1);
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

上面代码是我们自己定义的拷贝构造函数，那如果我们不显示定义。系统也会生成默认的拷贝构造函数。如下：

class Date
{
public:
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date(const Date& d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 10, 1);
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

请看结果：

好像也能完成拷贝构造。

其实系统生成的默认拷贝构造函数，按内存存储字节来完成拷贝，这种拷贝我们叫做浅拷贝，也叫值拷贝。

对于日期这样的类来说，浅拷贝也就是值拷贝能达到我们的目标。但是对于另一些类来说，浅拷贝就会出错。比如：

lass 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;
};
int main()
{
	 String s1("hello");
	 String s2(s1);
}

上述的代码使用了浅拷贝，但是s1和s2中的成员变量却指向的是同一块地址。这样，当我们调用析构函数就会对那块地址空间释放两次。而且如果我们要更改s1或s2中成员变量指向的内容时，另一个也会随之更改。

四、赋值运算符重载

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

赋值运算符重载函数名为：关键字operator后面接需要重载的运算符符号（中间不加空格）。

函数原型：返回值类型 operator操作符（参数列表）。

注意：不能通过连接其他符号来创建新的操作符。比如operator@
重载操作符必须有一个类类型或枚举类型的操作数。
用于内置类型的操作符。不能改变其含义。
对于.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

下面是一个==的运算符重载:

代码如下：

class Date
{
public:
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_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;
	}

	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 10, 1);
	d1.Print();
	Date d2(d1);
	d2.Print();
	cout << (d1 == d2) << endl;

	return 0;
}

下面是一个赋值运算符的重载：

代码如下：

class Date
{
public:
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_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;
	}
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}

	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 10, 1);
	Date d2(d1);
	cout << (d1 == d2) << endl;
	Date d3;
	d3.Print();
	d3 = d1;
	d3.Print();
	return 0;
}

如果一个类没有显示的定义赋值运算符重载，编译器也会生成一个，完成对象按照字节序的值的拷贝。 当然，这种拷贝也属于浅拷贝。

五、const成员

const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

请看下方代码：

class Date
{
public:
 void Display()
 {
	cout << "Display ()" << endl;
	cout << "year:" << _year << endl;
	cout << "month:" << _month << endl;
	cout << "day:" << _day << endl << endl;
 }
 void Display() const
 {
	cout << "Display () const" << endl;
	cout << "year:" << _year << endl;
	cout << "month:" << _month << endl;
	cout << "day:" << _day << endl << endl;
 }
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
void Test()
{
	Date d1;
	d1.Display();

	const Date d2;
	d2.Display();
}

这里对象d1的初始化是正常的，而d2对象的初始化就会有问题：

我是这样理解的，如果不写构造函数，让编译器自动生成的话，其实编译器对内置类型啥都没做，所以不能算作初始化。

六、取地址符重载

class Date
{
public:
	Date* operator&()
	{
		return this;
	}

	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

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