web-dev-qa-db-fra.com

Convertir lptstr en char *

Est-ce que quelqu'un saurait comment convertir le type LPTSTR en char * en C++?

c++charlptstr
15
user37875

Dépend si c'est Unicode ou non, il apparaît. LPTSTR est char * si ce n'est pas Unicode ou w_char * si c'est le cas.

Mieux discuté ici (réponse acceptée, à lire)

11
JamesSugrue

Voici beaucoup de façons de le faire. CString, macros ATL ou API Win32 de MFC ou ATL.

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

Vous pouvez utiliser les macros ATL pour convertir:

USES_CONVERSION;
pBuffer = T2A(szString);

C chaîne:

CStringA cstrText(szString);

ou l'API Win32 WideCharToMultiByte si UNICODE est défini.

7
John Z

Si votre paramètre de caractère du compilateur est défini sur Jeu de caractères Unicode , alorsLPTSTRsera interprété comme wchar_t * . Dans ce cas, la conversion de caractères Unicode en multi-octets est requise.
(Dans Visual Studio, le paramètre est situé dans Propriétés du projet\Propriétés de configuration\Général\Jeu de caractères)

L'exemple de code ci-dessous devrait vous donner une idée:

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

D'autre part, si votre paramètre de caractère du compilateur est défini sur Multibyte, alorsLPTSTRsera interprété comme char * .

Dans ce cas:

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

Regarde aussi:

Une autre discussion à propos de la conversion wchar_t: Comment utilisez-vous correctement WideCharToMultiByte
Article MSDN: http://msdn.Microsoft.com/en-us/library/dd374130(v=vs.85).aspx
Identificateurs de page de code valides: 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, alors disons que vous devez utiliser Unicode. Et vous utilisez certaines fonctions, telles que LookupAccountSid, indispensables au fonctionnement de votre programme, mais elles renvoient LPTSTR pour les informations importantes que vous DEVEZ traiter comme une chaîne (quelle que soit la raison (sa programmation, ce genre de choses se produit)

Maintenant, si vous utilisiez plusieurs octets, cela ne poserait pas de problème. Mais il y a un moyen de le résoudre. Ceci est ma méthode et est certes bâclée. Néanmoins, vous devriez pouvoir voir comment cela fonctionne.

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

Toutes les questions demandent juste. Je me rends compte que c’est un vieux post - mais j’aime bien poster pour les gens dans le futur qui viennent. (Des gens comme moi)

0
maxtuzz

J'espère que cela aidera quelqu'un, car il m'a fallu un certain temps pour comprendre comment le faire.

Tout d’abord, LPTSTR est de type pointeur et correspond fondamentalement à TCHAR* (en supposant que <tchar.h> est inclus). Notez que la taille de TCHAR varie en fonction du type de codage de caractères. c'est-à-dire que si unicode est défini, TCHAR est égal à wchar_t, sinon il s'agit de char.

Naturellement, si vous convertissez un caractère large en une char normale, vous ne pouvez conserver que le LSB et vous risquez de perdre certaines données. C'était irritant pour moi. alors j'ai écrit le code suivant. Son principal avantage est la conversion sans perte de données.

Soit dit en passant, si la perte de données vous convient, alors wcstombs fait le travail.

#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
polfosol ఠ_ఠ

Il me manquait un exemple simple, alors le voici:

(pour moi, char * est identique à char [])

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