1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDAN Jozwiak: fundição Tipo, no sentido mais simples, é uma

2
00:00:10,270 --> 00:00:13,300
modo para alterar a interpretação de um computador de alguns dados por

3
00:00:13,300 --> 00:00:16,560
implícita ou explicitamente, alterando seu tipo de dados.

4
00:00:16,560 --> 00:00:19,940
Como alterar um int a um float, ou vice-versa.

5
00:00:19,940 --> 00:00:21,550
Para entender tipo de vazamento, é preciso

6
00:00:21,550 --> 00:00:22,680
começar com o básico -

7
00:00:22,680 --> 00:00:24,140
tipos de dados próprios.

8
00:00:24,140 --> 00:00:26,960
Em linguagens como C, todas as variáveis ​​têm algum tipo

9
00:00:26,960 --> 00:00:29,690
do tipo de dados que determina como o computador, e do mesmo modo

10
00:00:29,690 --> 00:00:32,140
o usuário, que interpreta variável.

11
00:00:32,140 --> 00:00:35,160
Numéricos tipos de dados, tais como um int, longo tempo float, e

12
00:00:35,160 --> 00:00:38,110
duplo, todos têm suas próprias características únicas e são

13
00:00:38,110 --> 00:00:41,370
usado para especificar valores com os mais variados e de precisão.

14
00:00:41,370 --> 00:00:44,800
Tipo de vazamento nos permite ter um número de ponto flutuante como

15
00:00:44,800 --> 00:00:49,170
3,14 e obter a peça antes do decimal, 3 neste caso,

16
00:00:49,170 --> 00:00:51,590
, lançando-a um int.

17
00:00:51,590 --> 00:00:53,900
Vamos dar um exemplo do idioma Inglês para um breve

18
00:00:53,900 --> 00:00:56,910
revisão de tipos, e para ver como tipo de vazamento pode mudar

19
00:00:56,910 --> 00:00:59,380
a nossa forma de interpretar uma parte dos dados.

20
00:00:59,380 --> 00:01:05,269
Para os dados, vamos dar os símbolos aqui.

21
00:01:05,269 --> 00:01:07,570
Eu só referir a essas linhas cuidadosamente configurados como

22
00:01:07,570 --> 00:01:10,100
símbolos, mas como alguém que conhece o idioma Inglês,

23
00:01:10,100 --> 00:01:12,750
você imediatamente reconhecer que eles são, de fato, as letras.

24
00:01:12,750 --> 00:01:15,580
Você implicitamente compreendido o tipo de dados.

25
00:01:15,580 --> 00:01:17,620
Olhando para esta seqüência de letras, podemos ver dois

26
00:01:17,620 --> 00:01:20,140
palavras diferentes, cada um com seu próprio significado.

27
00:01:20,140 --> 00:01:25,530
Não há o substantivo, o vento, como o vento sopra no exterior.

28
00:01:25,530 --> 00:01:28,280
E há o verbo, o vento, como no que eu preciso

29
00:01:28,280 --> 00:01:31,410
enrolar meu relógio analógico.

30
00:01:31,410 --> 00:01:33,420
Este é um exemplo interessante, porque podemos ver

31
00:01:33,420 --> 00:01:36,270
como o tipo que nós atribuímos aos nossos dados, se substantivo ou

32
00:01:36,270 --> 00:01:39,080
verbais, muda a forma como usamos esses dados -

33
00:01:39,080 --> 00:01:41,730
como o vento palavra ou vento.

34
00:01:41,730 --> 00:01:44,100
Apesar de um computador não se preocupa com gramática e peças

35
00:01:44,100 --> 00:01:47,750
de fala Inglês, o mesmo princípio básico se aplica.

36
00:01:47,750 --> 00:01:50,290
Isto é, nós podemos mudar a interpretação do exato

37
00:01:50,290 --> 00:01:53,140
mesmos dados armazenados na memória simplesmente convertê-lo a um

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

39
00:01:54,576 --> 00:01:57,250
Aqui estão os tamanhos dos tipos mais comuns em um 32-bit

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

41
00:01:58,340 --> 00:02:02,070
Temos um char menos 1 byte int e float de 4 bytes, um longo

42
00:02:02,070 --> 00:02:04,390
de comprimento e uma dupla de 8 bytes.

43
00:02:04,390 --> 00:02:07,670
Porque um int ocupa 4 bytes, vai demorar até 32 bits

44
00:02:07,670 --> 00:02:10,060
quando ele é armazenado na memória como uma série binária

45
00:02:10,060 --> 00:02:11,500
de zeros e uns.

46
00:02:11,500 --> 00:02:14,020
Enquanto a nossa variável permanece como um tipo int, o

47
00:02:14,020 --> 00:02:16,740
computador sempre converter os uns e zeros de

48
00:02:16,740 --> 00:02:19,120
binário para o número original.

49
00:02:19,120 --> 00:02:21,270
No entanto, teoricamente poderia lançar os 32

50
00:02:21,270 --> 00:02:23,510
bits em uma série de tipos booleanos.

51
00:02:23,510 --> 00:02:26,090
E então o computador não verá mais um número, mas

52
00:02:26,090 --> 00:02:28,810
vez, uma coleção de zeros e uns.

53
00:02:28,810 --> 00:02:31,570
Nós também pode tentar ler esses dados como um numérico diferente

54
00:02:31,570 --> 00:02:34,660
tipo, ou mesmo como uma seqüência de quatro caracteres.

55
00:02:34,660 --> 00:02:37,820
Ao lidar com números em casting, você deve considerar como

56
00:02:37,820 --> 00:02:40,470
a precisão do seu valor será afetada.

57
00:02:40,470 --> 00:02:43,240
Tenha em mente que a precisão pode permanecer o mesmo,

58
00:02:43,240 --> 00:02:47,150
ou você pode perder precisão, mas você nunca pode ganhar precisão.

59
00:02:47,150 --> 00:02:49,060
Vamos passar para as três formas mais comuns que você pode

60
00:02:49,060 --> 00:02:50,400
perder precisão.

61
00:02:50,400 --> 00:02:53,060
Lançando um float para um int causará truncamento de tudo

62
00:02:53,060 --> 00:02:54,900
depois do ponto decimal, então você fica

63
00:02:54,900 --> 00:02:55,950
com o número inteiro.

64
00:02:55,950 --> 00:03:02,000
Se tomarmos o x bóia que será igual a 3,7, pode-se lançar

65
00:03:02,000 --> 00:03:05,580
esta variável x para um int, basta escrever em int

66
00:03:05,580 --> 00:03:07,050
parênteses.

67
00:03:07,050 --> 00:03:10,010
Sempre que usamos este termo aqui, nós vamos efetivamente

68
00:03:10,010 --> 00:03:12,810
estar usando o valor de três, porque nós truncado

69
00:03:12,810 --> 00:03:14,880
tudo depois do ponto decimal.

70
00:03:14,880 --> 00:03:17,210
Nós também podemos converter um longo tempo para um int, que será

71
00:03:17,210 --> 00:03:20,760
similarmente levar a uma perda de bits de ordem superior.

72
00:03:20,760 --> 00:03:23,910
Um longo tempo ocupa 8 bytes, ou 64 bits na memória.

73
00:03:23,910 --> 00:03:27,050
Então, quando nós lançá-lo para um int que só tem 4 bytes, ou 32

74
00:03:27,050 --> 00:03:29,820
bits, que são, essencialmente, cortando todos os bits que

75
00:03:29,820 --> 00:03:32,420
representam os valores mais elevados binários.

76
00:03:32,420 --> 00:03:34,690
Você também pode lançar um duplo para um float, que vai dar

77
00:03:34,690 --> 00:03:37,340
você flutuar o mais próximo possível do duplo sem

78
00:03:37,340 --> 00:03:39,100
necessariamente arredondamento lo.

79
00:03:39,100 --> 00:03:41,840
Semelhante ao nosso longo tempo de conversão int, a perda de

80
00:03:41,840 --> 00:03:44,890
precisão é porque um duplo contém mais dados.

81
00:03:44,890 --> 00:03:47,910
A dupla permitirá que você armazene 53 bits significativos,

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

83
00:03:50,650 --> 00:03:53,050
Considerando uma bóia só permitem armazenar 24

84
00:03:53,050 --> 00:03:56,235
bits significativos, cerca de sete dígitos significativos.

85
00:03:56,235 --> 00:03:58,700
Nestes dois últimos casos, pode ser útil para pensar

86
00:03:58,700 --> 00:04:01,200
digite elenco como redimensionar uma foto.

87
00:04:01,200 --> 00:04:03,860
Quando você vai de um tamanho grande para um tamanho pequeno, você não pode ver

88
00:04:03,860 --> 00:04:05,600
coisas tão claramente, porque você perdeu dados

89
00:04:05,600 --> 00:04:07,530
sob a forma de pixels.

90
00:04:07,530 --> 00:04:09,270
Tipo de vazamento também pode causar problemas quando

91
00:04:09,270 --> 00:04:11,050
ints para lançar carros alegóricos.

92
00:04:11,050 --> 00:04:13,920
Desde que flutua em uma máquina de 32 bits só tem 24

93
00:04:13,920 --> 00:04:16,959
bits significativos, eles não podem representar precisamente valores

94
00:04:16,959 --> 00:04:22,750
ao longo de 2 à potência de 24, ou 16777217.

95
00:04:22,750 --> 00:04:25,540
Agora vamos falar sobre o elenco explícito e implícito.

96
00:04:25,540 --> 00:04:28,000
Conversão explícita é quando escrevemos o tipo entre parênteses

97
00:04:28,000 --> 00:04:29,430
antes de um nome de variável.

98
00:04:29,430 --> 00:04:33,100
Como exemplo, antes que escreveu int entre parênteses antes de nossa

99
00:04:33,100 --> 00:04:35,640
flutuar variável x.

100
00:04:35,640 --> 00:04:37,200
Desta forma, obtemos o valor int, o

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
A conversão implícita é quando o compilador muda automaticamente

104
00:04:42,970 --> 00:04:46,340
tipos semelhantes às de um tipo super, ou exercer algum outro tipo de

105
00:04:46,340 --> 00:04:48,310
lançando sem exigir que o usuário escreva

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

107
00:04:49,720 --> 00:04:53,550
Por exemplo, quando adicionar 5 e 1,1, nossos valores já

108
00:04:53,550 --> 00:04:55,680
tipos associados a eles.

109
00:04:55,680 --> 00:04:59,480
O 5 é um int, enquanto 1,1 é um flutuante.

110
00:04:59,480 --> 00:05:02,390
A fim de adicioná-los, o computador lança 5 em uma bóia,

111
00:05:02,390 --> 00:05:04,530
que teria sido a mesma coisa que escrevendo 5.0 na

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

113
00:05:06,476 --> 00:05:13,210
Mas esta forma de dizer flutuador 5, ou 5,0, mais o que já era

114
00:05:13,210 --> 00:05:16,960
uma bóia, 1.1, e de lá podemos realmente adicionar estes

115
00:05:16,960 --> 00:05:18,640
valores e obter o valor 6.1.

116
00:05:21,170 --> 00:05:23,500
A conversão implícita também nos permite atribuir variáveis ​​de

117
00:05:23,500 --> 00:05:25,590
tipos diferentes uns dos outros.

118
00:05:25,590 --> 00:05:28,110
Nós sempre podemos atribuir um tipo menos precisa em um mais

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

120
00:05:29,250 --> 00:05:37,060
Por exemplo, se temos um duplo x, y e um int -

121
00:05:37,060 --> 00:05:40,120
e estes poderiam ter quaisquer valores que estabelecemos que eles -

122
00:05:40,120 --> 00:05:43,560
podemos dizer x é igual a y.

123
00:05:43,560 --> 00:05:46,340
Porque o casal tem mais precisão do que um int, então nós

124
00:05:46,340 --> 00:05:48,380
não vai perder nenhuma informação.

125
00:05:48,380 --> 00:05:50,420
Por outro lado, não seria necessariamente correcto afirmar

126
00:05:50,420 --> 00:05:54,060
y é igual a x, como a dupla pode ter um valor maior do que

127
00:05:54,060 --> 00:05:55,220
o número inteiro.

128
00:05:55,220 --> 00:05:57,420
E assim, o número inteiro pode não ser capaz de realizar todos os

129
00:05:57,420 --> 00:05:59,560
informações armazenadas na dupla.

130
00:05:59,560 --> 00:06:02,610
A conversão implícita também é usado em operadores de comparação como

131
00:06:02,610 --> 00:06:06,410
maior do que, menor que, ou o operador de igualdade.

132
00:06:06,410 --> 00:06:13,050
Dessa forma, podemos dizer que se 5,1 é maior do que 5, e temos a

133
00:06:13,050 --> 00:06:14,750
resultado verdadeiro.

134
00:06:14,750 --> 00:06:18,470
Porque 5 é um int, mas vai ser convertido para um flutuador, a fim de

135
00:06:18,470 --> 00:06:22,090
ser comparado com o flutuador 5.1, diríamos 5.1 é

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

137
00:06:24,550 --> 00:06:31,320
O mesmo é verdade em dizer se é igual a 2,0 é igual a 2.

138
00:06:31,320 --> 00:06:34,190
Nós também obter verdade, pois o computador vai lançar o

139
00:06:34,190 --> 00:06:39,750
inteiro de 2 a flutuar e então dizer 2,0 equivale a 2,0 é igual,

140
00:06:39,750 --> 00:06:41,660
isso é verdade.

141
00:06:41,660 --> 00:06:44,180
Não se esqueça que também pode lançar entre ints e chars,

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

143
00:06:46,350 --> 00:06:49,690
Chars também precisa ser reduzido a binário, que é por isso que você

144
00:06:49,690 --> 00:06:51,920
pode converter facilmente entre chars e seus respectivos

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

146
00:06:53,260 --> 00:06:56,180
Para saber mais sobre isso, confira nosso vídeo em ASCII.

147
00:06:56,180 --> 00:06:58,080
Quando você toma um momento para pensar sobre como os dados estão armazenados,

148
00:06:58,080 --> 00:06:59,990
ele começa a fazer muito sentido.

149
00:06:59,990 --> 00:07:02,790
É como a diferença entre o vento eo vento.

150
00:07:02,790 --> 00:07:05,490
Os dados são os mesmos, mas o tipo pode alterar a forma como

151
00:07:05,490 --> 00:07:06,720
interpretá-lo.

152
00:07:06,720 --> 00:07:10,430
Meu nome é Jordan Jozwiak, este CS50.