{"id":6147,"date":"2021-05-27T20:22:12","date_gmt":"2021-05-27T20:22:12","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/surprise-included-inheritance-and-member-functions-of-class-templates\/"},"modified":"2021-05-27T20:22:12","modified_gmt":"2021-05-27T20:22:12","slug":"surprise-included-inheritance-and-member-functions-of-class-templates","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/surprise-included-inheritance-and-member-functions-of-class-templates\/","title":{"rendered":"Surprise Included: Inheritance and Member Functions of Class Templates"},"content":{"rendered":"

In my last post, “Class Templates<\/a>“, I presented the basics. Today, I may surprise you with the inheritance of class templates and the instantiation of member functions of class templates.<\/p>\n

<\/p>\n

 \"ClassTemplate\"<\/p>\n

 <\/p>\n

Here is the first surprise. At least, it was it for me.<\/p>\n

Inherited Member Functions of Class Templates are not Available<\/h2>\n

Let’s start simple.<\/p>\n

\n
\/\/ inheritance.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> Base<\/span>{\r\npublic:<\/span>\r\n    void<\/span> func(){                    \/\/ (1)<\/span>\r\n        std::<\/span>cout <<<\/span> \"func\\n\"<\/span><\/span><\/span>;\r\n    }\r\n};\r\n\r\nclass<\/span> Derived<\/span>:<\/span> public<\/span> Base{\r\npublic:<\/span>\r\n    void<\/span> callBase(){\r\n        func();                      \/\/ (2)<\/span>\r\n    }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    Derived derived;\r\n    derived.callBase();              \r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I implemented a class Base<\/span> and Derived<\/span>. Derived<\/code> is public derived from Base<\/span> and can, therefore, be used in its method callBase<\/span> (line 2), the member function func<\/span> from class Base<\/span>. Okay, I have nothing to add to the output of the program.<\/span><\/p>\n
 \"inheritance\"<\/p>\n
Making Base<\/span> a class template changes the behavior.<\/p>\n
\n
\/\/ templateInheritance.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Base<\/span>{\r\npublic:<\/span>\r\n    void<\/span> func(){                    \/\/ (1)<\/span>\r\n        std::<\/span>cout <<<\/span> \"func\\n\"<\/span><\/span><\/span>;\r\n    }\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Derived<\/span>:<\/span> public<\/span> Base<<\/span>T><\/span>{\r\npublic:<\/span>\r\n    void<\/span> callBase(){\r\n        func();                      \/\/ (2)<\/span>\r\n    }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    Derived<<\/span>int<\/span>><\/span> derived;\r\n    derived.callBase();              \r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I assume the compiler error may surprise you.<\/p>\n
\"templateInheritance1\"<\/p>\n
The line “there are no arguments to ‘func’ that depend on a template parameter, so a declaration of ‘func’ must be available<\/span>” from the error message gives the first hint. func<\/span> is a so-called non-dependent name because its name does not depend on the template parameter T<\/code>. Non-dependent names are looked up and bound at the point of the template definition. Consequently, the compiler does not look in the from T dependent base class Base<T><\/span>, and there is no name func<\/span> available outside the class template. Only dependent names are looked up and bound at the point of template instantiation.<\/p>\n
This process is called Two Phase Lookup.<\/a> The first phase is, in particular, responsible for looking up non-dependent names; the second phase is responsible for looking up dependent names.<\/p>\n
There are three workarounds to extend the name lookup to the dependent base class. The following example uses all three.<\/p>\n
 <\/p>\n
\n
\/\/ templateInheritance2.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Base<\/span>{\r\npublic:<\/span>\r\n  void<\/span> func1() const<\/span> {\r\n    std::<\/span>cout <<<\/span> \"func1()\\n\"<\/span><\/span><\/span>;\r\n  }\r\n  void<\/span> func2() const<\/span> {\r\n    std::<\/span>cout <<<\/span> \"func2()\\n\"<\/span><\/span><\/span>;\r\n  }\r\n  void<\/span> func3() const<\/span> {\r\n    std::<\/span>cout <<<\/span> \"func3()\\n\"<\/span><\/span><\/span>;\r\n  }\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Derived<\/span>:<\/span> public<\/span> Base<<\/span>T><\/span>{\r\npublic:<\/span>\r\n  using<\/span> Base<<\/span>T>::<\/span>func2;              \/\/ (2)<\/span>\r\n  void<\/span> callAllBaseFunctions<\/span>(){\r\n\r\n    this<\/span>-><\/span>func1();                   \/\/ (1)<\/span>\r\n    func2();                         \/\/ (2)<\/span>\r\n    Base<<\/span>T>::<\/span>func3();                \/\/ (3)<\/span>\r\n\r\n  }\r\n};\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  Derived<<\/span>int<\/span>><\/span> derived;\r\n  derived.callAllBaseFunctions();\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
    \n
  1. Make the name dependent<\/strong>: The call this->func1<\/span> in line 1 is dependent because this<\/span> is implicit dependent. The name lookup will consider, in this case, all base classes.<\/li>\n
  2. Introduce the name into the current scope:<\/strong> The expression using Base<T>::func2<\/span> (line 2) introduces func2<\/span> into the current scope.<\/li>\n
  3. Call the name fully qualified<\/strong>: Calling func3<\/span> fully qualified (line 3) will break a virtual dispatch and may cause new surprises.<\/li>\n<\/ol>\n
    Which option should you use? In general, I prefer the first option making func1<\/code> dependent: this->func1<\/code>. This solution does even work when you rename your base class. <\/p>\n
    In the end, here is the output of the program.<\/p>\n
    \"templateInheritance2\"<\/p>\n<\/p>\n
    Instantiation of Member Functions is Lazy<\/h2>\n
    Lazy means the instantiation of a member function of a class template happens only when needed. Proof? Here we are.<\/p>\n
    <\/p>\n
    \n
    \/\/ lazy.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>class<\/span> T<\/span>><\/span> \r\nstruct<\/span> Lazy{\r\n    void<\/span> func() { std::<\/span>cout <<<\/span> \"func<\/span>\\n\"<\/span>; }<\/span>\r\n    void<\/span> func2<\/span>(); \/\/ not defined (1)<\/span>\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n  Lazy<<\/span>int<\/span>><\/span> lazy;\r\n  lazy.func();\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Although the method func2<\/span> () (1) of class Lazy<\/span> is only declared but not defined, the compiler accepts the program. Because func2,<\/span> a definition of the member function is not necessary. <\/span><\/p>\n
    \"lazy\"<\/p>\n
    This laziness of the instantiation process of member functions has two interesting properties.<\/p>\n
    Save Resources<\/h2>\n
    When you instantiate, for example, a class template  Array2<\/code> for various types, only the used member functions are instantiated. This laziness does not hold for a non-template class Array1<\/code>. Let me show you an example on C++ Insights.<\/p>\n
    <\/p>\n
    \n
    \/\/ lazyInstantiation.cpp<\/span>\r\n\r\n#include <cstddef> <\/span>\r\n\r\nclass<\/span> Array1<\/span> { \r\n public<\/span>:<\/span> \r\n    int<\/span> getSize() const<\/span> { \r\n      return<\/span> 10<\/span>; \r\n } \r\n private<\/span>:<\/span> \r\n    int<\/span> elem[10<\/span>]; \r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, std::<\/span>size_t<\/span> N><\/span> \r\nclass<\/span> Array2<\/span> { \r\n public<\/span>:<\/span> \r\n    std::<\/span>size_t<\/span> getSize() const<\/span> {\r\n        return<\/span> N;\r\n    }\r\n  private:<\/span> \r\n     T elem[N]; \r\n}; \r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    Array1 arr;\r\n    \r\n    Array2<<\/span>int<\/span>, 5<\/span>><\/span> myArr1;\r\n    Array2<<\/span>double<\/span>, 5<\/span>><\/span> myArr2;   \/\/ (1)<\/span> \r\n    myArr2.getSize();           \/\/ (2) <\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
     The member function getSize()<\/code> of the class template Array2<\/code> is only instantiated for myArr2<\/code> (1). The call causes this instantiation myArr2.getSize()<\/code> (2).<\/p>\n
     C++ Insights<\/a> shows the truth. The crucial lines in the following screenshot are lines 40 and 59.<\/p>\n
    \"lazyInstantiation\"<\/p>\n
    Partial Usage of Class Templates<\/h3>\n
    You can instantiate class templates with template arguments that do not support all member functions. When you don’t call those member functions, all is fine.<\/p>\n
    <\/p>\n
    \n
    \/\/ classTemplatePartial.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T>         \/\/ (1) <\/span><\/span>\r\nclass<\/span> Matrix <\/span>{\r\n public:<\/span>\r\n    explicit<\/span> Matrix(std::<\/span>initializer_list<<\/span>T><\/span> inList):<\/span> data(inList) {}\r\n    void<\/span> printAll() const<\/span> {   \/\/ (2)<\/span>\r\n        for<\/span> (const<\/span> auto<\/span>&<\/span> d:<\/span> data) std::<\/span>cout <<<\/span> d <<<\/span> \" \"<\/span>;\r\n    }\r\nprivate:<\/span>\r\n    std::<\/span>vector<<\/span>T><\/span> data;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    const<\/span> Matrix<<\/span>int<\/span>><\/span> myMatrix1({1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>});\r\n    myMatrix1.printAll();   \/\/ (3)<\/span> \r\n\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n    const<\/span> Matrix<<\/span>int<\/span>><\/span> myMatrix2({10<\/span>, 11<\/span>, 12<\/span>, 13<\/span>});\r\n    myMatrix2.printAll();  \/\/ (4)<\/span> \r\n\r\n     std::cout << \"\\n\\n\"<\/span>;     
    \r\n    const<\/span> Matrix<<\/span>Matrix<<\/span>int<\/span>>><\/span> myMatrix3({myMatrix1, myMatrix2});\r\n    \/\/ myMatrix3.printAll(); ERROR (5)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The class template Matrix<\/code> (1) is intentionally simple. It has a type parameter T,<\/code> that holds its data in a std::vector<\/code>, and can be initialized by a std::initalizer_list<\/code>. Matrix<\/code> supports the member function printAll()<\/code> to display all its members. (3) and (4) show its usage. The output operator is not overloaded for Matrix<\/code> Consequently, I can create<\/code> myMatrix3<\/code> having other Matrix objects as members, but I cannot display them.<\/p>\n
     \"classTemplatePartial\"<\/p>\n
     <\/p>\n
    Enabling line 5 causes a pretty verbose error message of about 274 lines.<\/p>\n
     \"classTemplatePartialError\"<\/p>\n
    What’s next?<\/h2>\n
    I will write about alias templates and template parameters in my next post.<\/p>\n
    Bad Marketing<\/h2>\n
    I did a bad marketing job. A few people asked me in the last few days if my C++20 book, published on LeanPub<\/a>, is available in physical form. Sure, since one month. Choose your preferred Amazon Marketplace.<\/p>\n
     <\/p>\n
    \n
    US: <\/a>https:\/\/www.amazon.com\/dp\/B09328NKXK<\/a><\/div>\n
    UK: <\/a>https:\/\/www.amazon.co.uk\/dp\/B09328NKXK<\/a><\/div>\n
    DE: <\/a>https:\/\/www.amazon.de\/dp\/B09328NKXK<\/a><\/div>\n
    FR: <\/a>https:\/\/www.amazon.fr\/dp\/B09328NKXK<\/a><\/div>\n
    ES: <\/a>https:\/\/www.amazon.es\/dp\/B09328NKXK<\/a><\/div>\n
    IT: <\/a>https:\/\/www.amazon.it\/dp\/B09328NKXK<\/a><\/div>\n
    JP: <\/a>https:\/\/www.amazon.co.jp\/dp\/B09328NKXK<\/a><\/div>\n
    CA: <\/a>https:\/\/www.amazon.ca\/dp\/B09328NKXK<\/a><\/div>\n
     <\/div>\n
     <\/div>\n<\/div>\n<\/div>\n
     <\/p>\n<\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    In my last post, “Class Templates“, I presented the basics. Today, I may surprise you with the inheritance of class templates and the instantiation of member functions of class templates.<\/p>\n","protected":false},"author":21,"featured_media":6140,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[],"class_list":["post-6147","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6147","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=6147"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6147\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6140"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6147"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6147"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6147"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}