{"id":5013,"date":"2016-11-03T21:53:07","date_gmt":"2016-11-03T21:53:07","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/override-and-final\/"},"modified":"2023-06-26T12:37:29","modified_gmt":"2023-06-26T12:37:29","slug":"override-and-final","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/override-and-final\/","title":{"rendered":"override and final"},"content":{"rendered":"

Using the context-sensitive keyword override and final, you can explicitly manage the overriding of virtual functions. In particular, the keyword override solves many issues with difficulty finding bugs in object hierarchies: Methods that should override methods of base classes. The result is syntactically but not a semantically correct program. The program performs the wrong stuff in the right way.<\/p>\n

<\/p>\n

 <\/p>\n

override<\/h2>\n

To override a method, the signature of the overriding method has to match precisely. What sounds easy is often not easy in practice: If the method’s signature fits not precisely, you will get the correct program with the wrong behavior. That’s simple; a different method will be invoked.<\/p>\n

The name override<\/span> in the method declaration expresses that the method should override a virtual method of a base class. The compiler checks the assertion. It checks the parameter of the method, the return type of the method, and qualifiers like const<\/span> and volatile.<\/span> Of course, the compiler notices if the overridden<\/em> method is not virtual.<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33<\/pre>\n<\/td>\n
\n
\/\/ override.cpp<\/span>\r\n\r\nclass<\/span> Base<\/span> {\r\n\r\n  void<\/span> func1();\r\n  virtual<\/span> void<\/span> func2(float<\/span>);\r\n  virtual<\/span> void<\/span> func3() const<\/span>;\r\n  virtual<\/span> long<\/span> func4(int<\/span>);\r\n\r\n  virtual<\/span> void<\/span> f();\r\n\r\n};\r\n\r\nclass<\/span> Derived<\/span>: public<\/span> Base {\r\n\r\n  virtual<\/span> void<\/span> func1() override;\r\n\r\n  virtual<\/span> void<\/span> func2(double<\/span>) override;\r\n\r\n  virtual<\/span> void<\/span> func3() override;\r\n\r\n  virtual<\/span> int<\/span> func4(int<\/span>) override;\r\n\r\n  void<\/span> f() override;\r\n\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  Base base;\r\n  Derived derived;\r\n\r\n};\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
If you compile the program, the compiler will complain a lot. The error message is very specific.<\/p>\n
The compiler complains in line 16 that the method func1<\/span> is not overriding a method. The same holds for the func2.<\/span> It has the wrong parameter type. It goes on with the method func3. func3<\/span> has no const<\/span> qualifier. func4<\/span> has the wrong return type. Only method f<\/span> in line 24 did it right and overrides the method f<\/span> of their base class.<\/p>\n
.<\/p>\n
\"override\"<\/p>\n
It’s a job for final<\/span> If a virtual method should not be overridden.<\/p>\n<\/p>\n
final<\/h2>\n
final<\/span> supports two use cases. First, you can declare a method that can not be overridden; second, you can define a class from which you can not derive. The compiler uses the same rules as in the case of override<\/span> to determine if a method overrides a method of a base class. Of course, the strategy goes the other way around because the final should suppress the overriding of a method. Therefore, the compiler checks the parameter of the method, their return type, and the const\/volatile<\/span> qualifiers.<\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30<\/pre>\n<\/td>\n
\n
\/\/ final.cpp<\/span>\r\n\r\nclass<\/span> Base<\/span> {\r\n  virtual<\/span> void<\/span> h(int<\/span>) final;\r\n  virtual<\/span> void<\/span> g(long<\/span> int<\/span>);\r\n};\r\n\r\nclass<\/span> Derived<\/span>: public<\/span> Base {\r\n  virtual<\/span> void<\/span> h(int<\/span>);\r\n  virtual<\/span> void<\/span> h(double<\/span>);\r\n  virtual<\/span> void<\/span> g(long<\/span> int<\/span>) final;\r\n};\r\n\r\nclass<\/span> DerivedDerived<\/span>: public<\/span> Derived {\r\n  virtual<\/span> void<\/span> g(long<\/span> int<\/span>);\r\n};\r\n\r\nstruct<\/span> FinalClass final { };\r\nstruct<\/span> DerivedClass: FinalClass { };\r\n\r\nint<\/span> main(){\r\n\r\n  Base base;\r\n  Derived derived;\r\n  DerivedDerived derivedDerived;\r\n\r\n  FinalClass finalClass;\r\n  DerivedClass derivedClass;\r\n\r\n};\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
What’s happening at compile time?<\/p>\n
The compiler does its job very neatly. It complains that the method h<\/span> in the class Base<\/span> (line 4) is overridden by the method in class Derived<\/span> (line 9). Of course, it’s okay that the method h<\/span> (line 10) in class Derived<\/span> overloads f for the parameter type double.<\/span> The method g (line 11) in the class Derived is quite interesting.<\/span> The method overrides method g<\/span> (line 5) of the class Base<\/span> and declares the method final.<\/span> Therefore, g<\/span> can not be overridden in DerivedDerived<\/span> (line 15).<\/p>\n
To the class FinalClass<\/span> (line 18). DerivedClass<\/span> can not be derived from FinalClass,<\/span> because the BaseClass<\/span> is final.<\/p>\n
\"final\"<\/p>\n
 <\/p>\n
I intentionally ignored one fact. The keywords override<\/span> and final<\/span> are context-sensitive keywords<\/strong>. What does that mean?<\/p>\n
Context-sensitive keywords<\/h2>\n
override<\/span> and final<\/span> are only keywords in specific contexts. These contexts are the declaration of a method or a class. If you use them in other contexts, they will be identifiers. What was the reason for introducing context-sensitive keywords into the C++ standard? On the one hand, the C++ standardization committee doesn’t like it introducing new keywords; on the other hand, the classical programs keep valid if they use the context-sensitive keywords override<\/span> and final.<\/span> With classical programs, I mean a program written with C++98\/C++03 syntax in mind.<\/p>\n
Context-sensitive keywords following a key principle of C++: Don’t break existing code.<\/strong><\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18<\/pre>\n<\/td>\n
\n
\/\/ keywords.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nvoid<\/span> override(){ std::cout << \"override\"<\/span> << std::endl; }\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  override();\r\n  \r\n  auto<\/span> final(2011);\r\n  std::cout << \"final: \"<\/span> << final << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
My small program is valid C++, although I named the function override<\/span> (line 5) and gave the variable the name final<\/span> (line 13).<\/p>\n
\"keywords\"<\/p>\n
Only for the sake of completeness. C++11 has with default<\/span> and delete<\/span> additional context-sensitive keywords.<\/p>\n
What’s next?<\/h2>\n
The new keyword nullptr<\/span> defines a null pointer constant in C++11. nullptr<\/span> clears the ambiguity of the number 0 in C++ and the macro NULL in C. How? You have to wait for the next post. <\/a><\/a><\/span><\/span><\/p>\n
 <\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Using the context-sensitive keyword override and final, you can explicitly manage the overriding of virtual functions. In particular, the keyword override solves many issues with difficulty finding bugs in object hierarchies: Methods that should override methods of base classes. The result is syntactically but not a semantically correct program. The program performs the wrong stuff […]<\/p>\n","protected":false},"author":21,"featured_media":5010,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[515,516],"class_list":["post-5013","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-final","tag-override"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5013","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=5013"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5013\/revisions"}],"predecessor-version":[{"id":6930,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5013\/revisions\/6930"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5010"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5013"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5013"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5013"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}