singleton_pool
A interface de singleton_pool é exatamente a mesma de pool, e os ponteiros de memória de tipos de dados simples (POD) podem ser alocados, mas é um singleton.
singleton_pool está localizado no namespace boost. Para usar o componente singleton_pool, o arquivo de cabeçalho <boost/pool/singleton_pool.hpp> precisa ser incluído, a saber:
#include <boost/pool/singleton_pool.hpp>
using namespace boost;
singleton_pool usa a biblioteca boost.thread para fornecer garantia de segurança de thread por padrão, portanto, precisa vincular a biblioteca boost_thread.Se multi-threading não for usado, a macro BOOST_POOL_NO_MT poderá ser definida antes do arquivo de cabeçalho.
resumo da aula
template <typename Tag, unsigned RequestedSize>
class singleton_ pool
{
public:
static bool is_from(void * ptr);
static void* malloc(); //分配内存
static void* ordered_malloc();
static void* ordered_malloc(size_type n);
static void free(void * ptr); //归还内存
static void ordered_free(void* ptr);
static voidfree(void * ptr, std: : size_t n);
static voidordered_free (void * ptr, size_type n);
static bool release_memory(); //释放内存
static bool purge_memory();
);
uso
singleton_pool tem principalmente dois parâmetros de tipo de modelo (o restante pode usar valores padrão). O primeiro Tag é usado apenas para marcar diferentes singletons, que podem ser classes vazias ou até mesmo declarações (este uso também é usado para boost.exception). O segundo parâmetro RequestedSize é equivalente ao inteiro request_size no construtor do pool, indicando o tamanho do bloco de memória alocado pelo pool.
A interface de singleton_pool é exatamente a mesma de pool, mas as funções de membro são todas estáticas, então não há necessidade de declarar uma instância de singleton_pool. Use operadores de campo diretamente ::para chamar funções de membro estáticas. Como singleton_pool é um singleton, seu ciclo de vida é tão longo quanto o programa inteiro. A menos que release_memory() ou purge_memory() seja chamado manualmente, singleton_pool não liberará automaticamente a memória ocupada. Exceto por esses dois pontos, o uso de singleton_pool é exatamente o mesmo que pool.
#define BOOST_POOL_NO_MT //不使用多线程
#include <boost/pool/singleton_pool.hpp>
struct pool_tag {
}; //仅仅用于标记的空类
typedef singleton_pool<pool_tag, sizeof(int)> spl; //内存池定义
int main()
{
int* p = (int*)spl::malloc(); //分配一个整数内存块
assert(spl::is_from(p));
spl::release_memory(); //释放所有未被分配的内存
} //spl的内存直到程序结束才完全释放,而不是退出作用域
Quando singleton_pool é usado, é melhor usar typedef para simplificar o nome, caso contrário, o nome do tipo ficará muito longo e difícil de usar. Como mostrado no código:
typedef singleton_pool<pool_tag,sizeof (int)> spl;
A classe pool_tag usada para marcação pode ser simplificada novamente, e a classe de tag pode ser declarada diretamente na lista de parâmetros do modelo, para que a definição de tipo de singleton_pool possa ser concluída em uma instrução, por exemplo:
typedef singleton_pool<struct pool_tag, sizeof (int)> spl;
exemplo de código
#define BOOST_POOL_NO_MT
#include <boost/pool/singleton_pool.hpp>
struct pool_tag {
};
typedef singleton_pool<pool_tag, sizeof(int)> spl;
void case4()
{
int* p = (int*)spl::malloc();
assert(spl::is_from(p));
spl::release_memory();
}
int main()
{
case4();
}