C++ Programmer's Cookbook

/***

Author - Nishant Sivakumar
Copyright(C) - Nishant Sivakumar 2005

***/

#pragma once

#include <wtypes.h>

#include <vector>
#include <string>

#include <vcclr.h>

using namespace System;
using namespace System::Runtime::InteropServices;

namespace StringUtilities
{
    //Class StringConvertorBase
    //Serves as the abstract base class for StringConvertor and implements
    //default initialization and clean-up code.
    ref class StringConvertorBase abstract
    {
    protected:
        StringConvertorBase()
        {
            InternalInit();    
        }    

        ~StringConvertorBase()
        {
            InternalCleanUp();
        }

        //While the finalizer is included to take care of cases
        //where the destructor does not get called, it's highly inefficient
        //and ruins the purpose of the class if the class is not used
        //with deterministic destruction. It's recommended that you either use
        //the auto-variable non-handle declaration format or explicitly
        //call delete on the StringConvertor object after use.
        !StringConvertorBase()
        {
            InternalCleanUp();

#ifdef _DEBUG
            throw gcnew Exception("Finalizer should not have got called");
#else
            Diagnostics::Trace::WriteLine("Finalizer should not have got called");
#endif
        }

        std::vector< gcroot<IntPtr> >* m_vec_hglobal;
        std::vector< gcroot<IntPtr> >* m_vec_bstr;

        //Frees the allocated unmanaged memory
        void InternalCleanUp()
        {
            for each(gcroot<IntPtr> ptr in *m_vec_hglobal)
            {
                Marshal::FreeHGlobal(ptr);
            }
            m_vec_hglobal->clear();
            delete m_vec_hglobal;

            for each(gcroot<IntPtr> ptr in *m_vec_bstr)
            {
                Marshal::FreeBSTR(ptr);
            }
            m_vec_bstr->clear();
            delete m_vec_bstr;
        }

        void InternalInit()
        {
            m_vec_hglobal = new std::vector< gcroot<IntPtr> >(); 
            m_vec_bstr = new std::vector< gcroot<IntPtr> >(); 
        }
    };

    //Class StringConvertor
    //General purpose convertor class for System::String (both from and to)
    ref class StringConvertor : StringConvertorBase
    {
    protected:
        String^ m_String; //The internal System::String object

    public: 
        //Various constructors each taking a different type as argument
        StringConvertor(String^ s) : m_String(s)
        {
            if(m_String == nullptr)
                throw gcnew Exception("You need to pass a non-null String");            
        }

        StringConvertor(const char* s)
        {
            if(s == nullptr)
                throw gcnew Exception("You need to pass a non-null char*");
            m_String = gcnew String(s);
        }

        StringConvertor(const __wchar_t* s)
        {
            if(s == nullptr)
                throw gcnew Exception("You need to pass a non-null __wchar_t*");
            m_String = gcnew String(s);
        }

        StringConvertor(array<Char>^ s)
        {
            if(s == nullptr)
                throw gcnew Exception("You need to pass a non-null Char array");
            m_String = gcnew String(s);
        }

        StringConvertor(BSTR s)
        {
            if(s == nullptr)
                throw gcnew Exception("You need to pass a non-null BSTR");
            m_String = gcnew String(s);
        }

        StringConvertor(std::string s)
        {
            m_String = gcnew String(s.c_str());
        }

        StringConvertor(std::wstring s)
        {
            m_String = gcnew String(s.c_str());
        }

        //Methods

        virtual String^ ToString() override
        {
            return m_String;
        }

        //Operators

        operator String^()
        {
            return m_String;
        }

        //Properties    

        //Returns an interior pointer to the underlying string. The
        //pointer is of type const Char so you can only read through it.
        property interior_ptr<const Char> InteriorConstCharPtr
        {
            interior_ptr<const Char> get()
            {
                return PtrToStringChars(m_String);            
            }
        }

        //Returns an interior pointer to the underlying string that can be
        //written to. Use with extreme care, as you are directly editing the 
        //System::String's internal character buffer.
        property interior_ptr<Char> InteriorCharPtr
        {
            interior_ptr<Char> get()
            {
                return const_cast< interior_ptr<Char> >(InteriorConstCharPtr);             
            }
        }

        //Generic character mapping to use with LPTSTR.
        //Since it's a #define, intellisense won't show it.

#ifdef _UNICODE 
    #define NativeTCharPtr NativeWideCharPtr
#else
    #define NativeTCharPtr NativeCharPtr
#endif

        //Returns a char* (allocated on the native heap)
        property char* NativeCharPtr
        {
            char* get()
            {
                IntPtr ptr = Marshal::StringToHGlobalAnsi(m_String);
                if(ptr != IntPtr::Zero)
                {
                    m_vec_hglobal->push_back(ptr);
                    return reinterpret_cast<char*>(static_cast<void*>(ptr));
                }
                else 
                    return nullptr;            
            }
        }

        //Returns a __wchar_t* (allocated on the native heap)
        property __wchar_t* NativeWideCharPtr
        {
            __wchar_t* get()
            {
                IntPtr ptr = Marshal::StringToHGlobalUni(m_String);
                if(ptr != IntPtr::Zero)
                {
                    m_vec_hglobal->push_back(ptr);
                    return reinterpret_cast<__wchar_t*>(static_cast<void*>(ptr));
                }
                else 
                    return nullptr;
            }
        }

        //Returns a CLI array of Chars
        property array<Char>^ CharArray
        {
            array<Char>^ get()
            {
                return m_String->ToCharArray();
            }
        }

        //Returns a BSTR allocated natively (unmanaged heap)
        property BSTR BSTRCopy
        {
            BSTR get()
            {
                IntPtr ptr = Marshal::StringToBSTR(m_String);
                if(ptr != IntPtr::Zero)
                {
                    m_vec_bstr->push_back(ptr);
                    return reinterpret_cast<BSTR>(static_cast<void*>(ptr));
                }
                else 
                    return nullptr;    
            }
        }

        //Returns an std::string object
        property std::string STLAnsiString
        {
            std::string get()
            {
                IntPtr ptr = Marshal::StringToHGlobalAnsi(m_String);
                if(ptr != IntPtr::Zero)
                {
                    std::string tmp(reinterpret_cast<char*>(static_cast<void*>(ptr)));
                    Marshal::FreeHGlobal(ptr);
                    return tmp;                    
                }
                return std::string();
            }
        }

        //Returns an std::wstring object
        property std::wstring STLWideString
        {
            std::wstring get()
            {
                IntPtr ptr = Marshal::StringToHGlobalUni(m_String);
                if(ptr != IntPtr::Zero)
                {
                    std::wstring tmp(reinterpret_cast<__wchar_t*>(static_cast<void*>(ptr)));
                    Marshal::FreeHGlobal(ptr);
                    return tmp;                    
                }
                return std::wstring();
            }
        }
    };
}

三，其他

对于COM，在托管代码和非托管代码之间进行的所有调用都必须满足各自编程模型强加的要求。托管和非托管编程模型在很多方面是不同的。下表显示了每个模型的定义特征。

特征	非托管模型	托管模型
代码模型	基于接口	基于对象
标识	GUID	强名称
错误处理机制	HRESULT	异常
类型兼容性	二进制标准	类型标准
类型定义	类型库	元数据
类型安全	非类型安全	可选安全
版本控制	不可变的	灵活的

COM类型对应：

COM 值类型	COM 引用类型	系统类型
bool	bool *	System.Int32
char、small	char *、small *	System.SByte
short	short *	System.Int16
long、int	long *、int *	System.Int32
Hyper	hyper *	System.Int64
unsigned char、byte	unsigned char *、byte *	System.Byte
wchar_t、unsigned short	wchar_t *、unsigned short *	System.UInt16
unsigned long、unsigned int	unsigned long *、unsigned int *	System.UInt32
unsigned hyper	unsigned hyper *	System.UInt64
float	float *	System.Single
double	double *	System.Double
VARIANT_BOOL	VARIANT_BOOL *	System.Boolean
void*	void **	System.IntPtr
HRESULT	HRESULT *	System.Int16 或 System.IntPtr
SCODE	SCODE *	System.Int32
BSTR	BSTR *	System.String
LPSTR 或 [string, ...] char *	LPSTR *	System.String
LPWSTR 或 [string, …] wchar_t *	LPWSTR *	System.String
VARIANT	VARIANT *	System.Object
DECIMAL	DECIMAL *	System.Decimal
DATE	DATE *	System.DateTime
GUID	GUID *	System.Guid
CURRENCY	CURRENCY *	System.Decimal
IUnknown *	IUnknown **	System.Object
IDispatch *	IDispatch **	System.Object
SAFEARRAY( type )	SAFEARRAY( type ) *	type []

四，参考：
        http://www.codeproject.com/managedcpp/StringConvertor.asp

        http://www.voidnish.com/articles/ShowArticle.aspx?code=StringConvertor