In programming language
s, name binding is the association of entities (data and/or code) with identifier
An identifier bound to an object is said to reference
that object. Machine language
s have no built-in notion of identifiers, but name-object bindings as a service and notation for the programmer is implemented by programming languages. Binding is intimately connected with scoping
, as scope determines which names bind to which objects – at which locations in the program code (lexically
) and in which one of the possible execution paths (temporally
Use of an identifier
in a context that establishes a binding for
is called a binding (or
defining) occurrence. In all other occurrences (e.g., in expressions, assignments, and subprogram calls), an identifier stands for what it is bound to; such occurrences are called applied occurrences.
* ''Static binding'' (or ''early binding'') is name binding performed before the program is run.
* ''Dynamic binding'' (or ''late binding'' or ''virtual binding'') is name binding performed as the program is running.
An example of a static binding is a direct C
function call: the function referenced by the identifier cannot change at runtime.
But an example of dynamic binding is dynamic dispatch
, as in a C++
virtual method call. Since the specific type of a polymorphic
object is not known before runtime (in general), the executed function is dynamically bound. Take, for example, the following Java
public void foo(java.util.List list)
is an interface
must refer to a subtype
of it. Is it a reference to a
, or some other subtype
? The actual method referenced by
is not known until runtime. In C, such an instance of dynamic binding may be a call to a function pointed to by a variable or expression of a function pointer type whose value is unknown until it actually gets evaluated at run-time.
Rebinding and mutation
Rebinding should not be confused with mutation.
* ''Rebinding'' is a change to the ''referencing'' identifier.
* ''Mutation'' is a change to the ''referenced'' entity.
Consider the following Java
list = new LinkedList();
list = null;
initially references nothing (it is uninitialized
); it is then rebound to reference an object (a linked list of strings). The linked list referenced by
is then mutated, adding a string to the list. Lastly,
is rebound to
Late static binding is a variant of binding somewhere between static and dynamic binding. Consider the following PHP
class B extends A
In this example, the PHP interpreter binds the keyword
, and so the call to
produces the string "hello". If the semantics of
had been based on late static binding, then the result would have been "bye".
Beginning with PHP version 5.3, late static binding is supported.
in the above were changed to
as shown in the following block, where the keyword
would only be bound at runtime, then the result of the call to
would be "bye":
class B extends A
* Late binding
* Branch table
method of applying name binding via branch table or function pointers
* Dynamic dispatch
* Higher-order abstract syntax
Category:Programming language concepts
Category:Articles with example Java code
pt:Vinculação de nomes (computação)