Calling a templatized std::function stored in a map - c++

Question

I'm attempting to create a base class that will store signals (in the form of an int) and allow me to later use them to call functions specified by the derived class. They are stored in an unordered_map because it's exactly what I need -- 1 signal = 1 function (plus it's fast).
Though, I'm having some trouble calling them, getting a huge error in the form of:
no match for call to ‘(std::unordered_map<int, std::function<void()>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<const int, std::function<void()> > > >::mapped_type {aka std::function<void()>}) (int&, int&)’
The compile-error is from signals_[_sig](args...);
const int SIGCHANGE = 1;
template<typename... Args>
class Signal {
private:
std::unordered_map< int, std::function<void(Args...)> > signals_;
inline void SetSignal(const int& _sig, std::function<void(Args...)> _func) {
signals_[_sig] = _func;
}
public:
Signal() {}
~Signal() {}
template<typename... Ts>
void Sig(const int& _sig, Ts... args) {
if (signals_.find(_sig) != signals_.end()) {
signals_[_sig](args...);
}
}
};
class Obj : public Signal<> {
private:
int num_;
public:
Obj* child;
void Change(int _num) {
num_ = _num;
child->Sig(SIGCHANGE, _num);
}
void HandleChanged(int _num) {
num_ = _num;
}
};
int main() {
Obj* obj1 = new Obj();
Obj* obj2 = new Obj();
obj1->child = obj2;
obj1->Change(10);
}
Also, I have no idea if I'm using the templates correctly - it's been ages since I last used them. Should each function have its own template? Why do I have to specify the template before the class if I want to use it for a member variable?

Answer 1

As you function has a single int parameter, you need to have
class Obj : public Signal<int>
instead of
class Obj : public Signal<>
The later creates a map with functions prototyped void(), whereas you need a function prototyped void(int).
Also, templatizing the Sig function is useless, because you will not be able to call it with any other set of parameters than Args anyway. So it can simply be
void Sig(const int& _sig, Args... args) {
if (signals_.find(_sig) != signals_.end()) {
signals_[_sig](args...);
}
}
If your goal is to support storing functions with arbitrary prototype, that does need to be done different way, basically via runtime polymorphism (all the items in the map need to be of the same type, so the type itself would need to do the call polymorphism under the hood).
EDIT
One possibility with function prototypes defined according to the signal type. Requires that the signal ints will always be passed as compile-time constants - the different functor for particular signal types are stored in std::tuple:
const int SIGZERO = 0;
const int SIGCHANGE = 1;
const int SIGOTHER = 2;
// non-specialized template intentionally left empty
// (or can provide default prototype)
template<int SIG>
struct SignalPrototype;
template<>
struct SignalPrototype<SIGZERO>
{
typedef std::function< void() > type;
};
template<>
struct SignalPrototype<SIGCHANGE>
{
typedef std::function< void(int) > type;
};
template<>
struct SignalPrototype<SIGOTHER>
{
typedef std::function< void(int, int) > type;
};
class Signal {
private:
std::tuple<
SignalPrototype<SIGZERO>::type,
SignalPrototype<SIGCHANGE>::type,
SignalPrototype<SIGOTHER>::type
> signals_;
protected:
template<int SIG>
inline void SetSignal(typename SignalPrototype<SIG>::type _func) {
std::get<SIG>(signals_) = _func;
}
public:
template<int SIG, typename... Ts>
void Sig(Ts... args) {
SignalPrototype<SIG>::type func = std::get<SIG>(signals_);
if (func)
func(args...);
}
};
struct MyHandler : SignalPrototype<SIGCHANGE>::type
{
void operator()(int x)
{
std::cout << "Called MyHandler with x = " << x << std::endl;
}
};
class Obj : public Signal {
private:
int num_;
public:
Obj* child;
Obj()
{
SetSignal<SIGCHANGE>(MyHandler());
}
void Change(int _num) {
num_ = _num;
child->Sig<SIGZERO>();
child->Sig<SIGCHANGE>(_num);
child->Sig<SIGOTHER>(1, 2);
}
void HandleChanged(int _num) {
num_ = _num;
}
};
(and in general, it could be actually better for Signal to be member of the Obj instead of inheritance)