關鍵字篇

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}; 
 

還用空的結構體大小不為0，而為1 ，因為最小的c語言類型為char，一個字節，struct的設計者要求struct至少能容納一個字符

另外，結構體還有一個很神奇的東西--柔性數組，也就是結構體的最后一個成員可以定義為一個柔性數組--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 

這種寫法還算正常，GCC擴充的，能夠接受，下面這種。。

奇葩寫法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語言博大精深，有著各種鮮為人知的高級特性，這里列出來的只是九牛一毛而已，權當復習而已。