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

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

C’è una syntax più pulita se stai usando una versione recente di .net

#include "stdafx.h" #include  #include  using namespace System; int main(array ^args) { System::String^ managedString = "test"; msclr::interop::marshal_context context; std::string standardString = context.marshal_as(managedString); return 0; } 

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

C’è un articolo di msdn per varie altre conversioni

E in risposta al “modo più semplice” nelle versioni successive di C ++ / CLI, puoi farlo senza marshal_context. So che questo funziona in Visual Studio 2010; Non sono sicuro di prima.


 #include "stdafx.h" #include  #include  using namespace msclr::interop; int main(array ^args) { System::String^ managedString = "test"; std::string standardString = marshal_as(managedString); return 0; } 

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

C # usa il formato UTF16 per le sue stringhe.
Quindi, oltre alla semplice conversione dei tipi, dovresti anche essere consapevole del formato effettivo della stringa.

Durante la compilazione per set di caratteri multi-byte, Visual Studio e l’API Win presuppongono UTF8 (in realtà la codifica di Windows che è Windows-28591 ).
Durante la compilazione per il set di caratteri Unicode, Visual Studio e l’API Win assumono UTF16.

Pertanto, è necessario convertire anche la stringa da UTF16 a UTF8 e non solo convertire in std :: string.
Ciò diventerà necessario quando si lavora con formati multi-carattere come alcune lingue non latine.

L’idea è di decidere che std::wstring rappresenta sempre UTF16 .
E std::string rappresenta sempre UTF8 .

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

 #include "stdafx.h" #include  #include  using namespace System; int main(array ^args) { System::String^ managedString = "test"; msclr::interop::marshal_context context; //Actual format is UTF16, so represent as wstring std::wstring utf16NativeString = context.marshal_as(managedString); //C++11 format converter std::wstring_convert> convert; //convert to UTF8 and std::string std::string utf8NativeString = convert.to_bytes(utf16NativeString); return 0; } 

O fallo in una syntax più compatta:

 int main(array ^args) { System::String^ managedString = "test"; msclr::interop::marshal_context context; std::wstring_convert> convert; std::string utf8NativeString = convert.to_bytes(context.marshal_as(managedString)); return 0; } 

Ho avuto troppi errori ambigui con le risposte di cui sopra (sì, sono un noob in C ++)

Questo ha funzionato per me per l’invio di stringhe da C # a 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 funziona dalla conversione di String ^ in std :: string

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

PER ULTERIORI RICERCHE, sembra che questo sia più pulito e più sicuro.

Sono passato a utilizzare questo metodo, invece.

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

Creazione di un componente Windows Runtime che è ansible utilizzare:

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