Escriba la firma

format_list_bulleted Contenido keyboard_arrow_down

ImprimirCitar

Define las entradas y salidas para una función, subrutina o método

En informática, una firma de tipo o anotación de tipo define las entradas y salidas de una función, subrutina o método. Una firma de tipo incluye el número, los tipos y el orden de los argumentos contenidos en una función. Una firma de tipo se usa típicamente durante la resolución de sobrecarga para elegir la definición correcta de una función que se llamará entre muchas formas sobrecargadas.

Ejemplos

C/C++

En C y C++, la firma de tipo se declara mediante lo que comúnmente se conoce como prototipo de función. En C/C++, una declaración de función refleja su uso; por ejemplo, un puntero de función con la firma (int)(char, doble) sería llamado como:

char c;doble d;int Ret Val = ()*f Ptr)c, d);

`Erlang`

En Erlang, las firmas de tipo pueden declararse opcionalmente, como:

-spec función_nombre()Tipo1(), Tipo2(), ...) - out_type().

Por ejemplo:

-spec ################################################################################################################################################################################################################################################################()Número()) - boolean().

`Haskell`

Una firma de tipo en Haskell generalmente toma la siguiente forma:

función Nombre :: arg1 Tipo - arg2 Tipo - ... - argNType

Observe que el tipo del resultado se puede considerar como todo lo que está más allá del primer argumento proporcionado. Esta es una consecuencia del curry, que es posible gracias al soporte de Haskell para funciones de primera clase; esta función requiere dos entradas donde se proporciona un argumento y la función es "currida" para producir una función para el argumento no proporcionado. Por lo tanto, llamar a f x, donde f :: a -> b -> c, produce una nueva función f2 :: b -> c que se puede llamar f2 b para producir c.

Las especificaciones de tipo reales pueden consistir en un tipo real, como Entero, o una variable de tipo general que se usa en funciones polimórficas paramétricas, como a, o b, o cualquierTipo. Entonces podemos escribir algo como: nombre de función :: a -> a -> ... -> a

Dado que Haskell admite funciones de orden superior, las funciones se pueden pasar como argumentos. Esto se escribe como: nombre de función :: (a -> a) -> a

Esta función toma una función con firma de tipo a -> a y devuelve datos de tipo a fuera.

`Java`

En la máquina virtual Java, las firmas de tipo internas se utilizan para identificar métodos y clases en el nivel del código de la máquina virtual.

Ejemplo: El método String Cadena.subcadena(int, int) se representa en bytecode como Ljava/lang /Cadena.subcadena(II)Ljava /idioma/Cadena;.

La firma del método main parece este:

público estática vacío principal()String[] args);

Y en el bytecode desensamblado, toma la forma de Lsome /paquete/Principal/principal:([Ljava/lang/Cadena;)V

La firma del método para main() El método contiene tres modificadores:

public indica que main() método puede ser llamado por cualquier objeto.
static indica que main() método es un método de clase.
void indica que main() método no tiene valor de retorno.

`Firma`

La firma de una función consiste en el prototipo de función. Especifica la información general sobre una función como el nombre, el alcance y los parámetros. Muchos lenguajes de programación utilizan la manipulación de nombres para transmitir más información semántica de los compiladores a los enlazadores. Además de la manipulación, hay un exceso de información en la firma de una función (almacenada internamente en la mayoría de los compiladores) que no está fácilmente disponible, pero se puede acceder a ella.

Comprender la noción de una firma de función es un concepto importante para todos los estudios de informática.

Las técnicas modernas de orientación de objetos hacen uso de interfaces, que son esencialmente plantillas hechas de firmas de funciones.
C++ utiliza la sobrecarga de funciones con varias firmas.

La práctica de la herencia múltiple requiere la consideración de las firmas de funciones para evitar resultados impredecibles.

La teoría de la informática, y el concepto de polimorfismo en particular, hacen mucho uso del concepto de firma de función.

En el lenguaje de programación C, la firma es aproximadamente equivalente a su definición de prototipo.

Did you mean: The term n#34;signature" may carry other meanings in computer science: 
Las firmas de archivos pueden identificar o verificar el contenido de un archivo.
Las firmas de bases de datos pueden identificar o verificar el esquema o una versión de una base de datos.
En la familia ML de lenguajes de programación, la "signatura" se utiliza como una palabra clave que se refiere a una construcción del sistema de módulos que desempeña el papel de una interfaz.
Firma del método
En la programación de computadoras, especialmente en la programación orientada a objetos, un método se identifica comúnmente por su firma de método única, que generalmente incluye el nombre del método y el número, tipos y orden de sus parámetros. Una firma de método es el tipo más pequeño de un método.
Ejemplos
C/C++
En C/C++, la firma del método es el nombre del método y el número y tipo de sus parámetros, pero es posible tener un último parámetro que consiste en una matriz de valores:
int printf()const char*, ... );
La manipulación de estos parámetros se puede realizar utilizando las rutinas en el encabezado de la biblioteca estándar <stdarg.h>.
En C++, el tipo de retorno también puede seguir la lista de parámetros, lo que se conoce como tipo de retorno final. La diferencia es solo sintáctica; en cualquier caso, la firma resultante es idéntica:
auto printf()const char*... ) - int;
C#
De manera similar a la sintaxis de C, las firmas de métodos en C# se componen de un nombre y el número y tipo de sus parámetros, donde el último parámetro puede ser una matriz de valores:
vacío Añadir()Fuera. int suma, params int[] valor);[...]Añadir()Fuera. suma, 3, 5, 7, 11, -1); // sum = = 25
Java
En Java, la firma de un método se compone de un nombre y el número, tipo y orden de sus parámetros. Los tipos de retorno y las excepciones lanzadas no se consideran parte de la firma del método, ni tampoco los nombres de los parámetros; el compilador los ignora para verificar la unicidad del método.
Las firmas de los métodos ayudan a distinguir los métodos sobrecargados (métodos con el mismo nombre) en una clase. Los tipos de devolución no se incluyen en la sobrecarga. Solo se deben usar firmas de métodos para distinguir los métodos sobrecargados.
Por ejemplo, los siguientes dos métodos tienen firmas diferentes:
vacío algo()String[] x); // hacer algo(String[])vacío algo()String x); // hacer algo(String)
Los dos métodos siguientes tienen la misma firma:
int algo()int x); // hacer algo(int)vacío algo()int Sí.) lanzamientos Excepción; // hacer algo(int)
Julia
En Julia, las firmas de función toman la siguiente forma:
Comisión()venta::Int, Tasa::Float64)::Float64
Los tipos en los argumentos se utilizan para el envío múltiple. El tipo de devolución se valida cuando la función devuelve un valor y se genera una excepción de tiempo de ejecución si el tipo del valor no coincide con el tipo especificado.
Los tipos abstractos están permitidos y se recomienda implementar un comportamiento general que sea común a todos los subtipos. Por lo tanto, la función anterior se puede reescribir de la siguiente manera. En este caso, la función puede aceptar cualquier subtipo Integer y Real según corresponda.
Comisión()venta::Integer, Tasa::Real)::Real
Los tipos son completamente opcionales en los argumentos de función. Cuando no se especifica, es equivalente a usar el tipo Any, que es el supertipo de todos los tipos. Es idiomático especificar tipos de argumentos pero no tipo de retorno.
Objetivo-C
En el lenguaje de programación Objective-C, las firmas de métodos para un objeto se declaran en el archivo de encabezado de la interfaz. Por ejemplo,
- ()id)init Con Int:()int)valor;
define un método initWithInt que devuelve un objeto general (un id) y toma un argumento entero. Objective-C solo requiere que un tipo en una firma sea explícito cuando el tipo no es id; esta firma es equivalente:
- init Con Int:()int)valor;
Óxido
En Rust, las firmas de funciones toman la siguiente forma:
f Comisión()venta: u32, Tasa: f64) - f64;

Más resultados...