What is difference between protected and private derivation in c++ [duplicate]

Question

Possible Duplicate:
Difference between private, public and protected inheritance in C++

What is difference between deriving as protected or private in c++? i am not able to figure out, since both seem to restrict base class member access from derived class object

Answer 1

Let's consider a code example showing what would be allowed (or not) using different levels of inheritance:

 class BaseClass {};

 void freeStandingFunction(BaseClass* b);

 class DerivedProtected : protected BaseClass
 {
     DerivedProtected()
     {
         freeStandingFunction(this); // Allowed
     }
 };

DerivedProtected can pass itself to freeStandingFunction because it knows it derives from BaseClass.

 void freeStandingFunctionUsingDerivedProtected()
 {
     DerivedProtected nonFriendOfProtected;
     freeStandingFunction(&nonFriendOfProtected); // NOT Allowed!
 }

A non-friend (class, function, whatever) cannot pass a DerivedProtected to freeStandingFunction, because the inheritance is protected, so not visible outside derived classes. Same goes for private inheritance.

 class DerivedFromDerivedProtected : public DerivedProtected
 {
     DerivedFromDerivedProtected()
     {
         freeStandingFunction(this); // Allowed
     }
 };

A class derived from DerivedProtected can tell that it inherits from BaseClass, so can pass itself to freeStandingFunction.

 class DerivedPrivate : private BaseClass
 {
      DerivedPrivate()
      {
          freeStandingFunction(this); // Allowed
      }
 };

The DerivedPrivate class itself knows that it derives from BaseClass, so can pass itself to freeStandingFunction.

class DerivedFromDerivedPrivate : public DerivedPrivate
{
     DerivedFromDerivedPrivate()
     {
          freeStandingFunction(this); // NOT allowed!
     }
};

Finally, a non-friend class further down the inheritance hierarchy cannot see that DerivedPrivate inherits from BaseClass, so cannot pass itself to freeStandingFunction.

Answer 2

Use this matrix (taken from here) to decide the visibility of inherited members:

inheritance\member  |     private     |   protected   |   public
--------------------+-----------------+---------------+--------------
private             |  inaccessible   |    private    |  private
protected           |  inaccessible   |    protected  |  protected
public              |  inaccessible   |    protected  |  public
--------------------+-----------------+---------------+--------------

Example 1:

class A { protected: int a; }
class B : private A {};       // 'a' is private inside B

Example 2:

class A { public: int a; }
class B : protected A {};     // 'a' is protected inside B

Example 3:

class A { private: int a; }
class B : public A {};        // 'a' is inaccessible outside of A

Answer 3

private allows only the class it is declared in to access it protected allows that class and derived/sub classes to access as if it were private