Conversió de tipus
| Característiques tècniques | |
|---|---|
| Plataforma | C standard library |
| Més informació | |
| Stack Exchange | Etiqueta  |
|
| |
En informàtica, la conversió de tipus,[1][2] el càsting de tipus,[1] [3] la coacció de tipus,[3] i el malabarisme de tipus [4][5] són maneres diferents de canviar una expressió d'un tipus de dades a un altre.. Un exemple seria la conversió d'un valor enter en un valor de coma flotant o la seva representació textual com una cadena i viceversa. Les conversions de tipus poden aprofitar determinades característiques de les jerarquies de tipus o representacions de dades. Dos aspectes importants d'una conversió de tipus són si es produeix implícitament (automàticament) o explícitament,[1] [6] i si la representació de dades subjacent es converteix d'una representació a una altra, o si una representació donada només es reinterpreta com la representació d'una altra. tipus de dades.[6] [7] En general, es poden convertir tant els tipus de dades primitives com les compostes.
Cada llenguatge de programació té les seves pròpies regles sobre com es poden convertir els tipus. Els idiomes amb una mecanografia forta normalment fan poca conversió implícita i descoratgen la reinterpretació de les representacions, mentre que els idiomes amb una mecanografia feble realitzen moltes conversions implícites entre tipus de dades. El llenguatge d'escriptura feble sovint permet forçar el compilador a interpretar arbitràriament un element de dades com a representacions diferents; això pot ser un error de programació no evident o un mètode tècnic per tractar directament el maquinari subjacent.
En la majoria dels idiomes, la paraula coacció s'utilitza per indicar una conversió implícita, ja sigui durant la compilació o durant el temps d'execució. Per exemple, en una expressió que barreja nombres enters i de coma flotant (com 5 + 0,1), el compilador convertirà automàticament la representació entera en representació de coma flotant perquè les fraccions no es perdin. Les conversions de tipus explícites s'indiquen escrivint codi addicional (per exemple, afegint identificadors de tipus o cridant rutines integrades) o codificant rutines de conversió perquè el compilador les utilitzi quan, d'altra manera, s'aturaria amb una discrepància de tipus.
En la majoria de llenguatges semblants a ALGOL, com ara Pascal, Modula-2, Ada i Delphi, la conversió i el càsting són conceptes clarament diferents. En aquests idiomes, la conversió es refereix a canviar de manera implícita o explícita un valor d'un format d'emmagatzematge de tipus de dades a un altre, per exemple, un nombre enter de 16 bits a un nombre sencer de 32 bits. Les necessitats d'emmagatzematge poden canviar com a conseqüència de la conversió, inclosa una possible pèrdua de precisió o truncament. La paraula cast, d'altra banda, es refereix a canviar explícitament la interpretació del patró de bits que representa un valor d'un tipus a un altre. Per exemple, 32 bits contigus es poden tractar com una matriu de 32 booleans, una cadena de 4 bytes, un nombre enter de 32 bits sense signe o un valor de coma flotant de precisió única IEEE. Com que els bits emmagatzemats no es canvien mai, el programador ha de conèixer detalls de baix nivell, com ara el format de representació, l'ordre dels bytes i les necessitats d'alineació, per llançar de manera significativa.
A la família de llenguatges C i ALGOL 68, la paraula cast normalment es refereix a una conversió de tipus explícita (en lloc d'una conversió implícita), provocant certa ambigüitat sobre si es tracta d'una reinterpretació d'un patró de bits o d'una representació de dades reals. conversió. Més important és la multitud de maneres i regles que s'apliquen a quin tipus de dades (o classe) es troba un punter i com un punter pot ser ajustat pel compilador en casos com l'herència d'objectes (classe).
Càsting explícit en diversos idiomes[modifica]
Llenguatges semblants a C[modifica]
La conversió de tipus implícita, també coneguda com a coacció o malabarisme de tipus, és una conversió de tipus automàtica per part del compilador. Alguns llenguatges de programació permeten que els compiladors proporcionin coacció; altres ho requereixen.
En una expressió de tipus mixt, les dades d'un o més subtipus es poden convertir en un supertipus segons sigui necessari en temps d'execució perquè el programa s'executi correctament. Per exemple, el següent és un codi legal de llenguatge C:
double d;
long l;
int i;
if (d > i) d = i;
if (i > l) l = i;
if (d == l) d *= 2;
Encara qued ,l, ii a diferents tipus de dades, es convertiran automàticament en tipus de dades iguals cada vegada que s'executi una comparació o assignació. Aquest comportament s'ha d'utilitzar amb precaució, ja que poden sorgir conseqüències no desitjades. Les dades es poden perdre en convertir representacions de coma flotant a sencers, ja que els components fraccionaris dels valors de coma flotant es truncaran (arrodonint cap a zero). Per contra, la precisió es pot perdre en convertir representacions d'enter a coma flotant, ja que un tipus de coma flotant pot ser incapaç de representar exactament tots els valors possibles d'algun tipus d'enter. Per exemple, float</link> podria ser un tipus de precisió única IEEE 754, que no pot representar l'enter 16777217 exactament, mentre que un tipus enter de 32 bits sí.
C# i C++[modifica]
En C#, la conversió de tipus es pot fer d'una manera segura o no segura (és a dir, semblant a C), l'anterior s'anomena casted type cast.
Animal animal = new Cat();
Bulldog b = (Bulldog) animal; // if (animal is Bulldog), stat.type(animal) is Bulldog, else an exception
b = animal as Bulldog; // if (animal is Bulldog), b = (Bulldog) animal, else b = null
animal = null;
b = animal as Bulldog; // b == null
En C++ es pot aconseguir un efecte similar utilitzant la sintaxi de distribució d'estil C++.
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 = nullptr
Bulldog& 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 avoided
delete animal; // always free resources
animal = nullptr;
b = dynamic_cast<Bulldog*>(animal); // b == nullptr
Referències[modifica]
- ↑ 1,0 1,1 1,2 Mehrotra, Dheeraj. S. Chand's Computer Science (en anglès). S. Chand, 2008, p. 81–83. ISBN 978-8121929844.
- ↑ Programming Languages - Design and Constructs (en anglès). Laxmi Publications, 2013, p. 35. ISBN 978-9381159415.
- ↑ 3,0 3,1 Reilly, Edwin. Concise Encyclopedia of Computer Science (en anglès). John Wiley & Sons, 2004, p. 82, 110. ISBN 0470090952.
- ↑ Fenton, Steve. Pro TypeScript: Application-Scale JavaScript Development (en anglès). Apress, 2017, p. xxiii. ISBN 978-1484232491.
- ↑ «PHP: Type Juggling - Manual» (en anglès). php.net. [Consulta: 27 gener 2019].
- ↑ 6,0 6,1 Olsson, Mikael. C++ Quick Syntax Reference (en anglès). Apress, 2013, p. 87–89. ISBN 978-1430262770.
- ↑ Kruse, Rudolf. Computational Intelligence: A Methodological Introduction (en anglès). Springer, 16 setembre 2016, p. 269. ISBN 978-1447172963.