C++ .NET convert System :: String to std :: string

Question

¿Cómo se convierte System :: String en std :: string en C++ .NET?

Answer 1

No es la sintaxis más limpia si está utilizando una versión reciente de .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; 
} 

Esto también le da una mejor limpieza en la cara de excepciones.

Hay un msdn article para varias otras conversiones

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

y en respuesta a la "manera fácil" en versiones posteriores de C++/CLI, puede hacerlo sin la marshal_context. Sé que esto funciona en Visual Studio 2010; no estoy seguro antes de eso.

---

#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

que tenía demasiados errores ambiguos a aparecer con las respuestas anteriores (sí, soy un C++ novato)

Esto funcionó para mí para el envío de cadena de C# para C++ CLI

C#

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

---

C++ CLI

función:

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

función que trabaja a partir de la conversión de cadena^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; 
} 

EN nuevas investigaciones, parece que esto es más limpio y más seguro.

Cambié a utilizar este método en su lugar.

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

Answer 5

Creación de un tiempo de ejecución de componentes de Windows que puede utilizar:

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

Answer 6

C# utiliza el formato UTF16 por sus cadenas.
Por lo tanto, además de convertir los tipos, también debe ser consciente del formato real de la cadena.

cuando se compila para caracteres multi-byte conjunto Visual Studio y la API Win asume UTF8 (En realidad codificación ventanas que es Windows-28591).
Al compilar para Conjunto de caracteres Unicode Visual Studio y la API de Windows asumen UTF16.

Por lo tanto, también debe convertir la cadena de UTF16 a formato UTF8, y no solo convertir a std :: string.
Esto será necesario cuando trabaje con formatos de caracteres múltiples, como algunos idiomas no latinos.

La idea es decidir que std::wstringsiempre representa UTF16.
Y std::stringsiempre representa UTF8.

Esto no se aplica por el compilador, es más una buena política que tener.

#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 lo tiene en una sintaxis más compacta:

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

no hacer