1
00:00:00,000 --> 00:00:00,520

2
00:00:00,520 --> 00:00:03,530
>> ENCEINTE: Écrivons un programme qui
invite l'utilisateur à deux cordes et

3
00:00:03,530 --> 00:00:07,170
signale ensuite si ces chaînes
sont identiques ou non identiques.

4
00:00:07,170 --> 00:00:10,290
J'ai déjà commencé à nous hors ici par
printf appeler deux fois et appelant

5
00:00:10,290 --> 00:00:14,520
GetString deux fois, stocker le retour
valeurs de s et t, respectivement.

6
00:00:14,520 --> 00:00:17,960
>> Maintenant, mes instincts de comparer ces deux
cordes serait d'utiliser le familier

7
00:00:17,960 --> 00:00:19,160
opérateur d'égalité -

8
00:00:19,160 --> 00:00:22,070
si s est égal égaux t.

9
00:00:22,070 --> 00:00:28,120
Ensuite, je vais aller de l'avant et d'impression
sur "Vous avez tapé la même chose!

10
00:00:28,120 --> 00:00:35,190
Sinon, si ce n'est pas vrai, je suis tout simplement
aller taper printf ("Vous avez tapé

11
00:00:35,190 --> 00:00:37,880
choses différentes!

12
00:00:37,880 --> 00:00:38,850
>> Assez simple -

13
00:00:38,850 --> 00:00:41,820
Je suis tout simplement en comparant s contre
t, et si elles sont égales,

14
00:00:41,820 --> 00:00:43,250
imprimer autant.

15
00:00:43,250 --> 00:00:45,450
Disons compiler et exécuter ce programme.

16
00:00:45,450 --> 00:00:51,950
Faire comparer 0. / Comparer
0, dire quelque chose, bonjour,

17
00:00:51,950 --> 00:00:54,200
dire quelque chose, bonjour.

18
00:00:54,200 --> 00:00:56,870
>> Malheureusement, le programme pense que je n'ai
tapé des choses différentes, même si je

19
00:00:56,870 --> 00:00:59,530
clairement typé "bonjour" le
même manière les deux fois.

20
00:00:59,530 --> 00:01:00,850
Maintenant, pourquoi cela pourrait-il être?

21
00:01:00,850 --> 00:01:03,750
>> Eh bien, il s'avère que tout cela
temps, les chaînes ont été un peu plus

22
00:01:03,750 --> 00:01:06,780
complexe d'une séquence de caractères
sous la hotte.

23
00:01:06,780 --> 00:01:11,450
En réalité, une chaîne est un pointeur ou un
adresse, en particulier l'adresse

24
00:01:11,450 --> 00:01:14,640
du premier caractère par le fait que
séquence de caractères.

25
00:01:14,640 --> 00:01:18,640
>> Et quand on compare s contre t
avec le signe égal égal, nous sommes

26
00:01:18,640 --> 00:01:23,200
fait demander, est cette adresse
égal égal à cette adresse?

27
00:01:23,200 --> 00:01:26,850
Et cela ne va pas être le cas si
l'utilisateur a tapé dans deux différents

28
00:01:26,850 --> 00:01:30,370
cordes et nous avons appelé deux fois GetString
pour les obtenir, parce que la mémoire

29
00:01:30,370 --> 00:01:34,480
que GetString utilise pour stocker le premier
chaîne pourrait être ici dans la RAM, mais la

30
00:01:34,480 --> 00:01:37,120
mémoire qui GetString utilise pour stocker
la deuxième chaîne va

31
00:01:37,120 --> 00:01:38,760
d'être ici dans la RAM.

32
00:01:38,760 --> 00:01:42,380
Et bien sûr, puis, ces deux morceaux de
mémoire ont des adresses différentes pour

33
00:01:42,380 --> 00:01:44,220
leurs premiers caractères.

34
00:01:44,220 --> 00:01:46,120
>> Il en est de s égal égal à t?

35
00:01:46,120 --> 00:01:46,885
Eh bien, non.

36
00:01:46,885 --> 00:01:50,510
Si s et t pointent vers différents
segments de mémoire, car ils seraient par

37
00:01:50,510 --> 00:01:54,140
réclamer à deux reprises GetString, ils ne sont pas,
en effet, va être le même.

38
00:01:54,140 --> 00:01:57,700
Il semble donc que ce soit le cas pour que
comparer deux chaînes dans la intuitif

39
00:01:57,700 --> 00:02:01,050
manière que nous attendons, caractère pour
caractère, nous devons une autre technique

40
00:02:01,050 --> 00:02:02,300
tout à fait.

41
00:02:02,300 --> 00:02:03,902