Why does the derived class have access to the private field of the base class?

Question

class Base {
 public:
  class FirstBase {
    friend class Base;
    int x = 10;
  };

  class SecondBase : public FirstBase {
   public:
    SecondBase() : FirstBase() {}
    void t() { std::cout << FirstBase::x; }
  };
};

This code compiles and works, but I don't understand why it works. Can explain or cite sources to read?

I use gcc version 11.4.0 std=C++17

note that the inheritance isn't essential for the example. You can make `x` a static member and `SecondBase` will still have access https://godbolt.org/z/zWxsYWjo5 — 463035818_is_not_an_ai, Aug 14 '23 at 11:52

score 28 · Accepted Answer · answered Aug 14 '23 at 11:54

28

Base is a friend of FirstBase, and SecondBase can access anything Base can access.

From the latest draft:
class.access, item 2:

A member of a class can also access all the members to which the class has access.

(Note that "nested" classes are members of the enclosing class.)

with the footnote

Access permissions are thus transitive and cumulative to nested and local classes.

Note that the inheritance is irrelevant - this is also fine:

class Base {
 public:
  class FirstBase {
    friend class Base;
    int x = 10;
  };

  class SecondBase {
   public:
    SecondBase() {}
    void t(FirstBase fb) { std::cout << fb.x; }
  };
};

answered Aug 14 '23 at 11:54

molbdnilo

64,751
3
43
82

friendship is not transitive, aside from that, true enough. – Deduplicator Aug 14 '23 at 21:56
3

@Deduplicator It can be, "to nested and local classes", as per The Standard. – molbdnilo Aug 15 '23 at 06:16
I meant that being friend of friend doesn't mean anything. – Deduplicator Aug 15 '23 at 08:02
3

@Deduplicator Nobody said that it does. *Access permissions* are transitive in the situations specified in the standard. – molbdnilo Aug 15 '23 at 08:19

simre · Answer 2 · 2023-08-14T11:49:00.253

Because Base is a friend of FirstBase. So inside Base you can access everything in FirstBase. And SecondBase is inside Base so SecondBase can access FirstBase. If you remove the friend relationship or you move SecondBase outside of Base, it'll break immediately as you expect.

class Base {
 public:
  class FirstBase {
    friend class Base; // This vill give access to FirstBase private members inside Base.
    int x = 10;
  };

  // SecondBase is inside Base so you can access FirstBase private members due to the friend relationship
  class SecondBase : public FirstBase {
   public:
    SecondBase() : FirstBase() {}
    void t() { std::cout << FirstBase::x; }
  };
};

Why does the derived class have access to the private field of the base class?

2 Answers2