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

2
00:00:00,520 --> 00:00:03,530
>> SPEAKER: Laten we een programma schrijven dat
vraagt ​​de gebruiker om twee strings en

3
00:00:03,530 --> 00:00:07,170
Vervolgens meldt of die strings
gelijk of niet gelijk.

4
00:00:07,170 --> 00:00:10,290
Ik heb ons al begonnen hier uit door
bellen printf tweemaal en bellen

5
00:00:10,290 --> 00:00:14,520
Tweemaal getString, het opslaan van de terugkeer
waarden van s en t respectievelijk.

6
00:00:14,520 --> 00:00:17,960
>> Nu, mijn instinct om te vergelijken deze twee
snaren zou de vertrouwde gebruiken

7
00:00:17,960 --> 00:00:19,160
gelijkheidsoperator -

8
00:00:19,160 --> 00:00:22,070
Als s gelijk gelijk t.

9
00:00:22,070 --> 00:00:28,120
Dan ga ik verder en afdrukken gaan
uit "Je hebt getypt hetzelfde!

10
00:00:28,120 --> 00:00:35,190
Anders, als dat is niet waar, ik ben gewoon
gaat printf typen ("Je hebt getypt

11
00:00:35,190 --> 00:00:37,880
verschillende dingen!

12
00:00:37,880 --> 00:00:38,850
>> Vrij eenvoudig -

13
00:00:38,850 --> 00:00:41,820
Ik ben gewoon te vergelijken en tegen
t, en als ze gelijk zijn,

14
00:00:41,820 --> 00:00:43,250
printen zo veel.

15
00:00:43,250 --> 00:00:45,450
Laten we dit programma te compileren en uit te voeren.

16
00:00:45,450 --> 00:00:51,950
Maak vergelijken 0. / Vergelijken
0, zeg iets, hello,

17
00:00:51,950 --> 00:00:54,200
iets zeggen, hallo.

18
00:00:54,200 --> 00:00:56,870
>> Helaas, het programma denkt dat ik heb
getypt verschillende dingen, hoewel ik

19
00:00:56,870 --> 00:00:59,530
duidelijk getypt "hallo" de
dezelfde manier beide keren.

20
00:00:59,530 --> 00:01:00,850
Nu, waarom zou dat zijn?

21
00:01:00,850 --> 00:01:03,750
>> Nou, het blijkt dat dit alles
tijd, hebben snaren een beetje meer geweest

22
00:01:03,750 --> 00:01:06,780
complexer dan een reeks tekens
onder de motorkap.

23
00:01:06,780 --> 00:01:11,450
In werkelijkheid, een string is een pointer of een
adres, specifiek dit adres

24
00:01:11,450 --> 00:01:14,640
van het eerste teken in dat
reeks tekens.

25
00:01:14,640 --> 00:01:18,640
>> En dus, als we vergelijken s tegen t
met het gelijke gelijk-teken, we zijn

26
00:01:18,640 --> 00:01:23,200
eigenlijk vraagt, is dit adres
gelijk gelijk naar dit adres?

27
00:01:23,200 --> 00:01:26,850
En dat zal niet het geval zijn als
de gebruiker in twee verschillende heeft getypt

28
00:01:26,850 --> 00:01:30,370
strings en we hebben GetString twee keer gebeld
om ze te krijgen, omdat het geheugen

29
00:01:30,370 --> 00:01:34,480
dat GetString gebruikt voor het opslaan van de eerste
koord zou hier in het RAM, maar de

30
00:01:34,480 --> 00:01:37,120
geheugen dat GetString gebruikt om op te slaan
de tweede snaar gaat

31
00:01:37,120 --> 00:01:38,760
hier in het RAM zijn.

32
00:01:38,760 --> 00:01:42,380
En natuurlijk dan die twee stukjes
geheugen verschillende adressen

33
00:01:42,380 --> 00:01:44,220
hun eerste karakters.

34
00:01:44,220 --> 00:01:46,120
>> Dus is s gelijk gelijk naar t?

35
00:01:46,120 --> 00:01:46,885
Nou, nee.

36
00:01:46,885 --> 00:01:50,510
Als s en t die naar verschillende
delen van het geheugen, als ze zouden zijn door

37
00:01:50,510 --> 00:01:54,140
roepen GetString twee keer, ze zijn niet,
in feite zal hetzelfde zijn.

38
00:01:54,140 --> 00:01:57,700
Dus lijkt het het geval dat voor
twee strings te vergelijken in de intuïtieve

39
00:01:57,700 --> 00:02:01,050
manier die we verwachten, karakter voor
karakter, andere techniek hebben we

40
00:02:01,050 --> 00:02:02,300
helemaal.

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