日韩亚洲视频,亚洲精品久久久久久一区二区,亚洲国产专区

梨树阛_�� — Mon, 01 Oct 2012 07:53:00 GMT

开门见山，我先提出几个问题�Q�大家可以先��x��Q�然后我再说出我的方�?br /> 1.如何判断一个数M是否�?的N�ơ方�Q?br /> 2.一个数N�Q�如何得��C��个数是M�Q�M是不��于N的最��?的K�ơ方

先说�W�一个问题，我有两个思�\
�W�一�Q�可以通过判断M的二�q�制�?的个数。而判断M�?的个数可以通过下面�Ҏ��获得

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

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

    return cnt;
}

很明显M�?的个��Cؓ1和M�?的N�ơ方互�ؓ冲要条�g
�W�二个思�\�Q�我们可以这��P��q�是利用M的二�q�制表示�Q�从最高位开始，以变量high_pos表示�W�一�?的下标，接着从最低位开始，变量low_pos表示�W�一�?的下标，如果high_pos=low_pos,则M�?的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;
}

再说�W�二个问�?br />其实有了�W�一个问题的思�\�Q�这个问题就更好解决了，先判断一个数是否�?^N�Q�如果是�Q�直接返回，否则�q�回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�?^highestBit求余
    highestBit += ( mask > 0 );

    return (1<}

梨树阛_�� 2012-10-01 15:53 发表评论

梨树阛_�� — Thu, 19 Jul 2012 03:41:00 GMT

写服务器的，通常会涉及到内存池的东西�Q�自己在�q�方面也看了写了一些东西，有些体会�Q�写出来跟大家分享下�?br /> 内存池基本包含以下几个东西，�W�一�Q�初始化。第二，分配内存。第三，回收内存。所谓初始化�Q�就是在服务器启动的时候，或者第一�ơ需要内存的时候，�pȝ��分配很大的一块内存，方便之后的��用。分配内存，��是从内存池中取出需要的内存�l�外部��用，当然�q�里需要考虑的是当内存池中没有内存可分配时候的处理。回收内存，��单来��_��是外面对象生命期结束了�Q�将分配出去的内存回收入内存池中。好了简单概念就说完了，我们先来看一�U�最��单的设计方式�?font class="Apple-style-span" color="#0000ff" size="2">

//��Z��方便描述�Q�这里附上几个简单的链表操作�?/font>

#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
{
//该指针用来记录空闲节�?/font>

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

//分配内存“�?#8221;的函�?br /> bool mem_pool_resize(size_t size)
{
//该函数创建size个不�q�箋的对象，把他们通过链表的方式加入到s_mem_pool.free�?br /> 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

//初始化函�?/div>

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)

}

好了最��单的内存池的大致框架��是�q�样。我们先来看下他的过�E�。首先，在mem_pool_init()函数中，他先分配512个不�q�箋的student对象。每分配出来一个就把它加入到free链表中，初始化完成后内存池大概是�q�样�?br />
接下来就是从内存池中取出一个对象get_data()。函数先��d��断是否有�I�闲的对象，有则直接分配�Q�否则再向系�l�获取一"�?大的内存。调用一�ơ后的内存池大概是这��L��

释放对象�Q�再把对象加入到Free链表中�?br /> 以上��是�q�程的简单分析，下面我们来看看他的缺炏V�?br /> �W�一�Q�内存不是连�l�的�Q�容易��生碎�?br /> �W�二�Q�一个类型就得写一个这��L��内存池，很麻�?br /> �W�三�Q��ؓ了构��个内存池�Q�每个没对象必须加上一个prev,next指针
好了�Q�我们来优化一下它。我们重新定义下我们的结构体

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

static struct mem_pool
{
    //该下标用来记录空闲节�?/span>
    int free;
    //内存�?/span>
    union student *mem;
    //已分配结点个�?/span>
    size_t alloc_cnt�Q?br /> }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))�Q?br />     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
//初始化函�?/span>
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;
}

我们来看看改�q�了些什么。第一student�Ҏ��了联合体�Q�这主要是�ؓ了不占用额外的内存，也就是我们上面所说的�W�三个缺点，�W�二�Q�我们��用了realloc函数�Q�这��h��们可以��我们分配出来的内存是�q�箋的。我们初始化的时候多了一个for循环�Q�这是�ؓ了记录空闲对象的下标�Q�当我们取出一个对象时�Q�free可以立刻知道下一个空闲对象的位置�Q�释攄��时候，对象先记录free此时的��|��接着再把free赋值成该对象在数组的下标，�q�样��完成了回收工作�?br /> 我们�l�箋分析�q�段代码�Q�问题在realloc函数上，如果我们的s_mem_pool.mem已经很大了，在realloc的时候我们都知道�Q�先要把原来的数据做一�ơ拷贝，所以如果数据量很大的情况下做一�ơ拷贝，是会消耗性能的。那�q�里有没有好的办法呢�Q�我们进一步优�?br /> 思�\大概是这�?br /> 初始�?br />
再次分配的时候，我们只需要重新分配新的内存单元，而不需要拷贝之前的内存单元�?br />
因此��Z��此思�\�Q�我们修�Ҏ��们的代码

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

struct student
{
    int index;

    char name[32];
    byte sex;
};

static struct mem_pool
{
    //该下标用来记录空闲节�?/span>
    int free;
    //内存�?/span>
    struct student **mem;
    //已分配块个数
    size_t block_cnt�Q?br /> }s_mem_pool;

#define BLOCK_SIZE        256        //每块的大��?/span>
//分配内存块的函数
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 *))�Q?br />     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
//初始化函�?/span>
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;
}

�q�里不一��L��地方主要�?/span>mem_pool_resize函数中，mem变成�?�U�指针，每次realloc的时候只需要分配指针数�l�的大小�Q�无��L��贝对象，�q�样可以提高效率�Q�但是�ؓ了在释放的时候把对象攑֛�该放的位�|�，我们�q�里在结构体里加入了index变量�Q�记录它的下标。在内存池里�Q�它表示下个�I�闲对象的下标，在内存池外，它表�C�在内存池中的下标。�ȝ��来说满��了一个需求，却又带来了新的问题，有没有更好的�Ҏ��呢，�{�案是肯定，不过今天先写到这里，明天�l�箋�?/span>

梨树阛_�� 2012-07-19 11:41 发表评论

梨树阛_�� — Thu, 12 Jul 2012 01:59:00 GMT

昨天在看一��文章的时候，�H�然惌��v了这个基��性的问题�Q�自�׃��直对它的区别不是很清楚，于是今天上午研究下了�Q�分享下自己的理解�?对它很清楚的同学们可以略�q�此��文�?
从存储方式来��_��文�g在磁盘上的存储方式都是二�q�制形式�Q�所以，文本文�g其实也应该算二进制文件。那么他们的区别呢，各自的优�~�点呢？不急，我慢慢道来�?br /> 先从他们的区别来��_��虽然都是二进制文�Ӟ��但是二进制代表的意思不一栗��打个比方，一个�h�Q�我们可以叫他的大名�Q�可以叫他的��名�Q�但其实都是代表�q�个人。二�q�制��d��是将内存里面的数据直接读写入文本中，而文本呢�Q�则是将数据先�{换成了字�W�串�Q�再写入到文本中。下面我用个例子来说明�?br /> 我们定义了一个结构体�Q�表�C�Z��个学生信息，我们打算把学生的信息分别用二�q�制和文本的方式写入到文件中�?br />

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

我们定义两个�Ҏ��Q�分别表�C�内存写入和文本写入

//使用二进制写�?/span>
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); //此处省略文�g是否打开��p�|的判�?/span>
    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+");   //此处省略文�g是否打开��p�|的判�?/span>
    fprintf(fp,"%d%s%f",stdu.num,stdu.name,stdu.score); //��数据�{换成字符�Ԍ��字符串的格式可以自己定义�Q?/span>
    fclose(fp);
}
//MAIN函数调用前面两个�Ҏ��
int _tmain(int argc, _TCHAR* argv[])
{
    write_to_binary_file();
    write_to_text_file();

    return 0;
}

我们来看下，文�g里面的格�? 2�q�制文�g

文本文�g

2�q�制文�g里面��?11�~�码�?F�Q?个字节，�q�刚好是111�?6�q�制表示�Q�而文本文件中则写�?1�Q?1�Q?1用了3个字节，表示111�?3 68 69 6E 65 表示shine�Q�之�?�q�制文�g里是几个�q�箋的FE�Q�而文本文件中�?8 30......文本文�g��Q�Ҏ��80.000000用了38(表示8) 30(表示0) 2E(表示.) 30(表示0) 30(表示0) 30(表示0) 30(表示0) 30(表示0) 30(表示0)�Q�二�q�制文�g用了4个字节表�C��Q�Ҏ��00 00 A0 42
通过�q�里我们可以初见端倪了�Q�二�q�制��数据在内存中的样子原封不动的搬到文件中�Q�文本格式则是将每一个数据�{换成字符写入到文件中�Q�他们在大小上，布局上都有着区别。由此可以看出，2�q�制文�g可以从读出来直接用，但是文本文�g�q�多一�?#8220;��译”的过�E�，因此2�q�制文�g的可�U�L��性好�?/span>

梨树阛_�� 2012-07-12 09:59 发表评论

梨树阛_�� — Thu, 12 Jul 2012 01:51:00 GMT

先看一个简单的使用例子

求�Q意个自然数的�q�x��和：

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�~�译器中�Q�默认情况下�Q�参数进栈的��序是由叛_��左的�Q�因此，参数�q�栈以后的内存模型如下图所�C�：
最后一个固定参数的地址位于�W�一个可变参��C��下，�q�且是连�l�存储的�?
| 最后一个可变参�?高内存地址�? | �W�N个可变参�?| �W�一个可变参�?| 最后一个固定参�?| �W�一个固定参�?低内存地址�?
明白上面那个��序�Q�就知道其实可变参数��是玩弄参数的地址�Q�已辑ֈ�“不定”的目�? 下面我摘自VC中的源码来解�?br />va_list,va_start,va_arg,va_end�?
1.其实va_list��是我们�q�x��l�常用的char* typedef char * va_list;
2.va_start该宏的目的就是将指针指向最后一个固定参数的后面�Q�即�W�一个不定参数的起始地址 #define va_start(ap,v)( ap = (va_list)&v + _INTSIZEOF(v) ) v卌��C�最后一个固定参敎ͼ�&v表示v的地址�Q? #define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) 该宏其实是一个内存对齐的操作。即表示大于sizeof(n)且�ؓsizeof(int)倍数的最��整数。这句话有点�l�，其实丑և�个例子就��单了。比�?--4�Q�则�q�回4,5--8则返�?
3.va_arg 该宏的目的是��ap指针�l�箋后移�Q�读取后面的参数�Q�t表示参数�c�d��。该宏首先将ap指针�U�d��C��一个参数的起始地址ap += _INTSIZEOF(t)�Q�然后将本参数的��D��? #define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
4.va_end��指针赋�I? #define va_end(ap) ap = (va_list)0 有了�q�个分析我们可以把上例中的代码重新翻译下

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;
}

�q�样我们也可以写出我们自��q��printf�?img src ="http://m.shnenglu.com/yg2362/aggbug/182955.html" width = "1" height = "1" />

梨树阛_�� 2012-07-12 09:51 发表评论