C++概述1

/**
     *  【C++语言-绪论】
     *      <计算机程序>
     *          计算机的工作 是 用程序 来控制的；
     *          程序 是 指令的集合；
     *          指令 是 计算机可以识别的指令；
     *
     *      <机器语言>
     *          计算机硬件系统 可以识别的 二进制指令 组成的语言；
     *
     *      <面向对象的语言>
     *          属于 高级语言；
     *          将 客观事物 看作 具有属性和行为的对象；
     *          通过 抽象 找出同一类对象的共同的属性和行为，形成类；
     *          通过 类的继承与多态 实现代码重用；
     *
     *      <面向对象的方法>
     *          将 数据与对数据的操作方法 封装在一起，作为一个相互依存、不可分离的整体---对象；
     *          对 同类型的对象 抽象其共性，形成类；
     *          类 通过一个简单的外部接口，与外界发生关系；
     *          对象与对象之间 通过消息进行通信；
     */

/**
     *  【C++-简单程序设计】
     *      <C++的产生>
     *          C++不是第一个面向对象的语言，但它是第一个流行起来的面向对象的语言；
     *          最初的C++语言 被称为 "带类的C"；
     *
     *      <C++的特点>
     *          兼容C
     *              保持了C的简洁、高效、接近汇编语言等特点；
     *              对C的类型系统进行了改革和补充；
     *              C++也支持面向过程的程序设计，不是一个纯正的面向对象的语言；
     *
     *          支持面向对象的方法
     *          支持泛型程序设计方法
     *
     *      <C++字符集>
     *          C++字符集包括：
     *              A~Z, a~z
     *              0~9
     *              ! # % ^...
     *
     *          关键字：
     *              C++预定义的单词；
     *
     *          标识符：
     *              程序员声明的单词；
     *
     *          文字：
     *              在程序中直接使用符号表示的数据；
     *
     *          操作符：
     *              用于实现各种运算的符号；
     *
     *          分隔符：
     *              用于分隔各个词法记号或程序正文；
     *
     *          空白符：
     *              空格、tab键产生从字符、垂直制表符、换行符、回车符、注释...
     *
     *          常量：
     *              在程序运行的整个过程中其值始终不可改变的量，也就是直接使用符号（文字）表示的值；
     *                  eg：12、3.5、'a'...
     *
     *              整数常量：
     *                  10进制：若干0~9的数字
     *                  8进制：0开头，若干0~7的数字
     *                  16进制：0x开头，若干0~9的数字及A~F的字母（大小写均可）
     *
     *                  后缀字母L（或l）表示长整型，
     *                  后缀字母U（或u）表示无符号型，
     *                  可同时后缀L和U（大小写无关）
     *
     *              字符常量：
     *                  单引号括起来的一个字符
     *                      eg: 'a', 'D'
     *
     *          变量：
     *              程序可操作的存储区的名称；
     *              每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中；
     *
     *              存储类型：
     *                  C++ 程序中变量/函数的范围（可见性）和生命周期；
     *                  放置在它们所修饰的类型之前；
     *
     *          ...
     *
     */

/**
     *  【函数】
     *      函数的参数传递
     *
     *          默认情况下，C++ 使用 值传递 来传递参数；
     *
     *          值传递：
     *              传递实参的值的拷贝（单向）；
     *
     *              实参和形参的联系切断
     *
     *          引用传递：
     *              传递 实参的地址或引用（双向）；
     */

/**
     *  【类与对象】
     *      C++ 在 C 语言的基础上增加了面向对象编程；
     *
     *      抽象：
     *          对 具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的 过程：
     *              先注意问题的本质及描述，其次是实现过程或细节；
     *              数据抽象：
     *                  描述某类对象的属性或状态；
     *              函数抽象：
     *                  描述某类对象的共有的行为特征或具有的功能；
     *              抽象的实现：
     *                  类的声明；
     *
     *
     *      继承：
     *          继承的实现：
     *              派生类的声明；
     *
     *      多态：
     *
     *
     *      类定义：
     *          class 类名称
     *          {
     *              访问修饰符：
     *                  变量
     *                  函数
     *          };
     *
     *      对象定义：
     *          类名 对象名称；
     *
     *      结构体定义与初始化：
     *          struct 结构体名称{
     *              公有成员
     *              私有成员
     *              保护型成员
     *          };
     *
     *          类型名 变量名 = {成员数据1值, 成员数据2值};
     *
     *      联合体
     *          union 联合体名称{
     *              公有成员
     *              私有成员
     *              保护型成员
     *          };
     *
     *          特点：
     *              成员公有相同的内存单元；
     *              任何2个成员不会同时有效
     */

/**
     *  【数据的共享与保护】
     *
     *      <命名空间>
     *          解决什么问题？
     *              不同库中 相同名称的函数、类、变量等；
     *          声明：
     *              namespace namespace_name{}
     *          命名空间使用：
     *              1、namespace_name :: 函数名称
     *
     *              2、using namespace namespace_name;
     *
     *
     *      <作用域>
     *          文件作用域：
     *              开始于 声明点，结束于文件尾；
     *
     *      <类的友元>：
     *          单向；
     *          友元函数：
     *              friend 返回值 函数名(参数列表);
     *          友元类：
     *              class A{
     *                  friend class B;
     *              };
     *
     *      <常对象>
     *
     *          改变状态的方式：
     *              1、状态赋值
     *              2、调用状态对应的函数
     *
     *          常对象：
     *              const 类名 对象名
     *          常引用：
     *              const 类型说明符 &引用名
     *          常数组：
     *              类型说明符 const 数组名[大小]...
     *          常指针：
     *              指向常量的指针；
     *
     *      <C++程序的一般组织结构>
     *          一个源程序可以划分为多个源文件：
     *              类声明文件.h
     *              类实现文件.cpp
     *              类使用文件 main()所在的.cpp
     *
     *      <标准C++类库>
     *          标准C++类与组件在逻辑上分为6种类型：
     *              输入/输出
     *              容器类与ADT
     *              存储管理类
     *              算法
     *              错误处理
     *              运行环境支持
     *
     *      <编译预处理>
     *          #include
     *              用于将指定头文件嵌入源文件中;
     *          #define
     *              定义符号常量
     *              定义带参数宏
     *          #undef
     *              删除由#define定义的宏，使其不再起作用；
     *          #ifndef
     *              if not defined
     *          #if 表达式 #else #endif
     *              条件编译指令
     *          #ifdef 标识符 #else #endif
     *              标识符被#define定义过
     *
     */

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

/**
     *  【数组、指针、字符串、引用】
     *      <数组>：
     *          what？
     *              具有一定顺序关系的 若干相同类型变量 的集合体；
     *              连续的内存位置组成；
     *
     *          数组声明：
     *              type arrayName [ arraySize ];
     *
     *          数组初始化：
     *              double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
     *              double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
     *              balance[4] = 50.0;
     *
     *          内存状态：
     *              一维数组：
     *                  数组元素 在内存中顺次存放，地址连续，固定大小；
     *                  数组名字 是 数组首元素的内存地址；
     *
     *              二维数组：
     *                  由一维数组构成；
     *
     *          数组作为参数传递：
     *              实质 将实参的首地址 进行传递；
     *
     *          对象数组：
     *              声明：
     *                  类名 数组名[数组个数];
     *              访问方式：
     *                  数组名[下标].成员名
     *              初始化：
     *                  类名 数组名[数组个数] = {类名(构造器), 类名(构造器)};
     *
     *      <指针>：
     *          what？
     *              用于 间接访问内存单元；
     *              指针变量：
     *                  存放变量、代码等内存地址的变量；
     *
     *          指针声明：
     *              对象类型 *变量名;
     *              eg: int i;
     *                  int *j = &i; 获取i变量的内存地址 ，赋值给指针变量；
     *                  *j = 3; 将3 存储到 变量i的内存单元；
     *                      间接寻址：
     *                          通过 目标内存单元的地址 访问 内存单元；
     *
     *              地址运算符：
     *                  &:
     *                      获取某个变量在内存中的首地址；
     *                  *:
     *                      指针类型名称修饰；
     *
     *          指针类型：
     *              常量指针：
     *                  不能通过指针改变对象的值；
     *                  指针变量本身存储的地址可以改变；
     *
     *                  int a; const int *p1 = &a;  (错误：*p1 = 1;)
     *                  int b; p1 = &b;
     *
     *              指向函数的指针：
     *                  作用：
     *                      指向程序代码存储区；
     *                  声明：
     *                      存储类型 数据类型 (*函数指针名)();
     *
     *              对象指针：
     *                  声明：
     *                      类名 *对象指针名；
     *                  通过对象指针访问对象成员：
     *                      对象指针名 -> 成员名
     *
     *              this指针：
     *                  指向当前对象本身；
     *
     *          指针的算术运算：
     *              加一、减一运算：
     *                  指向 下一个或前一个数据；
     *
     *          指针与数组：
     *              数组名就是内存单元首地址;
     *
     *              int[] a;
     *              int *pa = a;
     *              ***
     *                  a 等价于 a[0] 等价于 *pa;
     *
     *          动态申请内存操作符new：
     *              new 类型T名称(初始化参数列表)
     *
     *              功能：
     *                  在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值；
     *
     *              结果值：
     *                  成功：
     *                      T类型的指针，指向新分配的内存地址；
     *                  失败：
     *                      抛出异常；
     *
     *              内存泄漏：
     *                  分配内存，但未释放；
     *
     *              动态申请释放数组：
     *                  申请：new 数组类型名[数组长度]
     *                  释放： delete[] 数组名指针
     *
     *
     *      <字符串>
     *          C++ 提供了以下两种类型的字符串表示形式：
     *              C 风格字符串：
     *                  字符串实际上是使用 null 字符 \0 终止的一维字符数组；
     *                      eg：
     *                          char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
     *                          char site[] = "RUNOOB";
     *
     *
     *              C++ 引入的 string 类类型：
     *                  C++ 标准库提供了 string 类类型
     *
     *      <引用>：
     *          是某个已存在变量的另一个名字；
     *
     *          本质：
     *              指针
     *
     *          声明：
     *              int i = 10;
     *              int& ir = i;
     */