public 상속과 private 상속의 차이점?

문법책을 보다가 의문점이 생겨서 질문을 드립니다.
다름아니라...
A class, B class 있다고 했을 때...
A class 가 기반 클래스 B class 가 파생 클래스 일때...
class B : public A
일때 B클래스에서 protected는 A class에 protected, public 멤버에 접근할수 있고 외부에서는 A class의 public , B class의 public에 접근 할수 있고
class B: private A
일때 B클래스에서 protected는 A class에 protected, public 멤버에 접근할
수 있고 외부에서는 A class의 public에 접근할수없고 B class의 public에 접근할수가 있다고 나옵니다.그래서 나름대로 시험을 해볼려고 실험을 해봤습니다.
a.h

     1 #ifndef __A_H__
      2 #define __A_H__
      3
      4 class A
      5 {
      6 public :
      7     A();
      8     virtual ~A();
      9     void Init();
     10
     11 protected :
     12     void Init1();
     13
     14 private :
     15     void Init2();
     16 };
     17
     18 #endif

      1 #include "a.h"
      2 #include <cstdio>
      3
      4 A::A()
      5 {
      6 }
      7
      8 A::~A()
      9 {
     10
     11 }
     12
     13 void A::Init()
     14 {
     15     printf( "A public\n" );
     16 }
     17
     18 void A::Init1()
     19 {
     20     printf( "A protected\n" );
     21 }
     22
     23 void A::Init2()
     24 {
     25     printf( "A private\n" );
     26 }

      1 #ifndef __B_H__
      2 #define __B_H__
      3
      4 #include "a.h"
      5
      6 class B: private A
      7 {
      8 public :
      9     B();
     10     virtual ~B();
     11     void bInit();
     12
     13 protected:
     14     void bInit1();
     15
     16 private:
     17     void bInit2();
     18 };
     19
     20 #endif

      1 #include "b.h"
      2 #include <cstdio>
      3
      4 B::B()
      5 {
      6
      7 }
      8
      9 B::~B()
     10 {
     11 }
     12
     13 void B::bInit()
     14 {
     15     printf( "B public\n" );
     16     bInit1();
     17 }
     18
     19 void B::bInit1()
     20 {
     21     A::Init(); // 접근 가능
     22     A::Init1(); // 접근 가능
     23     printf( "B protected\n" );
     24 }
     25
     26 void B::bInit2()
     27 {
     28     printf( "B private\n" );
     29 }

     1 #ifndef __C_H__
      2 #define __C_H__
      3
      4 #include "a.h"
      5
      6 class C
      7 {
      8 public :
      9     C();
     10     ~C();
     11     void cInit();
     12 protected :
     13     void cInit1();
     14 private :
     15     void cInit2();
     16     A a;
     17 };
     18
     19 #endif

      1 #include "c.h"
      2 #include <cstdio>
      3
      4 C::C()
      5 {
      6
      7 }
      8
      9 C::~C()
     10 {
     11
     12 }
     13
     14 void C::cInit()
     15 {
     16     a.Init(); // 이론대로 하면 여기서 접근 불가능이라고 나와야 하는데..접근 가능합니다.
     17     printf( "C public\n" );
     18 }
     19
     20 void C::cInit1()
     21 {
     22     printf( "C protected\n" );
     23 }
     24
     25 void C::cInit2()
     26 {
     27     printf( "C private\n" );
     28 }

         1 #include "b.h"
      2 #include "c.h"
      3
      4 int main( void )
      5 {
      6     B b;
      7     C c;
      8
      9     b.bInit();
     10     c.cInit();
     11
     12     return 0;
     13 }