Динамическое связывание

проблем

класса A , то по правилам С++ объекта типа B

также может использоваться, как объект типа A. Иными словами, объект производного класса является также объектом базового класса.
Следовательно
объект класса B может инициализировать объект класса A
объект класса B может быть фактическим аргументом для функции с формальным аргументом класса A
то же для возвращаемого значения

общего предка)
сохранить контроль типов
(различать аргументы классов, имеющих общего предка)

const Point& , const String& ) ;
};

class Shell_Window :

public Window {
public:
Shell_Window(const Point& , const Point& , const String& ) ;
void change_size(const Point&);
void execute(const String&);
};
class Input_Window : public Window {
public:
Input_Window(const Point& , const Point& , const String& ) ;
String read_input();
};

видов окон методы
// и является полиморфной
void blank( Window& w )

{
w.clear();
w.move_cursor( Point(0,0) );
w.add( “This window was blank” );
}

char*[ ] ) {
Text_Window tw(Point(10,2), Point(40,6), “TW”);
Shell_Window sw(Point(10,2), Point(40,6), “SW”);
Input_Window

iw(Point(10,2), Point(40,6), “IW”);
sleep(2) ;
blank(tw) ;
blank(sw) ;
blank(iw) ;
sleep(2) ;
}

Input_Window

int yes_or_no(Input_Window& w, const String& question)
{
String answer ;
do

{
w.clear();
w.move_cursor( Point(0,0) );
w.add(question);
answer = w.read_input() ;
} while ( answer != “yes” && answer != “no” );
return answer == “yes” ;
}

общие
// для всех видов окон методы
// и является полиморфной
void collapse(

Window& w ) {
w.clear();
w.change_size( Point(5,5) );
}

{
Window w(Point(10,2), Point(40,6), “W”);
Shell_Window sw(Point(10,2), Point(40,6), “SW”);
w.add(“This is a text

in a Window object”) ;
sw.add(“This is a file list in a Shell_Window ”) ;
sw.execute(“dir”) ;
sleep(2) ;
collapse(w) ;
collapse(sw) ; // окно недопустимо уменьшится
sleep(2) ;
}

какой метод будет вызываться?
Window::change_size(const Point&)
Shell_Window::change_size(const Point&)
Требуются средства языка, обеспечивающие второй

вызов

этапе компиляции
определяется по объявленному типу вызывающего объекта
Динамическое или позднее

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

метод класса Window согласно объявлению формального аргумента
При динамическом связывании компилятор

откладывает выбор метода до выполнения программы, когда есть точная информация о типе объекта – фактического параметра

Объект, как экземпляр класса, должен содержать информацию о своем типе
Требуются

накладные расходы по сравнению со статическим связыванием

связывание
Чтобы применить динамическое связывание для конкретного метода, его надо описать

в базовом классе с ключевым словом virtual
Информация о типе объекта будет анализироваться во время выполнения программы и определять вызов метода (т.е. используется алгоритм вызова)

Point& size,
const String& title);
~Window( );
void move(const

Point& new_upleft);
Point upper_left() const;
Point lower_right() const;
Point size() const;
virtual void change_size(const Point& new_size);
// если новый размер меньше минимального, то окно
// уменьшается только до минимального размера

базового класса
плюс – нет лишних расходов
Все методы объявлять виртуальными
минус –

максимальные накладные расходы
плюс – код базового класса не меняется
Проанализировать возможное развитие класса и объявить виртуальные методы на основе этого анализа
НО как стать таким умным?

{
Window w(Point(10,2), Point(40,6), “W”);
Text_Window tw(Point(20,12), Point(20,5), “TW”);

Shell_Window sw(Point(10,2), Point(40,6), “SW”);
Input_Window iw(Point(10,4), Point(10,8), “IW”);

Window* all_windows[5];
all_windows[0] = &w ;
all_windows[1] = &tw ;
all_windows[2] = &sw ;
all_windows[3] = &iw ;
all_windows[4] = NULL ;
sleep(2) ;
for( int i=0; all_windows[i]; i++ )
collapse(*all_windows[i]) ;
sleep(2) ;
}

Point(5,5) );
}
void main( int, char*[ ] ) {
Window w(Point(10,2), Point(40,6),

“W”);
Shell_Window sw(Point(1,2), Point(40,6), “SW”);
w = sw ;
collapse2(sw) ; // окно недопустимо уменьшится
sleep(2) ;
}

int, char*[ ] ) {
A* po = new B ;

// вызывается конструктор
// класса B
delete po ; // вызывается деструктор класса А
}

class B : public A {
public:
B( );
~B( );
……..
};

main( int, char*[ ] ) {
A* po = new B

; // вызывается конструктор
// класса B
delete po ; // вызывается деструктор класса В
}

class B : public A {
public:
B( );
~B( );
……..
};

существующий код
писать полиморфные функции (функция blank)
писать функции только для определенного

производного класса (функция yes_or_no)
Динамическое связывание требует накладных расходов
Имеет тонкости применения
передача аргумента по ссылке
использование указателей