Понятие статического и динамического связывания. Понятие статического и динамического связывания Статическое и динамическое связывание c

Я действительно запутался в динамической привязке и статической привязке. Я читал, что определение типа объекта во время компиляции называется статической привязкой и определение его во время выполнения называется динамическим связыванием.

Что происходит в коде ниже:

Статическое связывание или динамическое связывание?
Что это за полиморфизм?

Class Animal { void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { void eat() { System.out.println("Dog is eating"); } } public static void main(String args) { Animal a=new Animal(); a.eat(); }

2018-05-20 10:33

2018-05-20 10:46

Проверь это класс сотрудника имеет абстрактный earning() функции, и каждый класс имеет toString() реализация

Employee employees = new Employee; // initialize array with Employees employees = new SalariedEmployee(); employees = new HourlyEmployee(); employees = new CommissionEmployee(); employees = new BasePlusCommissionEmployee(); for (Employee currentEmployee: employees){ System.out.println(currentEmployee); // invokes toString System.out.printf("earned $%,.2f%n", currentEmployee.earnings()); }

Все вызовы метода toString а также earnings разрешаются на execution time , на основе type of the object к которому относится текущий сотрудник,

Этот процесс известен как dynamic binding или late binding

Начиная с версии PHP 5.3.0 появилась особенность, называемая позднее статическое связывание, которая может быть использована для того чтобы получить ссылку на вызываемый класс в контексте статического наследования.

Если говорить более точно, позднее статическое связывание сохраняет имя класса указанного в последнем "не перенаправленном вызове". В случае статических вызовов это явно указанный класс (обычно слева от оператора :: ); в случае не статических вызовов это класс объекта. "Перенаправленный вызов" - это статический вызов, начинающийся с self:: , parent:: , static:: , или, если двигаться вверх по иерархии классов, forward_static_call() . Функция get_called_class() может быть использована чтобы получить строку с именем вызванного класса, и static:: представляет ее область действия.

Само название "позднее статическое связывание" отражает в себе внутреннюю реализацию этой особенности. "Позднее связывание" отражает тот факт, что обращения через static:: не будут вычисляться по отношению к классу, в котором вызываемый метод определен, а будут вычисляться на основе информации в ходе исполнения. Также эта особенность была названа "статическое связывание" потому, что она может быть использована (но не обязательно) в статических методах.

Ограничения self::

Пример #1 Использование self::

class A {
echo __CLASS__ ;
}
public static function test () {
self :: who ();
}
}

class B extends A {
public static function who () {
echo __CLASS__ ;
}
}

B :: test ();
?>

Использование позднего статического связывания

Позднее статическое связывание пытается устранить это ограничение предоставляя ключевое слово, которое ссылается на класс, вызванный непосредственно в ходе выполнения. Попросту говоря, ключевое слово, которое позволит вам ссылаться на B из test() в предыдущем примере. Было решено не вводить новое ключевое слово, а использовать static , которое уже зарезервировано.

Пример #2 Простое использованиеstatic::

class A {
public static function who () {
echo __CLASS__ ;
}
public static function test () {
static:: who (); // Здесь действует позднее статическое связывание
}
}

class B extends A {
public static function who () {
echo __CLASS__ ;
}
}

B :: test ();
?>

Результат выполнения данного примера:

Замечание :

В нестатическом контексте вызванным классом будет тот, к которому относится экземпляр объекта. Поскольку $this-> будет пытаться вызывать закрытые методы из той же области действия, использование static:: может дать разные результаты. Другое отличие в том, что static:: может ссылаться только на статические поля класса.

Пример #3 Использование static:: в нестатическом контексте

class A {
private function foo () {
echo "success!\n" ;
}
public function test () {
$this -> foo ();
static:: foo ();
}
}

class B extends A {
/* foo() будет скопирован в В, следовательно его область действия по прежнему А,
и вызов будет успешен*/
}

class C extends A {
private function foo () {
/* исходный метод заменен; область действия нового метода С */
}
}

$b = new B ();
$b -> test ();
$c = new C ();
$c -> test (); //не верно
?>

Результат выполнения данного примера:

success! success! success! Fatal error: Call to private method C::foo() from context "A" in /tmp/test.php on line 9

Замечание :

Разрешающая область позднего статического связывания будет фиксирована вычисляющем ее статическим вызовом. С другой стороны, статические вызовы с использованием таких директив как parent:: или self:: перенаправляют информацию вызова.

Пример #4 Перенаправленные и не перенаправленные вызовы

Связывание в языке C++

Двумя основными целями при разработке языка программирования С++ были эффективное использование памяти и скорость выполнения. Он был задуман как усовершенствование языка С, в частности, для объектно-ориентированных приложений. Основной принцип С++: никакое свойство языка не должно приводить к возникновению дополнительных издержек (как по памяти, так и по скорости), если данное свойство программистом не используется. Например, если вся объектная ориентированность С++ игнорируется, то оставшаяся часть должна работать так же быстро, как и традиционный С. Поэтому неудивительно что большинство методов в С++ связываются статически (во время компиляции), а не динамически (во время выполнения).

Связывание методов в этом языке является довольно сложным. Для обычных переменных (не указателей или ссылок) оно осуществляется статически. Но когда объекты обозначаются с помощью указателей или ссылок, используется динамическое связывание. В последнем случае решение о выборе метода статического или динамического типа диктуется тем, описан ли соответствующий метод с помощью ключевого слова virtual. Если он объявлен именно так, то метод поиска сообщения базируется на динамическом классе, если нет на статическом. Даже в тех случаях, когда используется динамическое связывание, законность любого запроса определяется компилятором на основе статического класса получателя.

Рассмотрим, например, следующее описание классов и глобальных переменных: class Mammal

printf («cant speak»);

class Dog: public Mammal

printf («wouf wouf»);

printf («wouf wouf, as well»);

Mammal *fido = new Dog;

Выражение fred.speak() печатает «cant speak», однако вызов fido->speak() также напечатает «cant speak», поскольку соответствующий метод в классе Mammal не объявлен как виртуальный. Выражение fido->bark() не допускается компилятором, даже если динамический тип для fido класс Dog. Тем не менее статический тип переменной всего лишь класс Mammal.

Если мы добавим слово virtual:

virtual void speak()

printf («cant speak»);

то получим на выходе для выражения fido->speak() ожидаемый результат.

Относительно недавнее изменение в языке С++ добавление средств для распознавания динамического класса объекта. Они образуют систему RTTI (Run-Time Type Identification идентификация типа во время выполнения).

В системе RTTI каждый класс имеет связанную с ним структуру типа typeinfo, которая кодирует различную информацию о классе. Поле данных name одно из полей данных этой структуры содержит имя класса в виде текстовой строки. Функция typeid может использоваться для анализа информации о типе данных. Следовательно, следующая ниже команда будет печатать строку «Dog» динамический тип данных для fido. В этом примере необходимо разыменовывать переменную-указатель fido, чтобы аргумент был значением, на которое ссылается указатель, а не самим указателем:

cout << «fido is a» << typeid(*fido).name() << endl;

Можно также спросить, используя функцию-член before, соответствует ли одна структура с информацией о типе данных подклассу класса, соотносящегося с другой структурой. Например, следующие два оператора выдают true и false:

if (typeid(*fido).before (typeid(fred)))…

if (typeid(fred).before (typeid(lassie)))…

До появления системы RTTI стандартный программистский трюк состоял в том, чтобы явным образом закодировать в иерархии класса методы быть экземпляром. Например, для проверки значения переменных типа Animal на принадлежность к типу Cat или к типу Dog можно было бы определить следующую систему методов:

virtual int isaDog()

virtual int isaCat()

class Dog: public Mammal

virtual int isaDog()

class Cat: public Mammal

virtual int isaCat()

Теперь для определения того, является ли текущим значением переменной fido величина типа Dog, можно использовать команду fido->isaDog(). Если возвращается ненулевое значение, то можно привести тип переменной к нужному типу данных.

Возвращая указатель, а не целое число, мы объединяем проверку на принадлежность к подклассу и приведение типа. Это аналогично другой части системы RTTI, называемой dynamic_cast, которую мы вкратце опишем. Если некая функция в классе Mammal возвращает указатель на Dog, то класс Dog должен быть предварительно описан. Результатом присваивания является либо нулевой указатель, либо правильная ссылка на класс Dog. Итак, проверка результата все еще должна осуществляться, но мы исключаем необходимость приведения типа. Это показано в следующем примере:

class Dog; // предварительное описание

virtual Dog* isaDog()

virtual Cat* isaCat()

class Dog: public Mammal

virtual Dog* isaDog()

class Cat: public Mammal

virtual Cat* isaCat()

Оператор lassie = fido->isaDog(); теперь выполним всегда. В результате переменная lassie получает ненулевое значение, только если fido имеет динамический класс Dog. Если fido не принадлежит Dog, то переменной lassie будет присвоен нулевой указатель.

lassie = fido->isaDog();

… // fido и в самом деле относится к типу Dog

… // присваивание не сработало

… // fido не принадлежит к типу Dog

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

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

// конвертировать только в том случае, если fido является собакой

lassie = dynamic_cast < Dog* > (fido);

// затем проверить, выполнено ли приведение

В язык C++ были добавлены еще три типа приведения (static_cast, const_cast и reinterpret_cast), но они используются в особых случаях и поэтому здесь не описываются. Программистам рекомендуется применять их как более безопасные средства вместо прежнего механизма приведения типов.

2. Проектная часть

Связывание - подстановка в коды программы вызовов конкретных функций -методов класса . Имеет смысл только для производных классаов.

Обычно компилятор имеет необходимую информацию для того, чтобы определить, какая функция имеется в виду. Например, если в программе встречается вызов obj.f(), компилятор однозначно выбирает функцию f()в зависимости от типа адресатаobj. Если в программе используются указатели на экземпляры класса:ptr->f(), выбор функции - метода класса определяется типом указателя.

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

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

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

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

Виртуальные функции

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

Виртуальные функции:

имеют в прототипе в базовом классе ключевое слово virtual;

обязательно функции-члены класса:

Во всех производных классах должны иметь такой же прототип (указание слова virtualв производных классах не обязательно).

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

Пример: классы Точка и Окружность.

virtual void print();

class Circle: public Point{

void print(); // можно virtual void print();

void Point::print()

cout << "Point (" << x << ", " << y << ")";

void Circle::print()

cout << "Circle with center in "; Point::print();

cout << "and radius " << rad;

Использование:

Point p1(3,5), p2(1,1), *pPtr;

Cicle c1(1), c2(p2, 1);

pPtr = &p1; pPtr->print(); // получим: Point (3, 5)

pPtr = &c2; pPtr->print(); // получим:

Circle with center in Point (1, 1) and radius 1

Пример использования динамического связывания: список

Наиболее часто динамичесое связывание используется с контейнерными классами, содержащими указатель на базовый класс; в такие контейнерные классы можно включать информацию, относящуюся и к базовому, и к любым производным классам.

Рассмотрим пример - список, содержащий и точки, и окружности.

// конструктор

Item():info(NULL), next(NULL){}

Item(Point *p):info(p), next(NULL){}

List():head(NULL){}

void insert(Point *p){p->next = head; head = p;}

void List::print()

for(Item *cur = head; cur; cur = cur->next){

cur->info->print();

cout << endl;

Использование класса:

Point *p = new Point(1,2);

mylist.insert(p);

p = new Cicle(1,2,1);

mylist.insert(p);

Circle with center in Point (1, 2) and radius 1