POCO C++库学习和分析 -- 流 (一)

合集下载

POCO C 库学习和分析 -- 通知和事件 (四)

POCO C  库学习和分析 -- 通知和事件 (四)

POCO C++库学习和分析-- 通知和事件(四)5. 事件Poco中的事件和代理概念来自于C#。

对于事件的使用者,也就是调用方来说,用法非常的简单。

5.1 从例子说起首先让我们来看一个同步事件例子,然后再继续我们的讨论:[cpp]1.#include "Poco/BasicEvent.h"2.#include "Poco/Delegate.h"3.#include <iostream>4.ing Poco::BasicEvent;ing Poco::Delegate;7.8.class Source9.{10.public:11. BasicEvent<int> theEvent;12.void fireEvent(int n)13. {14. theEvent(this, n);15.// theEvent.notify(this, n); // alternative syntax16. }17.};18.19.class Target20.{21.public:22.void onEvent(const void* pSender, int& arg)23. {24. std::cout << "onEvent: " << arg << std::endl;25. }26.};27.28.int main(int argc, char** argv)29.{30. Source source;31. Target target;32. source.theEvent += Poco::delegate(&target, &Target::onEvent);33. source.fireEvent(42);34. source.theEvent -= Poco::delegate(&target, &Target::onEvent);35.36.return 0;37.}从上面的代码里,我们可以清晰的看到几个部分,数据源Source,事件BasicEvent<T>,目标对象Target。

POCO C++库学习和分析 -- 哈希

POCO C++库学习和分析 -- 哈希

POCO C++库学习和分析-- 哈希1. Hash概论在理解Poco中的Hash代码之前,首先需要了解一下Hash的基本理论。

下面的这些内容和教课书上的内容并没有太大的差别。

1.1 定义下面这几段来自于百度百科:Hash:一般翻译做"散列",也有直接音译为"哈希"的,就是把任意长度的输入(又叫做预映射,pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。

这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。

简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

Hash table:散列表,也叫哈希表,是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。

这个映射函数叫做散列函数,存放记录的数组叫做散列表。

* 若结构中存在关键字和K相等的记录,则必定存储在f(K)的位置上。

由此,不需比较便可直接取得所查记录。

这个对应关系f称为散列函数(Hash function),按这个思想建立的表为散列表。

* 对不同的关键字可能得到同一散列地址,即key1≠key2,而f(key1)=f(key2),这种现象称冲突。

具有相同函数值的关键字对该散列函数来说称做同义词。

* 综上所述,根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集(区间)上,并以关键字在地址集中的“象”,作为这条记录在表中的存储位置,这种表便称为散列表,这一映象过程称为散列造表或散列,所得的存储位置称散列地址。

这个现象也叫散列桶,在散列桶中,只能通过顺序的方式来查找,一般只需要查找三次就可以找到。

科学家计算过,当重载因子不超过75%,查找效率最高。

* 若对于关键字集合中的任一个关键字,经散列函数映象到地址集合中任何一个地址的概率是相等的,则称此类散列函数为均匀散列函数(Uniform Hash function),这就是使关键字经过散列函数得到一个“随机的地址”,从而减少冲突。

Poco入门介绍

Poco入门介绍

Poco入门介绍1.Poco库简介官方网站: /index.htmlPOCO C++库是开源的用于简化和加速C++开发面向网络、可移植应用程序的C++库集,POCO库和C++标准库可以很好的集成并填补了C++标准库缺乏的功能空隙。

POCO库的模块化、高效的设计及实现使得POCO特别适合嵌入式开发。

核心库是: Foundation, XML, Util 和 Net. 附加库中其中2个是NetSSL和Data,NetSSL 为Net库中的网络类提供SSL支持, Data库提供访问不同SQL数据库的一致性接口支持的平台:Microsoft WindowsLinuxMac OS XHP-UX,Solaris,AIX*Embedded Linux(UcLibc,glibc)iOSWinodows Embedded CEQNX2.常用功能点> Any and DynamicAny classes> Cache framework> Cryptography (cryptographic hashes, encryption based on OpenSSL)> Date and Time classes> Events (signal/slot mechanism) and notifications framework> FTP client for transferring files> Filesystem classes for platform-independent path manipulation,directory listing and globing > HTML form handling> HTTP server and client (also secure), C++ Server Page Compiler> Logging framework> Multithreading: basic threads and synchronization and advanced facilities (thread pool, active objects, work queues, etc.)> POP3 client for receiving mail> Platform Abstraction: write once, compile and run on multiple platforms> Processes and IPC> Reactor framework> Regular expressions (based on PCRE)> SMTP client for sending mail> SQL database access (SQLite, MySQL, ODBC)> SSL/TLS support based on OpenSSL> Shared library and class loading>Smart pointers and memory management (buffer, pool)> Sockets and raw sockets> Stream classes for Base64 and HexBinary encoding/decoding, compression (zlib), line ending conversion, reading/writing tomemory, etc> String formatting and string utilities> TCP server framework (multithreaded)> Text encodings and conversions> Tuples> URI handling> UTF-8 and Unicode support> UUID handling and generation> XML parsing (SAX2 and DOM) and XML generation> Zip file manipulation2.编译安装2.1 windows下的编译安装2.1.1 Visual Studio 2008 下的编译安装---省略演示2.1.2 Eclipse 下的编译安装---演示为主1.安装MinGW+msys cygwin2.安装eclipse3.设置eclipse编译工具链2.2 unix/linux平台下的编译安装主要步骤如下:1.2.3.HelloWorld 开发自己的第一个应用3.1构建自己的工程a.创建工程目录hellWorldb.创建目录include src 目录helloWorld/include/srcMakefilec. 创建hellWorld.cpp文件3.2编写Makefile警告:Objects,target,target_version,target_libs变量最末尾一定不能有空格,否则编译会出现异常3.3 编译Gmake shared_release3.4 运行3.5 调试4.核心模块介绍4.1.跨平台编译包编译脚本目录$POCO_BASE/build常见的修改:POCO_BASE 定义poco代码目录OSARCH_64BITS =1 定义64位编译模式SRCDIR = src makefile与.cpp的位置INCDIR = include .h文件夹LIBDIR = lib lib文件夹BINDIR = bin bin文件夹OBJDIR = obj/$(OSNAME)/$(OSARCH)DEPDIR = .dep/$(OSNAME)/$(OSARCH)LIBPATH = $(POCO_BUILD)/$(LIBDIR)BINPATH = $(POCO_BUILD)/$(COMPONENT)/$(BINDIR) -->建议改为$(BINDIR)OBJPATH = $(POCO_BUILD)/$(COMPONENT)/$(OBJDIR)-->可以不用管)$(OBJDIR)DEPPATH = $(POCO_BUILD)/$(COMPONENT)/$(DEPDIR)-->依赖文件目录)$(DEPDIR)系统自带的编译指令:all: $(DEFAULT_TARGET)all_static: static_debug static_releaseall_shared: shared_debug shared_releaseall_debug: static_debug shared_debugall_release: static_release shared_release自定义编译指令:CFLAGS += -gCXXFLAGS += -gPOCO_FLAGS +=COMMONFLAGS = -DPOCO_BUILD_HOST=$(HOSTNAME) $(POCO_FLAGS)添加额外的头文件路径:POCO_ADD_INCLUDE += $(ORACLE_HOME)/precomp/public $(ORACLE_HOME)/rdbms/public $(ORACLE_HOME)/rdbms/demoPOCO_ADD_LIBRARY +=$(ORACLE_HOME)/$(OraLib)添加额外的链接库非POCO编译出来的库SYSLIBS +=-locci -lclntsh编译方式:gmake shared_releasegmake shared_debuggmake static_releasegmake static_debuggmake all_releasegmake all_debuggmake all4.2.Foundation库4.2.1 core 模块a.Platform abstraction1.统一了各个平台的数据类型比如long ,int ,long long 等,参考types.h2.平台的big-endian和little-endian 参考ByteOrder.h3.平台类型相关信息platform.hb. Memory Management1.智能指针(smart pointer)和共享指针(shared pointer) 参考AutoPtr.h,SharedPtr.h2.据以引用计数器的垃圾回收机制AtomicCounter.h,refCountedObject.h3.单件类(singleton objects) SingletonHolder.hc.String Utilities字符串的比较(大小写转换,大小写无关转换,去除空白符号,字符转换和连接,分拆),参考String.h,StringTokenizer.hd.Error Handling1. 断言类,类似assert,主要使用宏断言,比如poco_asert(myPtr);参考Bugcheck.h2.异常类, 了解Poco::exception结构,使用POCO_DECLARE_EXCEPTION宏,参考Exception.h4.2.2.streamspass4.2.3.Threadingpass4.2.4.DateTimea.Timestamp 微秒级精度,对gettimeofday()封装,参考Timestamp.hb.Stopwatch 计时器,参考Stopwatch.hc.DateTime 日历时间,参考DateTime.hd.日历时间的格式转换DateTimeFormat,DateTimeFormatter,DateTimeParser 等e.日历时区Timezonef.本地时间LocalDateTime4.2.5 FileSystem与平台无关的文件,目录的操作类。

POCOC++库学习和分析--异常、错误处理、调试

POCOC++库学习和分析--异常、错误处理、调试

POCO C++库学习和分析--异常、错误处理、调试1.异常处理C++同C语言相比,提供了异常机制。

通过使用tycatch关键字可以捕获异常,这种机制使得程序员在程序异常发生时,可以通过判断异常类型,来决定程序是否继续执行,并在程序结束之前优雅的释放各类资源。

当然对于C++的异常机制也存在着很多的争议。

在这里,并不对此展开讨论,只介绍一下Poco中的异常类。

Poco中的异常类:1.所有的异常类都是Poco::Exception的子类。

2.Poco::Exception 继承自std::exception 类。

3.Fou ndation库中涉及的异常类,包括了下面一些:a) Poco::LogicException 类负责处理程序错误,包括了Asserti on Violati on Excepti onNullPo in terExcepti onNullValueExcepti onBugcheckExcepti onIn validArgume ntExceptio nNotImpleme ntedExcepti onRan geExcepti onIllegalStateExcepti onIn validAccessExcepti onSig nalExceptio nNotFo un dExceptio nLibraryLoadExcepti on LibraryAlreadyLoadedExcepti on NoThreadAvailableExcepti onPropertyNotSupportedExcepti on PoolOverflowExcepti on NoPermissionException| OutOfMemoryExceptio nDataExcepti onDataFormatExcepti onSyn taxExcepti on CircularRefere nceExcepti onPathS yn taxExcepti on lOExcepti onProtocolExcepti on FileExcepti on FileExistsExceptio n FileNotFo un dExcepti on PathNotFo un dExceptionFileRead Onl yExcepti on FileAccessDe ni edExcepti on CreateFileExceptio nOpen FileExcepti on WriteFileExceptio n ReadFileExcepti on|Unknown URISchemeExceptio n成员函数及数据定义:1.Poco::Exception包括了一个名字,这是一个静态的字符串,用来描述异常本身。

POCO C++库学习和分析 -- 线程 (四)

POCO C++库学习和分析 -- 线程 (四)

POCO C++库学习和分析-- 线程(四)5. 主动对象5.1 线程回顾在讨论主动对象之前,我想先说一下对于Poco中多线程编程的理解。

大家都知道,对于多线程编程而言最基本的元素只有两个数据:锁和线程。

线程提高了程序的效率,也带来了数据的竞争,因此为了保证数据的正确性,孪生兄弟"锁"随之产生。

对于不同的操作系统和编程语言而言,线程和锁通常是以系统API的方式提供的,不同语言和不同操作系统下API并不相同,但线程和锁的特性是一致的,这也是对线程和锁进行封装的基础。

比如所有的系统线程API都提供了线程开始函数,其中可以设置线程的入口函数,提供了线程终止等功能。

用面对对象的思想对线程和锁进行封装后,线程和锁就可以被看成编程时的一个基本粒子,一堆积木中的一个固定模块,用来搭建更大的组件。

除了线程和锁这两个基本模块之外,定时器和线程池也比较常用。

线程池多用作线程频繁创建的时候。

在Poco中,把线程池封装成为一个对象,池中的线程在池存在时始终存活,只不过是线程状态有所不同,不是运行中就是挂起。

如果把线程看成一种资源的话,线程资源的申请和释放被放入了线程池的构造和析构函数中,Poco的这种封装也就是C++推荐的方法。

在Poco的线程池实现中,ThreadPool类还提供了一个线程池的单件接口。

这个由静态函数定义:[cpp]view plaincopy1.static ThreadPool& defaultPool();通过这个函数,使用者可以很方便的从Poco库中获取一个线程的起点,而无需关心线程维护的细节,这样使用者可以进一步把注意力放在需要实现的业务上。

在实现了ThreadPool的这个接口后,Poco类中关于线程的更高级封装即可以实现。

如定时器(Timer),主动对象(Activity Object),任务(Task)。

在Poco实现定时器,实现ThreadPool中的PooledThread,以及接下来要讨论的主动对象中的ActiveRunnable,RunnableAdapter,ActiveDispatcher时,可以发现这些类都从Runnable继承。

POCO C++库学习和分析 -- 内存管理 (三)

POCO C++库学习和分析 -- 内存管理 (三)

POCO C++库学习和分析-- 内存管理(三)看完Poco库中的智能指针,基本上Poco中的内存管理已经快结束了。

其他的部分都是些边边角角的东西,非常的简单。

下面一一介绍。

4. AutoReleasePoolAutoReleasePool类的出现也同样是为了解决用户动态分配对象的释放问题,但同智能指针AutoPtr和SharedPtr通过把堆上的对象包装成栈对象,再通过引用计数在类的析构函数中实现自动删除对象的解决方案不同是,其策略为构造一个容器,用来存储动态对象的指针,在AutoReleasePool析构函数中统一释放。

这个过程和java语言中的垃圾收集机制是类似的,只不过AutoReleasePool实现的非常简单,在AutoReleasePool销毁时释放资源,而在java语言中会连续不断的定时检查并释放闲置资源。

当然为了实现这个过程,AutoReleasePool对所释放的类是有要求的,释放的类必须实现release()接口。

下面通过一个例子来说明问题:[cpp]view plaincopy1.#include "Poco/AutoReleasePool.h"ing Poco::AutoReleasePool;3.class C4.{5.public:6. C()7. {}8.void release()9. {10.delete this;11. }12.};13.14.int main(int argc, char** argv)15.{16. AutoReleasePool<C> pool;17. C* pC = new C;18. pool.add(pC);19. pC = new C;20. pool.add(pC);21.return 0;22.}23.// all C's deleted其类图如下:在图中可以看出,AutoReleasePool实际上就是原生指针的一个容器,在其内部定义为:[cpp]view plaincopy1.std::list<C*> ObjectList _list需要注意的是,如果同时使用AutoReleasePool和AutoPtr对指针进行管理时,应该如此实现:[cpp]view plaincopy1.AutoReleasePool<C> arp;2.AutoPtr<C> ptr = new C;3. ...4.arp.add(ptr.duplicate());很明显此刻AutoReleasePool和AutoPtr对对象应该共享所有权。

POCO C++库学习和分析 -- 文件系统

POCO C++库学习和分析 -- 文件系统

POCO C++库学习和分析-- 文件系统既然作为一个框架性的库,自然会提供对于文件系统的操作。

在Poco库中,封装了一些类去完成上述操作。

这些类包括了:1. Poco::Path2. Poco::File3. Poco::TemporaryFile4. Poco::DirectoryIterator5. Poco::Glob这些类在实现上并没有什么特殊的注意点,主要是不同操作系统API的调用。

如果想学习API函数的话,确实是一个不错的例子。

在这里将主要介绍这些类的接口和使用,主要以翻译Poco的使用文档为主。

1. Poco::Path1.1 路径:1. 在不同操作系统中,指明文件和目录所在位置的标示符是不一样的。

2. 标示符的不一致,会造成代码在不同平台之间移植的困难。

3. Poco::Path类抽象了不同标识符之间的区别,使程序员可以把注意力集中在业务的开发上。

4. Poco::Path类支持Windows、Unix、OpenVMS操作系统。

1.2 Poco路径简介:Poco中的路径包括了:1. 一个可选的节点(node)名:a) 在Windows上,这是计算机在UNC(Universal Naming Convention)路径中的名字b) 在OpenVMS中,这代表一个集群系统中的节点名c) 在Unix中,此名字未被使用。

2. 一个可选的设备(device)名:a) 在Windows上,这是一个驱动器盘符b) 在OpenVMS上,这是存储盘符的名字c) 在Unix,此名字未被使用。

3. 一个目录名的列表4. 一个文件名(包括扩展名)和版本号(OpenVMS特有)Poco支持两种路径:1. 绝对路径以根目录为起点的描述资源的目录2. 相对目录以某一个确定路径为起点的描述资源的目录(通常这是用户的当前目录)相对目录可以被转换为绝对目录(反之,并不成立)。

在Poco中路径的指向可以是一个目录也可以是一个文件。

POCO C++库学习和分析 -- 日期与时间

POCO C++库学习和分析 -- 日期与时间

POCO C++库学习和分析-- 日期与时间在Poco库中,与时间和日期相关的一些类,其内部实现是非常简单的。

看相关文档时,比较有意思的倒是历史上的不同时间表示法。

1. 系统时间函数在编程时,时间函数不可避免的会被使用。

linux系统下相关时间的数据结构有time_t,timeval,timespec,tm,clock_t; windows下time_t,tm,SYSTEMTIME,clock_t。

其中clock_t、timeval、timespec用于表示时间跨度,time_t、tm、SYSTEMTIME用于表示绝对时间。

不同的数据结构之间,多少也有些差异。

首先这些时间结构体的精度不同,Second(time_t/tm),microsecond(timeval/SYSTEMTIME), nanoSeconds(timespec)。

起始时间不同,time_t起始于1970年1月1日0时0分0秒,tm表示起始于1900年,SYSTEMTIME 起始于1601年,clock起始于机器开机。

同这些数据结构相关联,C语言为tm,time_t提供了一组函数用于时间运算和数据结构转换:[cpp]view plaincopy1.// 日历时间(一个用time_t表示的整数)2.3.// 比较日历时间4.double difftime(time_t time1, time_t time0);5.// 获取日历时间6.time_t time(time_t * timer);7.// 转换日历时间为字符串8.char * ctime(const time_t *timer);9.// 转换日历时间为我们平时看到的把年月日时分秒分开显示的时间格式tm(GMT timezone)10.struct tm * gmtime(const time_t *timer);11.// 转换日历时间为我们平时看到的把年月日时分秒分开显示的时间格式tm(本地 timezone)12.struct tm * localtime(const time_t * timer);13.// 关于本地时间的计算公式:14.localtime = utctime[Gmt time] + utcOffset()[时区偏移] + dst()[夏令时偏移]15.16.17.// 把tm转换为字符串18.char * asctime(const struct tm * timeptr);19.// 把tm转换为日历时间20.time_t mktime(struct tm * timeptr);21.22.23.// 获取开机以来的微秒数24.clock_t clock (void);我们回想一下程序中的时间数据结构和函数的用法,可以发现主要是2个目的:1. 获取绝对时间2. 获取两个时间点的相对时间2. Timestamp类同C语言中函数类似,Poco中定义了自己的时间类。

POCOC++库学习和分析--流(一)

POCOC++库学习和分析--流(一)

POCOC++库学习和分析--流(⼀)POCO C++库学习和分析 -- 流(⼀)流(Stream)是C++和C之间的⼀⼤区别。

写C++的程序员都知道流的⽤法。

在Poco库中,在标准流的基础上⼜扩充了⼀些流,分别是基于Base64和HexBinary的编解码流,使⽤zlib的数据压缩流,⼆进制的I/O流,⽂件流,以及⼀些其他的辅助流;另外Poco库还提供了⼀个扩展的结构,⽤于创建⽤户⾃定义流。

Poco库中所有的流类都与标准c++库中的流兼容。

并且在Poco库中,⼤多数流都仅仅是个过滤器,这意味着它们不会直接从设备中读取或者写⼊数据,通常情况下它们会链接到另⼀个流上。

下⾯我们分别对它们进⾏介绍。

1. 标准c++流介绍在介绍Poco的流之前,我觉得有必要了解C++中的输⼊输出流,不然就会觉得Poco中的流很难理解。

在看完C++的流结构后,⾃然会对Poco库中的流内容豁然开朗。

我也⼀样。

为了保证语⾔和平台⽆关,C++和C⼀样,不具备内部输⼊输出能⼒。

语⾔的输⼊输出能⼒是和操作系统相关的,在最底层都是通过调⽤操作系统的I/O库实现。

在C++的iostream流库中,存在着两个基本部分。

分别是:1. 流:C++把输⼊和输出看作字节流。

输⼊时,程序从输出流中抽取字节;输出时,程序将字节插⼊到输出流中。

流充当了程序和流源或者流⽬标之间的桥梁。

2. 缓冲区:缓冲区是⽤作中介的内存块,它是将信息从设备传输到程序或者从程序传输到设备的临时存储⼯具,⽤以匹配程序和设备之间速度的差距。

从设计上说,增加了缓冲区,使的C++的iostream结构更具有扩展性。

C++的 :下⾯对C++中各个流类的介绍主要来⾃于wiki以及⽹站 。

1.1 ios_baseios_base类封装了C++标准中的流,并定义了在输⼊输出中不依赖于读写的数据类型的基本信息和⾏为,如格式化信息、异常状态、事件回调等。

在类std::ios_base中,保存了下述关于流的信息:格式控制信息的枚举类型fmtflags ,影响到如何解释输⼊串⾏的格式、如何⽣成输出串⾏的格式,例如整数是⽤16进制还是10进制表⽰,浮点数是科学计数法还是定点形式;流的状态枚举类型iostate,如数据是否完整、是否到达流的末尾、是否读写失败等;流的打开⽅式枚举类型openmode,如读取、写⼊、追加、创建时删除原内容、⼆进制打开、流的定位位置枚举类型seekdir,如开始位置、当前位置、结尾位置等。

C++POCO库中文编程

C++POCO库中文编程

C++POCO库中文编程1 What is POCO?POCO 是什么?这是我最常被人问到的。

POCO 是POrtable COmponents 的缩写,官方主页:。

是一个十分超卓的C++ 库,相当于Java 的Class Library、.NET 的Framework 和Apple 的Cocoa。

它与Boost 是十分不一样的,简单说Boost 即是相当于Advanced STL。

2 本系列文章所运用的POCO 版别POCO C++ Library 1.4.3p1 (2012-01-23)3 库逻辑布局下图摘自POCO 官网。

OS API 是运用操作系统层的,C++/C Standard Libararies 是规范库,其他的模块都是POCO 所供给的,包含:Foundation、XML、Crypto、XML、Util、Net、Zip、NetSSL、Data(撑持SQLite、ODBC、MySQL)、Tools & Utilities、Application。

4 撑持渠道Desktop/Server: - Windows - Linux - Mac OS X - Solaris - HP-UX - AIXEmbedded: - Windows Embedded CE - Embedded Linux (uClibc or glibc) - iOS - QNX - VxWorks - Android5 NamespacesPocoPoco::CryptoPoco::DataPoco::Data::MySQLPoco::Data::ODBCPoco::Data::SQLitePoco::NetPoco::UtilPoco::Util::UnitsPoco::Util::Units::ConstantsPoco::Util::Units::InternalPoco::Util::Units::ValuesPoco::XMLPoco::ZipC++ POCO库中文编程参阅攻略(2)根本数据类型(Poco/Types.h)根本类型在Poco/Types.h头文件中。

POCO C++库学习和分析 -- 线程 (三)

POCO C++库学习和分析 -- 线程 (三)

POCO C++库学习和分析-- 线程(三)4. 定时器定时器作为线程的扩展,也是编程时经常会被用到的元素。

在程序设计上,定时器的作用是很简单。

预定某个定时器,即希望在未来的某个时刻,程序能够得到时间到达的触发信号。

编程时,一般对定时器使用有下面一些关注点:1. 定时器的精度。

Poco中的定时器精度并不是很高,具体精度依赖于实现的平台(Windows or Linux)2. 定时器是否可重复,即定时器是否可触发多次。

Poco中的定时器精度支持多次触发也支持一次触发,由其构造函数Timer决定[cpp]view plaincopy1.Timer(long startInterval = 0, long periodicInterval = 0);2./// Creates a new timer object. StartInterval and periodicInterval3./// are given in milliseconds. If a periodicInterval of zero is4./// specified, the callback will only be called once, after the5./// startInterval expires.6./// To start the timer, call the Start() method.3. 一个定时器是否可以设置多个时间。

Poco中定时器不支持设置多个时间,每个定时器对应一个时间。

如果需要多个时间约定的话,使用者要构造多个定时器。

4.1 定时器实现Poco中的定时器并不复杂,下面是它的类图。

在类图中,Timer继承自Runnable类,也就是说Timer实现了自己的run函数。

来看一看,run函数的实现。

[cpp]view plaincopy1.void Timer::run()2.{3. Poco::Timestamp now;4.long interval(0);5.do6. {7.long sleep(0);8.do9. {10. now.update();11. sleep = static_cast<long>((_nextInvocation - now)/1000);12.if (sleep < 0)13. {14.if (interval == 0)15. {16. sleep = 0;17.break;18. }19. _nextInvocation += interval*1000;20. ++_skipped;21. }22. }23.while (sleep < 0);24.25.if (_wakeUp.tryWait(sleep))26. {27. Poco::FastMutex::ScopedLock lock(_mutex);28. _nextInvocation.update();29. interval = _periodicInterval;30. }31.else32. {33.try34. {35. _pCallback->invoke(*this);36. }37.catch (Poco::Exception& exc)38. {39. Poco::ErrorHandler::handle(exc);40. }41.catch (std::exception& exc)42. {43. Poco::ErrorHandler::handle(exc);44. }45.catch (...)46. {47. Poco::ErrorHandler::handle();48. }49. interval = _periodicInterval;50. }51. _nextInvocation += interval*1000;52. _skipped = 0;53. }54.while (interval > 0);55. _done.set();56.}在run函数中,我们发现定时器的业务就是不断更新下一次触发时间,并通过睡眠等待到预定时间,触发调用者业务。

POCO C++库学习和分析 -- 随机数和数字摘要

POCO C++库学习和分析 --  随机数和数字摘要

POCO C++库学习和分析-- 随机数和数字摘要在程序设计时,有时候我们需要生成随机数和数字摘要。

在Poco库中,也提供了上述功能,下面我们一一叙述:1. 随机数生成Poco中生成随机数的类为Poco::Random类。

它根据PRNG(pseudo random number generator )算法设计,采用了一个累加的非线性反馈算法。

PRNG算法可以产生0 ~ 2^31之间的随机数整数。

在接口上Poco::Random提供了一些函数,可以使使用者直接得到其他形式的随机数。

如char, bool, float 和double 类型。

另外Poco库中还提供了RandomInputStream类,用于Poco::Random类的流操作。

成员函数:1. void seed(Poco::UInt32 seed)根据给定的种子值生成随机数。

2. void seed()使用任意值(从RandomInputStream类中获取)生成随机数。

3. 默认的构造时,Poco::Random类采用当前的时间和日期生成随机数。

如果想要更好的随机效果,需要显式的调用seed()方法4. UInt32 next()返回0 ~ 2^31之间的随机整数5. UInt32 next(UInt32 n)返回0 ~ n之间的随机整数6. char nextChar()返回随机Char值7. bool nextBool()返回随机bool值8. float nextFloat()返回随机float值,范围0 ~ 19. double nextDouble()返回随机double值,范围0 ~ 1下面是关于Random的一个例子:[cpp]view plaincopy1.#include "Poco/Random.h"2.#include "Poco/RandomStream.h"3.#include <iostream>ing Poco::Random;ing Poco::RandomInputStream;6.int main(int argc, char** argv)7.{8. Random rnd;9. rnd.seed();10. std::cout << "Random integer: " << rnd.next() << std::endl;11. std::cout << "Random digit: " << rnd.next(10) << std::endl;12. std::cout << "Random char: " << rnd.nextChar() << std::endl;13. std::cout << "Random bool: " << rnd.nextBool() << std::endl;14. std::cout << "Random double: " << rnd.nextDouble() << std::endl;15. RandomInputStream ri;16. std::string rs;17. ri >> rs;18.return 0;19.}2. 密码散列下面这段是Wiki上关于密码散列的介绍:A cryptographic hash function is a hash function with certain additional security properties to make it suitable for use as a primitive in various information security applications, such as authentication and message integrity. A hash function takes a long string (or message) of any length as input and produces a fixed length string as output, sometimes termed a message digest or a digital fingerprint. Wikipedia2.1 概述密码散列(cryptographic hash)是将目标文本转换成具有相同长度的、不可逆的杂凑字符串(或叫做消息摘要)。

POCO C++库学习和分析 -- 通知和事件 (三)

POCO C++库学习和分析 -- 通知和事件 (三)

POCO C++库学习和分析-- 通知和事件(三)4. 异步通知4.1 NotificationQueue类Poco中的异步通知是通过NotificationQueue类来实现的,同它功能类似还有类PriorityNotificationQueue和TimedNotificationQueue。

不同的是PriorityNotificationQueue类中对消息分了优先级,对优先级高的消息优先处理;而TimedNotificationQueue对消息给了时间戳,时间戳早的优先处理,而和其压入队列的时间无关。

所以接下来我们主要关注NotificationQueue的实现。

事实上NotificationQueue是个非常有趣的类。

让我们来看一下它的头文件:[cpp]view plaincopy1.class Foundation_API NotificationQueue2./// A NotificationQueue object provides a way to implement asynchronous3./// notifications. This is especially useful for sending notifications4./// from one thread to another, for example from a background thread to5./// the main (user interface) thread.6.///7./// The NotificationQueue can also be used to distribute work from8./// a controlling thread to one or more worker threads. Each worker thread9./// repeatedly calls waitDequeueNotification() and processes the10./// returned notification. Special care must be taken when shutting11./// down a queue with worker threads waiting for notifications.12./// The recommended sequence to shut down and destroy the queue is to13./// 1. set a termination flag for every worker thread14./// 2. call the wakeUpAll() method15./// 3. join each worker thread16./// 4. destroy the notification queue.17.{18.public:19. NotificationQueue();20./// Creates the NotificationQueue.21.22. ~NotificationQueue();23./// Destroys the NotificationQueue.24.25.void enqueueNotification(Notification::Ptr pNotification);26./// Enqueues the given notification by adding it to27./// the end of the queue (FIFO).28./// The queue takes ownership of the notification, thus29./// a call like30./// notificationQueue.enqueueNotification(new MyNotification);31./// does not result in a memory leak.32.33.void enqueueUrgentNotification(Notification::Ptr pNotification);34./// Enqueues the given notification by adding it to35./// the front of the queue (LIFO). The event therefore gets processed36./// before all other events already in the queue.37./// The queue takes ownership of the notification, thus38./// a call like39./// notificationQueue.enqueueUrgentNotification(new MyNotification);40./// does not result in a memory leak.41.42. Notification* dequeueNotification();43./// Dequeues the next pending notification.44./// Returns 0 (null) if no notification is available.45./// The caller gains ownership of the notification and46./// is expected to release it when done with it.47.///48./// It is highly recommended that the result is immediately49./// assigned to a Notification::Ptr, to avoid potential50./// memory management issues.51.52. Notification* waitDequeueNotification();53./// Dequeues the next pending notification.54./// If no notification is available, waits for a notification55./// to be enqueued.56./// The caller gains ownership of the notification and57./// is expected to release it when done with it.58./// This method returns 0 (null) if wakeUpWaitingThreads()59./// has been called by another thread.60.///61./// It is highly recommended that the result is immediately62./// assigned to a Notification::Ptr, to avoid potential63./// memory management issues.64.65. Notification* waitDequeueNotification(long milliseconds);66./// Dequeues the next pending notification.67./// If no notification is available, waits for a notification68./// to be enqueued up to the specified time.69./// Returns 0 (null) if no notification is available.70./// The caller gains ownership of the notification and71./// is expected to release it when done with it.72.///73./// It is highly recommended that the result is immediately74./// assigned to a Notification::Ptr, to avoid potential75./// memory management issues.76.77.void dispatch(NotificationCenter& notificationCenter);78./// Dispatches all queued notifications to the given79./// notification center.80.81.void wakeUpAll();82./// Wakes up all threads that wait for a notification.83.84.bool empty() const;85./// Returns true iff the queue is empty.86.87.int size() const;88./// Returns the number of notifications in the queue.89.90.void clear();91./// Removes all notifications from the queue.92.93.bool hasIdleThreads() const;94./// Returns true if the queue has at least one thread waiting95./// for a notification.96.97.static NotificationQueue& defaultQueue();98./// Returns a reference to the default99./// NotificationQueue.100.101.protected:102. Notification::Ptr dequeueOne();103.104.private:105.typedef std::deque<Notification::Ptr> NfQueue;106.struct WaitInfo107. {108. Notification::Ptr pNf;109. Event nfAvailable;110. };111.typedef std::deque<WaitInfo*> WaitQueue;112.113. NfQueue _nfQueue;114. WaitQueue _waitQueue;115.mutable FastMutex _mutex;116.};从定义可以看到NotificationQueue类管理了两个deque容器。

POCO C++库学习和分析 -- 进程

POCO C++库学习和分析 -- 进程

POCO C++库学习和分析-- 进程Poco::Foundation库中涉及进程的内容主要包括了4个主题,分别是进程(Process)、进程间同步(inter-process synchronization)、管道(Pipes)、共享内存(Shared Memory)。

我们都知道管道、共享内存、网络通讯是进程间数据交互的3种基本方式。

由于网络通讯足够复杂,在Poco的结构划分里被单独分成了一个库Net,Foundation库中并没有涉及。

下面一一介绍:1. 进程关于中的进程其实没有什么可说的,不管是其内部实现还是外部使用都非常的简单。

内部实现上只不过是不同操作系统进程API的封装,下面是它的类图:在Poco中进程类的所有成员函数都是静态函数。

主要的功能函数覆盖3个方面:1. 创建新进程2. 销毁其他进程3. 获取当前进程信息值得注意的是,在Poco中进程创建时,可以对进程的I/O进程重定向。

其函数如下:[cpp]view plaincopy1.ProcessHandle Process::launch( const std::string& path, const std::vector<std::string>& args, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe)2. 进程间同步Poco库中提供了Poco::NamedMutex和Poco::NamedEvent类用于进程间的同步。

同线程间同步的类Mutex,Event相比,进程间同步都是命名的,这毫无疑问是因为操作系统的底层函数的要求。

其类图如下:3. 管道我们都知道管道是一个单向的通讯通道,或者用来读或者用来写。

如果两个进程间要实现双向的通讯,必须在进程之间创建两个管道。

Poco库中也封装了管道方便进程通讯,但Poco库中对于管道的读写,却不是通过管道的本身,而是通过Poco::PipeOutputStream和Poco::PipeInputStream 两个类。

POCO C++库学习和分析 -- 任务

POCO C++库学习和分析 -- 任务

POCO C++库学习和分析-- 任务1. 任务的定义任务虽然在Poco::Foundation库的目录结构中被单独划出,其实也可以被看成线程的应用,放在线程章节。

首先来看一下Poco中对于任务的描述:∙task主要应用在GUI和Seerver程序中,用于追踪后台线程的进度。

∙应用Poco任务时,需要类Poco::Task和类Poco::TaskManager配合使用。

其中类Poco::Task继承自Poco::Runnable,它提供了接口可以便利的报告线程进度。

Poco::TaskManager则对Poco::Task 进行管理。

∙为了完成取消和上报线程进度的工作:a. 使用者必须从Poco::Task创建一个子类并重写runTask()函数b. 为了完成进度上报的功能,在子类的runTask()函数中,必须周期的调用setProgress()函数去上报信息c. 为了能够在任务运行时终止任务,必须在子类的runTask()函数中,周期性的调用isCancelled()或者sleep()函数,去检查是否有任务停止请求d. 如果isCancelled()或者sleep()返回真,runTask()返回。

∙Poco::TaskManager通过使用Poco::NotificationCenter 去通知所有需要接受任务消息的对象从上面描述可以看出,Poco中Task的功能就是能够自动汇报线程运行进度。

2. 任务用例Task的应用非常简单,下面是其一个使用例子:[cpp]view plaincopy1.#include "Poco/Task.h"2.#include "Poco/TaskManager.h"3.#include "Poco/TaskNotification.h"4.#include "Poco/Observer.h"5.ing Poco::Observer;7.class SampleTask: public Poco::Task8.{9.public:10. SampleTask(const std::string& name): Task(name)11. {}12.13.14.void runTask()15. {16.for (int i = 0; i < 100; ++i)17. {18. setProgress(float(i)/100); // report progress19.if (sleep(1000))20.break;21. }22. }23.};24.25.class ProgressHandler26.{27.public:28.void onProgress(Poco::TaskProgressNotification* pNf)29. {30. std::cout << pNf->task()->name()31. << " progress: " << pNf->progress() << std::endl;32. pNf->release();33. }34.void onFinished(Poco::TaskFinishedNotification* pNf)35. {36. std::cout << pNf->task()->name() << " finished." << std::endl;37. pNf->release();38. }39.};40.41.int main(int argc, char** argv)42.{43. Poco::TaskManager tm;44. ProgressHandler pm;45.tm.addObserver(46. Observer<ProgressHandler, Poco::TaskProgressNotification>47. (pm, &ProgressHandler::onProgress)48. );49.tm.addObserver(50. Observer<ProgressHandler, Poco::TaskFinishedNotification>51. (pm, &ProgressHandler::onFinished)52. );53.tm.start(new SampleTask("Task 1")); // tm takes ownership54.tm.start(new SampleTask("Task 2"));55.tm.joinAll();56.return 0;57.}3. Task类图最后给出Poco中Task的类图。

poco库介绍

poco库介绍

POCO C++库导游2010年07月16日星期五 15:23POCO C++库导游IntroductionA Guided Tour of the POCO C++ Libraries简介POCO C++库是开源的用于简化和加速C++开发面向网络、可移植应用程序的C++库集,POCO库和C++标准库可以很好的集成并填补了C++标准库缺乏的功能空隙。

POCO库的模块化、高效的设计及实现使得POCO特别适合嵌入式开发。

在嵌入式开发领域,由于C++既适合底层(设备I/O、中断处理等)和高层面向对象开发,越来越流行。

当然POCO也准备好了面对企业级挑战。

包含4个核心库及一些附加库. 这4个核心库是: Foundation, XML, Util 和Net. 附加库中其中2个是NetSSL和Data,NetSSL为Net库中的网络类提供SSL 支持, Data库提供访问不同SQL数据库的一致性接口。

POCO以网络中心的跨平台C++软件开发,就像苹果的Cocoa之余Mac开发, 或Ruby on Rails 之余Web 开发—强大而不失简单有趣的用于创建应用的平台. POCO 严格使用标准ANSI/ISO C++创建, 包含标准库. 程序库的贡献者试图在使用C++高级特性、易于理解的类、干净的代码、连续及易于维护间得到平衡.Foundation基本库Foundation库是POCO的心脏.它包含底层平台的封装层,也包含经常使用的工具类和函数. 包含规定字节大小整数类型, 转换整数与字节顺序的函数, Poco::Any 类 (基于 boost::any), 错误处理及调试工具, 包含各种异常类和支持断言. 同时也包含一些内存管理类, 包括基于引用计数的智能指针,和用与buffer管理及内存池的类. 对于字符串的处理, POCO包含一些函数和其他的东西, 串trim操作, 大小写敏感的比较和大小写转换. 以类对Unicode的基本支持:转换文本的不同编码, 包括UTF-8 和 UTF-16. 支持格式化和解析数字, 包括sprintf 的类型安全变量. 还提供了基于著名的PCRE 库()的正则表达式。

POCO C++库学习和分析 -- UUID

POCO C++库学习和分析 -- UUID

POCO C++库学习和分析-- UUID1. 概述通用唯一识别码(英语:Universally Unique Identifier,简称UUID)是一种软件建构的标准。

UUID 的目的,是让分散式系统中的所有元素,都能有唯一的辨识信息,而不需要通过中央控制端来做辨识信息的指定。

一组UUID,是由一串16位组(亦称128位)的16进位数字所构成,是故UUID理论上的总数为216 x 8=2128,约等于3.4 x 1038。

UUID的标准型式包含32个16进位数字,以连字号分为五段,形式为8-4-4-4-12的36个字符。

Poco中提供了Poco::UUID类来存储UUID信息,提供了Poco::UUIDGenerator类生成UUID信息。

其类图如下:2. Poco::UUID与Poco::UUIDGenerator类Poco::UUID类很简单,用于存储UUID信息,支持所有的值语义,包括所有的关系运算符,也支持字符串之间的相互准换。

Poco::UUIDGenerator类用于生成UUID信息。

UUIDGenerator类生成UUID信息的方法有3中,分别是基于时间生成、基于名字(数字摘要)生成、基于随机数生成。

基于时间的函数如下:[cpp]view plaincopy1.UUID UUIDGenerator::create()2.{3. FastMutex::ScopedLock lock(_mutex);4.5.if (!_haveNode)6. {7. Environment::nodeId(_node);8. _haveNode = true;9. }10. Timestamp::UtcTimeVal tv = timeStamp();11. UInt32 timeLow = UInt32(tv & 0xFFFFFFFF);12. UInt16 timeMid = UInt16((tv >> 32) & 0xFFFF);13. UInt16 timeHiAndVersion = UInt16((tv >> 48) & 0x0FFF) + (UUID::UUID_TIME_BASED << 12);14. UInt16 clockSeq = (UInt16(_random.next() >> 4) & 0x3FFF) | 0x8000;15.return UUID(timeLow, timeMid, timeHiAndVersion, clockSeq, _node);16.}从上面我们看到,其获取了Mac地址信息和当前时间戳,最终生成uuid信息。

POCO C++库学习和分析 -- 流 (三)

POCO C++库学习和分析 -- 流 (三)

POCO C++库学习和分析-- 流(三)5 . ZLib Stream流Poco::DeflatingInputStream、Poco::DeflatingOutputStream、Poco::InflatingInputStream和Poco::InflatingOutputStream把zlib的压缩过程封装成为流方式。

在讨论其实现之前,先来了解一下涉及到的压缩和校验算法。

5.1 zlib库在Poco中实现的压缩过程是通过zlib库实现的。

下面对zlib的介绍主要来自于wiki百科。

zlib是提供资料压缩之用的函式库,由Jean-loup Gailly与Mark Adler所开发,初版0.9版在1995年5月1日发表。

zlib目前应用很广泛,下面是其一些应用例子:* Linux核心:使用zlib以实作网络协定的压缩、档案系统的压缩以及开机时解压缩自身的核心。

* libpng,用于PNG图形格式的一个实现,对bitmap数据规定了DEFLATE作为流压缩方法。

* Apache:使用zlib实作http 1.1。

* OpenSSH、OpenSSL:以zlib达到最佳化加密网络传输。

* FFmpeg:以zlib读写Matroska等以DEFLATE算法压缩的多媒体串流格式。

* rsync:以zlib最佳化远端同步时的传输。

* The dpkg and RPM package managers, which use zlib to unpack files from compressed software packages.* Subversion 、Git和CVS 版本控制系统,使用zlib来压缩和远端仓库的通讯流量。

* dpkg和RPM等包管理软件:以zlib解压缩RPM或者其他封包。

* 因为其代码的可移植性,宽松的许可以及较小的内存占用,zlib在许多嵌入式设备中也有应用。

zlib支持两种封装格式:gzip和zlib stream。

C++的I,O流库(一)

C++的I,O流库(一)

一、屏幕输出1、使用预定义的插入符cout <<数据1<<数据2<<endl;a、在该输出语句中,可以串联多个插入运算符,输出多个数据项;b、在插入运算符右边可以写任意复杂的表达式,系统自动计算出它的值并传给插入符。

c、在使用插入符时要注意运算符的优先级,当遇到比插入符优先级别低的运算时(如三目运算符?:),要用一个括号括起来。

2、使用成员函数put()输出一个字符格式如下:cout.put(char c);连续输出cout.put(char c1) .put(char c2)…;3、使用成员函数write()输出一个字符串格式如下:cout.write(const char *sir,int n);其中:sir是一个字符指针或数组;n为输出字符串中字符的个数。

二、键盘输入1、使用预定义的提取符格式如下:cin >> <表达式> >> <表达式>…提取符可以连续写多个,每个后面跟一个表达式,该表达式通常是获得输入值的变量或对象。

2、使用成员函数get()获取一个字符格式如下:cin.get(char &ch);&ch是一个字符变量的地址值,用来存放所获得的字符。

get()函数的另外一种形式getline(),该函数的功能是可以从输入流中读取多个字符。

格式如下:cin.getline(char *buf,int limit,Deline= '\n');其中:buf是一个字符指针或者是一个字符数组;limit用来限制读取到buf字符数组中的字符个数,最多只能读到limit-1个。

Deline是读取字符时指定的结束符,默认值是'\n'。

getline()函数可以用来每次读取一行,结束操作的条件有:⑴从输入流中读取limit-1个字符后;⑵从输入流中读取到换行符或其他终止符;⑶从输入流中读取到文件或输入流结束符后。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

POCO C++库学习和分析-- 流(一)流(Stream)是C++和C之间的一大区别。

写C++的程序员都知道流的用法。

在Poco库中,在标准流的基础上又扩充了一些流,分别是基于Base64和HexBinary的编解码流,使用zlib的数据压缩流,二进制的I/O流,文件流,以及一些其他的辅助流;另外Poco库还提供了一个扩展的结构,用于创建用户自定义流。

Poco库中所有的流类都与标准c++库中的流兼容。

并且在Poco库中,大多数流都仅仅是个过滤器,这意味着它们不会直接从设备中读取或者写入数据,通常情况下它们会链接到另一个流上。

下面我们分别对它们进行介绍。

1. 标准c++流介绍在介绍Poco的流之前,我觉得有必要了解C++中的输入输出流,不然就会觉得Poco中的流很难理解。

在看完C++的流结构后,自然会对Poco库中的流内容豁然开朗。

我也一样。

为了保证语言和平台无关,C++和C一样,不具备内部输入输出能力。

语言的输入输出能力是和操作系统相关的,在最底层都是通过调用操作系统的I/O库实现。

在C++的iostream流库中,存在着两个基本部分。

分别是:1. 流:C++把输入和输出看作字节流。

输入时,程序从输出流中抽取字节;输出时,程序将字节插入到输出流中。

流充当了程序和流源或者流目标之间的桥梁。

2. 缓冲区:缓冲区是用作中介的内存块,它是将信息从设备传输到程序或者从程序传输到设备的临时存储工具,用以匹配程序和设备之间速度的差距。

从设计上说,增加了缓冲区,使的C++的iostream结构更具有扩展性。

C++的输入输出类图:下面对C++中各个流类的介绍主要来自于wiki以及网站cplusplus。

1.1 ios_baseios_base类封装了C++标准中的流,并定义了在输入输出中不依赖于读写的数据类型的基本信息和行为,如格式化信息、异常状态、事件回调等。

在类std::ios_base中,保存了下述关于流的信息:格式控制信息的枚举类型fmtflags ,影响到如何解释输入串行的格式、如何生成输出串行的格式,例如整数是用16进制还是10进制表示,浮点数是科学计数法还是定点形式;流的状态枚举类型iostate,如数据是否完整、是否到达流的末尾、是否读写失败等;流的打开方式枚举类型openmode,如读取、写入、追加、创建时删除原内容、二进制打开、流的定位位置枚举类型seekdir,如开始位置、当前位置、结尾位置等。

流的事件枚举类型event,如“擦除”事件erase_event,改变locale设置事件imbue_event,复制格式事件copyfmt_event。

流的私有的其它额外保存的数据,为一个long型数组与一个指针数组。

一个成员类failure,用于作为C++标准中,流输入输出类库抛出的各种异常的基类。

一个成员类Init,用于封装cout、cin、wcout等8个静态对象的初始化函数。

成员函数包括:格式化:1. 读取/设置流的格式[cpp]view plaincopy1.fmtflags flags() const;2.fmtflags flags (fmtflags fmtfl);例子:[cpp]view plaincopy1.// modify flags2.#include <iostream> // std::cout, std::ios3.4.int main () {5. std::cout.flags ( std::ios::right | std::ios::hex | std::ios::showbase );6. std::cout.width (10);7. std::cout << 100 << '\n';8.return 0;9.}2. 设置流的格式,与原有格式合并[cpp]view plaincopy1.fmtflags setf (fmtflags fmtfl);2.fmtflags setf (fmtflags fmtfl, fmtflags mask);例子:1.// modifying flags with setf/unsetf2.#include <iostream> // std::cout, std::ios3.4.int main () {5. std::cout.setf ( std::ios::hex, std::ios::basefield ); // set hex as the basefield6. std::cout.setf ( std::ios::showbase ); // activate showbase7. std::cout << 100 << '\n';8. std::cout.unsetf ( std::ios::showbase ); // deactivate showbase9. std::cout << 100 << '\n';10.return 0;11.}输出:Output:0x64643. 根据参数mask,清除流的格式的某些位(bit)[cpp]view plaincopy1.void unsetf (fmtflags mask);例子:[cpp]view plaincopy1.// modifying flags with setf/unsetf2.#include <iostream> // std::cout, std::ios3.4.int main () {5. std::cout.setf ( std::ios::hex, std::ios::basefield ); // set hex as the basefield6. std::cout.setf ( std::ios::showbase ); // activate showbase7. std::cout << 100 << '\n';8. std::cout.unsetf ( std::ios::showbase ); // deactivate showbase9. std::cout << 100 << '\n';10.return 0;11.}输出:0x64644. 读取/设置显示浮点数时的精度[cpp]view plaincopy1.streamsize precision() const;2.streamsize precision (streamsize prec);例子:[cpp]view plaincopy1.// modify precision2.#include <iostream> // std::cout, std::ios3.4.int main () {5.double f = 3.14159;6. std::cout.unsetf ( std::ios::floatfield ); // floatfield not set7. std::cout.precision(5);8. std::cout << f << '\n';9. std::cout.precision(10);10. std::cout << f << '\n';11. std::cout.setf( std::ios::fixed, std:: ios::floatfield ); // floatfield set to fixed12. std::cout << f << '\n';13.return 0;14.}输出:3.14163.141593.14159000005. 读取/设定流的输出数据的显示宽度[cpp]view plaincopy1.streamsize width() const;2.streamsize width (streamsize wide);例子:[cpp]view plaincopy1.// field width2.#include <iostream> // std::cout, std::left3.4.int main () {5. std::cout << 100 << '\n';6. std::cout.width(10);7. std::cout << 100 << '\n';8. std::cout.fill('x');9. std::cout.width(15);10. std::cout << std::left << 100 << '\n';11.return 0;12.}输出:100100100xxxxxxxxxxxx语言环境:1. 给流设置本地语言环境[cpp]view plaincopy1.locale imbue (const locale& loc);例子:[cpp]view plaincopy1.// imbue example2.#include <iostream> // std::cout3.#include <locale> // std::locale4.5.int main()6.{7. std::locale mylocale(""); // get global locale8. std::cout.imbue(mylocale); // imbue global locale9. std::cout << 3.14159 << '\n';10.return 0;11.}输出:3,141592. 获取当前使用语言环境[cpp]view plaincopy1.locale getloc() const;1.2 basic_iosbasic_ios定义出“与字符类型及其相应字符特性相关”的stream class的共同属性,其中包括清除流状态、设置流状态、拷贝流标志、返回或设置流缓冲区指针、设置本地化相关信息、返回或设置填充字符、字符转换,还包括了stream所用的缓冲器.basic_ios在其内部定义了一个指向streambuf的指针。

相关文档
最新文档