【C++】POCO学习总结（十四）：引用计数、共享指针、缓冲区管理
【C++】郭老二博文之：C++目录
1、Poco::AutoPtr 智能指针
1.1 说明
Poco::AutoPtr是一个含有引用计数的“智能”指针模版。
Poco::AutoPtr用于支持引用计数的类实例化。支持引用计数的类需要有以下要求：
- 维护一个引用计数(在创建时初始化为1)
- 实现void duplicate()方法，增加引用计数
- 实现void release()方法，减少引用计数，当它达到零时，删除对象
Poco::AutoPtr支持完整的值语义(默认构造函数、复制构造函数、赋值)，可以在集合中使用
(例如std::vector或std::map)。
使用Poco::AutoPtr::isNull()或Poco::AutoPtr::operator !()来测试是否为空
AutoPtr强制转换总是类型安全的(内部使用了dynamic_cast，因此无效的强制转换将导致空指针)。
AutoPtr::AutoPtr(C* pObject, bool shared); // shared=true，表示为共享指针
1.2 用法
下面的示例中 RCO 维护一个引用计数_rc，在创建时，将_rc赋值为1，然后实现两个方法duplicate和release，示例源码如下：
#include "Poco/AutoPtr.h"
using Poco::AutoPtr;
class RCO
{
public:
RCO(): _rc(1){}
void duplicate()
{
++_rc; // Warning: not thread safe!
}
void release()
{
if (--_rc == 0) delete this; // Warning: not thread safe!
}
private:
int _rc;
};
int main(int argc, char** argv)
{
RCO* pNew = new RCO; // _rc == 1
AutoPtr<RCO> p1(pNew); // _rc == 1
AutoPtr<RCO> p2(p1); // _rc == 2
AutoPtr<RCO> p3(pNew, true); // _rc == 3
p2 = 0; // _rc == 2
p3 = 0; // _rc == 1
RCO* pRCO = p1; // _rc == 1
p1 = 0; // _rc == 0 -> deleted
// pRCO and pNew now invalid!
p1 = new RCO; // _rc == 1
return 0;
} // _rc == 0 -> deleted
2、Poco::RefCountedObject 引用计数对象
2.1 说明
Poco::RefCountedObject 实现线程安全的引用计数语义。从poco-1.3.4版本开始，它使用特定于平台的原子操作。
Poco::RefCountedObject可以用作实现引用计数的类的基类。
Poco::RefCountedObject有一个受保护的析构函数，禁止复制构造和赋值。
所有引用计数的对象都应该有一个受保护的析构函数，以禁止显式使用delete。
2.2 用法
#include "Poco/RefCountedObject.h"
#include "Poco/AutoPtr.h"
#include 3、Poco::AutoReleasePool 自动释放池
3.1 说明
Poco::AutoReleasePool获取添加到它的每个对象的所有权
当Poco::AutoReleasePool被销毁(或者它的release()方法被调用)时，它通过调用每个对象的release()方法释放对它持有的所有对象的引用。
3.2 用法
#include "Poco/AutoReleasePool.h"
using Poco::AutoReleasePool;
class C
{
public:
C(){}
void release() {delete this;}
};
int main(int argc, char** argv)
{
AutoReleasePool<C> pool;
C* pC = new C;
pool.add(pC);
pC = new C;
pool.add(pC);
return 0;
}
// 两次new的C，都将被销毁
4、Poco::SharedPtr 共享指针
4.1 说明
Poco::AutoPtr用于类自身含有引用计数的对象；
Poco::SharedPtr为普通类实现引用计数（自身不需要实现引用计数的类）
头文件：#include “Poco/SharedPtr.h”
警告：将同一个普通指针分配给不同的Poco::SharedPtr将导致该对象有多个所有者，从而导致未定义的行为(换句话说，崩溃)。
一旦对一个对象使用了Poco::SharedPtr，就不要再使用指向那个对象的普通指针了
Poco::SharedPtr支持完整的值语义(默认构造函数、复制构造函数、赋值)，并可用于集合(例如std::vector或std::map)。
使用SharedPtr::isNull()或SharedPtr::operator !()来测试是否为空
4.2 用法
#include "Poco/SharedPtr.h"
#include 4.3 自定义释放策略
Poco::SharedPtr的默认实现将简单地调用delete pObj
用new[]创建的对象，默认使用delete 肯定会出错，因为释放时，需要调用delete[] pObj
可以在创建Poco::SharedPtr时，使用自定义释放策略
模版如下：
Poco::SharedPtr
使用示例
template <class C>
class ArrayReleasePolicy
{
public:
static void release(C* pObj) {delete [] pObj;}
};
char* pStr = new char[100];
Poco::SharedPtr<char, Poco::ReferenceCounter, ArrayReleasePolicy> p(pStr);
5、Poco::DynamicFactory 动态工厂类模板
5.1 说明
Poco::DynamicFactory支持按“name”名称创建对象。
头文件：#include “Poco/DynamicFactory.h”
Poco::DynamicFactory管理的所有类必须有一个共同的基类。
Poco::DynamicFactory为基类实例化。
C* Poco::DynamicFactory::createInstance(const std::string& name) const;创建具有给定名称的子类的实例。
要做到这一点，类和它们的实例化器(工厂类)必须在Poco::DynamicFactory中注册
5.2 用法
#include "Poco/DynamicFactory.h"
#include "Poco/SharedPtr.h"
using Poco::DynamicFactory;
using Poco::SharedPtr;
class Base {};
class A: public Base{};
class B: public Base{};
int main(int argc, char** argv)
{
DynamicFactory<Base> factory;
# a）注册
factory.registerClass<A>("A");
factory.registerClass<B>("B");
# b）使用工厂来创建
SharedPtr<Base> pA = factory.createInstance("A");
SharedPtr<Base> pB = factory.createInstance("B");
# c）取消注册
factory.unregisterClass("B");
# d）检查是否存在
bool haveA = factory.isClass("A"); // true
bool haveB = factory.isClass("B"); // false (已取消注册)
bool haveC = factory.isClass("C"); // false (没有注册过)
return 0;
}
6、Poco::Instantiator 实例化辅助类
6.1 说明
使用Poco::DynamicFactory工厂方法来创建类，类必须有默认构造函数，如果没有，需要Poco::Instantiator来辅助实现。
6.2 用法
#include "Poco/DynamicFactory.h"
using Poco::DynamicFactory;
using Poco::AbstractInstantiator;
class Base {};
class A: public Base {};
class C: public Base
{
public:
C(int i): _i(i){}
private:
int _i;
};
class CInstantiator: public AbstractInstantiator<Base>
{
public:
CInstantiator(int i): _i(i){}
Base* createInstance() const { return new C(_i);}
private:
int _i;
}
int main(int argc, char** argv)
{
DynamicFactory<Base> factory;
factory.registerClass<A>("A");
factory.registerClass("C", new CInstantiator(42));
return 0;
}
7、Poco::Buffer 缓冲区管理
7.1 说明
当与遗留的C库或操作系统调用接口时，通常需要提供一定大小的缓冲区。
如果缓冲区大于几个字节，则必须在堆上分配。
这需要某种类型的内存管理，以确保缓冲区在不再使用时被删除，即使在异常的情况下。
std::auto_ptr或Poco::SharedPtr(具有默认的发布策略)不能在这里使用，因为它们不适用于数组。
Poco::Buffer可用于提供固定大小的缓冲区(数组)，该缓冲区在堆上分配，并在Buffer对象超出作用域时自动删除。
7.2 用法
头文件：#include “Poco/Buffer.h”
- begin()方法返回一个指向缓冲区开头的指针。
- end()方法返回一个指向缓冲区末尾的指针。
- 索引操作符提供对缓冲区中单个元素的访问。
#include 8、Poco::MemoryPool 内存池
8.1 说明
许多应用程序需要非常频繁地分配和释放给定大小的缓冲区。
在堆上分配缓冲区会影响性能，并可能导致堆碎片。
因此，一旦缓冲区被分配，重用它是有意义的。
Poco::MemoryPool 是一个内存池，一次分配，多次使用，维护一定大小的内存块集合
8.2 用法
- void* MemoryPool::get()：从内存池中获取一个指向连续内存块的指针。如果没有可用的块，则分配一个新的块。可以限制块的最大数量。如果没有更多的块可用，则抛出OutOfMemoryException。
- void MemoryPool::release(void* ptr)：将内存块释放回内存池。
#include "Poco/MemoryPool.h"
#include 9、POCO::SingletonHolder 线程安全的单例
9.1 说明
POCO提供了一个POCO::SingletonHolder类，帮助对延迟创建的单例进行线程安全管理。
头文件：#include “Poco/SingletonHolder.h”
单例实例在第一次被请求时创建在堆上。
当应用程序终止时，单例实例被销毁。
9.2 用法
#include "Poco/SingletonHolder.h"
class MySingleton
{
public:
MySingleton(){// ...}
~MySingleton(){// ...}
// ...
static MySingleton& instance()
{
static Poco::SingletonHolder<MySingleton> sh;
return *sh.get();
}
}