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

2
00:00:00,520 --> 00:00:03,530
>> SPEAKER: La oss skrive et program som
ber brukeren om to strenger og

3
00:00:03,530 --> 00:00:07,170
deretter rapporterer om de strenger
er de samme eller ikke de samme.

4
00:00:07,170 --> 00:00:10,290
Jeg har allerede startet oss her ved
ringer printf to ganger og ringer

5
00:00:10,290 --> 00:00:14,520
GetString to ganger, lagring retur
verdier i s og t, henholdsvis.

6
00:00:14,520 --> 00:00:17,960
>> Nå, til mine instinkter sammenligne disse to
strengene ville være å bruke det kjente

7
00:00:17,960 --> 00:00:19,160
likestilling operatør -

8
00:00:19,160 --> 00:00:22,070
Hvis s er lik lik t.

9
00:00:22,070 --> 00:00:28,120
Så jeg kommer til å gå videre og print
out "Du skrev det samme!

10
00:00:28,120 --> 00:00:35,190
Else, hvis det ikke er sant, jeg er rett og slett
kommer til å skrive printf ("Du skrev inn

11
00:00:35,190 --> 00:00:37,880
forskjellige ting!

12
00:00:37,880 --> 00:00:38,850
>> Ganske grei -

13
00:00:38,850 --> 00:00:41,820
Jeg er ganske enkelt å sammenligne s mot
t, og hvis de er like,

14
00:00:41,820 --> 00:00:43,250
skrive ut så mye.

15
00:00:43,250 --> 00:00:45,450
La oss kompilere og kjøre dette programmet.

16
00:00:45,450 --> 00:00:51,950
Gjør sammenligne 0. / Sammenligne
0, si noe, hallo,

17
00:00:51,950 --> 00:00:54,200
si noe, hallo.

18
00:00:54,200 --> 00:00:56,870
>> Dessverre, mener det programmet jeg har
skrevet forskjellige ting, selv om jeg

19
00:00:56,870 --> 00:00:59,530
tydelig skrevet "hallo" den
samme måte begge ganger.

20
00:00:59,530 --> 00:01:00,850
Nå, hvorfor kan det være?

21
00:01:00,850 --> 00:01:03,750
>> Vel, det viser seg at alt dette
tid, har strenger vært litt mer

22
00:01:03,750 --> 00:01:06,780
komplisert enn en sekvens av tegn
under panseret.

23
00:01:06,780 --> 00:01:11,450
I virkeligheten er en streng en peker eller en
adresse, nemlig den adresse

24
00:01:11,450 --> 00:01:14,640
for det første tegnet i den
sekvens av tegn.

25
00:01:14,640 --> 00:01:18,640
>> Og så når vi sammenligner s mot t
med lik likhetstegnet, er vi

26
00:01:18,640 --> 00:01:23,200
faktisk spør, er denne adressen
lik lik denne adressen?

27
00:01:23,200 --> 00:01:26,850
Og som ikke kommer til å være tilfelle hvis
brukeren har skrevet inn i to forskjellige

28
00:01:26,850 --> 00:01:30,370
strenger og vi har kalt GetString to ganger
for å få dem, fordi hukommelsen

29
00:01:30,370 --> 00:01:34,480
at GetString bruker til å lagre den første
string kan være her i RAM, men den

30
00:01:34,480 --> 00:01:37,120
minne som GetString bruker til å lagre
den andre strengen går

31
00:01:37,120 --> 00:01:38,760
å være her i RAM.

32
00:01:38,760 --> 00:01:42,380
Og selvfølgelig, da, de to biter av
minne har ulike adresser for

33
00:01:42,380 --> 00:01:44,220
sin aller første tegn.

34
00:01:44,220 --> 00:01:46,120
>> Så er s lik lik t?

35
00:01:46,120 --> 00:01:46,885
Vel, nei.

36
00:01:46,885 --> 00:01:50,510
Hvis s og t peker til forskjellige
biter av minne, som de ville være med

37
00:01:50,510 --> 00:01:54,140
ringer GetString to ganger, er de ikke,
i virkeligheten kommer til å være den samme.

38
00:01:54,140 --> 00:01:57,700
Derfor synes det å være tilfelle at for å
sammenligne to strenger i den intuitive

39
00:01:57,700 --> 00:02:01,050
måte som vi forventer, tegnet for
karakter, trenger vi en annen teknikk

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

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