BSTR zu std::string (std::wstring) und andersherum

Question

Bei der Arbeit mit COM in C++ sind die Strings normalerweise von BSTR Datentyp. Jemand kann BSTR Umhüllung wie CComBSTR oder MS's CString . Aber weil ich nicht ATL oder MFC in MinGW Compiler verwenden können, gibt es Standard-Code-Schnipsel zu konvertieren BSTR a std::string (oder std::wstring ) und vice versa?

Gibt es auch einige Nicht-MS-Verpackungen für BSTR ähnlich wie CComBSTR ?

アップデート

Vielen Dank an alle, die mir in irgendeiner Weise geholfen haben! Nur weil niemand das Problem der Konvertierung zwischen BSTR y std::string Ich möchte Ihnen hier einige Hinweise geben, wie Sie dies tun können.

Im Folgenden sind die Funktionen aufgeführt, die ich zur Konvertierung verwende BSTR a std::string y std::string a BSTR beziehungsweise:

std::string ConvertBSTRToMBS(BSTR bstr)
{
    int wslen = ::SysStringLen(bstr);
    return ConvertWCSToMBS((wchar_t*)bstr, wslen);
}

std::string ConvertWCSToMBS(const wchar_t* pstr, long wslen)
{
    int len = ::WideCharToMultiByte(CP_ACP, 0, pstr, wslen, NULL, 0, NULL, NULL);

    std::string dblstr(len, '\0');
    len = ::WideCharToMultiByte(CP_ACP, 0 /* no flags */,
                                pstr, wslen /* not necessary NULL-terminated */,
                                &dblstr[0], len,
                                NULL, NULL /* no default char */);

    return dblstr;
}

BSTR ConvertMBSToBSTR(const std::string& str)
{
    int wslen = ::MultiByteToWideChar(CP_ACP, 0 /* no flags */,
                                      str.data(), str.length(),
                                      NULL, 0);

    BSTR wsdata = ::SysAllocStringLen(NULL, wslen);
    ::MultiByteToWideChar(CP_ACP, 0 /* no flags */,
                          str.data(), str.length(),
                          wsdata, wslen);
    return wsdata;
}

Answer 1

BSTR a std::wstring :

// given BSTR bs
assert(bs != nullptr);
std::wstring ws(bs, SysStringLen(bs));

 
std::wstring a BSTR :

// given std::wstring ws
assert(!ws.empty());
BSTR bs = SysAllocStringLen(ws.data(), ws.size());

---

Schiedsrichter der Ärzte:

1. std::basic_string<typename CharT>::basic_string(const CharT*, size_type)
2. std::basic_string<>::empty() const
3. std::basic_string<>::data() const
4. std::basic_string<>::size() const
5. SysStringLen()
6. SysAllocStringLen()

Answer 2

Sie könnten auch Folgendes tun

#include <comdef.h>

BSTR bs = SysAllocString("Hello");
std::wstring myString = _bstr_t(bs, false); // will take over ownership, so no need to free

oder std::string, wenn Sie dies bevorzugen

EDIT: Wenn Ihre ursprüngliche Zeichenfolge mehrere eingebettete \0 wird dieser Ansatz nicht funktionieren.

Answer 3

Es gibt eine C++-Klasse namens _bstr_t . Es verfügt über nützliche Methoden und eine Sammlung von überladenen Operatoren.

So können Sie zum Beispiel einfach von einem const wchar_t * oder eine const char * einfach tun _bstr_t bstr = L"My string"; Dann können Sie es wieder umwandeln, indem Sie const wchar_t * s = bstr.operator const wchar_t *(); . Sie können es sogar wieder in ein normales Zeichen umwandeln const char * c = bstr.operator char *(); Sie können dann einfach die const wchar_t * oder die const char * zur Initialisierung einer neuen std::wstring oe std::string .

Answer 4

Übergeben Sie den BSTR einfach direkt an den wstring-Konstruktor, er ist kompatibel mit einem wchar_t*:

BSTR btest = SysAllocString(L"Test");
assert(btest != NULL);
std::wstring wtest(btest);
assert(0 == wcscmp(wtest.c_str(), btest));

Die Umwandlung von BSTR in std::string erfordert zunächst eine Umwandlung in char*. Das ist verlustbehaftet, da BSTR einen utf-16 kodierten Unicode-String speichert. Es sei denn, Sie wollen in utf-8 kodieren. In der ICU-Bibliothek finden Sie Hilfsmethoden, um dies zu tun und die resultierende Zeichenkette zu bearbeiten.