<\/strong><\/p>\n
If a function templates forward its arguments without changing its lvalue or rvalue characteristics, we call it perfect forwarding.<\/p>\n
Great. But what are lvalues and rvalues? Now, I have to make a little detour.<\/p>\n
Lvalues and Rvalues<\/h2>\n
I will not discuss the details about lvalues and rvalues and introduce, therefore glvalues,<\/em> xvalues<\/em> ,and prvalues. <\/em>That’s not necessary. In case, you are curious, read the post from Anthony Williams: Core C++ – lvalues and rvalues. <\/a>I will provide in my post a sustainable intuition.<\/p>\n Rvalues<\/strong> are<\/p>\n If one of the characteristics holds for an object, it will be an rvalue. In reverse, that means that lvalues have a name and an address. Here are a few examples for rvalues:<\/p>\n <\/p>\n Rvalues are on the right side of an assignment. The value 5 and the constructor call are std::string(“Rvalue”)<\/span> rvalues because you can neither determine the address of the value 5 nor has the created string object a name. The same holds for the addition of the rvalues in the expression std::string(“R”) + std::string(“value”).<\/span><\/p>\n The addition of the two strings a + b<\/span> is interesting. Both strings are lvalues, but the addition creates a temporary object. A particular use case is std::move(b).<\/span> The new C++11 function converts the lvalue b into an rvalue reference. <\/span><\/p>\n Rvalues are on the right side of an assignment; lvalues can be on the left side of an assignment. But that is not always true:<\/p>\n <\/p>\n <\/p>\n Although variable five is an lvalue. But five is constant, and you can not use it on the left side of an assignment. <\/span><\/p>\n But now to the challenge of this post: Perfect forwarding. To get an intuition for the unsolved problem, I will create a few perfect<\/em> factory methods.<\/p>\n<\/p>\n First, a short disclaimer. The expression a perfect factory method is no formal term.<\/p>\n A perfect factory method<\/strong> is, for me, a generic factory method. In particular, that means that the function should have the following characteristics:<\/p>\n I want to say it less formally. A perfect factory method should be able to create each arbitrary object.<\/p>\n Let’s start with the first iteration.<\/p>\n For efficiency reasons, the function template should take its arguments by reference. To say it exactly. As a non-constant lvalue reference. Here is the function template create<\/span> in my first iteration. <\/p>\n <\/p>\n <\/p>\n If I compile the program, I will get a compiler error. The reason is that the rvalue (line 21) can not be bound to a non-constant lvalue reference.<\/p>\n Now, I have two ways to solve the issue.<\/p>\n Here is the factory method create<\/span> overloaded for a constant lvalue reference and a non-constant lvalue reference.<\/p>\n <\/p>\n <\/p>\n <\/p>\n The program produces the expected result.<\/p>\n That was easy. Too easy. The solution has two conceptual issues.<\/p>\n <\/p>\n Now, I have the solution in the shape of the C++ function std::forward.<\/span><\/p>\n With std::forward,<\/span> the solution looks promising.<\/p>\n <\/p>\n\n
int<\/span> five= 5;\r\nstd::string a= std::string(\"Rvalue\"<\/span>);\r\nstd::string b= std::string(\"R\"<\/span>) + std::string(\"value\"<\/span>);\r\nstd::string c= a + b;\r\nstd::string d= std::move(b);
\r\n<\/pre>\n<\/div>\nconst<\/span> int<\/span> five= 5;\r\nfive= 6;\r\n<\/pre>\n<\/div>\nA perfect factory method<\/h2>\n
\n
First iteration<\/h3>\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<\/pre>\n<\/td>\n
\n \/\/ perfectForwarding1.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T,typename<\/span> Arg>\r\nT create(Arg& a){\r\n return<\/span> T(a);\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n \r\n std::cout << std::endl;\r\n\r\n \/\/ Lvalues<\/span>\r\n int<\/span> five=5;\r\n int<\/span> myFive= create<int<\/span>>(five);\r\n std::cout << \"myFive: \"<\/span> << myFive << std::endl;\r\n\r\n \/\/ Rvalues<\/span>\r\n int<\/span> myFive2= create<int<\/span>>(5);\r\n std::cout << \"myFive2: \"<\/span> << myFive2 << 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![\"perfectForwarding1\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/12\/perfectForwarding1.png\")
<\/p>\n\n
Second iteration<\/h3>\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<\/pre>\n<\/td>\n
\n \/\/ perfectForwarding2.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T,typename<\/span> Arg>\r\nT create(Arg& a){\r\n return<\/span> T(a);\r\n}\r\n\r\ntemplate<\/span> <typename<\/span> T,typename<\/span> Arg>\r\nT create(const<\/span> Arg& a){\r\n return<\/span> T(a);\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n std::cout << std::endl;\r\n\r\n \/\/ Lvalues<\/span>\r\n int<\/span> five=5;\r\n int<\/span> myFive= create<int<\/span>>(five);\r\n std::cout << \"myFive: \"<\/span> << myFive << std::endl;\r\n\r\n \/\/ Rvalues<\/span>\r\n int<\/span> myFive2= create<int<\/span>>(5);\r\n std::cout << \"myFive2: \"<\/span> << myFive2 << 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![\"perfectForwarding2\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/12\/perfectForwarding2.png\")
<\/p>\n\n
Third iteration<\/h3>\n
![\"perfectForwarding4\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/12\/perfectForwarding4.png\")
<\/p>\n