年近くの私はまたコードの仕事を书くことを始めて、再び1つのC++のデータベースの接続の池の类を书いて、个人はとても便利だと感じます

使用方法:

std::string select()
{
	try
	{	
		Framework::database db;
		const char* sql="select to_char(sysdate, 'yyyy-mm-dd hh24:mi:ss') from dual";
		//    *
		otl_stream o(100, sql, *db);
		
		while (!o.eof())
		{
			std::string s("");
			o >> s;
			return s;
		}
	}
	catch(otl_exception& p)
	{  }
	return "";
}

int main(int argc, char** argv)
{
	//          
	Framework::database::initialize("BILL/BILL@crm", 5);
	//       
	std::string s = select();
	printf("pool size = %d result = %s
", Framework::database::size(), s.c_str());
	Framework::database::finished();
	return 0;
}

//  Header.h
//  Created by xuwn on 15/2/10.

#ifndef __POOL_HPP__
#define __POOL_HPP__
#define	OTL_ORA11G_R2 // Compile OTL 4.0/OCI11.2
#define	OTL_STL	// Turn	on STL features

#include "mutex.hpp"
#include "otlv4.h"
#include 

/* how to use
 * example for use pool and databse 
 */
/*
std::string select()
{
	try
	{	
		Framework::database db;
		const char* sql="select to_char(sysdate, 'yyyy-mm-dd hh24:mi:ss') from dual";
		
		otl_stream o(100, sql, *db);
		
		while (!o.eof())
		{
			std::string s("");
			o >> s;
			return s;
		}
	}
	catch(otl_exception& p)
	{  
	}
	
	return "";
}

int main(int argc, char** argv)
{
	Framework::database::initialize("BILL/BILL@crm", 5);
	std::string s = select();
	printf("pool size = %d result = %s
", Framework::database::size(), s.c_str());
	Framework::database::finished();
	return 0;
}
*/

namespace Framework
{
const int MAX_SIZE = 255;
const int MIN_SIZE = 5;

template 
class pool : public std::vector
{
private:
	typedef typename std::vector::iterator iterator;
protected:
//public:
	 pool() { }
	~pool() { }	
protected:
	T dequeue()
	{
		Framework::guard<:mutex> guard(mutex_);
		iterator it = std::vector::begin();
		if (it != std::vector::end()) 
		{
			object_ = (T)*it;
			std::vector::erase(it);
		}
		return object_;
	}
	
	void enqueue(T v)
	{
		Framework::guard<:mutex> guard(mutex_);
		std::vector::push_back(v);
	}
private:
	pool(const pool& src);
	pool& operator=(const pool& src);
private:
	Framework::mutex	mutex_;
	T 			object_;
	friend class        	database;
};

static pool *instance = NULL;

class database
{
public:
	static void initialize(const char* connect_string, int size=5)
	{
		if (instance) return ;
		instance = new pool;
		otl_connect::otl_initialize(1);
		size = (size > MIN_SIZE && size < MAX_SIZE) ? size : MIN_SIZE;
		for (int i = 0; i < size; i++)
		{   
			otl_connect* connect = new otl_connect;
			try
			{
				connect->rlogon(connect_string);
				instance->enqueue(connect);
			}
			catch (...)
			{
				if (connect) delete connect;
				throw;
			}
		}
	}
	
	/*        
	 */
    static int size()
    {
        return instance->size();
    }
    /*        ，       
     */
    static void finished()
    {
    	pool::iterator it = instance->begin();
    	for (; it != instance->end(); ++it)
    	{
    		otl_connect* o = (otl_connect*)*it;
    		o->logoff();
    		delete o;
    	}
    	
    	delete instance;
    }
public:
	database()
	{
		db_ = instance->dequeue();
	}
	
	~database()
	{  
		if (db_) instance->enqueue(db_);
	}
public:
	otl_connect* operator->()
	{   return db_;  }
	
	otl_connect& operator*()
	{   return *db_;  }
private:
	otl_connect* db_;
};
	
} // end namespace
#endif // end __POOL_HPP__