![\"fear\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/09\/fear.png\")
<\/p>\nThe rule “T.5: Combine generic and OO techniques to amplify their strengths, not their costs” of the core guidelines to generic programming uses type erasure as an example. Type erasure? Really! Of course, it takes me two posts to explain this advanced template technique.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
First of all: What does type erasure mean?<\/p>\n
Of course, you already often used type erasure in C++ or C. The C-ish type erasure is a void pointer; the C++-ish erasure is object orientation. Let’s start with a void pointer.<\/p>\n
Let’s have a closer look at the declaration of <\/p>\n with:<\/p>\n <\/p>\n The comparison function cmp Thanks to the void pointer, Maybe you want to sort a In C++, we can do better:<\/p>\n<\/p>\n Here is a simple example, which serves as a starting point for further variations.<\/p>\n <\/p>\n <\/p>\n The output of the program is not so thrilling.<\/p>\n To say it more formally. In Object Orientated Programming, you implement an interface. In dynamically typed languages such as Python, you are not interested in interfaces; you are interested in behavior.<\/p>\n Let me make a short detour.<\/p>\n In Python, you care about behavior and not about formal interfaces. This idea is well-known as duck typing. <\/a>To make it short, the expression goes back to the poem from James <\/a>Whitcomb<\/a> Rileys:<\/a> Here it is:<\/p>\n <\/p>\n \u201cWhen I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.\u201d<\/p>\n What does that mean? Imagine a function Don’t ask for permission; ask for forgiveness.<\/p>\n In our Duck’s case, you invoke the function Okay, this is the end of my detour. Maybe you wonder why I wrote about duck typing in this C++ post. The reason is quite straightforward. Thanks to templates, we have duck typing in C++. When you combine duck typing together with OO, it even becomes type-safe.<\/p>\n <\/p>\n In this example, I use a dispatch table (1) which maps characters to callables. A callable can be a function (1), a function object (2), or a function object created by To complete the example, here is the output.<\/p>\n <\/p>\n Before I write more about type erasure with templates in the next post, let me summarise the three techniques to implement type erasure.<\/p>\n You can implement type erasure with void pointers, object orientation, or templates. Only the implementation with templates is type-safe and doesn’t require a type hierarchy. The missing details of templates will follow.<\/p>\nstd::qsort<\/code>:<\/p>\n\nvoid<\/span> qsort<\/span>(void<\/span> *<\/span>ptr, std::<\/span>size_t<\/span> count, std::<\/span>size_t<\/span> size, cmp);\r\n<\/pre>\n<\/div>\n\nint<\/span> cmp<\/span>(const<\/span> void<\/span> *<\/span>a, const<\/span> void<\/span> *<\/span>b);\r\n<\/pre>\n<\/div>\n<\/code> should return a<\/p>\n\n
std::qsort<\/code> it is generally applicable but also quite error-prone.<\/p>\nstd::vector<int>,<\/code> but you used a comparator for C-strings. The compiler can not catch this error because the type information was removed. You end with undefined behavior.<\/p>\nObject Orientation<\/h2>\n
\n\/\/ typeErasureOO.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\nstruct<\/span> BaseClass{ \/\/ (2)<\/span>\r\n\tvirtual<\/span> std::<\/span>string getName() const<\/span> =<\/span> 0<\/span>;\r\n};\r\n\r\nstruct<\/span> Bar:<\/span> BaseClass{ \/\/ (4)<\/span>\r\n\tstd::<\/span>string getName() const<\/span> override {\r\n\t return<\/span> \"Bar\"<\/span>;\r\n\t}\r\n};\r\n\r\nstruct<\/span> Foo:<\/span> BaseClass{ \/\/ (4)<\/span>\r\n\tstd::<\/span>string getName() const<\/span> override{\r\n\t return<\/span> \"Foo\"<\/span>;\r\n\t}\r\n};\r\n\r\nvoid<\/span> printName<\/span>(std::<\/span>vector<<\/span>const<\/span> BaseClass*><\/span> vec){ \/\/ (3)<\/span>\r\n for<\/span> (auto<\/span> v:<\/span> vec) std::<\/span>cout <<<\/span> v-><\/span>getName() <<<\/span> std::<\/span>endl;\r\n}\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n\t\r\n\tstd::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n\tFoo foo;\r\n\tBar bar; \r\n\t\r\n\tstd::<\/span>vector<<\/span>const<\/span> BaseClass*><\/span> vec{&<\/span>foo, &<\/span>bar}; \/\/ (1)<\/span>\r\n\t\r\n\tprintName(vec);\r\n\t\r\n\tstd::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\nstd::vector<const Base*><\/code> (1) has a pointer to a constant BaseClasses<\/code>. BaseClass<\/code> is abstract Base Class, which is used in (3). Foo<\/code> and Bar<\/code> (4) are the concrete classes.<\/p>\n![\"typeErasureOO\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/09\/typeErasureOO.png\")
<\/p>\nFoo<\/code> and Bar<\/code> implement the interface of the BaseClass<\/code> and can, therefore, be used instead of BaseClass.<\/code> This principle is called Liskov substitution principle<\/a> and is type erasure in OO.<\/p>\nTemplates<\/h2>\n
![\"snake](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/09\/snake-312561_1280.png\")
<\/p>\nacceptOnlyDucks<\/code> that only accepts ducks as an argument. All derived types can invoke the function in statically typed languages such as C++. In Python, all types, which behave like Duck<\/code>‘s, can be used to invoke the function. To make it more concrete. If a bird behaves like Duck<\/code> it is a Duck<\/code>. Python often uses a proverb to describe this behavior quite well.<\/p>\nacceptsOnlyDucks<\/code> with a bird and hope for the best. If something terrible happens, you catch the exception with an except clause. Often this strategy works very well and very fast in Python.<\/p>\nstd::function<\/code> as a polymorphic function wrapper is a nice example of type erasure in C++.<\/p>\nstd::function<\/h3>\n
std::function<\/code> can accept everything which behaves like a function. To be more precise. This can be any callable such as a function, a function object, a function object created by std::bind,<\/span> or just a lambda function.<\/p>\n\n\/\/ callable.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\ndouble<\/span> add<\/span>(double<\/span> a, double<\/span> b){\r\n\treturn<\/span> a +<\/span> b;\r\n}\r\n\r\nstruct<\/span> Sub{\r\n\tdouble<\/span> operator<\/span>()(double<\/span> a, double<\/span> b){\r\n\t\treturn<\/span> a -<\/span> b;\r\n\t}\r\n};\r\n\r\ndouble<\/span> multThree<\/span>(double<\/span> a, double<\/span> b, double<\/span> c){\r\n\treturn<\/span> a *<\/span> b *<\/span> c;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n using<\/span> namespace<\/span> std::<\/span>placeholders;\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n std::<\/span>map<<\/span>const<\/span> char<\/span> , std::<\/span>function<<\/span>double<\/span>(double<\/span>, double<\/span>)>><\/span> dispTable{ \/\/ (1)<\/span>\r\n {'+'<\/span>, add }, \/\/ (2)<\/span>\r\n {'-'<\/span>, Sub() }, \/\/ (3)<\/span>\r\n {'*'<\/span>, std::<\/span>bind(multThree, 1<\/span>, _1, _2) }, \/\/ (4)<\/span>\r\n {'\/'<\/span>,[](double<\/span> a, double<\/span> b){ return<\/span> a \/<\/span> b; }}}; \/\/ (5)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> \"3.5 + 4.5 = \"<\/span> <<<\/span> dispTable['+'<\/span>](3.5<\/span>, 4.5<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"3.5 - 4.5 = \"<\/span> <<<\/span> dispTable['-'<\/span>](3.5<\/span>, 4.5<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"3.5 * 4.5 = \"<\/span> <<<\/span> dispTable['*'<\/span>](3.5<\/span>, 4.5<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"3.5 \/ 4.5 = \"<\/span> <<<\/span> dispTable['\/'<\/span>](3.5<\/span>, 4.5<\/span>) <<<\/span> std::<\/span>endl;\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\nstd::bind<\/code> (3), or a lambda function. The key point of std::function<\/code> is that it accepts all different function types<\/em> and erases their types. std::function<\/code> requires from its callables that it takes two double's<\/code> and returns a double: std::function<double(double, double)>.<\/code><\/p>\n![\"callable\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/09\/callable.png\")
<\/p>\n![\"TypeErasureCompare\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/09\/TypeErasureCompare.png\")
<\/p>\nWhat’s next?<\/h2>\n