1
00:00:00,000 --> 00:00:03,250
>> SPEAKER 1: La oss nå skrive et program
de virkelig sammenligner to strenger

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

3
00:00:04,245 --> 00:00:06,830
La oss bruke sammenligne 0 som
vårt utgangspunkt.

4
00:00:06,830 --> 00:00:11,550
Men la oss først skrelle tilbake på laget som
er strengen type og skrive det

5
00:00:11,550 --> 00:00:14,120
for hva det virkelig er, som
er en røye stjerne.

6
00:00:14,120 --> 00:00:17,740
Det er adressen til en karakter,
spesielt det første tegn i en

7
00:00:17,740 --> 00:00:21,010
sekvens av tegn som vi hadde mer
vanligvis kjent som en streng.

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

9
00:00:21,880 --> 00:00:25,660
La oss omskrive at strengen erklæring
som røye stjerne.

10
00:00:25,660 --> 00:00:28,690
Og nå må vi ikke lenger
sammenligne s mot t, lest

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

12
00:00:30,150 --> 00:00:33,180
Vi ønsker å virkelig sammenligne
to strenger selv.

13
00:00:33,180 --> 00:00:37,520
For å gjøre dette, kan vi bruke en funksjon
erklærte i string.h.

14
00:00:37,520 --> 00:00:40,920
Så jeg vil legge til at omfatte
på toppen av filen min.

15
00:00:40,920 --> 00:00:43,130
>> Og så kommer jeg til å skifte
denne linjen her.

16
00:00:43,130 --> 00:00:47,920
Snarere enn å sammenligne s mot t, jeg er
kommer til å kalle en funksjon oppsikt komp,

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

18
00:00:52,290 --> 00:00:56,480
Vi vil utsette deretter til streng i forhold til
finne ut om s og t er faktisk lik

19
00:00:56,480 --> 00:00:59,870
og la den finne ut hvordan å sammenligne
dem tegn for tegn.

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

21
00:01:02,410 --> 00:01:06,920
kommer til å returnere 0 dersom de to strenger
pekt på av s og t er like.

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

23
00:01:09,490 --> 00:01:13,740
alfabetisk eller et positivt tall hvis
s skulle komme etter t alfabetisk.

24
00:01:13,740 --> 00:01:16,090
>> Men for nå, vi bare bryr seg
om likestilling.

25
00:01:16,090 --> 00:01:19,270
Så jeg kommer til å bare teste om
returverdien av strengen sammenligne,

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

27
00:01:21,450 --> 00:01:24,940
Og hvis så, kommer jeg til å hevde at
de to strenger er de samme.

28
00:01:24,940 --> 00:01:26,820
>> Men jeg kommer til å gjøre en
annen endring i tillegg.

29
00:01:26,820 --> 00:01:30,410
Det viser seg at få streng, per sin
dokumentasjon, kan noen ganger gå tilbake

30
00:01:30,410 --> 00:01:34,320
null, en sentinel verdi som, ifølge
å få strenger dokumentasjon, hjelp

31
00:01:34,320 --> 00:01:35,450
noe dårlig skjedde.

32
00:01:35,450 --> 00:01:38,830
For eksempel, vi kjørte ut av minnet eller
brukeren liksom ikke samarbeide.

33
00:01:38,830 --> 00:01:41,080
>> String sammenligne, i mellomtiden,
er lite skjøre.

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

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

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

37
00:01:47,970 --> 00:01:52,210
Så for å unngå at potensialet helt,
Jeg først kommer til å vikle denne bruken av

38
00:01:52,210 --> 00:01:56,350
string sammenligne ved å rykke inn hele denne
blokk med kode og først bare gjør

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

40
00:02:03,140 --> 00:02:08,280
>> Innpakning at hvis annet konstruere at jeg
skrev tidligere med klammeparentes som

41
00:02:08,280 --> 00:02:12,270
vel, slik at denne gangen jeg bare berøre
s og t hvis jeg er sikker på at

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

43
00:02:13,450 --> 00:02:17,220
La oss nå lagre, sammenstille, og
å kjøre dette programmet.

44
00:02:17,220 --> 00:02:22,240
>> Gjør sammenligne en prikk slash sammenligne en.

45
00:02:22,240 --> 00:02:23,950
Jeg vil si hei igjen.

46
00:02:23,950 --> 00:02:25,890
Etterfulgt av hello ennå igjen.

47
00:02:25,890 --> 00:02:28,110
Og denne gangen, jeg faktisk
skriver det samme.

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