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

I w odpowiedzi na" łatwiejszy sposób " w późniejszych wersjach C++/CLI, można to zrobić bez marshal_context. Wiem, że to działa w Visual Studio 2010; nie jestem pewien co do tego wcześniej.

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

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 # używa formatu UTF16 dla swoich ciągów.
Tak więc, oprócz tylko konwersji typów, powinieneś również być świadomy o rzeczywistym formacie ciągu.

Podczas kompilacji dla wielobajtowego zestawu znaków Visual Studio i Win API przyjmują UTF8(w rzeczywistości kodowanie windows, które jest Windows-28591).
Podczas kompilacji dla zestawu znaków Unicode Visual studio i Win API przyjmują UTF16.

Więc musisz przekonwertować ciąg znaków z UTF16 do formatu UTF8 jak również, i nie tylko konwertować do std:: string.
Będzie to konieczne podczas pracy z formatami wieloznakowymi, takimi jak niektóre języki inne niż łacińskie.

Chodzi o to, aby zdecydować, że std::wstring zawsze reprezentuje UTF16 .
Oraz std::string zawsze reprezentuje UTF8 .

To nie jest wymuszane przez kompilator, to bardziej dobra polityka.

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

Lub mieć ją w bardziej zwartej składni:

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

Miałem zbyt wiele niejasnych błędów pojawiających się z powyższymi odpowiedziami (tak, jestem noobem C++)

To mi pomogło przy wysyłaniu ciągów z C# do C++ CLI

C #

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

C++ CLI

Funkcja:

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

Funkcja, która działa od konwersji String^ do 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;
}

Przełączyłem się na użycie tej metody.

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

Tworzenie komponentu Windows Runtime, którego możesz użyć:

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