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

2
00:00:00,520 --> 00:00:03,530
>> SPEAKER: Lad os skrive et program,
beder brugeren om to strygere og

3
00:00:03,530 --> 00:00:07,170
derefter rapporterer om disse strings
er de samme eller ikke det samme.

4
00:00:07,170 --> 00:00:10,290
Jeg har allerede startede os her ved
kalder printf to gange og ringer

5
00:00:10,290 --> 00:00:14,520
GetString to gange, lagring tilbagevenden
værdier i s og t, hhv.

6
00:00:14,520 --> 00:00:17,960
>> Nu, at mine instinkter sammenligne disse to
strenge ville være at bruge den velkendte

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

8
00:00:19,160 --> 00:00:22,070
hvis s er lig lig t.

9
00:00:22,070 --> 00:00:28,120
Så jeg har tænkt mig at gå videre og udskrive
out "Du har skrevet det samme!

10
00:00:28,120 --> 00:00:35,190
Else, hvis det ikke er sandt, jeg er simpelthen
kommer til at skrive printf ("Du har indtastet

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

12
00:00:37,880 --> 00:00:38,850
>> Forholdsvis ligetil -

13
00:00:38,850 --> 00:00:41,820
Jeg blot at sammenligne s mod
t, og hvis de er lige,

14
00:00:41,820 --> 00:00:43,250
udskrivning ud så meget.

15
00:00:43,250 --> 00:00:45,450
Lad os kompilere og køre dette program.

16
00:00:45,450 --> 00:00:51,950
Foretag sammenligne 0. / Sammenligne
0, sige noget, hallo,

17
00:00:51,950 --> 00:00:54,200
sige noget, hej.

18
00:00:54,200 --> 00:00:56,870
>> Desværre programmet tror jeg har
indtastet forskellige ting, selvom jeg

19
00:00:56,870 --> 00:00:59,530
tydeligt skrevet "hello" den
samme måde begge gange.

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

21
00:01:00,850 --> 00:01:03,750
>> Tja, det viser sig, at alt dette
tid har strenge været lidt mere

22
00:01:03,750 --> 00:01:06,780
kompleks end en sekvens af tegn
under hætten.

23
00:01:06,780 --> 00:01:11,450
I virkeligheden er en streng en pegepind eller en
adresse, specifikt adresse

24
00:01:11,450 --> 00:01:14,640
det første tegn på, at
sekvens af tegn.

25
00:01:14,640 --> 00:01:18,640
>> Og så når vi sammenligner s mod t
med lige lighedstegnet, er vi

26
00:01:18,640 --> 00:01:23,200
faktisk beder, er denne adresse
lig lige til denne adresse?

27
00:01:23,200 --> 00:01:26,850
Og det kommer ikke til at være tilfældet, hvis
brugeren har indtastet i to forskellige

28
00:01:26,850 --> 00:01:30,370
strygere og vi har kaldt getString to gange
at få dem, fordi hukommelsen

29
00:01:30,370 --> 00:01:34,480
at getString bruger til at lagre den første
streng kunne være her i RAM, men den

30
00:01:34,480 --> 00:01:37,120
hukommelse, getString bruger til at lagre
den anden streng går

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

32
00:01:38,760 --> 00:01:42,380
Og selvfølgelig, så de to bidder af
hukommelse har forskellige adresser for

33
00:01:42,380 --> 00:01:44,220
deres allerførste tegn.

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

35
00:01:46,120 --> 00:01:46,885
Nå, nej.

36
00:01:46,885 --> 00:01:50,510
Hvis s og t peger på forskellige
bidder af hukommelsen, da de ville være med

37
00:01:50,510 --> 00:01:54,140
ringer getString to gange, de ikke er,
i virkeligheden, vil være den samme.

38
00:01:54,140 --> 00:01:57,700
Så det lader til at være tilfældet, at til
sammenligne to strenge i den intuitive

39
00:01:57,700 --> 00:02:01,050
måde, at vi forventer, karakter for
karakter, har vi brug en anden teknik

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

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