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

2
00:00:00,410 --> 00:00:03,130
>> DAVID J. MALAN: Então, verifica-se que
copiar uma string não é tão

3
00:00:03,130 --> 00:00:05,750
simples quanto copiar um primitivo,
como um int ou um float.

4
00:00:05,750 --> 00:00:09,190
Afinal, debaixo do capô uma string
é um caracteres de seqüência.

5
00:00:09,190 --> 00:00:13,130
Então, copiando uma string, portanto, tem a
envolver copiar toda essa seqüência de

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

7
00:00:14,240 --> 00:00:17,470
>> Vamos voltar nossa atenção para que
última implementação e arrancar esta

8
00:00:17,470 --> 00:00:21,470
linha, corda t é igual a s, o que
claramente não era suficiente.

9
00:00:21,470 --> 00:00:24,440
Vamos substituí-lo por uma linha que
parece, ao contrário, como esta.

10
00:00:24,440 --> 00:00:34,020
Cordas t recebe malloc de comprimento da corda de
s e 1 vezes o tamanho de um caracter.

11
00:00:34,020 --> 00:00:36,320
>> Agora há citação um pouco vai
em nessa linha de código.

12
00:00:36,320 --> 00:00:39,330
Primeiro, malloc, abreviação de memória
atribuição, e o

13
00:00:39,330 --> 00:00:40,700
função faz exatamente isso.

14
00:00:40,700 --> 00:00:44,740
Dado um número inteiro, ele retorna a você o
endereço de um bloco de memória de

15
00:00:44,740 --> 00:00:45,960
que muitos bytes.

16
00:00:45,960 --> 00:00:50,090
Enquanto isso, o comprimento da corda de s mais 1
pretende indicar que queremos como

17
00:00:50,090 --> 00:00:54,690
muitos bytes como s já ocupa,
incluindo o seu terminador nulo, o

18
00:00:54,690 --> 00:00:57,050
barra invertida 0 no final de uma string.

19
00:00:57,050 --> 00:01:00,170
>> Enquanto isso, eu não me lembro, necessariamente,
quão grande é um char é que, mesmo

20
00:01:00,170 --> 00:01:04,340
embora na maioria dos sistemas é simplesmente uma
byte, então eu vou chamar tamanho do char para

21
00:01:04,340 --> 00:01:08,210
descobrir dinamicamente como grande
um caráter individual é.

22
00:01:08,210 --> 00:01:12,550
Uma vez multiplicados juntos, eu voltar a
número total de bytes que eu preciso.

23
00:01:12,550 --> 00:01:14,680
>> Mas o que se malloc não
devolver a memória que precisamos?

24
00:01:14,680 --> 00:01:16,730
É melhor eu verificar para que os seguintes.

25
00:01:16,730 --> 00:01:23,330
Se t é igual a null, então eu vou primeiro
para s livres, a memória retornado por get

26
00:01:23,330 --> 00:01:27,120
string, e então eu vou
retornar 1, para significar erro.

27
00:01:27,120 --> 00:01:30,360
>> Mas, se está tudo bem, eu vou continuar
usar um loop de quatro e iterar

28
00:01:30,360 --> 00:01:31,110
como se segue.

29
00:01:31,110 --> 00:01:36,000
Para int i obter 0, n é igual
o comprimento da corda de s.

30
00:01:36,000 --> 00:01:40,350
Eu vou fazer isso, desde que i é
inferior ou igual a n, de modo que eu

31
00:01:40,350 --> 00:01:44,460
iteração através e incluindo a
caractere de terminação nula em s.

32
00:01:44,460 --> 00:01:47,450
>> E em cada iteração, estou
indo para incrementar i.

33
00:01:47,450 --> 00:01:52,496
Enquanto isso, dentro desse loop, copiar
s do i-th em caráter de t i-th

34
00:01:52,496 --> 00:01:59,310
localização, basta fazer t
suporte i recebe suporte s i.

41
00:01:59,320 --> 00:02:02,750
>> Vamos agora salvar, compilar e
executar este novo programa.

42
00:02:02,750 --> 00:02:06,690
Fazer cópia de cópia 1 ponto barra 1.

43
00:02:06,690 --> 00:02:09,460
E eu vou dizer algo como
Olá em todas as letras minúsculas.

44
00:02:09,460 --> 00:02:12,280
E, felizmente, desta vez a minha
original permanece inalterado.

45
00:02:12,280 --> 00:02:13,660
Olá em todas as letras minúsculas.

46
00:02:13,660 --> 00:02:15,540
Mas a cópia é, de fato, capitalizada.

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