2
这是this question的后续行动，我鼓励我在可变模板运算符（）（...）实现中使用完美转发。这里，我想用调用free函数和成员函数具有可变参数我的观察者模式：完美的转发导致错误我不明白
#ifndef _SIGNALS_H_
#define _SIGNALS_H_
#include <utility>
/** Interface for delegates with a specific set of arguments **/
template<typename... args>
class AbstractDelegate
{
public:
virtual void operator()(args&&...) const = 0;
virtual ~AbstractDelegate() {}
};
/** Concrete function delegate that discards the function's return value **/
template<typename ReturnType, typename... args>
class FnDelegate : public AbstractDelegate<args...>
{
public:
/** member function typedef **/
using Fn = ReturnType(*)(args...);
/** constructor **/
FnDelegate(Fn fn)
: fn_{fn}
{
}
/** call operator that calls the stored function **/
void operator()(args&&... a) const override
{
(*fn_)(std::forward<args>(a)...);
}
private:
/** function pointer **/
const Fn fn_;
};
/** forward declaration **/
template<typename... args>
class Connection;
/** Signal class that can be connected to**/
template<typename... args>
class Signal
{
public:
/** connection pointer typedef **/
typedef Connection<args...>* connection_p;
/** constructor **/
Signal()
: connections_(NULL),
blocked_(false)
{
}
/** call operator that notifes all connections associated with this Signal.
The most recently associated connection will be notified first **/
void operator()(args&&... a) const
{
// only notify connections if this signal is not blocked
if (!blocked())
{
auto c = connections_;
while(c != NULL)
{
(*c)(std::forward<args>(a)...);
c = c->next();
}
}
}
/** connect to this signal **/
void connect(connection_p p)
{
p->next_ = connections_;
connections_ = p;
p->signal_ = this;
}
/** disconnect from this signal.
Invalidates the connection's signal pointer
and removes the connection from the list **/
void disconnect(connection_p conn)
{
// find connection and remove it from the list
connection_p c = connections_;
if (c == conn)
{
connections_ = connections_->next();
conn->next_ = NULL;
conn->signal_ = NULL;
return;
}
while(c != NULL)
{
if (c->next() == conn)
{
c->next_ = conn->next();
conn->next_ = NULL;
conn->signal_ = NULL;
return;
}
c = c->next();
}
}
/** block events from this signal **/
void block()
{
blocked_ = true;
}
/** unblock events from this signal **/
void unblock()
{
blocked_ = false;
}
/** is this signal blocked? **/
bool blocked() const
{
return blocked_;
}
/** destructor. disconnects all connections **/
~Signal()
{
connection_p p = connections_;
while(p != NULL)
{
connection_p n = p->next();
disconnect(p);
p = n;
}
}
connection_p connections() const {return connections_;}
private:
connection_p connections_;
bool blocked_;
};
/** connection class that can be connected to a signal **/
template<typename... args>
class Connection
{
public:
/** template constructor for static member functions and free functions.
allocates a new delegate on the heap **/
template<typename ReturnType>
Connection(Signal<args...>& signal, ReturnType (*Fn)(args...))
: delegate_(new FnDelegate<ReturnType, args...>(Fn)),
signal_(NULL),
next_(NULL),
blocked_(false)
{
signal.connect(this);
}
/** get reference to this connection's delegate **/
AbstractDelegate<args...>& delegate() const
{
return *delegate_;
}
/** call this connection's delegate if not blocked **/
void operator()(args&&... a) const
{
if (!blocked())
{
delegate()(std::forward<args>(a)...);
}
}
/** get pointer to next connection in the signal's list **/
Connection* next() const
{
return next_;
}
/** is this connection connected to a valid signal? **/
bool connected() const
{
return (signal_ != NULL);
}
/** block events for this connection **/
void block()
{
blocked_ = true;
}
/** unblock events for this connection **/
void unblock()
{
blocked_ = false;
}
/** is this connection blocked? **/
bool blocked() const
{
return blocked_;
}
/** desctructor. If the signal is still alive, disconnects from it **/
~Connection()
{
if (signal_ != NULL)
{
signal_->disconnect(this);
}
delete delegate_;
}
const Signal<args...>* signal() const {return signal_;}
friend class Signal<args...>;
private:
AbstractDelegate<args...>* delegate_;
Signal<args...>* signal_;
Connection* next_;
bool blocked_;
};
/** free connect function: creates a connection (static member or free function) on the heap
that can be used anonymously **/
template<typename ReturnType, typename... args>
Connection<args...>* connect(Signal<args...>& signal, ReturnType (*fn)(args...))
{
return new Connection<args...>(signal, fn);
}
#endif // _SIGNALS_H_
我试图使用它在这些方面：
Signal<int> sig;
void print(int i)
{
std::cout << "print(" << i << ")" << std::endl;
}
int get(int i)
{
return i;
}
int main()
{
connect(sig, print);
sig(3);
int i = 4;
sig(i); // <-- here I get an error
sig(get(5));
}
我得到的错误是
main.cpp: In function ‘int main()’:
main.cpp:21:10: error: cannot bind ‘int’ lvalue to ‘int&&’
sig(i);
^
In file included from main.cpp:2:0:
main.h:89:10: error: initializing argument 1 of ‘void Signal<args>::operator()(args&& ...) const [with args = {int}]’
void operator()(args&&... a) const
^
的误差消失，当我用const int&无处不在，即Signal<const int&> sig和void print(const int&)，但我不明白为什么。此外，在“标志”信号的情况下，通过const bool&会感到尴尬。
你能提出一个解决方案，可以在这里提供更多的灵活性吗？
由于它直接基于@ Morwenn在原始问题中的回答，因此我在那里评论过。 –
你的'sig :: operator（）'不使用完美转发。为了完美的转发工作，您需要模板类型推导，这意味着您有一个函数模板（其中类型可以从参数表达式中推导出来）。 'operator（）'不是函数模板。 – dyp
如果您删除了与此问题无关的所有内容（比如您未调用的函数），那么您的代码将更容易遵循。 – celtschk