it-swarm.com.de

Wie konvertiere ich std :: string nach LPCSTR?

Wie kann ich ein std::string zu LPCSTR? Wie kann ich ein std::string zu LPWSTR?

Ich bin total verwirrt mit diesen LPCSTRLPSTRLPWSTR und LPCWSTR.

Sind LPWSTR und LPCWSTR gleich?

108
Cute

str.c_str() gibt Ihnen ein const char *, das ist ein LPCSTR (Long Pointer to Constant STRing) - bedeutet, dass es ein Zeiger auf ein 0 Abgeschlossene Zeichenfolge. W bedeutet eine breite Zeichenkette (bestehend aus wchar_t anstelle von char).

110
Lou Franco

Rufen Sie c_str() auf, um ein const char * (LPCSTR) aus einem std::string.

Auf den Namen kommt es an:

LPSTR - (langer) Zeiger auf String - char *

LPCSTR - (langer) Zeiger auf konstante Zeichenfolge - const char *

LPWSTR - (langer) Zeiger auf Unicode (breite) Zeichenfolge - wchar_t *

LPCWSTR - (langer) Zeiger auf konstante Unicode-Zeichenfolge (breite Zeichenfolge) - const wchar_t *

LPTSTR - (langer) Zeiger auf TCHAR (Unicode, wenn UNICODE definiert ist, ANSI, wenn nicht) Zeichenfolge - TCHAR *

LPCTSTR - (langer) Zeiger auf konstanten TCHAR-String - const TCHAR *

Sie können den L (langen) Teil der Namen ignorieren - dies ist ein Überbleibsel von 16-Bit-Windows.

147
Nick Meyer

Hierbei handelt es sich um von Microsoft definierte typedefs, die den folgenden Elementen entsprechen:

LPCSTR: Zeiger auf nullterminierte Konstante von char

LPSTR: Zeiger auf nullterminierte Zeichenfolge von char (häufig wird ein Puffer übergeben und als 'Ausgabe'-Parameter verwendet)

LPCWSTR: Zeiger auf nullterminierte Zeichenfolge von const wchar_t

LPWSTR: Zeiger auf nullterminierte Zeichenfolge von wchar_t (Häufig wird ein Puffer übergeben und als 'Ausgabe'-Parameter verwendet)

Das "Konvertieren" eines std::string In einen LPCSTR hängt vom genauen Kontext ab, aber in der Regel ist der Aufruf von .c_str() ausreichend.

Das funktioniert.

void TakesString(LPCSTR param);

void f(const std::string& param)
{
    TakesString(param.c_str());
}

Beachten Sie, dass Sie nicht versuchen sollten, so etwas zu tun.

LPCSTR GetString()
{
    std::string tmp("temporary");
    return tmp.c_str();
}

Der von .c_str() zurückgegebene Puffer gehört der Instanz std::string Und ist nur gültig, bis der String das nächste Mal geändert oder zerstört wird.

Das Konvertieren eines std::string In ein LPWSTR ist komplizierter. Wenn Sie ein LPWSTR wünschen, müssen Sie einen veränderbaren Puffer benötigen und Sie müssen auch sicher sein, dass Sie verstehen, was Zeichencodierung das std::string Verwendet. Wenn das std::string Einen String enthält, der die Standardcodierung des Systems verwendet (hier Windows vorausgesetzt), können Sie die Länge des erforderlichen Puffers für breite Zeichen ermitteln und die Transcodierung mit MultiByteToWideChar (einer Win32-API) durchführen Funktion).

z.B.

void f(const std:string& instr)
{
    // Assumes std::string is encoded in the current Windows ANSI codepage
    int bufferlen = ::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), NULL, 0);

    if (bufferlen == 0)
    {
        // Something went wrong. Perhaps, check GetLastError() and log.
        return;
    }

    // Allocate new LPWSTR - must deallocate it later
    LPWSTR widestr = new WCHAR[bufferlen + 1];

    ::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), widestr, bufferlen);

    // Ensure wide string is null terminated
    widestr[bufferlen] = 0;

    // Do something with widestr

    delete[] widestr;
}
32
CB Bailey

Mit LPWSTR können Sie den Inhalt der Zeichenfolge ändern, auf die sie verweist. Mit LPCWSTR konnten Sie den Inhalt der Zeichenfolge, auf die sie verweist, nicht ändern.

std::string s = SOME_STRING;
// get temporary LPSTR (not really safe)
LPSTR pst = &s[0];
// get temporary LPCSTR (pretty safe)
LPCSTR pcstr = s.c_str();
// convert to std::wstring
std::wstring ws; 
ws.assign( s.begin(), s.end() );
// get temporary LPWSTR (not really safe)
LPWSTR pwst = &ws[0];
// get temporary LPCWSTR (pretty safe)
LPCWSTR pcwstr = ws.c_str();

LPWSTR ist nur ein Zeiger auf die ursprüngliche Zeichenfolge. Sie sollten es anhand des obigen Beispiels nicht von der Funktion zurückgeben. Um nicht temporäres LPWSTR zu erhalten, sollten Sie eine Kopie der ursprünglichen Zeichenfolge auf dem Heap erstellen. Überprüfen Sie das folgende Beispiel:

LPWSTR ConvertToLPWSTR( const std::string& s )
{
  LPWSTR ws = new wchar_t[s.size()+1]; // +1 for zero at the end
  copy( s.begin(), s.end(), ws );
  ws[s.size()] = 0; // zero at the end
  return ws;
}

void f()
{
  std::string s = SOME_STRING;
  LPWSTR ws = ConvertToLPWSTR( s );

  // some actions

  delete[] ws; // caller responsible for deletion
}
18

Die MultiByteToWideChar Antwort, die Charles Bailey gegeben hat, ist die richtige. Da LPCWSTR nur eine Typangabe für const WCHAR* Ist, kann widestr im Beispielcode überall dort verwendet werden, wo eine LPWSTR erwartet wird oder eine LPCWSTR Es wird erwartet.

Eine kleine Verbesserung wäre, std::vector<WCHAR> Anstelle eines manuell verwalteten Arrays zu verwenden:

// using vector, buffer is deallocated when function ends
std::vector<WCHAR> widestr(bufferlen + 1);

::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), &widestr[0], bufferlen);

// Ensure wide string is null terminated
widestr[bufferlen] = 0;

// no need to delete; handled by vector

Wenn Sie zu Beginn mit breiten Zeichenfolgen arbeiten müssen, können Sie auch std::wstring Anstelle von std::string Verwenden. Wenn Sie mit dem Windows-Typ TCHAR arbeiten möchten, können Sie std::basic_string<TCHAR> Verwenden. Das Konvertieren von std::wstring Nach LPCWSTR oder von std::basic_string<TCHAR> Nach LPCTSTR ist nur eine Frage des Aufrufs von c_str. Wenn Sie zwischen ANSI- und UTF-16-Zeichen wechseln, wird MultiByteToWideChar (und die Umkehrung WideCharToMultiByte) in das Bild eingefügt.

4
Joel

Das Konvertieren ist einfach:

std::string myString;

LPCSTR lpMyString = myString.c_str();

Hierbei ist zu beachten, dass c_str keine Kopie von myString zurückgibt, sondern nur einen Zeiger auf die Zeichenfolge, die std :: string umschließt. Wenn Sie eine Kopie benötigen, müssen Sie diese mit strcpy selbst erstellen.

2
Nick Haddad

Die Konvertierung ist einfach:

std :: string str; LPCSTR lpcstr = str.c_str ();

1
Timbo

Der einfachste Weg, einen std::string In einen LPWSTR umzuwandeln, ist meiner Meinung nach:

  1. Konvertieren Sie den std::string In einen std::vector<wchar_t>
  2. Nehmen Sie die Adresse des ersten wchar_t Im Vektor.

std::vector<wchar_t> Hat einen Template-Ctor, der zwei Iteratoren benötigt, wie z. B. die Iteratoren std::string.begin() und .end(). Dies konvertiert jedoch jedes Zeichen in einen wchar_t. Dies ist nur gültig, wenn std::string ASCII oder Latin-1 enthält, da Unicode-Werte Latin-1-Werten ähneln. Wenn es CP1252 oder Zeichen aus einer anderen Codierung enthält, Es ist komplizierter, dann müssen Sie die Zeichen konvertieren.

1
MSalters