アクセス指定子

class A : X {
  class B { }; // B はプライベートです。
public:
  typedef B BB; // BB はパブリックです。
};
void f() {
  A::B y; // エラー、 A::B はプライベートです。
  A::BB x; // OK、 A::BB はパブリックです。
}

struct B { virtual int f(); }; // f は B 内ではパブリックです。
class D : public B { private: int f(); }; // f は D 内ではプライベートです。
void f() {
 D d;
 B& b = d;
 b.f(); // OK、 B::f() はパブリックです。 たとえプライベートでも D::f() が呼ばれます。
 d.f(); // エラー、 D::f() はプライベートです。
}

class A { };
class B : private A { };
class C : public B {
   A* p; // エラー、無修飾の名前探索は B のプライベートな基底としての A を発見します。
   ::A* q; // OK、修飾付き名前探索は名前空間レベルの宣言を発見します。
};

class W { public: void f(); };
class A : private virtual W { };
class B : public virtual W { };
class C : public A, public B {
void f() { W::f(); } // OK、 W は B を通して C からアクセス可能です。
};

struct S {
  class A; // S::A はパブリックです。
private:
  class A {}; // エラー、アクセスを変えることはできません。
};

class S {
 public: // n、f、E、A、B、C、U はパブリックメンバです。
    int n;
    static void f() {}
    enum E {A, B, C};
    struct U {};
};
int main()
{
    S::f(); // S::f は main からアクセス可能です。
    S s;
    s.n = S::B; // S::n および S::B は main からアクセス可能です。
    S::U x; // S::U は main からアクセス可能です。
}

struct Base {
 protected:
    int i;
 private:
    void g(Base& b, struct Derived& d);
};
 
struct Derived : Base {
    void f(Base& b, Derived& d) // 派生クラスのメンバ関数。
    {
        ++d.i; // OK、 d の型は Derived です。
        ++i; // OK、暗黙の「*this」の型は Derived です。
//      ++b.i; // エラー、 Base を通してプロテクテッドメンバにアクセスすることはできません。
//                 (さもなければ Derived2 のような別の派生クラスの
//                  基底の実装を変更できてしまいます)
    }
};
 
void Base::g(Base& b, Derived& d) // Base のメンバ関数。
{
    ++i; // OK。
    ++b.i; // OK。
    ++d.i; // OK。
}
 
void x(Base& b, Derived& d) // 非メンバ、非フレンド。
{
//    ++b.i; // エラー、非メンバからアクセスできません。
//    ++d.i; // エラー、非メンバからアクセスできません。
}

struct Base {
 protected:
    int i;
};
 
struct Derived : Base {
    void f()
    {
//      int Base::* ptr = &Base::i;    // エラー、 Derived を用いて表さなければなりません。
        int Base::* ptr = &Derived::i; // OK。
    }
};

class S {
 private:
    int n; // S::n はプライベートです。
 public:
    S() : n(10) {} // this->n は S::S からアクセス可能です。
    S(const S& other) : n(other.n) {} // other.n は S::S からアクセス可能です。
};