C++ WCHAR Manipulationen

Entwickle ich eine kleine Win32-Anwendung in C++.
Ich habe studiert C++ Grundlagen vor langer Zeit, so dass ich nun vollkommen verwirrt, weil der Zeichenketten in C++. Es gab keine WCHAR oder TCHAR nur char und String.
Nach einer kleinen Untersuchung habe ich beschlossen, nicht zu verwenden TCHAR.

Mein Problem ist ganz einfach, denke ich, aber ich finde keine klare Anleitung, wie Sie zu manipulieren strings in C++. Betroffen von PHP coding letzten paar Jahren habe ich erwartet, dass etwas, das einfach mit Streichern Manipulationen und war falsch!

Einfach, alles, was ich brauche, ist, um neue Daten in eine Zeichenfolge um.

    WCHAR* cs = L"\0";
    swprintf( cs, "NEW DATA" );

Dies war mein Erster Versuch. Beim Debuggen meiner app habe ich untersucht, swprintf stellt nur die ersten 2 chars auf meinem cs var. Ich habe gelöst mein problem auf diese Weise:

    WCHAR cs[1000];
    swprintf( cs, "NEW DATA" );

Aber in der Regel diesen trick scheitern könnte, da in meinem Fall neue Daten nicht konstanter Wert, sondern eine andere variable, das könnte potentialy breiter sein, als 1000 chars lang. Und mein code sieht wie folgt aus:

    WCHAR cs[1000];
    WCHAR* nd1;
    WCHAR* nd2;
    wcscpy(nd1, L"Some value");
    wcscpy(nd2, L"Another value"); //Actually these vars stores the path for user selected folder
    swprintf( cs, "The paths are %s and %s", nd1, nd2);

In diesem Fall gibt es die Möglichkeit, als nd1 und nd2 gesamtzeichenzahl könnte größer sein als 1000 chars so wichtige Daten verloren.

Die Frage ist, wie kann ich kopieren Sie alle Daten, die ich brauche, um WCHAR-string deklariert diese Weise WCHAR* wchar_var; ohne alles zu verlieren?

P. S. Da bin ich auf Russisch die Frage unklar ist. Lassen Sie mich nun zu diesem, und ich werde versuchen zu erklären, mein Problem klarer und komplexer.

Sie sollten wahrscheinlich verwenden Sie wchar_t und std::wstring. Und Lesen Sie ein wenig mehr über Zeiger, die Letzte code-snippet kopiert Daten mit nicht initialisierten Zeigern, das heißt, Sie überschreiben könnte etwas in den Speicher des Prozesses.
Ich werde auf jeden Fall Lesen über Pointer!
Ich habe den tag string.
Dann sollten Sie wissen, dass die Verwendung eines nicht initialisierten Zeiger ist schlecht, ja?
Ja, sicherlich! Ich habe gelernt, über Zeiger, wenn ich untersucht habe, in der Schule, aber das war vor langer Zeit, also muss ich mein wissen auffrischen. Vielen Dank!

InformationsquelleAutor Geradlus_RU | 2012-11-13

  1. 7

    In der modernen Windows-Programmierung, es ist OK einfach zu ignorieren TCHAR und stattdessen wchar_t (WCHAR) und Unicode UTF-16.

    (TCHAR ist ein Modell der Vergangenheit, wenn Sie wollte, eine einzige code-Basis und produzieren sowohl ANSI/MBCS und Unicode-builds ändern einige Präprozessor-Schalter wie _UNICODE und UNICODE.)

    In jedem Fall sollten Sie die Verwendung von C++ und bequem string-Klassen um Ihren code zu vereinfachen. Sie können ATL::CString (das entspricht CStringW in Unicode-builds, die den Standard seit VS2005) oder STL ist std::wstring.

    Mit CString Sie tun können:

    CString str1 = L"Some value";
CString str2 = L"Another value";
CString cs;
cs.Format(L"The paths are %s and %s", str1.GetString(), str2.GetString());

    CString bietet auch die richtige überlastungen operator+ zum verketten von strings (so dass Sie nicht haben, um berechnen Sie die Gesamtlänge der resultierenden Zeichenkette, dynamisch reserviert einen Puffer für die Ziel-string oder überprüfen der vorhandenen Puffer-Größe, rufen Sie wcscpy, wcscat, vergessen Sie nicht, lassen Sie die Puffer, etc).

    Und Sie können einfach vorbei kommen Instanzen von CString Win32-APIs erwarten const wchar_t* (LPCWSTR/PCWSTR) Parameter, da CString bietet eine implizite Konvertierung Betreiber const wchar_t*.

    Ich nicht vertraut mit ATL für jetzt. Und auch ich habe beschlossen, zu verwenden .NETTO in weitere apps für Windows. Ich nehme an, es ist ein weiterer string-routine .NET, gibt es nicht?
    Sie nicht haben, um vertraut sein mit ATL zu verwenden CString. Sie können nur #include <atlstr.h> und verwenden CString mit seinen praktischen Funktionen (einschließlich laden von Zeichenfolgen aus der Anwendung der Ressourcen). CString ist besser integriert in die Win32-Programmierung als std::wstring.
    Ich danke Ihnen sehr! Ich werde versuchen, es jetzt

    InformationsquelleAutor Mr.C64

  2. 2

    Wenn man mit einem WCHAR*, werden Sie den Aufruf undefiniert Verhalten, weil Sie einen Zeiger haben, aber nicht zeigen, bis alles gültig. Sie müssen herausfinden, wie lange der resultierende string wird dynamisch Speicherplatz für den string. Zum Beispiel:

    WCHAR* cs;
WCHAR* nd1;
WCHAR* nd2;

nd1 = new WCHAR[lstrlen(L"Some value") + 1]; //+1 for the null terminator
nd2 = new WCHAR[lstrlen(L"Another value") + 1];
cs = new WCHAR[lstrlen(L"The paths are  and ") + lstrlen(nd1) + lstrlen(nd2) + 1];

wcscpy(nd1, L"Some value");
wcscpy(nd2, L"Another value"); //Actually these vars stores the path for user selected folder
swprintf( cs, L"The paths are %s and %s", nd1, nd2);

delete[] nd1;
delete[] nd2;
delete[] cs;

    Aber das ist sehr unschön und fehleranfällig. Wie bereits erwähnt, sollten Sie mit Hilfe std::wstring statt, so etwas wie dieses:

    std::wstring cs;
std::wstring nd1;
std::wstring nd2;

nd1 = L"Some value";
nd2 = L"Another value";
cs = std::wstring(L"The paths are ") + nd1 + L" and " + nd2;
    Darüber habe ich nachgedacht "hässlich-Weg", sondern auch, weil diese wirklich hässlich ist die zweite Möglichkeit, die Sie haben sieht aus wie El Dorado für mich! Danke!

    InformationsquelleAutor Dark Falcon

  3. 1

    Empfehlen ATL CStringW Klasse statt raw WCHAR, es ist viel mehr nützlich. CString ist wrapper für dynamisch allozierten C-string. Sie verwaltet Länge der Zeichenfolge & reserviert Speicher Puffer entsprechend nach jeder operation, so dass Sie würde nicht interessieren.

    Typische Verwendung:

    #include <atlstr.h>

CStringW s;
s.Format(L"The paths are %s and %s", L"Some value", L"Another value");
const WCHAR* wstr = s.GetString(); //To pass to some API that need WCHAR

    oder

    #include <atlstr.h>

CStringW s(L"The paths are ");
s += L"Some value";
s += L" and ";
s += L"Another value";
const WCHAR* wstr = s.GetString(); //To pass to some API that need WCHAR
    Sie können übergeben Sie einfach einen CString Instanz zu APIs erfordern const WCHAR*, da CString bietet einen praktischen, impliziten const wchar_t* Betreiber für diesen Zweck.
    Ja, natürlich, aber mit expliziten GetString() vorzuziehen ist.
    Nein, CString::GetString() macht nur Sinn in Kontexten wie swprintf() mit einem printf-wie format-string und %s. Ich würde einfach direkt übergeben eine CString - Instanz als argument an eine Funktion mit einem LPCWSTR parameter.
    Ersten, vorbei CString als printf-wie func-argument wird auch funktionieren, weil CString ist Binär-kompatibel mit char*/wchar_t*. Zweite, implizite Konvertierungen ist gefährlich und verwirrend. Explizite Konvertierungen werden stattdessen verwendet. Das ist, weil std::string hat keine solche const char*() Betreiber.
    Die Tatsache, dass CString arbeitet mit printf()-ähnliche Funktionen ist eine Art "hack"; es ist kein robuster code. Sogar MSDN rät, dass die Verwendung und schlägt vor, einen expliziten cast (aber ich finde den Aufruf str.GetString() besser als static_cast<const wchar_t*>(str)). Darüber hinaus, vorbei an CString zu const wchar_t* Parameter ist Prima (mir CString str; ... SetWindowText(hWnd, str); ist OK, aber SetWindowText(hWnd, str.GetString()); ist ugly "code").

    InformationsquelleAutor Rost

Schreibe einen Kommentar