boost中信号的应用

最新推荐文章于 2023-12-01 20:36:46 发布
最新推荐文章于 2023-12-01 20:36:46 发布
阅读量389 收藏
点赞数

// signal.cpp : 定义控制台应用程序的入口点。
//
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;

void slots1()
{
 cout << "slots1 call" << endl;
}


void slots2()
{
 cout << "slots2 call" << endl;
}

struct Hello
{
 void operator()() const
 {
  std::cout << "Hello";
 }
};


int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<void()> sig;
 sig.connect(&slots1);
 sig.connect(&slots2);
 sig.connect(Hello());
  sig();

 boost::signals2::signal<void ()> sig1;
 sig1.connect(Hello());
 sig1();


 int act;
 cin >> act;

 return 0;
}

*/

/*

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;

template<int N>
struct Slot
{
 void operator()()
 {
  cout << "Slot current N value is : " << N << endl;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<void()> sig;
 sig.connect(Slot<1>(), boost::signals2::at_back);  // 最后一个被调用
 sig.connect(Slot<99>(), boost::signals2::at_front);  // 第一个被调用
 sig.connect(5, Slot<55>(), boost::signals2::at_back); // 组号5的最后一个
 sig.connect(5, Slot<57>(), boost::signals2::at_front);// 组号5的第一个
 sig.connect(10, Slot<100>());// 组号10该组只有一个
 sig();
 int act;
 cin >> act;
 return 0;
}
*/

/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;

template<int N>
struct Slot
{
 int operator()(int x)
 {
  cout << "Slot current N * x value is : " << N << endl;
  return (N * x);
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<int(int)> sig;
 sig.connect(Slot<10>());
 sig.connect(Slot<100>());
 cout << *sig(2) << endl;

 int a;
 cin >> a;
 return 0;
}
*/

/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
 int operator()(int x)
 {
  cout << "Slot current N * x value is : " << N << endl;
  return (N * x);
 }
};
template<typename T>
class combiner
{
public:
 typedef pair<T, T> result_type;
 combiner(T t = T()) : v(t)
 {

 }

 template<typename InputIterator>
 result_type operator()(InputIterator begin, InputIterator end) const
 {
  if (begin == end)
  {
   return result_type();
  }

  vector<T> vec(begin, end);
  T sum = accumulate(vec.begin(), vec.end(), v);
  T max = *max_element(vec.begin(), vec.end());

  return result_type(sum, max);
 }

private:
 T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<int(int), combiner<int> > sig;
 sig.connect(Slot<10>());
 sig.connect(Slot<20>());
 sig.connect(Slot<3>());
 BOOST_AUTO(x, sig(2));
 cout << x.first << ", " << x.second << endl;
 return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;

template<int N>
struct Slot
{
 int operator()(int x)
 {
  cout << "Slot current N * x value is : " << N << endl;
  return (N * x);
 }
};

template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
 return true;
}

template<typename T>
class combiner
{
public:
 typedef pair<T, T> result_type;
 combiner(T t = T()) : v(t)
 {
 }

 template<typename InputIterator>
 result_type operator()(InputIterator begin, InputIterator end) const
 {
  if (begin == end)
  {
   return result_type();
  }

  vector<T> vec(begin, end);
  T sum = accumulate(vec.begin(), vec.end(), v);
  T max = *max_element(vec.begin(), vec.end());
  return result_type(sum, max);
 }

private:
 T v;
};


int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<int(int)> sig;
 // assert(sig.empty());
 sig.connect(0, Slot<10>());
 sig.connect(Slot<20>());
 sig(10);
 sig.connect(1, Slot<30>());
 sig(20);
 assert(sig.num_slots() == 3);
 sig.disconnect(0);
 // assert(sig.num_slots() == 1);
 sig.disconnect(Slot<30>());
 // assert(sig.empty());

 sig(2);

 return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;

template<int N>
struct Slot
{
 int operator()(int x)
 {
  cout << "Slot current N * x value is : " << N << endl;
  return (N * x);
 }
};

template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
 return true;
}

template<typename T>
class combiner
{
public:
 typedef pair<T, T> result_type;
 combiner(T t = T()) : v(t)
 {}

 template<typename InputIterator>
 result_type operator()(InputIterator begin, InputIterator end) const
 {
  if (begin == end)
  {
   return result_type();
  }

  vector<T> vec(begin, end);
  T sum = accumulate(vec.begin(), vec.end(), v);
  T max = *max_element(vec.begin(), vec.end());
  return result_type(sum, max);
 }

private:
 T v;
};


int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<int(int)> sig;
 boost::signals2::connection c1 = sig.connect(0, Slot<10>());
 int aa = sig.num_slots();
 boost::signals2::connection c2 = sig.connect(0, Slot<10>());
  aa = sig.num_slots();

 boost::signals2::connection c3 = sig.connect(0, Slot<10>());
  aa = sig.num_slots();


 c1.disconnect();
  aa = sig.num_slots();
 assert(sig.num_slots() == 2);
 assert(!c1.connected());
 assert(c2.connected());

 return 0;
}

*/

/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;


template<int N>
struct Slot
{
 int operator()(int x)
 {
  cout << "Slot current N * x value is : " << endl;

  return (N * x);
 }
};

template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
 return true;
}

template<typename T>
class combiner
{
public:
 typedef pair<T, T> result_type;
 combiner(T t = T()) : v(t)
 {

 }

 template<typename InputIterator>
 result_type operator()(InputIterator begin, InputIterator end) const
 {
  if (begin == end)
  {
   return result_type();
  }

  vector<T> vec(begin, end);
  T sum = accumulate(vec.begin(), vec.end(), v);
  T max = *max_element(vec.begin(), vec.end());

  return result_type(sum, max);
 }

private:
 T v;
};


int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<int(int)> sig;

 sig.connect(0, Slot<10>());
 assert(sig.num_slots() == 1);
 {
  boost::signals2::scoped_connection sc = sig.connect(0, Slot<20>());
  assert(sig.num_slots() == 2);
  sig(2);
 }
 assert(sig.num_slots() == 1);
 sig(10);
 return 0;
}

*/


/*


#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;


template<int N>
struct Slot
{
 void operator()(int x)
 {
  cout << "Slot current N is : " << N << endl;
 }
};

template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
 return true;
}

template<typename T>
class combiner
{
public:
 typedef pair<T, T> result_type;
 combiner(T t = T()) : v(t)
 {

 }

 template<typename InputIterator>
 result_type operator()(InputIterator begin, InputIterator end) const
 {
  if (begin == end)
  {
   return result_type();
  }

  vector<T> vec(begin, end);
  T sum = accumulate(vec.begin(), vec.end(), v);
  T max = *max_element(vec.begin(), vec.end());

  return result_type(sum, max);
 }

private:
 T v;
};


int _tmain(int argc, _TCHAR* argv[])
{
 boost::signals2::signal<void(int)> sig;

 boost::signals2::connection c1 = sig.connect(0, Slot<10>());
 boost::signals2::connection c2 = sig.connect(0, Slot<20>());

 assert(sig.num_slots() == 2);
 sig(2);

 cout << "begin blocking..." << endl;
 {
  boost::signals2::shared_connection_block block(c1);
  assert(sig.num_slots() == 2);
  assert(c1.blocked());
  sig(2);
 }

 cout << "end blocking.." << endl;
 assert(!c1.blocked());
 sig(2);

 

 return 0;
}
*/

/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>

// include Boost header
#include <boost/signals2/signal.hpp>

// the class with slot function
class CObject
{
public:
 int  m_ObjIndex;

 CObject( int idx )
 {
  m_ObjIndex  = idx;
 }

 void slotFunc()
 {
  std::cout << "Object " << m_ObjIndex << std::endl;
 }
};

int main( int argc, char** argv )
{
 // create signal
 typedef boost::signals2::signal<void ()> TSignalType;
 TSignalType  mSignal;

 // create object
 CObject  *pObj1 = new CObject( 1 );

 // connect signal /slot
 mSignal.connect( std::bind( &CObject::slotFunc, pObj1 ) );

 // emit signal
 mSignal();

 return 0;
}

*/

/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>

// include Boost header
#include <boost/signals2/signal.hpp>

// the class with slot function
class CObject
{
public:
 int  m_ObjIndex;

 CObject( int idx )
 {
  m_ObjIndex  = idx;
 }

 void slotFunc()
 {
  std::cout << "Object " << m_ObjIndex << std::endl;
 }
};

int main( int argc, char** argv )
{
 // create signal
 typedef boost::signals2::signal<void ()> TSignalType;
 TSignalType  mSignal;
 // create object
 CObject  *pObj1 = new CObject( 1 );
 // connect signal /slot
 mSignal.connect( std::bind( &CObject::slotFunc, pObj1 ) );
 // emit signal
 mSignal();

 return 0;
}

*/

/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>

// include Boost header
#include <boost/signals2/signal.hpp>

// the class with slot function
class CObject
{
public:
 int  m_ObjIndex;

 CObject( int idx )
 {
  m_ObjIndex  = idx;
 }

 void slotFunc()
 {
  std::cout << "Object " << m_ObjIndex << std::endl;
 }
};

int main( int argc, char** argv )
{
 // create signal
 typedef boost::signals2::signal<void ()> TSignalType;
 TSignalType  mSignal;
 // create object
 CObject  *pObj1 = new CObject( 1 );

 // connect signal /slot
 {
  boost::shared_ptr<CObject> spObj( pObj1 );
  mSignal.connect(TSignalType::slot_type(&CObject::slotFunc, spObj.get()).track(spObj));
  // emit signal
  mSignal();
 }

 // emit signal
 mSignal();

 return 0;
}

*/

hxq2146041
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Boost：多进程间通过信号量同步
风静如云的博客
12-02 277
Boot可以通过信号量boost::interprocess::interprocess_semaphore进行多进程间的同步。最大阻塞时间式等待：timed_wait(const boost::posix_time::ptime&abs_time);介绍了如何在多进程间共享内存，既然是共享内存，那么久存在竞争的问题。可以看到，两个进程通过信号量完成了读写的同步。其中构造参数0，用于初始化信号量的初始值。非阻塞式等待：try_wait();阻塞式等待：wait();
【转发】基于Boost的数据处理器及线程安全类和信号量
04-02
1. 线程安全的双端队列，可用于多线程中传递数据，数据类型包括二进制流、简单类型、对象等。 2. 封装了boost的condition_variable，使其使用方法很接近Windows的Event。其优势在于能跨平台使用。 3. 封装了boost的mutex，能跨平台使用。 4. 封装了boost的mutex的scoped_lock，能跨平台使用。
boost信号量 boost::interprocess::interprocess_semaphore的用法
weixin_30236595的博客
09-30 2223
使用方法首先给信号量初始化赋值,可以根据需要设定需要的值,之前在写项目的过程中用这个控制下载的线程个数。 1 boost::interprocess::interprocess_semaphore m_semaphore(0); 然后就是pv操作了,v操作就只有一个post(),post()一次,信号量加1.p操作有三个,看函数名字都很明显知道是什么意思, wait(...
boost库关于信号量的描述
成长之路
01-05 4520
<br />信号量是基于内部计数的进程间同步的机制，提供两个操作：<br /> ·等待：测试信号量的计数，如果值小于0则等待，否则减小信号量计数。<br />·Post：增加信号量计数。如果某个进程阻塞，某个进程会被唤醒。（翻译不通，If any process is blocked, one of those processes is awoken.）<br />如果初始化信号量为1，那么wait操作等同于互斥锁mutex，post同于互斥解锁。这种信号量称为二进制信号binary semaphore。<
量化交易之c++篇 - boost库 - 信号槽机制
04-18 313
【代码】量化交易之c++篇 - boost库 - 信号槽机制。
asmall.zip_SIMULINK_boost小信号_boost电路_matlab_小信号模型
07-15
标题中的“asmall.zip_SIMULINK_boost小信号_boost...总的来说，这个压缩包提供的资料可以帮助学习者理解和应用MATLAB的SIMULINK工具，对BOOST升压电路进行小信号建模和仿真，进而深入理解电路的动态行为和性能优化。
boost中文手册C++
05-21
Boost库是C++编程语言的一...通过深入学习和应用Boost中文手册中的内容，C++开发者可以充分利用这些工具来提升代码质量，降低项目风险，提高开发效率。无论是开发大型系统还是服务器，Boost库都是一个不可或缺的资源。
电压型CRM Boost PFC小信号建模分析与补偿设计
07-29
在功率因数校正领域，CRM-Boost PFC电路因其在输出功率小于100 W的应用中能够降低开关损耗和电磁干扰而受到关注。然而，针对电压控制模式下的CRM-Boost PFC，现有的文献较少涉及其小信号建模和分析。 电压控制模式...
boost中文文档
11-04
9. **图形界面**：Boost.Graph库允许用图论的方法来解决复杂问题，而Boost.Signals库则提供了信号和槽机制，用于组件间的通信。 10. **文件系统**：Boost.Filesystem库提供了跨平台的文件系统操作接口，简化了对...
传感技术中的LEM传感器在交错Boost型PFC电路中的应用
12-08
【传感技术中的LEM传感器在交错Boost型PFC电路中的应用】这一主题主要涉及电力电子领域中的功率因数校正（PFC）技术和模糊控制技术在液压伺服系统中的应用。LEM传感器是传感技术的一种，通常用于测量电流、电压等...
信号量封装
03-09
多线程通讯 信号量的封装
基于Boost的数据处理器及线程安全类和信号量
01-04
1. 线程安全的双端队列，可用于多线程中传递数据，数据类型包括二进制流、简单类型、对象等。 2. 封装了boost的condition_variable，使其使用方法很接近Windows的Event。其优势在于能跨平台使用。 3. 封装了boost的mutex，能跨平台使用。 4. 封装了boost的mutex的scoped_lock，能跨平台使用。相对于CWnLock，其优势在于发生异常时能自动解锁，避免线程死锁。 5. // 一个可用于线程间传递数据的类。此类的优势在于： // 1. 跨平台 // 2. 将线程通信间比较难的线程安全、信号通知等机制均封装在对象中 // 3. 由于数据的传递完全依靠事件通知，因此数据的流转效率以及吞吐量均非常高（已经使用在公司海外股票FeedHandler上，吞吐量轻松突破每秒500,000个包） // 4. 接口简单，使用非常方便（可参考BoostDemo程序） // 使用方法 // CDataHandler是一个基类，使用时定义子类对其进行继承。 // 继承类重写DataThread和DataFunc方法（一般情况下仅需重写DataFunc方法即可）
c++ boost 线程级信号量
doj85149的博客
04-11 702
1 class FS_Semaphora { 2 private: 3 unsigned int count; 4 boost::condition_variable condition; 5 boost::mutex lock; 6 7 public: 8 FS_Sema...
Boost.Asio信号量和串口
2301_79446920的博客
08-18 309
除了网络通信，Boost.Asio还包含了其他的I/O功能。
C++ Boost提供的六种进程间通信技术介绍
最新发布
琅嬛福地
12-01 1195
内存映射文件（Memory-Mapped Files）是一种进程间通信（IPC）机制，允许文件或设备（通常是磁盘上的文件）的内容被映射到进程的地址空间。这样，文件可以像访问常规内存数组一样被访问，而不是使用传统的文件读写API。这种技术不仅可以用于文件I/O，还经常用于进程间的共享内存。以下是内存映射文件工作原理的概述：文件映射文件打开：首先，需要有一个文件。这个文件可以是已存在的，也可以是新创建的，用于将数据持久存储到磁盘。创建映射：操作系统提供了创建内存映射的API。
c++ boost库--信号处理
Timeinsist的博客
06-12 1783
c++ boost库–信号处理 标签（空格分隔）： c++ boost 概述 在windows编程中，每一次按键，或者数遍移动，或者其他动作都会向系统消息队列中，投递一条对应的消息，而应用程序捕捉到对应的消息后，要在消息循环中做对应的处理，例如按下键盘，要会产生WM_KEYDOWN消息，在消息循环中要对其进行处理。按下按键即为事件，而对消息进行处理的代码即为消息处理器，qt中直接将每...
C++boost库信号槽的使用
CyanNoah的博客
03-08 1465
C++boost库信号槽的使用为什么使用信号槽使用的库例程 为什么使用信号槽 为了解耦，因为建设一定规模的程序时，为了未来的可维护性扩展性，使用信号槽是个不错的想法。 好比某道菜可能有多个方法去制作，所以我们在炒制的地方标注根据客人需求制作，这样就不至于客人需求不一样时就需要给厨师一份新的菜谱为了替换菜谱上的某个小地方，这样实现了解耦。 使用的库 我们这里使用boost的信号槽库，安装boost库后可以包含以下来使用库中的方式实现功能。 #include <boost/signals2.hpp>
c++实现boost中信号（c++观察者模式）
m08090420的博客
01-05 376
boost中信号用着特别简单，需要就注册不需要要就删除，可以注册任意的对象函数，只要触发信号所有注册了该信号的对象都会被调用。下面就自己实现一个类似的功能。首先实现一个信号发送者的基类，所有需要发送信号的对象都继承该类就可以了，代码如下： //发送信号 class CRecvSignal; class CSendSignal { public: friend class CRecvSi...
boost::signals2的介绍及应用（信号与插槽）
TypicalSpider的博客
01-17 1304
signals2基于Boost里的另一个库signals实现了线程安全的观察者模式。
Boost C++实战应用开发指南
4. 应用开发实践：本书通过80多个实战配方，涵盖了从基础到高级的Boost库使用技巧，包括如何使用特定库解决实际问题，优化代码性能，以及如何在项目中集成Boost库。每个配方都是一次独立的任务，读者可以通过实践来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值