enum year ( fresh, sops,	junior,	senior,	grad};
class student { protected:
int    student id;
double gpa;
year   у ;
char   name[30];
public:
student(char* nm, int id, double g, year x);
void print();
};
enum support { ta, ra, fellowship, others-class grad_student: public student { protected:
support s;
char    dept[10] ;
char    thesis [80];
public:
grad student (char* nm, int id, double g, year x, support t, char* d, char* th);
void print() ;
};

В этом примере grad_student – порожденный класс, a student -базовый класс. Общее наследование также означает, что полученный класс grad_student – подтип класса student. Следовательно, студент, окончивший институт – студент, но студент не может быть студентом, окончившим институт.
Порожденный класс представляет собой модификацию основного класса, которая наследует общие и защищенные члены базового класса. Таким образом, в примере grad_student члены student – student_id,gpa, name, year и print унаследованы. Часто порожденный класс добавляет новые члены к уже существующим членам класса, как в случае grad student, который имеет три новых члена-данных и переопределенную функцию-член print. Функция-член print перекрывается. Это означает то, что порожденный класс имеет реализацию функции-члена, отличающуюся от базового.
//Проверка правил преобразования указателей.

main (){
student s("Mae Pohl", 100, 3.425, fresh), *ps = &s ;
grad student gs("Morris Pohl", 200, 3.2564, grad, ta,
"Pharmacy", "Retail Pharmacies"), *pgs;
ps -> print(); //student::print
ps = pgs = &gs;
ps -> print(); //student::print
pgs -> print(); //grad_student::print }

Видимость в производном классе
Ограничение доступа private, protected или public для базового класса имеют следующий смысл для зоны видимости членов базового класса в производном. По умолчанию устанавливается private.
• Скрытые члены базового класса недоступны в производном.
• При объявлении Private – открытые и защищенные члены базового класса в производном классе становятся закрытыми.
• При объявлении Protected – открытые и защищенные члены базового класса в производном классе становятся защищенными .
• При объявлении Public – открытые и защищенные члены базового класса в производном классе становятся открытыми и защищенными соответственно.
Графически эти правила представлены на рисунке :
Объявление Базовый класс Производный класс
Private
private private
protected protected
public public

Protected private private

protected protected
public public

Public
private private

protected protected

public public
ПОВТОРНОЕ ИСПОЛЬЗОВАНИЕ КОДА:
ГРАНИЦЫ ДИНАМИЧЕСКОГО МАССИВА
Приведем пример класса безопасного массива vect. Используем код повторно и расширим этот тип до безопасного массива с динамическими пределами – верхним и нижним. Такой стиль объявления массива более гибок и позволяет индексам непосредственно соответствовать прикладной области. Вспомните, что тип динамического безопасного массива vect проверяет индексы на нахождение в диапазоне пределов массива и создает массивы с использованием свободной памяти. Объявление класса следующее:
//Реализация типа динамического безопасного массива vect

class vect
{private:
int *p;                 //базовый указатель int
size;                   //число элементов
public:                  //конструкторы и деструкторы
vect();                 //создает массив размерностью 10
vect(int 1);            //создает массив размерностью 1
vect(vect& v);           //инициализация от vect
vect(int  a[], int 1);  //инициализация от массива
~vect() { delete [] р; }
int ub() { return (size - 1); } //верхняя граница ints
operator[](int i) ;        //получение элемента
//проверенного на соответствие границам
vect& operators(vect& v);
vect operator+(vect& v);
};

Производный тип будет иметь private члены 1_bnd и u_bnd, которые будут хранить нижний и верхний пределы созданного безопасного массива. Производный тип повторно использует представление и код исходного типа.
//Порожденный сип безопасного массива — класс vect_bnd class vect_bnd: public vect

{private:
int l_bnd, u_bnd;
public:
vect_bnd() ;
vect bnd(int, int);
int& operator[](int) ;
int ub() { return (u_bnd); }
int lb() { return (l_bnd); }
};

Конструкторы порожденного класса вызывают конструкторы базового класса. При этом используется такая же синтаксическая конструкция, как и для инициализации членов.
заголовок функции: имя_базового_класса(список_параметров)
В более ранних компиляторах C++ в случае одиночного наследования имя базового класса могло быть опущено и понималось неявно. Сейчас это считается анахронизмом.

vect bnd::vect bnd() :vect(10)
{l_bnd = 0;
u_bnd = 9;
}
vect bnd::vect bnd(int lb, int ub) :vect(ub - lb + 1)
{l_bnd = lb;
u_bnd = ub;
}

Обратите внимание на то, как конструкторы порожденного класса вызывают конструкторы базового класса. Дополнительный код инициализирует пару
границ диапазона. В качестве альтернативы это может быть выполнено инициализаций в списке.
vect_bnd::vect_bnd(int lb, int ub):
vect(ub – lb + 1), l_bnd(lb), u_bnd(ub) {}

Можно также повторно использовать код при перегрузке оператора индексации [].
Int& vect_bnd::operator[](int i)
{if (i < l_bnd || u_bnd < i)
{ cerr « “index out of range\n”;
exit(1) ;
};
return (vect::operator[](i – l_bnd));
}
Это будет очень неэффективно. Почему? Потому, что проверка пределов теперь выполняется дважды. Чтобы избежать этого, необходимо внести два изменения. Во-первых, нужно изменить привилегию доступа члена vect: : р на protected, так что бы порожденный класс имел непосредственный доступ к ранее private реализации vect. Это позволяет сделать второе изменение:
использовать р в функции-члене vect_bnd: : operator[](). Теперь код будет более эффективным:

int& vect_bnd::operator [](int i)
{if (i < l_bnd || u_bnd < i)
{cerr « "index out of range\n";
exit(1) ;
};
return (p[i - l_bnd]) ;
}

Обратите внимание на компромисс между повторным использованием кода и эффективностью. Это распространенный случай. Отметьте также, что наследование требует учета трех уровней доступа. Что должно быть строго частным (private), а что будет защищено (protected), зависит от того, что потенциально может быть повторно использовано.

Совместимость типов предка и потомка.
• Класс потомок всегда можно преобразовать в класс предок.
• Всегда и во всех конструкциях класс потомок может использоваться через ссылку на класс предок.
• Ссылка на класс предок может указывать любой из классов потомков без явного преобразования.
• Указатель на класс потомок может содержать класс предок, но требуется явное преобразование типов. Это очень опасная практика.

Class A{  …};
Class B:public A{…};

A A1;*A2;
B B1,*B2;

A=B;          //Допустимо
B=A;          //Не допустимо
B2=B(&A);     //Допустимо но может привести к ошибке
A2=B;         //Допустимо

Виртуальные методы. Полиморфизм.
Виртуальные методы объявляются с использованием служебного слова virtual. Методы объявленные один раз виртуальными, будут виртуальными во всех потомках. В потомках они могут объявляются как с использованием слова virtual так и без него, в любом случае они остаются виртуальными.

• Позволяют выбирать функции члены с одним и тем же именем через указатель функции в зависимости от типа созданного объекта, а не от типа указателя.
• Является одним из типов полиморфизма.
• Типы аргументов, их количество, а также тип возвращаемого значения должны быть у перегруженных функций одинаковыми.
• Не могут быть статическими.

Рассмотрим пример использования виртуальных классов.

#include
#include
#include
#include
enum Boolean{False,True};
const
int DefColor=1, BackColor=0;

class TShape
{protected:
int x,y;
int color;
Boolean Visible;
virtual void Paint(int Color)=0;
public:
TShape(int X,int Y,int Color):x(X),y(Y),color(Color){};
void Draw(){Paint(color); Visible=True; };
void Clear(){Paint(BackColor);Visible=False; }
void Move(int X,int Y);
};

void TShape::Move(int X,int Y)
{
if (Visible) Clear();
x=X;
y=Y;
Draw();
}

class TPixel: public TShape
{protected:
void Paint(int Color);
public:
TPixel(int X,int Y,int Color):TShape(X,Y,Color){};
};

void TPixel::Paint(int Color)
{
putpixel(x,y,Color);
}

class TCircle:public TShape
{protected:
int radius;
void Paint(int Color);
public:
TCircle(int X,int Y,int Radius,int Color)
:TShape(X,Y,Color), radius(Radius){};
};

void TCircle::Paint(int Color)
{
setcolor(Color);
circle(x,y,radius);
}

void main()
{TShape Shape(10,10,3);  // ОШИБКА нельзя создать экземпляр
// виртуального класса
TShape *PShape;
TPixel Pixel(10,20,15);
TCircle Circle(150,150,50,3);

int gdriver = DETECT, gmode;
initgraph(&gdriver, &gmode, "..\\bgi\\");
if (graphresult() != grOk)  /* an error occurred */
{
cout<<"Graphics error"<
cout<<"Press any key to halt";       getch();       exit(1);             /* return with error code */    }  Pixel.Draw();  Circle.Draw();  PShape=&Pixel;  PShape->Clear();
Circle.Move(400,150);

getch();
closegraph();
}

Виртуальные методы могут быть так же и перегружаемыми, но этот подход может привести к неожиданным последствиям.

#include
class A
{public:
int f;
virtual void fun(int a){cout<<"A::fun(int)"<<
virtual void fun(double a){cout<<"A::fun(double)"<<
};
class B:public A
{public:
int c;
virtual void fun(int a){cout<<"B::fun(int)"<<fun(4.5);      //A::fun(double)
pa->fun(4);        //B::fun(int)
pb=&b;
pb->fun(4.5);      //B::fun(int)
pb->fun(4);        //B::fun(int)
return 0;
}

class А { public: void f(); /* ... */ };
class В { public: void f(); /* ... */ };
class С : public A, public В { /* ... */ };

С с;
c.f(); // Ошибка: какое f(), из А или из В?
c.A::f(): // Правильно

class С : public A, public В
{public:
void f() {A::f(); B::f();} // Перекрываем обе функции II...
}
c.f(): // Теперь правильно

Struct X{intl; /*...*/X(int);};
class A public X { /* ... */ A( int); };
class В public X { /* ... */ B( int): };
class С public A, public В {/*...*/ C( int);};

Графически это может быть представлено следующим образом:
К членам общего базового класса можно обратиться через имя одного из производных классов, используя оператор разрешения доступа.

С с( 0 );
++c.i; // Ошибка: какое I, из А или из В? ++c.A::i; // Правильно
С * ср = new C( 0 );
Х * хр = ср; // Ошибка: какое X?
Х*хр=(А*)ср; //Правильно

Виртуальные базовые классы…
• Для классов, порожденных от производных классов с общим виртуальным базовым классом, существует только один экземпляр объекта общего базового класса.
• Объявляются включением ключевого слова virtual в спецификатор ограничения доступа базового класса .

struct V {int i; /*...*/V(int);};
class A virtual public V { /* ... */ A( int); };
class В virtual public V { /* ... */ B( int); };
class С public A, public В { /* ... */ C( Int); };

Графически это представлено на рисунке.

Для доступа к членам общего базового класса не требуется ничего указывать дополнительно, поскольку существует лишь один объект этого класса.
Если виртуальный базовый класс и производный класс разделяют имя какого-либо поля, фукции-члена или перечисления, то имя в производном классе скрывает имя в виртуальном базовом классе.

Struct V {int i; void f(); /* ... */ };
struct A :virtual V{int i; int f(); /* ... */ };
struct В :virtual V{ /* ... */};
class С : public A, public В
{
...
void g(){i=f();} //Правильно
// Как A::i, так и A::f() скрывают V::i и V::f()
};

Их конструкторы, если таковые имеются, вызываются конструктором последнего класса в цепочке производных классов.
• В объявлении класса могут быть смешаны с невиртуальными базовыми классами.
• Могут вызывать нежелательные множественные вызовы методов в витруальном базовом классе, если переопределенный метод вызывает метод-предок в обоих классах предках, то метод в базовом классе вызывается 2 раза

//Тип безопасного массива vect с	перегрузкой []
class vect
{private:
int* p;    //базовый указатель
int  size; //число элементов
public:
//конструкторы и деструкторы
vect();      //создает массив из 10	элементов
vect(int п); //создает массив из п элементов
vect(const vect& v);       //инициализируется vect
vect(const int a[], int n);//инициализируется массивом
~vect() { delete [] p} ;
//прочие функции-члены
int ub(){return (size -1);} //проверка верхней границы
int& operator[](int i);     //элемент, проверяемый на
//выход за пределы
vect& operator=(const vect& v); //перегруженное присвоение
vect operator+(const vect& v);  //перегруженное сложение
};

Добавляются два вспомогательных конструктора:
vect::vect(const int а[],int n) //преобразует обычный массив

{if (n <= 0)
{
cerr<<"illegal vect size: "<<
exit(l) ;
}
size = n;
p = new int[size]; for (int i = 0; i < size; ++i)
p[i] = a[i];
}

vect::vect(const vect& v) //конструктор копии
{size = v.size;
p = new int[size];
for (int i = 0; i < size; ++i) p[i] = v.p[i] ;
}

Перегруженный оператор индексации берет целый аргумент и проверяет, находится ли это значение в пределах диапазона. Если да, он использует это значение для того, чтобы возвратить адрес индексированного элемента.

intS vect::operator [](int i)
{if (i < 0 || i > (size - 1)) {
cerr<<"illegal vect index: "<<
exit(l) ;
}
return (p[i]);
}

Перегруженный оператор индексации имеет возвращаемый тип и один параметр. Он должен быть нестатической функцией-членом. Хорошим стилем будет поддержание непротиворечивости между значением оператора индексации [ ], который определяется пользователем, и стандартным его значением. Таким образом, наиболее общий прототип функции:
имякласса& operator[] (целостный тип);

В таких функциях возвращается значение ссылки, которое может использоваться с любой стороны выражения назначения.
Когда назначение не перегружено, оно определяется по умолчанию с семантикой, представляющей собой присвоение значения. Это иногда называется семантикой “поверхностного копирования” и не всегда допустимо (см. главу 6). Удостовериться в том, что семантика по умолчанию правильна входит в обязанности поставщика класса. Если нет, как это произошло в нашем случае с vect, поставщик класса должен перегрузить конструкцию с правильной семантикой. Возможно также перегрузить оператор назначения с обработкой сигналов ошибочного поведения.
В следующем примере функция-член перегружает назначение для класса vect:

vectS vect::operator=(const vectS v)
{int s = (size < v.size) ? size : v.size;
if (v.size != size)
cerr<<"copying different size arrays "
<<<" and "<<
for (int i = 0; i < s;	++i) p[i] = v.p[i] ;
return (*this) ;
}

class clock
{private:
  unsigned long int tot_sees, sees, mins, hours, days;
 public:
  clock(unsigned long int i); //конструктор и преобразование
  void print();               //форматированный вывод
  void tick();                //добавление одной секунды
  clock operator++(){ this->tick(); return (*this); }
};

Этот класс перегружает префиксный оператор приращения. Сигнатурой для перегрузки совместимого постфиксного оператора приращения будет
lock operator++(int). После перегрузки эта форма оператора приращения неявно вызывается с целым значением 0 в качестве реального целого параметра. Перегруженный оператор представляет собой функцию-член и может быть вызван со своим аргументом по умолчанию. Функция-член tlick добавляет одну секунду к неявному аргументу перегруженного оператора++.

inline clock::clock (unsigned long int i)
{tot secs = i;
 sees = tot sees % 60;
 mins = (tot_secs / 60) % 60;
 hours = (tot_secs / 3600) %60;
 days = tot_secs / 86400;
}

void clock::tick()
{clock temp (++tot sees) ;
 sees = temp.sees;
 mins = temp.mons;
 hours = temp.hours;
 days = temp.days;
}

Конструктор выполняет удобное преобразование из tot_secs в дни, часы, минуты и секунды. Например, поскольку в дне 86400 секунд, деление нацело на эту константу дает число дней. функция-член tick создает clock temp, который добавляет одну секунду к общему времени. Конструктор действует как функция преобразования, которая, собственно, и обновляет время.
Перегруженный operator++() также обновляет неявную переменную clock и возвращает обновленное значение. Он может быт написан также, как и tick (), за исключением оператора

return (temp).
void clock::print ()
(cout<

class clock
{
 friend clock operator+(const clock& cl,const clock& c2);
}

clock operator+(const clock& c1, const clock& c2)
{clock temp(c1.tot sees + c2.tot sees);
 return (temp) ;
};

class clock
{
 clock operator-(const clock& с);
};

clock clock::operator-(const clock& c)
{
 clock temp( tot_secs - c.tot_secs);
 return (temp) ;
}

clock operator*(unsigned long int m,const clock& c)
{
 clock temp(m * с.tot secs);
 return (temp);
}