国产精品久久综合,国产精品av免费在线观看,激情成人av

回调函数

IssAc — Wed, 13 Aug 2008 12:26:00 GMT

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

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

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

　　因�ؓ可以把调用者与被调用者分开。调用者不兛_��谁是被调用者，所有它需知道的，只是存在一个具有某�U�特定原型、某些限制条�Ӟ��如返回��gؓ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��定时��_��E�序会得到相应的通知�Q�但通知机制的实现者对我们的程序一无所知。而此�Ӟ��需有一个特定原型的函数指针�Q�用�q�个指针来进行回调，来通知我们的程序事件已�l�发生。实际上�Q�SetTimer() API使用了一个回调函数来通知计时器，而且�Q�万一没有提供回调函数�Q�它�q�会把一个消息发往�E�序的消息队列�?br>
　　另一个��用回调机制的API函数是EnumWindow()�Q�它枚�D屏幕上所有的��层�H�口�Q��ؓ每个�H�口调用一个程序提供的函数�Q��ƈ传递窗口的处理�E�序。如果被调用者返回一个��|��q��l�进行�P代，否则�Q�退出。EnumWindow()�q�不兛_��被调用者在何处�Q�也不关心被调用者用它传递的处理�E�序做了什么，它只兛_��q�回��|��因�ؓ��Z��q�回��|��它将�l�箋执行或退出�?br>
　　不管怎么��_��回调函数是��l�自C语言的，因而，在C++中，应只在与C代码建立接口�Q�或与已有的回调接口打交道时�Q�才使用回调函数。除了上�q�情况，在C++中应使用虚拟�Ҏ��或函数符�Q�functor�Q�，而不是回调函数�?br>
　　一个简单的回调函数实现

　　下面创徏了一个sort.dll的动态链接库�Q�它导出了一个名为CompareFunction的类�?-typedef int (__stdcall *CompareFunction)(const byte*, const byte*)�Q�它��是回调函数的类型。另外，它也导出了两个方法：Bubblesort()和Quicksort()�Q�这两个�Ҏ��原型相同�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�两个函数接受以下参敎ͼ�

　　·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�两个函数的会对数组�q�行某种排序�Q�但每次都需军_��两个元素哪个排在前面�Q�而函��C��有一个回调函敎ͼ�其地址是作��Z��个参��C��递进来的。对�~�写者来��_��不必介意函数在何处实玎ͼ�或它怎样被实现的�Q�所需在意的只是两个用于比较的元素的地址�Q��ƈ�q�回以下的某个��|��库的�~�写者和使用者都必须遵守�q�个�U�定�Q�：

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

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

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�所以函数在使用的数据类型方面，会有所局限�?br>
　　对��用者来��_��必须有一个回调函敎ͼ�其地址要传递给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��灉|��性就比较大了�?/p>
调用�U�定

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

#define CALLBACK __stdcallor

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

　　作�ؓ回调函数的C++�Ҏ��

　　因�ؓ�q�x��很可能会使用到C++�~�写代码�Q�也�怼�惛_��把回调函数写成类中的一个方法，但先来看看以下的代码�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�将会得��C��面这个编译错误：

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

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

��类成员函数用做C回调函数

提出问题�Q?/font>
回调函数是基于C�~�程的Windows SDK的技术，不是针对C++的，�E�序员可以将一个C函数直接作�ؓ回调函数�Q�但是如果试囄��接��用C++的成员函��C��为回调函数将发生错误�Q�甚至编译就不能通过�?br>分析原因�Q?/font>
普通的C++成员函数都隐含了一个传递函��C��为参敎ͼ�亦即“this”指针�Q�C++通过传递一个指向自�w�的指针�l�其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解�ؓ什么C++�cȝ��多个实例可以�׃�n成员函数但是��有不同的数据成员。由于this指针的作用，使得��一个CALLBACK型的成员函数作�ؓ回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配，从而导致回调函数安装失�?br>解决�Ҏ��Q?/font>
一,不��用成员函敎ͼ�直接使用普通C函数�Q��ؓ了实现在C函数中可以访问类的成员变量，可以使用友元操作�W?friend)�Q�在C++中将该C函数说明�?font color=#ff1493>�cȝ��友元卛_��。这�U�处理机制与普通的C�~�程中��用回调函��C��栗��?br>�?使用静态成员函�?/font>�Q�静态成员函��C��使用this指针作�ؓ隐含参数�Q�这样就可以作�ؓ回调函数了。静态成员函数具有两大特点：其一�Q�可以在没有�c�d��例的情况下��用；其二�Q�只能访问静态成员变量和静态成员函敎ͼ�不能讉K��非静态成员变量和非静态成员函数。由于在C++中��用类成员函数作�ؓ回调函数的目的就是�ؓ了访问所有的成员变量和成员函敎ͼ�如果作不到这一点将不具有实际意义。我们通过使用静态成员函数对非静态成员函�?font color=#ff1493>包装的办法来解决问题。类实例可以通过附加参数�?font color=#ff1493>全局变量的方式的方式传递到静态成员函��C��。分别�D例如下：

1�Q�参��C��递的方式
   #include <iostream.h>
   class TClassA
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(void* pt2Object, char* text);
      // more.
   };

   // 静态包装函敎ͼ�能够调用成员函数Display(),本��n做�ؓ回调函数来��?/span>
   void TClassA::Wrapper_To_Call_Display(void* pt2Object, char* string)
   {
       // 昑ּ��c�d��转换
       TClassA* mySelf = (TClassA*) pt2Object;

       // 调用普通成员函�?/span>
       mySelf->Display(string);
   }

   // 回调函数的宿�?在这里回调用函数被��?/span>
   void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))
   {
      // 使用回调函数
      pt2Function(pt2Object, "hi, i'm calling back using a argument ;-)");
   }

   // 执行�C�Z��
   void Callback_Using_Argument()
   {
      TClassA objA;
      DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);
   }

2�Q�全局变量的方�?br>   #include <iostream.h>
   void* pt2Object;        // 全局变量,可以指向��L��对象
   class TClassB
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(char* text);

   };

   // 静态的包装函数
   void TClassB::Wrapper_To_Call_Display(char* string)
   {
       //需要保证全局变量值的正确�?/span>
       TClassB* mySelf = (TClassB*) pt2Object;
       mySelf->Display(string);
   }

   // 回调用函数的宿主,在这里回调用函数被��?/span>
   void DoItB(void (*pt2Function)(char* text))
   {

      pt2Function("hi, i'm calling back using a global ;-)");   // make callback
   }

   // 执行�C�Z��
   void Callback_Using_Global()
   {
      TClassB objB;
      pt2Object = (void*) &objB;
      DoItB(TClassB::Wrapper_To_Call_Display);
   }

注意�Q�通过上面两种�Ҏ��的比较可以看出，�W?�U�方法中静态包装函数可以和普通成员函��C��持签名一��_��当回调函数的宿主接口不能改变�Ӟ��q�种�Ҏ��特别有用。但因�ؓ使用了全局变量�Q�也不是一个好的设计�?/p>

IssAc 2008-08-13 20:26 发表评论

__cdecl __fastcall�?__stdcall

IssAc — Wed, 13 Aug 2008 11:41:00 GMT

[转蝲内容,地址不详]
Visual C++ Compiler Options可以指定的Calling Convention�?3�U�：
　　/Gd /Gr /Gz
　　�q�三个参数决定了�Q?br>　　1.函数参数以何�U�顺序入栈，叛_��左还是左到右�?br>　　2.在函数运行完后，是调用函数还是被调用函数清理入栈的参数�?br>　　3.在编译时函数名字是如何�{换的�?/p>
　　下面我们分别详细介绍�Q?br>　　1./Gd
　　�q�是�~�译器默认的转换模式�Q�对一般函��C��?C的函数调用�{换方式__cdecl�Q�但是对于C++ 成员函数和前面修��C��__stdcall __fastcall的函数除外�?br>　　2./Gr
　　对于一般函��C��用__fastcall函数调用转换方式�Q�所有��用__fastcall的函数必��要有函数原形。但对于C++ 成员函数和前面修��C��__cdecl __stdcall 的函数除外�?br>　　3./Gz
　　对于所�?C函数使用__stdcall函数调用转换方式�Q�但对于可变参数�?C函数以及用__cdecl __fastcall修饰�q�的函数和C++ 成员函数除外。所有用__stdcall修饰的函数必��L��函数原�Ş�?br>　　事实上，对于x86�pȝ��Q�C++ 成员函数的调用方式有点特别，��成员函数的this
指针攑օ�ECX�Q�所有函数参��C��叛_��左入栈，被调用的成员函数负责清理入栈�?br>参数。对于可变参数的成员函数�Q�始�l��用__cdecl的�{换方式�?br>　　下面该进入主题，分别讲一下这三种函数调用转换方式有什么区别：
　　1.__cdecl
　　�q�是�~�译器默认的函数调用转换方式�Q�它可以处理可变参数的函数调用。参数的入栈��序是从叛_��左。在函数�q�行�l�束后，��p��用函数负责清理入栈的参数。在�~�译�Ӟ��在每个函数前面加上下划线(_)�Q�没有函数名大小写的转换。即_functionname
　　每一个调用它的函数都包含清空堆栈的代码，所以��生的可执行文件大��会比调用_stdcall函数的大。函数采用从叛_��左的压栈方式。注意：对于可变参数的成员函敎ͼ�始终使用__cdecl的�{换方式�?
　　2.__fastcall
　　有一些函数调用的参数被放入ECX�Q�EDX中，而其它参��C��叛_��左入栈。被调用函数在它��要�q�回时负责清理入栈的参数。在内嵌汇编语言的时候，需要注意寄存器的��用，以免与编译器使用的��生冲�H�。函数名字的转换是：@functionname@number没有函数名大��写的�{换，number表示函数参数的字节数。由于有一些参��C�� 需要入栈，所以这�U��{换方式会在一定程度上提高函数调用的速度�?br>　　3.__stdcall
　　函数参数从右向左入栈�Q�被调用函数负责入栈参数的清理工作。函数名转换格式如下�Q?a href="mailto:_functionname@number">_functionname@number
　　下面我们亲自写一个程序，看看各种不同的调用在�~�译后有什么区别，我们的被�?nbsp;用函数如下：

int function(int a, int b)
{
    return a + b;
}
void main()
{
    function(10, 20);
}

1.__cdecl

_function
push    ebp
mov     ebp, esp
mov     eax, [ebp+8]       ;参数1
add     eax, [ebp+C]       ;加上参数2
pop     ebp
retn
_main
push    ebp
mov     ebp, esp
push    14h                ;参数 2入栈
push    0Ah                ;参数 1入栈
call    _function          ;调用函数
add     esp, 8             ;修正�?br>xor     eax, eax
pop     ebp
retn

2.__fastcall

@function@8
push    ebp
mov     ebp, esp           ;保存栈指�?br>sub     esp, 8             ;多了两个局部变�?br>mov     [ebp-8], edx       ;保存参数 2
mov     [ebp-4], ecx       ;保存参数 1
mov     eax, [ebp-4]       ;参数 1
add     eax, [ebp-8]       ;加上参数 2
mov     esp, ebp           ;修正�?br>pop     ebp
retn
_main
push    ebp
mov     ebp, esp
mov     edx, 14h           ;参数 2�l�EDX
mov     ecx, 0Ah           ;参数 1�l�ECX
call    @function@8        ;调用函数
xor     eax, eax
pop     ebp
retn

3.__stdcall

_function@8
push    ebp
mov     ebp, esp
mov     eax, [ebp]         ;参数 1
add     eax, [ebp+C]       ;加上参数 2
pop     ebp
retn    8                  ;修复�?br>_main
push    ebp
mov     ebp, esp
push    14h                ;参数 2入栈
push    0Ah                ;参数 1入栈
call    _function@8　　　　;函数调用
xor     eax, eax
pop     ebp
retn
可见上述三种�Ҏ��各有各的特点�Q�而且_main必须是__cdecl�Q�一般WIN32的函数都是__stdcall。而且在Windef.h中有如下的定义：
#define CALLBACK __stdcall
#define WINAPI　 __stdcall

　　补：
　　C++�~�译时函数名修饰�U�定规则�Q?
　　__stdcall调用�U�定�Q?
　　1)、以"?"标识函数名的开始，后跟函数名；
　　2)、函数名后面�?@@YG"标识参数表的开始，后跟参数表；
　　3)、参数表以代可��C�：
　　X--void �Q?
　　D--char�Q?
　　E--unsigned char�Q?
　　F--short�Q?
　　H--int�Q?
　　I--unsigned int�Q?
　　J--long�Q?
　　K--unsigned long�Q?
　　M--float�Q?
　　N--double�Q?
　　_N--bool�Q?
　　PA--表示指针�Q�后面的代号表明指针�c�d��Q�如果相同类型的指针�q�箋出现�Q�以"0"代替�Q�一�?0"代表一�ơ重复；
　　4)、参数表的第一��ؓ该函数的�q�回值类型，其后依次为参数的数据�c�d��,指针标识在其所指数据类型前�Q?
　　5)、参数表后以"@Z"标识整个名字的结束，如果该函数无参数�Q�则�?Z"标识�l�束�?
　　其格式�ؓ"?functionname@@YG*****@Z"�??functionname@@YG*XZ"�Q�例�?　　int Test1(char *var1,unsigned long)-----“?Test1@@YGHPADK@Z” 　　void Test2() -----“?Test2@@YGXXZ”
　　__cdecl调用�U�定�Q?
　　规则同上面的_stdcall调用�U�定�Q�只是参数表的开始标识由上面�?@@YG"变�ؓ"@@YA"�?
　　__fastcall调用�U�定�Q?
　　规则同上面的_stdcall调用�U�定�Q�只是参数表的开始标识由上面�?@@YG"变�ؓ"@@YI"�?
　　VC++对函数的省缺声明�?__cedcl",��只能被C/C++调用.
　　注意�Q?
　　1、_beginthread需要__cdecl的线�E�函数地址�Q�_beginthreadex和CreateThread需要__stdcall的线�E�函数地址�?
　　2、一般WIN32的函数都是__stdcall。而且在Windef.h中有如下的定义：
　　#define CALLBACK __stdcall
　　#define WINAPI　 __stdcall
　　3、extern "C" _declspec(dllexport) int __cdecl Add(int a, int b);
　　typedef int (__cdecl*FunPointer)(int a, int b);
　　修饰�W�的书写��序如上�?
　　4�?extern "C"的作用：如果Add(int a, int b)是在c语言�~�译器编译，而在c++文�g使用�Q�则需要在c++文�g中声明：extern "C" Add(int a, int b)�Q�因为c�~�译器和c++�~�译器对函数名的解释不一��P��c++�~�译器解释函数名的时候要考虑函数参数�Q�这��h��了方便函数重载，而在c语言中不存在函数�?载的问题�Q�，使用extern "C"�Q�实质就是告诉c++�~�译器，该函数是c库里面的函数。如果不使用extern "C"则会出现链接错误�?
　　一般象如下使用�Q?
　　#ifdef _cplusplus
　　#define EXTERN_C extern "C"
　　#else
　　#define EXTERN_C extern
　　#endif
　　#ifdef _cplusplus
　　extern "C"{
　　#endif
　　EXTERN_C int func(int a, int b);
　　#ifdef _cplusplus
　　}
　　#endif
　　5、MFC提供了一些宏�Q�可以��用AFX_EXT_CLASS来代替__declspec(DLLexport)�Q��ƈ修饰�c�d��Q�从而导出类�Q�AFX_API_EXPORT来修饰函敎ͼ�AFX_DATA_EXPORT来修饰变�?
　　AFX_CLASS_IMPORT�Q�__declspec(DLLexport)
　　AFX_API_IMPORT�Q�__declspec(DLLexport)
　　AFX_DATA_IMPORT�Q�__declspec(DLLexport)
　　AFX_CLASS_EXPORT�Q�__declspec(DLLexport)
　　AFX_API_EXPORT�Q�__declspec(DLLexport)
　　AFX_DATA_EXPORT�Q�__declspec(DLLexport)
　　AFX_EXT_CLASS�Q?ifdef _AFXEXT
　　AFX_CLASS_EXPORT
　　#else
　　AFX_CLASS_IMPORT
　　6�?DLLMain负责初始�?Initialization)和结�?Termination)工作�Q�每当一个新的进�E�或者该�q�程的新的线�E�访问DLL�Ӟ�� 或者访问DLL的每一个进�E�或者线�E�不再��用DLL或者结束时�Q�都会调用DLLMain。但是，使用TerminateProcess�?TerminateThread�l�束�q�程或者线�E�，不会调用DLLMain�?
　　7、一个DLL在内存中只有一个实�?
　　DLL�E�序和调用其输出函数的程序的关系�Q?
　　1)、DLL与进�E�、线�E�之间的关系
　　DLL模块被映��到调用它的�q�程的虚拟地址�I�间�?
　　DLL使用的内存从调用�q�程的虚拟地址�I�间分配�Q�只能被该进�E�的�U�程所讉K��?
　　DLL的句柄可以被调用�q�程使用�Q�调用进�E�的句柄可以被DLL使用�?
　　DLLDLL可以有自��q��数据�D�，但没有自��q��堆栈�Q��用调用进�E�的栈，与调用它的应用程序相同的堆栈模式�?
　　2)、关于共享数据段
　　DLL 定义的全局变量可以被调用进�E�访问；DLL可以讉K��调用�q�程的全局数据。��用同一DLL的每一个进�E�都有自��q��DLL全局变量实例。如果多个线�E��ƈ发访�?同一变量�Q�则需要��用同步机�Ӟ��对一个DLL的变量，如果希望每个使用DLL的线�E�都有自��q��|��则应该��用线�E�局部存�?TLS�Q�Thread Local Strorage)

IssAc 2008-08-13 19:41 发表评论

[Demo] -- DataTransformTool

IssAc — Thu, 07 Aug 2008 11:02:00 GMT

自己动手做的一个简单的工具,可以用来计算输入的日�?br>
1.一�q�中的第多少�?
2.是什么星�?br>3.�q�一天星期几
4.分割栏操作的复习

初学MFC的一个小�l�习 ..
下面留个链接 .供以后回��?..~
/Files/IssacAsimoy/DataTransformTool.rar

生成的exe文�g居然不能在别人的机子上运�?提示�~�少库文�?..~

解决一.
project->settings->general
��USE   MFC in a shared DLL 改�ؓUse MFC in a static libery
左边选release�Q�再�~�译

解决�?
�q�有办法��是使用.net或是Install Shell来把�q�个�q�个�E�序�l�打包出�?
�q�是最正式的方�?

IssAc 2008-08-07 19:02 发表评论

《MFCWindows�E�序设计�?-Hello MFC

IssAc — Mon, 28 Jul 2008 13:30:00 GMT

//hello.h
class CMyApp:public CWinApp
{
public:
    virtual BOOL InitInstance();
};

class CMainWindow:public CFrameWnd
{
public:
    CMainWindow();

protected:
    afx_msg void OnPaint();
    DECLARE_MESSAGE_MAP()
};

#include <afxwin.h>
#include "Hello.h"

CMyApp myApp;

BOOL CMyApp::InitInstance()
{
    m_pMainWnd=new CMainWindow;
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
    return TRUE;
}

BEGIN_MESSAGE_MAP (CMainWindow, CFrameWnd)
    ON_WM_PAINT ()
END_MESSAGE_MAP ()

CMainWindow::CMainWindow()
{
    Create(NULL,_T("The Hello Application"));
}

void CMainWindow::OnPaint()
{
    CPaintDC dc(this);
    CRect rect;
    GetClientRect(&rect);
    dc.DrawText(_T("Hello,MFC"),-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
}

IssAc 2008-07-28 21:30 发表评论