C++ Programmer's Cookbook

{C++ 基础} {C++ 高级} {C#界面,C++核心算法} {设计模式} {C#基础}

C++与.NET中基础类型的对应及转化


前言:为了介绍C#写界面,C++写算法的快捷交互开发方式,首先介绍c++,C#内部的DLL,COM调用.

一,基础类型



二,字符类型

/***

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

charsmall

char *small *

System.SByte

short

short *

System.Int16

longint

long *int *

System.Int32

Hyper

hyper *

System.Int64

unsigned charbyte

unsigned char *byte *

System.Byte

wchar_tunsigned short

wchar_t *unsigned short *

System.UInt16

unsigned longunsigned 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.Int16System.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

posted on 2007-05-29 13:55 梦在天涯 阅读(4750) 评论(3)  编辑 收藏 引用 所属分类: CPlusPlusManage c++ /CLI

评论

# re: C++与.NET中基础类型的对应及转化 2007-06-04 14:38 看图软件

好东西饿,支持  回复  更多评论   

# re: C++与.NET中基础类型的对应及转化 2007-06-04 23:22 梦在天涯

非托管 C 语言类型 托管类名 说明
HANDLE void* System.IntPtr 32 位
BYTE unsigned char S ystem.Byte 8 位
SHORT short System.Int16 16 位
WORD unsigned short System.UInt16 16 位
INT int System.Int32 32 位
UINT unsigned int System.UInt32 32 位
LONG long System.Int32 32 位
BOOL bool System.BOOL 8 位
DWORD unsigned long System.UInt32 32 位
ULONG unsigned long System.UInt32 32 位
CHAR char System.Char 用 ANSI 修饰。
LPSTR char* System.String 或 System.StringBuilder 用 ANSI 修饰。
LPCSTR Const char* System.String 或 System.StringBuilder 用 ANSI 修饰。
LPWSTR wchar_t* System.String 或 System.StringBuilder 用 Unicode 修饰。
LPCWSTR Const wchar_t* System.String 或 System.StringBuilder 用 Unicode 修饰。
FLOAT Float System.Single 32 位
DOUBLE Double System.Double 64 位
  回复  更多评论   

# re: C++与.NET中基础类型的对应及转化 2007-06-05 09:41 梦在天涯

msdn 上:
BOOL
long
System.Int32
32 位
  回复  更多评论   


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


公告

EMail:itech001#126.com

导航

统计

  • 随笔 - 461
  • 文章 - 4
  • 评论 - 746
  • 引用 - 0

常用链接

随笔分类

随笔档案

收藏夹

Blogs

c#(csharp)

C++(cpp)

Enlish

Forums(bbs)

My self

Often go

Useful Webs

Xml/Uml/html

搜索

  •  

积分与排名

  • 积分 - 1633320
  • 排名 - 5

最新评论

阅读排行榜