Conversion C ++ / CLI de System :: String ^ vers std :: string

Quelqu'un peut-il s'il vous plaît poster un code simple qui convertirait,

System::String^

À,

C ++ std::string

Ie, je veux juste attribuer la valeur de,

String^ originalString;

À,

std::string newString;

Découvrez System::Runtime::InteropServices::Marshal::StringToCoTaskMemUni()et ses amis.

Désolé, impossible de publier le code maintenant; Je n'ai pas de VS sur cette machine pour vérifier qu'elle se compile avant de publier.

Ne roulez pas les vôtres, utilisez ces wrappers pratiques (et extensibles) fournis par Microsoft.

Par exemple:

#include <msclr\marshal_cppstd.h>

System::String^ managed = "test";
std::string unmanaged = msclr::interop::marshal_as<std::string>(managed);

Vous pouvez facilement le faire comme suit

#include <msclr/marshal_cppstd.h>

System::String^ xyz="Hi boys"; 

std::string converted_xyz=msclr::interop::marshal_as< std::string >( xyz);

Cela a fonctionné pour moi:

#include <stdlib.h>
#include <string.h>
#include <msclr\marshal_cppstd.h>
//..
using namespace msclr::interop;
//..
System::String^ clrString = (TextoDeBoton);
std::string stdString = marshal_as<std::string>(clrString); //String^ to std
//System::String^ myString = marshal_as<System::String^>(MyBasicStirng); //std to String^
prueba.CopyInfo(stdString); //MyMethod
//..
//Where: String^ = TextoDeBoton;
//and stdString is a "normal" string;

Voici quelques routines de conversion que j'ai écrites il y a de nombreuses années pour un projet c ++ / cli, elles devraient toujours fonctionner.

void StringToStlWString ( System::String const^ s, std::wstring& os)
    {
        String^ string = const_cast<String^>(s);
        const wchar_t* chars = reinterpret_cast<const wchar_t*>((Marshal::StringToHGlobalUni(string)).ToPointer());
        os = chars;
        Marshal::FreeHGlobal(IntPtr((void*)chars));

    }
    System::String^ StlWStringToString (std::wstring const& os) {
        String^ str = gcnew String(os.c_str());
        //String^ str = gcnew String("");
        return str;
    }

    System::String^ WPtrToString(wchar_t const* pData, int length) {
        if (length == 0) {
            //use null termination
            length = wcslen(pData);
            if (length == 0) {
                System::String^ ret = "";
                return ret;
            }
        }

        System::IntPtr bfr = System::IntPtr(const_cast<wchar_t*>(pData));
        System::String^ ret = System::Runtime::InteropServices::Marshal::PtrToStringUni(bfr, length);
        return ret;
    }

    void Utf8ToStlWString(char const* pUtfString, std::wstring& stlString) {
        //wchar_t* pString;
        MAKE_WIDEPTR_FROMUTF8(pString, pUtfString);
        stlString = pString;
    }

    void Utf8ToStlWStringN(char const* pUtfString, std::wstring& stlString, ULONG length) {
        //wchar_t* pString;
        MAKE_WIDEPTR_FROMUTF8N(pString, pUtfString, length);
        stlString = pString;
    }

J'ai passé des heures à essayer de convertir une valeur ToString de liste de forme Windows en une chaîne standard afin de pouvoir l'utiliser avec fstream pour la sortie dans un fichier txt. Mon Visual Studio n'est pas fourni avec des fichiers d'en-tête de marshal que plusieurs réponses que j'ai trouvées utilisaient. Après tant d'essais et d'erreurs, j'ai finalement trouvé une solution au problème qui utilise simplement System :: Runtime :: InteropServices:

void MarshalString ( String ^ s, string& os ) {
   using namespace Runtime::InteropServices;
   const char* chars = 
      (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

//this is the code to use the function:
scheduleBox->SetSelected(0,true);
string a = "test";
String ^ c = gcnew String(scheduleBox->SelectedItem->ToString());
MarshalString(c, a);
filestream << a;

Et voici la page MSDN avec l'exemple: http://msdn.microsoft.com/en-us/library/1b4az623(v=vs.80).aspx

Je sais que c'est une solution assez simple, mais cela m'a pris des HEURES de dépannage et de visite de plusieurs forums pour enfin trouver quelque chose qui fonctionnait.

J'ai trouvé un moyen simple d'obtenir une std :: string à partir d'un String ^ est d'utiliser sprintf ().

char cStr[50] = { 0 };
String^ clrString = "Hello";
if (clrString->Length < sizeof(cStr))
  sprintf(cStr, "%s", clrString);
std::string stlString(cStr);

Inutile d'appeler les fonctions Marshal!

MISE À JOUR Merci à Eric, j'ai modifié l'exemple de code pour vérifier la taille de la chaîne d'entrée afin d'éviter un débordement de tampon.

C # utilise le format UTF16 pour ses chaînes.
Donc, en plus de simplement convertir les types, vous devez également être conscient du format réel de la chaîne.

Lors de la compilation pour le jeu de caractères multi-octets, Visual Studio et l'API Win supposent UTF8 (en fait l'encodage Windows qui est Windows-28591 ).
Lors de la compilation pour jeu de caractères Unicode Visual Studio et l'API Win supposent UTF16.

Ainsi, vous devez également convertir la chaîne du format UTF16 au format UTF8, et pas seulement la convertir en std :: string.
Cela deviendra nécessaire lorsque vous travaillez avec des formats à plusieurs caractères comme certaines langues non latines.

L'idée est de décider que représente std::wstring toujours UTF16 .
Et représente std::string toujours UTF8 .

Ce n'est pas imposé par le compilateur, c'est plus une bonne politique à avoir.

#include "stdafx.h"
#include <string>
#include <codecvt>
#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;
}

Ou ayez-le dans une syntaxe plus compacte:

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

J'aime rester à l'écart du marshaller.

Using CString newString(originalString);

Cela me semble beaucoup plus propre et plus rapide. Pas besoin de s'inquiéter de la création et de la suppression d'un contexte.

// J'ai utilisé VS2012 pour écrire le code ci-dessous - convert_system_string en Standard_Sting

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

        using namespace System;
        using namespace Runtime::InteropServices; 


        void MarshalString ( String^ s, std::string& outputstring )
        {  
           const char* kPtoC =  (const char*) (Marshal::StringToHGlobalAnsi(s)).ToPointer();                                                        
           outputstring = kPtoC;  
           Marshal::FreeHGlobal(IntPtr((void*)kPtoC));  
        }   

        int _tmain(int argc, _TCHAR* argv[])
        {
             std::string strNativeString;  
             String ^ strManagedString = "Temp";

             MarshalString(strManagedString, strNativeString);  
             std::cout << strNativeString << std::endl; 

             return 0;
        }