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

2
00:00:02,350 --> 00:00:05,444

3
00:00:05,444 --> 00:00:06,360
DOUG LLOYD: Très bien.

4
00:00:06,360 --> 00:00:07,770
Sorte d'un sujet étrange, non?

5
00:00:07,770 --> 00:00:09,050
Les nombres magiques.

6
00:00:09,050 --> 00:00:12,012
Que mangez-il dire quand il est
parler de chiffres magiques?

7
00:00:12,012 --> 00:00:14,220
Eh bien, certains des programmes
que nous avons écrit dans CS50

8
00:00:14,220 --> 00:00:16,660
jusqu'à présent ont eu une certaine bizarre
numéros sorte de jetés en eux.

9
00:00:16,660 --> 00:00:19,680
Peut-être que nous ne le faisons pas pour des raisons
comprendre entièrement dès maintenant.

10
00:00:19,680 --> 00:00:23,950
Par exemple, dans le problème Mario, nous
plafonné la hauteur de la pyramide à 23.

11
00:00:23,950 --> 00:00:26,880
Nous vous dit explicitement
ne peut pas aller plus haut que 23.

12
00:00:26,880 --> 00:00:28,702
>> Mais qu'est-ce que 23 cela veut dire?

13
00:00:28,702 --> 00:00:30,410
Eh bien, si vous lisez le
spec attentivement, vous

14
00:00:30,410 --> 00:00:32,493
aurait vu que le
raison pour laquelle nous l'a couvert à 23

15
00:00:32,493 --> 00:00:36,160
est parce que la hauteur standard
d'une fenêtre de terminal est de 24.

16
00:00:36,160 --> 00:00:38,860
Et si nous avons la
pyramide être plus grand que cela,

17
00:00:38,860 --> 00:00:41,290
il pourrait faire cette chose bizarre
où il dirige hors de l'écran.

18
00:00:41,290 --> 00:00:45,140
Et vous savez, ce qui ne
ce que cela signifie dans le contexte, non?

19
00:00:45,140 --> 00:00:48,880
>> Est la signification du 23 immédiatement évident
à quelqu'un qui regarde votre programme

20
00:00:48,880 --> 00:00:51,550
et a peut-être un autre
fenêtre de terminal de la taille?

21
00:00:51,550 --> 00:00:52,330
Probablement pas.

22
00:00:52,330 --> 00:00:53,080
Il semble que, OK.

23
00:00:53,080 --> 00:00:55,005
Eh bien, pourquoi est-il un peu moins de 23?

24
00:00:55,005 --> 00:00:56,880
En général, il est le genre
d'une mauvaise habitude fait

25
00:00:56,880 --> 00:00:58,940
pour écrire des constantes dans votre code.

26
00:00:58,940 --> 00:01:02,190
Pour ce faire, lorsque vous faites réellement
écrire une constante dans votre code,

27
00:01:02,190 --> 00:01:05,630
il est parfois appelé en utilisant
numéros de magie, qui est quelque chose

28
00:01:05,630 --> 00:01:08,030
nous voulons généralement pour essayer d'éviter.

29
00:01:08,030 --> 00:01:12,830
>> Par exemple, nous allons jeter un coup d'oeil
à ce simple fonction ici.

30
00:01:12,830 --> 00:01:15,726
Évidemment, il n'y a pas de données
type dans C appelé carte ou le pont.

31
00:01:15,726 --> 00:01:16,600
Il suffit donc de garder avec moi.

32
00:01:16,600 --> 00:01:18,910
Il est un peu de
pseudo mélangé ici.

33
00:01:18,910 --> 00:01:21,050
Ceci est une fonction appelée
traiter carte qui apparemment

34
00:01:21,050 --> 00:01:26,570
prend une plate-forme en tant que paramètre, et
volonté de sortie pour me une seule carte.

35
00:01:26,570 --> 00:01:30,990
>> Et je fais quelque chose ici où je
une boucle qui va de 0 à 52,

36
00:01:30,990 --> 00:01:33,394
et je traite une carte.

37
00:01:33,394 --> 00:01:35,310
Eh bien, nous avons une magie
nombre ici, à droite.

38
00:01:35,310 --> 00:01:38,790
Voyez-vous ce que le nombre magique est?

39
00:01:38,790 --> 00:01:42,280
Ou, plus important, avez-vous
voir quel est le problème ici?

40
00:01:42,280 --> 00:01:44,310
En particulier, si ce
est juste une fonction

41
00:01:44,310 --> 00:01:48,030
dans son propre fichier dans un
dossier qui contient

42
00:01:48,030 --> 00:01:49,970
un tas de différents
fichiers, dont chacun

43
00:01:49,970 --> 00:01:51,670
fait une autre chose à un jeu de cartes.

44
00:01:51,670 --> 00:01:57,310
Peut-être que les mélange, ou traite une main
de cinq cartes au lieu d'une seule carte.

45
00:01:57,310 --> 00:01:59,420
>> Voyez-vous ce que le
problème pourrait être ici?

46
00:01:59,420 --> 00:02:03,220
Voyez-vous le nombre magique
Je l'ai injecté dans le code?

47
00:02:03,220 --> 00:02:04,390
Il est 52, à droite.

48
00:02:04,390 --> 00:02:06,440
>> Comme, intuitivement vous le savez probablement, OK.

49
00:02:06,440 --> 00:02:09,740
Comme un jeu standard de
cartes contient 52 cartes.

50
00:02:09,740 --> 00:02:12,570
Mais, dans notre programme, il est juste
type de flottant autour de là.

51
00:02:12,570 --> 00:02:15,280
Il est comme tout d'un coup il ya un 52.

52
00:02:15,280 --> 00:02:18,290
>> Une façon de résoudre ce
problème est de le faire.

53
00:02:18,290 --> 00:02:22,724
Nous sommes très explicitement maintenant
appelant la taille de pont que 52.

54
00:02:22,724 --> 00:02:25,390
Il donne un peu plus intuitive
dire lorsque dans la boucle for

55
00:02:25,390 --> 00:02:28,650
plus tard on dit alors, i
est inférieure à la taille de pont.

56
00:02:28,650 --> 00:02:32,666
Il semble juste mieux que de dire 52.

57
00:02:32,666 --> 00:02:34,290
Maintenant, cela ne résout effectivement le problème.

58
00:02:34,290 --> 00:02:38,460
Il ne donne une certaine symbolique
un sens à la constante.

59
00:02:38,460 --> 00:02:40,820
Mais il ne sorte de réalité
introduire un autre problème

60
00:02:40,820 --> 00:02:43,770
qui pourrait ne pas être immédiatement apparent.

61
00:02:43,770 --> 00:02:45,859
Même si cette variable
est déclarée globally--

62
00:02:45,859 --> 00:02:47,650
vous vous souvenez de ce qu'il
signifie que lorsque nous déclarons

63
00:02:47,650 --> 00:02:50,500
une variable à l'échelle mondiale par rapport au niveau local?

64
00:02:50,500 --> 00:02:53,340
Même si nous déclarons une variable
à l'échelle mondiale, ce qui si il ya

65
00:02:53,340 --> 00:02:55,500
dans une autre fonction
notre gamme de fonctions

66
00:02:55,500 --> 00:02:59,750
qui traitent de la manipulation de la carte
que les changements par inadvertance taille du pont,

67
00:02:59,750 --> 00:03:02,727
ou elle augmente par
1 ou diminue par 1.

68
00:03:02,727 --> 00:03:04,060
Cela pourrait causer des problèmes, non?

69
00:03:04,060 --> 00:03:08,261
Surtout si nous avons affaire à un ensemble
de cartes où mélanger les cartes complète

70
00:03:08,261 --> 00:03:08,760
est requis.

71
00:03:08,760 --> 00:03:12,804
Si la taille de pont est diminuée
par une, par exemple, à 51,

72
00:03:12,804 --> 00:03:14,970
nous ne sommes pas réellement brassage
toutes les cartes éventuellement.

73
00:03:14,970 --> 00:03:16,500
Nous partons d'une d'entre elles.

74
00:03:16,500 --> 00:03:21,680
Et cette valeur pourrait peut-être
prédit ou exploité par un mauvais acteur.

75
00:03:21,680 --> 00:03:24,920
>> C fournit ce qu'on appelle un
directive de préprocesseur, qui

76
00:03:24,920 --> 00:03:27,764
est aussi appelé une macro pour
créer constantes symboliques.

77
00:03:27,764 --> 00:03:30,180
Et en fait, vous avez déjà
vu une directive de préprocesseur,

78
00:03:30,180 --> 00:03:32,916
même si vous ne l'avez pas entendu
qui appelle avec #include.

79
00:03:32,916 --> 00:03:37,150
Il est un autre exemple d'une macro
ou directive de préprocesseur.

80
00:03:37,150 --> 00:03:41,290
>> La façon de créer des constantes symboliques,
ou de donner un nom à une constante

81
00:03:41,290 --> 00:03:43,740
de sorte qu 'il présente plus
ce qui signifie, est comme suit.

82
00:03:43,740 --> 00:03:47,030
#define, le nom, le remplacement.

83
00:03:47,030 --> 00:03:49,140
Vraiment important côté
ici vraiment rapide.

84
00:03:49,140 --> 00:03:54,180
Ne pas mettre un point-virgule
la fin de vos #defines.

85
00:03:54,180 --> 00:03:57,310
Donc, il est #define, le nom, le remplacement.

86
00:03:57,310 --> 00:03:59,540
>> Lorsque votre programme est compilé,
ce qui se passe réellement

87
00:03:59,540 --> 00:04:01,740
est le compilateur si vous allez
de passer par votre code

88
00:04:01,740 --> 00:04:06,770
et remplacer chaque instance de
le mot «nom» avec tout ce que vous

89
00:04:06,770 --> 00:04:08,860
mettre en remplacement.

90
00:04:08,860 --> 00:04:13,060
De manière analogue, si #include est en quelque sorte
de similaire à copier et coller,

91
00:04:13,060 --> 00:04:15,700
puis #define est en quelque sorte
similaire à rechercher et remplacer,

92
00:04:15,700 --> 00:04:19,180
si vous avez déjà utilisé cette fonctionnalité dans un
programme de traitement de texte, par exemple.

93
00:04:19,180 --> 00:04:26,345
>> Ainsi, par exemple, si je
#define PI comme 3.14159265,

94
00:04:26,345 --> 00:04:28,720
si vous êtes mieux mathématiquement
inclinée et vous avez soudainement

95
00:04:28,720 --> 00:04:31,640
voir 3.14159265 vol
autour de votre code,

96
00:04:31,640 --> 00:04:33,517
vous le savez probablement, il parle pi.

97
00:04:33,517 --> 00:04:35,850
Mais peut-être que nous pouvons lui donner un
peu de signification plus symbolique.

98
00:04:35,850 --> 00:04:39,850
Et nous pouvons dire à la place #define
pi que celle bouchée de numéros

99
00:04:39,850 --> 00:04:42,110
que je ne vais pas garder
lisant et relisant.

100
00:04:42,110 --> 00:04:45,560
>> Et qu'est-ce qui va se passer ensuite au
compilation est lorsque le programme est

101
00:04:45,560 --> 00:04:48,530
compilé, la première chose qui
qui va se passer est il faudra passer par

102
00:04:48,530 --> 00:04:51,520
et il va remplacer à chaque fois
il voit grand P, I majuscule,

103
00:04:51,520 --> 00:04:55,610
il va littéralement remplacer par
3.14 et ainsi de suite, de sorte que vous

104
00:04:55,610 --> 00:04:58,090
ne pas avoir à le taper à chaque
temps pendant que votre programme encore

105
00:04:58,090 --> 00:05:00,631
a la fonctionnalité que vous
attendre, parce que vous travaillez

106
00:05:00,631 --> 00:05:05,090
à la manipulation, multipliant,
divise, quel qu'il soit par pi.

107
00:05:05,090 --> 00:05:08,230
>> Vous n'êtes pas limité à cette
substitution pour que des chiffres.

108
00:05:08,230 --> 00:05:12,279
Par exemple, je pourrais #define
Bien sûr que le CS50 de chaîne.

109
00:05:12,279 --> 00:05:14,070
Dans ce cas, lorsque le
programme est compilé,

110
00:05:14,070 --> 00:05:16,236
#define passera par le
code, remplacer chaque fois

111
00:05:16,236 --> 00:05:19,900
il voit "bien sûr" avec le CS50 de chaîne.

112
00:05:19,900 --> 00:05:21,720
>> Vous remarquerez ici
aussi que je fréquemment

113
00:05:21,720 --> 00:05:26,090
#define tout mon défini symbolique
constantes, pour ainsi dire,

114
00:05:26,090 --> 00:05:28,130
sont toujours en majuscules.

115
00:05:28,130 --> 00:05:28,960
Il est une convention.

116
00:05:28,960 --> 00:05:30,170
Il est pas nécessaire.

117
00:05:30,170 --> 00:05:33,900
La raison généralement les gens vont utiliser
toutes les capitales quand ils #defining

118
00:05:33,900 --> 00:05:37,590
est juste pour le rendre vraiment clair que
cet élément particulier de mon code

119
00:05:37,590 --> 00:05:38,820
est une constante définie.

120
00:05:38,820 --> 00:05:43,730
Si elle était minuscule, il est possible que
il pourrait être confondu avec une variable.

121
00:05:43,730 --> 00:05:46,120
Et cela est probablement
pas une bonne chose à faire.

122
00:05:46,120 --> 00:05:48,910
>> Donc, ce particulier
solution est beaucoup mieux

123
00:05:48,910 --> 00:05:50,550
que chacun des précédents.

124
00:05:50,550 --> 00:05:59,950
Si je premier #define taille de paquet de 52, puis
maintenant mon utilisation de 52, ou la taille de pont ici,

125
00:05:59,950 --> 00:06:01,850
est beaucoup plus intuitif et beaucoup plus sûr.

126
00:06:01,850 --> 00:06:03,280
Vous ne pouvez pas manipuler une constante.

127
00:06:03,280 --> 00:06:05,259
Vous ne pouvez pas dire 52 plus plus.

128
00:06:05,259 --> 00:06:06,800
Cela ne va pas pour le convertir en 53.

129
00:06:06,800 --> 00:06:09,390
Vous ne pouvez pas changer 52 à quelque chose.

130
00:06:09,390 --> 00:06:12,470
>> Vous pouvez modifier une variable
dont la valeur est 52,

131
00:06:12,470 --> 00:06:14,870
qui a été la première solution que nous avions avant.

132
00:06:14,870 --> 00:06:17,000
Et vous pourriez augmenter
cette variable à 53.

133
00:06:17,000 --> 00:06:21,100
Mais vous ne pouvez pas dire 52 plus plus et
avoir ce soudain tourner 52 en 53.

134
00:06:21,100 --> 00:06:23,350
52 est toujours 52.

135
00:06:23,350 --> 00:06:28,860
Et si vous ne pouvez pas changer par inadvertance
Taille longue ici en le manipulant,

136
00:06:28,860 --> 00:06:29,940

137
00:06:29,940 --> 00:06:32,390
>> Un autre bon côté
effet de ce bien est

138
00:06:32,390 --> 00:06:38,310
qui êtes-vous conscient que
tous les pays à travers le monde

139
00:06:38,310 --> 00:06:40,690
utiliser un jeu de cartes de la taille 52?

140
00:06:40,690 --> 00:06:45,630
Par exemple, il est très commun dans
Allemagne à utiliser une taille de paquet de 32,

141
00:06:45,630 --> 00:06:48,020
où ils dépouillent certains
des cartes de faible valeur.

142
00:06:48,020 --> 00:06:50,960
Et dans ce cas, je
voulu au port ma suite

143
00:06:50,960 --> 00:06:55,390
des fonctions qui traitent de
carte manipulation à l'Allemagne.

144
00:06:55,390 --> 00:06:59,440
Je pouvais dans le premier cas, nous
a montré, à aller et remplacer

145
00:06:59,440 --> 00:07:03,570
toutes les instances de 52 dans mon code 32.

146
00:07:03,570 --> 00:07:07,940
>> Mais ici, si je #define taille de pont
que 32 tout en haut de mon code,

147
00:07:07,940 --> 00:07:11,730
si je dois changer, je peux
juste aller et changer une chose.

148
00:07:11,730 --> 00:07:15,010
Recompiler mon code, et tous
un coup, il se propage à travers.

149
00:07:15,010 --> 00:07:18,850
En fait, nous pouvons changer le pont
taille à une valeur que nous voulons.

150
00:07:18,850 --> 00:07:22,500
>> Puis-je vous intéresser dans un
jeu de la taille de pont pick-up?

151
00:07:22,500 --> 00:07:23,430
>> Je suis Doug Lloyd.

152
00:07:23,430 --> 00:07:25,840
Et cela est CS50.

153
00:07:25,840 --> 00:07:27,772