1
00:00:00,000 --> 00:00:03,250
>> SPEAKER 1: Lad os nu skrive et program
de virkelig sammenligner to strenge

2
00:00:03,250 --> 00:00:04,245
tegn for tegn.

3
00:00:04,245 --> 00:00:06,830
Lad os bruge sammenligne 0.
vores udgangspunkt.

4
00:00:06,830 --> 00:00:11,550
Men lad os først skræl tilbage det lag, der
er den streng type og omskrive det

5
00:00:11,550 --> 00:00:14,120
for, hvad det virkelig er, som
er en char stjerne.

6
00:00:14,120 --> 00:00:17,740
Det er adressen på en karakter,
specifikt første tegn i en

7
00:00:17,740 --> 00:00:21,010
sekvens af tegn, som vi havde mere
generelt kender som en streng.

8
00:00:21,010 --> 00:00:21,880
>> Samme for t.

9
00:00:21,880 --> 00:00:25,660
Lad os omskrive denne streng erklæring
som char stjerne.

10
00:00:25,660 --> 00:00:28,690
Og nu er vi nødt til ikke længere
sammenligne s mod t, lest

11
00:00:28,690 --> 00:00:30,150
vi sammenligner to adresser.

12
00:00:30,150 --> 00:00:33,180
Vi vil virkelig sammenligne
to strenge selv.

13
00:00:33,180 --> 00:00:37,520
For at gøre dette, kan vi bruge en funktion
erklæret i string.h.

14
00:00:37,520 --> 00:00:40,920
Så jeg vil tilføje, at omfatte
på toppen af ​​min fil.

15
00:00:40,920 --> 00:00:43,130
>> Og så har jeg tænkt mig at ændre
denne linje her.

16
00:00:43,130 --> 00:00:47,920
Snarere end at sammenligne s mod t, er jeg
kommer til at kalde en funktion opsigt comp,

17
00:00:47,920 --> 00:00:52,290
for streng sammenligne, og videregive
i som argumenter s og t.

18
00:00:52,290 --> 00:00:56,480
Vi vil udskyde derefter til snor sammenligne med
regne ud, hvis s og t er faktisk lige

19
00:00:56,480 --> 00:00:59,870
og lad det regne ud, hvordan at sammenligne
dem tegn for tegn.

20
00:00:59,870 --> 00:01:02,410
>> Nu, i henhold til dokumentation
for streng sammenligne, det er faktisk

21
00:01:02,410 --> 00:01:06,920
vil returnere 0, hvis de to strenge
pegede på af s og t er de samme.

22
00:01:06,920 --> 00:01:09,490
Det kommer til at returnere et negativt tal
hvis s bør komme før t

23
00:01:09,490 --> 00:01:13,740
alfabetisk eller et positivt tal, hvis
s bør komme efter t alfabetisk.

24
00:01:13,740 --> 00:01:16,090
>> Men for nu, vi kun bekymrer
om ligestilling.

25
00:01:16,090 --> 00:01:19,270
Så jeg har tænkt mig at blot at teste om
returværdien af ​​strengen sammenligne,

26
00:01:19,270 --> 00:01:21,450
passerer s og t, er lig 0.

27
00:01:21,450 --> 00:01:24,940
Og hvis ja, vil jeg hævde, at
De to strenge er de samme.

28
00:01:24,940 --> 00:01:26,820
>> Men jeg har tænkt mig at gøre en
andre ændringer så godt.

29
00:01:26,820 --> 00:01:30,410
Det viser sig, get streng, i dens
dokumentation kan undertiden tilbage

30
00:01:30,410 --> 00:01:34,320
null, en sentinel værdi, der ifølge
at få strengene dokumentation midler

31
00:01:34,320 --> 00:01:35,450
noget slemt skete.

32
00:01:35,450 --> 00:01:38,830
For eksempel, vi løb tør for hukommelse eller
brugeren eller anden måde ikke samarbejdede.

33
00:01:38,830 --> 00:01:41,080
>> String sammenligne, i mellemtiden,
er lidt skrøbelig.

34
00:01:41,080 --> 00:01:44,730
Hvis du passerer det null for enten dens
første eller det andet argument, dårlig

35
00:01:44,730 --> 00:01:45,650
ting kan ske.

36
00:01:45,650 --> 00:01:47,970
Dårlige ting normalt involverer
segmentering fejl.

37
00:01:47,970 --> 00:01:52,210
Så for at undgå dette potentiale helt,
Jeg først kommer til at ombryde denne brug af

38
00:01:52,210 --> 00:01:56,350
snor sammenligne ved at indrykke denne hele
blok af kode, og først kun gør

39
00:01:56,350 --> 00:02:03,140
at hvis s er ikke lig med nul
og t er ikke lig med nul.

40
00:02:03,140 --> 00:02:08,280
>> Indpakning, at hvis ellers konstruere, at jeg
skrevet tidligere med krøllede parenteser som

41
00:02:08,280 --> 00:02:12,270
godt, så denne gang jeg kun berøre
s og t, hvis jeg er sikker på, at

42
00:02:12,270 --> 00:02:13,450
de er ikke nul.

43
00:02:13,450 --> 00:02:17,220
Lad os nu gemme, kompilere, og
returnerer til dette program.

44
00:02:17,220 --> 00:02:22,240
>> Gør sammenligne 1 dot skråstreg Sammenlign 1.

45
00:02:22,240 --> 00:02:23,950
Jeg vil sige hej igen.

46
00:02:23,950 --> 00:02:25,890
Efterfulgt af hej endnu en gang.

47
00:02:25,890 --> 00:02:28,110
Og denne gang, jeg virkelig
skrive det samme.

48
00:02:28,110 --> 00:02:30,255