【探寻C++之旅】第二章：类和对象（上）

  
媒介

   今天，我们继承踏入追寻C++的冒险历程。上一章我们简朴先容了C++中新的语法等知识，那么本章将为各人先容C++中非常紧张的一个概念：类和对象。下面让我们一起来进入类和对象的学习。
  1. 类和对象是什么

首先，我们要知道什么是类和对象：
   类（Class）是面向对象步伐设计（OOP，Object-Oriented Programming）实现信息封装的底子。类是一种用户定义的引用数据类型，也称类类型。每个类包罗数据阐明和一组操作数据或传递消息的函数。对象（Object）：类的实例称为对象。
  类的实质是一种引用数据类型，类似于 byte、short、int、long、double 等基本数据类型，不同的是它是一种复杂的数据类型。因为它的本质是数据类型，也就是我们所说的自定义类型，而不是数据，所以不存在于内存中，不能被直接操作，只有被实例化为对象时，才会变得可操作。类具有三大特性，分别是：封装、继承、多态。它与我们在C语言中学习的布局体是类似的。下面让我们进一步的认识类和对象。
2. 类的定义

我们先来定义一个简朴的日期类

1. class Date
2. {
3. public:
4.     void Init(int year, int month, int day)
5.         {
6.                 _year = year;
7.                 _month = month;
8.                 _day = day;
9.         }
10.     void print()
11.     {
12.         cout << _year << "年" << _month << "月" << _day << "日";
13.         }
14. private:   
15.     int _year;
16.     int _month;
17.     int _day;
18. };

复制代码

2.1 类定义的格式

在上面的代码中：

• class为定义类的关键字，Date为类的名字，{ }中为类的主体。
  
• 注意类定义结束时后面分号不能省略。
  
• 类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
  
• public和 private 是访问限定符。
  

为了区分成员变量，⼀般习惯上成员变量会加⼀个特别标识，如成员变量前⾯或者后⾯加_ 或者 m 开头，
C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变革是struct中可以定义函数，⼀般情况下我们照旧推荐用class定义类。

1. // C++升级struct升级成了类
2. // 1、类⾥⾯可以定义函数
3. // 2、struct名称就可以代表类型
4. // 3、C++兼容C中struct的⽤法
5. typedef struct ListNodeC
6. {
7.         struct ListNodeC* next;
8.         int val;
9. }LTNode;
10. // 不再需要typedef，ListNodeCPP就可以代表类型
11. struct ListNodeCPP
12. {
13.         void Init(int x)
14.         {
15.                 next = nullptr;
16.                 val = x;
17.         }
18.         ListNodeCPP* next;
19.         int val;
20. }

复制代码

至于在C++中，用class和struct有什么区别，我们在下面讲解访问限定符的时候会进行先容。
2.2 访问限定符

首先，我们来简朴相识一下什么是封装：
   封装就是将抽象得到的数据和举动（或功能）相联合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的联合，形成“类”，其中数据和函数都是类的成员。封装性将数据和操作封装为一个有机的整体，由于类中私有成员都是隐藏的，只向外部提供有限的接口，所以可以或许包管内部的高内聚性和与外部的低耦合性。用者不必相识详细的实现细节，而只是要通过外部接口，以特定的访问权限来利用类的成员，可以或许增强安全性和简化编程。
  C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法联合在⼀块，让对象更加美满，通过访问权限选择性的将其接⼝提供给外部的⽤⼾使⽤。
在C++中访问限定符一共有三种：

• public修饰的成员在类外可以直接被访问；
  
• protected和private修饰的成员在类外不能直接被访问，
  
• 在当前的先容中protected和private是⼀样的，到了后面讲到继承时才能体现出他们的区别。
  

访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有访问限定符，作⽤域就到 }即类结束。例如上述的日期类中：

⼀般成员变量都会被限制为private/protected，须要给别⼈使⽤的成员函数会放为public。
至于struct和class的区别则在于：

• class定义的成员没有被访问限定符修饰时默认为private，
  
• struct定义的成员没有被访问限定符修饰时默认为public。
  

2.3 类域

类定义了⼀个新的作⽤域，类的所有成员都在类的作⽤域中，在类外定义成员时，须要使⽤ :: 作⽤域操作符指明成员属于哪个类域。例如：

1. #include<iostream>
2. using namespace std;
4. class Date
5. {
6. public:
7.     //成员函数
8.     void Init(int year, int month, int day);
9. private:   
10.     //成员变量
11.     int _year;
12.     int _month;
13.     int _day;
14. };
15. // 声明和定义分离，需要指定类域
16. void Date::Init(int year, int month, int day)
17. {
18.         _year = year;
19.         _month = month;
20.         _day = day;
21. }
23. int main()
24. {
25.         Date now;
26.         now.Init(1, 1, 1);
27.         return 0;
28. }

复制代码

类域影响的是编译的查找规则，上面步伐中print如果不指定类域Date，那么编译器就把print当成全局函数，那么编译时，找不到_year等成员的声明/定义在哪⾥，就会报错。指定类域Date，就是知道print是成员函数，当前域找不到的_year等成员，就会到类域中去查找。
3. 实例化

所谓实例化便是如何天生一个对象，下面我们先来看一看实例化的概念。
3.1 实例化概念

类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。
⼀个类可以实例化出多个对象，实例化出的对象 占⽤实际的物理空间，存储类成员变量。打个⽐⽅：类实例化出对象就像现实中使⽤建筑设计图制作出房⼦，类就像是设计图，设计图规划了有多少个房间，房间⼤⼩功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。
用类实例化对象跟我们定义各种类型的变量是差不多的

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public:
6.         void Init(int year, int month, int day)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         void Print()
13.         {
14.         cout << _year << "年" << _month << "月" << _day << "日";
15.         }
16. private:
17.         // 这⾥只是声明，没有开空间
18.         int _year;
19.         int _month;
20.         int _day;
21. };
22. int main()
23. {
24.         // Date类实例化出对象d1和d2
25.         Date d1;
26.         Date d2;
27.         d1.Init(2024, 3, 31);
28.         d1.Print();
29.         d2.Init(2024, 7, 5);
30.         d2.Print();
31.         return 0;
32. }

复制代码

3.2 对象大小

分析⼀下类对象中哪些成员呢？类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包罗成员变量，那么成员函数是否包罗呢？⾸先函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中⾮要存储的话，只能是成员函数的指针。再分析⼀下，对象中是否有存储指针的须要呢，Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量year/month/_day存储各⾃的数据，但是d1和d2的成员函数Init/Print指针却是⼀样的，存储在对象中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。这⾥须要再额外哆嗦⼀下，其实函数指针是不须要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指令[call 地址]， 其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在运⾏时找，就须要存储函数地址，这个我们以后会讲解。

上⾯我们分析了对象中只存储成员变量，C++规定类实例化的对象也要符合内存对⻬的规则。
   **内存对齐规则 : **
  

• 第⼀个成员在与布局体偏移量为0的地址处。
  
• 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
  
• 对⻬数 = 编译器默认的⼀个对⻬数 与 该成员⼤⼩的较⼩值。
  
• 不同的编译器的默认对齐数不同。例如在VS中默认的对⻬数为8。
  
• 布局体总⼤⼩为：最⼤对⻬数（所有变量类型最⼤者与默认对⻬参数取最⼩）的整数倍。
  
• 如果嵌套告终构体的情况，嵌套的布局体对⻬到⾃⼰的最⼤对⻬数的整数倍处，布局体的整体⼤⼩就是所有最⼤对⻬数（含嵌套布局体的对⻬数）的整数倍。
  

  注意：没有成员变量的类实例化的对象的大小为1，这是因为如果⼀个字节都不给，怎么表⽰对象存在过呢！所以这⾥给1字节，纯粹是为了占位标识对象存在。
4. this指针

在我们的Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和Print函数时，该函数是如何知道应该访问的是d1对象照旧d2对象呢？那么这⾥就要看到C++给了⼀个隐含的this指针解决这⾥的问题。
编译器编译后，类的成员函数默认都会在形参第⼀个位置，增长⼀个当前类类型的指针，叫做this指针。⽐如Date类的Init的真实原型为： void Init(Date* const this, int year,int month, int day)
我们看到，在成员函数中this指针本身被const修饰，不能被改变，但其指向的值也就是对象的成员变量可以被修改。类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值：this->_year = year;
C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显⽰使⽤this指针。也就是：

1. class Date
2. {
3. public:
4.         // void Init(Date* const this, int year, int month, int day)
5.     //虽然实质是这样，但我们在写成员函数的形参时不能把this指针写出来
6.         void Init(int year, int month, int day)
7.         {
8.                 _year = year;
9.         //this->_month = month;
10.         //实质是这样，在函数体内可以把this指针显示的写出来，如下面的day;
11.                 _month = month;
12.                 this->_day = day;
13.         }
14.         void Print()
15.         {
16.                 cout << _year << "/" << _month << "/" << _day << endl;
17.         }
18. private:
19.         // 这⾥只是声明，没有开空间
20.         int _year;
21.         int _month;
22.         int _day;
23. }

复制代码

5. C++和C语言实现Stack（栈）的对比

⾯向对象三⼤特性：封装、继承、多态，下⾯的对⽐我们可以开端相识⼀下封装。通过下⾯两份代码对⽐，我们发现C++实现Stack形态上照旧发⽣了挺多的变革，底层和逻辑上没啥变革。

• C++中数据和函数都放到了类⾥⾯，通过访问限定符进⾏了限制，不能再随意通过对象直接修改数据，这是C++封装的⼀种体现，这个是最紧张的变革。这⾥的封装的本质是⼀种更严酷规范的管理，制止出现乱访问修改的问题。当然封装不仅仅是这样的，我们后⾯还须要不停的去学习。
  
• C++中有⼀些相对⽅便的语法，⽐如Init给的缺省参数会⽅便许多，成员函数每次不须要传对象地址，因为this指针隐含的传递了，⽅便了许多，使⽤类型不再须要typedef⽤类名就很⽅便。
  
• 在我们这个C++⼊⻔阶段实现的Stack看起来变了许多，但是实质上变革不⼤。等着我们后⾯看STL中的⽤适配器实现的Stack，可以更加感受到C++的魅⼒。
  

1. #include<iostream>
2. using namespace std;
3. typedef int STDataType;
4. class Stack
5. {
6. public:
7.         // 成员函数
8.         void Init(int n = 4)
9.         {
10.                 _a = (STDataType*)malloc(sizeof(STDataType) * n);
11.                 if (nullptr == _a)
12.                 {
13.                         perror("malloc申请空间失败");
14.                         return;
15.                 }
16.         _capacity = n;
17.                 _top = 0;
18.         }
19.         void Push(STDataType x)
20.         {
21.                 if (_top == _capacity)
22.                 {
23.                         int newcapacity = _capacity * 2;
24.                         STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
25.                         sizeof(STDataType));
26.                         if (tmp == NULL)
27.                         {
28.                                 perror("realloc fail");
29.                                 return;
30.                         }
31.                         _a = tmp;
32.                         _capacity = newcapacity;
33.                 }
34.         _a[_top++] = x;
35.         }
36.     void Pop()
37.         {
38.                 assert(_top > 0);
39.                 --_top;
40.         }
41.     bool Empty()
42.         {
43.                 return _top == 0;
44.         }
45.     int Top()
46.         {
47.                 assert(_top > 0);
48.                 return _a[_top - 1];
49.         }
50.     void Destroy()
51.         {
52.                 free(_a);
53.                 _a = nullptr;
54.                 _top = _capacity = 0;
55.         }
56. private:
57.         // 成员变量
58.         STDataType* _a;
59.         size_t _capacity;
60.         size_t _top;
61. }

复制代码

至于C语言实现的栈这里就不再赘述，感兴趣的朋友可以参考之前的文章数据布局——栈。
尾声

   若有纰漏或不足之处接待各人在评论区留言或者私信，同时也接待各位一起探究学习。感谢您的观看！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。