linux C++/C 动态链接库使用

linux下的生成动态库是so

gcc -shared 就可以。
　1.对Linux操作，一般都推荐在普通用户模式下，如果需要超级用户的权限，则可以通过su root，输入root用户密码切换。我是个人学习使用，同时又有很多的操作都要使用root用户，因此就直接在root用户下进行编译。 
　　2.编译生成动态库的命令为：gcc (-fpic) -shared -o libmyfunction.so myfunction.c 
　　-fpic 使输出的对象模块是按照可重定位地址方式生成的。
　　-shared指定把对应的源文件生成对应的动态链接库文件。

有关动态链接库的概念，何时使用，使用的优点就不在此多多解释了，下面，简单记录一下使用的具体过程。

1、涉及到的库<dlfcn.h>，该库中提供了四个轻松调用动态链接库的API
 a) void *dlopen (const char *so_file_path, int open_mode)
  dlopen是打开动态链接库文件的API，这里so_file_path是so文件的路径，open_mode是打开so文件的模式，
  常用的有两种：RTLD_NOW和RTLD_LAZY，
  RTLD_NOW：在dlopen()方法调用完成之前就去动态的解析so文件里面的所有未定义的符号，如果无法解析，则打开失败。
  RTLD_LAZY: 只有当so文件里面的未定义的符号在真正使用的时候才去解析。
  这里要注意的是：如果加载的动态库还依赖其他的动态库，必须使用RTLD_NOW。
  函数调用成功，则返回该so文件的句柄（指针）so_handle，否则返回NULL。
 b) void *dlsym (void *so_handle,const char *method_name)
  dlsym的调用是用来得到so文件某个具体的函数的指针的，函数调用成功则返回method_name函数的指针，否则返回NULL。
  so_handle：使用dlopen()返回的so句柄
  method_name：定义在so中的方法名（这里要注意的是，该so方法中不能有重载的函数，当然，c语言是不支持函数重载的）
 c) int dlclose (void *so_handle)
  关闭dlopen()返回的so句柄
  这里要注意：如果在使用dlsym()返回的函数指针的时候调用了该方法，那么，肯定会出现Segment fault的错误，因为调用此方法之后，代表对so动态库的资源回收。
 d) char *dlerror (void)
  返回在调用上述方法失败时的具体错误信息。

2、下面来看一个简单的实例：
 该实例的场景是：把student.cpp和teacher.cpp写成动态库的形式提供给callPlugin.cpp调用，如果再需要开发一个其他的类如：police.cpp，只需要按照有关约定编写好，再编译成动态库，则可不要更改任何应用程序的框架代码，即 实现了插件式开发。
 1）base.h，该文件的作用是定义两个基本方法，也就是接口方法，提供给接口调用者和接口实现者使用。
 // base.h
 #include<iostream>
 #include<string>
 using namespace std; 

 class BasePeople;
 // 下面两个方法必须都用extern "C"进行修饰，这个主要是因为C++中的符号命名方法和C的不一样，具体可以查看有关资料
 // 在C++中，方法method(int a, float b)可能会被命名为：method_int_float，而在C++中则命名为:method
 // 这其实就是C++能支持函数重载，而C却不能的主要原因之一
 extern "C" BasePeople* create_BasePeople(const string & name, const int age);
 extern "C" void delete_BasePeople(BasePeople * pp);
 
 static const string __CREATE_OBJECT__ = "create_BasePeople";
 static const string __DELETE_OBJECT__ = "delete_BasePeople";

 class BasePeople{
  public:
   BasePeople(const string & name, const int age) : name_(name),age_(age){ 
    cout << "BasePeople's constructor invoked" << endl;
   } 
   
   virtual ~BasePeople(){
    cout << "BasePeople's de-constructor invoked" << endl;
   }
   
   virtual void speak() = 0;
   void test(){
    cout << "This is the test method!" << endl;
   }
  protected:
   int age_;
   string name_;
 };
 
 2）student.cpp,该文件是class BasePeople的继承类，同时，该文件将被生成libstudent.so动态库，同时提供给callPlugin.cpp调用
 // student.cpp
 #include "base.h" 

 class student : public BasePeople{
  public:
   student(const string & name, const int age) : BasePeople(name,age)
   {
    cout << "student's constructor invoked" << endl;
   }
   
   virtual ~student(){
    cout << "student's de-constructor invoked" << endl;
   }
   
   virtual void speak(){
    int i = 0;
    while(i < 10){
     cout << "I am a student, my name is " << this->name_ << ", and my age is " << this->age_ << endl;
     sleep(1);
     ++ i;
    }
   }
 };
 
 // 动态库文件libstudent.so中必须包含有在base.h中申明的两个extern "C" 方法
 BasePeople* create_BasePeople(const string & name, const int age){
  //student* sd = new student(name,age);
  return new student(name,age); 
 }

 void delete_BasePeople(BasePeople * pp){
  if(pp)
   delete pp;
 }
 
 3）teacher.cpp，该文件和student.cpp一样，只是会生成libteacher.so动态库。
 // teacher.cpp
 #include "base.h"

 class teacher : public BasePeople{
  public:
   teacher(const string & name, const int age) : BasePeople(name,age)
   {
    cout << "teacher's constructor invoked" << endl;
   }
   
    virtual ~teacher(){
    cout << "teacher's de-constructor invoked" << endl;
   }
   
   virtual void speak(){
    int i = 0; 
    while(i < 10){
     cout << "I am a teacher, my name is " << this->name_ << ", and my age is " << this->age_ << endl;
     sleep(1);
     ++ i;
    }
   }
 }; 

 BasePeople* create_BasePeople(const string & name, const int age){
  //teacher* sd = new teacher(name,age);
  return new teacher(name,age); 
 }

 void delete_BasePeople(BasePeople * pp){
  if(pp)
   delete pp;
 }
 
 4）callPlugin.cpp调用类的实现
 // callPlugin.cpp
 #include "base.h"
 #include <dlfcn.h>
 #include <pthread.h>
  
 class callPlugin{
  typedef BasePeople* ObjectPtr;
  typedef ObjectPtr (*createObjectPtr)(const string &, const int);
  typedef void (*deleteObjectPtr)(ObjectPtr);

  public:
   callPlugin(const string & soPath, const int openMode = RTLD_LAZY) : soPath_(soPath), openMode_(openMode){
    cout << "callPlugin constructor invoked!" << endl;
   }
    
   ~callPlugin(){
    cout << "callPlugin de-constructor invoked!" << endl;
   } 
   
   int excute(){
    void * pluginHandler = openPlugin();
    if(pluginHandler){
     // 得到create_BasePeople方法的指针
     createObjectPtr createFunc = (createObjectPtr) dlsym(pluginHandler,__CREATE_OBJECT__.c_str());
     ObjectPtr people = NULL;
     if(createFunc){
      people = createFunc("luoxiaoyi",23);
      people->speak();
      people->test();
     }else{
      cout << "callPlugin::excute() createFunc error :" << dlerror() << endl;
     }
     
     // 得到delete_BasePeople方法的指针
     deleteObjectPtr deleteFunc = (deleteObjectPtr) dlsym(pluginHandler,__DELETE_OBJECT__.c_str());
      
     if(deleteFunc){
      deleteFunc(people);
     }else{
      cout << "callPlugin::excute() deleteFunc error :" << dlerror() << endl;
     }
     
     // 关闭pluginHandler，回收资源
     dlclose(pluginHandler); 
     pluginHandler = NULL;
    }else{
     cout << "callPlugin::excute() pluginHandler error :" << dlerror() << endl;
    }
   }
  private:
   // so动态库的路径，可以是绝对路径，也可以是相对路径
   string soPath_;
   // so动态库的打开模式RTLD_NOW，RTLD_LAZY
   int openMode_;
   
   /**
   * 调用dlopen，同时得到相关so文件的句柄
   */
   void* openPlugin(){
    if(soPath_.size() < 1){
     cout << "plugin file[soPath=" << soPath_ << "] cannot be empty!" << endl;
     return NULL;
    }
    
    if(openMode_ == RTLD_NOW || openMode_ == RTLD_LAZY)
     return dlopen(soPath_.c_str(),openMode_);
    else
     return dlopen(soPath_.c_str(),RTLD_LAZY);
   }
 };
 
 // 供多线程调用的方法
 void* callFun(void *arg){
  callPlugin* cp = (callPlugin*) arg;
  cp->excute();
 }
 /*************************************************** main() **********************************************/
 int main(){
  // 加载动态库
  callPlugin cp1("libstudent.so");        // ----------------------------->标记1
  callPlugin cp2("libteacher.so");   // ----------------------------->标记2
  
  // 创建新线程，用于调用libteacher.so的执行
  pthread_t thread;
  pthread_create(&thread,NULL,callFun,&cp2); 
  
  // 执行
  cp1.excute();  
  
  // 等待thread线程执行完毕
  pthread_join(thread,NULL);
  return 0;
 }
 
 5）编译指令
 g++ teacher.cpp -fPIC -shared -o /usr/local/cep/libteacher.so
 g++ student.cpp -fPIC -shared -o /usr/local/cep/libstudent.so
 g++ callPlugin.cpp base.cpp -o callPlugin -ldl -pthread 
 
 6）可能出现的问题以及参考解决方案
 编译完成之后，如果你此时运行./callPlugin，则可能会报无法找到动态库的错误。解决的方法如下：
 a）讲main方法中的标记1和2里面so文件的路径改为绝对路径/usr/local/cep/libstudent.so、/usr/local/cep/libteacher.so，重新编译callPlugin.cpp，然后运行，如果还不行尝试b）；
 b）如果你有root权限，可以通过修改/etc/ld.so.conf来达到此目的，修改方法为：在/etc/ld.so.conf中加入你的so所在的目录，在这里如：/usr/local/cep，完了之后，再运行ldconfig命令，至于为何要这样，您可以网上搜下/etc/ld.so.conf的作用，如果没有root权限，则可尝试c）；
 c）没有root权限的情况，可以通过用环境变量LD_LIBRARY_PATH指定路径，但是这里要注意的是，不同的系统可能环境变量不一样，指定方法如：LD_LIBRARY_PATH=.;这样就把LD_LIBRARY_PATH指定为当前目录，然后使用export LD_LIBRARY_PATH命令即可。
 
 通过以上三步，你基本可以解决库文件无法找到的问题了，如果还是无法解决相关问题，那么请网上找找对应的错误咯
 注意：添加了-c参数，即g++ -c那么很有可能出现only ET_DYN and ET_EXEC can be loaded错误，解决方法简单，去掉-c即可。