De Wikipedia, la enciclopedia libre
  (Redirigido desde Cast (programación informática) )
Saltar a navegación Saltar a búsqueda
Para conocer el proceso de concesión de licencias de aviación, consulte Conversión de tipos (aviación) .

En informática , conversión de tipos , [1] [2] conversión de tipos , [1] [3] coerción de tipos , [3] y malabares de tipos [4] [5] son formas diferentes de cambiar una expresión de un tipo de datos a otro . Un ejemplo sería la conversión de un valor entero en un valor de punto flotante o su representación textual como una cadena , y viceversa. Las conversiones de tipos pueden aprovechar ciertas características de las jerarquías de tipos o representaciones de datos.. Dos aspectos importantes de una conversión de tipo son si ocurre implícitamente (automáticamente) o explícitamente , [1] [6] y si la representación de datos subyacente se convierte de una representación a otra, o si una representación dada se reinterpreta simplemente como la representación de otra tipo de datos. [6] [7] En general, se pueden convertir tanto los tipos de datos primitivos como los compuestos .

Cada lenguaje de programación tiene sus propias reglas sobre cómo se pueden convertir los tipos. Los lenguajes con mecanografía fuerte suelen realizar pocas conversiones implícitas y desalientan la reinterpretación de representaciones, mientras que los lenguajes con mecanografía débil realizan muchas conversiones implícitas entre tipos de datos. El lenguaje de escritura débil a menudo permite forzar al compilador a interpretar arbitrariamente un elemento de datos con diferentes representaciones; esto puede ser un error de programación no obvio o un método técnico para tratar directamente con el hardware subyacente.

En la mayoría de los lenguajes, la palabra coerción se usa para denotar una conversión implícita , ya sea durante la compilación o durante el tiempo de ejecución . Por ejemplo, en una expresión que mezcla números enteros y de coma flotante (como 5 + 0.1), el compilador convertirá automáticamente la representación entera en una representación de coma flotante para que no se pierdan las fracciones. Las conversiones de tipo explícitas se indican escribiendo código adicional (por ejemplo, agregando identificadores de tipo o llamando a rutinas integradas ) o codificando rutinas de conversión para que el compilador las utilice cuando de otra manera se detendría con una falta de coincidencia de tipos.

En la mayoría de los lenguajes similares a ALGOL , como Pascal , Modula-2 , Ada y Delphi , la conversión y el casting son conceptos claramente diferentes. En estos lenguajes, la conversión se refiere a cambiar implícita o explícitamente un valor de un formato de almacenamiento de tipo de datos a otro, por ejemplo, un número entero de 16 bits a un número entero de 32 bits. Las necesidades de almacenamiento pueden cambiar como resultado de la conversión, incluida una posible pérdida de precisión o truncamiento. La palabra emitir , por otro lado, se refiere a cambiar explícitamente la interpretación del patrón de bitsque representa un valor de un tipo a otro. Por ejemplo, 32 bits contiguos pueden tratarse como una matriz de 32 valores booleanos, una cadena de 4 bytes, un entero de 32 bits sin signo o un valor de punto flotante de precisión simple IEEE. Debido a que los bits almacenados nunca se cambian, el programador debe conocer detalles de bajo nivel, como el formato de representación, el orden de bytes y las necesidades de alineación, para emitir de manera significativa.

En la familia de lenguajes C y ALGOL 68 , la palabra cast generalmente se refiere a una conversión de tipo explícita (a diferencia de una conversión implícita), lo que genera cierta ambigüedad sobre si se trata de una reinterpretación de un patrón de bits o una representación de datos reales. conversión. Más importante es la multitud de formas y reglas que se aplican a qué tipo de datos (o clase) se ubica mediante un puntero y cómo el compilador puede ajustar un puntero en casos como la herencia de objetos (clases).

Comparación de idiomas [ editar ]

Lenguajes similares a C [ editar ]

Conversión de tipo implícita [ editar ]

La conversión implícita de tipos, también conocida como coerción , es una conversión automática de tipos por parte del compilador . Algunos lenguajes de programación permiten que los compiladores proporcionen coerción; otros lo requieren.

En una expresión de tipo mixto, los datos de uno o más subtipos se pueden convertir a un supertipo según sea necesario en tiempo de ejecución para que el programa se ejecute correctamente. Por ejemplo, el siguiente es un código de lenguaje C legal :

doble  d ; largo  l ; int  i ;si  ( d  >  i )  d  =  i ; si  ( i  >  l )  l  =  i ; si  ( d  ==  l )  d  * =  2 ;

Aunque d , l e i pertenecen a diferentes tipos de datos, se convertirán automáticamente en tipos de datos iguales cada vez que se ejecute una comparación o asignación. Este comportamiento debe usarse con precaución, ya que pueden surgir consecuencias no deseadas . Los datos se pueden perder al convertir representaciones de punto flotante a entero, ya que los componentes fraccionarios de los valores de punto flotante se truncarán (redondearán hacia cero). Por el contrario, la precisión se puede perder al convertir representaciones de entero a punto flotante, ya que un tipo de punto flotante puede no ser capaz de representar exactamente un tipo entero. Por ejemplo, podría ser un IEEE 754floattipo de precisión simple, que no puede representar el número entero 16777217 exactamente, mientras que un tipo entero de 32 bits sí puede. Esto puede conducir a un comportamiento poco intuitivo, como lo demuestra el siguiente código:

#include  <stdio.h>int  main ( vacío ) {  int  i_value  =  16777217 ;  float  f_value  =  16777216.0 ;  printf ( "El entero es:% d \ n " ,  i_value );  printf ( "El flotante es:% f \ n " ,  f_value );  printf ( "Su igualdad:% d \ n " ,  i_value  ==  f_value ); }

En compiladores que implementan flotantes como precisión simple IEEE e ints como al menos 32 bits, este código dará esta impresión peculiar:

El número entero es: 16777217El flotador es: 16777216.000000Su igualdad: 1

Tenga en cuenta que 1 representa la igualdad en la última línea de arriba. Este comportamiento extraño se debe a una conversión implícita de i_valueflotar cuando se compara con f_value. La conversión provoca una pérdida de precisión, lo que hace que los valores sean iguales antes de la comparación.

Conclusiones importantes:

  1. floatpara intprovocar el truncamiento , es decir, la eliminación de la parte fraccionaria.
  2. doublea floatcausa el redondeo de dígitos.
  3. longa intcausas que caen del exceso de bits de orden superior.
Tipo de promoción [ editar ]

Un caso especial de conversión de tipos implícita es la promoción de tipos, donde el compilador expande automáticamente la representación binaria de objetos de tipo entero o de punto flotante. Las promociones se usan comúnmente con tipos más pequeños que el tipo nativo de la unidad aritmética lógica (ALU) de la plataforma de destino , antes de las operaciones aritméticas y lógicas, para que tales operaciones sean posibles, o más eficientes si la ALU puede trabajar con más de un tipo. C y C ++ realizan dicha promoción para objetos de tipo booleano, carácter, carácter ancho, enumeración y enteros cortos que se promueven a int, y para objetos de tipo float, que se promueven a doble. A diferencia de otros tipos de conversiones, las promociones nunca pierden precisión ni modifican el valor almacenado en el objeto.

En Java :

int  x  =  3 ; doble  y  =  3,5 ; Sistema . fuera . println ( x  +  y );  // La salida será 6.5

Conversión de tipo explícito [ editar ]

La conversión de tipo explícita es una conversión de tipo que se define explícitamente dentro de un programa (en lugar de ser realizada por un compilador para la conversión de tipo implícita). Lo define el usuario en el programa.

doble  da  =  3,3 ; doble  db  =  3,3 ; doble  dc  =  3,4 ; int  resultado  =  ( int ) da  +  ( int ) db  +  ( int ) dc ;  // resultado == 9 // si se usara la conversión implícita (como con "resultado = da + db + dc"), el resultado sería igual a 10

Hay varios tipos de conversión explícita.

comprobado
Antes de realizar la conversión, se realiza una verificación en tiempo de ejecución para ver si el tipo de destino puede contener el valor de origen. De lo contrario, se genera una condición de error.
desenfrenado
No se realiza ninguna comprobación. Si el tipo de destino no puede contener el valor de origen, el resultado no está definido.
patrón de bits
La representación de bits sin procesar de la fuente se copia literalmente y se vuelve a interpretar de acuerdo con el tipo de destino. Esto también se puede lograr mediante aliasing .

En programación orientados a objetos idiomas, los objetos también pueden ser abatido  : una referencia de una clase base se moldea a una de sus clases derivadas.

C # y C ++ [ editar ]

En C # , la conversión de tipos se puede realizar de forma segura o insegura (es decir, similar a C), la primera se llama conversión de tipos comprobados . [8]

Animal  animal  =  gato nuevo  ();Bulldog b = (Bulldog) animal; // if (animal is Bulldog), stat.type(animal) is Bulldog, else an exceptionb = animal as Bulldog; // if (animal is Bulldog), b = (Bulldog) animal, else b = nullanimal = null;b = animal as Bulldog; // b == null

In C++ a similar effect can be achieved using C++-style cast syntax.

Animal* animal = new Cat;Bulldog* b = static_cast<Bulldog*>(animal); // compiles only if either Animal or Bulldog is derived from the other (or same)b = dynamic_cast<Bulldog*>(animal); // if (animal is Bulldog), b = (Bulldog*) animal, else b = nullptrBulldog& br = static_cast<Bulldog&>(*animal); // same as above, but an exception will be thrown if a nullptr was to be returned // this is not seen in code where exception handling is avoidedanimal = nullptr;b = dynamic_cast<Bulldog*>(animal); // b == nullptrdelete animal; // always free resources

Eiffel[edit]

In Eiffel the notion of type conversion is integrated into the rules of the type system. The Assignment Rule says that an assignment, such as:

x := y

is valid if and only if the type of its source expression, y in this case, is compatible with the type of its target entity, x in this case. In this rule, compatible with means that the type of the source expression either conforms to or converts to that of the target. Conformance of types is defined by the familiar rules for polymorphism in object-oriented programming. For example, in the assignment above, the type of y conforms to the type of x if the class upon which y is based is a descendant of that upon which x is based.

Definition of type conversion in Eiffel[edit]

The actions of type conversion in Eiffel, specifically converts to and converts from are defined as:

A type based on a class CU converts to a type T based on a class CT (and T converts from U) if either

CT has a conversion procedure using U as a conversion type, or
CU has a conversion query listing T as a conversion type

Example[edit]

Eiffel is a fully compliant language for Microsoft .NET Framework. Before development of .NET, Eiffel already had extensive class libraries. Using the .NET type libraries, particularly with commonly used types such as strings, poses a conversion problem. Existing Eiffel software uses the string classes (such as STRING_8) from the Eiffel libraries, but Eiffel software written for .NET must use the .NET string class (System.String) in many cases, for example when calling .NET methods which expect items of the .NET type to be passed as arguments. So, the conversion of these types back and forth needs to be as seamless as possible.

 my_string: STRING_8 -- Native Eiffel string my_system_string: SYSTEM_STRING -- Native .NET string ... my_string := my_system_string

In the code above, two strings are declared, one of each different type (SYSTEM_STRING is the Eiffel compliant alias for System.String). Because System.String does not conform to STRING_8, then the assignment above is valid only if System.String converts to STRING_8.

The Eiffel class STRING_8 has a conversion procedure make_from_cil for objects of type System.String. Conversion procedures are also always designated as creation procedures (similar to constructors). The following is an excerpt from the STRING_8 class:

 class STRING_8 ... create make_from_cil ... convert make_from_cil ({SYSTEM_STRING}) ...

The presence of the conversion procedure makes the assignment:

 my_string := my_system_string

semantically equivalent to:

 create my_string.make_from_cil (my_system_string)

in which my_string is constructed as a new object of type STRING_8 with content equivalent to that of my_system_string.

To handle an assignment with original source and target reversed:

 my_system_string := my_string

the class STRING_8 also contains a conversion query to_cil which will produce a System.String from an instance of STRING_8.

 class STRING_8 ... create make_from_cil ... convert make_from_cil ({SYSTEM_STRING}) to_cil: {SYSTEM_STRING} ...

The assignment:

 my_system_string := my_string

then, becomes equivalent to:

 my_system_string := my_string.to_cil

In Eiffel, the setup for type conversion is included in the class code, but then appears to happen as automatically as explicit type conversion in client code. The includes not just assignments but other types of attachments as well, such as argument (parameter) substitution.

Rust[edit]

Rust provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the as keyword.[9]

println!("1000 as a u16 is: {}", 1000 as u16);

Security issues[edit]

In hacking, typecasting is the misuse of type conversion to temporarily change a variable's data type from how it was originally defined.[10] This provides opportunities for hackers since in type conversion after a variable is "typecast" to become a different data type, the compiler will treat that hacked variable as the new data type for that specific operation.[11]

See also[edit]

  • Downcasting
  • Run-time type information#dynamic cast and Java cast
  • Type punning

References[edit]

  1. ^ a b c Mehrotra, Dheeraj (2008). S. Chand's Computer Science. pp. 81–83. ISBN 978-8121929844.
  2. ^ Programming Languages - Design and Constructs. 2013. p. 35. ISBN 978-9381159415.
  3. ^ a b Reilly, Edwin (2004). Concise Encyclopedia of Computer Science. pp. 82, 110. ISBN 0470090952.
  4. ^ Fenton, Steve (2017). Pro TypeScript: Application-Scale JavaScript Development. pp. xxiii. ISBN 978-1484232491.
  5. ^ "PHP: Type Juggling - Manual". php.net. Retrieved 27 January 2019.
  6. ^ a b Olsson, Mikael (2013). C++ Quick Syntax Reference. pp. 87–89. ISBN 978-1430262770.
  7. ^ Kruse, Rudolf; Borgelt, Christian; Braune, Christian; Mostaghim, Sanaz; Steinbrecher, Matthias (16 September 2016). Computational Intelligence: A Methodological Introduction. p. 269. ISBN 978-1447172963.
  8. ^ Mössenböck, Hanspeter (25 March 2002). "Advanced C#: Checked Type Casts" (PDF). Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. p. 5. Retrieved 4 August 2011. at C# Tutorial
  9. ^ "Casting - Rust By Example". doc.rust-lang.org.
  10. ^ Jon Erickson Hacking, 2nd Edition: The Art of Exploitation 2008 1593271441 p51 "Typecasting is simply a way to temporarily change a variable's data type, despite how it was originally defined. When a variable is typecast into a different type, the compiler is basically told to treat that variable as if it were the new data type, but only for that operation. The syntax for typecasting is as follows: (typecast_data_type) variable ..."
  11. ^ Arpita Gopal Magnifying C 2009 8120338618 p.59 "From the above, it is clear that the usage of typecasting is to make a variable of one type, act like another type for one single operation. So by using this ability of typecasting it is possible for create ASCII characters by typecasting integer to its ..."

External links[edit]

  • Casting in Ada
  • Casting in C++
  • C++ Reference Guide Why I hate C++ Cast Operators, by Danny Kalev
  • Casting in Java
  • Implicit Conversions in C#
  • Implicit Type Casting at Cppreference.com
  • Static and Reinterpretation castings in C++
  • Upcasting and Downcasting in F#