开发工作中经常有这样的场景，和同事联调的时候，对方发了一个测试包过来，这边用tcpdump –Xlnsp0抓到包了，但是程序结果不正确，然后自己debug，修改，然后需要再测试，这时候再让同事发一个？如果不正确，这一来一回的比较慢，如果有个工具自动把tcpdump抓下来的内容再发出去，就ok了。

于是问题就是这样的，比如用tcpdump –Xlnps0抓到一个udp包，然后用工具把这个包重新发出去。

最近在使用linux下的共享库so的时候遇到一个奇怪的问题，做个记录，方便备查。

一般来说，如果用gcc编译的时候加上-shared和-fPIC选项，可以把源文件编译成一个so文件，可以在其他源程序连接阶段把这个链接上去，从而可以调用so文件提供的函数接口，这样可以多文件共用一个so文件提供的函数，即节省内存空间，也便于更新，所有的接口只需要更新so文件就行。

其实除了上面的方法，还有一个方法，那就是在运行时由程序自己动态加载so文件，使用一系列系统调用如dlopen，dlsym，dlclose等来进行动态加载，获取函数地址从而进行函数调用，关闭加载的so文件等。

一般以第一种方法用得多，但是第二种方法更灵活，结合配置文件，更具一般意义上的服务扩展性。 但是就是在用第二种方法的时候出现了一点问题。

这里把问题抽象一下，假设有一个源文件是要编译为so文件的，假设这个源文件只提供一个简单的函数，add，取两个整数为参数，返回它们的和，源文件为add.c，代码如下：

#include <stdio.h> 
 
int add(int a, int b) 
{ 
    return a+b; 
} 

编译

gcc -shared -fPIC add.c -o libadd.so
 

然后写个脚手架程序来测试，test.c，代码如下：

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

int main(int argc, char *argv[])
{
    void * handle;
    int (*func)(int, int);
    char *error;

    handle = dlopen("libadd.so", RTLD_LAZY);
    if(!handle)
    {
        fprintf(stderr, "%s\n", dlerror());
        exit(1);
    }

    func = (int (*)(int,int))dlsym(handle, "add");
    if((error = dlerror()) != NULL)
    {
        fprintf(stderr, "%s\n", error);
        exit(1);
    }

    func(3, 4);
    dlclose(handle);

    return 0;
}
 

编译

gcc test.c -o test -ldl

然后修改LD_LIBRARY_PATH变量，加上库所在的目录，这里是当前目录

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
 

好的，这样是没有问题的，这样的方法是标准的动态加载so库的方法，但是问题在什么地方呢，如果把gcc换成g++，问题就出现了 整个编译完成后，执行test，它会告诉你

./libadd.so: undefined symbol: add
 

找不到符号add 然后用nm看一下libadd.so的符号名

$ nm libadd.so |grep add

00000000000005ec T _Z3addii

它娘的，这是c++编译器的符号命名法，用c++filt看一下

$ c++filt _Z3addii

add(int, int)

看吗，这才是我们很显而易见的函数名 所以，解决方案出来，把库源文件的函数当C符号来处理，这样

extern "C" {
// the function code
...
}

然后编译运行，这就是好的，编译出来后用nm看一下

$ nm libadd.so |grep add

00000000000005dc T add

哈哈，这就好了，然后在dlsym中写符号名的时候就直接写add就行了。

这里例子虽然是用g++编译纯C文件，其实是真正的cpp文件也是可以的。

这是一个很有意思的问题，也是在面试中最容易被问到的问题之一。这个问题有个正式的名字叫Hamming_weight，而且wikipedia上也提供了很好的位运算解决的方法，这个下面也会提到。

解决这个问题的第一想法是一位一位的观察，判断是否为1，是则计数器加一，否则跳到下一位，于是很容易有这样的程序。

int test(int n)
{
	int count=0;
	while(n != 0){
		if(n%2 ==1)
			count++;
		n /= 2;
	}
	return count;
}

或者和其等价的位运算版本：

int test(int n)
{
	int count=0;
	while(n != 0){
		count += n&1;
		n >>= 1;
	}
	return count;
}

这样的方法复杂度为二进制的位数，即[tex]\log_2n[/tex]，于是可是想一下，有没有只与二进制中1的位数相关的算法呢。

可以考虑每次找到从最低位开始遇到的第一个1，计数，再把它清零，清零的位运算操作是与一个零，但是在有1的这一位与零的操作要同时不影响未统计过的位数和已经统计过的位数，于是可以有这样一个操作 n&(n-1) ，这个操作对比当前操作位高的位没有影响，对低位则完全清零。拿6（110）来做例子，第一次 110&101=100，这次操作成功的把从低位起第一个1消掉了，同时计数器加1，第二次100&011=000，同理又统计了高位的一个1，此时n已变为0，不需要再继续了，于是110中有2个1。

代码如下：

int test(int n)
{
	int count=0;
	while(n != 0){
		n &= n-1;
		count ++;
	}
	return count;
}

这几个方法虽然也用到了位运算，但是并没有体现其神奇之处，下面这个版本则彰显位运算的强大能力，若不告诉这个函数的功能，一般一眼看上去是想不到这是做什么的，这也是wikipedia上给出的计算hamming_weight方法。

int test(int n)
{
	n = (n&0x55555555) + ((n>>1)&0x55555555);
	n = (n&0x33333333) + ((n>>2)&0x33333333);
	n = (n&0x0f0f0f0f) + ((n>>4)&0x0f0f0f0f);
	n = (n&0x00ff00ff) + ((n>>8)&0x00ff00ff);
	n = (n&0x0000ffff) + ((n>>16)&0x0000ffff);

	return n;
}

没有循环，5个位运算语句，一次搞定。

比如这个例子，143的二进制表示是10001111，这里只有8位，高位的0怎么进行与的位运算也是0，所以只考虑低位的运算，按照这个算法走一次

+---+---+---+---+---+---+---+---+
| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |   <---143
+---+---+---+---+---+---+---+---+
|  0 1  |  0 0  |  1 0  |  1 0  |   <---第一次运算后
+-------+-------+-------+-------+
|    0 0 0 1    |    0 1 0 0    |   <---第二次运算后
+---------------+---------------+
|        0 0 0 0 0 1 0 1        |   <---第三次运算后，得数为5
+-------------------------------+

这里运用了分治的思想，先计算每对相邻的2位中有几个1，再计算每相邻的4位中有几个1，下来8位，16位，32位，因为2^5＝32，所以对于32位的机器，5条位运算语句就够了。

像这里第二行第一个格子中，01就表示前两位有1个1，00表示下来的两位中没有1，其实同理。再下来01+00=0001表示前四位中有1个1，同样的10+10=0100表示低四位中有4个1，最后一步0001+0100=00000101表示整个8位中有5个1。

以前在哪看到的，安全焦点吧！丢这做个备份

/*输入原来的15位身份证号码，产生新的18位身份证号码的程序*/

#include "stdio.h"
#include "string.h"
#include "conio.h"

/*
* gen New 18 ID Card from old 15 ID
*/
char genNewID( char ID[], char NewID[])
{
    int W[18] = {7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2,1};
    char A[11] = {'1','0','x','9','8','7','6','5','4','3','2'};
    int i,j,S;

    if(strlen(ID) != 15)
        return -1;

    memcpy( NewID, ID, 6 );
    NewID[6]='1';
    NewID[7]='9';
    NewID[8]=0;
    strcat( NewID, &ID[6] );
    S = 0;
    for(i=0;i<17;i++)
    {
        j = (NewID[i] - '0') * W[i];
        S = S + j;
    }

    S = S % 11;
    NewID[17] = A[S];
    NewID[18] = 0;

    return A[S];
}

int main(int argc, char* argv[])
{
    char ID[20], NewID[20], ret;

    puts("输入原来的15位身份证号码，产生新的18位身份证号码\n");
    do{
        printf("Input your old 15 ID Card: ");
        scanf( "%s", ID );
        if(stricmp(ID, "exit") == 0)break;
        ret = genNewID( ID, NewID );
        printf("Your New 18 ID Card:       %s \n", ret != -1 ? NewID : "Input Error!!");
    }while(1);

    getch();

    return 0;
}