Introduction:

Recently, while acquainting myself with the new company, I encountered a piece of unusual code.

It seems quite straightforward. We start by declaring a base class with a private virtual function, which is then called by a public member function. Next, we derive a class from the base class and override the virtual function. This pattern is known as the Template Pattern. It defines the skeleton of an algorithm but allows subclasses to override specific steps without altering its structure. The code appears sound until we scrutinize the derived class.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include<iostream>
#include<memory>

class base {
public:
    base() = default;
    void callPrivateFunction(){
        privateFunction();
    }
private:
    virtual void privateFunction(){
        std::cout<<"The call comes from a private function"<<std::endl;
    }
};

class derived : public base {
public:
    void privateFunction() override {
        std::cout<<"The cal comes from the overrided function"<<std::endl;
    }
};

int main(){
    base *ptr = new derived();
    ptr->callPrivateFunction();

    derived *ptr_derived = new derived();
    ptr_derived->privateFunction();
    return 0;
}

code_examples/cpp_examples/01_myth_of_override/src/main.cpp at main · StarGazer1995/code_examples

Contribute to StarGazer1995/code_examples development by creating an account on GitHub.

https://github.com/StarGazer1995/code_examples/blob/main/cpp_examples/01_myth_of_override/src/main.cpp

My initial thought was, ‘How can we override a private virtual function? It wouldn’t pass the compilation test.’ However, I was surprised by the real compiler’s response: PASS.

Not only does it override the private virtual function, but it also changes the access level of the function in the derived class.

This seems to violate coding rules. The virtual function shouldn’t be accessible by derived classes. However, it appears that the override has a higher priority than the public and private declarations. I sought clarification from ChatGPT but didn’t receive a satisfactory answer. After consulting the C++ reference, I found a solution on our favorite platform, Stack Overflow.

virtual function specifier - cppreference.com

https://en.cppreference.com/w/cpp/language/virtual#In_detail

It’s surprising that the C++ committees have left this issue to developers, essentially telling us to ‘handle it ourselves.’ This approach grants too much freedom to manipulate virtual functions, potentially leading to violations of coding rules. The committees should address this to prevent such issues during development. One possible solution could be to restrict the override syntax to the protected level, thus providing more control and reducing the risk of unintended violations.