Unmanaged to Managed:
------------------------------------
char* su;
String^ sm = gcnew String(su);

wchar_t* su;
String^ sm = gcnew String(su);

std::string su;
String^ sm = gcnew String(su.c_str());

std::wstring su;
String^ sm = gcnew String(su.c_str());

Managed to Unmanaged:
------------------------------------
Wide string version:
   String^ sm = "Hello";
   pin_ptr<wchar_t> pu = PtrToStringChars(sm);
   // PtrToStringChars is an inline function in vcclr.h, and it returns
   // a raw pointer to the internal representation of the String.
   // After pinning "p", it can be passed to unmanaged code:
   wchar_t* su = pu;
   // when "pu" goes out of scope, "su" becomes invalid!

Ansi (8-bit) version:
   ScopedHGlobal s_handle(Marshal::StringToHGlobalAnsi(sm));
   char* su = s_handle.c_str();
   // when "s_handle" goes out of scope, "su" becomes invalid!
Where ScopedHGlobal is a helper class written by myself:
   using namespace System::Runtime::InteropServices;
   public ref class ScopedHGlobal
   {
   public:
      ScopedHGlobal(IntPtr p) : ptr(p) { }
      ~ScopedHGlobal() { Marshal::FreeHGlobal(ptr); }
      char* c_str() { return reinterpret_cast<char*>(ptr.ToPointer()); }
   private:
      System::IntPtr ptr;
   };

Tom

You cannot convert String^ to String. It makes no sense.

To access the constant unicode string inside String^:

String^ x = gcnew String ("Hi.");
{
   pin_ptr<const wchar_t> pStr = PtrToStringChars (x);
   const wchar_t *s = pStr;
}    // unpin

Brian

You cannot use stack semantics with String. So you can't have something like

String s;

It always has to be :-

String^ s;

Stack semantics is also not available for array and delegate.