C++ .NET converti System :: String in std :: string

Question

Come si converte System :: String in std :: string in C++ .NET?

Answer 1

C'è sintassi più pulito se si sta utilizzando una versione recente di .NET

#include "stdafx.h" 
#include <string> 

#include <msclr\marshal_cppstd.h> 

using namespace System; 

int main(array<System::String ^> ^args) 
{ 
    System::String^ managedString = "test"; 

    msclr::interop::marshal_context context; 
    std::string standardString = context.marshal_as<std::string>(managedString); 

    return 0; 
} 

Questo ti dà anche una migliore pulizia di fronte alle eccezioni.

C'è un msdn article per varie altre conversioni

Answer 2

stdString = toss(systemString); 

    static std::string toss(System::String^s) 
    { 
    // convert .NET System::String to std::string 
    const char* cstr = (const char*) (Marshal::StringToHGlobalAnsi(s)).ToPointer(); 
    std::string sstr = cstr; 
    Marshal::FreeHGlobal(System::IntPtr((void*)cstr)); 
    return sstr; 
    } 

Answer 3

e in risposta al "modo più semplice" nelle versioni successive di C++/CLI, è possibile farlo senza il marshal_context. So che questo funziona in Visual Studio 2010; Non sono sicuro di prima.

---

#include "stdafx.h" 
#include <string> 

#include <msclr\marshal_cppstd.h> 

using namespace msclr::interop; 

int main(array<System::String ^> ^args) 
{ 
    System::String^ managedString = "test"; 

    std::string standardString = marshal_as<std::string>(managedString); 

    return 0; 
} 

---

Answer 4

ho avuto troppi errori ambigui che mostra il passo con le risposte di cui sopra (sì, io sono un C++ niubbo)

Questo ha funzionato per me per l'invio di stringa da C# per C++ CLI

C#

bool result; 
result = mps.Import(mpsToolName); 

---

C++ CLI

funzione:

bool ManagedMPS::Import(System::String^ mpsToolNameTest) 
std::string mpsToolName; 
mpsToolName = toStandardString(mpsToolNameTest); 

funzione che lavora dalla conversione String^a std :: string

static std::string toStandardString(System::String^ string) 
{ 
using System::Runtime::InteropServices::Marshal; 
System::IntPtr pointer = Marshal::StringToHGlobalAnsi(string); 
char* charPointer = reinterpret_cast<char*>(pointer.ToPointer()); 
std::string returnString(charPointer, string->Length); 
Marshal::FreeHGlobal(pointer); 
return returnString; 
} 

ON ulteriori ricerche, sembra che questo è più pulito e più sicuro.

Ho scelto invece di utilizzare questo metodo.

std::string Utils::ToUnmanagedString(String^ stringIncoming) 
{ 
    std::string unmanagedString = marshal_as<std::string>(stringIncoming); 
    return unmanagedString; 
} 

Answer 5

Creazione di un runtime componenti di Windows è possibile utilizzare:

String^ systemString = "Hello"; 
std::wstring ws1(systemString ->Data()); 
std::string standardString(ws1.begin(), ws1.end()); 

Answer 6

C# utilizza il formato UTF16 per le sue corde.
Quindi, oltre alla semplice conversione dei tipi, è necessario essere consapevoli del formato effettivo della stringa.

Durante la compilazione per Set di caratteri multibyte Visual Studio e l'API Win presuppongono UTF8 (In realtà la codifica di Windows che è Windows-28591).
Durante la compilazione per Set di caratteri Unicode Visual Studio e l'API Win assumono UTF16.

Quindi, è necessario convertire anche la stringa da UTF16 a UTF8 e non solo convertire in std :: string.
Questo diventerà necessario quando si lavora con formati a più caratteri come alcune lingue non latine.

L'idea è quella di decidere che std::wstringsempre rappresenta UTF16.
E std::stringsempre rappresenta UTF8.

Questo non è applicato dal compilatore, è più una buona politica da avere.

#include "stdafx.h" 
#include <string> 

#include <msclr\marshal_cppstd.h> 

using namespace System; 

int main(array<System::String ^> ^args) 
{ 
    System::String^ managedString = "test"; 

    msclr::interop::marshal_context context; 

    //Actual format is UTF16, so represent as wstring 
    std::wstring utf16NativeString = context.marshal_as<std::wstring>(managedString); 

    //C++11 format converter 
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert; 

    //convert to UTF8 and std::string 
    std::string utf8NativeString = convert.to_bytes(utf16NativeString); 

    return 0; 
} 

o fa in una sintassi più compatta:

int main(array<System::String ^> ^args) 
{ 
    System::String^ managedString = "test"; 

    msclr::interop::marshal_context context; 
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert; 

    std::string utf8NativeString = convert.to_bytes(context.marshal_as<std::wstring>(managedString)); 

    return 0; 
}