關鍵字篇
volatile關鍵字
鮮為人知的關鍵字之一volatile，表示變量是'易變的'，之所以會有這個關鍵字，主要是消除編譯優化帶來的一些問題，看下面的代碼
1 int a = 8; 2 int b = a; 3 int c = a;
編譯器認為，上面的第2句代碼與第三句代碼之間，沒有存在對a賦值的語句，所以編譯出來的匯編代碼在講a的值賦給c的時候，不會再次到內存取這個變量的值，而是取cache中的值。這樣雖然提高了效率，但也帶來了一些問題，比如如果變量a被多個線程共享，且在a賦值給了b之后，a的值立馬被另一個線程修改，則再賦值給c的就是過時的數據，有時希望c拿到的是實時的數據，這個時候volatile關鍵字就派上了用場
volatile int a = 8; int b = a; int c = a;
上面的關鍵字告訴編譯器a的值是隨時可能發生變化的值，要求每次使用都到內存中取值，這樣就能保證c能獲得實時數據。
sizeof關鍵字
很多人都認為sizeof 是函數，因為帶括號嘛，還有返回值，不是函數是啥。其實sizeof 是關鍵字，不信你在測試變量的時候把括號去掉試試，當然，如果測試的是類型，則必須加括號，因為你如果sizeof 類型，不打擴號的話，編譯器認為你在定義變量，而定義變量的時候前面顯然是只能是修飾符如const，static和extern之類的，絕對不能是sizeof 所以會報錯。
1 int a = 9; 2 sizeof(a) ; // 合法 3 sizeof a ; // 合法 4 sizeof int ;// 非法 5 sizeof(int);// 合法
register關鍵字
register關鍵字定義的變量可能放在寄存器里面，可能放在寄存器里，也可能放在內存里，所以為了安全起見，不能對寄存器變量取地址，所以下面的代碼編譯會報錯
1 register int a = 0; 2 printf("%d\n",&a);
const關鍵字
C語言中，const關鍵字定義了一個不可變的變量a ，注意a還是一個變量，沒錯是變量，不是常量，只是值不能變，是只讀變量，編譯的時候是不能確定值的。下面的代碼可以說明問題
1 const int a = 4; 2 int arr[a];
上面的代碼在VC6.0的ANSI標准下會報錯，因為const定義的依然是變量，當然在GNU這種先進的編譯器下會通過。
typedef關鍵字
大多人認為typedef是定義一個新的數據類型，其實不是，typedef關鍵字是給一個已經存在的數據類型取一個別名，很多人喜歡在定義類型的同時使用 typedef關鍵字，這就讓自己慢慢的也誤以為typedef是在定義一種新的數據類型
1 typedef struct s{ 2 int a; 3 int b; 4 int c; 5 } NS;
其實換成像下面這樣可能會更好
1 struct s{ 2 int a; 3 int b; 4 int c; 5 }; 6 typedef struct s NS;
另外看看下面的代碼
先添加這樣的聲明
1 typedef struct s * PNS;
看下面的代碼
1 NS ns; 2 const PNS pns1 = &ns; 3 pns1->a = 8; 4 NS ns2 ; 5 pns1 = &ns2; // 報錯,pns1 只讀 6 PNS const pns2 = &ns; 7 pns2->a = 8; 8 pns2 = &ns2; // 報錯，pns2 只讀
大家可能都能明白 const int * p和 int * const p的區別，但這里就有些模糊了，這個結果顛覆了大家的思維。
這是因為能把 （struct s *）重定義為一個整體，const遇到整體的類型定義會直接將這個整體忽略，也就是對於const int * p和 int * const p以及const int p和 int const p，編譯器會把int忽略，得到 const * p和* const p，以及const p。
所以對於cosnt PNS pns1 和 PNS const pns2，PNS會被忽略，就得到了const pns1和const pns2，所以const修飾什么顯而易見
數據類型篇
struct類型
相信讓大家說struct與c++class的區別，99%的開發者都知道有，標准的C語言中struct中不能定義函數的
1 struct s{ 2 int a; 3 int getA(){ 4 return a; 5 } 6 };
上面的代碼在C語言的環境下會報錯。再就是struct與class的默認訪問屬性不同。
除了上面的區別，struct還具備一些class不具備的一些屬性
1 struct s{ 2 int a; 3 int b; 4 int c; 5 }; 6 // 直接初始化 7 struct s ele = {1,2}; 8 // 全部成員初始化為0 9 struct s ele2 = {0}; 10 // 指定初始化 11 struct s ele3 = {.a = 1};
還用空的結構體大小，在老版本的VC6.0 （應該是C89標准）不為0，而為1 ，因為最小的c語言類型為char，一個字節，struct的設計者要求struct至少能容納一個字符，但是到了現在的C11標准，C語言中的空結構體大小為0，在C++中大小為1。
另外，結構體還有一個很神奇的東西--柔性數組，也就是結構體的最后一個成員可以定義為一個柔性數組--b變長數組。這個柔性數組的大小不會算在結構體的大小內，向下面這樣
1 struct s{ 2 int a; 3 int b; 4 int c; 5 int arr[]; 6 }; 7 8 typedef struct s NS; 9 typedef struct s * PNS; 10 // 實例化 11 PNS p = (PNS) malloc(sizeof(NS)+100*sizeof(int));
上面的代碼就定義了一個結構體，並且分配了一個大小為100的柔性數組
多字符常量
1 int str = 'ABCD';
上面的代碼會讓四個字母分別占據int的四個字節，至於具體值，取決於存儲的是大端模式還是小端模式
表達式和結構篇
switch語句
奇葩寫法1
1 char ch = 'c'; 2 switch(ch){ 3 case 'a'...'z': 4 printf("a-z"); 5 break; 6 case 'A'...'Z': 7 printf("A-Z"); 8 break; 9 default: 10 break; 11 } 12 //運行結果a-z
這種寫法還算正常，GNU C擴充的，能夠接受，下面這種。。
奇葩寫法2
1 int a = 3,b = 4,m; 2 switch(a){ 3 case 1: 4 printf("1"); 5 break; 6 if(b == 4){ 7 case 2: 8 printf("2"); 9 ; 10 }else case 3:{ 11 printf("3"); 12 for(m = 1;m<3;m++){ 13 case 4: 14 printf("4"); 15 ; 16 } 17 } 18 default: 19 break; 20 } 21 // 運行結果 344
第一次看到，我也驚呆了
scanf忽略輸入
這個問題相比很多人都遇到過，scanf讀取無用的換行符，下面的代碼可以很好的解決這個問題
1 char c1,c2; 2 scanf("%c%*c%c",&c1,&c2); 3 putchar(c1); 4 putchar(c2);
這樣，你換行輸入單個字符才不會有問題，也有用下面這樣的代碼過濾換行符的
1 while((ch = getchar()) == '\n');
printf變量限定格式
1 int a=3; 2 float m = 3.1415926; 3 printf("%.*f\n",a,m); // 3.142
宏定義中的#號
1 #define SQR(x) printf("x^2 = %d\n",((x)*(x))); 2 #define SQR2(x) printf(""#x"^2 = %d\n",((x)*(x))); 3 #define SQR3(x) printf("%d^2 = %d\n",x,((x)*(x))); 4 5 SQR(3); // x^2 = 9 6 SQR2(3); // 3^2 = 9 7 SQR3(3); // 3^2 = 9
數組名
數組名是指針常量，定義完之后不能修改
1 int arr[3] = {1,2,3}; 2 int a2[3]; 3 int * p = a2; 4 arr = p; 5 arr = a2;
函數調用時不能傳遞數組，傳遞的只不過是一個指針
1 void fun(int arr[100]){ 2 printf("%d\n",sizeof(arr)); 3 } 4 int arr[3] = {1,2,3}; 5 fun(arr); // 4
沒錯，那個參數列表中的100然並luan。關於向函數傳遞數組，后面還有講解。
指針與函數篇
指針這部分如果學到比較好的這個應該都知道，算不得什么特性
直接對內存地址賦值
1 *(int*)0x12ff7c = 100;
取數組一行的最后一個值
1 int arr[5] = {1,2,3,4,5}; 2 printf("%d\n",*(*(&arr+1)-1)); // 5
這個其實也很簡單，arr是一級指針，列指針，再取一次地址后得到行指針，+1之后偏移一行，再解引用降級為列指針，再減1恰好指向arr[4]，所以就是5。另外注意arr其實就是&arr[0]的值，也就是數組首元素的首地址。它與數組首地址其實有區別的，當arr為二維數組的時候，兩者就存在區別。如果為二位數組，則arr==&arr[0]==&&arr[0][0]。
數組與指針參數
就像前面說到的，不能像函數傳遞一個數組，傳遞數組，編譯器總是將它解析成一個指向數組首元素的指針，也就是說傳遞的使用個指針，指向數組的首元素，但不指向數組，也就是說傳遞arr與傳遞&arr[0]沒有區別，這進一步說明了數組首地址與數組首元素的首地址是有卻別的。
另外，指針傳遞也是數值傳遞看下面的代碼
1 int f(int * p){ 2 p = NULL; 3 } 4 int a = 3; 5 int *p = &a; 6 f(p); 7 printf("%d\n",*p);
在沒有C++引用傳遞的情況下，想傳遞指針，就要傳遞指針的指針。像下面這樣
1 int f2( int ** pp){ 2 *pp = (int *) malloc(sizeof (int)); 3 **pp = 9; 4 } 5 f2(&p); 6 printf("%d\n",*p); // 9
指針返回值
不要將局部變量的地址作為返回值返回，像下面這樣的代碼。
1 int * getP(){ 2 int a = 4; 3 return &a; 4 } 5 int * getP1(){ 6 int * p = (int *) malloc(sizeof(int)); 7 *p = 4; 8 return p; 9 } 10 11 int *p = getP(); 12 int *p1 = getP1(); 13 printf("%d\n",*p); 14 printf("%d\n",*p1);
雖然在我測試的時候都給出了正確的結果，但是這樣做還是很危險的，因為局部變量在函數執行完畢后會被銷毀，這個時候如果將局部變量的地址返回可能會得到野指針。
函數指針
下面來分析一個比較復雜的函數指針調用
1 (*(int** (*) (int **,int **))0)(int **,int **);
有點暈，其實分開來看，
int** (*) (int **,int **) 其實就是一個函數指針，函數的返回值是整形的二級指針，參數是兩個整形的二級指針。
而(int** (*) (int **,int **))0就是講地址0指向的區域轉換為函數指針
*(int** (*) (int **,int **))0就是對這個函數進行解引用
而(*(int** (*) (int **,int **))0)(int **,int **)則是指行函數調用
先整理這么多吧，C語言博大精深，有着各種鮮為人知的高級特性，這里列出來的只是九牛一毛而已，權當復習而已。