關鍵字篇
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語言博大精深，有着各種鮮為人知的進階特性，這裡列出來的隻是九牛一毛而已，權當複習而已。
![241 Different Ways to Add Parentheses（C代碼版）[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)