Why C++ requires public inheritance, ignoring friend declarations, to make dynamic downcast working?

Question

Here we have a class B, inherited from class A, and it has a friend class C. Being a friend, C should have access to everything in B, including the A base class.

To test it,

first we create a B instance.
we upcast its address to an A*
then we try downcast it with dynamic_cast<> again to B*.

The expected result is to get back the address of the original B instance.

#include <cstdint>
#include <cstdio>

class A {
  public:
    virtual ~A() {};
};

class C;

class B : protected A { // <- this should be public to work! Why?
  friend C;
};

class C {
  public:
    void doit() {
      B *b = new B();
      printf("b= %p\n", b);
      A *a = static_cast<A*>(b);
      printf("a= %p\n", a);
      B *bb = dynamic_cast<B*>(a);
      printf("bb=%p\n", bb);
      delete b;
    };
};

int main() {
  C c;
  c.doit();
  return 0;
};

The common problem in similar cases, that the base class has to be polymorph (which is guaranted here by its empty virtual destructor), is here solved.

However, the dynamic casting still does not work: bb should have the same adress as b.

My experiments show, the only way to make it working, if A is a public base class of B. But... C is a friend of B. It does not work even as protected.

Why is it so?

I use gcc-8, if it matters.

Private inheritance means the base class is private, and only accessible to the derived class. — NathanOliver, Jun 17 '20 at 13:58
Related: [Why does protected inheritance cause dynamic_cast to fail?](https://stackoverflow.com/questions/12765174) — alter_igel, Jun 17 '20 at 13:58
It's standard mandated. Probably cause in the end, supporting this will require keeping multiple RTTI records (for different access specifiers). This may be considered undesirable for some. — StoryTeller - Unslander Monica, Jun 17 '20 at 14:00
Which is also correct. Protected means only children, grandchildren, ect., classes can access it's members — NathanOliver, Jun 17 '20 at 14:01
@ThomasSablik I wanted minimal example, and I wanted to print pointer addresses to demonstrate the problem. I will fix it soon, but it won't be minimal any more. — peterh, Jun 17 '20 at 14:04
[11.9.3#1](https://eel.is/c++draft/class.friend#1) "A friend of a class is a function or class that is given permission to use the private and protected member names from the class." and thats it, no access to private/protected base — 463035818_is_not_an_ai, Jun 17 '20 at 14:04
No, not and friends. Only derived classes have access. To all others those base class members are private. — NathanOliver, Jun 17 '20 at 14:06
@idclev463035818 this may be getting off-topic but here is an [online demo](https://coliru.stacked-crooked.com/a/224dfb7a577b0143) of what appears to be a violation of that (interpretation of the) quote from the standard. It appears g++ allows friends to access private base classes and their members. Is g++ wrong? — alter_igel, Jun 17 '20 at 14:10
@alterigel I believe private/protected base classes should work as private/protected members. — peterh, Jun 17 '20 at 14:12
@alterigel actually I never thought about it before, when I looked it up, thats how I interpreted the standard, but that `const Secret& s = a;` seems to show something else — 463035818_is_not_an_ai, Jun 17 '20 at 14:13
@alterigel btw I dont think it is offtopic, and I don't quite agree with the duplicate. OP seems to be aware about the difference between public/protected/private inheritance, there is even one answer that claims that friends would see private bases which contradicts the observations (https://stackoverflow.com/a/1374362/4117728). Voting to reopen — 463035818_is_not_an_ai, Jun 17 '20 at 14:15
@idclev463035818 @NathanOliver Am I going insane, or are [`private` and `protected` bases indeed accessible from `friend` classes](http://eel.is/c++draft/class#access.base-4.2)? I'd say reason the `dynamic_cast` fails is because the runtime check simply doesn't use the same set of rules as base class accessibility: [it requires the base to be `public`](http://eel.is/c++draft/expr.dynamic.cast#8). Note that you can see this in the code: remove `friend C` and the cast from `B*` to `A*` fails to compile, since `A` is not an accessible base of `B` in `C` unless `C` is a `friend` of `B`. — HTNW, Jun 17 '20 at 14:16
as [linked by @‌‌‌‌alter_igel](https://stackoverflow.com/questions/62430684/why-c-requires-public-inheritance-ignoring-friend-declarations-to-make-dynam#comment110412870_62430684), this doesn't relate to `friend`, you cannot cast even in `B` itself. — apple apple, Apr 18 '23 at 14:38

Yusuf R. Karagöz · Answer 1 · 2022-11-11T10:40:31.347

1

Think "dynamic_cast" as a global function. "friend C;" gives the friendship to "class C" not to "dynamic_cast".

Member access check is at compile time.

dynamic_cast checks the base-accessibility at Runtime. RTTI has the base-accessibility information (see MS implementation rtti.cpp; __RTDynamicCast), but not the friendship.

edited Nov 11 '22 at 10:40

answered Nov 11 '22 at 08:07

Yusuf R. Karagöz

589
8
22

Thanks! What if I declare in `B` a `friend dynamic_cast()`? – peterh Nov 11 '22 at 11:33
@peterh it is not possible. but if it were, same thing as if you were defined a friend function from a extern dll. It is pre compiled, and "friend" has no effect. Of course all that explain here is not the reality, and only to understand it, and to separate compile-time and runtime-time specifications. – Yusuf R. Karagöz Nov 15 '22 at 09:03

peterh · Accepted Answer · 2020-08-05T17:22:07.927

0

Summarizing the useful infos and cited resources in the comments, a self-answer can be written.

First, the friend declaration is a no-issue: friend affects only the accessibility of the members of the class where it is declared on, but not its base class(es).

Second, accessibility check in C++ goes in compilation time. But the accessibility check of dynamic_cast happens in runtime. This accessibility check is far more restrictive, and the dynamic_cast can happen only if the inheritance is public.

Its likely reason is that doing it correctly would probably require different rtti tables for the different access levels.

edited Aug 05 '20 at 17:22

answered Jun 18 '20 at 10:55

peterh

11,875
18
85
108

1

If a better answer is posted, it will be accepted and not this. – peterh Jun 18 '20 at 10:55
`friend` *does* affect the accessibility of base classes, because accessibility of base classes is defined by the accessibility of members. If `friend` didn't affect base class accessibility, the `static_cast` would fail, since `A` needs to be an accessible base class of `B` in order for it to go through. It's also very likely not "incompetence." It would have been *easier* for the committee to say "`dynamic_cast(u)`, where `U *u`, succeeds if `u` points to a `T` and `U` is an accessible base of `T`." They likely made this restriction for performance reasons or something. – HTNW Jun 22 '20 at 00:07
@HTNW Ok, but the cost is: to be able to downcast to the base class, you need to unneededly reveal the base members. This is a needless limitation, and violates encapsulation. It is also very un-intuitive: the intuitive (and, imho, correct) solution would be, if friend *would* affect the accessibility of the base, public/protected/private base classes should be available on the same rules than the public/protected/private members. It is also a design mistake, because having different rules for runtime casting than for compile-time is clearly conceptionally bad. – peterh Jun 22 '20 at 09:36
@HTNW I believe they knew this problem, but they "solved" it by saying, that some dirty and complex template trickery would be a feasible solution. While it is not. Templates are an addition to the C++ and independent from the inheritance system. – peterh Jun 22 '20 at 09:37

Why C++ requires public inheritance, ignoring friend declarations, to make dynamic downcast working?

2 Answers2

Linked