Function Overriding

Imagine a base class with a virtual function, and a derived class that defines a function whose name is almost identical to the base version. The derived function looks like it was written to replace the base one. A reader skimming the code would likely assume the two are connected. This section asks whether that assumption is correct, and how a programmer can remove the doubt for anyone who reads the code later.

The belief behind that guess is common and it is a misconception. A function with a slightly different name, or a slightly different type, may be intended to override the base function. It may also be intended to be a separate function. Appearance does not settle which one was meant. The rest of this article works through the precise rule that decides the question, the keyword that states intent, and the closely related idea of overloading, where one name is shared by several functions.

Overriding matters because of what happens when a function is called through the base class. The diagram below follows one such call. The caller invokes the base class virtual function. When the derived class contains a function that overrides it, that overriding function is the one that takes the call, and its result returns to the caller. The diagram shows that path. Notice that the path only exists when the derived function really is an override, which is exactly what the matching rule in the next section decides.

The word exactly carries the weight here. The comparison below uses a generic example with a function named notify that takes one int in the base class. The derived function with the same name and the same parameter type overrides the base function. A derived function whose parameter type is double is a separate function, even though its name matches. A derived function named notif with an int parameter is also separate, even though its signature looks nearly identical to the base one. In each non-matching case, the derived function may have been intended as a replacement, but the rule does not treat it as one.

The source notes that in large class hierarchies it is not always obvious whether overriding was intended. A hierarchy may have many levels, many base classes, and many functions with similar names. A reader scanning a derived class cannot always tell, from the code alone, whether a near-match function was meant to replace an inherited virtual function or to add something new beside it.

This ambiguity is about the reader, not only the machine. The programmer who wrote the code knows what was intended. The problem is that the intent stays hidden unless the code says it. That gap is what the override keyword is designed to close.

The source uses print as its example. It declares three overloads of print with different parameter lists. The name print is therefore not one function that handles every type; it is a set of separate functions that the compiler treats as alternatives. The compiler's choice is made at each call site, so the same name can invoke different functions in different places in the same program.

For every call to an overloaded name, the compiler follows the same decision. It first collects the functions with that name. It then asks whether one of them is most appropriate for the argument types at that call. If one is, that function is invoked. If no alternative is better than the others, the call is ambiguous and the compiler reports an error. The source describes the outcome of this comparison but does not list the full ranking rules, so this article focuses on observable results: which call succeeds and which is rejected.

Apply the same steps to a call that passes a string literal, such as print with the text D is for Digital. The argument is a string, so the compiler selects print(string). Both calls follow the same four steps, and only the argument types differ between them.

The two candidates are declared with the same two types, but in swapped positions. One expects the integer first and the other expects it second. The comparison below lays them side by side for the call print(0, 0). Each candidate matches the call in one position and not in the other, so neither is better overall.