中文字幕在线观看亚洲日韩,久久精品国产亚洲av麻豆小说,亚洲AV本道一区二区三区四区

allic — Tue, 05 Jun 2012 10:00:00 GMT

#pragma pack() struct test { char m1; double m4; int m3; }; #pragma pack() #pragma pack(8) struct A { int n; char c; short s; }; struct B { char c; int n; short s; }; #pragma pack() sizeof test:16 sizeof a:8 sizeof b:12 �~�译器默认的成员寚w��值是8字节�Q�通过#pragma pack(show)指��o�Q�编译的时候在输出栏会限制默认寚w��倹{��以上程序运行完通过调试的内存察看功能得到a和b的内存存储区域如下： a的存储区域：0x0012FED0 02 00 00 00 31 00 03 00 b的存储区域：0x0012FEBC 31 00 00 00 02 00 00 00 03 00 00 00 最前面�?字节整数是变量的起始地址�Q�后面是变量的整个存储区域�? 现在我们按照 align of member = min( pack setting value, sizeof(member) )的公式分析一下a和b的存储�? a的第一个成员n为int�Q�大��ؓ4�Q�align of a.n = min(8,sizeof(int) )�Q�对齐��gؓ4。第一个成员相对于�l�构体�v始地址�?偏移开始，前四个字�?2 00 00 00即�ؓn的存储区域，因�ؓx86是Little Endian�Q�低字节在前�Q�的字节��序�Q�所以第一字节�?�Q�后面三个字�?�Q�我们通常写成0x00000002�Q? a的第二个成员c为char�Q�大��ؓ1�Q�align of a.c=min(8,sizeof(char))�Q�对齐��gؓ1。c紧接着a后面存储从偏�U?开始，满��1字节寚w��的要求。它的��gؓ'1'�Q�ASCII码�ؓ0x31�Q�共一个字�?1�Q? a的第三个成员为short�Q�大��ؓ2�Q�align of a.s=min(8,sizeof(short))�Q�对齐��gؓ2。如果紧接第二个成员从偏�U?开始存储就不满��?字节寚w��Q�因此蟩�q?个字节，从偏�U?字节的地方开始存储，��x��后两个字�?3 00�Q? b的第一个成员c为char�Q�大��ؓ1�Q�align of a.c=min(8,sizeof(char))�Q�对齐��gؓ1。第一个成员从偏移起始地址0字节开始存储，它的��gؓ'1'�Q�ASCII码�ؓ0x31�Q�共一个字�?1�Q? b的第二个成员n为int�Q�大��ؓ4�Q�align of a.n = min(8,sizeof(int) )�Q�对齐��gؓ4。如果紧接第二个成员后面从偏�U?开始存储就不能4字节寚w��Q�因此蟩�q?个字节，从偏�U?字节的地方开始存储，即第5-8的四个字�?2 00 00 00�Q? b的第三个成员为short�Q�大��ؓ2�Q�align of a.s=min(8,sizeof(short))�Q�对齐��gؓ2。紧接第二个成员从偏�U?字节的地方开始存储，�?-10两个字节03 00�Q? �q�时有�h可能要问�Q�b��Z��么最后多了两个字�?0 00呢？�q�就是我们下面要讲的�Q�整个结构体的对齐�? 2、align指��o align指��o可以用于讄��各种内置�c�d��、自定义�c�d��如struct、union或class的的寚w��方式。指令格式�ؓ�Q�__declspec(align(#)) �Q?是对齐��|��取��gؓ2�?�ơ方�?�?192�ơ方。在声明自定义类型或内置变量�Ӟ��如果指定了对齐��|��则对应变量的起始地址必须是该值的整数倍。除此外�Q�它�q�会影响�l�构体的大小。下面引用两�D�MSDN关于align的描�q�ͼ� Without __declspec(align(#)), Visual C++ aligns data on natural boundaries based on the size of the data, for example 4-byte integers on 4-byte boundaries and 8-byte doubles on 8-byte boundaries. Data in classes or structures is aligned within the class or structure at the minimum of its natural alignment and the current packing setting (from #pragma pack or the /Zp compiler option). 从这�D�可以看出，如果没有讄��align(#)��|��变量x按照sizeof(x)来对齐�v始地址。类或结构体内的成员在类或结构体内部按照min( pack setting value,sizeof(member))来对齐。这个我们在pack指��o部分已经分析�q��? The sizeof value for any structure is the offset of the final member, plus that member's size, rounded up to the nearest multiple of the largest member alignment value or the whole structure alignment value, whichever is greater. 从这�D�可以看出，align(#)指��o会媄响结构体或类的大��。�ȝ��公式为： sizeof(structure) = (�l�构体最后一个成员的偏移 + sizeof(�l�构体最后一个成�? ) 上取�?( n* max( �l�构体各成员的对齐�?align(#)讄��的�?) ); 其中n为正整数�? �Ҏ��该公式我们分析一下b��Z��么后面会多两个填充字�?�? b的最后一个成s偏移�?�Q�大��ؓ2�Q�b中各成员寚w��值最大的�?�Q�因为未讄��align(#)�Q�所以上取整的数��gؓ4n�?+2�?的倍数上取整�ؓ12。因此后面需要填充两个字节，�q�样才能使sizeof(b) == 12�?

allic 2012-06-05 18:00 发表评论

win32环境C语言实现最基本的DLL�~�写及调用实例，��试通过[原]

allic — Mon, 06 Apr 2009 05:46:00 GMT

开发环境是DEV C++,采用C语言�~�写
创徏一个DLL��目�Q�项目名�U�hello,DLL�~�写采用的是DEV C++中的�C�Z��代码

头文件dll.h
#ifndef _DLL_H_
#define _DLL_H_

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */

DLLIMPORT void HelloWorld (void);

#endif /* _DLL_H_ */

C文�g
dllmain.c
#include
#include

DLLIMPORT void HelloWorld ()
{
MessageBox (0, "Hello World from DLL!\n", "Hi", MB_ICONINFORMATION);
}

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

case DLL_PROCESS_DETACH:
break;

case DLL_THREAD_ATTACH:
break;

      case DLL_THREAD_DETACH:
        break;
    }

/* Returns TRUE on success, FALSE on failure */
return TRUE;
}

�q�有要注意的�?def文�g中指定输出的函数�Q�编译生成了hello.dll文�g

DLL调用部分
dllcall.c
#include
#include
#include

HINSTANCE hDLL; //定义DLL包柄
typedef void ( *func)(); //定义函数指针原型
func hello; //定义函数指针
int main()
{
if (hDLL == NULL)
hDLL=LoadLibrary("hello.dll"); //加蝲DLL
hello = (func)GetProcAddress(hDLL,"HelloWorld"); //获取函数指针
hello();
FreeLibrary(hDLL); //释放DLL
return 0;
}

�~�译执行

allic 2009-04-06 13:46 发表评论

allic — Fri, 03 Apr 2009 15:06:00 GMT

实例来自互联�|�，�q�段��试代码实现了基本的文�g传输原理�Q�没有实现错误处理�?br />
//////////////////////////////////////////////////////////////////////////////////////
// file_server.c 文�g传输��序服务器示�?br />//////////////////////////////////////////////////////////////////////////////////////
//本文件是服务器的代码
#include     // for sockaddr_in
#include     // for socket
#include     // for socket
#include         // for printf
#include         // for exit
#include         // for bzero
/*
#include
#include
#include
#include
*/
#define HELLO_WORLD_SERVER_PORT    6666
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

int main(int argc, char **argv)
{
    //讄��一个socket地址�l�构server_addr,代表服务器internet地址, 端口
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(server_addr)); //把一�D�内存区的内容全部设�|��ؓ0
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);

    //创徏用于internet的流协议(TCP)socket,用server_socket代表服务器socket
    int server_socket = socket(PF_INET,SOCK_STREAM,0);
    if( server_socket < 0)
    {
        printf("Create Socket Failed!");
        exit(1);
    }

    //把socket和socket地址�l�构联系��h��
    if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
    {
        printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
        exit(1);
    }

    //server_socket用于监听
    if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
    {
        printf("Server Listen Failed!");
        exit(1);
    }
    while (1) //服务器端要一直运�?br />    {
        //定义客户端的socket地址�l�构client_addr
        struct sockaddr_in client_addr;
        socklen_t length = sizeof(client_addr);

        //接受一个到server_socket代表的socket的一个连�?br />        //如果没有�q�接��h��,��q��待到有连接请�?-�q�是accept函数的特�?br />        //accept函数�q�回一个新的socket,�q�个socket(new_server_socket)用于同连接到的客��L��通信
        //new_server_socket代表了服务器和客��L��之间的一个通信通道
        //accept函数把连接到的客��L��信息填写到客��L��的socket地址�l�构client_addr�?br />        int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
        if ( new_server_socket < 0)
        {
            printf("Server Accept Failed!\n");
            break;
        }

        char buffer[BUFFER_SIZE];
        bzero(buffer, BUFFER_SIZE);
        length = recv(new_server_socket,buffer,BUFFER_SIZE,0);//�q�里先接收客��L��发来的要获取的文件名
        if (length < 0)
        {
            printf("Server Recieve Data Failed!\n");
            break;
        }
        char file_name[FILE_NAME_MAX_SIZE+1];
        bzero(file_name, FILE_NAME_MAX_SIZE+1);
        strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));
//        int fp = open(file_name, O_RDONLY);
//        if( fp < 0 )
        FILE * fp = fopen(file_name,"r");
        if(NULL == fp )
        {
            printf("File:\t%s Not Found\n", file_name);
        }
        else
        {
            bzero(buffer, BUFFER_SIZE);
            int file_block_length = 0;
//            while( (file_block_length = read(fp,buffer,BUFFER_SIZE))>0)
            while( (file_block_length = fread(buffer,sizeof(char),BUFFER_SIZE,fp))>0)
            {
                printf("file_block_length = %d\n",file_block_length);
                //发送buffer中的字符串到new_server_socket,实际是给客户�?br />                if(send(new_server_socket,buffer,file_block_length,0)<0)
                {
                    printf("Send File:\t%s Failed\n", file_name);
                    break;
                }
                bzero(buffer, BUFFER_SIZE);
            }                                                                 //�q�段代码是��@环读取文件的一�D�|��据，在��@环调用send�Q�发送到客户端，�q�里��一点的TCP每次接受最多是1024字节�Q�多了就会分片，因此每次发送时��量不要��过1024字节�?/font>
//            close(fp);
            fclose(fp);
            printf("File:\t%s Transfer Finished\n",file_name);
        }
        //关闭与客��L��的连�?br />        close(new_server_socket);
    }
    //关闭监听用的socket
    close(server_socket);
    return 0;
}

//////////////////////////////////////////////////////////////////////////////////////
// file_client.c 文�g传输客户端程序示�?br />//////////////////////////////////////////////////////////////////////////////////////
//本文件是客户机的代码
#include     // for sockaddr_in
#include     // for socket
#include     // for socket
#include         // for printf
#include         // for exit
#include         // for bzero
/*
#include
#include
#include
#include
*/

#define HELLO_WORLD_SERVER_PORT    6666
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

int main(int argc, char **argv)
{
    if (argc != 2)
    {
        printf("Usage: ./%s ServerIPAddress\n",argv[0]);
        exit(1);
    }

    //讄��一个socket地址�l�构client_addr,代表客户机internet地址, 端口
    struct sockaddr_in client_addr;
    bzero(&client_addr,sizeof(client_addr)); //把一�D�内存区的内容全部设�|��ؓ0
    client_addr.sin_family = AF_INET;    //internet协议�?br />    client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自动获取本机地址
    client_addr.sin_port = htons(0);    //0表示让系�l�自动分配一个空闲端�?br />    //创徏用于internet的流协议(TCP)socket,用client_socket代表客户机socket
    int client_socket = socket(AF_INET,SOCK_STREAM,0);
    if( client_socket < 0)
    {
        printf("Create Socket Failed!\n");
        exit(1);
    }
    //把客��h��的socket和客��h��的socket地址�l�构联系��h��
    if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
    {
        printf("Client Bind Port Failed!\n");
        exit(1);
    }

    //讄��一个socket地址�l�构server_addr,代表服务器的internet地址, 端口
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //服务器的IP地址来自�E�序的参�?br />    {
        printf("Server IP Address Error!\n");
        exit(1);
    }
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    socklen_t server_addr_length = sizeof(server_addr);
    //向服务器发�v�q�接,�q�接成功后client_socket代表了客��h��和服务器的一个socket�q�接
    if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
    {
        printf("Can Not Connect To %s!\n",argv[1]);
        exit(1);
    }

    char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    printf("Please Input File Name On Server:\t");
    scanf("%s", file_name);

    char buffer[BUFFER_SIZE];
    bzero(buffer,BUFFER_SIZE);
    strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));
    //向服务器发送buffer中的数据
    send(client_socket,buffer,BUFFER_SIZE,0);

//    int fp = open(file_name, O_WRONLY|O_CREAT);
//    if( fp < 0 )
    FILE * fp = fopen(file_name,"w");
    if(NULL == fp )
    {
        printf("File:\t%s Can Not Open To Write\n", file_name);
        exit(1);
    }

    //从服务器接收数据到buffer�?br />    bzero(buffer,BUFFER_SIZE);
    int length = 0;
    while( length = recv(client_socket,buffer,BUFFER_SIZE,0))       //循环接收�Q�再写到文�g
    {
        if(length < 0)
        {
            printf("Recieve Data From Server %s Failed!\n", argv[1]);
            break;
        }
//        int write_length = write(fp, buffer,length);
        int write_length = fwrite(buffer,sizeof(char),length,fp);
        if (write_length        {
            printf("File:\t%s Write Failed\n", file_name);
            break;
        }
        bzero(buffer,BUFFER_SIZE);
    }
    printf("Recieve File:\t %s From Server[%s] Finished\n",file_name, argv[1]);

    close(fp);
    //关闭socket
    close(client_socket);
    return 0;
}

allic 2009-04-03 23:06 发表评论

多种语言socket�~�程集锦—win32

allic — Fri, 03 Apr 2009 14:34:00 GMT

借此地方整理以下socket�~�程的多�U�语�a�的实玎ͼ�socket可以跨��^台的通信�Q�因此多语言、多�q�_��下的实现有必要了解的。代码都是源自网上，感谢�|�友的分享�?br />
socket�~�程在windows下的C语言实现�Q�dev C++下编译通过
�~�译时设�|�编译选项工具-->�~�译选项-->�~�译器，��N��在�q�接器命令行加入以下命��o�Q�在对话框中�?lwsock32
//server.c
#include
#include
int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD( 1, 1 );

    err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        return;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 ||
    HIBYTE( wsaData.wVersion ) != 1 ) {
        WSACleanup();
        return;
    }
    SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);

    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
    addrSrv.sin_family=AF_INET;
    addrSrv.sin_port=htons(6000);

    bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

    listen(sockSrv,5);

    SOCKADDR_IN addrClient;
    int len=sizeof(SOCKADDR);
    while(1)
    {
        SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
        char sendBuf[50];
        sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));
        send(sockConn,sendBuf,strlen(sendBuf)+1,0);
        char recvBuf[50];
        recv(sockConn,recvBuf,50,0);
        printf("%s\n",recvBuf);
        closesocket(sockConn);
    }
}

//客户端代�?br />#include
#include
int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD( 1, 1 );

    err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        return;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 ||
        HIBYTE( wsaData.wVersion ) != 1 ) {
        WSACleanup( );
        return;
    }
    SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);

    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
    addrSrv.sin_family=AF_INET;
    addrSrv.sin_port=htons(6000);
    connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
    send(sockClient,"hello",strlen("hello")+1,0);
    char recvBuf[50];
    recv(sockClient,recvBuf,50,0);
    printf("%s\n",recvBuf);
    closesocket(sockClient);
    WSACleanup();
}

allic 2009-04-03 22:34 发表评论

allic — Wed, 25 Feb 2009 06:53:00 GMT

一��介�l�Linux下的多线�E�编�E�的文章
1 引言
　　�U�程�Q�thread�Q�技术早�?0�q�代��p��提出�Q�但真正应用多线�E�到操作�pȝ��中去�Q�是�?0�q�代中期�Q�solaris是这斚w��的佼��D��。传�l�的
Unix也支持线�E�的概念�Q�但是在一个进�E�（process�Q�中只允许有一个线�E�，�q�样多线�E�就意味着多进�E�。现在，多线�E�技术已�l�被许多操作�p?br />�l�所支持�Q�包括Windows/NT�Q�当�Ӟ��也包括Linux�?br />　　��Z��么有了进�E�的概念后，�q�要再引入线�E�呢�Q��用多�U�程到底有哪些好处？什么的�pȝ��应该选用多线�E�？我们首先必须回答�q�些问题�?br />　　使用多线�E�的理由之一是和�q�程相比�Q�它是一�U�非�?节�P"的多��d��操作方式。我们知道，在Linux�pȝ��下，启动一个新的进�E�必��d��配给
它独立的地址�I�间�Q�徏立众多的数据表来�l�护它的代码�D�c��堆栈段和数据段�Q�这是一�U?昂贵"的多��d��工作方式。而运行于一个进�E�中的多�?br />�U�程�Q�它们彼此之间��用相同的地址�I�间�Q�共享大部分数据�Q�启动一个线�E�所��p��的空间远�q�小于启动一个进�E�所��p��的空��_��而且�Q�线�E�间
彼此切换所需的时间也�q�远��于�q�程间切换所需要的旉��。据�l�计�Q��ȝ��说来�Q�一个进�E�的开销大约是一个线�E�开销�?0倍左叻I��当然�Q�在�?br />体的�pȝ��上，�q�个数据可能会有较大的区别�?br />　　使用多线�E�的理由之二是线�E�间方便的通信机制。对不同�q�程来说�Q�它们具有独立的数据�I�间�Q�要�q�行数据的传递只能通过通信的方式进
行，�q�种方式不仅�Ҏ��Q�而且很不方便。线�E�则不然�Q�由于同一�q�程下的�U�程之间�׃�n数据�I�间�Q�所以一个线�E�的数据可以直接为其它线�E�所
用，�q�不仅快��P��而且方便。当�Ӟ��数据的共享也带来其他一些问题，有的变量不能同时被两个线�E�所修改�Q�有的子�E�序中声明�ؓstatic的数
据更有可能给多线�E�程序带来灾难性的打击�Q�这些正是编写多�U�程�E�序时最需要注意的地方�?br />　　除了以上所说的优点外，不和�q�程比较�Q�多�U�程�E�序作�ؓ一�U�多��d��、�ƈ发的工作方式�Q�当然有以下的优点：
　　1)
提高应用�E�序响应。这对图形界面的�E�序��其有意义，当一个操作耗时很长�Ӟ��整个�pȝ��都会�{�待�q�个操作�Q�此时程序不会响应键盘、鼠标�?br />菜单的操作，而��用多�U�程技术，��耗时长的操作�Q�time consuming�Q�置于一个新的线�E�，可以避免�q�种��尬的情��c�?br />　　2) 使多CPU�pȝ��更加有效。操作系�l�会保证当线�E�数不大于CPU数目�Ӟ��不同的线�E�运行于不同的CPU上�?br />　　3) 改善�E�序�l�构。一个既长又复杂的进�E�可以考虑分�ؓ多个�U�程�Q�成为几个独立或半独立的�q�行部分�Q�这��L��E�序会利于理解和修改�?br />　　下面我们先来��试�~�写一个简单的多线�E�程序�?br />2 ��单的多线�E�编�E?br />　　Linux�pȝ��下的多线�E�遵循POSIX�U�程接口�Q�称为pthread。编写Linux下的多线�E�程序，需要��用头文�gpthread.h�Q�连接时需要��用库libp
thread.a。顺便说一下，Linux下pthread的实现是通过�pȝ��调用clone�Q�）来实现的。clone�Q�）是Linux所�Ҏ��的系�l�调用，它的使用方式�c�M��
fork�Q�关于clone�Q�）的详�l�情况，有兴��的读者可以去查看有关文档说明。下面我们展�C�Z��个最��单的多线�E�程�?example1.c�?br />/* example.c*/
#include
#include
void thread(void)
{
int i;
for(i=0;i<3;i++)
printf("This is a pthread.n");
}
int main(void)
{
pthread_t id;
int i,ret;
ret=pthread_create(&id,NULL,(void *) thread,NULL);
if(ret!=0){
printf ("Create pthread error!n");
exit (1);
}
for(i=0;i<3;i++)
printf("This is the main process.n");
pthread_join(id,NULL);
return (0);
}
我们�~�译此程序：
gcc example1.c -lpthread -o example1
�q�行example1�Q�我们得到如下结果：
This is the main process.
This is a pthread.
This is the main process.
This is the main process.
This is a pthread.
This is a pthread.
再次�q�行�Q�我们可能得到如下结果：
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
　　前后两次�l�果不一��P��q�是两个�U�程争夺CPU资源的结果。上面的�C�Z��中，我们使用��C��两个函数�Q�　　pthread_create和pthread_join�Q?br />�q�声明了一个pthread_t型的变量�?br />　　pthread_t在头文�g/usr/include/bits/pthreadtypes.h中定义：
　　typedef unsigned long int pthread_t;
　　它是一个线�E�的标识�W�。函数pthread_create用来创徏一个线�E�，它的原型为：
　　extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,
　　void *(*__start_routine) (void *), void *__arg));
　　�W�一个参��Cؓ指向�U�程标识�W�的指针�Q�第二个参数用来讄��U�程属性，�W�三个参数是�U�程�q�行函数的�v始地址�Q�最后一个参数是�q�行函数
的参数。这里，我们的函数thread不需要参敎ͼ�所以最后一个参数设为空指针。第二个参数我们也设为空指针�Q�这样将生成默认属性的�U�程�?br />对线�E�属性的讑֮�和修�Ҏ��们将在下一节阐�q�。当创徏�U�程成功�Ӟ��函数�q�回0�Q�若不�ؓ0则说明创建线�E�失败，常见的错误返回代码�ؓEAGAIN
和EINVAL。前者表�C�系�l�限制创建新的线�E�，例如�U�程数目�q�多了；后者表�C�第二个参数代表的线�E�属性值非法。创建线�E�成功后�Q�新创徏�?br />�U�程则运行参��C��和参数四��定的函敎ͼ�原来的线�E�则�l�箋�q�行下一行代码�?br />　　函数pthread_join用来�{�待一个线�E�的�l�束。函数原型�ؓ�Q?br />　　extern int pthread_join __P ((pthread_t __th, void **__thread_return));
　　�W�一个参��Cؓ被等待的�U�程标识�W�，�W�二个参��Cؓ一个用户定义的指针�Q�它可以用来存储被等待线�E�的�q�回倹{��这个函数是一个线�E�阻�?br />的函敎ͼ�调用它的函数��一直等待到被等待的�U�程�l�束为止�Q�当函数�q�回�Ӟ��被等待线�E�的资源被收回。一个线�E�的�l�束有两�U�途径�Q�一�U�是
象我们上面的例子一��P��函数�l�束了，调用它的�U�程也就�l�束了；另一�U�方式是通过函数pthread_exit来实现。它的函数原型�ؓ�Q?br />　　extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
　　唯一的参数是函数的返回代码，只要pthread_join中的�W�二个参数thread_return不是NULL�Q�这个值将被传递给
thread_return。最后要说明的是�Q�一个线�E�不能被多个�U�程�{�待�Q�否则第一个接收到信号的线�E�成功返回，其余调用pthread_join的线�E�则�q?br />回错误代码ESRCH�?br />　　在这一节里�Q�我们编写了一个最��单的�U�程�Q��ƈ掌握了最常用的三个函数pthread_create�Q�pthread_join和pthread_exit。下面，我们�?br />了解�U�程的一些常用属性以及如何设�|�这些属性�?br />3 修改�U�程的属�?br />　　在上一节的例子里，我们用pthread_create函数创徏了一个线�E�，在这个线�E�中�Q�我们��用了默认参数�Q�即��该函数的第二个参数设�ؓNUL
L。的��，对大多数�E�序来说�Q��用默认属性就够了�Q�但我们�q�是有必要来了解一下线�E�的有关属性�?br />　　属性结构�ؓpthread_attr_t�Q�它同样在头文�g/usr/include/pthread.h中定义，喜欢�q�根问底的�h可以自己��L��看。属性��g��能直接设�|?br />�Q�须使用相关函数�q�行操作�Q�初始化的函��Cؓpthread_attr_init�Q�这个函数必��d��pthread_create函数之前调用。属性对象主要包括是否绑�?br />、是否分��R��堆栈地址、堆栈大��、优先��。默认的属性�ؓ非绑定、非分离、缺�?M的堆栈、与父进�E�同��L�别的优先�U��?br />　　关于�U�程的绑定，牉|��到另外一个概念：轻进�E�（LWP�Q�Light Weight
Process�Q�。轻�q�程可以理解为内核线�E�，它位于用户层和系�l�层之间。系�l�对�U�程资源的分配、对�U�程的控制是通过轻进�E�来实现的，一个轻
�q�程可以控制一个或多个�U�程。默认状况下�Q�启动多��轻�q�程、哪些轻�q�程来控制哪些线�E�是��q��l�来控制的，�q�种状况即称为非�l�定的。绑
定状况下�Q�则��֐�思义�Q�即某个�U�程固定�?�l?在一个轻�q�程之上。被�l�定的线�E�具有较高的响应速度�Q�这是因为CPU旉��片的调度是面向轻�q?br />�E�的�Q�绑定的�U�程可以保证在需要的时候它��L��一个轻�q�程可用。通过讄��被绑定的轻进�E�的优先�U�和调度�U�可以��得绑定的�U�程满��诸如�?br />时反应之�cȝ��要求�?br />　　讄��U�程�l�定状态的函数为pthread_attr_setscope�Q�它有两个参敎ͼ��W�一个是指向属性结构的指针�Q�第二个是绑定类型，它有两个取��|��
PTHREAD_SCOPE_SYSTEM�Q�绑定的�Q�和PTHREAD_SCOPE_PROCESS�Q�非�l�定的）。下面的代码卛_��Z��一个绑定的�U�程�?br />#include
pthread_attr_t attr;
pthread_t tid;
/*初始化属性��|��均设为默认�?/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *) my_function, NULL);
　　�U�程的分��ȝ��态决定一个线�E�以什么样的方式来�l�止自己。在上面的例子中�Q�我们采用了�U�程的默认属性，即�ؓ非分��ȝ��态，�q�种情况�?br />�Q�原有的�U�程�{�待创徏的线�E�结束。只有当pthread_join�Q�）函数�q�回�Ӟ��创徏的线�E�才��终止，才能释放自己占用的系�l�资源。而分��ȝ��E?br />不是�q�样子的�Q�它没有被其他的�U�程所�{�待�Q�自��p��行结束了�Q�线�E�也��q��止了�Q�马上释攄��l�资源。程序员应该�Ҏ��自己的需要，选择适当
的分��ȝ��态。设�|�线�E�分��ȝ��态的函数�?pthread_attr_setdetachstate�Q�pthread_attr_t *attr, int
detachstate�Q�。第二个参数可选�ؓPTHREAD_CREATE_DETACHED�Q�分��ȝ��E�）�?PTHREAD
_CREATE_JOINABLE�Q�非分离�U�程�Q�。这里要注意的一�Ҏ��Q�如果设�|�一个线�E��ؓ分离�U�程�Q�而这个线�E�运行又非常快，它很可能�?br />pthread_create函数�q�回之前��q��止了�Q�它�l�止以后��可能将�U�程号和�pȝ��资源�U�M��l�其他的�U�程使用�Q�这栯��用pthread_create的线�E�就�?br />��C��错误的线�E�号。要避免�q�种情况可以采取一定的同步措施�Q�最��单的�Ҏ��之一是可以在被创建的�U�程里调�?br />pthread_cond_timewait函数�Q�让�q�个�U�程�{�待一会儿�Q�留��够的旉��让函数pthread_create�q�回。设�|�一�D늭�待时��_��是在多线�E�编�E�里�?br />用的�Ҏ��。但是注意不要��用诸如wait�Q�）之类的函敎ͼ�它们是��整个�q�程睡眠�Q��ƈ不能解决�U�程同步的问题�?br />　　另外一个可能常用的属性是�U�程的优先��Q�它存放在结构sched_param中。用函数pthread_attr_getschedparam和函�?br />pthread_attr_setschedparam�q�行存放�Q�一般说来，我们��L��先取优先�U�，对取得的��g��改后再存攑֛�厅R��下面即是一�D늮�单的例子�?br />#include
#include
pthread_attr_t attr;
pthread_t tid;
sched_param param;
int newprio=20;
pthread_attr_init(&attr);
pthread_attr_getschedparam(&attr, ¶m);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, ¶m);
pthread_create(&tid, &attr, (void *)myfunction, myarg);
　　
4 �U�程的数据处�?br />　　和进�E�相比，�U�程的最大优点之一是数据的�׃�n性，各个�q�程�׃�n父进�E�处沿袭的数据段�Q�可以方便的获得、修�Ҏ��据。但�q�也�l�多�U�程
�~�程带来了许多问题。我们必��d��心有多个不同的进�E�访问相同的变量。许多函数是不可重入的，卛_��时不能运行一个函数的多个拯��Q�除�?br />使用不同的数据段�Q�。在函数中声明的静态变量常常带来问题，函数的返回��g��会有问题。因为如果返回的是函数内部静态声明的�I�间的地址
�Q�则在一个线�E�调用该函数得到地址后��用该地址指向的数据时�Q�别的线�E�可能调用此函数�q�修改了�q�一�D�|��据。在�q�程中共享的变量必须�?br />关键字volatile来定义，�q�是��Z��防止�~�译器在优化�Ӟ��如gcc中��?OX参数�Q�改变它们的使用方式。�ؓ了保护变量，我们必须使用信号量�?br />互斥�{�方法来保证我们对变量的正确使用。下面，我们��逐步介绍处理�U�程数据时的有关知识�?br />4.1 �U�程数据
　　在单�U�程的程序里�Q�有两种基本的数据：全局变量和局部变量。但在多�U�程�E�序里，�q�有�W�三�U�数据类型：�U�程数据�Q�TSD:
Thread-Specific
Data�Q�。它和全局变量很象�Q�在�U�程内部�Q�各个函数可以象使用全局变量一栯��用它�Q�但它对�U�程外部的其它线�E�是不可见的。这�U�数据的�?br />要性是显而易见的。例如我们常见的变量errno�Q�它�q�回标准的出错信息。它昄��不能是一个局部变量，几乎每个函数都应该可以调用它�Q�但�?br />又不能是一个全局变量�Q�否则在
A�U�程里输出的很可能是B�U�程的出错信息。要实现诸如此类的变量，我们��必��M��用线�E�数据。我们�ؓ每个�U�程数据创徏一个键�Q�它和这个键
相关联，在各个线�E�里�Q�都使用�q�个键来指代�U�程数据�Q�但在不同的�U�程里，�q�个键代表的数据是不同的�Q�在同一个线�E�里�Q�它代表同样的数
据内宏V�?br />　　和线�E�数据相关的函数主要�?个：创徏一个键�Q��ؓ一个键指定�U�程数据�Q�从一个键��d��U�程数据�Q�删除键�?br />　　创徏键的函数原型为：
　　extern int pthread_key_create __P ((pthread_key_t *__key,
　　void (*__destr_function) (void *)));
　　�W�一个参��Cؓ指向一个键值的指针�Q�第二个参数指明了一个destructor函数�Q�如果这个参��C��为空�Q�那么当每个�U�程�l�束�Ӟ��pȝ��调�?br />�q�个函数来释攄��定在�q�个键上的内存块。这个函数常和函数pthread_once ((pthread_once_t*once_control, void (*initroutine)
(void)))一起��用，��Z��让这个键只被创徏一�ơ。函数pthread_once声明一个初始化函数�Q�第一�ơ调用pthread_once时它执行�q�个函数�Q�以�?br />的调用将被它忽略�?br />　　在下面的例子中，我们创徏一个键�Q��ƈ��它和某个数据相兌��。我们要定义一个函数createWindow�Q�这个函数定义一个图形窗口（数据�c?br />型�ؓFl_Window *�Q�这是图形界面开发工具FLTK中的数据�c�d��Q�。由于各个线�E�都会调用这个函敎ͼ�所以我们��用线�E�数据�?br />/* 声明一个键*/
pthread_key_t myWinKey;
/* 函数 createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 调用函数createMyKey�Q�创建键*/
pthread_once ( & once, createMyKey) ;
/*win指向一个新建立的窗�?/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* �Ҏ��H�口作一些可能的讄��工作�Q�如大小、位�|�、名�U�等*/
setWindow(win);
/* ��窗口指针值绑定在键myWinKey�?/
pthread_setpecific ( myWinKey, win);
}
/* 函数 createMyKey�Q�创��Z��个键�Q��ƈ指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}
/* 函数 freeWinKey�Q�释攄��?/
void freeWinKey ( Fl_Window * win){
delete win;
}
　　�q�样�Q�在不同的线�E�中调用函数createMyWin�Q�都可以得到在线�E�内部均可见的窗口变量，�q�个变量通过函数
pthread_getspecific得到。在上面的例子中�Q�我们已�l��用了函数pthread_setspecific来将�U�程数据和一个键�l�定在一赗��这两个函数的原
型如下：
　　extern int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer));
　　extern void *pthread_getspecific __P ((pthread_key_t __key));
　　�q�两个函数的参数意义和��用方法是显而易见的。要注意的是�Q�用pthread_setspecific��Z��个键指定新的�U�程数据�Ӟ��必须自己释放原有
的线�E�数据以回收�I�间。这个过�E�函数pthread_key_delete用来删除一个键�Q�这个键占用的内存将被释放，但同栯��注意的是�Q�它只释��N��?br />用的内存�Q��ƈ不释放该键关联的�U�程数据所占用的内存资源，而且它也不会触发函数pthread_key_create中定义的destructor函数。线�E�数�?br />的释攑ֿ��d��释放键之前完成�?br />4.2 互斥�?br />　　互斥锁用来保证一�D�|��间内只有一个线�E�在执行一�D�代码。必要性显而易见：假设各个�U�程向同一个文仉��序写入数据，最后得到的�l�果
一定是��N��性的�?br />　　我们先看下面一�D�代码。这是一个读/写程序，它们公用一个缓冲区�Q��ƈ且我们假定一个缓冲区只能保存一条信息。即�~�冲区只有两个状�?br />�Q�有信息或没有信息�?br />void reader_function ( void );
void writer_function ( void );
char buffer;
int buffer_has_item=0;
pthread_mutex_t mutex;
struct timespec delay;
void main ( void ){
pthread_t reader;
/* 定义延迟旉��*/
delay.tv_sec = 2;
delay.tv_nec = 0;
/* 用默认属性初始化一个互斥锁对象*/
pthread_mutex_init (&mutex,NULL);
pthread_create(&reader, pthread_attr_default, (void *)&reader_function), NULL);
writer_function( );
}
void writer_function (void){
while(1){
/* 锁定互斥�?/
pthread_mutex_lock (&mutex);
if (buffer_has_item==0){
buffer=make_new_item( );
buffer_has_item=1;
}
/* 打开互斥�?/
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
void reader_function(void){
while(1){
pthread_mutex_lock(&mutex);
if(buffer_has_item==1){
consume_item(buffer);
buffer_has_item=0;
}
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
　　�q�里声明了互斥锁变量mutex�Q�结构pthread_mutex_t��Z��公开的数据类型，其中包含一个系�l�分配的属性对象。函�?br />pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，��调用函�?br />pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函�?br />pthread_mutexattr_settype用来讄��互斥锁属性。前一个函数设�|�属性pshared�Q�它有两个取��|��
PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进�E�中的线�E�同步，后者用于同步本�q�程的不同线�E�。在上面的例子中�Q?br />我们使用的是默认属性PTHREAD_PROCESS_
PRIVATE。后者用来设�|�互斥锁�c�d��Q�可选的�c�d��有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK�?br />PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机�Ӟ��一般情况下�Q�选用最后一个默认属性�?br />　　pthread_mutex_lock声明开始用互斥锁上锁，此后的代码直臌��用pthread_mutex_unlock为止�Q�均被上锁，卛_��一旉��只能被一个线�E�调
用执行。当一个线�E�执行到pthread_mutex_lock处时�Q�如果该锁此时被另一个线�E��用，那此�U�程被阻塞，即程序将�{�待到另一个线�E�释放此
互斥锁。在上面的例子中�Q�我们��用了pthread_delay_np函数�Q�让�U�程睡眠一�D�|��_��是��Z��防止一个线�E�始�l�占据此函数�?br />　　上面的例子非常简单，��׃��再介�l�了�Q�需要提出的是在使用互斥锁的�q�程中很有可能会出现死锁�Q�两个线�E�试囑֐�时占用两个资源，�q�按
不同的次序锁定相应的互斥锁，例如两个�U�程都需要锁定互斥锁1和互斥锁2�Q�a�U�程先锁定互斥锁1�Q�b�U�程先锁定互斥锁2�Q�这时就出现了死�?br />。此时我们可以��用函�?br />pthread_mutex_trylock�Q�它是函数pthread_mutex_lock的非��d��版本�Q�当它发现死锁不可避免时�Q�它会返回相应的信息�Q�程序员可以针对死锁
做出相应的处理。另外不同的互斥锁类型对死锁的处理不一��P��但最主要的还是要�E�序员自己在�E�序设计注意�q�一炏V�?br />4.3 条�g变量
　　前一节中我们讲述了如何��用互斥锁来实现线�E�间数据的共享和通信�Q�互斥锁一个明昄��~�点是它只有两种状态：锁定和非锁定。而条�?br />变量通过允许�U�程��d��和等待另一个线�E�发送信��L��Ҏ��弥补了互斥锁的不��I��它常和互斥锁一起��用。��用时�Q�条件变量被用来��d��一个线
�E�，当条件不满��Ӟ��U�程往往解开相应的互斥锁�q�等待条件发生变化。一旦其它的某个�U�程改变了条件变量，它将通知相应的条件变量唤�?br />一个或多个正被此条件变量阻塞的�U�程。这些线�E�将重新锁定互斥锁�ƈ重新��试条�g是否满��。一般说来，条�g变量被用来进行线扉K��的同�?br />�?br />　　条�g变量的结构�ؓpthread_cond_t�Q�函数pthread_cond_init�Q�）被用来初始化一个条件变量。它的原型�ؓ�Q?br />　　extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
　　其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指针。结构pthread_condattr_t是条�?br />变量的属性结构，和互斥锁一��h��们可以用它来讄��条�g变量是进�E�内可用�q�是�q�程间可用，默认值是 PTHREAD_
PROCESS_PRIVATE�Q�即此条件变量被同一�q�程内的各个�U�程使用。注意初始化条�g变量只有未被使用时才能重新初始化或被释放。释放一个条�?br />变量的函��Cؓpthread_cond_ destroy�Q�pthread_cond_t cond�Q�。　
　　函数pthread_cond_wait�Q�）使线�E�阻塞在一个条件变量上。它的函数原型�ؓ�Q?br />　　extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
　　pthread_mutex_t *__mutex));
　　�U�程解开mutex指向的锁�q�被条�g变量cond��d��。线�E�可以被函数pthread_cond_signal和函�?br />pthread_cond_broadcast唤醒�Q�但是要注意的是�Q�条件变量只是�v��d��和唤醒线�E�的作用�Q�具体的判断条�g�q�需用户�l�出�Q�例如一个变量是�?br />�?�{�等�Q�这一�Ҏ��们从后面的例子中可以看到。线�E�被唤醒后，它将重新��查判断条件是否满��I��如果�q�不满��Q�一般说来线�E�应该仍��d��?br />�q�里�Q�被�{�待被下一�ơ唤醒。这个过�E�一般用while语句实现�?br />　　另一个用来阻塞线�E�的函数是pthread_cond_timedwait�Q�）�Q�它的原型�ؓ�Q?br />　　extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
　　pthread_mutex_t *__mutex, __const struct timespec *__abstime));
　　它比函数pthread_cond_wait�Q�）多了一个时间参敎ͼ��l�历abstime�D�|��间后�Q�即使条件变量不满��Q�阻塞也被解除�?br />　　函数pthread_cond_signal�Q�）的原型�ؓ�Q?br />　　extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
　　它用来释放被��d��在条件变量cond上的一个线�E�。多个线�E�阻塞在此条件变量上�Ӟ��哪一个线�E�被唤醒是由�U�程的调度策略所军_��的。要
注意的是�Q�必��ȝ��保护条�g变量的互斥锁来保护这个函敎ͼ�否则条�g满��信号又可能在��试条�g和调用pthread_cond_wait函数之间被发出，�?br />而造成无限制的�{�待。下面是使用函数pthread_cond_wait�Q�）和函数pthread_cond_signal�Q�）的一个简单的例子�?br />pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count　() {
pthread_mutex_lock (&count_lock);
while(count==0)
pthread_cond_wait( &count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock (&count_lock);
}
increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
　　count��gؓ0�Ӟ�� decrement函数在pthread_cond_wait处被��d��Q��ƈ打开互斥锁count_lock。此�Ӟ��当调用到函数
increment_count�Ӟ��pthread_cond_signal�Q�）函数改变条�g变量�Q�告知decrement_count�Q�）停止��d��。读者可以试着让两个线�E�分别运行这
两个函数�Q�看看会出现什么样的结果�?br />　　函数pthread_cond_broadcast�Q�pthread_cond_t
*cond�Q�用来唤醒所有被��d��在条件变量cond上的�U�程。这些线�E�被唤醒后将再次竞争相应的互斥锁�Q�所以必��d��心��用这个函数�?br />4.4 信号�?br />　　信号量本质上是一个非负的整数计数器，它被用来控制对公��p��源的讉K��。当公共资源增加�Ӟ��调用函数sem_post�Q�）增加信号量。只�?br />当信号量值大于０�Ӟ��才能使用公共资源�Q��用后�Q�函数sem_wait�Q�）减少信号量。函数sem_trywait�Q�）和函数pthread_
mutex_trylock�Q�）起同��L��作用�Q�它是函数sem_wait�Q�）的非��d��版本。下面我们逐个介绍和信号量有关的一些函敎ͼ�它们都在头文�?br />/usr/include/semaphore.h中定义�?br />　　信号量的数据�c�d��为结构sem_t�Q�它本质上是一个长整型的数。函数sem_init�Q�）用来初始化一个信号量。它的原型�ؓ�Q?br />　　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
　　sem为指向信号量�l�构的一个指针；pshared不�ؓ�Q�时此信号量在进�E�间�׃�n�Q�否则只能�ؓ当前�q�程的所有线�E�共享；value�l�出了信号量�?br />初始倹{�?br />　　函数sem_post( sem_t *sem
)用来增加信号量的倹{��当有线�E�阻塞在�q�个信号量上�Ӟ��调用�q�个函数会��其中的一个线�E�不在阻塞，选择机制同样是由�U�程的调度策略决�?br />的�?br />　　函数sem_wait( sem_t *sem
)被用来阻塞当前线�E�直��C��号量sem的值大�?�Q�解除阻塞后��sem的值减一�Q�表明公��p��源经使用后减��。函数sem_trywait ( sem_t *sem
)是函数sem_wait�Q�）的非��d��版本�Q�它直接��信号量sem的值减一�?br />　　函数sem_destroy(sem_t *sem)用来释放信号量sem�?br />　　下面我们来看一个��用信号量的例子。在�q�个例子中，一共有4个线�E�，其中两个�U�程负责从文件读取数据到公共的缓冲区�Q�另两个�U�程�?br />�~�冲��取数据作不同的处理（加和乘运��）�?br />/* File sem.c */
#include
#include
#include
#define MAXSTACK 100
int stack[MAXSTACK][2];
int size=0;
sem_t sem;
/* 从文�?.dat��d��数据�Q�每��M��ơ，信号量加一*/
void ReadData1(void){
FILE *fp=fopen("1.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*从文�?.dat��d��数据*/
void ReadData2(void){
FILE *fp=fopen("2.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*��d��{�待�~�冲区有数据�Q�读取数据后�Q�释攄��_��l�箋�{�待*/
void HandleData1(void){
while(1){
sem_wait(&sem);
printf("Plus:%d+%d=%dn",stack[size][0],stack[size][1],
stack[size][0]+stack[size][1]);
--size;
}
}
void HandleData2(void){
while(1){
sem_wait(&sem);
printf("Multiply:%d*%d=%dn",stack[size][0],stack[size][1],
stack[size][0]*stack[size][1]);
--size;
}
}
int main(void){
pthread_t t1,t2,t3,t4;
sem_init(&sem,0,0);
pthread_create(&t1,NULL,(void *)HandleData1,NULL);
pthread_create(&t2,NULL,(void *)HandleData2,NULL);
pthread_create(&t3,NULL,(void *)ReadData1,NULL);
pthread_create(&t4,NULL,(void *)ReadData2,NULL);
/* 防止�E�序�q�早退出，让它在此无限期等�?/
pthread_join(t1,NULL);
}
　　在Linux下，我们用命令gcc -lpthread sem.c -o sem生成可执行文件sem�?br />我们事先�~�辑好数据文�?.dat�?.dat�Q�假讑֮�们的内容分别�? 2 3 4 5 6 7 8 9 10�?-1 -2 -3 -4 -5 -6 -7 -8 -9 -10
�Q�我们运行sem�Q�得到如下的�l�果�Q?br />Multiply:-1*-2=2
Plus:-1+-2=-3
Multiply:9*10=90
Plus:-9+-10=-19
Multiply:-7*-8=56
Plus:-5+-6=-11
Multiply:-3*-4=12
Plus:9+10=19
Plus:7+8=15
Plus:5+6=11
　　从中我们可以看出各个�U�程间的竞争关系。而数值�ƈ未按我们原先的顺序显�C�出来这是由于size�q�个数��D��各个�U�程��L��修改的缘故。这
也往往是多�U�程�~�程要注意的问题�?br />5 ��结
　　多线�E�编�E�是一个很有意思也很有用的技术，使用多线�E�技术的�|�络蚂蚁是目前最常用的下载工具之一�Q��用多�U�程技术的grep比单�U�程
的grep要快上几倍，�c�M��的例子还有很多。希望大家能用多�U�程技术写出高效实用的好程序来�?br />本文��:http://www.china-pub.com 作�? 姚��?(2001-08-11 09:05:00)

allic 2009-02-25 14:53 发表评论

BT�U�子文�g格式

allic — Thu, 20 Nov 2008 06:08:00 GMT

BT�U�子文�g使用了一�U�叫bencoding的编码方法来保存数据�?br />bencoding现有四种�c�d��的数据：srings(字符�?�Q�integers(整数)�Q�lists(列表)�Q�dictionaries(字典)
�~�码规则如下�Q?br />strings(字符�?�~�码为：<字符串长�?gt;�Q?lt;字符�?gt;
例如�Q��?:test 表示为字�W�串"test"
4:例子表示为字�W�串“例子�?br />字符串长度单位�ؓ字节
没开始或�l�束标记

integers(整数)�~�码为：i<整数>e
开始标记i�Q�结束标��Cؓe
例如�Q� i1234e 表示为整�?234
i-1234e 表示为整�?1234
整数没有大小限制
i0e 表示为整�?
i-0e 为非�?br />�?开头的为非法如�Q?i01234e 为非�?/p>

lists(列表)�~�码为：le
开始标��Cؓl,�l�束标记为e
列表里可以包含�Q何bencoding�~�码�c�d��Q�包括整敎ͼ�字符�Ԍ��列表�Q�字典�?br />例如�Q� l4:test5abcdee 表示��Z��个字�W�串["test","abcde"]

dictionaries(字典)�~�码为de
开始标��Cؓd,�l�束标记为e
关键字必��Mؓbencoding字符�?br />值可以�ؓ��M��bencoding�~�码�c�d��
例如�Q� d3:agei20ee 表示为{"age"=20}
d4:path3:C:\8:filename8:test.txte 表示为{"path"="C:\","filename"="test.txt"}

具体文�g�l�构如下�Q?br />全部内容必须都�ؓbencoding�~�码�c�d��?br />整个文�g��Z��个字典结�?包含如下关键�?br />announce:tracker服务器的URL(字符�?
announce-list(可�?:备用tracker服务器列�?列表)
creation date(可�?:�U�子创徏的时��_��Unix标准旉��格式�Q�从1970 1�?�?00:00:00到创建时间的�U�数(整数)
comment(可�?:备注(字符�?
created by(可�?:创徏人或创徏�E�序的信�?字符�?
info:一个字典结构，包含文�g的主要信息，为分二种情况�Q�单文�g�l�构或多文�g�l�构
单文件结构如下：
          length:文�g长度�Q�单位字�?整数)
          md5sum(可�?�Q�长32个字�W�的文�g的MD5校验和，BT不��用这个��|��只是��Z��兼容一些程序所保留!(字符�?
          name:文�g�?字符�?
          piece length:每个块的大小�Q�单位字�?整数)
          pieces:每个块的20个字节的SHA1 Hash的�?二进制格�?
多文件结构如下：
          files:一个字典结�?br />                 length:文�g长度�Q�单位字�?整数)
                 md5sum(可�?:同单文�g�l�构中相�?br />                 path:文�g的�\径和名字�Q�是一个列表结构，如\test\test.txt 列表为l4:test8test.txte
          name:最上层的目录名�?字符�?
          piece length:同单文�g�l�构中相�?br />          pieces:同单文�g�l�构中相同�?br />实例�Q?br />用记事本打开一�?torrent可以看来�c�M��如下内容
d8:announce35:http://www.manfen.net:7802/announce13:creation datei1076675108e4:infod6:lengthi17799e4:name62:MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent12:piece lengthi32768e6:pieces20:?W �?�w?�R�排T酆ee

很容易看�?br />announce�Q?a >http://www.manfen.net:7802/announce
creation date�Q?076675108�U?02/13/04 20:25:08)
文�g�?MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent
文�g大小�Q?7799字节
文�g块大��＝32768字节

allic 2008-11-20 14:08 发表评论

函数指针作�ؓ�l�构体成员，实现函数注册

allic — Sat, 11 Oct 2008 02:24:00 GMT

有时我们需要将函数作�ؓ�l�构体的成员�Q�模拟C++�cȝ��情�Ş�Q�可应用于方法注册�?br />#include

struct a
{
void (*func)(char *);
};

void hello(char *name)
{
printf ("hello %s\n",name);
}

int main()
{
    struct a a1;
    a1.func = hello;
    a1.func("illusion");
    system("PAUSE");
    return 0;
}

allic 2008-10-11 10:24 发表评论

allic — Sat, 10 May 2008 08:21:00 GMT

在sqlite.org 上下载得到Windows版本的sqlite,它是以sqlitedll.zip文�g提供�?其中有sqlite3.def�?sqlite3.dll文�g,当然可以直接通过LoadLibrary�{�WIN32API来操作dll,查找其中包含的函�?�q��用这些函�?但是一般都不这么做,原因很简�?�q�样太麻�?所以一般先使用LIB命��o生成用于链接的lib,然后把sqlite头文件sqlite3.h包含�q�程序中,
�q�样直接调用 sqlite的API��方便多�?当然sqlite3.h文�g得从sqlite源代码（以sqlite-source-3_3_4.zip文�g提供�Q�中搞到,在源码中sqlite3.h�q�个头文件是sqlite3.h.in存在的，解压出来�Ҏ��sqlite.h��可以了.
使用VC++的LIB命��o有以下步骤：
�Q?�Q�设�|�VC98中LIB.exe所在的路径�Q?
D:\MyDoc\db\capi>set path=%path%;"D:\Program Files\Microsoft Visual Studio\VC98\Bin"
(2)生成SQLite的lib文�g�Q?
D:\MyDoc\db\capi>LIB /DEF:SQLITE3.DEF /MACHINE:IX86

Microsoft (R) Library Manager Version 6.00.8168 Copyright (C) Microsoft Corp 1992-1998. All rights reserved. Creating library SQLITE.lib and object SQLITE.exp
�q�样��成功地创徏了在WIN32�E�序中访问sqlite所需要的�?可以用于链接WIN32�E�序.
到此所有��用sqlite的准备工作已告罄.现在在MSVC6中新��Z��个Win32 Console Application工程,把sqlite.dll,sqlite.h和sqlite.lib文�g复制到工�E�文件夹�?把sqlite.h文�g加入到项目中,然后在Project Setting的Link中的对象库模块中增加sqlite.lib文�g. 或者project->add to project->files�Q�选择�q�个lib文�g
然后修改加入如下代码卛_��:

#include
#include
#include
#include
#include "sqlite3.h"

using namespace std;

sqlite3* pDB;

int createTable()
{
char* errMsg;
std::string dropTab="drop table test_tab;";
string strSQL= "create table test_tab (f1 int, f2 long, f3 varchar(20));";
int res = sqlite3_exec(pDB,dropTab.c_str(),0,0, &errMsg);
if (res != SQLITE_OK)
{
std::cout << "执行SQL 出错." << errMsg << std::endl;
//return -1;
}

res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

if (res != SQLITE_OK)
{
    std::cout << "执行创徏table的SQL 出错." << errMsg << std::endl;
    return -1;
}
else
{
      std::cout << "创徏table的SQL成功执行."<< std::endl;
}

return 0;
}

int insert1()
{
char* errMsg;

int res = sqlite3_exec(pDB,"begin transaction;",0,0, &errMsg);

for (int i= 1; i < 100; ++i)
{
    std::stringstream strsql;
    strsql << "insert into test_tab values(";
    strsql << i << ","<< (i+10) <<",'huyi'"<< ");";
    std::string str = strsql.str();
    cout << str <    res = sqlite3_exec(pDB,str.c_str(),0,0, &errMsg);
    if (res != SQLITE_OK)
    {
      std::cout << "执行SQL 出错." << errMsg << std::endl;
      return -1;
    }
}
res = sqlite3_exec(pDB,"commit transaction;",0,0, &errMsg);
std::cout << "SQL成功执行."<< std::endl;
return 0;
}

int select1()
{
char* errMsg;
int nrow = 0, ncolumn = 0;
char **azResult; //二维数组存放�l�果
string strSQL= "select * from test_tab;";
/*
int res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

if (res != SQLITE_OK)
{
    std::cout << "执行SQL 出错." << errMsg << std::endl;
    return -1;
}
else
{
       std::cout << "SQL成功执行."<< std::endl;
}
*/
sqlite3_get_table(pDB, strSQL.c_str(), &azResult, &nrow, &ncolumn, &errMsg);
     int i = 0;
for( i=0 ; i<( nrow + 1 ) * ncolumn ; i++ )
{
   if (i>0 && i%ncolumn==0)
    printf("\n");
      printf( "%s ",azResult[i]);
}
         printf("\n");
//释放�?azResult 的内存空�?br /> sqlite3_free_table( azResult );
sqlite3_close(pDB); //关闭数据�?br /> return 0;
}

int main(int argc, char* argv[])
{
if (argc < 2)
{
std::cout << "误��入命令行参数�Q�sqlite数据库名." << std::endl;
return 0;
}

int res = sqlite3_open(argv[1], &pDB);

if( res ){
    std::cout << "Can't open database: "<< sqlite3_errmsg(pDB);
    sqlite3_close(pDB);
    return -1;
}
res = createTable();
if (res != 0)
{
      return 0;
}
res = insert1();
if (res != 0)
{
      return 0;
}
select1();
   return 0;
}

allic 2008-05-10 16:21 发表评论

allic — Thu, 10 Apr 2008 15:39:00 GMT

int prime(int m)
{
   int i,k;
   k=sqrt(m);
   for(i = 2; i < k; i++)
   if(m % i == 0)
      return 0;
return 1;
}

allic 2008-04-10 23:39 发表评论

��Z��C语言的内存池设计与实现[转]

allic — Thu, 10 Apr 2008 15:26:00 GMT

介绍�Q?/p>

设计内存池的目标是�ؓ了保证服务器长时间高效的�q�行�Q�通过对申��L��间小而申请频�J�的对象�q�行有效��理�Q�减��内存碎片的产生�Q�合理分配管理用户内存，从而减��系�l�中出现有效�I�间��_��Q�而无法分配大块连�l�内存的情况�?/p>

目标�Q?/p>

此次设计内存池的基本目标�Q�需要满��线�E�安全性（多线�E�）�Q�适量的内存泄露越界检查，�q�行效率不太低于malloc/free方式�Q�实现对4-128字节范围内的内存�I�间甌��的内存池��理�Q�非单一固定大小对象��理的内存池�Q��?/p>

内存池技术设计与实现

本内存池的设计方法主要参考SGI的alloc的设计方案，��Z��适合一般的应用�Q��ƈ在alloc的基��上做一些简单的修改�?/p>

Mempool的内存池设计�Ҏ��如下�Q�也可参考候捷《深入剖析STL》）

从系�l�申请大块heap内存�Q�在此内存上划分不同大小的区块，�q�把��h��相同大小的区块连接�v来，�l�成一个链表。比如A大小的块�Q�组成链表L�Q�当甌��A大小�Ӟ��直接从链表L头部�Q�如果不为空�Q�上取到一块交�l�申误��，当释放A大小的块�Ӟ��直接挂接到L的头部。内存池的原理比较简单，但是在具体实现过�E�中大量的细节需要注意�?/p>

1�Q�字节对齐�?/p>

��Z��方便内存池中对象的管理，需要对甌��内存�I�间的进行调��_��在Mempool中，字节寚w��的大��ؓ最接近8倍数的字节数。比如，用户甌��5个字节，Mempool首先会把它调整�ؓ8字节。比如申�?2字节�Q�会调整�?4�Q�对比关�p�d��?/p>

序号	寚w��字节	范围
0	8	1-8
1	16	9-16
2	24	17-24
3	32	25-32
4	40	33-40
5	48	41-48
6	56	49-56
7	64	57-64
8	72	65-72
9	80	73-80
10	88	81-88
11	96	89-96
12	104	97-104
13	112	105-112
14	120	113-120
15	128	121-128

�Q�图1�Q?/p>

对于��过128字节的申��P��直接调用malloc函数甌��内存�I�间。这里设计的内存池�ƈ不是�Ҏ��有的对象�q�行内存��理�Q�只是对甌��内存�I�间��，而申请频�J�的对象�q�行��理�Q�对于超�q?28字节的对象申��P��不予考虑。这个需要与实际��目�l�合�Q��ƈ不是固定不变的。实现对齐操作的函数如下

static size_t round_up(size_t size)
{
return (((size)+7) &~ 7);// �?字节寚w��
}

2�Q�构建烦引表

内存池中��理的对象都是固定大��，现在要管�?-128字节的范围内的对象申��L��_��除了采用上面提到的字节对齐外�Q�还需要变通一下，�q�就是徏立烦引表�Q�做法如下；
static _obj* free_list[16];
创徏一个包�?6个_obj*指针的数�l�，关于_obj�l�构后面详细讲解。free_list[0]记录所有空闲空间�ؓ8字节的链表的首地址�Q�free_list[1]对应16字节的链表，free_list[2]对应24字节的列表。free_list中的下标和字节链表对应关�p�d��考图1中的“序号”和“对齐字节”之间的关系。这�U�关�p�，我们很容易用��法计算出来。如�?/p>

static size_t freelist_index(size_t size)
{
return (((size)+7)/7-1);// �?字节寚w��
}

所以，�q�样当用��L��L��间A�Ӟ��我们只是通过上面��单的转换�Q�就可以跌��{到包含A字节大小的空闲链表上,如下�Q?br />_obj** p = free_list[freelist_index(A)];

3:构徏�I�闲链表

通过索引表，我们知道mempool中维持着16条空闲链表，�q�些�I�闲链表中管理的�I�闲对象大小分别�?�Q?6�Q?4�Q?2�Q?0�?28。这些空闲链表链接�v来的方式完全相同。一般情况下我们构徏单链表时需要创建如下的一个结构体�?/p>

struct Obj
{
    Obj *next;
    Char* p;
    Int iSize;
}

next指针指向下一个这��L��l�构�Q�p指向真正可用�I�间,iSize用于只是可用�I�间的大��，在其他的一些内存池实现中，�q�有更复杂的�l�构体，比如�q�包括记录此�l�构体的上��l�构体的指针�Q�结构体中当前��用空间的变量�{�，当用��L��L��间时�Q�把此结构体��d��的用��L��L��间中去，比如用户甌��12字节的空��_��可以�q�样�?/p>

Obj *p = (Obj*)malloc(12+sizeof(Obj));
p->next = NULL;
p->p = (char*)p+sizeof(Obj);
p->iSize = 12;

但是�Q�我们�ƈ没有采用�q�种方式�Q�这�U�方式的一个缺点就是，用户甌��空间时�Q�内存池加料太多了。比如用��L��?2字节�Ӟ��而真实情冉|��内存池向内存甌��?2+ sizeof(Obj)=12+12=24字节的内存空��_��q�样��费大量内存用在标记内存�I�间上去�Q��ƈ且也没有体现索引表的优势。Mempool采用的是union方式

union Obj
{
Obj *next;
char client_data[1];
}

�q�里除了把上面的struct修改为union�Q��ƈ把int iSize��L��Q�同时把char*p�Q�修改�ؓchar client_data[1]�Q��ƈ没有做太多的修改。而优势也恰恰体现在这里。如果采用struct方式�Q�我们需要维护两条链表，一条链表是�Q�已分配内存�I�间链表�Q�另一条是未分配（�I�闲�Q�空间链表。而我们��用烦引表和union�l�构体，只需要维护一条链表，��x��分配�I�间链表。具体如�?/p>

索引表的作用有两�?�Q�如上所��_��l�护16条空闲链�?�Q�变相记录每条链表上�I�间的大��，比如下标�?的烦引表内维持着是大��ؓ24字节的空闲链表。这��h��们通过索引表减��在�l�构体内记录p所指向�I�间大小的iSize变量。从而减��?个字节�?/p>

Union的特性是�Q�结构内的变量是互斥存在的。再�q�行状态下�Q�只是存在一�U�变量类型。所以在�q�里sizeof(Obj)的大��ؓ4�Q�难道这里我们也需要把�q?字节也加到用��L��L��间中��d��Q�其实不是，如果�q�样�Q�我们又�Ҏ��了union的特性�?/p>

当我们构建空闲分配链表时�Q�我们通过next指向下一个union�l�构体，�q�样我们不��用p指针。当把这个结构体分配出去�Ӟ��我们直接�q�回client_data的地址�Q�此时client_data正好指向甌��I�间的首字节。所以这��P��我们��׃��用在用户甌��I�间上添加�Q何东�ѝ�?/p>

�?

Obj的连接方式如上所�C�，�q�样我们无需为用��L��L��间添加�Q何内宏V�� ?/p>

4�Q�记录申��L��间字节数

如果采用面向对象方式�Q�或者我们在释放内存池的�I�间时能够明��知道释攄��间的大小�Q�无需采用�q�种方式�?/p>

�?

在C语言中的free没有传递释攄��间大��，而可以正��释放，在这里也是模仿这�U�方式，采用�q�种记录甌��I�间大小的方式去释放内存。用��L��L��?1操作��在字节寚w��之前执行�Q�找到合适空间后�Q�把首字节改写�ؓ甌��I�间的大��，当然1个字节最多纪�?56个数�Q�如果项目需要，可以讄��为short�c�d��或者int�c�d��Q�不�q�这样就需要占用用��h��较大的空间。当释放内存�I�间�Ӟ��首先��d��q�个字节�Q�获取空间大��，�q�行释放。�ؓ了便于对大于128字节对象的大��进行合适的释放�Q�同时也对大�?28字节的内存申��P��d��1字节记录大小。所以现在这里限制了用户内存甌��I�间不得大于255字节�Q�不�q�现在已�l�满��项目要求。当然也可以修改为用short�c�d��记录甌��I�间的大��?/p>

    // 甌��
    *(( unsigned char *)result) = (size_t)n;
    unsigned char * pTemp = (unsigned char*)result;
    ++pTemp;
    result = (_obj*)pTemp;
    return result;

    // 释放
    unsigned char * pTemp = (unsigned char *)ptr;
    --pTemp;
    ptr = (void*)pTemp;
    n = (size_t)(*( unsigned char *)ptr);

5�Q�内存池的分配原�?/p>

在内存池的设计中�Q�有两个重要的操作过�E?�Q�chunk_alloc�Q�申请大块内存，2�Q�refill回填操作�Q�内存池初始化化时�ƈ不是为烦引表中的每一��w��创徏�I�闲分配链表�Q�这个过�E�会推迟刎ͼ�只有用户提取��h��时才会创��L��分配链表。详�l�参考如下代码（在sgi中stl_alloc.h文�g中你也可以看到这两个函数�Q�，主要步骤在注释中已经说明�?/p>

/**
* @bri: 甌��大块内存�Q��ƈ�q�回size*(*nobjs)大小的内存块
* @param: size,round_up寚w��后的大小,nobjs
* @return: �q�回指向�W�一个对象内存指�?br />*/
static char* chunk_alloc(size_t size, int *nobjs)
{
     /**< �q�回指针 */
     char* __result;
     /**< 甌��内存块大��?*/
     size_t __total_bytes = size *(*nobjs);
     /**< 当前内存可用�I�间 */
     size_t __bytes_left = _end_free - _start_free;

     /**< 内存池中�q�有大片可用内存 */
     if (__bytes_left >= __total_bytes)
     {
         __result = _start_free;
         _start_free += __total_bytes;
         return (__result);
     }
     /**< 臛_��q�有一个对象大��的内存�I�间 */
     else if (__bytes_left >= size)
     {
         *nobjs = (int)(__bytes_left/size);
         __total_bytes = size * (*nobjs);
         __result = _start_free;
         _start_free += __total_bytes;
         return (__result);
     }
     /**< 内存池中没有��M��I�间 */
     else
     {
         /**< 重新甌��内存池的大小 */
         size_t __bytes_to_get = 2 * __total_bytes + round_up(_heap_size >> 4);
         /**< 把内存中剩余的空间添加到freelist�?*/
         if(__bytes_left > 0)
         {
              _obj *VOLATILE* __my_free_list =
                   _free_list + freelist_index(__bytes_left);
              ((_obj*)_start_free)->free_list_link =
*__my_free_list;
              *__my_free_list = (_obj*)_start_free;
         }
         // 甌��新的大块�I�间
         _start_free = (char*)malloc(__bytes_to_get);
         /*=======================================================================*/
         memset(_start_free,0,__bytes_to_get);
         /*=======================================================================*/
         // �pȝ��内存已经无可用内存，那么从内存池中压�~�内�?br />         if(0 == _start_free)
         {
              size_t __i;
              _obj *VOLATILE* __my_free_list;
              _obj *__p;
              /**< 从freelist中逐项��查可用空�?此时只收集比size对象大的内存�I�间) */
              for (__i = size; __i <= (size_t)__MAX_BYTES; __i += __ALIGN)
              {
                   __my_free_list = _free_list + freelist_index(__i);
                   __p = *__my_free_list;
                   /**< 扑ֈ��I�闲�?*/
                   if (__p != 0)
                   {
                       *__my_free_list = __p->free_list_link;
                       _start_free = (char*)__p;
                       _end_free = _start_free + __i;
                       return (chunk_alloc(size,nobjs));
                   }
              }
              _end_free = 0;
              /**< 再次甌��内存�Q�可能触发一个异�?*/
              _start_free = (char*)malloc(__bytes_to_get);
         }
         /**< 记录当前内存池的定w�� */
         _heap_size += __bytes_to_get;
         _end_free = _start_free + __bytes_to_get;
         return (chunk_alloc(size,nobjs));
     }
}

/*=======================================================================*/
/**
* @bri: 填充freelist的连接，默认填充20�?br /> * @param: __n�Q�填充对象的大小�Q?字节寚w��后的value
* @return: �I�闲
*/
static void* refill(size_t n)
{
     int __nobjs = 20;
     char* __chunk = (char*)chunk_alloc(n, &__nobjs);
     _obj *VOLATILE* __my_free_list;
     _obj *VOLATILE* __my_free_list1;
     _obj * __result;
     _obj * __current_obj;
     _obj * __next_obj;
     int __i;
     // 如果内存池中仅有一个对�?br />     if (1 == __nobjs)
         return(__chunk);
     __my_free_list = _free_list + freelist_index(n);
     /* Build free list in chunk */
     __result = (_obj*)__chunk;
     *__my_free_list = __next_obj = (_obj*)(__chunk + n);
     __my_free_list1 = _free_list + freelist_index(n);
     for (__i = 1;; ++__i)
     {
         __current_obj = __next_obj;
         __next_obj = (_obj*)((char*)__next_obj+n);
         if(__nobjs - 1 == __i)
         {
              __current_obj->free_list_link = 0;
              break;
         }else{
              __current_obj->free_list_link = __next_obj;
         }
     }
     return(__result);
}

�l�过上面操作后，内存池可能会成�ؓ如下的一�U�状态。从图上我们可以看到�Q�已�l�构��Z��8�Q?4�Q?8�Q?28字节的空闲分配链表，而其他没有分配空闲分配链表的他们的指针都指向NULL。我们通过判断索引表中的指针是否�ؓNULL�Q�知道是否已�l�构建空闲分配表或者空闲分配表是否用完�Q�如果此处指针�ؓNULL�Q�我们调用refill函数�Q�重新申�?0个这样大��的内存�I�间�Q��ƈ把他们连接�v来。在refill函数内，我们要查看大内存中是否有可用内存�Q�如果有�Q��ƈ且大��合适，��p��回给refill函数�?br />

�?

6�Q�线�E�安�?br /> 采用互斥体，保证�U�程安全�?br />
内存池测�?/p>

内存池的��试主要分两部分��试1�Q�单�U�程下malloc与mempool的分配速度�Ҏ��2�Q�多�U�程下malloc和mempool的分配速度�Ҏ��Q�我们分�?�Q?0�Q?6个线�E�进行测试了�?br /> ��试环境�Q�操作系�l�：windows2003+sp1�Q�VC7.1+sp1�Q�硬件环境：intel(R) Celeron(R) CPU 2.53GHz,512M物理内存�?br />
甌��内存�I�间讑֮�如下
#define ALLOCNUMBER0 4
#define ALLOCNUMBER1 7
#define ALLOCNUMBER2 23
#define ALLOCNUMBER3 56
#define ALLOCNUMBER4 10
#define ALLOCNUMBER5 60
#define ALLOCNUMBER6 5
#define ALLOCNUMBER7 80
#define ALLOCNUMBER8 9
#define ALLOCNUMBER9 100

Malloc方式和mempool方式均��用如上数据进行内存空间的甌��和释放。申误��E�，每次循环甌��释放上述数据20��?br /> 我们对malloc和mempool�Q�分别进行了如下甌��ơ数的测试（单位��Z��Q?/p>

100

150

200

malloc和mempool在单�U�程�Q�多�U�程�Q�release�Q�debug版的各种��试数据�Q��Ş成如下的�l�计�?

�?

可以看到mempool无论在多�U�程�q�是在单�U�程情况下，mempool的速度都优于malloc方式的直接分配�?/p>

Malloc方式debug模式下，在不同的�U�程下，�q�行旉��如下�Q�通过囄��可知�Q�malloc方式�Q�在debug模式下，甌��I�间的速度和多�U�程的关�p�M��大。多�U�程方式�Q�要略快于单�U�程的运行实现�?/p>

�?

Malloc方式release模式��试�l�果如下�?/p>

�?

多线�E�的优势�Q�逐渐体现出来。当执行200w�ơ申请和释放�Ӟ��多线�E�要比单�U�程�?500ms左右�Q��?�Q?0�Q?6个线�E�之间的差别�q�不是特别大。不�q�整体感�?个线�E�的�q�行旉��要稍微高�?0�Q?6个线�E�的情况下，意味着�q�程中线�E�越多用在线�E�切换上的时间就��多�?/p>

下面是mempool在debug��试�l�果

�?

下面是mempool在release模式下的��试�l�果

�?

以上所有统计图中所用到的数据，是我们测试三�ơ后�q�_��倹{�?/p>

通过上面的测试，可以知道mempool的性能基本上超�q�直接malloc方式�Q�在200w�ơ申请和释放的情况下�Q�单�U�程release版情况下�Q�mempool比直接malloc�?10倍。而在4个线�E�情况下�Q�mempool要比直接malloc�?倍左叟뀂以上测试只是申请速度的测试，在不同的压力情况下，��试�l�果可能会不同，��试�l�果也不能说明mempool方式比malloc方式�E�_��?br />
��结�Q�内存池基本上满��_��期设计目标，但是她�ƈ不是完美的，有缺��P��比如,不能甌��大于256字节的内存空��_��无内存越界检查，无内存自动回�~�功能等。只是这些对我们的媄响还不是那么重要�?/p>

�׃��q�是一个公叔R��目，代码涉及版权�Q�所以不能发布出来。如果你惛_��自己的内存池�Q�可以与我联�p�ugg_xchj#hotmail.com.

allic 2008-04-10 23:26 发表评论

[�ȝ��]软�g工程师笔试题目（C++�Q?

allic — Sun, 06 Apr 2008 11:02:00 GMT

摘要: 发布之前先申明两点： 1 所有资料来自网�l?主要是CSDN)�Q�本人只是收集和转发。 �?2 所有问题解�{?��其是代�?只是参考，不保证正��? 先发基本问题�Q�再发编�E�问�?.........4. static有什么用途？�Q�请臛_��说明两种�Q?.限制变量的作用域2.讄��变量的存储域7. 引用与指针有什么区别？1) 引用必须被初始化�Q�指针不必�?) 引用初始化以后不能被改变�Q�指�?.. 阅读全文

allic 2008-04-06 19:02 发表评论

allic — Sat, 29 Mar 2008 05:30:00 GMT

有volatie修饰的变量，每次操作旉��循下面动作：
从内存取值�?--> 攑օ�寄存器�?---> 操作 ---->写回内存
没有volatie修饰的变量，操作可能遵��@�Q�可能就是不是所有情况都如此�Q�：
从内存取值�?--> 攑օ�寄存器�?---> �W�一�ơ操作�?----> �W�二�ơ操作（此时仍操作寄存器中的��|�� ……�?--->�W�N�ơ操作�?--->写回内存

volatile变量的修改要求即时被所有cpu可见�Q�所以会要求cache一致性。对一些weak memory model的cpu�Q�还有对memory access order的限制�?br />

allic 2008-03-29 13:30 发表评论

allic — Sun, 23 Mar 2008 02:02:00 GMT

二维数组的传�?br />二��数组传递参数时�Q�不能以一个二�U�指针的方式�Q�以二��指针的方式只传递了�q�个二��数组的首地址�Q�但没有带出�q�个二维数组各元素的地址�Q�编译器不能通过二��指针的移动寻扑օ�元素。对于二�U�数�l�要用数�l�指针的形式传参

#include
void print_arr (char (*a)[4])
{
    int i;
    for(i = 0; i < 3; i++)
    printf("%s\n", a[i]);
}

int main()
{
    char *str_arr[3][4] = {"yes", "no", "uncertain"};
    print_arr (str_arr);
    return 0;
}

如果要以二��指针的�Ş式传参，可以在定义�ؓ字符串指针数�l�的形式
char *str_arr[] = {"yes", "no", "uncertain"};
void print_arr (char **a)
{
    int i;
    for (i=0; i<3;i++)
    printf("%s\n", *(a+1));
}

allic 2008-03-23 10:02 发表评论

�|�络套接字结构体

allic — Fri, 21 Mar 2008 11:13:00 GMT

netdb.h:

/* Description of data base entry for a single host. */
struct hostent
{
char *h_name; /* Official name of host. */
char **h_aliases; /* Alias list. */
int h_addrtype; /* Host address type. */
int h_length; /* Length of address. */
char **h_addr_list; /* List of addresses from name server. */
#define h_addr h_addr_list[0] /* Address, for backward compatibility. */
};

struct sockaddr{
        unisgned short  as_family;
        char          sa_data[14];
};

struct sockaddr_in{
        unsigned short       sin_family;
         unsigned short int    sin_port;
         struct in_addr       sin_addr;
         unsigned char          sin_zero[8];
}

typedef uint32_t in_addr_t;
struct in_addr
{
in_addr_t s_addr;
};

allic 2008-03-21 19:13 发表评论

探讨C语言中的回调函数

allic — Sat, 16 Feb 2008 04:00:00 GMT

回调函数是一个程序员不能昑ּ�调用的函敎ͼ�通过��回调函数的地址传给
调用者从而实现调用。回调函��C��用是必要的，在我们想通过一个统一接口实现�?
同的内容�Q�这时用回掉函数非常合适。比如，我们为几个不同的讑֤�分别写了不同
的显�C�函敎ͼ�void TVshow(); void ComputerShow(); void NoteBookShow()...�{?
�{�。这是我们想用一个统一的显�C�函敎ͼ�我们�q�时��可以用回掉函数了。void sho
w(void (*ptr)()); 使用时根据所传入的参��C��同而调用不同的回调函数�?
      不同的编�E�语�a�可能有不同的语法�Q�下面�D一个c语言中回调函数的例子�Q?
其中一个回调函��C��带参敎ͼ�另一个回调函数带参数�?
      例子1�Q?
//Test.c
#include
#include
int Test1()
{
  int i;
  for (i=0; i<30; i++)
  {
    printf("The %d th charactor is: %c\n", i, (char)('a' + i%26));

  }
  return 0;
}
int Test2(int num)
{
  int i;
  for (i=0; i  {
   printf("The %d th charactor is: %c\n", i, (char)('a' + i%26));

  }
  return 0;
}
void Caller1(void (*ptr)())//指向函数的指针作函数参数
{
  (*ptr)();
}
void Caller2(int n, int (*ptr)())//指向函数的指针作函数参数,�q�里�W�一个参数是为指向函数的指针服务的，
{                                               //不能写成void Caller2(int (*ptr)(int n))�Q�这��L��定义语法错误�?
  (*ptr)(n);
  return;
}
int main()
{
  printf("************************\n");
  Caller1(Test1); //相当于调用Test2();
  printf("&&&&&&************************\n");
  Caller2(30, Test2); //相当于调用Test2(30);
  return 0;
}
      以上通过��回调函数的地址传给调用者从而实现调用，但是需要注意的是带
参回调函数的用法。要实现回调�Q�必��首先定义函数指针。函数指针的定义�q�里�E?
微提一下。比如：
    int (*ptr)(); �q�里ptr是一个函数指针，其中(*ptr)的括号不能省略，因�ؓ
括号的优先��高于星号�Q�那样就成了一个返回类型�ؓ整型的函数声明了

allic 2008-02-16 12:00 发表评论

realloc,malloc,calloc的区别及free(zz)

allic — Fri, 15 Feb 2008 14:01:00 GMT

三个函数的申明分别是:
void* realloc(void* ptr, unsigned newsize);
void* malloc(unsigned size);
void* calloc(size_t nelem, size_t elsize);
都在stdlib.h函数库内

它们的返回值都是请求系�l�分配的地址,如果��h��p�|��p��回NULL

malloc用于甌��一�D�|��的地址,参数size为需要内存空间的长度,�?
char* p;
p=(char*)malloc(20);

calloc�?span style="FONT-WEIGHT: bold">malloc�怼�,参数nelem为申请地址的单位元素长�?elsize为元素个�?�?
char* p;
p=(char*)calloc(sizeof(char),20);
�q�个例子与上一个效果相�?br />
realloc是给一个已�l�分配了地址的指针重新分配空�?参数ptr为原有的�I�间地址,newsize是重新申��L��地址长度
�?
char* p;
p=(char*)malloc(sizeof(char)*20);
p=(char*)realloc(p,sizeof(char)*40);

注意�Q�这里的�I�间长度都是以字节�ؓ单位�?br />

C语言的标准内存分配函敎ͼ�malloc�Q?a name="1">calloc�Q�realloc�Q�free�{��?br />malloc�?span style="FONT-WEIGHT: bold">calloc的区别�ؓ1块与n块的区别�Q?br />malloc调用形式�?�c�d��*)malloc(size)�Q�在内存的动态存储区中分配一块长度�ؓ“size”字节的�q�箋区域�Q�返回该区域的首地址�?br />calloc调用形式�?�c�d��*)calloc(n�Q�size)�Q�在内存的动态存储区中分配n块长度�ؓ“size”字节的�q�箋区域�Q�返回首地址�?br />realloc调用形式�?�c�d��*)realloc(*ptr�Q�size)�Q�将ptr内存大小增大到size�?br />free的调用�Ş式�ؓfree(void*ptr)�Q�释放ptr所指向的一块内存空间�?br />C++中�ؓnew/delete函数�?/p>

allic 2008-02-15 22:01 发表评论

allic — Fri, 15 Feb 2008 02:15:00 GMT

使用�U�程�~�写�E�序需要技巧，而多�U�程的程序中的bug非常难以跟踪、调试，因�ؓ�q�些bug�l�常是难以再现的�?br />
竞争条�g�Q?br />当一个线�E�访问一个数据结构的时候，另一个线�E�也讉K��同一个数据结构，�q�时��出��C��竞争条�g——两个线�E�（也可能是多个�Q�竞争对同一个资源的讉K��?br />当其中一个线�E�处理到一部分的时候，另外的线�E�可能进入了对同一数据的处理，而且��Z��调度的原因，它运行的比前一个更快；�q�时�Q�同��L��处理可能��出��C��多次�?br />例如�Q�一个代表�Q务列表的单向链表�Q�队列）�Q�一个线�E�从当前元素中读��Z��下一个�Q务，�q�发��C��一个�Q务不是空�Q�准备将此一个�Q务置为NULL�q�执行�Q务；�q�时�Q�调度��得这个线�E�停下来�Q�另一个线�E�也从当前元素中��d��了下一个�Q务，当然下个��d��仍然不是�I��|��q�个�U�程也将要执行下一个�Q务。这��P��在某些不�q�的情况下，�q�个��d��被执行了两次�?br />更�ؓ不幸的情况下�Q�执行�Q务的�q�程中线�E�被中断�Q�此时另一个线�E�释放了��d��的内存，那么执行中的�U�程会导致段错误�?br />在比较“幸�q�”的情况下，�q�些事情可能从来也不发生�Q�但是当�E�序�q�行在负荷很高的�pȝ��中时�Q�这个bug��׃��凸现出来�?br />
互斥�?/strong>�Q?br />��Z��排除竞争条�g的媄响，应该使一些操作变成“原子的”——这些操作既不能分割也不能中断�?br />当一个线�E�锁定了互斥锁后�Q�其他线�E�也要求锁定�q�个互斥锁的时候，��׃��被阻塞；直到前面的线�E�解除锁定后�Q�其他线�E�才可以解除��d��恢复�q�行�?br />GNU/Linux保证�U�程在锁定互斥锁的过�E�中不会发生竞争条�g�Q�只有一个线�E�可以锁定互斥锁�Q�其他线�E�的锁定��h��都会被阻塞�?br />
创徏互斥锁（Mutex�Q�，需要：
｀创徏一个pthread_mutex_t�c�d��的变量，��其指针传入函数pthread_mutex_init中；该函数的�W�二个参数是指向一个mutex属性对象（�q�个对象用来指定mutex的属性）的指针。mutex对象只能初始化一�ơ�?br />｀更简单的办法是，使用PTHREAD_MUTEX_INITIALIZER来获得默认属性的mutex对象�Q?br />pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

使用mutex�Q?br />｀调用pthread_mutex_lock函数�Q�如果mutex对象未被锁定�Q�则此函数立卌��回；如果已被锁定�Q�则此函数阻塞此�U�程的执行，直到mutex被解除锁定�?br />｀每次解除锁定后，只有一个线�E�可以解除阻塞恢复执行，其他调用�U�程都会�l�箋��d��。选定的解除阻塞的�U�程是不可预知的�?br />｀调用pthread_mutex_unlock函数�Q�可以解除调用线�E�对mutex对象的锁定。在锁定mutex的线�E�中�Q�必��调用此函数以解除锁定�?br />
mutex提供了解决竞争条件的�Ҏ��Q�但是它带来了一�U�新的bug—�?strong>死锁�Q?strong>deadlock�Q��?br />所谓死锁，��是说一个线�E�在�{�待永远不会发生的条件�?br />一个简单的死锁�Q�一个线�E�锁定它自己已经锁定的mutex。这时程序的表现依赖于mutex的类型：
｀快速排他锁�Q�fast mutex�Q�——导致死锁�?br />｀递归排他锁（recursive mutex�Q�——不��D��死锁。同一个线�E�可以安全的多次锁定同一个已锁定的mutex�Q�但是锁定的�ơ数会被记录下来�Q�该�U�程�q�必��调用相应次数的pthread_mutex_unlock才能真正解除对mutex的锁定�?br />｀��错排他锁�Q�error-checking mutex�Q�——GNU/Linux视此操作为死锁，但是寚w��定的mutex调用pthread_mutex_lock函数�Q�函数立卌��回错误码EDEADLK�?br />
mutex的锁定函��C��d��Q�有旉��要一个不��d��p��知道mutex是否已锁定的函数�Q�以在发现mutex已锁的情况下��d��成其他工作�ƈ在以后再来检查。这��L��函数是：
pthread_mutex_trylock
如果传入的mutex已经被其他线�E�锁定，那么�q�个函数�q�回错误码EBUSY�Q�如果未被锁定，此函��C��锁定mutex�Q��ƈ�q�回0。这个函��C��会阻塞�?/div>

allic 2008-02-15 10:15 发表评论

allic — Tue, 29 Jan 2008 16:45:00 GMT

在linux下进行C�E�序�Ӟ��隑օ�会出现这里那里的错误�Q�对于像�D�错误的调试�Q�对于生手可能比较麻烦，无从下手�Q�我惌��是一个C�E�序员的必经的经历。一旦出现这��L��错误是相当棘手的。相信调试过几次��L��错误后再�ơ遇到就能很��L��的解决了�?br /> �D�错误的产生主要是由于内存操作有误，如访问的数组��界�Q�向�I�地址赋��|��取值等。调试段错误是要借助gdb调试工具。对于那些立卛_��现的错误很好调试�Q�如果是很时间才出现的错误，��可以通过生成core文�g。通过调试core文�g定位错误产生的地方，而有些错误�ƈ非是一��D��看出来。像在多�U�程情况下，在没有保护的情况下操作数据库时也会��生段错误。一个不可重入函数在单线�E�下�q�行没有问题。可能到多线�E�情况下��׃��出现��界的情��c��因而意识到多线�E�下的�ƈ发机制�?br /> 对于��d�@环的调试�Q�也可以借助gdb�Q�当�E�序出现��d�@环时�Q�将gdb attach到程序上�Q�如�?是主�q�程序出现死循环�Q�可以通过设断�Ҏ��法跟�t�，而对于多�U�程�E�序可以通过查看哪个�U�程在运行，基本上能定位错误出现的地斏V�?img src ="http://www.tkk7.com/huyi2006/aggbug/178436.html" width = "1" height = "1" />

allic 2008-01-30 00:45 发表评论

什么是core文�g�Q�怎么产生core文�g ----from csdn

allic — Mon, 21 Jan 2008 14:18:00 GMT

1. 前言:
有的�E�序可以通过�~�译, 但在�q�行时会出现Segment fault(�D�错�?. �q�通常都是指针错误引�v�?
但这不像�~�译错误一样会提示到文�?>�? 而是没有��M��信息, 使得我们的调试变得困难�v�?

2. gdb:
有一�U�办法是, 我们用gdb的step, 一步一步寻�?
�q�放在短��的代码中是可行�? 但要让你step一个上万行的代�? 我想你会从此厌恶�E�序员这个名�? 而把他叫做调试员.
我们�q�有更好的办�? �q�就是core file.

3. ulimit:
如果惌��pȝ��在信号中断造成的错误时产生core文�g, 我们需要在shell中按如下讄��:
#讄��core大小为无�?br />ulimit -c unlimited
#讄��文�g大小为无�?br />ulimit unlimited

�q�些需要有root权限, 在ubuntu下每�ơ重新打开中断都需要重新输入上面的�W�一条命�? 来设�|�core大小为无�?

4. 用gdb查看core文�g:
下面我们可以在发生运行时信号引�v的错误时发生core dump�?
发生core dump之后, 用gdb�q�行查看core文�g的内�? 以定位文件中引发core dump的行.
gdb [exec file] [core file]
�?
gdb ./test test.core
在进入gdb�? 用bt命��o查看backtrace以检查发生程序运行到哪里, 来定位core dump的文�?>�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1669532

allic 2008-01-21 22:18 发表评论

allic — Tue, 25 Dec 2007 10:18:00 GMT

看似��单的一�D늨�序如�?
int main()
{
   int i,j[8];
   for(i=0;i<=8;i++)
    j[i]=0;
   return 0;
}
    gcc�~�译�q�行会陷入死循环.

    因�ؓ变量 i 和数�l?j[8]是保存在栈中�Q�默认是由高地址向低地址方向存储. 输出变量地址可以发现: i 存储位置�?xbfd90dec, j[0]、j[1]...j[7]在内存的地址分别�?xbfdab05c�?xbfdab060,...0xbfdab078. 如下所�C�：
         高地址 <--------------------------------------->低地址
                        i,j[7],j[6],j[5],j[4],j[3],j[2],j[1],j[0]

    如果在int i,j[8]后面再定义变量int c,那么c��存攑֜�j[0]的往低方向的下一个地址0xbfdab058 .

现在不难理解�q�段�E�序��Z��么会出现��d�@环了。j[8]的位�|�就是变量i所在的位置。这样当i=8时的j[i]=0语句�Q�实际上��是��i的值置�?�Q�然�?i 又从0�?循环一直下�? 如果��原句改为int j[8],i; ��׃��会出现死循环�Q�而仅仅是一个段��界错误.

另一个程�?
#include
int main()
{
        int i;
        char c;
        for(i=0;i<5;i++)
        {
                scanf("%d",&c);
                printf("i=%d ",i);
        }
        printf("\n");
}
�~�译后运�?br />[foxman@local~]#./a.out
0    (输入0)
i=0 (输出 i �?
1
i=0
2
i=0
3
i=0
4
i=0
...
�q�样一直��@环下厅R�?/font>

问题在于�Q�c被声明�ؓchar�c�d��Q�而不是int�c�d��。当�E�序要求scanf��d��一个整数时�Q�应该传递给它一个指向整数的指针。而程序中scanf得到的却是一个指向字�W�的指针�Q�scanf函数�q�不能分辨这�U�情况，只能��这个指向字�W�的指针作�ؓ指向整数的指针而接受，�q�且在指针指向的位置存储一个整数。因为整数所占的存储�I�间要大于字�W�所占的存储�I�间�Q�所以c附近的内存会被覆�?

�׃��面分析，i �?c 是由高地址��C��地址存储在栈中，�q�样在c所在位�|�尝试存储一�?字节变量�Q�会占用比c高的3个字�?覆盖�?i 字节的低3�?�Q�即�?i ��L��为零�Q�一直��@环下�?

如果每次输入Ctrl+D作�ؓ字符�l�止�W�不存储int到c处，那么��׃��输出正常i=0..4�?

allic 2007-12-25 18:18 发表评论

C语言面试题大汇��M��微��Y亚洲技术中心面试题

allic — Thu, 10 May 2007 04:27:00 GMT

　1�Q�进�E�和�U�程的差别�?

　　�U�程是指�q�程内的一个执行单�?也是�q�程内的可调度实�?

　　与进�E�的区别:

　　(1)调度�Q�线�E�作��度和分配的基本单位，�q�程作�ؓ拥有资源的基本单�?

　　(2)�q�发性：不仅�q�程之间可以�q�发执行�Q�同一个进�E�的多个�U�程之间也可�q�发执行

　　(3)拥有资源�Q�进�E�是拥有资源的一个独立单位，�U�程不拥有系�l�资源，但可以访问隶属于�q�程的资�?

　　(4)�pȝ��开销�Q�在创徏或撤消进�E�时�Q�由于系�l�都要�ؓ之分配和回收资源�Q�导致系�l�的开销明显大于创徏或撤消线�E�时的开销�?
　
　　2.��试�Ҏ��

　　人工��试�Q�个人复查、抽查和会审

　　机器��试�Q�黑盒测试和白盒��试

　　2�Q�Heap与stack的差别�?

　　Heap是堆�Q�stack是栈�?

　　Stack的空间由操作�pȝ��自动分配/释放�Q�Heap上的�I�间手动分配/释放�?

　　Stack�I�间有限�Q�Heap是很大的自由存储�?

　　C中的malloc函数分配的内存空间即在堆�?C++中对应的是new操作�W��?

　　�E�序在编译期对变量和函数分配内存都在栈上�q�行,且程序运行过�E�中函数调用时参数的传递也在栈上进行�?

　　3�Q�Windows下的内存是如何管理的�Q?

　　4�Q�介�l?Net�?Net的安全性�?

　　5�Q�客��L��如何讉K��.Net�l��g实现Web Service�Q?

　　6�Q�C/C++�~�译器中虚表是如何完成的�Q?

　　7�Q�谈谈COM的线�E�模型。然后讨��E�内/外组件的差别�?

　　8�Q�谈谈IA32下的分页机制

　　��页(4K)两��分页模式�Q�大��?4M)一�U?

　　9�Q�给两个变量�Q�如何找��Z��个带环单链表中是什么地方出现环的？

　　一个递增一�Q�一个递增二，他们指向同一个接�Ҏ��是环出现的地方

　　10�Q�在IA32中一共有多少�U�办法从用户态蟩到内核态？

　　通过调用门，从ring3到ring0�Q�中断从ring3到ring0�Q�进入vm86�{�等

　　11�Q�如果只惌��E�序有一个实例运行，不能�q�行两个。像winamp一��P��只能开一个窗口，怎样实现�Q?

　　用内存映��或全局原子�Q�互斥变量）、查扄��口句�?.

　　FindWindow�Q�互斥，写标志到文�g或注册表,�׃�n内存�?　

　　12�Q�如何截取键盘的响应�Q�让所有的‘a’变成‘b’？

　　键盘钩子SetWindowsHookEx
　
　　13�Q�Apartment在COM中有什么用�Q��ؓ什么要引入�Q?
　
　　14�Q�存储过�E�是什么？有什么用�Q�有什么优点？

　　我的理解��是一堆sql的集合，可以建立非常复杂的查询，�~�译�q�行�Q�所以运行一�ơ后�Q�以后再�q�行速度比单独执行SQL快很�?
　
　　15�Q�Template有什么特点？什么时候用�Q?

　　16�Q�谈谈Windows DNA�l�构的特点和优点�?

　　17.�|�络�~�程中设计�ƈ发服务器�Q��用多�q�程 �?多线�E?�Q�请问有什么区别？

　　1�Q�进�E�：子进�E�是父进�E�的复制品。子�q�程获得父进�E�数据空间、堆和栈的复制品�?

　　2�Q�线�E�：相对与进�E�而言�Q�线�E�是一个更加接�q�与执行体的概念�Q�它可以与同�q�程的其他线�E�共享数据，但拥有自��q��栈空��_��拥有独立的执行序列�?

　　两者都可以提高�E�序的�ƈ发度�Q�提高程序运行效率和响应旉��?

　　�U�程和进�E�在使用上各有优�~�点�Q�线�E�执行开销��，但不利于资源��理和保护；而进�E�正相反。同�Ӟ��U�程适合于在SMP机器上运行，而进�E�则可以跨机器迁�U�R�?

allic 2007-05-10 12:27 发表评论

allic — Thu, 10 May 2007 03:25:00 GMT

1、局部变量能否和全局变量重名�Q?

　　�{�：能，局部会屏蔽全局。要用全局变量�Q�需要��?::"

　　局部变量可以与全局变量同名�Q�在函数内引用这个变量时�Q�会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言�Q�在同一个函数内可以定义多个同名的局部变量，比如在两个��@环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个��@环体内�?

　　2、如何引用一个已�l�定义过的全局变量�Q?

　　�{�：extern

　　可以用引用头文�g的方式，也可以用extern关键字，如果用引用头文�g方式来引用某个在头文件中声明的全局变理�Q�假定你��那个变写错了，那么在编译期间会报错�Q�如果你用extern方式引用�Ӟ��假定你犯了同��L��错误�Q�那么在�~�译期间不会报错�Q�而在�q�接期间报错�?

　　3、全局变量可不可以定义在可被多�?C文�g包含的头文�g中？��Z��么？

　　�{�：可以�Q�在不同的C文�g中以static形式来声明同名全局变量�?

　　可以在不同的C文�g中声明同名的全局变量�Q�前提是其中只能有一个C文�g中对此变量赋初��|��此时�q�接不会出错

　　4、语句for( �Q? �Q?有什么问题？它是什么意思？

　　�{�：和while(1)相同�?

　　5、do……while和while……do有什么区别？

　　�{�：前一个��@环一遍再判断�Q�后一个判断以后再循环

　　6、请写出下列代码的输出内�?

　　#include
　　main()
　　{
　　　int a,b,c,d;
　　　a=10;
　　　b=a++;
　　　c=++a;
　　　d=10*a++;
　　　printf("b�Q�c�Q�d�Q?d�Q?d�Q?d"�Q�b�Q�c�Q�d�Q?
　　　return 0;
　　}

　　�{�：10�Q?2�Q?20

　　7、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

　　全局变量(外部变量)的说明之前再冠以static ��构成了静态的全局变量。全局变量本��n��是静态存储方式，静态全局变量当然也是静态存储方式�?�q�两者在存储方式上�ƈ无不同。这两者的区别虽在于非静态全局变量的作用域是整个源�E�序�Q?当一个源�E�序由多个源文�g�l�成�Ӟ��非静态的全局变量在各个源文�g中都是有效的�?而静态全局变量则限制了其作用域�Q?卛_��在定义该变量的源文�g内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文�g内，只能��源文件内的函数公用，因此可以避免在其它源文�g中引起错误�?

　　从以上分析可以看出，把局部变量改变�ؓ静态变量后是改变了它的存储方式��x��变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的��用范围�?

　　static函数与普通函��C��用域不同。仅在本文�g。只在当前源文�g中��用的函数应该说明为内部函�?static)�Q�内部函数应该在当前源文件中说明和定义。对于可在当前源文�g以外使用的函敎ͼ�应该在一个头文�g中说明，要��用这些函数的源文件要包含�q�个头文�?

　　static全局变量与普通的全局变量有什么区别：static全局变量只初使化一�ơ，防止在其他文件单元中被引�?

　　static局部变量和普通局部变量有什么区别：static局部变量只被初始化一�ơ，下一�ơ依据上一�ơ结果��|��

　　static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中�l�持一份拷�?

　　8、程序的局部变量存在于�Q�堆栈）中，全局变量存在于（静态区 �Q�中�Q�动态申��h��据存在于�Q?堆）中�?

　　9、设有以下说明和定义�Q?

　　typedef union {long i; int k[5]; char c;} DATE;
　　struct data { int cat; DATE cow; double dog;} too;
　　DATE max;

　　则语�?printf("%d",sizeof(struct date)+sizeof(max));的执行结果是�Q�___52____

　　�{�：DATE是一个union, 变量公用�I�间. 里面最大的变量�c�d��是int[5], 占用20个字�? 所以它的大��是20
data是一个struct, 每个变量分开占用�I�间. 依次为int4 + DATE20 + double8 = 32.
所以结果是 20 + 32 = 52.

　　当然...在某�?6位编辑器�? int可能�?字节,那么�l�果�?int2 + DATE10 + double8 = 20

　　10、队列和栈有什么区别？
　　
　　队列先进先出�Q�栈后进先出

　　11、写��Z��列代码的输出内容

　　#include
　　int inc(int a)
　　{
　　　return(++a);
　　}
　　int multi(int*a,int*b,int*c)
　　{
　　　return(*c=*a**b);
　　}
　　typedef int(FUNC1)(int in);
　　typedef int(FUNC2) (int*,int*,int*);

　　void show(FUNC2 fun,int arg1, int*arg2)
　　{
　　　INCp=&inc;
　　　int temp =p(arg1);
　　　fun(&temp,&arg1, arg2);
　　　printf("%d\n",*arg2);
　　}

　　main()
　　{
　　　int a;
　　　show(multi,10,&a);
　　　return 0;
　　}

　　�{�：110

　　12、请扑և�下面代码中的所以错�?

　　说明�Q�以下代码是把一个字�W�串倒序�Q�如“abcd”倒序后变为“dcba�?

　　1�?include"string.h"
　　2、main()
　　3、{
　　4�?char*src="hello,world";
　　5�?char* dest=NULL;
　　6�?int len=strlen(src);
　　7�?dest=(char*)malloc(len);
　　8�?char* d=dest;
　　9�?char* s=src[len];
　　10�?while(len--!=0)
　　11�?d++=s--;
　　12�?printf("%s",dest);
　　13�?return 0;
　　14、}

　　�{�：

　　�Ҏ��1�Q?

　　int main()
　　{
　　　char* src = "hello,world";
　　　int len = strlen(src);
　　　char* dest = (char*)malloc(len+1);//要�ؓ\0分配一个空�?
　　　char* d = dest;
　　　char* s = &src[len-1];//指向最后一个字�W?
　　　while( len-- != 0 )
　　　*d++=*s--;
　　　*d = 0;//��N��要加\0
　　　printf("%s\n",dest);
　　　free(dest);// 使用完，应当释放�I�间�Q�以免造成内存汇泄�?
　　　return 0;
　　}

allic 2007-05-10 11:25 发表评论

�Ҏ��像头�~�程的研�I�小�?

allic — Tue, 08 May 2007 12:28:00 GMT

**//* $Id: directshow.c,v 1.22 2005/11/12 14:12:39 fuhuizhong Exp $ */

#ifndef lint
static char vcid[] = "$Id: directshow.c,v 1.22 2005/11/12 14:12:39 fuhuizhong Exp $";
#endif /* lint */

/**//*
* 作者：傅惠�?
* /modified by xiaoshao_0_0
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "jpeglib.h"
#include
#include
#include
#include
#include
#define USB_VIDEO "/dev/video1"

SDL_Surface *screen,*img;
int cam_fd;
int width,height;
const int bpp = 24;
struct video_mmap cam_mm;
struct video_capability cam_cap;
struct video_picture cam_pic;
struct video_mbuf cam_mbuf;
struct video_window win;
char *cam_data = NULL;
int nframe;

void errexit(char *msg)
...{
fputs(msg,stderr);
exit(-1);
}

void e_sig(int signum)
...{
printf(" ERROR:signal %d ",signum);
exit(-1);
}

void setup_sighandler()
...{
signal(SIGTERM,&e_sig);
signal(SIGINT,&e_sig);
signal(SIGSEGV,&e_sig);
signal(SIGILL,&e_sig);
signal(SIGFPE,&e_sig);
}

void init_video(int w,int h,int bpp); /**//* bpp == bits per pixel, 暂时无效*/
void init_screen(int w,int h,int bpp); /**//* like above*/
void read_video(int ,int);
void show_img(char *pixels);
void window_loop();
void exchange_r_b( char * f,long size);
void compress_to_jpeg_file( FILE *outfile, char * image_buffer,int w,int h, int quality);
void save_snapshot();

void free_dev()
...{
printf("free device ");
close(cam_fd);
}

int main(int argc,char *argv[])
...{
int i;
float scale = 1.0;
if( argc == 2 ) ...{
scale = atof(argv[1]);
if(scale<0.3 || scale>1.0)
errexit("scale out of range (0.3 ~ 1.0) ");
}
width = (int)(640*scale);
height = (int)(480*scale);

atexit( &free_dev );
init_video(width,height,bpp);
init_screen(width,height,bpp);
setup_sighandler();

window_loop();

getchar();
munmap(cam_data,cam_mbuf.size);

exit(0);
}

void config_vid_pic()
...{
char *hp = getenv("HOME");
char cfpath[100];
FILE *cf;
int ret;
sprintf( cfpath,"%s/.dshow.conf",hp );
cf = fopen(cfpath,"r");
/**//* The struct video_picture consists of the following fields

brightness Picture brightness
hue Picture hue (colour only)
colour Picture colour (colour only)
contrast Picture contrast
whiteness The whiteness (greyscale only)
depth The capture depth (may need to match the frame buffer depth)
palette Reports the palette that should be used for this image

The following palettes are defined

VIDEO_PALETTE_GREY Linear intensity grey scale (255 is brightest).
VIDEO_PALETTE_HI240 The BT848 8bit colour cube.
VIDEO_PALETTE_RGB565 RGB565 packed into 16 bit words.
VIDEO_PALETTE_RGB555 RGV555 packed into 16 bit words, top bit undefined.
VIDEO_PALETTE_RGB24 RGB888 packed into 24bit words.
VIDEO_PALETTE_RGB32 RGB888 packed into the low 3 bytes of 32bit words. The top 8bits are undefined.
VIDEO_PALETTE_YUV422 Video style YUV422 - 8bits packed 4bits Y 2bits U 2bits V
VIDEO_PALETTE_YUYV Describe me
VIDEO_PALETTE_UYVY Describe me
VIDEO_PALETTE_YUV420 YUV420 capture
VIDEO_PALETTE_YUV411 YUV411 capture
VIDEO_PALETTE_RAW RAW capture (BT848)
VIDEO_PALETTE_YUV422P YUV 4:2:2 Planar
VIDEO_PALETTE_YUV411P YUV 4:1:1 Planar
*/
if (ioctl(cam_fd, VIDIOCGPICT, &cam_pic) < 0) ...{
errexit("ERROR:VIDIOCGPICT ");
}
//cam_pic.palette =VIDEO_PALETTE_RAW;
cam_pic.palette =VIDEO_PALETTE_RGB24;

if( cf==NULL ) ...{
cam_pic.brightness = 44464;
cam_pic.hue = 36000;
cam_pic.colour = 0;
cam_pic.contrast = 43312;
cam_pic.whiteness = 13312;
cam_pic.depth = 24;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
return;
}

fscanf(cf,"%d",&cam_pic.brightness);
fscanf(cf,"%d",&cam_pic.hue);
fscanf(cf,"%d",&cam_pic.colour);
fscanf(cf,"%d",&cam_pic.contrast);
fscanf(cf,"%d",&cam_pic.whiteness);
fclose( cf );
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}

}

void init_video(int w,int h,int bpp) /**//* bpp == bytes per pixel*/
...{
int ret;

cam_fd = open( USB_VIDEO, O_RDWR );
if( cam_fd<0 )
errexit("Can't open video device ");

ret = ioctl( cam_fd,VIDIOCGCAP,&cam_cap );
/**//* 摄像头的基本信息
struct video_capability cam_cap;
name[32] Canonical name for this interface
type Type of interface
channels Number of radio/tv channels if appropriate
audios Number of audio devices if appropriate
maxwidth Maximum capture width in pixels
maxheight Maximum capture height in pixels
minwidth Minimum capture width in pixels
minheight Minimum capture height in pixels
*/
if( ret<0 ) ...{
errexit("Can't get device information: VIDIOCGCAP ");
}

print_device_info();

/**//* The struct video_window contains the following fields.

x The X co-ordinate specified in X windows format.
y The Y co-ordinate specified in X windows format.
width The width of the image capture.
height The height of the image capture.
chromakey A host order RGB32 value for the chroma key.
flags Additional capture flags.
clips A list of clipping rectangles. (Set only)
clipcount The number of clipping rectangles. (Set only)
*/
if( ioctl(cam_fd,VIDIOCGWIN,&win)<0 ) ...{
errexit("ERROR:VIDIOCGWIN ");
}
win.x = 0;
win.y = 0;
win.width=width;
win.height=height;
if (ioctl(cam_fd, VIDIOCSWIN, &win) < 0) ...{
errexit("ERROR:VIDIOCSWIN ");
}

config_vid_pic();

ret = ioctl(cam_fd,VIDIOCGMBUF,&cam_mbuf);
/**//*
struct video_mbuf
{
int size; Total memory to map
int frames; Frames
int offsets[VIDEO_MAX_FRAME];
};
*/

/**//*struct video_buffer.
视频�~�存的信息读取结构，讑֮�也是一��L��l�构。但是一般是X自己讑֮��Q�你只要��d��好了�?
void *base Base physical address of the buffer
int height Height of the frame buffer
int width Width of the frame buffer
int depth Depth of the frame buffer
int bytesperline Number of bytes of memory between the start of two adjacent lines*/

if( ret<0 ) ...{
errexit("ERROR:VIDIOCGMBUF,Can't get video_mbuf ");
}
printf("Frames:%d ",cam_mbuf.frames);
nframe = cam_mbuf.frames;
cam_data = (char*)mmap(0, cam_mbuf.size, PROT_READ|PROT_WRITE,MAP_SHARED,cam_fd,0);
if( cam_data == MAP_FAILED ) ...{
errexit("ERROR:mmap ");
}
printf("Buffer size:%d Offset:%d ",cam_mbuf.size,cam_mbuf.offsets[0]);
}

void print_device_info()
...{
int type=cam_cap.type;
int i;
char type_info[14][100]=
...{
"VID_TYPE_CAPTURE Can capture to memory",
"VID_TYPE_TUNER Has a tuner of some form",
"VID_TYPE_TELETEXT Has teletext capability",
"VID_TYPE_OVERLAY Can overlay its image onto the frame buffer",
"VID_TYPE_CHROMAKEY Overlay is Chromakeyed",
"VID_TYPE_CLIPPING Overlay clipping is supported",
"VID_TYPE_FRAMERAM Overlay overwrites frame buffer memory",
"VID_TYPE_SCALES The hardware supports image scaling",
"VID_TYPE_MONOCHROME Image capture is grey scale only",
"VID_TYPE_SUBCAPTURE Capture can be of only part of the image",
"VID_TYPE_MPEG_DECODER Can decode MPEG streams",
"VID_TYPE_MPEG_ENCODER Can encode MPEG streams",
"VID_TYPE_MJPEG_DECODER Can decode MJPEG streams",
"VID_TYPE_MJPEG_ENCODER Can encode MJPEG streams",
};
printf("Device name:%s Width:%d ~ %d Height:%d ~ %d ",
cam_cap.name,
cam_cap.maxwidth, cam_cap.minwidth,
cam_cap.maxheight, cam_cap.minheight);
for(i=0;i<14;i++)
...{
if(type&(2^i))
...{ printf(type_info[i]);
printf(" ");
}
else
...{
printf("==not supported==%s",type_info[i]);
printf(" ");
}
}
}

void init_screen(int w,int h,int bpp) // like above
...{
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) ...{
fprintf(stderr, "无法初始化SDL: %s ", SDL_GetError());
exit(1);
}
img = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, bpp, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000);
screen = SDL_SetVideoMode(width, height, bpp, SDL_SWSURFACE);
if ( screen == NULL ) ...{
fprintf(stderr, "无法讄��视频模式�Q?s ", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
}

void read_video(int captrue_frame,int sync_frame)
...{
int ret;
//int frame=0; /*�q�个��g��比较关键*/
//�q�个地方原作者弄错了�?
cam_mm.frame=captrue_frame;
/**//* struct video_mmap
{
unsigned int frame; Frame (0 - n) for double buffer
int height,width;
unsigned int format; should be VIDEO_PALETTE_*
};
*/
ret = ioctl(cam_fd,VIDIOCMCAPTURE,&cam_mm);
if( ret<0 ) ...{
errexit("ERROR: VIDIOCMCAPTURE ");
}
//cam_mm.frame=sync_frame;
ret = ioctl(cam_fd,VIDIOCSYNC,&sync_frame);
if( ret<0 ) ...{
errexit("ERROR: VIDIOCSYNC ");
}
}

void show_img(char *pixels)
...{
int row_stride = width*3;
char *pbuf = (char*)img->pixels;
int row;

/**//* for(row=0; rowmemcpy(pbuf, pixels, row_stride);
pbuf += img->pitch;
pixels += row_stride;
}*/
memcpy(pbuf,pixels,row_stride*height);
SDL_BlitSurface(img, NULL, screen, NULL);
SDL_UpdateRect(screen,0,0,width,height);
}

void window_loop()
...{
int ret;
SDL_Event event;
int keystat = 0;
Uint32 ticks = 0;
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,1000);
/**///////////////
cam_mm.height = height;
cam_mm.width = width;
cam_mm.frame=0;
cam_mm.format=VIDEO_PALETTE_RGB24;
ret = ioctl(cam_fd,VIDIOCMCAPTURE,&cam_mm);

if( ret<0 ) ...{
errexit("ERROR: VIDIOCMCAPTURE ");
}
//Here just start caputer frame0,it not in the loop.
/**///////////////
while ( 1 ) ...{
SDL_PollEvent(&event);
switch (event.type) ...{
case SDL_QUIT:
exit(0);
case SDL_KEYDOWN:
if( event.key.keysym.sym == SDLK_F8 && keystat == 0 )
save_snapshot();
if( event.key.keysym.sym == SDLK_F9 && keystat == 0 )
config_vid_pic();
if( event.key.keysym.sym == SDLK_UP && keystat == 0 )
increase_brightness();
if( event.key.keysym.sym == SDLK_DOWN && keystat == 0 )
decrease_birghtness();
if( event.key.keysym.sym == SDLK_LEFT && keystat== 0 )
increase_contrast();
if( event.key.keysym.sym == SDLK_RIGHT && keystat==0 )
decrease_contrast();
keystat = 1;
break;
case SDL_KEYUP:
keystat = 0;
break;
default:
break;
}
if( (SDL_GetTicks()-ticks)<30)
continue;
read_video(1,0);//captrue=1,sync=0
show_img( cam_data+cam_mbuf.offsets[0]);
read_video(0,1);//captrue=0,sync=1
show_img( cam_data+cam_mbuf.offsets[1]);
ticks = SDL_GetTicks();
}
}
void increase_brightness()
...{
int ret=0;
cam_pic.brightness+=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void decrease_birghtness()
...{
int ret=0;
cam_pic.brightness-=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void increase_contrast()
...{
int ret=0;
cam_pic.contrast+=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void decrease_contrast()
...{
int ret=0;
cam_pic.contrast-=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*讄��摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}

void compress_to_jpeg_file( FILE *outfile, char * image_buffer,int w,int h, int quality)
...{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1]; /**//* pointer to JSAMPLE row[s] */
int row_stride; /**//* physical row width in image buffer */
int image_width;
int image_height;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, outfile);

image_width = w;
image_height = h;
cinfo.image_width = image_width; /**//* image width and height, in pixels */
cinfo.image_height = image_height;
cinfo.input_components = 3; /**//* # of color components per pixel */
cinfo.in_color_space = JCS_RGB; /**//* colorspace of input image */
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, quality, TRUE /**//* limit to baseline-JPEG values */);
jpeg_start_compress(&cinfo, TRUE);
row_stride = image_width * 3; /**//* JSAMPLEs per row in image_buffer */
while (cinfo.next_scanline < cinfo.image_height) ...{
row_pointer[0] = (JSAMPROW)& image_buffer[cinfo.next_scanline * row_stride];
(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
}

jpeg_finish_compress(&cinfo);

jpeg_destroy_compress(&cinfo);

/**//* And we're done! */
}
void exchange_r_b( char * f,long size)
...{
char r,b;
long i;
for( i = 0; i < size ; i++)
...{
r = *f;
b = *( f + 2);
*f = b;
*(f + 2) = r;
f = f +3;
}

}

void save_snapshot()
...{
char *basepath = getenv("HOME");
char *basename = "/snapsot";
char *extname = ".jpg";
char filename[100];
int i = 0;
FILE *fo;
for(;;) ...{
sprintf(filename,"%s%s%d%s",basepath,basename,i,extname);
fo = fopen(filename,"rb");
if( fo==NULL )
break;
else
fclose(fo);
i += 1;
}
printf("snapshot:%s ",filename);
fo = fopen(filename,"wb");
exchange_r_b( cam_data, width*height );
compress_to_jpeg_file( fo, cam_data, width, height, 90 );
fclose(fo);
}

一个比较清淅的摄像头参数设�|?br />

//loadVariablesNum("schlist.tx", 0);
//fscommand("fullscrean", true);
var my_cam = Camera.get();
//LAN
//Lower image quality, higher motion quality my_cam.setQuality(400000,0)
//Higher image quality, lower motion qualitymy_cam.setQuality(0,100)
//// ��保最低品质�ؓ 100�Q�无论采用多大的带宽
my_cam.setQuality(0, 100); //
my_cam.setKeyFrameInterval(15);
my_cam.setLoopback(true);
//my_cam.setMotionLevel(35, 1000);
my_cam.setMode(320, 240, 25, true);

// 捕获摄像�?br />myVideo1.attachVideo(my_cam);
myVideo1.smoothing = true;
myVideo1._alpha = 100;
myVideo1._rotation = 360;
// 在舞��C��?myVideo1 对象的边界内昄��视频��?br />my_cam.onStatus = function(infoMsg) {
if (infoMsg.code == 'Camera.Muted') {
  // 拒绝
  trace('User denies access to the camera');
} else if (infoMsg.code == 'Camera.Unmuted') {
  // 接受
  trace('User allows access to the camera');
}

};
//System.showSettings(3);
// 昄��指定�?Flash Player"讄��"面板
stop();

allic 2007-05-08 20:28 发表评论

一个生产�?消费者的模型

allic — Thu, 03 May 2007 05:44:00 GMT

一个很好的多线�E�和互斥锁学习例�E�，是一个生产�?消费者的模型

#include
#include
#include
#include
#define BUFFER_SIZE 16

struct prodcons
{
   int buffer[BUFFER_SIZE];
   pthread_mutex_t lock;/*互斥�?/
   int readpos, writepos;
   pthread_cond_t notempty;/*�~�冲区非�I�Z��?/
   pthread_cond_t notfull;/*�~�冲区非满信�?/
};

void init(struct prodcons *b)
{
   pthread_mutex_init(&b->lock, NULL);
   pthread_cond_init(&b->notempty, NULL);
   pthread_cond_init(&b->notfull, NULL);
   b->readpos = 0;
   b->writepos = 0;
}
void put(struct prodcons *b, int data)
{
   pthread_mutex_lock(&b->lock);//获取互斥�?br />   while((b->writepos + 1) % BUFFER_SIZE == b->readpos)
   {
      printf("wait for not full\n");
      pthread_cond_wait(&b->notfull, &b->lock);//不满旉��出��d��
   }
   b->buffer[b->writepos] = data;
   b->writepos++;
   if(b->writepos >= BUFFER_SIZE) b->writepos = 0;
   pthread_cond_signal(&b->notempty);//讄��状态变�?br />   pthread_mutex_unlock(&b->lock);//释放互斥�?br />}

int get(struct prodcons *b)
{
   int data;
   pthread_mutex_lock(&b->lock);
   while(b->writepos == b->readpos)
   {
     printf("wait for not empty\n");
     pthread_cond_wait(&b->notempty, &b->lock);
   }
   data = b->buffer[b->readpos];
   b->readpos++;
   if(b->readpos >= BUFFER_SIZE) b->readpos = 0;
   pthread_cond_signal(&b->notfull);
   pthread_mutex_unlock(&b->lock);
   return data;
}

#define OVER (-1)
struct prodcons buffer;

void *producer(void *data)
{
   int n;
   for(n=0; n<1000; n++)
   {
      printf("put->%d\n",n);
      put(&buffer, n);
   }
   put(&buffer, OVER);
   printf("producer stopped\n");
   return NULL;
}

void *consumer(void *data)
{
   int d;
   while(1)
   {
      d = get(&buffer);
      if(d == OVER)
      break;
      printf("             %d->get\n",d);
   }
   printf("consumer stopped!\n");
   return NULL;
}
int main(void)
{
   pthread_t th_a, th_b;
   void *retval;
   init(&buffer);
   pthread_create(&th_a, NULL, producer, 0);
   pthread_create(&th_b, NULL, consumer, 0);
   pthread_join(th_a, &retval);
   pthread_join(th_b, &retval);
   return 0;
}
pthread_cond_wait函数�Q�是�U�程��d��在一个条件变量上�Q�原型�ؓ�Q?br />extern int pthread_cond_wait(pthread_cond_t *_restrict_cond, pthread_mutex_t* _restrict_mutex)
�U�程解开mutex指向的锁�q�被条�g变量cond��d��Q�线�E�可以被函数pthread_cond_signal和pthread_cond_broadcast唤醒�?br />�q�有另一个函数pthread_cond_timedwait函数�Q�他比vpthread_cond_wait函数多一个时间参敎ͼ��l�历�l�定旉��後，��d��被解除�?/p>

allic 2007-05-03 13:44 发表评论

C/C++中的日期和时�?

allic — Mon, 30 Apr 2007 10:50:00 GMT

C/C++中的日期和时�?

摘要�Q?
本文从介�l�基��概念入手�Q�探讨了在C/C++中对日期和时间操作所用到的数据结构和函数�Q��ƈ对计时、时间的获取、时间的计算和显�C�格式等斚w��q�行了阐�q�。本文还通过大量的实例向你展�C�Z��time.h头文件中声明的各�U�函数和数据�l�构的详�l��用方法�?

关键字：
UTC�Q�世界标准时��_��Q�Calendar Time�Q�日历时��_��Q�epoch�Q�时间点�Q�，clock tick�Q�时钟计时单元）

1�Q�概�?
在C/C++中，对字�W�串的操作有很多值得注意的问题，同样�Q�C/C++�Ҏ��间的操作也有许多值得大家注意的地斏V��最�q�，在技术群中有很多�|�友也多�ơ问到过C++语言中对旉��的操作、获取和昄��{�等的问题。下面，在这��文章中�Q�笔者将主要介绍在C/C++中时间和日期的��用方�?

通过学习许多C/C++库，你可以有很多操作、��用时间的�Ҏ��。但在这之前你需要了解一些“时间”和“日期”的概念�Q�主要有以下几个�Q?
Coordinated Universal Time�Q�UTC�Q�：协调世界�Ӟ��又称��Z��界标准时��_��也就是大家所熟知的格林威��L��准时��_��Greenwich Mean Time�Q�GMT�Q�。比如，中国内地的时间与UTC的时差�ؓ+8�Q�也��是UTC+8。美国是UTC-5�?
Calendar Time�Q�日历时��_��是用“从一个标准时间点到此时的旉��l�过的秒数”来表示的时间。这个标准时间点对不同的�~�译器来说会有所不同�Q�但对一个编译系�l�来��_��q�个标准旉��Ҏ��不变的，该编译系�l�中的时间对应的日历旉��都通过该标准时间点来衡量，所以可以说日历旉��是“相�Ҏ��间”，但是无论你在哪一个时区，在同一时刻对同一个标准时间点来说�Q�日历时间都是一��L��?
epoch�Q�时间点。时间点在标准C/C++中是一个整敎ͼ�它用此时的时间和标准旉��点相差的�U�数�Q�即日历旉��Q�来表示�?
clock tick�Q�时钟计时单元（而不把它叫做旉��滴答�ơ数�Q�，一个时钟计时单元的旉��长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位�?

我们可以使用ANSI标准库中的time.h头文件。这个头文�g中定义的旉��和日期所使用的方法，无论是在�l�构定义�Q�还是命名，都具有明昄��C语言风格。下面，我将说明在C/C++中怎样使用日期的时间功能�?

2�Q?计时
C/C++中的计时函数是clock()�Q�而与其相关的数据�c�d��是clock_t。在MSDN中，查得对clock函数定义如下�Q?
clock_t clock( void );
�q�个函数�q�回从“开启这个程序进�E�”到“程序中调用clock()函数”时之间的CPU旉��计时单元�Q�clock tick�Q�数�Q�在MSDN中称之�ؓ挂钟旉��Q�wal-clock�Q�。其中clock_t是用来保存时间的数据�c�d��Q�在time.h文�g中，我们可以扑ֈ�对它的定义：
#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
很明显，clock_t是一个长整�Ş数。在time.h文�g中，�q�定义了一个常量CLOCKS_PER_SEC�Q�它用来表示一�U�钟会有多少个时钟计时单元，其定义如下：
#define CLOCKS_PER_SEC ((clock_t)1000)
可以看到每过千分之一�U�（1毫秒�Q�，调用clock�Q�）函数�q�回的值就�?。下面�D个例子，你可以��用公式clock()/CLOCKS_PER_SEC来计��一个进�E�自�w�的�q�行旉��Q?
void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}
当然�Q�你也可以用clock函数来计��你的机器运行一个��@环或者处理其它事件到底花了多��时��_��
#include “stdio.h�?
#include “stdlib.h�?
#include “time.h�?
int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* ��量一个事件持�l�的旉��*/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- )
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}

在笔者的机器上，�q�行�l�果如下�Q?
Time to do 10000000 empty loops is 0.03000 seconds
上面我们看到旉��计时单元的长度�ؓ1毫秒�Q�那么计时的�_�ֺ�也�ؓ1毫秒�Q�那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而��计时�_�ֺ�更高呢？通过��试�Q�你会发现这��h��不行的。在标准C/C++中，最��的计时单位是一毫秒�?

3�Q�与日期和时间相关的数据�l�构

在标准C/C++中，我们可通过tm�l�构来获得日期和旉��Q�tm�l�构在time.h中的定义如下�Q?
#ifndef _TM_DEFINED
struct tm {
int tm_sec; /* �U?�?取值区间�ؓ[0,59] */
int tm_min; /* �?- 取值区间�ؓ[0,59] */
int tm_hour; /* �?- 取值区间�ؓ[0,23] */
int tm_mday; /* 一个月中的日期 - 取值区间�ؓ[1,31] */
int tm_mon; /* 月䆾�Q�从一月开始，0代表一月） - 取值区间�ؓ[0,11] */
int tm_year; /* �q�䆾�Q�其值等于实际年份减�?900 */
int tm_wday; /* 星期 �?取值区间�ؓ[0,6]�Q�其�?代表星期天，1代表星期一�Q�以此类�?*/
int tm_yday; /* 从每�q�的1�?日开始的天数 �?取值区间�ؓ[0,365]�Q�其�?代表1�?日，1代表1�?日，以此�c�L�� */
int tm_isdst; /* 夏��o时标识符�Q�实行夏令时的时候，tm_isdst为正。不实行夏��o时的�q�候，tm_isdst�?�Q�不了解情况�Ӟ��tm_isdst()��?/
};
#define _TM_DEFINED
#endif

ANSI C标准�U�C��用tm�l�构的这�U�时间表�C�Zؓ分解旉��(broken-down time)。而日历时��_��Calendar Time�Q�是通过time_t数据�c�d��来表�C�的�Q�用time_t表示的时��_��日历旉��Q�是从一个时间点�Q�例如：1970�q?�?�?�?�?�U�）到此时的�U�数。在time.h中，我们也可以看到time_t是一个长整型敎ͼ�
#ifndef _TIME_T_DEFINED
typedef long time_t; /* 旉��?*/
#define _TIME_T_DEFINED /* 避免重复定义 time_t */
#endif

大家可能会��生疑问：既然time_t实际上是长整型，到未来的某一天，从一个时间点�Q�一般是1970�q?�?�?�?�?�U�）到那时的�U�数�Q�即日历旉��Q�超��Z��长整形所能表�C�的数的范围怎么办？对time_t数据�c�d��的值来��_��它所表示的时间不能晚�?038�q?�?8�?9�?4�?7�U�。�ؓ了能够表�C�更久远的时��_��一些编译器厂商引入�?4位甚��x��长的整�Ş数来保存日历旉��。比如微软在Visual C++中采用了__time64_t数据�c�d��来保存日历时��_��q��过_time64()函数来获得日历时��_��而不是通过使用32位字的time()函数�Q�，�q�样��可以通过该数据类型保�?001�q?�?�?�?�?�U�（不包括该旉��点）之前的时间�?

在time.h头文件中�Q�我们还可以看到一些函敎ͼ�它们都是以time_t为参数类型或�q�回值类型的函数�Q?
double difftime(time_t time1, time_t time0);
time_t mktime(struct tm * timeptr);
time_t time(time_t * timer);
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);

此外�Q�time.h�q�提供了两种不同的函数将日历旉��Q�一个用time_t表示的整敎ͼ�转换为我们��^时看到的把年月日时分�U�分开昄��的时间格式tm�Q?

struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);

通过查阅MSDN�Q�我们可以知道Microsoft C/C++ 7.0中时间点的��|��time_t对象的��|��是从1899�q?2�?1�?�?�?�U�到该时间点所�l�过的秒敎ͼ�而其它各�U�版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970�q?�?�?�?�?�U�到该时间点所�l�过的秒数�?

4�Q�与日期和时间相关的函数及应�?

在本节，我将向大家展�C�怎样利用time.h中声明的函数�Ҏ��间进行操作。这些操作包括取当前旉��、计��时间间隔、以不同的�Ş式显�C�时间等内容�?

4.1 获得日历旉��

我们可以通过time()函数来获得日历时��_��Calendar Time�Q�，其原型�ؓ�Q�time_t time(time_t * timer);
如果你已�l�声明了参数timer�Q�你可以从参数timer�q�回现在的日历时��_��同时也可以通过�q�回��D��回现在的日历旉��Q�即从一个时间点�Q�例如：1970�q?�?�?�?�?�U�）到现在此时的�U�数。如果参��Cؓ�I�（NUL�Q�，函数��只通过�q�回��D��回现在的日历旉��Q�比如下面这个例子用来显�C�当前的日历旉��Q?

#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}

�q�行的结果与当时的时间有养I��我当时运行的�l�果是：

The Calendar Time now is 1122707619

其中1122707619��是我运行程序时的日历时间。即�?970�q?�?�?�?�?�U�到此时的秒数�?

4.2 获得日期和时�?

�q�里说的日期和时间就是我们��^时所说的�q�、月、日、时、分、秒�{�信息。从�W?节我们已�l�知道这些信息都保存在一个名为tm的结构体中，那么如何��一个日历时间保存�ؓ一个tm�l�构的对象呢�Q?

其中可以使用的函数是gmtime()和localtime()�Q�这两个函数的原型�ؓ�Q?

struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);

其中gmtime()函数是将日历旉��转化��Z��界标准时��_��x��林尼��L��_��Q��ƈ�q�回一个tm�l�构体来保存�q�个旉��Q�而localtime()函数是将日历旉��转化为本地时间。比如现在用gmtime()函数获得的世界标准时间是2005�q?�?0�?�?8�?0�U�，那么我用localtime()函数在中国地��得的本地旉��会比世界标准旉��?个小�Ӟ��?005�q?�?0�?5�?8�?0�U�。下面是个例子：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NUL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}

�q�行�l�果是：

Local hour is: 15
UTC hour is: 7

4.3 固定的时间格�?

我们可以通过asctime()函数和ctime()函数��时间以固定的格式显�C�出来，两者的�q�回值都是char*型的字符丌Ӏ�返回的旉��格式为：

星期�?月䆾日期 �?�?�U?�q�\n\0
例如�Q�Wed Jan 02 02:03:55 1980\n\0

其中\n是一个换行符�Q�\0是一个空字符�Q�表�C�字�W�串�l�束。下面是两个函数的原型：
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);
其中asctime()函数是通过tm�l�构来生成具有固定格式的保存旉��信息的字�W�串�Q�而ctime()是通过日历旉��来生成时间字�W�串。这��L��话，asctime�Q�）函数只是把tm�l�构对象中的各个域填到时间字�W�串的相应位�|�就行了�Q�而ctime�Q�）函数需要先参照本地的时间设�|�，把日历时间�{化�ؓ本地旉��Q�然后再生成格式化后的字�W�串。在下面�Q�如果t是一个非�I�的time_t变量的话�Q�那么：
printf(ctime(&t));
�{��h于：
struct tm *ptr;
ptr=localtime(&t);
printf(asctime(ptr));
那么�Q�下面这个程序的两条printf语句输出的结果就是不同的了（除非你将本地时区设�ؓ世界标准旉��所在的时区�Q�：

#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
return 0;
}

�q�行�l�果�Q?

Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005

4.4 自定义时间格�?

我们可以使用strftime�Q�）函数��时间格式化为我们想要的格式。它的原型如下：

size_t strftime(
char *strDest,
size_t maxsize,
const char *format,
const struct tm *timeptr
);

我们可以�Ҏ��format指向字符串中格式命��o把timeptr中保存的旉��信息攑֜�strDest指向的字�W�串中，最多向strDest中存放maxsize个字�W�。该函数�q�回向strDest指向的字�W�串中放�|�的字符数�?

函数strftime()的操作有些类��g��sprintf()�Q�识别以癑ֈ��?%)开始的格式命��o集合�Q�格式化输出�l�果攑֜�一个字�W�串中。格式化命��o说明串strDest中各�U�日期和旉��信息的确切表�C�方法。格式串中的其他字符原样放进串中。格式命令列在下面，它们是区分大��写的�?

%a 星期几的��?
%A 星期几的全称
%b 月分的简�?
%B 月䆾的全�U?
%c 标准的日期的旉��?
%C �q�䆾的后两位数字
%d 十进制表�C�的每月的第几天
%D �?�?�q?
%e 在两字符域中�Q�十�q�制表示的每月的�W�几�?
%F �q?�?�?
%g �q�䆾的后两位数字�Q��用基于周的年
%G �q�分�Q��用基于周的年
%h ��写的月䆾�?
%H 24��时制的��时
%I 12��时制的��时
%j 十进制表�C�的每年的第几天
%m 十进制表�C�的月䆾
%M 十时制表�C�的分钟�?
%n 新行�W?
%p 本地的AM或PM的等��h��C?
%r 12��时的时�?
%R 昄��时和分钟：hh:mm
%S 十进制的�U�数
%t 水��^制表�W?
%T 昄��时分�U�：hh:mm:ss
%u 每周的第几天�Q�星期一为第一�?�Q��g��0�?�Q�星期一�?�Q?
%U �W�年的第几周�Q�把星期日做为第一天（��g��0�?3�Q?
%V 每年的第几周�Q��用基于周的年
%w 十进制表�C�的星期几（��g��0�?�Q�星期天�?�Q?
%W 每年的第几周�Q�把星期一做�ؓ�W�一天（��g��0�?3�Q?
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十�q�制�q�䆾�Q��g��0�?9�Q?
%Y 带世�U�部分的十进制年�?
%z�Q?Z 时区名称�Q�如果不能得到时区名�U�则�q�回�I�字�W��?
%% 癑ֈ��?

如果��x��C�现在是几点了，�q�以12��时制显�C�，��p��下面�q�段�E�序�Q?

#include “time.h�?
#include “stdio.h�?
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NUL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}

其运行结果�ؓ�Q?
It is now 4PM

而下面的�E�序则显�C�当前的完整日期�Q?

#include
#include

void main( void )
{
struct tm *newtime;
char tmpbuf[128];
time_t lt1;
time( <1 );
newtime=localtime(<1);
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
printf(tmpbuf);
}

�q�行�l�果�Q?

Today is Saturday, day 30 of July in the year 2005.

4.5 计算持箋旉��的长�?

有时候在实际应用中要计算一个事件持�l�的旉��长度�Q�比如计��打字速度。在�W?节计旉��分中�Q�我已经用clock函数举了一个例子。Clock()函数可以�_��到毫�U��。同�Ӟ��我们也可以��用difftime()函数�Q�但它只能精��到�U�。该函数的定义如下：

double difftime(time_t time1, time_t time0);

虽然该函数返回的以秒计算的时间间隔是double�c�d��的，但这�q�不说明该时间具有同double一��L��_��度，�q�是由它的参数觉得的�Q�time_t是以�U��ؓ单位计算的）。比如下面一�D늨�序：

#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
time_t start,end;
start = time(NUL);
system("pause");
end = time(NUL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}

�q�行�l�果为：
��h��L��键��l? . .
The pause used 2.000000 seconds.
��h��L��键��l? . .

可以惛_��Q�暂停的旉��q�不那么巧是整整2�U�钟。其实，你将上面�E�序的带有�?/<-”注释的一行用下面的一行代码替换：

printf("The pause used %f seconds.\n",end-start);

其运行结果是一��L��?

4.6 分解旉��转化为日历时�?

�q�里说的分解旉��是以年、月、日、时、分、秒�{�分量保存的旉��l�构�Q�在C/C++中是tm�l�构。我们可以��用mktime�Q�）函数��用tm�l�构表示的时间�{化�ؓ日历旉��。其函数原型如下�Q?
time_t mktime(struct tm * timeptr);
其返回值就是�{化后的日历时间。这��h��们就可以先制定一个分解时��_��然后对这个时间进行操作了�Q�下面的例子可以计算�?997�q?�?日是星期几：
#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}
�q�行�l�果�Q?
Tue Jul 01 00:00:01 1997

现在注意了，有了mktime()函数�Q�是不是我们可以操作现在之前的�Q何时间呢�Q�你可以通过�q�种办法��出1945�q?�?5��h��星期几吗�Q�答案是否定的。因��个时间在1970�q?�?日之前，所以在大多数编译器中，�q�样的程序虽然可以编译通过�Q�但�q�行时会异常�l�止�?

5�Q��ȝ��

本文介绍了标准C/C++中的有关日期和时间的概念�Q��ƈ通过各种实例讲述了这些函数和数据�l�构的��用方法。笔者认为，和时间相关的一些概忉|��相当重要的，理解�q�些概念是理解各�U�时间格式的转换的基��Q�更是应用这些函数和数据�l�构的基��?img src ="http://www.tkk7.com/huyi2006/aggbug/114844.html" width = "1" height = "1" />

allic 2007-04-30 18:50 发表评论

动态二�l�数�l�的内存分配问题

allic — Sat, 14 Apr 2007 02:01:00 GMT

一个关于动态二�l�数�l�分配内存的问题�Q�以前也有做遇见�q�这��L��Q�今天在�|�上参考了一个可以分配�Q意类型的�C�Z��Q�写了一个仅分配整型的二�l�数�l�小��试�E�序�Q�在VC++6.0上测试通过

int **AllocMatrix ( int iRow, int iCol )
void FreeMatrix ( int** p )

�C�Z��E�序�Q?/p>

#include < stdio.h >
#include < stdlib.h >
#include < string .h >
//////////////////////////////////////////////////////////// //
void FreeMatrix( int ** p);
int ** AllocMatrix( int iRow, int iCol);

int ** AllocMatrix( int iRow, int iCol)
{
     int ** tdarray = NULL;
     int * tmparray = NULL;
     int i = 0 ;
     // allocate pointer array
     if ( ! (tdarray = ( int ** )malloc( sizeof ( char * ) * iRow)))
     {
        printf( " allocate iRow wrong\n " );
        exit( 1 );
    }
     // allocate actual array space
     if ( ! (tmparray = ( int * )malloc( sizeof ( int ) * (iRow * iCol))))
     {
        FreeMatrix(tdarray);
        printf( " allocate iRow wrong\n " );
        exit( 1 );
    }
     // initialize memory
    memset(tmparray, 0x00 , sizeof ( int ) * (iRow * iCol));
     // evaluate the pointer array
     for (i = 0 ; i < iRow; i ++ )
        tdarray[i] = (tmparray + (i * iCol) * sizeof ( int ));
     return tdarray;
}

void FreeMatrix( int ** p)
{
     if (p)
     {
        free(p[ 0 ]);
        free(p);
    }
}

void main( void )
{
     int ** arr = AllocMatrix( 2 , 2 );
    arr[ 1 ][ 1 ] = 1 ;
    arr[ 0 ][ 1 ] = 4 ;
    printf( " %d, %d \n " ,arr[ 1 ][ 1 ], arr[ 0 ][ 1 ]);
    FreeMatrix(arr);
}

allic 2007-04-14 10:01 发表评论

C语言中动态分配数�l?一�l?

allic — Fri, 13 Apr 2007 13:36:00 GMT

C语言中动态分配数�l?一�l?

当初学Pascal的时候就惌��q�个问题�Q�如何动态的定义及��用数�l�呢�Q�记得一般用数组的时候都是先指定大小的。当旉��老师�Q�老师说是不可以的。后来又问了一位教C++的老师�Q�他告诉我在C++里用new可以做到�Q�一直不用C++�Q�所以也不明白。今天在逛论坛时�l�于扑ֈ�了C语言中的用法(看原�?�Q?/p>

    int *a;
    int N;
    scanf("%d", &N);
    a = (int *) malloc(N * sizeof(int));
    ....
    free(a);

�q�样��动态分配了数组a[N]。数�l�的长度N可输入确定，也可用程序中的变量确定。但要注意程序结束后要用free()��其释放�Q�否则内存会泄漏�?

--------------------------------------------------------------------------------
验证一下：

#include
#include
int main()
{
int i = 0;

int *a;
int N;

    printf("Input array length: ");
    scanf("%d", &N);
    printf("\n");

    a = (int *) malloc(N * sizeof(int));

    for(i = 0; i < N; i++)
    {
        a[i] = i + 1;

        printf("%-5d", a[i]);
        if ((i + 1) % 10 == 0)
            printf("\n");
    }

free(a);

printf("\n");
return 0;
}

�q�行�l�果(VC):
=========================================================
Input array length: 100�?/p>

1    2    3    4    5    6    7    8    9    10
11   12   13   14   15   16   17   18   19   20
21   22   23   24   25   26   27   28   29   30
31   32   33   34   35   36   37   38   39   40
41   42   43   44   45   46   47   48   49   50
51   52   53   54   55   56   57   58   59   60
61   62   63   64   65   66   67   68   69   70
71   72   73   74   75   76   77   78   79   80
81   82   83   84   85   86   87   88   89   90
91   92   93   94   95   96   97   98   99   100

=========================================================

allic 2007-04-13 21:36 发表评论