4. #define WCHAR String

#define WCHAR String

  • M

    Hi Leser,
    in meiner App verwende ich teilweise vordefinierte Strings wie z.B.

    #define CSZ_STRING  "Hallo Welt"

    Wird bei einer Funktion ein char-String benötigt, so setze ich z.B.

    strcpy( csz_ziel, CSZ_STRING );

    ein. Hier wird ein char-String aus CSZ_STRING gebildet.

    Wird bei einer Funktion ein TCHAR-String benötigt, so setze ich z.B.

    _tcscpy( tcsz_ziel, TEXT(CSZ_STRING) );

    ein.
    Je nach Unicode Einstellung des Compilers wird entweder ein char- oder ein wchar-String daraus gebildet.
    Soweit, sogut.

    Wird bei einer Funktion ein WCHAR-String benötigt, dann schaffe ich es nicht, den Compiler zu überzeugen, ein wchar-String aus CSZ_STRING zu bilden 😕 , wie beispielsweise so:

    wcscpy( wcsz_ziel, L(CSZ_STRING) );
//Hier meldet der Compiler: error C2065: 'L': nichtdeklarierter Bezeichner

    oder auch so:

    wcscpy( wcsz_ziel, L##(CSZ_STRING) );
//Hier meldet der Compiler: error C2014: Präprozessoer-Direktive muss mit dem ersten Zeichen in der Zeile beginnen
//                          error C2065: 'L': nichtdeklarierter Bezeichner

    Ich hoffe Ihr könnt mir da weiterhelfen?
    Martin

    [EDIT:]
    Sorry, habs vergessen: Der verwendete Compiler ist Visual Studio bzw. VC++

    0
  • I

    Machs einfach so?

    #if defined(_UNICODE) || defined(UNICODE)
    #define CSZ_STRING  L"Hallo Welt"
#else
    #define CSZ_STRING "Hallo Welt"
#endif
    0
  • Mod

    Ich würde alles intern immer in der TCHAR Notation verwenden.
    Wenn ich tatsächlich mal eine andere Form benötige helfen die ATL Makros CT2W etc.

    Dein Problem ist dass das L kein Operator ist sondern zusammen mit dem " einen Ausdruck bildet eben L".

    Ansonsten:

    #define TEST "Test"
#define WIDESTRING(x) L#x
wchar_t *p = WIDESTRING(TEST);
    0

  • Martin Richter schrieb:

    Ich würde alles intern immer in der TCHAR Notation verwenden.

    Warum nimmst du dann wchar_t*?
    Warum nicht

    #define TEST "Test"
TCHAR *p = _T(TEST);

    und sparst dabei das Makro und nimmst das vorhandene?

    0
  • M

    Hi,
    Danke für Eure Mühen, einige Vorschläge kann ich so nicht umsetzen, einige gaben mir den entscheidenden Tipp.

    Eines vorneweg, warum ich alle drei Definitions-Möglichkeiten (char, TCHAR und WCHAR) gleichzeitig benötige.
    Nun, standardmäßig benutze ich TCHAR.
    Bei einer Ausgabe in eine ASCII-Datei oder parsen von einer ASCII-Datei benötige ich char.
    Zu guter Letzt benötigen einige Funktionen wiederum reinen WCHAR-Text. Insbesondere die meisten neueren Funktionen, die seit Windows Vista hinzugekommen sind.

    @Icematix:
    Ich brauche zeitgleich alle drei Definitionen.
    Desweiteren möchte ich daß in einem Projekt der Stringinhalt nur an einer einzigen Stelle definiert wird.
    Ansonsten besteht nämlich die Gefahr daß bei einer Stringänderung (z.B. beim Übersetzen in andere Sprachen) nur an einer Stelle gepflegt wird und die anderen übersehen werden....

    @Martin:
    Fast richtig, allerdings wird hier eine doppelte Raute benötigt.
    Der Stringize Operator (#) macht nämlich aus WIDESTRING(TEST) den String LTEST (und nicht wie gewünscht L"Test" 😮 )

    Da 'L' kein Operator ist, muß man den Token-Pasting Operator (##) anwenden.
    Dieser funktioniert im Zusammenhang mit dem String-Literal 'L' aber auch nur in einer sog. "doppelten Makro-Expansion".
    Hmmm, warum erst bei doppelter Makro-Expansion, ist mir nicht so ganz einleuchtend 😕 .

    Letztendlich habe ich es so als Makro realisiert, in Anlehnung an das originale TEXT() von Windows-SDK:

    #define __WTEXT(x)  L##x
#define WTEXT(x)    __WTEXT(x)

    Danke
    Martin

    0
  • Mod

    Mmacher schrieb:

    @Martin:
    Fast richtig, allerdings wird hier eine doppelte Raute benötigt.
    Der Stringize Operator (#) macht nämlich aus WIDESTRING(TEST) den String LTEST (und nicht wie gewünscht L"Test" 😮 )

    Du irrst schwer.

    Wenn Test ein #define ist wie in meinem Sample ist ## falsch!
    Probier es aus!

    Selbst wenn Du alle drei Formen brauchst würde ich bei Bedarf einfach immer den entsprechenden ATL Operator verwenden. Und vor allem nicht auf die Konstanten!
    Hier würde ich immer TCHAR Notation verwenden und erst im Bedarfsfall CT2x verwenden. Oder immer Unicode und im Bedarfsfall CW2x!

    Ich sehe keinen Grund Konstanten in allen drei Fromen zu gebrauchen.

    0
  • M

    Da gestern am heiligen Tage der Väter das Wetter nicht so recht mitspielte, habe ich ein paar Experimente am PC durchführen können...

    Martin Richter schrieb:

    Du irrst schwer.
    Wenn Test ein #define ist wie in meinem Sample ist ## falsch!
    Probier es aus!

    Hmmm, mag sein, daß ich mich irre, aber ich werde aus Deiner Aussage nicht schlau 😕
    Nehme ich Dein Beispielcode mit dem Stringize Operator (#):

    #define TEST "Test"
#define WIDESTRING(x) L#x

void Testfunc( void )
{
  wchar_t *p = WIDESTRING( TEST );
  printf( "\nAusgabe von WIDESTRING: '%S'", p );
}

    so erscheint folgende Ausgabe:

    Ausgabe von WIDESTRING: 'TEST'

    Nehme ich dagegen meine Makros mit dem Token-Pasting Operator (##):

    #define TEST "Test"
#define __WTEXT(x)  L##x
#define WTEXT(x)    __WTEXT(x)

void Testfunc( void )
{
  wchar_t *p = WTEXT( TEST );
  printf( "\nAusgabe von WTEXT: '%S'", p );
}

    erscheint folgende Ausgabe:

    Ausgabe von WTEXT: 'Test'

    Auch das Inspizieren des Variableninhalts im Watch-Fenster des Debuggers zeigt mir, daß der Token-Pasting Operator (##) wohl oder übel notwendig ist.

    Martin

    BTW: Das Windows SDK-eigene Makro TEXT() verwendet selbst auch den Token-Pasting Operator ##.

    0
  • Mod

    Du hast recht... Sorry!

    0
Anmelden zum Antworten