借助可变模板实现观察者模式的一种替代方式

最新推荐文章于 2021-09-01 08:54:03 发布
最新推荐文章于 2021-09-01 08:54:03 发布
阅读量397 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a571255945/article/details/103794894
版权

陈硕在观察者模式之缪中提到,Observe模式有本质的问题,问题的根本原因在于面向对象的设计.其中的一个问题是,observer是基类,带来了非常强的耦合,强度仅次于友元类型,这种耦合限制了成员函数的名字,参数,返回值,还限制了成员函数所属的类型(必须是observer的派生类).还有一些其他的问题,这里不细述了,C++语言可以通过function/bind绕开Observer模式的限制.书中的代码实现了一个信号曹机制来进行一对多回调(观察者本质上就为了方便一对多的处理),说实话代码刚刚能看懂,理解还不够深入,这里记录下,后面再逐步深入.
首先是一个简单的可变模板实现(非线程安全),实现了一对多回调.

//SignalSlotTrivial.h
// Created by root on 1/1/20.
//

#ifndef MUDUO_SIGNALSLOTTRIVIAL_H
#define MUDUO_SIGNALSLOTTRIVIAL_H

#include <memory>
#include <vector>
#include <iostream>
#include <functional>
template<typename Signature>
class SignalTrivial;

template <typename RET, typename... ARGS>
class SignalTrivial<RET(ARGS...)>
{
public:
    typedef std::function<void (ARGS...)> Functor;

    void connect(Functor&& func)
    {
        functors_.push_back(std::forward<Functor>(func));
    }

    void call(ARGS &&... args)
    {
        // gcc 4.6 supports
        //for (const Functor& f: functors_)
        typename std::vector<Functor>::iterator it = functors_.begin();
        for (; it != functors_.end(); ++it)
        {
            (*it)(args...);
        }
    }
private:
    std::vector<Functor> functors_;
};


#endif //MUDUO_SIGNALSLOTTRIVIAL_H

线程安全的版本:

//SignalSlot.h
// Created by root on 1/1/20.
//

#ifndef MUDUO_SIGNALSLOT_H
#define MUDUO_SIGNALSLOT_H

#include <mutex>
#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

#include <vector>

namespace muduo
{

    namespace detail
    {

        template<typename Callback>
        struct SlotImpl;

        template<typename Callback>
        struct SignalImpl : boost::noncopyable
        {
            typedef std::vector<boost::weak_ptr<SlotImpl<Callback> > > SlotList;

            SignalImpl()
                    : slots_(new SlotList)
            {
            }

            void copyOnWrite()
            {
//                mutex_.assertLocked();
//                mutex_.try_lock();
                if (!slots_.unique())
                {
                    slots_.reset(new SlotList(*slots_));
                }
                assert(slots_.unique());
            }

            void clean()
            {
                std::lock_guard<std::mutex> lock(mutex_);
                copyOnWrite();
                SlotList& list(*slots_);
                typename SlotList::iterator it(list.begin());
                while (it != list.end())
                {
                    if (it->expired())
                    {
                        it = list.erase(it);
                    }
                    else
                    {
                        ++it;
                    }
                }
            }

            std::mutex mutex_;
            boost::shared_ptr<SlotList> slots_;
        };

        template<typename Callback>
        struct SlotImpl : boost::noncopyable
        {
            typedef SignalImpl<Callback> Data;
            SlotImpl(const boost::shared_ptr<Data>& data, Callback&& cb)
                    : data_(data), cb_(cb), tie_(), tied_(false)
            {
            }

            SlotImpl(const boost::shared_ptr<Data>& data, Callback&& cb,
                     const boost::shared_ptr<void>& tie)
                    : data_(data), cb_(cb), tie_(tie), tied_(true)
            {
            }

            ~SlotImpl()
            {
                boost::shared_ptr<Data> data(data_.lock());
                if (data)
                {
                    data->clean();
                }
            }

            boost::weak_ptr<Data> data_;
            Callback cb_;
            boost::weak_ptr<void> tie_;
            bool tied_;
        };

    }

/// This is the handle for a slot
///
/// The slot will remain connected to the signal fot the life time of the
/// returned Slot object (and its copies).
    typedef boost::shared_ptr<void> Slot;

    template<typename Signature>
    class Signal;

    template <typename RET, typename... ARGS>
    class Signal<RET(ARGS...)> : boost::noncopyable
    {
    public:
        typedef std::function<void (ARGS...)> Callback;
        typedef detail::SignalImpl<Callback> SignalImpl;
        typedef detail::SlotImpl<Callback> SlotImpl;

        Signal()
                : impl_(new SignalImpl)
        {
        }

        ~Signal()
        {
        }

        Slot connect(Callback&& func)
        {
            boost::shared_ptr<SlotImpl> slotImpl(
                    new SlotImpl(impl_, std::forward<Callback>(func)));
            add(slotImpl);
            return slotImpl;
        }

        Slot connect(Callback&& func, const boost::shared_ptr<void>& tie)
        {
            boost::shared_ptr<SlotImpl> slotImpl(new SlotImpl(impl_, func, tie));
            add(slotImpl);
            return slotImpl;
        }

        void call(ARGS&&... args)
        {
            SignalImpl& impl(*impl_);
            boost::shared_ptr<typename SignalImpl::SlotList> slots;
            {
                std::lock_guard<std::mutex> lock(impl.mutex_);
                slots = impl.slots_;
            }
            typename SignalImpl::SlotList& s(*slots);
            for (typename SignalImpl::SlotList::const_iterator it = s.begin(); it != s.end(); ++it)
            {
                boost::shared_ptr<SlotImpl> slotImpl = it->lock();
                if (slotImpl)
                {
                    boost::shared_ptr<void> guard;
                    if (slotImpl->tied_)
                    {
                        guard = slotImpl->tie_.lock();
                        if (guard)
                        {
                            slotImpl->cb_(args...);
                        }
                    }
                    else
                    {
                        slotImpl->cb_(args...);
                    }
                }
            }
        }

    private:
        void add(const boost::shared_ptr<SlotImpl>& slot)
        {
            SignalImpl& impl(*impl_);
            {
                std::lock_guard<std::mutex> lock(impl.mutex_);
                impl.copyOnWrite();
                impl.slots_->push_back(slot);
            }
        }
        const boost::shared_ptr<SignalImpl> impl_;
    };
}
#endif //MUDUO_SIGNALSLOT_H


//
// Created by root on 1/1/20.
//

#include "SignalSlotTrivial.h"
#include "SignalSlot.h"
#include <iostream>

#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>



#if 0
class String
{
public:
    String(const char* str)
    {
        printf("String ctor this %p\n", this);
    }

    String(const String& rhs)
    {
        printf("String copy ctor this %p, rhs %p\n", this, &rhs);
    }

    String(String&& rhs)
    {
        printf("String move ctor this %p, rhs %p\n", this, &rhs);
    }
};

class Foo : boost::noncopyable
{
public:
    void zero();
    void zeroc() const;
    void one(int);
    void oner(int&);
    void onec(int) const;
    void oneString(const String& str);
    // void oneStringRR(String&& str);
    static void szero();
    static void sone(int);
    static void soneString(const String& str);
};

void Foo::zero()
{
    printf("Foo::zero()\n");
}

void Foo::zeroc() const
{
    printf("Foo::zeroc()\n");
}

void Foo::szero()
{
    printf("Foo::szero()\n");
}

void Foo::one(int x)
{
    printf("Foo::one() x=%d\n", x);
}

void Foo::onec(int x) const
{
    printf("Foo::onec() x=%d\n", x);
}

void Foo::sone(int x)
{
    printf("Foo::sone() x=%d\n", x);
}

void Foo::oneString(const String& str)
{
    printf("Foo::oneString\n");
}

void Foo::soneString(const String& str)
{
    printf("Foo::soneString\n");
}

int main()
{
    SignalTrivial<void()> signal;

//    signal.connect(&Foo::szero);

    Foo f;
    signal.connect(std::bind(&Foo::one, &f, 42));

    const Foo cf;
    signal.connect(boost::bind(&Foo::zeroc, &cf));
    signal.connect(boost::bind(&Foo::onec, &cf, 128));
    printf("========\n");
    signal.call();

    return 0;
}

#endif


#if 1

#define BOOST_TEST_MAIN
#ifdef BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
#else
#include <boost/test/included/unit_test.hpp>
#endif
class String
{
public:
    String(const char* str)
    {
        printf("String ctor this %p\n", this);
    }

    String(const String& rhs)
    {
        printf("String copy ctor this %p, rhs %p\n", this, &rhs);
    }

    String(String&& rhs)
    {
        printf("String move ctor this %p, rhs %p\n", this, &rhs);
    }
};

class Foo : boost::noncopyable
{
public:
    void zero();
    void zeroc() const;
    void one(int);
    void oner(int&);
    void onec(int) const;
    void oneString(const String& str);
    // void oneStringRR(String&& str);
    static void szero();
    static void sone(int);
    static void soneString(const String& str);
};

void Foo::zero()
{
    printf("Foo::zero()\n");
}

void Foo::zeroc() const
{
    printf("Foo::zeroc()\n");
}

void Foo::szero()
{
    printf("Foo::szero()\n");
}

void Foo::one(int x)
{
    printf("Foo::one() x=%d\n", x);
}

void Foo::onec(int x) const
{
    printf("Foo::onec() x=%d\n", x);
}

void Foo::sone(int x)
{
    printf("Foo::sone() x=%d\n", x);
}

void Foo::oneString(const String& str)
{
    printf("Foo::oneString\n");
}

void Foo::soneString(const String& str)
{
    printf("Foo::soneString\n");
}
#if 0
BOOST_AUTO_TEST_CASE(testSignalSlotTrivialZero)
{
    SignalTrivial<void()> signal;

    printf("========\n");
    signal.call();

    signal.connect(&Foo::szero);

    printf("========\n");
    signal.call();

    Foo f;
    signal.connect(boost::bind(&Foo::zero, &f));

    printf("========\n");
    signal.call();

    signal.connect(boost::bind(&Foo::one, &f, 42));

    printf("========\n");
    signal.call();

    const Foo cf;
    signal.connect(boost::bind(&Foo::zeroc, &cf));

    printf("========\n");
    signal.call();

    signal.connect(boost::bind(&Foo::onec, &cf, 128));

    printf("========\n");
    signal.call();

    printf("========\n");
    signal.call();
}
#endif

#if 0
BOOST_AUTO_TEST_CASE(testSignalSlotTrivialOne)
{
    SignalTrivial<void(int)> signal;

    printf("========\n");
    signal.call(500);

    signal.connect(&Foo::sone);

    printf("========\n");
    signal.call(510);

    Foo f;
    signal.connect(boost::bind(&Foo::one, &f, _1));

    printf("========\n");
    signal.call(520);

    const Foo cf;
    signal.connect(boost::bind(&Foo::onec, &cf, _1));

    printf("========\n");
    signal.call(530);
}
#endif

#if 0
BOOST_AUTO_TEST_CASE(testSignalSlotTrivialString)
{
    SignalTrivial<void(const String&)> signal;
    signal.call("hello");

    signal.connect(&Foo::soneString);

    printf("========\n");
    signal.call("hello");

    Foo f;
    signal.connect(boost::bind(&Foo::oneString, &f, _1));

    printf("========\n");
    signal.call("hello");
}
#endif

#if 0
BOOST_AUTO_TEST_CASE(testSignalSlotZero)
{
    muduo::Signal<void()> signal;

    printf("==== testSignalSlotZero ====\n");
    signal.call();

    muduo::Slot s1 = signal.connect(&Foo::szero);

    printf("========\n");
    signal.call();

    Foo f;
    muduo::Slot s2 = signal.connect(boost::bind(&Foo::zero, &f));

    printf("========\n");
    signal.call();

    muduo::Slot s3 = signal.connect(boost::bind(&Foo::one, &f, 42));

    printf("========\n");
    signal.call();

    const Foo cf;
    muduo::Slot s4 = signal.connect(boost::bind(&Foo::zeroc, &cf));

    printf("========\n");
    signal.call();

    muduo::Slot s5 = signal.connect(boost::bind(&Foo::onec, &cf, 128));

    printf("========\n");
    signal.call();

    s1 = muduo::Slot();
    printf("========\n");
    signal.call();


    s4 = s3 = s2 = muduo::Slot();

    printf("========\n");
    signal.call();

}
#endif

#if 1
BOOST_AUTO_TEST_CASE(testSignalSlotOne)
{
    muduo::Signal<void(int)> signal;

    printf("========\n");
    signal.call(50);


    muduo::Slot s4;
    {
        muduo::Slot s1 = signal.connect(&Foo::sone);

        printf("========\n");
        signal.call(51);

        Foo f;
        muduo::Slot s2 = signal.connect(boost::bind(&Foo::one, &f, _1));

        printf("========\n");
        signal.call(52);

        const Foo cf;
        muduo::Slot s3 = signal.connect(boost::bind(&Foo::onec, &cf, _1));

        printf("========\n");
        signal.call(53);

        s4 = s3;
    }

    printf("========\n");
    signal.call(54);
}
#endif

#if 1
BOOST_AUTO_TEST_CASE(testSignalSlotLife)
{
    muduo::Slot s1;

    {
        muduo::Signal<void()> signal;
        s1 = signal.connect(&Foo::szero);

        printf("========\n");
        signal.call();

        Foo f;
        boost::function<void()> func = boost::bind(&Foo::zero, &f);

        s1 = signal.connect(func);

        printf("========\n");
        signal.call();
    }
}
#endif

#endif
copy_O_move
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
来，展示一下工作中常用的设计模式
q1472750149的博客
12-30 3287
平时我们写代码呢，多数情况都是流水线式写代码，基本就可以实现业务逻辑了。如何在写代码中找到乐趣呢，我觉得，最好的方式就是：使用设计模式优化自己的业务代码。今天跟大家聊聊日常工作中，我都使用过哪些设计模式。 工作中常用到哪些设计模式 1.策略模式 1.1 业务场景 假设有这样的业务场景，大数据系统把文件推送过来，根据不同类型采取不同的解析方式。多数的小伙伴就会写出以下的代码： if(type=="A"){ //按照A格式解析 }else if(type=="B"){ ...
C++ 代码实现观察者模式
02-01
在Qt中，可以使用`QObservable`和`QObserver`接口，或者直接利用`signals`和`slots`机制，这是一种更简洁且面向对象的方式来实现观察者模式。`QObservable`类可以发送信号，`QObserver`类可以连接这些信号并执行相应...
java observer_Java9弃用Observable类和Observer接口的替代方案
weixin_42279592的博客
02-12 1458
弃用原因：他们没有为应用程序提供足够丰富的事件模型。例如，他们只能支持某些更改的概念，但不传达有关更改的任何信息。不可序列化-因为，Observable不实现可序列化。因此，您既不能序列化Observable也不能对其子类进行序列化。没有线程安全-方法可以被其子类覆盖，并且事件通知可以以不同的顺序发生，并且可能在不同的线程上发生，这足以破坏任何“线程安全”。并且大多数问题都具有修复的复杂性，但仍然...
观察者模式取代BroadCast
weixin_33704591的博客
09-17 56
2019独角兽企业重金招聘Python工程师标准>>> ...
模板应用--观察者模式
hebezai的专栏
08-27 2402
c++模板实现的线程安全观察者模式，支持观察多个对象，观察者与Subject之间无耦
使用观察者模式监听系统参数的改变(1)--新增
二楼后座
05-07 334
  可以先阅读  使用观察者模式监听Map值的改变   1. 数据库表 sys_params      数据库为: oracle 10g2   create table SYS_PARAMS ( PARAM_ID VARCHAR2(36) PRIMARY KEY, PARAM_NAME VARCHAR2(20) not null, PARAM_VALU...
10. 观察者模式1
08-03
观察者模式在实际应用中有多种实现方式： - **同步阻塞**：在事件发生时，主题会立即通知所有观察者，每个观察者依次执行其更新操作。这种方式简单直观，但如果观察者数量多或执行时间长，可能导致阻塞。 - **异步非...
一种基于可变功率负载电流波形的基波估计算法
06-12
为了实现可变功率负载的非侵入式辨识,提出一种基于负载电流波形的特征辨识解决方案。由可变功率负载的电流波形出发,借助其结构上的特点,如波形的周期性、奇对称性等,运用离散傅里叶变换,由零电流区域的数据建立待解...
访问者模式简介和java代码实现
最新发布
07-05
为了解决这一问题，访问者模式可以采用双分派实现，即在元素类中也包含一个访问者类型参数，这样在访问者接口中只需要声明一个通用的 visit 方法，而元素类则根据自身类型决定调用哪个具体方法。 双分派的实现原理...
一种液晶立体显示器格式的设计与实现
10-22
视差屏障通过光栅阵列（利用摩尔干涉条纹判别法精确安装在显示器液晶面板上）准确控制每一个像素透过的光线，只让右眼或左眼看到，由于右眼和左眼观看液晶面板的角度不同，利用这一角度差遮住光线就可将图像分配给...
基于模板、类型安全、通用的观察者模式的C++实现
08-22
Implementation of Template-based, type-safe and generic Observer Pattern for C++基于模板、类型安全、通用的观察者模式的C++实现；包含库文件和使用示例。
Template Signal Processing Library
07-06
TSPL(Template Signal Processing Library) 是一个 C++ 的信号处理库，主要包括滤波器设计、时频分析和小波变换，同时还包含一些关于向量和矩阵的基本算法，所有的算法基于 C++ 模板类编写而成
模式6-替代模板方式模式
我的博客
07-28 907
目的： 替代模板方式模式（模板方式模式-指定算法大致轮廓，并让调用者完成对某些细节的插入） (ns org.liango.oo.template.制作评分报表) (defn make-grade-report { :doc "制作评分报表" } [num-to-letter print-gr
设计模式（十二）观察者模式
if_i_were_a的博客
11-12 129
观察者模式（Observer）又叫做发布订阅模式（Publish/Subscibe） 观察者模式定义了一种一对多的依赖关系，让读个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。 public abstract class Subject { private List&lt;Observer&gt; observers...
信号与槽函数 一对多 muduo实现
weixin_43360707的博客
10-12 242
信号与槽 https://blog.csdn.net/a571255945/article/details/103794894 template<typename Signature> class SignalTrivial; template <typename RET, typename... ARGS> class SignalTrivial<RET(ARGS...)> { typedef std::function<RET(ARGS...)> F
c++ 11 实现简单 signal slot
zsyddl2的专栏
10-31 2004
c++ 11以前要实现 signal slot 非常麻烦，需要重写很多代码。之前使用 libsig++ 后来发现 这代码中与qt 的slots emit等名称冲突。虽然可以解决，但是比较麻烦。所以 就使用 新的 c++特性，自行实现了简单的 signal 类。 目前实现比较简单。没有太多考虑异常或者智能情况。 这里面包含了结合线程使用,编程异步信号的 部分代码.需要屏蔽掉才能正常使用....
linux 多线程服务端编程读书笔记（一）
qq_40028201的博客
05-24 754
linux 多线程服务端编程读书笔记（一） 第一章 线程安全的对象生命期管理 1、class线程安全的三个条件： 多个线程访问表现出正确的行为 无论操作系统如何调度，以及线程的执行顺序如何 调用端代码不需要额外的同步与协调动作 由此，STL大多数的class都不是线程安全的，需要外部加锁才能同时访问 MutexLock与MutexLockGuard 2、线程安全的对象构造方法 ...
C++行为型模式-实现观察者模式
灰太狼的小秘密
09-01 6885
一、观察者模式基本概念 二、改进观察者模式 参考文献： 【1】
muduo网络库源码复现笔记(四):base库的Thread.h和CurrentThread.h
梁熙民的csdn博客
06-27 359
Muduo网络库简介 muduo 是一个基于 Reactor 模式的现代 C++ 网络库，作者陈硕。它采用非阻塞 IO 模型，基于事件驱动和回调，原生支持多核多线程，适合编写 Linux 服务端多线程网络应用程序。 muduo网络库的核心代码只有数千行，在网络编程技术学习的进阶阶段，muduo是一个非常值得学习的开源库。目前我也是刚刚开始学习这个网络库的源码，希望将这个学习过程记录下来。这个网络库的源码已经发布在GitHub上，可以点击这里阅读。目前Github上这份源码已经被作者用c++11重写，我学习的
vue观察者模式和订阅
05-13
发布-订阅模式和观察者模式是两种常见的设计模式，它们都可以用于在Vue中实现组件之间的通信。 在Vue中，观察者模式是通过`watch`来实现的。当我们使用`watch`来观察一个数据时，Vue会在该数据发生变化时自动执行我们定义的回调函数。这种方式非常适合用于对单个数据的变化进行监听和处理。 而发布-订阅模式则需要借助Vue提供的事件总线`$emit`和`$on`来实现。我们可以在一个组件中使用`$emit`来触发一个事件，然后在其他组件中使用`$on`来监听这个事件并执行相应的操作。这种方式适合用于多个组件之间的通信，可以实现任意组件之间的消息传递。 总的来说，Vue中的观察者模式适合用于对单个数据的变化进行监听和处理，而发布-订阅模式则适合用于实现组件之间的通信。当我们需要实现多个组件之间的消息传递时，可以选择使用事件总线来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值