类与对象（中）--六大默认函数--重点

类与对象（中）–类与对象的重点

1.构造函数–六大默认函数之一

​ 咱们可以理解成，这个函数是怕我们忘了对对象进行初始化而出现的。妈妈再也不用担心我忘记初始化对象了。

我们来看看构造函数的特点以及是如何实现的

构造函数的特性：

构造函数的特征：
其特征如下：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

   创建对象时，编译器会自动完成初始化

4. 构造函数可以重载。

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

---

构造函数的实现

#include
using namespace std;

class Date
{
public:
	void Print();
	Date(int year = 2022, int month = 9, int day = 2);
private:
	int _year;
	int _month;
	int _day;
};

Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

int main()
{
	Date d1;//没有初始化
	d1.Print();

	Date d2(2003, 6, 10);
	d2.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

​ 大家可以看到上述代码的效果，就算没有在main函数里面进行初始化，却还是完成了初始化，其实是我们在创建对象时，编译器就自动帮我们调用了构造函数。注意，想要调用构造函数，初始化时传入的参数要和构造函数的参数对应，不然编译器就会报：找不到合适的构造函数的错误，所以建议：构造函数写成全缺省参数

---

编译器自动生成的构造函数有何用处？

我们在一个类中不定义构造函数，来看看编译器默认生成的构造函数有什么特点？

#include
using namespace std;

//学生类定义了构造函数，构造函数里面还有一个打印效果
class Student
{
public:
	Student(int num = 202103008,int age = 18,double weight = 60);
private:
	int _num;
	int _age;
	double _weight;
};

//日期函数时没有构造函数的
class Date
{
public:
	void Print();
private:
	int _year;
	int _month;
	int _day;

	Student _s;//成员变量里面有一个自定义类型
};

void Date::Print()
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

student::Student(int num = 202103008,int age = 18,double weight = 60)//将构造函数定义在类的外面
	{
		_num = num;
		_age = age;
		_weight = 60;
		cout << "num:" << num << endl << "age:" << age << endl << "weight:" << weight << endl;
	}

int main()
{
	Date d1;
	d1.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

​ 大家可以看到上述代码的效果，日期类的内置类型没有进行任何操作，还是随机值。但是奇怪的是，日期类里面的学生类的构造函数被调用了。

总结：编译器生成的构造函数是有偏见的，对内置类型不做任何处理，而对自定义类型进行处理（调用其构造函数）

---

对默认构造函数的理解

​ 大家不要认为默认构造函数时编译器自动生成的构造函数，这个理解时不全面的，应该理解成在我们创建变量时，能不传入参数，编译器就自动帮你调用的构造函数，叫做默认构造函数，总共有三种。

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

当然了，构造函数是支持重载的，下面这段代码，大家自取分析以下吧。

#include
using namespace std;

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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

---

2.析构函数

​ 如果说构造函数是怕我们忘记初始化而出现，那么析构函数你可以理解成是怕我们忘记free掉malloc的空间而出现怕我们写bug，真是操碎了心啊。

---

析构函数的特征：

其特征如下：

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

---

析构函数的实现：

​ 由于日期类是不需要malloc的，所以咱们用栈类来演示析构函数：

#include
using namespace std;

class Stack
{
public:
    //构造函数
	Stack(int capacity = 4)
	{
		if (nullptr == _a)
		{
			_size = 0;
			_capacity = 0;
		}
		else
		{
			_a = (int*)malloc(sizeof(int)*capacity);
			_size = 0;
			_capacity = capacity;
		}
	}
	//析构函数
	~Stack()
	{
        cout<<"~Stack()"<<endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}

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

int main()
{
	Stack st;
	return 0;//当对象的声明周期结束，编译器就会自动调用析构函数
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

---

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

​ 类似于默认生成的构造函数一样，对内存类型不作任何处理，但是对自定义类型会调用其析构函数。

代码演示：

#include
using namespace std;
//有析构函数的字符串类
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

---

3.拷贝构造函数–六大默认成员函数之一

​ 假如有一个日期类，我们创建了一个对象d1，但是我们再想创建一个与d1一摸一样的d2对象，你会咱们办呢？

#include
using namespace std;

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

	void Print()
	{
		printf("%d-%d-%d\n", _year, _month, _day);
	}


private:
	int _year;
	int _month;
	int _day;

};

int main()
{
	Date d1(2003,6,10);
	d1.Print();
	
	//如果我们想要创建一个与d1一样的对象d2，按原来的方法，我们是这样的
	Date d2(2003, 6, 10);
	d2.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

---

拷贝构造函数的特性：

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷 贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

---

拷贝构造函数的实现：

代码演示：

#include
using namespace std;

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

	void Print()
	{
		printf("%d-%d-%d\n", _year, _month, _day);
	}
	
    //拷贝构造函数
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

private:
	int _year;
	int _month;
	int _day;

};

int main()
{
	Date d1(2003,6,10);
	d1.Print();
	
	Date d2(d1);//创建d2是按着d1的模样取创建的
	d2.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

---

为什么拷贝构造函数必须传引用：

​ 我们来谈一谈普通的传参传参，形参是一个临时变量来接收实参的值的，当在拷贝构造中我们传的是对象的值时，那么形参来接收这个值时就会再调用拷贝构造（我调用我自己），这样会陷入无限递归模式，最终程序会崩溃，当然编译器是不允许这样的语法的，会报一个编译错误。

​ 总结：自定义类型传参建议使用传引用，不传引用也不是不可以，但是会多调用构造函数。

---

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

#include
using namespace std;

class A
{
public:
	A(int a = 100)
	{
		_a = a;
	}

	A(A& aa)
	{
		_a = aa._a;
		cout << "A(A& aa)" << endl;
	}



private:
	int _a;
};

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

	void Print()
	{
		printf("%d-%d-%d\n", _year, _month, _day);
	}


private:
	int _year;
	int _month;
	int _day;

	A _aa;

};

int main()
{
	Date d1(2003,6,10);
	d1.Print();
	
	Date d2(d1);//创建d2是按着d1的模样取创建的
	d2.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

我们可以看到编译器默认生成的拷贝构造函数的作用：

1. 对内置类型（int,double,char等），会完成其值拷贝（浅拷贝）
2. 对自定义类型，会调用自定义类型的拷贝构造函数。

我们可以看到，这里编译器不在偏心了，手心手背都是肉啊！，对内置类型和自定义类型都进行了处理。

---

编译器默认生成的拷贝构造函数的缺点

前面我们可以看到，编译器默认生成的拷贝构造函数会完成其值拷贝，那肯定会有深拷贝，栈类就是需要深拷贝的一个例子。

代码演示：

#include
using namespace std;

class Stack
{
public:
	//构造函数
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int));
		_size = 0;
		_capacity = capacity;
	}
	//析构函数
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = _size = 0;
	}

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

int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

​ 如果栈类的拷贝构造函数也仅仅只是值拷贝的话，他们他们其实就是同一块空间,也就是说对一个栈空间进行增删查改，另一个栈也会被操作,而且最终调用析构函数的时候对一块空间析构了两次，程序崩溃。
​ 默认生成的拷贝构造函数对日期类够用，对栈类不够用

---

4.赋值运算符重载–六大默认成员函数之一

​ 构造函数与拷贝构造函数都是在对象创建的时候，对对象的内容进行处理，但是当对象创建完成之后，还有其他方法来修改对象的内容吗？

函数重载与运算符重载的区别和意义：

1. 函数重载：函数名相同的函数是允许存在的，这样就大大地丰富了函数的功能和可读性！

​ 就例如：C语言时，Add_int函数只能实现int类型的相加，要实 现double类型的相加就必须再定义一个Add_double函数

​ 而c++的函数重载实现了，Add函数可以实现int类型的相加也 可以实现double类型的相加，这样使得函数的灵活性也更高。

2. 运算符重载，运算符+，-,*,/,++,>,<等运算符是内置类型可以直接使用的，而自定义类型不可以直接使用，当我们使用了运算符重载，并且实现了其功能，那么自定义类型也可以像内置类型一样地去使用运算符了。

​ 这也是为什么c++的cout，cin可以不用声明类型的原因,因为 他们也是用函数重载来实现的

​ 当然cout和cin的自定义类型用法实现在我的下一篇文章里面：

---

赋值运算符重载的特性：

赋值运算符主要有四点：

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

---

赋值运算符重载的实现：

代码演示：

#include
using namespace std;


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

	void Print()
	{
		printf("%d-%d-%d\n", _year, _month, _day);
	}

	Date& operator=(const Date& d)//自定义类型做形参，建议使用传引用，这样就可以不调用拷贝构造
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
        
        return this;
	}

private:
	int _year;
	int _month;
	int _day;

	//A aa;

};
//
int main()
{

	Date d1;
	d1.Print();
	Date d2(2003, 6, 10);
	d2.Print();

	d2 = d1;
	d2.Print();

	//既然他是模仿内置函数的运算符的，能不能实现连续赋值呢
	Date d3(2012,6,6);//给他一个返回值
	d1 = d2 = d3;
	d1.Print();
	d2.Print();
	d3.Print();
    
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

---

编译器自动生成的赋值运算符重载

#include
using namespace std;


class A
{
public:
	A(int a = 100)
	{
		_a = a;
	}
	//A类的赋值运算符重载
	A& operator=(A& aa)
	{
		_a = aa._a;
		cout << "operator=(A& aa)" << endl;
		return *this;
	}
private:
	int _a;
};

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

	void Print()
	{
		printf("%d-%d-%d\n", _year, _month, _day);
	}

private:
	int _year;
	int _month;
	int _day;

	A aa;

};
//
int main()
{
	Date d1;
	Date d2(2022, 9, 7);

	d2 = d1;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

大家可以看到，这个和编译器默认生成的拷贝构造函数类似：

1. 对内置类型（int,double,char等），会完成其值拷贝（浅拷贝）
2. 对自定义类型，会调用自定义类型的拷贝构造函数。

同样也是默认生成的拷贝构造函数对日期类够用，对栈类不够用

---

5.六大默认成员函数总结–其实是四大

由于还剩下的两个几乎没有太多的利用价值，我把他们放在了下一篇文章里。

类与对象（下）里面了。

函数特性：

1. 构造函数：
   • 函数名与类名相同
   • 用类创建对象时会调用默认的构造函数
   • 默认构造函数分为（全缺省，无参，编译器自动生成）
   • 无返回值
   • 支持重载
2. 析构函数
   • 函数名-- ~+类名
   • 无返回值
   • 无函数参数–所以不支持函数重载
   • 对象销毁时时自动调用
   • 先构造的后析构，后构造的先析构（栈的特性FILO）
3. 拷贝构造函数
   • 是构造函数的重载
   • 函数参数有且只有一个，而且是自定义类型
   • 传参必须时候传引用，否则会造成无限递归
4. 赋值运算符重载
   • 返回*this

---

编译器自动生成的大比较

1. 构造函数
   • 对内置类型不做任何处理，对自定义类型会调用其构造函数
2. 析构函数
   • 对内置类型不做任何处理，对自定义类型会调用其析构函数
3. 拷贝构造函数
   • 对内置类型会进行浅拷贝（值拷贝），对自定义类型会调用其拷贝构造函数
4. 赋值运算符重载
   • 对内置类型会进行浅拷贝（值拷贝），对自定义类型会调用其赋值运算符重载

---

6.日期类各功能的实现

包含了

1. 日期+天数
2. 日期+=天数
3. 日期-天数
4. 日期-=天数
5. 日期-日期
6. 日期大小的相互比较 > < >= <= == !=
7. 日期的前置++，后置++
8. 日期的前置–，后置–

由三个文件来实现程序，已经将其分享到gitee，大家可以自行观看

2.3日期类各功能实现/2.3日期类各功能实现 · small_sheep/cplusplus0study - 码云 - 开源中国 (gitee.com)

---

本片文章真的制作不易，花费博主大量笔墨和精力，还望观众老爷们可以细心观看，多多点赞，评论。

你们的支持是我最大的动力，感谢！(* ￣3)(ε￣ *)