[C++] Umgang mit Unicode

[Glocke]

Hi,

von meiner SDL-Oberfläche lese ich einen String ein, der Unicode-Zeichen enthält. Diesen will ich per SDL_Net (also via Socket) an die Gegenseite schicken. Da ich mit dem Versenden von Strings bisher Probleme hatte, sende ich zuerst die Länge der Zeichenkette (als unsigned int) und dann jeden char (mit myString[index]) einzeln und lese auf der Gegenseite die entsprechenden Daten und rekonstruiere den String. Allerdings gehen dabei Sonderzeichen wie ß usw. verloren.

Wie gehe ich am besten mit Unicode-Characters um? Im Grunde könnte ich ja den int-Wert des Zeichens schicken und daraus das Zeichen rekonstruieren. Nur weiß ich nicht, wie ich an den Wert komme und wie ich quasi "zurück-caste". Mit normalen char ist das ja kein Problem ^^

Btw verwende ich kein .NET

LG Glocke

[cloidnerux]

Wie gehe ich am besten mit Unicode-Characters um? Im Grunde könnte ich ja den int-Wert des Zeichens schicken und daraus das Zeichen rekonstruieren. Nur weiß ich nicht, wie ich an den Wert komme und wie ich quasi "zurück-caste". Mit normalen char ist das ja kein Problem ^^

Auch ein Unicode-Zeichen ist nur eine Zahl, die etwas repräsentieren soll. Ein char ist auch eine Zahl, aber eben eine kleinere und ein "char" kann nach ASCII nicht so viele Zeichen einnehmen. Was du also machen musst, ist denn UNICDE-String Zahl für Zahl zu senden und zu wieder zu einem string zusammen bauen.

[Glocke]

Soweit so gut, aber wie wandel ich meine Zahl (die ein Unicodezeichen repräsentiert) wieder zum Zeichen zurück? Ein cast zu char hilft da ja nicht.

LG Glocke

[fat-lobyte]

von meiner SDL-Oberfläche lese ich einen String ein, der Unicode-Zeichen enthält. Diesen will ich per SDL_Net (also via Socket) an die Gegenseite schicken. Da ich mit dem Versenden von Strings bisher Probleme hatte, sende ich zuerst die Länge der Zeichenkette (als unsigned int) und dann jeden char (mit myString[index]) einzeln und lese auf der Gegenseite die entsprechenden Daten und rekonstruiere den String. Allerdings gehen dabei Sonderzeichen wie ß usw. verloren.

Bist du sicher, dass das ein Unicode-Problem ist? Wenn deine Oberfläche tatsächlich unicode einliest und die Gegenseite tatsächlich Unicode empfängt, sollte es keine Probleme geben. Ich glaube, es liegt eher daran dass eine der Seiten eine andere Kodierung verwendet. Überprüf mal die einlesefunktionen der SDL bzw. dem was du auf der Gegenseite zum Anzeigen verwendest.

Auch ein Unicode-Zeichen ist nur eine Zahl, die etwas repräsentieren soll.

So ganz einfach ist das nicht. Das stimmt für UTF-32-Kodierte Zeichen, wenn sie aber UTF-8/UTF-16 kodiert sind, könnte es passieren dass sie in mehrere bytes aufgespalten werden, so wird schnell aus einem Zeichen 3 (nicht 2! Das unicode steuerzeichen kommt noch dazu.) bzw 5 Bytes.

[Xin]

Soweit so gut, aber wie wandel ich meine Zahl (die ein Unicodezeichen repräsentiert) wieder zum Zeichen zurück? Ein cast zu char hilft da ja nicht.

Das ist auch nicht nötig, denn eine ASCII-Zeichen ist eine Zahl und ein Unicodezeichen sind eine Reihe von Zahlen.

Bitte gib den String mal Zahl für Zahl aus, zum Beispiel so:

Code: Alles auswählen

char const * text = "Hello World";

unsigned int i=0;
while( text[i] )
{
  printf( "%d. Zeichen: %d\n", i, text[i] );
  i++;
};

Das machst Du auch auf der Empfängerseite.
Kommen die Zahlen identisch an?

[nufan]

Soweit so gut, aber wie wandel ich meine Zahl (die ein Unicodezeichen repräsentiert) wieder zum Zeichen zurück? Ein cast zu char hilft da ja nicht.

Unicode Zeichen sind in SDL keine chars, sondern Uint16.

Einlesen kannst du das grob gesagt so:

Code: Alles auswählen

void readUnicode()
{ 
  SDL_EnableUNICODE( 1 );  
  SDL_EnableKeyRepeat( 400, 30 );

  // ...

  while( !done )
  {
    SDL_WaitEvent( &event );    
    switch( event.type )
    {
      case SDL_KEYDOWN:
                        unkey = event.key.keysym.unicode;
                        mod = event.key.keysym.mod;
                        // Gültige Taste und Strg ist nicht gedrückt.
                        if( unkey != SDLK_UNKNOWN && !(mod & KMOD_CTRL) )
                        {
                   
                          if( unkey == SDLK_BACKSPACE )
                          {
                            // Letztes Zeichen löschen.
                            // ...
                          }           
                          // Enter gedrückt -> Eingabe abbrechen, wenn Zeichen vorhanden sind.
                          else if( (unkey == SDLK_RETURN || unkey == SDLK_KP_ENTER) )
                          {
                            if (i > 0)
                              done = 1;    
                          }
                          // Gültiges Zeichen und es wurden weniger als 15 Zeichen eingegeben.
                          else if( i < 15 && unkey != SDLK_TAB && unkey != SDLK_ESCAPE )
                          {
                            // Zeichen an den Unicode-String (Uint16[]) dranhängen und Ausgabe aktualisieren.
                            // ...
                          }
                        }
                        break;
    }
  }
  
  SDL_EnableKeyRepeat( 0, 30 );
  SDL_EnableUNICODE( 0 );
}

Und darstellen damit:
http://www.libsdl.org/projects/SDL_ttf/ ... html#SEC45

[Glocke]

@Xin: Also auf beiden Seiten stimmt die Reihenfolge

@fat-lobyte: Das was von der Oberfläche eingelesen wird ist Unicode. Gebe ich den string außerdem mit std::cout aus, erscheinen die korrekten Symbole im Terminal. Auf beiden Seite des Sockets verwende ich SDL_Net - somit sollte die Kodierung die gleiche sein.

@nufan: Das Problem ist das Senden via Socket! Einlesen von der Oberfläche funktioniert.

[Xin]

@Xin: Also auf beiden Seiten stimmt die Reihenfolge

Okay, Du empfängst also, was Du sendest.
Heißt, Du kannst das ganze Network-Zeugs als Fehlerquelle ausklammern, Du kannst Dir also überlegen, warum zwei Programme diese Zeichenreihenfolge mal so und mal so interpretieren.

Hast Du beide auf Unicode eingestellt?

Code: Alles auswählen

 SDL_EnableUNICODE( 1 );  

sehe ich bei nufan's Code, fehlt das beim Empfänger?

[fat-lobyte]

@fat-lobyte: Das was von der Oberfläche eingelesen wird ist Unicode. Gebe ich den string außerdem mit std::cout aus, erscheinen die korrekten Symbole im Terminal. Auf beiden Seite des Sockets verwende ich SDL_Net - somit sollte die Kodierung die gleiche sein.

nufan hat geschrieben, dass die eingelesenen Zeichen Uint16 sind, das bedeutet sie sind UTF-16 kodiert.
Wenn du Zeichen mit std::cout ausgibst, wird erwartet, dass die Zeichen UTF-8 kodiert sind. Genau das wird wahrscheinlich das Problem sein.

Du könntest, wenn du auf Windows bist std::wcout verwenden, das verwendet statt char's wchar_t's. wchar_t ist auf Windows 16 Bit groß, auf Linux 32 Bit.

Ansonsten musst du deine Strings irgendwie umkodieren. Dazu kannst du entweder die libicu verwenden, oder wenn du C++11 verwenden kannst, irgendwie mit der String-Konvertierungslibrary: http://en.cppreference.com/w/cpp/string/multibyte

[Glocke]

Wie eingangs gesagt, weiß ich nicht wie ich die einzelnen Unicode-Chars korrekt sende. Wandle ich jeden char des Strings in einen unsigned int um (um den Zahlenwert zu erhalten), bekomme ich ihn auf der Gegenseite nicht wieder zusammengesetzt, weil ich nicht weiß wie. Wie gesagt: Der cast zum char wäre ja Quatsch.

Und nein, auf beiden Seiten ist SDL-seitig Unicode aktiviert. Btw habe ich zu Testzwecken eine Variable mal direkt mit "asßdf" initialisiert. Dabei gibt es beim ß Probleme. Ich hole zeichenweise mit myString[index] die chars, caste die zum unsigned int und schicke die rüber. Für die Zeichenkette sendet er die Zahlen 97 ("a"), 115 ("s"), 4294967235, 4294967199, 100 ("d") und 102 ("f").

/EDIT: ich schau mir mal http://en.cppreference.com/w/cpp/string/multibyte an