久久激情亚洲精品无码?V,久久久91人妻无码精品蜜桃HD,国产香蕉久久精品综合网

Sun, 14 Mar 2010 16:05:00 GMT

求windows xp �J�体版，最好是台湾版的�Q�要能一步步的手动安�?惌��双系�l?

找了好几天了�Q�很多资源都下不�?br>
今天好不�Ҏ(gu��)��下了一个，但是香港版的�Q�且安装到选择盘符�Ӟ��键盘所有键都不能��用，所以还是无法安�?br>
谢谢各位大哥大姐帮帮忙，��弟感激不尽�Q?img src ="http://www.shnenglu.com/twzheng/aggbug/109710.html" width = "1" height = "1" />

谭文�?/a> 2010-03-15 00:05 发表评论

Sun, 06 Jan 2008 06:41:00 GMT

摘要: Visual C++�U�程同步技术剖析摘自：(x��)天极�|�作者：(x��)中国甉|�L传播研究所郎锐　摘要�Q?多线�E�同步技术是计算��Y件开发的重要技术，本文对多�U�程的各�U�同步技术的原理和实现进行了初步探讨。　　关键词：(x��) VC++6.0�Q?�U�程同步�Q��(f��)界区�Q�事�Ӟ��互斥�Q�信号量�Q? 　　阅读目录�Q?　　使线�E�同�?　　临界区　　��理事�g内核对象　　信号量内核对象　　互斥内核对象　　��结　　... 阅读全文

谭文�?/a> 2008-01-06 14:41 发表评论

Sun, 06 Jan 2008 06:12:00 GMT

句柄的本�?/strong>
摘自好易教程�|?/span>

一、书上定义：(x��)

<>(Microsoft Press,by Richard Wilton)
    在Windows环境中，句柄是用来标识项目的�Q�这些项目包括：(x��)模块(module)、�Q�?task)、实�?(instance)、文�?file)、内存块(block of memory)、菜�?menu)、控�?control)、字�?font)、资�?resource)�Q�包括图�?icon)�Q�光�?(cursor)�Q�字�W�串(string)�{�、GDI对象(GDI object)�Q�包括位�?bitmap)�Q�画�?brush)�Q�元文�g�Q�metafile�Q?调色�?palette)�Q�画�W?pen)�Q�区�?(region)�Q�以�?qi��ng)设备描�q�表(device context)�?

<(南京大学出版�C?�Q?br>    句柄是WONDOWS用来标识被应用程序所建立或��用的对象的唯一整数�Q�W(xu��)INDOWS使用各种各样的句柄标识诸如应用程序实例，�H�口�Q�控�Ӟ��位图�Q�GDI对象�{�等。WINDOWS句柄有点象C语言中的文�g句柄�?

二、MFC源代码：(x��)

#ifdef STRICT
typedef void *HANDLE;
#define DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
#else
typedef PVOID HANDLE;
#define DECLARE_HANDLE(name) typedef HANDLE name
#endif

DECLARE_HANDLE(HMODULE);
DECLARE_HANDLE(HINSTANCE);
DECLARE_HANDLE(HLOCAL);
DECLARE_HANDLE(HGLOBAL);
DECLARE_HANDLE(HDC);
DECLARE_HANDLE(HRGN);
DECLARE_HANDLE(HWND);
DECLARE_HANDLE(HMENU);
DECLARE_HANDLE(HACCEL);
DECLARE_HANDLE(HTASK);

三、理解：(x��)
    HANDLE��是PVOID�Q�也��是无类型指针，
    上面�q�些资源的句柄Handles都不�q�是指向struct的指针，至于�q�个struct的用处，�q�M$都说unused了，现在解释下M$�q�么做的意义�Q�这��是所谓数据封装，你可以在你的�E�序中把M$的内部结构指针传来传去，可是你却不知道它到底指向的内�Ҏ(gu��)��什么�?br>
    句柄与指针确实是完全不同的两个概��c(di��n)��句柄仅仅是一�?2位整敎ͼ�W(xu��)IN32中用于标记某个系�l�或�q�程的对象，可以理解为对象烦引（�׃��M$未完全公开相关技术，在一定程度上只能如此理解�Q�，�q�个索引更像是一�U�映��关�p�（从句柄到对象指针的映��）�Q�而不是纯�_Ҏ(gu��)��义上�?#8220;数组下标”�?

     句柄可以理解为用于指向或标识内存的一�?#8220;资源”�Q�这些资源如�Q�文�?file)、内存块(block of memory)、菜�?menu)�{�等。操作系�l�通过句柄来定位核心对象和�pȝ��资源�?br>    指针即�ؓ(f��)指向内存�?#8220;数据或指�?#8221;某一单元�?br>
    说的��切一点，句柄实际上是一�U�指向某�U�资源的指针�Q�但与指针又有所不同�Q�指针对应着一个数据在内存中的地址�Q�得��C��指针��可以自由地修改该数据。Windows�q�不希望一般程序修改其内部数据�l�构�Q�因��样太不安全。所以Windows�l�每个��用GlobalAlloc�{�函数声明的内存区域指定一个句�?本质上仍是一个指针，但不要直接操作它)�Q��^时你只是在调用API函数时利用这个句柄来说明要操作哪�D�内存�?br>

四、引喻：(x��)
   牧童遥指杏花�?br>   牧童的手为指针，杏花村的牌子为句柄，杏花村酒店�ؓ(f��)对象的实�?

附注�Q�获得窗口句柄三�U�方�?br>
1.HWND FindWindow(LPCTSTR lpClassName, LPCTSTR lpWindowName)

   HWND FindWindowEx(HWND hwndParent, HWND hwndChildAfter,LPCTSTR lpClassName, LPCTSTR lpWindowName)

2.HWND WindowFromPoint(POINT& Point)//获得当前鼠标光标位置的窗口HWND

3.BOOL CALLBACK EnumChildProc(HWND hwnd,LPARAM lParam)

   BOOL CALLBACK EnumChildWindows(HWND hWndParent, WNDENUMPROC lpEnumFunc,LPARAM lParam)

   BOOL CALLBACK EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

   BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)

谭文�?/a> 2008-01-06 14:12 发表评论

关于strcpy()与memcpy()比较

Wed, 13 Jun 2007 12:57:00 GMT

关于strcpy()与memcpy()比较

举例�Q?/p>
{

byte a[4];// 每一个字节赋数值类�?br>
byte c1[4];

byte c2[4];

memcpy(c1, a, sizeof(byte)*4); //正确使用

strcpy((char*)(byte*)c2, (char*)(byte*)a);//错误调用

}

函数原型

   strcpy

   extern char *strcpy(char *dest,char *src);

   #include

   功能�Q�把src所指由NULL�l�束的字�W�串复制到dest所指的数组�?br>
   说明:src和dest所指内存区域不可以重叠且dest必须有��够的�I�间来容�U�src的字�W�串�?br>
   �q�回指向dest的指�?br>

memcpy

extern void *memcpy(void *dest,void *src,unsigned int count);

#include

   功能�Q�由src所指内存区域复制count个字�W�串到dest所指内存区�?

   说明�Q�src和dest所指内存区域不能重叠，函数�q�回指向dest的指�?函数原型

关于memcpy的用�?/span>

作用�Q�在dest处拷贝src处的字节�Q��ƈ以count来计��需要拷贝的字节数量�Q�进行内存的拯��?/span>

参数�Q?dest:新的存贮区的开始部�?nbsp; src�Q�需要拷贝的开始部�?nbsp;   count�Q�需要拷贝的字节数备注：(x��)dest,src�Q�它们都是从各自的地址处进行写入，如果是p而不�?amp;p,那么奖会(x��)取得p的��|��地址�Q?在该值的地址处进行读出或写入�?/span>

例：(x��)

int* intPoint = new int(3333);

int* intPoint1;

//在intPoint1的地址处写入intPoint地址处的��|��也就是intPoint指针倹{�?nbsp;

memcpy( &intPoint1, &intPoint, 4 );

//使intPoint1指向了intPoint. �? int* intPoint = new int(3333);

cout << *intPoint1 << endl;

可以看出　strcpy()　是处理的字符�?遇零�l�束)�Q�memcpy()　是处理一个缓冲区�Q�void*�c�d��的）�Q�而我们的内容中有数字0�Q�而数�?又是字符串的�l�尾字符 ' \0' 的数字表玎ͼ�字符串拷贝是遇到0��q��束，所以，如果要拷贝的�~�冲区如果是非字�W�串那么��尽量用memcpy()�Q�这样可以避免出错的可能�?/p>

谭文�?/a> 2007-06-13 20:57 发表评论

Mon, 21 May 2007 08:51:00 GMT

C/C++中回调函数初�?/h1> [摘自] 天极开发网�Q�http://dev.yesky.com/�Q?/span>

         ��?br>
　　对于很多初学者来��_(d��)��往往觉得回调函数很神�U�，很想知道回调函数的工作原理。本文将要解释什么是回调函数、它们有什么好处、�ؓ(f��)什么要使用它们�{�等问题�Q�在开始之前，假设你已�l�熟知了函数指针�?

　　什么是回调函数�Q?/strong>

　　��而言之，回调函数��是一个通过函数指针调用的函数。如果你把函数的指针�Q�地址�Q�作为参��C��递给另一个函敎ͼ�当这个指针被用�ؓ(f��)调用它所指向的函数时�Q�我们就说这是回调函数�?br>
　　��Z��么要使用回调函数�Q?/strong>

　　因�ؓ(f��)可以把调用者与被调用者分开。调用者不兛_��谁是被调用者，所有它需知道的，只是存在一个具有某�U�特定原型、某些限制条�Ӟ��如返回��gؓ(f��)int�Q�的被调用函数�?br>
　　如果想知道回调函数在实际中有什么作用，先假设有�q�样一�U�情况，我们要编写一个库�Q�它提供了某些排序算法的实现�Q�如冒��排序、快速排序、shell排序、shake排序�{�等�Q�但��Z��库更加通用�Q�不惛_��函数中嵌入排序逻辑�Q�而让使用者来实现相应的逻辑�Q�或者，惌��库可用于多种数据�c�d��Q�int、float、string�Q�，此时�Q�该怎么办呢�Q�可以��用函数指针，�q�进行回调�?br>
　　回调可用于通知机制�Q�例如，有时要在�E�序中设�|�一个计时器�Q�每��C��定时��_(d��)��E�序�?x��)得到相应的通知�Q�但通知机制的实现者对我们的程序一无所知。而此�Ӟ��需有一个特定原型的函数指针�Q�用�q�个指针来进行回调，来通知我们的程序事件已�l�发生。实际上�Q�SetTimer() API使用了一个回调函数来通知计时器，而且�Q�万一没有提供回调函数�Q�它�q�会(x��)把一个消息发往�E�序的消息队列�?br>
　　另一个��用回调机制的API函数是EnumWindow()�Q�它枚�D屏幕上所有的��层�H�口�Q��ؓ(f��)每个�H�口调用一个程序提供的函数�Q��ƈ传递窗口的处理�E�序。如果被调用者返回一个��|��q��l�进行�P代，否则�Q�退出。EnumWindow()�q�不兛_��被调用者在何处�Q�也不关心被调用者用它传递的处理�E�序做了什么，它只兛_��q�回��|��因�ؓ(f��)��Z��q�回��|��它将�l�箋执行或退出�?br>
　　不管怎么��_(d��)��回调函数是��l�自C语言的，因而，在C++中，应只在与C代码建立接口�Q�或与已有的回调接口打交道时�Q�才使用回调函数。除了上�q�情况，在C++中应使用虚拟�Ҏ(gu��)��或函数符�Q�functor�Q�，而不是回调函数�?br>
　　一个简单的回调函数实现

　　下面创徏了一个sort.dll的动态链接库�Q�它导出了一个名为CompareFunction的类�?-typedef int (__stdcall *CompareFunction)(const byte*, const byte*)�Q�它?y��u)��是回调函数的类型。另外，它也导出了两个方法：(x��)Bubblesort()和Quicksort()�Q�这两个�Ҏ(gu��)��原型相同�Q�但实现了不同的排序��法�?br>

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

void DLLDIR __stdcall Quicksort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

　　�q�两个函数接受以下参敎ͼ�(x��)

　　·byte * array�Q�指向元素数�l�的指针�Q��Q意类型）�?br>
　　·int size�Q�数�l�中元素的个数�?br>
　　·int elem_size�Q�数�l�中一个元素的大小�Q�以字节为单位�?br>
　　·CompareFunction cmpFunc�Q�带有上�q�原型的指向回调函数的指针�?br>
　　�q�两个函数的�?x��)对数组�q�行某种排序�Q�但每次都需军_��两个元素哪个排在前面�Q�而函��C��有一个回调函敎ͼ�其地址是作��Z��个参��C��递进来的。对�~�写者来��_(d��)��不必介意函数在何处实玎ͼ�或它怎样被实现的�Q�所需在意的只是两个用于比较的元素的地址�Q��ƈ�q�回以下的某个��|��库的�~�写者和使用者都必须遵守�q�个�U�定�Q�：(x��)

　　·-1�Q�如果第一个元素较?y��u)��，那它在已排序好的数组中，应该排在�W�二个元素前面�?br>
　　·0�Q�如果两个元素相�{�，那么它们的相对位�|��ƈ不重要，在已排序好的数组中，谁在前面都无所谓�?

　　·1�Q�如果第一个元素较大，那在已排序好的数�l�中�Q�它应该排第二个元素后面�?br>
　　��Z��以上�U�定�Q�函数Bubblesort()的实现如下，Quicksort()��q��微复杂一点：(x��)

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc)
{
　for(int i=0; i < size; i++)
　{
　　for(int j=0; j < size-1; j++)
　　{
　　　//回调比较函数
　　　if(1 == (*cmpFunc)(array+j*elem_size,array+(j+1)*elem_size))
　　　{
　　　　//两个相比较的元素�怺��?br>　　　　byte* temp = new byte[elem_size];
　　　　memcpy(temp, array+j*elem_size, elem_size);
　　　　memcpy(array+j*elem_size,array+(j+1)*elem_size,elem_size);
　　　　memcpy(array+(j+1)*elem_size, temp, elem_size);
　　　　delete [] temp;
　　　}
　　}
　}
}

　　注意�Q�因为实��C��使用了memcpy()�Q�所以函数在使用的数据类型方面，�?x��)有所局限�?br>
　　对��用者来��_(d��)��必须有一个回调函敎ͼ�其地址要传递给Bubblesort()函数。下面有二个��单的�C�Z��Q�一个比较两个整敎ͼ�而另一个比较两个字�W�串�Q?br>

int __stdcall CompareInts(const byte* velem1, const byte* velem2)
{
　int elem1 = *(int*)velem1;
　int elem2 = *(int*)velem2;

　if(elem1 < elem2)
　　return -1;
　if(elem1 > elem2)
　　return 1;

　return 0;
}

int __stdcall CompareStrings(const byte* velem1, const byte* velem2)
{
　const char* elem1 = (char*)velem1;
　const char* elem2 = (char*)velem2;
　return strcmp(elem1, elem2);
}

　　下面另有一个程序，用于��试以上所有的代码�Q�它传递了一个有5个元素的数组�l�Bubblesort()和Quicksort()�Q�同时还传递了一个指向回调函数的指针�?br>

int main(int argc, char* argv[])
{
　int i;
　int array[] = {5432, 4321, 3210, 2109, 1098};

　cout << "Before sorting ints with Bubblesort\n";
　for(i=0; i < 5; i++)
　　cout << array[i] << '\n';

　Bubblesort((byte*)array, 5, sizeof(array[0]), &CompareInts);

　cout << "After the sorting\n";
　for(i=0; i < 5; i++)
　　cout << array[i] << '\n';

　const char str[5][10] = {"estella","danielle","crissy","bo","angie"};

　cout << "Before sorting strings with Quicksort\n";
　for(i=0; i < 5; i++)
　　cout << str[i] << '\n';

　Quicksort((byte*)str, 5, 10, &CompareStrings);

　cout << "After the sorting\n";
　for(i=0; i < 5; i++)
　　cout << str[i] << '\n';

　return 0;
}

　　如果惌��行降序排序（大元素在先）�Q�就只需修改回调函数的代码，或��用另一个回调函敎ͼ��q�样�~�程��h��灉|��性就比较大了�?br>
         调用�U�定

　　上面的代码中�Q�可在函数原型中扑ֈ�__stdcall�Q�因为它以双下划�U�打��_(d��)��所以它是一个特定于�~�译器的扩展�Q�说到底也就是微软的实现。�Q何支持开发基于Win32的程序都必须支持�q�个扩展或其�{��h(hu��n)物。以__stdcall标识的函��C��用了标准调用�U�定�Q��ؓ(f��)什么叫标准�U�定呢，因�ؓ(f��)所有的Win32 API�Q�除了个别接受可变参数的除外�Q�都使用它。标准调用约定的函数在它们返回到调用者之前，都会(x��)从堆栈中�U�除掉参敎ͼ��q�也是Pascal的标准约定。但在C/C++中，调用�U�定是调用者负责清理堆栈，而不是被调用函数�Q��ؓ(f��)强制函数使用C/C++调用�U�定�Q�可使用__cdecl。另外，可变参数函数也��用C/C++调用�U�定�?br>
　　Windows操作�pȝ��采用了标准调用约定（Pascal�U�定�Q�，因�ؓ(f��)其可减小代码的体�U�。这点对早期的Windows来说非常重要�Q�因为那时它�q�行在只�?40KB内存的电(sh��)脑上�?br>
　　如果你不喜欢__stdcall�Q�还可以使用CALLBACK宏，它定义在windef.h中：(x��)

#define CALLBACK __stdcallor

#define CALLBACK PASCAL //而PASCAL在此�?defined成__stdcall

　　作�ؓ(f��)回调函数的C++�Ҏ(gu��)��

　　因�ؓ(f��)�q�x��很可能会(x��)使用到C++�~�写代码�Q�也�怼�(x��)惛_��把回调函数写成类中的一个方法，但先来看看以下的代码�Q?br>

class CCallbackTester
{
　public:
　int CALLBACK CompareInts(const byte* velem1, const byte* velem2);
};

Bubblesort((byte*)array, 5, sizeof(array[0]),
&CCallbackTester::CompareInts);

　　如果使用微��Y的编译器�Q�将�?x��)得��C��面这个编译错误：(x��)

error C2664: 'Bubblesort' : cannot convert parameter 4 from 'int (__stdcall CCallbackTester::*)(const unsigned char *,const unsigned char *)' to 'int (__stdcall *)(const unsigned char *,const unsigned char *)' There is no context in which this conversion is possible

　　�q�是因�ؓ(f��)非静态成员函数有一个额外的参数�Q�this指针�Q�这��迫使你在成员函数前面加上static。当�Ӟ��q�有几种�Ҏ(gu��)��可以解决�q�个问题�Q�但限于��幅�Q�就不再��了�?br>

谭文�?/a> 2007-05-21 16:51 发表评论

Windows数据�c�d��

Mon, 21 May 2007 07:55:00 GMT
     摘要: Platform SDK: Windows API Windows Data Types [摘自] MSDN The data types supported by Microsoft® Windows® are used to define function return values, function an...  阅读全文

谭文�?/a> 2007-05-21 15:55 发表评论

Sun, 20 May 2007 17:46:00 GMT

[转] 最通俗��显�?#8220;IO模式”解析
[源] �Q�http://hi.baidu.com/firebird/blog/item/f592b3193a02814542a9adeb.html

     一�Q�select模型
    二：(x��)WSAAsyncSelect模型
    三：(x��)WSAEventSelect模型
    四：(x��)Overlapped I/O 事�g通知模型
    五：(x��)Overlapped I/O 完成例程模型
    六：(x��)IOCP模型

原文名：(x��)《基于Delphi的Socket I/O模型全接�?nbsp;�?
老陈有一个在外地工作的女儿，不能�l�常回来�Q�老陈和她通过信�g联系。他们的信会(x��)被邮递员投递到他们的信��里�?nbsp;

�q�和Socket模型非常�c�M��。下面我��׃��老陈接收信�g��Z��讲解Socket I/O模型�?nbsp;

一�Q�select模型

老陈非常想看到女儿的信。以至于他每�?0分钟��׃��楼检查信��，看是否有奛_��的信�Q�在�q�种情况下，“下楼��查信��?#8221;然后回到��g��耽误了老陈太多的时��_(d��)��以至于老陈无法做其他工作�?nbsp;

select模型和老陈的这�U�情况非常相��|��(x��)周而复始地��L��?.....如果有数�?.....接收/发�?......

使用�U�程来select应该是通用的做法：(x��)

procedure TListenThread.Execute;
var
　 addr : TSockAddrIn;
　 fd_read : TFDSet;
　 timeout : TTimeVal;
　 ASock,
　 MainSock : TSocket;
　 len, i : Integer;
begin
　 MainSock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
　 addr.sin_family := AF_INET;
　 addr.sin_port := htons(5678);
　 addr.sin_addr.S_addr := htonl(INADDR_ANY);
　 bind( MainSock, @addr, sizeof(addr) );
　 listen( MainSock, 5 );

　 while (not Terminated) do
　 begin
　　 FD_ZERO( fd_read );
　　 FD_SET( MainSock, fd_read );
　　 timeout.tv_sec := 0;
　　 timeout.tv_usec := 500;
　　 if select( 0, @fd_read, nil, nil, @timeout ) > 0 then //臛_��?个等待Accept的connection
　　 begin
　　　 if FD_ISSET( MainSock, fd_read ) then
　　　 begin
　　　 for i:=0 to fd_read.fd_count-1 do //注意�Q�fd_count <= 64�Q?
   也就是说select只能同时��理最�?4个连�?nbsp;
　　　 begin
　　　　 len := sizeof(addr);
　　　　 ASock := accept( MainSock, addr, len );
　　　　 if ASock <> INVALID_SOCKET then
　　　　　 ....//为ASock创徏一个新的线�E�，在新的线�E�中再不停地select
　　　　 end;
　　　 end; 　　
　　 end;
　 end; //while (not self.Terminated)

　 shutdown( MainSock, SD_BOTH );
　 closesocket( MainSock );
end;

二：(x��)WSAAsyncSelect模型

后来�Q�老陈使用了微软公司的新式信箱。这�U�信��非常先�q�，一旦信��里有新的信�Ӟ��盖茨��׃��(x��)�l�老陈打电(sh��)话：(x��)喂，大爷�Q�你有新的信件了�Q�从此，老陈再也不必频繁上下楼检查信��׃��Q�牙也不��g��Q�你瞅准了，蓝天......不是�Q�微�?.....

微��Y提供的WSAAsyncSelect模型��是�q�个意思�?nbsp;

WSAAsyncSelect模型是Windows下最��单易用的一�U�Socket I/O模型。��用这�U�模型时�Q�W(xu��)indows�?x��)把�|�络事�g以消息的形势通知应用�E�序�?nbsp;

首先定义一个消息标�C�常量：(x��)

const WM_SOCKET = WM_USER + 55;

再在主Form的private域添加一个处理此消息的函数声明：(x��)

private
procedure WMSocket(var Msg: TMessage); message WM_SOCKET;

　

然后��可以��用WSAAsyncSelect了：(x��)

var
　 addr : TSockAddr;
　 sock : TSocket;

　 sock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
　 addr.sin_family := AF_INET;
　 addr.sin_port := htons(5678);
　 addr.sin_addr.S_addr := htonl(INADDR_ANY);
　 bind( m_sock, @addr, sizeof(SOCKADDR) );

　 WSAAsyncSelect( m_sock, Handle, WM_SOCKET, FD_ACCEPT or FD_CLOSE );

　 listen( m_sock, 5 );
　 ....

应用�E�序可以�Ҏ(gu��)��到WM_SOCKET消息�q�行分析�Q�判断是哪一个socket产生了网�l�事件以�?qi��ng)事件类型�?x��)

procedure TfmMain.WMSocket(var Msg: TMessage);
var
　 sock : TSocket;
　 addr : TSockAddrIn;
　 addrlen : Integer;
　 buf : Array [0..4095] of Char;
begin
　 //Msg的WParam是��生了�|�络事�g的socket句柄�Q�LParam则包含了事�g�c�d��
　 case WSAGetSelectEvent( Msg.LParam ) of
　 FD_ACCEPT :
　　 begin
　　　 addrlen := sizeof(addr);
　　　 sock := accept( Msg.WParam, addr, addrlen );
　　　 if sock <> INVALID_SOCKET then
　　　　 WSAAsyncSelect( sock, Handle, WM_SOCKET, FD_READ or FD_WRITE or FD_CLOSE );
　　 end;

　　 FD_CLOSE : closesocket( Msg.WParam );
　　 FD_READ : recv( Msg.WParam, buf[0], 4096, 0 );
　　 FD_WRITE : ;
　 end;
end;

三：(x��)WSAEventSelect模型

后来�Q�微软的信箱非常畅销�Q�购买微软信��q��Z��百万计数......以至于盖茨每�?4��时�l�客��h��?sh��)话�Q�篏得腰酸背痛，喝蚁力神都不好��。微软改�q�了他们的信��：(x��)在客��L(f��ng)��家中��d��一个附加装�|�，�q�个装置�?x��)监视客��L(f��ng)��信箱�Q�每当新的信件来��_(d��)��此装�|�会(x��)发出“��C��件到�?#8221;壎ͼ�提醒老陈��L��信。盖茨终于可以睡觉了�?nbsp;

同样要��用线�E�：(x��)

procedure TListenThread.Execute;
var
　 hEvent : WSAEvent;
　 ret : Integer;
　 ne : TWSANetworkEvents;
　 sock : TSocket;
　 adr : TSockAddrIn;
　 sMsg : String;
　 Index,
　 EventTotal : DWORD;
　 EventArray : Array [0..WSA_MAXIMUM_WAIT_EVENTS-1] of WSAEVENT;
begin
　 ...socket...bind...
　 hEvent := WSACreateEvent();
　 WSAEventSelect( ListenSock, hEvent, FD_ACCEPT or FD_CLOSE );
　 ...listen...

　 while ( not Terminated ) do
　 begin
　　 Index := WSAWaitForMultipleEvents( EventTotal, @EventArray[0], FALSE,
  WSA_INFINITE, FALSE );
　　 FillChar( ne, sizeof(ne), 0 );
　　 WSAEnumNetworkEvents( SockArray[Index-WSA_WAIT_EVENT_0],
    EventArray
  [Index-WSA_WAIT_EVENT_0], @ne );

　　 if ( ne.lNetworkEvents and FD_ACCEPT ) > 0 then
　　 begin
　　　 if ne.iErrorCode[FD_ACCEPT_BIT] <> 0 then
　　　　 continue;

　　　 ret := sizeof(adr);
　　　 sock := accept( SockArray[Index-WSA_WAIT_EVENT_0], adr, ret );
　　　 if EventTotal > WSA_MAXIMUM_WAIT_EVENTS-1 then
      //�q�里W(xu��)SA_MAXIMUM_WAIT_EVENTS同样�?4
　　　 begin
　　　　 closesocket( sock );
　　　　 continue;
　　　 end;

　　　 hEvent := WSACreateEvent();
　　　 WSAEventSelect( sock, hEvent, FD_READ or FD_WRITE or FD_CLOSE );
　　　 SockArray[EventTotal] := sock;
　　　 EventArray[EventTotal] := hEvent;
　　　 Inc( EventTotal );
　　 end;

　　 if ( ne.lNetworkEvents and FD_READ ) > 0 then
　　 begin
　　　 if ne.iErrorCode[FD_READ_BIT] <> 0 then
　　　　 continue;
　　　　 FillChar( RecvBuf[0], PACK_SIZE_RECEIVE, 0 );
　　　　 ret := recv( SockArray[Index-WSA_WAIT_EVENT_0], RecvBuf[0],
    PACK_SIZE_RECEIVE, 0 );
　　　　 ......
　　　 end;
　　 end;
end;

四：(x��)Overlapped I/O 事�g通知模型

后来�Q�微软通过调查发现�Q�老陈不喜�Ƣ上下楼收发信�g�Q�因��Z��下楼其实很浪�Ҏ(gu��)��间。于是微软再�ơ改�q�他们的信箱。新式的信箱采用了更为先�q�的技术，只要用户告诉微��Y自己的家在几楼几��P��新式信箱�?x��)把信�g直接传送到用户的家中，然后告诉用户�Q�你的信件已�l�放��C��的家中了�Q�老陈很高��_(d��)��因�ؓ(f��)他不必再亲自收发信�g了！

Overlapped I/O 事�g通知模型和W(xu��)SAEventSelect模型在实��C��非常�怼��Q�主要区别在"Overlapped”�Q�Overlapped模型是让应用�E�序使用重叠数据�l�构(WSAOVERLAPPED)�Q�一�ơ投递一个或多个Winsock I/O��h��。这些提交的��h��完成后，应用�E�序�?x��)收到通知。什么意思呢�Q�就是说�Q�如果你想从socket上接收数据，只需要告诉系�l�，��q��l��ؓ(f��)你接收数据，而你需要做的只是�ؓ(f��)�pȝ��提供一个缓冲区~~~~~

Listen�U�程和W(xu��)SAEventSelect模型一模一��P��Recv/Send�U�程则完全不同：(x��)

procedure TOverlapThread.Execute;
var
　 dwTemp : DWORD;
　 ret : Integer;
　 Index : DWORD;
begin
　 ......

　 while ( not Terminated ) do
　 begin
　　 Index := WSAWaitForMultipleEvents
   ( FLinks.Count, @FLinks.Events[0], FALSE,
    RECV_TIME_OUT, FALSE );
　　 Dec( Index, WSA_WAIT_EVENT_0 );
　　 if Index > WSA_MAXIMUM_WAIT_EVENTS-1 then
    //��时或者其他错�?nbsp;
　　　 continue;

　　 WSAResetEvent
   ( FLinks.Events[Index] );
　　 WSAGetOverlappedResult( FLinks.Sockets[Index],
      FLinks.pOverlaps[Index], @dwTemp, FALSE,FLinks.
     pdwFlags[Index]^ );

　　 if dwTemp = 0 then //�q�接已经关闭
　　 begin
　　　 ......
　　　 continue;
　　 end else
　 begin
　　 fmMain.ListBox1.Items.Add( FLinks.pBufs[Index]^.buf );
　 end;

　 //初始化缓冲区
　 FLinks.pdwFlags[Index]^ := 0;
　 FillChar( FLinks.pOverlaps[Index]^,
    sizeof(WSAOVERLAPPED), 0 );
　 FLinks.pOverlaps[Index]^.
   hEvent := FLinks.Events[Index];
　 FillChar( FLinks.pBufs[Index]^.buf^,
   BUFFER_SIZE, 0 );

　 //递一个接收数据请�?nbsp;
　 WSARecv( FLinks.Sockets[Index], FLinks.pBufs[Index], 1,
       FLinks.pdwRecvd[Index]^, FLinks.pdwFlags[Index]^,
      FLinks.pOverlaps[Index], nil );
end;
end;

五：(x��)Overlapped I/O 完成例程模型

老陈接收到新的信件后�Q�一般的�E�序是：(x��)打开信封----掏出信纸----阅读信�g----回复信�g......��Z��q�一步减�ȝ��戯��担，微��Y又开发了一�U�新的技术：(x��)用户只要告诉微��Y对信件的操作步骤�Q�微软信��将按照�q�些步骤��d��理信�Ӟ��不再需要用户亲自拆�?阅读/回复了！老陈�l�于�q�上了小资生�z�！

Overlapped I/O 完成例程要求用户提供一个回调函敎ͼ�发生新的�|�络事�g的时候系�l�将执行�q�个函数�Q?nbsp;

procedure WorkerRoutine( const dwError, cbTransferred : DWORD;
const
lpOverlapped : LPWSAOVERLAPPED; const dwFlags : DWORD ); stdcall;

然后告诉�pȝ��用WorkerRoutine函数处理接收到的数据�Q?nbsp;

WSARecv( m_socket, @FBuf, 1, dwTemp, dwFlag, @m_overlap, WorkerRoutine );
　　然后......没有什么然后了�Q�系�l�什么都�l�你做了�Q�微软真实体��_(d��)��

while ( not Terminated ) do//�q�就是一个Recv/Send�U�程要做的事�?.....什么都不用做啊�Q�！�Q?nbsp;
begin
　 if SleepEx( RECV_TIME_OUT, True ) = WAIT_IO_COMPLETION then //
　 begin
　　 ;
　 end else
　 begin
　　 continue;
　 end;
end;

六：(x��)IOCP模型

微��Y信箱��g��很完��，老陈也很满意。但是在一些大公司情况却完全不同！�q�些大公司有��C��万计的信��，每秒钟都有数以百计的信�g需要处理，以至于微软信��q��常因��负药��转而崩溃！需要重新启动！微��Y不得不��出杀手锏......

微��Y�l�每个大公司�z�了一名名�?#8220;Completion Port”的超�U�机器�h�Q�让�q�个机器人去处理那些信�g�Q?nbsp;

“Windows NT��组注意到这些应用程序的性能没有预料的那么高。特别的�Q�处理很多同时的客户��h��意味着很多�U�程�q�发地运行在�pȝ��中。因为所有这些线�E�都是可�q�行的[没有被挂起和�{�待发生什么事]�Q�Microsoft意识到NT内核��p��了太多的旉��来�{换运行线�E�的上下文[Context]�Q�线�E�就没有得到很多CPU旉��来做它们的工作。大家可能也都感觉到�q�行模型的瓶颈在于它为每一个客戯��求都创徏了一个新�U�程。创建线�E�比起创��E�开销要小�Q�但也远不是没有开销的。我们不妨设想一下：(x��)如果事先开好N个线�E�，让它们在那hold[堵塞]�Q�然后可以将所有用��L(f��ng)��h��都投递到一个消息队列中厅R��然后那N个线�E�逐一从消息队列中��d��出消息�ƈ加以处理。就可以避免针对每一个用戯��求都开�U�程。不仅减��了�U�程的资源，也提高了�U�程的利用率。理��Z��很不错，你想我等泛泛之辈都能惛_��来的问题�Q�Microsoft又怎会(x��)没有考虑到呢?”-----摘自nonocast的《理解I/O Completion Port�?nbsp;

先看一下IOCP模型的实玎ͼ�(x��)

//创徏一个完成端�?nbsp;
FCompletPort := CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0,0,0 );

//接受�q�程�q�接�Q��ƈ把这个连接的socket句柄�l�定到刚才创建的IOCP�?nbsp;
AConnect := accept( FListenSock, addr, len);
CreateIoCompletionPort( AConnect, FCompletPort, nil, 0 );

//创徏CPU�?2 + 2个线�E?nbsp;
for i:=1 to si.dwNumberOfProcessors*2+2 do
begin
　 AThread := TRecvSendThread.Create( false );
　 AThread.CompletPort := FCompletPort;//告诉�q�个�U�程�Q�你要去�q�个IOCP去访问数�?nbsp;
end;

��p��么简单，我们要做的就是徏立一个IOCP�Q�把�q�程�q�接的socket句柄�l�定到刚才创建的IOCP上，最后创建n个线�E�，�q�告诉这n个线�E�到�q�个IOCP上去讉K��数据��可以了�?nbsp;

再看一下TRecvSendThread�U�程都干些什么：(x��)

procedure TRecvSendThread.Execute;
var
　 ......
begin
　 while (not self.Terminated) do
　 begin
　　 //查询IOCP状态（数据��d��操作是否完成�Q?nbsp;
　　 GetQueuedCompletionStatus( CompletPort, BytesTransd,
    CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT );

　　 if BytesTransd <> 0 then
　　　 ....;//数据��d��操作完成
　　
　　　 //再投递一个读数据��h��
　　　 WSARecv( CompletKey, @(pPerIoDat^.BufData), 1,
    BytesRecv, Flags, @(pPerIoDat^.Overlap), nil );
　　 end;
end;

��d��U�程只是��单地��查IOCP是否完成了我们投递的��d��操作�Q�如果完成了则再投递一个新的读写请求�?nbsp;

应该注意刎ͼ�我们创徏的所有TRecvSendThread都在讉K��同一个IOCP�Q�因为我们只创徏了一个IOCP�Q�，�q�且我们没有使用临界区！��N��不会(x��)产生冲突吗？不用考虑同步问题吗？

�q�正是IOCP的奥妙所在。IOCP不是一个普通的对象�Q�不需要考虑�U�程安全问题。它�?x��)自动调配访问它的线�E�：(x��)如果某个socket上有一个线�E�A正在讉K��Q�那么线�E�B的访问请求会(x��)被分配到另外一个socket。这一切都是由�pȝ��自动调配的，我们无需�q�问�?/div>

谭文�?/a> 2007-05-21 01:46 发表评论

Wed, 09 May 2007 03:47:00 GMT

[转] typename 的两个含�?/strong>
【摘自】armman的专�?br>
template class Widget;        // uses "class"
template class Widget;     // uses "typename"
　　�{�案�Q�没什么不同。在声明一�?template type parameter�Q�模板类型参敎ͼ��Ӟ��class �?typename 意味着完全相同的东�ѝ��一些程序员更喜�Ƣ在所有的旉��都用 class�Q�因为它更容易输入。其他�h更喜��?typename�Q�因为它暗示着�q�个参数不必要是一�?class type�Q�类�c�d��Q�。少数开发者在��M��c�d��都被允许的时候��?typename�Q�而把 class 保留�l�仅接受 user-defined types�Q�用户定义类型）的场合。但是从 C++ 的观点看�Q�class �?typename 在声明一�?template parameter�Q�模板参敎ͼ�时意味着完全相同的东�ѝ�?br>
　　然而，C++ �q�不��L��?class �?typename 视�ؓ(f��)�{�同的东�ѝ��有时必��M��?typename。�ؓ(f��)了理解这一点，我们不得不讨论在一�?template�Q�模板）中涉�?qi��ng)到的两�U�名字�?br>
　　假设我们有一个函数的模板�Q�它能取得一�?STL-compatible container�Q�STL 兼容容器�Q�中持有的能赋值给 ints 的对象。进一步假设这个函数只是简单地打印它的�W�二个元素的倹{��它是一个用�p�涂的方法实现的�p�涂的函敎ͼ�而且��像下面写的�Q�它甚至不能�~�译�Q�但是请��这些事先放在一边：(x��)

template // print 2nd element in
void print2nd(const C& container) // container;
{
　// this is not valid C++!
　if (container.size() >= 2) {
　　C::const_iterator iter(container.begin()); // get iterator to 1st element
　　++iter; // move iter to 2nd element
　　int value = *iter; // copy that element to an int
　　std::cout << value; // print the int
　}
}
　　�q�个函数中的两个 local variables�Q�局部变量）�Q�iter �?value。iter 的类型是 C::const_iterator�Q�一个依赖于 template parameter�Q�模板参敎ͼ�C 的类型。一�?template�Q�模板）中的依赖于一�?template parameter�Q�模板参敎ͼ�的名字被�U�Cؓ(f��) dependent names�Q�依赖名字）。当一�?dependent names�Q�依赖名字）嵌套在一�?class�Q�类�Q�的内部�Ӟ��U�它�?nested dependent name�Q�嵌套依赖名字）。C::const_iterator 是一�?nested dependent name�Q�嵌套依赖名字）。实际上�Q�它是一�?nested dependent type name�Q�嵌套依赖类型名�Q�，也就是说�Q�一个涉�?qi��ng)到一�?type�Q�类型）�?nested dependent name�Q�嵌套依赖名字）�?br>
　　print2nd 中的另一�?local variable�Q�局部变量）value ��h�� int �c�d��。int 是一个不依赖于�Q�?template parameter�Q�模板参敎ͼ�的名字。这��L(f��ng)��名字�?non-dependent names�Q�非依赖名字�Q�闻名�?br>
　　nested dependent name�Q�嵌套依赖名字）�?x��)导致解析困难。例如，假设我们更加愚蠢��C��q�种�Ҏ(gu��)��开�?print2nd�Q?br>template
void print2nd(const C& container)
{
　C::const_iterator * x;
　...
}
　　�q�看上去好像是我们将 x 声明��Z��个指�?C::const_iterator �?local variable�Q�局部变量）。但是它看上��d��此仅仅是因�ؓ(f��)我们知道 C::const_iterator 是一�?type�Q�类型）。但是如�?C::const_iterator 不是一�?type�Q�类型）呢？如果 C 有一�?static data member�Q�静态数据成员）��y��叫�?const_iterator 呢？再如�?x ��y是一�?global variable�Q�全局变量�Q�的名字呢？在这�U�情况下�Q�上面的代码��׃��是声明一�?local variable�Q�局部变量）�Q�而是成�ؓ(f��) C::const_iterator 乘以 x�Q�当�Ӟ��q�听��h��有些愚蠢�Q�但它是可能的，而编�?C++ 解析器的人必��考虑所有可能的输入�Q�甚��x��愚蠢的�?br>
　　直到 C 成�ؓ(f��)已知之前�Q�没有�Q何办法知�?C::const_iterator 到底是不是一�?type�Q�类型）�Q�而当 template�Q�模板）print2nd 被解析的时候，C �q�不是已知的。C++ 有一条规则解册��个歧义：(x��)如果解析器在一�?template�Q�模板）中遇��C��?nested dependent name�Q�嵌套依赖名字）�Q�它假定那个名字不是一�?type�Q�类型）�Q�除非用其它方式告诉它。缺省情况下�Q�nested dependent name�Q�嵌套依赖名字）不是 types�Q�类型）。（对于�q�条规则有一个例外）

　　��C��q�个�Q�再看看 print2nd 的开��_(d��)��(x��)
templatevoid print2nd(const C& container)
{
　if (container.size() >= 2) {
　　C::const_iterator iter(container.begin()); // this name is assumed to
　　... // not be a type
　　�q��ؓ(f��)什么不是合法的 C++ 现在应该很清楚了。iter �?declaration�Q�声明）仅仅�?C::const_iterator 是一�?type�Q�类型）时才有意义，但是我们没有告诉 C++ 它是�Q��?C++ ��假定它不是。要惌��{变这个�Ş势，我们必须告诉 C++ C::const_iterator 是一�?type�Q�类型）。我们将 typename 攑֜�紧挨着它的前面来做到这一点：(x��)

template // this is valid C++
void print2nd(const C& container)
{
if (container.size() >= 2) {
typename C::const_iterator iter(container.begin());
...
}
}
　　通用的规则很��单：(x��)在涉�?qi��ng)到一个在 template�Q�模板）中的 nested dependent type name�Q�嵌套依赖类型名�Q�的��M��时候，必须把单�?typename 攑֜�紧挨着它的前面。（重申一下，我待�?x��)儿要描�q�C��个例外。）

　　typename 应该仅仅被用于标�?nested dependent type name�Q�嵌套依赖类型名�Q�；其它名字不应该用它。例如，�q�是一个取得一�?container�Q�容器）和这�?container�Q�容器）中的一�?iterator�Q��P代器�Q�的 function template�Q�函数模板）�Q?br>
template // typename allowed (as is "class")
void f(const C& container, // typename not allowed
typename C::iterator iter); // typename required
　　C 不是一�?nested dependent type name�Q�嵌套依赖类型名�Q�（它不是嵌套在依赖于一�?template parameter�Q�模板参敎ͼ�的什么东西内部的�Q�，所以在声明 container 时它不必�?typename 前置�Q�但�?C::iterator 是一�?nested dependent type name�Q�嵌套依赖类型名�Q�，所以它必需�?typename 前置�?br>
　　"typename must precede nested dependent type names"�Q?/span>“typename 必须前置于嵌套依赖类型名”�Q�规则的例外�?typename 不必前置于在一�?list of base classes�Q�基�c�d��表）中的或者在一�?member initialization list�Q�成员初始化列表�Q�中作�ؓ(f��)一�?base classes identifier�Q�基�c�L��识符�Q�的 nested dependent type name�Q�嵌套依赖类型名�Q�。例如：(x��)

template
class Derived: public Base::Nested { // base class list: typename not
　public: // allowed
　　explicit Derived(int x)
　　: Base::Nested(x) // base class identifier in mem
　　{
　　　// init. list: typename not allowed
　　　　typename Base::Nested temp; // use of nested dependent type
　　　... // name not in a base class list or
　　} // as a base class identifier in a
　... // mem. init. list: typename required
};
　　�q�样的矛监־�令�h讨厌�Q�但是一旦在�l�历中获得一点经验，几乎不会(x��)在意它�?br>
　　让我们来看最后一�?typename 的例子，因�ؓ(f��)它在看到的真实代码中��h��代表性。假设我们在写一个取得一�?iterator�Q��P代器�Q�的 function template�Q�函数模板）�Q�而且我们要做一�?iterator�Q��P代器�Q�指向的 object�Q�对象）的局部拷�?temp�Q�我们可以这样做�Q?br>template
void workWithIterator(IterT iter)
{
　typename std::iterator_traits::value_type temp(*iter);
　...
}
　　不要�?std::iterator_traits::value_type 吓倒你。那仅仅是一�?standard traits class�Q�标准特性类�Q�的使用�Q�用 C++ 的说法就�?"the type of thing pointed to by objects of type IterT"�Q?/span>“被类型�ؓ(f��) IterT 的对象所指向的东西的�c�d��”�Q�。这个语句声明了一个与 IterT objects 所指向的东西类型相同的 local variable�Q�局部变量）(temp)�Q�而且�?iter 所指向�?object�Q�对象）�?temp �q�行了初始化。如�?IterT �?vector::iterator�Q�temp ��是 int �c�d��。如�?IterT �?list::iterator�Q�temp ��是 string �c�d��。因�?std::iterator_traits::value_type 是一�?nested dependent type name�Q�嵌套依赖类型名�Q�（value_type 嵌套�?iterator_traits 内部�Q�而且 IterT 是一�?template parameter�Q�模板参敎ͼ��Q�，我们必须让它�?typename 前置�?br>
　　如果觉得�?std::iterator_traits::value_type 令�h讨厌�Q�就惌��那个与它相同的东西来代表它。如果像大多数程序员�Q�对多次输入它感到恐惧，那么��需要创��Z��?typedef。对于像 value_type �q�样�?traits member names�Q�特性成员名�Q�，一个通用的惯例是 typedef name �?traits member name 相同�Q�所以这��L(f��ng)��一�?local typedef 通常定义成这��P��(x��)

template void workWithIterator(IterT iter)
{
　typedef typename std::iterator_traits::value_type value_type;

　value_type temp(*iter);
　...
}
　　很多�E�序员最初发�?"typedef typename" �q�列不太和谐�Q�但它是涉及(qi��ng) nested dependent type names�Q�嵌套依赖类型名�Q�规则的一个合理的附带�l�果�?br>
　　一些编译器接受必需 typename 时它却缺��q��代码�Q�一些编译器接受不许 typename 时它却存在的代码�Q�还有少数的�Q�通常是老旧的）�?x��)拒�l?typename 出现在它必需出现的地斏V��这��意味着 typename �?nested dependent type names�Q�嵌套依赖类型名�Q�的交互作用�?x��)导致一些轻微的可移植性问题�?br>
Things to Remember　　 ·在声�?template parameters�Q�模板参敎ͼ��Ӟ��class �?typename 是可互换的�?br>　　·�?typename ��L��?nested dependent type names�Q�嵌套依赖类型名�Q�，�?base class lists�Q�基�c�d��表）中或在一�?member initialization list�Q�成员初始化列表�Q�中作�ؓ(f��)一�?base class identifier�Q�基�c�L��识符�Q�时除外�?/span>

谭文�?/a> 2007-05-09 11:47 发表评论

Mon, 07 May 2007 16:04:00 GMT
C++/CLR泛型与C++模板之间的对�?span style="FONT-SIZE: 24pt">[摘自�~�程乐园]

Visual Studio 2005把泛型编�E�的�c�d��参数模型引入了微�?NET框架�l��g。C++/CLI支持两种�c�d��参数机制--通用语言�q�行�Ӟ��CLR�Q�泛型和C++模板。本文将介绍两者之间的一些区�?-特别是参数列表和�c�d��U�束模型之间的区别�?

　　参数列表又回来了

　　参数列表与函数的信号�Q�signature�Q�类��|��(x��)它标明了参数的数量和每个参数的类型，�q�把�l�每个参数关联一个唯一的标识符�Q�这样在模板定义的内部，每个参数��可以被唯一地引用�?br>
　　参数在模板或泛型的定义中起占位符�Q�placeholder�Q�的作用。用户通过提供�l�定到参数的实际值来建立对象实例。参数化�c�d��的实例化�q��单的文本替代�Q�宏扩展机制��是使用文本替代的）。相反地�Q�它把实际的用户值绑定到定义中的相关的�Ş式参��C��?br>
　　在泛型中�Q�每个参数都表现为Object�c�d��或衍生自Object的类型。在本文后面你可以看刎ͼ��q�约束了你可能执行的操作�c�d��或通过�c�d��参数声明的对象。你可以通过提供更加明确的约束来调整�q�些�U�束关系。这些明��的�U�束引用那些衍生出实际类型参数的基类或接口集合�?br>
　　模板除了支持�c�d��参数之外�Q�还支持表达式和模板参数。此外，模板�q�支持默认的参数倹{��这些都是按照位�|�而不是名�U�来分解的。在两种机制之下�Q�类型参数都是与�c�L��c�d��名称关键字一起引入的�?br>
　　参数列表的额外的模板功能

　　模板作�ؓ(f��)�c�d��参数的补充，允许两种�c�d��的参敎ͼ�(x��)非类型（non-type�Q�参数和模板参数。我们将分别��短地介绍一下�?br>
　　非类型参数受常数表达式的�U�束。我们应该立��x��到它是数值型或字�W�串帔R��。例如，如果选择提供固定大小的堆栈，你就可能同时指定一个非�c�d��的大��参数和元素�c�d��参数�Q�这样就可以同时按照元素�c�d��和大��来划分堆栈实例的类别。例如，你可以在代码1中看到带有非�c�d��参数的固定大��的堆栈�?br>
　　代码1�Q�带有非�c�d��固定大小的堆�?br>
template
public ref class tStack
{
　array ^m_stack;
　int top;

　public:
　　tStack() : top( 0 )
　　{ m_stack = gcnew array( size ); }
};
　　此外�Q�如果模板类设计者可以�ؓ(f��)每个参数指定默认��|��使用��h��可能方便多了。例如，把缓冲区的默认大��设�|��ؓ(f��)1KB��是很好的。在模板机制下，可以�l�参数提供默认��|��如下所�C�：(x��)

// 带有默认值的模板声明
template
public ref class FixedSizeStack {};
　　用户可以通过提供明确的第二个值来重蝲默认大小��|��(x��)

// 最�?28个字�W�串实例的堆�?br>FixedSizeState ^tbs = gcnew FixedSizeStack;
　　否则�Q�由于没有提供第二个参数�Q�它使用了相关的默认��|��如下所�C�：(x��)

// 最�?024个字�W�串实例的堆�?br>FixedSizeStack ^tbs = gcnew FixedSizeStack;
　　使用默认的参数值是标准模板库（STL�Q�的一个基本的设计特征。例如，下面的声明就来自ISO-C++标准�Q?br>
// ISO-C++名字�I�间std中的默认�c�d��参数值示�?
{
　template >
　class queue;

　template >
　class vector;
　// ...
}
　　你可以提供默认的元素�c�d��Q�如下所�C�：(x��)

// 带有默认的元素类型的模板声明
template
public ref class tStack {};

　　从设计的角度来说很难证明它的正确性，因�ؓ(f��)一般来说容器不�?x��)集中在在单个默认类型上�?br>
　　指针也可以作为非�c�d��参数�Q�因为对象或函数的地址在编译时��已知了�Q�因此是一个常量表辑ּ�。例如，你可能希望�ؓ(f��)堆栈�c�L��供第三个参数�Q�这个参数指明遇到特定条件的时候��用的回调处理�E�序。明智地使用typedef可以大幅度简化那些表面上看�v来很复杂的声明，如下所�C�：(x��)

typedef void (*handler)( ... array^ );
template
public ref class tStack {};
　　当然�Q�你可以为处理程序提供默认�?-在这个例子中�Q�是一个已有的�Ҏ(gu��)��的地址。例如，下面的缓冲区声明��提供了大小和处理程序：(x��)

void defaultHandler( ... array^ ){ ... }

template < class elemType,
int size = 1024,
handler cback = &defaultHandler >
public ref class tStack {};
　　�׃��默认值的位置�ơ序优先于命名次序，因此如果不提供明��的大小��|��即�ɘq�个大小与默认值是重复的）�Q�就无法提供重蝲的处理程序的。下面就是可能用到的修改堆栈的方法：(x��)

void demonstration()
{
　// 默认的大��和处理�E�序
　tStack ^ts1 = nullptr;
　// 默认的处理程�?br>　tStack ^ts2 = gcnew tStack;
　// 重蝲所有的三个参数
　tStack ^ts3;
}

　　模板支持的第二种额外的参数就是template模板参数--也就是这个模板参数本�w�表��Cؓ(f��)一个模�ѝ��例如：(x��)

// template模板参数
template

久久激情亚洲精品无码?V,久久久91人妻无码精品蜜桃HD,国产香蕉久久精品综合网

关于strcpy()与memcpy()比较

Windows数据�c�d��

��C��C++中的预处理宏

一、��用预处理�?/span>

二、宏的常见陷�?/span>

[转] 深入探讨MFC消息循环和消息�܇

深入探讨MFC消息循环和消息�܇

用VC.NET制作启动屏幕

字符串函�?strtok(char s, char delim)

ASCII Table

友元函数和友元类

久久激情亚洲精品无码?V,久久久91人妻无码精品蜜桃HD,国产香蕉久久精品综合网

关于strcpy()与memcpy()比较

Windows数据�c�d��

��C��C++中的预处理宏

一、��用预处理�?/span>

二、宏的常见陷�?/span>

[转] 深入探讨MFC消息循环和消息�܇

深入探讨MFC消息循环和消息�܇

用VC.NET制作启动屏幕

字符串函�?strtok(char *s, char *delim)

ASCII Table

友元函数和友元类

字符串函�?strtok(char s, char delim)