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定义过
     *
     */

  

/**
     *  【数组、指针、字符串、引用】
     *      <数组>:
     *          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;
     */

  

posted on 2022-04-11 23:34  anpeiyong  阅读(25)  评论(0编辑  收藏  举报

导航