// derived classes                                            Output  
#include <iostream.h>                                           20                    
class CPolygon {                                                10
  protected:
    int width, height;
  public:
    void set_values (int a, int b)

      { width=a; height=b;}
  };
class CRectangle: public CPolygon {
  public:
    int area (void)
      { return (width * height); }
  };
class CTriangle: public CPolygon {
  public:
    int area (void)
      { return (width * height / 2); }
  };
int main () {
  CRectangle rect;
  CTriangle trgl;
  rect.set_values (4,5);
  trgl.set_values (4,5);
  cout << rect.area() << endl;
  cout << trgl.area() << endl;
  return 0;
}
As you may see, objects of classes CRectangle and CTriangle each contain members of CPolygon, 
that are: width, height and set_values(). The protected specifier is similar to private, its only 
difference occurs when deriving classes. When we derive a class, protected members of the base class 
can be used by other members of the derived class, nevertheless private member cannot. Since we 
wanted width and height to have the ability to be manipulated by members of the derived classes 
CRectangle and CTriangle and not only by members of CPolygon, we have used protected access 
instead of private. 
We can summarize the different access types according to whom can access them in the following way: 
Access
public
protected
private
members of the same class
yes
yes
yes
members of derived classes
yes
yes
no
not-members
yes
no
no

where "not-members" represent any reference from outside the class, such as from main(), from another class or from any function, either global or local. 
In our example, the members inherited by CRectangle and CTriangle follow with the same access permission as in the base class CPolygon: 
CPolygon::width           // protected access
CRectangle::width         // protected access
CPolygon::set_values()    // public access
CRectangle::set_values()  // public access
This is because we have derived a class from the other as public, remember: 
class CRectangle: public CPolygon;
this public keyword represents the minimum level of protection that the inherited members of the 
base class (CPolygon) must acquire in the new class (CRectangle). The minimum access level for 
the inherited members can be changed by specifying protected or private instead of public. 
For example, daughter is a class derived from mother that we defined thus: 
class daughter: protected mother;
this would establish protected as the minimum access level for the members of daughter that it i
nherited from mother. That is, all members that were public in mother would become protected 
in daughter, that would be the minimum level at which they can be inherited. Of course, this would 
not restrict that daughter could have its own public members. The minimum level would only be 
established for the inherited members of mother. 
The most common use of an inheritance level different from public is private that serves to 
completely encapsulate the base class, since, in that case, nobody except its own class will be able
to access the members of the base class from which it is derived. Anyway, in most cases classes 
are derived as public. 
If no access level is explicitly written private is assumed for classes created with the class 
keyword and public for those created with struct.