最近我开始实现一个使用＆＃34; Observer模式的消息调度系统＆＃34;：这里没什么特别的。当我开发它时，我认为发送＆＃34; Message＆＃34;来自＆＃34;主题的对象＆＃34;这可能从根本上是彼此不同的，可以从许多观察员那里读到＆＃34;。
这些不同的消息采用不同消息类的形式（例如，考虑＆＃34;用户注销消息＆＃34;，＆＃34;屏幕模式toogle＆＃34;＆＃34;音量级别已更改＆＃ 34;，所有这些都需要不同的信息）很快我就发现了＃34;观察者＆＃34;我不想知道我想要创造的每一条不同的信息（至少可以说......不可持续）。相反，我希望每个观察者能够对特定类型的消息做出反应。
所以为了做点什么，我认为双重调度可能是我的选择。经过一段时间我得到了这篇文章（c ++ 11只因为for循环）：
#include <iostream>
#include <vector>
#include <string>
/**
* A few forward declarations.
*/
class Message_base;
class Message_type_a;
class Message_type_b;
/**
* Base observer...
*/
class Observer_base
{
public:
/**
* All these implementations are empty so we don't have to specify them
* in every single derived class.
*/
virtual void get_message(const Message_base&) {}
virtual void get_message(const Message_type_a&) {}
virtual void get_message(const Message_type_b&) {}
};
/**
* Specification of all message types.
*/
class Message_base
{
public:
/**
* This is the method that will implement the double dispatching in all
* derived classes.
*/
virtual void be_recieved(Observer_base &r) const=0; //Now that's a nasty method name.
};
class Message_type_a:public Message_base
{
private:
int integer_value;
public:
Message_type_a(int v):integer_value(v) {}
int get_integer_value() const {return integer_value;}
void be_recieved(Observer_base &r) const {r.get_message(*this);}
};
class Message_type_b:public Message_base
{
private:
std::string string_value;
public:
Message_type_b(const std::string v):string_value(v) {}
std::string get_string_value() const {return string_value;}
void be_recieved(Observer_base &r) const {r.get_message(*this);}
};
/**
* This is the base clase for the Subject... Notice that there are no virtual
* methods so we could as well instantiate this class instead of derive it.
*/
class Subject_base
{
private:
std::vector<Observer_base *> observers;
public:
void emit_message(const Message_base& m) {for(auto o : observers) m.be_recieved(*o);} //Again, nasty to read since it's... backwards.
void register_observer(Observer_base * o) {observers.push_back(o);}
};
/**
* Now we will create a subject class for the sake of it. We could just call the
* public "emit_message" from main passing Message objects.
*/
class Subject_derived:public Subject_base
{
public:
void emit_message_a(int v) {emit_message(Message_type_a(v));}
void emit_message_b(const std::string v) {emit_message(Message_type_b(v));}
};
/**
* This gets fun... We make two observers. One will only get type_a messages
* and the other will get type_b.
*/
class Observer_type_a:public Observer_base
{
private:
int index; //We will use it to identify the observer.
public:
Observer_type_a(int i):index(i) {}
void get_message(const Message_type_a& m) {std::cout<<"Observer_type_a ["<<index<<"] : got type_a message : "<<m.get_integer_value()<<std::endl;}
};
class Observer_type_b:public Observer_base
{
private:
std::string name; //Merely to identify the observer.
public:
Observer_type_b(const std::string& n):name(n) {}
void get_message(const Message_type_b& m) {std::cout<<"Observer_type_b ["<<name<<"] : got type_b message : "<<m.get_string_value()<<std::endl;}
};
/**
* Stitch all pieces together.
*/
int main(int argc, char ** argv)
{
Observer_type_a o_a1(1);
Observer_type_a o_a2(2);
Observer_type_b o_b1("Sauron");
Observer_type_b o_b2("Roverandom");
Subject_derived s_a;
s_a.register_observer(&o_a1);
s_a.register_observer(&o_b1);
s_a.emit_message_a(23);
s_a.emit_message_b("this is my content");
s_a.register_observer(&o_a2);
s_a.register_observer(&o_b2);
s_a.emit_message_a(99);
s_a.emit_message_b("this is my second content");
//gloriously exit.
return 0;
}
为了清楚起见，我会在这里说出我的目标：
我的问题出现了：我是否错过了一个更简单的实现来实现我的目标？
值得一提的是，将使用的系统将不会有那么多观察者，同时可能少于10个主体。
答案 0 :(得分：3)
一些元编程样板：
// a bundle of types:
template<class...>struct types{using type=types;};
// a type that does nothing but carry a type around
// without being that type:
template<class T>struct tag{using type=T;};
// a template that undoes the `tag` operation above:
template<class Tag>using type_t=typename Tag::type;
// a shorter way to say `std::integral_constant<size_t, x>`:
template<std::size_t i>struct index:std::integral_constant<std::size_t, i>{};
获取types<...>中的类型索引：
// this code takes a type T, and a types<...> and returns
// the index of the type in there.
// index_of
namespace details {
template<class T, class Types>
struct index_of{};
}
template<class T, class Types>
using index_of_t=type_t<details::index_of<T,Types>>;
namespace details {
// if the first entry in the list of types is T,
// our value is 0
template<class T, class...Ts>struct index_of<T, types<T,Ts...>>:
tag< index<0> >
{};
// otherwise, it is 1 plus our value on the tail of the list:
template<class T, class T0, class...Ts>
struct index_of<T, types<T0, Ts...>>:
tag< index< index_of_t<T,types<Ts...>{}+1 > >
{};
}
这是一个单一的“频道”广播公司（它发送一种消息）：
// a token is a shared pointer to anything
// below, it tends to be a shared pointer to a std::function
// all we care about is the lifetime, however:
using token = std::shared_ptr<void>;
template<class M>
struct broadcaster {
// f is the type of something that can eat our message:
using f = std::function< void(M) >;
// we keep a vector of weak pointers to people who can eat
// our message. This lets them manage lifetime independently:
std::vector<std::weak_ptr<f>> listeners;
// reg is register. You pass in a function to eat the message
// it returns a token. So long as the token, or a copy of it,
// survives, broadcaster will continue to send stuff at the
// function you pass in:
token reg( f target ) {
// if thread safe, (write)lock here
auto sp = std::make_shared<f>(std::move(target));
listeners.push_back( sp );
return sp;
// unlock here
}
// removes dead listeners:
void trim() {
// if thread safe, (try write)lock here
// and/or have trim take a lock as an argument
listeners.erase(
std::remove_if( begin(listeners), end(listeners), [](auto&& p){
return p.expired();
} ),
listeners.end()
);
// unlock here
}
// Sends a message M m to every listener who is not dead:
void send( M m ) {
trim(); // remove dead listeners
// (read) lock here
auto tmp_copy = listeners; // copy the listeners, just in case
// unlock here
for (auto w:tmp_copy) {
auto p = w.lock();
if (p) (*p)(m);
}
}
};
这是一个多通道subject，可以支持任意数量的不同消息类型（在编译时确定）。如果您未能匹配消息类型，则send和/或reg将无法编译。您有责任决定邮件是const&还是值或其他什么。尝试reg rvalue消息将无法正常工作。旨在M明确传递给reg和send。
// fancy wrapper around a tuple of broadcasters:
template<class...Ts>
struct subject {
std::tuple<broadcaster<Ts>...> stations;
// helper function that gets a broadcaster compatible
// with a message type M:
template<class M>
broadcaster<M>& station() {
return std::get< index_of_t<M, types<Ts...>>{} >( stations );
}
// register a message of type M. You should call with M explicit usually:
template<class M>
token reg( std::function<void(M)> listener ) {
return station<M>().reg(std::move(listener));
}
// send a message of type M. You should explicitly pass M usually:
template<class M>
void send( M m ) {
station<M>().send(std::forward<M>(m));
}
};
当您reg时，它会返回token，即std::shared_ptr<void>。只要此令牌（或副本）存活，消息就会流动。如果它消失，则返回到reged回调的消息将结束。通常这意味着听众应该维护一个std::vector<token>和reg lambda，它们会毫不犹豫地使用this。
在C ++ 14 / 1z中，上面的内容有点好（我们可以取消types<...>和index_of）。
如果在广播周期中添加侦听器，则不会将其发送到。如果在广播周期中删除了一个监听器，则在删除它之后它将不会被发送到该监听器。
为广播公司的读写器锁定设置了线程安全注释。
在调用trim或send时，将回收为给定广播公司分配给死听众的内存。但是，std::function很久以前就已经被破坏了，因此在下一个send之前只浪费了有限的内存。我这样做，因为无论如何我们将迭代消息列表，不妨先清理任何混乱。
此解决方案没有RTTI或动态转换，只会将消息发送给理解它们的侦听器。
在c++17中，事情会变得更简单。删除所有元编程样板，删除subject（保留broadcaster）并执行此操作以处理多个频道：
template<class...Ms>
struct broadcasters : broadcaster<Ms>... {
using broadcaster<Ms>::reg...;
using broadcaster<Ms>::send...;
template<class M>
broadcaster<M>& station() { return *this; }
};
此broadcasters现在几乎在上面的subject上有所改善。
由于自c++11以来std::function的改进，reg函数通常做正确的事情，除非信号选项过于相似。如果您遇到reg或send的问题，则必须致电.station<type>().reg(blah)。
但99/100次你可以做一个.reg( lambda )和.send( msg )并且重载决议是正确的。
这是整个系统增加了模块化插入式线程安全系统：
struct not_thread_safe {
struct not_lock {~not_lock(){}};
auto lock() const { return not_lock{}; }
};
struct mutex_thread_safe {
auto lock() const { return std::unique_lock<std::mutex>(m); }
private:
mutable std::mutex m;
};
struct rw_thread_safe {
auto lock() { return std::unique_lock<std::shared_timed_mutex>(m); }
auto lock() const { return std::shared_lock<std::shared_timed_mutex>(m); }
private:
mutable std::shared_timed_mutex m;
};
template<class D, class>
struct derived_ts {
auto lock() { return static_cast<D*>(this)->lock(); }
auto lock() const { return static_cast<D const*>(this)->lock(); }
};
using token = std::shared_ptr<void>;
template<class M, class TS=not_thread_safe>
struct broadcaster:
TS
{
using f = std::function< void(M) >;
mutable std::vector<std::weak_ptr<f>> listeners;
token reg( f target )
{
auto l = this->lock();
auto sp = std::make_shared<f>(std::move(target));
listeners.push_back( sp );
return sp;
}
// logically const, but not really:
void trim() const {
auto l = const_cast<broadcaster&>(*this).lock();
auto it = std::remove_if( listeners.begin(), listeners.end(), [](auto&& p){
return p.expired();
} );
listeners.erase( it, listeners.end() );
}
// logically const, but not really:
void send( M m ) const
{
trim(); // remove dead listeners
auto tmp_copy = [this]{
auto l = this->lock();
return listeners; // copy the listeners, just in case
}();
for (auto w:tmp_copy) {
auto p = w.lock();
if (p) (*p)(m);
}
}
};
template<class TS, class...Ms>
struct basic_broadcasters :
TS,
broadcaster<Ms, derived_ts<basic_broadcasters<TS, Ms...>, Ms> >...
{
using TS::lock;
using broadcaster<Ms, derived_ts<basic_broadcasters<TS, Ms...>, Ms> >::reg...;
using broadcaster<Ms, derived_ts<basic_broadcasters<TS, Ms...>, Ms> >::send...;
template<class M>
broadcaster<M, derived_ts<basic_broadcasters<TS, Ms...>, M>>& station() { return *this; }
template<class M>
broadcaster<M, derived_ts<basic_broadcasters<TS, Ms...>, M>> const& station() const { return *this; }
};
template<class...Ms>
using broadcasters = basic_broadcasters<rw_thread_safe, Ms...>;
broadcasters<Messages...>现在是一个读写锁定广播类，它使用1个公共共享锁来同步每个广播队列。
basic_broadcasters<not_thread_safe, Messages...>创建一个没有锁定（即，不是线程安全）。
答案 1 :(得分：1)
我认为你应该坚持更简单的事情。如果所有观察者都处理所有消息，那么您必须有一个观察者类型。如果消息不相关，则每个观察者都只观察它处理的消息。
使用Boost :: Signal2的解决方案是：
#include <string>
#include <cstdio>
#include <iostream>
#include <functional>
#include <boost/signals2/signal.hpp>
class Subject
{
public:
void emit_message_a(int v) {
sig_a(v);
}
void emit_message_b(const std::string v) {
sig_b(v);
}
template<typename F>
void register_listener_a(const F &listener)
{
sig_a.connect(listener);
}
template<typename F>
void register_listener_b(const F &listener)
{
sig_b.connect(listener);
}
private:
boost::signals2::signal<void (int)> sig_a;
boost::signals2::signal<void (std::string)> sig_b;
};
class Observer
{
public:
Observer():
name("John")
{}
void observe(int v) {
std::cout << name << " has observed phoenomenon int: " << v << std::endl;
}
void observe(std::string v) {
std::cout << name << " has observed phoenomenon string: " << v << std::endl;
}
private:
std::string name;
};
int main()
{
Subject s;
Observer o;
s.register_listener_a([&](int v){o.observe(v);});
s.register_listener_b([&](std::string v){o.observe(v);});
s.register_listener_a([](int val) {
std::cout << "Received message a : " << val << std::endl;
});
s.register_listener_a([](int message_a) {
printf("I have received message a, too! It is %d.\n", message_a);
});
s.register_listener_b([](std::string msg) {
std::cout << "A B type message was received! Help!\n";
});
s.emit_message_a(42);
s.emit_message_b("a string");
s.emit_message_a(-1);
s.emit_message_b("another string");
}
运行它，我得到：
John has observed phoenomenon int: 42
Received message a : 42
I have received message a, too! It is 42.
John has observed phoenomenon string: a string
A B type message was received! Help!
John has observed phoenomenon int: -1
Received message a : -1
I have received message a, too! It is -1.
John has observed phoenomenon string: another string
A B type message was received! Help!
如果您打算使用它，请务必阅读the manual。