1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDANIE JOZWIAK: Type de coulée, dans le sens le plus simple, est un

2
00:00:10,270 --> 00:00:13,300
moyen de modifier l'interprétation d'un ordinateur de certaines données par

3
00:00:13,300 --> 00:00:16,560
implicitement ou explicitement, changeant son type de données.

4
00:00:16,560 --> 00:00:19,940
Telles que la modification d'un int à un flotteur, ou vice versa.

5
00:00:19,940 --> 00:00:21,550
Pour comprendre la conversion de type, nous avons besoin de

6
00:00:21,550 --> 00:00:22,680
Commençons par les bases -

7
00:00:22,680 --> 00:00:24,140
types de données eux-mêmes.

8
00:00:24,140 --> 00:00:26,960
Dans les langages de programmation tels que C, toutes les variables ont une sorte

9
00:00:26,960 --> 00:00:29,690
de type de données qui détermine le mode de l'ordinateur, et également

10
00:00:29,690 --> 00:00:32,140
l'utilisateur, interprète cette variable.

11
00:00:32,140 --> 00:00:35,160
Types de données numériques comme un int, long long, float et

12
00:00:35,160 --> 00:00:38,110
double, ont tous leurs propres caractéristiques uniques et sont

13
00:00:38,110 --> 00:00:41,370
utilisé pour spécifier les valeurs de différentes gammes et de précision.

14
00:00:41,370 --> 00:00:44,800
Transtypage nous permet de prendre un nombre à virgule flottante comme

15
00:00:44,800 --> 00:00:49,170
3,14 et obtenir la partie avant la virgule, 3 dans ce cas,

16
00:00:49,170 --> 00:00:51,590
en le jetant sur un int.

17
00:00:51,590 --> 00:00:53,900
Prenons un exemple tiré de la langue anglaise pour une brève

18
00:00:53,900 --> 00:00:56,910
l'examen des types, et de voir comment la conversion de type peut changer

19
00:00:56,910 --> 00:00:59,380
la façon dont nous interprétons un morceau de données.

20
00:00:59,380 --> 00:01:05,269
Pour les données, nous allons prendre les symboles ici.

21
00:01:05,269 --> 00:01:07,570
Je viens de faire référence à ces lignes soigneusement configurés comme

22
00:01:07,570 --> 00:01:10,100
symboles, mais comme quelqu'un qui connaît la langue anglaise,

23
00:01:10,100 --> 00:01:12,750
vous immédiatement reconnaître qu'ils sont, en fait, des lettres.

24
00:01:12,750 --> 00:01:15,580
Vous implicitement compris le type de données.

25
00:01:15,580 --> 00:01:17,620
En regardant cette chaîne de lettres, nous pouvons voir deux

26
00:01:17,620 --> 00:01:20,140
mots différents, chacun avec sa propre signification.

27
00:01:20,140 --> 00:01:25,530
Il ya le nom, le vent, comme dans les coups de vent à l'extérieur.

28
00:01:25,530 --> 00:01:28,280
Et il ya le verbe, le vent, comme dans J'ai besoin de

29
00:01:28,280 --> 00:01:31,410
remonter ma montre analogique.

30
00:01:31,410 --> 00:01:33,420
Ceci est un exemple intéressant, parce que nous pouvons voir

31
00:01:33,420 --> 00:01:36,270
comment le type que nous attribuons à nos données, que ce soit substantif ou

32
00:01:36,270 --> 00:01:39,080
verbes, change la façon dont nous utilisons ces données -

33
00:01:39,080 --> 00:01:41,730
comme le vent mot ou le vent.

34
00:01:41,730 --> 00:01:44,100
Même si un ordinateur ne se soucient pas de la grammaire et des pièces

35
00:01:44,100 --> 00:01:47,750
d'expression anglaise, le même principe de base s'applique.

36
00:01:47,750 --> 00:01:50,290
Autrement dit, nous pouvons changer l'interprétation exacte de l'

37
00:01:50,290 --> 00:01:53,140
les mêmes données stockées dans la mémoire par une simple coulée à une

38
00:01:53,140 --> 00:01:54,576
type différent.

39
00:01:54,576 --> 00:01:57,250
Voici les tailles des types les plus communs sur un 32-bit

40
00:01:57,250 --> 00:01:58,340
le système d'exploitation.

41
00:01:58,340 --> 00:02:02,070
Nous avons un char à 1 byte, int et float à 4 octets, un long

42
00:02:02,070 --> 00:02:04,390
de long et un double de 8 octets.

43
00:02:04,390 --> 00:02:07,670
Parce qu'un int occupe 4 octets, il faudra jusqu'à 32 bits

44
00:02:07,670 --> 00:02:10,060
quand il est stocké dans la mémoire comme une série binaire

45
00:02:10,060 --> 00:02:11,500
de zéros et de uns.

46
00:02:11,500 --> 00:02:14,020
Tant que notre variable reste comme un type int, le

47
00:02:14,020 --> 00:02:16,740
ordinateur sera toujours convertir les uns et de zéros de

48
00:02:16,740 --> 00:02:19,120
binaire dans le numéro d'origine.

49
00:02:19,120 --> 00:02:21,270
Cependant, nous pourrions théoriquement jeter ces 32

50
00:02:21,270 --> 00:02:23,510
bits en une série de types booléens.

51
00:02:23,510 --> 00:02:26,090
Et puis l'ordinateur ne serait plus voir un certain nombre, mais

52
00:02:26,090 --> 00:02:28,810
au lieu d'une collection de zéros et de uns.

53
00:02:28,810 --> 00:02:31,570
On pourrait aussi essayer de lire ces données comme une valeur numérique différente

54
00:02:31,570 --> 00:02:34,660
taper, ou même comme une chaîne de quatre caractères.

55
00:02:34,660 --> 00:02:37,820
Lorsque vous traitez avec des numéros de coulée, vous devez tenir compte

56
00:02:37,820 --> 00:02:40,470
la précision de votre valeur sera affectée.

57
00:02:40,470 --> 00:02:43,240
Gardez à l'esprit que la précision peut rester le même,

58
00:02:43,240 --> 00:02:47,150
ou vous pouvez perdre en précision, mais vous ne pouvez jamais gagner en précision.

59
00:02:47,150 --> 00:02:49,060
Passons en revue les trois façons les plus courantes que vous pouvez

60
00:02:49,060 --> 00:02:50,400
une perte de précision.

61
00:02:50,400 --> 00:02:53,060
Jetant un flotteur à un int provoque la troncature de tout

62
00:02:53,060 --> 00:02:54,900
après la virgule, de sorte que vous êtes de gauche

63
00:02:54,900 --> 00:02:55,950
avec le nombre entier.

64
00:02:55,950 --> 00:03:02,000
Si nous prenons le x flotteur qui sera égal à 3,7, nous pouvons jeter

65
00:03:02,000 --> 00:03:05,580
cette variable x de type int int en écrivant simplement dans

66
00:03:05,580 --> 00:03:07,050
parenthèses.

67
00:03:07,050 --> 00:03:10,010
Chaque fois que nous utilisons ce terme ici, nous allons effectivement

68
00:03:10,010 --> 00:03:12,810
utiliser la valeur de trois parce que nous avons tronqué

69
00:03:12,810 --> 00:03:14,880
tout après la virgule.

70
00:03:14,880 --> 00:03:17,210
Nous pouvons également convertir un long long en int, qui sera

71
00:03:17,210 --> 00:03:20,760
même conduire à une perte de bits d'ordre supérieur.

72
00:03:20,760 --> 00:03:23,910
Un long long prend 8 octets, ou 64 bits en mémoire.

73
00:03:23,910 --> 00:03:27,050
Ainsi, lorsque nous le jeter à un int qui ne dispose que de 4 octets, ou 32

74
00:03:27,050 --> 00:03:29,820
bits, nous sommes essentiellement coupant tous les morceaux que

75
00:03:29,820 --> 00:03:32,420
représentent les valeurs binaires plus élevés.

76
00:03:32,420 --> 00:03:34,690
Vous pouvez aussi jeter un double à un flotteur, ce qui donnera

77
00:03:34,690 --> 00:03:37,340
vous le flotteur le plus proche possible de la double sans

78
00:03:37,340 --> 00:03:39,100
nécessairement arrondissant.

79
00:03:39,100 --> 00:03:41,840
Semblable à notre long long int à la conversion, la perte de

80
00:03:41,840 --> 00:03:44,890
C'est parce que la précision d'un double contient plus de données.

81
00:03:44,890 --> 00:03:47,910
Un double vous permettra de stocker 53 bits significatifs,

82
00:03:47,910 --> 00:03:50,650
environ 16 chiffres significatifs.

83
00:03:50,650 --> 00:03:53,050
Alors qu'un flotteur ne vous permettent de stocker 24

84
00:03:53,050 --> 00:03:56,235
bits significatifs, environ sept chiffres significatifs.

85
00:03:56,235 --> 00:03:58,700
Dans ces deux derniers cas, il peut être utile de penser à

86
00:03:58,700 --> 00:04:01,200
taper coulée que le redimensionnement d'une photo.

87
00:04:01,200 --> 00:04:03,860
Lorsque vous passez d'une grande taille d'une petite taille, vous ne pouvez pas voir

88
00:04:03,860 --> 00:04:05,600
les choses aussi clairement que vous avez perdu des données

89
00:04:05,600 --> 00:04:07,530
sous la forme de pixels.

90
00:04:07,530 --> 00:04:09,270
Conversion de type peut également causer des problèmes lorsque nous

91
00:04:09,270 --> 00:04:11,050
ints jeté à flotteurs.

92
00:04:11,050 --> 00:04:13,920
Depuis flotte sur une machine 32-bit seulement ont 24

93
00:04:13,920 --> 00:04:16,959
bits significatifs, ils ne peuvent pas représenter avec exactitude les valeurs

94
00:04:16,959 --> 00:04:22,750
plus de 2 à la puissance de 24, ou 16777217.

95
00:04:22,750 --> 00:04:25,540
Maintenant, nous allons parler de cast explicite et implicite.

96
00:04:25,540 --> 00:04:28,000
Conversion explicite, c'est quand nous écrivons le type entre parenthèses

97
00:04:28,000 --> 00:04:29,430
devant un nom de variable.

98
00:04:29,430 --> 00:04:33,100
A titre d'exemple, nous avons écrit avant int entre parenthèses avant notre

99
00:04:33,100 --> 00:04:35,640
float x variables.

100
00:04:35,640 --> 00:04:37,200
De cette façon, nous obtenons la valeur int, le

101
00:04:37,200 --> 00:04:38,593
valeur tronquée de 3,7 -

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

103
00:04:40,370 --> 00:04:42,970
Transtypage implicite est lorsque le compilateur change automatiquement

104
00:04:42,970 --> 00:04:46,340
types similaires à un type super, ou effectue une autre sorte de

105
00:04:46,340 --> 00:04:48,310
coulée sans que l'utilisateur d'écrire

106
00:04:48,310 --> 00:04:49,720
code supplémentaire.

107
00:04:49,720 --> 00:04:53,550
Par exemple, lorsque nous ajoutons 5 et 1.1, nos valeurs ont déjà

108
00:04:53,550 --> 00:04:55,680
types qui leur sont associés.

109
00:04:55,680 --> 00:04:59,480
La figure 5 est un int, alors que 1.1 est un flotteur.

110
00:04:59,480 --> 00:05:02,390
Afin de les ajouter, l'ordinateur lance 5 dans un flotteur,

111
00:05:02,390 --> 00:05:04,530
ce qui aurait été la même chose que l'écriture 5,0 dans le

112
00:05:04,530 --> 00:05:06,476
la première place.

113
00:05:06,476 --> 00:05:13,210
Mais de cette façon que nous disons flotteur 5 ou 5.0, ainsi que ce qui était déjà

114
00:05:13,210 --> 00:05:16,960
un flotteur, 1,1, et de là, nous pouvons ajouter ces

115
00:05:16,960 --> 00:05:18,640
valeurs et obtenir la valeur 6.1.

116
00:05:21,170 --> 00:05:23,500
Transtypage implicite nous permet également d'affecter des variables de

117
00:05:23,500 --> 00:05:25,590
types différents les uns des autres.

118
00:05:25,590 --> 00:05:28,110
On peut toujours attribuer un type moins précis dans un plus

119
00:05:28,110 --> 00:05:29,250
unique précis.

120
00:05:29,250 --> 00:05:37,060
Par exemple, si nous avons un x double, et un y int -

121
00:05:37,060 --> 00:05:40,120
et ceux-ci pourraient avoir les valeurs que nous leur fixées à -

122
00:05:40,120 --> 00:05:43,560
nous pouvons dire x est égal à y.

123
00:05:43,560 --> 00:05:46,340
Parce que le double est plus précis qu'un int, afin que nous

124
00:05:46,340 --> 00:05:48,380
ne perdre aucune information.

125
00:05:48,380 --> 00:05:50,420
D'autre part, il ne serait pas nécessairement correct de dire

126
00:05:50,420 --> 00:05:54,060
y est égal à x, car la double peut avoir une valeur plus grande que

127
00:05:54,060 --> 00:05:55,220
le nombre entier.

128
00:05:55,220 --> 00:05:57,420
Et si l'entier pourrait ne pas être en mesure de tenir tous les

129
00:05:57,420 --> 00:05:59,560
les informations stockées dans le double.

130
00:05:59,560 --> 00:06:02,610
Transtypage implicite est également utilisé dans les opérateurs de comparaison, comme

131
00:06:02,610 --> 00:06:06,410
supérieur à, inférieur à, ou de l'opérateur d'égalité.

132
00:06:06,410 --> 00:06:13,050
De cette façon, nous pouvons dire si 5.1 est supérieur à 5, et nous obtenons le

133
00:06:13,050 --> 00:06:14,750
entraîner vrai.

134
00:06:14,750 --> 00:06:18,470
Parce que 5 est un int, mais ça va être converti en un flotteur pour

135
00:06:18,470 --> 00:06:22,090
être comparé au flotteur 5.1, nous dirions 5.1 est

136
00:06:22,090 --> 00:06:24,550
supérieur à 5,0.

137
00:06:24,550 --> 00:06:31,320
Le même est vrai de dire si 2,0 est égal à égal à 2.

138
00:06:31,320 --> 00:06:34,190
Nous aimerions également obtenir vrai, parce que l'ordinateur va lancer le

139
00:06:34,190 --> 00:06:39,750
entier de 2 à flotter et ensuite dire 2,0 est égale à égale 2,0,

140
00:06:39,750 --> 00:06:41,660
cela est vrai.

141
00:06:41,660 --> 00:06:44,180
N'oubliez pas que nous pouvons également effectuer des conversions entre entiers et les caractères,

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

143
00:06:46,350 --> 00:06:49,690
Chars doivent également être réduite en binaire, c'est pourquoi vous

144
00:06:49,690 --> 00:06:51,920
pouvez facilement convertir entre les caractères et leurs respectives

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

146
00:06:53,260 --> 00:06:56,180
Pour en savoir plus à ce sujet, consultez notre vidéo sur l'ASCII.

147
00:06:56,180 --> 00:06:58,080
Lorsque vous prenez un moment pour réfléchir à la façon dont les données est stocké,

148
00:06:58,080 --> 00:06:59,990
il commence à faire beaucoup de sens.

149
00:06:59,990 --> 00:07:02,790
C'est comme la différence entre l'énergie éolienne et l'énergie éolienne.

150
00:07:02,790 --> 00:07:05,490
Les données sont les mêmes, mais le type ne peut changer la façon dont nous

151
00:07:05,490 --> 00:07:06,720
l'interpréter.

152
00:07:06,720 --> 00:07:10,430
Mon nom est Jordan Jozwiak, ce CS50.