CM2A - CM2W convert System::String to native char

//
//  vcclr.h - helper code for using the managed extensions to C++
//
//      Copyright (C) Microsoft Corporation
//      All rights reserved.
//
 
#if _MSC_VER > 1000
#pragma once
#endif
 
#if !defined(_INC_VCCLR)
#define _INC_VCCLR
#ifndef RC_INVOKED
 
#using <mscorlib.dll>
#include <gcroot.h>
 
#pragma warning(push)
#pragma warning(disable:4400)
 
#ifdef __cplusplus_cli
typedef cli::interior_ptr<const System::Char> __const_Char_ptr;
typedef cli::interior_ptr<const System::Byte> __const_Byte_ptr;
typedef cli::interior_ptr<System::Byte> _Byte_ptr;
typedef const System::String^ __const_String_handle;
#define _NULLPTR nullptr
#else
typedef const System::Char* __const_Char_ptr;
typedef const System::Byte* __const_Byte_ptr;
typedef System::Byte* _Byte_ptr;
typedef const System::String* __const_String_handle;
#define _NULLPTR 0
#endif
 
 
//
// get an interior gc pointer to the first character contained in a System::String object
//
inline __const_Char_ptr PtrToStringChars(__const_String_handle s) {
 
    _Byte_ptr bp = const_cast<_Byte_ptr>(reinterpret_cast<__const_Byte_ptr>(s));
    if( bp != _NULLPTR ) {
        unsigned offset = System::Runtime::CompilerServices::RuntimeHelpers::OffsetToStringData;
        bp += offset;
    }
    return reinterpret_cast<__const_Char_ptr>(bp);
}
 
#pragma warning(pop)
 
#undef _NULLPTR
 
#include <boost/scoped_array.hpp>
 
template<size_t cchDest = 128>
class CM2AEX
{
    CHAR szDest_[cchDest];
    boost::scoped_array<char> Str_;
public:
    CM2AEX(const System::String^ _Src)
    {
        pin_ptr<const wchar_t> pwszSrc = PtrToStringChars(_Src);
        
        size_t cchSrc = wcslen(pwszSrc);
        if (cchSrc < cchDest)
        {
            WideCharToMultiByte(CP_ACP, 0, pwszSrc, cchSrc + 1, szDest_, cchDest, 
                NULL, NULL);
        }
        else
        {
            Str_.reset(new char[cchSrc + 1]);
            WideCharToMultiByte(CP_ACP, 0, pwszSrc, cchSrc + 1, Str_.get(), 
                cchSrc + 1, NULL, NULL);
        }
    }
    operator PSTR()
    {
        return Str_.get() ? Str_.get() : szDest_;
    }
private:
    CM2AEX(const CM2AEX&);
    CM2AEX& operator=(const CM2AEX&);
};
 
typedef CM2AEX<> CM2A;
 
template<size_t cchDest = 128>
class CM2WEX
{
    WCHAR wszDest_[cchDest];
    boost::scoped_array<wchar_t> Str_;
public:
    CM2WEX(const System::String^ _Src)
    {
        pin_ptr<const wchar_t> pwszSrc = PtrToStringChars(_Src);
        
        size_t cchSrc = wcslen(pwszSrc);
        if (cchSrc < cchDest)
        {
            lstrcpyW(wszDest_, pwszSrc);
        }
        else
        {
            Str_.reset(new wchar_t[cchSrc + 1]);
            lstrcpyW(Str_.get(), pwszSrc);
        }
    }
    operator PWSTR()
    {
        return Str_.get() ? Str_.get() : wszDest_;
    }
private:
    CM2WEX(const CM2WEX&);
    CM2WEX& operator=(const CM2WEX&);
};
 
typedef CM2WEX<> CM2W;
 
#endif /* RC_INVOKED */
#endif //_INC_VCCLR

OutputDebugString(CM2W(Str));
или если надо продлить время жизни
CM2W _(Str);
OutputDebugString(_);

#include "stdafx.h"
#include <cstdio>
#include <cstdlib>
#include <vcclr.h>
 
using namespace System;
 
int main(array<System::String ^> ^args)
{
    String ^s = "bla bla bla";
    pin_ptr<const wchar_t> wch = PtrToStringChars(s);// to wchar_t*
    printf_s("%S\n", wch);
    size_t conv_chars = 0, sz_in_bytes = (s->Length + 1) * 2;
    errno_t err;
    char *ch = (char*)malloc(sz_in_bytes);
    err = wcstombs_s(&conv_chars, ch, sz_in_bytes, wch, sz_in_bytes);//to char*
    if(err != 0)
      printf_s("wcstombs_s failed\n");
    printf_s("%s", ch);
    Console::ReadKey();
    return 0;
}

#include <msclr/marshal.h>
 
int main()
    {
    msclr::interop::marshal_context ctx;
    System::String ^ str = "Shit!";
    char * unmanaged_str = (char *)ctx.marshal_as<char const *>(str);
    wchar_t * unmanaged_wstr = (wchar_t *)ctx.marshal_as<wchar_t const *>(str);
    }