Overriding methods with lower permission

[danil52]

Hello there,
I have the following code:

class Base {
public:
virtual void f() {cout << "Base::f()" << endl;}
virtual void f(int) {cout << "Base::f(in t)" << endl;}
};
class Derived : public Base {
void f() {cout << "Derived::f ()" << endl;}
};

int main() {
Base *ptr = new Derived();
ptr->f();
ptr->f(1);

return 0;
}

As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.
But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

[puzzlecracker]

On Jul 28, 1:53*pm, [e-mail] wrote:

Hello there,
I have the following code:

class Base {
public:
* virtual void f() {cout << "Base::f()" << endl;}
* virtual void f(int) {cout << "Base::f(in t)" << endl;}

};

class Derived : public Base {
* void f() {cout << "Derived::f ()" << endl;}

};

int main() {
* Base *ptr = new Derived();
* ptr->f();
* ptr->f(1);

* return 0;

}

As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.
But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

That's allowed in C++. However, you're not allowed to provide more
accessibility than provided by super class, in other words making it a
private member a public in subclass is prohibited under the current
standard.

[Pete Becker]

On 2008-07-28 13:53:41 -0400, da*****@mail.ru said:

>
As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.

Java creates many misapprehension s.

But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

Neither. Base::f is public, and Derived::f is private, just like you
said they should be. Access is checked statically. That is, ptr->f()
can call f because f is public in Base. Try it with a pointer to
Derived.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Pete Becker]

On 2008-07-28 14:35:25 -0400, puzzlecracker <ir*********@gm ail.comsaid:

On Jul 28, 1:53Â*pm, [e-mail] wrote:

>Hello there,
I have the following code:

class Base {
public:
Â* virtual void f() {cout << "Base::f()" << endl;}
Â* virtual void f(int) {cout << "Base::f(in t)" << endl;}

};

class Derived : public Base {
Â* void f() {cout << "Derived::f ()" << endl;}

};

int main() {
Â* Base *ptr = new Derived();
Â* ptr->f();
Â* ptr->f(1);

Â* return 0;

}

As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.
But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

That's allowed in C++. However, you're not allowed to provide more
accessibility than provided by super class, in other words making it a
private member a public in subclass is prohibited under the current
standard.

No, it's not. I think you're confusing this with the rule about using
directives, which are not allowed to increase access.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[danil52]

On Jul 28, 2:37*pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-07-28 13:53:41 -0400, [e-mail] said:

As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.

Java creates many misapprehension s.

But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

Neither. Base::f is public, and Derived::f is private, just like you
said they should be. Access is checked statically. That is, ptr->f()
can call f because f is public in Base. Try it with a pointer to
Derived.

--
* Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Well, that's obvious, access is checked only at compile-time. Compiler
would have no idea which object is being used at run-time. Using
pointer to Derived would produce an error - as expected. I understand
all of that.

But the fact is - I am able to call a private function! Compiler lets
me override the function and give it lower permissions, which,
logically shouldn't happen (Java compiler would choke on that piece of
code).

[Pete Becker]

On 2008-07-28 15:04:41 -0400, da*****@mail.ru said:

>
But the fact is - I am able to call a private function! Compiler lets
me override the function and give it lower permissions, which,
logically shouldn't happen (Java compiler would choke on that piece of
code).

Why shouldn't it happen? You said you wanted to override f, and you
said you don't want outsiders to be able to call Derived::f directly.
The two aren't inconsistent from a language perspective. If you don't
want that, don't do it. <g.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[puzzlecracker]

On Jul 28, 2:42*pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-07-28 14:35:25 -0400, puzzlecracker <ironsel2...@gm ail.comsaid:

On Jul 28, 1:53*pm, [e-mail] wrote:

Hello there,
I have the following code:

class Base {
public:
* virtual void f() {cout << "Base::f()" << endl;}
* virtual void f(int) {cout << "Base::f(in t)" << endl;}

};

class Derived : public Base {
* void f() {cout << "Derived::f ()" << endl;}

};

int main() {
* Base *ptr = new Derived();
* ptr->f();
* ptr->f(1);

* return 0;

}

As you can see, I overridden Base::f() from public, to private access
permission. Being the Java guy that I am, I expected a compiler error.
But to my surprise, the program ran fine, and called the private
version? Is this a compiler bug (I use g++), or is the function
explicitly converted to public? Thank you.

That's allowed in C++. However, you're not allowed to provide more
accessibility than provided by super class, in other words making it a
private member a public in subclass is prohibited under the current
standard.

No, it's not. I think you're confusing this with the rule about using
directives, which are not allowed to increase access.

--
* Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Argh, I see. Actually I wasn't. Would you explain the rule about
using
directives?

Thanks

[Pete Becker]

On 2008-07-28 16:55:48 -0400, puzzlecracker <ir*********@gm ail.comsaid:

Would you explain the rule about
using
directives?

class Base
{
void f();
public:
void g();
};

class Derived: public Base
{
void f(int); // hides Base::f
void g(int); // hides Base::g
// make base version visible (ignore duplication):
using Base::f; // OK: same access
using Base::g; // OK: more restricted access
protected:
using Base::f; // error: less restricted access
using Base::g; // OK: more restricted access
public:
using Base::f; // error: less restricted access
using Base::g; // OK: same access
};

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[=?ISO-8859-1?Q?Marcel_M=FCller?=]

Hi,

da*****@mail.ru schrieb:

>Neither. Base::f is public, and Derived::f is private, just like you
said they should be. Access is checked statically. That is, ptr->f()
can call f because f is public in Base. Try it with a pointer to
Derived.

Well, that's obvious, access is checked only at compile-time. Compiler
would have no idea which object is being used at run-time. Using
pointer to Derived would produce an error - as expected. I understand
all of that.

But the fact is - I am able to call a private function! Compiler lets
me override the function and give it lower permissions, which,
logically shouldn't happen (Java compiler would choke on that piece of
code).

it is quite common that an implementation of an interface (in fact a
pure function) should not be called directly. The standard gives you a
chance to restrict this.
Marcel

[Gennaro Prota]

Pete Becker wrote:

On 2008-07-28 16:55:48 -0400, puzzlecracker <ir*********@gm ail.comsaid:

>Would you explain the rule about
using
directives?

class Base
{
void f();
public:
void g();
};

class Derived: public Base
{
void f(int); // hides Base::f
void g(int); // hides Base::g
// make base version visible (ignore duplication):
using Base::f; // OK: same access
using Base::g; // OK: more restricted access
protected:
using Base::f; // error: less restricted access
using Base::g; // OK: more restricted access
public:
using Base::f; // error: less restricted access
using Base::g; // OK: same access
};

Where did you get this from? First, f isn't accessible in Derived, and
that's an error. All the rest is OK; aren't using declarations (and
not "directives ") intended to allow what was previously made with
access declarations?

--
Gennaro Prota | <https://sourceforge.net/projects/breeze/>
Do you need expertise in C++? I'm available.