1
00:00:00,000 --> 00:00:00,410

2
00:00:00,410 --> 00:00:03,130
>> DAVID J. MALAN: Så det viser seg at
kopierer en string er ikke på langt nær så

3
00:00:03,130 --> 00:00:05,750
enkelt som å kopiere en primitiv,
som en int eller en flåte.

4
00:00:05,750 --> 00:00:09,190
Tross alt, under panseret en streng
er en sekvens tegn.

5
00:00:09,190 --> 00:00:13,130
Så kopierer en streng, derfor må
bære å kopiere at hele sekvensen av

6
00:00:13,130 --> 00:00:14,240
tegn.

7
00:00:14,240 --> 00:00:17,470
>> La oss vende oppmerksomheten tilbake til det
siste implementering og rive ut dette

8
00:00:17,470 --> 00:00:21,470
linje, string t er lik s, som
åpenbart ikke var tilstrekkelig.

9
00:00:21,470 --> 00:00:24,440
La oss erstatte den med en linje som
ser, i stedet, som dette.

10
00:00:24,440 --> 00:00:34,020
String t får malloc av hyssinglengde på
s pluss 1 ganger størrelsen av en røye.

11
00:00:34,020 --> 00:00:36,320
>> Nå er det sitatet litt skjer
på i denne linjen med kode.

12
00:00:36,320 --> 00:00:39,330
Først malloc, kort for minne
allokering, og

13
00:00:39,330 --> 00:00:40,700
Funksjonen gjør nettopp det.

14
00:00:40,700 --> 00:00:44,740
Gitt et heltall, returnerer den til deg
adressen til en del av minnet

15
00:00:44,740 --> 00:00:45,960
at mange bytes.

16
00:00:45,960 --> 00:00:50,090
I mellomtiden, den strenglengde s pluss en
er ment for å vise at vi vil ha som

17
00:00:50,090 --> 00:00:54,690
mange bytes som er allerede okkuperer,
inkludert sin avsluttende null, den

18
00:00:54,690 --> 00:00:57,050
backslash 0 på slutten av en streng.

19
00:00:57,050 --> 00:01:00,170
>> I mellomtiden, vet jeg ikke nødvendigvis huske
hvor stor røye er, selv

20
00:01:00,170 --> 00:01:04,340
men på de fleste systemer er det rett og slett en
byte, så jeg skal ringe størrelse på røye til

21
00:01:04,340 --> 00:01:08,210
finne ut dynamisk hvor stort
en individuell karakter er.

22
00:01:08,210 --> 00:01:12,550
Når multiplisert sammen, jeg får tilbake
totalt antall byte som jeg trenger.

23
00:01:12,550 --> 00:01:14,680
>> Men hva hvis malloc ikke klarer å
returnere minne vi trenger?

24
00:01:14,680 --> 00:01:16,730
Jeg ville sjekke best for det som følger.

25
00:01:16,730 --> 00:01:23,330
Hvis t er lik null, så jeg først kommer
til gratis s, minnet returneres av get

26
00:01:23,330 --> 00:01:27,120
streng, og da kommer jeg til å
tilbake 1, for å betegne feil.

27
00:01:27,120 --> 00:01:30,360
>> Men hvis alt er bra, kommer jeg til å fortsette
å benytte en fire-løkke og iterere

28
00:01:30,360 --> 00:01:31,110
som følger.

29
00:01:31,110 --> 00:01:36,000
For int jeg får 0, n er lik
strengen lengden på s.

30
00:01:36,000 --> 00:01:40,350
Jeg kommer til å gjøre dette så lenge jeg er
mindre enn eller lik n, så at jeg

31
00:01:40,350 --> 00:01:44,460
iterere opp gjennom og herunder
null avslutnings karakter i s.

32
00:01:44,460 --> 00:01:47,450
>> Og på hver iterasjon, er jeg
kommer til å øke i.

33
00:01:47,450 --> 00:01:52,496
I mellomtiden, på innsiden av denne sløyfen, kopiere
s i-ende tegn til t i-th

34
00:01:52,496 --> 00:01:59,310
plassering, er det nok å gjøre t
brakett jeg får s brakett jeg.

41
00:01:59,320 --> 00:02:02,750
>> La oss nå lagre, sammenstille, og
kjøre dette nye programmet.

42
00:02:02,750 --> 00:02:06,690
Gjør kopien en prikk slash kopi ett.

43
00:02:06,690 --> 00:02:09,460
Og jeg vil si noe sånt
hallo i små bokstaver.

44
00:02:09,460 --> 00:02:12,280
Og heldigvis, denne gangen min
opprinnelige forblir uendret.

45
00:02:12,280 --> 00:02:13,660
hallo i små bokstaver.

46
00:02:13,660 --> 00:02:15,540
Men kopien er, faktisk, kapitalisert.

47
00:02:37,120 --> 00:02:38,963