\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<\/pre>\n<\/td>\n\n\/\/ average.cpp<\/span>\r\n\r\n#include <distance.h><\/span>\r\n#include <unit.h><\/span>\r\n\r\nusing<\/span> namespace<\/span> Distance::Unit;\r\n\r\nint<\/span> main(){\r\n\r\n std:: cout << std::endl;\r\n\r\n std::cout << \"1.0_km: \"<\/span> << 1.0_km << std::endl;\r\n std::cout << \"1.0_m: \"<\/span> << 1.0_m << std::endl;\r\n std::cout << \"1.0_dm: \"<\/span> << 1.0_dm << std::endl;\r\n std::cout << \"1.0_cm: \"<\/span> << 1.0_cm << std::endl;\r\n \r\n std::cout << std::endl;\r\n\r\n std::cout << \"0.001 * 1.0_km: \"<\/span> << 0.001 * 1.0_km << std::endl;\r\n std::cout << \"10 * 1_dm: \"<\/span> << 10 * 1.0_dm << std::endl;\r\n std::cout << \"100 * 1.0cm: \"<\/span> << 100 * 1.0_cm << std::endl;\r\n std::cout << \"1_km \/ 1000: \"<\/span> << 1.0_km \/ 1000 << std::endl;\r\n\r\n std::cout << std::endl;\r\n std::cout << \"1.0_km + 2.0_dm + 3.0_dm + 4.0_cm: \"<\/span> << 1.0_km + 2.0_dm + 3.0_dm + 4.0_cm << std::endl;\r\n std::cout << std::endl;\r\n \r\n auto<\/span> work= 63.0_km;\r\n auto<\/span> workPerDay= 2 * work;\r\n auto<\/span> abbrevationToWork= 5400.0_m;\r\n auto<\/span> workout= 2 * 1600.0_m;\r\n auto<\/span> shopping= 2 * 1200.0_m;\r\n \r\n auto<\/span> distPerWeek1= 4*workPerDay-3*abbrevationToWork+ workout+ shopping;\r\n auto<\/span> distPerWeek2= 4*workPerDay-3*abbrevationToWork+ 2*workout;\r\n auto<\/span> distPerWeek3= 4*workout + 2*shopping;\r\n auto<\/span> distPerWeek4= 5*workout + shopping;\r\n\r\n std::cout << \"distPerWeek1: \"<\/span> << distPerWeek1 << std::endl;\r\n \r\n auto<\/span> averageDistance= getAverageDistance({distPerWeek1,distPerWeek2,distPerWeek3,distPerWeek4});\r\n std::cout<< \"averageDistance: \"<\/span> << averageDistance << 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 The literal operators are implemented in the namespace Distance::unit<\/span>. You should use namespaces for user-defined literals because name collisions are, for two reasons, very likely. First, the suffixes are usually very short; second, the suffixes usually stand for units that already established abbreviations. I used the suffixes km, m, dm, a, and cm in the program.<\/span><\/p>\nHere is the output of the program. My unit for distances is a meter.<\/p>\n ![\"average\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/10\/average.png\") <\/p>\n
I display in lines 12 – 15 the various distances; I calculate in lines 19 – 22 the meter in various resolutions. The last test looks quite promising.
1.0_km + 2.0_dm + 3.0_dm + 4.0_cm<\/span> is 1000.54 m<\/span> (line 54). The compiler takes care of the calculations with all units.<\/p>\nThe key question remains. How many meters will I drive on average a week? For convenience, I define a few constants: work, workPerDay, abbrevationToWork, <\/span>and shopping.<\/span> These are my building blocks for the four weeks (lines 34 – 37). I went 493 km in the first week by car. The function getAverageDisttance<\/span> (line 41) helps me to get the average. I have to invoke it with an initializer list. I drive 255900m on average per week. That needs to change! And that has changed. I’m now an independent trainer.<\/p>\nUnder the hood<\/h3>\nI ignored one fact. Where are the MyDistance<\/span> objects defined? They are hidden in the program behind the automatic type deduction. Therefore, the explicit type for the variable work (line 28) is Distance::Distance<\/span>. Line 28 is equivalent to Distance::MyDistance work= 63.0_km;<\/span><\/p>\n <\/p>\n ![\"arithmetik\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/10\/arithmetik.png\") <\/p>\n
<\/p>\n The following steps will automatically happen if I use 1.5_km + 105.1_m in the source code. The compiler maps at first the suffixes km<\/span> and m<\/span> to the corresponding literal operators; second, the compiler maps the + operator to the overloaded + operator of the MyDistance<\/span> objects. Both steps can only work if the programmer implements the right operators in his contract. In this concrete case, he has to implement the literal operator and + operator. The black arrows in the graphic stand for the automatically performed mapping of the compiler. The red arrows stand for the functionality that the programmer has to implement.<\/p>\nWhat’s still missing to make the graphic complete? Right! The meat behind the red arrows.<\/p>\n Tasks of the programmer<\/h3>\nAt first, to the known overloading of operators. I overloaded for the class MyDistance<\/span> basic arithmetic (lines 15 – 28) and the output operator (lines 30 – 33). The operators are global functions and can use – thanks to their friendship – the internals of the class. I store in the private variable m<\/span> the distance. The function getAverageDistance<\/span> (lines 41 – 45) is applying the overloaded addition and division operator.<\/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\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<\/pre>\n<\/td>\n\n\/\/ distance.h<\/span>\r\n\r\n#ifndef DISTANCE_H<\/span>\r\n#define DISTANCE_H<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <ostream><\/span>\r\n\r\n\r\nnamespace<\/span> Distance{\r\n class<\/span> MyDistance<\/span>{\r\n public:\r\n MyDistance(double<\/span> i):m(i){}\r\n\r\n friend<\/span> MyDistance operator<\/span>+(const<\/span> MyDistance& a, const<\/span> MyDistance& b){\r\n return<\/span> MyDistance(a.m + b.m);\r\n }\r\n friend<\/span> MyDistance operator<\/span>-(const<\/span> MyDistance& a,const<\/span> MyDistance& b){\r\n return<\/span> MyDistance(a.m - b.m);\r\n }\r\n\t
friend<\/span> MyDistance operator<\/span>*(double<\/span> m, const<\/span> MyDistance& a){\r\n return<\/span> MyDistance(m*a.m);\r\n }\r\n\t \r\n friend<\/span> MyDistance operator<\/span>\/(const<\/span> MyDistance& a, int<\/span> n){\r\n return<\/span> MyDistance(a.m\/n);\r\n }\r\n\t \r\n friend<\/span> std::ostream& operator<\/span><< (std::ostream &out, const<\/span> MyDistance& myDist){\r\n out << myDist.m << \" m\"<\/span>;\r\n return<\/span> out;\r\n }\r\n\tprivate:\r\n\t double<\/span> m;\r\n\t \r\n };\r\n \r\n}\r\n \r\nDistance::MyDistance getAverageDistance(std::initializer_list<Distance::MyDistance> inList){\r\n auto<\/span> sum= Distance::MyDistance{0.0};\r\n for<\/span> (auto<\/span> i: inList) sum = sum + i ;\r\n return<\/span> sum\/inList.size(); \r\n}\r\n\r\n\r\n#endif<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n <\/p>\n Shorter but more thrilling are the literal operators.<\/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<\/pre>\n<\/td>\n\n\/\/ unit.h<\/span>\r\n\r\n#ifndef UNIT_H<\/span>\r\n#define UNIT_H<\/span>\r\n\r\n#include <distance.h><\/span>\r\n\r\nnamespace<\/span> Distance{\r\n\r\n namespace<\/span> Unit{\r\n MyDistance operator<\/span> \"\"<\/span> _km(long<\/span> double<\/span> d){\r\n return<\/span> MyDistance(1000*d);\r\n }\r\n MyDistance operator<\/span> \"\"<\/span> _m(long<\/span> double<\/span> m){\r\n return<\/span> MyDistance(m);\r\n }\r\n MyDistance operator<\/span> \"\"<\/span> _dm(long<\/span> double<\/span> d){\r\n return<\/span> MyDistance(d\/10);\r\n }\r\n MyDistance operator<\/span> \"\"<\/span> _cm(long<\/span> double<\/span> c){\r\n return<\/span> MyDistance(c\/100);\r\n }\r\n }\r\n}\r\n\r\n#endif<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n <\/p>\n The literal operators take as an argument a long double and return a MyDistance<\/span> object. MyDistance<\/span> is automatically normalized to meters. And now? That was the whole functionality that the programmer has to provide.<\/p>\nI ignored one big optimization potential in my program. Almost all operations can be performed at compile time; almost all objects can be instantiated at compile time. To make that happen, I must declare the operations and objects as constexpr<\/span>. <\/p>\nWhat’s next?<\/h2>\nYou can define user-defined literals not only for floating-point numbers. You can do it for integers, characters, and C strings. In addition, C++ has two ways to do integers and floating-point numbers. One is called cooked, the other raw. I have a lot more to write about user-defined literals. Wait for the next post.<\/a><\/span><\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n<\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" User-defined literals are a unique feature in all mainstream programming languages. They empower you to combine values with units.<\/p>\n","protected":false},"author":21,"featured_media":4997,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[517],"class_list":["post-4999","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-user-defined-literals"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4999","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=4999"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4999\/revisions"}],"predecessor-version":[{"id":6933,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4999\/revisions\/6933"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4997"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4999"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4999"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4999"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}} | | | | | |