C++ —— 类和对象（上）_c++ main 用对象

---

1.面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题；
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成；

2.类的引入

C语言结构体中只能定义变量，在C++中，结构体不仅可以定义变量，也可以定义函数。

//日期类
struct Date
{
	//成员函数
	void DateInit(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//成员变量
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在C++中，更喜欢用class来代替struct；

3. 类的定义

class className
{
	//类体：由成员函数和成员变量组成
}; //一定要加分号！
1
2
3
4

class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略；
类体中内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数；

类的两种定义方式：
1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理；

class Person
{
public:
	//显示基本信息
	void showInfo()
	{
		cout << _name << "-" << _sex << "-" << _age << endl;
	}

private:
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

**2.**类声明放在.h文件中，成员函数定义放在.cpp文件中；注意：成员函数名前需要加类名 ::

//.h文件
class Person
{
public:
	显示基本信息
	void showInfo();

private:
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};

//.cpp文件
//指定域中函数进行定义
void Person::showInfo()
{
	cout << _name << "-" << _sex << "-" << _age << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 类的访问限定符及封装

4.1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一起，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用；

访问限定符的说明：
1.public修饰的成员在类外可以直接被访问；
2.protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）；
3.访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止，如果后面没有出现访问限定符，作用域到 } 即类结束；
4.class的默认访问权限是private,struct的默认访问权限为public(因为struct要兼容C)；

下面简单的对struct 和 class的默认权限进行测验：

class Date
{
	int _year;
	int _month;
	int _day;
};


struct Person
{
	char* name;
	char* sex;
	int age;
};

int main()
{
	Date d1;
	Person p1;

	d1._year;
	//p1.age;

	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

先对class进行测验：

再对struct进行测验：

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别；

4.2 struct 和 class的区别

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认权限是public,class定义的类默认访问权限是private。

4.3 封装

面向对象的三大特征：封装、继承、多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互；封装的本质是一种管理，让用户更方便来使用类；

例如：

1.对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机，怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
2.当我们发现古文明时，例如兵马俑，我们是怎么处理的呢？以C语言来说，就是将兵马俑完全开放，不做任何管理，这就需要来参观的人有足够的素质，但难免会有几个素质较差的人就会破坏兵马俑，说不定哪个时候就断胳膊少腿的；以C++来说，就是国家介入管理，对兵马俑用设施保护起来，人们可以进去参观，但要受到监督，不允许你做的，你不能做，这就是一种管理；

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

5. 类的实例化

用类类型创建对象的过程，称为类的实例化
1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；
2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量；
3.做个比方。类实例化出对象就像在现实中使用建筑设计图建造出房子，类就像设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

域作用限定符能否对类中成员生效?
首先得说明下，对类成员变量与对成员函数的访问都是禁止的，但两者原因并不相同，下面进行讲解:

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


int main()
{
	Date::_year;//error
	Date::Print();//error
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

先讲对类成员变量，由于类成员函数涉及*this指针，本章后面再进行讲解；
在讲解前我先提出一个问题：类是声明还是定义？
很明显，类就是声明，因为它并没有创建物理空间，只有当它实例化后，它的每个对象才能算是定义；如果你要使用域限定符访问域中成员变量，那么前提是：域中的成员变量必须是已经定义过了的！但类中的变量只是声明，这与域作用限定符的前提不符；

6. 类对象模型

6.1 如何计算类对象的大小

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

class Person
{
	char* name;
	char* sex;
	int age;
};

int main()
{
	cout << sizeof(Date) << endl;
	cout << sizeof(Person) << endl;
	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

计算类的大小仍然使用的是sizeof，但这里有一个疑问：类中既有成员变量，又有成员函数，那么类的大小是多少呢？需不需要将成员函数的地址也一并算进去呢？

6.2 类对象的存储方式猜测

1.对象中既包含成员变量，也包含成员函数

缺点：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时， 每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

2.代码只保存一份，在对象中保存存放代码的地址

3.只保存成员变量，成员函数存放在公共的代码段

对于上述三种存储方式，计算机到底是按照哪种方式来存储的呢？

可以看到，在类对象中，并没有使用多余的空间来存储成员函数，也就是说编译器采用了第三种方式存储类对象；

注意：空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象；

class Person
{};

class Date
{
public:
	void Print(){};
};


int main()
{
	cout << sizeof(Date) << endl;
	cout << sizeof(Person) << endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.3 结构体内存对齐规则

1.第一个成员在结构体偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值；
VS默认对齐数为8
3.结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍；
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍；

7. this指针

7.1 this指针的引出

我们先来定义一个日期类Date

class Date
{
public:
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void SetDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	d1.SetDate(2022, 9, 22);
	d2.SetDate(2022, 9, 23);
	d1.Display();
	d2.Display();
	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

对于上述类，有这样一个问题：
Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
C++通过引入this指针解决该问题，即：C++编译器给每个"非静态的成员函数"增加了一个隐藏的this指针参数，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中所有"成员变量"的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

7.2 this指针的特性

1.this指针的类型：类类型*const，即成员函数中，不能给this指针赋值；
2.只能在"成员函数"的内部使用；
3.this指针本质上是"成员函数"的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4.this指针是"成员函数"第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递；

class Date
{
public:
	void Display()
	{
		cout << _year << endl;
	}
	//编译器隐含this指针
	//void Display(Date* this){} 
private:
	_year;
	_month;
	_day;
};

d1.Display();
//编译器完成this指针传递
d1.Display(&d1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们来看看两道题：
1.this指针存在哪里？

因为this指针是形参，所以存放在栈区中；

2.this指针可以为空吗？
先来看下面这两段代码：

下面两段程序的编译结果是：A.编译报错 B.运行出错 C.正常运行

//1.
class A
{
public:
	void Print()
	{
		cout <<"Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}


//2.
class A
{
public:
	void Print()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->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

对于程序1，该程序可以正常运行；因为：成员函数存在代码段中，编译器调用函数后，不会到p指向的对象中寻找函数地址；
对于程序2，该程序运行时崩溃；因为：该函数对成员变量进行了访问，但由于this指针为空，这就导致了对空指针进行解引用的操作，这会在运行时报错；

答案：

this指针可以为空，但需要保证不会进行成员变量的访问；

回到我们在类的实例化中讲到的：域作用限定符能否作用于类的第二种情况；
能否对类成员函数使用域作用限定符呢？
答案是不能，因为：类的成员函数具有隐藏的this指针，如果使用域作用限定符访问，仍然没有一个具体化的对象，这就会导致了this指针无法接收到具体对象的地址，那该函数也就由于调用参数缺少而无法调用；