it-swarm.com.de

Lptstr in char umrechnen

Könnte jemand zufällig wissen, wie man den Typ LPTSTR in char * in C++ konvertiert?

15
user37875

Hängt davon ab, ob es Unicode ist oder nicht. LPTSTR ist char *, wenn nicht Unicode, oder w_char *, wenn dies der Fall ist.

Besser hier diskutiert (akzeptierte Antwort lesenswert)

11
JamesSugrue

Hier sind viele Möglichkeiten, dies zu tun. MFC- oder ATL-CString-, ATL-Makros oder Win32-API.

LPTSTR szString = _T("Testing");
char* pBuffer;

Sie können ATL-Makros zum Konvertieren verwenden:

USES_CONVERSION;
pBuffer = T2A(szString);

CString:

CStringA cstrText(szString);

oder die Win32-API WideCharToMultiByte, wenn UNICODE definiert ist.

7
John Z

Wenn Ihre Compiler-Zeicheneinstellung auf Unicode-Zeichensatz eingestellt ist, wirdLPTSTRals wchar_t * interpretiert. In diesem Fall ist die Umwandlung von Unicode in Multibyte-Zeichen erforderlich.
(In Visual Studio befindet sich die Einstellung unter Projekteigenschaften\Konfigurationseigenschaften\Allgemein\Zeichensatz)

Der folgende Beispielcode sollte eine Idee geben:

#include <windows.h>

/* string consisting of several Asian characters */
LPTSTR wcsString = L"\u9580\u961c\u9640\u963f\u963b\u9644";
//LPTSTR wcsString = L"OnlyAsciiCharacters";

char* encode(const wchar_t* wstr, unsigned int codePage)
{
    int sizeNeeded = WideCharToMultiByte(codePage, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* encodedStr = new char[sizeNeeded];
    WideCharToMultiByte(codePage, 0, wstr, -1, encodedStr, sizeNeeded, NULL, NULL);
    return encodedStr;
}

wchar_t* decode(const char* encodedStr, unsigned int codePage)
{
   int sizeNeeded = MultiByteToWideChar(codePage, 0, encodedStr, -1, NULL, 0);
   wchar_t* decodedStr = new wchar_t[sizeNeeded ];
   MultiByteToWideChar(codePage, 0, encodedStr, -1, decodedStr, sizeNeeded );
   return decodedStr;
}

int main(int argc, char* argv[])
{
   char* str = encode(wcsString, CP_UTF8); //UTF-8 encoding
   wchar_t* wstr = decode(str, CP_UTF8);
   //If the wcsString is UTF-8 encodable, then this comparison will result to true.
   //(As i remember some of the Chinese dialects cannot be UTF-8 encoded 
   bool ok = memcmp(wstr, wcsString, sizeof(wchar_t) * wcslen(wcsString)) == 0; 
   delete str;
   delete wstr;

   str = encode(wcsString, 20127); //US-ASCII (7-bit) encoding
   wstr = decode(str, 20127);
   //If there were non-ascii characters existing on wcsString, 
   //we cannot return back, since some of the data is lost
   ok = memcmp(wstr, wcsString, sizeof(wchar_t) * wcslen(wcsString)) == 0; 
   delete str;
   delete wstr;
}

Wenn Ihre Compiler-Zeicheneinstellung dagegen auf Multibyte gesetzt ist, wirdLPTSTRals char * interpretiert.

In diesem Fall:

LPTSTR x = "test";
char* y;
y = x;

Siehe auch:

Eine weitere Diskussion über die Umwandlung von wchar_t: Wie verwendet man WideCharToMultiByte
MSDN-Artikel: http://msdn.Microsoft.com/en-us/library/dd374130(v=vs.85).aspx
IDs für gültige Codeseiten: http://msdn.Microsoft.com/en-us/library/dd317756(v=vs.85).aspx

6
vahapt
char * pCopy = NULL;
if (sizeof(TCHAR) == sizeof(char))
{
    size_t size = strlen(pOriginal);
    pCopy = new char[size + 1];
    strcpy(pCopy, pOriginal);
}
else
{
    size_t size = wcstombs(NULL, pOriginal, 0);
    pCopy = new char[size + 1];
    wcstombs(pCopy, pOriginal, size + 1);
}
3
Mark Ransom

OK, sagen wir also, Sie MÜSSEN Unicode verwenden. Und Sie verwenden einige Funktionen wie LookupAccountSid, die für das Funktionieren Ihres Programms erforderlich sind. Sie geben jedoch LPTSTR für wichtige Informationen zurück, die Sie als Zeichenfolge verarbeiten müssen (aus welchem ​​Grund auch immer - es ist Programmieren, solche Dinge passieren).

Wenn Sie nun Multibyte verwenden, wäre dies kein Problem. Aber es gibt einen Weg, um es zu lösen. Dies ist meine Methode und ist zwar schlampig. Sie sollten jedoch trotzdem sehen können, wie es funktioniert.

const std::wstring &wstring = AcctName; // AcctName being my LPTSTR string
int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstring[0], (int)wstring.size(), NULL, 0, NULL, NULL);
std::string strTo(size_needed, 0);

WideCharToMultiByte(CP_UTF8, 0, & wstring[0], (int)wstring[0], &strTo[0], size_needed, NULL, NULL);

char* charUserName = new char[strTo.size() + 1];

// Set charUserName via copying
std::copy(strTo.begin(), strTo.end(), charUserName);
charUserName[strTo.size()] = '\0';

SetUPI(charUserName); // charUserName being my converted char * - 
// You don't need this last part - but this is an example of passing to method
// that takes a string

Fragen Sie einfach. Mir ist klar, dass dies ein alter Beitrag ist - aber ich poste gerne für Leute in der Zukunft, die kommen. (Leute wie ich)

0
maxtuzz

Ich hoffe, das hilft jemandem, denn ich habe eine Weile gebraucht, um herauszufinden, wie ich das mache.

Zuallererst ist LPTSTR ein Zeigertyp und er ist im Wesentlichen äquivalent zu TCHAR* (vorausgesetzt, <tchar.h> ist enthalten). Beachten Sie, dass die Größe von TCHAR je nach Art der Zeichenkodierung variiert. Wenn also Unicode definiert ist, ist TCHAR gleich wchar_t, andernfalls char.

Wenn Sie ein breites Zeichen in einen normalen char konvertieren, können Sie natürlich nur das LSB beibehalten und möglicherweise Daten verlieren. Das hat mich irgendwie irritiert. Also habe ich den folgenden Code geschrieben. Sein Hauptvorteil ist die Konvertierung ohne Datenverlust.

Übrigens: Wenn Sie mit dem Datenverlust einverstanden sind, erledigt wcstombs den Job.

#include <cstring>
#include <algorithm>
#include <tchar.h>

void lptstr2str(LPTSTR tch, char* &pch) // or (TCHAR* tch, char* &pch)
{
#ifndef UNICODE
    std::memcpy(pch, tch, strlen(tch) + 1);
#else
    size_t n =
        sizeof(TCHAR) / sizeof(char)* wcsnlen(tch, std::string::npos);
    pch = new char[n + 1];
    std::memcpy(pch, tch, n + 1);
    int len = n - std::count(pch, pch + n, NULL);
    std::remove(pch, pch + n, NULL);
    pch[len] = NULL;
#endif
}
0

Mir fehlte ein einfaches Beispiel, also hier ist es:

(für mich char * ist identisch mit char [])

LPCTSTR myLPCTSTR = getLPCTSTR();
TCHAR myT[500];
wcscpy(myT,myLPCTSTR);
char myC[500];
sprintf(myC, "%S", myT);
0
Racky