![\"CharakteristikenFunktionaleProgrammierungFirstClassFunctionsEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/CharakteristikenFunktionaleProgrammierungFirstClassFunctionsEng.png\")
<\/p>\nOne of the characteristics of functional programming is first-class functions. First-class functions behave like data and are heavily used in the Standard Template Library.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Do first-class functions behave like data? What does that mean?<\/p>\n
First-class functions can be<\/p>\n
std::accumulate(vec.begin(), vec.end(), 1, []{ int<\/span> a, int<\/span> b}{ return<\/span> a * b; })<\/p>\n One short remark on the second point. The function makeAdd<\/span> returns the lambda function [](int a, int b){ return a + b; }<\/span>. This function needs two int<\/span> arguments and returns an int<\/span> value: std::function<int(int,int)><\/span>. You can bind the return value of makeAdd<\/span> to the generic function wrapper myAdd<\/span> and execute it.<\/span><\/span><\/span> <\/span><\/p>\n My post Functional in C++11 and C++14: Dispatch Table and Generic Lambdas show which power lies in first-class functions. <\/a> Have a look at the dispatch table in C++.<\/p>\n Function pointers are the first-class functions of the poor man. Even C has function pointers. C++ goes a few steps further. In particular, you can connect the evolution of the function concept with the evolution of C++.<\/p>\n<\/p>\n Simplified, evolution consists of four steps.<\/p>\n C knows functions. C++ added function objects. These are objects which behave like functions because their call operator is overloaded. C++11 added lambda functions; C++14 made them generic. Each step made functions in C++ even more powerful.<\/p>\n Admittedly, that was a lot of theory. Therefore, the example is following right now. Here are the four steps of the function concepts in C++.<\/p>\n <\/p>\n <\/p>\n The program begins with the function addMe<\/span> (line 8 – 10), the function object AddMe<\/span> (line 12 – 23), the lambda function (line 45 and 51), and the generic lambda function in line 59, 63, and 64. The program’s purpose is to concatenate the strings of the vector myString (line 27) in different ways with the help of the algorithm std::accumulate.<\/span> Therefore, it is pretty comfortable that std::accumulate<\/span> is a higher-order function (wait for my next post) and can accept first-class functions. I use a function pointer, a function object, and a (generic) lambda function as the first-class function.<\/p>\n I apply in line 29 the function pointer addMe.<\/span> The function objects AddMe<\/span> and AddMe(:)<\/span> (lines 35 and 39) are more comfortable to use because I can parametrize the glue between the strings. The lambda functions offer the same comfort (lines 45 and 51). In particular, the lambda function lambdaFunc<\/span> uses a copy of the variable glue<\/span> (line 49). Therefore, the lambda function is a closure. The generic lambda function [glue](auto fir, auto sec){ return fir + glue + sec; })<\/span> (line 59) is the most interesting one. As closure, they also use variable glue.<\/span> I apply the generic lambda function<\/span> lambdaFuncGeneric<\/span> to a std::vector<std::string> (line 27) <\/span>and a <\/span>std::vector<int><\/span> (line 69). In the case of std::vector<int><\/span>, the result is 55.<\/p>\n In the end, the output of the program.<\/p>\n The evolution will not end with C++14. In C++20, we get high-probability coroutines, which generalize functions. Coroutines can be suspended and resumed. I will write a post about it. So, stay tuned. For didactical reasons, I used std::accumulate<\/span> to add pairs of elements together. That can be done much more straightforward – even for generic lambda functions – because std::accumulate has a simple version that needs no callable. The simple version adds their elements together, starting with the first element. Therefore, I can write line 65 a lot simpler: auto fromLambdaFuncGeneric1= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}). <\/span>The same holds for fromLambdaFuncGeneric2<\/span><\/span>. <\/span><\/p>\n\n
<\/strong><\/li>\n<\/ul>\n std::function<int<\/span>(int<\/span>, int<\/span>)> makeAdd(){\r\n return<\/span> [](int<\/span> a, int<\/span> b){ return<\/span> a + b; };\r\n }\r\n std::function<int<\/span>(int<\/span>, int<\/span>)> myAdd= makeAdd();\r\n myAdd(2000, 11); \/\/ 2011<\/span><\/samp><\/code><\/pre>\n\n
<\/strong><\/li>\n<\/ul>\nThe evolution of the function concept<\/h2>\n
![\"FunctionEvolutionEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/FunctionEvolutionEng.png\")
<\/p>\n\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\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67\r\n68\r\n69\r\n70\r\n71\r\n72\r\n73\r\n74\r\n75<\/pre>\n<\/td>\n
\n \/\/ evolutionOfFunctions.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <numeric><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::string addMe(std::string fir, std::string sec){\r\n return<\/span> fir + \" \"<\/span> + sec;\r\n};\r\n\r\nstruct<\/span> AddMe{\r\n \r\n AddMe()= default<\/span>;\r\n AddMe(std::string gl): glue(gl) {}\r\n \r\n std::string operator<\/span>()(std::string fir, std::string sec) const<\/span> {\r\n return<\/span> fir + glue + sec;\r\n }\r\n \r\n std::string glue= \" \"<\/span>;\r\n \r\n};\r\n\r\nint<\/span> main(){\r\n \r\n std::vector<std::string> myStrings={\"The\"<\/span>, \"evolution\"<\/span>, \"of\"<\/span>, \"the\"<\/span>, \"function\"<\/span>, \"concept\"<\/span>, \"in\"<\/span>, \"C++.\"<\/span>};\r\n \r\n std::string fromFunc= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, addMe);\r\n \r\n std::cout << fromFunc << std::endl;\r\n \r\n std::cout << std::endl;\r\n \r\n std::string fromFuncObj= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, AddMe());\r\n \r\n std::cout << fromFuncObj << std::endl;\r\n \r\n std::string fromFuncObj2= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, AddMe(\":\"<\/span>));\r\n \r\n std::cout << fromFuncObj2 << std::endl;\r\n \r\n std::cout << std::endl;\r\n \r\n std::string fromLambdaFunc= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, [](std::string fir, std::string sec){ return<\/span> fir + \" \"<\/span> + sec; });\r\n \r\n std::cout << fromLambdaFunc << std::endl;\r\n \r\n std::string glue=\":\"<\/span>;\r\n \r\n auto<\/span> lambdaFunc= [glue](std::string fir, std::string sec){ return<\/span> fir + glue + sec; };\r\n \r\n std::string fromLambdaFunc2= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, lambdaFunc);\r\n \r\n std::cout << fromLambdaFunc2 << std::endl;\r\n \r\n std::cout << std::endl;\r\n \r\n std::string fromLambdaFuncGeneric= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, [glue](auto<\/span> fir, auto<\/span> sec){ return<\/span> fir + glue + sec; });\r\n \r\n std::cout << fromLambdaFuncGeneric << std::endl;\r\n \r\n auto<\/span> lambdaFuncGeneric= [](auto<\/span> fir, auto<\/span> sec){ return<\/span> fir + sec; };\r\n \r\n auto<\/span> fromLambdaFuncGeneric1= std::accumulate(myStrings.begin(), myStrings.end(), std::string{}, lambdaFuncGeneric);\r\n \r\n std::cout << fromLambdaFuncGeneric1 << std::endl;\r\n \r\n std::vector<int<\/span>> myInts={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\r\n \r\n auto<\/span> fromLambdaFuncGeneric2= std::accumulate(myInts.begin(), myInts.end(), int<\/span>{}, lambdaFuncGeneric);\r\n \r\n std::cout << fromLambdaFuncGeneric2 << std::endl;\r\n \r\n}<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n![\"evolutionOfFunctions\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/evolutionOfFunctions.png\")
<\/p>\n
<\/em><\/p>\nBut that can be done more easily<\/h3>\n
What’s next?<\/h2>\n