IT博客-yunshichen-随笔分类-C/C++

Ubuntu下动态共享库(so)开发精悍教程

Chenyunshi — Fri, 28 Aug 2009 13:50:00 GMT

在网上找到一篇很棒的文章: http://www.yolinux.com/TUTORIALS/LibraryArchives-StaticAndDynamic.html

翻译并根据实际情况进行了小小修改,仅关注Linux下动态共享库(Dynamic shared library .so)的开发.

1 简单的so实例

源文件

//test1.c

int test1(){
return 1;
}

//test2.c

int test2(){
return2;
}

//mytest.c

#include <stdio.h>
int test1();
int test2();
int main(){
printf("result of test1:= %d\n",test1());
printf("result of test2:= %d\n",test2());
}

打包成so文件

在代码的目录下运行如下命令: (如果你不是Ubuntu系统,请将命令的sudo都去掉)

gcc -Wall -fPIC -c *.c
gcc -shared -Wl,-soname,libctest.so.1 -o libctest.so.1.0 *.o
sudo mv libctest.so.1.0 /usr/lib
sudo ln -sf /usr/lib/libctest.so.1.0 /usr/lib/libctest.so
sudo ln -sf /usr/lib/libctest.so.1.0 /usr/lib/libctest.so.1

参数详解:

-Wall: 包含warning信息
-fPIC: 编译动态库必须,输出不依赖位置的代码(原文 :Compiler directive to output position independent code)
-shared: 编译动态库必需选项
-W1: 向链接器(Linker)传递一些参数.在这里传递的参数有 "-soname libctest.so.1"
-o: 动态库的名字. 在这个例子里最终生成动态库 libctest.so.1.0

两个符号链接的含义:

第一个:允许应用代码用 -lctest 的语法进行编译.
第二个:允许应用程序在运行时调用动态库.

2 so路径设置

为了使应用程序能够在运行时加载动态库,可以通过3种方式指定动态库的路径(以下例子均假定/opt/lib是动态库所在位置):

用ldconfig指定路径

运行

sudo ldconfig -n /opt/lib

/opt/lib 是动态库所在路径. 这种方式简单快捷,便于程序员开发.缺点是重启后即失效.

修改/etc/ld.so.conf文件

打开/etc/ld.so.confg 文件,并将/opt/lib 添加进去.

(注: 在Ubuntu系统中, 所有so.conf文件都在/etc/ld.so.conf.d目录. 你可以仿照该目录下的.conf文件写一个libctest.conf并将/opt/lib填入)

用环境变量LD_LIBRARY_PATH指定路径

环境变量的名字一般是LD_LIBRARY_PATH, 但是不同的系统可能有不同名字. 例如

Linux/Solaris: LD_LIBRARY_PATH, SGI: LD_LIBRARYN32_PATH, AIX: LIBPATH, Mac OS X: DYLD_LIBRARY_PATH, HP-UX: SHLIB_PATH) (注: 此说法未经验证)

修改~/.bashrc , 增加以下脚本:

if [ -d /opt/lib ];
then
LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH
fi

export LD_LIBRARY_PATH

在第一章的简单例子中, /usr/lib 是Ubuntu默认的动态库目录,所以我们不须指定动态库目录也能运行应用程序.

3 简单的动态调用so例子

C调用例子

保留第一章的test1.c和test2.c文件,并增加ctest.h头文件如下:

#ifndef CTEST_H
#define CTEST_H

#ifdef __cplusplus
extern "C" {
#endif

int test1();
int test2();

#ifdef __cplusplus
}
#endif

#endif

我们继续使用第一章生成的libctest.so,仅需增加一个新的应用程序 prog.c:

//prog.c

#include <stdio.h>
#include <dlfcn.h>
#include "ctest.h"

int main(int argc, char **argv)
{
   void *lib_handle;
   int (*fn)();
   char *error;

   lib_handle = dlopen("libctest.so", RTLD_LAZY);
   if (!lib_handle)
   {
      fprintf(stderr, "%s\n", dlerror());
      return 1;
   }

   fn = dlsym(lib_handle, "test1");
   if ((error = dlerror()) != NULL)
   {
      fprintf(stderr, "%s\n", error);
      return 1;
   }

   int y=fn();
   printf("y=%d\n",y);

   dlclose(lib_handle);

   return 0;
}

然后用如下命令运行(由于没有使用其他库,所以忽略-L等参数):

gcc -Wall prog.c -lctest -o prog -ldl
./progdl

方法简介

dlopen("libctest.so", RTLD_LAZY): 加载动态库,如果加载失败返回NULL. 第二个参数可以是:

RTLD_LAZY: lazy模式. 直到源码运行到改行才尝试加载.
RTLD_NOW: 马上加载.
RTLD_GLOBAL: 不解(原文: Make symbol libraries visible.)

dlsym(lib_handle, "test1"): 返回函数地址. 如果查找函数失败则返回NULL.

和微软的动态加载dll技术对比如下:

::LoadLibrary() - dlopen()
::GetProcAddress() - dlsym()
::FreeLibrary() - dlclose()

C++调用例子

增加一个prog2.cpp

#include <dlfcn.h>
#include <iostream>
#include "ctest.h"

using namespace std;
int main(){
    void *lib_handle;
    //MyClass* (*create)();
    //ReturnType (* func_name)();
    int (* func_handle)();
    string nameOfLibToLoad("libctest.so");
    lib_handle = dlopen(nameOfLibToLoad.c_str(), RTLD_LAZY);
    if (!lib_handle) {
        cerr << "Cannot load library: " << dlerror() << endl;
    }
    // reset errors
    dlerror();
    // load the symbols (handle to function "test")
    //create = (MyClass* (*)())dlsym(handle, "create_object");
    //destroy = (void (*)(MyClass*))dlsym(handle, "destroy_object");
    func_handle =(int(*)())dlsym(lib_handle, "test1");

    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        cerr << "Cannot load symbol test1: " << dlsym_error << endl;
    }

    cout<<"result:= "<<func_handle()<<endl;

    dlclose(lib_handle);

    return 0;
}

然后用如下命令运行:

g++ -Wall prog2.cpp -lctest -o prog2 -ldl
./prog2

编译命令简介

假设C文件是prog.c, C++调用文件是prog2.cpp,那么编译脚本分别是:

C语言:

gcc -Wall -I/path/to/include-files -L/path/to/libraries prog.c -lctest -o prog

C++语言:

g++ -Wall -I/path/to/include-files -L/path/to/libraries prog2.cpp -lctest -ldl -o prog2

参数详解:

-I: 指定头文件目录.
-L: 指定库目录.
-lctest: 调用动态库libctest.so.1.0. 如果在打包so时没有创建第一个符号链接,那么这个参数会导致编译不成功.
-ldl: C++编译必须

4 C++开发带class的so

//myclass.h

#ifndef __MYCLASS_H__
#define __MYCLASS_H__

class MyClass
{
public:
  MyClass();

  /* use virtual otherwise linker will try to perform static linkage */
  virtual void DoSomething();

private:
  int x;
};

#endif

//myclass.cpp

#include "myclass.h"
#include <iostream>

using namespace std;

extern "C" MyClass* create_object()
{
  return new MyClass;
}

extern "C" void destroy_object( MyClass* object )
{
  delete object;
}

MyClass::MyClass()
{
  x = 20;
}

void MyClass::DoSomething()
{
  cout<<x<<endl;
}

//class_user.cpp

#include <dlfcn.h>
#include <iostream>
#include "myclass.h"

using namespace std;

int main(int argc, char **argv)
{
  /* on Linux, use "./myclass.so" */
  void* handle = dlopen("./myclass.so", RTLD_LAZY);

  MyClass* (*create)();
  void (*destroy)(MyClass*);

  create = (MyClass* (*)())dlsym(handle, "create_object");
  destroy = (void (*)(MyClass*))dlsym(handle, "destroy_object");

  MyClass* myClass = (MyClass*)create();
  myClass->DoSomething();
  destroy( myClass );
}

编译和运行:

g++ -fPIC -shared myclass.cpp -o myclass.so
g++ class_user.cpp -ldl -o class_user
./class_user

Chenyunshi 2009-08-28 21:50 发表评论

C语言速记附录B 资源引用

Chenyunshi — Sun, 04 May 2008 09:27:00 GMT

摘要: 附录B 参考书和网络资源阅读全文

Chenyunshi 2008-05-04 17:27 发表评论

C语言速记第五章标准库函数

Chenyunshi — Sun, 04 May 2008 09:17:00 GMT

摘要: 标准库函数介绍和用法阅读全文

Chenyunshi 2008-05-04 17:17 发表评论

C语言速记附录A 格式速查

Chenyunshi — Sun, 04 May 2008 09:10:00 GMT

摘要: 有用的查询阅读全文

Chenyunshi 2008-05-04 17:10 发表评论

C语言速记第四章练习

Chenyunshi — Thu, 01 May 2008 07:16:00 GMT

摘要: 一些有趣的练习.管中窥豹,可以大致推断C标准库的实现. 阅读全文

Chenyunshi 2008-05-01 15:16 发表评论

C语言速记第三章拾遗补阙

Chenyunshi — Thu, 01 May 2008 07:09:00 GMT

Chapter 3 拾遗补阙

3.1 标准输入的缓冲区

当你使用标准输入函数,如getchar,gets,scanf时,请注意缓冲区问题.简言之,当你使用如下函数时:

int c=getchar();

    编译器会将键盘输入的字符存储到系统的缓冲区,再从缓冲区返回一个字符给c变量.在这个语句,实际上你至少输入了两个字符(第二个字符是回车).这个回车符号保存在缓冲区里.当你再次使用getchar或者gets时,这些函数会检查缓冲区,发现缓冲区还有字符,于是就直接读取这个字符,而不是读入键盘输入.

    也就是说,这些函数实际上并不是读入键盘输入的字符,而是先检查缓冲区.请观察以下这个错误的例子:

    puts("Input a char:");
    int c=getchar();

    puts("What char is it?");
    putchar(c);
    putchar('\n');

    c=getchar();
    putchar(c);

    system("pause");

    这个程序的本意是从键盘输入两次字符并打印.但你会发觉控制台只让你输入一次字符就自动结束.原因是第二个getchar发现缓冲区还有字符(上一个getchar留下的回车符号),所以它不等键盘输入就直接返回.

    所以,为了确保程序运行正确,每次运行getchar,gets,scanf..等函数时,先清空标准输入的缓冲区,语法如下:

fflush(stdin);

这个例子会加深你的了解:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
int main() {
    puts("Input a char:");
    int c=getchar();//Experiment to input a line instead of a char , and comment fflush(stdin) to watch the reslut.
    puts("What char is it?");
    putchar(c);
    putchar('\n');

    fflush(stdin);

    char s[20];
    puts("Input a line:");
    gets(s);

    puts("What line is it?");
    puts(s);

    fflush(stdin);

    system("pause");

    return 0;
}

Chenyunshi 2008-05-01 15:09 发表评论

C语言速记第二章指针

Chenyunshi — Fri, 25 Apr 2008 10:13:00 GMT

Chapter 2 指针

2.1 变量与内存地址

我们都很熟悉变量的声明赋值语句,例如:

int a=5;

在这个简单的语句中,编译器实际上做了如下大量的工作:

创建变量名 a
为变量分配存储空间.假设这段空间的地址是0xFF6600
在地址空间存入值"5"

当然,以上描述是抽象性的,不涉及实际的技术细节.

当我们使用这个变量,例如打印a的值时,编译器会做如下工作:

查找变量a
查找变量a的地址空间
从地址空间取值

在许多"现代"的高级编程语言里,声明变量,取值,一切都显得很自然,因为编译器隐藏了变量关于地址的细节.而C将地址细节提供给程序员,鼓励程序员写出更快效率更高的程序.

2.2 指针(Pointer)的概念

为了精确的理解指针,请区分变量值和变量的精确含义.变量a的值是字面量(literal text)5 ,这个"5"不能再改变. 但是变量a的值可以改变为6,7,8...等等.有时候你可以把变量理解为一个小仓库,里面的东西可以搬来搬去.

指针正是这样一个小仓库.不同的是char类型变量存储字符串的值,int类型存储数值型值,而地址类型(指针)存储地址的值.例如如下我们声明一个指针pa,并用&符号取出a地址并赋给pa:

int a=5;
int* pa=&a;

用一句简单的printf,你可以看到pa的值,即a的地址:

printf("Value of pa is:%x",pa);

当然,由于pa本身也是变量,根据2.1的描述,变量本身也有地址,我们可以试试打印pa的地址如下:

printf("Address of pa is:%x",&pa);

    *用于指针前表示取值,即"取指针所存储地址所存储的值".例如a的值是5,a的地址是0x66ff00,pa的值是0x66ff00,则*pa表示0x66ff00上所存储的值,也就是5.所以*pa==5;为了避免这种拗口的叫法,通常*pa也称为"取pa所指向变量的值."

    为了帮助你更好的理解指针,请确保自己理解如下几个概念:

地址:变量所分配到的存储空间.例如char型的存储空间是1字节,int型是4字节(在现代32位操作系统).
变量的值:变量所被分配存储空间所存放的字面量.例如字符型的'a','b','c',数值型的1,2,3,地址型的0xFFCC00,0xFFCCFF 等.
指针:地址的变量.指针的值不是普通的如1,2,3,'c','d','f' ... 等字面量,而是内存的地址.
& :从变量中取出地址.
* :取pa所指向变量的值.

国内一些不太精确的教科书经常将"指针"和"指针变量"概念混用,让人瞠目不知所云.根据如上的精确定义,"指针"应指地址变量,"指针变量"应指地址变量的变量.所以"指针"并不等于"指针变量".请观察如下例子:

    int a=5;
    int* pa=&a;
    int* ppa=&pa;

上例中,a是变量,pa是指针,ppa可称为指针变量,或指针的指针.有趣的是,当你声明指针的指针时,观察如下例子:

int*************************************************** ppa=&pa;

    在我的gcc3.45中编译运行正确.

    这里的讨论并不仅仅为了咬文嚼字.回想过去学习指针的经历,许多国内教材的翻译水平让我抓狂.如果你实在厌烦了玩弄文字把戏,你可以到官方网上进行学习: www.cplusplus.com

    最后,请运行这个例子以加深巩固本章节的学习(为方便对比,我将地址值以10进制形式输出):

#include <stdio.h>
#include <stdlib.h>

int main() {

    int a=5;
    int* pa=&a;

    printf("Value of a is : %d\n",a);
    printf("Address of a is : %d\n",&a);

    printf("Value of pa is : %d\n",pa);
    printf("Value of which pa pointed to is : %d\n",*pa);
    printf("Address of pa itself is : %d\n",&pa);

    int*************************************************** ppa=&pa;
    printf("Value of ppa is : %d\n",ppa);
    printf("Value of which ppa pointed to is : %d\n",*ppa);
    printf("Address of ppa itself is : %d\n",&ppa);




    //system("pause");
    return 0;
}

2.3 指针和数组

    数组和指针的关系极其紧密.数组由一系列类型相同的元素组成,这些元素的地址是连续的.事实上,数组名本身就是一个指针,只不过该指针的值不能再更改(称为常量指针).

    以下这个例子会让你加深理解:

#include
#include

int main() {
    int arr[]= { 3, 7, 9, 11, 1, 6, 7, 5, 4, 2 };

    printf("1.What's arr? %d\n", arr);
    printf("2.What's &arr? %d\n", &arr);
    printf("3.What's &arr[0]? %d\n\n", &arr[0]);

    printf("4.What's arr[-2]? %d\n", arr[-2]);
    printf("5.What's arr[2]? %d\n\n", arr[2]);

    int* pa=&arr;
    pa+=4;
    printf("6.What's *pa? %d\n", *pa);
    printf("7.What's pa[2]? %d\n", pa[2]);
    printf("8.What's pa[-2]? %d\n", pa[-2]);

    return 0;
}

有一个特性你必须知道,当数组作为函数的形参时,它实际上是一个指针.在紧接着数组声明后用sizeof函数,你可以得到数组的总地址空间,而在函数内,你用sizeof仅得到指针本身的大小(32位机器上是4字节). 例如:

#include
#include

int strlen(char* a){
    printf("Size of a is:%d\n",sizeof(a));
    int c=0;
    while(*a++)c++;
    return c;
}

int main() {
    char arr[]="Hello,world!";
    printf("Size of arr is:%d\n",sizeof(arr));


    //This couldn't be compiled.
    //arr++;

    int l=strlen(&arr);
    printf("Length of array is:%d\n",l);

    return 0;
}

2.4 指针和字符串

声明字符串可以用数组或指针方式.但这两种方式存在差异.例如:

    char a[20]="Hello,world";
    //a="hello";//This couldn't be compiled.
    a[0] ='s'; //OK.

    char* str="Hello,world";
    str="Another world!";
    str++;//OK.
    //*str='s';//This couldn't be compiled.
    //str[0]='s';//This couldn't be compiled.

总结数组方式和指针方式声明字符串的区别如下:

数组方式有实际的空间,所以可以单独改变元素值.而指针方式不能.
虽然都是指针变量.但指针方式的指针可以运算,而数组方式不能.
指针方式中的指针可以指向另一个字符串,而数组方式的指针不能.所以要改变一个数组的值,只能逐个元素进行改变.

以下这个例子演示了如何使用系统函数strcpy

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char* a="I'm a big enough buffer from string copied";
    char b[80];

    char* s="This is a beautiful world.";

    char* t=NULL;
    //t = strcpy(a,s);//Couldn't be run!
    printf("t is : %s\n",t);

    t =strcpy(b,s);
    printf("t is : %s\n",t);

    return 0;
}

技术上,指针形式定义的字符串变量实际上指向常量的字符串,该常量不能改变.有关常量和指针的关系,我们在下一节继续讨论.

2.5 指针和常量

常量是什么就不多加讨论了.见如下例子:

#include <stdio.h>
#include <stdlib.h>

int main() {
    const int a=5;
    printf("a is:%d\n",a);
    //a=6;//This will not be compiled.
}

    常量(的)指针(pointer to constant )即指向常量的指针.也就是说,假设*p==5,进行*p=6的操作会失败.

    相反,指针(的)常量(constant pointer )表示指针的值不能改变,而指针指向的对象的值可以改变.

    数组名本身就是一个指针常量,所以数组名不能进行通常的指针运算.而用指针声明字符串时,该指针是指针常量,所以不能再改变各元素的值.

    如果你觉得这个中文意义的区分有点拗口,请牢记代码方式:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int a=5,b=7;
    const int* c=&a;

    //*c=8;//This couldn't be compiled.
    c=&b;//OK.

    int* const d=&a;
    *d=10;
    //d=&a;    //This couldn't be compiled.

}

    如果const在int*之前,则该变量是常量指针.const(常量)int*(指针)
    如果const在int*之后,则该变量是指针常量.int*(指针)const(常量) .

    是不是很好记忆,呵呵.

    常量指针有着实际的实用意义.假设某个函数的形参为指针,在我们操作这个指针时,很容易把指针指向的对象值也改变,如果将该指针指向的对象声明为常量(即声明常量指针为形参),以下代码说明一切:

#include <stdio.h>
#include <stdlib.h>

int strlen(const int* str){
    int c=0;
    while(*str++){
        //*s='t';//This couldn't be compiled.
        c++;
    }
    return c;
}

int main() {
    char s[]="Don't change this string!";

    int l=strlen(s);

}

2.6 函数指针(Pointer to function)

    乍一看,C语言并没有"接口"的概念,习惯使用Java的程序员可能对此有点失望.其实,回忆一下"回调函数"的概念(callback function).无论我们学哪种语言,都会被教导我们要将代码写在哪里,才能被编译器编译进而运行.最著名的回调函数就是main函数,我们将代码写在main里,编译器就会运行我们的代码(如果没有错误的话).

    所以,回调函数其实就是接口.在C语言,这通过函数指针来实现.

    先看看函数指针的语法:

int* someFunc1(int a);//一个普通的函数声明
int* (*someFunc2)(int a);//声明函数指针

必须通过观察代码才能更好理解函数指针的实际作用

#include <stdio.h>
#include <stdlib.h>

typedef char* (*YOUR_NAME)();

char* fun1(){
    return "Diego";
}
char* fun2(){
    return "Chen";
}

void handleName(YOUR_NAME y){
    char* s=y();

    printf("Welcome,%s\n",s);
}

int main() {
    YOUR_NAME y1 = fun1;
    handleName(y1);
    handleName(fun2);

    return 0;
}

这段代码的知识点有:

如何声明函数指针
如何为函数指针变量赋值.
实际的应用

粗略地看,以上例子似乎平平无奇,其实不然.稍具Java Servlet编程经验的程序员都知道,处理web请求是一个相当简单的事情----实现Servlet的doGet或者doPost函数则可.也许我们羡慕Servlet面向程序员的简易友好的接口并且想用C语言实现,于是我们考虑如下伪码:

typedef struct REQUEST_STRUCT
typedef void (*HANDLE_REQUEST_PROC)(REQUEST_STRUCT req)

void doGet(){
    REQUEST_STRUCT req;
    //Initializes req.

    //Gets function from implementation by programmer.
    HANDLE_REQUEST_PROC proc = ..//Gets from somewhere.

    //Executes it.
    proc();

    //Continue other operations

}

    如果没有函数指针的帮助,这简直不可能.

    简单的说,函数指针的重要作用在于允许代码在运行时才进行连接.对于一些框架设计工作来说,预定义的供给程序员实现的回调函数是必不可少的,只有函数指针才能达到这个目的.

    函数指针的语法总结如下:

如何声明(对比普通函数的声明).
如何赋值(仅需要函数名,不需要函数参数表)

void (* FUNCTIONS) (int a,int b);//声明函数指针
void func1(int a,int b);//符合该函数指针声明的函数
void func2(int a,int b);//符合该函数指针声明的函数

FUNCTIONS y = func1;//赋值
y=func2;//赋值

2.7 指针和动态内存分配

动态分配的内存地址空间是连续的,分配完的空间会返回起始地址的指针:

char* pstr = (char*)malloc(100*sizeof(char));

所以,在这个场合你还是会用到指针.关于动态内存的使用会有专题章节进行总结.

2.8 指针用法总结

C语言里关于指针的应用场合总结如下:

遍历数组元素
引用字符串
提供面向程序员的接口,技术上以函数指针实现.
分配动态内存

Chenyunshi 2008-04-25 18:13 发表评论

C语言速记第一章快速入门

Chenyunshi — Thu, 24 Apr 2008 08:26:00 GMT

摘要: Chapter 1 快速入门 1.1 尽快Hello world 这个简单的例子有助于你快速进入C的世界:#include #include #define PI 3.1415926float circle(float r);int main(int argc, char* argv) ...{ float r... 阅读全文

Chenyunshi 2008-04-24 16:26 发表评论