久久久黄片,国产精品成人久久久久三级午夜电影,久久综合综合久久综合

Windows动态链接库DLL[实践]

Sunshine Alike — Wed, 07 Jul 2010 16:24:00 GMT

一直对动态链接库�q�个东西很陌生，今天刚好调试别�h写的一个DLL��目�Q�顺便就来研�I�一下下�?br />动态链接库的原理，好处那些��先不说了，直接来看怎么使用�?br />首先写一个动态链接库�Q�其�?span style="color: rgb(0, 0, 0);"> __declspec(dllexport)是用于MS�~�译器的一个关键字�Q�用来将DLL中的内容导出而不需�?def文�g了�?br />下面的cpp里就函数的定义了�Q�DllMain函数跟普通的win32 console的main函数很像�?br />使用cl /c DLLImplement.cpp
link /dll DLLImplement.obj
��可以得��C��个DLLImplement.dll��Z��也会导出一�?/span>DLLImplement.lib�q�个跟静态链接库很像的东西，实际上它的作用只是导出那些方法和变量的名字�?br />

1 extern "C"
2 {
3     __declspec(dllexport) void Set(int i);
4     __declspec(dllexport) int Get();
5     __declspec(dllexport) void SayHello();
6
7     int value;
8 }

1 #include <iostream>
2 #include <objbase.h>
3 #include "DLLHeader.h"
4
5
6 void Set(int i)
7 {
8     value = i;
9 }
10 int Get()
11 {
12     return value;
13 }
14 void SayHello()
15 {
16     std::cout<<"Hello, I'm DLL, value is "<<value<<std::endl;
17 }
18
19
20 BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
21 {
22     HANDLE g_hModule;
23
24     switch(dwReason)
25     {
26     case DLL_PROCESS_ATTACH:
27        std::cout<<"DLL is attached!"<<std::endl;
28        g_hModule = (HINSTANCE)hModule;
29        break;
30
31     case DLL_PROCESS_DETACH:
32        std::cout<<"DLL is detached!"<<std::endl;
33        g_hModule=NULL;
34        break;
35     }
36
37     return TRUE;
38 }
39

使用DLL的方法，�?�U�：使用def文�g/使用LoadLibrary和GetProcAddress�Ҏ��/使用导出的lib配合头文件�?br />�W�一�U�太�ȝ��q�里不介�l�，只说明一下后两种的��用方法�?br />

1 #include <iostream>
2 #include <windows.h>
3
4 typedef void (*SET)(int);
5 typedef int (*GET)(void);
6 typedef void (*SAYHELLO)(void);
7
8 int main(int argc, char **argv)
9 {
10     SET pSet = 0;
11     GET pGet = 0;
12     SAYHELLO pSayHello = 0;
13
14     HINSTANCE hinst=::LoadLibrary("DLLImplement.dll");
15     if (0 == hinst)
16     {
17         std::cout<<"load dll failed!"<<std::endl;
18         return -1;
19     }
20
21     pSet = (SET)GetProcAddress(hinst, "Set");
22     pGet = (GET)GetProcAddress(hinst, "Get");
23     pSayHello = (SAYHELLO)GetProcAddress(hinst, "SayHello");
24
25     if (0 == pSet || 0 == pGet || 0 == pSayHello)
26     {
27         std::cout<<"get function failed!"<<std::endl;
28         return -1;
29     }
30
31     //ready to call the function
32     (*pSet)(10);
33     int i = (*pGet)();
34     std::cout<<"Get value from dll, value is "<<i<<std::endl;
35     (*pSayHello)();
36
37     return 0;
38 }

�q�种调用�Ҏ��属于昄��调用�Q��用的时候需要知道DLL文�g的�\径，�q�有DLL里面的方法的名字�Q�还是有点不太方�ѝ��更多的时候，都是使用最后一�U�隐式调用的�Ҏ��Q�即配合头文件和导出的lib�Q�需要在�q�行链接的时候加入DLLImplement.lib卛_��Q�方法如下：

1 #include <iostream>
2 #include "DLLHeader.h"
3
4 using namespace std;
5
6
7 int main (int argc, char **argv)
8 {
9     Set(100);
10     cout<<"Set value in DLL"<<endl;
11     int i = Get();
12     cout<<"Get value in DLL, value is "<<i<<endl;
13
14     SayHello();
15     return 0;
16 }

到这里对DLL有了一个大概的感性认识，具体的理论性的知识�Q�等有机会慢慢再写出来�?br />
抱怨一句，最�q�有�Ҏ��了，惌��写的日志都没写�?br />扑֮�习也�ȝ��Q�写代码肩膀脖子酸痛�?br />IT民工的命咋就�q�么苦哩�?br />

Sunshine Alike 2010-07-08 00:24 发表评论

Linux Note

Sunshine Alike — Sun, 14 Mar 2010 13:06:00 GMT

最�q�才开始接触linux�pȝ��Q�Ubuntu 9.10�Q�，有些东西�Ҏ��忘记�Q�备忘之�Q�待�l��?br />
1.g++�~�译问题

//main.cpp
#include <iostream>
using namespace std;

//headers
void show();

int main()
{
    cout<<"library test function show(): ";
    show();
    return 0;
}

//libtest.cpp
#include <iostream>
using namespace std;

void show()
{
cout<<"hello library test!"<<endl;
}

静态库�Q?br />首先�~�译libtest.cpp生成中间文�g libtest.o
g++ -c libtest.cpp
然后��其打包成静态库 staticlib.a
ar -rc staticlib.a libtest.o
最后��用静态库与main.cpp�q�行�~�译得到执行文�gstaticlib
g++ -o staticlib main.cpp staticlib.a
�q�行./staticlib 成功�Q�！

动态库�Q?br />首先同样需要编译生成中间文�?b>libteset.o�Q�但一般加�?fPIC选项�?br />其意思是位置独立代码 �Q�指�C�编译程序生成的代码要适合�׃�n库的内容�q�样的代码能够根据蝲入内存的位置计算内部地址
g++ -c -fPIC libtest.cpp
然后打包生成动态库dynamiclib.so
g++ -shared libtest.o -o dynamiclib.so
最后生成可执行文�gdynamiclib
g++ -o dynamic main.cpp dynamiclib.so
�q�行./dynamiclib �l�果出错了，提示找不到动态库�?/b>
原因是linux下动态库不像windows里那样会自动��L��当前目录下的dll�Q�这需要把�~�译出来的动态库攑ֈ��pȝ��?/usr/lib �?/lib下才能运行程序�?br />或者还可以在编译的时候就指定路径也可以，例如在最后一步的时候：
g++ -o dynamic main.cpp ./dynamiclib.so
再次�q�行./dynamiclib 成功�Q�！

Sunshine Alike 2010-03-14 21:06 发表评论

sizeof�l�极无惑 (�?

Sunshine Alike — Fri, 27 Mar 2009 08:53:00 GMT

转自�Q?a href="/andxie99/archive/2006/10/26/14230.html">http://www.shnenglu.com/andxie99/archive/2006/10/26/14230.html

1. 定义�Q?br />sizeof是C/C++中的一个操作符�Q�operator�Q�，��单的说其作用��是�q�回一个对象或者类型所占的内存字节数�?br />MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types).
This keyword returns a value of type size_t.
其返回值类型�ؓsize_t�Q�在头文件stddef.h中定义。这是一个依赖于�~�译�pȝ��的��|��一般定义�ؓ
typedef unsigned int size_t;
世上�~�译器林林��L��，但作��Z��个规范，它们都会保证char、signed char和unsigned char的sizeof��gؓ1�Q�毕竟char是我们编�E�能用的最��数据类型�?

2. 语法�Q?br />sizeof有三�U�语法�Ş式，如下�Q?br />1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( �c�d�� );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写�?代替�Q��ؓ求�Ş式统一以及减少我们大脑的负担，�W?�U�写法，忘掉它吧�Q?br />实际上，sizeof计算对象的大��也是�{换成对对象类型的计算�Q�也��是��_��同种�c�d��的不同对象其sizeof值都是一致的。这里，对象可以�q�一步�g伸至表达式，即sizeof可以对一个表辑ּ�求��|��~�译器根据表辑ּ�的最�l�结果类型来��定大小�Q�一般不会对表达式进行计��。如�Q?br />sizeof( 2 );// 2的类型�ؓint�Q�所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型�ؓdouble�Q?也会被提升成double�c�d��Q�所以等价于 sizeof( double );
sizeof也可以对一个函数调用求��|��其结果是函数�q�回�c�d��的大��，函数�q�不会被调用�Q�我们来看一个完整的例子�Q?br />char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型�ؓchar�Q�所以sz = sizeof( char )�Q�foo()�q�不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定�Q�函数、不能确定类型的表达式以及位域（bit-field�Q�成员不能被计算sizeof��|��即下面这些写法都是错误的�Q?br />sizeof( foo );// error

void foo2() { }
sizeof( foo2() );// error

struct S
{
unsigned int f1 : 1;
unsigned int f2 : 5;
unsigned int f3 : 12;
};
sizeof( S.f1 );// error

3. sizeof的常量�?br />sizeof的计��发生在�~�译时刻�Q�所以它可以被当作常量表辑ּ�使用�Q�如�Q?br />char ary[ sizeof( int ) * 10 ]; // ok
最新的C99标准规定sizeof也可以在�q�行时刻�q�行计算�Q�如下面的程序在Dev-C++中可以正��执行：
int n;
n = 10; // n动态赋�?br />char ary[n]; // C99也支持数�l�的动态定�?br />printf("%d\n", sizeof(ary)); // ok. 输出10
但在没有完全实现C99标准的编译器中就行不通了�Q�上面的代码在VC6中就通不�q�编译。所以我们最好还是认为sizeof是在�~�译期执行的�Q�这样不会带来错误，让程序的可移植性强些�?/font>

4. 基本数据�c�d��的sizeof
�q�里的基本数据类型指short、int、long、float、double�q�样的简单内�|�数据类型，�׃��它们都是和系�l�相关的�Q�所以在不同的系�l�下取值可能不同，�q�务必引��h��们的注意�Q�尽量不要在�q�方面给自己�E�序的移植造成�ȝ��?br />一般的�Q�在32位编译环境中�Q�sizeof(int)的取��gؓ4�?/font>

5. 指针变量的sizeof
学过数据�l�构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既然是来存攑֜�址的，那么它当然等于计��机内部地址�ȝ��的宽度。所以在32位计��机中，一个指针变量的�q�回值必定是4�Q�注意结果是以字节�ؓ单位�Q�，可以预计�Q�在��来�?4位系�l�中指针变量的sizeof�l�果�?�?br />char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)();// 函数指针
sizeof( pc ); // �l�果�?
sizeof( pi ); // �l�果�?
sizeof( ps ); // �l�果�?
sizeof( ppc ); // �l�果�?
sizeof( pf );// �l�果�?
指针变量的sizeof��g��指针所指的对象没有��M��关系�Q�正是由于所有的指针变量所占内存大��相�{�，所以MFC消息处理函数使用两个参数WPARAM、LPARAM��p��传递各�U�复杂的消息�l�构�Q��用指向结构体的指针）�?/font>

6. 数组的sizeof
数组的sizeof值等于数�l�所占用的内存字节数�Q�如�Q?br />char a1[] = "abc";
int a2[3];
sizeof( a1 ); // �l�果�?�Q�字�W�串末尾�q�存在一个NULL�l�止�W?br />sizeof( a2 ); // �l�果�?*4=12�Q�依赖于int�Q?br />一些朋友刚开始时把sizeof当作了求数组元素的个敎ͼ�现在�Q�你应该知道�q�是不对的，那么应该怎么求数�l�元素的个数呢？Easy�Q�通常有下面两�U�写法：
int c1 = sizeof( a1 ) / sizeof( char ); // 总长�?单个元素的长�?br />int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长�?�W�一个元素的长度
写到�q�里�Q�提一问，下面的c3�Q�c4值应该是多少呢？
void foo3(char a3[3])
{
int c3 = sizeof( a3 ); // c3 == ?
}
void foo4(char a4[])
{
int c4 = sizeof( a4 ); // c4 == ?
}也许当你试图回答c4的值时已经意识到c3�{�错了，是的�Q�c3!=3。这里函数参数a3已不再是数组�c�d��Q�而是蜕变成指针，相当于char* a3�Q��ؓ什么？仔细��x��׃��难明白，我们调用函数foo1�Ӟ��E�序会在栈上分配一个大��ؓ3的数�l�吗�Q�不会！数组是“传址”的�Q�调用者只需��实参的地址传递过去，所以a3自然为指针类型（char*�Q�，c3的��g��׃ؓ4�?/font>

7. �l�构体的sizeof
�q�是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体�Q?br />struct S1
{
char c;
int i;
};
问sizeof(s1)�{�于多少�Q�聪明的你开始思考了�Q�char�?个字节，int�?个字节，那么加�v来就应该�?。是�q�样吗？你在你机器上试过了吗�Q�也�怽�是对的，但很可能你是错的�Q�VC6中按默认讄��得到的结果�ؓ8�?br />Why�Q��ؓ什么受伤的��L��我？
请不要沮丧，我们来好好琢��一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节敎ͼ�好吧�Q�那��p��我们来看看S1的内存分配情况：
S1 s1 = { 'a', 0xFFFFFFFF };
定义上面的变量后�Q�加上断点，�q�行�E�序�Q�观察s1所在的内存�Q�你发现了什么？
以我的VC6.0��Z��Q�s1的地址�?x0012FF78�Q�其数据内容如下�Q?br />0012FF78:? 61 CC CC CC FF FF FF FF
发现了什么？怎么中间�Ҏ��?个字节的CC�Q�看看MSDN上的说明�Q?br />When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原来如此�Q�这��是传说中的字节寚w��啊！一个重要的话题出现了�?br />��Z��么需要字节对齐？计算机组成原理教导我们这��h��助于加快计算机的取数速度�Q�否则就得多花指令周期了。�ؓ此，�~�译器默认会对结构体�q�行处理�Q�实际上其它地方的数据变量也是如此）�Q�让宽度�?的基本数据类型（short�{�）都位于能�?整除的地址上，让宽度�ؓ4的基本数据类型（int�{�）都位于能�?整除的地址上，以此�c�L��。这��P��两个��C��间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了�?br />让我们交换一下S1中char与int的位�|�：
struct S2
{
int i;
char c;
};
看看sizeof(S2)的结果�ؓ多少�Q�怎么�q�是8�Q�再看看内存�Q�原来成员c后面仍然�?个填充字节，�q�又是�ؓ什么啊�Q�别着急，下面�ȝ��规律�?br />
字节寚w��的细节和�~�译器实现相养I��但一般而言�Q�满��三个准则：
1) �l�构体变量的首地址能够被其最宽基本类型成员的大小所整除�Q?br />2) �l�构体每个成员相对于�l�构体首地址的偏�U�量�Q�offset�Q�都是成员大��的整数倍，如有需要编译器会在成员之间加上填充字节�Q�internal adding�Q�；
3) �l�构体的��d��ؓ�l�构体最宽基本类型成员大��的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding�Q��?br />对于上面的准则，有几炚w��要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏�U�量了呢�Q�因为有了第1点存在，所以我们就可以只考虑成员的偏�U�量�Q�这��h��考�v来简单。想想�ؓ什么�?br />�l�构体某个成员相对于�l�构体首地址的偏�U�量可以通过宏offsetof()来获得，�q�个宏也在stddef.h中定义，如下�Q?br />#define offsetof(s,m)?? (size_t)&(((s *)0)->m)
例如�Q�想要获得S2中c的偏�U�量�Q�方法�ؓ
size_t pos = offsetof(S2, c);// pos�{�于4
2) 基本�c�d��是指前面提到的像char、short、int、float、double�q�样的内�|�数据类型，�q�里所说的“数据宽度”就是指其sizeof的大��。由于结构体的成员可以是复合�c�d��Q�比如另外一个结构体�Q�所以在��L��最宽基本类型成员时�Q�应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合�c�d��作�ؓ整体看待�?br />�q�里叙述��h��有点拗口�Q�思考�v来也有点挠头�Q�还是让我们看看例子吧（具体数��g��以VC6��Z��Q�以后不再说明）�Q?br />struct S3
{
char c1;
S1 s;
char c2
};
S1的最宽简单成员的�c�d��为int�Q�S3在考虑最宽简单类型成员时是将S1“打散”看的，所以S3的最宽简单类型�ؓint�Q�这��P��通过S3定义的变量，其存储空间首地址需要被4整除�Q�整个sizeof(S3)的��g��应该�?整除�?br />c1的偏�U�量�?�Q�s的偏�U�量呢？�q�时s是一个整体，它作为结构体变量也满��_��面三个准则，所以其大小�?�Q�偏�U�量�?�Q�c1与s之间侉K��?个填充字节，而c2与s之间��׃��需要了�Q�所以c2的偏�U�量�?2�Q�算上c2的大��ؓ13�Q?3是不能被4整除的，�q�样末尾�q�得补上3个填充字节。最后得到sizeof(S3)的��gؓ16�?br />通过上面的叙�q�ͼ�我们可以得到一个公式：
�l�构体的大小�{�于最后一个成员的偏移量加上其大小再加上末��填充字节数目�Q�即�Q?br />sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )

到这里，朋友们应该对�l�构体的sizeof有了一个全新的认识�Q�但不要高兴得太早，有一个媄响sizeof的重要参量还未被提及�Q�那便是�~�译器的pack指��o。它是用来调整结构体寚w��方式的，不同�~�译器名�U�和用法略有不同�Q�VC6中通过#pragma pack实现�Q�也可以直接修改/Zp�~�译开兟�?pragma pack的基本用法�ؓ�Q?pragma pack( n )�Q�n为字节对齐数�Q�其取��gؓ1�?�?�?�?6�Q�默认是8�Q�如果这个值比�l�构体成员的sizeof值小�Q�那么该成员的偏�U�量应该以此��gؓ准，��x��_��l�构体成员的偏移量应该取二者的最��|��公式如下�Q?br />offsetof( item ) = min( n, sizeof( item ) )
再看�C�Z��Q?br />#pragma pack(push) // ��当前pack讄��压栈保存
#pragma pack(2)// 必须在结构体定义之前使用
struct S1
{
char c;
int i;
};
struct S3
{
char c1;
S1 s;
char c2
};
#pragma pack(pop) // 恢复先前的pack讄��
计算sizeof(S1)�Ӟ��min(2, sizeof(i))的��gؓ2�Q�所以i的偏�U�量�?�Q�加上sizeof(i)�{�于6�Q�能够被2整除�Q�所以整个S1的大��ؓ6�?br />同样�Q�对于sizeof(S3)�Q�s的偏�U�量�?�Q�c2的偏�U�量�?�Q�加上sizeof(c2)�{�于9�Q�不能被2整除�Q�添加一个填充字节，所以sizeof(S3)�{�于10�?br />现在�Q�朋友们可以��L��的出一口气了，:)

�q�有一点要注意�Q�“空�l�构体”（不含数据成员�Q�的大小不�ؓ0�Q�而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空�l�构体”变量又如何得以区分呢？于是�Q�“空�l�构体”变量也得被存储�Q�这��L��译器也就只能为其分配一个字节的�I�间用于占位了。如下：
struct S5 { };
sizeof( S5 ); // �l�果�?

8. 含位域结构体的sizeof
前面已经说过�Q�位域成员不能单独被取sizeof��|��我们�q�里要讨论的是含有位域的�l�构体的sizeof�Q�只是考虑到其�Ҏ��性而将其专门列了出来�?br />C99规定int、unsigned int和bool可以作�ؓ位域�c�d��Q�但�~�译器几乎都�Ҏ��作了扩展�Q�允许其它类型类型的存在�?br />使用位域的主要目的是压羃存储�Q�其大致规则为：
1) 如果盔R��位域字段的类型相同，且其位宽之和��于�c�d��的sizeof大小�Q�则后面的字�D�将紧邻前一个字�D�存储，直到不能容纳为止�Q?br />2) 如果盔R��位域字段的类型相同，但其位宽之和大于�c�d��的sizeof大小�Q�则后面的字�D�将从新的存储单元开始，其偏�U�量为其�c�d��大小的整数倍；
3) 如果盔R��的位域字�D늚��c�d��不同�Q�则各编译器的具体实现有差异�Q�VC6采取不压�~�方式，Dev-C++采取压羃方式�Q?br />4) 如果位域字段之间�I�插着非位域字�D�，则不�q�行压羃�Q?br />5) 整个�l�构体的��d��ؓ最宽基本类型成员大��的整数倍�?br />
�q�是让我们来看看例子�?br />�C�Z��1�Q?br />struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

位域�c�d��为char�Q�第1个字节仅能容�U�下f1和f2�Q�所以f2被压�~�到�W?个字节中�Q�而f3只能从下一个字节开始。因此sizeof(BF1)的结果�ؓ2�?br />�C�Z��2�Q?br />struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
�׃��盔R��位域�c�d��不同�Q�在VC6中其sizeof�?�Q�在Dev-C++中�ؓ2�?br />�C�Z��3�Q?br />struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
非位域字�D늩�插在其中�Q�不会��生压�~�，在VC6和Dev-C++中得到的大小均�ؓ3�?br />

9. 联合体的sizeof
�l�构体在内存�l�织上是��序式的�Q�联合体则是重叠式，各成员共享一�D�内存，所以整个联合体的sizeof也就是每个成员sizeof的最大倹{��结构体的成员也可以是复合类型，�q�里�Q�复合类型成员是被作为整体考虑的�?br />所以，下面例子中，U的sizeof值等于sizeof(s)�?br />union U
{
int i;
char c;
S1 s;
};

Sunshine Alike 2009-03-27 16:53 发表评论