Can a private operator be accessible from outside?

Question

i.e. if I define operators == and + in my class in a private section, can they be accessible from main?

It works in MSVS 2008 and 2010 but for me it seems to be a bug in a compiler. Is it so?

Answer 1

Functions or members declared under private access specifier will not be accessible outside the class member functions.

There are 3 access specifiers for a class/struct/Union in C++. These access specifiers define how the members of the class can be accessed. Of course, any member of a class is accessible within that class(Inside any member function of that same class). Moving ahead to type of access specifiers, they are:

Public - The members declared as Public are accessible from outside the Class through an object of the class.
Protected - The members declared as Protected are accessible from outside the class BUT only in a class derived from it.
Private - These members are only accessible from within the class. No outside Access is allowed.

Friends to the rescue!
Declaring a function as friend inside another class allows that function to access all the member functions inside the class irrespective of the access specifier rules. friend It is a way to bypass the access specifier rules laid out in C++. Similary, a class declared as friend inside another class will allow the class being declared as friend to have access to all the members of the class. Note that the friend declaration can be given under any access specifer and it will have the same effect.

An source code example:

    class MyClass
    {
        public:
            int a;
        protected:
            int b;
        private:
            int c;
            friend void doSomething(MyClass obj);
    };

    void doSomething(MyClass obj)
    {
        obj.a = 10;     //Allowed
        obj.b = 20;     //Allowed, 
        obj.c = 30;     //Allowed, 
    }


    int main()
    {
        MyClass obj;
        obj.a = 10;     //Allowed
        obj.b = 20;     //Not Allowed, gives compiler error
        obj.c = 30;     //Not Allowed, gives compiler error
    }

So in your usage if you are using friend then you can have access to the private members of the class or else your compiler is buggy you should consider changing it!

Answer 2

You will have to show the code to get a sensible explanation of why the compiler is accepting it. My guess is that you are implementing them as friend free functions. At any rate, for the sake of argument, assume you have:

class bar {
   friend bool operator==( bar const &, bar const & ) {
      return true;
   }
   bar operator+( bar const & ) {
      return *this;
   }
};

int main() {
   bar a, b;
   a == b;    // ok
   //a + b;   // nok: operator+ is private from this context
}

And now the explanation. In the example, operator+ is declared as a member function inside a private section, as such, access specifiers apply and unless main is a friend of the class it will not have access to it. On the other hand operator== is implemented as a free function (even if the definition is provided inside the class braces) and access specifiers do not apply there.

The code is almost equivalent (there is a small difference when it comes to lookup) to:

class bar {
   friend bool operator==( bar const &, bar const & ); // just declare as friend
   //...
};
bool operator==( bar const &, bar const & ) {
   return true;
}

Where it is much simpler to reason about accessibility of operator== from the main function.