1
00:00:00,000 --> 00:00:02,420
>> [Jouer de la musique]

2
00:00:02,420 --> 00:00:05,189

3
00:00:05,189 --> 00:00:05,980
CONFÉRENCIER: Très bien.

4
00:00:05,980 --> 00:00:08,540
Donc, nous allons parler d'une autre
chose qui est un peu unique de C,

5
00:00:08,540 --> 00:00:10,010
ce qui est des types de données et variables.

6
00:00:10,010 --> 00:00:12,340
Quand je dis unique de C, je vraiment
seulement signifier dans le cadre de,

7
00:00:12,340 --> 00:00:14,470
si vous avez été un programmeur
pour un temps très long,

8
00:00:14,470 --> 00:00:16,270
Vous avez probablement pas
travaillé avec des types de données

9
00:00:16,270 --> 00:00:18,470
si vous avez utilisé moderne
langages de programmation.

10
00:00:18,470 --> 00:00:20,432
Langues modernes comme
PHP et JavaScript,

11
00:00:20,432 --> 00:00:22,640
que nous verrons également un peu
par la suite dans le cadre,

12
00:00:22,640 --> 00:00:25,550
vous ne avez pas réellement besoin de spécifier
le type d'une variable de données

13
00:00:25,550 --> 00:00:26,270
lorsque vous l'utilisez.

14
00:00:26,270 --> 00:00:28,067
>> Vous venez de le déclarer et de commencer à l'utiliser.

15
00:00:28,067 --> 00:00:29,900
Si il est un entier, il
sais qu'il est un entier.

16
00:00:29,900 --> 00:00:31,960
Si elle est un personnage, il est
sait qu'il est un personnage.

17
00:00:31,960 --> 00:00:35,320
Si il est un mot, il sait
il est une chaîne, soi-disant.

18
00:00:35,320 --> 00:00:37,300
>> Mais en C, qui est un
langue plus ancienne, nous avons besoin

19
00:00:37,300 --> 00:00:39,420
pour spécifier les données
type de chaque variable

20
00:00:39,420 --> 00:00:42,990
que nous créons la première fois
que nous utilisons cette variable.

21
00:00:42,990 --> 00:00:45,030
Donc C est livré avec une certaine
intégré dans les types de données.

22
00:00:45,030 --> 00:00:46,972
Et nous allons nous familiariser
avec certains de ceux-ci.

23
00:00:46,972 --> 00:00:50,180
Et puis après, nous parlerons également un
peu de certains des types de données

24
00:00:50,180 --> 00:00:54,450
que nous avons écrit pour vous,
de sorte que vous pouvez les utiliser dans CS50.

25
00:00:54,450 --> 00:00:56,130
>> Le premier est int.

26
00:00:56,130 --> 00:00:59,110
Le type de données int est utilisé pour les variables
qui va stocker des valeurs entières.

27
00:00:59,110 --> 00:01:03,210
Donc, 1, 2, 3, négative 1, 2, 3, et ainsi de suite.

28
00:01:03,210 --> 00:01:05,960
Entiers, ce qui est quelque chose que vous
devrait garder à l'esprit pour le quiz,

29
00:01:05,960 --> 00:01:09,590
toujours prendre jusqu'à quatre octets
de la mémoire, qui est 32 bits.

30
00:01:09,590 --> 00:01:11,620
Il y a huit bits dans un octet.

31
00:01:11,620 --> 00:01:14,470
>> Cela signifie donc que la gamme de
valeurs qui peut stocker un nombre entier

32
00:01:14,470 --> 00:01:19,130
est limitée par ce qui peut tenir dans
32 bits valeur de l'information.

33
00:01:19,130 --> 00:01:21,850
Maintenant, il se trouve que,
il a été décidé il ya longtemps

34
00:01:21,850 --> 00:01:24,310
que nous diviser
cette gamme de 32 bits

35
00:01:24,310 --> 00:01:26,650
en nombres entiers négatifs
et des nombres entiers positifs,

36
00:01:26,650 --> 00:01:28,390
chaque demi obtenir de la gamme.

37
00:01:28,390 --> 00:01:32,230
Ainsi, la gamme de valeurs que nous représentons
avec une gamme entière de négative 2

38
00:01:32,230 --> 00:01:36,520
à la puissance 31 à 2 à
la puissance 31 moins 1,

39
00:01:36,520 --> 00:01:38,190
causez vous avez aussi besoin d'un endroit pour 0.

40
00:01:38,190 --> 00:01:41,650
>> Donc, fondamentalement, la moitié des valeurs possibles
vous pouvez tenir dans un int sont négatifs,

41
00:01:41,650 --> 00:01:42,610
et la moitié sont positifs.

42
00:01:42,610 --> 00:01:47,270
Et à peu près ici, il est question négative
2 milliards à environ 2 milliards de positif.

43
00:01:47,270 --> 00:01:50,207
Donner ou prendre quelques centaines de millions.

44
00:01:50,207 --> 00:01:52,290
Voilà ce que vous pouvez adapter
dans une variable entière.

45
00:01:52,290 --> 00:01:55,490
Maintenant, nous avons aussi quelque chose
appelé un entier non signé.

46
00:01:55,490 --> 00:01:59,220
Maintenant ints non signés ne sont pas un
type de variable distincte.

47
00:01:59,220 --> 00:02:01,590
Plutôt, non signé est
ce qu'on appelle un qualificatif.

48
00:02:01,590 --> 00:02:04,990
Il modifie les données
Type de légèrement entier.

49
00:02:04,990 --> 00:02:07,850
>> Et dans ce cas, ce unsigned
désigne: et vous pouvez également

50
00:02:07,850 --> 00:02:11,530
utiliser d'autres types de données non signés,
entier est pas le seul.

51
00:02:11,530 --> 00:02:15,310
Ce qu'il fait est effectivement doubles
la gamme de valeurs positives

52
00:02:15,310 --> 00:02:19,350
qu'un entier peut prendre au
aux dépens de ne plus permettre

53
00:02:19,350 --> 00:02:21,140
vous de prendre des valeurs négatives.

54
00:02:21,140 --> 00:02:25,400
Donc, si vous avez des chiffres que vous connaissez
obtiendra plus de 2 milliards, mais moins

55
00:02:25,400 --> 00:02:31,280
de 4 milliards, pour example--
qui est 2 à la 32e power--

56
00:02:31,280 --> 00:02:33,330
vous pouvez utiliser
un unsigned int si vous

57
00:02:33,330 --> 00:02:35,050
connaître votre valeur ne sera jamais négatif.

58
00:02:35,050 --> 00:02:37,216
>> Vous avez de temps en temps
utilisé pour les variables non signés

59
00:02:37,216 --> 00:02:39,460
dans CS50, qui est pourquoi je mentionne ici.

60
00:02:39,460 --> 00:02:43,830
Mais encore une fois, la plage de valeurs que vous
peut représenter avec un entier non signé

61
00:02:43,830 --> 00:02:48,240
en tant que nombre entier à t régulier, sont égaux à 0
à 2 à la 32e puissance moins 1,

62
00:02:48,240 --> 00:02:50,840
soit environ 0 à 4000000000.

63
00:02:50,840 --> 00:02:53,730
Donc, vous avez effectivement doublé la
plage positive que vous pouvez adapter,

64
00:02:53,730 --> 00:02:56,270
mais vous avez abandonné tout
les valeurs négatives.

65
00:02:56,270 --> 00:03:00,040
>> Maintenant, en passant, non signé
est le seul qualificatif pas

66
00:03:00,040 --> 00:03:01,790
que nous pourrions voir pour
types de données variables.

67
00:03:01,790 --> 00:03:05,779
Il ya aussi des choses appelées
court et long et const.

68
00:03:05,779 --> 00:03:07,820
Const nous verrons un peu
peu plus tard dans le cours.

69
00:03:07,820 --> 00:03:10,830
Court et long, nous ne sera probablement pas.

70
00:03:10,830 --> 00:03:12,830
>> Mais il suffit de savoir qu'il y
sont d'autres qualificatifs.

71
00:03:12,830 --> 00:03:14,080
Unsigned est pas le seul.

72
00:03:14,080 --> 00:03:16,596
Mais il est le seul que nous sommes
va parler maintenant.

73
00:03:16,596 --> 00:03:17,310
Ainsi, très bien.

74
00:03:17,310 --> 00:03:18,393
Donc, nous avons couvert entiers.

75
00:03:18,393 --> 00:03:19,200
Et après?

76
00:03:19,200 --> 00:03:20,130
>> Chars.

77
00:03:20,130 --> 00:03:23,620
Donc, les caractères sont utilisés pour les variables
qui va stocker les caractères simples.

78
00:03:23,620 --> 00:03:24,850
Char est l'abréviation de caractère.

79
00:03:24,850 --> 00:03:27,870
Et parfois, vous pourriez entendre
les gens prononcent comme voiture.

80
00:03:27,870 --> 00:03:32,020
>> Donc personnages prennent toujours un
octet de mémoire, qui est à seulement 8 bits.

81
00:03:32,020 --> 00:03:35,700
Donc, ce qui signifie qu'ils ne peuvent tenir
des valeurs de l'ordre de 2 négative

82
00:03:35,700 --> 00:03:42,430
à la septième puissance, ou négative 128,
à 2 à la 7e puissance moins 1, ou 127.

83
00:03:42,430 --> 00:03:45,710
>> Merci à ASCII, il était
décidé depuis longtemps un moyen

84
00:03:45,710 --> 00:03:50,805
pour cartographier ces chiffres positifs
0 à 127 à divers personnages

85
00:03:50,805 --> 00:03:52,182
qui existe sur toute notre clavier.

86
00:03:52,182 --> 00:03:54,640
Donc, comme nous le verrons plus tard dans
le cours, et vous aurez probablement

87
00:03:54,640 --> 00:03:57,700
venir à mémoriser à un certain
point A majuscule, pour example--

88
00:03:57,700 --> 00:04:00,732
la capitale de caractères A-
cartes pour le numéro 65.

89
00:04:00,732 --> 00:04:02,940
Et la raison en est que
parce que ce qui est il est

90
00:04:02,940 --> 00:04:05,490
été attribué par la norme ASCII.

91
00:04:05,490 --> 00:04:07,850
>> Minuscules A est 97.

92
00:04:07,850 --> 00:04:11,900
Le caractère 0 lorsque vous
effectivement taper le caractère, pas

93
00:04:11,900 --> 00:04:13,532
représentant le nombre zéro, est de 48.

94
00:04:13,532 --> 00:04:15,240
Vous apprendrez un couple
de ces que vous allez.

95
00:04:15,240 --> 00:04:17,990
Et vous aurez certainement venus à avoir besoin
les un peu plus tard dans CS50.

96
00:04:17,990 --> 00:04:20,450

97
00:04:20,450 --> 00:04:23,390
>> Le prochain grand type de données
est nombres à virgule flottante.

98
00:04:23,390 --> 00:04:26,100
Donc, nombres à virgule flottante sont
également connu comme nombres réels.

99
00:04:26,100 --> 00:04:28,850
Ils sont essentiellement des chiffres qui
avoir un point en eux décimal.

100
00:04:28,850 --> 00:04:33,360
Valeurs à virgule flottante
comme entiers sont également

101
00:04:33,360 --> 00:04:36,090
contenu à l'intérieur 4 octets de mémoire.

102
00:04:36,090 --> 00:04:37,580
Maintenant, il ya pas de carte ici.

103
00:04:37,580 --> 00:04:40,890
Il n'y a pas de numéro de ligne, parce
pour décrire la gamme d'un flotteur

104
00:04:40,890 --> 00:04:44,550
ne sait pas exactement ou intuitive.

105
00:04:44,550 --> 00:04:47,350
>> Qu'il suffise de dire que vous
avoir 32 bits pour travailler avec.

106
00:04:47,350 --> 00:04:49,730
Et si vous avez un certain nombre
comme pi, qui a

107
00:04:49,730 --> 00:04:55,510
une partie entière 3, et un flottant
point de partie, ou partie décimale 0,14159,

108
00:04:55,510 --> 00:04:58,735
et ainsi de suite, vous devez être
capable de représenter tous it--

109
00:04:58,735 --> 00:05:02,420
la partie entière et la partie décimale.

110
00:05:02,420 --> 00:05:04,550
>> Alors, que pensez-vous que cela pourrait signifier?

111
00:05:04,550 --> 00:05:08,180
Une chose est que si la décimale
partie plus en plus longue,

112
00:05:08,180 --> 00:05:10,660
si je dois un très grand
partie entière, je ne pourrais pas

113
00:05:10,660 --> 00:05:13,090
être en mesure d'être aussi précis
avec la partie décimale.

114
00:05:13,090 --> 00:05:15,280
Et qui est vraiment le
limitation d'un flotteur.

115
00:05:15,280 --> 00:05:17,229
>> Flotteurs ont un problème de précision.

116
00:05:17,229 --> 00:05:19,270
Nous avons seulement 32 bits à
travailler avec, donc nous ne pouvons

117
00:05:19,270 --> 00:05:22,510
être si précis avec notre partie décimale.

118
00:05:22,510 --> 00:05:27,300
Nous ne pouvons pas avoir nécessairement une décimale
rôle précis à 100 ou 200 chiffres,

119
00:05:27,300 --> 00:05:29,710
parce que nous avons seulement
32 bits pour travailler avec.

120
00:05:29,710 --> 00:05:31,590
Voilà donc une limitation d'un flotteur.

121
00:05:31,590 --> 00:05:33,590
>> Maintenant, heureusement, il ya
un autre type de données appelée

122
00:05:33,590 --> 00:05:36,530
double, qui a quelque peu
traite de ce problème.

123
00:05:36,530 --> 00:05:39,980
Doubles, comme flotteurs, sont également utilisés pour
stocker des nombres réels, ou virgule flottante

124
00:05:39,980 --> 00:05:40,840
des valeurs.

125
00:05:40,840 --> 00:05:44,340
La différence est que
doubles sont à double précision.

126
00:05:44,340 --> 00:05:48,177
Ils peuvent tenir 64 bits de
données, ou huit octets.

127
00:05:48,177 --> 00:05:49,010
Qu'est-ce que cela veut dire?

128
00:05:49,010 --> 00:05:51,801
Eh bien, cela signifie que nous pouvons être beaucoup plus
précise avec le point décimal.

129
00:05:51,801 --> 00:05:54,830
Au lieu d'avoir pi à sept
endroits peut-être, avec un flotteur,

130
00:05:54,830 --> 00:05:56,710
nous pouvons peut-être avoir à 30 places.

131
00:05:56,710 --> 00:05:59,824
Si ce qui est important, vous voudrez peut-
d'utiliser un double au lieu d'un flotteur.

132
00:05:59,824 --> 00:06:01,740
Fondamentalement, si vous êtes
tout travail où

133
00:06:01,740 --> 00:06:06,540
ayant une très longue décimale
et beaucoup de précision est importante,

134
00:06:06,540 --> 00:06:08,630
vous voulez probablement
utiliser une double overfloat.

135
00:06:08,630 --> 00:06:11,250
Maintenant, pour la plupart de votre travail dans
CS50, un flotteur devrait suffire.

136
00:06:11,250 --> 00:06:15,340
Mais ne savent que les doubles existent en tant que
façon de traiter avec la précision un peu

137
00:06:15,340 --> 00:06:20,980
problème en vous donnant un supplément de 32
bits à travailler avec vos numéros.

138
00:06:20,980 --> 00:06:23,650
>> Or, ce ne sont pas un type de données.

139
00:06:23,650 --> 00:06:24,390
Ceci est un type.

140
00:06:24,390 --> 00:06:25,340
Et il a appelé vide.

141
00:06:25,340 --> 00:06:27,506
Et je parle à ce sujet
ici parce que nous avons probablement

142
00:06:27,506 --> 00:06:29,520
vu à quelques reprises déjà dans CS50.

143
00:06:29,520 --> 00:06:32,020
Et vous demandez peut-être
ce qu'il est tout au sujet.

144
00:06:32,020 --> 00:06:33,390
>> Donc vide est un type.

145
00:06:33,390 --> 00:06:34,097
Il existe.

146
00:06:34,097 --> 00:06:35,180
Mais il est un type de données.

147
00:06:35,180 --> 00:06:39,350
>> Nous ne pouvons pas créer une variable de type
annuler et d'attribuer une valeur.

148
00:06:39,350 --> 00:06:42,519
Mais les fonctions, par exemple,
peut avoir un type de retour void.

149
00:06:42,519 --> 00:06:45,060
Fondamentalement, si vous voyez une fonction
qui a un type de retour void,

150
00:06:45,060 --> 00:06:46,970
cela signifie qu'il ne renvoie pas de valeur.

151
00:06:46,970 --> 00:06:49,440
Pouvez-vous penser d'une commune
fonction que nous avons utilisé jusqu'à présent

152
00:06:49,440 --> 00:06:52,780
dans CS50 qui ne retourne pas une valeur?

153
00:06:52,780 --> 00:06:54,700
>> Printf est un.

154
00:06:54,700 --> 00:06:56,820
Printf fait pas réellement
rien à vous retourner.

155
00:06:56,820 --> 00:06:59,850
Elle imprime quelque chose à la
écran, et il est fondamentalement

156
00:06:59,850 --> 00:07:01,650
un effet secondaire de ce fait printf.

157
00:07:01,650 --> 00:07:03,620
Mais il ne vous donne pas une valeur de retour.

158
00:07:03,620 --> 00:07:08,419
Vous ne capturer et stocker le résultat
dans une variable pour l'utiliser plus tard.

159
00:07:08,419 --> 00:07:10,710
Elle imprime juste quelque chose à
l'écran et vous avez terminé.

160
00:07:10,710 --> 00:07:14,360
>> Donc, nous disons que printf
est une fonction de vide.

161
00:07:14,360 --> 00:07:16,450
Il ne renvoie rien.

162
00:07:16,450 --> 00:07:18,580
>> La liste de périmètre d'un
fonction peut également être vide.

163
00:07:18,580 --> 00:07:21,410
Et vous avez vu aussi que
un peu dans CS50 trop.

164
00:07:21,410 --> 00:07:22,300
Void main Int.

165
00:07:22,300 --> 00:07:23,260
Est-ce que sonner une cloche?

166
00:07:23,260 --> 00:07:24,080

167
00:07:24,080 --> 00:07:27,220
Fondamentalement, ce que cela signifie est que
principale ne prend pas de paramètres.

168
00:07:27,220 --> 00:07:29,520
Il n'y a pas que l'argument
se passé dans principal.

169
00:07:29,520 --> 00:07:32,780
Maintenant, plus tard, nous voyons qu'il ya
un moyen de transmettre des arguments en principal,

170
00:07:32,780 --> 00:07:36,189
mais jusqu'à présent, ce que nous avons
vu est nulle principal int.

171
00:07:36,189 --> 00:07:37,730
Principale juste ne prend pas d'arguments.

172
00:07:37,730 --> 00:07:40,236
Et donc nous précisons que en disant vide.

173
00:07:40,236 --> 00:07:42,110
Nous sommes juste en étant très
explicite sur le fait

174
00:07:42,110 --> 00:07:44,430
qu'il ne prend pas d'arguments.

175
00:07:44,430 --> 00:07:47,160
>> Donc pour l'instant, il suffit de
dire que nulle essentiellement

176
00:07:47,160 --> 00:07:50,789
devrait simplement servir comme un espace réservé
pour vous de penser à rien.

177
00:07:50,789 --> 00:07:52,080
Il est pas vraiment faire quelque chose.

178
00:07:52,080 --> 00:07:53,550
Il n'y a pas de valeur de retour ici.

179
00:07:53,550 --> 00:07:54,770
Il n'y a pas les paramètres ici.

180
00:07:54,770 --> 00:07:55,709
Il est vide.

181
00:07:55,709 --> 00:07:57,250
Il est un peu plus complexe que cela.

182
00:07:57,250 --> 00:08:00,640
Mais cela devrait suffire pour
la plus grande partie du cours.

183
00:08:00,640 --> 00:08:05,010
Et nous espérons que vous avez maintenant un peu
peu plus d'un concept de ce vide est.

184
00:08:05,010 --> 00:08:08,460
>> Donc, ceux qui sont les cinq types que vous aurez
rencontre qui sont intégrés à C.

185
00:08:08,460 --> 00:08:10,670
Mais dans CS50 nous avons aussi une bibliothèque.

186
00:08:10,670 --> 00:08:13,550
CS50.h, que vous pouvez inclure.

187
00:08:13,550 --> 00:08:15,930
Et qui vous fournira
avec deux types supplémentaires

188
00:08:15,930 --> 00:08:18,280
que vous serez probablement en mesure
à utiliser sur vos missions,

189
00:08:18,280 --> 00:08:21,210
ou tout simplement travailler généralement programmation.

190
00:08:21,210 --> 00:08:23,030
>> Le premier d'entre eux est bool.

191
00:08:23,030 --> 00:08:26,780
Ainsi, le type de données booléen,
bool, est utilisé pour les variables

192
00:08:26,780 --> 00:08:28,114
qui va stocker une valeur booléenne.

193
00:08:28,114 --> 00:08:29,863
Si vous avez jamais entendu
ce terme avant, vous

194
00:08:29,863 --> 00:08:31,960
pourrait savoir qu'un booléenne
valeur est capable de seulement

195
00:08:31,960 --> 00:08:34,440
la tenue de deux valeurs distinctes différentes.

196
00:08:34,440 --> 00:08:35,872
Vrai et faux.

197
00:08:35,872 --> 00:08:37,580
Maintenant, ce semble assez
fondamentale, non?

198
00:08:37,580 --> 00:08:40,496
Il est un peu une surprise que cette
inexistant dans C comme il est intégré.

199
00:08:40,496 --> 00:08:42,640
Et dans de nombreuses langues modernes,
bien sûr, les booléens

200
00:08:42,640 --> 00:08:45,390
sont un type de données standard par défaut.

201
00:08:45,390 --> 00:08:47,192
Mais en C, ils sont en fait pas.

202
00:08:47,192 --> 00:08:48,400
Mais nous avons créé pour vous.

203
00:08:48,400 --> 00:08:51,910
Donc, si jamais vous avez besoin pour créer
une variable dont le type est bool,

204
00:08:51,910 --> 00:08:55,230
juste être sûr de #inclure CS50.h
au début de votre programme,

205
00:08:55,230 --> 00:08:57,800
et vous serez en mesure de créer
variables de type BOOL.

206
00:08:57,800 --> 00:09:02,095
>> Si vous oubliez de #inclure CS50.h, et
vous commencez à utiliser des variables de type booléen,

207
00:09:02,095 --> 00:09:04,970
vous pourriez rencontrer quelques problèmes
quand vous compilez votre programme.

208
00:09:04,970 --> 00:09:06,490
Il suffit donc être à l'affût pour cela.

209
00:09:06,490 --> 00:09:11,180
Et peut-être vous pouvez simplement fixer le
problèmes de livres, y compris CS50.h.

210
00:09:11,180 --> 00:09:14,590
>> L'autre grand type de données que nous
fournir pour vous dans la bibliothèque CS50

211
00:09:14,590 --> 00:09:15,670
est une chaîne.

212
00:09:15,670 --> 00:09:17,130
Donc ce qui est une chaîne?

213
00:09:17,130 --> 00:09:18,520
Les chaînes sont vraiment juste des mots.

214
00:09:18,520 --> 00:09:20,000
Ils sont des collections de caractères.

215
00:09:20,000 --> 00:09:20,640
Ils sont des mots.

216
00:09:20,640 --> 00:09:21,390
Ils sont des phrases.

217
00:09:21,390 --> 00:09:22,480
Ils sont paragraphes.

218
00:09:22,480 --> 00:09:25,850
Peut-être des livres entiers, même.

219
00:09:25,850 --> 00:09:29,690
>> Très courte à très longue
série de caractères.

220
00:09:29,690 --> 00:09:34,310
Si vous avez besoin d'utiliser des chaînes,
par exemple, pour stocker un mot,

221
00:09:34,310 --> 00:09:37,609
juste être sûr d'inclure CS50.h
au début de votre programme

222
00:09:37,609 --> 00:09:38,900
de sorte que vous pouvez utiliser le type de chaîne.

223
00:09:38,900 --> 00:09:43,910
Et puis, vous pouvez créer des variables
dont le type de données est une chaîne.

224
00:09:43,910 --> 00:09:46,160
Maintenant, plus tard dans le cours,
Nous verrons également que ce est

225
00:09:46,160 --> 00:09:47,752
pas toute l'histoire, que ce soit.

226
00:09:47,752 --> 00:09:49,460
Nous allons rencontrer des choses
structures dites,

227
00:09:49,460 --> 00:09:54,249
qui vous permettra de groupe ce qui peut être
un entier et une chaîne en une seule unité.

228
00:09:54,249 --> 00:09:56,290
Et nous pouvons l'utiliser pour
un but, qui pourrait

229
00:09:56,290 --> 00:09:57,750
utile plus tard dans le cours.

230
00:09:57,750 --> 00:09:59,500
>> Et nous apprendrons aussi
sur les types définis,

231
00:09:59,500 --> 00:10:01,720
qui vous permettent de créer
vos propres types de données.

232
00:10:01,720 --> 00:10:03,060
Nous ne devons pas à vous soucier
à ce sujet pour l'instant.

233
00:10:03,060 --> 00:10:04,550
Mais il suffit de savoir que ce est
quelque chose sur l'horizon,

234
00:10:04,550 --> 00:10:07,633
qu'il ya beaucoup plus à cet ensemble
ce genre de chose que je vous dis simplement

235
00:10:07,633 --> 00:10:08,133
maintenant.

236
00:10:08,133 --> 00:10:10,591
Alors, maintenant que nous avons appris
peu de données de base

237
00:10:10,591 --> 00:10:14,230
les types et les types de données CS50, nous allons
parler de la façon de travailler avec des variables

238
00:10:14,230 --> 00:10:18,530
et créer en utilisant ces
types de données dans nos programmes.

239
00:10:18,530 --> 00:10:22,670
Si vous voulez créer une variable,
tout ce que vous devez faire est de deux choses.

240
00:10:22,670 --> 00:10:24,147
>> D'abord, vous devez lui donner un type.

241
00:10:24,147 --> 00:10:26,230
La deuxième chose que vous devez
à faire est de lui donner un nom.

242
00:10:26,230 --> 00:10:28,740
Une fois que vous avez fait cela et giflé un
virgule à la fin de cette ligne,

243
00:10:28,740 --> 00:10:29,830
vous avez créé une variable.

244
00:10:29,830 --> 00:10:32,370
>> Alors, voici deux exemples.

245
00:10:32,370 --> 00:10:35,744
Numéro Int; lettre omble ;.

246
00:10:35,744 --> 00:10:36,660
Qu'ai-je fait ici?

247
00:10:36,660 --> 00:10:38,110
Je ai créé deux variables.

248
00:10:38,110 --> 00:10:40,190
>> La première, la variable de
nom est le numéro.

249
00:10:40,190 --> 00:10:44,830
Et le numéro est capable de tenir entier
saisir des valeurs, car son type est int.

250
00:10:44,830 --> 00:10:48,040
Lettre est une autre variable
qui peut contenir des caractères

251
00:10:48,040 --> 00:10:50,240
car son type de données est char.

252
00:10:50,240 --> 00:10:51,772
>> Assez simple, non?

253
00:10:51,772 --> 00:10:53,480
Si vous vous trouvez
dans une situation où

254
00:10:53,480 --> 00:10:56,250
vous devez créer plusieurs
les variables de même type,

255
00:10:56,250 --> 00:10:58,740
vous ne devez spécifier
le nom du type une fois.

256
00:10:58,740 --> 00:11:01,600
Ensuite, il suffit énumérer autant de variables
de ce type que vous avez besoin.

257
00:11:01,600 --> 00:11:04,230
>> Donc, je ne pouvais par exemple, ici
dans cette troisième ligne de code,

258
00:11:04,230 --> 00:11:07,420
dire int hauteur ;, nouvelle ligne.

259
00:11:07,420 --> 00:11:08,291
Largeur int ;.

260
00:11:08,291 --> 00:11:09,290
Et ce serait trop de travail.

261
00:11:09,290 --> 00:11:12,039
Je serais encore obtenir deux variables appelées
hauteur et en largeur, dont chacune

262
00:11:12,039 --> 00:11:12,730
est un nombre entier.

263
00:11:12,730 --> 00:11:16,970
Mais je suis autorisé à, les choses à la syntaxe C,
consolider en une seule ligne.

264
00:11:16,970 --> 00:11:20,230
Int hauteur, la largeur; C'est la même chose.

265
00:11:20,230 --> 00:11:23,900
Je ai créé deux variables, l'un appelé
une hauteur appelée largeur, qui tous deux

266
00:11:23,900 --> 00:11:26,730
sont capables de tenir
valeurs de type integer.

267
00:11:26,730 --> 00:11:30,920
>> De même ici, je peux créer trois
valeurs à virgule flottante à la fois.

268
00:11:30,920 --> 00:11:33,350
Je peux peut-être créer une variable
appelé racine carrée de 2--

269
00:11:33,350 --> 00:11:35,766
qui vraisemblablement finira
tenir le point-- flottante

270
00:11:35,766 --> 00:11:39,222
que la représentation de la place
racine de 2-- racine carrée de 3, et pi.

271
00:11:39,222 --> 00:11:41,180
Je pourrais l'ai fait
sur trois lignes distinctes.

272
00:11:41,180 --> 00:11:47,690
Float, racine carrée 2; Float racine carrée
3; flotter pi; et que ce serait trop de travail.

273
00:11:47,690 --> 00:11:50,590
>> Mais encore une fois, je ne peux consolider
cela en une seule ligne de code.

274
00:11:50,590 --> 00:11:54,050
Rend les choses un peu
court, pas aussi maladroit.

275
00:11:54,050 --> 00:11:57,259
>> Maintenant, en général, il est bon que la conception à la
déclarer une variable lorsque vous en avez besoin.

276
00:11:57,259 --> 00:11:59,050
Et nous allons parler un peu
peu plus à ce sujet

277
00:11:59,050 --> 00:12:00,945
plus tard au cours
lorsque nous discutons de la portée.

278
00:12:00,945 --> 00:12:03,320
Donc, ne pas nécessairement besoin de
créer tous vos variables

279
00:12:03,320 --> 00:12:05,990
au début du programme,
certaines personnes auraient pu le faire par le passé,

280
00:12:05,990 --> 00:12:08,700
ou était certainement un très commune
il ya les pratiques de codage de nombreuses années

281
00:12:08,700 --> 00:12:11,700
lorsque l'on travaille avec C. Vous pourriez juste
vouloir créer un droit variable lorsque

282
00:12:11,700 --> 00:12:13,140
vous en avez besoin.

283
00:12:13,140 --> 00:12:13,640
Bien.

284
00:12:13,640 --> 00:12:15,150
Nous avons donc créé des variables.

285
00:12:15,150 --> 00:12:16,790
Comment pouvons-nous les utilisons?

286
00:12:16,790 --> 00:12:18,650
Après, nous déclarons une
variables, nous ne devons pas

287
00:12:18,650 --> 00:12:21,237
pour spécifier le type de données
de cette variable plus.

288
00:12:21,237 --> 00:12:24,070
En fait, si vous le faites, vous pourriez
retrouver avec des conséquences étranges

289
00:12:24,070 --> 00:12:25,490
que nous allons sorte de gommer pour le moment.

290
00:12:25,490 --> 00:12:27,365
Mais il suffit de dire,
des choses étranges vont

291
00:12:27,365 --> 00:12:30,740
à commencer à se produire si vous inadvertance
re-déclarer des variables avec le même nom

292
00:12:30,740 --> 00:12:32,210
encore et encore.

293
00:12:32,210 --> 00:12:33,882
>> Donc ici, je dois quatre lignes de code.

294
00:12:33,882 --> 00:12:36,090
Et je dois un couple de
commentaires là juste indiquant

295
00:12:36,090 --> 00:12:37,840
ce qui se passe sur
chaque ligne, juste pour aider

296
00:12:37,840 --> 00:12:40,520
vous êtes situé dans ce qui se passe.

297
00:12:40,520 --> 00:12:41,520
Numéro Donc int ;.

298
00:12:41,520 --> 00:12:42,520
Vous avez vu que précédemment.

299
00:12:42,520 --> 00:12:44,000
Voilà une déclaration de variable.

300
00:12:44,000 --> 00:12:46,670
>> Je avons maintenant créé une variable
nombre qui est appelé

301
00:12:46,670 --> 00:12:48,970
capable de maintenir les valeurs de type entier.

302
00:12:48,970 --> 00:12:50,210
Je l'ai déclaré il.

303
00:12:50,210 --> 00:12:53,770
>> La ligne suivante je assigner
une valeur de nombre.

304
00:12:53,770 --> 00:12:54,992
Nombre égal à 17.

305
00:12:54,992 --> 00:12:55,950
Ce qui s'y passe?

306
00:12:55,950 --> 00:12:58,880
Je mets le numéro 17
à l'intérieur de cette variable.

307
00:12:58,880 --> 00:13:02,760
>> Donc, si jamais je puis imprimer ce
le contenu de nombre sont plus tard,

308
00:13:02,760 --> 00:13:04,030
ils me disent qu'il est 17.

309
00:13:04,030 --> 00:13:07,030
Donc, je l'ai déclaré une variable,
et puis je l'ai assigné.

310
00:13:07,030 --> 00:13:10,570
>> Nous pouvons répéter le processus
nouveau avec la lettre char ;.

311
00:13:10,570 --> 00:13:11,640
Voilà une déclaration.

312
00:13:11,640 --> 00:13:14,010
Lettre égale le capital
H. Ceci est une mission.

313
00:13:14,010 --> 00:13:16,030
Assez simple, aussi.

314
00:13:16,030 --> 00:13:18,319
>> Maintenant, ce processus pourrait
semble un peu ridicule.

315
00:13:18,319 --> 00:13:20,110
Pourquoi faisons-nous ça
en deux lignes de code?

316
00:13:20,110 --> 00:13:21,401
Y at-il une meilleure façon de le faire?

317
00:13:21,401 --> 00:13:22,250
En fait, il est.

318
00:13:22,250 --> 00:13:24,375
Parfois, vous pourriez voir
ce appelée initialisation.

319
00:13:24,375 --> 00:13:28,446
Il est quand vous déclarez une variable
et attribuer une valeur à la fois.

320
00:13:28,446 --> 00:13:30,320
Ceci est en fait une jolie
chose commune à faire.

321
00:13:30,320 --> 00:13:32,870
Lorsque vous créez une variable, vous avez normalement
veux qu'il y ait une certaine valeur de base.

322
00:13:32,870 --> 00:13:34,330
Même si elle est 0 ou quelque chose.

323
00:13:34,330 --> 00:13:36,180
Vous venez de vous donnez une valeur.

324
00:13:36,180 --> 00:13:38,360
>> Vous pouvez initialiser une variable.

325
00:13:38,360 --> 00:13:42,320
Int nombre est égal à 17 est le même que
les deux premières lignes de code en haut.

326
00:13:42,320 --> 00:13:46,829
H est égal à Char lettre est la même que la
troisième et quatrième lignes de code ci-dessus.

327
00:13:46,829 --> 00:13:49,620
La livraison la plus importante ici
lorsque nous déclarer et assigner

328
00:13:49,620 --> 00:13:51,740
variables est après nous avons
déclarée, avis

329
00:13:51,740 --> 00:13:53,700
Je ne suis pas en utilisant à nouveau le type de données.

330
00:13:53,700 --> 00:13:57,916
Je ne dis pas int nombre est égal à 17 sur
la deuxième ligne de code, par exemple.

331
00:13:57,916 --> 00:13:59,290
Je dis juste que nombre équivaut à 17.

332
00:13:59,290 --> 00:14:02,537
>> Encore une fois, re-déclarer une variable après
vous avez déjà déclaré il peut conduire

333
00:14:02,537 --> 00:14:03,620
dans une certaine conséquence bizarre.

334
00:14:03,620 --> 00:14:05,950
Il suffit donc de faire attention à cela.

335
00:14:05,950 --> 00:14:06,660
>> Je suis Doug Lloyd.

336
00:14:06,660 --> 00:14:08,870
Et cela est CS50.

337
00:14:08,870 --> 00:14:10,499