1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 Bibliothèque]

2
00:00:02,490 --> 00:00:04,220
[Nate Hardison] [Université de Harvard]

3
00:00:04,220 --> 00:00:07,260
[C'est CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
La bibliothèque CS50 est un outil utile que nous avons installé sur l'appareil

5
00:00:11,510 --> 00:00:15,870
pour le rendre plus facile pour vous d'écrire des programmes qui invitent les utilisateurs pour l'entrée.

6
00:00:15,870 --> 00:00:21,670
Dans cette vidéo, nous allons tirer le rideau et regarde ce qui est exactement dans la bibliothèque CS50.

7
00:00:21,670 --> 00:00:25,520
>> Dans la vidéo sur des bibliothèques C, on parle de la façon dont vous les fichiers # include têtes

8
00:00:25,520 --> 00:00:27,570
de la bibliothèque dans votre code source,

9
00:00:27,570 --> 00:00:31,150
et puis vous liez avec un fichier de bibliothèque binaire, durant la phase de liaison

10
00:00:31,150 --> 00:00:33,140
du processus de compilation.

11
00:00:33,140 --> 00:00:36,440
Les fichiers d'en-tête de spécifier l'interface de la bibliothèque.

12
00:00:36,440 --> 00:00:41,280
Autrement dit, ils détaillent toutes les ressources que la bibliothèque dispose pour vous d'utiliser,

13
00:00:41,280 --> 00:00:45,250
comme des déclarations de fonctions, constantes et types de données.

14
00:00:45,250 --> 00:00:48,890
Le fichier de bibliothèque binaire contient la mise en œuvre de la bibliothèque,

15
00:00:48,890 --> 00:00:54,580
qui est compilé à partir des fichiers d'en-tête de la bibliothèque et la bibliothèque pour les fichiers. code source C.

16
00:00:54,580 --> 00:00:59,820
>> Le fichier de bibliothèque binaire n'est pas très intéressant à regarder car il est bien, en binaire.

17
00:00:59,820 --> 00:01:03,300
Donc, nous allons jeter un oeil aux fichiers d'en-tête de la bibliothèque à la place.

18
00:01:03,300 --> 00:01:07,710
Dans ce cas, il n'y a qu'un seul fichier d'en-tête appelé cs50.h.

19
00:01:07,710 --> 00:01:11,040
Nous l'avons installé dans le répertoire include utilisateur

20
00:01:11,040 --> 00:01:15,150
ainsi que les fichiers d'en-tête les bibliothèques du système des autres.

21
00:01:15,150 --> 00:01:21,530
>> Une des premières choses que vous remarquerez est que cs50.h # includes fichiers en-tête provenant d'autres bibliothèques -

22
00:01:21,530 --> 00:01:25,670
float, bool limites, standard, et lib standard.

23
00:01:25,670 --> 00:01:28,800
Encore une fois, suivant le principe de ne pas réinventer la roue,

24
00:01:28,800 --> 00:01:33,490
nous avons construit la bibliothèque CS0 l'aide des outils fournis que d'autres pour nous.

25
00:01:33,490 --> 00:01:38,690
>> La prochaine chose que vous verrez dans la bibliothèque, c'est que nous définissons un nouveau type appelé "chaîne."

26
00:01:38,690 --> 00:01:42,330
Cette ligne vraiment juste crée un alias pour le type char *,

27
00:01:42,330 --> 00:01:46,000
de sorte qu'il ne devient pas magiquement imprégner le nouveau type de chaîne avec des attributs

28
00:01:46,000 --> 00:01:49,650
souvent associé à des objets string dans d'autres langues,

29
00:01:49,650 --> 00:01:50,850
comme la longueur.

30
00:01:50,850 --> 00:01:55,180
La raison pour laquelle nous avons fait c'est de protéger les nouveaux programmeurs des détails sanglants

31
00:01:55,180 --> 00:01:57,580
de pointeurs jusqu'à ce qu'ils soient prêts.

32
00:01:57,580 --> 00:02:00,130
>> La prochaine partie du fichier d'en-tête est la déclaration des fonctions

33
00:02:00,130 --> 00:02:04,410
que la bibliothèque CS50 offre ainsi que la documentation.

34
00:02:04,410 --> 00:02:06,940
Notez que le niveau de détail dans les commentaires ici.

35
00:02:06,940 --> 00:02:10,560
C'est super important que les gens sachent comment utiliser ces fonctions.

36
00:02:10,560 --> 00:02:19,150
Nous déclarons, à son tour, agit pour demander à l'utilisateur et caractères de retour, doubles, flotteurs, entiers,

37
00:02:19,150 --> 00:02:24,160
à long soupire, et cordes, en utilisant notre propre type de chaîne.

38
00:02:24,160 --> 00:02:26,260
Suivant le principe de dissimulation d'information,

39
00:02:26,260 --> 00:02:31,640
nous avons mis notre définition dans un fichier séparé la mise en œuvre c -. cs50.c--

40
00:02:31,640 --> 00:02:35,110
situé dans le répertoire source de l'utilisateur.

41
00:02:35,110 --> 00:02:38,040
Nous avons fourni ce fichier de sorte que vous pouvez jeter un oeil à elle,

42
00:02:38,040 --> 00:02:41,490
apprendre de lui, et le recompiler sur des machines différentes si vous le souhaitez,

43
00:02:41,490 --> 00:02:45,510
même si nous pensons qu'il est préférable de travailler sur l'appareil de cette classe.

44
00:02:45,510 --> 00:02:47,580
Quoi qu'il en soit, nous allons jeter un coup d'oeil maintenant.

45
00:02:49,020 --> 00:02:54,620
>> Les fonctions getchar, GetDouble, GetFloat, getInt, et GetLongLong

46
00:02:54,620 --> 00:02:58,160
sont tous construits sur le dessus de la fonction GetString.

47
00:02:58,160 --> 00:03:01,510
Il s'avère qu'ils suivent tous essentiellement le même modèle.

48
00:03:01,510 --> 00:03:04,870
Ils utilisent une boucle while pour inviter l'utilisateur à une ligne d'entrée.

49
00:03:04,870 --> 00:03:08,430
Elles retournent une valeur particulière si l'utilisateur entre une ligne vide.

50
00:03:08,430 --> 00:03:11,750
Ils tentent d'analyser l'entrée de l'utilisateur dans le type approprié,

51
00:03:11,750 --> 00:03:15,010
qu'il s'agisse d'un char, un double, un flotteur, etc

52
00:03:15,010 --> 00:03:18,710
Et puis ils retournent le résultat soit si l'entrée a été correctement analysé

53
00:03:18,710 --> 00:03:21,330
ou ils Nouvelle invite l'utilisateur.

54
00:03:21,330 --> 00:03:24,230
>> À un niveau élevé, il n'ya rien de vraiment difficile ici.

55
00:03:24,230 --> 00:03:28,760
Vous pourriez avoir écrit le code de structure similaire vous-même dans le passé.

56
00:03:28,760 --> 00:03:34,720
Peut-être la partie la plus énigmatique est l'avenir de l'appel sscanf qui analyse l'entrée de l'utilisateur.

57
00:03:34,720 --> 00:03:38,160
Sscanf fait partie de la famille de conversion format d'entrée.

58
00:03:38,160 --> 00:03:42,300
Il vit dans io.h référence, dont le travail consiste à analyser une chaîne C,

59
00:03:42,300 --> 00:03:46,520
selon un format particulier, stocker les résultats d'analyse dans la variable

60
00:03:46,520 --> 00:03:48,720
fourni par l'appelant.

61
00:03:48,720 --> 00:03:53,570
Comme les fonctions de conversion de format d'entrée sont très utiles, les fonctions couramment utilisées

62
00:03:53,570 --> 00:03:56,160
qui ne sont pas super intuitif au premier abord,

63
00:03:56,160 --> 00:03:58,300
nous allons passer en revue la façon dont fonctionne sscanf.

64
00:03:58,300 --> 00:04:03,330
>> Le premier argument est un sscanf char * - un pointeur sur un caractère.

65
00:04:03,330 --> 00:04:05,150
Pour que la fonction fonctionne correctement,

66
00:04:05,150 --> 00:04:08,340
ce caractère doit être le premier caractère d'une chaîne de C,

67
00:04:08,340 --> 00:04:12,270
terminé avec l'hypothèse nulle caractère \ 0.

68
00:04:12,270 --> 00:04:15,120
Il s'agit de la chaîne à analyser

69
00:04:15,120 --> 00:04:18,269
Le second argument de sscanf est une chaîne de format,

70
00:04:18,269 --> 00:04:20,839
généralement transmis comme une constante chaîne,

71
00:04:20,839 --> 00:04:24,040
et vous avez pu voir une chaîne comme ça avant lorsque vous utilisez printf.

72
00:04:24,040 --> 00:04:28,650
Un signe pour cent dans la chaîne de format indique un spécificateur de conversion.

73
00:04:28,650 --> 00:04:30,850
Le caractère qui suit immédiatement un signe pour cent,

74
00:04:30,850 --> 00:04:35,430
indique le type C que nous voulons sscanf se convertir à l'.

75
00:04:35,430 --> 00:04:40,090
En getInt, vous voyez qu'il ya un% d et un c%.

76
00:04:40,090 --> 00:04:48,690
Cela signifie que sscanf va essayer à un int décimal - le d% - et un char -% c.

77
00:04:48,690 --> 00:04:51,510
Pour chaque indicateur de conversion dans la chaîne de format,

78
00:04:51,510 --> 00:04:56,620
sscanf attend un argument correspondant tard dans sa liste d'arguments.

79
00:04:56,620 --> 00:05:00,850
Cet argument doit pointer vers un endroit approprié dactylographiée

80
00:05:00,850 --> 00:05:04,000
dans lequel stocker le résultat de la conversion.

81
00:05:04,000 --> 00:05:08,910
>> La façon habituelle de procéder est de créer une variable sur la pile avant l'appel sscanf

82
00:05:08,910 --> 00:05:11,440
pour chaque élément que vous souhaitez analyser à partir de la chaîne

83
00:05:11,440 --> 00:05:15,520
puis utilisez l'opérateur d'adresse - l'esperluette - à passer des pointeurs

84
00:05:15,520 --> 00:05:19,100
de ces variables à l'appel sscanf.

85
00:05:19,100 --> 00:05:22,720
Vous pouvez voir que dans getInt nous faire exactement cela.

86
00:05:22,720 --> 00:05:28,240
Juste avant l'appel sscanf, nous déclarons un entier n et un appelé c appel caractères sur la pile,

87
00:05:28,240 --> 00:05:32,340
et nous passons des pointeurs vers eux dans l'appel sscanf.

88
00:05:32,340 --> 00:05:35,800
Mettre ces variables sur la pile est préférable à l'utilisation d'espace alloué

89
00:05:35,800 --> 00:05:39,350
sur le tas avec malloc, puisque vous éviter le surcoût de l'appel malloc,

90
00:05:39,350 --> 00:05:43,060
et vous n'avez pas à vous soucier de fuite de mémoire.

91
00:05:43,060 --> 00:05:47,280
Les caractères non préfixé par le signe pour cent ne demande pas de conversion.

92
00:05:47,280 --> 00:05:50,380
Au contraire, ils ne font qu'ajouter à la spécification de format.

93
00:05:50,380 --> 00:05:56,500
>> Par exemple, si la chaîne de format dans getInt étaient d% au lieu,

94
00:05:56,500 --> 00:05:59,800
sscanf serait chercher la lettre d'un suivi par un int,

95
00:05:59,800 --> 00:06:04,360
et tandis qu'il tente de convertir le type int, il ne serait pas faire autre chose avec l'un.

96
00:06:04,360 --> 00:06:07,440
La seule exception à cette règle est un espace.

97
00:06:07,440 --> 00:06:11,030
Caractères blancs dans la chaîne de format correspond à aucune quantité d'espaces -

98
00:06:11,030 --> 00:06:12,890
même pas du tout.

99
00:06:12,890 --> 00:06:18,100
Donc, c'est pour cela que le commentaire évoque peut-être avec la direction et / ou les espaces de fin.

100
00:06:18,100 --> 00:06:22,910
Donc, à ce stade, il ressemble à notre appel sscanf essaiera d'analyser chaîne d'entrée de l'utilisateur

101
00:06:22,910 --> 00:06:25,380
en vérifiant premier espace possible,

102
00:06:25,380 --> 00:06:29,300
suivie d'un int qui sera convertie et stockée dans la variable int n

103
00:06:29,300 --> 00:06:33,090
suivie d'une certaine quantité d'espace, et suivi d'un caractère

104
00:06:33,090 --> 00:06:35,810
stockés dans le répertoire c omble variable.

105
00:06:35,810 --> 00:06:37,790
>> Qu'en est-il de la valeur de retour?

106
00:06:37,790 --> 00:06:41,560
Sscanf va analyser la ligne d'entrée de bout en bout,

107
00:06:41,560 --> 00:06:44,860
l'arrêt lorsqu'elle arrive à la fin ou lors d'un caractère en entrée

108
00:06:44,860 --> 00:06:49,320
ne correspond pas à un caractère de format ou quand il ne peut pas faire une conversion.

109
00:06:49,320 --> 00:06:52,690
Valeur de retour Il est utilisé pour identifier quand il s'est arrêté.

110
00:06:52,690 --> 00:06:55,670
Si elle s'est arrêtée, car il a atteint la fin de la chaîne d'entrée

111
00:06:55,670 --> 00:07:00,630
avant d'effectuer des conversions et avant d'échouer à correspondre à une partie de la chaîne de format,

112
00:07:00,630 --> 00:07:04,840
alors la constante spéciale EOF est retournée.

113
00:07:04,840 --> 00:07:08,200
Sinon, elle renvoie le nombre de conversions réussies,

114
00:07:08,200 --> 00:07:14,380
qui peut être 0, 1 ou 2, étant donné que nous avons demandé deux conversions.

115
00:07:14,380 --> 00:07:19,000
Dans notre cas, nous voulons faire en sorte que l'utilisateur a tapé dans un int et seulement un int.

116
00:07:19,000 --> 00:07:23,370
>> Donc, nous voulons sscanf pour renvoyer 1. Voir pourquoi?

117
00:07:23,370 --> 00:07:26,850
Si sscanf retourné 0, alors aucun conversions ont été faites,

118
00:07:26,850 --> 00:07:31,690
si l'utilisateur a entré autre chose qu'un int au début de l'entrée.

119
00:07:31,690 --> 00:07:37,100
Si sscanf renvoie 2, l'utilisateur a bien rempli le taper au début de l'entrée,

120
00:07:37,100 --> 00:07:41,390
mais ils ont ensuite tapé dans un certain caractère non blanc après

121
00:07:41,390 --> 00:07:44,940
depuis l'% c conversion a réussi.

122
00:07:44,940 --> 00:07:49,570
Wow, c'est tout à fait une longue explication pour un appel de fonction.

123
00:07:49,570 --> 00:07:53,460
Quoi qu'il en soit, si vous voulez plus d'informations sur sscanf et ses frères et sœurs,

124
00:07:53,460 --> 00:07:57,130
consultez les pages de manuel, Google, ou les deux.

125
00:07:57,130 --> 00:07:58,780
Il ya beaucoup d'options de chaîne de format,

126
00:07:58,780 --> 00:08:03,830
et ceux-ci peuvent vous faire économiser beaucoup de travail manuel en essayant d'analyser des chaînes en C.

127
00:08:03,830 --> 00:08:07,180
>> La dernière fonction dans la bibliothèque à regarder est GetString.

128
00:08:07,180 --> 00:08:10,310
Il s'avère que GetString est une fonction difficile à écrire correctement,

129
00:08:10,310 --> 00:08:14,290
même si elle semble comme une tâche simple et commun.

130
00:08:14,290 --> 00:08:16,170
Pourquoi est-ce le cas?

131
00:08:16,170 --> 00:08:21,380
Eh bien, nous allons réfléchir à la façon dont nous allons stocker la ligne que l'utilisateur tape po

132
00:08:21,380 --> 00:08:23,880
Depuis une chaîne est une séquence de caractères,

133
00:08:23,880 --> 00:08:26,430
nous pourrions le stocker dans un tableau sur la pile,

134
00:08:26,430 --> 00:08:31,250
mais nous aurions besoin de savoir combien de temps le tableau va être quand on le déclare.

135
00:08:31,250 --> 00:08:34,030
De même, si nous voulons le mettre sur le tas,

136
00:08:34,030 --> 00:08:38,090
nous avons besoin de passer à malloc le nombre d'octets que nous voulons réserve,

137
00:08:38,090 --> 00:08:39,730
mais cela est impossible.

138
00:08:39,730 --> 00:08:42,760
Nous n'avons aucune idée du nombre de caractères que l'utilisateur va taper

139
00:08:42,760 --> 00:08:46,590
avant que l'utilisateur ne fait de les taper.

140
00:08:46,590 --> 00:08:50,720
>> Une solution naïve à ce problème est de simplement réserver une grande partie de l'espace, par exemple,

141
00:08:50,720 --> 00:08:54,540
un bloc de 1000 caractères pour l'entrée de l'utilisateur,

142
00:08:54,540 --> 00:08:57,980
en supposant que l'utilisateur n'aurait jamais taper une chaîne longue.

143
00:08:57,980 --> 00:09:00,810
C'est une mauvaise idée pour deux raisons.

144
00:09:00,810 --> 00:09:05,280
Premièrement, en supposant que les utilisateurs n'ont généralement pas taper dans les chaînes si longtemps,

145
00:09:05,280 --> 00:09:07,610
vous pourriez perdre beaucoup de mémoire.

146
00:09:07,610 --> 00:09:10,530
Sur les machines modernes, ce ne serait pas un problème si vous faites cela

147
00:09:10,530 --> 00:09:13,890
dans un ou deux cas isolés,

148
00:09:13,890 --> 00:09:17,630
mais si vous prenez entrée de l'utilisateur dans une boucle et stocker pour une utilisation ultérieure,

149
00:09:17,630 --> 00:09:20,870
vous pouvez rapidement sucer une tonne de mémoire.

150
00:09:20,870 --> 00:09:24,450
En outre, si le programme que vous écrivez est un petit ordinateur -

151
00:09:24,450 --> 00:09:28,100
un dispositif comme un smartphone ou autre chose avec une mémoire limitée -

152
00:09:28,100 --> 00:09:32,060
cette solution peut entraîner des problèmes beaucoup plus rapidement.

153
00:09:32,060 --> 00:09:36,450
La seconde raison, plus grave de ne pas le faire, c'est qu'il laisse votre programme vulnérable

154
00:09:36,450 --> 00:09:39,710
à ce qu'on appelle une attaque par débordement de tampon.

155
00:09:39,710 --> 00:09:45,840
En programmation, un tampon est une mémoire utilisée pour stocker temporairement des données d'entrée ou de sortie,

156
00:09:45,840 --> 00:09:48,980
qui dans ce cas est de notre chevalier 1000-bloc.

157
00:09:48,980 --> 00:09:53,370
Un débordement de tampon se produit lorsque des données sont écrites après la fin du bloc.

158
00:09:53,370 --> 00:09:57,790
>> Par exemple, si un utilisateur ne fait tapez plus de 1000 caractères.

159
00:09:57,790 --> 00:10:01,570
Vous avez sans doute vécu ce accidentellement lors de la programmation avec les tableaux.

160
00:10:01,570 --> 00:10:05,620
Si vous avez un tableau de 10 entiers, rien ne vous empêche d'essayer de lire ou d'écrire

161
00:10:05,620 --> 00:10:07,810
l'int 15.

162
00:10:07,810 --> 00:10:10,000
Il n'y a pas d'avertissements du compilateur ou d'erreurs.

163
00:10:10,000 --> 00:10:13,250
Le programme seulement bévues, continuer tout droit et accède à la mémoire

164
00:10:13,250 --> 00:10:18,150
où il pense que l'int 15e sera, et ce qui peut écraser vos autres variables.

165
00:10:18,150 --> 00:10:22,040
Dans le pire des cas, vous pouvez remplacer certains des internes de votre programme

166
00:10:22,040 --> 00:10:26,820
mécanismes de contrôle, l'origine de votre programme de réellement exécuter des instructions différentes

167
00:10:26,820 --> 00:10:28,340
que vous le souhaitez.

168
00:10:28,340 --> 00:10:31,360
>> Maintenant, ce n'est pas commun de le faire accidentellement,

169
00:10:31,360 --> 00:10:35,150
mais c'est une technique assez répandue que les méchants utiliser pour briser des programmes

170
00:10:35,150 --> 00:10:39,080
et mettre du code malveillant sur les ordinateurs des autres.

171
00:10:39,080 --> 00:10:42,910
Par conséquent, nous ne pouvons pas utiliser notre solution naïve.

172
00:10:42,910 --> 00:10:45,590
Nous devons trouver un moyen d'empêcher nos programmes d'être vulnérable

173
00:10:45,590 --> 00:10:47,880
à une attaque par débordement de tampon.

174
00:10:47,880 --> 00:10:51,430
Pour ce faire, nous devons nous assurer que notre tampon peut se développer comme nous le lisons

175
00:10:51,430 --> 00:10:53,850
plus entrée de l'utilisateur.

176
00:10:53,850 --> 00:10:57,440
La solution? Nous utilisons un tampon alloué tas.

177
00:10:57,440 --> 00:10:59,950
Puisque nous ne pouvons redimensionner en utilisant le redimensionnement de la fonction realloc,

178
00:10:59,950 --> 00:11:04,580
et nous gardons la trace de deux nombres - l'indice de la fente vide suivante dans la mémoire tampon

179
00:11:04,580 --> 00:11:08,390
et la longueur ou de la capacité de la mémoire tampon.

180
00:11:08,390 --> 00:11:13,210
Nous lisons dans les caractères de l'utilisateur un à la fois en utilisant la fonction fgetc.

181
00:11:13,210 --> 00:11:19,360
L'argument de la fonction fgetc prend - stdin - est une référence à la chaîne d'entrée standard,

182
00:11:19,360 --> 00:11:23,810
qui est un canal d'entrée préconnecté qui est utilisé pour transférer l'entrée de l'utilisateur

183
00:11:23,810 --> 00:11:26,270
à partir de la borne à l'émission.

184
00:11:26,270 --> 00:11:29,890
>> Chaque fois que l'utilisateur tape un caractère nouveau, nous vérifions pour voir si l'indice

185
00:11:29,890 --> 00:11:35,810
de la fente à côté libre plus 1 est plus grand que la capacité de la mémoire tampon.

186
00:11:35,810 --> 00:11:39,690
Le +1 est disponible en cause si le prochain index libre est de 5,

187
00:11:39,690 --> 00:11:44,150
alors notre buffer de longueur doit être de 6 à 0 grâce indexation.

188
00:11:44,150 --> 00:11:48,350
Si nous sommes à court d'espace dans la mémoire tampon, puis nous essayons de le redimensionner,

189
00:11:48,350 --> 00:11:51,690
le doubler afin que nous réduisons le nombre de fois que nous redimensionner

190
00:11:51,690 --> 00:11:54,760
si l'utilisateur tape dans une chaîne très longue.

191
00:11:54,760 --> 00:11:57,950
Si la chaîne est devenu trop long ou si nous manquons de mémoire de tas,

192
00:11:57,950 --> 00:12:01,350
nous libérer de notre tampon et return null.

193
00:12:01,350 --> 00:12:04,170
>> Enfin, nous ajoutons le caractère à la mémoire tampon.

194
00:12:04,170 --> 00:12:08,200
Une fois que l'utilisateur clique sur entrer ou revenir, signalant une nouvelle ligne,

195
00:12:08,200 --> 00:12:12,050
ou le caractère spécial - le contrôle d - qui marque la fin de l'entrée,

196
00:12:12,050 --> 00:12:16,240
nous faisons une vérification pour voir si l'utilisateur a effectivement tapé dans rien du tout.

197
00:12:16,240 --> 00:12:18,820
Sinon, nous retourner null.

198
00:12:18,820 --> 00:12:22,280
Dans le cas contraire, parce que notre tampon est probablement plus important que nous avons besoin,

199
00:12:22,280 --> 00:12:24,830
dans le pire des cas, il est presque deux fois plus grand que nous devons

200
00:12:24,830 --> 00:12:27,830
puisque nous doubler chaque fois que nous redimensionner,

201
00:12:27,830 --> 00:12:31,840
nous faisons une nouvelle copie de la chaîne en utilisant juste la quantité d'espace dont nous avons besoin.

202
00:12:31,840 --> 00:12:34,220
Nous ajoutons un 1 supplémentaire à l'appel malloc,

203
00:12:34,220 --> 00:12:37,810
de sorte qu'il ya de la place pour le caractère spécial terminateur null - le \ 0,

204
00:12:37,810 --> 00:12:41,990
dont nous joindre à la chaîne une fois que nous copier dans le reste des personnages,

205
00:12:41,990 --> 00:12:45,060
en utilisant strcpy strncpy au lieu de

206
00:12:45,060 --> 00:12:48,830
afin que nous puissions préciser exactement combien de caractères que nous voulons copier.

207
00:12:48,830 --> 00:12:51,690
Strcpy copie jusqu'à ce qu'il rencontre un \ 0.

208
00:12:51,690 --> 00:12:55,740
Ensuite nous libérons notre buffer et renvoie la copie à l'appelant.

209
00:12:55,740 --> 00:12:59,840
>> Qui savait par exemple une fonction simple en apparence pourrait être si compliqué?

210
00:12:59,840 --> 00:13:02,820
Maintenant, vous savez ce qui se passe dans la bibliothèque CS50.

211
00:13:02,820 --> 00:13:06,470
>> Mon nom est Nate Hardison, et c'est CS50.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]