Méthode 1 :
Code:
enum op_code
{
DO_OPERATION_1 = 6,
DO_OPERATION_2 = 12,
DO_OPERATION_6 = 12,
DO_OPERATION_BLA = 7,
DO_OPERATION_UNBOUND = 8,
};
namespace enums
{
// declaration of the enum values in an MPL vector
template<> struct get_values< op_code > { typedef boost::mpl::vector_c< op_code, DO_OPERATION_1, DO_OPERATION_2, DO_OPERATION_BLA, DO_OPERATION_UNBOUND > type; };
// declaration of the handlers signatures for our enum
template<> struct get_signature< op_code > { typedef signature< void, std::string const&, std::string const& > type; };
}
// declaration of the handlers and binding to the dispatcher
void do_opcode_1(std::string const& param1, std::string const& param2) { std::cout << "doing opcode 1" << std::endl; }
template<> enums::signature_of< op_code > const& enums::get_handler< op_code, DO_OPERATION_1 >::type::value = do_opcode_1;
void do_opcode_2(std::string const& param1, std::string const& param2) { std::cout << "doing opcode 2" << std::endl; }
template<> enums::signature_of< op_code > const& enums::get_handler< op_code, DO_OPERATION_2 >::type::value = do_opcode_2;
void do_opcode_bla(std::string const& param1, std::string const& param2) { std::cout << "doing opcode bla" << std::endl; }
template<> enums::signature_of< op_code > const& enums::get_handler< op_code, DO_OPERATION_BLA >::type::value = do_opcode_bla;
Méthode 2 :
Code:
std::unordered_map<op_code, void (*)(const std::string&, const std::string&)>
tableau = {
{ DO_OPERATION_1, &do_opcode_1 },
{ DO_OPERATION_2, &do_opcode_2 },
{ DO_OPERATION_BLA, &do_opcode_bla }
};
Donc d'après toi si les gens préfèrent la méthode 2 c'est parce qu'ils n'ont pas pris conscience de la puissance que pouvait leur apporter la métaprogrammation ?
Je troll un peu, mais 99.9 % des codes utilisant la métaprogrammation à outrance ont un équivalent infiniment plus simple et très légèrement plus lent.
Personnellement j'ai jamais utilisé boost.lambda bien que je connaissais son existance, tout simplement à cause de la syntaxe dégeulasse. Quand les lambdas sont arrivés en C++11 je les ai utilisés day1 sur la première version de gcc qui les supportait.
C'est pas une question de peur ou de méconnaissance, c'est juste que c'est mieux quand c'est plus simple et plus propre.