C++语言程序设计(第5版 郑莉、董渊)学习笔记（自用~）

C++语言程序设计 第5版

• 1.前言
• 2.内容
• • 第一章 绪论
  • • 1.1语言发展
    • • 1.1.1 概述 机器语言——>汇编语言——>高级语言（包括C++）
      • 1.1.2 面向对象
      • • 结构化程序设计（面向过程的程序设计方法)
        • 面向对象的方法
    • 1.2 信息存储
    • • • 1.2.1 二进制
        • 1.2.2 进制转换
        • 1.2.3 信息存储单位
        • 1.2.4 二进制数编码表示（原、反、补）
        • 1.2.5 程序开发概念
  • 第二章 C++语言简单程序设计
  • • 2.1 概述
    • • 2.1.1 C++语言特点
      • 2.1.2 词法记号
    • 2.2 基本数据类型和表达式
    • • 2.2.1 基本数据类型
      • 2.2.2 常量
      • 2.2.3 变量
      • 2.2.4 运算符与表达式
    • 2.3 数据的输入输出
    • • 2.3.1 I/O流
      • 2.3.2 I/O格式控制
    • 2.4 控制结构
    • 2.5 类型别名、auto
  • 第三章 函数
  • • 3.1 函数的定义与使用
    • 3.2 函数参数传递
    • 3.3 内联函数
    • 3.4 带默认形参值的函数
    • 3.5 函数重载
    • 3.6 C++系统库函数
  • 第四章 类与对象
  • • 4.1 面向对象的基本特点
    • • 4.1.1 抽象
      • 4.1.2 封装
      • 4.1.3 继承
      • 4.1.4 多态
    • 4.2 类和对象
    • • 4.2.1 类的定义和使用
      • 4.2.2 类成员的访问控制
      • 4.2.3 对象
      • 4.2.4 类的成员函数
    • 4.3 构造函数
    • 4.4 拷贝构造函数
    • • 4.4重点 拷贝构造函数调用的三种情况
    • 4.5 析构函数
    • 4.6 类的组合
    • • 4.6重点 构造、析构函数的调用顺序
    • 4.7 类的组合
    • 4.8 UML图形标识
    • 4.9 结构体 struct
    • 4.10 组合体 union（联合体）
    • 4.11 枚举类型 enum
    • • 4.11.1 不限定作用域的枚举类型
      • 4.11.2 限定作用域的枚举类
      • 4.11.3注意
    • 共用体 和 枚举类型 混合使用实例
  • 第五章 数据的共享与保护
  • • 5.1 标识符的作用域与可见性
    • • 5.1.1 作用域
• 3.总结
• 4.更新日志

1.前言

临近期末 整理笔记后续复习使用
前三章 大多关于C
后面的 才是真正C++精华

2.内容 第一章 绪论 1.1语言发展 1.1.1 概述 机器语言——>汇编语言——>高级语言（包括C++）

软件：各种程序+文档资料
指令：计算机可识别的命令（所有指令的集合叫做指令系统）
汇编语言：将机器语言映射为一些可被读懂的助记符 eg:ADD
高级语言：屏蔽机器细节，采用有一定含义的数据命名和执行语句
面向对象的语言：为了能更直接地描述客观世界中存在的事物

1.1.2 面向对象

面向对象的编程语言将客观事物看作具有属性和行为（或称服务）的对象，通过抽象找出同一类对象的共同属性和行为，形成类。

结构化程序设计（面向过程的程序设计方法)

①自顶向下、逐步求精;
②程序结构按功能划分为若干个基本模块，模块形成树状结构
③模块之间关系尽量简单，功能上相对独立
④每个模块内部均是由顺序、选择、循环结构组成
⑤模块化的实现具体方法是 使用子程序

面向对象的方法

①将数据 及 对数据的操作方法（即 函数 ） 封装在一起，作为对象
②对同类型对象抽象出共性，形成类
③类通过外部接口与外界发生关系，对象与对象之间通过 **消息（即 函数调用 ）**进行通信

基本概念：

1.对象：描述客观事物的实体（由一组属性和一组行为构成） [直升飞机]

2.类：具有相同属性和服务的一组对象的集合 [飞机类]

3.封装：将对象的属性和服务组合成独立的系统单位，并尽可能隐蔽对象的细节

4.继承：特殊类拥有一般类的全部属性和服务 [儿子继承父亲 直升飞机类继承飞机类]

5.多态性：一般类中定义的行为，被特殊类继承后，可以有不同的实现 [同一个行为，根据调用对象不同，进行不同的响应]

（先大致了解即可，后续会详细介绍~）

面向对象软件开发流程：

分析——>设计——>编程——>测试——>维护
OOA——>OOD——>OOP——>OOT——>OOSM

1.2 信息存储 1.2.1 二进制 1.2.2 进制转换

1.R进制转换为十进制： 乘以对应的 权 再求和
2.十进制转换为R进制：
①整数部分 除R取余，倒读
②小数部分 乘R取整，正读
3.二、八、十六进制转换
每位八进制数相当于3位二进制数
每位十六进制数相当于4位二进制数

1.2.3 信息存储单位

位 bit
字节 byte/B 1B=8bit 1KB=1024B 1MB=1024KB 1GB=1024MB
字 word ：独立的信息单位 （8位、16位、32位、64位）
机器字长 与机器硬件指标有关，一般指参加运算的寄存器所含有的二进制位数（32位 、 64位）

1.2.4 二进制数编码表示（原、反、补）

原码： 由于原码对于 +0 和 -0 的表示不同，所以才去寻找其它表示方法
反码： 原码除了符号位外，逐位取反 （相当于原码、补码转换的跳板）
补码： 反码+1

从原码到补码的转换：原码 除了符号位 按位取反再加1
从补码到原码也可以 除了符号位 按位取反再加1

注意：补码运算时，可能会 “溢出”，导致结果不是预想的

1.2.5 程序开发概念

源程序： 用源语言（汇编语言、高级语言…）编写的、有待翻译的程序
目标程序： 源程序通过翻译加工后生成的程序 （机器语言、汇编语言或其它中间语言）
翻译程序： 包括以下三种

①汇编程序 （将汇编语言编写的源程序 翻译为 机器语言形式的程序）
②编译程序 （将高级语言编写的源程序翻译为 机器指令）
③解释程序（ 逐句 将高级语言编写的源程序翻译为 机器指令）

完整程序过程

编辑 ——>  编译  ——>  连接  ——>  执行
    .cpp       .obj        .exe

第二章 C++语言简单程序设计 2.1 概述 2.1.1 C++语言特点

①尽量兼容C ②支持面向对象的方法

初步体验

#include 
using namespace std;
int main()
{
	cout<<"Hello~"< 
2.1.2 词法记号 
1.关键字
 ①基本数据类型： bool、char、short、int、float、double
 ②执行： default、case、continue、break、goto、static、extern、auto
 ③类： class、delete、friend、virtual、union、inline、operator、template
 （涵盖常用的部分~）
 
2.操作符（运算符）
 用于各种运算的符号 + - * / 以及 and(与) or(或) not(非) xor(异或)…
 
3.标识符
 程序员定义的单词
 规则： 大小写字母或下划线开头、由大小写字母下划线和数字组成、不能是C++的关键字或者操作符
 
4.文字
 程序中直接使用符号表示的数据 包括 数字、字符、字符串、布尔文字
 
5.分隔符
 用于分隔各个词法记号或程序正文
 （） {} ， ： ；
 
6.空白
 空格、制表符（TAB）、垂直制表符、换行符、回车符、注释
 
2.2 基本数据类型和表达式 
2.2.1 基本数据类型 
 
2.2.2 常量 
1.整型常量：正整数、负整数、零 eg: 123 0123 0x5af 123ll（ll表示类型至少为 long long）
 2.实型常量：
 ①一般形式 12.5 -12.5
 ②指数形式 3.1415e+3 即 3.1415 * 103
 3.字符常量
 单引号括起来的字符 ‘a’ ‘!’
 4.字符串常量
 双引号括起来的字符 “abcde”
 5.布尔常量
 true 、 false
 6.符号常量
 
const int PI=3.14159;
//PI即为符号常量，表示3.14159
 
2.2.3 变量 
1.声明形式：
 
数据类型   变量名1，变量名2.....
int i;
 
2.变量的初始化
 在定义变量的同时，对其设置初始值
 
//四种方式
int i=10;
int i={10};
int i{10};
int i(10);
 
3.变量的存储类型
 
auto 暂时性存储，其存储空间可被若干变量多次覆盖使用
register 放在通用寄存器中，访问的速度较快
extern  在所有函数、程序段中均可引用
static  内存中固定地址存放 ，整个程序运行期间均有效
 
2.2.4 运算符与表达式 
表达式是计算求值的基本单位
 ①算术运算符：
 
+ - * /   %  ++  --

int i=10;
cout< 
②赋值运算符
 
a=4;
a=b=9;
 
③逗号运算
 
a=3*5,a*4;     //结果为60，但a的值为15（因为并非a*=60）
 
④逻辑运算
 关系运算是一种比较简单的逻辑运算
 
优先级较高  <  <=   >   >=
较低     ==   !=
 
其余
 
优先级逐渐降低
!   &&    ||
非   与    或
 
注意：
 && || 具有 “短路” 特性，即运行时先对第一个操作数求值，
 对于 && 而言，如果第一个操作数其值为false，则不再对第二个操作数求值
 对于|| 而言，如果第一个操作数其值为true，则不再对第二个操作数求值
 
⑤条件运算符
 表达式1？表达式2：表达式3
 先计算表达式1，如果表达式1为true，则执行表达式2，否则执行表达式3
 
//输出a，b中较大的数字
int a=3,b=5;
cout<< a>b ? a : b;
 
⑥sizeof运算符
 sizeof运算符用于计算某种类型的对象在内存中所占的字节数
 
sizeof(int);

int a;
sizeof(a);
 
⑦位运算
 
 &          |          ^
按位与    按位或    按位异或
全1为1   有1则1   相同为0，不同为1
 
⑧运算符的优先级和结合性
 
 
 ⑨混合运算时数据类型转换
 
转换基本原则:由低类型数据转换为高类型数据
char(unsigned)   short(unsigned)   int(unsigned)   long(unsigned)    long long   float  double
低                                                                                       高
 
2.3 数据的输入输出 
2.3.1 I/O流 
cin 输入
 cout 输出
 
<<  预定义的插入符
>>  提取符
 
2.3.2 I/O格式控制 
头文件 iomanip
例子： 输出浮点数3.14159，设置域宽为5个字符，小数点后保留两位有效数字
#include 
using namespace std;
#include 
int main()
{
	double a = 3.14159;
	cout << setw(5) << setprecision(3) << a << endl;
	      //域宽5      //包括小数点，共3位
	return 0;
}
 

 上图中 在3前面有一个空格字符，加上小数点一个字符，共5个字符，即域宽为5
 
2.4 控制结构 
if
if else
if else if else (嵌套)
while
do while {};  

for()     [范围for语句挺方便的，着重学习掌握一下]
例子：
遍历数组a

int a[5]={1,2,3,4,5};
for(int i=0;i<5;i++)
	cout< 
2.5 类型别名、auto 
typedef long long ll;
//用 ll 替代原来的 long long  两者表示的含义相同

long long a=10;
//等价于
ll  a=10;
 
auto 即令编译器自己判断变量的类型（可能猜错）

double a=3.5;
auto b=a;
cout< 
 
 
第三章 函数 
3.1 函数的定义与使用 
//函数定义
类型说明符 函数名（形参列表）
{
	
}

//函数（原型）声明     (函数调用之前，要进行函数声明)
类型说明符 函数名（形参列表）;


//函数调用
函数名（实参列表）
 
3.2 函数参数传递 
1.值传递
 发生函数调用时，给形参分配内存空间，并用实参来初始化形参（直接将实参的值传递给形参） [这一过程是参数值的单向传递过程]
 
2.引用传递
 形参为引用， 则可以通过形参的修改影响实参
 
void swap(int &x,int &y)
{
	int t=x;
	x=y;
	y=t;
}

swap(a,b);
 
3.3 内联函数 
将功能简单、规模较小、使用频繁的函数，设计为内联函数，节省参数传递、控制转移的开销
 （内联函数并非在调用时发生控制转移，而是在编译时将函数体嵌入在每个调用处）
 
inline 类型说明符   函数名(形参表)
{
	语句序列
}
 
3.4 带默认形参值的函数 
函数在定义时，可以预先声明默认的形参值
 有默认值的形参必须在形参列表的最后（因为实参和形参的结合顺序是从左向右）
 
在相同的作用域内，不允许在同一个函数的多个声明中对同一个参数的默认值重复定义，即使前后定义的值相同也不行。如下图：
 
 
3.5 函数重载 
两个以上的函数，具有相同的函数名，但是形参个数或者类型不同，编译器根据实参和形参的类型，个数的最佳匹配，自动确定调用哪一个函数
 

 补充：还有一种是根据类型中是否包含 const 确定
 
3.6 C++系统库函数 
cmath 等 c开头的基本上是继承c而来的，不建议使用.h结尾的
 
第四章 类与对象 
4.1 面向对象的基本特点 
4.1.1 抽象 
抽象：对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。
 包括 数据抽象（即基本性质）、行为抽象（功能抽象）
 
eg：对于时钟类，数据抽象是指抽离出 时、分、秒 行为抽象是指 显示时间、设置时间
 
4.1.2 封装 
将抽象所得到的数据和行为相结合，形成有机整体（将抽象出来的东西形成一个 ”类“）
 
4.1.3 继承 
特殊类与一般类的关系
 
4.1.4 多态 
包括 重载多态、强制多态、包含多态、参数多态
 多态性：一段程序可以处理多种类型对象的能力
 
4.2 类和对象 
面向对象程序设计中，程序模块是由类构成的。
 类是对逻辑上相关的函数与数据的封装，它是对问题的抽象描述。
 定义一个类，便可以定义该类的变量，该变量称为该类的对象（类的实例化）
 
4.2.1 类的定义和使用 
class 类名称{
	public:
		外部接口
	private:
		私有成员
	protected:
		保护成员
};
 
4.2.2 类成员的访问控制 
对类成员权限的控制，可通过设置成员的访问控制属性而实现。
 访问控制属性可以有一下3种：public 、private、protected
 
public:外部接口
private:只可本类成员访问,类外部任何访问都不可
protected: 与private类似，但是在继承时与private不同
 
4.2.3 对象 
类的特定实体（实例）
 
类名  对象名
Clock my_clock;
 
4.2.4 类的成员函数 
在类的外部，只可访问到类的公有成员，类的成员函数可以访问到类的全部成员
 类外访问成员函数 用 .
 
 
注意：类的成员函数中，既可以访问目的对象的私有成员，又可以访问当前类的其他对象的私有成员。
 
1.带默认形参值的成员函数
 
 2.内联成员函数
 
1.隐式声明:将函数体放在类内
2.显式声明:类外前面加上inline
 
 
4.3 构造函数 
在定义对象的时候进行数据成员设置，称为对象的初始化
 
构造函数:在对象被创建时，利用特定的值构造对象，将对象初始化为一个特定的状态
（在对象创建时自动被调用）
 
使用初始化列表初始化，效率更高~
 
构造函数：
1.默认构造函数（系统提供）
2.构造函数（为了完成自己想要的初始化）
3.拷贝构造函数（复制构造函数）
 
 
4.4 拷贝构造函数 
使用一个已经存在的对象，去初始化同类的一个对象
 参数为 本类对象的引用
 
class 类名{
	public:
		类名（形参表）    //构造函数
		类名（类名 &对象名）  //拷贝构造函数
}

类名::类名（类名 &对象名）
{
	函数体
}
 
 
4.4重点 拷贝构造函数调用的三种情况 
（1）用类的一个对象去初始化类的另一个对象时
 
Point p1(1,2);
//以下两种均可
Point p2(p1);
Point p3=p2;
 
注意是初始化！！！并非赋值！！！
 
Point p1(1,2);
Point p2;
p2=p1;
//这样则不会调用拷贝构造函数，而是利用 = 的重载 进行赋值
 
（2）函数的形参是类的对象，调用函数时，进行形参和实参结合时
 
void fun(Point p)
{
	cout<
	Point p1(1,2);
	fun(p1);      //调用函数时，拷贝构造函数被调用
}
 
（3）如果函数的返回值是类的对象，函数执行完成返回调用者时
 
Point fun()
{
	Point p1(1,2);
	retunr p1;       //创建临时无名对象，执行拷贝构造函数
}

int main()
{
	Point b=fun();      //无名对象在执行完成后消失
}
 
4.5 析构函数 
完成对象被删除前的一些清理工作
 在对象的生存期即将结束时自动被调用
 析构函数不接受任何参数
 
~类名（） {}   //这样即可
 
4.6 类的组合 
一个类中内嵌其他类的对象作为成员的情况
 
类名::类名 （所有所需形参）:内嵌对象1（从所有形参中取出部分），内嵌对象2（同理）...
{类的初始化}
 
4.6重点 构造、析构函数的调用顺序 
（1）调用内嵌对象的构造函数，调用顺序按照 内嵌对象在组合类定义中出现的次序
 （与 内嵌对象在构造函数的初始化列表中出现的顺序 无关！！！！）
 （2）执行本类构造函数
 
析构函数调用顺序与构造函数调用顺序 相反~~
 
4.7 类的组合 
#include 
using namespace std;
//线段类 类的组合  一个线段两个端点以及长度
#include 
class Point {
public:
	Point(double x = 0, double y = 0) :x(x), y(y) {}
	Point(Point& p);
	double get_x() { return x; }
	double get_y() { return y; }
private:
	double x, y;
};

Point::Point(Point& p)   //拷贝构造函数
{
	x = p.x;
	y = p.y;
	cout << "调用Point类拷贝构造函数" << endl;
}  


class Line {
public:
	Line(Point p3, Point p4) :p1(p3), p2(p4) { len = sqrt((p3.get_x() - p4.get_x()) * (p3.get_x() - p4.get_x()) + (p3.get_y() - p4.get_y() * (p3.get_y() - p4.get_y()))); }    //构造函数
	Line(Line& l);
private:
	Point p1, p2;   //两个端点
	double len;       //线段长度
};

Line::Line(Line& l)//:p1(l.p1),p2(l.p2)   //注意区分两种写法，决定是否调用拷贝构造函数
{
	//如果放在里面写，则不会调用Point类的拷贝构造函数，因为利用的是 = 号的重载
	p1 = l.p1;
	p2 = l.p2;
	len = l.len;
	cout << "调用Line类拷贝构造函数" << endl;
}

int main()
{
	Point p1(1, 2), p2(4, 5);
	Line l1(p1, p2);
	Line l2(l1);

	return 0;
}
 
 
前向引用声明，自己看看
 
4.8 UML图形标识 
UML :Unified Modeling Language 统一建模语言，是面向对象建模语言，并非编程语言
 
UML类图：由类和与之相关的各种静态关系共同组成的图形
 
UML表示关系
 1.依赖关系
 
A----->B  表示类A使用了类B 或者说 类A依赖类B
 
2.作用关系——关联
 
 	重数A                  重数B
类A———————————————————————————类B

重数A决定了类B的每个对象与类A的多少个对象发生作用
重数B决定了类A的每个对象与类B的多少个对象发生作用
 
3.包含关系——聚集和组合
 聚集：整体包含部分
 组合：整体与部分共存
 
4.9 结构体 struct 
结构体中，未指定访问控制属性的成员，默认为public
 
struct 结构体名称{
	(public:) 
		公有成员
	protected：
		保护成员
	private:
		私有成员
};

 
//用结构体表示学生的信息   学号 姓名 性别  年龄
#include 
using namespace std;

struct student {
	int id;
	string name;
	string sex;
	int age;
}st[5];   //创建类型为student 名称为st 大小为5 的数组

int main()
{
	student stu = { 421000,"小黑","男",21 };   //创建名称为 stu的对象
	cout << "INFORMATION:" << endl;
	cout << stu.id << " " << stu.name << " " << stu.sex << " " << stu.age << endl;
	return 0;
}
 
 
4.10 组合体 union（联合体） 
应用场景：一组数据，任何两个数据不会同时有效的情况下
 联合体的默认访问控制属性也是public
 联合体的全部数据成员共享同一组内存单元
 
限制：
 
1.联合体的各个对象成员，不可有自定义的构造函数、自定义的析构函数和重载的赋值运算符
2.联合体不能继承，也不支持多态
（一般只用联合体来存储一些公有的数据）
 
tip:联合体也可以不声明名称称为无名联合体，可以由成员项的名字直接访问
 
union{
	int i;
	float f;
};
//使用方法
i=10;
f=2.2;
 
4.11 枚举类型 enum 
将变量的可取值一一列举出来，便可构成一个枚举类型
 类型： 不限定作用域的枚举类型 和 限定作用域的枚举类
 
4.11.1 不限定作用域的枚举类型 
enum (枚举类型名) {变量值列表};
enum weekday {sun,mon,tue,wed,thu,fri,sat};

//枚举类
enum class (枚举类型名) {变量值列表};
//或者
enum struct (枚举类型名) {变量值列表};
enum class weekday {sun,mon,tue,wed,thu,fri,sat};
 
4.11.2 限定作用域的枚举类 
略
 
4.11.3注意 
1.对枚举元素，按常量处理，不能对他们赋值  （指的是枚举元素不可修改，枚举变量的值当然可以修改~）
sun=0     //非法
2.也可以在声明时另行定义枚举元素的值
enum weekday {sun=7,mon=1,tue,wed,thu,fri,sat};    //tue=2 wed=3 ....依次+1
3.枚举值可以进行关系运算
4.整数值不可直接赋给枚举变量，如需赋值，需要进行强制类型转换
5.可以将enum 作为 switch 语句的表达式 ，而将枚举值作为 case 标签
 
#include 
using namespace std;

enum gameresult {
	win, lose, tie, cancel    //注意不加 ;
};     //注意加 ;

int main()
{
	gameresult t = cancel;

	for (int i = win; i <= cancel; i++)   //枚举类型 可 隐式转换为 int 类型
	{
		int result = (gameresult)i;
		if (result == t)
			cout << "CANCEL";
		else
		{
			if (result == win)
				cout << "WIN" << endl;
			if (result == lose)
				cout << "LOSE" << endl;
			if (result == tie)
				cout << "TIE" << endl;
		}
	}
	return 0;
}
 
 
共用体 和 枚举类型 混合使用实例 
//使用联合体保存成绩信息，并且根据不同数据，进行输出

#include 
using namespace std;

class Exam {
public:
	Exam(string name, char gd) :name(name), mode(GRADE), grade(gd) {}
	Exam(string name, bool pa) :name(name), mode(PASS), pass(pa) {}
	Exam(string name, int pt) :name(name), mode(PERCENT),percent(pt) {}
	void show();
private:
	string name;
	enum {
		GRADE,
		PASS,
		PERCENT
	}mode;
	union {
		char grade;   //等级制
		bool pass;  //是否通过
		int percent; //百分比
	};
};

void Exam::show()
{
	cout << name << ":";
	switch (mode)
	{
	case GRADE:
		cout << grade << endl;
		break;
	case PASS:
		cout << (pass ? "PASS" : "FAIL")<< endl;
		break;
	case PERCENT:
		cout << percent << endl;
		break;
	}
}

int main()
{
	Exam c1("C++", 'A');
	Exam c2("高数", 90);
	Exam c3("离散", true);
	c1.show();
	c2.show();
	c3.show();
	return 0;
}
 
 
第五章 数据的共享与保护 
5.1 标识符的作用域与可见性 
作用域讨论的是标识符的有效范围
 可见性是讨论标识符是否可以被引用
 
5.1.1 作用域 
作用域是一个标识符在程序正文中有效的区域
 
种类：
 
1.函数原型作用域
2.局部作用域（块作用域）
3.类作用域
4.文件作用域
5.命名空间作用域
6.限定作用域的枚举类
 
1.函数原型作用域
 C++程序中最小的作用域。
 函数原型声明时形式参数的作用范围就是函数原型作用域
 
//如下函数声明   x , y 在其他地方不可用
//并且在函数声明时，真正起作用的只有形参类型，可省去形参名称，为了增加可读性，加上更好
int add(int x,int y);  
 
#include 
using namespace std;

int add(int m, int n)
{
	return m + n;
}

int main()
{
	//这两种声明均可 ~
	int add(int, int);
	int add(int x, int y);  //x、y并无实际意义
	cout< 

 2.局部作用域
 函数形参列表中形参的作用域，从形参列表中的声明处开始，到整个函数体结束
 函数体内声明的变量，作用域从声明处开始，一直到声明所在的块结束的花括号为止（块：用花括号括起来的）
 [具有局部作用域的变量也称为局部变量]
 
3.类作用域
 类X的成员m具有类作用域，对m的访问方式有
 
1.如果在X的成员函数中，未声明同名的局部作用域标识符，那么可在函数内可以直接访问成员m
2.通过表达式x.m或者X::m  这正是程序中访问对象成员的基本方法
3.ptr->m   ptr为指向X类的一个对象的指针
 
4.文件作用域
 不在前述各个作用域中出现的声明，就具有文件作用域，这样的标识符作用域开始于声明点，结束于文件尾
 eg:全局变量
 
3.总结 
C++由C发展而来，许多细碎的知识点，但重要的知识点较为集中，理解掌握即可
 
4.更新日志 
2022.7.1 计划10天左右整理完成 前八章 主要知识点~ (考试范围)
 2022.7.2 整理至 第四章 类和对象
 
欢迎评论留言、指正~~