久久永久免费,亚洲国产天堂久久国产91,伊人久久亚洲影院

��毛 — Mon, 05 Jul 2010 15:08:00 GMT

boost里的program_options提供�E�序员一�U�方便的命��o行和配置文�g�q�行�E�序选项讄��的方法�?br> 其文��例子中有如下代码：

1 using namespace boost::program_options;
2 //声明需要的选项
3 options_description desc("Allowed options");
4 desc.add_options()
5 ("help,h", "produce help message")
6 ("person,p", value<string>()->default_value("world"), "who");

    看第4�?行，是不是感觉很怪？�q�种方式体现了函数式�~�程中最大的特点�Q�函数是一�c�d��|��引用资料来说,所�?#8220;函数是一�c�d��|��First Class Value�Q?#8221;指的是函数和值是同等的概念，一个函数可以作为另外一个函数的参数�Q�也可以作�ؓ��g��用。如果函数可以作��Z��c�d��g��用，那么我们��可以写��Z��些函敎ͼ�使得�q�些函数接受其它函数作�ؓ参数�q�返回另外一个函数。比如定义了f和g两个函数�Q�用compose(f,g)的风格就可以生成另外一个函敎ͼ�使得�q�个函数执行f(g(x))的操作，则可�U�compose为高阶函敎ͼ�Higher-order Function�Q��?br>
    program_options里的�q�种方式是怎么实现的呢�Q�通过分析boost的源代码�Q�我们自己来写个�c�M��的实现看看：
     test.h

1 #pragma once
2
3 #include <iostream>
4 using namespace std;
5
6 class Test;
7
8 class Test_easy_init
9 {
10 public:
11     Test_easy_init(Test* owner):m_owner(owner){}
12
13     Test_easy_init & operator () (const char* name);
14     Test_easy_init & operator () (const char* name,int id);
15 private:
16     Test* m_owner;
17 };
18
19
20 class Test
21 {
22 public:
23     void add(const char* name);
24     void add(const char* name,int id);
25
26     Test_easy_init add_some();
27
28 };

test.cpp

1 #include "test.h"
2
3 Test_easy_init & Test_easy_init::operator () (const char* name,int id)
4 {
5
6     m_owner->add(name,id);
7     return *this;
8 }
9
10
11 Test_easy_init & Test_easy_init::operator () (const char* name)
12 {
13
14     m_owner->add(name);
15     return *this;
16 }
17
18 Test_easy_init Test::add_some()
19 {
20     return Test_easy_init(this);
21 }
22
23
24 void Test::add(const char* name)
25 {
26     cout<<"add:"<<name<<endl;
27 }
28
29 void Test::add(const char* name,int id)
30 {
31     cout<<"add:"<<name<<"-"<<id<<endl;
32 }

使用方式�Q?br>

1 Test t1;
2
3 t1.add_some()
4     ("hello",1)
5     ("no id")
6     ("hello2",2);

是不是很有意思。add_some()�Ҏ��q�回一个Test_easy_init�cȝ��对象�Q�Test_easy_init�c�重载了操作�W?)�Q�操作符()�Ҏ��q�回Test_easy_init�c�d��象自�w�的引用。�?

��毛 2010-07-05 23:08 发表评论

��毛 — Sun, 27 Sep 2009 06:50:00 GMT

摘要: 上一��内存池的实现其实更像一个后备列表的实现。��用上来说不是很方便，要申��L��内存块是一个BLOCK�l�构的一个个成员�Q�而且每次从系�l�内存堆中申请都是一��块一��块�Q�也没有考虑字节寚w��。因此让我们来看看新的一个内存池的实现吧�?nbsp; �q�个内存池是�Ҏ��《c++应用�E�序性能优化》书里的固定��寸的内存池原理做了一些改动用C语言写的。大家有兴趣... 阅读全文

��毛 2009-09-27 14:50 发表评论

一个简单实用的内存池之一�Q�c实现)

��毛 — Thu, 17 Sep 2009 14:34:00 GMT

都知道频�J�分配内存释攑ֆ�存很耗系�l�资源，而且�Ҏ��造成内存��片。因此写了个��单的内存池实玎ͼ��简单越好，��Z��么？做复杂了效率�q�不如直接malloc。因此这个内存池采用链表�q�接内存块的方式�Q�分配的是固定大��的内存块，从池中取内存和归�q�内存是用的�I�闲链表堆栈操作�Q?没有使用�U�程锁，如果要线�E�安全，��在外部调用内存池的地方加锁�?br>
做过一个简单的��试�Q?0万次内存池调用的效率大概比直接分配释攑ֆ�存提高了30-50%。但是前提是内存池不能加锁（pthread_mutex�Q�，加锁的内存池效率和直接分配内存的效率差不多，有时候还要多点点。（��试的环境是每次2K�Q?个双核CPU�Q�FREEBSD7�Q?br>
代码实现�Q?br>

struct memblock
{
   int              used;
   void*            data;
   struct memblock* next;
   struct memblock* createnext;
};

struct mempool
{
    int            size;//memblock大小
    int            unused;//�I�闲的memblock大小
    int            datasize;//每次分配的数据大��?��是memblock.data)
    struct memblock*    free_linkhead;//�I�闲memblock链表�?/span>
    struct memblock*    create_linkhead;//所有创建的memblock链表��_��内存池释攄��时候��用，防止内存池释攄��g��q�有memblock未归�q�的情况

};
typedef void (*free_callback)(void*);//释放回调函数�Q�释放membloc.data用，可以��单的直接用free函数

void    mempool_init(int initialSize,int datasize);//初始化mempool
void    mempool_dealloc(struct mempool* pool,free_callback callback);//释放mempool
void*    mempool_get(struct mempool* pool);//获取一个memblock
void    mempool_release(struct mempool* pool,struct memblock* block);//归还一个memblock

/*********************************
* mempool
* ******************************/
//malloc一个memblock
static struct memblock* mempool_allocblock( struct mempool* pool );

//------------------implement--------
void*
mempool_init( int initialSize, int datasize )
{
    struct mempool* pool = malloc( sizeof( struct mempool ) );
    pool->unused = 0;
    pool->datasize = datasize;
    pool->free_linkhead = NULL;

    //预先初始化initialSize个内存块
     pool->create_linkhead = NULL;
    int i;
    for ( i = 0; i < initialSize; i++ ) {
        struct memblock* block = mempool_allocblock( pool );
        mempool_release( pool, block );
    }
    return ( pool );
}

void
mempool_dealloc( struct mempool* pool, free_callback callback )
{
    struct memblock* block = NULL;
    //��所有创建的memblock释放�?/span>
    while ( pool->create_linkhead != NULL ) {
        block = pool->create_linkhead;
        pool->create_linkhead = pool->create_linkhead->createnext;
    //执行free回调�?/span>
        if ( callback ) {
            ( *callback )( block->data );
        }
        free( block );
    }
    free( pool );
    L_DEBUG( "%s:size(%d),unused(%d)", __func__, pool->size, pool->unused );
}

static struct memblock*
mempool_allocblock( struct mempool* pool )
{
    struct memblock* block = malloc( sizeof( struct memblock ) );
    block->data = malloc( sizeof( pool->datasize ) );
    block->next = NULL;
    block->used = 1;//表示已��?br>
    //加入所有创建的memblock的链表头
    block->createnext = pool->create_linkhead;
    pool->create_linkhead = block;

    pool->size++;
    return ( block );
}

void
mempool_release( struct mempool* pool, struct memblock* block )
{
    if ( block == NULL ) {
        L_WARN( "%s:release a NULL!", __func__ );
        return;
    }
    if ( block->used != 1 ) {
        L_WARN( "%s:used!=1", __func__ );
        return;
    }
    //��归�q�的内存块放到空闲链表头�?/span>
    block->used = 0;//表示�I�闲
    block->next = pool->free_linkhead;
    pool->free_linkhead = block;
    pool->unused++;//�I�闲�?1
}

void*
mempool_get( struct mempool* pool )
{

    struct memblock* block = NULL;
    if ( pool->free_linkhead ) {
    //从空闲链表头取出一个内存块
        block = pool->free_linkhead;
        pool->free_linkhead = pool->free_linkhead->next;
        block->next = NULL;
        block->used = 1;//表示已��?/span>
        pool->unused--;//�I�闲内存块数-1
    }
    else {
    //没有�I�闲的内存块�Q�创��Z��?/span>
        block = mempool_allocblock( pool );
    }
    return ( block );
}

��毛 2009-09-17 22:34 发表评论