30
#include<iostream>

using namespace std;
class base
{
public:
    virtual void add() {
        cout << "hi";
    }
};

class derived : public base
{
private:
    void add() {
        cout << "bye";
    }
};

int main()
{
    base *ptr;
    ptr = new derived;
    ptr->add();
    return 0;
}

Output is bye

I dont have a problem with how this is implemented. I understand you use vtables and the vtable of derived contains the address of the new add() function. But add() is private shouldn't compiler generate an error when I try to access it outside the class? Somehow it doesn't seem right.

Bruce
  • 33,927
  • 76
  • 174
  • 262

3 Answers3

33

add() is only private in derived, but the static type you have is base* - thus the access restrictions of base apply.
In general you can't even know at compile time what the dynamic type of a pointer to base will be, it could e.g. change based on user input.

This is per C++03 §11.6:

The access rules (clause 11) for a virtual function are determined by its declaration and are not affected by the rules for a function that later overrides it.
[...] Access is checked at the call point using the type of the expression used to denote the object for which the member function is called [...]. The access of the member function in the class in which it was defined [...] is in general not known.

Georg Fritzsche
  • 97,545
  • 26
  • 194
  • 236
  • @Georg Fritzsche Can you please give me link of c++03 from where you copied this link. I googled but not found, want to study c++ –  May 25 '14 at 17:46
  • @Jai: ["Where do I find the current C or C++ standard documents?"](http://stackoverflow.com/questions/81656/where-do-i-find-the-current-c-or-c-standard-documents) – Georg Fritzsche Jun 02 '14 at 10:35
12

Access modifiers, such as public, private and protected are only enforced during compilation. When you call the function through a pointer to the base class, the compiler doesn't know that the pointer points to an instance of the derived class. According to the rules the compiler can infer from this expression, this call is valid.

It is usually a semantic error to reduce the visibility of a member in a derived class. Modern programming languages such as Java and C# refuse to compile such code, because a member that is visible in the base class is always accessible in the derived class through a base pointer.

Hosam Aly
  • 41,555
  • 36
  • 141
  • 182
5

To add a little to Georg's answer:

Remember that the compiler has no control over and cannot guarantee anything about derived classes. For example, I could ship my type in a library and derive from it in an entirely new program. How is the library compiler supposed to know that derived might have a different access specifier? The derived type didn't exist when the library was compiled.

In order to support this, the compiler would have to know access specifiers at runtime and throw an exception if you attempted to access a private member.

Puppy
  • 144,682
  • 38
  • 256
  • 465