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

2
00:00:00,520 --> 00:00:03,530
>> Speak: Låt oss skriva ett program som
uppmanar användaren att två strängar och

3
00:00:03,530 --> 00:00:07,170
sedan rapporterar om dessa strängar
är samma eller inte samma.

4
00:00:07,170 --> 00:00:10,290
Jag har redan börjat oss här av
ringer printf två gånger och ringer

5
00:00:10,290 --> 00:00:14,520
GetString två gånger, lagra retur
värden i s-och t, ​​respektive.

6
00:00:14,520 --> 00:00:17,960
>> Nu, mina instinkter en jämförelse
strängar skulle vara att använda det välbekanta

7
00:00:17,960 --> 00:00:19,160
jämlikhet operatören -

8
00:00:19,160 --> 00:00:22,070
Om s är lika med lika t.

9
00:00:22,070 --> 00:00:28,120
Då kommer jag att gå vidare och skriva ut
ut "Du skrev samma sak!

10
00:00:28,120 --> 00:00:35,190
Annars, om det inte är sant, jag är helt enkelt
kommer att skriva printf ("Du skrev

11
00:00:35,190 --> 00:00:37,880
olika saker!

12
00:00:37,880 --> 00:00:38,850
>> Ganska okomplicerad -

13
00:00:38,850 --> 00:00:41,820
Jag är helt enkelt att jämföra er mot
t, och om de är lika,

14
00:00:41,820 --> 00:00:43,250
skriva ut så mycket.

15
00:00:43,250 --> 00:00:45,450
Låt oss kompilera och köra programmet.

16
00:00:45,450 --> 00:00:51,950
Gör jämför 0. / Jämföra
0, säga något, hej,

17
00:00:51,950 --> 00:00:54,200
säga något, hej.

18
00:00:54,200 --> 00:00:56,870
>> Tyvärr tror det program jag har
skrivit olika saker, även om jag

19
00:00:56,870 --> 00:00:59,530
tydligt skrivit "hej" med
samma sätt båda gånger.

20
00:00:59,530 --> 00:01:00,850
Nu, varför skulle det vara?

21
00:01:00,850 --> 00:01:03,750
>> Tja, visar det sig att allt detta
tid, har strängar varit lite mer

22
00:01:03,750 --> 00:01:06,780
komplex än en sekvens av tecken
under huven.

23
00:01:06,780 --> 00:01:11,450
I verkligheten är en sträng en pekare eller en
adress, specifikt adressen

24
00:01:11,450 --> 00:01:14,640
för det första tecknet i det
sekvens av tecken.

25
00:01:14,640 --> 00:01:18,640
>> Och så när vi jämför s mot t
med likhetslikhetstecken, vi är

26
00:01:18,640 --> 00:01:23,200
faktiskt frågar, är denna adress
lika lika med denna adress?

27
00:01:23,200 --> 00:01:26,850
Och det kommer inte att vara fallet om
användaren har matat in i två olika

28
00:01:26,850 --> 00:01:30,370
strängar och vi har kallat GetString två gånger
för att få dem, eftersom minnet

29
00:01:30,370 --> 00:01:34,480
att GetString använder för att lagra den första
sträng kan vara här i RAM, men det

30
00:01:34,480 --> 00:01:37,120
minne som GetString använder för att lagra
den andra strängen kommer

31
00:01:37,120 --> 00:01:38,760
att vara här i RAM.

32
00:01:38,760 --> 00:01:42,380
Och naturligtvis då, dessa två bitar av
minnet har olika adresser för

33
00:01:42,380 --> 00:01:44,220
deras allra första tecknen.

34
00:01:44,220 --> 00:01:46,120
>> Så är s lika lika till t?

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

36
00:01:46,885 --> 00:01:50,510
Om s och t är riktade till olika
bitar av minnet, eftersom de skulle vara med

37
00:01:50,510 --> 00:01:54,140
ringer GetString två gånger, är de inte,
i själva verket kommer att vara densamma.

38
00:01:54,140 --> 00:01:57,700
Så det verkar vara så att till
jämföra två strängar i den intuitiva

39
00:01:57,700 --> 00:02:01,050
sätt som vi förväntar oss, tecken för
karaktär, behöver vi en annan teknik

40
00:02:01,050 --> 00:02:02,300
helt och hållet.

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