Convierta lptstr en char *

Question

¿Alguien sabe cómo convertir el tipo LPTSTR en char * en C++?

Answer 1

Depende si es Unicode o no aparece. LPTSTR es char * si no Unicode, o w_char * si es así.

Discussed better here (respuesta aceptada vale la pena leer)

Answer 2

Aquí hay muchas maneras de hacerlo. CString de MFC o ATL, macros ATL o API de Win32.

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

Puede utilizar macros para convertir ATL:

USES_CONVERSION; 
pBuffer = T2A(szString); 

CString:

CStringA cstrText(szString); 

o la API de Win32 WideCharToMultiByte si UNICODE se define.

Answer 3

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); 
} 

Answer 4

Si su compilador Carácter El ajuste se establece en Unicode juego de caracteres, entonces LPTSTR será interpretado como wchar_t *. En ese caso, se requiere la conversión de caracteres de Unicode a Multibyte.
(En Visual Studio, el establecimiento se encuentra en Propiedades del proyecto \ Propiedades de configuración \ general \ juego de caracteres)

El código de ejemplo siguiente debe darle 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 su La configuración de caracteres del compilador está configurada en Multibyte, luego LPTSTR se interpretará como char *.

En ese caso:

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

Véase también:

Otra discusión acerca de la conversión wchar_t: How do you properly use WideCharToMultiByte
MSDN artículo: http://msdn.microsoft.com/en-us/library/dd374130(v=vs.85).aspx
válidos identificadores de página de códigos: http://msdn.microsoft.com/en-us/library/dd317756(v=vs.85).aspx

Answer 5

sin duda muchos (por ejemplo, nosotros unix folk) retrocederán horrorizados ante el mad-hat ter Doble expresión de Microserf: "si su compilador está en modo Unicode, use LPWSTR o pegue un" T_ "frente a él, pero solo si es una cadena estática, que es lo mismo que una" L ", o use T2A() si usando ATL, pero que ahora está desactualizado, o usa 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á, ya sea el if-true no compilará o if-false no 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érico].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; 
} 

Answer 6

Bien, entonces digamos que TIENE que usar Unicode. Y usa 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 (por alguna razón, es programación, cosas así)

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 simplemente 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. (personas como yo)

Answer 7

Espero que esto ayude a alguien, porque me llevó un tiempo descubrir cómo hacerlo.

En primer lugar, LPTSTR es del tipo de puntero y es básicamente equivalente a TCHAR* (suponiendo que se incluye <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 uno normal char, 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á 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 
} 

Answer 8

me faltaba algún ejemplo sencillo lo que aquí está:

(para mí char * es idéntica a char [])

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