Functors in static global arrays - c++

Question

I've been trying to figure out how to properly pair a function with an id. What I've been doing so far is a C-way of doing it:
#include <iostream>
void PrintA();
void PrintB();
struct Function
{
int id;
void (*function)();
};
static const Function functions[] =
{
{1, PrintA},
{2, PrintB},
{0, 0}
};
void PrintA()
{
std::cout << "A" << std::endl;
};
void PrintB()
{
std::cout << "B" << std::endl;
};
int main()
{
int id = 1;
for(int i = 0; functions[i].function != 0 ; i++)
{
if(functions[i].id == id)
{
functions[i].function();
}
}
}
I'm trying to achieve the same functionality using functors in C++. I suppose I need to use inheritance to be able to store the different functions in the same array meaning I also need to use pointers for the array in order to prevent slicing. Is the following way of doing this the correct way and are there any alternatives?
Also is there any simpler version to call the operator than how I did it?
#include <iostream>
#include <memory>
class Base
{
public:
virtual void operator()() = 0;
};
class PrintA : public Base
{
public:
void operator()();
};
void PrintA::operator()()
{
std::cout << "A" << std::endl;
}
class PrintB : public Base
{
public:
void operator()();
};
void PrintB::operator()()
{
std::cout << "B" << std::endl;
}
struct Functor
{
int id;
std::shared_ptr<Base> function;
};
static Functor functors[] =
{
{1, std::shared_ptr<Base>(new PrintA)},
{2, std::shared_ptr<Base>(new PrintB)},
{0, 0}
};
int main()
{
int id = 2;
for(int i = 0; functors[i].function != 0 ; i++)
{
if(functors[i].id == id)
{
functors[i].function->operator()();
}
}
}
EDIT: I have to use a rather old GCC version making it impossible to use c++11 features. Boost is available, though. I suppose an std::map would be a good idea, but what I was really asking (didn't really make it clear) was that is there a better way to store the functions than shared_ptr. I suppose that std::function/boost::function way is the way to do it.

Answer 1

In C++11 (or Boost, if you're stuck in the past), this kind of type erasure is available in the function wrapper; and there's always been map to perform the ID-based lookup. So your example is as simple as:
#include <map>
#include <functional>
#include <iostream>
// Note: This will be a lot messier if you're stuck with a pre-2011 compiler.
// You'll need to define the functors (or functions) separately, and either
// initialise the map with the result of a function call (possibly using
// Boost.Assign), or write some code somewhere else to populate it.
//
// Or use an array, with lookup code like your C implementation.
std::map<int, std::function<void()>> functors {
{1, [](){std::cout << "A" << std::endl;}},
{2, [](){std::cout << "B" << std::endl;}}
};
int main() {
functors[2]();
}
As noted in the comments, if the real situation is as simple as the example, you could use a function pointer rather than function (and still initialise it with a lambda, if you like), and an array (indexed by id) rather than a map. My example assumes that you want a more general solution, mapping arbitrary values to arbitrary functors.

Answer 2

Simple:
#include <functional>
#include <iostream>
#include <vector>
void sayA() { std::cout << "A" << std::endl; }
void sayB() { std::cout << "B" << std::endl; }
struct Foo
{
explicit Foo(int i) : i_(i) {}
void operator()() const { std::cout << "foo " << i_<< "!" << std::endl; }
int i_;
};
std::vector<std::function<void()>> funcs{ sayA, sayB, Foo(42) };
int main()
{
for (const auto& f : funcs) f();
}