¿Qué es la vinculación temprana y tardía?

Hay dos conceptos principales en confusión: encuadernación y carga. Se confunde con el concepto de DataBinding, que está en algún lugar en el medio a menudo haciendo ambas cosas. Después de considerarlo, voy a agregar un concepto más, para completar la trifecta, el envío.

Tipos

Enlace tardío : el tipo es desconocido hasta que la variable se ejerce durante el tiempo de ejecución; por lo general a través de la asignación, pero hay otros medios para forzar a un tipo; los idiomas tipeados dinámicamente llaman a esto una característica subyacente, pero muchos lenguajes tipificados estáticamente tienen algún método para lograr un enlace tardío

Se implementa a menudo utilizando tipos dinámicos [especiales], introspección / reflexión, opciones de indicadores y compiladores, o mediante métodos virtuales mediante préstamos y extensiones de envío dinámico

Enlace temprano : se conoce el tipo antes de que la variable se ejecute durante el tiempo de ejecución, generalmente a través de medios declarativos estáticos

Se implementa a menudo utilizando tipos primitivos estándar

Funciones

Envío estático : función específica conocida o subrutina en tiempo de compilación; es inequívoco y está emparejado por la firma

Implementado como funciones estáticas; ningún método puede tener la misma firma

Dynamic Dispatch : no es una función específica o subrutina en tiempo de compilación; determinado por el contexto durante la ejecución. Hay dos enfoques diferentes para el "envío dinámico", que se distinguen por la información contextual que se utiliza para seleccionar la implementación de la función adecuada.

En single [ dynamic ] dispatch , solo se utiliza el tipo de instancia para determinar la implementación de la función adecuada. En lenguajes de tipo estático, lo que esto significa en la práctica es que el tipo de instancia decide qué implementación de método se usa independientemente del tipo de referencia indicado cuando la variable se declara / asigna. Debido a que solo se utiliza un solo tipo, el tipo de la instancia del objeto, para inferir la implementación apropiada, este enfoque se denomina "envío único".

También hay múltiple [ dinámico ] envío , donde los tipos de parámetros de entrada también ayudan a determinar a qué función de implementación llamar. Debido a que varios tipos, tanto el tipo de instancia como el tipo (s) de los parámetros (s), influyen en la implementación del método seleccionado, este enfoque se denomina "envío múltiple".

Implementado como funciones virtuales o abstractas; otras pistas incluyen métodos anulados, ocultos o sombreados.

NB: Si la sobrecarga de métodos implica un envío dinámico es específico del idioma. Por ejemplo, en Java, los métodos sobrecargados se distribuyen de forma estática .

Valores

Carga diferida : estrategia de inicialización del objeto que difiere la asignación de valor hasta que sea necesario ; permite que un objeto esté en un estado esencialmente válido pero a sabiendas incompleto y que espere hasta que se necesiten los datos antes de cargarlo; a menudo es especialmente útil para cargar grandes conjuntos de datos o esperar en recursos externos

Se implementa con frecuencia al no cargar una colección o lista a propósito en un objeto compuesto durante las llamadas del constructor o de la inicialización hasta que alguna persona que llama en sentido descendente solicita ver el contenido de dicha colección (por ejemplo, get_value_at, get_all_as, etc.). Las variaciones incluyen la carga de metainformación sobre la colección (como tamaño o claves), pero omitiendo los datos reales; también proporciona un mecanismo para algunos tiempos de ejecución para proporcionar a los desarrolladores un esquema de implementación Singleton bastante seguro y eficiente

Carga impaciente : estrategia de inicialización del objeto que realiza de inmediato todas las asignaciones de valores para que todos los datos deban estar completos antes de considerarse que están en un estado válido.

Se implementa a menudo proporcionando objetos compuestos con todos sus datos conocidos tan pronto como sea posible, como durante una llamada o inicialización del constructor

Enlace de datos : a menudo implica la creación de un enlace activo o mapa entre dos flujos de información compatibles para que los cambios en uno se reflejen en el otro y viceversa; para ser compatibles, a menudo tienen que tener un tipo de base o interfaz común

Se implementa a menudo como un intento de proporcionar una sincronización más clara y coherente entre los diferentes aspectos de la aplicación (por ejemplo, ver el modelo para ver, modelar para el controlador, etc.) y habla sobre conceptos como origen y destino, puntos finales, enlace / desvinculación, actualización, y eventos como on_bind, on_property_change, on_explicit, on_out_of_scope

NOTA DE EDICIÓN: Última edición importante para proporcionar una descripción de ejemplos de cómo ocurren a menudo. Los ejemplos de códigos particulares dependen completamente de la implementación / tiempo de ejecución / plataforma

Cualquier cosa que se decida por el compilador mientras se compila puede referirse a TIEMPO TEMPRANO / COMPILADO y cualquier cosa que se decida en RUNTIME se llama TARDE / DURACIÓN vinculante.

Por ejemplo,

Método Sobrecarga y Método Anulación .

1) En Sobrecarga de métodos , el compilador decide sus métodos a los métodos, en el sentido de que el compilador decide la función a la que se va a llamar en el momento de la compilación. De ahí que sea VINCULACIÓN TEMPRANA .

2) En la Anulación del método, en RUNTIME se decide a qué método se llamará. Por lo tanto, se refiere como TARDE CLASIFICACIÓN .

Intenté mantenerlo simple y fácil de conseguir. Espero que esto ayude.

La vinculación tardía es cuando el comportamiento se evalúa en tiempo de ejecución. Es necesario cuando realmente desea determinar cómo actuar basándose en la información que solo tiene cuando el programa se está ejecutando. El ejemplo más claro en mi opinión es el mecanismo de la función virtual, específicamente en C ++.

class A
{
public:
    void f() {}
    virtual void g() {}
};

class B : public A
{
    void f() {}
    virtual void g() {}
};

int main()
{
    A* a = new B;
    a->f();
    a->g();
}

En este ejemplo, a->f() en realidad llamará a void A::f() , porque está enlazado de manera temprana (o estática), por lo que el programa en tiempo de ejecución piensa es solo un indicador de un tipo A variable, mientras que a->g() realmente llamará void B::g() , porque el compilador, al ver que g() es virtual, inyecta código para buscar la dirección de la función correcta para llamar en tiempo de ejecución.

si está familiarizado con los punteros de función, este sería un ejemplo. Se puede decir que las funciones definidas son de enlace temprano. mientras que si usas punteros de función su vinculación tardía.

  int add(int x,int y)
  {
    return x+y;
  }
  int sub(int x,int y)
  {
      return x-y;
  }


    int main()
    {
     //get user choice
     int(*fp)(int,int);
     //if add
      fp=add;
     //else if sub
     fp=sub;
     cout<<fp(2,2);
    }

aquí las funciones agregar y sub son funciones (su dirección se enlaza al compilar el vinculador de tiempo)

pero el puntero a la función está enlazado tarde que fp puede llamar a agregar o sub en función de la elección del usuario [en tiempo de ejecución].

La vinculación temprana y tardía solo tiene sentido en el contexto de los tipos y no en la forma en que la describe. Casi todos los lenguajes modernos están escritos en el sentido de que todos los valores tienen tipos fijos. La diferencia se produce cuando nos fijamos en los idiomas tipificados de forma dinámica o estática. En los idiomas tipeados dinámicamente, las variables no tienen tipos, por lo que pueden referirse a valores de cualquier tipo y esto significa que cuando llama a un método en un objeto al que hace referencia una variable, la única forma de determinar si esa llamada es válida o no es busque la clase para el objeto y vea si ese método existe realmente. Esto permite algunas cosas interesantes, como agregar nuevos métodos a las clases en el tiempo de ejecución porque la búsqueda del método real se aplaza hasta el último momento. La mayoría de las personas llaman a este estado de cosas tarde vinculante.

En un lenguaje de tipo estático, las variables tienen tipos y una vez declaradas no pueden referirse a ningún valor que no sea del mismo tipo. Esto no es estrictamente cierto, pero asumámoslo por ahora. Ahora, si sabe que la variable solo se referirá a valores de un tipo específico, entonces no hay razón para averiguar si una llamada de método es válida o no en el tiempo de ejecución, ya que puede determinar la validez antes de ejecutar el código. Esto se conoce como vinculación temprana.

Un ejemplo para demostrar el enlace tardío en ruby:

a = 1 # a is an integer at this point
a.succ # asking for its successor is valid

class A
  def method_a
    # some code
  end
end

a = A.new
a.method_a # this is also valid
a.succ # this is not valid


class A # we can re-open the class and add a method
  def succ
    # some more code
  end
end
a.succ # now this is valid

La secuencia de acciones anterior no es posible en un lenguaje como Java donde todos los tipos se corrigen en el tiempo de ejecución.

En lugar de darte una definición académica, intentaré mostrarte algunas de las diferencias usando un ejemplo del mundo real usando VBA:

Enlace temprano:

Dim x As FileSystemObject
Set x = New FileSystemObject
Debug.Print x.GetSpecialFolder(0)

Esto requiere que se establezca una referencia al componente "Microsoft Scripting Runtime" en tiempo de diseño . Tiene la ventaja de que recibe un mensaje de error en el momento de la compilación cuando tiene un error tipográfico en FileSystemObject o nombres de métodos como GetSpecialFolder .

Enlace tardío

Dim x As Object
Set x = CreateObject("Scripting.FileSystemObject")
Debug.Print x.GetSpecialFolder(0)

Esto no requiere que se establezca una referencia de antemano, la creación de la instancia y la determinación del tipo solo ocurrirán en tiempo de ejecución. El compilador no se quejará en tiempo de compilación cuando intenta llamar a un método inexistente de x , esto llevará a un error de tiempo de ejecución solo cuando se ejecuta la línea específica.

Por lo tanto, la desventaja de la vinculación tardía es que no tiene ningún tipo de comprobación fuerte aquí. Pero esa es también la ventaja: supongamos que tiene un componente donde existen varias versiones, y cada versión más reciente proporciona algunas funciones adicionales. (Un ejemplo del mundo real son los componentes de MS Office, como la interfaz COM de Excel). solo una versión anterior disponible, evite ejecutar funciones que no funcionen con esa versión.

Quizás el ejemplo más común de enlace tardío es resolver URL de Internet. Admite sistemas dinámicos y sistemas grandes sin tratar de vincular y enlazar todos los sitios del mundo antes de que pueda alcanzarlos, pero por otro lado incurre en algunos gastos generales (búsqueda de DNS, mucho menos enrutamiento de IP) en tiempo de ejecución.

De esa manera, la mayoría de las variedades de vinculación en entornos de lenguaje son más o menos tempranas, en tiempo de compilación o de enlace.

Cada tipo tiene costos y beneficios.