linux编译动态库与调用

      动态库是一个包含可由多个程序同时使用的代码和数据的库，动态库不是可执行文件。动态链接提供了一种方法，使进程可以调用不属于其可执行代码的函数。函数的可执行代码位于一个 动态库 中，该 动态库 包含一个或多个已被编译、链接并与使用它们的进程分开存储的函数。动态库 还有助于共享数据和资源。多个应用程序可同时访问内存中单个动态库 副本的内容。动态库 是一个包含可由多个程序同时使用的代码和数据的库。

背景还是编静态库那个背景，就是我们一个库里提供了多种排序方法，所以源代码还是原来那份源代码。

SortInterface.h

    #ifndef SORTINTERFACE_H  
    #define SORTINTERFACE_H  
      
    #define Interface  struct  
    //排序  
    Interface ISort  
    { //冒泡排序  
      virtual void BubbleSort(char* ptr,int len)=0;  
      //快速排序  
      virtual void QuickSort(char* ptr,int Low,int High)=0;  
      //一个循环排序  
      virtual void OneWhileSort(char* ptr,int len)=0;  
    };  
    //给他们一个获取我们子类对象的接口（算法实现的接口）  
    extern "C" ISort *GetCSort(void);  
    #endif  

Sort.h

    #ifndef SORT_H  
    #define SORT_H  
    #include "SortInterface.h"   
    class CSort:public ISort  
    {   
     public:  
      CSort(){}  
      ~CSort(){}  
      //冒泡排序  
      virtual void BubbleSort(char* ptr,int len);  
      //快速排序  
      virtual void QuickSort(char* ptr,int Low,int High);  
      //一个循环排序  
      virtual void OneWhileSort(char* ptr,int len);  
    };  
    #endif  

Sort.cpp

 

    #include "Sort.h"  
    ISort* GetISort(void)  
    {  
       return (new CSort);  
    }  
      
      
      //冒泡排序  
    void CSort::BubbleSort(char* ptr,int len)  
    {   
      for(int i=0;i<len-1;i++)  
      {  
          for(int j=i+1;j<len;j++)  
          {  
              if(ptr[i]>ptr[j])  
              {  
                  ptr[i]+=ptr[j];  
                  ptr[j]=ptr[i]-ptr[j];  
                  ptr[i]=ptr[i]-ptr[j];  
              }  
          }  
      }  
      return ;  
    }  
      //快速排序  
    void CSort::QuickSort(char* ptr,int Low,int High)  
    {  
       if(Low>High)  
         return;  
       char temp=ptr[Low];  
       int tempLow=Low;  
       int tempHigh=High;  
       while(tempLow<tempHigh)  
        {  
          while(tempLow<tempHigh&&temp<=ptr[tempHigh])  
             {  
               tempHigh--;  
             }  
          char tempData=ptr[tempHigh];  
          ptr[tempHigh]=ptr[tempLow];  
          ptr[tempLow]=tempData;  
          while(tempLow<tempHigh&&temp>ptr[tempLow])  
             {  
               tempLow++;  
             }  
          tempData=ptr[tempHigh];  
          ptr[tempHigh]=ptr[tempLow];  
          ptr[tempLow]=tempData;  
        }  
        QuickSort(ptr,Low,tempLow-1);  
        QuickSort(ptr,tempLow+1,High);  
        return;  
    }  
    //一个循坏排序  
    void CSort::OneWhileSort(char* Array,int len)  
    {  
        int temp=0;  
        int i=0;  
        while (i < len)  
        {    
            temp++;  
            if (i == 0 || Array[i - 1] <= Array[i])  
            {  
                i+=temp;  
                temp=0;  
            }  
            else  
            {  
                int t = Array[i];  
                Array[i] = Array[i - 1];  
                Array[i - 1] = t;  
                i--;  
            }  
        }  
        return;  
    }  

好了上面源代码已经准备好了，开始编译。

第一步：将源代码编译成动态库。

g++ Sort.cpp -fPIC -shared -o test.so

好像动态库编译完成了？那么接下来就是测试我们的动态库了

测试代码

main.cpp

#include <iostream>
#include <stdio.h>
#include <dlfcn.h>
#include <unistd.h>
//头文件
#include"SortInterface.h"

using namespace std;



int main()
{
    //动态库代码
    ISort *(*GetISort)(void);
    void *TreeDll = dlopen("../dll/dllfile/Sort.so",RTLD_LAZY);
    if(NULL == TreeDll)
    {
      printf("load library libtdlc.so error.\nErrmsg:%s\n",dlerror());
      return -1;
    }
    GetISort= (ISort *(*)(void))dlsym(TreeDll,"GetISort");
    const char *dlmsg = dlerror();
    if(NULL != dlmsg)
     {
       printf("get class testdl error\nErrmsg:%s\n",dlmsg);
       dlclose(TreeDll);
       return -1;
     }
   
    ISort*TempRule =GetISort();

    char a[20]{12,1,9,2,0,11,7,19,4,15,18,5,14,13,10,16,6,3,8,17};
    TempRule->QuickSort(a,0,19);
    for(int i=0;i<20;i++)
       {
        printf("%d\n",a[i]);
       }
  return 0;
}

编译一下可执行文件。

g++ main.cpp -o a.out -ldl     //不加ldl会报未定义的引用

./a.out //试一试