windows动态库开发

最新推荐文章于 2024-03-09 16:06:22 发布
最新推荐文章于 2024-03-09 16:06:22 发布
阅读量1.6k 收藏 7
点赞数 1
分类专栏： C/C++笔记 文章标签： C DLL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yahstudio/article/details/38794037
版权

本篇主要讲述动态库的开发、动态库的测试与调用、添加log日志记录的应用。


动态库原理浅析

1.       动态库是什么，它有什么作用？

Windows系统平台上提供了一种完全不同的较有效的编程和运行环境，你可以将独立的程序模块创建为较小的DLL(Dynamic Linkable Library)文件，并可对它们单独编译和测试。在运行时，只有当EXE程序确实要调用这些DLL模块的情况下，系统才会将它们装载到内存空间中。这种方式不仅减少了EXE文件的大小和对内存空间的需求，而且使这些DLL模块可以同时被多个应用程序使用。详见文档《Win32环境下动态链接库(DLL)编程原理》。

 

2.       动态库的导出

动态库的导出有两种方法：

(1)     __declspec(dllexport)intMyFunction(int n);

这样就可以将动态库中的函数MyFunction()导出了。

(2)     需要一个Des文件，通过该文件来导出动态库。

（Master没细说这种方法，不过说了这两种方法都较常用）

说明：在后面的例程中将使用第一种导出方法，并且将__declspec(dllexport)int放到宏定义中去。

 

3.       与DLL模块建立链接（应用程序加载动态库）

与DLL模块建立链接也有两种方法：

(1)     隐式链接方式

程序员在建立一个DLL文件时，链接程序会自动生成一个与之对应的LIB导入文件。该文件包含了每一个DLL导出函数的符号名和可选的标识号，但是并不含有实际的代码。LIB文件作为DLL的替代文件被编译到应用程序项目中。具体操作方法会在后面提到。

(2)     显式链接方式（动态加载）

显式链接方式对于集成化的开发语言（例如VB）比较适合。

 

说明：在后面的例程中将使用第一种链接方法。

 

4.       应用程序(exe文件)怎样找到动态库？

(Master)这对于不同的系统版本，其方式不一样，如在XP、win7、win8系统下都不一样。例如在XP系统下，应用程序是优先到C:\Windows\System32路径下去找，完了之后再到对应目录下去找。

 

动态库的调用

先不说如何开发动态库，先来感受一下动态库是如何被使用的。

Step1：复制所需文件到指定位置

这里需要三个文件，socketclient.dll、socketclient.lib、socketclientdll.h，将这三个文件复制到项目目录下，如下图所示。然后再将头文件socketclientdll.h添加到工程里。

 

dll和lib文件打不开，这里就只展示socketclientdll.h文件了。

/*
下面定义了一套socket客户端发送报文接受报文的api接口
请写出这套接口api的调用方法
*/
 
#ifndef _INC_Demo01_H
#define _INC_Demo01_H
 
#ifdef  __cplusplus
extern "C" {
#endif
   
    //------------------第一套api接口---Begin--------------------------------//
    //客户端初始化获取handle上下
    int cltSocketInit(void **handle /*out*/);
   
    //客户端发报文
    int cltSocketSend(void *handle /*in*/, unsigned char *buf /*in*/,  int buflen /*in*/);
   
    //客户端收报文
    int cltSocketRev(void *handle /*in*/, unsigned char *buf /*in*/, int *buflen /*in out*/);
   
    //客户端释放资源
    int cltSocketDestory(void *handle/*in*/);
    //------------------第一套api接口---End-----------------------------------//
   
   
    //------------------第二套api接口---Begin--------------------------------//
    //客户端初始化
    int cltSocketInit2(void **handle);
 
    //客户端发报文
    int cltSocketSend2(void *handle, unsigned char *buf,  int buflen);
   
    //客户端收报文
    int cltSocketRev2(void *handle, unsigned char **buf, int *buflen);
    int cltSocketRev2_Free(unsigned char **buf);
   
    //客户端释放资源
    int cltSocketDestory2(void **handle);
    //------------------第二套api接口---End--------------------------------//
   
#ifdef  __cplusplus
}
#endif
 
#endif  /* _INC_Demo01_H */

 

Step2：链接lib文件

右击工程名→properties，弹出如下对话框，

 

将socketclient.lib文件的文件名复制到图中所示位置，完了如下图。

 

 

Step3：新建源文件，编写调用动态库的代码。

main.c文件

#include "stdio.h"
#include "string.h"
#include "socketclientdll.h"
 
int main()
{
    int  rv = 0;
    void *handle = NULL;
    unsigned char buf[100];//in
    int buflen = 100;//in
    unsigned char buf2[2048];
    int buflen2 = 2048;
 
    strcpy(buf, "abcdef");//将字符串"abcdef"拷贝到buf中，包括。
    buflen = strlen(buf);
   
//C语言的数据，并不一定都是以结尾的字符串，
    //比如说对明文加密的密文。
 
    //客户端初始化
    rv = cltSocketInit(&handle);//显然是在被调函数cltSocketInit()中为handle分配内存。（千万不能将handle声明为二级指针，然后再传递给该函数。）
    if(rv != 0)
    {
       return rv;
    }
   
    //客户端发报文
    rv = cltSocketSend(handle, buf, buflen);//debug时只能看到handle中存放的地址，看不到该地址所指内存空间的值，所以不确定handle所指字符是否以结尾。
    if(rv != 0)
    {
       return rv;
    }
   
    //客户端收报文
    rv = cltSocketRev(handle, buf2, &buflen2);//debug时看到buf2中只有abcdef六个字符，f后不是。所以handle所指空间的字符f后应该不是了。
    if(rv != 0)
    {
       return rv;
    }
    printf("%s\n", buf2);//buf2并非以结尾，程序执行到这里时还没有崩溃就已经很给面子了。
    //若真想正确打印接收到的报文，可以按照长度buflen2一个字符一个字符地打印。
 
    cltSocketDestory(handle);
 
    printf("hello...\n");
    getchar();
    return 0;
}

上面的例程是已经定义了一套socket客户端发送报文、接受报文的api接口，并且发送、接收等函数都已经写好了，封装在库文件中(lib文件)，我们只需调用即可。那么这些动态库库究竟是如何生成的呢？这些库文件(这里其实就是dll和lib文件)里面装的是什么呢？这在后面会详细讲到。

 

前面一节是讲述如何使用已经创建好的动态库，这一节则是讲述如何开发动态库。这里就以实现前一节的动态库功能为例来讲述实际工程开发中是如何实现动态库的创建与开发的。

动态库的建立

Step1：新建工程

第一步和之前的新建工程一样，如下图所示。

 

接下来的一步和之前略有不同，如下图所示。

 

Step2：添加头文件itcast_comm.h。头文件内容如下。

#ifndef _SOCEKETCLIET_H_
#define _SOCEKETCLIET_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define _ITCAST_OS_WIN32_ 
#define _ITCAST_OS_LINUX_
 
 
#ifdef _ITCAST_OS_WIN32_   
#define ITCAST_FUNC_EXPORT(returnType)     __declspec(dllexport) returnType
#else
#ifdef _ITCAST_OS_LINUX
#define ITCAST_FUNC_EXPORT(returnType) __attribute__ ((visibility("default"))) returnType
#else 
#define ITCAST_FUNC_EXPORT(returnType)    returnType
#endif
#endif
 
#ifdef __cplusplus
}
#endif
 
 
#endif

 

Step3：新建源文件MySocketLib.c

接下来就是在要在文件MySocketLib.c里编辑自己的库函数了。我们就以master给的第一套api接口为例来编写这些函数的具体源代码。

这里先打桩，然后再编写个动态库测试程序来看看有木有成功，若成功了则继续往下编写动态库函数。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "itcast_comm.h"
 
//------------------第一套api接口---Begin--------------------------------//
//客户端初始化
int cltSocketInit(void **handle /*out*/)
{
    printf("func cltSocketInit() begin....\n");//这里先随便输出个东西，然后再测试动态库有没有创建成功，若成功了然后再继续往下编写动态库。
    printf("func cltSocketInit() end....\n");
    return 0;
}
 
//客户端发报文
int cltSocketSend(void *handle /*in*/, unsigned char *buf /*in*/,  int buflen /*in*/)
{
    return 0;
}
 
//客户端收报文
int cltSocketRev(void *handle /*in*/, unsigned char *buf /*in*/, int *buflen /*in out*/)
{
    return 0;
}
 
//客户端释放资源
int cltSocketDestory(void *handle/*in*/)
{
    return 0;
}
//------------------第一套api接口---End-----------------------------------//

一般的函数是像上述这样定义的，可是动态库开发不一样，这里需要将各个函数的返回类型用itcast_comm.h头文件中的宏定义ITCAST_FUNC_EXPORT(returnType)来替换，完了如下所示。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "itcast_comm.h"
 
//------------------第一套api接口---Begin--------------------------------//
//客户端初始化
ITCAST_FUNC_EXPORT(int)
cltSocketInit(void **handle /*out*/)
{
    printf("func cltSocketInit() begin....\n");//这里先随便输出个东西，然后再测试动态库有没有创建成功，若成功了然后再继续往下编写动态库。
    printf("func cltSocketInit() end....\n");
    return 0;
}
 
//客户端发报文
ITCAST_FUNC_EXPORT(int)
cltSocketSend(void *handle /*in*/, unsigned char *buf /*in*/,  int buflen /*in*/)
{
    return 0;
}
 
//客户端收报文
ITCAST_FUNC_EXPORT(int)
cltSocketRev(void *handle /*in*/, unsigned char *buf /*in*/, int *buflen /*in out*/)
{
    return 0;
}
 
//客户端释放资源
ITCAST_FUNC_EXPORT(int)
cltSocketDestory(void *handle/*in*/)
{
    return 0;
}
//------------------第一套api接口---End-----------------------------------//

 

Step4：编译生成动态库文件，如下所示。


 

动态库测试程序的建立

类似动态库调用那一节，需要添加lib文件到测试工程的链接器。

Step1：新建测试工程

新建一个工程，这个工程是用来测试刚刚开发的动态库的。注意这时候就是新建一个普通的工程，与新建动态库开发环境有所不同，不同点如下图所示。

 

Step2：复制所需文件到指定位置

如“同动态库的调用”一节所述，这里也需要三个文件。

将在动态库开发中生成的两个文件MySocketLib.dll、MySocketLib.lib和socketclientdll.h共三个文件复制到指定位置，如下图所示。然后再将头文件socketclientdll.h添加到工程里。

 

Step3：链接lib文件

同样是右击工程名→properties，将MySocketLib.lib文件的文件名复制到下图所示位置。


 

Step4：新建源文件，编写调用动态库的代码。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "socketclientdll.h"
 
int main()
{
    int rv = 0;
    void *handle = NULL;
    rv = cltSocketInit(&handle);
    if(rv != 0)
    {
       printf("func cltSocketInit():%d.\n",rv);
       return rv;
    }
    printf("hello.\n");
    system("pause");
    return 0;
}

 

Step5：编译调试

在“rv = cltSocketInit(&handle);”处设置断点，如果能够成功进入该函数(也就是进入了动态库)，并成功执行该函数里面的代码，则说明动态库调用成功了。

 

编写动态库函数

当测试程序成功测试了动态库的调用后，就说明动态库已经创建成功了。接下来就是要继续完善动态库函数了。

最后动态库的源代码如下。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "itcast_comm.h"
 
//句柄只不过是一套api运行时的资源环境，说白了它就是内存首地址。
typedef struct _SocketHandle
{
    char ip[128];
    int  port;
    unsigned char *buf;
    int buflen;
}SocketHandle;
 
//------------------第一套api接口---Begin--------------------------------//
//客户端初始化
ITCAST_FUNC_EXPORT(int)
cltSocketInit(void **handle /*out*/)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    //printf("func cltSocketInit() begin....\n");
   
    sh = (SocketHandle *)malloc(sizeof(SocketHandle));
    if(sh == NULL)
    {
       ret = -1;
       return ret;
    }
    memset(sh, 0, sizeof(SocketHandle));
    strcpy(sh->ip, "192.168.1.254");//随便写得一个IP地址，演示而已。
    sh->port = 0x8;//随便写得一个数字。
 
    printf("func cltSocketInit() end....\n");
    *handle = sh;
    return ret;
}
 
//客户端发报文
ITCAST_FUNC_EXPORT(int)
cltSocketSend(void *handle /*in*/, unsigned char *buf /*in*/,  int buflen /*in*/)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    if(handle==NULL || buf==NULL || buflen>2048*10)
    {
       ret = -1;
       return ret;
    }
    sh = (SocketHandle *)handle;
    sh->buf = (char *)malloc(buflen);
    if(sh->buf == NULL)
    {
       ret = -2;
       return ret;
    }
    memcpy(sh->buf, buf, buflen);
    sh->buflen = buflen;
 
    return ret;
}
 
//客户端收报文
ITCAST_FUNC_EXPORT(int)
cltSocketRev(void *handle /*in*/, unsigned char *buf /*in*/, int *buflen /*in out*/)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    if(handle==NULL || buf==NULL || buflen==NULL)
    {
       ret = -1;
       return ret;
    }
    sh = (SocketHandle *)handle;
    memcpy(buf, sh->buf, sh->buflen);
    *buflen = sh->buflen;
 
    return ret;
}
 
//客户端释放资源
ITCAST_FUNC_EXPORT(int)
cltSocketDestory(void *handle/*in*/)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    if(handle==NULL)
    {
       ret = -1;
       return ret;
    }
    sh = (SocketHandle *)handle;
    if(sh->buf != NULL)
    {
       free(sh->buf);
       sh->buf = NULL;
    }
    if(sh != NULL)
    {
       free(sh);
       sh = NULL;
    }
    return ret;
}
//------------------第一套api接口---End-----------------------------------//

编译该动态库工程即可更新在对应路径下的动态库文件MySocketLib.dll和MySocketLib.lib。

动态库文件弄好之后，就要测试动态库中的函数是否可用，那么就要将新生成的两个库文件拷贝到之前的测试程序路径下，以替换之前的库文件。具体方法在前面已经说过了。

 

将动态库文件拷贝后，就要编写动态库测试程序了，以便于测试这些动态库函数是否可用，测试程序如下所示。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "socketclientdll.h"
 
//句柄只不过是一套api运行时的资源环境，说白了它就是内存首地址。
int main()
{
    int rv = 0;
    void *handle = NULL;
    unsigned char buf[2048];
    int buflen = 0;
    unsigned char buf2[2048];
    int buflen2 = 0;
 
    strcpy(buf, "abcdefg123456789");
    buflen = 10;//buf中可以有个字符，但是需要发送多少个是由buflen来决定滴。
 
    rv = cltSocketInit(&handle);//为handle分配内存，初始化handle。
    if(rv != 0)
    {
       printf("func cltSocketInit():%d.\n",rv);
       return rv;
    }
 
    rv = cltSocketSend(handle, buf, buflen);//从buf中拷贝buflen个字符到handle中的buf。
    if(rv != 0)
    {
       printf("func cltSocketSend():%d.\n",rv);
       return rv;
    }
 
    rv = cltSocketRev(handle, buf2, &buflen2);//从handle中的buf拷贝buflen2个字符到buf2中。
    if(rv != 0)
    {
       printf("func cltSocketRev():%d.\n",rv);
       return rv;
    }
 
    rv = cltSocketDestory(handle);
    if(rv != 0)
    {
       printf("func cltSocketDestory():%d.\n",rv);
       return 0;
    }
 
    printf("hello.\n");
    system("pause");
    return 0;
}

编译该测试工程后，就可以调试测试动态库函数是否编写成功了，如果没有则还需要到动态库开发环境中去修改库函数，然后将新生成的库文件拷贝到测试程序路径下再次测试，这样直到测试成功为止。

 

添加日志记录

工程开发中，常常需要将程序的执行状态记录下来保存到一个日志文件中去，以便于调试。

这里需要两个文件：itcastlog.h和itcastlog.c，哪里需要用到日志记录，就将这个两个文件复制到哪里，比如上一节中的动态库想要用日志来记录程序执行状态，就将这两个文件复制到动态库程序目录下，然后将头文件itcastlog.h添加到工程中。

若在MySocketLib.c文件中想要用日志记录，那么还要在MySocketLib.c中包含头文件itcastlog.h。

 

itcastlog.h文件如下

//written by master1999@163.com
//20140323
//itcastlog.h 日志头文件
 
 
#ifndef _ITCAST_LOG_H_
#define _ITCAST_LOG_H_
 
/*
#define IC_NO_LOG_LEVEL         0
#define IC_DEBUG_LEVEL          1
#define IC_INFO_LEVEL           2
#define IC_WARNING_LEVEL    3
#define IC_ERROR_LEVEL          4;
*/
 
/************************************************************************/
/*
const char *file：文件名称
int line：文件行号
int level：错误级别
       0 -- 没有日志
       1 -- debug级别
       2 -- info级别
       3 -- warning级别
       4 -- err级别
int status：错误码
const char *fmt：可变参数
*/
/************************************************************************/
//实际使用的Level
extern int  LogLevel[5];
void ITCAST_LOG(const char *file, int line, int level, int status, const char *fmt, ...);
 
#endif

 

itcastlog.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#include "itcastLog.h"
 
#define ITCAST_DEBUG_FILE_  "socketclient.log"
#define ITCAST_MAX_STRING_LEN      10240
 
//Level类别
#define IC_NO_LOG_LEVEL         0
#define IC_DEBUG_LEVEL          1
#define IC_INFO_LEVEL           2
#define IC_WARNING_LEVEL    3
#define IC_ERROR_LEVEL          4
 
int  LogLevel[5] = {IC_NO_LOG_LEVEL, IC_DEBUG_LEVEL, IC_INFO_LEVEL, IC_WARNING_LEVEL, IC_ERROR_LEVEL};
 
//Level的名称
char ICLevelName[5][10] = {"NOLOG", "DEBUG", "INFO", "WARNING", "ERROR"};
 
static int ITCAST_Error_GetCurTime(char* strTime)
{
    struct tm*    tmTime = NULL;
    size_t        timeLen = 0;
    time_t        tTime = 0;
   
    tTime = time(NULL);
    tmTime = localtime(&tTime);
    //timeLen = strftime(strTime, 33, "%Y(Y)%m(M)%d(D)%H(H)%M(M)%S(S)", tmTime);
    timeLen = strftime(strTime, 33, "%Y.%m.%d %H:%M:%S", tmTime);
   
    return timeLen;
}
 
static int ITCAST_Error_OpenFile(int* pf)
{
    char   fileName[1024];
   
    memset(fileName, 0, sizeof(fileName));
#ifdef WIN32
    sprintf(fileName, "c:\\itcast\\%s",ITCAST_DEBUG_FILE_);
#else
    sprintf(fileName, "%s/log/%s", getenv("HOME"), ITCAST_DEBUG_FILE_);
#endif
   
    *pf = open(fileName, O_WRONLY|O_CREAT|O_APPEND, 0666);
    if(*pf < 0)
    {
        return -1;
    }
   
    return 0;
}
 
static void ITCAST_Error_Core(const char *file, int line, int level, int status, const char *fmt, va_list args)
{
    char str[ITCAST_MAX_STRING_LEN];
    int strLen = 0;
    char tmpStr[64];
    int tmpStrLen = 0;
    int  pf = 0;
   
    //初始化
    memset(str, 0, ITCAST_MAX_STRING_LEN);
    memset(tmpStr, 0, 64);
   
    //加入LOG时间
    tmpStrLen = ITCAST_Error_GetCurTime(tmpStr);
    tmpStrLen = sprintf(str, "[%s] ", tmpStr);
    strLen = tmpStrLen;
 
    //加入LOG等级
    tmpStrLen = sprintf(str+strLen, "[%s] ", ICLevelName[level]);
    strLen += tmpStrLen;
   
    //加入LOG状态
    if (status != 0)
    {
        tmpStrLen = sprintf(str+strLen, "[ERRNO is %d] ", status);
    }
    else
    {
        tmpStrLen = sprintf(str+strLen, "[SUCCESS] ");
    }
    strLen += tmpStrLen;
 
    //加入LOG信息
    tmpStrLen = vsprintf(str+strLen, fmt, args);
    strLen += tmpStrLen;
 
    //加入LOG发生文件
    tmpStrLen = sprintf(str+strLen, " [%s]", file);
    strLen += tmpStrLen;
 
    //加入LOG发生行数
    tmpStrLen = sprintf(str+strLen, " [%d]\n", line);
    strLen += tmpStrLen;
   
    //打开LOG文件
    if(ITCAST_Error_OpenFile(&pf))
    {
       return ;
    }
   
    //写入LOG文件
    write(pf, str, strLen);
    //IC_Log_Error_WriteFile(str);
   
    //关闭文件
    close(pf);
   
    return ;
}
 
void ITCAST_LOG(const char *file, int line, int level, int status, const char *fmt, ...)
{
    va_list args;
   
    //判断是否需要写LOG
//  if(level!=IC_DEBUG_LEVEL && level!=IC_INFO_LEVEL && level!=IC_WARNING_LEVEL && level!=IC_ERROR_LEVEL)
    if(level == IC_NO_LOG_LEVEL)
    {
       return ;
    }
   
    //调用核心的写LOG函数
    va_start(args, fmt);
    ITCAST_Error_Core(file, line, level, status, fmt, args);
    va_end(args);
   
    return ;
}

 

那么再实践中是如何使用的呢？其实很简单，作为示例，下面就展示一下cltSocketInit()函数是如何调用日志显示的，如下所示。

//客户端初始化
ITCAST_FUNC_EXPORT(int)
cltSocketInit(void **handle /*out*/)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    //printf("func cltSocketInit() begin....\n");也可以将这一句也改为用log日志记录的方式，如下所示。
    ITCAST_LOG(__FILE__, __LINE__, LogLevel[2], ret, "func cltSocketInit() begin....\n");
    sh = (SocketHandle *)malloc(sizeof(SocketHandle));
    if(sh == NULL)
    {
       ret = -1;
       ITCAST_LOG(__FILE__, __LINE__, LogLevel[4], ret, "(SocketHandle *)malloc(sizeof(SocketHandle))");
       return ret;
    }
    memset(sh, 0, sizeof(SocketHandle));
    strcpy(sh->ip, "192.168.1.254");//随便写得一个IP地址，演示而已。
    sh->port = 0x8;//随便写得一个数字。
   
    //printf("func cltSocketInit() end....\n");
    ITCAST_LOG(__FILE__, __LINE__, LogLevel[2], ret, "func cltSocketInit() end....\n");
    *handle = sh;
    return ret;
}

执行完程序后，看C:\itcast目录下的log文件，如下图所示。

生成的日志是被放在了C盘根目录下的itcast文件夹里，这可以由itcastlog.c文件中的ITCAST_Error_OpenFile()函数看出来。注意是要先在C盘根目录下新建一个文件名为itcast的文件夹。

 

 

第二套API函数实现动态库开发

前面讲述动态库的开发是基于第一套API函数接口来实现的，接下来要用第二套API函数来实现。

其实基本原理和第一套API函数实现是一样的，只不过第二套API的部分函数的接口不一样，所以导致了函数内容有些变化。如下所示。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "itcast_comm.h"
#include "itcastlog.h"
 
typedef struct _SocketHandle
{
    char ip[128];
    int  port;
    unsigned char *buf;
    int buflen;
}SocketHandle;
 
//------------------第二套api接口---Begin--------------------------------//
//客户端初始化
ITCAST_FUNC_EXPORT(int)
cltSocketInit2(void **handle)
{
    //同第一套API函数
}
 
//客户端发报文
ITCAST_FUNC_EXPORT(int)
cltSocketSend2(void *handle, unsigned char *buf,  int buflen)
{
    //同第一套API函数
}
 
//客户端收报文
ITCAST_FUNC_EXPORT(int)
cltSocketRev2(void *handle, unsigned char **buf, int *buflen)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    char *tmp = NULL;
 
    if(handle==NULL || buf==NULL || buflen==NULL)
    {
       ret = -1;
       ITCAST_LOG(__FILE__, __LINE__, LogLevel[4], ret, "cltSocketRev2():(handle==NULL || buf==NULL || buflen==NULL)");
       return ret;
    }
    sh = (SocketHandle *)handle;
 
    tmp = (char *)malloc(sh->buflen);
    if(tmp == NULL)
    {
       ret = -1;
       ITCAST_LOG(__FILE__, __LINE__, LogLevel[4], ret, "tmp = (char *)malloc(sh->buflen)");
       return ret;
    }
    *buf = tmp;
    *buflen = sh->buflen;
 
    return ret;
}
ITCAST_FUNC_EXPORT(int)
cltSocketRev2_Free(unsigned char **buf)
{
    int ret = 0;
    unsigned char *tmp = NULL;
    if(buf == NULL)
    {
       ret = -1;
       ITCAST_LOG(__FILE__, __LINE__, LogLevel[4], ret, "cltSocketRev2_Free():(buf == NULL)");
       return ret;
    }
    tmp = *buf;
    if(tmp != NULL)
    {
       free(tmp);
       tmp = NULL;
    }
    *buf = NULL;
    return ret;
}
 
//客户端释放资源
ITCAST_FUNC_EXPORT(int)
cltSocketDestory2(void **handle)
{
    int ret = 0;
    SocketHandle *sh = NULL;
 
    if(handle==NULL)
    {
       ret = -1;
       return ret;
    }
    sh = (SocketHandle *)*handle; //强制类型转换与取内容运算符优先级相同，但这里遵循从又向左的优先级。
    if(sh->buf != NULL)
    {
       free(sh->buf);
       sh->buf = NULL;
    }
    if(sh != NULL)
    {
       free(sh);
       sh = NULL;
    }
    *handle = NULL;
    return ret;
}
//------------------第二套api接口---End--------------------------------//

 

 

取取经
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
提供socket的各种使用的dll
08-25
提供socket的各种使用的dll，包括服务器的建立（线程池），消息通知，客户端的各个函数的使用
UE4 Socket多线程非阻塞通信【1】
热门推荐
迷雾森林的专栏
01-18 1万+
昨日不可追,今日尤可为.勤奋,炽诚,不忘初心 前面写了一篇有关于虚幻4加载第三方库的博客思前顾后,感觉细节还是有必要拎起来注意下. ue4自带的Fsocket用起来依旧不是那么的顺手,感觉超出了我的理解范围了.另外我也不想让我近一个礼拜研究的C++ Socket无用武之地,毅然决然的决定使用自己的C++通讯库.再美再豪华的别墅真不如自己亲手搭建的草庐来的舒畅.这就好比我表弟...
linux、windows 动态库与静态库的实现
最新发布
m0_51095029的博客
03-09 1023
在使用keil的时候遇到这样一个事情，我调用了一个函数，只有函数声明，但是我想查看函数的实现却不行，为什么会这样，这不来了嘛,我们在使用printf函数等，都是加上头文件直接调用，学校里并没有详细说这个函数的底层实现，以及动态库和静态库的概念可以理解为我写了一个通用的函数，我只希望别人使用我的函数接口，并不知道我的底层实现，那么我们可以将写的函数放在文件内编译成一个共享库。
loadlibrary：将Windows动态链接库移植到Linux
02-02
loadlibrary：将Windows动态链接库移植到Linux
linux下动态库开发调用
04-11
linux系统下用eclipse开发c++动态库（MyDll），并用c++程序（HelloWord）静态和动态2种方法调用动态库的例子，里面有比较详细的注释，适合初学者。
ffmpeg6.0最新64位windows编译动态库
10-09
鉴于ffmpeg在windows下编译比较困难,对于学习者来说需要花费很大精力,所以我在此帮大家做了。采用vs2022，msvc17.0编译,64位debug版本，添加了zlib和sdl支持，其他的已经内置了。
Windows和Linux动态库的生成及使用
目前在做 ROS相关的工作，主要是写ROS相关和C++的学习心得
04-23 2000
c和C++使用动态链接库的主要意义在于：节省系统资源当应用程序需要链接大量的库函数时，使用静态链接库会导致应用程序的体积变得很大，而且每个应用程序都需要拥有一份完整的代码库，这会浪费系统资源。相比之下，动态链接库可以被多个应用程序共享，从而避免了重复加载代码的情况，减少了系统资源的浪费。简化代码维护使用动态链接库可以将库函数和应用程序的代码分离开来，这样有利于代码的维护和升级。如果需要更新库函数，只需要替换动态链接库即可，不需要重新编译和部署应用程序。
Windows 上开发使用跨平台 C++ 动态链接库 (DLL)
henry_23的博客
07-04 2531
记录 Windows 上开发使用跨平台 C++ 动态链接库的一些问题, 包括 "未定义符号" 以及找不到库的问题.
DLL(Dynamic Link Libraries)专题
落叶小灌木.BLOG
08-29 1020
原文出处：http://www.microsoft.com/china/community/program/OriginalArticles/techdoc/dll.mspx目录 引言 调用方式 MFC中的DLL DLL入口函数 关于调用约定 关于DLL的函数 模块定义文件(.DEF) DLL程序和调用其输出函数的程序的关系引言 　　比较大的
Windows静态库和动态库的创建和使用
蜻蜓的专栏
07-10 339
偶们在实际的编程开发中，经常会遇到运行时无法找到某个DLL文件或者链接时无法找到某个LIB文件。然后，我们就开始乱GOOGLE一下，然后将VS2005的设置改变一下，或许就Ok了，我们将别人开发的DLL或者LIB导入到我们的编程中，那么这些lib，DLL到底是什么呢？下面，偶就细
动态库连接时的初始化函数
qq_37061368的博客
06-08 1576
Linux Linux上使用GCC构建动态链接库时，可以使用__attribute__((constructor))和__attribute__((destructor))函数属性来输出DLL的构造和析构函数。构造函数会在dlopen返回前或库被装载时调用，析构函数会在dlclose返回前或者main函数返回后，或者卸载库过程中被调用。 对于加载Haskell代码编写的动态链接库，使用示例如下： __attribute__((constructor)) static void hslib_ini..
windows动态链接库.rar
05-26
Dynamic Link Library，即动态链接库，是Microsoft在Windows操作系统中实现共享函数库概念的一种实现方式，这种库包含了可由多个程序同时使用的代码和数据 它其中windows中 一些作为DLL实现的文件有：ActiveX控件（.ocx）文件：如windows上的日历控件。控制面板（.cpl）文件：控制面板中的每一项都是一个专用的DLL。设备驱动程序（.drv）文件：如控制打印到打印机的打印机驱动程序。动态链接库在企业级开发中无处不在，本课程包含Windows动态链接库相关知识点，通过浅显易懂的代码与讲解，让你熟悉掌握动态链接库技术!
4.4版本ffmpeg windows动态库，包含32位和64位，支持X264和X265
02-04
使用win11的wsl1编译，比使用mingw编译的运行时效率更高，体积更小，亲测很稳定
动态库编程
08-03
DLL开发源码，包括测试代码，对DLL的开发，调用实例代码 如想了解DLL的原理，基础知识，请浏览本人博客，从原理到实践有详尽介绍 http://blog.csdn.net/mingojiang
将Windows动态链接库移植到Linux-C/C++开发
05-26
将Windows Dynamic Link库移植到Linux简介此存储库包含一个库，该库允许本机Linux程序从Windows DLL加载和调用函数。 作为演示，我已将Windows移植Windows动态链接库移植到Linux简介此存储库包含一个库，该库允许本机Linux程序从Windows DLL加载和调用函数。 作为演示，我已将Windows Defender移植到Linux。 $ ./mpclient eicar.com main（）：正在扫描eicar.com ... EngineScanCallback（）：正在扫描输入EngineScanCallback（）：已识别威胁病毒：DOS / EICAR_Test_File。 它是如何工作的？ peloader目录包含一个自ndiswrapper派生的自定义PE / COFF加载器。
windows下opencv开发库
06-16
windows下opencv开发所需的头文件，静态链接库以及动态链接库，可以直接使用不需要再编译安装。
关于在函数中定义大数组（局部变量）所导致的问题
春播秋忙
04-18 1万+
函数中定义大数组（局部变量）的问题 今天调程序时（我用的是DSP处理器），在函数内部定义了两个较大的数组:float a[300],float[300]，编译无错也无警告， 但运行时程序会出错，像是跑飞的样子，后来我将这两个大数组放到函数外（全局变量），则就正常了。 后来我百度“函数中定义大数组”，说是这造成了栈溢出，还建议不要在函数中使用较的数组。   一个由c/C++编译的程序占
关于数组类型的外部变量的声明
春播秋忙
05-15 5413
example.c unsigned int Buf[10];
关于指针在结构体中的调用
春播秋忙
04-12 4895
typedef struct { int dat; int *ptr; }Sample; Sample temp; printf("%d\n",&temp.dat); printf("%d\n",&temp.ptr); printf("%d\n",temp.dat); printf("%d\n",temp.ptr);
ffmpeg windows 动态库
10-24
FFmpeg是一款开源音视频处理工具，可以在Windows系统上...总结来说，FFmpeg的Windows动态库提供了强大的音视频处理功能，通过链接和加载这些动态库，开发人员可以自由地进行各种音视频处理操作，并实现定制化的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值