{"id":6190,"date":"2021-07-29T06:34:44","date_gmt":"2021-07-29T06:34:44","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/template-instantiation\/"},"modified":"2024-07-19T07:57:23","modified_gmt":"2024-07-19T07:57:23","slug":"template-instantiation","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/template-instantiation\/","title":{"rendered":"Template Instantiation"},"content":{"rendered":"

Template instantiation is creating a concrete function or a concrete class out of a function or class template. Creating template instantiation can be implicit (compiler-generated) or explicit (user-provided).<\/p>\n

<\/p>\n

\"templatesInstantiation\"<\/p>\n

When you need a template for a specific argument, the compiler auto-generates it. Sometimes, you want to remove template definitions from header files or avoid compute-power-consuming template instantiation. In this case, explicit instantiation is your friend.<\/p>\n

Implicit Instantiation<\/h2>\n

Implicit instantiation should be your default choice. Implicit instantiation means the compiler automatically generates the concrete function or class for the provided template arguments. The compiler also deduces the template arguments from the function’s arguments. In C++17, the compiler can also deduce the template arguments for class templates.<\/p>\n

<\/p>\n

\n
\/\/ implicitTemplateInstantiation.cpp<\/span>\n\n#include <iostream><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nclass<\/span> MyClass<\/span>{\n public:<\/span>\n    MyClass(T t) { }\n    std::<\/span>string getType() const<\/span> {\n        return<\/span> typeid<\/span>(T).name();\n    }\n};\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\nbool<\/span> isSmaller(T fir, T sec){\n    return<\/span> fir <<\/span> sec;\n}\n\nint<\/span> main(){\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\n  \n    std::<\/span>vector vec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};          \/\/ (1)<\/span>\n    std::<\/span>cout <<<\/span> \"vec.size(): \"<\/span> <<<\/span> vec.size() <<<\/span> '\\n'<\/span>;\n  \n    MyClass myClass<\/span>(5<\/span>);                      \/\/ (2)<\/span>\n    std::<\/span>cout <<<\/span> \"myClass.getType(): \"<\/span> <<<\/span> myClass.getType() <<<\/span> '\\n'<\/span>;\n  \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n    std::<\/span>cout <<<\/span> \"isSmaller(5, 10): \"<\/span> \n              <<<\/span> isSmaller(5<\/span>, 10<\/span>) <<<\/span> '\\n'<\/span>;   \/\/ (3)<\/span>\n    std::<\/span>cout <<<\/span> \"isSmaller<double>(5.5f, 6.5): \"<\/span> \n              <<<\/span> isSmaller<<\/span>double<\/span>><\/span>(5.5f<\/span>, 6.5<\/span>) <<<\/span> '\\n'<\/span>;    \/\/ (4)<\/span>\n  \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n}\n<\/pre>\n<\/div>\n
Lines (1) and (2) use class template argument deduction (CTAG). std::vector<\/code> or MyClass<\/code> can deduce its type from their constructor arguments. Line (3) also deduces its template argument. In line (4), on the contrary, the template argument double<\/code> is explicitly specified: isSmaller<double>(5.5f, 6.5<\/code>).<\/p>\n
\"implicitTemplateInstantiation\"<\/p>\n
The compiler creates a concrete function or class for each implicit template instantiation. C++Insights<\/a> visualizes this process.<\/p>\n
This automatic process is very comfortable but has a few drawbacks.<\/p>\n
    \n
  1. When you implicitly instantiate a template, its definition is typically visible in a header file. However, you may not want to disclose the definition.<\/li>\n
  2. When you need a template for specific template arguments, the compiler instantiates if unavailable in the concrete translation unit. A translation unit is the source file after processing the C preprocessor. Typically, the linker removes all redundant template instantiations and keeps one. This is a waste of time and space.<\/li>\n<\/ol>\n
    Both issues can be solved with explicit template instantiation.<\/p>\n
    Explicit Instantiation<\/h2>\n
    Explicit instantiation has two flavors: explicit instantiation definition and explicit instantiation declaration.<\/p>\n