Override, final, and catching signature mistakes

Understanding Override, final, and catching signature mistakes

A derived declaration overrides a base virtual function only when the name, the parameter type list, the const/volatile qualification and the ref-qualifier all match exactly. When one of those drifts, the compiler cannot tell a typo from a deliberately different function, so it takes the declaration at face value: you get a new member that hides the base name inside the derived class, while the base's virtual dispatch entry still points at the base implementation. That is why the bug is so hard to see. Calling on a derived-typed object finds the new function and looks correct, but any call through a base reference or pointer runs the base version.

The override specifier inverts that default by asserting, at compile time, that this declaration really does replace a virtual function found in some base. The compiler checks the assertion and rejects the program when nothing matches, which catches a forgotten const, an int where the base said long, a misspelled name, a base function that was never declared virtual, and, most valuably, a later edit to the base signature that would otherwise quietly orphan every derived class. Writing override also makes the function virtual, so a derived declaration needs only one of the two words, and the convention is to keep override.

The final specifier closes doors instead of checking them. On a virtual function it forbids any further derived class from overriding it; on a class it forbids using that class as a base at all. Both state that a hierarchy stops here and have the compiler enforce it instead of a comment, and as a side effect they let the optimizer turn a virtual call into a direct one whenever the static type is known to be final. Neither specifier changes the behaviour of a program that was already correct; they only change which programs are allowed to compile.

#include <iostream>
#include <string>

struct Shape {
    virtual std::string name() const { return "Shape"; }
    virtual ~Shape() = default;
};

struct Circle : Shape {
    // No trailing const: this is a NEW function, not an override.
    std::string name() { return "Circle"; }
    // std::string name() override { return "Circle"; }  // error: does not override
};

struct Square : Shape {
    std::string name() const override { return "Square"; }
};

void report(const Shape& s) {
    std::cout << "report sees: " << s.name() << '\n';
}

int main() {
    Circle c;
    Square q;
    std::cout << "direct call: " << c.name() << '\n';
    report(c);
    report(q);
}

Worked examples

#include <iostream>

struct Logger {
    virtual void write(int code)     { std::cout << "Logger::write(int) " << code << '\n'; }
    virtual void write(double value) { std::cout << "Logger::write(double) " << value << '\n'; }
    virtual ~Logger() = default;
};

struct FileLogger : Logger {
    // long, not int: matches neither base signature
    void write(long code) { std::cout << "FileLogger::write(long) " << code << '\n'; }
};

int main() {
    FileLogger f;
    f.write(1);
    f.write(2.5);

    Logger& base = f;
    base.write(1);
    base.write(2.5);
}

#include <iostream>

struct Widget {
    virtual void draw() const { std::cout << "Widget\n"; }
    virtual ~Widget() = default;
};

struct Button : Widget {
    void draw() const final { std::cout << "Button\n"; }
};

struct IconButton final : Button {
    // void draw() const override {}   // error: overrides final Button::draw
    void setIcon() { std::cout << "icon set\n"; }
};

// struct Fancy : IconButton {};        // error: IconButton is final

int main() {
    IconButton b;
    b.setIcon();
    const Widget& w = b;
    w.draw();
}

#include <iostream>
#include <memory>

struct Node {
    virtual Node* clone() const { return new Node(*this); }
    virtual const char* tag() const { return "Node"; }
    virtual ~Node() = default;
};

struct Leaf : Node {
    Leaf* clone() const override { return new Leaf(*this); }  // covariant return: allowed
    const char* tag() const override { return "Leaf"; }
    // int tag() const override;  // error: conflicting return type
};

int main() {
    Leaf leaf;
    std::unique_ptr<Leaf> exact{leaf.clone()};
    const Node& n = leaf;
    std::unique_ptr<Node> viaBase{n.clone()};
    std::cout << exact->tag() << ' ' << viaBase->tag() << '\n';
}

Important notes

Common mistakes

Try it yourself