Linkage (software)

In programming, linkage describes how names can or can not refer to the same entity throughout the whole program or one single translation unit.

The static keyword is used in C to restrict the visibility of a function or variable to its translation unit. This is also valid in C++. C++98 and C++03 deprecated this usage in favor of anonymous namespaces, but is no longer deprecated in C++11. Also, C++ implicitly treats any constnamespace-scope variable as having internal linkage unless it is explicitly declared extern, unlike C.

A name's linkage is related to, but distinct from, its scope. The scope of a name is the part of a translation unit where it is visible. For instance, a name with global scope (which is the same as file-scope in C and the same as the global namespace-scope in C++) is visible in any part of the file. Its scope will end at the end of the translation unit, whether or not that name has been given external or internal linkage.

If the name has external linkage, the entity that name denotes may be referred to from another translation unit using a distinct declaration for that same name, and from other scopes within the same translation unit using distinct declarations. Were the name given internal linkage, such a declaration would denote a distinct entity, although using the same name, but its entity could be referred to by distinct declarations within the same translation unit. A name that has no linkage at all cannot be referred to from declarations in different scopes, not even from within the same translation unit. Examples of such names are parameters of functions and local variables. The details differ between C (where only objects and functions - but not types - have linkage) and C++ and between this simplified overview.

Linkage between languages must be done with some care, as different languages adorn their external symbols differently. A common idiom uses extern"C" to link C++ and C code.

Definition of 'linkage' quoted from ISO/IEC 9899:TC3 (C99 Standard). C uses the term "identifier" where this article uses "name" (the latter of which is what C++ uses to formalize linkage):

An identifier declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage.^[1]

The following is a common example of linkage:

In demo1.c:

// El calificador "extern" es opcional // Por defecto, las funciones tienen enlace externo /* extern */ void foo ( void ); int main ( void ) { foo (); return 0 ; }

En demo2.c :

void foo ( void ) { // implementación real aquí... }

La función foo()se declara en dos archivos, con su cuerpo definido en demo2.c . Mediante enlace, la llamada en demo1.c hace referencia a la llamada en demo2.c . Este es un ejemplo de enlace externo para una función.foo()main()foo

// Si se trata de un compilador de C++, utilice el enlace de C #ifdef __cplusplus extern "C" { #endif// Cualquier símbolo declarado aquí obtiene enlace C void foo (); int bar ( int a , int b );// Si se trata de un compilador de C++, finaliza el enlace con C #ifdef __cplusplus } #endif

void qux ();extern"C"voidfoo(void(*fp)(void));voidbar(){foo(qux);}

 "test.cpp", line 5: Warning (Anachronism): Formal argument fp of type extern "C" void(*)() in call to foo(extern "C" void(*)()) is being passed void(*)().

C++ offers the following forms of linkage:^[5][6]

// static symbols receive internal linkagestaticintdouble(intn){return2*n;}// constexpr implicitly grants internal linkageconstexprsize_tMAX_ATTEMPTS=3;// inline constexpr grants external linkageinlineconstexprsize_tMAX_CONNECTIONS=100;

// A.cppinti=1;// Actual declaration and definition of i// B.cppexterninti;// Declares the existence of i// C.cpp int i = 2 ; // Error: i ya está definido (en A.cpp) extern int i = 3 ; // Mismo error

exportar módulo wikipedia.ejemplos.mylib ;​​​​export extern "C++" { // Fuerza que el contenido del encabezado tenga una conexión de módulo global cuando se exporta #include <wikipedia/examples/MyLib.hpp> }

paquete org.wikipedia.examples ;clase pública Foo { int público agregar ( int a , int b ) { return a + b ; } }

#incluir <gcj/cni.h>// Encabezado generado automáticamente #include <org/wikipedia/examples/Foo.h>usando org :: wikipedia :: ejemplos :: Foo ;extern "Java" { int addThroughJava ( int a , int b ) { Foo * foo = new Foo (); return foo -> add ( a , b ); // Nota: foo no debe eliminarse, ya que es un objeto gestionado por el recolector de basura de Java } }

En D , un bloque de código que se pretende declarar como proveniente de otro lenguaje puede marcarse :extern(...)

• extern(C)^{[ 11 ]} (paraC)
• extern(C++)^{[ 12 ]} (paraC++)
• extern(Objective-C)^{[ 13 ]} (paraObjective-C)
• extern(D)^{[ 14 ]}

En Rust , se utiliza para marcar el enlace C, y siempre es , ya que Rust no puede garantizar la seguridad de las funciones externas. ^{[ 15 ]}extern"C"unsafe

use std :: ffi ::{ CString , c_char };unsafe extern "C" { fn puts ( s : * const c_char ) -> i32 ; }fn main () { let s = CString :: new ( "Hello from Rust!" ). unwrap ();inseguro { puts ( s . as_ptr ()); } }

Mientras tanto, para exponer las funciones de Rust a C:

#[unsafe(no_mangle)] pub extern "C" fn add ( a : i32 , b : i32 ) -> i32 { a + b }

Rust ofrece los siguientes bloques externos: ^{[ 16 ]}

• unsafeextern"Rust"(Convención de llamada predeterminada en Rust)
• unsafeextern"C"(la ABI de C predeterminada)

Existen otros bloques específicos del sistema, muchos de los cuales corresponden a atributos del compilador C/C++, por ejemplo, correspondientes a .unsafeextern"stdcall"[[gnu::stdcall]]

• Interfaz binaria de la aplicación (ABI)
• Compatibilidad de C y C++
• Enlazador (informática)
• Deformación de nombres