{"id":5134,"date":"2017-01-19T06:58:34","date_gmt":"2017-01-19T06:58:34","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/functional-in-c-dispatch-table\/"},"modified":"2023-06-26T12:26:41","modified_gmt":"2023-06-26T12:26:41","slug":"functional-in-c-dispatch-table","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/functional-in-c-dispatch-table\/","title":{"rendered":"Functional in C++11 and C++14: Dispatch Table and Generic Lambdas"},"content":{"rendered":"

My favorite example, the dispatch table, shows how nicely the features in modern C++ work together. A dispatch table <\/a>is a table of pointers to functions. In my case, it is a table of handles for polymorphic function wrappers.<\/p>\n

<\/p>\n

 <\/p>\n

But at first, what do I mean by modern C++? I use the dispatch table features from C++11. I added this post, C++14, to the timeline. Why? You will see it later.<\/p>\n

\"timeline.FunktionalInCpp11Cpp14Eng\"<\/p>\n

Dispatch table<\/h2>\n

Thanks to Arne Mertz<\/a>, I used the C++11 features uniform initialization in combination with an initializer list. That further improved the following example.<\/em><\/p>\n

The example shows a simple dispatch table that maps characters to function objects.<\/em><\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31<\/pre>\n<\/td>\n
\n
\/\/ dispatchTable.cpp<\/span>\r\n\r\n#include <cmath><\/span>\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n#include <map><\/span>\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  \/\/ dispatch table<\/span>\r\n  std::map< const<\/span> char<\/span> , std::function<double<\/span>(double<\/span>,double<\/span>)> > dispTable{\r\n    {'+'<\/span>,[](double<\/span> a, double<\/span> b){ return<\/span> a + b;} },\r\n    {'-'<\/span>,[](double<\/span> a, double<\/span> b){ return<\/span> a - b;} },\r\n    {'*'<\/span>,[](double<\/span> a, double<\/span> b){ return<\/span> a * b;} },\r\n    {'\/'<\/span>,[](double<\/span> a, double<\/span> b){ return<\/span> a \/ b;} } };\r\n\r\n  \/\/ do the math<\/span>\r\n  std::cout << \"3.5+4.5= \"<\/span> << dispTable['+'<\/span>](3.5,4.5) << std::endl;\r\n  std::cout << \"3.5-4.5= \"<\/span> << dispTable['-'<\/span>](3.5,4.5) << std::endl;\r\n  std::cout << \"3.5*4.5= \"<\/span> << dispTable['*'<\/span>](3.5,4.5) << std::endl;\r\n  std::cout << \"3.5\/4.5= \"<\/span> << dispTable['\/'<\/span>](3.5,4.5) << std::endl;\r\n\r\n  \/\/ add a new operation<\/span>\r\n  dispTable['^'<\/span>]=  [](double<\/span> a, double<\/span> b){ return<\/span> std::pow(a,b);};\r\n  std::cout << \"3.5^4.5= \"<\/span> << dispTable['^'<\/span>](3.5,4.5) << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n};\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
How does the magic work? The dispatch table is, in my case, a std::map<\/span> that contains pairs of const char<\/span> and std::function<double(double, double)<\/span>. Of course, you can use a std::unordered_map<\/span> instead of a std::map. std::function<\/span> is a so-called polymorphic function wrapper. Thanks to std::function<\/span>, it can take all that behaves like a function. This can be a function, a function object, or a lambda function (lines 14 -17). The only requirements of std::function<double(double, double)><\/span> are that its entities need two double<\/span> arguments and return a double<\/span> argument. The lambda functions fulfill this requirement.<\/p>\n
I use the function object in lines 20 – 23. Therefore, the call of dispTable[‘+’] <\/span>in line 20 returns that function object, which was initialized by the lambda function [](double a, double b){ return a + b; }<\/span> (line 14). To execute the function object, two arguments are needed. I use them in the expression dispTable[‘+’](3.5, 4.5).<\/span><\/p>\n
A std::map<\/span> is a dynamic data structure. Therefore, I can add and use the ‘^’<\/span> operation (line 27) at runtime. Here is the calculation.<\/p>\n
\"dispatchTable\"<\/p>\n
Still, a short explanation is missing. Why is this my favorite example in C++?<\/p>\n<\/p>\n
Like in Python<\/h3>\n
I often give Python seminars. A dispatch table is one of my favorite examples to motivate the easy usage of Python. That is, by the way, the reason why Python needs no case statement.<\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20<\/pre>\n<\/td>\n
\n
# dispatchTable.py<\/span>\r\n\r\ndispTable={\r\n  \"+\"<\/span>: (lambda<\/span> x, y: x+y),\r\n  \"-\"<\/span>: (lambda<\/span> x, y: x-y),  \r\n  \"*\"<\/span>: (lambda<\/span> x, y: x*y),\r\n  \"\/\"<\/span>: (lambda<\/span> x, y: x\/y)\r\n}\r\n\r\nprint<\/span>\r\n\r\nprint<\/span> \"3.5+4.5= \"<\/span>, dispTable['+'<\/span>](3.5, 4.5)\r\nprint<\/span> \"3.5-4.5= \"<\/span>, dispTable['-'<\/span>](3.5, 4.5)\r\nprint<\/span> \"3.5*4.5= \"<\/span>, dispTable['*'<\/span>](3.5, 4.5)\r\nprint<\/span> \"3.5\/4.5= \"<\/span>, dispTable['\/'<\/span>](3.5, 4.5)\r\n\r\ndispTable['^'<\/span>]= lambda<\/span> x, y: pow(x,y)\r\nprint<\/span> \"3.5^4.5= \"<\/span>, dispTable['^'<\/span>](3.5, 4.5)\r\n\r\nprint<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The implementation is based on the functional features of Python. Thanks to std::map,<\/span> std::function,<\/span> and lambda-functions, I can now use the same example in C++11 to emphasize the expressive power of C++. A fact I would not have dreamed of ten years ago.<\/p>\n
\"dispatchTablePython\" <\/p>\n
Generic lambda-functions<\/h2>\n
I almost forgot it. Lambda functions become more potent with C++14. Lambda function can automatically deduce the types of its arguments. The feature is based on automatic type deduction with auto.<\/span> Of course, lambda functions and automatic type deduction are characteristics of functional programming.<\/p>\n
 <\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29<\/pre>\n<\/td>\n
\n
\/\/ generalizedLambda.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <typeinfo><\/span>\r\n\r\nint<\/span> main(){\r\n    \r\n  std::cout << std::endl;\r\n  \r\n  auto<\/span> myAdd= [](auto<\/span> fir, auto<\/span> sec){ return<\/span> fir+sec; };\r\n  \r\n  std::cout << \"myAdd(1, 10)= \"<\/span> << myAdd(1, 10) << std::endl;\r\n  std::cout << \"myAdd(1, 10.0)= \"<\/span> << myAdd(1, 10.0) << std::endl;\r\n  std::cout << \"myAdd(std::string(1),std::string(10.0)= \"<\/span> \r\n            <<  myAdd(std::string(\"1\"<\/span>),std::string(\"10\"<\/span>)) << std::endl;\r\n  std::cout << \"myAdd(true, 10.0)= \"<\/span> << myAdd(true, 10.0) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"typeid(myAdd(1, 10)).name()= \"<\/span> << typeid<\/span>(myAdd(1, 10)).name() << std::endl;\r\n  std::cout << \"typeid(myAdd(1, 10.0)).name()= \"<\/span> << typeid<\/span>(myAdd(1, 10.0)).name() << std::endl;\r\n  std::cout << \"typeid(myAdd(std::string(1), std::string(10))).name()= \"<\/span> \r\n            << typeid<\/span>(myAdd(std::string(\"1\"<\/span>), std::string(\"10\"<\/span>))).name() << std::endl;\r\n  std::cout << \"typeid(myAdd(true, 10.0)).name()= \"<\/span> << typeid<\/span>(myAdd(true, 10.0)).name() << std::endl;\r\n    \r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
In line 11, I use the generic lambda function. This function can be invoked with arbitrary types for its arguments fir<\/span> and second<\/span> and deduces in addition automatically its return type. To use the lambda function, I gave the lambda function the name myAdd.<\/span> Line 13 – 17 shows the application of the lambda function. Of course, I’m interested in which type the compiler derives for the return type. For that, I use the typeid<\/span> operator in lines 21 -25. This operator needs the header <typeinfo>.<\/span><\/p>\n
The typeid<\/span> operator is not so reliable. It returns a C string, which depends on the implementation. You have not guaranteed that the C string is different for different types nor that the C string is the same for each program invocation. But for our use case, the typeid<\/span> operator is reliable enough.<\/p>\n
My desktop PC is broken. Therefore I execute the program at cppreference.com.<\/a><\/p>\n
\"generalizedLambdaFunctions\"<\/p>\n
The output shows the different return types. The C string i<\/span> and d<\/span> stands for the types int<\/span> and double.<\/span> The type of the C++ strings is not so good readable. But you can see that std::string<\/span> is an alias for std::basic_string. <\/span><\/p>\n
What’s next?<\/h2>\n
In the next post<\/a>, I will write about the near and distant functional future of C++. With C++17 and C++20, the functional aspect of C++ becomes more powerful.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
My favorite example, the dispatch table, shows how nicely the features in modern C++ work together. A dispatch table is a table of pointers to functions. In my case, it is a table of handles for polymorphic function wrappers.<\/p>\n","protected":false},"author":21,"featured_media":5130,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[365],"tags":[472,459,412],"class_list":["post-5134","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-functional","tag-associative-containers","tag-lambdas","tag-python"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5134","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5134"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5134\/revisions"}],"predecessor-version":[{"id":6897,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5134\/revisions\/6897"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5130"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5134"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5134"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5134"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}