1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDAN Jozwiak: conversión de tipos, en el sentido más simple, es un

2
00:00:10,270 --> 00:00:13,300
manera de alterar la interpretación de una computadora de algunos datos por

3
00:00:13,300 --> 00:00:16,560
implícita o explícitamente cambiando su tipo de datos.

4
00:00:16,560 --> 00:00:19,940
Tal como cambiar un int a un float, o viceversa.

5
00:00:19,940 --> 00:00:21,550
Para entender la conversión de tipos, tenemos que

6
00:00:21,550 --> 00:00:22,680
empezar con lo básico -

7
00:00:22,680 --> 00:00:24,140
mismos tipos de datos.

8
00:00:24,140 --> 00:00:26,960
En los lenguajes de programación como C, todas las variables tienen algún tipo

9
00:00:26,960 --> 00:00:29,690
de tipo de datos que determina cómo el ordenador, incluso

10
00:00:29,690 --> 00:00:32,140
el usuario, interpreta esa variable.

11
00:00:32,140 --> 00:00:35,160
Tipos de datos numéricos, como un int, long long, float y

12
00:00:35,160 --> 00:00:38,110
dobles, todas ellas tienen sus propias características y son

13
00:00:38,110 --> 00:00:41,370
utiliza para especificar los valores de diferentes rangos y precisión.

14
00:00:41,370 --> 00:00:44,800
Forzado de tipos nos permite tener un número de punto flotante como

15
00:00:44,800 --> 00:00:49,170
3.14 y obtener la parte antes del decimal, 3 en este caso,

16
00:00:49,170 --> 00:00:51,590
echando a un int.

17
00:00:51,590 --> 00:00:53,900
Tomemos un ejemplo del idioma Inglés por un breve

18
00:00:53,900 --> 00:00:56,910
la revisión de los tipos, y para ver cómo la conversión de tipos puede cambiar

19
00:00:56,910 --> 00:00:59,380
la forma en que interpretamos una pieza de datos.

20
00:00:59,380 --> 00:01:05,269
Para los datos, vamos a tomar los símbolos aquí.

21
00:01:05,269 --> 00:01:07,570
Acabo de hacer referencia a estas líneas cuidadosamente configurados como

22
00:01:07,570 --> 00:01:10,100
símbolos, sino como alguien que conoce el idioma Inglés,

23
00:01:10,100 --> 00:01:12,750
inmediatamente reconocen que son, de hecho, las letras.

24
00:01:12,750 --> 00:01:15,580
Usted entiende implícita del tipo de datos.

25
00:01:15,580 --> 00:01:17,620
En cuanto a esta cadena de letras que podemos ver a dos

26
00:01:17,620 --> 00:01:20,140
palabras diferentes, cada uno con su propio significado.

27
00:01:20,140 --> 00:01:25,530
Ahí está el sustantivo, el viento, al igual que en el viento de afuera.

28
00:01:25,530 --> 00:01:28,280
Y ahí está el verbo, el viento, como en lo que

29
00:01:28,280 --> 00:01:31,410
cuerda a mi reloj analógico.

30
00:01:31,410 --> 00:01:33,420
Este es un ejemplo interesante, ya que podemos ver

31
00:01:33,420 --> 00:01:36,270
cómo el tipo que le asignamos a nuestros datos, ya sea sustantivo o

32
00:01:36,270 --> 00:01:39,080
verbales, cambia la forma en que utilizamos los datos -

33
00:01:39,080 --> 00:01:41,730
como el viento o el viento palabra.

34
00:01:41,730 --> 00:01:44,100
Aunque un equipo no se preocupa acerca de la gramática y las piezas

35
00:01:44,100 --> 00:01:47,750
de habla Inglés, el mismo principio se aplica.

36
00:01:47,750 --> 00:01:50,290
Es decir, se puede cambiar la interpretación de la exacta

37
00:01:50,290 --> 00:01:53,140
mismos datos almacenados en la memoria por simple colada a una

38
00:01:53,140 --> 00:01:54,576
tipo diferente.

39
00:01:54,576 --> 00:01:57,250
Aquí son los tamaños de los tipos más comunes de un 32-bit

40
00:01:57,250 --> 00:01:58,340
del sistema operativo.

41
00:01:58,340 --> 00:02:02,070
Tenemos un char a 1 byte, int y float en 4 bytes, una larga

42
00:02:02,070 --> 00:02:04,390
de largo y un doble de 8 bytes.

43
00:02:04,390 --> 00:02:07,670
Debido a que un int ocupa 4 bytes, se tardará hasta 32 bits

44
00:02:07,670 --> 00:02:10,060
cuando se almacena en la memoria como una serie binaria

45
00:02:10,060 --> 00:02:11,500
de ceros y unos.

46
00:02:11,500 --> 00:02:14,020
Mientras nuestra variable permanece como un tipo int, el

47
00:02:14,020 --> 00:02:16,740
equipo siempre va a convertir esos unos y ceros de

48
00:02:16,740 --> 00:02:19,120
binario en el número original.

49
00:02:19,120 --> 00:02:21,270
Sin embargo, en teoría podría arrojar los 32

50
00:02:21,270 --> 00:02:23,510
bits en una serie de tipos booleanos.

51
00:02:23,510 --> 00:02:26,090
Y luego el ordenador ya no ve un número, pero

52
00:02:26,090 --> 00:02:28,810
en lugar de un conjunto de ceros y unos.

53
00:02:28,810 --> 00:02:31,570
También puede tratar de leer esos datos como diferente numérico

54
00:02:31,570 --> 00:02:34,660
escribir, o incluso como una cadena de cuatro caracteres.

55
00:02:34,660 --> 00:02:37,820
Cuando se trata de números en casting, debe considerar cómo

56
00:02:37,820 --> 00:02:40,470
la precisión de su valor se verá afectado.

57
00:02:40,470 --> 00:02:43,240
Tenga en cuenta que la precisión puede permanecer igual,

58
00:02:43,240 --> 00:02:47,150
o puedes perder precisión, pero nunca se puede ganar precisión.

59
00:02:47,150 --> 00:02:49,060
Vamos a través de las tres formas más comunes que se pueden

60
00:02:49,060 --> 00:02:50,400
perder precisión.

61
00:02:50,400 --> 00:02:53,060
Al lanzar un flotador a un int hará que el truncamiento de todo

62
00:02:53,060 --> 00:02:54,900
después del punto decimal, por lo que está a la izquierda

63
00:02:54,900 --> 00:02:55,950
con el número entero.

64
00:02:55,950 --> 00:03:02,000
Si tomamos el flotador que x será igual a 3,7, podemos echar

65
00:03:02,000 --> 00:03:05,580
esta variable x a un int simplemente escribiendo int en

66
00:03:05,580 --> 00:03:07,050
paréntesis.

67
00:03:07,050 --> 00:03:10,010
Cada vez que usamos este término aquí, que efectivamente va a

68
00:03:10,010 --> 00:03:12,810
a utilizar el valor de tres, ya que hemos truncado

69
00:03:12,810 --> 00:03:14,880
todo después del punto decimal.

70
00:03:14,880 --> 00:03:17,210
También puede convertir un long long a int, que será

71
00:03:17,210 --> 00:03:20,760
igualmente conducir a una pérdida de bits de alto orden.

72
00:03:20,760 --> 00:03:23,910
A long long ocupa 8 bytes o 64 bits en la memoria.

73
00:03:23,910 --> 00:03:27,050
Así que cuando la echó a un int que sólo tiene 4 bytes, o 32

74
00:03:27,050 --> 00:03:29,820
bits, esencialmente estamos cortando todos los bits que

75
00:03:29,820 --> 00:03:32,420
representan los valores binarios más altos.

76
00:03:32,420 --> 00:03:34,690
También puede lanzar un doble a un flotador, que dará

77
00:03:34,690 --> 00:03:37,340
que el flotador más cercano posible al doble sin

78
00:03:37,340 --> 00:03:39,100
necesariamente redondeo.

79
00:03:39,100 --> 00:03:41,840
Similar a nuestro long long int a la conversión, la pérdida de

80
00:03:41,840 --> 00:03:44,890
precisión se debe a que un doble contiene más datos.

81
00:03:44,890 --> 00:03:47,910
Un doble le permitirá almacenar 53 bits de menor peso,

82
00:03:47,910 --> 00:03:50,650
aproximadamente 16 dígitos significativos.

83
00:03:50,650 --> 00:03:53,050
Mientras que un flotador sólo le permitirá almacenar 24

84
00:03:53,050 --> 00:03:56,235
bits de menor peso, aproximadamente siete dígitos significativos.

85
00:03:56,235 --> 00:03:58,700
En estos dos últimos casos, puede ser útil pensar

86
00:03:58,700 --> 00:04:01,200
conversión de tipos como cambiar el tamaño de una foto.

87
00:04:01,200 --> 00:04:03,860
Cuando se pasa de un gran tamaño a un tamaño pequeño, no se puede ver

88
00:04:03,860 --> 00:04:05,600
las cosas con tanta claridad, porque la pérdida de datos

89
00:04:05,600 --> 00:04:07,530
en forma de píxeles.

90
00:04:07,530 --> 00:04:09,270
Forzado de tipos también pueden causar problemas cuando

91
00:04:09,270 --> 00:04:11,050
emitir ints a flote.

92
00:04:11,050 --> 00:04:13,920
Dado que flota en una máquina de 32 bits sólo tienen 24

93
00:04:13,920 --> 00:04:16,959
bits significativos, no pueden representar con precisión los valores

94
00:04:16,959 --> 00:04:22,750
más de 2 a la potencia de 24, o 16777217.

95
00:04:22,750 --> 00:04:25,540
Ahora vamos a hablar de una conversión explícita e implícita.

96
00:04:25,540 --> 00:04:28,000
Una conversión explícita es cuando se escribe entre paréntesis el tipo

97
00:04:28,000 --> 00:04:29,430
antes de un nombre de variable.

98
00:04:29,430 --> 00:04:33,100
Por ejemplo, antes de escribir int entre paréntesis antes de nuestra

99
00:04:33,100 --> 00:04:35,640
flotar variable x.

100
00:04:35,640 --> 00:04:37,200
De esta manera, obtenemos el valor int, el

101
00:04:37,200 --> 00:04:38,593
valor truncado de 3,7 -

102
00:04:38,593 --> 00:04:40,370
3.

103
00:04:40,370 --> 00:04:42,970
Conversión implícita es cuando el compilador cambia automáticamente

104
00:04:42,970 --> 00:04:46,340
tipos similares a un tipo de super, o realiza alguna otra clase de

105
00:04:46,340 --> 00:04:48,310
de colada sin necesidad de que el usuario escriba

106
00:04:48,310 --> 00:04:49,720
cualquier código adicional.

107
00:04:49,720 --> 00:04:53,550
Por ejemplo, cuando sumamos 5 y 1,1, nuestros valores ya tienen

108
00:04:53,550 --> 00:04:55,680
tipos asociados con ellos.

109
00:04:55,680 --> 00:04:59,480
El 5 es un int, mientras que 1.1 es una carroza.

110
00:04:59,480 --> 00:05:02,390
Con el fin de añadirlos, el ordenador pone en un flotador 5,

111
00:05:02,390 --> 00:05:04,530
lo que habría sido la misma cosa que escribir en el 5,0

112
00:05:04,530 --> 00:05:06,476
primer lugar.

113
00:05:06,476 --> 00:05:13,210
Pero de esta manera decimos flotador 5 o 5,0, además de lo que ya era

114
00:05:13,210 --> 00:05:16,960
un flotador, 1,1, y de allí en realidad podemos añadir estos

115
00:05:16,960 --> 00:05:18,640
valores y obtener el valor 6,1.

116
00:05:21,170 --> 00:05:23,500
Conversión implícita también nos permite asignar variables de

117
00:05:23,500 --> 00:05:25,590
tipos diferentes entre sí.

118
00:05:25,590 --> 00:05:28,110
Siempre podemos asignar un tipo menos precisa en una más

119
00:05:28,110 --> 00:05:29,250
un preciso.

120
00:05:29,250 --> 00:05:37,060
Por ejemplo, si tenemos una doble x, y una y int -

121
00:05:37,060 --> 00:05:40,120
y que éstas podrían tener cualquier valor que las asignamos al -

122
00:05:40,120 --> 00:05:43,560
podemos decir que x es igual a y.

123
00:05:43,560 --> 00:05:46,340
Debido a que el matrimonio tiene más precisión que un int, por lo que

124
00:05:46,340 --> 00:05:48,380
no perderá ninguna información.

125
00:05:48,380 --> 00:05:50,420
Por otra parte, no necesariamente sería correcto decir

126
00:05:50,420 --> 00:05:54,060
y es igual a x, porque el doble podría tener un valor mayor que

127
00:05:54,060 --> 00:05:55,220
el número entero.

128
00:05:55,220 --> 00:05:57,420
Y así, el número entero no podría ser capaz de contener toda la

129
00:05:57,420 --> 00:05:59,560
información almacenada en el doble.

130
00:05:59,560 --> 00:06:02,610
Conversión implícita también se utiliza en los operadores de comparación como

131
00:06:02,610 --> 00:06:06,410
mayor que, menor que, o el operador de igualdad.

132
00:06:06,410 --> 00:06:13,050
De esta manera podemos decir si 5,1 es mayor que 5, y tenemos la

133
00:06:13,050 --> 00:06:14,750
resultar cierto.

134
00:06:14,750 --> 00:06:18,470
Dado que el 5 es un int, pero va a ser echado a un flotador para

135
00:06:18,470 --> 00:06:22,090
ser comparado con el 5,1 flotador, diríamos 5.1 es

136
00:06:22,090 --> 00:06:24,550
mayor que 5,0.

137
00:06:24,550 --> 00:06:31,320
Lo mismo es cierto con decir si es igual a 2,0 es igual a 2.

138
00:06:31,320 --> 00:06:34,190
También queremos conseguir cierto, porque el equipo echará la

139
00:06:34,190 --> 00:06:39,750
número entero de 2 a flotar y luego decir 2,0 es igual a es igual a 2,0,

140
00:06:39,750 --> 00:06:41,660
esto es cierto.

141
00:06:41,660 --> 00:06:44,180
No olvide que también puede lanzar entre enteros y caracteres,

142
00:06:44,180 --> 00:06:46,350
o valores ASCII.

143
00:06:46,350 --> 00:06:49,690
Chars también deben reducirse a binario, por lo que usted

144
00:06:49,690 --> 00:06:51,920
puede convertir fácilmente entre caracteres y sus respectivas

145
00:06:51,920 --> 00:06:53,260
Valores ASCII.

146
00:06:53,260 --> 00:06:56,180
Para aprender más sobre esto, echa un vistazo a nuestro video en ASCII.

147
00:06:56,180 --> 00:06:58,080
Cuando usted toma un momento para pensar acerca de cómo los datos se almacenan,

148
00:06:58,080 --> 00:06:59,990
comienza a hacer un montón de sentido.

149
00:06:59,990 --> 00:07:02,790
Es como la diferencia entre el viento y el viento.

150
00:07:02,790 --> 00:07:05,490
Los datos son el mismo, pero el tipo que puede cambiar cómo

151
00:07:05,490 --> 00:07:06,720
interpretarla.

152
00:07:06,720 --> 00:07:10,430
Mi nombre es Jordan Jozwiak, este CS50.