指定存储文件的编码格式（上）

   1 // test__OutputUtf8File.cpp : 定义控制台应用程序的入口点。
   2 //
   3 
   4 #include "stdafx.h"
   5 #include <windows.h>
   6 #include <string>
   7 #include <iostream>
   8 
   9 #define UTF8_SIGN 3
  10 #define UTF16_SIGN 2
  11 
  12 
  13 
  14 //************************************
  15 // Method:    Utf16leFileToUtf8File
  16 // FullName:  Utf16leFileToUtf8File
  17 // Access:    public 
  18 // Returns:   BOOL
  19 // Qualifier:将lpUtf16leFile文件内容写入到lpUtf8File文件中
  20 // Parameter: CONST LPTSTR lpUtf16leFile：输入文件utf16le编码
  21 // Parameter: CONST LPTSTR lpUtf8File：输出文件为utf8-with-BOM编码
  22 // *注：lpUtf16leFile文件只读；lpUtf8File文件总是创建或覆盖
  23 //************************************
  24 BOOL Utf16leFileToUtf8File(CONST LPTSTR lpUtf16leFile, CONST LPTSTR lpUtf8File)
  25 {
  26     HANDLE hUtf16leFile = NULL;
  27     HANDLE hUtf8File = NULL;
  28 
  29 
  30     //create file
  31     hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  32     if (INVALID_HANDLE_VALUE == hUtf16leFile)
  33     {
  34         int errLogNumber = GetLastError();
  35         printf_s("error number:%d\n", errLogNumber);
  36         return FALSE;
  37     }
  38 
  39 
  40     //read UTF16LE encode file content
  41     LPWSTR lpReadContentByUTF16 = NULL;
  42     DWORD cbReadContentByUTF16 = 0;
  43     DWORD cbPreReadContentByUTF16 = 0;
  44     DWORD cchReadContentByUTF16 = 0;
  45 
  46     cbReadContentByUTF16 = SetFilePointer(hUtf16leFile, 0, NULL, FILE_END);
  47     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF16)
  48     {
  49         int errLogNumber = GetLastError();
  50         printf_s("error number:%d\n", errLogNumber);
  51         ::CloseHandle(hUtf16leFile);
  52         return FALSE;
  53     }
  54     lpReadContentByUTF16 = (WCHAR *)malloc(cbReadContentByUTF16);
  55     if (NULL == lpReadContentByUTF16)
  56     {
  57         printf_s("malloc error\n");
  58         ::CloseHandle(hUtf16leFile);
  59         return FALSE;
  60     }
  61     ZeroMemory(lpReadContentByUTF16, cbReadContentByUTF16);
  62     SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
  63     if (FALSE == ReadFile(hUtf16leFile, lpReadContentByUTF16, cbReadContentByUTF16, &cbPreReadContentByUTF16, NULL))
  64     {
  65         int errLogNumber = GetLastError();
  66         printf_s("error number:%d\n", errLogNumber);
  67         free(lpReadContentByUTF16);
  68         ::CloseHandle(hUtf16leFile);
  69         return FALSE;
  70     }
  71     cchReadContentByUTF16 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 / sizeof(WCHAR) + 1) : (cbReadContentByUTF16 / sizeof(WCHAR)));
  72 
  73 
  74     //transform encode
  75     LPSTR lpWriteContentByUTF8 = NULL;
  76     DWORD cchWriteContentByUTF8 = 0;
  77     DWORD cbWriteContentByUTF8 = 0;
  78     DWORD cbPreWriteContentByUTF8 = 0;
  79 
  80     cbWriteContentByUTF8 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 + sizeof(WCHAR)) : (cbReadContentByUTF16));
  81     cchWriteContentByUTF8 = cchReadContentByUTF16;
  82     lpWriteContentByUTF8 = (CHAR *)malloc(cbWriteContentByUTF8);
  83     if (NULL == lpWriteContentByUTF8)
  84     {
  85         printf_s("malloc error\n");
  86         free(lpReadContentByUTF16);
  87         ::CloseHandle(hUtf16leFile);
  88         return FALSE;
  89     }
  90     ZeroMemory(lpWriteContentByUTF8, cbWriteContentByUTF8);
  91     if (0 == WideCharToMultiByte(CP_UTF8, 0, lpReadContentByUTF16, cchReadContentByUTF16, lpWriteContentByUTF8, cbWriteContentByUTF8, NULL, NULL))
  92     {
  93         printf_s("transform error\n");
  94         free(lpReadContentByUTF16);
  95         free(lpWriteContentByUTF8);
  96         ::CloseHandle(hUtf16leFile);
  97         return FALSE;
  98     }
  99 
 100 
 101     //write UTF8 encode file content
 102     hUtf8File = ::CreateFile(lpUtf8File, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 103     if (INVALID_HANDLE_VALUE == hUtf8File)
 104     {
 105         printf("Terminal failure: Unable to write to file.\n");
 106         free(lpReadContentByUTF16);
 107         free(lpWriteContentByUTF8);
 108         ::CloseHandle(hUtf16leFile);
 109         return FALSE;
 110     }
 111     for (int i = 0; i != cbWriteContentByUTF8; ++i)
 112     {
 113         if (TEXT(‘\0‘)==lpWriteContentByUTF8[i])
 114         {
 115             cchWriteContentByUTF8 = i;
 116             //lpWriteContentByUTF8[i] = 0;//设置结束符，但是utf8好像不用把
 117             break;
 118         }
 119     }
 120     SetFilePointer(hUtf8File, 0, NULL, FILE_BEGIN);
 121     if (FALSE == WriteFile(hUtf8File, lpWriteContentByUTF8, cchWriteContentByUTF8, &cbPreWriteContentByUTF8, NULL))
 122     {
 123         int errLogNumber = GetLastError();
 124         printf_s("error number:%d\n", errLogNumber);
 125         free(lpReadContentByUTF16);
 126         free(lpWriteContentByUTF8);
 127         ::CloseHandle(hUtf16leFile);
 128         return FALSE;
 129     }
 130 
 131 
 132     //release resource
 133     free(lpReadContentByUTF16);
 134     free(lpWriteContentByUTF8);
 135     ::CloseHandle(hUtf16leFile);
 136     ::CloseHandle(hUtf8File);
 137 
 138     return TRUE;
 139 
 140 }
 141 
 142 //************************************
 143 // Method:    Utf16leFileToUtf8NoBOMFile
 144 // FullName:  Utf16leFileToUtf8NoBOMFile
 145 // Access:    public 
 146 // Returns:   BOOL
 147 // Qualifier:将lpUtf16leFile文件内容写入到lpUtf8NoBOMFile文件中
 148 // Parameter: CONST LPTSTR lpUtf16leFile：输入文件utf16le编码
 149 // Parameter: CONST LPTSTR lpUtf8NoBOMFile：输出文件为utf8-without-BOM编码
 150 // *注：lpUtf16leFile文件只读；lpUtf8NoBOMFile文件总是创建或覆盖
 151 //************************************
 152 BOOL Utf16leFileToUtf8NoBOMFile(CONST LPTSTR lpUtf16leFile, CONST LPTSTR lpUtf8NoBOMFile)
 153 {
 154     HANDLE hUtf16leFile = NULL;
 155     HANDLE hUtf8NoBOMFile = NULL;
 156 
 157 
 158     //create UTF16LE file
 159     hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 160     if (INVALID_HANDLE_VALUE == hUtf16leFile)
 161     {
 162         int errLogNumber = GetLastError();
 163         printf_s("error number:%d\n", errLogNumber);
 164         return FALSE;
 165     }
 166 
 167 
 168     //read UTF16LE encode file content
 169     LPWSTR lpReadContentByUTF16 = NULL;
 170     DWORD cbReadContentByUTF16 = 0;
 171     DWORD cbPreReadContentByUTF16 = 0;
 172     DWORD cchReadContentByUTF16 = 0;
 173 
 174     cbReadContentByUTF16 = SetFilePointer(hUtf16leFile, 0, NULL, FILE_END);
 175     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF16)
 176     {
 177         int errLogNumber = GetLastError();
 178         printf_s("error number:%d\n", errLogNumber);
 179         ::CloseHandle(hUtf16leFile);
 180         return FALSE;
 181     }
 182     lpReadContentByUTF16 = (WCHAR *)malloc(cbReadContentByUTF16);
 183     if (NULL == lpReadContentByUTF16)
 184     {
 185         printf_s("malloc error\n");
 186         ::CloseHandle(hUtf16leFile);
 187         return FALSE;
 188     }
 189     ZeroMemory(lpReadContentByUTF16, cbReadContentByUTF16);
 190     SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
 191     if (FALSE == ReadFile(hUtf16leFile, lpReadContentByUTF16, cbReadContentByUTF16, &cbPreReadContentByUTF16, NULL))
 192     {
 193         int errLogNumber = GetLastError();
 194         printf_s("error number:%d\n", errLogNumber);
 195         free(lpReadContentByUTF16);
 196         ::CloseHandle(hUtf16leFile);
 197         return FALSE;
 198     }
 199     cchReadContentByUTF16 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 / sizeof(WCHAR) + 1) : (cbReadContentByUTF16 / sizeof(WCHAR)));
 200 
 201 
 202     //transform encode
 203     LPSTR lpWriteContentByUTF8 = NULL;
 204     DWORD cchWriteContentByUTF8 = 0;
 205     DWORD cbWriteContentByUTF8 = 0;
 206     DWORD cbPreWriteContentByUTF8 = 0;
 207 
 208     cbWriteContentByUTF8 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 + sizeof(WCHAR)) : (cbReadContentByUTF16));
 209     cchWriteContentByUTF8 = cchReadContentByUTF16;
 210     lpWriteContentByUTF8 = (CHAR *)malloc(cbWriteContentByUTF8);
 211     if (NULL == lpWriteContentByUTF8)
 212     {
 213         printf_s("malloc error\n");
 214         free(lpReadContentByUTF16);
 215         ::CloseHandle(hUtf16leFile);
 216         return FALSE;
 217     }
 218     ZeroMemory(lpWriteContentByUTF8, cbWriteContentByUTF8);
 219     if (0 == WideCharToMultiByte(CP_UTF8, 0, lpReadContentByUTF16, cchReadContentByUTF16, lpWriteContentByUTF8, cbWriteContentByUTF8, NULL, NULL))
 220     {
 221         printf_s("transform error\n");
 222         free(lpReadContentByUTF16);
 223         free(lpWriteContentByUTF8);
 224         ::CloseHandle(hUtf16leFile);
 225         return FALSE;
 226     }
 227 
 228 
 229     //write UTF8NoBOM encode file content
 230     LPSTR lpWriteContentByUTF8NOBOM = NULL;
 231     DWORD cbWriteContentByUTF8NOBOM = 0;
 232 
 233     hUtf8NoBOMFile = ::CreateFile(lpUtf8NoBOMFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 234     if (INVALID_HANDLE_VALUE == hUtf8NoBOMFile)
 235     {
 236         printf("Terminal failure: Unable to write to file.\n");
 237         free(lpReadContentByUTF16);
 238         free(lpWriteContentByUTF8);
 239         ::CloseHandle(hUtf16leFile);
 240         return FALSE;
 241     }
 242     for (int i = 0; i != cbWriteContentByUTF8; ++i)
 243     {
 244         if (TEXT(‘\0‘) == lpWriteContentByUTF8[i])
 245         {
 246             cbWriteContentByUTF8NOBOM = i - UTF8_SIGN;
 247             break;
 248         }
 249     }
 250     lpWriteContentByUTF8NOBOM = (CHAR *)malloc(cbWriteContentByUTF8NOBOM);
 251     if (NULL == lpWriteContentByUTF8NOBOM)
 252     {
 253         printf_s("malloc error\n");
 254         free(lpReadContentByUTF16);
 255         free(lpWriteContentByUTF8);
 256         ::CloseHandle(hUtf16leFile);
 257         return FALSE;
 258     }
 259     ZeroMemory(lpWriteContentByUTF8NOBOM, cbWriteContentByUTF8NOBOM);
 260     CopyMemory(lpWriteContentByUTF8NOBOM, lpWriteContentByUTF8 + UTF8_SIGN, cbWriteContentByUTF8NOBOM);
 261     SetFilePointer(hUtf8NoBOMFile, 0, NULL, FILE_BEGIN);
 262     if (FALSE == WriteFile(hUtf8NoBOMFile, lpWriteContentByUTF8NOBOM, cbWriteContentByUTF8NOBOM, &cbPreWriteContentByUTF8, NULL))
 263     {
 264         int errLogNumber = GetLastError();
 265         printf_s("error number:%d\n", errLogNumber);
 266         free(lpReadContentByUTF16);
 267         free(lpWriteContentByUTF8);
 268         free(lpWriteContentByUTF8NOBOM);
 269         ::CloseHandle(hUtf16leFile);
 270         return FALSE;
 271     }
 272 
 273 
 274     //release resource
 275     free(lpReadContentByUTF16);
 276     free(lpWriteContentByUTF8);
 277     free(lpWriteContentByUTF8NOBOM);
 278     ::CloseHandle(hUtf16leFile);
 279     ::CloseHandle(hUtf8NoBOMFile);
 280 
 281     return TRUE;
 282 
 283 }
 284 
 285 //************************************
 286 // Method:    Utf16leFileToUtf8NoBOMFile2
 287 // FullName:  Utf16leFileToUtf8NoBOMFile2
 288 // Access:    public 
 289 // Returns:   BOOL
 290 // Qualifier:
 291 // Parameter: CONST LPTSTR lpUtf16leFile：输入文件utf16le编码
 292 // Parameter: CONST LPTSTR lpUtf8NoBOMFile：输出文件为utf8-without-BOM编码
 293 // *注：lpUtf16leFile文件只读；lpUtf8NoBOMFile文件总是创建或覆盖
 294 //************************************
 295 BOOL Utf16leFileToUtf8NoBOMFile2(CONST LPTSTR lpUtf16leFile, CONST LPTSTR lpUtf8NoBOMFile)
 296 {
 297     HANDLE hUtf16leFile = NULL;
 298     HANDLE hUtf8NoBOMFile = NULL;
 299 
 300 
 301     //create UTF16LE file
 302     hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 303     if (INVALID_HANDLE_VALUE == hUtf16leFile)
 304     {
 305         int errLogNumber = GetLastError();
 306         printf_s("error number:%d\n", errLogNumber);
 307         return FALSE;
 308     }
 309 
 310 
 311     //read UTF16LE encode file content
 312     LPWSTR lpReadContentByUTF16 = NULL;
 313     DWORD cbReadContentByUTF16 = 0;
 314     DWORD cbPreReadContentByUTF16 = 0;
 315     DWORD cchReadContentByUTF16 = 0;
 316 
 317     cbReadContentByUTF16 = SetFilePointer(hUtf16leFile, 0, NULL, FILE_END);
 318     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF16)
 319     {
 320         int errLogNumber = GetLastError();
 321         printf_s("error number:%d\n", errLogNumber);
 322         ::CloseHandle(hUtf16leFile);
 323         return FALSE;
 324     }
 325     lpReadContentByUTF16 = (WCHAR *)malloc(cbReadContentByUTF16);
 326     if (NULL == lpReadContentByUTF16)
 327     {
 328         printf_s("malloc error\n");
 329         ::CloseHandle(hUtf16leFile);
 330         return FALSE;
 331     }
 332     ZeroMemory(lpReadContentByUTF16, cbReadContentByUTF16);
 333     SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
 334     if (FALSE == ReadFile(hUtf16leFile, lpReadContentByUTF16, cbReadContentByUTF16, &cbPreReadContentByUTF16, NULL))
 335     {
 336         int errLogNumber = GetLastError();
 337         printf_s("error number:%d\n", errLogNumber);
 338         free(lpReadContentByUTF16);
 339         ::CloseHandle(hUtf16leFile);
 340         return FALSE;
 341     }
 342     cchReadContentByUTF16 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 / sizeof(WCHAR) + 1) : (cbReadContentByUTF16 / sizeof(WCHAR)));
 343 
 344 
 345     //transform encode
 346     LPSTR lpWriteContentByUTF8 = NULL;
 347     DWORD cchWriteContentByUTF8 = 0;
 348     DWORD cbWriteContentByUTF8 = 0;
 349     DWORD cbPreWriteContentByUTF8 = 0;
 350 
 351     cbWriteContentByUTF8 = ((cbReadContentByUTF16 % sizeof(WCHAR)) != 0 ? (cbReadContentByUTF16 + sizeof(WCHAR)) : (cbReadContentByUTF16));
 352     cchWriteContentByUTF8 = cchReadContentByUTF16;
 353     lpWriteContentByUTF8 = (CHAR *)malloc(cbWriteContentByUTF8);
 354     if (NULL == lpWriteContentByUTF8)
 355     {
 356         printf_s("malloc error\n");
 357         free(lpReadContentByUTF16);
 358         ::CloseHandle(hUtf16leFile);
 359         return FALSE;
 360     }
 361     ZeroMemory(lpWriteContentByUTF8, cbWriteContentByUTF8);
 362     if (0 == WideCharToMultiByte(CP_UTF8, 0, lpReadContentByUTF16, cchReadContentByUTF16, lpWriteContentByUTF8, cbWriteContentByUTF8, NULL, NULL))
 363     {
 364         printf_s("transform error\n");
 365         free(lpReadContentByUTF16);
 366         free(lpWriteContentByUTF8);
 367         ::CloseHandle(hUtf16leFile);
 368         return FALSE;
 369     }
 370 
 371 
 372     //write UTF8NOBOM file content
 373     hUtf8NoBOMFile = ::CreateFile(lpUtf8NoBOMFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 374     if (INVALID_HANDLE_VALUE == hUtf8NoBOMFile)
 375     {
 376         printf("Terminal failure: Unable to write to file.\n");
 377         free(lpReadContentByUTF16);
 378         free(lpWriteContentByUTF8);
 379         ::CloseHandle(hUtf16leFile);
 380         return FALSE;
 381     }
 382     for (int i = 0; i != cbWriteContentByUTF8; ++i)
 383     {
 384         if (TEXT(‘\0‘) == lpWriteContentByUTF8[i])
 385         {
 386             cchWriteContentByUTF8 = i;
 387             break;
 388         }
 389     }
 390     SetFilePointer(hUtf8NoBOMFile, 0, NULL, FILE_BEGIN);
 391     if (FALSE == WriteFile(hUtf8NoBOMFile, lpWriteContentByUTF8 + UTF8_SIGN, cchWriteContentByUTF8 - UTF8_SIGN, &cbPreWriteContentByUTF8, NULL))
 392     {
 393         int errLogNumber = GetLastError();
 394         printf_s("error number:%d\n", errLogNumber);
 395         free(lpReadContentByUTF16);
 396         free(lpWriteContentByUTF8);
 397         ::CloseHandle(hUtf16leFile);
 398         ::CloseHandle(hUtf8NoBOMFile);
 399         return FALSE;
 400     }
 401 
 402 
 403     //release resource
 404     free(lpReadContentByUTF16);
 405     free(lpWriteContentByUTF8);
 406     ::CloseHandle(hUtf16leFile);
 407     ::CloseHandle(hUtf8NoBOMFile);
 408 
 409     return TRUE;
 410 }
 411 
 412 //************************************
 413 // Method:    Utf8FileToUtf16leFile
 414 // FullName:  Utf8FileToUtf16leFile
 415 // Access:    public 
 416 // Returns:   BOOL
 417 // Qualifier:将utf8编码格式文件转换为utf16le编码格式文件
 418 // Parameter: CONST LPTSTR lpUtf8File：utf8编码格式文件
 419 // Parameter: CONST LPTSTR lpUtf16leFile：utf16le编码格式文件
 420 //************************************
 421 BOOL Utf8FileToUtf16leFile(CONST LPTSTR lpUtf8File, CONST LPTSTR lpUtf16leFile)
 422 {
 423     HANDLE hUtf16leFile = NULL;
 424     HANDLE hUtf8File = NULL;
 425 
 426 
 427     //create UTF8 file
 428     hUtf8File = ::CreateFile(lpUtf8File, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 429     if (INVALID_HANDLE_VALUE == hUtf8File)
 430     {
 431         int errLogNumber = GetLastError();
 432         printf_s("error number:%d\n", errLogNumber);
 433         return FALSE;
 434     }
 435 
 436 
 437     //read UTF8 encode file content
 438     LPSTR lpReadContentByUTF8 = NULL;
 439     DWORD cbReadContentByUTF8 = 0;
 440     DWORD cbPreReadContentByUTF8 = 0;
 441     DWORD cchReadContentByUTF8 = 0;
 442 
 443     cbReadContentByUTF8 = SetFilePointer(hUtf8File, 0, NULL, FILE_END);
 444     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF8)
 445     {
 446         int errLogNumber = GetLastError();
 447         printf_s("error number:%d\n", errLogNumber);
 448         ::CloseHandle(hUtf8File);
 449         return FALSE;
 450     }
 451     lpReadContentByUTF8 = (CHAR *)malloc(cbReadContentByUTF8);
 452     if (NULL == lpReadContentByUTF8)
 453     {
 454         printf_s("malloc error\n");
 455         ::CloseHandle(hUtf8File);
 456         return FALSE;
 457     }
 458     ZeroMemory(lpReadContentByUTF8, cbReadContentByUTF8);
 459     SetFilePointer(hUtf8File, 0, NULL, FILE_BEGIN);
 460     if (FALSE == ReadFile(hUtf8File, lpReadContentByUTF8, cbReadContentByUTF8, &cbPreReadContentByUTF8, NULL))
 461     {
 462         int errLogNumber = GetLastError();
 463         printf_s("error number:%d\n", errLogNumber);
 464         free(lpReadContentByUTF8);
 465         ::CloseHandle(hUtf8File);
 466         return FALSE;
 467     }
 468     if (sizeof(CHAR) != sizeof(BYTE))
 469     {
 470         free(lpReadContentByUTF8);
 471         ::CloseHandle(hUtf8File);
 472         return FALSE;
 473     }
 474     cchReadContentByUTF8 = cbReadContentByUTF8;
 475 
 476 
 477     //transform encode
 478     LPWSTR lpWriteContentByUTF16 = NULL;
 479     DWORD cchWriteContentByUTF16 = 0;
 480     DWORD cbWriteContentByUTF16 = 0;
 481     DWORD cbPreWriteContentByUTF16 = 0;
 482 
 483     cbWriteContentByUTF16 = cchReadContentByUTF8 * 2;
 484     cchWriteContentByUTF16 = cchReadContentByUTF8;
 485     lpWriteContentByUTF16 = (WCHAR *)malloc(cbWriteContentByUTF16);
 486     if (NULL == lpWriteContentByUTF16)
 487     {
 488         printf_s("malloc error\n");
 489         free(lpReadContentByUTF8);
 490         ::CloseHandle(hUtf8File);
 491         return FALSE;
 492     }
 493     ZeroMemory(lpWriteContentByUTF16, cbWriteContentByUTF16);
 494     if (0 == MultiByteToWideChar(CP_UTF8, 0, lpReadContentByUTF8, cbReadContentByUTF8, lpWriteContentByUTF16, cchWriteContentByUTF16))
 495     {
 496         printf_s("transform error\n");
 497         free(lpReadContentByUTF8);
 498         free(lpWriteContentByUTF16);
 499         ::CloseHandle(hUtf8File);
 500         return FALSE;
 501     }
 502 
 503 
 504     //write UTF16LE encode file content
 505     hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 506     if (INVALID_HANDLE_VALUE == hUtf16leFile)
 507     {
 508         printf("Terminal failure: Unable to write to file.\n");
 509         free(lpReadContentByUTF8);
 510         free(lpWriteContentByUTF16);
 511         ::CloseHandle(hUtf8File);
 512         return FALSE;
 513     }
 514     for (int i = 0; i != cbWriteContentByUTF16 -1; ++i)
 515     {
 516         if (0 == lpWriteContentByUTF16[i] && 0 == lpWriteContentByUTF16[i+1])
 517         {
 518             cbWriteContentByUTF16 = i;
 519             break;
 520         }
 521     }
 522     //////////////////////////////////////////////////////////////////////////
 523 
 524     //std::wstring wstrText = L"output to utf8 with BOM.\r\n输出到utf8带BOM的文件中。\r\nengli  sh";
 525     //int lgText = wstrText.length();
 526     //int lgText2 = wstrText.size();
 527     //std::cout << lgText << "" << lgText2 << std::endl;
 528 
 529     //////////////////////////////////////////////////////////////////////////
 530     SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
 531     if (FALSE == WriteFile(hUtf16leFile, lpWriteContentByUTF16, cbWriteContentByUTF16 * sizeof(WCHAR), &cbPreWriteContentByUTF16, NULL))
 532     {
 533         int errLogNumber = GetLastError();
 534         printf_s("error number:%d\n", errLogNumber);
 535         free(lpReadContentByUTF8);
 536         free(lpWriteContentByUTF16);
 537         ::CloseHandle(hUtf16leFile);
 538         ::CloseHandle(hUtf8File);
 539         return FALSE;
 540     }
 541 
 542 
 543     //release resource
 544     free(lpReadContentByUTF8);
 545     free(lpWriteContentByUTF16);
 546     ::CloseHandle(hUtf16leFile);
 547     ::CloseHandle(hUtf8File);
 548 
 549     return TRUE;
 550 
 551 }
 552 
 553 BOOL Utf8NoBOMFileToUtf16leFile(CONST LPTSTR lpUtfNoBOM8File, CONST LPTSTR lpUtf16leFile)
 554 {
 555     return Utf8FileToUtf16leFile(lpUtfNoBOM8File, lpUtf16leFile);
 556 
 557     //HANDLE hUtf16leFile = NULL;
 558     //HANDLE hUtf8File = NULL;
 559 
 560 
 561     ////create UTF8 file
 562     //hUtf8File = ::CreateFile(lpUtf8File, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 563     //if (INVALID_HANDLE_VALUE == hUtf8File)
 564     //{
 565     //    int errLogNumber = GetLastError();
 566     //    printf_s("error number:%d\n", errLogNumber);
 567     //    return FALSE;
 568     //}
 569 
 570 
 571     ////read UTF8 encode file content
 572     //LPSTR lpReadContentByUTF8 = NULL;
 573     //DWORD cbReadContentByUTF8 = 0;
 574     //DWORD cbPreReadContentByUTF8 = 0;
 575     //DWORD cchReadContentByUTF8 = 0;
 576 
 577     //cbReadContentByUTF8 = SetFilePointer(hUtf8File, 0, NULL, FILE_END);
 578     //if (INVALID_SET_FILE_POINTER == cbReadContentByUTF8)
 579     //{
 580     //    int errLogNumber = GetLastError();
 581     //    printf_s("error number:%d\n", errLogNumber);
 582     //    ::CloseHandle(hUtf8File);
 583     //    return FALSE;
 584     //}
 585     //lpReadContentByUTF8 = (CHAR *)malloc(cbReadContentByUTF8);
 586     //if (NULL == lpReadContentByUTF8)
 587     //{
 588     //    printf_s("malloc error\n");
 589     //    ::CloseHandle(hUtf8File);
 590     //    return FALSE;
 591     //}
 592     //ZeroMemory(lpReadContentByUTF8, cbReadContentByUTF8);
 593     //SetFilePointer(hUtf8File, 0, NULL, FILE_BEGIN);
 594     //if (FALSE == ReadFile(hUtf8File, lpReadContentByUTF8, cbReadContentByUTF8, &cbPreReadContentByUTF8, NULL))
 595     //{
 596     //    int errLogNumber = GetLastError();
 597     //    printf_s("error number:%d\n", errLogNumber);
 598     //    free(lpReadContentByUTF8);
 599     //    ::CloseHandle(hUtf8File);
 600     //    return FALSE;
 601     //}
 602     //if (sizeof(CHAR) != sizeof(BYTE))
 603     //{
 604     //    free(lpReadContentByUTF8);
 605     //    ::CloseHandle(hUtf8File);
 606     //    return FALSE;
 607     //}
 608     //cchReadContentByUTF8 = cbReadContentByUTF8;
 609 
 610 
 611     ////transform encode
 612     //LPWSTR lpWriteContentByUTF16 = NULL;
 613     //DWORD cchWriteContentByUTF16 = 0;
 614     //DWORD cbWriteContentByUTF16 = 0;
 615     //DWORD cbPreWriteContentByUTF16 = 0;
 616 
 617     //cbWriteContentByUTF16 = cchReadContentByUTF8 * 2;
 618     //cchWriteContentByUTF16 = cchReadContentByUTF8;
 619     //lpWriteContentByUTF16 = (WCHAR *)malloc(cbWriteContentByUTF16);
 620     //if (NULL == lpWriteContentByUTF16)
 621     //{
 622     //    printf_s("malloc error\n");
 623     //    free(lpReadContentByUTF8);
 624     //    ::CloseHandle(hUtf8File);
 625     //    return FALSE;
 626     //}
 627     //ZeroMemory(lpWriteContentByUTF16, cbWriteContentByUTF16);
 628     //if (0 == MultiByteToWideChar(CP_UTF8, 0, lpReadContentByUTF8, cbReadContentByUTF8, lpWriteContentByUTF16, cchWriteContentByUTF16))
 629     //{
 630     //    printf_s("transform error\n");
 631     //    free(lpReadContentByUTF8);
 632     //    free(lpWriteContentByUTF16);
 633     //    ::CloseHandle(hUtf8File);
 634     //    return FALSE;
 635     //}
 636 
 637 
 638     ////write UTF16LE encode file content
 639     //hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 640     //if (INVALID_HANDLE_VALUE == hUtf16leFile)
 641     //{
 642     //    printf("Terminal failure: Unable to write to file.\n");
 643     //    free(lpReadContentByUTF8);
 644     //    free(lpWriteContentByUTF16);
 645     //    ::CloseHandle(hUtf8File);
 646     //    return FALSE;
 647     //}
 648     //for (int i = 0; i != cbWriteContentByUTF16 - 1; ++i)
 649     //{
 650     //    if (0 == lpWriteContentByUTF16[i] && 0 == lpWriteContentByUTF16[i + 1])
 651     //    {
 652     //        cbWriteContentByUTF16 = i;
 653     //        break;
 654     //    }
 655     //}
 656     ////////////////////////////////////////////////////////////////////////////
 657 
 658     ////std::wstring wstrText = L"output to utf8 with BOM.\r\n输出到utf8带BOM的文件中。\r\nengli  sh";
 659     ////int lgText = wstrText.length();
 660     ////int lgText2 = wstrText.size();
 661     ////std::cout << lgText << "" << lgText2 << std::endl;
 662 
 663     ////////////////////////////////////////////////////////////////////////////
 664     //SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
 665     //if (FALSE == WriteFile(hUtf16leFile, lpWriteContentByUTF16, cbWriteContentByUTF16 * sizeof(WCHAR), &cbPreWriteContentByUTF16, NULL))
 666     //{
 667     //    int errLogNumber = GetLastError();
 668     //    printf_s("error number:%d\n", errLogNumber);
 669     //    free(lpReadContentByUTF8);
 670     //    free(lpWriteContentByUTF16);
 671     //    ::CloseHandle(hUtf16leFile);
 672     //    ::CloseHandle(hUtf8File);
 673     //    return FALSE;
 674     //}
 675 
 676 
 677     ////release resource
 678     //free(lpReadContentByUTF8);
 679     //free(lpWriteContentByUTF16);
 680     //::CloseHandle(hUtf16leFile);
 681     //::CloseHandle(hUtf8File);
 682 
 683     //return TRUE;
 684 
 685 }
 686 
 687 BOOL Utf8FileToUtf8NoBOMFile(CONST LPTSTR lpUtf8File, CONST LPTSTR lpUtf8NoBOMFile)
 688 {
 689     HANDLE hUtf8NoBOMFile = NULL;
 690     HANDLE hUtf8File = NULL;
 691 
 692 
 693     //create file
 694     hUtf8File = ::CreateFile(lpUtf8File, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 695     if (INVALID_HANDLE_VALUE == hUtf8File)
 696     {
 697         int errLogNumber = GetLastError();
 698         printf_s("error number:%d\n", errLogNumber);
 699         return FALSE;
 700     }
 701 
 702 
 703     //read UTF8 encode file content
 704     LPSTR lpReadContentByUTF8 = NULL;
 705     DWORD cbReadContentByUTF8 = 0;
 706     DWORD cbPreReadContentByUTF8 = 0;
 707     DWORD cchReadContentByUTF8 = 0;
 708 
 709     cbReadContentByUTF8 = SetFilePointer(hUtf8File, 0, NULL, FILE_END);
 710     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF8)
 711     {
 712         int errLogNumber = GetLastError();
 713         printf_s("error number:%d\n", errLogNumber);
 714         ::CloseHandle(hUtf8File);
 715         return FALSE;
 716     }
 717     lpReadContentByUTF8 = (CHAR *)malloc(cbReadContentByUTF8);
 718     if (NULL == lpReadContentByUTF8)
 719     {
 720         printf_s("malloc error\n");
 721         ::CloseHandle(hUtf8File);
 722         return FALSE;
 723     }
 724     ZeroMemory(lpReadContentByUTF8, cbReadContentByUTF8);
 725     SetFilePointer(hUtf8File, 0, NULL, FILE_BEGIN);
 726     if (FALSE == ReadFile(hUtf8File, lpReadContentByUTF8, cbReadContentByUTF8, &cbPreReadContentByUTF8, NULL))
 727     {
 728         int errLogNumber = GetLastError();
 729         printf_s("error number:%d\n", errLogNumber);
 730         free(lpReadContentByUTF8);
 731         ::CloseHandle(hUtf8File);
 732         return FALSE;
 733     }
 734     if (sizeof(CHAR) != sizeof(BYTE))
 735     {
 736         free(lpReadContentByUTF8);
 737         ::CloseHandle(hUtf8File);
 738         return FALSE;
 739     }
 740     cchReadContentByUTF8 = cbReadContentByUTF8;
 741     
 742 
 743     //write UTF8NoBOM encode file content
 744     LPSTR lpWriteContentByUTF8NoBOM = NULL;
 745     DWORD cbWriteContentByUTF8NoBOM = 0;
 746     DWORD cbPreWriteContentByUTF8NoBOM = 0;
 747     DWORD cchWriteContentByUTF8NoBOM = 0;
 748 
 749     cbWriteContentByUTF8NoBOM = cbReadContentByUTF8 - UTF8_SIGN;
 750     lpWriteContentByUTF8NoBOM = (CHAR *)malloc(cbWriteContentByUTF8NoBOM);
 751     if (NULL == lpWriteContentByUTF8NoBOM)
 752     {
 753         printf_s("malloc error\n");
 754         free(lpReadContentByUTF8);
 755         ::CloseHandle(hUtf8File);
 756         return FALSE;
 757     }
 758     ZeroMemory(lpWriteContentByUTF8NoBOM, cbWriteContentByUTF8NoBOM);
 759 
 760     CopyMemory(lpWriteContentByUTF8NoBOM, lpReadContentByUTF8 + UTF8_SIGN, cbWriteContentByUTF8NoBOM);
 761 
 762     hUtf8NoBOMFile = ::CreateFile(lpUtf8NoBOMFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 763     if (INVALID_HANDLE_VALUE == hUtf8NoBOMFile)
 764     {
 765         printf("Terminal failure: Unable to write to file.\n");
 766         free(lpReadContentByUTF8);
 767         free(lpWriteContentByUTF8NoBOM);
 768         ::CloseHandle(hUtf8File);
 769         return FALSE;
 770     }
 771     SetFilePointer(hUtf8NoBOMFile, 0, NULL, FILE_BEGIN);
 772     if (FALSE == WriteFile(hUtf8NoBOMFile, lpWriteContentByUTF8NoBOM, cbWriteContentByUTF8NoBOM, &cbPreWriteContentByUTF8NoBOM, NULL))
 773     {
 774         int errLogNumber = GetLastError();
 775         printf_s("error number:%d\n", errLogNumber);
 776         free(lpReadContentByUTF8);
 777         free(lpWriteContentByUTF8NoBOM);
 778         ::CloseHandle(hUtf8NoBOMFile);
 779         ::CloseHandle(hUtf8File);
 780         return FALSE;
 781     }
 782 
 783 
 784     //release resource
 785     free(lpReadContentByUTF8);
 786     free(lpWriteContentByUTF8NoBOM);
 787     ::CloseHandle(hUtf8NoBOMFile);
 788     ::CloseHandle(hUtf8File);
 789 
 790     return TRUE;
 791 
 792 }
 793 
 794 BOOL Utf8NoBOMFileToUtf8File(CONST LPTSTR lpUtf8NoBOMFile, CONST LPTSTR lpUtf8File)
 795 {
 796     HANDLE hUtf8NoBOMFile = NULL;
 797     HANDLE hUtf8File = NULL;
 798 
 799 
 800     //create file
 801     hUtf8NoBOMFile = ::CreateFile(lpUtf8NoBOMFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 802     if (INVALID_HANDLE_VALUE == hUtf8NoBOMFile)
 803     {
 804         int errLogNumber = GetLastError();
 805         printf_s("error number:%d\n", errLogNumber);
 806         return FALSE;
 807     }
 808 
 809 
 810     //read UTF8 encode file content
 811     LPSTR lpReadContentByUTF8NoBOM = NULL;
 812     DWORD cbReadContentByUTF8NoBOM = 0;
 813     DWORD cbPreReadContentByUTF8NoBOM = 0;
 814     DWORD cchReadContentByUTF8NoBOM = 0;
 815 
 816     cbReadContentByUTF8NoBOM = SetFilePointer(hUtf8NoBOMFile, 0, NULL, FILE_END);
 817     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF8NoBOM)
 818     {
 819         int errLogNumber = GetLastError();
 820         printf_s("error number:%d\n", errLogNumber);
 821         ::CloseHandle(hUtf8NoBOMFile);
 822         return FALSE;
 823     }
 824     lpReadContentByUTF8NoBOM = (CHAR *)malloc(cbReadContentByUTF8NoBOM);
 825     if (NULL == lpReadContentByUTF8NoBOM)
 826     {
 827         printf_s("malloc error\n");
 828         ::CloseHandle(hUtf8NoBOMFile);
 829         return FALSE;
 830     }
 831     ZeroMemory(lpReadContentByUTF8NoBOM, cbReadContentByUTF8NoBOM);
 832     SetFilePointer(hUtf8NoBOMFile, 0, NULL, FILE_BEGIN);
 833     if (FALSE == ReadFile(hUtf8NoBOMFile, lpReadContentByUTF8NoBOM, cbReadContentByUTF8NoBOM, &cbPreReadContentByUTF8NoBOM, NULL))
 834     {
 835         int errLogNumber = GetLastError();
 836         printf_s("error number:%d\n", errLogNumber);
 837         free(lpReadContentByUTF8NoBOM);
 838         ::CloseHandle(hUtf8NoBOMFile);
 839         return FALSE;
 840     }
 841     if (sizeof(CHAR) != sizeof(BYTE))
 842     {
 843         free(lpReadContentByUTF8NoBOM);
 844         ::CloseHandle(hUtf8NoBOMFile);
 845         return FALSE;
 846     }
 847     cchReadContentByUTF8NoBOM = cbReadContentByUTF8NoBOM;
 848 
 849 
 850     //write UTF8NoBOM encode file content
 851     LPSTR lpWriteContentByUTF8 = NULL;
 852     DWORD cbWriteContentByUTF8 = 0;
 853     DWORD cbPreWriteContentByUTF8 = 0;
 854     DWORD cchWriteContentByUTF8 = 0;
 855 
 856     cbWriteContentByUTF8 = cbReadContentByUTF8NoBOM + UTF8_SIGN;
 857     lpWriteContentByUTF8 = (CHAR *)malloc(cbWriteContentByUTF8);
 858     if (NULL == lpWriteContentByUTF8)
 859     {
 860         printf_s("malloc error\n");
 861         free(lpReadContentByUTF8NoBOM);
 862         ::CloseHandle(hUtf8NoBOMFile);
 863         return FALSE;
 864     }
 865     ZeroMemory(lpWriteContentByUTF8, cbWriteContentByUTF8);
 866 
 867     lpWriteContentByUTF8[0] = 0xef;
 868     lpWriteContentByUTF8[1] = 0xbb;
 869     lpWriteContentByUTF8[2] = 0xbf;
 870     CopyMemory(lpWriteContentByUTF8 + UTF8_SIGN, lpReadContentByUTF8NoBOM, cbWriteContentByUTF8 - UTF8_SIGN);
 871 
 872     hUtf8File = ::CreateFile(lpUtf8File, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 873     if (INVALID_HANDLE_VALUE == hUtf8File)
 874     {
 875         printf("Terminal failure: Unable to write to file.\n");
 876         free(lpWriteContentByUTF8);
 877         free(lpReadContentByUTF8NoBOM);
 878         ::CloseHandle(hUtf8NoBOMFile);
 879         return FALSE;
 880     }
 881     SetFilePointer(hUtf8File, 0, NULL, FILE_BEGIN);
 882     if (FALSE == WriteFile(hUtf8File, lpWriteContentByUTF8, cbWriteContentByUTF8, &cbPreWriteContentByUTF8, NULL))
 883     {
 884         int errLogNumber = GetLastError();
 885         printf_s("error number:%d\n", errLogNumber);
 886         free(lpWriteContentByUTF8);
 887         free(lpReadContentByUTF8NoBOM);
 888         ::CloseHandle(hUtf8NoBOMFile);
 889         ::CloseHandle(hUtf8File);
 890         return FALSE;
 891     }
 892 
 893 
 894     //release resource
 895     free(lpWriteContentByUTF8);
 896     free(lpReadContentByUTF8NoBOM);
 897     ::CloseHandle(hUtf8NoBOMFile);
 898     ::CloseHandle(hUtf8File);
 899 
 900     return TRUE;
 901 
 902 }
 903 
 904 BOOL Utf16leFileToUtf16beFile(CONST LPTSTR lpUtf16leFile, CONST LPTSTR lpUtf16beFile)
 905 {
 906     HANDLE hUtf16leFile = NULL;
 907     HANDLE hUtf16beFile = NULL;
 908 
 909 
 910     //create file
 911     hUtf16leFile = ::CreateFile(lpUtf16leFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 912     if (INVALID_HANDLE_VALUE == hUtf16leFile)
 913     {
 914         int errLogNumber = GetLastError();
 915         printf_s("error number:%d\n", errLogNumber);
 916         return FALSE;
 917     }
 918 
 919 
 920     //read UTF16le encode file content
 921     LPBYTE lpReadContentByUTF16le = NULL;
 922     DWORD cbReadContentByUTF16le = 0;
 923     DWORD cbPreReadContentByUTF16le = 0;
 924     DWORD cchReadContentByUTF16le = 0;
 925 
 926     cbReadContentByUTF16le = SetFilePointer(hUtf16leFile, 0, NULL, FILE_END);
 927     if (INVALID_SET_FILE_POINTER == cbReadContentByUTF16le)
 928     {
 929         int errLogNumber = GetLastError();
 930         printf_s("error number:%d\n", errLogNumber);
 931         ::CloseHandle(hUtf16leFile);
 932         return FALSE;
 933     }
 934     if (0 != cbReadContentByUTF16le % 2)
 935     {
 936         printf_s("read byte error\n");
 937         ::CloseHandle(hUtf16leFile);
 938         return FALSE;
 939     }
 940     lpReadContentByUTF16le = (BYTE *)malloc(cbReadContentByUTF16le);
 941     if (NULL == lpReadContentByUTF16le)
 942     {
 943         printf_s("malloc error\n");
 944         ::CloseHandle(hUtf16leFile);
 945         return FALSE;
 946     }
 947     ZeroMemory(lpReadContentByUTF16le, cbReadContentByUTF16le);
 948     SetFilePointer(hUtf16leFile, 0, NULL, FILE_BEGIN);
 949     if (FALSE == ReadFile(hUtf16leFile, lpReadContentByUTF16le, cbReadContentByUTF16le, &cbPreReadContentByUTF16le, NULL))
 950     {
 951         int errLogNumber = GetLastError();
 952         printf_s("error number:%d\n", errLogNumber);
 953         free(lpReadContentByUTF16le);
 954         ::CloseHandle(hUtf16leFile);
 955         return FALSE;
 956     }
 957     //std::wstring wstrText(lpReadContentByUTF16le);
 958     //printf("%s\n", wstrText);
 959     if (sizeof(WCHAR) != sizeof(BYTE)*2)
 960     {
 961         free(lpReadContentByUTF16le);
 962         ::CloseHandle(hUtf16leFile);
 963         return FALSE;
 964     }
 965 
 966 
 967     //write UTF8NoBOM encode file content
 968     LPBYTE lpWriteContentByUTF16be = NULL;
 969     DWORD cbWriteContentByUTF16be = 0;
 970     DWORD cbPreWriteContentByUTF16be = 0;
 971     DWORD cchWriteContentByUTF16be = 0;
 972 
 973     cbWriteContentByUTF16be = cbReadContentByUTF16le;
 974     lpWriteContentByUTF16be = (BYTE *)malloc(cbWriteContentByUTF16be);
 975     if (NULL == lpWriteContentByUTF16be)
 976     {
 977         printf_s("malloc error\n");
 978         free(lpReadContentByUTF16le);
 979         ::CloseHandle(hUtf16leFile);
 980         return FALSE;
 981     }
 982     ZeroMemory(lpWriteContentByUTF16be, cbWriteContentByUTF16be);
 983 
 984     CopyMemory(lpWriteContentByUTF16be, lpReadContentByUTF16le, cbWriteContentByUTF16be);
 985 
 986     for (DWORD i = 0; i < cbWriteContentByUTF16be; i += 2)//每两值交换
 987     {
 988         lpWriteContentByUTF16be[i] = lpWriteContentByUTF16be[i] ^ lpWriteContentByUTF16be[i + 1];
 989         lpWriteContentByUTF16be[i + 1] = lpWriteContentByUTF16be[i + 1] ^ lpWriteContentByUTF16be[i];
 990         lpWriteContentByUTF16be[i] = lpWriteContentByUTF16be[i] ^ lpWriteContentByUTF16be[i + 1];
 991         //BYTE hex_ = 0x0;
 992         //hex_ = lpWriteContentByUTF16be[i];
 993         ////printf("%x\n", lpWriteContentByUTF16be[i]);
 994         //lpWriteContentByUTF16be[i] = lpWriteContentByUTF16be[i + 1];
 995         //lpWriteContentByUTF16be[i + 1] = hex_;
 996     }
 997 
 998     hUtf16beFile = ::CreateFile(lpUtf16beFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 999     if (INVALID_HANDLE_VALUE == hUtf16beFile)
1000     {
1001         printf("Terminal failure: Unable to write to file.\n");
1002         free(lpWriteContentByUTF16be);
1003         free(lpReadContentByUTF16le);
1004         ::CloseHandle(hUtf16leFile);
1005         return FALSE;
1006     }
1007     SetFilePointer(hUtf16beFile, 0, NULL, FILE_BEGIN);
1008     if (FALSE == WriteFile(hUtf16beFile, lpWriteContentByUTF16be, cbWriteContentByUTF16be, &cbPreWriteContentByUTF16be, NULL))
1009     {
1010         int errLogNumber = GetLastError();
1011         printf_s("error number:%d\n", errLogNumber);
1012         free(lpWriteContentByUTF16be);
1013         free(lpReadContentByUTF16le);
1014         ::CloseHandle(hUtf16leFile);
1015         ::CloseHandle(hUtf16beFile);
1016         return FALSE;
1017     }
1018 
1019 
1020     //release resource
1021     free(lpWriteContentByUTF16be);
1022     free(lpReadContentByUTF16le);
1023     ::CloseHandle(hUtf16leFile);
1024     ::CloseHandle(hUtf16beFile);
1025 
1026     return TRUE;
1027 
1028 }
1029 
1030 BOOL Utf16beFileToUtf16leFile(CONST LPTSTR lpUtf16beFile, CONST LPTSTR lpUtf16leFile)
1031 {
1032     return Utf16leFileToUtf16beFile(lpUtf16beFile, lpUtf16leFile);
1033 }
1034 
1035 
1036 
1037 
1038 enum FileCodeType
1039 {
1040     OTHER = 0,
1041     UTF16LE,
1042     UTF8,
1043     UTF8_NO_BOM,
1044     UTF16BE
1045 };
1046 
1047 //************************************
1048 // Method:    CodeFileAToCodeFileB
1049 // FullName:  CodeFileAToCodeFileB
1050 // Access:    public 
1051 // Returns:   bool
1052 // Qualifier:读取指定编码文件A的内容输出到指定编码文件B
1053 // Parameter: CONST LPTSTR lpFileA：输入文件
1054 // Parameter: CONST FileCodeType wCodeTypeA：输入文件类型（包括：utf16le\utf16be\utf8\ANSI）
1055 // Parameter: CONST LPTSTR lpFileB：输出文件
1056 // Parameter: CONST FileCodeType wCodeTypeB：输出文件类型（包括：utf16le\utf16be\utf8\utf8 without BOM\ANSI）
1057 //************************************
1058 BOOL CodeFileAToCodeFileB(CONST LPTSTR lpFileA, CONST FileCodeType emCodeTypeA, CONST LPTSTR lpFileB, CONST FileCodeType emCodeTypeB)
1059 {
1060     BOOL bSUCCESS = FALSE;
1061     HANDLE hFileA = NULL;
1062     HANDLE hFileB = NULL;
1063 
1064     if (OTHER == emCodeTypeA || OTHER == emCodeTypeB)
1065     {
1066         return bSUCCESS;
1067     }
1068     if (NULL == lpFileA || NULL == lpFileB)
1069     {
1070         return bSUCCESS;
1071     }
1072 
1073     switch (emCodeTypeA)
1074     {
1075         case UTF16LE:
1076         {
1077             switch (emCodeTypeB)
1078             {
1079                 case UTF16BE:
1080                 {
1081                     return Utf16leFileToUtf16beFile(lpFileA, lpFileB);
1082                 }
1083                     break;
1084                 case UTF8:
1085                 {
1086                     return Utf16leFileToUtf8File(lpFileA, lpFileB);
1087                 }
1088                     break;
1089                 case UTF8_NO_BOM:
1090                 {
1091                     return Utf16leFileToUtf8NoBOMFile2(lpFileA, lpFileB);
1092                 }
1093                     break;
1094                 default:;
1095             }
1096         }
1097             break;
1098         case UTF8:
1099         {
1100             switch (emCodeTypeB)
1101             {
1102                 case UTF16LE:
1103                 {
1104                     return Utf8FileToUtf16leFile(lpFileA, lpFileB);
1105                 }
1106                 break;
1107                 case UTF16BE:
1108                 {
1109 
1110                 }
1111                 break;
1112                 case UTF8_NO_BOM:
1113                 {
1114                     return Utf8FileToUtf8NoBOMFile(lpFileA, lpFileB);
1115                 }
1116                 break;
1117                 default:;
1118             }
1119         }
1120             break;
1121         case UTF8_NO_BOM:
1122         {
1123             switch (emCodeTypeB)
1124             {
1125                 case UTF16LE:
1126                 {
1127                     return Utf8NoBOMFileToUtf16leFile(lpFileA, lpFileB);
1128                 }
1129                 break;
1130                 case UTF8:
1131                 {
1132                     return Utf8NoBOMFileToUtf8File(lpFileA, lpFileB);
1133                 }
1134                 break;
1135                 case UTF16BE:
1136                 {
1137 
1138                 }
1139                 break;
1140                 default:;
1141             }
1142         }
1143             break;
1144         case UTF16BE:
1145         {
1146             switch (emCodeTypeB)
1147             {
1148                 case UTF16LE:
1149                 {
1150                     return Utf16beFileToUtf16leFile(lpFileA, lpFileB);
1151                 }
1152                 break;
1153                 case UTF8:
1154                 {
1155                     
1156                 }
1157                 break;
1158                 case UTF8_NO_BOM:
1159                 {
1160 
1161                 }
1162                 break;
1163                 default:;
1164             }
1165         }
1166         break;
1167         default:;
1168     }
1169 
1170     return bSUCCESS = TRUE;
1171 }
1172 
1173 
1174 
1175 
1176 void test__BYTETOCHAR();
1177 void test__BYTETOWCHAR();
1178 
1179 int _tmain(int argc, _TCHAR* argv[])
1180 {
1181 
1182 
1183 
1184     CONST LPTSTR lpInputFileUTF8 = TEXT("input-utf8.txt");
1185     CONST LPTSTR lpInputFileUTF16le = TEXT("input-utf16le.txt");
1186     CONST LPTSTR lpInputFileUTF16be = TEXT("input-utf16be.txt");
1187     CONST LPTSTR lpInputFileUTF8NoBOM = TEXT("input-utf8-no-bom.txt");
1188 
1189     CONST LPTSTR lpOutputFileUTF8NoBOM = TEXT("output-utf8-no-bom.txt");
1190     CONST LPTSTR lpOutputFileUTF8 = TEXT("output-utf8.txt");
1191     CONST LPTSTR lpOutputFileUTF16le = TEXT("output-utf16le.txt");
1192     CONST LPTSTR lpOutputFileUTF16be = TEXT("output-utf16be.txt");
1193 
1194 
1195     //CodeFileAToCodeFileB(lpInputFileUTF16le, UTF16LE, lpOutputFileUTF8, UTF8);
1196     //CodeFileAToCodeFileB(lpInputFileUTF16le, UTF16LE, lpOutputFileUTF8NoBOM, UTF8_NO_BOM);
1197     //CodeFileAToCodeFileB(lpInputFileUTF8, UTF8, lpOutputFileUTF8NoBOM, UTF8_NO_BOM);
1198     //CodeFileAToCodeFileB(lpInputFileUTF8, UTF8, lpOutputFileUTF16le, UTF16LE);
1199     //CodeFileAToCodeFileB(lpInputFileUTF8NoBOM, UTF8_NO_BOM, lpOutputFileUTF16le, UTF16LE);
1200     //CodeFileAToCodeFileB(lpInputFileUTF8NoBOM, UTF8_NO_BOM, lpOutputFileUTF8, UTF8);
1201     //CodeFileAToCodeFileB(lpInputFileUTF16le, UTF16LE, lpOutputFileUTF16be, UTF16BE);
1202     //CodeFileAToCodeFileB(lpInputFileUTF16be, UTF16BE, lpOutputFileUTF16le, UTF16LE);
1203 
1204 
1205 
1206 
1207     //test__BYTETOCHAR();
1208     test__BYTETOWCHAR();
1209 
1210 
1211     return 0;
1212 }
1213 
1214 
1215 
1216 
1217 
1218 void test__BYTETOCHAR()
1219 {
1220     //TEXT("output to utf8 with BOM.\r\n输出到utf8带BOM的文件中。\r\nengli  sh");
1221     HANDLE hFileA = NULL;
1222     HANDLE hFileB = NULL;
1223     LPBYTE lpByte = NULL;
1224     INT cbByte = 0;
1225     INT cchByte = 0;
1226     LPSTR lpChar = NULL;
1227     INT cbChar = 0;
1228     INT cchChar = 0;
1229 
1230     hFileA = ::CreateFile(TEXT("input.txt"), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1231     if (INVALID_HANDLE_VALUE == hFileA) return;
1232     cchByte = cbByte = SetFilePointer(hFileA, 0, NULL, FILE_END);
1233     if (INVALID_SET_FILE_POINTER  == cbByte) return;
1234     lpByte = (BYTE *)malloc(cbByte);
1235     if (NULL == lpByte) return;
1236     ZeroMemory(lpByte, cbByte);
1237     SetFilePointer(hFileA, 0, NULL, FILE_BEGIN);
1238     if (FALSE == ReadFile(hFileA, lpByte, cbByte, NULL, NULL)) return;
1239 
1240     cchChar = cbChar = cbByte;
1241     lpChar = (CHAR *)malloc(cbChar);
1242     if (NULL == lpChar) return;
1243     ZeroMemory(lpChar, cbChar);
1244 
1245     for (INT i = 0; i != cbByte; ++i)
1246     {
1247         lpChar[i] = (CHAR)lpByte[i];
1248     }
1249 
1250     //////////////////////////////////////////////////////////////////////////
1251 
1252     std::string strText(lpChar);
1253     printf("%s\n", strText.c_str());
1254 
1255     //////////////////////////////////////////////////////////////////////////
1256 
1257     hFileB = ::CreateFile(TEXT("output.txt"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1258     SetFilePointer(hFileB, 0, NULL, FILE_BEGIN);
1259     if (FALSE == WriteFile(hFileB, lpChar, cbChar, NULL, NULL)) return;
1260 
1261     free(lpByte);
1262     free(lpChar);
1263     CloseHandle(hFileA);
1264     CloseHandle(hFileB);
1265 }
1266 void test__BYTETOWCHAR()
1267 {
1268     HANDLE hFileA = NULL;
1269     HANDLE hFileB = NULL;
1270     LPBYTE lpByte = NULL;
1271     INT cbByte = 0;
1272     INT cchByte = 0;
1273     LPWSTR lpWChar = NULL;
1274     INT cbWChar = 0;
1275     INT cchWChar = 0;
1276 
1277     hFileA = ::CreateFile(TEXT("input.txt"), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1278     if (INVALID_HANDLE_VALUE == hFileA) return;
1279     cchByte = cbByte = SetFilePointer(hFileA, 0, NULL, FILE_END);
1280     if (INVALID_SET_FILE_POINTER == cbByte) return;
1281     lpByte = (BYTE *)malloc(cbByte);
1282     if (NULL == lpByte) return;
1283     ZeroMemory(lpByte, cbByte);
1284     SetFilePointer(hFileA, 0, NULL, FILE_BEGIN);
1285     if (FALSE == ReadFile(hFileA, lpByte, cbByte, NULL, NULL)) return;
1286 
1287     cbWChar = cbByte;
1288     cchWChar = cbWChar / sizeof(WCHAR);
1289     lpWChar = (WCHAR *)malloc(cbWChar);
1290     if (NULL == lpWChar) return;
1291     ZeroMemory(lpWChar, cbWChar);
1292 
1293     CopyMemory(lpWChar, lpByte, cbWChar);
1294 
1295     //////////////////////////////////////////////////////////////////////////
1296 
1297     std::wstring strText(lpWChar);
1298     wprintf(L"%s\n", strText.c_str());
1299 
1300     //////////////////////////////////////////////////////////////////////////
1301 
1302     hFileB = ::CreateFile(TEXT("output.txt"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1303     SetFilePointer(hFileB, 0, NULL, FILE_BEGIN);
1304     if (FALSE == WriteFile(hFileB, lpWChar, cbWChar, NULL, NULL)) return;
1305 
1306     free(lpByte);
1307     free(lpWChar);
1308     CloseHandle(hFileA);
1309     CloseHandle(hFileB);
1310 }
1311 void test_CHARTOBYTE()
1312 {
1313 
1314 }
1315 void test__WCHARTOBYTE()
1316 {
1317 
1318 }