функция-член g() не имеет доступа к членам х и у несмотря на то, что 
первоначально эти члены имели статус protected и public. 

    Квалификация доступа к отдельным членам 

    Спецификатор базового класса потенциально влияет на все наследуемые члены. 
Например, при объявлении 
    class А {         
    public:	
        int x;	' , 
       А() { cout « "Inside A's constructor\n"; x = 0; } 
       void Display(void) { cout « "x == " « x « '\n'; }
    } ;

класс В может наследовать А в качестве закрытого базового класса:	

   class В: private A {                                                   
   public:	
     B():  A()  { cout « "Inside B's constructor\n";  }   
    } ; 

    Поскольку класс А объявлен закрытым в В, все прежде открытые в А члены 
теперь закрыты в В. Это означает, что во всех последующих производных от В 
классах или внешних по отношению к В операторах нельзя вызвать функцию-член 
Display (), наследованную из класса А. Следующие строки скомпилируются и 
выполнятся правильно: 

    A objectA; 
    objectA. Display();        // Все в порядке,   Display() открыта в классе А 

    Строки же, приведенные ниже,  при компиляции вызовут сообщение об 
ошибке '"A::Display()'  is not accessible..." 'A:: Display ()' недоступна). 

    В objects; 
    objects.Display();       // ??? DisplayO закрыта в В 

    Если вы хотите сделать закрытыми в производном классе только некоторые из 
наследуемых членов, можно выборочно квалифицировать один или несколько из них. 
Предположим, вы хотите, чтобы открытый в А целочисленный член х стал закрытым 
в В, а открытая в А функция Display() осталась бы открытой в В так, чтобы 
внешние операторы могли ее вызывать. Для этого укажите базовый класс А 
закрытым в В, как это уже делалось ранее, а в открытой секции В квалифицируйте 
наследуемые члены, которые вы хотели бы оставить открытыми: 

    class В:   private А {	
    public:                       .    
      A::Display;               // Выборочное уточнение DisplayO          
      В():  А() { cout « "Inside B's constructor^";   }                      
    }  

    Выражение A::Display; в открытой секции класса В указывает компилятору, 
что этот член, объявленный в классе А, должен остаться открытым. Наследуемый 
целочисленный член х станет закрытым членом класса В, как и прежде, однако 
функция-член Display() останется открытой. Предыдущая попытка вызова Display()
для объекта класса В теперь скомпилируется и выполнится правильно: 

    В objectB;	
    objects. Display();  // Display() - открытый член В 


    Использование конструкторов и деструкторов 

    Как уже упоминалось, в производном классе обычно необходим конструктор, 
если он определен и в базовом классе, кроме того, конструктор базового 
класса должен вызываться, чтобы инициализировать все данные-члены в базовых классах. 
    Деструкторы, напротив, не нуждаются в таких строгостях. В производном 
классе деструктор нужен только при наличии членов, которые необходимо удалять, 
когда объект производного класса выходит из области видимости. Рассмотрим 
базовый класс, объявленный следующим образом:	

    class TBase {	
    private: 
       char *basep; public: 
       TBase(const char *s)  { basep = strdup(s);   } 
       ~TBase() { delete basep;   } 
       const char «GetStr(void)  {  return basep;   }
   } ; 
   
    
    342     Часть III. Программирование на ANSI C++ 
