char、wchar_t、T_char

從字符到整數

char是一種整數類型，這句話的含義是，char所能表示的字符在C/C++中都是整數類型。好，接下來，很多文章就會舉出一個典型例子，比如，'a'的數值就是0x61。這種說法對嗎？如果你細心的讀過K&R和BS對於C和C++描述的原著，你就會馬上反駁道，0x61只是'a'的ASCII值，並沒有任何規定C/C++的char值必須對應ASCII。C/C++甚至沒有規定char佔幾位，只是規定了sizeof(char)等於1。
當然，目前大部分情況下，char是8位的，並且，在ASCII範圍內的值，與ASCII對應。

本地化策略集（locale）

“將'a'翻譯成0x61的整數值”，“將ASCII範圍內的編碼與char的整數值對應起來”，類似這樣的規定，是特定系統和特定編譯器制定的，C/C++中有個特定的名詞來描述這種規定的集合：本地化策略集（locale。也有翻譯成“現場”）。而翻譯——也就是代碼轉換（codecvt）只是這個集合中的一個，C++中定義爲策略（facet。也有翻譯爲“刻面”）

C/C++的編譯策略

“本地化策略集”是個很好的概念，可惜在字符和字符串這個層面上，C/C++並不使用（C++的locale通常只是影響流（stream）），C/C++使用更直接簡單的策略：硬編碼。
簡單的說，字符（串）在程序文件（可執行文件，非源文件）中的表示，與在程序執行中在內存中的表示一致。考慮兩種情況：
A、char c = 0x61;
B、char c = 'a';
情況A下，編譯器可以直接認識作爲整數的c，但是在情況B下，編譯器必須將'a'翻譯成整數。編譯器的策略也很簡單，就是直接讀取字符（串）在源文件中的編碼數值。比如：
const char* s = "中文abc";
這段字符串在GB2312（Windows 936），也就是我們的windows默認中文系統源文件中的編碼爲：
0xD6   0xD0   0xCE 0xC4 0x61 0x62 0x63
在UTF-8，也就是Linux默認系統源文件中的編碼爲：
0xE4   0xB8   0xAD   0xE6   0x96   0x87   0x61   0x62   0x63
一般情況下，編譯器會忠實於源文件的編碼爲s賦值，例外的情況比如VC會自作聰明的把大部分其他類型編碼的字符串轉換成GB2312（除了像UTF-8 without signature這樣的倖存者）。
程序在執行的時候，s也就保持是這樣的編碼，不會再做其他的轉換。

寬字符 wchar_t
正如char沒有規定大小，wchar_t同樣沒有標準限定，標準只是要求一個wchar_t可以表示任何系統所能認識的字符，在win32中，wchar_t爲16位；Linux中是32位。wchar_t同樣沒有規定編碼，因爲Unicode的概念我們後面才解釋，所以這裏只是提一下，在win32中，wchar_t的編碼是UCS-2BE；而Linux中是UTF-32BE（等價於UCS-4BE），不過簡單的說，在16位以內，一個字符的這3種編碼值是一樣的。因此：
const wchar_t* ws = L"中文abc";
的編碼分別爲：
0x4E2D   0x6587    0x0061   0x0062   0x0063                                                //win32，16位
0x00004E2D   0x00006587    0x00000061   0x00000062   0x00000063        //Linux，32位
大寫的L是告訴編譯器：這是寬字符串。所以，這時候是需要編譯器根據locale來進行翻譯的。
比如，在Windows環境中，編譯器的翻譯策略是GB2312到UCS-2BE；Linux環境中的策略是UTF-8到UTF-32BE。
這時候就要求源文件的編碼與編譯器的本地化策略集中代碼翻譯的策略一致，例如VC只能讀取GB2312的源代碼（這裏還是例外，VC太自作聰明瞭 ，會將很多其他代碼在編譯時自動轉換成GB2312），而gcc只能讀取UTF-8的源代碼（這裏就有個尷尬，MinGW運行win32下，所以只有GB2312系統才認；而MinGW卻用gcc編寫，所以自己只認UTF-8，所以結果就是，MinGW的寬字符被廢掉了）。
寬字符（串）由編譯器翻譯，還是被硬編碼進程序文件中。

T_char：

自動識別當前類型，並轉換爲wchar_t和char

附：

以下爲比較好的char*和wchar_t*互轉的兩個函數（僅用於utf8和unicode的轉換)

1. #include <stdio.h> 
2. #include <string.h> 
3. #include <malloc.h> 
4. #include <wchar.h> 
5. #include <assert.h> 
6.  
7. wchar_t* ConvertUtf8ToUnicode(char* putf8) 
8. { 
9. int i,k,len; 
10.  
11. assert(putf8); 
12.  
13. len = strlen(putf8); 
14. wchar_t* result = (wchar_t*)malloc(sizeof(wchar_t)*len); 
15. if (result) 
16. { 
17.    k = 0; 
18.    for (i=0;i<len;) 
19.    { 
20.     if (0 == (0x80 & putf8[i])) 
21.     {//one byte 
22.      result[k++] = (wchar_t)putf8[i++]; 
23.      continue; 
24.     } 
25.  
26.     if (0xe0 == (0xe0 & putf8[i])) 
27.     {//three byte 
28.      result[k] = (putf8[i] & 0x1F) << 12; 
29.      result[k] |= (putf8[i+1] & 0x3F) << 6; 
30.      result[k++] |= (putf8[i+2] & 0x3F); 
31.  
32.      i += 3; 
33.  
34.      continue; 
35.     } 
36.  
37.     if (0xc0 == 0xc0 & putf8[i]) 
38.     {//two byte 
39.      result[k] = (putf8[i] & 0x1F) << 8; 
40.      result[k++] |= (putf8[i+1] & 0x3F); 
41.  
42.      i += 2; 
43.     } 
44.    } 
45.    result[k++] = 0; 
46. } 
47. return result; 
48. } 
49.  
50. char* ConvertUnicodeToUtf8(wchar_t* punicode) 
51. { 
52. int i,k,len; 
53.  
54. assert(punicode); 
55. len = wcslen(punicode); 
56. char* result = (char*)malloc(sizeof(char)*len*3); 
57. if (NULL != result) 
58. { 
59.    k = 0; 
60.    for (i=0;i<len;i++) 
61.    { 
62.     if (0x80 > punicode[i]) 
63.     { 
64.      result[k++] = (char)punicode[i]; 
65.     } 
66.     else 
67.     {    
68.      result[k++] = (char)(0xe0|(punicode[i]>>12)); 
69.      result[k++] = (char)(0x80|((punicode[i]>>6)&0x3f)); 
70.      result[k++] = (char)(0x80|(punicode[i]&0x3f)); 
71.     } 
72.    } 
73.    result[k++] = 0; 
74. } 
75. return result; 
76. }