Позднее связывание

Эта статья посвящена связыванию имени с операцией. Информацию о выборе реализации полиморфной операции см. в разделе Динамическая диспетчеризация .

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

При раннем связывании , или статическом связывании , в объектно-ориентированном языке этапе компиляции исправляются все типы переменных на и выражений . Обычно оно сохраняется в скомпилированной программе как смещение в таблице виртуальных методов («v-таблица»). Напротив, при позднем связывании компилятор не считывает достаточно информации, чтобы проверить существование метода или связать его слот в v-таблице. Вместо этого метод ищется по имени во время выполнения.

Основное преимущество использования позднего связывания в программировании модели компонентных объектов (COM) заключается в том, что компилятор не требует ссылки на библиотеки, содержащие объект, во время компиляции . Это делает процесс компиляции более устойчивым к конфликтам версий, при которых v-таблица класса может быть случайно изменена. (Это не проблема для платформ, скомпилированных точно в срок, таких как .NET или Java , поскольку v-таблица создается во время выполнения виртуальной машиной на основе библиотек, когда они загружаются в работающее приложение. )

История

Термин «позднее связывание» восходит как минимум к 1960-м годам, где его можно найти в «Сообщениях ACM» . Этот термин широко использовался для описания соглашений о вызовах в таких языках, как Lisp, хотя обычно он имел негативный оттенок в отношении производительности.

В 1980-х годах Smalltalk популяризировал объектно-ориентированное программирование (ООП), а вместе с ним и позднее связывание. Алан Кей однажды сказал: «Для меня ООП означает только обмен сообщениями, локальное сохранение, защиту и сокрытие состояний-процессов, а также чрезвычайно позднее связывание всех вещей. Это можно сделать в Smalltalk и в LISP. Возможно, существуют и другие системы в что это возможно, но я о них не знаю».

В начале-середине 1990-х годов Microsoft активно продвигала свой стандарт COM как двоичный интерфейс между различными языками ООП-программирования. COM-программирование в равной степени способствовало раннему и позднему связыванию, при этом многие языки поддерживают и то, и другое на уровне синтаксиса.

В 2000 году Алекс Мартелли ввёл термин « утиная типизация » для обозначения аналогичной концепции, но с другим акцентом. В то время как позднее связывание обычно фокусируется на деталях реализации, утиная типизация фокусируется на возможности игнорировать типы и концентрироваться на методах, которые объект имеет в данный момент.

Поздние реализации связывания

Позднее связывание в динамически типизированных объектно-ориентированных языках.

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

Позднее связывание в Лиспе

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

Пример использования интерактивного сеанса Clozure Common Lisp :

? (defun foo ()
    (bar pi))   ; a still undefined function BAR gets called
;Compiler warnings :
;   In FOO: Undefined function BAR
FOO

? (defun bar (x)   ; now we define it
    (* x 2))
BAR

? (foo)    ; calling foo and it uses the recent definition of BAR
6.283185307179586D0

? (defun bar (x)   ; now we redefine BAR
    (* x 1000))
BAR

? (foo)    ;  FOO now calls the new function, there is no need to recompile/link/load FOO
3141.592653589793D0

? (type-of 'bar)   ;  BAR is a symbol
SYMBOL

? (symbol-function 'bar)  ; the symbol BAR has a function binding
#<Compiled-function BAR #x302000D1B21F>

Позднее связывание в C++

В C++ позднее связывание (также называемое «динамическим связыванием») означает то, что обычно происходит, когда virtual Ключевое слово используется в объявлении метода. Затем C++ создает так называемую виртуальную таблицу , которая представляет собой справочную таблицу для таких функций, к которым всегда будут обращаться при их вызове. Обычно термин «позднее связывание» используется в пользу « динамической отправки ».

Позднее связывание на языках COM

В COM-программировании вызов метода с поздней привязкой выполняется с использованием интерфейса IDispatch . Некоторые языки на основе COM, такие как Visual Basic 6, имеют синтаксическую поддержку вызова этого интерфейса. Это делается путем определения типа переменной как Object. Другие, такие как C++, требуют, чтобы вы явно вызывали GetIDsOfNames для поиска метода и Invoke для его вызова.

Позднее связывание в .NET

связывание означает переопределение В .NET позднее virtual метод, такой как C++, или реализация интерфейса. Компилятор создает виртуальные таблицы для каждого вызова виртуального или интерфейсного метода, который используется во время выполнения для определения реализации для выполнения.

Также, как и COM и Java, среда Common Language Runtime предоставляет API-интерфейсы отражения, которые могут выполнять вызовы позднего связывания. Использование этих вызовов зависит от языка.

В C# 4 в язык также добавлен псевдотип «динамический». Это будет использоваться вместо типа Object, чтобы указать, что желательно позднее связывание. Конкретный необходимый механизм позднего связывания определяется во время выполнения с использованием среды выполнения динамического языка в качестве отправной точки.

Visual Basic использует их всякий раз, когда переменная имеет тип Object и действует директива компилятора «Option Strict Off». Это настройка по умолчанию для нового проекта VB. До версии 9 позднее связывание можно было выполнять только для объектов .NET и COM. В VB 10 это было распространено на объекты на основе DLR.

Позднее связывание в Java

В Java существует три определения позднего связывания.

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

В настоящее время в Java-программировании популярно использовать термин «позднее связывание» как синоним динамической диспетчеризации . Java, В частности, это относится к механизму единой диспетчеризации используемому с виртуальными методами.

Наконец, Java может использовать позднее связывание, используя свои API-интерфейсы отражения, и интроспекцию типов почти так же, как это делается в программировании COM и .NET. Вообще говоря, те, кто программирует только на Java, не называют это поздним связыванием. Точно так же в программировании на Java не одобряется использование методов «утиной типизации», вместо этого используются абстрактные интерфейсы.

Известно, что Oracle, нынешний владелец Java, использует термин «позднее связывание» в смысле «утиной типизации» при обсуждении Java и других языков в одной и той же документации.

Раннее и позднее связывание в PL/SQL и Ada

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

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

Это различие, по-видимому, уникально для PL/SQL и Ada. Другие языки, которые могут вызывать процедуры PL/SQL, а также другие механизмы баз данных, используют только позднее связывание.

Критика

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

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

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

См. также

• Привязка имени