[boost, template,c++]模板编程之缓冲池的设计与实现

本篇文章主要介绍一下如何使用 boost中的shared_ptr 和模板编程来实现一个简易的缓冲池(CachePool)
该缓冲池的内部存储容器为 stl 中的map>
其中 key 默认是 std::string 类型
value 的类型是根据创建 CachePool 的时候所使用的类型指针，该指针用来指向缓冲区中缓存的对象在系统中的位置
所包含的方法有: 
                       1. 从缓冲池中根据索引值(map->key) 来返回查找到的指向对象拷贝的指针(可修改)
                        2. 从缓冲池中根据索引值(map->key) 来返回查找到的指向对象本体的指针(不可修改)
                        3. 向缓冲池中根据索引值(map->key) 来插入传入的对象拷贝的指针
                        4. 清空缓冲池中指定索引值(map->key) 的缓冲区，并释放该块缓冲区空间
                        5. 清空缓冲池中全部缓冲区，并安全释放所有的缓冲空间

编程环境: vs2010 
涉及到的编程知识 : c++ , boost , template ,stl

---

---

//SharedPtr.hpp

#ifndef SHARED_PTR_HPP__
#define SHARED_PTR_HPP__


#include <boost/shared_ptr.hpp>
template <typename T>
class sharedptr
{
public :
    typedef boost::shared_ptr<T> type ;
} ;


#endif

//CachePool.hpp

#ifndef CACHE_POOL_HPP__
#define CACHE_POOL_HPP__

#include "SharedPtr.hpp"
#include <string>
#include <map>

template <typename T, typename Id = std::string>
class CachePool
{
public :
    typedef typename sharedptr<T>::type TPtr ;

    TPtr get( const Id &inId )
    {
        TPtr result = mCachePool[inId] ;

        if ( result )
            result = TPtr( new T(*result)) ;
        return result ;
    }

    const TPtr getConst ( const Id &inId )
    {
        return mCachePool[inId] ;
    }

    void add ( TPtr inPtr , const Id &inId )
    {
        TPtr copy( new T(*inPtr )) ;
        // new T( object )
        mCachePool[inId] = copy ;
    }

    void drop ()
    {
        mCachePool.clear() ;
    }

    void drop ( const Id &inId )
    {
        mCachePool[inId].reset() ;
    }


private :
    typedef std::map<Id, TPtr> CachePoolCont ;
    CachePoolCont mCachePool ;
} ;
#endif //CachePool.hpp

//Main.cpp

#include <cstdio>
#include <string>
#include <cstdlib>
#include <iostream>

#include "SharedPtr.hpp"
#include "CachePool.hpp"

class obj1
{
public :

    obj1( std::string name )
    {
        std::cout <<"create  "<< name << std::endl ;
        _name = name ;

    }

    void print ()
    {
        std::cout<<"print  " << _name <<std::endl ;
    }

public:
    std::string _name ;
} ;



typedef struct btnode
{
    std::string name ;
    btnode () :name(NULL)
    {}
    btnode ( std::string & n ) : name (n)
    {}
}BtNode_t ;


int main ()
{

// here we test whether type of T can be a class type

    sharedptr<obj1>::type p1 ( new obj1("obj1->Aimer")) ;
 // create a object and points it by shared_ptr

    CachePool<obj1> cachePool1 ;
 // create a CachePool just store obj1 type

    cachePool1.add( p1 , p1->_name ) ;
// adds the obj1's instance 's shared pointer into the CachePool

    p1 = cachePool1.get( "obj1->Aimer" ) ;
// try to get object from CachePool with key = "obj1->Aimer"


    std::cout << "name " << p1->_name << std::endl ;
// out put the object 's name


// here we test whether type of T can be a struct type

    CachePool<BtNode_t> BtNodePool ;
// creates a object and points it by shared pointer

    sharedptr<BtNode_t>::type pNode ( new BtNode_t( std::string("node->Kokia")) ) ;
    // create a struct instance and points it by shared pointer with type of BtNode_t

    BtNodePool.add(pNode , pNode->name ) ;
    // insert the shared pointer (with type of BtNode_t) into CachePool (type of BtNode_t )

    pNode = BtNodePool.getConst("node->Kokia") ;
// try to get object from Cache< BtNode_t type> with key = "ode->Kokia"

    std::cout << "name " << pNode->name << std::endl ;
// out put get object 's name

    system("pause") ;
    return 0 ;
}

end