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. C++ : 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 = &pi; // 指针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 = &pi;  //指针指向一个const常量, 自身也必须是const
      }
    • 常量指针 : 必须初始化, 一旦初始化完成, 它的值就不能被改变了.

      void testConst() {
          int errNum = 9;
          int *const curErr = &errNum;  // curErr 将一直指向 errNum
          const double pi = 3.14;
          const double *const pip = &pi; // 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
      }
阅读更多
文章标签: c语言
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭