Lea el archivo Unicode UTF-8 en wstring

Question

¿Cómo puedo leer un archivo Unicode (UTF-8) en wstring (s) en la plataforma de Windows?

Answer 1

Respondió esta pregunta en Confused about C++'s std::wstring, UTF-16, UTF-8 and displaying strings in a windows GUI. En resumen, wstring se basa en el estándar UCS-2, que es el predecesor de UTF-16. Este es un estándar estrictamente de dos bytes. Creo que esto cubre el árabe.

Answer 2

Aquí es una función específica de la plataforma para Windows solamente:

size_t GetSizeOfFile(const std::wstring& path) 
{ 
    struct _stat fileinfo; 
    _wstat(path.c_str(), &fileinfo); 
    return fileinfo.st_size; 
} 

std::wstring LoadUtf8FileToString(const std::wstring& filename) 
{ 
    std::wstring buffer;   // stores file contents 
    FILE* f = _wfopen(filename.c_str(), L"rtS, ccs=UTF-8"); 

    // Failed to open file 
    if (f == NULL) 
    { 
     // ...handle some error... 
     return buffer; 
    } 

    size_t filesize = GetSizeOfFile(filename); 

    // Read entire file contents in to memory 
    if (filesize > 0) 
    { 
     buffer.resize(filesize); 
     size_t wchars_read = fread(&(buffer.front()), sizeof(wchar_t), filesize, f); 
     buffer.resize(wchars_read); 
     buffer.shrink_to_fit(); 
    } 

    fclose(f); 

    return buffer; 
} 

uso de este modo:

std::wstring mytext = LoadUtf8FileToString(L"C:\\MyUtf8File.txt"); 

Nota todo el archivo se carga en la memoria, por lo que puede que no desee utilizarlo para archivos muy grandes

Answer 3

De acuerdo con un comentario de @Hans Passant, la forma más sencilla es usar _wfopen_s. Abra el archivo con el modo rt, ccs=UTF-8.

Aquí hay otra solución pura de C++ que funciona al menos con VC++ 2010:

#include <locale> 
#include <codecvt> 
#include <string> 
#include <fstream> 
#include <cstdlib> 

int main() { 
    const std::locale empty_locale = std::locale::empty(); 
    typedef std::codecvt_utf8<wchar_t> converter_type; 
    const converter_type* converter = new converter_type; 
    const std::locale utf8_locale = std::locale(empty_locale, converter); 
    std::wifstream stream(L"test.txt"); 
    stream.imbue(utf8_locale); 
    std::wstring line; 
    std::getline(stream, line); 
    std::system("pause"); 
} 

excepción de locale::empty() (aquí locale::global() podría funcionar también) y la sobrecarga de wchar_t* del basic_ifstream constructor, esto aún debe ser bastante estándar-obediente (donde "estándar" significa C++ 0x, por supuesto).

Answer 4

Con el apoyo de C++ 11, puede utilizar std::codecvt_utf8 facetque encapsula la conversión entre una cadena de codificación UTF-8 bytes y UCS2 o UCS4 cadena de caracteres y que se puede utilizar para leer y escribir archivos UTF-8, tanto texto y binario

Para utilizar facet por lo general crea locale objectque encapsula la información específica de la cultura como un conjunto de facetas que definen colectivamente un entorno localizado específica. Una vez que tenga un objeto local, puede imbue su búfer de la secuencia con ella:

#include <sstream> 
#include <fstream> 
#include <codecvt> 

std::wstring readFile(const char* filename) 
{ 
    std::wifstream wif(filename); 
    wif.imbue(std::locale(std::locale::empty(), new std::codecvt_utf8<wchar_t>)); 
    std::wstringstream wss; 
    wss << wif.rdbuf(); 
    return wss.str(); 
} 

que puede ser utilizado como esto:

std::wstring wstr = readFile("a.txt"); 

alternativa, puede configurar the global C++ locale antes de trabajar con corrientes de cuerda, que hace que todas las llamadas futuras al constructor predeterminado std::locale devuelvan una copia de la configuración regional global de C++ (no es necesario imbuir de manera explícita las memorias intermedias de la secuencia):

std::locale::global(std::locale(std::locale::empty(), new std::codecvt_utf8<wchar_t>)); 

Answer 5

Esto es un poco crudo, pero ¿qué hay de leer el archivo como viejos bytes sin formato y luego convertir el búfer de bytes a wchar_t *?

Algo así como:

#include <iostream> 
#include <fstream> 
std::wstring ReadFileIntoWstring(const std::wstring& filepath) 
{ 
    std::wstring wstr; 
    std::ifstream file (filepath.c_str(), std::ios::in|std::ios::binary|std::ios::ate); 
    size_t size = (size_t)file.tellg(); 
    file.seekg (0, std::ios::beg); 
    char* buffer = new char [size]; 
    file.read (buffer, size); 
    wstr = (wchar_t*)buffer; 
    file.close(); 
    delete[] buffer; 
    return wstr; 
} 

Answer 6

#include <iostream> 
#include <fstream> 
#include <string> 
#include <locale> 
#include <cstdlib> 

int main() 
{ 
    std::wifstream wif("filename.txt"); 
    wif.imbue(std::locale("zh_CN.UTF-8")); 

    std::wcout.imbue(std::locale("zh_CN.UTF-8")); 
    std::wcout << wif.rdbuf(); 
}