类与对象（中篇）

Posted 2021-11-10 雨轩（小宇）

类与对象中篇

• 前言
• 类的六个默认成员函数
• 构造函数和析构函数
• • 1、构造
  • 2、析构
  • 3、拷贝构造函数
• 赋值运算符重载
• const成员

前言

这篇偏难，万字总结，需要读者细心观看，需要有上篇的基础。

类的六个默认成员函数

如果一个类中什么都没有，简称为空类。但空类里面会自动生成6个默认成员函数，因为这是由编译器生成的，我们看不到。

空类：class Date {};

构造函数和析构函数

1、构造

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

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

知道了构造函数的特点，那么我们可以来看看构造函数到底有什么用？

class Date
{
public:
	//构造函数支持重载，那么也支持缺省（全缺省，半缺省，缺省）
	Date(int year = 1, int month = 2, int day = 3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	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;
	d1.SetDate(2018, 5, 1);
	d1.Display();

	Date d2(2021, 10, 21);
	d2.Display();
//注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	Date d3();
	return 0;
}

通过这一段代码，我们可以得知，在不使用构造函数时，我们只能创建对象，在调用方法来设置日期。使用构造函数，可以在创建对象时就将日期信息带进去了，避免了调用函数的繁琐。

• 关于构造函数全缺省的问题

1. 通过代码我们发现，当构造函数写成全缺省的时候，我们创建对象不传参也不会报错，编译器会把它当成默认构造函数（即无参），此时我们不需要在自己定义一个无参构造函数。
2. 我们也可以在创建对象时传参，也不会报错，所以这是构造函数写成全缺省的好处
3. 传参即有参构造，不传参即无参构造函数

• 重点 1

1. 这里需要注意的是，构造函数支持重载，我们通过有参构造函数去去初始化对象的时候，也要显示的写上无参构造函数，或者语法会出错。
2. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
3. 构造函数既然可以重载，那么也支持缺省值的用法
4. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数

• 重点 2

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

• 重点3

关于编译器生成的默认成员函数，有很多小伙伴会疑惑：我们不显示写构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又啥都没干。d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。那编译器默认生成的构造函数有什么用？

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
	Time _tt;//自定义类型 struct、class、union
};
int main()
{
	Date d;
	return 0;
}

运行这个程序我们会发现Time 类的构造函数被调用了。

编译器默认生成的构造函数的作用：编译器生成默认的构造函数会对自定义类型成员 _tt 调用的它的默认成员函数。
C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型

• 重点4

对于成员变量，我们要注意成员变量的风格，设置其名称时要注意不要与形参重名，避免起冲突。

看程序编译的结果，成员变量未检测到，Set函数中相当于形参赋给形参了。

虽然从上一篇，我们知道可以用this指针解决命名冲突的问题。

但是，我们自己写成员变量的时候就要注意这种冲突，避免程序崩溃。

因此我们可以用驼峰法命名或者加一个下划线来避免命名冲突（常用的方法是加下划线）

其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

2、析构

析构函数：析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作

• 与构造函数一样析构函数是特殊的成员函数。

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

#include<iostream>
using namespace std;
#include<assert.h>
typedef int DataType;
class SeqList
{
public:
	// 使用了缺省，当创建对象时不传参，也不会报错
	SeqList(int capacity = 10)
	{
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
		if (_pData)
		{
			free(_pData); // 释放堆上的空间
			_pData = NULL; // 将指针置为空
			_capacity = 0;
			_size = 0;
		}
		cout << "~SeqList()" << endl;
	}
private:
	int* _pData;
	size_t _size;
	size_t _capacity;
};
int main()
{
	SeqList q(20);
	//对象声明周期结束就会调用析构函数，清理指针_pData,_size,_capacity
	return 0;
}

与构造函数一样，如果一个类中包含自定义类型，也会调用它的析构函数

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

3、拷贝构造函数

在大多数情况下，我们可能会复制一个对象，也就是拷贝的意思，那么我们如何在创建对象时，创建一个与这个对象一某一样的新对象呢？

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数也是构造函数，相当于重载
	//const保证不修改，因为是拷贝，所以修改的话没有任何意义
	//但这里必须得用引用，为什么？继续看下面
	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;
	Date d2(d1);//传参
	d1.Print();
	d2.Print();
	return 0;
}

将对象当做参数传过去即可

构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

上面的代码中留了一个问题，为什么拷贝构造的函数要用引用的形式，如果用传值的方式会出现什么后果？

这里会出现无穷递归，传参也是一个拷贝构造，注意拷贝构造方法传引用，不要传值

我们再来看看若未显示定义拷贝构造函数，编译器默认生成的拷贝构造函数。

class A
{
public:
	A()
	{

	}
	A(const A& a)
	{
		cout << "const A& a" << endl;
	}
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A _a;
};
int main()
{
	Date d1;
	// 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的
	Date d2(d1);
	d1.Print();
	d2.Print();
	return 0;
}

通过编译结果我们可以看到，使用编译器的默认构造函数效果是一样的，编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了。

我们不写，编译器默认生成拷贝构造，跟构造和析构又不太一样的
不会去区分内置类型和自定义类型成员，都会处理
1、内置类型，字节序的浅拷贝（按字节序的拷贝）
2、自定义类型，会去调用他的拷贝构造完成拷贝

但这只是对于日期类，如果对于其他类也可以使用编译器默认的拷贝构造函数嘛？

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

这也就是字节序的值拷贝（浅拷贝）带来的危险，至于怎么解决，我们后期在来学习。

所以我们可以总结为以下几点

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
3. 要注意浅拷贝带来的危险

赋值运算符重载

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

函数名：关键字operator加重载的运算符符号
函数原型：返回值类型 operator操作符(参数列表)

注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型或者枚举类型的操作数
• 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
• 作为类成员的重载函数时，其形参看起来比操作数数目少 1 成员函数的操作符有一个默认的形参this，限定为第一个形参
• .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现

我们先来看看 == 运算符的重载

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;
}
void Test()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl;
}
int main()
{
	Test();
	return 0;
}

我们通过重载 == 运算符，然后就可以判断两个对象是否相等了，但是这里没有封装成成员函数，安全性不高，接下来我们重载成成员函数

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d2)
	{
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	d1 == d2;  
// d1==d2 -> d1.operator(d2) -> d1.operator(&d1,d2)
	d1.operator==(d2);// 与d1==d2效果一样
	return 0;
}

这里我们重载成了成员函数之后，发现不能直接去调用这个函数了，只能用对象去调用这个接口函数，体现了封装的好处。

我们这里也发现封装之后有两种调用方式，他们的效果是一样的，汇编代码是一样的。

我们再来看看经常用到的赋值运算符重载

class Date
{
public:
	Date(int year = 1900, 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;
	}
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	//注意返回引用，为什么就不用我说了，前面讲到的临时变量
	}
	void Traverse()
	{
		cout << _year << _month << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 22);
	Date d2;
	d2 = d1;
	d2.Traverse();
	return 0;
}

通过重载，我们就可以将 d1 赋值给 d2，但是这里同学们发现了为什么运算符重载要返回引用嘛？

返回引用，减少了一次拷贝构造
赋值运算符主要有四点：

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝

这里我们会发现编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝，但是我们也还是需要自己写赋值重载函数的，上面讲到的对同一块空间释放的问题，忘记的可以翻翻上面，也是浅拷贝的问题，后面再说。

总结：

1. 运算符默认都是给内置类型变量使用的
2. 自定义类型的变量想用这些运算符，得自己进行运算符重载
3. 自己进行运算符重载，也就是写一个函数去定义运算符的行为

const成员

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

class Date
{
public:
	//加了const，表示成员函数为一个常函数，不能对任何成员做修改
	void Display() const
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year = 0; // 年
	int _month = 0; // 月
	int _day = 0; // 日
};
void Test()
{
	Date d1;
	d1.Display();
	
}
int main()
{
	Test();
	return 0;
}

如果修改了，会出现下面的语法错误

const总结

1. 成员函数加const，是有好处的，这样const 对象 和 非const对象都可以调用
2. 不是所有成员函数都要加const
3. 如果一个成员函数内部需要修改成员变量，那就不用加const，比如初始化的函数等
4. 如果对成员不做任何修改的函数，在写的时候最好加上const

const 常考

1. const对象可以调用非const成员函数吗？ 不能
2. 非const对象可以调用const成员函数吗？ 能
3. const成员函数内可以调用其它的非const成员函数吗？ 不能
4. 非const成员函数内可以调用其它的const成员函数吗？ 能

const权限可以缩小，不能方法

不明白的可以去看看const的用法