c++ - Convierta lptstr en char*
(8)
Aquí hay muchas maneras de hacer esto. CString de MFC o ATL, macros ATL o API de Win32.
LPTSTR szString = _T("Testing");
char* pBuffer;
Puede usar macros ATL para convertir:
USES_CONVERSION;
pBuffer = T2A(szString);
Cuerda C:
CStringA cstrText(szString);
o la API de Win32 WideCharToMultiByte si está definido UNICODE .
¿Alguien sabe cómo convertir el tipo LPTSTR a char * en C ++?
Depende si es Unicode o no aparece. LPTSTR es char * si no Unicode, o w_char * si es así.
Discutido mejor aquí (respuesta aceptada que vale la pena leer)
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);
}
sin duda, muchos (por ejemplo, nosotros unix folk) retrocederán con horror ante el doble discurso de Microserf: "si su compilador está en modo Unicode, use LPWSTR o pegue un" T_ "frente a él, pero solo si es un estático string, que es lo mismo que una "L", o use T2A () si usa ATL, pero que ahora está desactualizado, o use VARIANT pero no si está enlazando con COM / OLE "...).
El "if (sizeof (TCHAR) == sizeof (char))" enumerado en esta página es un intento lógico de una buena solución, pero no se compilará: if-true no compilará o if-false wont ''compilar, dependiendo de las banderas del compilador (¡Aaargh!). Para una solución portátil de escritura y olvídate, deberá recurrir a la macro UNICODE [demasiado genérica]. Ofrezco esta adaptación del código anterior:
string mfc_to_zstring (CString &sref)
{
char nojoy[65536];
char *ptr, *psin = NULL;
string sot;
LPCTSTR p = sref;
#if UNICODE
if (sizeof(TCHAR) != sizeof(char))
{
size_t n = wcstombs(NULL, p, 0);
if (n > 65530)
{
psin = new char[n + 1];
wcstombs(psin, p, n + 1);
ptr = psin;
}
else
{
wcstombs(nojoy, p, n + 1);
ptr = nojoy;
}
sot = ptr;
if (psin != NULL)
delete psin;
}
else
{ std::cerr << "Aaargh! Microsoft horror./n"; exit(1); }
#else
if (sizeof(TCHAR) == sizeof(char))
{
const char *ptr = p;
sot = ptr;
}
else
{ std::cerr << "Aaargh! You should never see this line/n"; exit(1); }
#endif
return sot;
}
OK, entonces digamos que TIENE que usar Unicode. Y utiliza algunas funciones como LookupAccountSid, que son necesarias para que su programa funcione, pero devuelven LPTSTR para obtener información importante que NECESITA procesar como cadena de caracteres (por alguna razón, es programación, sucede algo como esto).
Ahora, si estuvieras usando multibyte, esto no sería un problema. Pero hay una manera de resolverlo. Este es mi método y es ciertamente descuidado. Pero, sin embargo, debería ser capaz de ver cómo funciona.
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
Cualquier pregunta solo pregunte Me doy cuenta de que esta es una publicación anterior, pero me gusta publicar para las personas en el furture que vienen buscando. (gente como yo)
Espero que esto ayude a alguien, porque me tomó un tiempo descubrir cómo hacerlo.
En primer lugar, LPTSTR es de tipo puntero y es básicamente equivalente a TCHAR* (suponiendo que se <tchar.h> ). Tenga en cuenta que el tamaño de TCHAR varía según el tipo de codificación de caracteres. es decir, si se define unicode, TCHAR es igual a wchar_t ; de lo contrario, es char .
Naturalmente, si convierte un carácter ancho en un char normal, solo puede conservar el LSB y puede perder algunos datos. Esto fue de alguna manera irritante para mí. entonces escribí el siguiente código. Su principal ventaja es hacer la conversión sin perder ningún dato.
Por cierto, si estás bien con la pérdida de datos, entonces wcstombs hace el trabajo.
#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
}
Me faltaba un ejemplo simple, así que aquí está:
(para mí char * es idéntico a char [])
LPCTSTR myLPCTSTR = getLPCTSTR();
TCHAR myT[500];
wcscpy(myT,myLPCTSTR);
char myC[500];
sprintf(myC, "%S", myT);
Si la Configuración de caracteres del compilador está configurada en Conjunto de caracteres Unicode , entonces LPTSTR se interpretará como wchar_t * . En ese caso, se requiere la conversión de caracteres de Unicode a Multibyte.
(En Visual Studio, la configuración se encuentra en Propiedades del proyecto / Propiedades de configuración / General / Conjunto de caracteres)
El siguiente código de muestra debería dar una idea:
#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;
}
Por otro lado, si la Configuración de caracteres del compilador está configurada en Multibyte, entonces LPTSTR se interpretará como char * .
En ese caso:
LPTSTR x = "test";
char* y;
y = x;
Ver también:
Otra discusión sobre la conversión de wchar_t: ¿Cómo se usa correctamente WideCharToMultiByte?
Artículo de MSDN: http://msdn.microsoft.com/en-us/library/dd374130(v=vs.85).aspx
Identificadores de página de código válidos: http://msdn.microsoft.com/en-us/library/dd317756(v=vs.85).aspx