C++学习摘要记录(1)

正文

• 类

  1. 输入运算符 (>>) , 输出运算符 (<<)
  2. std是一个类（输入输出标准）

using namespace std; //要么这么使用
std::cout ; std::cin ; //要么这么使用

• 术语表

  1. 参数 argument
  2. 赋值 assignment
  3. 程序块 block
  4. 缓冲区 buffer
  5. 内置类型 built-in type
  6. Cerr 一个ostream对象
  7. 字符串字面值常量
  8. cin 一个instream对象
  9. class
  10. class type
  11. clog 一个ostream对象 , 通常用于报告程序的执行信息,存入一个日志文件中
  12. comnet 注释
  13. condition 条件
  14. cout 一个ostream对象 , 通常用于程序的正常输出
  15. { } 程序块
  16. header 头文件, 使类或其他名字的定义可被多个程序使用的一种机制.
  17. main 每个程序只有一个main函数
  18. ::运算符 表示命名空间xxx中的名字xxx
  19. #include 头文件包含指令 , 使头文件中代码可被程序执行

• 基本数据类型
  bool
  char
  wchar_t
  char16_t
  char32_t
  short
  int
  long
  long long
  float
  double
  long double

• signed和unsigned的区别

  unsigned a和unsigned int a等价。singed a和singed int a等价。为被unsigned修饰的变量赋一个负值得到的结果是最大值加上这个负值再+1。signed b这种情况b的值可以为负，输出负数再正常不过。sign没加ed不能用来修饰类型。

• 字面值常量

  1. java :　二进制时用0b10(表示二进制用0b)、010（表示八进制用0）、0x10（表示十六进制用0x）
  2. Ｃ++ : 024 八进制 , 0x / 0X 十六进制 , 20 十进制

  字符串字面值结尾处为一个空字符’\0’ , 字符串字面值实际长度要比他内容多1

• 指定字面值的类型

  前缀u Unicode16字符 char16_t
  前缀U Unicode32字符 char32_t
  前缀L 宽字符 wchar_t
  前缀u8 UTF-8 char
  后缀u/U unsigned
  后缀l/L long
  后缀ll/LL long long
  后缀f/F float
  后缀l/L long double

• 变量初始化

  列表初始化 :

  int units_sold = 0;
  int units_sold = { 0 };
  int units_sold{ 0 };
  int units_sold( 0 );

• 变量声明和定义

  变量能且只能被定义一次 , 但是可以被多次声明

  extern int i; // 声明i
  int j;  //声明并定义j
  extern double pi = 3.1416; //定义pi

• 复合类型

  • 引用(reference) :
    引用类型的初始值必须为一个 对象

    int ival = 24;
    int &refVal = ival; //refVal 指向ival

  • 指针(pointer) : 是”指向”另外一种类型的复合类型

    1. 指针本身就是一个对象, 允许对指针赋值和拷贝 , 在指针的生命周期内它可以先后指向几个不同的对象.
    2. 指针无须在定义时初始化.
    3. 指针类型要和他所指对象严格匹配
       

       int *ip1, *ip2; //指针ip1 , ip2 ;
       int ival = 24;
       int *p = &ival; //p是指向变量ival的指针

  • 空指针(null pointer) : 不指向任何对象 ;
    warn : 使用未初始化的指针是引发运行时错误的一大原因.

    int *p1 = nullptr;
    int *p2 = 0;
    int *p3 = NULL; //必须 #include <cstdlib>

  • 引用 访问的时它最初的绑定对象

  • 指针 给指针赋值就是令他存放一个新的地址 , 从而指向一个全新的对象.

    int i = 42;
    int *pi1 = 0;
    int *pi2 = &i;
    int *pi3 = pi2; // 现在指针pi3 和 pi2 都指向i

  • void* 指针 : 可用于存放任意对象的地址.

    double obj = 3.14 , *pd = &obj;
    void *pv = &obj;

  • 指向指针的指针 :

    int ival = 1024;
    int *pi = &ival; // 指针pi 指向 引用ival
    int **ppi = π // 指针ppi 指向 指针pi
    int ***pppi = &ppi; // 指针pppi 指向 指针ppi

  • 指向指针的引用 :

    int test() {
        int i = 42;
        int *p;
        int *&r = p;  //r是一个对p指针的引用
    
        r = &i;  
        r = 0; //可以直接赋值,  表示p指针指向的引用i , i赋值为0
    }
    

  • const 限定符 : 跟java 中 final 关键字类似
    多个文件之间共享const对象, 须在变量定义之前添加extern(声明)关键字.

  • const 的引用 : 对常量的引用

    void testConst() {
        const int ci = 1024;
        const int &ri = ci; // 引用及其对应的对象都是常量
    }

  • 指向常量的指针 : 不能改变其所指对象的值

    void testConst1() {
        const double pi = 3.15;
        const double *ptr = π  //指针指向一个const常量, 自身也必须是const
    }

  • 常量指针 : 必须初始化, 一旦初始化完成, 它的值就不能被改变了.

    void testConst() {
        int errNum = 9;
        int *const curErr = &errNum;  // curErr 将一直指向 errNum
        const double pi = 3.14;
        const double *const pip = π // pip是一个一直指向常量对象的常量指针
    }

  • 顶层const : 表示指针本身是一个常量

  • 底层const : 表示指针所指对象是一个常量

    void testConst() {
        int i = 0;
        int *const pl = &i; // 这是一个顶层const , 不能改变p1的值
        const int ci = 42; // 这是一个顶层const , 不能改变ci的值
        const int *p2 = &ci; // 这是一个底层const , 允许改变p2的值
    }
    

  • 常量表达式 : 是指值不会改变并且在编译过程就能得到计算结果的表达式

    void testConst() {
        const int max_files = 20; //常量表达式
        const int limit = max_files + 1; //常量表达式
    }

  • constexpr变量 : 验证变量的值是否是一个常量表达式.

    void testConst() {
        constexpr int mf = 20;
        constexpr int limit = mf + 1;
    }

  • 指针和constexpr : constexpr把它所定义的对象置为了顶层const

    void testConst() {
        const int *p = nullptr; //p是一个指向整型常量的指针
        constexpr int *q = nullptr; //q是一个指向证书的常量指针
    }

• 处理类型 :

  • 类型别名 : 使用 typedef , using 关键字

    void testAlias() {
        typedef double wages; //wages 是 double 的同义词
        typedef wages bas, *p; // bas 是 double 的同义词 , p 是 double* 的同义词
        using SI = Sales_item;  // SI 是 Sales_item 的同义词
    
        typedef char *pstring;
        const pstring cstr = 0; //cstr是指向char的常量指针
        const pstring *ps; // ps是一个指针 , 它的对象是指向char的常量指针
    }
    

  • auto 类型说明符 : 让编译器替我们去分析表达式所属的类型.

    void testAuto() {
        int i = 2; 
        float p = 1.3;
        auto sum = i + p; // auto 自动推断出 i + p 的类型
    
        const int c1 = i, &cr = c1;
        auto b = c1; // b 是一个整数
        auto c = cr; // c 是一个整数
        auto d = &i; // d 是一个整型指针
        auto e = &c1; // e 是一个指向整数常量的指针
    }

  • decltype 类型指示符 : 选择并返回操作数的数据类型 , 但却不实际计算表达式的值. decltype 作用的表达式是一个变量 , 则返回改变量的类型

    void testDecltype() {
        const int ci = 0, &cj = ci;
        decltype(ci) x = 0; // x 的类型是 const int
        decltype(cj) y = x; // y 的类型是 const int& , y 绑定到变量x
    
        int i = 42, *p = &i, &r = i;
        decltype(r + 0) b; // b代表一个 int类型
        decltype(i) e; // e是一个 int
    }