国内久久精品,亚洲一区二区不卡免费,亚洲人午夜精品免费

梦在天�� — Fri, 18 Jul 2008 14:28:00 GMT

一、��A�?/strong>

当微软推出VS.NET7实现了可扩展的托��C++后，C++�E�序员们反映不一。尽��大部分的程序员对于能够�l�箋使用C++感到很欣慎ͼ�但几乎所有的人对于托��C++提供的晦涩语法感到很痛苦。微软明显从反馈中感觉到托管C++不是那么成功�?

2003�q?0�?日，ECMA�Q�欧�z�计��机刉��商协会�Q�宣布成立专家组�Q�负责结合ISO标准C++与通用语言�Q�开发一个可扩展语言的标准，�q�个新的可扩展语�a�被称为C++/CLI标准。这个标准将被VS.NET2005的C++�~�译器支持�?

二、老语法存在的问题

1、晦涩繁琐的语法和文�?-�q�两�?双重底线"问题加重了阅�ȝ��负担�?

2、二��的CLI支持--相对与C#与VB.NET�Q�MC++使用不方便的工作区来提供CLI支持�Q�例如，它没有一个一一对应的结构来列�D.NET的集合�?

3、C++�?NET�_�陋地结�?-对于CLI�c�d��Q�你不能使用C++的特�Ԍ��例如模板�Q�同��P��对于C++�c�d��Q�你不能使用CLI的特�Ԍ��例如��片帐集�?

4、��o人�؜淆的指针--非托��的C++的指针及托管的引用指针都使用*语法�Q�这非常令�h��h��Q�因�?gc指针与托��指针在本质和行��Z��完全不同�?

5、MFC�~�译器不能��生可校验的代码�?

三、C++/CLI�l�我们提供了什么？

1、优雅流畅的语法和文�?-C++/CLI为C++开发�h员书写托��代码提供了一�U�非常自然的感觉�Q��ƈ且它提供了非托管代码到托��代码的�q�x��q�度。以前所谓的"双重底线"问题现在已经荡然无存�?

2、一��的CLI支持--CLI特色�Q�例如属性、碎片集合和属类得到了直接支持，此外�Q�C++/CLI�q�准许将�q�些特色用于本地非托��的�c�R�?

3、一��的C++�c�L��?-C++特色�Q�例如模板和析构函数对于拖管和非拖管�cȝ��l�有效。实际上�Q�C++/CLI是你可以"表面�?在栈或C++本地堆上声明一�?NET�c�d��唯一�?NET语言�?

4、在.NET与C++之间的沟壑上架�v了一座桥�?-C++开发�h员在抨击BCL时不再象��d��水的鱹{�?

5、C++/CLI�~�译器��生的可执行文件完全是可校验的�?

四�?Hello World"��程�?/strong>

using namespace System;
            void _tmain()
            {
            Console::WriteLine("Hello World");
            }

上述代码除了不需要引用mscorlib.dll库外�Q�与老的语法没有太大的区别，因�ؓ无论你什么时候��?clr�q�行�~�辑�Q�编译器都可以暗中进行引用（现在默认的是/clr:newSyntax�Q��?
五、句�?/strong>
与老的语法主要的�؜淆是我们习惯于��?�W�号来声明拖��引用或非拖��指针，在C++/CLI里微软引入了句柄的概��c�?

void _tmain() { //The ^ punctuator represents a handle String^ str = "Hello World"; Console::WriteLine(str); }

^�W�号代表一个托��对象（声明时看上去象个帽子�Q�，按照CLI的规定，句柄代表一个拖��对象的引用。句柄在CLI中是新的语法�Q�相当于C++中的-gc指针。句柄与指针不再��h��Q�在本质上两者完全不同�?
六、句柄与指针是怎样区分开来的�Q?/strong>
1、指针声明时使用*�W�号�Q�而句柄��用^�W�号�?
2、句柄是针对拖管堆上对象的拖��引用，而指针仅仅指向内存中的一个地址�?
3、指针很�E�_��Q�GC循环不会影响到它�Q�句柄在��Z��GC或内存紧张的情况下，可以指向不同的内存位�|��?
4、对于指针，�E�序开发�h员必��?昑ּ�"地删除，否则会面临泄露的危险�Q�而对于句柄，是否�q�行昑ּ�删除则完全根据程序�h员的爱好了�?
5、句柄一定要指向一个具体的�c�d��Q�即所谓的�c�d��安全性，而指针明显不是这��P��你决不可以将一个句柄指向Void^�c�d��?
6、正如new操作�W�返回一个指针一��P��gcnew�q�回一个句柄�?
七、CLR对象�C�Z��

void _tmain() { String^ str = gcnew String("Hello World"); Object^ o1 = gcnew Object(); Console::WriteLine(str); }

关键字gcnew用来实例化一个CLI对象�Q�而且它返回一个指向在CLR堆上的对象的句柄�Q�gcnew的优点在于它可以方便的让我们区分拖管和非拖管的实例对象�?
大部分情况下�Q�gcnew关键字和^操作�W�提供了你用来进行BCL的一切手�D�，但是很明显你需要创建和声明属于自己的拖��类和接口�?
八、声明类�?
CLR�c�d��有一个�Ş容词前缀用来说明�c�d��的种�c�，下面是C++/CLI中的�c�d��声明�C�Z��Q?

1�?CLR types o Reference types § ref class RefClass; § ref struct RefClass; 2�?Value types § value class ValClass; § value struct ValClass; o Interfaces § interface class IType; § interface struct IType; o Enumerations § enum class Color; § enum struct Color; 3�?Native types o class Native; o struct Native; �C�Z��Q? using namespace System; interface class IDog { void Bark(); }; ref class Dog : IDog { public: void Bark() { Console::WriteLine("Bow wow wow"); } }; void _tmain() { Dog^ d = gcnew Dog(); d->Bark(); }

上述�E�序中的代码与老的C++语言相比看上去非常简�z�，在以往的C++代码中，臛_��要用�?gc�?interface�q�两个关键词�?
九、装��?拆箱操作
在C++/CLI中，加箱是隐含的�Q�而且�c�d��是安全的�Q�一个二�q�制的拷贝被执行�q�在CLR堆上形成一个对象，�ȝ��是显式的�Q�仅仅需要��用reinterpret_cast操作�W�来解除引用�?

void _tmain() { int z = 44; Object^ o = z; //implicit boxing int y = *reinterpret_cast(o); //unboxing Console::WriteLine(" ",o,z,y); z = 66; Console::WriteLine(" ",o,z,y); } // 输出�l�果如下�Q? // 44 44 44 // 44 66 44

在上�q�C��码中�Q?o"对象是一个加��q��拯��Q�从�W�二个语句Console::WriteLine.的输出可以很明显地看刎ͼ�它�ƈ没有涉及到int�c�d��的整数倹{�?
当你对一�U�数值类型进行加��操作时�Q�返回的对象��C��了最初的数值类型�?

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; Console::WriteLine(o1->GetType()); Console::WriteLine(o2->GetType()); } // Output // System.Int32 // System.Single

因此不能对不同类型的对象�q�行�ȝ��操作�?

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; int y = *reinterpret_cast(o2);//System.InvalidCastException float g = *reinterpret_cast(o1);//System.InvalidCastException }

如果你非��试�q�么做，那么你将得到一个System.InvalidCastException。让我们来探讨一下完��的�c�d��安全性，如果你要看内部代码，你将看到微��Y的内部箱在实际中的运用。例如：

void Box2() { float y=45; Object^ o1 = y; }

�~�译后的代码是：

.maxstack 1 .locals (float32 V_0, object V_1) ldnull stloc.1 ldc.r4 45. stloc.0 ldloc.0 box [mscorlib]System.Single stloc.1 ret

�Ҏ��微��Y的内部文档，��操作将未加工的�c�d��转换��Z��个具体类型的实例�Q�这��工作的完成通过创徏一个新的对象�ƈ��数据拷贝到�q�个新分配的对象�?
十、写在后面的�?/strong>
��Z��么很多�h已经可以使用C、C++�?NET来开发程序但�q�在�U�极学习C++/CLI呢，我想有四个方面的原因�Q?
1、从�~�译器直到内层都�q�在支持C++代码�Q?
2、C++/CLI对于其他标准来说无意是具有毁灭性地�Q?
3、与生俱来的内部支持胜过所有其他CLI语言
4、所有在MFC中出现的下划�U�K��已不再存在�?/p>

梦在天�� 2008-07-18 22:28 发表评论

C++/CLI 中文

梦在天�� — Fri, 18 Jul 2008 14:18:00 GMT

C++/CLI中文文章�Q?br>

一�Q?br>
C++/CLI�Q�第一��的CLI语言(转蝲)

二，

梦在天�� 2008-07-18 22:18 发表评论

C++/CLI�Q�第一��的CLI语言(转蝲)

梦在天�� — Fri, 18 Jul 2008 14:12:00 GMT

C++/CLI�Q�第一��的CLI语言
2005-08-25 11:25 作者：朱先忠编�?出处�Q?天极�|?责�Q�~�辑�Q�方�?

1. ��?br>
　　本文�q�不是�ؓ了奉承C++/CLI的辉煌，也不是�ؓ了贬低其它如C#或者VB.NET�{�语�a��Q�相反，�q�只是一个非官方的、以一个喜�Ƣ这�U�语�a�的非微��Y雇员�w�䆾来论证C++/CLI有它的自��q��唯一的角�Ԍ��可作为第一��的.NET�~�程语言�?br>
　　一个不断在新闻�l�和技术论坛上出现的问题是�Q�当象C#和VB.NET�q�样的语�a�更适合于这�U�用途时�Q��ؓ什么要使用C++来开�?NET应用软�g。通常�q�样一些问题后面的评论说是�Q�C++语法是怎样的复杂和令�h费解�Q�C++现在是怎样一�U�过时的语言�Q�还有什么VS.NET设计者已不再像支持C#和VB.NET一��L��l�支持C++。其中一些猜疑是完全荒谬的，但有些说法部分正��。希望本文有助于澄清所有这些围�l�C++/CLI语言及其在VS.NET语言层次中的��C��的疑惑，��秘和不信�Q。请��C��Q�本作者既不�ؓ微��Y工作也没有从微��Y那里取得报酬�Q�只是想从技术上对C++/CLI作一评判�?br>
　　2. 快速简�z�的本机interop

　　除了P/Invoke机制可用在另外的象C#或VB.NET�q�样的语�a�外，C++提供了一�U�独有的interop机制�Q�称作C++ interop。C++ interop比P/Invoke直观得多�Q�因��Z��只是��单地#include需要的头文�Ӟ��q�与需要的库进行链接就能象在本机C++中一栯��用�Q何函数。另外，它比P/Invoke速度�?-�q�是很容易能证明的。现在，可争辩的是在实际应用软�g的开发中�Q�经由C++ interop获得的性能好处与花在用��h��口交互、数据库存取�?a class=bluekey target=_blank>�|�络数据转储、复杂数学算法等斚w��的时间相比可以被忽略�Q�但是事实是在有些情况下�Q�甚至通过每次interop调用节省的几个纳�U�也能给全局应用�E�序性能/响应造成巨大影响�Q�这是绝对不能被忽视的。下面有两部分代码片�?一个是使用P/Invoke机制的C#�E�序�Q�一个是使用C++ Interop机制的C++�E�序)�Q�我分别记录了其各自代码重复执行消耗的旉��(毫秒)。不��你如何解释�q�些数据�Q�不��这会对你的应用�E�序产生什么媄响，全是你的事。我仅打��事实性地指出�Q�C++代码的执行速度要比C#(其中使用了较多的本机interop调用)快�?br>
　　1) C#�E�序(使用P/Invoke)

[SuppressUnmanagedCodeSecurity]
[DllImport("kernel32.dll")]
static extern uint GetTickCount();
[SuppressUnmanagedCodeSecurity]
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
static extern uint GetWindowsDirectory(
[Out] StringBuilder lpBuffer, uint uSize);
static void Test(int x)
{
StringBuilder sb = new StringBuilder(512);
for (int i = 0; i < x; i++)
GetWindowsDirectory(sb, 511);
}
static void DoTest(int x)
{
uint init = GetTickCount();
Test(x);
uint tot = GetTickCount() - init;
Console.WriteLine("Took {0} milli-seconds for {1} iterations",tot, x);
}
static void Main(string[] args)
{
DoTest(50000);DoTest(500000);DoTest(1000000);DoTest(5000000);
Console.ReadKey(true);
}

　　2) C++�E�序(使用C++ Interop)

void Test(int x)
{
TCHAR buff[512];
for(int i=0; iGetWindowsDirectory(buff, 511);
}
void DoTest(int x)
{
DWORD init = GetTickCount();
Test(x);
DWORD tot = GetTickCount() - init;
Console::WriteLine("Took {0} milli-seconds for {1} iterations",tot, x);
}
int main(array ^args)
{
DoTest(50000);DoTest(500000);DoTest(1000000);DoTest(5000000);
Console::ReadKey(true);
return 0;
}

　　3) 速度比较

重复�ơ数 C# �E�序 C++�E�序

50,000 61 10

500,000 600 70

1,000,000 1162 140

5,000,000 6369 721

　　
　　其性能差别真是令�h惊愕�Q�这的确是说明�ؓ什么要使用C++/CLI的一个好理由�Q�如果你在��用本机interop�q�行开发，那么性能�Q�完全由于性能�Q�我��将被迫借助本机interop来实现�ƈ非基于web�?NET应用�E�序。当�Ӟ��Z��么我惌��使用.NET来开发需要大量本机interop技术的应用�E�序完全是另外一个问题�?br>
　　如果你仍怀疑这�U�性能优势�Q�有另外的理由来说明你�ؓ什么不得不使用C++/CLI而不是C#或VB.NET——源码膨胀�Q�下面是一个C++函数的例子，它��用了IP帮助者API来枚举一台机器上的网�l�适配器�ƈ且列��Z��每个适配器相联系的所有IP地址�?br>
　　4) 枚�Dn/w适配器的C++代码

void ShowAdapInfo()
{
PIP_ADAPTER_INFO pAdapterInfo = NULL;
ULONG OutBufLen = 0;
//得到需要的�~�冲区大��?br>if(GetAdaptersInfo(NULL,&OutBufLen)==ERROR_BUFFER_OVERFLOW)
{
int divisor = sizeof IP_ADAPTER_INFO;
#if _MSC_VER >= 1400
if( sizeof time_t == 8 ) divisor -= 8;
#endif
pAdapterInfo = new IP_ADAPTER_INFO[OutBufLen/divisor];
//取得适配器信�?br>if( GetAdaptersInfo(pAdapterInfo, &OutBufLen) != ERROR_SUCCESS )
{//调用��p�| }
else
{
int index = 0;
while(pAdapterInfo)
{
Console::WriteLine(gcnew String(pAdapterInfo->Description));
Console::WriteLine("IP Address list : ");
PIP_ADDR_STRING pIpStr = &pAdapterInfo->IpAddressList;
while(pIpStr)
{
Console::WriteLine(gcnew tring(pIpStr->IpAddress.String));
pIpStr = pIpStr->Next;
}
pAdapterInfo = pAdapterInfo->Next;
Console::WriteLine();
}
}
delete[] pAdapterInfo;
}
}

　　现在让我们看一个��用P/Invoke的C#版本�?br>
　　5) 使用P/Invoke技术的C#版本

const int MAX_ADAPTER_NAME_LENGTH = 256;
const int MAX_ADAPTER_DESCRIPTION_LENGTH = 128;
const int MAX_ADAPTER_ADDRESS_LENGTH = 8;
const int ERROR_BUFFER_OVERFLOW = 111;
const int ERROR_SUCCESS = 0;
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct IP_ADDRESS_STRING
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
public string Address;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct IP_ADDR_STRING
{
public IntPtr Next;
public IP_ADDRESS_STRING IpAddress;
public IP_ADDRESS_STRING Mask;
public Int32 Context;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct IP_ADAPTER_INFO
{
public IntPtr Next;
public Int32 ComboIndex;
[MarshalAs(UnmanagedType.ByValTStr,
SizeConst = MAX_ADAPTER_NAME_LENGTH + 4)]
public string AdapterName;
[MarshalAs(UnmanagedType.ByValTStr,
SizeConst = MAX_ADAPTER_DESCRIPTION_LENGTH + 4)]
public string AdapterDescription;
public UInt32 AddressLength;
[MarshalAs(UnmanagedType.ByValArray,
SizeConst = MAX_ADAPTER_ADDRESS_LENGTH)]
public byte[] Address;
public Int32 Index;
public UInt32 Type;
public UInt32 DhcpEnabled;
public IntPtr CurrentIpAddress;
public IP_ADDR_STRING IpAddressList;
public IP_ADDR_STRING GatewayList;
public IP_ADDR_STRING DhcpServer;
public bool HaveWins;
public IP_ADDR_STRING PrimaryWinsServer;
public IP_ADDR_STRING SecondaryWinsServer;
public Int32 LeaseObtained;
public Int32 LeaseExpires;
}
[DllImport("iphlpapi.dll", CharSet = CharSet.Ansi)]
public static extern int GetAdaptersInfo(IntPtr pAdapterInfo, ref int pBufOutLen);
static void ShowAdapInfo()
{
int OutBufLen = 0;
//得到需要的�~�冲区大��?br>if( GetAdaptersInfo(IntPtr.Zero, ref OutBufLen) ==
ERROR_BUFFER_OVERFLOW )
{
IntPtr pAdapterInfo = Marshal.AllocHGlobal(OutBufLen);
//取得适配器信�?br>if( GetAdaptersInfo(pAdapterInfo, ref OutBufLen) != ERROR_SUCCESS )
{ //调用��p�|�?}
else{
while(pAdapterInfo != IntPtr.Zero)
{
IP_ADAPTER_INFO adapinfo =
(IP_ADAPTER_INFO)Marshal.PtrToStructure(
pAdapterInfo, typeof(IP_ADAPTER_INFO));
Console.WriteLine(adapinfo.AdapterDescription);
Console.WriteLine("IP Address list : ");
IP_ADDR_STRING pIpStr = adapinfo.IpAddressList;
while (true){
Console.WriteLine(pIpStr.IpAddress.Address);
IntPtr pNext = pIpStr.Next;
if (pNext == IntPtr.Zero)
break;
pIpStr = (IP_ADDR_STRING)Marshal.PtrToStructure(
pNext, typeof(IP_ADDR_STRING));
}
pAdapterInfo = adapinfo.Next;
Console.WriteLine();
}
}
Marshal.FreeHGlobal(pAdapterInfo);
}
}

3. 栈语义和��定性的析构

　　C++�l�由栈语义模仿给了我们确定性的析构。简�a�之，栈语义是Dispose模式的良好的语法替代品。但是它在语义上比C# using块语法更直观些。请看下列的C#和C++代码�D�（都做一��L��事情-�q�接两个文�g的内容�ƈ把它写到�W�三个文件中�Q��?br>
　　1) C#代码--使用块语�?br>

public static void ConcatFilestoFile(String file1, String file2, String outfile)
{
String str;
try{
using (StreamReader tr1 = new StreamReader(file1))
{
using (StreamReader tr2 = new StreamReader(file2))
{
using (StreamWriter sw = new StreamWriter(outfile))
{
while ((str = tr1.ReadLine()) != null)
sw.WriteLine(str);
while ((str = tr2.ReadLine()) != null)
sw.WriteLine(str);
}
}
}
}
catch (Exception e)
{ Console.WriteLine(e.Message); }
}

　　2) C++代码--栈语�?br>

static void ConcatFilestoFile(String^ file1, String^ file2, String^ outfile)
{
String^ str;
try{
StreamReader tr1(file1);
StreamReader tr2(file2);
StreamWriter sw(outfile);
while(str = tr1.ReadLine())
sw.WriteLine(str);
while(str = tr2.ReadLine())
sw.WriteLine(str);
}
catch(Exception^ e)
{ Console::WriteLine(e->Message); }
}

　　C#代码与相�{�的C++ 代码相比不仅免不了冗长，而且using块语法让�E�序员自己明��地指定他想在哪儿调用Dispose�Q�using块的�l�束处）�Q�而��用C++/CLI的栈语义�Q�只需让编译器使用常规的范围规则来处理它即可。事实上�Q�这使得在C#中修改代码比在C++中更乏味-作�ؓ一实例�Q�让我们修改�q�些代码以便即��仅存在一个输入文件也能创��出文件。请看下面修改后的C#和C++代码�?br>
　　3) 修改后的C#代码

public static void ConcatFilestoFile(String file1, String file2, String outfile)
{
String str;
try{
using (StreamWriter sw = new StreamWriter(outfile))
{
try{
using (StreamReader tr1 = new StreamReader(file1))
{
while ((str = tr1.ReadLine()) != null)
sw.WriteLine(str);
}
}
catch (Exception) { }
using (StreamReader tr2 = new StreamReader(file2))
{
while ((str = tr2.ReadLine()) != null)
sw.WriteLine(str);
}
}
}
catch (Exception e){ }
}

　　把针对StreamWriter的using块放到顶层需要重新调整using块结�?-�q�在上面情况下显然不是个大问题，但是对于实际开发中的修改，�q�可能是相当模糊的且易导致逻辑错误的�?br>
　　4) 修改后的C++代码

static void ConcatFilestoFile(String^ file1, String^ file2, String^ outfile)
{
String^ str;
try{
StreamWriter sw(outfile);
try{
StreamReader tr1(file1);
while(str = tr1.ReadLine())
sw.WriteLine(str);
}
catch(Exception^){}
StreamReader tr2(file2);
while(str = tr2.ReadLine())
sw.WriteLine(str);
}
catch(Exception^){}
}

　　�q�样不是比在C#中的做更�Ҏ��些吗�Q�我恰好把StreamWriter声明�U�d��了顶部�ƈ增加了一个额外的try块，��p��些。甚臛_��于象在我的示例代码片断中的琐��事情，如果所涉及的复杂性在C++中大大减��，那么�Q�当你工作于更大的工�E�时你能惌��使用栈语义对你的�~�码效率千万的媄响�?br>
　　�q�不��信�Q�好�Q�让我们看一下成员对象和它们的析构吧。Imagine CLI GC�c�R1和R2�Q�二者都实现了Idisposable接口且都有函数F()�Q�还有一个CLI GC�c�R�Q�它有R1和R2成员和一个函数F()-它内部地调用R1和R2上的F()成员函数。让我们先看C#实现�?br>
　　5) 一个disposable�cȝ��承层�ơ的C#实现

class R1 : IDisposable{
public void Dispose() { }
public void F() { }
}
class R2 : IDisposable{
public void Dispose() { }
public void F() { }
}
class R : IDisposable{
R1 m_r1 = new R1();
R2 m_r2 = new R2();
public void Dispose()
{
m_r1.Dispose();
m_r2.Dispose();
}
public void F()
{
m_r1.F();
m_r2.F();
}
public static void CallR()
{
using(R r = new R())
{r.F();}
}
}

　　�q�里有几件事情要做：必须为每个disposable �c�L��工实现IDisposable接口�Q�对于具有成员R1和R2的类R�Q�Dispose�Ҏ��也需要调用成员类上的Dispose。现在让我们分析上面几个�cȝ��C++实现�?br>
　　6) �{��h的C++实现

ref class R1
{
public:
~R1(){}
void F(){}
};
ref class R2
{
public:
~R2(){}
void F(){}
};
ref class R
{
R1 m_r1;
R2 m_r2;
public:
~R(){}
void F()
{
m_r1.F();
m_r2.F();
}
static void CallR()
{
R r;
r.F();
}
};

　　注意�Q�这里不再有手工的Idisposable接口实现(我们的类中仅建立了析构器)而且最好的部分--�c�R的析构器(Dispose�Ҏ��)�q�没有在该类可能含有的可释放的成员上调用Dispose-它没有必要这样做�Q�编译器自动��Z��生成所有的代码�Q?

4. 混合�c�d��

　　我们知道�Q�C++支持本机�c�d��-��L��如此�Q�C++支持CLI�c�d��-本文正是特别��q�一点；它还支持混合�c�d��-��h��CLI成员的本机类型和��h��本机成员的CLI�c�d��Q�请��管考虑所有你能的可能需求�?br>
　　注意�Q�谈到Whidbey�Q��؜合类型实现还不完��_��我从Brandon�Q�Herb和Ronald发表的材料的理解得知�Q�存在这�U�相当酷的类�?-�l�一模型�Q�它��在Orcas中实�?-你能够在本机C++堆上new/delete CLI�c�d��Q�而且也能够在CLI堆上gcnew/delete本机�c�d��。但既然�q�是Whidbey以后的东西，本文不讨论统一模型�?br>
　　在我谈论你何时��用�؜合类型以前，我想向你说明什么是混合�c�d��。如果你理解混合�c�d��Q�请跌��下面几段。这里引用Brandon Bray的说法："一�U��؜合类型，或者是本机�c�ref�c�（需要有对象成员�Q�，或者是通过声明或��承被分配在垃圑֛�收堆或本机堆上的�?因此如果你有一个托��类型或者有一个有托管成员的本机类型，你就有了一个�؜合类型。VC++ Whidbey不直接支持�؜合类�?�l�一�c�d��模型是一�U�Whidbey之后的概�?�Q�但是它�l�我们划定了实现混合�c�d��的条件。让我们开始讨论包含托��成员的本机�c�d��?br>

ref class R
{
public:
void F(){}
//假定 non-trivial ctor/dtor
R(){}
~R(){}
};

　　在我的例子中�Q�设惌��托管�c�d��R有一个non-trivial构造器和一个non-trivial析构器�?br>

class Native
{
private:
gcroot m_ref;
public:
Native():
m_ref(gcnew R()){}
~Native()
{ delete m_ref; }
void DoF()
{ m_ref->F(); }
};

　　既然�Q�我不能在我的类中拥有一个R成员�Q�我使用了gcroot模板�c?在gcroot.h中声明，但是你要�?#include vcclr.h")�Q�它包装了System::Runtime::InteropServices::GCHandle�l�构。它是个象类一��L��灉|��指针�Q�它重蝲了运��符->以返回用作模板参数的托管�c�d��。因此在上面�c�M��Q�我可以使用m_ref�Q�就好象我已�l�声明它是R^�Q�而且你能在DoF函数中看到这正在起作用。实际上你可以节省delete�Q�这可以通过使用auto_gcroot(�c�M��于std::auto_ptr�Q�在msclr\auto_gcroot.h文�g中声�?代替gcroot来实现。下面是一个更好些的��用auto_gcroot的实现�?br>

class NativeEx
{
private:
msclr::auto_gcroot m_ref;
public:
NativeEx() : m_ref(gcnew R()){}
void DoF()
{ m_ref->F(); }
};

　　下面让我们看相反的情形：一个CLI�cȝ��本机成员�?br>

ref class Managed
{
private:
Native* m_nat;
public:
Managed():m_nat(new Native()){ }
~Managed()
{ delete m_nat; }
!Managed()
{ delete m_nat;
#ifdef _DEBUG
throw gcnew Exception("Oh, finalizer got called!");
#endif
}
void DoF()
{ m_nat->DoF(); }
};

　　我不能定义一个Native对象来作��Z��个ref�c�L��员，因此需要��用一个Native*对象来代�ѝ��我在构造器中new该Native对象�Q�然后在析构器和finalizer中delete它。如果你�q�行该工�E�的调试版，在执行到finalizer时将抛出一个异�? 因此开发者可以马上添加一个对delete的调用或��Z��的CLI�c�d��使用栈语义技术。奇怪的是，库开发小�l�没有徏立一个gcroot的反向实�?但这不是个大问题�Q�我们可以自己写�?br>

template ref class nativeroot
{
T* m_t;
public:
nativeroot():m_t(new T){}
nativeroot(T* t):m_t(t){}
T* operator->()
{ return m_t; }
protected:
~nativeroot()
{ delete m_t; }
!nativeroot()
{
delete m_t;
#ifdef _DEBUG
throw gcnew Exception("Uh oh, finalizer got called!");
#endif
}
};

　　�q�仅是个相当��单的灉|��指针实现�Q�就象一个负责本机对象分�?回收的ref�c�R��不��怎样�Q�借助nativeroot模板�c�，我们可以如下修改托管�c�：

ref class ManagedEx
{
private:
nativeroot m_nat;
public:
void DoF()
{ m_nat->DoF(); }
};

　　好，关于混合�c�d��的最大问题是什么呢�Q�你可能问。最大问题是�Q�现在你能�؜合��用你的MFC、ATL、WTL、STL代码仓库�?NET框架�Q��ƈ用可能的最直接的方�?只需写你的�؜合模式代码�ƈ�~�译实现!你可以徏立在一个DLL库中建立MFC �c�，然后建立一�?NET应用�E�序来调用这个DLL�Q�还需要把.NET�c�L��员添加到你的MFC�c�（也实现可以相反的情况�Q��?br>
　　作�ؓ一例，设想你有一MFC对话�?-它通过一个多行的�~�辑框接受来自用��L��数据-现在�Q�你有一新的要求-昄��一个只�ȝ��辑框�Q�它��显�C�当前在该多行编辑框中文本的md5哈希�l�果。你的队友正在悲叹他们将必须��p��几个��时�ȝ��crypto API�Q�而你的上司在担忧你们可能必须要买一个第三方加密库；那正是你在他们面前树立�Ş象的时候，你宣布你��在15分钟内做完这��Q务。下面是解决的办法：

　　��d��一个新的编辑框��C��的对话框资源中，�q�且��d��相应的DDX变量。选择/clr�~�译模式�q�且��d��下列代码��C��的对话框的头文�g中：

#include
using namespace System::Security::Cryptography;

　　使用auto_gcroot模板来声明一个MD5CryptoServiceProvider成员�Q?br>

protected:
msclr::auto_gcroot md5;

　　在OnInitDialog�q�程中，gcnew MD5CryptoServiceProvider成员�?br>

md5 = gcnew MD5CryptoServiceProvider();

　　�q�且为多行编辑框��d��一个EN_CHANGE处理器：

void CXxxxxxDlg::OnEnChangeEdit1()
{
using namespace System;
CString str;
m_mesgedit.GetWindowText(str);
array^ data = gcnew array(str.GetLength());
for(int i=0; idata[i] = static_cast(str[i]);
array^ hash = md5->ComputeHash(data);
CString strhash;
for each(Byte b in hash)
{
str.Format(_T("%2X "),b);
strhash += str;
}
m_md5edit.SetWindowText(strhash);
}

　　�q�里使用了�؜合类型：一个本机Cdialog�z��c�，该类含有一个MD5CryptoServiceProvider成员(CLI�c�d��)。你可以��L��地试验相反的情况�Q�如早期的代码片断已昄��的）——可以徏立一个Windows表单应用�E�序而且可能惛_��用一个本机类�?-�q�不成问题，使用上面定义的模板nativeroot卛_��?br>
5. 托管模板

　　也许你对泛型的概念已很清楚了�Q�它帮助你避免进入C++的模板梦��，它是实现模板的最��x��式，�{�等。好�Q�假设这些全部正��，C++/CLI支持泛型��p��M��其它CLI语言一�?但是它有而其它一些CLI语言�q�没有的是它�q�支持托��模�?也就是模板化的ref和value�c�R��如果你以前从未使用�q�模板，你不能一下欣赏这么多优点�Q�但是如果你有模板��用背景而且你已发现了泛型中存在的可能限制你�~�码的方式，托管模板��会大大减轻你的负担。你能联合��用泛型和模板- 事实上有可能用一个托��类型的模板参数来实例化一个泛型类�?��管相反的情形是不可能的�Q�因��行时��d��例化由泛型所�?。STL.NET (或STL/CLR)以后讨论�Q�请很好地利用泛型和托管模板的�؜合编�E�吧�?br>
　　泛型使用的子�c�d��U�束机制��防止你写出下面的代码：

generic T Add(T t1, T t2)
{ return t1 + t2; }

　　�~�译错误�Q?br>

error C2676: binary ’+’ : ’T’ does not define this operator or a conversion to a type acceptable to the predefined operator

　　现在��L��相应的模板版本：

template T Add(T t1, T t2)
{ return t1 + t2; }

　　那么��可以这样做�Q?br>

int x1 = 10, x2 = 20;
int xsum = Add(x1, x2);

　　�q�可以这样做�Q?br>

ref class R
{
int x;
public:
R(int n):x(n){}
R^ operator+(R^ r)
{ return gcnew R(x + r->x); }
};
//...
R^ r1 = gcnew R(10);
R^ r2 = gcnew R(20);
R^ rsum = Add(r1, r2);

　　�q�在一个象int的本机类型以及一个ref�c�d��(只要ref�c�d��有一�?�q�算�W?情况下都能工作良好。这个泛型缺点不是一个调试错误或�~�陷-它是设计造成的。泛型的实例化是在运行时通过调用配�g集实现的�Q�因此编译器不能��知一特定操作能被施行于一个泛型参敎ͼ�除非它匹配一个子�c�d��U�束�Q�因此编译器在定义泛型时解决�q�个问题。当你��用泛型时的另外一个妨��是�Q�它不会允许你��用非�c�d��参数。下列泛型类定义不会�~�译�Q?br>

generic ref class G{};

　　�~�译错：

error C2978: syntax error : expected ’typename’ or ’class’; found type ’int’; non-type parameters are not supported in generics

　　与托��模板相比较�Q?br>

template ref class R{};

　　如果你开始感�ȀC++向你提供了泛型和托管模板�Q�那么请看下面这一个例子：

template ref class R{
public:
void F()
{ Console::WriteLine("hey"); }
};
template<> ref class R
{
public:
void F()
{ Console::WriteLine("int"); }
};

　　你不能用泛型�q�样�~�码�Q�否则，��生：

　　�~�译错：error C2979: explicit specializations are not supported in generics

　　但可以在�l�承链中混合使用模板和泛型：

generic ref class Base
{
public:
void F1(T){}
};
template ref class Derived : Base
{
public:
void F2(T){}
};
//...
Derived d;
d.F1(10);
d.F2(10);

　　最后，你不能从一个泛型参数类型派生一个泛型类�?br>
　　下列代码不会成功�~�译�Q?br>

generic ref class R : T
{};

　　error C3234: a generic class may not derive from a generic type parameter

　　模板让你�q�样�?好像你还不知道这�?�Q?br>

ref class Base{
public:
void F(){}
};
generic ref class R : T
{};
//...
R r1;
r1.F();

　　�q�样�Q�当你下�ơ遇到对泛型的贬谤时�Q�你��q��道该怎么做了�?br>
　　6. STL/CLR

　　当大量��用STL的C++开发者�{�?NET1/1.1时一定感觉非常别扭，他们中的许多可能会放弃�ƈ转回到原来的本机�~�码。从技术上�Ԍ��你能�l�合.NET�c�d��(using gcroot)使用本机STL�Q�但是��生的�l�果代码可能相当低效�Q�更不用说是丑陋了：

std::vector< gcroot >* m_vec_hglobal;
//...
for each(gcroot ptr in *m_vec_hglobal)
{ Marshal::FreeHGlobal(ptr);}

　　大概VC++��组考虑��C��q�些�q�决定在Whidbey以后�Q�他们会提供STL.NET�Q�或STL/CLR�Q��ƈ可以单独从网上下载�?br>
　　你可能问��Z��么？Stan Lippman�Q�在他的MSDN文章(STL.NET Primer)中给��Z��3条原因：

　　·可扩展�?-STL设计把算法和容器隔离到自��q��应用�I�间-也就是你可以有一�l�容器和一�l�算法，�q�且你能在�Q何一个容器上使用�q�些��法�Q�同时你能在��M��一个算法中使用�q�些容器。因此，如果你添加一�U�新的算法，你能在�Q何一�U�容器中使用它；同样�Q�一个新的容器也可以与现有算法配合��用�?br>
　　·�l�一�?-所有核心C++开发者集中在一��P��汇集起他们精妙的STL专长�Q�再使用他们的专长则轻�R熟�\。要较好��C��用STL需要花�Ҏ��?然而一旦你掌握了它�Q�你��有了在.NET世界中��用你的技巧的明显优势。不是吗�Q?br>
　　·性能--STL.NET通过使用实现泛型接口的托��模板实现。�ƈ且既然它的核心已用C++和托��模板编码，可以期盼它比在BCL上��用的泛型容器更具有性能优势�?br>
　　使用�q�STL的�h不需要�Q何示范，所以下面代码有益于以前没有使用�q�STL的�h�?br>

vector vecstr;
vecstr.push_back("wally");
vecstr.push_back("nish");
vecstr.push_back("smitha");
vecstr.push_back("nivi");
deque deqstr;
deqstr.push_back("wally");
deqstr.push_back("nish");
deqstr.push_back("smitha");
deqstr.push_back("nivi");

　　我��用了两个STL.NET容器-vector和deque�Q��ƈ装满两个容器�Q��其看��h��相同(在两个容器中都��用了push_back)。现在，我将在两个容器上使用replace��法-我们再次看到�Q�这些代码是很相同的�?br>

replace(vecstr.begin(), vecstr.end(),
gcnew String("nish"), gcnew String("jambo"));
replace(deqstr.begin(), deqstr.end(),
gcnew String("nish"), gcnew String("chris"));

　　�q�里特别要注意的是我使用�?同样"的算�?-replace�q�在两个不同STL容器上��用相同的函数调用。这是当Stan谈及"可扩展�?时的意思。下面我用一个简单函数来证明�Q?br>

template void Capitalize(
ForwardIterator first�Q�ForwardIterator end)
{
for(ForwardIterator it = first; it < end; it++)
*it = (*it)->ToUpper();
}

　　它遍历一个System::String^容器�q�把其中的每个字�W�串转化为大写�?br>

Capitalize(vecstr.begin(), vecstr.end());
Capitalize(deqstr.begin(), deqstr.end());
for(vector::iterator it = vecstr.begin();
it < vecstr.end(); it++)
Console::WriteLine(*it);
Console::WriteLine();
for(deque::iterator it = deqstr.begin();
it < deqstr.end(); it++)
Console::WriteLine(*it);

　　上面我的��法能够与vector和deque容器工作良好。至此，不再�l�谈�Q�否则，guru站上的STL爱好者们会对我群��h��击，而非STL人可能感到厌烦。如果你�q�没使用�q�STL�Q�可以参考有兌��料�?br>
7. 熟悉的语�?br>
　　开发者经常迷恋他们所用的�~�程语言�Q�而很��是��Z��实用的目的。还记得当微软宣布不再�ؓVB6提供官方支持�Ӟ��VB6人的反抗吗？非VB6人对此可能非帔R��惊，而老道的VB6人早已�ؓ他们的语�a�作好葬礼准备了。事实上�Q�如果VB.NET从来没被发明�Q�多数VB6人将会离开.NET�Q�因为C#��会对他们非帔R��生，而它的祖先就是C++。如今，许多VB.NET人可能已�l��{向了C#�Q�但是他们不会从VB6直接转向C#�Q�VB.NET起到一个桥梁作用让他们的思想��q��开原来VB6思想。相应地�Q�如果微软仅发行VB.NET(而没有C#)�Q�那�?NET可能成�ؓ了新的面向对象VB�Q�且带有一个更大的�c�d��-C++�C�֛�的�h可能�Ҏ��嗤之以��E-他们甚至不会�ȝ��地检�?NET基础�c�d��。�ؓ什么�Q何��用一�U�特定语�a�的开发者会对另外一个团体的使用另外开发语�a�的开发者嗤之以鼻？�q�不是我要回�{�的问题�?-要回�{�该问题也许要先回答��Z��么有的�h喜欢威士忌，有的人喜�Ƣ可口可乐，而还有�h喜欢牛奶。所有我要说的是�Q�对开发者来��_��语法家族是个大问题�?br>
　　你认为对于一个具有C++背景的�h�Q�下面的代码��h��怎样的直觉性？

char[] arr =new char[128];

　　�?她可能回�{�的�W�一件事是，�Ҏ��h��错了位置。下面这句又如何�Q?br>

int y=arr.Length;

　　"呀!"-最可能的反映。现在把下面与前面相比较�Q?br>

char natarr[128];
array^ refarr=gcnew array(128);
int y=refarr->Length;

　　��h��意声明一个本机数�l�和一个托��数�l�时的语法区别。这里不同的模板形式的语法可视化地告诫开发者这一事实--refarr�q�不是典型的C++数组而且它可能是某种CLI�cȝ��z��?事实上确是如�?�Q�所以极有可能可以把�Ҏ��和属性应用于它�?br>
　　C#的finalizer语法最有可能引赯��{向C#的C++�E�序员的��h��。请看见下列C#代码�Q?br>

class R
{ ~R(){} }

　　好，�q�样~R看�v来象一个析构器但实际是个finalizer。�ؓ什么？请与下面的C++代码比较�Q?br>

ref class R
{
~R(){ }
!R(){ }
};

　　�q�里~R是析构器�Q�实际上�{��h于一个析构器的Dispose模式-但对C++人员来说�Q�这它的行�ؓ象个析构器）而新�?R语法是�ؓfinalizer建立�?�q�样��׃��再有��h��而且语法看上��M��与本机C++相匹配�?br>
　　��L��一下C#泛型语法�Q?br>

class R{};

　　再请看一下C++的语法：

generic ref class R{};

　　曄��使用�q�模板的人马上就看出�q�种C++语法�Q�而C#语法不能保证其没有�؜淆性且也不直观。我的观�Ҏ��Q�如果你以前��h��C++背景�Q�C++/CLI语法��最贴近于你以前所用。C#(以及J#)看上去象C++�Q�但是还有相当多的极��Z��人烦火的奇怪语义差别而且如果你没有完全放弃C++�Q�语法差别将永远不停地带�l�你混�ؕ和挫折。从�q�种意义上说�Q�我认�ؓVB.NET更好些，臛_��它有自己唯一的语法，所以那些共用C++和VB.NET的�h不会产生语法混�ؕ�?br>
　　8. �l�论

　　最后，至于你用什么语�a��~�程�Q�这可能依赖许多因素——如�Q�你在学校学习的是什么语�a��Q�你是用什么语�a�开发的现有代码仓库�Q�是否你的客户对你有具体的语�a�要求�{�。本文的主要目的是帮助你��定使用C++/CLI的几个明��的场所--�q�里�Q�它比另外CLI语言更具有明显优�ѝ��如果你开发的应用�E�序�?0%的��用时间是涉及本机interop�Q��ؓ何还要考虑使用另外的而不是C++�Q�如果你惛_��发一个通用集合�Q��ؓ什么仅把你自己限制在泛型上�Q�而不是结合泛型和模板的优势呢�Q�如果你已经用C++工作�Q��ؓ什么还要学习一�U�新的语�a�?我常觉得象C#和VB.NET�q�样的语�a��L��量向开发者隐藏CLR�Q�而C++不仅让你品味CLR�Q�甚臛_��以让你去亲吻CLR!

梦在天�� 2008-07-18 22:12 发表评论

CLI与C#比较

梦在天�� — Mon, 02 Jun 2008 06:17:00 GMT

来自�Q�The Most Powerful Language for .NET Framework Programming

            http://msdn.microsoft.com/en-us/library/ms379617(VS.80).aspx

比较�Q?br>

Description C++/CLI C#

Allocate reference type ReferenceType^ h = gcnew ReferenceType; ReferenceType h = new ReferenceType();

Allocate value type ValueType v(3, 4); ValueType v = new ValueType(3, 4);

Reference type, stack semantics ReferenceType h; N/A

Calling Dispose method ReferenceType^ h = gcnew ReferenceType;
delete h;
ReferenceType h = new ReferenceType();
((IDisposable)h).Dispose();

Implementing Dispose method ~TypeName() {} void IDisposable.Dispose() {}

Implementing Finalize method !TypeName() {} ~TypeName() {}

Boxing int^ h = 123; object h = 123;

Unboxing int^ hi = 123;
int c = *hi;
object h = 123;
int i = (int) h;

Reference type definition ref class ReferenceType {};
ref struct ReferenceType {};
class ReferenceType {}

Value type definition value class ValueType {};
value struct ValueType {};
struct ValueType {}

Using properties h.Prop = 123;
int v = h.Prop;
h.Prop = 123;
int v = h.Prop;

Property definition property String^ Name
{
    String^ get()
    {
        return m_value;
    }
    void set(String^ value)
    {
        m_value = value;
    }
} string Name
{
    get
    {
        return m_name;
    }
    set
    {
        m_name = value;
    }
}

thanks

梦在天�� 2008-06-02 14:17 发表评论

CLI中native的string和System::String转化

梦在天�� — Wed, 12 Mar 2008 08:47:00 GMT
     摘要: 一实例 �Q�代码下�?http://www.shnenglu.com/Files/mzty/SystemStringAndNativeString.rar�Q�nativeclass.h #pragma once #include #include class NativeClass{publ...  阅读全文

梦在天�� 2008-03-12 16:47 发表评论

C#的Form通过CLI调用C++的DLL

梦在天�� — Tue, 25 Dec 2007 11:14:00 GMT
     摘要: 一 �Ҏ��         C#的project调用C++的DLL�Q�一般也�?中方法：         1�Q�最��单的�Ҏ��Q�通过PInvoke�Q�但是只能调用全局function�Q�不能调用Class�?nbsp; &...  阅读全文

梦在天�� 2007-12-25 19:14 发表评论

NativeC++通过CLI调用C#的Form

梦在天�� — Tue, 25 Dec 2007 02:51:00 GMT

一调用�Ҏ��

      Native C++的project调用C#的DLL�Q�一般有3中方法：
      1�Q�通过COM��装
      2�Q�通过CLI/C++的Wrapper
      3) 在VS中可以直接修改NativeC++的project或是部分文�g��Z��用CLR来调用C#的DLL

�?实例
1�Q�C#的一个MyForm�c�，有public函数ShowMyForm�Q�）

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;

namespace CsharpDLL
{
    public class MyForm : Form
    {
        private Button button1;

        public void ShowMyForm()
        {
            this.ShowDialog();
        }
        public MyForm()
        {
            InitializeComponent();
            this.Text = "MyForm";
            this.StartPosition = FormStartPosition.CenterScreen;
        }
        private void InitializeComponent()
        {
            this.button1 = new System.Windows.Forms.Button();
            this.SuspendLayout();
            //
            // button1
            //
            this.button1.Location = new System.Drawing.Point(110, 74);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(75, 23);
            this.button1.TabIndex = 0;
            this.button1.Text = "TestMessageBox";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.button1_Click);
            //
            // MyForm
            //
            this.ClientSize = new System.Drawing.Size(292, 266);
            this.Controls.Add(this.button1);
            this.Name = "MyForm";
            this.ResumeLayout(false);

        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Hello, i am a Csharp Form!");
        }
    }
}

2�Q�C#的exe调用

using System;
using System.Collections.Generic;
using System.Text;

namespace CsharpTest
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Csharp main funtion start:");
            CsharpDLL.MyForm myForm = new CsharpDLL.MyForm();
            myForm.ShowMyForm();
            System.Console.WriteLine("Csharp main function end!");
        }
    }
}

3�Q�CLI/C++的warpper�Q�DLLexport函数CallCsharpForm�Q�）�Q�此函数中调用C#的MyForm

CPPCLIPROXYDLLFORCSHARPDLL_API void CallCsharpForm();

#using "../debug/CsharpDll.dll"

CPPCLIPROXYDLLFORCSHARPDLL_API void CallCsharpForm()
{
    CsharpDLL::MyForm^ myForm = gcnew CsharpDLL::MyForm();
    myForm->ShowMyForm();
}

4�Q�NativeC++的exe调用CLI的Wrapper来间接的调用MyForm

#include "stdafx.h"
#include <iostream>
#pragma comment(lib, "../debug/CppCLIProxyDLLForCsharpDLL.lib")

void CallCsharpForm();

int _tmain(int argc, _TCHAR* argv[])
{
    std::cout<<" Cpp Main function start:"<<std::endl;
    CallCsharpForm();
    std::cout<<" Cpp Main function end!"<<std::endl;
    return 0;
}

�?�ȝ��
要调试最好修改编译选项为Mixed�?br>
代码下蝲�Q?http://www.shnenglu.com/Files/mzty/CppCallCsharpByCLI.rar

梦在天�� 2007-12-25 10:51 发表评论

梦在天�� — Mon, 24 Dec 2007 09:47:00 GMT
     摘要: 一混合�c�L��谓�؜合类是指CLI/C++中native的Class中可以包含CLR对象�Q�CLR的class也可以包含Naitve的对象�?1�Q�native的class中包含CLR对象�Q�必��通过gcroot<>或auto_gcroot<>�?�Q�CLR中的class中包含native的对象，必须是指针，也可以��用高手写的CAutoNativePtr��指针�?注意�Q�C#中不�?..  阅读全文

梦在天�� 2007-12-24 17:47 发表评论

一个CLI/C++的DLL同时被C#的exe和NativeC++的exe调用

梦在天�� — Thu, 20 Dec 2007 14:47:00 GMT

一引子

      1�Q��用VS2005�Q�Native C++�Q�C#�Q�CLI/C++�?br>      2�Q�主要介�l�CLI/C++和Native C++, C#的交互，最总能够实��C��CLI/C++��Z��介的Native C++与C#的互调�?br>
�?实例

      1�Q�实��C��个CLI/C++的Dll�Q�在此Dll中包含一个RefClass能够被C#的exe调用。（实现�q�程�Q�在VS中徏立C++ CLR Class library 的一个Project�Q�然后增加一个类RefClass�Q�代码如下：

      refclass.h文�g�Q?br>
#pragma once

namespace ClrCppDll
{
    public ref class RefClass
    {
    public:
        RefClass(){}
        RefClass(int _x, int _y) : x(_x), y(_y)
        {
        }
        void PrintSelf();

    private:
        int x;
        int y;
    };
}

      refclass.cpp文�g�Q?br>
#include "stdafx.h"
#include "refclass.h"

using namespace System;
using namespace ClrCppDll;

void RefClass::PrintSelf()
{
    System::Console::WriteLine("hello, i am a ref cpp class");
    System::Console::WriteLine("x is {0}",x);
    System::Console::WriteLine("y is {0}",y);
}

      2�Q�能够调用上面第1�Q�步中的CLI/C++的Dll中class的C#的exe。（实现�q�程�Q�在VS建立C#的console Application�Q�然后reference 前面�?)生成的Dll�Q�代码如下：

         Program.cs文�g�Q?br>
using System;
using System.Collections.Generic;
using System.Text;

namespace CsharpTest
{
    class Program
    {
        static void Main(string[] args)
        {
            ClrCppDll.RefClass refClass = new ClrCppDll.RefClass(2,4);
            refClass.PrintSelf();
        }
    }
}

            上面2步的代码下蝲�Q?a href="http://www.shnenglu.com/Files/mzty/CSharpCPPCLI1.rar">http://www.shnenglu.com/Files/mzty/CSharpCPPCLI1.rar �Q�实现CLI/C++的dll能够被C#调用�Q?br>

     3�Q�对1�Q�实现的CLI/C++的Dll中增加能够被Native C++调用的NativeClass。代码如下：

      NativeClass.h文�g�Q?br>
#pragma once

namespace ClrCppDll
{
    public class NativeClass
    {
        public:
            NativeClass(){}
            NativeClass(int _x, int _y) : x(_x), y(_y)
            {}

            void printSelf();

        private:
            int x;
            int y;
    };
}

      NativeClass.cpp文�g�Q?br>
#include "stdafx.h"
#include <iostream>
#include "nativeclass.h"

using namespace ClrCppDll;

void NativeClass::printSelf()
{
    std::cout<<"hello,i am a native cpp class!"<<std::endl;
    std::cout<<"x is "<<x<<std::endl;
    std::cout<<"y is "<<y<<std::endl;
}

      问题�Q?/span> 如果我们直接在NativeC++的exe调用上面CLI/C++中的NativeClass�Q�会有问题，Error 1 error C3381: 'CppClrDll::NativeClass' : assembly access specifiers are only available in code compiled with a /clr option d:\cppandcsharpinteractivetest\csharpcppcli\clrcppdll\nativeclass.h 8�Q�这是�ؓ什么那�Q�我们想��x��们一般的Native C++的DLL的调用，都要��要被调用的Class或funtion导出才可以调用，惛_��q�里我们也对我们的NativeClass�q�行导出。（怎么导出可以看下面的代码�Q�但是当增加了对NativeClass的导出，调用的时候仍然有上面的error�Q�Error 1 error C3381: 'CppClrDll::NativeClass' : assembly access specifiers are only available in code compiled with a /clr option d:\cppandcsharpinteractivetest\csharpcppcli\clrcppdll\nativeclass.h 9�Q�最后只有查找资料（没有扑ֈ��Q�问别�h�Q�没有问刎ͼ��Q�最后想��C��用导出函数试试，一试果然可行啊�Q�哈哈哈�Q�so Happy�Q?span style="COLOR: #00ccff">其实后来发现是我加的导出__declspec(dllexport)的位�|�不对，应该是在class关键字后面，��M��导出�c�M��是可以的�?/span>导出�cȝ��代码可以下蝲新的sample�Q�增加导出和导出的函��C��码如下：

      (导出不久需要下面的2文�g�Q�还的定义宏 CLR_CPP_DLL在编译选项中，或直接写在文件中)
      clrcppdll.h

// ClrCppDll.h

#pragma once

#ifdef CLR_CPP_DLL
#define DLLIMPEXP __declspec(dllexport)
#else
#define DLLIMPEXP
#endif

namespace ClrCppDll
{
    DLLIMPEXP void  CallNativeClassPrintSelf();
}

      clrcppdll.cpp文�g�Q?br>
// This is the main DLL file.

#include "stdafx.h"
#include "NativeClass.h"
#include "ClrCppDll.h"

DLLIMPEXP void  ClrCppDll::CallNativeClassPrintSelf()
{
    ClrCppDll::NativeClass test(10,20);
    test.printSelf();
}

      4�Q�徏立一个NativeC++的exe来调�?�Q�生成的CLI/C++的Dll中的3�Q�增加的NativeClass�Q�实现过�E�：建立一个Native C++的console application�Q�代码如下：

       cpptest.cpp文�g�Q�（�l�过上一步问题的反复折磨�Q�终于搞定）�Q�同时别忘了要在�~�译选项中指定lib和lib的�\径）

// CppTest.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "../ClrCppDll/clrcppdll.h"

int _tmain(int argc, _TCHAR* argv[])
{
    /**//*ClrCppDll::NativeClass test(5,6);
    test.PrintSelf();*/

    ClrCppDll::CallNativeClassPrintSelf();
    return 0;
}

   上面四步��M��码下载：http://www.shnenglu.com/Files/mzty/CSharpCPPCLI2.rar �Q�实现CLI/C++的dll同时被Native C++和C#的调用）

      5�Q�扩展，增加在NativeClass中调用RefClass的funtion, 和RefClass中调用NativeClass的function�?br>
      代码下蝲�Q?a href="http://www.shnenglu.com/Files/mzty/CSharpCPPCLI3.rar">http://www.shnenglu.com/Files/mzty/CSharpCPPCLI3.rar �Q�最后代码下载，包含NativeClass与RefClass的互调）
                           http://www.shnenglu.com/Files/mzty/CSharpCPPCLI32.zip �Q�包含native class的导��Z��调用�Q?br>

      �?�ȝ��

      1) CLI/C++中如果想导出让NativeC++使用�Q�则最好导出函�?也可以导出类�?br>      2) CLI/C++的DLL可以没有像一般的NativeC++的Dll中的DllMain�Q�）函数�?br>      3) CLI/C++如果惛_��C#使用�Q�则一般是ref class�?br>

梦在天�� 2007-12-20 22:47 发表评论

C#通过C++/CLI调用C++DLL

梦在天�� — Mon, 04 Jun 2007 14:59:00 GMT

只要你会C++/CLI��比较容易哦�Q�或者说只要你会C++和C#学�v来也是很快的哦！�?br>

大家可以先参考，以后有时间加再写哦～

参考：http://www.codeproject.com/csharp/marshalCPPclass.asp

梦在天�� 2007-06-04 22:59 发表评论

C++�?NET中基��c�d��的对应及转化

梦在天�� — Tue, 29 May 2007 05:55:00 GMT
     摘要: 前言:��Z��介绍C#写界面，C++写算法的快捷交互开发方式，首先介绍c++�Q�C#内部的DLL�Q�COM调用.一�Q�基��c�d��二，字符�c�d�� /***Author - Nishant SivakumarCopyright(C) - Nishant Sivakumar 2005***/#pragma once#include&nb...  阅读全文

梦在天�� 2007-05-29 13:55 发表评论

C++/CLI

梦在天�� — Tue, 29 May 2007 05:38:00 GMT
     摘要: 前言:��Z��介绍C#写界面，C++写算法的快捷交互开发方式，首先介绍c++�Q�C#内部的DLL�Q�COM调用.一�Q�概念C++/CLI,�l�合和Native C++�?Net的特性，使我们可以在C++/CLI中更方便的��用Native C++�?Net资源�Q�更快捷的开发，所以有��C++/CLI是有史以来最强大的语�a��Q�但是强大也有他的弊端，��是复杂。也正是因�ؓ他的复杂所以许多C++的开发�h员�{到。net的时...  阅读全文

梦在天�� 2007-05-29 13:38 发表评论

C#界面�Q�C++��法

梦在天�� — Mon, 16 Apr 2007 14:41:00 GMT
     摘要:   阅读全文

梦在天�� 2007-04-16 22:41 发表评论

Managed c++与c++\CLI的区�?实例)

梦在天�� — Fri, 18 Aug 2006 02:58:00 GMT
     摘要: 1 Managed c++ (使用vs2002,2003,建立visual c++下的console application(.net ) project,project�q�有各种�c�d��)    �? 此时的project setting里一定是 :using Managed Extenstions ->Yes��单实�?using using namesp...  阅读全文

梦在天�� 2006-08-18 10:58 发表评论

Visual C++ .NET�~�程�Q�托��C++概述

梦在天�� — Fri, 18 Aug 2006 02:18:00 GMT
2000�q?月，Microsoft推出了“Microsoft.NET下一代互联网软�g和服务战略”，引�vIT行业的广泛关注�?000�q?月，Microsoft在旧金山发布了Enterprise 2000。同月，Microsoft原总裁兼首席执行官鲍尔默来��C��国就“下一代互联网”的主题�q�行演讲�Q�在中国掀起了一股�?NET旋风”�?000�q?1月，Microsoft在Comdex计算机大展上发布了Visual Studio.NET软�g�Q��ƈ展示了其.NET发展战略的框架体�p�d��开发工��L��相关�Ҏ��，全面加速了Microsoft�?NET技术进军市场的步伐�?

　　Microsoft�?NET战略意味着�Q�Microsoft以及在Microsoft�q�_��上的开发者将会制造服务，而不是制造��Y件。在未来几年之内�Q�Microsoft��陆�l�发布有�?NET的��^台和工具�Q�用于在因特�|�上开发Web服务。那�Ӟ��工作�?NET上的用户、开发�h员和IT工作人员都不再购买��Y件、安装��Y件和�l�护软�g。取而代之的是，他们��定制服务，软�g会自动安装，所有的�l�护和升�U�也会通过互联�|�进行。“Microsoft.NET 代表了一个集合、一个环境、一个可以作为��^台支持下一代Internet的可�~�程�l�构。”这��是鲍尔默对.NET的描�q��?br />

　　作�ؓ.NET的最新特性组成部分，Microsoft .NET Framework是一个用于构建，部��v和运行Web服务及应用程序的�q�_��。它为将现有投资与下一代应用程序和服务的集成提供了高��的，��Z��标准的，多语�a�环境�Q�同时它�q�用于解决Internet�U�应用程序的部��v和操作问题�?NET框架包含三个主要部分�Q�通用语言�q�行�Ӟ��一�l�层�ơ化的统一的类库，及组件化版本的动态服务器主页(�U�CؓASP.NET)�?br />
　　用于开�?NET Framework的语�a�有Visual C#、VB.NET和C++托管扩展(Managed Extensions for C++)。其中C#是开�?NET的元语言�Q�而C++托管扩展是在C++基础上徏立�v来的�Q�用来�ؓVisual C++�E�序员开�?NET框架应用�E�序而设计。�ؓ叙述方便�Q�我们将C++托管扩展��q��之�ؓ“托��C++”�?br />��Z��帮助C/C++以及Visual C++�E�序员或爱好者快速��用托��C++开�?NET Framework�E�序�Q�我们将陆箋推出相关的一�p�d��文章�?br />
　　本篇“托��C++概述”主要讲�q�C��什么是托管C++、开�?NET Framework(框架)的项目类型以及与标准C++之间的区别�?br />
　　1、什么是托管C++�Q?/font>

　　在回�{�这个问题，首先要搞清楚什么是“托��?Managed)。托��是.NET的一个专门概念，它是融于通用语言�q�行�?CLR)中的一�U�新的编�E�理念，因此我们完全可以把“托��”视为�?NET”。那么什么是“通用语言�q�行时”？通用语言�q�行时是.NET 框架应用�E�序的执行引挚。它提供了许多服务，其中包括�Q�代码管�?装入和执�?、类型安全性验证、元数据(高��c�d��信息)讉K��、�ؓ��理对象��理内存、管理代码，COM对象和预生成的DLLs(非管理代码和数据)的交互操作性、对开发�h员服务的支持�{�等�?br />
　　也就是说�Q��用托��C++意味着�Q�我们的代码可以被CLR所��理�Q��ƈ能开发出��h��最新特性如垃圾自动攉��、程序间�怺�讉K��{�的.NET框架应用�E�序�?br />
　　由托��概忉|��引发的C++应用�E�序包括托管代码、托��数据和托管�c�M��个组成部分。　　

　　(1) 托管代码�Q?Net环境提供了许多核心的�q�行(RUNTIME)服务�Q�比如异常处理和安全�{�略。�ؓ了能使用�q�些服务�Q�必��要�l�运行环境提供一些信息代�?元数�?�Q�这�U�代码就是托��代码。所有的C#、VB.NET、JScript.NET默认旉��是托��的�Q�但Visual C++默认时不是托��的�Q�必��d��~�译器中使用命��o行选项(/CLR)才能产生托管代码�?br />
　　(2) 托管数据�Q�与托管代码密切相关的是托管数据。托��数据是由公��p��a��q�行的垃圑֛�收器�q�行分配和释攄��数据。默认情况下�Q�C#、Visual Basic �?JScript.NET 数据是托��数据。不�q�，通过使用�Ҏ��的关键字�Q�C# 数据可以被标��Cؓ非托��数据。Visual C++数据在默认情况下是非托管数据�Q�即使在使用 /CLR 开��x��也不是托��的�?br />
　　(3) 托管�c?/b>�Q�尽��Visual C++数据在默认情况下是非托管数据�Q�但是在使用C++的托��扩展时�Q�可以��用“__gc”关键字��类标记为托��类。就像该名称所昄��的那��P��它表�C�类实例的内存由垃圾回收器管理。另外，一个托��类也完全可以成�?.NET 框架的成员，由此可以带来的好处是�Q�它可以与其他语�a��~�写的类正确地进行相互操作，如托��的C++�c�d��以从Visual Basic�cȝ��承等。但同时也有一些限�Ӟ��如托��类只能从一个基�cȝ��承等。需要说明的是，在托��C++应用�E�序中既可��用托��类也可以��用非托管�c�R��这里的非托��类不是指标准C++�c�，而是使用托管C++语言中的__nogc关键字的�c�R�?br />
2、用托管C++可以开�?NET框架的项目类�?br />
　　使用托管C++应该是C++�E�序员编�?NET框架应用�E�序最好的一�U�选择�Q�通过集成在Visual Studio.NET开发环境的托管C++向导�Q�我们可以创��Z��下几�U�开�?NET框架的项目类型：

　　(1) 托管C++应用�E�序:用来创徏一个支持托��扩展的单独C++应用�E�序�Q��用它�q�可创徏��M��c�d��的应用程序，包括.NET框架客户应用�E�序�?br />
　　(2) 托管C++�c�d��:用来创徏一个支持托��扩展的C++DLL�Q��用它可以生成一个能�?NET框架应用�E�序调用的托��类型的�l��g�?br />
　　(3) 托管C++�I�项目：用来创徏一个空的托��项目，该项目只含有支持托管扩展的正��编译和链接的开关选项。��用它能将一个已有的C++源文件进入到一个托��环境中�?br />
　　(4) 托管C++ Web服务�Q�用于创��Z��个项目，一个是C++托管扩展��目�Q�另一个是部��v��目�?br />
　　3、托��C++与标准C++的主要区�?/font>

　　��管托管C++是从标准C++建立而来的，但它与标准C++有着本质上的区别�Q�这主要体现在以下几个方面：

　　(1) �q�泛采用“名�U�空间�?namespace)

　　名称�I�间是类型的一�U�逻辑命名�Ҏ��Q?NET使用该命名方案用于将�c�d��按相兛_��能的逻辑�c�d��q�行分组�Q�利用名�U�空间可以��开发�h员更�Ҏ��在代码中��览和引用类型。当�Ӟ��我们也可��名�U�空间理解成是一个“类库名”�?

　　��管很早Microsoft��在Visual C++中支持名�U�空间的�~�程方式�Q�但是很��引起Visual C++�E�序员的普遍��x��。现在在托管C++�E�序中，我们必须使用�q�一方式�Q�即使用#using和using关键字。例如下面的��单程序代码是在控制台上输出“Hello World”：

#using
using namespace System;
int main(void)
{
Console::WriteLine(S"Hello World");
return 0;
}

　　代码中，#using是用来将一个元数据文�g输入到托��C++�E�序中，�q�些文�g可以是包含托��数据和�l�构的MSIL (Microsoft intermediate language�Q�微软中间语�a�)文�g�Q�如DLL、EXE、OBJ文�g�{�。mscorlib.dll�?NET框架的一个核心类库，包含主要的名�U�空间System。程序的�W�二行代码“using namespace System;”用来��用System名称�I�间。System�?NET框架根名�U�空��_��包含最基本的类型，如用于数据流的输�?输出的System::IO�{��?br />
　　在对托管C++�E�序开发的不断深入�Q�我们不久就会发玎ͼ�许多�c�d��的引用都要在�E�序的前面��?using和using来进行�?br />
　　(2) 基本数据�c�d��的变�?/b>

　　我们知道�Q�标准C++语言的数据类型是非常丰富的。而托��C++的数据类型更加丰富，不仅包含了标准C++中的数据�c�d��Q�而且新增了__int64(64位整�?、Decimal(96位十�q�制�?、String*(字符串类�?和Object*(对象�c�d��)�{�类型，�?-1列出它们各自数据�c�d��?br />
�c�d��描述标准C++�c�d��?/td> 托管C++�c�d��?/td> 长度(�?
布尔�?/td> bool bool 8
字符�?/td> char signed char 8
无符号字�W�型 unsigned char char 8
短整�?/td> short [int] short 16
无符��L��整型 unsigned short [int] unsigned short 16
整型 int int �?long 32
无符��h��?/td> unsigned [int] unsigned int �?long 32
长整�?/td> long [int] long 32
无符号长整型 unsigned long [int] unsigned long 32
单精度��Q点型 float float 32
双精度��Q点型 double double 64
长双�_�ֺ��点�?/td> long double -- 64
Unicode字符 -- wchar_t 16
64位整�?/td> -- __int64 64
无符�?4位整�?/td> -- unsigned __int64 64
96位十�q�制�?/td> -- Decimal 96
对象�c�d�� -- Object* 32
字符串类�?/td> -- String* --

　　需要注意的是，String和Object在定义一个变量时�Q�注意要有星�?�?�?�Q�但�q�个变量不是指针变量�Q�这与标准C++的含义是不一��L��。例如上面的代码可以改�ؓ�Q?br />
#using
using namespace System;
int main(void)
{
String* hello = S"Hello World";
Console::WriteLine(hello);
return 0;
}
　(3) 新增三个托管C++�c�d��Q�__gc class、__value class和__gc interface

　　一个__gc�c�L��l�构意味着该类或结构的生命周期是由.NET开发��^台自动管理及垃圾自动攉��Q�用户不必自已去调用delete来删除。定义一个__gc�c�L��l�构和标准C++基本�怼��Q�所不同的是在class或struct前加上__gc�Q�例如下面的代码�Q?br />
__gc class G {
public:
int k;
int sum(int);
};

G::sum(int i) {return i*(i + 1)/2;}
int main()
{
G * g = new G;
Console::WriteLine(g->sum(4)); // �l�果输出10
return 0;
}

　　但要注意�Q?/font>

　　A. 一个__gc�c�M��能从一个非托管�c�M��l�承�Q�且不能包含从它�z��的非托管�c�R��但一个__gc�c�L��多可以从一个托��类中��ѝ�?br />
　　B. 一个__gc�c�M��能定义成一个友元类或包含一个友元成员函数。所谓友元函敎ͼ�是用来让外部函数讉K��c�M��的私有和保护�c�d��成员�?br />
　　C. 一个__gc�c�M��能声明或定义以及重蝲new或delete操作以及不能包含using�{�声明�?br />
　　__value�c�L��用来使用��h��短生命期的小型数据项�Q�它不同于__gc�c�R��__gc�c�L��据分配在CLR堆中�Q�而__value�c�d��象是在运行栈或称为NDP(.NET Developer Platform�Q?NET开发者��^�?堆中创徏的，从而避免了垃圾回收器不断分配和释放�I�间而带来的开销。一个__value�c�d��以声明成��Z��个局部变量、参数和�q�回��|��也可嵌入��C��个__gc�c�M��或是作�ؓ一个静态变量或在C++堆中分配的变量。例如下面的代码�Q?br />
#using
using namespace System;
__value struct V { int i; };
__gc struct G { V v; }; // 嵌入到__gc�c�M��
V f(V v) { // 定义一个全局函数�Q�其值存储在�q�行栈中
v.i += 1; // 不媄响原来�Ş参v的�?br />return v; // �q�回V�l�构�c�d��的�?br />}
int main(void)
{
V v1 = {10}; // 在运行栈中声明�ƈ初始�?br />V v2 = f(v1); // 调用f函数�Q�此时v1中的i�?0�Q�而v2中的i�?1
G *pG = new G; // 为G实例分配堆空�?br />pG->v = v1; // pG的v中的i�?0
pG->v.i += v2.i; // pG的v中的i�?0+11=21
Console::WriteLine(v1.i); // 输出�l�果�?0
Console::WriteLine(v2.i); // 输出�l�果�?1
Console::WriteLine(pG->v.i); // 输出�l�果�?1
return 0;
}

　　除此之外�Q�所有的__gc对象都是从类System::Object�z��而来�Q�因而能够很�Ҏ��使用作用在__gc�c�M��的集合和映射功能。然而__value�c�d��q�没有与�q�个基类所�׃�n�Q�因而不能直接将__value作�ؓ函数中的Object*实参。�ؓ了解册��个问题，.NET允许我们使用__box关键字将一个__value�c�d��视�ؓ一个__gc对象。此时__value�c�d��被封装成一个__gc�c�L��?Stub)�Q��ƈ被复制到NDP堆中。由于在托管C++中，box不具备隐式�{换的功能�Q�因此在转换时必��L��明�{换的�c�d��?br />
　　托管C++中的__gc接口最能体现COM接口的思想�Q�它的定义和声明是非常简单的�Q�它除了关键字不同外�Q�与一个__gc�cȝ��声明极�ؓ�怼�。例如下面的代码定义了一个接口IMyBase�Q�其中包含了一个f的方法：

__gc __interface Ibase {
void f();
};

　　需要说明的是，接口中所有的�Ҏ��默认旉��是纯虚的且都是公有的�Q�我们不需要在�Ҏ��之前使用virtual关键字或在方法之后加上�? 0”。其�ơ，在一个__gc接口中不能包含数据成员以及静态成员，也不能包含�Q何类的声明。下面�D一个示例来说明__gc接口的��用：

#using
using namespace System;

__gc __interface Ibase1 {
int f(int);
};
__gc __interface Ibase2 {
int f(int);
};
__gc struct C: Ibase1, Ibase2 {
int f(int i) { // 接口�Ҏ��的实�?br />return 2*i-1;
};
};

int main(void){
C* c = new C;
Console::WriteLine((c -> f(1)).ToString()); // 输出�l�果�?
Console::WriteLine((__try_cast (c)->f(2)).ToString());
// 输出�l�果�?

Console::WriteLine((__try_cast (c)->f(3)).ToString());
// 输出�l�果�?

return 0;
}

　　代码中，__try_cast用来��某个对象�{换成一个指定类型，�q�当�c�d��转换��p�|时自动处理由此��生的异常。ToString用来��对象描�q�成一个字�W�串�?br />(4) ��化属性操�?br />
　　在__gc�c�M��可以使用.NET的属性，�q�个属性简化了属性函数的调用操作�Q�这与标准C++中的属性不一栗��在标准C++中分别通过get_和put_成员函数来设�|�或获取相关属性的倹{��现在，托管C++中的属性操作就好比是对一个属性变量进行操作，例如下列代码�Q?br />
#using
using namespace System;

__gc class G {
public:
__property int get_Size() {
Console::WriteLine(S"get_属�?);
return nSize;
};
__property void set_Size(int i) {
Console::WriteLine(S"set_属�?);
nSize = i;
};
private:
int nSize;
};

int main() {
G * pG = new G;
pG->Size = 10; // 调用set_Size
int i = pG->Size; // 调用get_Size
Console::WriteLine(i);
}

　　�E�序�l�果为：

　　　set_属�?br />
　　　get_属�?br />
　　　10

　　需要说明的是，托管C++使用__property关键字来定义一个属性的成员函数。从代码中可以看��|�和获取属性的成员函数名称中分别��用了set_和get_�Q�这��L��译器会自动生成一个伪成员变量Size�Q�这个变量名是set_和get_成员函数后面的名�U�。注意不要再在get_成员函数代码中��用这个伪成员变量Size�Q�它会引赯��函数的递归调用�?br />
　　(5) 托管C++的委�z?/b>

　　在C/C++中，一个函数的地址��是内存地址。这个地址不会带有��M��其它附加信息�Q�如函数的参��C��数、参数类型、函数的�q�回值类型以及这个函数的调用规范�{�。��M��Q�C/C++的回调函��C��具备�c�d��安全性。�?NET框架在回调函数的基础增加了提供类型安全的机制�Q�称为委�z��?br />
　　托管C++的委�z�方法不像C#那么复杂�Q�它��化了委派�l�大部分的内部机�Ӟ��因而��得它的��用变成非常简单容易。例如下面的代码�Q?br />
#using
using namespace System;

__delegate int GetDayOfWeek(); // 委派�Ҏ��的声�?br />__gc class MyCalendar
{
public:
MyCalendar() : m_nDayOfWeek(4) {}
int MyGetDayOfWeek() {
Console::WriteLine("非静态方�?);
return m_nDayOfWeek;
}
static int MyStaticGetDayOfWeek() {
Console::WriteLine("静态方�?);
return 6;
}
private:
int m_nDayOfWeek;
};

int main(void)
{
GetDayOfWeek * pGetDayOfWeek; // 声明委派�c�d��变量
int nDayOfWeek;

// ��类的静态方法MyStaticGetDayOfWeek�l�定成委�z?br />pGetDayOfWeek = new GetDayOfWeek(0, &MyCalendar::MyStaticGetDayOfWeek);
nDayOfWeek = pGetDayOfWeek->Invoke(); // 委派的调�?br />Console::WriteLine(nDayOfWeek);

// ��一个类的实例绑定成委派
MyCalendar * pcal = new MyCalendar();
pGetDayOfWeek =
static_cast(Delegate::Combine(pGetDayOfWeek,
new GetDayOfWeek(pcal, &MyCalendar::MyGetDayOfWeek)));
nDayOfWeek = pGetDayOfWeek->Invoke();
Console::WriteLine(nDayOfWeek);

// 删除�l�定委派的类实例
pGetDayOfWeek =
static_cast(Delegate::Remove(pGetDayOfWeek,
new GetDayOfWeek(pcal, &MyCalendar::MyGetDayOfWeek)));

return 0;
}

　　输出�l�果是：

　　　静态方�?br />　　
　　　6

　　　静态方�?br />
　　　非静态方�?br />
　　　4

　　4、结速语

　　��M��Q��用托��C++是C++�E�序员编�?NET框架应用�E�序最好的一�U�选择�Q�在充分理解.NET框架基础上，避免了��用其他语�a�如C#、VB.NET所带来的额外开销�?br />

梦在天�� 2006-08-18 10:18 发表评论

c++\CLI与c#

梦在天�� — Thu, 17 Aug 2006 08:46:00 GMT

Description C++/CLI C#

Allocate reference type ReferenceType^ h = gcnew ReferenceType; ReferenceType h = new ReferenceType();

Allocate value type ValueType v(3, 4); ValueType v = new ValueType(3, 4);

Reference type, stack semantics ReferenceType h; N/A

Calling Dispose method ReferenceType^ h = gcnew ReferenceType;
delete h;
ReferenceType h = new ReferenceType();
((IDisposable)h).Dispose();

Implementing Dispose method ~TypeName() {} void IDisposable.Dispose() {}

Implementing Finalize method !TypeName() {} ~TypeName() {}

Boxing int^ h = 123; object h = 123;

Unboxing int^ hi = 123;
int c = *hi;
object h = 123;
int i = (int) h;

Reference type definition ref class ReferenceType {};
ref struct ReferenceType {};
class ReferenceType {}

Value type definition value class ValueType {};
value struct ValueType {};
struct ValueType {}

Using properties h.Prop = 123;
int v = h.Prop;
h.Prop = 123;
int v = h.Prop;

Property definition property String^ Name
{
    String^ get()
    {
        return m_value;
    }
    void set(String^ value)
    {
        m_value = value;
    }
} string Name
{
    get
    {
        return m_name;
    }
    set
    {
        m_name = value;
    }

梦在天�� 2006-08-17 16:46 发表评论

Native c++ 和Managed �?interop

梦在天�� — Thu, 17 Aug 2006 08:26:00 GMT

4�U�方�?

There are four main ways to do interop in .NET between the managed and native worlds. COM interop can be accomplished using Runtime Callable Wrappers (RCW) and COM Callable Wrappers (CCW). The common language runtime (CLR) is responsible for type marshaling (except in the rare scenarios where a custom marshaler is used) and the cost of these calls can be expensive. You need to be careful that the interfaces are not too chatty; otherwise a large performance penalty could result. You also need to ensure that the wrappers are kept up to date with the underlying component. That said, COM interop is very useful for simple interop scenarios where you are attempting to bring in a large amount of native COM code.

The second option for interop is to use P/Invoke. This is accomplished using the DllImport attribute, specifying the attribute on the method declaration for the function you want to import. Marshaling is handled according to how it has been specified in the declaration. However, DllImport is only useful if you have code that exposes the required functions through a DLL export.

When you need to call managed code from native code, CLR hosting is an option. In such a scenario, the native application has to drive all of the execution: setting up the host, binding to the runtime, starting the host, retrieving the appropriate AppDomain, setting up the invocation context, locating the desired assembly and class, and invoking the operation on the desired class. This is definitely one of the most robust solutions in terms of control over what and when things happen, but it is also incredibly tedious and requires a lot of custom code.

The fourth option, and quite possibly the easiest and the most performant, is to use the interop capabilities in C++. By throwing the /clr switch, the compiler generates MSIL instead of native machine code. The only code that is generated as native machine code is code that just can't be compiled to MSIL, including functions with inline asm blocks and operations that use CPU-specific intrinsics such as Streaming SIMD Extensions (SSE). The /clr switch is how the Quake II port to .NET was accomplished. The Vertigo software team spent a day porting the original C code for the game to code that successfully compiled as C++ and then threw the /clr switch. In no time they were up and running on the .NET Framework. Without adding any additional binaries and simply by including the appropriate header files, managed C++ and native C++ can call each other without any additional work on the part of the developer. The compiler handles the creation of the appropriate thunks to go back and forth between the two worlds.

梦在天�� 2006-08-17 16:26 发表评论

Visual C++ �~�译器选项

梦在天�� — Thu, 17 Aug 2006 04:16:00 GMT

来自msdn:http://msdn.microsoft.com/library/chs/default.asp?url=/library/CHS/vccore/html/_core_compiler_options_listed_by_category.asp

优化

/O1 创徏��代�?/td>

/O2 创徏快速代�?/td>

/Oa 假设没有别名

/Ob 控制内联展开

/Od ��用优化

/Og 使用全局优化

/Oi 生成内部函数

/Op 改善��点��C��致�?/td>

/Os 代码大小优先

/Ot 代码速度优先

/Ow 假定在函数调用中使用别名

/Ox 使用最大优�?(/Ob2gity /Gs)

/Oy 省略框架指针

代码生成

/arch 使用 SSE �?SSE2 指��o生成代码

/clr 启用 C++ 的托��扩展�ƈ产生在公��p��a��q�行库上�q�行的输出文�?/td>

/EH 指定异常处理模型

/G3 优化代码以优�?386 处理器。在 Visual C++ 5.0 中已�l�停用，�~�译器将忽略此选项

/G4 优化代码以优�?486 处理器。在 Visual C++ 5.0 中已�l�停用，�~�译器将忽略此选项

/G5 优化代码以优�?Pentium

/G6 优化代码以优�?Pentium Pro、Pentium II �?Pentium III 处理�?/td>

/G7 针对 Pentium 4 �?Athlon 优化代码�?/td>

/GB �?/G6 �{�效�Q�将 _M_IX86 的��D��|��ؓ 600

/Gd 使用 __cdecl 调用�U�定

/Ge �Ȁ�z�d��栈探��?/td>

/GF
/Gf 启用字符串池

/Gh 调用挂钩函数 _penter

/GH 调用挂钩函数 _pexit

/GL 启用全程序优�?/td>

/Gm 启用最��重新生�?/td>

/GR 启用�q�行时类型信�?(RTTI)

/Gr 使用 __fastcall 调用�U�定

/Gs 控制堆栈探测

/GT 支持使用静态线�E�本地存储区分配的数据的�U�程安全

/GX 启用同步异常处理

/Gy 启用函数�U�链�?/td>

/Gz 使用 __stdcall 调用�U�定

/MD 使用 MSVCRT.lib 创徏多线�E?DLL

/MDd 使用 MSVCRTD.lib 创徏调试多线�E?DLL

/ML 使用 LIBC.lib 创徏单线�E�可执行文�g

/MLd 使用 LIBCD.lib 创徏调试单线�E�可执行文�g

/MT 使用 LIBCMT.lib 创徏多线�E�可执行文�g

/MTd 使用 LIBCMTD.lib 创徏调试多线�E�可执行文�g

输出文�g

/FA
/Fa 创徏列表文�g
讄��列表文�g�?/td>

/Fd 重命名程序数据库文�g

/Fe 重命名可执行文�g

/Fm 创徏映射文�g

/Fo 创徏对象文�g

/Fp 指定预编译头文�g�?/td>

/FR
/FR 生成��览器文�?/td>

/Fx ��插入的代码与源文�g合�ƈ

调试

/GS �~�冲区安全检�?/td>

/GZ �?/RTC1 相同

/RTC 启用�q�行旉��误检�?/td>

/Wp64 ��?64 位可�U�L��性问�?/td>

/Yd ��完整的调试信息攑֜�所有对象文件中

/Yl 创徏调试库时插入 PCH 引用

/Z7 生成�?C 7.0 兼容的调试信�?/td>

/Zd 生成行号

/Zi 生成完整的调试信�?/td>

预处理器

/AI 指定在解析传递到 #using 指��o的文件引用时搜烦的目�?/td>

/C 在预处理期间保留注释

/D 定义常数和宏

/E ��预处理器输出复制到标准输出

/EP ��预处理器输出复制到标准输出

/Fl 预处理指定的包含文�g

/FU 强制使用文�g名，��像它已被传递到 #using 指��o一�?/td>

/I 在目录中搜烦包含文�g

/P ��预处理器输出写入文�?/td>

/U �U�除预定义宏

/u �U�除所有的预定义宏

/X 忽略标准包含目录

/ZI ��调试信息包含在与“编辑�ƈ�l�箋”兼容的�E�序数据库中

语言

/vd 取消或启用隐藏的 vtordisp �c�L��?/td>

/vmb �Ҏ��向成员的指针使用最佳的�?/td>

/vmg �Ҏ��向成员的指针使用完全一般�?/td>

/vmm 声明多重�l�承

/vms 声明单一�l�承

/vmv 声明虚拟�l�承

/Za ��用语言扩展

/Zc �?/Ze 下指定标准行�?/td>

/Ze 启用语言扩展

/Zg 生成函数原型

/Zl �?.obj 文�g中移除默认库�?/td>

/Zp n ��装�l�构成员

/Zs 只检查语�?/td>

链接

/F 讄��堆栈大小

/LD 创徏动态链接库

/LDd 创徏调试动态链接库

/link ��指定的选项传递给 LINK

/MD 使用 MSVCRT.lib �~�译以创建多�U�程 DLL

/MDd 使用 MSVCRTD.lib �~�译以创��试多�U�程 DLL

/ML 使用 LIBC.lib �~�译以创建单�U�程可执行文�?/td>

/MLd 使用 LIBCD.lib �~�译以创��试单�U�程可执行文�?/td>

/MT 使用 LIBCMT.lib �~�译以创建多�U�程可执行文�?/td>

/MTd 使用 LIBCMTD.lib �~�译以创��试多�U�程可执行文�?/td>

预编译头

/Y- 忽略当前生成中的所有其他预�~�译头编译器选项

/Yc 创徏预编译头文�g

/Yd ��完整的调试信息攑֜�所有对象文件中

/Yu 在生成期间��用预�~�译头文�?/td>

/YX 自动处理预编译头

杂项

@ 指定响应文�g

/? 列出�~�译器选项

/c �~�译但不链接

/H 限制外部�Q�公共）名称的长�?/td>

/HELP 列出�~�译器选项

/J 更改默认�?char �c�d��

/nologo 取消昄��d��版权标志

/QI0f ��保 Pentium 0F 指��o没有问题

/QIfdiv FDIV、FPREM、FPTAN �?FPATAN 指��o有缺��L�� Intel Pentium 微处理器的变通方�?/td>

QIfist 当需要从��点�c�d��转换为整型时取消 Helper 函数 _ftol 的调�?/td>

/showIncludes 在编译期间显�C�所有包含文件的列表

/Tc
/TC 指定 C 源文�?/td>

/Tp
/TP 指定 C++ 源文�?/td>

/V 讄��版本字符�?/td>

/W 讄��警告�{��

/w ��用所有警�?/td>

/Wall 启用所有警告，包括默认情况下禁用的警告

/WL 在从命��o行编�?C++ 源代码时启用错误信息和警告消息的单行诊断

/Zm 指定预编译头内存分配限制

请参�?/h4>
C/C++ 生成参�?/a> | �~�译器选项 | 讄��~�译器选项

梦在天�� 2006-08-17 12:16 发表评论

非托��的vc工程中部分文件��?Net Framwork

梦在天�� — Thu, 17 Aug 2006 04:05:00 GMT
使用vs2005�?/font> �?,且工�E�不使用与编译头文�gstdafx.h.(保证可以,不可以来找我!)

一,建立一般的c++的console32的project ,name: Test ,工程setting使用默认,不改�?如下:

�?add header file: ManagedCppClass.h

#pragma  once

class ManagedCppClass
{
public:
    void PrintString();

};

�?add cpp file: ManagedCppClass.cpp

#using <mscorlib.dll>
using namespace System;

#include "ManagedCppClass.h"

void ManagedCppClass::PrintString()
{
    Console::WriteLine(S"Hello, i am a Managed cpp class ");
}
�?main函数如下:

#include "stdafx.h"
#include "ManagedCppClass.h"

int _tmain(int argc, _TCHAR* argv[])
{
    ManagedCppClass test;
    test.PrintString();
    return 0;
}
�?修改Managedcppclass.cpp文�g的property setting,

next

�?compile->link->run ,it is ok!

梦在天�� 2006-08-17 12:05 发表评论

使用c++\CLI实现c++托管与非托管混合�~�程

梦在天�� — Wed, 16 Aug 2006 06:23:00 GMT

Mixing Native and Managed Types in C++

Wow, its turning into a busy month. I just haven’t had any time to blog despite having a number of interesting topics to cover. I’ll try to get a few of them written soon. Here’s a topic from one of my regular readers.

The CLR naturally supports mixing managed and native method calls allowing you to easily call native functions from managed functions (which are of course natively compiled before execution) and visa versa. This is all largely transparent in C++. What’s not as transparent is how to mix managed and native types. The reason is that there is a greater distinction between native and managed types compared with function calls. Beside obvious differences such as those introduced by different calling conventions and virtual invocation, function calls aren’t all that different. Types however require a bit more help from the programmer/compiler since native and managed types can have very different characteristics. This is very evident in C# as you often need to decorate native type definitions with all kinds of attributes to control memory layout and marshalling. Fortunately for the C++ programmer the compiler takes care of much of this when you define or include native type definitions such as those found in the various Windows header files, but the programmer is still responsible for telling the compiler just how those types are to be used.

Visual C++ provides many of the building blocks for mixing native and managed types but in some cases you need to write a little code to help it along. Fortunately C++/CLI is very capable. Let’s consider a few different scenarios.

Embed Simple Managed Type in Native Type

Since the CLR needs to keep track of every single instance of a managed type in a process, storing some kind of reference/pointer/handle to a managed object in a native type is not directly supported since instances of native types can be allocated in any region of memory and cast to all kinds of foreign data types that would be completely opaque to the CLR and its services. Instead you need to register such occurrences with the CLR so that it is aware of these “native�?references to managed types. This is achieved with the use of the GCHandle type. Internally GCHandle manages a static table of (native) pointers that are used to lookup the objects in the managed heap. Of course using GCHandle directly from C++ can be quite tedious. It’s a CLS compliant value type which means native pointers are represented by IntPtr values. It also does not preserve static type information so static_casts are inevitable. Fortunately Visual C++ ships with the gcroot native template class that provides a strongly-typed interface over the GCHandle type.

#include

ref struct ManagedType
{
    void HelloDotNet()
    {
        Console::WriteLine("Hello .NET");
    }
};

struct NativeType
{
    ManagedType m1;          // Error!

    ManagedType^ m2;         // Error!

    gcroot m3; // OK
};

void main()
{
    NativeType native;
    native.m3 = gcnew ManagedType;

    native.m3->HelloDotNet();
}

As you can see, gcroot provides a “smart�?pointer for storing handles in native types. It may be smart but it does not provide automatic cleanup of resources. Specifically, the gcroot destructor makes no attempt to dispose of the managed object’s resources.

Embed Managed Resource in Native Type

Enter the auto_gcroot class. This native template class wraps a gcroot and provides transfer-of-ownership semantics for managed objects stored in native types. If you’re looking for a point of reference, think of the auto_ptr template class from the Standard C++ Library which does the same thing for native pointers. The auto_gcroot destructor takes care of “deleting�?the handle which results in the object’s IDisposable::Dispose method (if any) being called.

#include

ref struct ManagedType
{
    void HelloDotNet()
    {
        Console::WriteLine("Hello .NET");
    }

    ~ManagedType()
    {
        Console::WriteLine("dtor");

        // Compiler implements Dispose pattern...
    }
};

struct NativeType
{
    msclr::auto_gcroot m3; // OK
};

void main()
{
    NativeType native;
    native.m3 = gcnew ManagedType;

    native.m3->HelloDotNet();
}

The NativeType destructor (provided by the compiler) will automatically call the auto_gcroot destructor which will delete the managed object resulting in its destructor being called through its compiler generated Dispose method.

Embed Native Type in Managed Type

Now let’s turn things around. Let’s say we want to store a native type as a member of a managed type. The challenge is that the only native type the CLR really supports within managed types is a native pointer. C# programmers use IntPtr but that is only because IntPtr is the CLS compliant way of representing a native pointer and C# tries really hard to remain CLS compliant. The CLR fully supports storing native pointers without losing type information.

struct NativeType
{
};

ref struct ManagedType
{
    NativeType n1; // Error!

    NativeType* n2; // OK
};

That’s great except that now we have a resource management issue. Recall that C++ does not have the separation of memory and resource management evident in the CLR. The native object pointed to by the ManagedType member needs to be deleted. Here is one solution.

ref struct ManagedType
{
    NativeType* n2; // OK

    ~ManagedType()
    {
        if (0 != n2)
        {
            delete n2;
            n2 = 0;
        }
    }
};

Now the ManagedType has a Dispose implementation that will faithfully delete the native object. But this can become tedious and error prone very quickly. A better solution is to use some kind of “automatic�?approach. Fortunately C++/CLI support by-value semantics for members so all we need is a managed auto-pointer template class. With such a class the ManagedType becomes really simple.

ref struct ManagedType
{
    AutoPtr n2; // OK
};

ManagedType stores a pointer to a native object and its destructor automatically deletes the object. Woohoo!

The C++ compiler really takes care of a lot of boilerplate code. If you’re not sure just how much code the compiler is taking care of for you then take a look at the compiled assembly in a disassembler.

Although Visual C++ does not provide a managed AutoPtr class, it is reasonably simple to write one. Here is a basic implementation.

template
ref struct AutoPtr
{
    AutoPtr() : m_ptr(0)
    {
        // Do nothing
    }
    AutoPtr(T* ptr) : m_ptr(ptr)
    {
        // Do nothing
    }
    AutoPtr(AutoPtr% right) : m_ptr(right.Release())
    {
        // Do nothing
    }
    ~AutoPtr()
    {
        if (0 != m_ptr)
        {
            delete m_ptr;
            m_ptr = 0;
        }
    }
    T& operator*()
    {
        return *m_ptr;
    }
    T* operator->()
    {
        return m_ptr;
    }
    T* Get()
    {
        return m_ptr;
    }
    T* Release()
    {
        T* released = m_ptr;
        m_ptr = 0;
        return released;
    }
    void Reset()
    {
        Reset(0);
    }
    void Reset(T* ptr)
    {
        if (0 != m_ptr)
        {
            delete m_ptr;
        }
        m_ptr = ptr;
    }
private:
    T* m_ptr;
};

In a future post I may provide a few realistic examples of mixing native and managed code, but I hope this introduction has given you a few ideas on how to mix native and managed code and types effectively in C++.

来自: http://weblogs.asp.net/kennykerr/archive/2005/07/12/Mixing-Native-and-Managed-Types-in-C_2B002B00_.aspx

梦在天�� 2006-08-16 14:23 发表评论

A first look at C++/CLI(C++的管理扩�?

梦在天�� — Thu, 29 Dec 2005 07:14:00 GMT

Introduction

When Microsoft brought out the Managed Extensions to C++ with VS.NET 7, C++ programmers accepted it with mixed reactions. While most people were happy that they could continue using C++, nearly everyone was unhappy with the ugly and twisted syntax offered by Managed C++. Microsoft obviously took the feedback it got very seriously and they decided that the MC++ syntax wasn't going to be much of a success.

On October 6th 2003, the ECMA announced the creation of a new task group to oversee development of a standard set of language extensions to create a binding between the ISO standard C++ programming language and Common Language Infrastructure (CLI). It was also made known that this new set of language extensions will be known as the C++/CLI standard, which will be supported by the VC++ compiler starting with the Whidbey release (VS.NET 2005).

Problems with the old syntax

Ugly and twisted syntax and grammar - All those double underscores weren't exactly pleasing to the eye.

Second class CLI support - Compared to C# and VB.NET, MC++ used contorted workarounds to provide CLI support, for e.g. it didn't have a for-each construct to enumerate .NET collections.

Poor integration of C++ and .NET - You couldn’t use C++ features like templates on CLI types and you couldn’t use CLI features like garbage collection on C++ types.

Confusing pointer usage - Both unmanaged C++ pointers and managed reference pointers used the same * based syntax which was quite confusing because __gc pointers were totally different in nature and behavior from unmanaged pointers.

The MC++ compiler could not produce verifiable code

What C++/CLI gives us?

Elegant syntax and grammar -This gave a natural feel for C++ developers writing managed code and allowed a smooth transition from unmanaged coding to managed coding. All those ugly double underscores are gone now.

First class CLI support - CLI features like properties, garbage collection and generics are supported directly. And what's more, C++/CLI allows jus to use these features on native unmanaged classes too.

First class C++ support - C++ features like templates and deterministic destructors work on both managed and unmanaged classes. In fact C++/CLI is the only .NET language where you can *seemingly* declare a .NET type on the stack or on the native C++ heap.

Bridges the gap between .NET and C++ - C++ programmers won't feel like a fish out of water when they attack the BCL

The executable generated by the C++/CLI compiler is now fully verifiable.

Hello World

using namespace System; void _tmain() { Console::WriteLine("Hello World"); }

Well, that doesn't look a lot different from old syntax, except that now you don't need to add a reference to mscorlib.dll because the Whidbey compiler implicitly references it whenever you compile with /clr (which now defaults to /clr:newSyntax).

Handles

One major confusion in the old syntax was that we used the * punctuator with unmanaged pointers and with managed references. In C++/CLI Microsoft introduces the concept of handles.

void _tmain() { //The ^ punctuator represents a handle String^ str = "Hello World"; Console::WriteLine(str); }

The ^ punctuator (pronounced as cap) represents a handle to a managed object. According to the CLI specification a handle is a managed object reference. Handles are the new-syntax equivalent of __gc pointers in the MC++ syntax. Handles are not to be confused with pointers and are totally different in nature from pointers.

How handles differ from pointers?

Pointers are denoted using the * punctuator while handles are denoted using the ^ punctuator.

Handles are managed references to objects on the managed heap, pointers just point to a memory address.

Pointers are stable and GC cycles do not affect them, handles might keep pointing to different memory locations based on GC and memory compactions.

For pointers, the programmer must deleteexplicitly or else suffer a leak. For handles delete is optional.

Handles are type-safe while pointers are most definitely not. You cannot cast a handle to a void^.

Just as a new returns a pointer, a gcnew returns a handle.

Instantiating CLR objects

void _tmain() { String^ str = gcnew String("Hello World"); Object^ o1 = gcnew Object(); Console::WriteLine(str); }

The gcnew keyword is used to instantiate CLR objects and it returns a handle to the object on the CLR heap. The good thing about gcnew is that it allows us to easily differentiate between managed and unmanaged instantiations.

Basically, the gcnew keyword and the ^ operator offer just about everything you need to access the BCL. But obviously you'd need to create and declare your own managed classes and interfaces.

Declaring types

CLR types are prefixed with an adjective that describes what sort of type it is. The following are examples of type declarations in C++/CLI :-

CLR types
Reference types
refclass RefClass{...};
refstruct RefClass{...};
Value types
value class ValClass{...};
value struct ValClass{...};
Interfaces
interfaceclass IType{...};
interfacestruct IType{...};
Enumerations
enumclass Color{...};
enumstruct Color{...};

Native types
class Native{...};
struct Native{...};

using namespace System; interfaceclass IDog { void Bark(); }; refclass Dog : IDog { public: void Bark() { Console::WriteLine("Bow wow wow"); } }; void _tmain() { Dog^ d = gcnew Dog(); d->Bark(); }

There, the syntax is now so much more neater to look at than the old-syntax where the above code would have been strewn with double-underscored
keywords like __gc and __interface.

Boxing/Unboxing

Boxing is implicit (yaay!) and type-safe. A bit-wise copy is performed and an Object is created on the CLR heap. Unboxing is explicit - just do a reinterpret_cast and then dereference.

void _tmain() { int z = 44; Object^ o = z; //implicit boxingint y = *reinterpret_cast<int^>(o); //unboxing Console::WriteLine("{0} {1} {2}",o,z,y); z = 66; Console::WriteLine("{0} {1} {2}",o,z,y); } // Output// 44 44 44// 44 66 44

The Objecto is a boxed copy and does not actually refer the int value-type which is obvious from the output of the second Console::WriteLine.

When you box a value-type, the returned object remembers the original value type.

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; Console::WriteLine(o1->GetType()); Console::WriteLine(o2->GetType()); } // Output// System.Int32// System.Single

Thus you cannot try and unbox to a different type.

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; int y = *reinterpret_cast<int^>(o2);//System.InvalidCastExceptionfloat g = *reinterpret_cast<float^>(o1);
//System.InvalidCastException }

If you do attempt to do so, you'll get a System.InvalidCastException. Talk about perfect type-safety! If you look at the IL generated, you'll see the MSIL box instruction in action. For example :-

void Box2() { float y=45; Object^ o1 = y; }

gets compiled to :-

.maxstack 1 .locals (float32 V_0, object V_1) ldnull stloc.1ldc.r4 45. stloc.0ldloc.0 box [mscorlib]System.Single stloc.1ret

According to the MSIL docs, "The box instruction converts the ‘raw�?valueType (an unboxed value type) into an instance of type Object (of type O). This is accomplished by creating a new object and copying the data from valueType into the newly allocated object."

Further reading

Write Faster Code with the Modern Language Features of Visual C++ 2005 [from MSDN]

To C++ or not to C++, that is the question! [from my blog]

Conclusion

Alright, so why would anyone want to use C++/CLI when they can use C#, J# and that VB thingie for writing .NET code? Here are the four reasons I gave during my talk at DevCon 2003 in Trivandrum (Dec 2003).

Compile existing C++ code to IL (/clr magic)

Deterministic destruction

Native interop support that outmatches anything other CLI languages can offer

All those underscores in MC++ are gone ;-)

About Nishant Sivakumar

Editor
Site Builder Nish is a real nice guy living in Toronto who has been coding since 1990, when he was 13 years old. Originally from sunny Trivandrum in India, he has moved to Toronto so he can enjoy the cold winter and get to play in some snow.

He works for The Code Project and handles the Dundas MFC products Ultimate Toolbox, Ultimate Grid and Ultimate TCP/IP that are sold exclusively through The Code Project Storefront. He frequents the CP discussion forums when he is not coding, reading or writing. Nish hopes to visit at least three dozen countries before his human biological mechanism stops working (euphemism used to avoid the use of the d-word here), and regrets that he hasn't ever seen snow until now (will be rectified this December). Oh btw, it must be mentioned that normally Nish is not inclined to speak about himself in the 3rd person.

Nish has been a Microsoft Visual C++ MVP since October, 2002 - awfully nice of Microsoft, he thinks. He maintains an MVP tips and tricks web site - www.voidnish.com where you can find a consolidated list of his articles, writings and ideas on VC++, MFC, .NET and C++/CLI. Oh, and you might want to check out his blog on C++/CLI, MFC, .NET and a lot of other stuff - blog.voidnish.com

Nish loves reading Science Fiction, P G Wodehouse and Agatha Christie, and also fancies himself to be a decent writer of sorts. He has authored a romantic comedy Summer Love and Some more Cricket as well as a programming book �?Extending MFC applications with the .NET Framework.
Click here to view Nishant Sivakumar's online profile.

C++的管理扩�?/h1>
��?/b>
C++��理扩展是一�l�语�a�扩展�Q�它帮助Microsoft Visual C++开发�h员�ؓ微��Y.NET�~�写应用�E�序�?
��理扩展是有用的�Q�如果你�Q?
希望提高开发�h员��用C++�~�写.NET应用�E�序的生产率
要分阶段地将一大段代码从非��理C++中移植到.NET�q�_��?
想从.NET Framework应用�E�序中��用已有的非管理C++�l��g�?
想从非管理C++中��?NET Framework�l��g
在同一应用�E�序中�؜合非��理C++代码�?NET代码
C++��理扩展为开发�h员定�?NET Framework提供了无比的灉|��性。传�l�的非管理C++和管理C++代码可以自由地�؜合在一�?br />应用�E�序中。用��理扩展�~�写的应用程序可以利用两�U�代码的优点。��用管理扩展，现有�l��g可以方便地封装到.NET�l��g中，
在与.NET集成的同时保留原有投资�?
什么是��理扩展?
扩展允许你在C++中编写在.NET Framework控制下运行的��理�Q�或.NET�Q�类。（非管理C++�c�运行在传统的微软基于Windows?
的环境中。）一个管理类是一个内�|�的.NET�c�，可以完全利用.NET Framework�?
��理扩展是Visual C++开发系�l�的新关键字和属性。它们允许开发�h员决定哪些类或函数编译�ؓ��理或非��理代码�?br />�q�些部分然后��可以��^滑地与其它部分或外部库交互�?
��理扩展也用于在C++源代码中表示.NET�c�d��和概��c��这��允许开发�h员容易地�~�写.NET应用�E�序�Q�而无需�~�写额外代码�?
主要使用环境
��现有代码��^滑地�U�L��?.NET
如果你在C++代码上有大量投资�Q�管理扩展将帮你��它们��^滑地转移�?NET�q�_��中。因��Z��可以在一个应用程�?-
甚至是同一文�g中�؜合管理和非管理代码，你可以用很长旉��转移代码�Q�一个组件接一个组件地转换�?NET中�?
或你可以�l�箋在非��理C++中编写组�Ӟ��以利用该语言的强大功能和灉|��性，只用��理扩展�~�写��量的高性能�?
��装器（它��你的代码可以�?NET�l��g中调用）�?
�?.NET语言中访问C++�l��g
��理扩展允许你从��M��.NET语言中调用C++�c�R��你需要用扩展�~�写��单的��装器，它将你的C++�c�d��Ҏ��暴露�?
��理�c�R��封装器是完全的��理�c�，可以从�Q�?NET语言中调用。封装器�c�L��作�ؓ了管理类与非��理C++�c�间�?
映射层。它��单地��方法调用直接传递到非管理类中。管理扩展可用于调用��M��内置的动态链接库�Q�DLL�Q�及
内置�c�R�?
从内�|�代码中讉K��.NET �c?
使用��理扩展�Q�你可以创徏�q�从C++代码中直接调�?NET�c�R��你可以�~�写��?NET�l��g当作��M��其它��理C++�cȝ��
C++代码。你可以使用.NET Framework中内�|�的COM调用.NET�c�R��你使用COM�q�是使用��理扩展讉K��.NET�l��g
要依赖于你的工程。在一些情况下�Q�利用现有的COM支持是最好的选择。在另一些情况下�Q��用管理扩展可�?
会增加性能和开发者的生��率�?
在同一可执行文件中的管理和内置代码
Visual C++�~�译器能在管理和非管理上下文中自动而透明的翻译数据、指针和指��o��。这个过�E�是允许��理扩展
无缝��C��非管理代码交互的�q�程。开发�h员能够控制什么样的数据和代码可以��理。选择每个�c�L��函数是管�?
�q�是非管理的能力为开发�h员提供了更大的灵�z�L��。一些代码或数据�c�d��在非��理环境中执行得要比较好�?
另一斚w��Q�管理代码由于如��片攉��和类库等�Ҏ��，它提高了开发�h员的生��率。现有非��理代码可以一��?
一部分地�{化�ؓ��理代码�Q�因此保留了已有的投资�?/li>

梦在天�� 2005-12-29 15:14 发表评论

梦在天�� — Mon, 21 Nov 2005 02:47:00 GMT
     摘要: Managed, Unmanaged, Native: What Kind of Code Is This?  阅读全文

梦在天�� 2005-11-21 10:47 发表评论

梦在天�� — Fri, 18 Nov 2005 05:51:00 GMT
     摘要: 归纳��h��Q�泛型比非泛型具有下面两个优点： 1�?nbsp; 更加安全在非泛型�~�程中，虽然所有的东西都可以作为Object传递，但是在传递的�q�程中免不了要进行类型�{换。而类型�{换在�q�行时是不安全的。��用泛型编�E�将可以减少不必要的�c�d��转换�Q�从而提高安全性�?2�?nbsp; 效率更高在非泛型�~�程中，��简单类型作为Object传递时会引起Boxing和Unboxing操作�Q�这两个�q�程都是��h��...  阅读全文

梦在天�� 2005-11-18 13:51 发表评论

关于 “托��与非托��?�?大家都知道那些，来说��_��

梦在天�� — Fri, 18 Nov 2005 05:36:00 GMT

与非托管代码互操�?

��Z��使得现存的非.NET代码都可用，微��Y的设计��得CLR可以在应用程序里同时包含托管和非托管代码。CLR支持三种互操作：

托管代码调用DLL�Q�就是我们说的动态链接库�Q�中的非托管函数

托管代码使用现存的COM�l�徏�Q�非托管�l�徏作�ؓCOM服务器）

非托��代码��用托��类型（托管�c�d��作�ؓCOM服务器）

互操作�?BR>是否可以�?.NET 框架�E�序中��?COM 对象�Q?BR>是。您现在部��v的�Q�?COM �l��g都可以在托管代码中��用。通常情况下，所需的调整是完全自动�q�行的�?/P>
特别是，可以使用�q�行时可调用包装 (RCW) �?.NET 框架讉K�� COM �l��g。此包装��?COM �l��g提供�?COM 接口转换��Z�� .NET 框架兼容的接口。对�?OLE 自动化接口，RCW 可以从类型库中自动生成；对于�?OLE 自动化接口，开发�h员可以编写自定义 RCW�Q�手动将 COM 接口提供的类型映��ؓ�?.NET 框架兼容的类型�?/P>
是否可以�?COM �E�序中��?.NET 框架�l��g�Q?BR>是。您现在创徏的托��类型都可以通过 COM 讉K��。通常情况下，所需的配�|�是完全自动�q�行的。托��开发环境的某些新特性不能在 COM 中访问。例如，不能�?COM 中��用静态方法和参数化构造函数。一般，提前��定�l�定�c�d��所针对的用��h��一�U�较好的办法。如果类型需要在 COM 中��用，您将被限制在使用 COM 可访问的�Ҏ��?/P>
默认情况下，托管�c�d��可能是可见的�Q�也可能是不可见的，�q�由用于�~�写托管�c�d��的语�a�军_��?/P>
特别是，可以使用 COM 可调用包�?(CCW) �?COM 讉K�� .NET 框架�l��g。这�?RCW�Q�请参阅上一个问题）�怼��Q�但它们的方向相反。同��P��如果 .NET 框架开发工具不能自动生成包装，或者如果自动方式不是您所需要的�Q�则可以开发自定义�?CCW�?/P>
是否可以�?.NET 框架�E�序中��?Win32 API�Q?BR>是。��?P/Invoke�Q?NET 框架�E�序可以通过静�?DLL 入口点的方式来访问本��Z��码库�?/P>
下面�?C# 调用 Win32 MessageBox 函数的示例：

using System;
using System.Runtime.InteropServices;

class MainApp
{
    [DllImport("user32.dll", EntryPoint="MessageBox")]
    public static extern int MessageBox(int hWnd, String strMessage, String strCaption, uint uiType);

    public static void Main()
    {
        MessageBox( 0, "您好�Q�这�?PInvoke�Q?, ".NET", 0 );
    }
}

-----------------------------------------------------------------------------
什么是托管代码和托��数据？

托管代码是�ؓ面向公共语言�q�行库的服务�~�写的代码（请参阅“什么是公共语言�q�行库？”）。�ؓ了面向这些服务，该代码必��d��q�行库提供最低��别的信息�Q�元数据�Q�。默认情况下�Q�所�?C#、Visual Basic .NET �?JScript .NET 代码都受托管。默认情况下�Q�Visual Studio .NET C++ 代码不受托管�Q�但�~�译器可以通过指定命��o行开�?(/CLR) 来��生托��代码�?
与托��代码密切相关的是托��数据（由公��p��a��q�行库的垃圾回收器分配和释放的数据）。默认情况下�Q�C#、Visual Basic �?JScript .NET 数据受托��。然而，通过使用�Ҏ��的关键字可以��?C# 数据标记为非托管。默认情况下�Q�Visual Studio .NET C++ 数据不受托管�Q�即使在使用 /CLR 开��x��Q�，但在使用 C++ 托管扩展�Ӟ��可以通过使用 __gc 关键字将�c�L��Cؓ托管。正如名�U�所暗示的，�q�意味着用于�c�d��例的内存受垃圑֛�收器的托��。另外，�c�L��?.NET 框架�C�֌�的一名完全参与的成员�Q�这既带来了好处�Q�也带来了限制。其中一个好处是与用其他语言�~�写的类的正��互操作性（例如�Q�托��?C++ �c�d��以从 Visual Basic �cȝ��承）。其中一个限制是托管�c�d��能从基类�l�承�?/P>
--------------------------------------------------------------------------------
什么是公共语言�q�行�?(CLR)�Q?BR>公共语言�q�行时是 .NET 框架应用�E�序的执行引擎�?/P>
它提供许多服务，包括�Q?/P>
代码��理�Q�加载和执行�Q?/P>

应用�E�序内存隔离

�c�d��安全验证

IL 到本��Z��码的转换

元数据（增强的类型信息）讉K��

为托��对象管理内�?/P>

强制代码讉K��安全

异常处理�Q�包括跨语言异常

托管代码、COM 对象和现�?DLL�Q�非托管代码和数据）之间的互操作

自动�q�行对象布局

对开发�h员服务（配置、调试等�Q�的支持

什么是公共�c�d��pȝ�� (CTS)�Q?BR>公共�c�d��pȝ��是多信息�c�d��pȝ��Q�它被内�|�在公共语言�q�行时中�Q�支持大多数�~�程语言中的�c�d��和操作。公��q��型系�l�支持大量编�E�语�a�的完全实现�?/P>

什么是公共语言规范 (CLS)�Q?BR>公共语言规范是一�l�结构和限制�Q�用作库�~�写者和�~�译器编写者的指南。它使�Q何支�?CLS 的语�a�都可以完全��用库�Q��ƈ且�ɘq�些语言可以�怺�集成。公��p��a�规范是公��q��型系�l�的子集。对于那些需要编写代码供其他开发�h员��用的应用�E�序开发�h员，公共语言规范也非帔R��要。如果开发�h员遵�?CLS 规则来设计公��p��问的 API�Q�那么就可以在支持公��p��a��q�行时的��M��其他�~�程语言中很�Ҏ��C��用这�?API�?/P>

什么是 Microsoft 中间语言 (MSIL)�Q?BR>MSIL 是与 CPU 无关的指令集�?NET 框架�E�序被编译成 MSIL。它包含加蝲、存储、初始化和调用对象方法的指��o�?/P>
与元数据和公��q��型系�l�结合，MSIL 允许真正的跨语言集成�?/P>
MSIL 在执行前被�{换�ؓ机器代码�Q�而不是一边解释一�Ҏ��行�?/P>

梦在天�� 2005-11-18 13:36 发表评论

重复�ơ数	C# �E�序	C++�E�序
50,000	61	10
500,000	600	70
1,000,000	1162	140
5,000,000	6369	721

Description	C++/CLI	C#
Allocate reference type	ReferenceType^ h = gcnew ReferenceType;	ReferenceType h = new ReferenceType();
Allocate value type	ValueType v(3, 4);	ValueType v = new ValueType(3, 4);
Reference type, stack semantics	ReferenceType h;	N/A
Calling Dispose method	ReferenceType^ h = gcnew ReferenceType; delete h;	ReferenceType h = new ReferenceType(); ((IDisposable)h).Dispose();
Implementing Dispose method	~TypeName() {}	void IDisposable.Dispose() {}
Implementing Finalize method	!TypeName() {}	~TypeName() {}
Boxing	int^ h = 123;	object h = 123;
Unboxing	int^ hi = 123; *int c = hi;**	object h = 123; int i = (int) h;
Reference type definition	ref class ReferenceType {}; ref struct ReferenceType {};	class ReferenceType {}
Value type definition	value class ValueType {}; value struct ValueType {};	struct ValueType {}
Using properties	h.Prop = 123; int v = h.Prop;	h.Prop = 123; int v = h.Prop;
Property definition	property String^ Name { String^ get() { return m_value; } void set(String^ value) { m_value = value; } }	string Name { get { return m_name; } set { m_name = value; } }

�c�d��描述	标准C++�c�d��?/td>	托管C++�c�d��?/td>	长度(�?
布尔�?/td>	bool	bool	8
字符�?/td>	char	signed char	8
无符号字�W�型	unsigned char	char	8
短整�?/td>	short [int]	short	16
无符��L��整型	unsigned short [int]	unsigned short	16
整型	int	int �?long	32
无符��h��?/td>	unsigned [int]	unsigned int �?long	32
长整�?/td>	long [int]	long	32
无符号长整型	unsigned long [int]	unsigned long	32
单精度��Q点型	float	float	32
双精度��Q点型	double	double	64
长双�_�ֺ��点�?/td>	long double	--	64
Unicode字符	--	wchar_t	16
64位整�?/td>	--	__int64	64
无符�?4位整�?/td>	--	unsigned __int64	64
96位十�q�制�?/td>	--	Decimal	96
对象�c�d��	--	Object*	32
字符串类�?/td>	--	String*	--

/O1	创徏��代�?/td>
/O2	创徏快速代�?/td>
/Oa	假设没有别名
/Ob	控制内联展开
/Od	��用优化
/Og	使用全局优化
/Oi	生成内部函数
/Op	改善��点��C��致�?/td>
/Os	代码大小优先
/Ot	代码速度优先
/Ow	假定在函数调用中使用别名
/Ox	使用最大优�?(/Ob2gity /Gs)
/Oy	省略框架指针

/arch	使用 SSE �?SSE2 指��o生成代码
/clr	启用 C++ 的托��扩展�ƈ产生在公��p��a��q�行库上�q�行的输出文�?/td>
/EH	指定异常处理模型
/G3	优化代码以优�?386 处理器。在 Visual C++ 5.0 中已�l�停用，�~�译器将忽略此选项
/G4	优化代码以优�?486 处理器。在 Visual C++ 5.0 中已�l�停用，�~�译器将忽略此选项
/G5	优化代码以优�?Pentium
/G6	优化代码以优�?Pentium Pro、Pentium II �?Pentium III 处理�?/td>
/G7	针对 Pentium 4 �?Athlon 优化代码�?/td>
/GB	�?/G6 �{�效�Q�将 _M_IX86 的��D��\|��ؓ 600
/Gd	使用 __cdecl 调用�U�定
/Ge	�Ȁ�z�d��栈探��?/td>
/GF /Gf	启用字符串池
/Gh	调用挂钩函数 _penter
/GH	调用挂钩函数 _pexit
/GL	启用全程序优�?/td>
/Gm	启用最��重新生�?/td>
/GR	启用�q�行时类型信�?(RTTI)
/Gr	使用 __fastcall 调用�U�定
/Gs	控制堆栈探测
/GT	支持使用静态线�E�本地存储区分配的数据的�U�程安全
/GX	启用同步异常处理
/Gy	启用函数�U�链�?/td>
/Gz	使用 __stdcall 调用�U�定
/MD	使用 MSVCRT.lib 创徏多线�E?DLL
/MDd	使用 MSVCRTD.lib 创徏调试多线�E?DLL
/ML	使用 LIBC.lib 创徏单线�E�可执行文�g
/MLd	使用 LIBCD.lib 创徏调试单线�E�可执行文�g
/MT	使用 LIBCMT.lib 创徏多线�E�可执行文�g
/MTd	使用 LIBCMTD.lib 创徏调试多线�E�可执行文�g

/FA /Fa	创徏列表文�g 讄��列表文�g�?/td>
/Fd	重命名程序数据库文�g
/Fe	重命名可执行文�g
/Fm	创徏映射文�g
/Fo	创徏对象文�g
/Fp	指定预编译头文�g�?/td>
/FR /FR	生成��览器文�?/td>
/Fx	��插入的代码与源文�g合�ƈ

/GS	�~�冲区安全检�?/td>
/GZ	�?/RTC1 相同
/RTC	启用�q�行旉��误检�?/td>
/Wp64	��?64 位可�U�L��性问�?/td>
/Yd	��完整的调试信息攑֜�所有对象文件中
/Yl	创徏调试库时插入 PCH 引用
/Z7	生成�?C 7.0 兼容的调试信�?/td>
/Zd	生成行号
/Zi	生成完整的调试信�?/td>

/AI	指定在解析传递到 #using 指��o的文件引用时搜烦的目�?/td>
/C	在预处理期间保留注释
/D	定义常数和宏
/E	��预处理器输出复制到标准输出
/EP	��预处理器输出复制到标准输出
/Fl	预处理指定的包含文�g
/FU	强制使用文�g名，��像它已被传递到 #using 指��o一�?/td>
/I	在目录中搜烦包含文�g
/P	��预处理器输出写入文�?/td>
/U	�U�除预定义宏
/u	�U�除所有的预定义宏
/X	忽略标准包含目录
/ZI	��调试信息包含在与“编辑�ƈ�l�箋”兼容的�E�序数据库中

/vd	取消或启用隐藏的 vtordisp �c�L��?/td>
/vmb	�Ҏ��向成员的指针使用最佳的�?/td>
/vmg	�Ҏ��向成员的指针使用完全一般�?/td>
/vmm	声明多重�l�承
/vms	声明单一�l�承
/vmv	声明虚拟�l�承
/Za	��用语言扩展
/Zc	�?/Ze 下指定标准行�?/td>
/Ze	启用语言扩展
/Zg	生成函数原型
/Zl	�?.obj 文�g中移除默认库�?/td>
/Zp n	��装�l�构成员
/Zs	只检查语�?/td>

/F	讄��堆栈大小
/LD	创徏动态链接库
/LDd	创徏调试动态链接库
/link	��指定的选项传递给 LINK
/MD	使用 MSVCRT.lib �~�译以创建多�U�程 DLL
/MDd	使用 MSVCRTD.lib �~�译以创��试多�U�程 DLL
/ML	使用 LIBC.lib �~�译以创建单�U�程可执行文�?/td>
/MLd	使用 LIBCD.lib �~�译以创��试单�U�程可执行文�?/td>
/MT	使用 LIBCMT.lib �~�译以创建多�U�程可执行文�?/td>
/MTd	使用 LIBCMTD.lib �~�译以创��试多�U�程可执行文�?/td>

/Y-	忽略当前生成中的所有其他预�~�译头编译器选项
/Yc	创徏预编译头文�g
/Yd	��完整的调试信息攑֜�所有对象文件中
/Yu	在生成期间��用预�~�译头文�?/td>
/YX	自动处理预编译头

@	指定响应文�g
/?	列出�~�译器选项
/c	�~�译但不链接
/H	限制外部�Q�公共）名称的长�?/td>
/HELP	列出�~�译器选项
/J	更改默认�?char �c�d��
/nologo	取消昄��d��版权标志
/QI0f	��保 Pentium 0F 指��o没有问题
/QIfdiv	FDIV、FPREM、FPTAN �?FPATAN 指��o有缺��L�� Intel Pentium 微处理器的变通方�?/td>
QIfist	当需要从��点�c�d��转换为整型时取消 Helper 函数 _ftol 的调�?/td>
/showIncludes	在编译期间显�C�所有包含文件的列表
/Tc /TC	指定 C 源文�?/td>
/Tp /TP	指定 C++ 源文�?/td>
/V	讄��版本字符�?/td>
/W	讄��警告�{��
/w	��用所有警�?/td>
/Wall	启用所有警告，包括默认情况下禁用的警告
/WL	在从命��o行编�?C++ 源代码时启用错误信息和警告消息的单行诊断
/Zm	指定预编译头内存分配限制

国内久久精品,亚洲一区二区不卡免费,亚洲人午夜精品免费

C++/CLI 中文

C++/CLI�Q�第一���的CLI语言(转蝲)

C++/CLI�Q�第一���的CLI语言 2005-08-25 11:25 作者： 朱先忠编�?出处�Q?天极�|?责�Q�~�辑�Q�方�?

CLI与C#比较

CLI中native的string和System::String转化

C#的Form通过CLI调用C++的DLL

NativeC++通过CLI调用C#的Form

一个CLI/C++的DLL同时被C#的exe和NativeC++的exe调用

C#通过C++/CLI调用C++DLL

C++�?NET中基����c�d��的对应及转化

C++/CLI

C#界面�Q�C++���法

Managed c++与c++\CLI的区�?实例)

Visual C++ .NET�~�程�Q�托���C++概述

c++\CLI与c#

Native c++ 和Managed �?interop

Visual C++ �~�译器选项

请参�?/h4> C/C++ 生成参�?/a> | �~�译器选项 | 讄����~�译器选项 梦在天�� 2006-08-17 12:16 发表评论

非托���的vc工程中部分文件���?Net Framwork

使用c++\CLI实现c++托管与非托管混合�~�程

Mixing Native and Managed Types in C++

A first look at C++/CLI(C++的管理扩�?

Introduction

Problems with the old syntax

What C++/CLI gives us?

Hello World

Handles

How handles differ from pointers?

Instantiating CLR objects

Declaring types

Boxing/Unboxing

Further reading

Conclusion

About Nishant Sivakumar

关于 “托���与非托��?�?大家都知道那些，来说��_��

C++/CLI�Q�第一��的CLI语言(转蝲)

C++/CLI�Q�第一��的CLI语言
2005-08-25 11:25 作者：朱先忠编�?出处�Q?天极�|?责�Q�~�辑�Q�方�?

C++�?NET中基��c�d��的对应及转化

C#界面�Q�C++��法

Visual C++ .NET�~�程�Q�托��C++概述

请参�?/h4>
C/C++ 生成参�?/a> | �~�译器选项 | 讄��~�译器选项

梦在天�� 2006-08-17 12:16 发表评论

非托��的vc工程中部分文件��?Net Framwork

关于 “托��与非托��?�?大家都知道那些，来说��_��