C++博客-yg2362-随笔分类-C

两个小问题

梨树阳光 — Mon, 01 Oct 2012 07:53:00 GMT

开门见山，我先提出几个问题，大家可以先想想，然后我再说出我的方法
1.如何判断一个数M是否为2的N次方？
2.一个数N，如何得到一个数是M，M是不小于N的最小2的K次方

先说第一个问题，我有两个思路
第一，可以通过判断M的二进制中1的个数。而判断M中1的个数可以通过下面方法获得

int GetOneCnt(int m)
{
    if ( m == 0 )
        return 0;

    int cnt = 1;
    while(m & (m-1))
    {
        cnt++;
        m--;
    }

    return cnt;
}

很明显M中1的个数为1和M是2的N次方互为冲要条件
第二个思路，我们可以这样，还是利用M的二进制表示，从最高位开始，以变量high_pos表示第一个1的下标，接着从最低位开始，变量low_pos表示第一个1的下标，如果high_pos=low_pos,则M为2的N次方

int HighestBitSet(int input)
{
    register int result;

    if (input == 0)
    {
        return  -1;
    }

#ifdef WIN32
    _asm bsr eax, input
    _asm mov result, eax
#else
    asm("bsr %1, %%eax;"
    "movl %%eax, %0"
    :"=r"(result)
    :"r"(input)
    :"%eax");
#endif

    return result;
}

int LowestBitSet(int input)
{
    register int result;

    if (input == 0)
    {
        return  -1;
    }

#ifdef WIN32
    _asm bsf eax, input
    _asm mov result, eax
#else
    asm("bsf %1, %%eax;"
    "movl %%eax, %0"
    :"=r"(result)
    :"r"(input)
    :"%eax");
#endif

    return result;
}

再说第二个问题
其实有了第一个问题的思路，这个问题就更好解决了，先判断一个数是否为2^N，如果是，直接返回，否则返回2^(N+1)
代码如下

int CeilingPowerOfTwo(int iInput)
{
    if (iInput <= 1)
        return  1;

    int32_t highestBit = HighestBitSet(iInput);
    int32_t mask = iInput & ((1 << highestBit) - 1); // 相当于input对2^highestBit求余
    highestBit += ( mask > 0 );

    return (1<}

梨树阳光 2012-10-01 15:53 发表评论

浅谈内存池几种设计方式

梨树阳光 — Thu, 19 Jul 2012 03:41:00 GMT

写服务器的，通常会涉及到内存池的东西，自己在这方面也看了写了一些东西，有些体会，写出来跟大家分享下。
内存池基本包含以下几个东西，第一，初始化。第二，分配内存。第三，回收内存。所谓初始化，就是在服务器启动的时候，或者第一次需要内存的时候，系统分配很大的一块内存，方便之后的使用。分配内存，就是从内存池中取出需要的内存给外部使用，当然这里需要考虑的是当内存池中没有内存可分配时候的处理。回收内存，简单来说，就是外面对象生命期结束了，将分配出去的内存回收入内存池中。好了简单概念就说完了，我们先来看一种最简单的设计方式。

//为了方便描述，这里附上几个简单的链表操作宏

#define INSERT_TO_LIST( head, item, prev, next ) \

do{ \

if ( head ) \

(head)->prev = (item); \

(item)->next = (head); \

(head) = (item); \

}while(0)

#define REMOVE_FROM_LIST(head, item, prev, next) \

do{ \

if ( (head) == (item) ) \

{ \

(head) = (item)->next; \

if ( head ) \

(head)->prev = NULL; \

} \

else \

{ \

if ( (item)->prev ) \

(item)->prev->next = (item)->next; \

if ( (item)->next ) \

(item)->next->prev = (item)->prev; \

} \

}while(0)

struct student
{
char name[32];
byte sex;

struct student *prev,*next;
};

static struct mem_pool
{
//该指针用来记录空闲节点

struct student *free;
//该变量记录分配结点个数
size_t alloc_cnt;
}s_mem_pool;

//分配内存“块”的函数
bool mem_pool_resize(size_t size)
{
//该函数创建size个不连续的对象，把他们通过链表的方式加入到s_mem_pool.free中
for ( size_t i = 0;i < size;++i )
{

struct student *p = (struct student *)malloc(sizeof(struct student));

if ( !p )
return false;

p->prev = p->next = NULL;
INSERT_TO_LIST(s_mem_pool.free,p,prev,next);
}

s_mem_pool.alloc_cnt += size;
}

#define MEM_INIT_SIZE 512

#define MEM_INC_SIZE 256

//初始化函数

bool mem_pool_init()

{

if ( !mem_pool_resize(MEM_INIT_SIZE) )

return false;

return true;

}

struct student *get_data()

{

if ( s_mem_pool.free == NULL )

{

if ( !mem_pool_resize(MEM_INC_SIZE) )

return NULL;

}

struct student *ret = s_mem_pool.free;

REMOVE_FROM_LIST(s_mem_pool.free,ret,prev,next)

return ret;

}

void free_data(struct student *p)

{

if ( !p )

return;

memset(p,0,sizeof(struct student));

INSERT_TO_LIST(s_mem_pool.free,p,prev,next)

}

好了最简单的内存池的大致框架就是这样。我们先来看下他的过程。首先，在mem_pool_init()函数中，他先分配512个不连续的student对象。每分配出来一个就把它加入到free链表中，初始化完成后内存池大概是这样的

接下来就是从内存池中取出一个对象get_data()。函数先去判断是否有空闲的对象，有则直接分配，否则再向系统获取一"块"大的内存。调用一次后的内存池大概是这样的

释放对象，再把对象加入到Free链表中。
以上就是过程的简单分析，下面我们来看看他的缺点。
第一，内存不是连续的，容易产生碎片
第二，一个类型就得写一个这样的内存池，很麻烦
第三，为了构建这个内存池，每个没对象必须加上一个prev,next指针
好了，我们来优化一下它。我们重新定义下我们的结构体

union student
{
    int index;
    struct
    {
        char name[32];
        byte sex;
    }s;
};

static struct mem_pool
{
    //该下标用来记录空闲节点
    int free;
    //内存池
    union student *mem;
    //已分配结点个数
    size_t alloc_cnt；
}s_mem_pool;

//分配内存块的函数
bool mem_pool_resize(size_t size)
{
    size_t new_size = s_mem_pool.alloc_cnt+size;
    union student *tmp = (union student *)realloc(s_mem_pool.mem,new_size*sizeof(union student))；
    if ( !tmp )
        return false;

    memset(tmp+s_mem_pool.alloc_cnt,0,size*sizeof(union student));
    size_t i = s_mem_pool.alloc_cnt;
    for ( ;i < new_size - 1;++i )
    {
        tmp[i].index = i + 1;
    }

    tmp[i].index = -1;
    s_mem_pool.free = s_mem_pool.alloc_cnt;
    s_mem_pool.mem = tmp;
    s_mem_pool.alloc_cnt = new_size;

    return true;
}

#define MEM_INIT_SIZE    512
#define MEM_INC_SIZE    256
//初始化函数
bool mem_pool_init()
{
    if ( !mem_pool_resize(MEM_INIT_SIZE) )
        return false;

    return true;
}

union student *get_data()
{
    if ( s_mem_pool.free == -1 )
    {
        if ( !mem_pool_resize(MEM_INC_SIZE) )
            return NULL;
    }

    union student *ret = s_mem_pool.mem+s_mem_pool.free;
    s_mem_pool.free = ret->index;
    return ret;
}

void free_data(union student *p)
{
    if ( !p )
        return;

    p->index = s_mem_pool.free;
    s_mem_pool.free = p - s_mem_pool.mem;
}

我们来看看改进了些什么。第一student改成了联合体，这主要是为了不占用额外的内存，也就是我们上面所说的第三个缺点，第二，我们使用了realloc函数，这样我们可以使我们分配出来的内存是连续的。我们初始化的时候多了一个for循环，这是为了记录空闲对象的下标，当我们取出一个对象时，free可以立刻知道下一个空闲对象的位置，释放的时候，对象先记录free此时的值，接着再把free赋值成该对象在数组的下标，这样就完成了回收工作。
我们继续分析这段代码，问题在realloc函数上，如果我们的s_mem_pool.mem已经很大了，在realloc的时候我们都知道，先要把原来的数据做一次拷贝，所以如果数据量很大的情况下做一次拷贝，是会消耗性能的。那这里有没有好的办法呢，我们进一步优化
思路大概是这样
初始化

再次分配的时候，我们只需要重新分配新的内存单元，而不需要拷贝之前的内存单元。

因此基于此思路，我们修改我们的代码

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

struct student
{
    int index;

    char name[32];
    byte sex;
};

static struct mem_pool
{
    //该下标用来记录空闲节点
    int free;
    //内存池
    struct student **mem;
    //已分配块个数
    size_t block_cnt；
}s_mem_pool;

#define BLOCK_SIZE        256        //每块的大小
//分配内存块的函数
bool mem_pool_resize(size_t block_size)
{
    size_t new_cnt = s_mem_pool.block_cnt + block_size;
    struct student **tmp = (struct student **)realloc(s_mem_pool.mem,new_size*sizeof(struct student *))；
    if ( !tmp )
        return false;

    memset(tmp+s_mem_pool.block_cnt,0,size*sizeof(struct student*));
    for ( size_t i = s_mem_pool.block_cnt;i < new_cnt;++i )
    {
        tmp[i] = (struct student *)calloc(BLOCK_SIZE,sizeof(struct student));
        if ( !tmp[i] )
            return false;

        size_t j = 0;
        for(;j < BLOCK_SIZE - 1;++j )
        {
            tmp[i][j].index = i*BLOCK_SIZE+j+1;
        }

        if ( i != new_cnt-1 )
            tmp[i][j].index = (i+1)*BLOCK_SIZE;
        else
            tmp[i][j].index = -1;
    }

    s_mem_pool.free = s_mem_pool.alloc_cnt*BLOCK_SIZE;
    s_mem_pool.mem = tmp;
    s_mem_pool.block_cnt = new_cnt;

    return true;
}

#define MEM_INC_SIZE    10
//初始化函数
bool mem_pool_init()
{
    if ( !mem_pool_resize(MEM_INIT_SIZE) )
        return false;

    return true;
}

struct student *get_data()
{
    if ( s_mem_pool.free == -1 )
    {
        if ( !mem_pool_resize(MEM_INC_SIZE) )
            return NULL;
    }

    struct student *ret = s_mem_pool.mem[s_mem_pool.free/BLOCK_SIZE]+s_mem_pool.free%BLOCK_SIZE;
    int pos = s_mem_pool.free;
    s_mem_pool.free = ret->index;
    ret->index = pos;
    return ret;
}

void free_data(struct student *p)
{
    if ( !p )
        return;

    int pos = p->index;
    p->index = s_mem_pool.free;
    s_mem_pool.free = pos;
}

这里不一样的地方主要在mem_pool_resize函数中，mem变成了2级指针，每次realloc的时候只需要分配指针数组的大小，无须拷贝对象，这样可以提高效率，但是为了在释放的时候把对象放回该放的位置，我们这里在结构体里加入了index变量，记录它的下标。在内存池里，它表示下个空闲对象的下标，在内存池外，它表示在内存池中的下标。总的来说满足了一个需求，却又带来了新的问题，有没有更好的方法呢，答案是肯定，不过今天先写到这里，明天继续。

梨树阳光 2012-07-19 11:41 发表评论

浅谈二进制文件读写和文本文件读写的区别

梨树阳光 — Thu, 12 Jul 2012 01:59:00 GMT

昨天在看一篇文章的时候，突然想起了这个基础性的问题，自己一直对它的区别不是很清楚，于是今天上午研究下了，分享下自己的理解。(对它很清楚的同学们可以略过此篇文章)
从存储方式来说，文件在磁盘上的存储方式都是二进制形式，所以，文本文件其实也应该算二进制文件。那么他们的区别呢，各自的优缺点呢？不急，我慢慢道来。
先从他们的区别来说，虽然都是二进制文件，但是二进制代表的意思不一样。打个比方，一个人，我们可以叫他的大名，可以叫他的小名，但其实都是代表这个人。二进制读写是将内存里面的数据直接读写入文本中，而文本呢，则是将数据先转换成了字符串，再写入到文本中。下面我用个例子来说明。
我们定义了一个结构体，表示一个学生信息，我们打算把学生的信息分别用二进制和文本的方式写入到文件中。

struct Student
{
    int num;
    char name[20];
    float score;
};

我们定义两个方法，分别表示内存写入和文本写入

//使用二进制写入
void write_to_binary_file()
{
    struct Student stdu;
    stdu.num = 111;
    sprintf_s(stdu.name,20,"%s","shine");
    stdu.score = 80.0f;
    fstream binary_file("test1.dat",ios::out|ios::binary|ios::app); //此处省略文件是否打开失败的判断
    binary_file.write((char *)&stdu,sizeof(struct Student));//二进制写入的方式
    binary_file.close();
}
//文本格式写入
void write_to_text_file()
{
    struct Student stdu;
    stdu.num = 111;
    sprintf_s(stdu.name,20,"%s","shine");
    stdu.score = 80.0f;
    FILE *fp = fopen("test2.dat","a+");   //此处省略文件是否打开失败的判断
    fprintf(fp,"%d%s%f",stdu.num,stdu.name,stdu.score); //将数据转换成字符串（字符串的格式可以自己定义）
    fclose(fp);
}
//MAIN函数调用前面两个方法
int _tmain(int argc, _TCHAR* argv[])
{
    write_to_binary_file();
    write_to_text_file();

    return 0;
}

我们来看下，文件里面的格式 2进制文件

文本文件

2进制文件里面将111编码成6F，1个字节，这刚好是111的16进制表示，而文本文件中则写成31，31，31用了3个字节，表示111。73 68 69 6E 65 表示shine，之后2进制文件里是几个连续的FE，而文本文件中是38 30......文本文件将浮点数80.000000用了38(表示8) 30(表示0) 2E(表示.) 30(表示0) 30(表示0) 30(表示0) 30(表示0) 30(表示0) 30(表示0)，二进制文件用了4个字节表示浮点数00 00 A0 42
通过这里我们可以初见端倪了，二进制将数据在内存中的样子原封不动的搬到文件中，文本格式则是将每一个数据转换成字符写入到文件中，他们在大小上，布局上都有着区别。由此可以看出，2进制文件可以从读出来直接用，但是文本文件还多一个“翻译”的过程，因此2进制文件的可移植性好。

梨树阳光 2012-07-12 09:59 发表评论

不定参数的分析

梨树阳光 — Thu, 12 Jul 2012 01:51:00 GMT

先看一个简单的使用例子

求任意个自然数的平方和：

int SqSum(int n,)
{
    va_list arg_ptr;
    int sum = 0,_n = n;
    arg_ptr = va_start(arg_ptr,n);
    while(_n != 0)
    {
        sum += (_n*_n);
        _n = va_arg(arg_ptr,int);
    }
    va_end(arg_ptr);
    return sum;
}

首先解释下函数参数入栈情况在VC等绝大多数C编译器中，默认情况下，参数进栈的顺序是由右向左的，因此，参数进栈以后的内存模型如下图所示：
最后一个固定参数的地址位于第一个可变参数之下，并且是连续存储的。
| 最后一个可变参数(高内存地址处) | 第N个可变参数 | 第一个可变参数 | 最后一个固定参数 | 第一个固定参数(低内存地址处)
明白上面那个顺序，就知道其实可变参数就是玩弄参数的地址，已达到“不定”的目的下面我摘自VC中的源码来解释
va_list,va_start,va_arg,va_end宏
1.其实va_list就是我们平时经常用的char* typedef char * va_list;
2.va_start该宏的目的就是将指针指向最后一个固定参数的后面，即第一个不定参数的起始地址 #define va_start(ap,v)( ap = (va_list)&v + _INTSIZEOF(v) ) v即表示最后一个固定参数，&v表示v的地址， #define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) 该宏其实是一个内存对齐的操作。即表示大于sizeof(n)且为sizeof(int)倍数的最小整数。这句话有点绕，其实举几个例子就简单了。比如1--4，则返回4,5--8则返回8
3.va_arg 该宏的目的是将ap指针继续后移，读取后面的参数，t表示参数类型。该宏首先将ap指针移动到下一个参数的起始地址ap += _INTSIZEOF(t)，然后将本参数的值返回 #define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
4.va_end将指针赋空 #define va_end(ap) ap = (va_list)0 有了这个分析我们可以把上例中的代码重新翻译下

int SqSum(int n,)
{
    char *arg_ptr;
    int sum = 0,_n = n;
    arg_ptr = (char *)&n + 4;//本机上sizeof(int) = 4
    while(_n != 0)
    {
        sum += (_n*_n);
        arg_ptr += 4;
        _n = *(int *)(arg_ptr-4);
    }
    arg_ptr = (void*)0;
}

这样我们也可以写出我们自己的printf了

梨树阳光 2012-07-12 09:51 发表评论