先看一个例子：

有一个类a,他有一个成员函数a_mem_fun()，类a包含了保护成员obj_b1，obj_b1是类b1的对象，b1是类b的子类，b_mem_fun()是b类的保护成员，请问如下操作可以吗：  
  a_mem_fun()  
  {  
        obj_b1.b_mem_fun();  
  }  
  也就是下面的可行吗？  
  class   a  
  {  
        protected:  
                    b1   obj_b1;  
                    a_mem_fun(){obj_b1.b_mem_fun();}  
  };  
  class   b  
  {  
        protected:  
                    b_mem_fun();  
  };  
  class   b1   :   public   b  
  {  
   
  }

 

答案：不能这么访问，保护成员相当于私有，类外不能访问。注意：保护成员的提出主要是为了解决在派生类中要频繁访问基类中的私有成员而提出的，因此，把基类中的那些在其派生类中需要频繁访问的成员声明为保护成员，这样就解决了在派生类中可以直接对这些原本在基类中的私有成员（现在为保护成员）进行操作，减少了访问基类的频繁度。这样看似保护成员和公有成员一样了，其实不是这样的，因为公有成员可以被外部（或称为类外）访问，而保护成员不可以被外部访问，，O(∩_∩)O~。。。。。。。

 

扩展一下：  受保护的成员不能被外部随便访问时毋庸置疑的，若想让其它类可以访问此保护成员，一是把此类声明为friend，即友元类；若要使其它函数想访问此保护成员，则是把此函数声明为友元函数，这是一种思维，即采用友元的思想。二是把此类声明为该类的子类，此子类可以私有/公有继承都可以访问此保护成员。

 

 

保护成员的作用

1. 私有成员在派生类中是无权直接访问的，只能通过调用基类中的公有成员函数的方式实现。

2. 一定要直接访问基类中的私有成员，可以把这些成员说明为保护成员protected。一般格式：

       Class 类名

{    

           [private:]

               私有成员

           protected:

               保护成员      

           public:

               公有成员

       };

1、不涉及派生时，保护成员与私有成员的地位完全一致。

 

#include <iostream.h>

//***************************************************

class samp

{

       int a;

protected:

       int b;

public:

       int c;

       samp(int n,int m){a=n;b=m;}

       int geta(){return a;}

       int getb(){return b;}

};

//***************************************************

void main()

{     samp obj(10,20);

//     obj.a=11;        //Error,私有成员

//     obj.b=22;        //Error,保护成员

       obj.c=33;        //Ok

       cout<<obj.geta()<<' '<<obj.getb()<<' '<<obj.c<<endl; //Ok

}

输出结果：10 20 33

      

2、以公有派生时：基类中的保护成员->在派生类中仍是保护的

              

//基类中的保护成员在公有派生的派生类中仍是保护的

#include <iostream.h>

//**********************************************************

class base{

protected:

       int a,b;

public:

       void setab(int n,int m){a=n;b=m;}

};

 

class derive:public base{

       int c;

public:

       void setc(int n){c=n;}

       void showabc()

       {  cout<<a<<' '<<b<<' '<<c<<endl; }

};

//**********************************************************

void main()

{    

       derive obj;

       obj.setab(2,4);        //setab在派生类里仍是公有的，可以访问

       obj.setc(3);

       obj.showabc();

}

输出结果：2 4 3

3、以私有派生时：基类中的保护成员à在派生类中是私有的。

 

// 保护性成员在私有派生时，为私有的

#include <iostream.h>

//******************************************************

class base                     //基类

{

protected:

       int a;

public:

       void seta(int sa){a=sa;}

};

//drive1中，a、seta都变成私有的成员

class derive1:private base      //私有派生类

{    

protected:

       int b;

public:

       void setb(int sb){b=sb;}

};

//derive2中a、b和seta均为私有的成员，setb仍为公有的

class derive2:public derive1   //公有派生类

{

      int c;

public:

       void setc(int sc){c=sc;}

       void show()

       { 

              //cout<<a<<endl;                  //Error

              cout<<"b="<<b<<endl;

              cout<<"c="<<c<<endl;

       }

};

//******************************************************

void main()

{ 

       base op1;      op1.seta(1);

    derive1 op2;   op2.setb(2);

    derive2 op3;   op3.setb(2);  op3.setc(3);  op3.show();

}

输出结果：

       b=2

       c=3

实际上，私有和保护这两个关键字的性质很相似，一旦用其中一个对类成员进行了定义，那外部对这个类成员是无法访问的，但在涉及到派生时，他们在派生类里的属性就改变了：

保护成员，在公有派生时仍是保护的，在私有派生时，变成私有的了，但派生类可以访问此成员；

而私有成员，在派生时，无论是私有的还是公有的，派生类都不能直接访问此成员。这就是两者的关键。