【c++】构建c++知识体系：basics

C++ 评论
本文目的

回顾并构建c++ 知识体系

语言特性

  • 静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。（使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。）

  • 面向对象的特性：

    • 封装
    • 抽象
    • 继承
    • 多态

  • 标准库

    ​ 标准的 C++ 由三个重要部分组成：

    • 核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。
    • C++ 标准库，提供了大量的函数，用于操作文件、字符串等。
    • 标准模板库（STL），提供了大量的方法，用于操作数据结构等。

  • C++ 通常用于编写设备驱动程序和其他要求实时性的直接操作硬件的软件。

    C++ 广泛用于教学和研究。

    任何一个使用苹果电脑或 Windows PC 机的用户都在间接地使用 C++，因为这些系统的主要用户接口是使用 C++ 编写的。

基本语法
  • C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互
    • 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
    • 类 - 类可以定义为描述对象行为/状态的模板/蓝图。
    • 方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
    • 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。
  • 分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。
  • 语句块是一组使用大括号括起来的按逻辑连接的语句。
  • 不以行末作为结束符的标识，因此，您可以在一行上放置多个语句。
1
x = y; y = y+1; add(x, y);

  • 标识符

    C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。

    • 一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。
    • C++ 标识符内不允许出现标点字符，比如 @、& 和 %。
    • 大小写敏感

  • 关键字

    asmelsenewthis
    autoenumoperatorthrow
    boolexplicitprivatetrue
    breakexportprotectedtry
    caseexternpublictypedef
    catchfalseregistertypeid
    charfloatreinterpret_casttypename
    classforreturnunion
    constfriendshortunsigned
    const_castgotosignedusing
    continueifsizeofvirtual
    defaultinlinestaticvoid
    deleteintstatic_castvolatile
    dolongstructwchar_t
    doublemutableswitchwhile
    dynamic_castnamespacetemplate

  • 注释

    C++ 注释一般有两种：

    • // - 一般用于单行注释。
    • /*** … */** - 一般用于多行注释。

  • 数据类型

    • 基本内置类型

      类型关键字
      布尔型bool
      字符型char
      整型int
      浮点型float
      双浮点型double
      无类型void
      宽字符型wchar_t

    • 一些基本类型可以使用一个或多个类型修饰符进行修饰：

      • signed
      • unsigned
      • short
      • long

    • 各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

      • 注意：不同系统会有所差异，一字节为 8 位，各种类型的存储大小与系统位数有关。

      • 注意：默认情况下，int、short、long都是带符号的，即 signed。

      • 注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。

        *32位系统与64位系统的存储大小的差别（windows 相同）*

    • typedef声明

      为已有类型取一个新名字

      语法：typedef type newname

      例子：typedef int newint;

      ​ newint a;

    • 枚举类型

      派生数据类型，它是由用户定义的若干枚举常量的集合。

      如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓”枚举”是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

      • 语法：
      1
      2
      3
      4
      5
      6
      enum 枚举名{
          标识符[=整型常数]，
          标识符[=整型常数]，
              ...
          标识符[=整型常数]
      } 枚举变量;
      • 实例：
      1
      2
      3
      4
      5
      6
      7
      8
      #定义一个颜色枚举变量c
      enum color {
          red,
          orange,
          white
      } c;
      #赋值 red
      c = red;

      • 说明：

        如果枚举不初始化（=整型常数），默认从第一个开始，第一个名称为0，第二个为1，…依次类推。

        默认，后一个名称总比前面一个大1，但给某个名称手动赋值后，其后名称值会顺延,前面按默认值。

        例子：

        1
        2
        #red = 0 bule=6
        enum color { red, green=5, bule};

    • 变量类型

      • 变量声明

        • 变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。

        • 变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

        • 当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。

        • 可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

        • 同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。

      • 变量定义

        告诉编译器在何处创建变量的存储，以及如何创建变量的存储。

      • 变量初始化

        指定一个初始值。

        不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。

      • 变量作用域

        作用域是程序的一个区域，一般来说有三个地方可以定义变量：

        • 在函数或一个代码块内部声明的变量，称为局部变量。

          在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用

        • 在函数参数的定义中声明的变量，称为形式参数。

        • 在所有函数外部声明的变量，称为全局变量。

          全局变量的值在程序的整个生命周期内都是有效的。全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。

        在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。

        • 初始化

          当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。

          定义全局变量时，系统会自动初始化为下列值：

          数据类型初始化默认值
          int0
          char‘\0’
          float0
          double0
          pointerNULL

    • 常量

      • 定义

        在 C++ 中，有两种简单的定义常量的方式：

        • 使用 #define 预处理器。

          格式：#define identifier value

          例子：#define LENGTH 10(把常量定义为大写字母形式，是一个很好的编程实践。)

        • 使用 const 关键字。

    • 修饰符类型

      C++ 允许在 char、int 和 double 数据类型前放置修饰符。

      修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。

      下面列出了数据类型修饰符：

      • signed （可修饰整型、字符型，也可修饰long\short）
      • unsigned（可修饰整型、字符型，也可修饰long\short）
      • long（可修饰双精度型）
      • short（可修饰整型）

      允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int，只写单词 unsigned、short 或 long，int 是隐含的。

      ​ 例子：

      1
      2
      unsigned x;
      unsigned int y;
      • 类型限定符
      限定符含义
      constconst 类型的对象在程序执行期间不能被修改改变。
      volatile修饰符 volatile 告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。
      restrict由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。

    • 存储类

      存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

      • auto

        自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

        例子：

        1
        2
        3
        4
        auto f=3.14;      //double
        auto s("hello");  //const char*
        auto z = new auto(9); // int*
        auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

      • register

        register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

        1
        2
        3
        {
           register int  miles;
        }

        寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

      • static

        static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

        static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

        在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

      • extern

        extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

        当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

        extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候

      • mutable

        mutable 说明符仅适用于类的对象。

        它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

      • thread_local (C++11)

        使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

        thread_local 说明符可以与 static 或 extern 合并。

        可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

        以下演示了可以被声明为 thread_local 的变量：

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        thread_local int x;  // 命名空间下的全局变量
        class X
        {
            static thread_local std::string s; // 类的static成员变量
        };
        static thread_local std::string X::s;  // X::s 是需要定义的
         
        void foo()
        {
            thread_local std::vector<int> v;  // 本地变量
        }

      从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

    • 运算符

      运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符，并提供了以下类型的运算符：

      • 算术运算符

        运算符描述实例
        +把两个操作数相加A + B 将得到 30
        -从第一个操作数中减去第二个操作数A - B 将得到 -10
        *把两个操作数相乘A * B 将得到 200
        /分子除以分母B / A 将得到 2
        %取模运算符，整除后的余数B % A 将得到 0
        ++自增运算符，整数值增加 1A++ 将得到 11
        –自减运算符，整数值减少 1A– 将得到 9

      • 关系运算符

        运算符描述实例
        ==检查两个操作数的值是否相等，如果相等则条件为真。(A == B) 不为真。
        !=检查两个操作数的值是否相等，如果不相等则条件为真。(A != B) 为真。
        >检查左操作数的值是否大于右操作数的值，如果是则条件为真。(A > B) 不为真。
        <检查左操作数的值是否小于右操作数的值，如果是则条件为真。(A < B) 为真。
        >=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。(A >= B) 不为真。
        <=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。(A <= B) 为真。

      • 逻辑运算符

        运算符描述实例
        &&称为逻辑与运算符。如果两个操作数都 true，则条件为 true。(A && B) 为 false。
        ||称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。(A || B) 为 true。
        !称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false。!(A && B) 为 true。

      • 位运算符

        pqp & qp | qp ^ q
        00000
        01011
        11110
        10011

        ~、<<、>>运算，其中

        ~取反运算符，按二进制位进行”取反”运算。运算规则：~1=-2; ~0=-1;(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。（此处有错）

      • 赋值运算符

        运算符描述实例
        =简单的赋值运算符，把右边操作数的值赋给左边操作数C = A + B 将把 A + B 的值赋给 C
        +=加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数C += A 相当于 C = C + A
        -=减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数C -= A 相当于 C = C - A
        *=乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数C *= A 相当于 C = C * A
        /=除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数C /= A 相当于 C = C / A
        %=求模且赋值运算符，求两个操作数的模赋值给左边操作数C %= A 相当于 C = C % A
        <<=左移且赋值运算符C <<= 2 等同于 C = C << 2
        >>=右移且赋值运算符C >>= 2 等同于 C = C >> 2
        &=按位与且赋值运算符C &= 2 等同于 C = C & 2
        ^=按位异或且赋值运算符C ^= 2 等同于 C = C ^ 2
        |=

      • 杂项运算符

        运算符描述
        sizeofsizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
        Condition ? X : Y条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
        ,逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
        .（点）和 ->（箭头）成员运算符用于引用类、结构和共用体的成员。
        Cast强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
        &指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
        *指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

      • 优先级

        类别运算符结合性
        后缀() [] -> . ++ - -从左到右
        一元+ - ! ~ ++ - - (type)* & sizeof从右到左
        乘除* / %从左到右
        加减+ -从左到右
        移位<< >>从左到右
        关系< <= > >=从左到右
        相等== !=从左到右
        位与 AND&从左到右
        位异或 XOR^从左到右
        位或 OR|从左到右
        逻辑与 AND&&从左到右
        逻辑或 OR||从左到右
        条件?:从右到左
        赋值= += -= *= /= %=>>= <<= &= ^= |=从右到左
        逗号,从左到右

    • 循环

      循环类型描述
      while 循环当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
      for 循环多次执行一个语句序列，简化管理循环变量的代码。
      do…while 循环除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
      嵌套循环您可以在 while、for 或 do..while 循环内使用一个或多个循环。
      控制语句描述
      break 语句终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
      continue 语句引起循环跳过主体的剩余部分，立即重新开始测试条件。
      goto 语句将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。

    • 判断

      语句描述
      if 语句一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
      if…else 语句一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
      嵌套 if 语句您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
      switch 语句一个 switch 语句允许测试一个变量等于多个值时的情况。
      嵌套 switch 语句您可以在一个 switch 语句内使用另一个 switch 语句。

      • ？：运算符

        格式：Exp1 ? Exp2 : Exp3;

    • 函数

      当调用函数时，有三种向函数传递参数的方式：

      调用类型描述
      传值调用该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
      指针调用该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
      引用调用该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

      • 参数默认值

        定义一个函数，可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。如果指定了值，则会忽略默认值，使用传递的值。

        例子：

        1
        2
        3
        4
        5
        int sum(int a, int b=20) {  int result;   result = a + b;    return (result); }
        result = sum(a, b);//a+b，a,b均使用传递值
        cout << "Total value is :" << result << endl;
        result = sum(a);//a+20
        cout << "Total value is :" << result << endl;

      • lambda函数表达式

        C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。

        Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用，比如可以将它们赋给变量和作为参数传递，还可以像函数一样对其求值。

        Lambda 表达式本质上与函数声明非常类似。

        Lambda 表达式具体形式如下:

        1
        2
        [capture](parameters)->return-type{body}
        [capture](parameters){body}//无返回值，则

        例子：

        1
        2
        3
        [](int x, int y){ return x < y ; }//无返回值
        []{ ++global_x; } //无输入参数和返回值
        [](int x, int y) -> int { int z = x + y; return z + x; }//既有输入又有返回值

        在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。 与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的[]来指定：

        1
        2
        3
        4
        5
        6
        []      // 沒有定义任何变量。使用未定义变量会引发错误。
        [x, &y] // x以传值方式传入（默认），y以引用方式传入。
        [&]     // 任何被使用到的外部变量都隐式地以引用方式加以引用。
        [=]     // 任何被使用到的外部变量都隐式地以传值方式加以引用。
        [&, x]  // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
        [=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。

        外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：

        1
        [this]() { this->someFunc(); }();

    • 数字

      • 内置数学运算函数，#include

      • 随机数

        关于随机数生成器，有两个相关的函数。

        一个是 **rand()**，该函数只返回一个伪随机数。

        生成随机数之前必须先调用 srand() 函数。#设置种子

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        #include <iostream>
        #include <ctime>
        #include <cstdlib>
         
        using namespace std;
         
        int main ()
        {
           int i,j;
         
           // 设置种子
           srand( (unsigned)time( NULL ) );
         
           /* 生成 10 个随机数 */
           for( i = 0; i < 10; i++ )
           {
              // 生成实际的随机数
              j= rand();
              cout <<"随机数： " << j << endl;
           }
         
           return 0;
        }

    • 数组

      • 声明

        1
        2
        type arrayName [ arraySize ];
        例1：int arr[10];

      • 初始化

        1
        2
        3
        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;//单独赋值

      • 访问数组元素

        1
        double salary = balance[9];

      • 数组详解

        概念描述
        多维数组C++ 支持多维数组。多维数组最简单的形式是二维数组。
        指向数组的指针您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。
        传递数组给函数您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
        从函数返回数组C++ 允许从函数返回数组。

    • 字符串

      C++ 提供了以下两种类型的字符串表示形式：

      • C 风格字符串

        字符串实际上是使用 null 字符 \0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

        1
        char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};

        C++ 中有大量的函数用来操作以 null 结尾的字符串:

        序号函数 & 目的
        1strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
        2strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号，例如: string str1 = "runoob"; string str2 = "google"; string str = str1 + str2;
        3strlen(s1); 返回字符串 s1 的长度。#字符的数量，不包含后面的’\0’，而sizeof()是返回字节数
        4strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。
        5strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
        6strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

      • C++ 引入的 string 类类型

        C++ 标准库提供了 string 类类型 #include

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12

        // 复制 str1 到 str3
        str3 = str1;
        cout << "str3 : " << str3 << endl;
               
        // 连接 str1 和 str2
        str3 = str1 + str2;
        cout << "str1 + str2 : " << str3 << endl;
               
        // 连接后，str3 的总长度
        len = str3.size();
        cout << "str3.size() :  " << len << endl;

    • 指针

      概念描述
      C++ Null 指针C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。
      C++ 指针的算术运算可以对指针进行四种算术运算：++、–、+、-
      C++ 指针 vs 数组指针和数组之间有着密切的关系。
      C++ 指针数组可以定义用来存储指针的数组。
      C++ 指向指针的指针C++ 允许指向指针的指针。
      C++ 传递指针给函数通过引用或地址传递参数，使传递的参数在调用函数中被改变。
      C++ 从函数返回指针C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。

    • 引用

      引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

      引用很容易与指针混淆，它们之间有三个主要的不同：

      • 不存在空引用。引用必须连接到一块合法的内存。
      • 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
      • 引用必须在创建时被初始化。指针可以在任何时间被初始化。

      创建：

      1
      2
      3
      int i = 17;
      //为i 声明引用变量r
      int&  r = i;//r是一个初始化为i 的整型引用

      引用通常用于函数参数列表和函数返回值。

      必须清楚的两个与 C++ 引用相关的重要概念：

      概念描述
      把引用作为参数C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。
      把引用作为返回值可以从 C++ 函数中返回引用，就像返回其他数据类型一样。

    • 日期时间

      C++ 标准库没有提供所谓的日期类型。

      C++ 继承了 C 语言用于日期和时间操作的结构和函数。

      为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用头文件。

    • 基本输入输出

      C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。

      • IO库头文件

        头文件函数和描述
        该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。
        该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。
        该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

      • 标准输出流-cout

        预定义的对象 cout 是 iostream 类的一个实例。cout 对象”连接”到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的

        例子：

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        #include <iostream>
         
        using namespace std;
         
        int main( )
        {
           char str[] = "Hello C++";
         
           cout << "Value of str is : " << str << endl;
        }

      • 标准输入流-cin

        预定义的对象 cin 是 iostream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的.

        例：

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        #include <iostream>
         
        using namespace std;
         
        int main( )
        {
           char name[50];
         
           cout << "请输入您的名称： ";
           cin >> name;
           cout << "您的名称是： " << name << endl;
         
        }

        C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。

        流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

        1
        cin >> name >> age;//相当与cin >> name;cin >> age;

      • 标准错误流

        预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准输出设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

        cerr 也是与流插入运算符 << 结合使用的

        1
        2
        3
        4
        5
        6
        7
        #include <iostream>
        using namespace std;
        int main( )
        {
           char str[] = "Unable to read....";
           cerr << "Error message : " << str << endl;
        }

      • 标准日志流

        预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准输出设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。

        clog 也是与流插入运算符 << 结合使用的

        例：

        1
        2
        3
        4
        5
        6
        7
        #include <iostream> 
        using namespace std;
        int main( )
        {
           char str[] = "Unable to read....";
           clog << "Error message : " << str << endl;
        }

    • 数据结构

面向对象

  • 类&对象

    • 类定义

      定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

      class定义

      例：

      1
      2
      3
      4
      5
      6
      7
      class Box
      {
         public:
            double length;   // 盒子的长度
            double breadth;  // 盒子的宽度
            double height;   // 盒子的高度
      };

    • 对象定义

      类提供了对象蓝图。

  • 继承

  • 重载运算符和重载函数

  • 多态

  • 数据抽象

  • 数据封装

  • 接口（抽象类）

HongxunSystem Developer