c++ 11 实现简单 signal slot

最新推荐文章于 2021-12-16 12:49:38 发布
原创 最新推荐文章于 2021-12-16 12:49:38 发布 · 2.1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种在C++11中实现信号槽机制的方法，避免了使用libsig++与Qt信号槽机制的名称冲突问题。通过利用C++11的新特性，如std::function和模板，设计了一个简单的信号类，支持线程安全和异步信号发送。文章提供了详细的代码实现和示例，展示了如何连接和断开信号与槽。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

c++ 11以前要实现 signal slot 非常麻烦，需要重写很多代码。之前使用 libsig++ 后来发现 这代码中与qt 的slots emit等名称冲突。虽然可以解决，但是比较麻烦。所以 就使用 新的 c++特性，自行实现了简单的 signal 类。 目前实现比较简单。没有太多考虑异常或者智能情况。

     这里面包含了结合线程使用,编程异步信号的 部分代码.需要屏蔽掉才能正常使用.


#include <functional>
#include <map>
#include <vector>
#include "ScTypes.h"
#include "ScCoreDefine.h"

#define AsyncSignal
#ifdef AsyncSignal
#include "ScAsyncMessage.h"
#include "ScThread.h"
#include "ScMutex.h"
#include "ScReadWriteLock.h"
#endif

#ifdef PostMessage
#define PostMessageOld PostMessage
#undef  PostMessage
#endif
// A signal object may call multiple slots with the
// same signature. You can connect functions to the signal
// which will be called when the emit() method on the
// signal object is invoked. Any argument passed to emit()
// will be passed to the given functions.
//异步消息大约每秒d 70 万 r 500w
//不可使用引用作参数
namespace SimpleCpp {
	class CThread;

    class SCCORE_API CSignalInitializer {
    public:
        CSignalInitializer();
        ~CSignalInitializer();

        static CThread*	m_pThreadDefault;
        static CSignalInitializer m_signalInitializer;
    };

	template <class T_Ret, typename... Args>
	class CSignalConnection {
	public:
		CSignalConnection() {

		}
		CSignalConnection(const CSignalConnection& other) {
			m_pFun = other.m_pFun;
			m_pObject = other.m_pObject;
			m_function = other.m_function;
		}
		~CSignalConnection()
		{

		}

		CSignalConnection& operator =(const CSignalConnection& other) {
			m_pFun = other.m_pFun;
			m_pObject = other.m_pObject;
			m_function = other.m_function;

			return *this;
		}
	public:

		std::function<T_Ret(Args...)> m_function;
		void* m_pFun;
		void* m_pObject;
	};


	template <class T_Ret, typename... Args>
	class CSignal {

	public:

		CSignal(void* pOwner=nullptr, bool bThreadSafe=true)
#ifdef AsyncSignal
			: m_pThread(nullptr)

#endif
			//, m_pMutex(nullptr)
			, m_pOwner(pOwner)
		{
			//默认都要打开线程安全
			if (bThreadSafe)
			{
				//m_pMutex = new CMutex();
				m_pRWLock = new CReadWriteLock();
			}
		}

		// copy creates new signal
		CSignal(CSignal const& other)
#ifdef AsyncSignal
			: m_pThread(nullptr) 
#endif
			//, m_pMutex(nullptr)
		{
// 			if (other.m_pMutex)
// 			{
// 				m_pMutex = new CMutex();
// 			}
			
		}
		~CSignal() {
// 			for (auto it : m_lstSlots) {
// 				delete it.first;
// 			}
			if (m_pThread)
			{
				//m_pThread->RemoveMessage(this);
				m_pThread->RemoveSignal(this);
			}
			for (int i=0; i<m_lstSlots.size(); i++)
			{
				delete m_lstSlots[i];
			}
			m_lstSlots.clear();
// 			if (m_pMutex)
// 			{
// 				delete m_pMutex;
// 				m_pMutex = nullptr;
// 			}
			if (m_pRWLock)
			{
				delete m_pRWLock;
				m_pRWLock = nullptr;
			}
		}

		// connects a member function of a given object to this Signal  
// 		template < typename T_Fun, typename T_O, typename... A>
// 		int Connect(T_Fun&& fun, T_O&& object, A&& ... a) 
		template < typename T_Fun,  typename... A>
		int Connect(T_Fun&& fun,  A&& ... a)
		{
			ScDebug("%s: ptr fun \n", __FUNCTION__);
			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
			pConnection->m_pFun = (void*)*(long long*)&fun;
			pConnection->m_pObject = (void*)nullptr;

			pConnection->m_function = std::bind(fun, a...);
			//pConnection->m_function = std::bind(fun, object, a...);
			//m_lstSlots.insert({ ++m_Id, std::bind(fun, object, a...) });
			//m_lstSlots.insert({ pFunction, pFunction->m_function });
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 				m_lstSlots.push_back(pConnection);
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
				m_lstSlots.push_back(pConnection);
				m_pRWLock->UnlockForWrite();
			}
			else
			{
				m_lstSlots.push_back(pConnection);
			}

			return 0;
		}
// 		template < typename T_Fun>
// 		int Connect(T_Fun&& fun)
// 		{
// 			ScDebug("%s: ptr fun \n", __FUNCTION__);
// 			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
// 			pConnection->m_pFun = (void*)*(long long*)&fun;
// 			pConnection->m_pObject = (void*)nullptr;
// 
// 			pConnection->m_function = std::bind(fun);
// 			//pConnection->m_function = std::bind(fun, object, a...);
// 			if (m_pRWLock)
// 			{
// 				m_pRWLock->LockForWrite();
// 				m_lstSlots.push_back(pConnection);
// 				m_pRWLock->UnlockForWrite();
// 			}
// 			else
// 			{
// 				m_lstSlots.push_back(pConnection);
// 			}
// 
// 			return 0;
// 		}

		template <typename T_Ret1, typename T_O, typename... A>
		int Connect(T_Ret1 T_O::* fun, T_O* object, A&& ... a) {
			ScDebug("%s: mem fun \n", __FUNCTION__);
			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
			pConnection->m_pFun = (void*)*(long long*)&fun;//(void*)*(long long*)&fun;
			pConnection->m_pObject = (void*)object;
			pConnection->m_function = std::bind(fun, object, a...);

			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
				m_lstSlots.push_back(pConnection);
				m_pRWLock->UnlockForWrite();
			}
			else
			{
				m_lstSlots.push_back(pConnection);
			}
			return 0;
		}
		template < typename T_Fun,  typename... A>
		int Connect1(T_Fun* fun, A&& ... a) {
			ScDebug("%s: ptr fun \n", __FUNCTION__);
			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
			pConnection->m_pFun = (void*)*(long long*)fun;
			pConnection->m_pObject = (void*)nullptr;

			pConnection->m_function = std::bind(fun, a...);
	 
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
				m_lstSlots.push_back(pConnection);
				m_pRWLock->UnlockForWrite();
			}
			else
			{
				m_lstSlots.push_back(pConnection);
			}

			return 0;
		}
		template <typename T_Ret1, typename T_O, typename... A>
		int Connect1(T_Ret1 T_O::* fun, T_O* object, A&& ... a) {
 			ScDebug("%s: mem fun \n", __FUNCTION__);
 			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
			pConnection->m_pFun = (void*)*(long long*)&fun;//(void*)*(long long*)&fun;
 			pConnection->m_pObject = (void*)object;
 			pConnection->m_function = std::bind(fun, object, a...);
 
 			if (m_pRWLock)
 			{
 				m_pRWLock->LockForWrite();
 				m_lstSlots.push_back(pConnection);
 				m_pRWLock->UnlockForWrite();
 			}
 			else
 			{
 				m_lstSlots.push_back(pConnection);
 			}
			return 0;
		}

		template <typename T_Fun, typename T_O, typename... A>
		CSignalConnection<T_Ret, Args...> MemFun(T_Fun&& fun, T_O&& object, A&& ... a)
		{
			CSignalConnection<T_Ret, Args...> connection;
			connection.m_pFun = (void*)*(long long*)&fun;
			connection.m_pObject = (void*)&object;
			connection.m_function = std::bind(fun, object, a...);

			return connection;
		}
		template <typename T_Fun, typename T_O, typename... A>
		CSignalConnection<T_Ret, Args...> Fun(T_Fun&& fun, T_O&& object, A&& ... a)
		{
			CSignalConnection<T_Ret, Args...> connection;
			connection.m_pFun = (void*)*(long long*)&fun;
			connection.m_pObject = (void*)&object;
			connection.m_function = std::bind(fun, object, a...);

			return connection;
		}

		template <typename T_Fun, typename... A>
		CSignalConnection<T_Ret, Args...> PtrFun(T_Fun&& fun, A&& ... a)
		{
			CSignalConnection<T_Ret, Args...> connection;
			connection.m_pFun = (void*)*(long long*)&fun;
			connection.m_pObject = nullptr;
			//function.function = std::bind(fun, a...);
			return connection;
		}
		// connects a free function to the signal. The returned
        // can not use std::bind, use function ptr directly
		int Connect(std::function<T_Ret(Args...)> const& fun) {
             typedef T_Ret T_Fun(Args...);
             T_Fun* pFun = nullptr;
			 long long* pTmp = (long long*)fun.template target<T_Ret(*)(Args...)>();
            // fun.template target<decltype(pFun)>();
             //int64* pTmp = (int64*)fun.target<decltype(pFun)>();
			if (pTmp == nullptr)
			{//不能使用bind 方式绑定.
				return -1;
			}
			// 			;
			CSignalConnection<T_Ret, Args...> *pConnection = new CSignalConnection<T_Ret, Args...>();
			//pFunction->pFun = (void*)*(int64*)function.target<T_Ret(Args...)>();
			pConnection->m_pFun = (void*)*pTmp;
			pConnection->m_pObject = nullptr;
			pConnection->m_function = fun;

			//m_lstSlots.insert({ pFunction, fun });
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 				m_lstSlots.push_back(pConnection);
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
				m_lstSlots.push_back(pConnection);
				m_pRWLock->UnlockForWrite();
			}
			else
			{
				m_lstSlots.push_back(pConnection);
			}
			return 0;
		}
		//成员函数 mem function， 不可使用bind
		template < typename T_Fun, typename T_O, typename... A>
		int Disconnect(T_Fun&& fun, T_O&& object, A&& ... a) {
			CSignalConnection<T_Ret, Args...> connection;
			connection.m_pFun = (void*)*(long long*)&fun;
			connection.m_pObject = (void*)object;
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
			}
            typename std::vector<CSignalConnection<T_Ret, Args...> *> ::iterator item;
			for (item = m_lstSlots.begin(); item != m_lstSlots.end(); item++) {
				CSignalConnection<T_Ret, Args...>* pConnectionTmp;
				pConnectionTmp = *item;
				if (pConnectionTmp->m_pFun == connection.m_pFun
					&& pConnectionTmp->m_pObject == connection.m_pObject)
				{
					item = m_lstSlots.erase(item);
					delete pConnectionTmp;
					break;
				}
			}
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->UnlockForWrite();
			}
			return 0;
		}
		//断开普通函数 free function ， 不可使用 bind 
		int Disconnect(std::function<T_Ret(Args...)> const& fun) {

			long long* pTmp = (long long*)fun.template target<T_Ret(*)(Args...)>();
			if (pTmp == nullptr)
			{//不能使用bind 方式绑定.
				return -1;
			}

			CSignalConnection<T_Ret, Args...> connection;
			connection.m_pFun = (void*)*pTmp;
			connection.m_pObject = nullptr;
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
			}
            typename std::vector<CSignalConnection<T_Ret, Args...> *> ::iterator item;
			for (item = m_lstSlots.begin(); item != m_lstSlots.end(); item++) {
				CSignalConnection<T_Ret, Args...>* pConnectionTmp;
				pConnectionTmp = *item;
				if (pConnectionTmp->m_pFun == connection.m_pFun
					&& pConnectionTmp->m_pObject == connection.m_pObject)
				{
					item = m_lstSlots.erase(item);
					delete pConnectionTmp;
					break;
				}
			}
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->UnlockForWrite();
			}
			return 0;
		}

		int Connect(CSignalConnection<T_Ret, Args...> connection)
		{
			CSignalConnection<T_Ret, Args...>* pNewConnection = new CSignalConnection<T_Ret, Args...>(connection);

			//m_lstSlots.insert({ pFunction, function.m_function });
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
			}

			m_lstSlots.push_back(pNewConnection);
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->UnlockForWrite();
			}

			return 0;
		}

		// disconnects a previously connected function


		// disconnects all previously connected functions
		void Clear()  {
// 			for (auto it : m_lstSlots) {
// 				delete *it;
// 			}
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForWrite();
			}
			for (int i = 0; i < m_lstSlots.size(); i++)
			{
				delete m_lstSlots[i];
			}
			m_lstSlots.clear();
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->UnlockForWrite();
			}
		}

		// calls all connected functions
		T_Ret Emit(Args... p) {
			bool bVoid = std::is_same<T_Ret, void>::value;
			T_Ret ret(0);
#ifdef AsyncSignal
			if (m_pThread)
			{//异步信号
				//为了锁住 m_pThread 不被detach
				m_pRWLock->LockForWrite();
				if (!m_pThread)
				{
					m_pRWLock->UnlockForWrite();
					return ret;
				}
				CAsyncMessage<T_Ret, Args...>* pMessage = new CAsyncMessage<T_Ret, Args...>(p...);
				//pMessage->SetParams(p...);
				pMessage->m_pSignal = this;
				pMessage->m_pUserData = this;
				m_pThreadMessage = pMessage;
				m_pThread->PostMessage(pMessage);
				m_pRWLock->UnlockForWrite();
			}
			else 
#endif	
			{
// 				if (m_pMutex)
// 				{
// 					m_pMutex->Lock();
// 				}
				if (m_pRWLock)
				{
					m_pRWLock->LockForRead();
				}

				for (int i = 0; i < m_lstSlots.size(); i++)
				{
					m_lstSlots[i]->m_function(p...);
				}
// 				if (m_pMutex)
// 				{
// 					m_pMutex->Unlock();
// 				}
				if (m_pRWLock)
				{
					m_pRWLock->UnlockForRead();
				}
			}
			return ret;
		}
		//发射异步信号
		T_Ret EmitAsync(CThread* pThread, Args... p) {
			T_Ret ret(0);
#ifdef AsyncSignal
			if (pThread)
			{//异步信号
				CAsyncMessage<T_Ret, Args...>* pMessage = new CAsyncMessage<T_Ret, Args...>(p...);
				//pMessage->SetParams(p...);
				pMessage->m_pSignal = this;
				m_pThreadMessage = pMessage;
				pThread->PostMessage(pMessage);
			}
			else
#endif
			{
// 				if (m_pMutex)
// 				{
// 					m_pMutex->Lock();
// 				}
				if (m_pRWLock)
				{
					m_pRWLock->LockForRead();
				}
				for (int i = 0; i < m_lstSlots.size(); i++)
				{
					m_lstSlots[i]->m_function(p...);
				}
// 				if (m_pMutex)
// 				{
// 					m_pMutex->Unlock();
// 				}
				if (m_pRWLock)
				{
					m_pRWLock->UnlockForRead();
				}
			}
			return ret;
		}
		// assignment creates new Signal
		CSignal& operator=(CSignal const& other) {
			Clear();
			return *this;
		}
		
		vector<CSignalConnection<T_Ret, Args...>*>&	GetSlots()
		{
			return m_lstSlots;
		} 
		//附加到 thread， 那么消息将发到该线程去处理
		//也将是异步信号
		int		AttachThread(CThread* pThread) {
			if (pThread == nullptr)
			{
				m_pThread = CSignalInitializer::m_pThreadDefault;
			}
			else {
				m_pThread = pThread;
			}
			// 			if (!m_pMutex)
			// 			{//异步的一定需要是线程安全的。
			// 				m_pMutex = new CMutex();
// 			}
			if (!m_pRWLock)
			{//异步的一定需要是线程安全的。
				m_pRWLock = new CReadWriteLock();
			}
			return 0;
		};
		int		DetachThread(/*CThread* pThread*/)
		{
			m_pThread = nullptr;
			return 0;
		}
		int GetCount() {
			int nCount(0);
// 			if (m_pMutex)
// 			{
// 				m_pMutex->Lock();
// 				nCount = m_lstSlots.size();
// 				m_pMutex->Unlock();
// 			}
			if (m_pRWLock)
			{
				m_pRWLock->LockForRead();
				nCount = m_lstSlots.size();
				m_pRWLock->UnlockForRead();
			}
			else {
				nCount = m_lstSlots.size();
			}
			return nCount;
		}
		//
		CThread*	GetThread() {
			return m_pThread;
		};
		bool		Lock() {
// 			if (!m_pMutex)
// 			{
// 				return false;
// 			}
// 			return m_pMutex->Lock();
			if (!m_pRWLock)
			{
				return false;
			}
			return m_pRWLock->LockForRead();

		};
		bool		Unlock()
		{
// 			if (!m_pMutex)
// 			{
// 				return false;
// 			}
// 			return m_pMutex->Unlock();
			if (!m_pRWLock)
			{
				return false;
			}
			m_pRWLock->UnlockForRead();

			return true;
		};
		void*		GetOwner()
		{
			return m_pOwner;
		}
		void		SetOwner(void* pOwner)
		{
			m_pOwner = pOwner;
		}
	protected:
		//std::map<int, std::function<T_Ret(Args...)>> m_lstSlots;;
		//std::map<CFunction<T_Ret, Args...>*, std::function<T_Ret(Args...)>> m_lstSlots;
		std::vector<CSignalConnection<T_Ret, Args...>*>	m_lstSlots;
		CThread*	m_pThread;
		//CMutex*		m_pMutex;
		CReadWriteLock*	m_pRWLock=nullptr;
		void*		m_pOwner;
		CThreadMessage*	m_pThreadMessage=nullptr;
	};

  

使用connect或者disconnect， 直接传入函数地址。不要使用bind 方式传入。 这是为了 保存函数 地址和对象地址。以便 disconnect

测试(进行了修改,自由函数或者成员函数不再需要bind函数区分)：

int TestFun()
{
	return 0;
}
class CTestClass {
public:
	int TestFun()
	{
		return 0;
	}
};

void TestSignal1()
{
	CTestClass obj;
	CSignal<int> sig;
	//sig.MemFun(&CTestClass::TestFun, &obj);

	sig.Connect(&CTestClass::TestFun, &obj);
	sig.Connect(&TestFun);

	ScDebug("%s: %p, %p\n", __FUNCTION__, &CTestClass::TestFun, &TestFun);
	//Function(&CTestClass::TestFun);

	//Function(&TestFun);
}

此类内部，有 thread。可以自行屏蔽。这是为了扩展为线程异步信号。

类似qt 信号一样。可以让信号在某个线程中异步回调Slot。

传统的 异步消息处理方式 都是 case xxxx: OnXXX这样为程序扩展带来很大麻烦。每一个消息需要做函数映射处理，同时消息处理函数必须是完全是相同参数。

直接将信号扩展为异步信号。可以在任何时候，灵活绑定行程异步消息处理过程。同时可以使用任意参数的函数做消息和对应处理函数。 这可以极大方便程序使用。 后面再继续贴出线程异步信号

C++ 信号处理：`signal` 函数与多线程环境的挑战
weixin_41455464的博客
07-06 928
想象一下，你正在愉快地写代码，突然有人踹了你一脚（或者系统发生了什么事情），你被打断了，得先处理一下这个突发事件，然后再回去继续写代码。想象一下，你的程序有多个线程，其中一个线程正在修改一个全局变量，突然收到了一个信号，信号处理函数也在试图修改这个全局变量。如果信号处理函数需要获取一个互斥锁，而恰好某个线程已经持有这个互斥锁，并且被信号中断了，那么信号处理函数就会一直阻塞，导致死锁。函数呢，就是C++（更准确地说是C标准库）提供的一个接口，让你告诉操作系统，收到某个信号的时候，你想干点啥。
C++11 信号槽 signal/slot
sunweiliang的博客
03-24 2829
最近在看陈硕大大 的《Linux 多线程服务端编程：使用 muduo C++ 网络库》 ，看到里面用variadic template 和boost智能指针 实现了一个 signal/slot，现在C++11 已经把 boost的智能指针引入到标准库里边了。就想利用纯C++11 实现一遍。 结果发现，只要把原来代码中boost智能指针替换为c++11 的智能指针，把陈大大自己实现的MutexL...
C++ 模拟实现signal/slot
10-22
C++ 模拟实现signal/slot
C++回调机制实现(转)
weixin_33728708的博客
10-10 400
对于博客，从来是默默的转，最近终于有点时间可以写些自己的东西（其实也还要忙着准备找工呢），写出来与仅仅知道那么回事绝对大不一样，写也是学习的过程，不过向来多关注于功能实现，对一些基础概念把握不准确，望各位拍砖，不废话了。      什么是回调？通常发生在需要两个角色即调用者与实现者的情形上，即我们希望当产生某个事件时，调用实现者定义的某个函数。当然这个概念很大，不是说操作系统的信号量，条件变量什...
Qt signal slot 实现机制
06-18 1245
<br />今天被问到一个问题，如下：Qt的signal slot的实现机制。<br />现在整理一下：<br />概述<br /> <br />信号和槽机制是QT的核心机制，要精通QT编程就必须对信号和槽有所了解。信号和槽是一种高级接口，应用于对象之间的通信，它是QT的核心特性，也是QT区别于其它工具包的重要地方。信号和槽是QT自行定义的一种通信机制，它独立于标准的C/C++语言，因此要正确的处理信号和槽，必须借助一个称为moc（Meta Object Compiler）的QT工具，该工具是一个C++预处
std C++ slot signal机制
hhyttppd的专栏
05-16 6308
#include #include #include #include using namespace std;class A{public: void Clicked(int id) { cout << "A::Clicked" << endl; }};class B{public: void Clicked(int id) {
c++11中信号量(semaphore)的实现
热门推荐
ElisonWu的专栏
02-28 2万+
c++11中有 mutex (互斥量)，有 condition_variable (条件变量)，并没有 semaphore (信号量)。信号量，操作系统中一般都有提，后来 google 说可以使用 mutex+condition_variable 实现一个，后来写来写去，都死锁 (deadlock) ——，O__O"…，后来 google 了一个，整理了一下思路。 信号量 神马是信号量？信号量
C++中模拟实现signal/slot机制的探讨
C++中的Signal/Slot机制是一种观察者模式的实现，最初由Qt框架引入。这种机制允许对象之间进行松耦合的事件处理和回调函数调用。通常，signal代表一个事件的发生，而slot是响应这个事件所调用的方法。在Qt中，Signal...
C++ Signal/Slot Library (sigslot)
04-26
**C++ Signal/Slot Library (sigslot) 深度解析** C++ Signal/Slot Library，简称sigslot，是一个用于事件驱动编程的库，它提供了一种声明式的方式来连接对象间的通信，使得对象间的交互更加简洁和灵活。这种模式...
SignalSlot-开源
04-24
SignalSlot开源库正是为实现这一模式而设计的。本文将深入探讨SignalSlot框架的原理、特点以及使用方法。 ### 1. 信号与插槽的概念 信号（Signal）代表了一个事件的发生，例如按钮被点击。当这个事件发生时，会...
我自己的signal / slot实现
lionzl的专栏
09-11 606
我自己的signal / slot实现 发现原来已经有两个多月没有写blog了。近来工作都很忙，回到家都懒懒的不想动。虽然工作上做了很多有趣的东西，但毕竟有版权保护，在公司做的工作不能直接写在blog上，也要抽些时间整理一下才能放上来。     今天在 www.codepro
c_signal-slot.zip
05-09
C语言版本的信号槽： 1.没有参数个数限制 2.没有参数类型限制 3.没有信号对应的槽个数限制 4.线程安全级类型 5.信号与槽直接调用
YSignalSlot:仅标头C ++信号插槽机制的实现-开源
04-25
YSignalSlot是仅标头的C ++库。 它是通过C ++实现的信号时隙机制。 它类似于C ++信号，Boost :: signal和SigSlot。 它大量使用C ++ 11功能。 优点：-几乎所有内容都在编译时。 这样很快。 -它可以与单插槽功能或无限制插槽功能一起使用。 -“ emit”函数的返回类型是实际插槽函数的返回类型的指针，并且可以是任何类型。 -它支持“ void”返回类型。 -插槽可以设置为启用或禁用。 如果禁用插槽，则信号无法发射该插槽。 -如果发出的插槽被禁用或其返回类型为空，则“ emit”函数将返回“ NULL”指针。 -它与成员插槽功能一起使用。 -它使用元编程方法来实现“ static for loop”和“ static if”。 -信号可以嵌套使用。 -接收者可以是“ this”指针。 -它是免费的，并获得LGPL许可。 -它使用C ++ 11功能。
C++ Signal/Slot Library sigslot
伍意的博客
11-22 1872
 1. QT http://qt.nokia.com/ Qt是本人喜欢并熟悉的一个cross-platform库，用来创建跨平台的应用程序非常方便。不过这不是推荐的重点，因为没办法把它用到我们自己的非QT程序中。不过QT借助自己实现moc预处理器，将signal和slot的声明，完美的融合到了C++类声明中是非常不错的考虑。 2. boost::signal & boost::sign
c++实现信号槽
12-16 2745
本人虽不用Qt框架，但对其中的信号槽机制很感兴趣，近期读了csdn几篇关于信号槽的文章，从自身角度理解记录如下： 用c++实现信号槽机制（signal-slot) 信号槽机制的个人理解：信号槽是在两个c++类对象之间建立联系的通道，其中一个对象可称之为信号发送者(sender)，另一个对象可称之为信号接收者(recver)，sender通过信号槽发出信号后，recver就可以执行函数进行某些操作。也就是说应用程序通过信号槽可以在两个互不相关的对象之间建立起逻辑关系，使程序开发变得简洁、方便。 信号槽本
在ANSI C下设计和实现简便通用的signal-slot机制
quasiceo
09-06 3252
http://bbs.chinaunix.net/thread-1592226-2-1.html 注：在几处发表同样的主题，希望通过讨论，接收到大家提出各种建议或意见，抛砖引玉。 在ANSI C下设计和实现简便通用的signal-slot机制      ——一种平台相关但易于移植的，lambda表达式风格的，经由抵抗编译器而得的方案     最近在ARM平台下做一些开发，考虑到
在C++ 中使用信号和槽（Signals and Slots）
u011505568的专栏
09-01 1万+
简介 本文介绍sigslot这个库， 它是用C++实现的具有类型安全，线程安全的信号和槽机制的库。它完全使用C++语言进行编写，只有一个头文件，因此避免了在使用的时候进行源码的预编译。sigslot的主页是http://sigslot.sourceforge.net。 一个Signal/Slot的例子 在传统的C++代码中类之间的沟通是必须通过调用彼此的成员方法，这也就使得每个类要在定义的时...
C++11 信号槽 signal/slot / boost::signals::signal的使用方法
chenmeng729970897的博客
10-21 529
链接: .
C++ slot signal机制
宋文兵的专栏
05-12 1786
一、C++ slot signal机制的一个简单实现  出处：http://blog.youkuaiyun.com/hhyttppd/article/details/4192668         #include    #include    #include    #include    using namespace std;  class A{  public:      void Cl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值