一、前言
小伙伴们好呀，我是 a n d u i n anduin anduin . 上篇文章我们总算把 C 语言的一些坑填完了，我们的 C++ 的知识点也相对入门了。而今天，我们将迎来 C++ 学习过程中的第一道难关：类和对象 。对于类和对象，我将分为 上、中、下 三部分。
今天是类和对象的第一部分，是入门篇，内容比较多，比较杂，有一定难度，所以小伙伴们打起精神，我们开始学习啦！
二、初识面向过程和面向对象
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题 ；而C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
两种思想的设计方式截然不同，例如设计简单外卖系统：
面向过程：关注实现下单、接单、送餐等过程。体现到代码层面就是函数（方法），总体关注过程
面向对象：关注实现类对象及类对象间的关系。用户，商家，骑手，以及他们之间的关系，提现到代码层面就是类的设计和类之间的关系
C++是基于面向对象的语言：它可以面向过程和面向对象混编，原因是 C++ 兼容 C ；但是对于 java 等纯面向对象语言：只有面向对象 。
两种思想的设计方式完全不同，而我个人认为其实面向对象的设计思想更加好，这些在我们之后的学习中就可以看出来。
三、类的引入和定义
C++ 中定义类有两个关键字 struct/class .
例如：
struct Stu { char name[10]; int age; int id; }; class cl { char id[10]; char teacher[8]; int tage; };
C++ 兼容 C 中结构体的用法，同时 struct 在 C++ 中也升级成了类 。
在 C 中创建结构体局部变量，需要写成：
struct Stu s1;
但是升级为类之后，Stu 就直接变为类的名称，当定义局部变量时，可以写为 Stu s2 ；但是也可以像上面那么写，因为 C++ 是兼容 C 的。
struct Stu s1; // 兼容 c Stu s2; // 升级到类，Stu 为类名，也是类型
同样，对它们进行访问也没问题：
C++中的 struct（类）和结构体不同的是：除了可以定义成员变量（变量）还可以成员函数（函数），成员函数可以访问成员变量，但是如果成员函数中的形参和成员变量相同 ，就像这样：
struct Stu { char name[10]; int age; int id; void init(const char* name, int age, int id) {} };
这样就分不清形参和成员变量，所以C++就会引入 ‘_’ 的定义变量名，以作区分 ；所以通常会写作：
struct Stu { char _name[10]; int _age; int _id; void init(const char* name, int age, int id) {} };
这样就会更加清晰明了，一眼看出它们之间的关系。
在接下来讲解之前，我再说明一个点，由于C++是面向对象的，所以一般把定义的变量叫做对象 ，虽然变量也对，但是最好叫对象，之后我也都会这么讲。这时，我们简单写一个类，应用我们学的知识：
struct Stu { char _name[10]; int _age; int _id; void init(const char* name, int age, int id) { strcpy(_name, name); _age = age; _id = id; } void print() { cout << _name << endl; cout << _age << endl; cout << _id << endl; } }; int main() { struct Stu s1; Stu s2; s1.init("anduin", 19, 1); s2.init("guldan", 20, 2); s1.print(); s2.print(); return 0; }
四、类的访问限定符及封装
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
面向对象的三大特性：封装、继承、多态。
封装的特性：
- 在类中，类的数据和方法都放到一起
- 访问限定符
而访问限定符是封装的一个很厉害的特性，基于访问限定符，可以对 对象 进行 严格管控 ，所以我们先学一下它。
1、访问限定符
访问限定符说明：
public修饰的成员在类外可以 直接被访问
protected 和 private 修饰的成员在类外不能直接被访问（它们类似，但本质不一样）
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到 } 即类结束。
class的默认访问权限为private，struct为public(因为struct要兼容C)
默认访问限定符，即不写时，类中的默认访问权限；一般在定义类时，建议明确定义访问限定符 ，不要用 class/struct的默认限定
访问限定符是约束外面的，对于类中，则没有限定，类里面可以全局访问。
1, 2 点：
3, 4 点：
框起来的部分均为 public
5 点：
2、封装
封装是一种更好的严格管理，不封装是一种自由管理。
封装就是让数据和方法揉搓在一起，进行 严格 的管理。对于 C 是不封装的，是一种较 松散 的管理。C++ 是将数据和方法封装到类里面，C 是数据和方法分离的（数据访问控制是自由的，不受限制的）。
那么C++ 如何进行严格管理？假设定义一个栈：
class Stack { private: int* _a; int _top; int _capacity; public: void Init() { _a = nullptr; _top = _capacity; } void Push() {} void Pop() {} void Top() {} }; int main() { Stack st1; Stack st2; st1.Push(); st2.Pop(); }
如果对于 C 语言，进行 取top 其实可以有两种方式，就像我们实现的 栈 一样（代码在链接中），也可以通过下标进行访问；也可以调用 top 接口放元素。但是这种松散的方式，若不清楚 Stack 本身的状况贸然使用 很容易出错 ，就比如博客中的 top 有两个位置，一不小心就会使用出错。
并且C语言只是推荐调用接口函数，不推荐自己操作，并没有起到强制性的管理作用：
就好比都说“红灯停绿灯行”，这也是一种推荐，但是也会有人偏要做“孤勇者”，从而造成惨痛的结果，所以这里并不严格；如果硬是要强行访问结构，也没办法
但如果 C++ 将结构部分 定义成私有 ，方法定义成共有 ，进行严格管理，就不会出现之前的情况。
就比如：
private: int* _a; int _top; int _capacity;
这些是被 private 修饰，封装在类里面的，如果直接进行操作，即访问结构，就会报错，因为这时成员变量为私有，不让访问 。
而对于一些方法来说，可以通过 st.Push() / st.Top() 进行访问；用这些对象，调用相应的成员函数 ，不仅不要像之前一样 StackPush(&st1) 一样传参，并且由于成员函数就在类中，甚至连 StackPush 这样的函数名都不用写，因为这个类就是 Stack，对于成员函数直接写为 Push 即可 ；种种约定，让我们写代码十分舒适。
由此，我们总结一下，封装就是：
数据和方法都封装到类里
能访问定义成共有；不能访问定义成私有
好的，我给你用，不好的，直接锁死，不让你访问，这就是封装的好处 ，严格管控了。
较严格的定义：在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
五、类的作用域
先举个例子，假设写一个栈，写两个文件：
Stack.h :
#pragma once class Stack { public: void Init(); void push(int x); // ... private: int* _a; int capacity; int _top; };
Stack.cpp ：
当跨文件访问时，报错了。这是因为类是由作用域的，类定义了一个新的作用域，类的所有成员都在类的作用域中。
在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域：
