基本内置类型

字符型：char（由编译器决定是否有符号），signed char，unsigned char
有符号数向无符号数准换，自动取模。

C++中初始化不等价于赋值运算！

int a = 0;
int a = {0};
int a{0};  //列表初始化
int a(0);

变量声明与定义

extern int i; //声明i而非定义i
int j; //声明并定义j

extern int k = 0; //定义k

指针和数组

int ia[] = {1, 2, 3, 4, 5};
int *p = &ia[2]; //p指向索引为2的元素
int j = p[1];  //ia[3]; 等价于*(p+1);
int k = p[-2]; //ia[0]; 等价于*(p-2);

使用范围for处理多重数组

int ia[3][4] = { {1, 2}, {3, 4}, {5}};
size_t cnt = 0; //size_t是无符号整数
for(auto &row : ia){
    for(auto &col : row){
        col = cnt;  //写操作，for循环里必须引用
        cnt++;
    }
}
for(auto &row : ia){
    for(auto col : row){
    //即使读操作，for循环外层也必须引用，否则auto会将row视为指针，内层循环就会报错
        cout<<col<<endl;  
    }
}

复合类型

一条声明语句由一个基本数据类型和紧随其后的一个声明符列表组成。

引用是为对象另外起的一个名字，引用本身不是对象，且引用必须初始化。

指针本身就是对象，因此可以定义指向指针的指针。

int *p, n; //类型修饰符*是声明符的一部分, int* p也可以但容易产生误导

定义一个空指针

int *p1 = 0;
int *p2 = nullptr;  //c++11
int *p3 = NULL;

//注意下面这种会报错
int i = 0;
int *p4 = i;

赋值操作改变的是等号左边的对象。

const限定符

因为const对象一旦创建后就不能再改变，因此创建时必须初始化。
对象的类型决定了其上的操作

const引用

int i = 16;
const int &r1 = i; //const引用可以是非const对象
const int &r2 = 16;
const int &r3 = r1 * 2;

int &r4 = i;  //错误

指向常量的指针（底层const）

const int i = 6;
const int *p = &i; //不能修改*p

常量指针（顶层const）

int i = 0;
int *const p = &i;  //不能修改p

将变量声明为constexpr类型以便由编译器验证变量的值是否是一个常量表达式。

const int *p1 = nullptr;  //指向常量的指针
constexpr int *p2 = nullptr;  //常量指针，constexpr定义指针事只对指针有效，与指针所指的对象无关

处理类型

类型别名

typedef double wages;
using wages = double; //与上等价

auto

自动推断类型

使用auto一条语句中可以声明多个变量。因为一条声明语句只能有一个基本数据类型，因此所有变量的类型必须一样，否则报错。

auto a = 0, *b = a;
auto sz = 0, pi = 3.14; //报错

auto推断会忽略顶层const

auto推断引用类型得到的是引用对象的类型（即忽略引用）

int i = 0, &r = i;
auto a = r; //a是int类型，忽略引用

const int ci = i;  //ci是const int类型
auto b = ci; //b是int类型，忽略顶层const

另外auto作用于数组得到的是指针类型，decltype作用于数组得到数组类型。

int ia[] = {1, 2, 3, 4};

auto ia2(ia); //ia2是一个整型指针，等价于auto ia2(&ia[0]);

decltype ia3(ia); //ia3是一个含有十个整数的数组

decltype

decltype分析表达式得到类型，并不实际计算表达式的值。

decltype不会忽略顶层const，也不会忽略引用

如果表达式是解引用，decltype得到引用类型。

decltype((Var)) 结果是引用

devcltype(var) 只有Var是引用时结果才是引用

const int ci = 0, &cj = ci;
decltype(ci) x = 0; //x是const int类型
decltype(cj) y = x; //y是cosnt int &类型，引用必须初始化

int x = 6, *p = &x;
decltype(*p) y = x; //y是int &类型，不是int类型

变量和基本类型