Come gestire i valori unicode nelle stringhe JSON?

Question

Sto scrivendo un parser JSON in C++ e sono di fronte a un problema durante l'analisi di stringhe JSON:

La specifica JSON afferma che le stringhe JSON possono contenere caratteri unicode sotto forma di:

"here comes a unicode character: \u05d9 !" 

mio JSON parser tenta di mappare le stringhe JSON su std::string quindi, in genere, un carattere delle stringhe JSON diventa un carattere di std::string. Tuttavia, per quei caratteri Unicode, io davvero non so cosa fare:

devo solo mettere i valori byte prime nel mio std::string in questo modo:

std::string mystr; 
mystr.push_back('\0x05'); 
mystr.push_back('\0xd9'); 

O devo interpretare i due personaggi con un libreria come iconv e memorizzare il risultato codificato UTF-8 nella mia stringa, invece?

Devo usare uno std::wstring per memorizzare tutti i caratteri? Cosa succede allora su * NIX OS in cui wchar_t ha una lunghezza di 4 byte?

Sento che qualcosa non va nelle mie soluzioni ma non riesco a capire cosa. Cosa dovrei fare in quella situazione?

Answer 1

Dopo un po 'di scavo e grazie alla H2CO3's comments e Philipp's comments, finalmente ho potuto capire come questo dovrebbe funzionare:

Leggendo il RFC4627, Sezione 3. Encoding:

3. Codifica

   Il testo JSON DEVE essere codificato in Unicode. La codifica predefinita è
   UTF-8.

   Dal momento che i primi due caratteri di un testo JSON sarà sempre ASCII caratteri [RFC0020], è possibile determinare se un ottetto
   flusso è UTF-8, UTF-16 (BE o LE), o UTF -32 (BE o LE) guardando
   al modello di valori null nei primi quattro ottetti.

   00 00 00 xx UTF-32BE 
       00 xx 00 xx UTF-16BE 
       xx 00 00 00 UTF-32LE 
       xx 00 xx 00 UTF-16LE 
       xx xx xx xx UTF-8 
   

in modo che appaia un ottetto flusso JSON può essere codificato in UTF-8, UTF-16 o UTF-32 (in entrambi i loro BE o LE varianti, per gli ultimi due).

Una volta che sia chiaro, Section 2.5. Strings spiega come gestire quei \uXXXX valori in stringhe JSON:

Qualsiasi carattere può essere sfuggito. Se il carattere è nella Base
Multilingual Plane (U + 0000 a U + FFFF), allora può essere
rappresentato come una sequenza di sei caratteri: un solidus inversa, seguita
dalla lettera minuscola u, seguita da quattro cifre esadecimali che
codificano il punto di codice del carattere. Le lettere esadecimali A anche se
F possono essere maiuscole o minuscole. Ad esempio, una stringa contenente
un solo carattere di solidus inverso può essere rappresentata come
"\ u005C".

Con spiegazioni più complete per caratteri non nello Basic Multilingual Plane.

Per sfuggire un carattere esteso che non è nella base multilingue aereo, il carattere è rappresentato come una sequenza di dodici caratteri,
codificante la coppia di surrogati UTF-16. Ad esempio, una stringa
contenente solo il carattere G (U + 1D11E) può essere rappresentata come
"\ uD834 \ uDD1E".

Spero che questo aiuti.

Answer 2

Se fossi in te, userei std :: string solo per memorizzare UTF-8 e UTF-8. Se il testo JSON in entrata non contiene sequenze \ uXXXX, std :: string può essere utilizzato così com'è, da byte a byte, senza alcuna conversione.

quando si analizza \ uXXXX, si può semplicemente decodificarlo e convertirlo in UTF-8, in modo efficace trattandolo come se fosse vero caratteri UTF-8 al suo posto - questo è ciò che la maggior parte dei parser JSON stanno facendo in ogni caso (libjson di sicuro).

Concesso, con questo approccio, leggere JSON con \ uXXXX e scaricarlo immediatamente utilizzando la libreria è probabile che perda le sequenze \ uXXXX e le sostituisca con le loro effettive rappresentazioni UTF-8, ma a chi importa davvero? In definitiva, il risultato netto è ancora esattamente lo stesso.