数值类型int/double/float/long

0

char

"\0"

string

"\0"

bool

0，也就是false

优先级规则

首先从未声明的标识符开始分析；注意区分声明标识符和形参；

小括号括起来的优先级最高，最内侧的小括号优先级最高；

后缀运算符比前缀运算符优先级更高；

几个连续的后缀运算符，运算顺序从左到右；

几个连续的前缀运算符，运算顺序从右到左；

类型限定词const和volatile的作用域：如果左边紧跟指针运算符，则作用于左边的指针运算符，否则作用于类型区分符（左右均可）；

未声明的标识符：从左到右，第一个标识符就是未声明的标识符（先右后左，右左法则）；

右左法则

右左法则的实质：后缀运算符的优先级高于前缀运算符；

从未声明的标识符开始看，先看右边，再看左边；

向右看，要一直看到小括号或者没有运算符为止，然后再向左；

向右看，遇到小括号，就进入小括号里面，在小括号内部同样应用右左法则；

第一次原则

复杂声明的标识符到底是什么？取决于第一次和她结合的运算符是什么；

如果与标识符第一次结合的运算符是*，那么该标识符就是一个指针；

如果与标识符第一次结合的运算符是()，那么该标识符就是一个函数；

如果与标识符第一次结合的运算符是[]，那么该标识符就是一个数组；

遇到原则

如果分析过程中遇到指针运算符*，那么剩余部分就是该指针指向的对象类型；

如果分析过程中遇到[]，那么剩余部分就是数组中元素的类型；

如果分析过程中遇到()，那么剩余部分就是函数的返回值类型；

总原则

给复杂类型添加一个标识符，那么就变成有标识符的复杂声明分析问题了；

标识符定位原则

如果既有前缀运算符也有后缀运算符，那么标识符肯定位于紧邻的前缀运算符和后缀运算符之间；

如果有多个前缀运算符和后缀运算符的配对，那么标识符肯定位于第一个配对；

若只有前缀运算符，那么标识符位于所有前缀运算符的右侧；

若只有后缀运算符，那么标识符位于所有后缀运算符的左侧；

基本规则

typedef可以给指定类型取一个新名字，也叫自定义类型名；

typedef不会产生新的类型，而是给指定类型取了一个名字（别名）；

typedef是存储类区分符，不能和其他存储类区分符同时出现；

用自定义类型声明变量时，如果有还有其他限定符，则标识符首先与其他限定符结合，最后与自定义类型名结合；

typedef的自定义类型名和系统内置限定符相比，优先级更低；

例如，typedef int *T;const T a;则a先与const结合，再与T结合；

简化复杂声明

从左到右，从外到内，层层剥茧；

typedef应从左边开始对复杂类型进行简化，因为左边的优先级更低，而typedef优先级也更低；

从左边简化，可以保证简化部分的优先级低于未简化部分的优先级，保证了简化前后，运算顺序的一致性；

从低优先级开始简化，可以保证简化后的类型能够还原成原类型；

typedef简化步骤

首先找到最左边的类型区分符；

从类型区分符开始向右看，直到遇到小括号；

从最右边往左看，直到遇到小括号或者右边运算符分析完毕；

如果小括号是用来改变运算优先级的，则进入小括号进行左右分析；

如果有形参是复杂声明，则先简化形参，然后再简化其他部分；

一次可以简化一个或者多个运算符；

将简化后的类型重写声明（替代），然后再简化剩余部分；

整理简化后的声明，将相同的类型用同一个名称表示；

左值

右值

原意：赋值运算符左边的东西

原意：赋值运算符右边的东西

有内存单元

可能没有内存单元

可以寻址

可能无法寻址

表示一段连续内存

表示内存中的数值

如果没有const就可以被赋值

数值，无法赋值

左值可以在左边

左值也可以在右边

右值只能在右边

右值不能在左边

变量是左值；

字符串是一个不可修改的左值；

const变量是不可修改的左值；

立即数是右值

函数返回值也是右值

int(*f())[];

f()是一个函数，()括号内没有参数，表示f是一个无参函数

*f()表示对f()的返回值进行解引用，然后得到外边的类型

括号外边内容是int[]，表示返回值解引用后是一个int数组

因此函数返回值就是一个int数组的指针

综上，int (*f())[]表示一个无参的返回值是int数组指针的函数；

int(*g())();

g()是一个无参函数；

(*g())对函数返回值解引用

解引用的结果是一个函数int ■()；

因此，返回值就是int ■()这种函数的指针；

综上int(*g())()就是一个无参的，返回值是int ■()这种函数的指针的函数；

int(* h[2])();

h[2]是一个数组；

(* h[2])对数组元素解引用，就是得到数组的元素；

解引用后得到一个函数int ■()；

因此数组中存放的是函数的指针；

综上，int(* h[2])()就是一个存放int ■()这种函数的指针的数组；

多义符号

声明变量时

对变量进行运算时

*

表示指针类型

解引用

&

表示引用类型

取地址

声明区分符/前缀运算符

顺序无所谓

声明符/后缀运算符

随便嵌套

存储类区分符

类型限定词

类型区分符

声明符1

声明符2...

extern

static

auto

register

typedef

const只读的

volatile易变的

int

float

double

bool

void

枚举

结构体

联合类型

自定义类型

标识符

函数声明符()

数组声明符[]

指针声明符*

引用声明符&

5种声明符可以相互嵌套

嵌套之后仍然是一个声明符，且是一个整体

最多一个

可以多个

有且只有一个

存储类区分符

类型限定词

类型区分符

声明符...

声明区分符

声明符...

前缀运算符

声明符

后缀运算符

const

声明指针

指针本身p

指针的解引用*p

修饰p

int* const p1=&a;

//指针本身p不可更改

*p1 = 33;//OK

//p1 = &b;// 错误 C3892 “p1” : 不能给常量赋值

修饰*p

int const* p2 =& a;

//指针的解引用*p不可更改

p2 = &b;//OK

//*p2 = 11; //错误 C3892 “p2” : 不能给常量赋值

const int* p3 = &a;//指针的解引用不可更改

p3 = &b;//OK

//*p3 = 22;// 错误 C3892 “p3” : 不能给常量赋值

修饰p和*p

const int*const p4 = &a;//指针本身p不可更改，指针解引用*p也不可以更改

//p4 = &b;// 错误 C3892 “p4” : 不能给常量赋值

//*p4 = 22; // 错误 C3892 “p4” : 不能给常量赋值

int const* const p5 = &a;//指针本身p不可更改，指针解引用*p也不可以更改

//p5 = &b;

// 错误 C3892 “p4” : 不能给常量赋值

//*p5 = 22;// 错误 C3892 “p4” : 不能给常量赋值

总结：

l如果const在*和p之间，表示const只修饰p，而不修饰*p，表示p不可更改，而*p可以更改；

l如果const在*左侧，表示将*p看做一个整体，const修饰*p而不是p，表示*p不可更改，而p可以更改；

l如果在*左侧和右侧分别放置一个const，两个const分别修饰p和*p，表示p和*p都不可更改；

lp表示变量的指针，也就是变量的地址，p不可更改，也就是p的值或者p的指向不可更改；

l*p表示指针所指的变量，*p不可更改，表示p指向的变量的值不可更改；

l将*p看做一个整体时，const可以放在类型限定词int的左侧或者右侧，二者等价；