【C++】POCO学习总结（十四）：引用计数、共享指针、缓冲区管理

2023-12-14 04:28
文章标签 c++ 指针 学习 总结 引用 共享 管理 十四 计数 缓冲区 poco

本文主要是介绍【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 == 1AutoPtr<RCO> p1(pNew); // _rc == 1AutoPtr<RCO> p2(p1); // _rc == 2AutoPtr<RCO> p3(pNew, true); // _rc == 3p2 = 0; // _rc == 2p3 = 0; // _rc == 1RCO* pRCO = p1; // _rc == 1p1 = 0; // _rc == 0 -> deleted// pRCO and pNew now invalid!p1 = new RCO; // _rc == 1return 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 <iostream>
using Poco::RefCountedObject;
using Poco::AutoPtr;
class RCO: public RefCountedObject
{
public:RCO(){}void greet() const{std::cout << "Hello, world!" << std::endl;}
protected:~RCO(){}
};int main(int argc, char** argv)
{AutoPtr<RCO> pRCO(new RCO);pRCO->greet(); // AutoPtr has -> operator(*pRCO).greet(); // AutoPtr has * operatorstd::cout << "refcount: " << pRCO->referenceCount() << std::endl;RCO* p1 = pRCO; // AutoPtr supports conversion to plain pointerRCO* p2 = pRCO.get();return 0;
}

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 <string>
#include <iostream>
using Poco::SharedPtr;
int main(int argc, char** argv)
{std::string* pString = new std::string("hello, world!");Poco::SharedPtr<std::string> p1(pString); // rc == 1Poco::SharedPtr<std::string> p2(p1); // rc == 2p2 = 0; // rc == 1// p2 = pString; // 崩溃: 多个所有者p2 = p1; // rc == 2std::string::size_type len = p1->length(); // 使用“->”解引用std::cout << *p1 << std::endl; // 使用“*”解引用 return 0;
}

4.3 自定义释放策略

Poco::SharedPtr的默认实现将简单地调用delete pObj
用new[]创建的对象，默认使用delete 肯定会出错，因为释放时，需要调用delete[] pObj

可以在创建Poco::SharedPtr时，使用自定义释放策略

模版如下：

Poco::SharedPtr<T, ReferenceCounter, ArrayReleasePolicy>

使用示例

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"); // truebool 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 <Poco/Buffer.h>
#include <string>
#include <iostream>
using Poco::Buffer;
int main(int argc, char** argv)
{Buffer<char> buffer(1024);std::cin.read(buffer.begin(), buffer.size());std::streamsize n = std::cin.gcount();std::string s(buffer.begin(), n);std::cout << s << std::endl;return 0;
}

8、Poco::MemoryPool 内存池

8.1 说明

许多应用程序需要非常频繁地分配和释放给定大小的缓冲区。
在堆上分配缓冲区会影响性能，并可能导致堆碎片。
因此，一旦缓冲区被分配，重用它是有意义的。
Poco::MemoryPool 是一个内存池，一次分配，多次使用，维护一定大小的内存块集合

8.2 用法

  • void* MemoryPool::get()：从内存池中获取一个指向连续内存块的指针。如果没有可用的块，则分配一个新的块。可以限制块的最大数量。如果没有更多的块可用，则抛出OutOfMemoryException。
  • void MemoryPool::release(void* ptr)：将内存块释放回内存池。
#include "Poco/MemoryPool.h"
#include <string>
#include <iostream>
using Poco::MemoryPool;
int main(int argc, char** argv)
{MemoryPool pool(1024); // unlimited number of 1024 byte blocks// MemoryPool pool(1024, 4, 16); // at most 16 blocks; 4 preallocatedchar* buffer = reinterpret_cast<char*>(pool.get());std::cin.read(buffer, pool.blockSize());std::streamsize n = std::cin.gcount();std::string s(buffer, n);pool.release(buffer);std::cout << s << std::endl;return 0;
}

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();}
}

这篇关于【C++】POCO学习总结（十四）：引用计数、共享指针、缓冲区管理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/491150。

相关文章

C++中全局变量和局部变量的区别

C++中全局变量和局部变量的区别

《C++中全局变量和局部变量的区别》本文主要介绍了C++中全局变量和局部变量的区别,全局变量和局部变量在作用域和生命周期上有显著的区别,下面就来介绍一下,感兴趣的可以了解一下... 目录一、全局变量定义生命周期存储位置代码示例输出二、局部变量定义生命周期存储位置代码示例输出三、全局变量和局部变量的区别作用域
阅读更多...
C++中assign函数的使用

C++中assign函数的使用

《C++中assign函数的使用》在C++标准模板库中,std::list等容器都提供了assign成员函数,它比操作符更灵活,支持多种初始化方式,下面就来介绍一下assign的用法,具有一定的参考价... 目录​1.assign的基本功能​​语法​2. 具体用法示例​​​(1) 填充n个相同值​​(2)
阅读更多...
Spring Boot集成Druid实现数据源管理与监控的详细步骤

Spring Boot集成Druid实现数据源管理与监控的详细步骤

《SpringBoot集成Druid实现数据源管理与监控的详细步骤》本文介绍如何在SpringBoot项目中集成Druid数据库连接池,包括环境搭建、Maven依赖配置、SpringBoot配置文件... 目录1. 引言1.1 环境准备1.2 Druid介绍2. 配置Druid连接池3. 查看Druid监控
阅读更多...
c++ 类成员变量默认初始值的实现

c++ 类成员变量默认初始值的实现

《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录C++类成员变量初始化c++类的变量的初始化在C++中，如果使用类成员变量时未给定其初始值，那么它将被
阅读更多...
Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式

Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式

《Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式》本文详细介绍如何使用Java通过JDBC连接MySQL数据库,包括下载驱动、配置Eclipse环境、检测数据库连接等关键步骤,... 目录一、下载驱动包二、放jar包三、检测数据库连接JavaJava 如何使用 JDBC 连接 mys
阅读更多...
C++中NULL与nullptr的区别小结

C++中NULL与nullptr的区别小结

《C++中NULL与nullptr的区别小结》本文介绍了C++编程中NULL与nullptr的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编... 目录C++98空值——NULLC++11空值——nullptr区别对比示例 C++98空值——NUL
阅读更多...
C++ Log4cpp跨平台日志库的使用小结

C++ Log4cpp跨平台日志库的使用小结

《C++Log4cpp跨平台日志库的使用小结》Log4cpp是c++类库,本文详细介绍了C++日志库log4cpp的使用方法,及设置日志输出格式和优先级,具有一定的参考价值,感兴趣的可以了解一下... 目录一、介绍1. log4cpp的日志方式2.设置日志输出的格式3. 设置日志的输出优先级二、Window
阅读更多...
Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

《Knife4j+Axios+Redis前后端分离架构下的API管理与会话方案(最新推荐)》本文主要介绍了Swagger与Knife4j的配置要点、前后端对接方法以及分布式Session实现原理,... 目录一、Swagger 与 Knife4j 的深度理解及配置要点Knife4j 配置关键要点1.Spri
阅读更多...
JavaSE正则表达式用法总结大全

JavaSE正则表达式用法总结大全

《JavaSE正则表达式用法总结大全》正则表达式就是由一些特定的字符组成,代表的是一个规则,：本文主要介绍JavaSE正则表达式用法的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下... 目录常用的正则表达式匹配符正则表China编程达式常用的类Pattern类Matcher类PatternSynta
阅读更多...
从入门到精通C++11 ＜chrono＞ 库特性

从入门到精通C++11 ＜chrono＞ 库特性

《从入门到精通C++11＜chrono＞库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段（Durat
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2