1 类型转换
当执行算术运算时，操作数的类型如果不同，就会发生转换，数据类型一般朝着浮点精度高、长度更长的方向转换，整数型如果转换为signed不会丢失信息，就转换为signed，否则转换为unsigned。
K&R C所采用无房户后保留原著，就是当一个无符号类型与int或更小的整型混合使用时，结果类型是无符号类型。
2 C语言中const并不真正表示常量。
3 switch语句的缺点
1）switch语句最大的缺点是它不会在每个case标签后面的语句执行完毕后自动终止。
2）由于break语句事实上跳出的是最近的那层循环语句或switch语句，所以break可能使switch语句提前跳出结束。
4 C语言中的符号重载
| 符号 | 意义 |
| static |
在函数内部，表示该变量的值在各个调用间一直保持延续性 在函数这一级，表示该函数只对本文件可见 |
| extern |
用于函数定义，表示全局可见（属于冗余的） 用于变量，表示它在其他地方定义 |
| void |
作为函数的返回类型，表示不返回任何值 在指针声明中，表示通用指针的类型 位于参数列表中，表示没有参数 |
| * |
乘法运算符 用于指针，间接引用 在声明中，表示指针 |
| & |
位的AND操作符 取地址运算符 |
| = | 赋值符 |
| == | 比较运算符 |
|
<= <<= |
小于运算符 左移复合赋值运算符 |
| < |
小于运算符 #include指令的左定界符 |
| () |
在函数定义中，包围形式参数表 调用一个函数 改变表达式的运算次序 将值转换为其他类型（强制类型转换） 定义带参数的宏 包围sizeof操作符的操作数（如果它是类型名） |
5 C语言中的优先级
| 优先级问题 | 表达式 | 人们可能误以为的结果 | 实际结果 |
|
.的优先级高于*。->操作符 用于消除这个问题 |
*p.f | p所指对象的字段f (*p).f |
对p取f偏移，作为左值，然后进行 解除引用操作。*(p.f) |
| []高于* | int *ap[] | ap是个指向int数组的指针 int(*ap)[] | ap是个元素为int左值的数组int *(ap[]) |
| 函数()高于* | int *fp() | fp是个函数指针，所指函数返回int，int(*fp)() | fp是个函数，返回int*，int*(fp()) |
| ==和!=高于位运算符 | (val&mask!=0) | (val&mask)!=0 | val&(mask!=0) |
| ==和!=高于赋值符 | c=getchar()!=EOF | (c=getchar())!=EOF | c=(getchar()!=EOF) |
| 算术运算符高于移位运算符 | msb<<4+lsb | (msb<<4)+lsb | msb<<(4+lsb) |
| 逗号运算符在所有运算符中优先级最低 | i=1,2 | i=(1,2) | (i=1),2 |
结合性只用于表达式中出现两个以上相同优先级的操作符的情况，用于消除歧义。事实上，你会注意所有优先级相同的操作符，它们的结合性也相同。
6 返回局部对象的指针
char * localized_time(char* filename) { struct tm *tm_ptr; struct stat stat_block; char buffer[120]; stat(filename,&stat_block); tm_ptr=localtime(&stat_block.st_mtime); strftime(buffer,sizeof(buffer,"%a %b %e %T %Y",tm_ptr); return buffer; }
问题就出在最后一行，也就是返回buffer的那行。buffer是一个自动分配内存的数组，是该函数的局部变量。当控制流离开声明自动变量（即局部变量）的范围时，自动变量就会失效。这就意味着即使返回一个指向局部变量的指针，当函数结束时，由于该变量已被销毁，谁也不知道这个指针所指向的地址的内容是什么。
在C语言中，自动变量在堆栈中分配内存。当包含自动变量的函数或代码块退出时，它们所占用的内存便被回收，它们的内容肯定会被下一个调用的函数覆盖。这一切取决于堆栈中先前的自动变量位于何处，活动函数声明了什么变量，写入了什么内容等。原先自动变量地址的内容可能被立即覆盖，也可能稍后才被覆盖。
解决这种问题有几种方案：
1 返回一个指向字符串常量的指针。例如：
char* func() { return "Only works for simple strings";}
2 使用全局声明的数组。例如：
char *fun() {
...
my_global_array[i] =
...
return my_global_array;
}
这个适用于自己创建字符串的情况，也很简单易用。它的缺点在于任何人都有可能在任何时候修改这个全局数组，而且该函数的下一次调用也会覆盖该数组的内容。
3 使用静态数组。例如：
char * func()
{
static char buffer[20];
...
return buffer;
}
这就可以防止任何人修改这个数组。只有拥有指向该数组的指针的函数才能修改这个静态数组。但是，该函数的下一次调用将覆盖这个数组的内容，所以调用者必须在此之前使用或备份数组的内容。和全局数组一样，大型缓冲区如果闲置不用是非常浪费内存空间的。
4 显式分配一些内存，保存返回的值。例如：
char* func(){
char *s=malloc(120);
...
return s;
}
这个方法具有静态数组的优点，而且在每次调用时都创建一个新的缓冲区，所以该函数以后的调用不会覆盖以前的返回值。它适用于多线程的代码。它的缺点在于程序员必须承担内存管理的责任。根据程序的复杂程度，这项任务可能很容易，也可能很复杂。如果内存尚在使用就释放或者出现“内存泄露”（不再使用的内存未回收），就会产生令人难以置信的Bug。
5最好使用的解决方案就是要求调用者分配内存来保存函数的返回值。为了提高安全调用者应该同时指定缓冲区的大小。
void func(char* result,int size){
...
strncpy(result,"That't be in the data segment,Bob",size);
}
buffer=malloc(size);
func(buffer,size);
...
free(buffer);
如果程序员可以在同一代码块中同时进行“malloc”和“free”操作，内存管理是最为轻松的。这个解决方案就可以实现这一点。
7 声明是如何形成的
不合法的声明：
- 函数的返回值不能是一个函数，所以像foo()()这样是非法的。
- 函数的返回值不能是一个数组，所以像foo()[]这样是非法的。
- 数组里面不能有函数，所以像foo[]()这样是非法的。
合法的声明：
- 函数的返回值允许是一个函数指针，如： int(*fun())();
- 函数的返回值允许是一个指向数组的指针，如： int(*foo())[];
- 数组里面允许有函数指针，如int(*foo[])()
- 数组里面允许有其他数组，所以你经常看到int foo[][]
8 typedef的使用
typedef与define的区别：
首先，可以用其他类型说明符对宏类型名进行扩展，但对typedef所定义的类型名不能这样做。如下所示：
#define peach int
unsigned peach i; //没问题
typedef int banana;
unsigned banana i; //错误！ 非法
其次，在连续几个变量的声明中，用typedef定义的类型能够保证声明中所有的变量均为同一种类型，而用#define定义的类型则无法保证。如下所示：
#define int_ptr int *;
int_ptr chalk,cheese;
经过宏扩展，第二行变为：
int * chalk,cheese;
这使得chalk和cheese成为不同的类型：chalk是一个指向int的指针，而cheese则是一个int。相反，下面的代码中：
typedef char* char_ptr;
char_ptr Bentley,Rolls_Royce;
Bentley和Rolls_Royce的类型依然相同。虽然前面的类型名变了，但它们的类型相同，都是指向char的指针。
//下面两个声明具有相似的形式 typedef struct fruit{ int weight, price_per_lb; } fruit; //语句1 struct veg{ int weight,price_per_lb; } veg; //语句2
但它们代表的意思却完全不一样，语句1声明了结构表情“fruit”和由“typedef声明的结构类型”fruit“，其实际效果如下：
struct fruit mandarin; //使用结构标签fruit
fruit mandarin; //使用结构类型fruit
语句2声明了结构标签veg和变量veg，只有结构标签能够在以后的声明中使用，如
struct veg potato;
如果试图使用veg cabbage这样的声明，将是一个错误。这有点类似下面的写法：
int i;
i j;
9 声明和定义的区别
记住，C语言的对象必须有且只有一个定义，但它可以有多个extern声明。
定义是一种特殊的声明，它创建了一个对象；声明简单地说明了在其他地方创建的对象的名字，它允许你使用这个名字。
定义 只能出现在一个地方 确定对象的类型并分配内存，用于创建的对象。例如，int my_array[100];
声明 可以多次出现 描述对象的类型，用于指代其他地方定义的对象（例如在其他文件里）例：extern int my_array[];
区分定义和声明
只要记住下面的内容即可分清定义和声明：
声明相当于普通的声明：它所声明的并非自身，而是描述其他地方的创建的对象。
定义相当于特殊的声明：它为对象分配内存。
extern对象声明告诉编译器对象的类型和名字，对象的内存分配则在别处进行。由于并未在声明中为数组分配内存，所以并不需要提供关于数组长度的信息。对于多维数组，需要提供除最左边一维之外其他维的长度——这就给编译器足够的信息产生相应的代码。
10 数组和指针的访问
C语言引入了”可修改的左值“这个术语，它表示左值允许出现在赋值语句的左边，这个奇怪的术语是为与数组名区分，数组名也用于确定对象在内存中的位置，也是左值，但它不能作为赋值的对象。因此，数组名是个左值但不是可修改的左值。
左值：出现在赋值符左边的符号有时被称为左值。
右值：出现在赋值符右边的符号有时则被称为右值。
编译器为每个变量分配一个地址（左值）。这个地址在编译时可知，而且该变量在运行时一直保存于这个地址。相反，存储于变量中的值（它的右值）只有在运行时才可知。如果需要用到变量中存储的值，编译器就发出指令从指定的地址读入变量值并将它存于寄存器中。
这里的关键之处在于每个符号的地址在编译时可知。所以，如果编译器需要一个地址（可能还需要加上偏移量）来执行某种操作，它就可以直接进行操作，并不需要增加指令首先取得具体的地址。相反，对于指针，必须首先在运行时取得它的当前值，然后才能对它进行解除引用的操作（作为以后进行查找的步骤之一）。
相反，如果声明extern char *p，它将告诉编译器p是一个指针，它指向的对象是一个字符。为了取得这个字符，必须得到地址p的内容，把它作为字符的地址并从这个地址中取得这个字符。指针的访问要灵活很多，但需要增加一个额外的提取，如图所示：
11 数组和指针的其他区别
比较数组和指针的另外一个方法就是对比两者的特点。
数组和指针的区别
| 指针 | 数组 |
|
保存数据的地址 |
保存数据 |
|
间接访问数据，首先取得指针的内容，把它作为地址，然后从这个地址提取数据。 如果指针有一个下标[I],就把指针的内容加上I作为地址，从中提取数据 |
直接访问，a[I]只是简单地从a+I为地址取得数据 |
| 通常用于动态数据结构 | 通常用于存储固定数目且数据类型相同的元素 |
| 相关的函数为malloc() free() | 隐式分配和删除 |
| 通常指向匿名数据 | 自身即为数据名 |
定义指针时，编译器并不为指针所指向的对象分配空间，它只是分配指针本身的空间，除非在定义时赋给指针一个字符串常量进行初始化。例如，下面的定义创建了一个字符串常量（为其分配了内存）：
char *p="breadfruit";
注意只有对字符串常量才是如此。不能指望为浮点数之类的常量分配空间，如：
float *pip=3.141; //错误
初始化指针时所创建的字符串常量被定义为只读的。如果试图通过指针修改这个字符串的值，程序就会出现未定义的行为。
数组也可以用字符串常量进行初始化：
char a[]="gooseberry";
与指针相反，由字符串常量初始化的数组是可以修改的。
12 UNIX中的堆栈段和MS-DOS中的堆栈段
在UNIX中，当进程需要更多空间时，堆栈会自动生长。程序员可以想象堆栈是无限大的。这是UNIX胜过其他操作系统如MS-DOS的许多优势之一。在UNIX的实现中一般使用某种形式的虚拟内存。当试图访问当前系统分配给堆栈的空间之外时，它将产生一个硬件中断，称为页错误。处理页错误的方法有好几种，取决于对页的引用是否有效。
在正常情况下，内核通过向违规的进程发送合适的信号（可能是段错误）来处理对地址的引用。在堆栈顶部的下端有一个称为red zone的小型区域，如果对这个区域进行引用，不会产生失败。相反，操作系统通过一个好的内存块来增加堆栈段的大小。
在DOS中，在建立可执行文件时，堆栈的大小必须同时确定，而且它不能在运行时增加，如果你猜测错误，需要的堆栈空间大于所分配的空间，那么你和程序都会迷失。如果设置了检查选项，就会收到STACK OVERFLOW（堆栈溢出）消息。
13 返回局部指针的两种不同情况。
先看下面的程序：
#include<iostream> using namespace std; char* test2() { char p[] = "hello world"; return p; } char* test3(){ char *p = "hello world"; return p; } int main() { test2(); test3(); }
其中，test2中p是一个数组，分配在栈空间，在栈空间存放字符串。当是数组p，则函数会将字符串常量的字符逐个复制到p数组里面，返回p则是返回数组p，但是调用函数结束后p被销毁，里面的元素不存在了。
但是在test3中p是一个指针，则p指向存放字符串常量的地址，返回p则是返回字符串常量地址值，调用函数结束字符串常量不会消失（是常量）。所以返回常量的地址不会出错。
虽然都是返回局部变量的指针，但是test2结果会有问题，但是test3不会。