![\"super](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/12\/super-charged-engine-2770374_1280.jpg\")
<\/p>\nTemplate definitions deal with guidelines that are specific to a template implementation. This means, in particular, these rules focus on how a template definition depends on its context.<\/p>\n
<\/p>\n
<\/p>\n
Here are today’s rules for template definitions:<\/p>\n
The first rule is quite special.<\/p>\n
Honestly, it took me a few moments to get this rule. Let’s look at the function templates sort<\/span> and algo.<\/span> Here is a simplified example of the guidelines.<\/p>\n <\/p>\n It would be optimal but not always manageable if a template operates only on its arguments. This holds for the function template sort<\/span> but not for algo.<\/span>The function template algo<\/span> has dependencies to sqrt<\/span> and the function helper. <\/span>Ultimately, the implementation of algo<\/span> introduces more dependencies than the interface shows. If a template member does not depend on a template parameter, it removes from the template. A member may be a type or a method. By following this rule, you may decrease the code size because the non-generic code is factored out.<\/p>\n The example from the guidelines is relatively straightforward.<\/p>\n <\/p>\n The type Link<\/span> does not depend on the template parameter A<\/span>. So I can remove it and use it in List2.<\/span><\/p>\n <\/p>\n Was this an easy job? Yes? No! The title of this rule is about SCARY. What does that mean? I’m curious, but honestly, you can ignore the following lines.<\/p>\n The acronym SCARY<\/strong> describes assignments and initializations that are S<\/strong>eemingly erroneous (appearing C<\/strong>onstrained by conflicting generic parameters) but A<\/strong>ctually work with the R<\/strong>ight implementation (unconstrained bY<\/strong> the conflict due to minimized dependencies).<\/p>\n I hope you get it. For the details, see N2911<\/a>. In order not to bore you, here is the apparent idea applied to the standard container iterator: they have no dependency on the containers, The next rule helps to reduce code bloat.<\/p>\n Let me say it more informally: put the template’s functionality which does not depend on the template parameters, in a non-templated base class.<\/p>\n The guidelines present a quite obvious example.<\/p>\n <\/p>\n The enumeration is independent of the type parameter T and should, therefore, be placed in a non-templated base class.<\/p>\n <\/p>\n Now, Foo_base<\/span> can be used without template arguments and template instantiation.<\/p>\n This technique is quite interesting if you want to reduce your code size. Here is a simple class template Array.<\/span><\/p>\n <\/p>\n <\/p>\n If you study the class template Array,<\/span> you will see that the method getSize<\/span> is the same except for the type parameter N. Let me refactor the code and declare a class template Array<\/span> that depends on the type parameter T.<\/span><\/p>\n <\/p>\n\ntemplate<\/span><<\/span>typename<\/span> C><\/span>\r\nvoid<\/span> sort(C&<\/span> c)\r\n{\r\n std::<\/span>sort(begin(c), end(c)); \/\/ necessary and useful dependency<\/span>\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> Iter><\/span>\r\nIter algo(Iter first, Iter last) {\r\n for<\/span> (; first !=<\/span> last; ++<\/span>first) {\r\n auto<\/span> x =<\/span> sqrt(*<\/span>first); \/\/ potentially surprising dependency: which sqrt()?<\/span>\r\n helper(first, x); \/\/ potentially surprising dependency:<\/span>\r\n \/\/ helper is chosen based on first and x <\/span>\r\n}\r\n<\/pre>\n<\/div>\n
<\/span><\/p>\n<\/p>\n<\/span>T.61: Do not over-parameterize members (SCARY)<\/a><\/span><\/h3>\n
\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> A =<\/span> std::<\/span>allocator{}><\/span>\r\n \/\/ requires Regular<T> && Allocator<A><\/span>\r\nclass<\/span> List<\/span> {\r\npublic:<\/span>\r\n struct<\/span> Link { \/\/ does not depend on A<\/span>\r\n T elem;\r\n T*<\/span> pre;\r\n T*<\/span> suc;\r\n };\r\n\r\n using<\/span> iterator =<\/span> Link*<\/span>;\r\n\r\n iterator first() const<\/span> { return<\/span> head; }\r\n\r\n \/\/ ...<\/span>\r\nprivate:<\/span>\r\n Link*<\/span> head;\r\n};\r\n\r\nList<<\/span>int<\/span>><\/span> lst1;\r\nList<<\/span>int<\/span>, My_allocator><\/span> lst2;\r\n<\/pre>\n<\/div>\n\ntemplate<<\/span>typename<\/span> T><\/span>\r\nstruct<\/span> Link {\r\n T elem;\r\n T*<\/span> pre;\r\n T*<\/span> suc;\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> A =<\/span> std::<\/span>allocator{}><\/span>\r\n \/\/ requires Regular<T> && Allocator<A><\/span>\r\nclass<\/span> List2<\/span> {\r\npublic:<\/span>\r\n using<\/span> iterator =<\/span> Link<<\/span>T>*<\/span>;\r\n\r\n iterator first() const<\/span> { return<\/span> head; }\r\n\r\n \/\/ ...<\/span>\r\nprivate:<\/span>\r\n Link*<\/span> head;\r\n};\r\n\r\nList<<\/span>int<\/span>><\/span> lst1;\r\nList<<\/span>int<\/span>, My_allocator><\/span> lst2;\r\n<\/pre>\n<\/div>\nkey_compare<\/span><\/code><\/span><\/code><\/span>,<\/span> hasher<\/span><\/code>, key_equal<\/span><\/code>,<\/span> or allocator<\/span><\/code><\/span> types.<\/p>\n<\/span>T.62: Place non-dependent class template members in a non-templated base class<\/a><\/span><\/h3>\n
\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Foo<\/span> {\r\npublic:<\/span>\r\n enum<\/span> { v1, v2 };\r\n \/\/ ...<\/span>\r\n};\r\n<\/pre>\n<\/div>\n\nstruct<\/span> Foo_base {\r\n enum<\/span> { v1, v2 };\r\n \/\/ ...<\/span>\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Foo<\/span> :<\/span> public<\/span> Foo_base {\r\npublic:<\/span>\r\n \/\/ ...<\/span>\r\n};\r\n<\/pre>\n<\/div>\n\n\/\/ genericArray.cpp<\/span>\r\n\r\n#include <cstddef><\/span>\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, std::<\/span>size_t<\/span> N><\/span>\r\nclass<\/span> Array<\/span>{\r\npublic:<\/span>\r\n Array()=<\/span> default<\/span>;\r\n std::size_t<\/span> getSize() const<\/span>{\r\n return<\/span> N;\r\n }\r\nprivate:<\/span>\r\n T elem[N];\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n Array<<\/span>int<\/span>, 100<\/span>><\/span> arr1;\r\n std::<\/span>cout <<<\/span> \"arr1.getSize(): \"<\/span> <<<\/span> arr1.getSize() <<<\/span> std::<\/span>endl;\r\n\r\n Array<<\/span>int<\/span>, 200<\/span>><\/span> arr2;\r\n std::<\/span>cout <<<\/span> \"arr2.getSize(): \"<\/span> <<<\/span> arr2.getSize() <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n\/\/ genericArrayInheritance.cpp<\/span>\r\n\r\n#include <cstddef><\/span>\r\n#include <iostream><\/span>\r\n\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nclass<\/span> ArrayBase<\/span> {\r\nprotected:<\/span>\r\n ArrayBase(std::<\/span>size_t<\/span> n):<\/span> size(n) {} \r\n std::<\/span>size_t<\/span> getSize() const<\/span> {\r\n return<\/span> size;\r\n };\r\nprivate:<\/span>\r\n std::<\/span>size_t<\/span> size;\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T, std::<\/span>size_t<\/span> n><\/span>\r\nclass<\/span> Array<\/span>:<\/span> private<\/span> ArrayBase