Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Fix mistake about final and override not affecting final classes; reword enforcement to be clearer #2235

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
+3 −3
Open

Fix mistake about final and override not affecting final classes; reword enforcement to be clearer #2235

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions CppCoreGuidelines.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7428,14 +7428,14 @@ We want to eliminate two particular classes of errors:
* **implicit virtual**: the programmer intended the function to be implicitly virtual and it is (but readers of the code can't tell); or the programmer intended the function to be implicitly virtual but it isn't (e.g., because of a subtle parameter list mismatch); or the programmer did not intend the function to be virtual but it is (because it happens to have the same signature as a virtual in the base class)
* **implicit override**: the programmer intended the function to be implicitly an overrider and it is (but readers of the code can't tell); or the programmer intended the function to be implicitly an overrider but it isn't (e.g., because of a subtle parameter list mismatch); or the programmer did not intend the function to be an overrider but it is (because it happens to have the same signature as a virtual in the base class -- note this problem arises whether or not the function is explicitly declared virtual, because the programmer might have intended to create either a new virtual function or a new non-virtual function)

Note: On a class defined as `final`, it doesn't matter whether you put `override` or `final` on an individual virtual function.
Note: On a class defined as `final`, individual virtual functions cannot be overridden whether or not you put `final` on them. However, using `override`, or `final` without `virtual`, on a member function of a class marked `final` ensures that it overrides a base class virtual function.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Your first sentence is confusing. It reads like you're saying that virtual functions can't be overridden in the final class. But I think what you mean is that they can't be overridden again by something derived from the final class, because nothing can derive from it. It's just a confusing way to say "you can't derive from a final class"!

The second sentence is long and awkward.


Note: Use `final` on functions sparingly. It does not necessarily lead to optimization, and it precludes further overriding.

##### Enforcement

* Compare virtual function names in base and derived classes and flag uses of the same name that does not override.
* Flag overrides with neither `override` nor `final`.
* Compare virtual function names in base and derived classes and flag uses of the same name that do not have the same signatures and thus do not override.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Apart from correcting "does" to "do" (which should be fixed) this added text seems redundant, but maybe it helps clarify it if somebody isn't sure about the definition of override.

* Flag function overrides in derived classes containing neither `override` nor `final`.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This change isn't an improvement. Overrides have to be in derived classes, so adding that is redundant.

* Flag function declarations that use more than one of `virtual`, `override`, and `final`.

### <a name="Rh-kind"></a>C.129: When designing a class hierarchy, distinguish between implementation inheritance and interface inheritance
Expand Down