private, public, protected как модификаторы для наследования

Опубликовано 09.05.2012 | Автор: admin

После изучения модификаторов доступа внутри класса и простого наследования нужно понять принципы модификаторов доступа при наследовании. Модификаторы доступа public, private и protected применяются как внутри класса, так и к самому классу при наследовании. Вот об этих применяемых к классу модификаторах в этой статье и написано.

Классы, простое наследование. Первое знакомство
private, public, protected внутри класса

Для начала попробуйте понять таблицу:

public наследование

private наследование

protected наследование

сlass A
{
private: int x;
public: int y;
protected: int z;
};

сlass B как потомок A
{
private: int x;
public: int y;
protected: int z;
};

сlass C как потомок B
{
private: int x;
public: int y;
protected: int z;
};

сlass A
{
private: int x;
public: int y;
protected: int z;
};

сlass B как потомок А
{
private: int x;
public: int y;
protected: int z;
};

сlass C как потомок B
{
private: int x;
public: int y;
protected: int z;
};

сlass A
{
private: int x;
public: int y;
protected: int z;
};

сlass B как потомок A
{
private: int x;
public: int y;
protected: int z;
};

сlass C как потомок B
{
private: int x;
public: int y;
protected: int z;
};

Зачёркнутое в таблице не обозначает, что оно не наследуется, но обозначает, что модификатором доступа прямой контакт из наследника к такой части закрыт.

Используя public-наследование мы передаем потомкам всё, что есть в основном классе, в таком виде, как и записано в основном классе. Получаем клон основного класса. Разница в том, что элементы основного класса к элементам своего клона отношения не имеют. Это отображает листинг #1:

//Листинг #1        public-наследование
class A
{
  private: int x;
  public: int y;
  protected: int z;
};

class B:public A
{
    public:
       void update() //Открытая для программы функция
          {
            x = 100;    //хотя private унаследован, в потомке он только ест память. Будет ошибка
            y = 100;    //y из класса B стало равным 100
            z = 100;    //z из класса B стало равным 100
          }
};

class C:public B         //Класс С является классом-потомком на основе класса B
{
   public:
      void update()     //Открытая для программы функция
         {
           //x=100;     //хотя private унаследован, в потомке он только ест память. Будет ошибка
             y=100;     //y из класса C стало равным 100
             z=100;     //z из класса C стало равным 100
         }
};

//Листинг #1 public-наследование

class A

{

private: int x;

public: int y;

protected: int z;

};

class B:public A

{

public:

void update() //Открытая для программы функция

{

x = 100; //хотя private унаследован, в потомке он только ест память. Будет ошибка

y = 100; //y из класса B стало равным 100

z = 100; //z из класса B стало равным 100

}

};

class C:public B //Класс С является классом-потомком на основе класса B

{

public:

void update() //Открытая для программы функция

{

//x=100; //хотя private унаследован, в потомке он только ест память. Будет ошибка

y=100; //y из класса C стало равным 100

z=100; //z из класса C стало равным 100

}

};

Используя private-наследование можно создать первого потомка, от которого дальнейшее наследование будет бессмысленно. Если первый потомок получает возможность работы с некоторыми элементами, переданными по механизму наследования, то потомки первого потомка таких возможностей не получают. Кроме того, потомки первого потомка даже лишены возможности узнавать, кто их первый родитель. Предполагается, что потомки класса B не должны даже знать о существовании класса A (либо потомков класса B вообще не должно быть). Это отображается в листинге #2. (Примечание: Под первым потомком подразумевается потомок первого уровня. Таких потомков может быть сколько угодно)

//Листинг #2        private-наследование
class A
{
    private: int x;
         public: int y;
         protected: int z;
};

class B:private A
{
    public:
        void upate()
          {
            //x = 100;      //хотя private унаследован, в потомке он только ест память. Будет ошибка
            y = 200;        //y определился как объявленный в private внутри класса B
            z = 200;        //z определился как объявленный в private внутри класса B
          }
};

class C:public B            //Пытаемся создать потомок созданного класса B
{
    public:
        void update()
          {
             //x=300;       //Нельзя напрямую обратиться к private элементу унаследованному от родителя
             //y=300;       //Нельзя напрямую обратиться к private элементу унаследованному от родителя
             //z=300;       //Нельзя напрямую обратиться к private элементу унаследованному от родителя
          }
};

//Листинг #2 private-наследование

class A

{

private: int x;

public: int y;

protected: int z;

};

class B:private A

{

public:

void upate()

{

//x = 100; //хотя private унаследован, в потомке он только ест память. Будет ошибка

y = 200; //y определился как объявленный в private внутри класса B

z = 200; //z определился как объявленный в private внутри класса B

}

};

class C:public B //Пытаемся создать потомок созданного класса B

{

public:

void update()

{

//x=300; //Нельзя напрямую обратиться к private элементу унаследованному от родителя

//y=300; //Нельзя напрямую обратиться к private элементу унаследованному от родителя

//z=300; //Нельзя напрямую обратиться к private элементу унаследованному от родителя

}

};

Использованием protected-наследования программистом предполагается, что внутри всех потомков и потомков потомков и потомков потомков потомков будут использоваться только такие элементы, передаваемые механизмом наследования, которые будут защищены от влияния на себя извне своих классов. Это отображается в листинге #3:

//Листинг #3        protected-наследование
class A
{
   private: int x;
   public: int y;
   protected: int z;
};

class B:protected A
{
   public:
       void update()
         {
           //x=999;         //Нельзя обратиться напрямую к private элементу унаследованному от родителя
           y=999;           //y определился как объявленный в protected внутри класса B
           z=999;           //z определился как объявленный в protected внутри класса B
         }
};

class C:public B
{
   public:
       void update()
         {
         //  x = 777;       //Нельзя обратиться напрямую к private элементу унаследованному от родителя
           y = 777;         //y определился как объявленный в protected внутри класса C
           z = 777;         //z определился как объявленный в protected внутри класса C
         }
};

//Листинг #3 protected-наследование

class A

{

private: int x;

public: int y;

protected: int z;

};

class B:protected A

{

public:

void update()

{

//x=999; //Нельзя обратиться напрямую к private элементу унаследованному от родителя

y=999; //y определился как объявленный в protected внутри класса B

z=999; //z определился как объявленный в protected внутри класса B

}

};

class C:public B

{

public:

void update()

{

// x = 777; //Нельзя обратиться напрямую к private элементу унаследованному от родителя

y = 777; //y определился как объявленный в protected внутри класса C

z = 777; //z определился как объявленный в protected внутри класса C

}

};

Рубрика: Базовые знания, level "classer", Знакомства, Классы, Наследование

Peter Blood:

20.09.2012 в 11:47 дп

Очень хорошая статья. Автору большое спасибо

Ответить

Александр:

23.11.2012 в 12:06 дп

Спасибо.
Ссылку поправь на «Знакомство с protected (модификатор доступа внутри класса)»

admin:

23.11.2012 в 12:27 дп

Исправил. Спасибо

Ответить

Anonim:

13.03.2013 в 7:23 пп

Сижу разбираюсь в этой теме, смутила фраза «Нельзя обратиться к private элементу унаследованному от родителя».
Пришёл к выводу, что можно, если обратиться к нему через унаследованную аксессорную функцию 🙂

admin:

13.03.2013 в 10:21 пп

Давайте пример, что ли. Пример -то понагляднее будет чем выбрасывание терминов типа: «аксессорные функции»

13.03.2013 в 11:50 пп

Ну как-то так:

#include <iostream>
using namespace std;

class A
{
private:
int i;
public:
int j;
void seti_A(int tmp) {i = tmp;}
void setj_A(int tmp) {j = tmp;}
void showi() {cout<<"i="<<i<<"\n";}
void showj() {cout<<"j="<<j<<"\n";}
};

class B : private A
{
public:
void seti_B(int tmp) {seti_A(tmp); showi();} // обращаемся к private-элементу i, унаследованного от класса A
void setj_B(int tmp) {j = tmp; showj();}
};

int main()
{	B obB;
obB.seti_B(777);
obB.setj_B(666);
return 0;
}

#include <iostream>

using namespace std;

private:

int i;

int j;

void seti_A(int tmp) {i = tmp;}

void setj_A(int tmp) {j = tmp;}

void showi() {cout<<"i="<<i<<"\n";}

void showj() {cout<<"j="<<j<<"\n";}

void seti_B(int tmp) {seti_A(tmp); showi();} // обращаемся к private-элементу i, унаследованного от класса A

void setj_B(int tmp) {j = tmp; showj();}

int main()

{ B obB;

obB.seti_B(777);

obB.setj_B(666);

return 0;

На экране будет:
i=777
j=666

admin:

14.03.2013 в 12:32 дп

я исправлю в этих записях, что напрямую нельзя. Моя неточность.
что еще заметите, пишите. Спасибо.

Ответить

private, public, protected как модификаторы для наследования

7 комментариев на «“private, public, protected как модификаторы для наследования”»

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета