{"id":5640,"date":"2019-02-22T09:06:19","date_gmt":"2019-02-22T09:06:19","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/templates-misconceptions-and-surprises\/"},"modified":"2019-02-22T09:06:19","modified_gmt":"2019-02-22T09:06:19","slug":"templates-misconceptions-and-surprises","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/templates-misconceptions-and-surprises\/","title":{"rendered":"Templates: Misconceptions and Surprises"},"content":{"rendered":"

I often teach the basics of templates. Templates are special. Therefore, I encounter many misconceptions which cause surprises. Here are a few of them.<\/p>\n

<\/p>\n

 \"santa<\/p>\n

My first misconception is presumably apparent for many but not all C++ developers.<\/p>\n

Templates of Related Types are not Related<\/h2>\n

First of all, what does the related type mean? My informal term stands for types that can be implicitly converted<\/a>. Here is the starting point.<\/p>\n

 <\/p>\n

\n
\/\/ genericAssignment.cpp<\/span>\r\n\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, int<\/span> N><\/span>             \/\/ (1)<\/span>\r\nstruct<\/span> Point{\r\n    Point(std::<\/span>initializer_list<<\/span>T><\/span> initList):<\/span> coord(initList){}\r\n\r\n    std::<\/span>vector<<\/span>T><\/span> coord;    \r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    Point<<\/span>int<\/span>, 3<\/span>><\/span> point1{1<\/span>, 2<\/span>, 3<\/span>};\r\n    Point<<\/span>int<\/span>, 3<\/span>><\/span> point2{4<\/span>, 5<\/span>, 6<\/span>};\r\n  \r\n    point1 =<\/span> point2;                    \/\/ (2)<\/span>\r\n    \r\n    auto<\/span> doubleValue =<\/span> 2.2<\/span>;             \r\n    auto<\/span> intValue =<\/span> 2<\/span>;\r\n    doubleValue =<\/span> intValue;             \/\/ (3)<\/span>\r\n    \r\n    Point<<\/span>double<\/span>, 3<\/span>><\/span> point3{1.1<\/span>, 2.2<\/span>, 3.3<\/span>};\r\n    point3 =<\/span> point2;                    \/\/ (4)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The class template Point<\/span> stands for a point in an n-dimensional space. The type of the coordinates and the dimension can be adjusted (line 1). The coordinates are stored in a std::vector<T><\/span>. When I create two points with the same coordinate type and dimension, I can assign them.<\/p>\n
Now the misconception begins. You can assign an int<\/span> to a double <\/span>(line 3). Therefore, assigning a Point of ints to the point of doubles should be possible. The C++ compiler is quite specific about line 4. Both class templates are not related and cannot be assigned. They are different types.<\/p>\n
\"genericAssignment\"<\/p>\n
The error message gives the first hint. I need an assignment operator that supports the conversion from Point<int, 3><\/span> to Point<double, 3><\/span>. The class template now has a generic copy assignment operator.<\/p>\n
 <\/p>\n
\n
\/\/ genericAssignment2.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, int<\/span> N><\/span>\r\nstruct<\/span> Point{\r\n\r\n    Point(std::<\/span>initializer_list<<\/span>T><\/span> initList):<\/span> coord(initList){}\r\n\r\n    template<\/span> <<\/span>typename<\/span> T2><\/span>                        \r\n    Point<<\/span>T, N>&<\/span> operator<\/span>=<\/span>(const<\/span> Point<<\/span>T2, N>&<\/span> point){     \/\/ (1)<\/span>\r\n        static_assert(std::<\/span>is_convertible<<\/span>T2, T>::<\/span>value, \r\n                      \"Cannot convert source type to destination type!\"<\/span>);\r\n        coord.clear();\r\n        coord.insert(coord.begin(), point.coord.begin(), point.coord.end());\r\n        return<\/span> *<\/span>this<\/span>;\r\n    }\r\n    \r\n    std::<\/span>vector<<\/span>T><\/span> coord;\r\n    \r\n};\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  Point<<\/span>double<\/span>, 3<\/span>><\/span> point1{1.1<\/span>, 2.2<\/span>, 3.3<\/span>};\r\n  Point<<\/span>int<\/span>, 3<\/span>><\/span> point2{1<\/span>, 2<\/span>, 3<\/span>};\r\n  \r\n  Point<<\/span>int<\/span>, 2<\/span>><\/span> point3{1<\/span>, 2<\/span>};\r\n  Point<<\/span>std::<\/span>string, 3<\/span>><\/span> point4{\"Only\"<\/span>, \"a\"<\/span>, \"test\"<\/span>};\r\n\r\n  point1 =<\/span> point2;                                        \/\/ (3)<\/span>\r\n  \r\n  \/\/ point2 = point3;                                     \/\/ (4)<\/span>\r\n  \/\/ point2 = point4;                                     \/\/ (5)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Due to line (1), the copy assignment in line (3) works. Let’s have a closer look at the class template Point:<\/span> <\/p>\n