POCO C 库学习和分析 -- 通知和事件 (四)
poco 线程池用法 -回复
poco 线程池用法-回复Poco线程池用法Poco是一个基于C++的开源类库，提供了丰富的工具和组件，用于快速开发跨平台的应用程序。
其中，Poco线程池是其中一个很重要的组件，它能够简化多线程编程和管理，提高程序性能和可维护性。
本文将详细介绍Poco线程池的用法，并逐步解释其实现方式和注意事项。
I. Poco线程池的概念在多线程编程过程中，手动管理线程的创建、销毁和资源分配，会增加代码的复杂性并降低程序性能。
Poco线程池可以在应用程序中管理线程的生命周期，并且可以控制并发执行的任务数量。
简而言之，Poco 线程池是一种重用线程的机制，可以加速任务的执行并减少资源消耗。
II. 创建Poco线程池在使用Poco线程池之前，需要先创建一个线程池对象。
可以调用Poco::ThreadPool构造函数创建一个线程池对象，如下所示：Poco::ThreadPool threadPool(minCapacity, maxCapacity, idleTime,stackSize);其中，minCapacity是线程池的最小容量，maxCapacity是最大容量，idleTime是线程的空闲时间（以毫秒为单位），stackSize是线程栈的大小（以字节为单位）。
III. 向线程池添加任务一旦创建了线程池，就可以向其中添加任务。
任务使用Poco::Runnable接口表示，该接口要求实现run()函数，用于指定要在线程中执行的任务。
可以通过Poco线程池对象的start()函数将任务添加到线程池中，如下所示：threadPool.start(runnable);其中，runnable是实现了Poco::Runnable接口的具体任务对象，可以通过继承Poco::Runnable类或者实现Poco::Runnable接口来创建。
IV. 控制任务数量一个常见的问题是如何控制在线程池中并发执行的任务数量。
Poco线程池提供了一种简单的方法来限制任务的数量，通过设置线程池的最大容量来实现。
poco 线程池用法
poco线程池用法Poco是一个功能强大的C++库，提供了丰富的多线程编程工具，其中包括线程池机制。
线程池是一种常用的并发编程模型，它通过预先创建和池化线程来减少系统资源的开销，提高程序的性能和响应速度。
在Poco中，线程池的实现是通过Poco::ThreadPool类来实现的。
本篇文章将详细介绍Poco::ThreadPool的使用方法。
一、创建线程池要使用Poco::ThreadPool创建一个线程池，首先需要创建一个Poco::ThreadPool对象，并指定线程池的大小（即线程池中最大线程数）。
例如：```cppPoco::ThreadPool*threadPool=newPoco::ThreadPool(5);```这将创建一个包含5个线程的线程池。
二、提交任务创建线程池后，可以使用ThreadPool对象来提交任务。
任务可以是任何可调用对象，例如函数、lambda表达式或类对象成员函数。
提交任务时，需要将任务对象作为参数传递给ThreadPool对象的enqueue()方法。
例如：```cppvoidmyTask(){//任务执行的代码}intmain(){Poco::ThreadPool*threadPool=newPoco::ThreadPool(5);threadPool->enqueue(myTask);deletethreadPool;return0;}```上述代码中，myTask()函数被提交到线程池中，由线程池中的线程异步执行。
三、管理线程池Poco::ThreadPool提供了多种方法来管理线程池，例如添加、删除线程池、停止线程池等。
此外，还可以获取当前线程池中的线程数、已完成任务数等信息。
例如：```cppintcurrentThreadCount=threadPool->getThreadCount();intcompletedTasks=threadPool->getCompletedTasks();```四、注意事项在使用Poco::ThreadPool时，需要注意以下几点：1.不要在任务中创建新的线程或使用动态分配的线程。
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的使命
Poco是一个强大的类库，并易于构建自己的应用程序 Poco帮助你创建跨平台的应用程序（一次编写，多平台编译和运行） 模块化和可扩展，可应用于嵌入式到企业级程序 提供全面，易懂的编程接口 使用C++语言，快速且高效 Poco崇尚简易
在设计，代码风格和文档上保持一致
Poco强调代码质量，包括可读性，综合性，一致性，编码风格和可测试性 Poco使得C++编程更加容易
支持平台
桌面/服务器:
Windows, Linux, Mac OS X, Solaris, HP-UX, AIX
嵌入式系统:
Windows Embedded CE, Embedded Linux (uClibc or glibc), iOS, QNX, VxWorks, Android
2017年2月：Release 1.7.8
2017年2月：Release 1.7.8p2
Poco库概览
核心特性
支持Any 和 DynamicAny 的动态类型 提供缓存框架 日期和时间 事件与通知框架 基于PCRE的正则表达式 动态库加载
完美的指针和内存管理 (buffer, pool)
数据库
不同的数据库提供了统一的访问接口(SQLite, MySQL, ODBC) 自动数据类型匹配
支持集合类 (std::vector, std::set, std::map, etc.)
支持记录集和tuples 支持连接池
资源文档
官网（英文）：https:/// 用户指南： https:///docs/ 中文网站（个人）：/ 博客专栏：POCO C++库学习和分析（共33篇，作者：napu_sh）
c#委托与事件（详解）
c#委托与事件（详解）⽬录前⾔⼀、声明⽅法⼆、声明委托三、实例化委托四、使⽤委托总结前⾔.NET中的委托是⼀个类，它定义了⽅法的类型，是⼀个⽅法容器。
委托把⽅法当作参数，可以避免在程序中⼤量使⽤条件判断语句的情况。
项⽬名为Test，class类名为Program⼀、声明⽅法在class类中声明⼏个⽅法，以便委托的使⽤。
using System;namespace Test{class Program{/// <summary>/// 返回两个数中较⼤者/// </summary>/// <param name="num1">int类型</param>/// <param name="num2">int类型</param>/// <returns></returns>public static int max(int num1, int num2){return num1 > num2 ? num1 : num2;//如果num1⼤于num2时，就返回num1，否则返回num2}/// <summary>/// 返回两个数中较⼩者/// </summary>/// <param name="num1">int类型</param>/// <param name="num2">int类型</param>/// <returns></returns>public static int min(int num1, int num2){return num1 > num2 ? num2 : num1;//如果num1⼤于num2时，就返回num2，否则返回num1}static void Main(string[] args){}}}⼆、声明委托声明时使⽤delegate关键字来声明委托，委托声明定义了⼀个从System.Delegate类派⽣的类。
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继承。
C++事件分析(Event)
C++事件编程原文出处：Event Programming在微软 .NET 框架中可以定义托管类事件并用委托和+= 操作符处理这些事件。
这种机制似乎很有用，那么在本机C++ 中有没有办法做同样的事情？Several Readers 确实如此！Visual C++ .NET 具备所谓统一事件模型（Unified Event Model），它可以像托管类一样实现本机事件（用__event 关键字），但是由于本机事件存在一些不明显的技术问题，而微软的老大不打算解决这些问题，所以他们要我正式奉劝你不要使用它们。
那么这是不是就是说C++ 程序员与事件无缘了呢？当然不是！可以通过别的方法实现。
本文我将向你展示如何轻松实现自己漂亮的事件系统。
但是在动手之前，让我先大体上介绍一下事件和事件编程。
它是个重要的主题，当今对事件没有坚实的理解，你是无法编写程序的——什么是事件以及什么时候使用事件。
成功的编程完全在于对复杂性的掌控。
很久以前，函数被称为“子程序”（我知道，我这样说证明我已经老了!）管理复杂性的主要方式之一是自顶向下的编程模式。
高层实现类似“宇宙模型”，然后将它划分为更小的任务如：“银河系模型”以及“太阳系模型”等等，直到任务被划分为可以用单个函数实现为止。
目前自顶向下的编程模型仍被用于过程化的任务实现当中，但它不适用于发生顺序不确定的实时事件响应系统。
经典的例子便是GUI，程序必须响应用户的某些行为，比如按键或是鼠标移动。
实际上，事件编程很到程度上源于图形用户界面的出现。
在自顶向下的模型中，在顶部的高级部分对低级的实现各种不同任务的函数——如DoThis，DoThat 进行食物链式的调用。
但不久以后，低层部分需要回调（talk back），在Windows 中，可以调用Rectangle 或Ellipse 绘制一个矩形或椭圆，但最终Windows 需要调用你的应用程序来画窗口。
但应用程序都还不存在，它仍然处于被调用度状态！那么Windows 如何知道要调用哪个函数呢？这就是事件用处之所在。
poco用法 -回复
poco用法-回复Poco，全名为Portability and Optimized C++ Library，是一个跨平台的C++开发框架，广泛应用于移动设备开发及游戏开发等领域。
它提供了丰富的工具和类库，可以简化C++应用程序的开发过程，提高开发效率。
本文将一步一步回答关于Poco用法的问题，介绍如何使用该框架进行开发工作。
第一步：Poco的安装在开始使用Poco之前，首先需要将Poco框架安装到开发环境中。
Poco框架的安装步骤可能会因开发环境不同而有所不同，但一般来说，可以通过以下步骤完成：1. 下载Poco源码：Poco项目的源码通常可以在官方网站上下载。
根据你的操作系统和编译器版本选择合适的源码包，下载到本地。
2. 解压源码：将下载的源码包解压到你希望安装Poco的目录下。
3. 编译Poco：打开终端或命令提示符窗口，进入到Poco源码目录下执行相应的编译命令。
具体的编译命令需要根据你的操作系统和编译器来确定，可以在Poco的官方文档中找到相关信息。
4. 安装Poco：编译完成后，执行安装命令将Poco框架安装到系统中。
同样，具体的安装命令也可以在官方文档中找到。
完成以上步骤后，Poco框架就已经安装到了你的开发环境中，可以开始使用它进行开发工作了。
第二步：Poco的基本用法在开始使用Poco框架进行开发之前，首先需要在你的项目中引入Poco 的头文件和库文件。
这可以通过修改你的项目工程文件来完成，具体的方法会因开发工具而有所不同。
在引入完Poco框架后，你可以使用Poco提供的丰富功能来简化你的开发工作。
以下是几个常用的Poco模块和它们的用法说明：1. Poco Foundation：Poco Foundation模块提供了许多基础的类和工具，用于处理字符串、日期时间、文件、网络通信等。
使用该模块的常用步骤如下：- 引入头文件：在你的源文件中引入`Poco`下所需的头文件，例如：`#include <Poco/DateTime.h>`- 使用类或工具：在你的代码中使用Poco Foundation模块提供的类或工具，例如：`Poco::DateTime now;`2. Poco Net：Poco Net模块提供了网络编程所需的类和工具，用于创建和管理网络连接、发送和接收数据等。
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头文件中。
C++已经有Boost.Asio和libevent这样强大的库了为啥还不加入标准库？是利益问题还是？
C++已经有Boost.Asio和libevent这样强大的库了为啥还不加入标准库？是利益问题还是？在网络编程中，C++是一种非常流行的编程语言。
C++没有内置网络编程库，这导致了许多开发者使用第三方库来实现网络编程。
目前，Boost.Asio和libevent是两个非常流行的网络编程库。
虽然这些库非常强大，但它们并没有被纳入C++标准库。
这是为什么呢？是利益问题还是其他原因？我们来看看Boost.Asio和libevent的特点。
Boost.Asio是一个基于事件驱动的异步I/O 库，它提供了一种简单的方式来实现异步网络编程。
它支持TCP、UDP和IP协议，并且可以在多个平台上运行。
libevent是一个轻量级的事件通知库，它能够处理I/O事件、定时器事件和信号事件。
它也可以运行在多个平台上，并且支持多种I/O模型，包括select、poll、epoll和kqueue。
虽然Boost.Asio和libevent都非常强大，但它们都不是标准库的一部分。
这是因为标准库的设计需要考虑到许多因素，包括可移植性、性能、安全性和易用性。
为了确保标准库的质量，每个库都需要经过严格的审查和测试。
将新的库添加到标准库中需要耗费大量的时间和精力。
标准库的设计需要考虑到广泛的使用。
虽然Boost.Asio和libevent在网络编程中非常流行，但它们并不是唯一的选择。
有些开发者可能更喜欢使用其他库，比如Poco和ACE。
将Boost.Asio和libevent添加到标准库中可能会限制开发者的选择，这可能会对标准库的广泛使用造成影响。
另一个问题是利益问题。
虽然Boost.Asio和libevent都是开源库，但它们的维护者可能会有商业利益。
如果将这些库添加到标准库中，这可能会对维护者的商业利益造成影响。
这可能会导致维护者反对将这些库添加到标准库中。
将Boost.Asio和libevent添加到标准库中是一个复杂的问题。
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函数中，我们发现定时器的业务就是不断更新下一次触发时间，并通过睡眠等待到预定时间，触发调用者业务。
c++ poco 事件 同步异步 原理
C++ Poco事件-同步异步的深度解析在C++编程领域中，Poco（即C++通用组件库）是一个非常受欢迎的开源类库，它提供了许多丰富的功能和组件，其中的事件系统是其核心功能之一。
在实际应用中，我们常常需要处理各种事件，而了解Poco事件的同步异步原理对我们理解事件驱动编程有着重要的意义。
1. 什么是Poco事件？在Poco库中，事件是一种通过触发和响应机制来传递信息和进行交互的重要手段。
事件的触发者和响应者之间通过事件进行了解耦，使得整个系统更加灵活和可扩展。
2. Poco事件的同步与异步在Poco库中，事件通常可以被分为同步事件和异步事件两种类型。
对于同步事件，触发事件的线程和处理事件的线程是同一个线程，事件的触发和处理是顺序执行的。
而对于异步事件，触发事件的线程和处理事件的线程是不同的，事件的处理通常是在另一个线程中进行的，这样可以提高系统的响应速度和并发能力。
3. Poco事件的原理Poco事件的实现原理主要是基于观察者设计模式和信号与槽机制。
观察者设计模式通过定义一个主题和多个观察者，实现主题状态变化时的通知和观察者的更新。
而信号与槽机制则是一种基于回调的事件处理方式，当事件触发时，通过信号传递给槽函数进行处理。
4. Poco事件的使用在实际的C++项目中，我们可以通过Poco库提供的各种类和方法来使用事件。
首先需要定义一个事件类，并在需要的地方触发事件，监听事件并进行相应的处理。
对于同步事件，可以直接使用Poco库中提供的事件类；对于异步事件，通常需要创建新的线程或者利用Poco 中提供的线程池来进行处理。
总结与展望：通过本文的介绍，我们对于Poco事件的同步异步原理有了更深入的了解。
对于事件驱动的编程模式，理解事件的触发和处理方式，对于提高系统的性能和稳定性有着重要的意义。
在日后的C++项目中，我们可以充分利用Poco事件的特性，提高系统的可扩展性和并发能力。
个人观点：在实际项目中，我曾经在一个高并发的服务器程序中广泛使用Poco库中的事件机制。
POCO文档翻译：POCOC++库入门指南
POCO⽂档翻译：POCOC++库⼊门指南内容⽬录介绍POCO C++库是⼀组开源C++类库的集合，它们简化及加速了⽤C++来开发以⽹络功能为核⼼的可移植程序的过程。
这些库，完美地与C++标准库结合到⼀起，并且填补了它所留下的那些空缺。
它们具有模块化、⾼效的设计与实现，使得POCO C++库特别适合于进⾏嵌⼊式开发。
⽽这是C++编程语⾔正在变得越来越流⾏的领域，因为，它既能进⾏底层(设备I/O、中断处理，等等)的开发，也能进⾏⾼级的⾯向对象的开发。
当然，POCO也已经准备好⾯对企业级开发的挑战了。
POCO由4个核⼼库及若⼲个附加库组成。
核⼼库是：Foundation、XML、Util和Net。
其中的两个附加库是：NetSSL，为Net 库中的⽹络类提供SSL ⽀持；Data，⽤来以统⼀的形式访问不同的SQL 数据库。
POCO致⼒于进⾏以⽹络功能为核⼼的跨平台C++软件的开发，可以类⽐于Ruby on Rails对于Web开发的作⽤——⼀个功能强⼤⽽⼜简单易⽤的平台，⽤来构建妳⾃⼰的应⽤程序。
POCO是严格围绕标准ANSI/ISO C++来开发的，并且⽀持标准库。
贡献者们努⼒地达到以下要素之间的平衡：使⽤⾼级的C++特性；保持那些类的可理解性；保持代码的⼲净、⼀致及易维护性。
Foundation库POCO提供了⼀些类，⽤于处理多种变种中的⽇期及时间。
对于⽂件系统访问功能， POCO提供了和类，以及类。
在狠多程序中，某个部分需要向其它部分告知某些事件发⽣了。
POCO提供了、和事件 (类似于 C#事件) 来简化这个过程。
以下⽰例展⽰了 POCO事件的⽤法。
在这个⽰例中，类 Source 拥有⼀个公有事件，名为 theEvent ，它有⼀个参数，类型为 int 。
订阅者可以通过调⽤ operator +=来订阅，调⽤ operator -= 来取消订阅，并且要传⼊两个参数：指向某个对象的⼀个指针；以及，指向某个成员函数的指针。
C++实验报告-第四章-类与对象
C++实验报告实验4 类与对象一、实验目的1、掌握类的声明和使用2、掌握类的声明和对象的声明3、复习具有不同访问属性的成员的访问方式4、观察构造函数和析构函数的执行过程5、学习类的组合使用方法6、使用DEBUG调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序二、实验任务1、声明一个CPU类，包含等级rank、频率frequency、电压voltage等属性，有两个公有成员函数run、stop。
其中，rank为枚举类型CPU-Rank，声明为enum CPU-Rank{P1=1,P2,P3,P4,P5,P6,P7}, frequency为MHz的整数型，voltage为浮点型的电压值。
观察构造函数好析构函数的调用顺序。
2、声明一个简单的Computer类，有数据成员芯片cpu、存ram、光驱cdrom等，有两个公有成员函数run、stop。
cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，声明并实现这个类。
3、设计一个用于人事管理的People类。
考虑到通用性，这里只抽象出所有类型人员都具有的属性：number编号、sex性别、birthday出生日期、id号等。
其中出生日期声明为一个日期类嵌子对象。
用成员函数实现对人员信息的录入和显示。
要求包括：构造函数和析构函数、拷贝构造函数、嵌成员函数、组合。
三、实验容任务1：首先声明枚举类型，在这里出现了知识性错误，不清楚具体应如何声明，经查询相关书籍，知道应在类外进行声明。
初次用类来进行编程，在概念上是有一些混乱的，例如构造函数和析构函数的调用顺序等。
在用debug单步调试后，明白其中道理。
源程序：//Lab4_1.cpp#include<iostream>using namespace std;enum CPU_Rank {P1=1,P2,P3,P4,P5,P6,P7};class CPU { //CPU类的定义private: //私有数据成员CPU_Rank rank;int frequency;float voltage;public: //外部接口CPU(CPU_Rank r,int f,float v) { //CPU类的构造函数rank=r;frequency=f;voltage=v;cout<<"构造了一个CPU!"<<endl;}~CPU() { //CPU类的析构函数cout<<"析构了一个CPU!"<<endl;}void run(){cout<<"CPU开始运行"<<endl;}void stop(){cout<<"CPU停止运行"<<endl;}};//主函数int main(){CPU a(P6,300,2.0); //建立CPU类的对象a.run();a.stop();return 0;}实验结果：从debug调试中可知，在创建类的对象时，首先调用其构造函数，之后，在其他成员函数调用结束后，对象的生存期结束，系统便自动调用析构函数，进行析构。
poco 线程池用法 -回复
poco 线程池用法-回复Poco 是一个轻量级的C++ 库，它提供了许多功能丰富且易于使用的组件，简化了C++ 程序开发的过程。
其中一个重要的组件是Poco 线程池，它提供了一种高效且简洁的方法来管理线程任务。
本文将一步一步为您介绍Poco 线程池的用法，帮助您更好地理解和使用这个强大的工具。
# 第一步：了解Poco 线程池的基本原理和概念在开始使用Poco 线程池之前，我们需要先理解它的基本原理和概念。
Poco 线程池是一个用来管理线程任务的工具，它维护着一个线程池，其中包含了一组由用户定义的任务。
每当有新的任务到达时，线程池中的线程会自动分配并执行这些任务，最大程度地利用系统资源，提高任务处理的效率。
Poco 线程池的基本概念包括以下几个要点：1. 线程池大小：线程池中可同时存在的线程数量。
可以根据系统的硬件资源和任务需求来调整线程池的大小。
2. 任务队列：用于存放待执行的任务，按照先进先出的原则进行调度。
当线程池中的线程空闲时，会从任务队列中取出新的任务进行处理。
3. 任务接口：用于定义任务的接口，包括任务的执行方法以及可能需要的输入参数和返回值类型。
# 第二步：安装Poco C++ 库并配置开发环境在开始使用Poco 线程池之前，我们需要先安装Poco C++ 库并配置好开发环境。
Poco 官网提供了详细的安装和配置说明，可以根据自己的需求选择合适的安装方式（如源码编译、二进制安装等）。
安装完成后，需要确保开发环境能够正确地链接和引用Poco 库。
# 第三步：创建一个基本的线程池接下来，我们将创建一个基本的线程池，并向其中添加一些任务。
首先，我们需要包含必要的头文件：cpp#include <Poco/ThreadPool.h>#include <iostream>然后，我们可以使用Poco::ThreadPool 类来创建一个简单的线程池：cppPoco::ThreadPool threadPool;# 第四步：定义一个任务类为了将任务添加到线程池中，我们需要定义一个任务类，该类需要实现Poco::Runnable 接口中定义的run() 方法。
沃尔玛产品检验标准
.WALMART Stores, Inc.1. Introduction（略）2. Regulatory pliance 符合规定Walmart Suppliers must ply with all laws, including Federal, State and Local laws, as required under the Supplier Agreement.供应商必须按供应商协议要求遵守联邦、州和地方法律。
3. Footwear Testing Program 鞋测试程序This is an annual testing program that involves testing of the following samples:年度测试程序包括测试以下样品：Footwear Pre-Production/ponents Testing 鞋产前/部件测试Production Testing of plete Shoe 整鞋的生产测试In-Store Testing 场内测试Warehouse Testing 仓库测试Other testing at the request of the Walmart New York Office Technical Department or pliance Department 沃尔玛纽约办公室技术部或合规部要求的其他测试3.1 流程图Footwear Pre-Production/ponent Testing Process鞋产前/部件测试流程Manual Name: Walmart USA Footwear Revised: April 2010 43000双以上的订单需要测试女鞋高跟按4.1.7需要进行疲劳和撞击测试的，不论订单量多少，均应测试所有的新款，现有款式每年1X生产测试供应商改善并提交重测第二次测试生产测试生产测试纽约申诉办公室处理3000双及以内的订单不需要测试专注. 专业.专注 . 专业 .Footwear Production Testing Process 生产测试流程NOTE¹ Refer to Section 3..3.1 Production Testing Incentive Program incorporated into Production process.NOTE² Children's items are tested for restricted substances at each production accumulation level.NOTE³样品测试通过FIT 审批程序 第一次生产测试 订单5万双以内第二次生产测试 订单5万-10万双 在100万双以内，每10万双测试一次超过100万双，每25万双测试一次合格或基本合格——装运关键沃尔玛或重大缺陷 关键规定供应商改善并提交重测供应商按沃尔玛合规要求将改善计划送检测实验室批准合格或基本合格——关键沃尔玛POCO （注释3）——装运第二次测试合格或基本合格——关键沃尔玛POCO （注释3）——装运不合格，则提交纽约申诉办公室处理改善计划未被批准——取消订单改善计划批准，供应商改善并提交重测合格——关键规定POCO 程序（注释3）——装运不合格，则提交沃尔玛合规部处理注释1：根据3.3.1生产测试鼓励措施2：童鞋必须在每个生产步骤进行限制物质的测试3：直接进口或第一手成本订单需要在装运前进行POCO 测试，本土订单在配送到各门店之前进行POCO 测试（参加3.3.2）专注 . 专业 .Direct Import and First Cost orders require testing (POCO) prior to shipment to the states. Domestic landed orders require Warehouse Testing (POCO) prior to allocation of order to the stores (refer to Section 3.3.2 of this manual).Manual: Walmart USA Footwear Revised: April 2010 5In-Store Quality Audit Process 场内测试流程Note¹All items pulled from the store at least 1 x per year. Replenishable items pulled from the store 1 or 2 times per year based on Supplier performance (refer to section 3.3.1 of this manual)Manual Name: WM USA Footwear Revised: April 2010 6检测实验室根据沃尔玛订单，指定从商店取什么款式进行测试 检测实验室通过零售链查找各个场内检测商品是否可以取得检测实验室从商店抽取指定的检测样品（代表性尺码和全色系）检测合格或基本合格，场内检测完成，报告送达供应商关键规定不合格，自动扩大抽样重测关键沃尔玛不合格或重大缺陷，私人品牌由纽约上诉办公室决定重测，授权或国家品牌由采购/DMM 决定重测不要求扩大抽样重测要求扩大抽样重测自动关键规定不合格，报告提交沃尔玛合规部——产品召回，沃尔玛合规部向CPSC 报告召回关键沃尔玛不合格或重大缺陷，私人品牌的报告送达纽约上诉办公室，授权或国家品牌的报告送达采购/DMM ，由其在需要是通知产品撤柜注释：所有的商品每年至少从商品抽样一次。
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 中if的用法
poco 中if的用法在Poco中，if语句是一种很常见的控制结构。
它可以在程序中根据条件选择不同的执行分支。
在这篇文章中，我们将讨论if语句的用法及注意事项。
一、if语句的基本用法在C++中，if语句的一般形式是：if(条件语句){//执行语句}其中，条件语句是需要评估为真或假的表达式，如果评估结果为真，则执行花括号中的语句。
如果评估结果为假，则不执行语句，继续程序运行。
例如，下面的代码段将检查输入的数字是否为正数：int num;cin >> num;if (num > 0){cout << "这个数字是正数" << endl;}如果输入的数字是-1，则不会输出任何内容。
如果输入的数字是1，则输出“这个数字是正数”。
二、if-else语句除了简单的if语句，我们还可以使用if-else语句。
if-else语句的一般形式是：if (条件语句){//执行语句1}else{//执行语句2}其中，如果条件语句的评估结果为真，则执行执行语句1。
否则，执行执行语句2。
例如，下面的代码段将检查输入的数字是否为正数：int num;cin >> num;if (num > 0){cout << "这个数字是正数" << endl;}else{cout << "这个数字是非正数" << endl;}如果输入的数字是-1，则输出“这个数字是非正数”。
如果输入的数字是1，则输出“这个数字是正数”。
三、if-else if-else语句在某些情况下，我们可能需要在多个条件中选择一个执行分支。
这时，可以使用if-else if-else语句。
if-else if-else语句的一般形式是：if (条件1){//执行语句1}else if (条件2){//执行语句2}……else{//执行语句n}例如，下面的代码段将检查输入的数字是否为正数、负数或零：int num;cin >> num;if (num > 0){cout << "这个数字是正数" << endl;}else if (num < 0){cout << "这个数字是负数" << endl;}else{cout << "这个数字是零" << endl;}如果输入的数字是-1，则输出“这个数字是负数”。
POCOc++使用例子
POCOc++使⽤例⼦1.定时器#include "Poco/Timer.h"#include "Poco/Thread.h"using Poco::Timer;using Poco::TimerCallback;class TimerExample{public:void onTimer(Poco::Timer& timer){std::cout << "onTimer called." << std::endl;}};int main(int argc, char** argv){TimerExample te;Timer timer(250, 500); // fire after 250ms, repeat every 500mstimer.start(TimerCallback<TimerExample>(te, &TimerExample::onTimer));Thread::sleep(5000);timer.stop();return0;}2.管道#include "Poco/Process.h"#include "Poco/PipeStream.h"#include "Poco/StreamCopier.h"#include <fstream>using Poco::Process;using Poco::ProcessHandle;int main(int argc, char** argv){std::string cmd("/bin/ps");std::vector<std::string> args;args.push_back("-ax");Poco::Pipe outPipe;ProcessHandle ph = Process::launch(cmd, args, 0, &outPipe, 0);Poco::PipeInputStream istr(outPipe);std::ofstream ostr("processes.txt");Poco::StreamCopier::copyStream(istr, ostr);return 0;}3.poco 默认线程池#include "stdafx.h"#include "Poco/ThreadPool.h"#include "Poco/Runnable.h"#include <iostream>class HelloRunnable: public Poco::Runnable{virtual void run(){std::cout << "Hello, bingzhe" << std::endl;}};int main(int argc, char** argv){HelloRunnable runnable;Poco::ThreadPool::defaultPool().start(runnable);Poco::ThreadPool::defaultPool().joinAll();return0;}4.内存池#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;return0;}5.任务#include "Poco/Task.h"#include "Poco/TaskManager.h"#include "Poco/TaskNotification.h"#include "Poco/Observer.h"using Poco::Observer;class SampleTask: public Poco::Task{public:SampleTask(const std::string& name): Task(name){}void runTask(){for (int i = 0; i < 100; ++i){setProgress(float(i)/100); // report progressif (sleep(1000))break;}}};class ProgressHandler{public:void onProgress(Poco::TaskProgressNotification* pNf){std::cout << pNf->task()->name()<< " progress: " << pNf->progress() << std::endl;pNf->release();}void onFinished(Poco::TaskFinishedNotification* pNf){std::cout << pNf->task()->name() << " finished." << std::endl; pNf->release();}};int main(int argc, char** argv){Poco::TaskManager tm;ProgressHandler pm;tm.addObserver(Observer<ProgressHandler, Poco::TaskProgressNotification> (pm, &ProgressHandler::onProgress));tm.addObserver(Observer<ProgressHandler, Poco::TaskFinishedNotification> (pm, &ProgressHandler::onFinished));tm.start(new SampleTask("Task 1")); // tm takes ownershiptm.start(new SampleTask("Task 2"));tm.joinAll();return0;}6.通知#include "stdafx.h"#include "Poco/NotificationCenter.h"#include "Poco/Notification.h"#include "Poco/Observer.h"#include "Poco/NObserver.h"#include "Poco/AutoPtr.h"#include <iostream>using Poco::NotificationCenter;using Poco::Notification;using Poco::Observer;using Poco::NObserver;using Poco::AutoPtr;class BaseNotification: public Notification{public: void dosome(){printf("fuck!");}};class SubNotification: public BaseNotification};class Target{public:void handleBase(BaseNotification* pNf){std::cout << "handleBase: " << pNf->name() << std::endl;pNf->dosome();pNf->release(); // we got ownership, so we must release}void handleSub(const AutoPtr<SubNotification>& pNf){std::cout << "handleSub: " << pNf->name() << std::endl;}};int main(int argc, char** argv){NotificationCenter nc;Target target;nc.addObserver(Observer<Target, BaseNotification>(target, &Target::handleBase) );nc.addObserver(NObserver<Target, SubNotification>(target, &Target::handleSub) );nc.postNotification(new BaseNotification);nc.postNotification(new SubNotification);nc.removeObserver(Observer<Target, BaseNotification>(target, &Target::handleBase) );nc.removeObserver(NObserver<Target, SubNotification>(target, &Target::handleSub) );return0;}7.线程#include "Poco/Thread.h"#include "Poco/Runnable.h"#include <iostream>class HelloRunnable: public Poco::Runnable{virtual void run(){std::cout << "Hello, bingzhe!" << std::endl;}};int main(int argc, char** argv){HelloRunnable runnable;Poco::Thread thread;thread.start(runnable);thread.join();return0;}8.线程对象#include "Poco/Activity.h"#include "Poco/Thread.h"#include <iostream>using Poco::Thread;class ActivityExample{public:ActivityExample(): _activity(this,&ActivityExample::runActivity){}void start(){_activity.start();}void stop(){_activity.stop(); // request stop_activity.wait(); // wait until activity actually stops}protected:void runActivity()while (!_activity.isStopped()){std::cout << "bingzhe running." << std::endl;Thread::sleep(200);}}private:Poco::Activity<ActivityExample> _activity;};int main(int argc, char** argv){ActivityExample example;example.start();Thread::sleep(2000);example.stop();return0;}9.异步通知#include "stdafx.h"#include "Poco/Notification.h"#include "Poco/NotificationQueue.h"#include "Poco/ThreadPool.h"#include "Poco/Runnable.h"#include "Poco/AutoPtr.h"using Poco::Notification;using Poco::NotificationQueue;using Poco::ThreadPool;using Poco::Runnable;using Poco::AutoPtr;class WorkNotification: public Notification{public:WorkNotification(int data): _data(data) {}int data() const{return _data;}private:int _data;};class Worker: public Runnable{public:Worker(NotificationQueue& queue): _queue(queue) {} void run(){AutoPtr<Notification> pNf(_queue.waitDequeueNotification());while (pNf){WorkNotification* pWorkNf =dynamic_cast<WorkNotification*>(pNf.get());if (pWorkNf){printf("hi!bingzhe");// Sleep(100);}pNf = _queue.waitDequeueNotification();}}private:NotificationQueue& _queue;};int main(int argc, char** argv){NotificationQueue queue;Worker worker1(queue); // create worker threadsWorker worker2(queue);ThreadPool::defaultPool().start(worker1); // start workersThreadPool::defaultPool().start(worker2);// create some workfor (int i = 0; i < 100; ++i){queue.enqueueNotification(new WorkNotification(i));}while (!queue.empty()) // wait until all work is donePoco::Thread::sleep(100);queue.wakeUpAll(); // tell workers they're done ThreadPool::defaultPool().joinAll();return0;}。
C#事件的使用案例
C#事件的使⽤案例事件的使⽤案列⼀、案例背景在写⼀个询价报价的Winfrom程序时，程序⾸页FORM（form名为FrmEnquiry）显⽰的询价记录和报价记录，询价记录如下图：在⽤户点击新增询价记录后弹出询价记录编辑FORM（form名为FrmEnquiryEdit），界⾯如下图：案例需求：⽤户在编辑页⾯（FrmEnquiryEdit）中编辑完询价记录后在点击保存新增询价记录按钮后编辑界⾯(FrmEnquiryEdit)需要通知主界⾯更新显⽰出刚刚新增询价记录。
应⽤⾃定义事件，在⽤户点击保存新增询价记录按钮后触发事件通知主界⾯更新以实现案例需求。
代码实现步骤如下：1、⾸先定义⼀个⽤于在事件中传递数据⽤的事件数据类，代码如下： public class EqDocumentSavedEventArgs : EventArgs { private EnquiryDocument _enquiryDocument; ///<summary> ///编辑页⾯使⽤该属性传递新增编辑完成并保存后的询价记录 ///</summary> public EnquiryDocument EnquiryDocument { get => _enquiryDocument; } public EqDocumentSavedEventArgs(EnquiryDocument enquiry){ _enquiryDocument = enquiry;} }注：其中EnquiryDocument为我需要通过事件传递的询价记录实体类2、定义⼀个事件的委托，代码如下： public delegate void EqDocumentsChangedEventHandler(object sender, EqDocumentSavedEventArgs e);委托也是⼀个类，可以定义在命名空间中，跟其他类同级，案例代码层次结构如下：namespace xunjia1.Views{ public delegate void EqDocumentsChangedEventHandler(object sender, EqDocumentSavedEventArgs e); public partial class FrmEnquiry : DevExpress.XtraEditors.XtraForm{… …} public class EqDocumentSavedEventArgs : EventArgs {… … } … …}3、在编辑询价记录界⾯（FrmEnquiryEdit）中⽤2步中定义的委托声明事件，代码及层次结构如下：namespace xunjia1.Views{public partial class FrmEnquiryEdit : DevExpress.XtraEditors.XtraForm {… …public event EqDocumentsChangedEventHandler EqDocumentSaved;… … }}4、在主页⾯（FrmEnquiry）中编写收到事件后的处理⽅法（暨更新主页⾯），代码及层次结构如下：public partial class FrmEnquiry : DevExpress.XtraEditors.XtraForm{… … …… private void frmEnquiryEdit_EqDocumentSaved(object sender,EqDocumentSavedEventArgs eq){this.enquiryDocuments.Add(eq.EnquiryDocument);this.gridControl2.RefreshDataSource();}… … ……}5、在编辑页⾯（FrmEnquiryEdit）保存新增询价记录按钮⽅法中添加发布事件代码，代码及层次结构如下：public partial class FrmEnquiryEdit : DevExpress.XtraEditors.XtraForm {… …private void sBtnSaveEQDoc_Click(object sender, EventArgs e){… …//发布事件通知主界⾯更新数据if (EqDocumentSaved != null){ EqDocumentSavedEventArgs eq = new EqDocumentSavedEventArgs(enquiryDocument);EqDocumentSaved(this, eq);}… … } }注：如果没有任何客户将委托与该事件挂钩，该字段将为空；否则该字段引⽤应在调⽤该事件时调⽤的委托。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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。
其中source.theEvent += Poco::delegate(&target, &Target::onEvent)完成了，目标向数据源事件注册的过程。
大家都知道在C++中，程序运行是落实到类的实例的，看一下消息传递的过程，Poco是如何解决这个问题。
target是目标对象实例，Target::onEvent目标对象处理事件的函数入口地址。
source.fireEvent(42)触发事件运行，其定义为:[cpp]1.void fireEvent(int n)2.{3. theEvent(this, n);4.// theEvent.notify(this, n); // alternative syntax5.}theEvent(this, n)中存在两个参数，其中n为Target::onEvent(const void* pSender, int& arg)处理函数的参数，可理解为消息或者事件内容；this给出了触发源实例的信息。
ok。
这样消息的传递流程出来了。
消息源实例的地址，消息内容，目标实例地址，目标实例类的处理函数入口地址。
使用者填入上述信息就可以传递消息了。
相当简单。
而对于事件的开发者，如何实现上述功能。
这是另外一码事，用C++实现这么一个功能还是挺复杂的一件事。
看一下使用语言的方式，想一下用到的C++技术：1. +=/-= 重载[cpp]1.source.theEvent += Poco::delegate(&target, &Target::onEvent);2. 仿函式[cpp]1.theEvent(this, n);3. 模板开发者是不应该限定使用者发送消息的类以及接受消息类的类型的，因此C++中能够完成此功能的技术只有模板了。
关于模板编程还想聊上几句。
STL的特点在于算法和数据结构的分离，这个其实也是泛型编程的特点。
如果把使用者对于类的应用过程看做算法过程的话，就可以对这个过程进行泛型编程。
同时应该注意的是，算法和数据结构是存在关联的，这是隐含在泛型编程中的，能够使用某种算法的数据结构一定是符合该种算法要求的。
就拿Poco中事件的委托Delegate来说，目标对象处理事件的函数入口是存在某种假设的。
Poco中假设入口函数必须是如下形式之一：[cpp]1.void (TObj::*NotifyMethod)(const void*, TArgs&);2.void (TObj::*NotifyMethod)(TArgs&);3.void (*NotifyMethod)(const void*, TArgs&);4.void (*NotifyMethod)(void*, TArgs&);5.2 事件的实现下面一张图是Poco中Event的类图：下面另一张图是Poco中Event流动的过程：从图上看实现事件的类被分成了几类：1) Delegate：AbstractDelegate,Delegate,Expire,FunctionDelegate,AbstractPriorityDelegate,PriorityDelegate,F unctionPriorityDelegate：2) Strategy：NotificationStrategy，PriorityStrategy，DefaultStrategy，FIFOStrategy3) Event：AbstractEvent，PriorityEvent，FIFOEvent，BasicEvent我们取Delegate，DefaultStrategy，BasicEvent来分析，其他的只是在它们的基础上加了一些修饰，流程类似。
Delegate类定义如下：[cpp]1.template <class TObj, class TArgs, bool withSender = true>2.class Delegate: public AbstractDelegate<TArgs>3.{4.public:5.typedef void (TObj::*NotifyMethod)(const void*, TArgs&);6.7. Delegate(TObj* obj, NotifyMethod method):8. _receiverObject(obj),9. _receiverMethod(method)10. {11. }12.13. Delegate(const Delegate& delegate):14. AbstractDelegate<TArgs>(delegate),15. _receiverObject(delegate._receiverObject),16. _receiverMethod(delegate._receiverMethod)17. {18. }19.20. ~Delegate()21. {22. }23.24. Delegate& operator = (const Delegate& delegate)25. {26.if (&delegate != this)27. {28.this->_receiverObject = delegate._receiverObject;29.this->_receiverMethod = delegate._receiverMethod;30. }31.return *this;32. }33.34.bool notify(const void* sender, TArgs& arguments)35. {36. Mutex::ScopedLock lock(_mutex);37.if (_receiverObject)38. {39. (_receiverObject->*_receiverMethod)(sender, arguments);40.return true;41. }42.else return false;43. }44.45.bool equals(const AbstractDelegate<TArgs>& other) const46. {47.const Delegate* pOtherDelegate = reinterpret_cast<const Delegate*>(other.unwrap());48.return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;49. }50.51. AbstractDelegate<TArgs>* clone() const52. {53.return new Delegate(*this);54. }55.56.void disable()57. {58. Mutex::ScopedLock lock(_mutex);59. _receiverObject = 0;60. }61.62.protected:63. TObj* _receiverObject;64. NotifyMethod _receiverMethod;65. Mutex _mutex;66.67.68.private:69. Delegate();70.};我们可以看到Delegate类中存储了目标类实例的指针_receiverObject，同时存储了目标类处理函数的入口地址_receiverMethod，当初始化Delegate实例时，参数被带进。
Delegate类中处理事件的函数为bool notify(const void* sender, TArgs& arguments)，这是一个虚函数. 如果去看它的实现的话，它最终调用了目标类处理函数(_receiverObject->*_receiverMethod)(sender, arguments)。