class x{
 int a;
 public:
 int b;
 protected:
 int c;
 public:
 int d;
..........
};
class y: public x{
 .............
 public:
 ..............
 void print(){
  cout<<"\n a="<<a//ошибка
  <<" b="<<b//ошибка
  <<" c="<<c
  <<" d="<<d;
 }
 ..............
};
void main(){
 +------------+
 |            |
 +============+

Переопределение членов базового класса в производном
class x{
 protected:
 int a,b;
 public:
 x(int a1, int b1){ a=a1; b=b1; }
 void print(){ cout<<"\n a="<<a<<" b="<<b; }
};
class y: public x{
 int c;
 double b;
 public:
 y(int a2, int b1, int c1, double b2): x(a1,b1){
  c=c1; b=b2;
 }
 void print(){
  cout<<"\n a="<<a<<" x::b="<<x::b<<" c="<<c<<" b="<<b;
 }
 .............................
}
void main(){
 x x1(1,2);
 y y1(3,4,5,7.7);
 y1.print();//3 4 5 7.7
 x1.print();//1 2
 y1.x::print();// 3 4
}

Изменение вида доступа для члена базового класса в порождённом классе
Допускается изменение вида аттрибута доступа для базового класса в производном классе, но только для восстановления того типа доступа, который существовал в базовом классе.
Пример:
class x{
 int a;
 private:
 int b;
 protected:
 int c;
 public:
 int d;
 .........................
};
class y: private x{
 .......................
 public:
 x::a;//ошибка
 x::b;//ошибка
 x::c;//ошибка
 x::d;
 protected:
 x::a//ошибка
 x::b//ошибка
 x::c;
}

Необходимо внести изменения в класс Worker для реализации повременной оплаты и доплаты за стаж.
class Worker{
 protected:
 char name[15];
 char address[50];
 char post[30];
 double salary;
 .................
};
class WorkerM: public Worker{
 protected:
 int time;
 double tariff;
 int staj;
 int t1,t2;
 double k1,k2;
 public:
 WorkerM(char*,char*,char*,double,int,int,double,double);
 void print();
 void showSal();
 void getSal();
 void setTime(int);
 void setStaj(int);
 ...............
};
WorkerM::WorkerM(char* n, char* a, char* p, double tf, int st, int t11, int t21, double k11, double k21):Worker(n,a,p,0){
 tariff=tf; staj=st; t1=t11; t2=t21; k1=k11; k2=k21; time=0;
}
void WorkerM::showSal(){
 double s=time*tariff;
 if (staj>=t2) s*=k2;
 else if (staj>=t1) s*=k1;
 salary+=s; time=0;
 cout<<"\n"<<name" начислено:"<<salary;
}
void WorkerM::getSal(){
 showSal();
 cout<<"\n"<<name<<" выплачено: "<<salary;
 salary=0;
}
//вариант
double WorkerM::getSal(){
 ....................
 double s=salary;
 salary=0;
 return s;
}
void WorkerM::setTime(int t){
 time=t;
}

Совместимость объектов родительских и порождённых классов
class x{
 protected:
 int a,b;
 public:
 x(int,int);
 ....................
};
class y: public x{
 protected:
 int c;
 public:
 y(int,int,int);
 ......................
};
class z:public y{
 protected:
 int d;
 public:
 z(int,int,int,int);
....................
};

Объект класса x       Объект класса y       Объект класса z
+-------+             +---------+           +-------+
|   a   |<------------|    a    |<----------|   a   |
+=======+             +---------+           +-------+
|   b   |<------------|    b    |<----------|   b   |
+-------+             +---------+           +-------+
                      |    c    |<----------|   c   |
                      +---------+           +-------+
                                            |   d   |
                                            +-------+
Правила совместимости:
 1) объекту родительского класса можно присвоить объект порождённого класса;
 2) указателю или ссылке на объект родительского класса можно присвоить указатель или адрес объекта порождённого класса;
 3) формальному параметру - объекту, указателю или ссылке на объект родительского класса можно присвоить объект-указатель адрес порождённого класса соответственно.
class x{               class y: public x{     class z: public y
 ..........             ................       ................
 x(........);           y(...............);    z(...............);
 ..............         ...............        .................
};                     };                     };

void main(){
 x x1(........);
 x *px=new x(....);
 y y1(......);
 y *py=new y(.....);
 z z1(.........);
 z *pz=new z(.....);
 x1=y1;
 x1=z1;
 px=py;
 px=pz;
 y1=z1;
 py=pz;
 px=&y1;
 py=&z1;
 ............
}
void f1(x, &y, .....){ .............};
 f1(x1,z1,......);
 f1(z1,x1,.......);
 ................

Концепция полиморфизма
Понятие полиморфизма является одной из фундаментальных составляющих ООП. Оно позволяет в родительском классе определить методы, которые будут общими для всех последующих классов. При этом последующий класс может определять специфическую реализацию для некоторых (возможно, всех) полиморфных методов). Важнейший принцип полиморфизма "один интерфейс - несколько методов". Полиморфизм - это техника, позволяющая устанавливать некоторые элементы поведения родительского класса такими же, как и в порождённом классе. Основными механизмами для реализации полиморфизма в ООП являются виртуальные методы и абстрактные элементы.
 Виртуальные методы
Метод, при опеределении которого в родительском классе указано ключевое слово virtual и который был переопределён в одном или более наследующих классах, называется виртуальным методом, следовательно, каждый наследующий класс может иметь собственную конкретизацию виртуального метода. Выбор конкретизации виртуального метода осуществляется в соответствии с типом объекта, на который указывает ссылочная переменная во время выполнения программы. То есть не тип ссылочной переменной, а тип объекта, на который указывает ссылка, определяет версию виртуального метода.
Полиморфизм - это техника, позволяющая устанавливать некоторые элементы поведения родительского класса такими же, как и в порождённом классе.
+-------------+       +-----------+
| Родительский|<------|Порождённый|
|    класс    | ссылка|  класс    |
+-------------+------>+-----------+
|вир. метод   |       |вир. метод |
+-------------+       +-----------+
Если класс x содержит виртуальную функцию vf, а класс y, порождённый от класса x, также содержит функцию vf с той же сигнатурой, то обращение к vf для объекта класса x вызовет vf из y при доступе через указатель или ссылку на объект класса y. В этом случае говорят, что функция порождённого класса подменяет функцию родительского класса.
 Правила использования виртуальных методов:
 1) если сигнатуры функций в родительском и порождённом классах различны, то механизм виртуальности не включается;
 2) виртуальную функцию родительского класса нельзя переопределить функцией в порождённом классе, которая отличается от неё только типом возвращаемого значения;
 3) eсли функция объявлена виртуальной, то все функции с такой же сигнатурой и возвращаемым значением в порождённых классах становятся виртуальными;
 4) виртуальные функции не могут быть статическими или дружественными по отношению к другим классам;
 5) виртуальные функции наследуются.