对于学习c/c++的人来说，都应该知道这个符号的，如果你连这个运算符都不知道，可以说你压根就没有学过c/c++，虽然这个符号大家都知道是按位与运算符，但是很多时候看到别人的代码里面有这个运算的时候，就感觉别人的代码好难懂，好难理解。不信就来几段实际的代码看看。
int count(unsigned char n) { intsum=0; while(n) { n&=(n-1); sum++; } returnsum; }
对于稍微有点经验的人都知道这段代码是干什么用的，但是对于很多人我相信还是不知道这段代码是干什么用的，当然还有一部分人知道这段代码是干什么用的，但是说不出来为什么这段代码就能够实现那个功能。接下来我就简单的说一下这段代码。高手不要笑话，如果有错误的地方，还请多多指正。
首先我第一次看到这段代码的时候，是在一套笔试题里面，然后我当时不知道这段代码的作用，后来到网上查了一下，知道这是微软的一套笔试题，这个函数是用来统计n的二进制表示里面1的个数的。当时怎么也想不明白，为什么这样就可以计算出n的二进制里面1的个数。首先给出两个位运算满足的定理！
定理1：对于任意的同类型的两个整形数据x,y，必定满足x&y<=x，当然也满足x&y<=y。
证明：对于任意的X，肯定可以表示为X=a1*2^31+a2*2^30+…+a32*2^0.其中a1,a2…,a32的取值为0或者1，同理Y=b1*2^31+b2*2^30+…+b32*2^0.
因此X&Y=(a1&b1)*10^31+(a2&b2)*10^30+…+(a32&b32)*10^0.因为a1至a32和b1至b32的取值都为0或者1,同时与运算的规则为：0&0=0,1&1=1,0&1=0,1&0=0;因此可以肯定的得出，
a1&b1<=a1,a1&b1<=b1,因此可以x&y<=x，x&y<=y。
定理2：对于一个无符号非0的整形数据X，X对应的二进制序列a1,a2,a3…a32，X-1对应的二进制序列b1,b2,b3…b32.存在一个整数p，1<=p<=32，满足ap>ai,(i>p,i<=32),对于p,一定满足ap&bp=0;
对于定理2的描述很复杂，用通俗的话讲，就是对于一个无符号的非零整形数据X，X的二进制序列里面最右边为1的那一位，在X-1中该对应的位一定为0.
对于定理2的证明描述起来较为复杂就不写了。当然有兴趣的同学也可以下去自己证明。不会证明的也不重要，只要记住这个结论就可以了。
有了定理2，我们在返回来看上面的那段代码就比较容易弄明白了。X=x&(X-1)实际上是将X的二进制序列里面最右边的1变为了0，因此循环下去就可以计算出最开始X的二进制里面1的个数。
当然对于定理2里面的一些在代码里面的特殊应用。
比如判断一个数是不是2的n次幂。经过分析，一个数是x,如果是2的n次幂，那么x的二进制序列里面肯定只有一个位为1，因此x&(x-1)必定为0.这个通常可以用来判断一个数是不是2的n次幂。函数代码可以精炼到下面的情况：
bool foo(unsigned int x)
{
return(0==x&(x-1));
}
当然如果一个x是2的n次幂，那么x的二进制序列里面只有一位为1，假定第p位为1，那么x-1的二进制序列一定满足从第p+1位到末尾全都为1，这个自己想一想就能够明白。因此对于任意的一个整型数y,y&(x-1)的值和y%x的值相同。只有明白了这个道理才能看明白下面的代码。
这段代码是通过环形缓冲区实现的队列，代码很精炼。当然不是我写的，我是在网上看到的，拿到这段代码的时候，没有任何注释，然后自己看明白了，添上了一部分注释。也是在看这段代码的时候，总结出了上面的一些东西。其实我个人猜想stl里面的队列应该也是用的这个原理，当然他的功能更强大，但是基本思想肯定和这个一样的。
环形缓冲区实现的队列代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFSIZE 1024 * 1024
#define min(x, y) ((x) < (y) ? (x) : (y))
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//环形缓冲区结构体定义
struct cycle_buffer {
unsigned char *buf;
unsigned int size;
unsigned int in;
unsigned int out;
pthread_mutex_t lock;
};
//环形缓冲区全局的指针
static struct cycle_buffer *fifo = NULL;
//初始化环形缓冲区
static int init_cycle_buffer(void)
{
int size = BUFFSIZE,ret;
ret = size & (size -1); //判断size是不是2的n次幂,如果是ret为0,否则不为0
if (ret)
return ret;
fifo = (structcycle_buffer *) malloc(sizeof(struct cycle_buffer)); //分配缓冲区对象
if (!fifo)
return -1;
memset(fifo, 0,sizeof(struct cycle_buffer)); //填充为0
fifo->size = size; //初始化缓冲区大小
fifo->in = fifo->out= 0; //初始化读写下标
pthread_mutex_init(&fifo->lock, NULL); //初始化锁
fifo->buf = (unsignedchar *) malloc(size); //分配缓冲区大小
if (!fifo->buf)
free(fifo);
else
memset(fifo->buf,0, size); //缓冲区设置为0
return 0;
}
//读缓冲区
unsigned int fifo_get(unsigned char *buf, unsigned int len)
{
unsigned int l;
//求得此次能实际够读取数据的长度
len = min(len, fifo->in- fifo->out);
//由于fifo->size是一个2的n次幂的数,因此
//fifo->out&(fifo->size-1)和fifo->out%fifo->size的值相同
//那么fifo->size-(fifo->out& (fifo->size-1))就是读数据下
//标到缓冲区末尾的长度,后面的就容易理解了
l = min(len, fifo->size- (fifo->out & (fifo->size - 1)));
memcpy(buf,fifo->buf + (fifo->out & (fifo->size - 1)), l);
memcpy(buf + l,fifo->buf, len - l);
fifo->out += len;
//返回实际读取的数据的长度
return len;
}
//写缓冲区
unsigned int fifo_put(unsigned char *buf, unsigned int len)
{
unsigned int l;
len = min(len,fifo->size - fifo->in + fifo->out);
l = min(len, fifo->size- (fifo->in & (fifo->size - 1)));
memcpy(fifo->buf +(fifo->in & (fifo->size - 1)), buf, l);
memcpy(fifo->buf, buf +l, len - l);
fifo->in += len;
return len;
}
static void * thread_read(void *arg)
{
char buf[1024];
unsigned int n;
pthread_detach(pthread_self()); //线程分离
for (;;) {
memset(buf, 0,sizeof(buf));
pthread_mutex_lock(&fifo->lock);
n = fifo_get(buf,sizeof(buf));
pthread_mutex_unlock(&fifo->lock);
write(STDOUT_FILENO,buf, n);
}
printf("nnafterthread_read : %snn",buf);
return NULL;
}
static void * thread_write(void *arg)
{
unsigned char buf[] ="hello world";
pthread_detach(pthread_self());
for (;;) {
pthread_mutex_lock(&fifo->lock);
fifo_put(buf,strlen(buf));
pthread_mutex_unlock(&fifo->lock);
}
return NULL;
}
int main(void)
{
int ret;
pthread_t wtid, rtid;
ret =init_cycle_buffer();
if (ret == -1)
return ret;
pthread_create(&wtid,NULL, thread_write, NULL);
pthread_create(&rtid,NULL, thread_read, NULL);
pthread_exit(NULL); //保证主线程退出了,子线程还是能够运行
return 0;
}