1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [Semana 4, continuação]

2
00:00:02,310 --> 00:00:04,240
[David J. Malan - Harvard University]

3
00:00:04,240 --> 00:00:07,290
[Esta é CS50. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> Este é CS50, e este é o fim da semana 4.

5
00:00:11,290 --> 00:00:14,030
Então, uma notícia boa e uma má notícia.

6
00:00:14,030 --> 00:00:26,240
Não palestra na segunda-feira, não há problema definido na próxima semana. [Alunos aplaudindo]

7
00:00:26,240 --> 00:00:28,680
Você não vai gostar de onde isso vai dar.

8
00:00:28,680 --> 00:00:31,590
Mas nós temos isso em vez próxima quarta-feira,

9
00:00:31,590 --> 00:00:37,740
e há também o currículo por palestra sexta-feira uma próxima sexta-feira, para que possamos permanecer na pista.

10
00:00:37,740 --> 00:00:40,580
Mas tudo vai ser filmado, como de costume, para não se preocupar.

11
00:00:40,580 --> 00:00:44,100
>> E com relação a 0 Quiz o que vamos fazer para o final da semana

12
00:00:44,100 --> 00:00:47,140
é postar em cs50.net do curso homepage uma explicação

13
00:00:47,140 --> 00:00:50,160
de que tipo de expectativas que você deve ter quando se trata do primeiro questionário.

14
00:00:50,160 --> 00:00:55,100
Em geral, será de múltipla escolha, verdadeiro ou falso, resposta curta curtas problemas de codificação.

15
00:00:55,100 --> 00:00:57,360
Você não vai ser esperado para implementar o equivalente

16
00:00:57,360 --> 00:01:00,030
de um problema que você veria em um pset, para que você tenha um computador

17
00:01:00,030 --> 00:01:03,240
e um depurador e similares, mas não haverá pequenos problemas de codificação.

18
00:01:03,240 --> 00:01:06,900
>> E, de fato, o melhor guia para ter uma noção do que são como CS50 quizzes

19
00:01:06,900 --> 00:01:09,180
é ir para cs50.net, ir para o link Quizzes,

20
00:01:09,180 --> 00:01:11,920
e você pode ver os últimos anos no valor de questionários.

21
00:01:11,920 --> 00:01:16,600
Basta perceber que o currículo não tem sido sempre o mesmo ao longo dos anos.

22
00:01:16,600 --> 00:01:18,510
Às vezes, acrescentamos nós, às vezes, subtrair,

23
00:01:18,510 --> 00:01:20,670
então se você ver algum tópico em um daqueles velhos quizzes

24
00:01:20,670 --> 00:01:25,380
que você não tem idéia do que está falando, ela quer que tenha sido abordado

25
00:01:25,380 --> 00:01:27,210
ou que não cobri-lo.

26
00:01:27,210 --> 00:01:31,110
Mas, na forma de comentários, este domingo, segunda e terça-feira

27
00:01:31,110 --> 00:01:34,770
bem como um curso de largura sessão de revisão, na noite de domingo -

28
00:01:34,770 --> 00:01:37,500
horário e local a ser anunciado na página inicial do curso -

29
00:01:37,500 --> 00:01:40,120
que todos tenham a oportunidade de rever com os bolsistas do curso de ensino

30
00:01:40,120 --> 00:01:44,830
o material para este ano, tanto na seção e como uma classe cheia,

31
00:01:44,830 --> 00:01:48,400
e os que serão filmados, como de costume também.

32
00:01:48,400 --> 00:01:53,380
>> Tudo bem. Então, sem mais delongas, um comentário sobre aprovação / reprovação e add / drop.

33
00:01:53,380 --> 00:01:57,980
Você pode ter visto as minhas notas na noite passada, e isso é realmente apenas alguns garantia adicional

34
00:01:57,980 --> 00:02:01,250
que, se você está entre aqueles particularmente menos confortável ou em algum lugar entre

35
00:02:01,250 --> 00:02:04,870
e você está se sentindo um pouco acima da sua cabeça,

36
00:02:04,870 --> 00:02:08,430
perceber que é realmente muito normal, e não há uma estrutura de apoio ampla no lugar,

37
00:02:08,430 --> 00:02:13,530
um dos quais o horário de expediente tinham a intenção de melhorar ainda mais a minha noite por último e-mail,

38
00:02:13,530 --> 00:02:16,520
e perceber também que uma opção como aprovação / reprovação de uma classe como esta

39
00:02:16,520 --> 00:02:21,540
realmente se entende como um mecanismo para tomar a borda fora de um curso como este,

40
00:02:21,540 --> 00:02:24,200
para que novamente se você está gastando os 10, 15, 20 horas

41
00:02:24,200 --> 00:02:28,160
apenas tentando obter alguma pset para trabalhar e você sabe que é 90-95% do caminho

42
00:02:28,160 --> 00:02:32,100
mas você não pode encontrar algum bug maldito, num aprovação / reprovação modelo que é uma espécie de bem.

43
00:02:32,100 --> 00:02:36,230
>> A idéia é que, com esse mecanismo, você pode ir foco em suas outras Série de Exercícios

44
00:02:36,230 --> 00:02:39,530
ou dormir ou o que é que você quer focar.

45
00:02:39,530 --> 00:02:43,390
Então percebe que você tem até esta terça-feira que vem - tecnicamente na segunda-feira 5,

46
00:02:43,390 --> 00:02:50,840
mas é um feriado, para esta terça-feira que vem - para mudar de aprovação / reprovação para graduados ou vice-versa.

47
00:02:50,840 --> 00:02:54,450
E se você está realmente à beira do precipício e está pensando em deixar cair por completo,

48
00:02:54,450 --> 00:02:56,440
por favor me pegar depois de palestra ou mande-me uma nota.

49
00:02:56,440 --> 00:02:59,990
Adoraríamos pelo menos bate-papo antes de despedir.

50
00:02:59,990 --> 00:03:03,470
Tudo bem. Então começamos a retirar as rodinhas da última vez.

51
00:03:03,470 --> 00:03:06,030
Em particular, nós nos concentramos em seqüência.

52
00:03:06,030 --> 00:03:09,740
String é algo que é declarado na biblioteca CS50,

53
00:03:09,740 --> 00:03:14,340
especificamente no arquivo chamado cs50.h que nós vamos começar a olhar para esta semana ea próxima.

54
00:03:14,340 --> 00:03:17,250
Mas cadeia é realmente apenas uma simplificação de algo

55
00:03:17,250 --> 00:03:20,980
que é um pouco mais arcanely descrito como char *.

56
00:03:20,980 --> 00:03:24,090
Char estamos familiarizados. É apenas um único personagem.

57
00:03:24,090 --> 00:03:28,010
Mas * como de segunda-feira denotado o que? >> [Aluno] Um ponteiro.

58
00:03:28,010 --> 00:03:31,290
Um ponteiro. E o que é um ponteiro? >> [Aluno] Um endereço.

59
00:03:31,290 --> 00:03:33,420
>> É como um endereço, um local na memória.

60
00:03:33,420 --> 00:03:35,910
O que é um endereço ou local ou de memória?

61
00:03:35,910 --> 00:03:40,290
Mais uma vez, todos nós temos laptops com um show ou 2 gigabytes de memória RAM provavelmente estes dias,

62
00:03:40,290 --> 00:03:44,160
e isso significa que você tem um bilhão ou 2 bilhões de bytes no valor de memória.

63
00:03:44,160 --> 00:03:46,240
E isso realmente não importa o que fisicamente se parece,

64
00:03:46,240 --> 00:03:51,220
mas assumir a fé que você pode numerar todos os bytes individuais que tem seu próprio laptop -

65
00:03:51,220 --> 00:03:54,580
este é o byte 0, este é um byte, este é byte 2 bilhões -

66
00:03:54,580 --> 00:03:56,100
e isso é exatamente o que um computador faz.

67
00:03:56,100 --> 00:04:00,030
Quando você alocar espaço para um único personagem, por exemplo,

68
00:04:00,030 --> 00:04:02,480
que, obviamente, tem de viver em algum lugar na memória do seu computador,

69
00:04:02,480 --> 00:04:05,860
e talvez seja, no número de bytes 12345,

70
00:04:05,860 --> 00:04:08,470
e que está em algum lugar aqui em memória de seu computador.

71
00:04:08,470 --> 00:04:12,630
E o endereço depois de que o caráter é 12345.

72
00:04:12,630 --> 00:04:16,140
>> Agora, na semana 0 por agora, até agora, não temos realmente se importava

73
00:04:16,140 --> 00:04:19,170
onde na memória as coisas são armazenados porque geralmente utilizam símbolos,

74
00:04:19,170 --> 00:04:22,540
variáveis, e matrizes para realmente obter os nossos dados.

75
00:04:22,540 --> 00:04:24,950
Mas a partir de segunda-feira e ainda mais hoje, você agora vai ter

76
00:04:24,950 --> 00:04:27,710
todos os recursos mais expressivos com programas de escrita

77
00:04:27,710 --> 00:04:31,330
para realmente manipular a memória de um computador, contudo, você vê o ajuste,

78
00:04:31,330 --> 00:04:33,720
tanto para fins bons e ruins,

79
00:04:33,720 --> 00:04:39,620
bugs de ser um resultado muito comum neste ponto em aprender essas coisas.

80
00:04:39,620 --> 00:04:42,460
Mas o que isso realmente significa ser um char *?

81
00:04:42,460 --> 00:04:46,140
Vamos em frente de volta para - e nós vamos voltar a Binky como prometido hoje.

82
00:04:46,140 --> 00:04:48,670
Vamos a um exemplo simples aqui.

83
00:04:48,670 --> 00:04:53,060
Deixe-me salve este arquivo como compare.c, e deixe-me conseguir algum código do modelo aqui

84
00:04:53,060 --> 00:05:00,490
para incluir stdio.h, deixe-me dar-me também incluem cs50.h. Eu vou aumentar o zoom até lá.

85
00:05:00,490 --> 00:05:05,850
Deixe-me começar a escrever int main, main (void), e agora eu quero fazer algo como isto:

86
00:05:05,850 --> 00:05:13,520
printf ("Dê-me uma string:") e depois vou usar string s fica GetString

87
00:05:13,520 --> 00:05:16,750
para obter uma string do usuário, então eu vou pedir para o usuário para outra.

88
00:05:16,750 --> 00:05:21,870
("Dê-me outra string:") e eu vou pedir a eles através GetString para conseguir isso.

89
00:05:21,870 --> 00:05:27,020
Eu vou chamá-lo de t t porque vem depois de s e s é um bom nome para uma string se é muito genérica.

90
00:05:27,020 --> 00:05:30,030
Então GetString, e agora eu só quero fazer um teste de sanidade e eu vou dizer

91
00:05:30,030 --> 00:05:39,770
if (s == t), então eu vou apenas dizer que o usuário printf ("Você digitou a mesma coisa \ n");

92
00:05:39,770 --> 00:05:45,520
mais eu vou imprimir algo como ("Você digitou algo diferente! \ n")

93
00:05:45,520 --> 00:05:48,460
ou qualquer que seja a sentença será. Então, alguma coisa assim.

94
00:05:48,460 --> 00:05:52,200
Em seguida, como de costume, eu vou retornar 0 que apenas significa que nada de ruim aconteceu,

95
00:05:52,200 --> 00:05:54,400
e eu estou indo para ir em frente e compilar e executar este programa.

96
00:05:54,400 --> 00:05:56,540
>> Mas na segunda-feira nós rodamos este programa,

97
00:05:56,540 --> 00:06:00,420
e, na verdade, foram informados de que não é OLÁ OLÁ ADEUS e não é um adeus.

98
00:06:00,420 --> 00:06:03,140
O comportamento que vimos foi um pouco mais como este.

99
00:06:03,140 --> 00:06:11,450
Deixe-me ir para o meu diretório de origem, zoom aqui, e vamos faça comparar.

100
00:06:11,450 --> 00:06:14,570
Compilado bem. Deixa-me correr comparar. Dê-me uma string: OLÁ.

101
00:06:14,570 --> 00:06:16,300
Dê-me outra seqüência: OLÁ.

102
00:06:16,300 --> 00:06:18,000
Você digitou algo diferente!

103
00:06:18,000 --> 00:06:22,650
Bem, deixe-me tentar algo mais simples como 50, 50. Você digitou algo diferente!

104
00:06:22,650 --> 00:06:25,740
oi, oi. Então, claramente, algo está acontecendo aqui.

105
00:06:25,740 --> 00:06:28,440
Mas qual era a explicação para por que?

106
00:06:28,440 --> 00:06:33,850
Aparentemente, a linha 12 é completamente disfuncional.

107
00:06:34,300 --> 00:06:39,430
Qual é o problema fundamental aqui? Sim. >> [Aluno] Ele está comparando os endereços.

108
00:06:39,430 --> 00:06:41,850
Sim, exatamente. É realmente comparando os endereços

109
00:06:41,850 --> 00:06:44,580
em que OLÁ OLÁ e são armazenados.

110
00:06:44,580 --> 00:06:48,290
Ele não está comparando as letras OLÁ novo e de novo,

111
00:06:48,290 --> 00:06:52,370
porque o que realmente aconteceu, todo esse tempo que estamos usando GetString -

112
00:06:52,370 --> 00:06:56,130
Este quadro é mais uma vez a memória do nosso computador,

113
00:06:56,130 --> 00:07:00,100
e digamos que eu chamo GetString depois de declarar uma variável s.

114
00:07:00,100 --> 00:07:01,930
O que a minha memória parece?

115
00:07:01,930 --> 00:07:07,070
Vamos dizer que arbitrariamente s parece com isso. É um quadrado.

116
00:07:07,070 --> 00:07:09,040
E praticamente qualquer tempo eu desenhei um pedaço de memória na tela

117
00:07:09,040 --> 00:07:12,860
se é 32 bits eu tenho desenhado quadrados como este, porque realmente no aparelho,

118
00:07:12,860 --> 00:07:17,380
um ponteiro, um endereço, é de 32 bits. É o mesmo que um int.

119
00:07:17,380 --> 00:07:19,420
Isso pode variar de acordo com sistema de computador.

120
00:07:19,420 --> 00:07:24,630
Aqueles de vocês que são vagamente familiarizado com o fato de que o seu Mac ou PC é de 64 bits,

121
00:07:24,630 --> 00:07:28,120
que, na verdade, indica que o computador está usando ponteiros de 64 bits,

122
00:07:28,120 --> 00:07:33,730
64-bits de endereços, e entre os lados positivos de que é seus computadores

123
00:07:33,730 --> 00:07:35,560
RAM pode ter muito mais do que antigamente.

124
00:07:35,560 --> 00:07:39,240
Longa história curta, de volta ao dia em que os computadores usados ​​apenas 32 bits

125
00:07:39,240 --> 00:07:42,740
para representar os endereços, o maior número de bytes que você poderia representar

126
00:07:42,740 --> 00:07:46,280
nesse caso, foi o que se você tiver 32 bits?

127
00:07:46,280 --> 00:07:49,590
Então 4 bilhões, direito, porque 2 a 32 é de 4 bilhões.

128
00:07:49,590 --> 00:07:51,370
Este número foi recorrente no curso.

129
00:07:51,370 --> 00:07:55,240
>> Então, se você só tem 32 bits, o número mais alto que você pode contar para a cerca de 4 bilhões de dólares.

130
00:07:55,240 --> 00:07:58,750
Mas isso era uma limitação fundamental dos computadores, até alguns anos atrás

131
00:07:58,750 --> 00:08:01,180
porque se você só pode contar além de 4 bilhões,

132
00:08:01,180 --> 00:08:05,270
não importa se você comprar 8 gigabytes de memória RAM ou até 5 gigabytes de RAM;

133
00:08:05,270 --> 00:08:07,780
você não pode contar que a alta, por isso era inútil.

134
00:08:07,780 --> 00:08:11,430
Você poderia acessar apenas os primeiros 3 ou 4 gigabytes de memória do seu computador.

135
00:08:11,430 --> 00:08:14,410
Isso é menos de um problema agora, e você pode comprar MacBook Pros e Dells

136
00:08:14,410 --> 00:08:17,680
com 8 gigabytes de memória RAM ou mesmo mais esses dias.

137
00:08:17,680 --> 00:08:24,100
Mas se eu simplesmente alocar neste programa um ponteiro, um ponteiro chamado s,

138
00:08:24,100 --> 00:08:28,370
pode parecer que esta na tela, pois realmente precisamos descascar essa camada.

139
00:08:28,370 --> 00:08:33,520
Eu continuo dizendo cadeia, mas a partir de segunda-feira, string é realmente * char,

140
00:08:33,520 --> 00:08:35,590
o endereço de algum personagem.

141
00:08:35,590 --> 00:08:39,280
Portanto, vamos ter que roda formação fora mesmo que nós vamos continuar usando GetString para agora.

142
00:08:39,280 --> 00:08:42,600
Então eu s declarada, e este é um pedaço de memória, 32 bits.

143
00:08:42,600 --> 00:08:47,370
O que tem aqui na memória por padrão? >> [Resposta do aluno inaudível]

144
00:08:47,370 --> 00:08:50,040
O que é isso? >> [Aluno] Lixo. Lixo. >> Exatamente.

145
00:08:50,040 --> 00:08:54,610
Se o programador não colocar um valor em uma variável, que sabe o que é?

146
00:08:54,610 --> 00:08:57,990
Às vezes você tem sorte e é 0, que é uma espécie de bom valor padrão, limpo,

147
00:08:57,990 --> 00:09:00,310
mas como vimos segunda-feira, às vezes, é um disparate completo,

148
00:09:00,310 --> 00:09:04,130
um número muito grande positivo ou negativo que veio de onde?

149
00:09:05,350 --> 00:09:07,010
Sim. >> [Estudante] A função antes. Sim >>.

150
00:09:07,010 --> 00:09:10,170
>> Muitas vezes a função que foi chamado antes, porque lembre-se,

151
00:09:10,170 --> 00:09:13,920
como você chama funções na memória, eles ocupam mais espaço e mais de baixo para cima,

152
00:09:13,920 --> 00:09:17,040
e, logo que o retorno da função, que a memória fica reutilizado

153
00:09:17,040 --> 00:09:20,890
pelo próximo cara que é chamado, quem está usando o mesma fatia de memória.

154
00:09:20,890 --> 00:09:23,450
E se você tem lixo deixado lá, os valores anteriores,

155
00:09:23,450 --> 00:09:28,190
podemos confundir s como tendo algum valor quando realmente nós não pusemos nada lá.

156
00:09:28,190 --> 00:09:30,960
Portanto, a nossa memória RAM, neste ponto se parece com isso.

157
00:09:30,960 --> 00:09:36,030
Agora, no lado direito da linha 7 estamos chamando GetString,

158
00:09:36,030 --> 00:09:40,150
que estamos fazendo agora por semanas, mas o que é realmente GetString fazendo?

159
00:09:40,150 --> 00:09:43,350
GetString escrito pela equipe do CS50 é um pouco inteligente

160
00:09:43,350 --> 00:09:46,500
em que, assim que o usuário começa a digitar as teclas e hits Enter,

161
00:09:46,500 --> 00:09:50,010
Figuras GetString fora quantas teclas fizeram o sucesso do usuário,

162
00:09:50,010 --> 00:09:53,360
quantos caracteres eu preciso alocar RAM para.

163
00:09:53,360 --> 00:09:55,660
E onde que a RAM vem, quem sabe?

164
00:09:55,660 --> 00:09:58,930
Está em algum lugar do seu computador 2 gigabytes de memória ou outros enfeites.

165
00:09:58,930 --> 00:10:05,200
Mas vamos supor que o computador encontrou espaço para a palavra OLÁ aqui.

166
00:10:05,200 --> 00:10:08,710
A palavra que eu digitei foi H-E-L-L-O.

167
00:10:08,710 --> 00:10:13,510
E se tirar isso como uma sequência de caracteres, podemos chamar assim.

168
00:10:13,510 --> 00:10:17,860
Mas eu preciso fazer uma coisa extra. O que pertence ao final de qualquer cadeia em C?

169
00:10:17,860 --> 00:10:20,710
O personagem nulo, o que nós escrevemos como \ 0.

170
00:10:20,710 --> 00:10:23,980
É tecnicamente o número 0, mas a barra invertida faz toda mais clara a

171
00:10:23,980 --> 00:10:28,150
que este é literalmente o número 0, o inteiro 0;

172
00:10:28,150 --> 00:10:32,440
não é, por exemplo 0, entre aspas que você pode digitar no teclado.

173
00:10:32,440 --> 00:10:33,940
Portanto, esta é OLÁ.

174
00:10:33,940 --> 00:10:36,350
>> E o que podemos dizer na segunda-feira que uma função como GetString

175
00:10:36,350 --> 00:10:39,580
é, na verdade, voltando todas essas semanas?

176
00:10:39,580 --> 00:10:43,960
Não é devolver uma cadeia de per se, porque isso realmente não tem sentido

177
00:10:43,960 --> 00:10:47,710
porque as cordas não existem. Eles são uma espécie de fabricação na biblioteca CS50.

178
00:10:47,710 --> 00:10:51,300
O que é realmente uma seqüência, mais tecnicamente? >> [Aluno] É o primeiro caractere.

179
00:10:51,300 --> 00:10:55,950
Exatamente. É simplesmente o endereço do primeiro caractere que o usuário digitou dentro

180
00:10:55,950 --> 00:11:02,810
Então, se a minha palavra OLÁ termina-se em 123 o número de bytes e então em número de byte 124,

181
00:11:02,810 --> 00:11:08,320
125, 126, e assim por diante, se eu número apenas meus bytes de 0 em cima,

182
00:11:08,320 --> 00:11:12,650
o que realmente está retornando GetString é literalmente o número 123.

183
00:11:12,650 --> 00:11:19,270
Então, o que é colocado em s é o número 123, e não a letra H, não a palavra OLÁ,

184
00:11:19,270 --> 00:11:23,130
simplesmente o endereço em que eu possa encontrar a primeira letra do OLÁ.

185
00:11:23,130 --> 00:11:26,500
Mas isso não parece ser suficiente. Eu lhe pedi uma string, não um personagem.

186
00:11:26,500 --> 00:11:32,970
Assim como nós ou o computador saber que tipo de ELLO vêm junto com o H?

187
00:11:35,760 --> 00:11:37,460
Qual é o tipo de acordo que temos? Sim.

188
00:11:37,460 --> 00:11:40,100
[Aluno] Ele continua dizendo a si mesma para encontrar mais alguns personagens. >> Exatamente.

189
00:11:40,100 --> 00:11:44,570
>> Há essa convenção humano-computador em que quando você está lidando com cordas,

190
00:11:44,570 --> 00:11:49,410
também conhecido agora como estrelas char, você simplesmente tem que descobrir

191
00:11:49,410 --> 00:11:54,350
onde no final de cada corda na vida é realmente apenas uma iteração sobre isso com um loop,

192
00:11:54,350 --> 00:11:57,820
um loop while, qualquer que seja, de modo que quando você encontrar o final da cadeia

193
00:11:57,820 --> 00:12:02,160
agora você pode inferir que, oh, toda a palavra foi OLÁ.

194
00:12:02,160 --> 00:12:04,820
Aqueles de vocês com experiência anterior em programação pode saber em Java

195
00:12:04,820 --> 00:12:09,880
você pode apenas chamar. comprimento e em outras línguas você pode chamar comprimento ou similar.

196
00:12:09,880 --> 00:12:14,060
Isso porque em um monte de línguas, especialmente coisas chamadas linguagens orientadas a objeto,

197
00:12:14,060 --> 00:12:18,580
o comprimento de algo é uma espécie de encapsulado dentro de um pedaço de dados em si,

198
00:12:18,580 --> 00:12:24,000
muito como nós IDs encapsulados e nomes e casas dentro de um estudante na segunda-feira.

199
00:12:24,000 --> 00:12:28,700
Mas C é o nível mais baixo. Não há objetos ou classes, se você já ouviu esses termos antes.

200
00:12:28,700 --> 00:12:31,490
Tudo que você tem é realmente endereços de memória.

201
00:12:31,490 --> 00:12:35,540
Portanto, esta é uma espécie de maneira antiga de representar estruturas interessantes dados.

202
00:12:35,540 --> 00:12:38,760
Você tem um valor inicial como o endereço do primeiro caractere

203
00:12:38,760 --> 00:12:42,340
e depois é só convenção alguns arbitrária que todos concordam em seguir.

204
00:12:42,340 --> 00:12:46,420
Então, como é implementada comprimento da corda, que propomos?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, que alguns de vocês já usado algumas vezes. É muito simples, certo?

206
00:12:51,360 --> 00:12:53,060
É como se duas linhas de código.

207
00:12:53,060 --> 00:12:56,140
É praticamente um laço para de alguma sorte, talvez com uma variável adicional local.

208
00:12:56,140 --> 00:13:00,540
Mas strlen só tem que tomar um ponteiro e, em seguida, começar a olhar para \ 0.

209
00:13:00,540 --> 00:13:05,190
>> E assim que ele encontrar, ele pode retornar o número total de passos que é tomado em que seqüência.

210
00:13:05,190 --> 00:13:07,150
Assim, podemos deduzir o que se passa ao lado.

211
00:13:07,150 --> 00:13:11,850
Suponha então eu declaro t como eu fiz na linha 10.

212
00:13:11,850 --> 00:13:14,280
Trata-se de um valor de lixo. Quem sabe no início?

213
00:13:14,280 --> 00:13:18,490
Mas no lado direito da linha de 10 que eu estou chamando GetString novamente.

214
00:13:18,490 --> 00:13:20,050
Quem sabe onde isso acaba?

215
00:13:20,050 --> 00:13:23,830
Vamos arbitrariamente dizer que o sistema operacional encontrado espaço para ele caminho até aqui.

216
00:13:23,830 --> 00:13:28,610
Acontece que eu coincidentemente tipo H-E-L-L-O de novo,

217
00:13:28,610 --> 00:13:31,260
e assim podemos chamar o mesmo tipo de imagem.

218
00:13:31,260 --> 00:13:34,290
Mas o fato de que eu tenho esta imagem redesenhado é deliberada

219
00:13:34,290 --> 00:13:37,720
porque essa é uma. OLÁ diferente do que esta

220
00:13:37,720 --> 00:13:43,920
Portanto, aqui este pode ser local 456, este é 457, e assim por diante.

221
00:13:43,920 --> 00:13:47,170
Então, o que é colocado onde o ponto de interrogação era uma vez?

222
00:13:47,170 --> 00:13:50,190
Neste caso 456.

223
00:13:50,190 --> 00:13:53,540
Estamos colhendo estes números arbitrariamente porque realmente depois de hoje

224
00:13:53,540 --> 00:13:57,110
nós não vamos importar tanto com o que o endereço de qualquer coisa é.

225
00:13:57,110 --> 00:14:02,690
Tudo o que importa é que podemos descobrir o endereço de algum pedaço de dados como OLÁ.

226
00:14:02,690 --> 00:14:07,100
>> Então, realmente o que a maioria das pessoas em ciência da computação quando se fala de endereços de memória

227
00:14:07,100 --> 00:14:10,210
e falando sobre ponteiros especificamente,

228
00:14:10,210 --> 00:14:14,220
em vez de se preocupar descobrir 123 - quem se importa onde este material realmente é,

229
00:14:14,220 --> 00:14:17,440
apenas sabemos que ele está em algum endereço numérico -

230
00:14:17,440 --> 00:14:22,180
que simplificam o mundo e apenas dizer que s está a apontar para que o personagem

231
00:14:22,180 --> 00:14:25,080
e t está apontando para esse personagem.

232
00:14:25,080 --> 00:14:27,430
E o fato de que é uma seta é bastante intencional

233
00:14:27,430 --> 00:14:31,610
porque agora literalmente s está apontando para H e t está apontando para o outro H

234
00:14:31,610 --> 00:14:34,720
porque no fim do dia, que não importa qual é o endereço é,

235
00:14:34,720 --> 00:14:40,240
mas não importa de que temos a capacidade de expressar esse endereço com algum pedaço de código.

236
00:14:40,240 --> 00:14:42,730
Nós realmente não temos manipulado estes endereços apenas ainda

237
00:14:42,730 --> 00:14:47,770
então vamos ver onde podemos interpor e classificar de fazer as coisas com ponteiros,

238
00:14:47,770 --> 00:14:52,030
mas por agora na linha 12, literalmente, os valores que estamos comparando

239
00:14:52,030 --> 00:14:55,500
de acordo com essa história na linha 12?

240
00:14:56,570 --> 00:15:01,290
Nós estamos dizendo é 123 igual igual a 456? E isso não é definitivamente o caso.

241
00:15:01,290 --> 00:15:05,320
E mesmo conceitualmente, esse ponteiro definitivamente não é o mesmo que este

242
00:15:05,320 --> 00:15:09,500
porque você chamou GetString duas vezes, e GetString não tenta ser super inteligente,

243
00:15:09,500 --> 00:15:12,470
não tente perceber, oh, você digitou OLÁ cinco minutos atrás;

244
00:15:12,470 --> 00:15:15,090
deixe-me dar-lhe o mesmo ponteiro como lhes dei antes,

245
00:15:15,090 --> 00:15:18,450
ele só aloca um novo bloco de memória cada vez que você chamá-lo.

246
00:15:18,450 --> 00:15:20,350
>> Então, como vamos resolver esse problema?

247
00:15:20,350 --> 00:15:24,270
Se nível mais alto Eu quero comparar as cordas Olá e OLÁ -

248
00:15:24,270 --> 00:15:28,680
Eu não me importo com os ponteiros - como eu faço para responder a pergunta,

249
00:15:28,680 --> 00:15:31,980
se o usuário digitar a mesma coisa? O que é necessário aqui? Sim.

250
00:15:31,980 --> 00:15:35,200
[Estudante] Use uma função. >> Eu posso usar uma função fora da caixa.

251
00:15:35,200 --> 00:15:38,170
Eu posso usar uma função chamada strcmp, s-t-r-c-m-p,

252
00:15:38,170 --> 00:15:41,190
apenas a versão abreviada de dizer corda comparar.

253
00:15:41,190 --> 00:15:45,070
E se entrar, por exemplo, comparar dois, que está entre folhetos de hoje,

254
00:15:45,070 --> 00:15:46,690
Eu faço exatamente isso.

255
00:15:46,690 --> 00:15:51,750
Eu mantive tudo mais o mesmo a partir de uma linha para baixo, para 26 ou mais,

256
00:15:51,750 --> 00:15:54,360
e agora perceber esta parte mudou um pouco.

257
00:15:54,360 --> 00:15:57,690
Vamos ignorar a linha 28 por um momento e se concentrar apenas em um presente.

258
00:15:57,690 --> 00:16:00,410
O que nós dizemos segunda-feira que str comparação faz?

259
00:16:00,410 --> 00:16:05,200
Ele lida com o processo de tomar dois ponteiros, s e t, neste caso,

260
00:16:05,200 --> 00:16:08,480
espécie de praticamente colocando o dedo sobre essas duas cartas,

261
00:16:08,480 --> 00:16:11,530
eo que ele deve fazer é algo como um loop while ou um loop for,

262
00:16:11,530 --> 00:16:16,050
e ele diz que são estes os mesmos? Se assim for, move os dedos ou os ponteiros para a frente.

263
00:16:16,050 --> 00:16:17,970
São estes os mesmos, estes mesmos o, estes, o mesmo

264
00:16:17,970 --> 00:16:22,710
estes mesmos o, esses mesmos a? E ooh, eu estou no final da cadeia, tanto s e t.

265
00:16:22,710 --> 00:16:26,780
Não foram encontradas quaisquer contradições. Sim, essas seqüências são as mesmas.

266
00:16:26,780 --> 00:16:31,940
E o que str retorno se comparar duas cordas são os mesmos, aparentemente? Zero.

267
00:16:31,940 --> 00:16:35,900
Então, 0 é bom neste caso, porque se ele retorna -1 ou +1,

268
00:16:35,900 --> 00:16:40,560
isso significa que é só acontece de vir antes de t em ordem alfabética ou depois de t.

269
00:16:40,560 --> 00:16:43,760
E por que isso seria útil ter uma função que lhe diz que a corda vem antes

270
00:16:43,760 --> 00:16:46,720
ou depois de um dicionário?

271
00:16:46,720 --> 00:16:48,740
[Aluno] Pesquisando. >> Pesquisa e classificação.

272
00:16:48,740 --> 00:16:51,730
>> Assim, você pode fazer coisas como busca binária ou espécie de bolha ou merge sort

273
00:16:51,730 --> 00:16:53,230
onde você tem que comparar as coisas.

274
00:16:53,230 --> 00:16:56,420
Até agora, nós meio que cortar alguns cantos e só falou sobre a classificação

275
00:16:56,420 --> 00:16:59,430
no contexto de números, porque é agradável e fácil de falar,

276
00:16:59,430 --> 00:17:02,430
mas certamente você pode comparar strings, maçã e banana,

277
00:17:02,430 --> 00:17:05,349
porque se maçã é conhecido para vir antes da banana, do mesmo modo,

278
00:17:05,349 --> 00:17:09,319
você pode mover cordas em torno da memória como Rob fez com merge sort no vídeo

279
00:17:09,319 --> 00:17:15,880
e nós fizemos aqui no palco com uma espécie de seleção, tipo de inserção, e espécie de bolha.

280
00:17:15,880 --> 00:17:18,710
Então, onde mais podemos levar isso? Vamos tentar isso.

281
00:17:18,710 --> 00:17:23,980
Vamos esquecer que tipo de lição para um momento e tente agora e copiar 1.c para fazer o seguinte.

282
00:17:23,980 --> 00:17:26,800
Na linha 21 eu estou dizendo algo de impressão,

283
00:17:26,800 --> 00:17:28,520
então eu estou recebendo uma string do usuário,

284
00:17:28,520 --> 00:17:30,690
então eu estou verificando isso.

285
00:17:30,690 --> 00:17:33,620
Nós realmente não temos chegado a este hábito ainda, mas vamos fazer isso agora.

286
00:17:33,620 --> 00:17:40,990
Vamos realmente descascar essa camada. Isto é realmente char *. Esse cara é muito char *.

287
00:17:40,990 --> 00:17:45,690
Então, o que significa estar verificando se s == null?

288
00:17:45,690 --> 00:17:48,380
Acontece que quando você chamar uma função como GetString

289
00:17:48,380 --> 00:17:51,540
ou, mais geralmente basta perguntar a um computador para lhe dar um pouco de memória,

290
00:17:51,540 --> 00:17:53,030
algo poderia dar errado.

291
00:17:53,030 --> 00:17:56,630
Você poderia estar louco e pedir ao computador para um terabyte de memória

292
00:17:56,630 --> 00:18:01,780
pedindo trilhões de bytes de memória que simplesmente não existem no computador,

293
00:18:01,780 --> 00:18:05,130
mas funções GetString e outros precisam de alguma forma de gritar com você

294
00:18:05,130 --> 00:18:06,820
se você pediu muito.

295
00:18:06,820 --> 00:18:10,450
E a maneira GetString faz isso é, se você pediu mais memória

296
00:18:10,450 --> 00:18:14,250
que está disponível no computador, mesmo que isso é super, super baixa probabilidade

297
00:18:14,250 --> 00:18:17,730
porque nenhum de nós está indo para digitar um trilhão de caracteres e pressione a tecla Enter,

298
00:18:17,730 --> 00:18:21,980
mas baixa probabilidade que possa ser, eu ainda quero para verificar isso apenas no caso,

299
00:18:21,980 --> 00:18:26,120
eo valor especial que retorna GetString, resposta, e outras funções

300
00:18:26,120 --> 00:18:30,630
se algo deu errado é NULL em todas as tampas.

301
00:18:30,630 --> 00:18:36,520
>> E o que é NULL? NULL só acontece a representar um ponteiro. É 0 endereço de memória.

302
00:18:36,520 --> 00:18:40,800
O mundo decidiu que arbitrariamente, se esta é a memória do meu computador - você sabe o que? -

303
00:18:40,800 --> 00:18:46,260
vamos roubar apenas 1 byte de memória cada computador, e esta é a posição 0.

304
00:18:46,260 --> 00:18:49,560
Nós vamos dar-lhe um apelido de NULL, e vamos prometer

305
00:18:49,560 --> 00:18:52,660
que nós nunca vamos realmente colocar dados reais lá

306
00:18:52,660 --> 00:18:56,770
porque apenas arbitrariamente precisa de um valor especial, 0, NULL aka,

307
00:18:56,770 --> 00:19:00,230
para que possamos gritar com os usuários, se algo der errado.

308
00:19:00,230 --> 00:19:03,590
Caso contrário, você pode não saber é que 0 significa colocar algo aqui

309
00:19:03,590 --> 00:19:05,490
ou significa algo deu errado?

310
00:19:05,490 --> 00:19:09,190
Temos que concordar que não significa nada NULL foi devolvido,

311
00:19:09,190 --> 00:19:11,700
nenhum endereço real foi devolvido.

312
00:19:11,700 --> 00:19:15,210
Agora, aqui estou apenas adotar meu convenção humana de eu voltar uma da principal

313
00:19:15,210 --> 00:19:17,040
se algo der errado.

314
00:19:17,040 --> 00:19:20,650
Isso porque principal convenção de retorno é retornar 0 se bem,

315
00:19:20,650 --> 00:19:22,990
Um ou outro valor se mal.

316
00:19:22,990 --> 00:19:28,200
Mas GetString e qualquer função que se ocupa em memória retorna NULL se algo vai mal.

317
00:19:28,200 --> 00:19:33,480
>> Okay. Então, infelizmente, linha 27, super simples que seja, completamente falha ao copiar a cadeia.

318
00:19:33,480 --> 00:19:35,740
Por quê? Podemos ver isso como se segue.

319
00:19:35,740 --> 00:19:40,120
Eu estou afirmando na linha 27 para ser fazer uma cópia de s e chamando-o de t.

320
00:19:40,120 --> 00:19:45,790
Então eu não estou pedindo ao usuário para 2 cordas desta vez, estou apenas dizendo o valor em s

321
00:19:45,790 --> 00:19:47,870
devem ser colocados em t também.

322
00:19:47,870 --> 00:19:52,890
Então agora só para demonstrar como este é quebrado, na linha 29 em diante o que eu estou fazendo?

323
00:19:52,890 --> 00:19:56,980
Primeiro estou verificando se o comprimento da t é maior que 0.

324
00:19:56,980 --> 00:19:59,330
Há alguma corda lá. O usuário digitou alguma coisa dentro

325
00:19:59,330 --> 00:20:03,410
Qual é a linha 32, fazendo, aparentemente?

326
00:20:03,410 --> 00:20:08,910
[Resposta do aluno inaudível] Direito. >> Você pode tipo de inferir-lo de que eu disse que está fazendo.

327
00:20:08,910 --> 00:20:13,200
Mas, tecnicamente, o que se está fazendo? t [0] representa o que?

328
00:20:13,200 --> 00:20:15,140
[Aluno] O personagem 0. >> [Malan] O personagem 0.

329
00:20:15,140 --> 00:20:19,620
Ou, mais semelhante à humana, o primeiro caractere em t, o que quer que seja, H talvez neste caso.

330
00:20:19,620 --> 00:20:24,990
E toupper faz o que diz. Ele conta o caráter de t 0 e muda-la.

331
00:20:24,990 --> 00:20:28,430
Então isso significa tomar o caráter de t 0, torná-lo maiúsculas,

332
00:20:28,430 --> 00:20:30,320
e colocá-lo de volta no mesmo local.

333
00:20:30,320 --> 00:20:35,540
Então, se eu digitar Olá em letras minúsculas, isso deve mudar a h minúsculas para um H. de capital

334
00:20:35,540 --> 00:20:41,400
Mas o problema é que, em linhas 35 e 36 o que eu estou prestes a fazer é imprimir para nós s e t.

335
00:20:41,400 --> 00:20:43,120
E qual é o seu palpite?

336
00:20:43,120 --> 00:20:47,250
O que eu estou indo realmente para ver se eu digitei Olá em todas as minúsculas?

337
00:20:47,250 --> 00:20:52,280
O que vai ficar impresso? >> [Resposta do aluno inaudível] >> O que é isso?

338
00:20:52,280 --> 00:20:58,360
[Aluno] Big H eo resto pequeno. H >> O grande e pequena para o resto, que, s ou t?

339
00:20:58,360 --> 00:21:03,170
[Aluno] Ambos. Tanto >>. Exatamente. Então, vamos ver o que está acontecendo aqui.

340
00:21:03,170 --> 00:21:08,380
>> Deixe-me ir em frente e compilar este. Este é copy1, para fazer copy1. Tudo bem.

341
00:21:08,380 --> 00:21:14,840
Zoom dentro Deixe-me ir em frente e correr copy1, Enter, dizer algo: Olá em minúsculas.

342
00:21:14,840 --> 00:21:19,570
Ele capitalizados a cópia, mas, aparentemente, capitalizados o original, bem como,

343
00:21:19,570 --> 00:21:22,070
porque o que agora acontece nesta história?

344
00:21:22,070 --> 00:21:27,030
Na linha 27 eu realmente não parecem estar a copiar a cadeia,

345
00:21:27,030 --> 00:21:30,450
mas mesmo que você pode ter a esperança de que intuitivamente ser o caso,

346
00:21:30,450 --> 00:21:33,680
se você pensar sobre esse quadro, o que realmente eu fiz?

347
00:21:33,680 --> 00:21:35,410
Metade do quadro é o mesmo.

348
00:21:35,410 --> 00:21:39,390
Então, vamos reverter a tempo para que t ainda não existe na história.

349
00:21:39,390 --> 00:21:43,160
S pode existir na história, mas vamos minúsculas Olá neste momento.

350
00:21:43,160 --> 00:21:46,710
Então deixe-me corrigir o que eu realmente digitado dentro

351
00:21:46,710 --> 00:21:51,280
Neste caso, temos aqui h-e-l-l-o.

352
00:21:51,280 --> 00:21:58,050
Vamos desenhá-lo como uma seqüência de caracteres, colocar minhas linhas separadoras aqui e meu \ 0.

353
00:21:58,050 --> 00:22:05,980
Portanto, este é o lugar onde estamos, assim como a linha de 1 a 24-ish, mais ou menos, ter executado.

354
00:22:05,980 --> 00:22:07,800
Esta é a imagem da minha memória.

355
00:22:07,800 --> 00:22:10,800
Quando eu chegar à linha 27, o que acontece?

356
00:22:10,800 --> 00:22:14,730
Assim como antes, eu recebo um ponteiro, que eu vou desenhar como esta praça.

357
00:22:14,730 --> 00:22:19,740
É chamado de t. E o que é o seu valor por padrão? Quem sabe? Algum valor lixo.

358
00:22:19,740 --> 00:22:22,060
>> Então eu vou abstrata que fora como um ponto de interrogação.

359
00:22:22,060 --> 00:22:27,670
E, logo que o lado direito da linha 27 executa, o que estou colocando dentro de t?

360
00:22:27,670 --> 00:22:30,770
A mesma coisa que está em s.

361
00:22:30,770 --> 00:22:34,120
Então, se por um momento remover essa abstração da seta e dizemos:

362
00:22:34,120 --> 00:22:40,330
oh, este é o endereço de memória de carga 123, quando você diz que fica t s, ponto e vírgula,

363
00:22:40,330 --> 00:22:42,700
você está literalmente colocando 123 aqui.

364
00:22:42,700 --> 00:22:45,200
Agora, se nós tipo de simplificar o nosso mundo novamente com fotos,

365
00:22:45,200 --> 00:22:48,750
o que você realmente feito é apenas acrescentou uma outra seta para o seu mundo

366
00:22:48,750 --> 00:22:52,910
que está apontando de t para a mesma seqüência exata.

367
00:22:52,910 --> 00:22:59,730
Assim, quando na linha 31 e 32 eu realmente ir sobre a mudança de t [0],

368
00:22:59,730 --> 00:23:05,580
o que é t [0] aparentemente sinônimo de agora? s [0]

369
00:23:05,580 --> 00:23:07,030
Então, isso é tudo o que está acontecendo.

370
00:23:07,030 --> 00:23:09,900
E mesmo que esse tipo de sente um nível um pouco baixo e arcano

371
00:23:09,900 --> 00:23:12,760
e esse tipo de sensação, talvez intuitivamente este deveria ter apenas trabalhado -

372
00:23:12,760 --> 00:23:15,410
Fiz cópias de coisas antes e ele só trabalhou -

373
00:23:15,410 --> 00:23:18,590
se você realmente pensar sobre o que realmente é uma string, é um char *.

374
00:23:18,590 --> 00:23:21,700
Bem, o que é isso? É o endereço de algum personagem.

375
00:23:21,700 --> 00:23:24,930
Então, talvez, faz mais sentido que, quando você tenta fazer algo

376
00:23:24,930 --> 00:23:29,220
Super aparentemente simples como este, tudo o que você está fazendo é copiar o endereço de uma memória.

377
00:23:29,220 --> 00:23:32,530
Você não está realmente fazendo alguma coisa com a seqüência em si.

378
00:23:32,530 --> 00:23:37,500
Assim, mesmo se você não tem idéia de como você poderia resolver este problema no código,

379
00:23:37,500 --> 00:23:45,080
alto nível, conceitualmente, o que nós precisamos fazer a fim de fazer ta cópia fiel da s, aparentemente?

380
00:23:46,670 --> 00:23:48,820
Sim. >> [Aluno] Dê-lhe um novo local? >> Exatamente.

381
00:23:48,820 --> 00:23:50,800
>> Precisamos dar t um local novo.

382
00:23:50,800 --> 00:23:55,230
Precisamos de alguma forma criar um mundo em que temos um novo bloco de memória,

383
00:23:55,230 --> 00:24:00,090
que apenas por uma questão de clareza eu vou desenhar logo abaixo um presente, mas ele não precisa estar lá.

384
00:24:00,090 --> 00:24:04,880
Mas ele precisa ser do mesmo tamanho, então eu vou tirar essas linhas verticais no mesmo lugar.

385
00:24:04,880 --> 00:24:09,720
É bom se tudo isso é lixo inicialmente. Quem sabe o que estava lá?

386
00:24:09,720 --> 00:24:13,850
Mas, passo um vai ter que ser me dar tanta memória quanto eu preciso

387
00:24:13,850 --> 00:24:18,630
para atender a uma cópia do Olá, em seguida, descobrir como copiar o h aqui, o e aqui,

388
00:24:18,630 --> 00:24:20,390
o l, aqui e assim por diante.

389
00:24:20,390 --> 00:24:24,880
Mas isso já deve sentir-se um pouco óbvio, mesmo se alguns dos detalhes ainda são abstratos.

390
00:24:24,880 --> 00:24:28,690
Para copiar essa string para isso, é apenas um loop ou um loop while

391
00:24:28,690 --> 00:24:31,580
ou algo com que você se tornou ainda mais familiar.

392
00:24:31,580 --> 00:24:35,970
Então, vamos tentar isso. Deixe-me ir para copy2.c.

393
00:24:35,970 --> 00:24:43,270
Em copy2.c temos quase o mesmo programa, exceto para a linha 27.

394
00:24:43,270 --> 00:24:47,260
Parece um pouco complexo, mas se decompô-lo peça por peça,

395
00:24:47,260 --> 00:24:48,950
o lado esquerdo é a mesma.

396
00:24:48,950 --> 00:24:52,790
Char * t cria essa coisa na memória, ainda que com um ponto de interrogação

397
00:24:52,790 --> 00:24:54,680
porque não temos idéia do que está lá por padrão.

398
00:24:54,680 --> 00:24:57,920
No lado direito, estamos agora a introduzir uma nova função malloc,

399
00:24:57,920 --> 00:25:00,640
para alocar a memória, dá-me a memória,

400
00:25:00,640 --> 00:25:06,900
e, aparentemente, leva quantos argumentos, quantas coisas dentro de parênteses?

401
00:25:09,660 --> 00:25:12,130
Eu ouvi murmúrios de 1 e 2, mas é apenas uma.

402
00:25:12,130 --> 00:25:15,320
Não há vírgula, o que significa que há apenas uma coisa um dentro dos parênteses.

403
00:25:15,320 --> 00:25:17,720
Mesmo que não haja parênteses outros, deixe-me destacar

404
00:25:17,720 --> 00:25:21,460
o que está dentro dos parênteses ultraperiféricas, e é esta expressão:

405
00:25:21,460 --> 00:25:25,880
(Strlen (s) + 1) * sizeof (char).

406
00:25:25,880 --> 00:25:29,190
Então, se nós realmente pensar nisso, este está dizendo me dar o comprimento de s.

407
00:25:29,190 --> 00:25:34,440
Por que eu sou, porém, adicionando 1 para o comprimento? >> [Resposta do aluno inaudível]

408
00:25:34,440 --> 00:25:40,200
Exatamente. Precisamos de espaço para esse cara na cauda, ​​o sexto caractere que não tem sentido Inglês

409
00:25:40,200 --> 00:25:42,250
mas tem significado programático especial.

410
00:25:42,250 --> 00:25:46,800
>> Então precisamos de um + 1 para que, porque strlen retorna a expectativa humana de comprimento,

411
00:25:46,800 --> 00:25:50,890
Olá ou 5, ele não lhe dá o caráter nulo adicional.

412
00:25:50,890 --> 00:25:52,980
Então eu adicionar manualmente isso com + 1.

413
00:25:52,980 --> 00:25:56,060
E depois disso, tamanho * de (char), não temos visto isso antes.

414
00:25:56,060 --> 00:25:57,480
Este não é, tecnicamente, uma função.

415
00:25:57,480 --> 00:26:04,150
É uma palavra-chave especial que só diz o que o tamanho é de algum tipo de dados em um computador

416
00:26:04,150 --> 00:26:06,980
porque, na realidade, alguns de nós temos computadores de 32 bits.

417
00:26:06,980 --> 00:26:10,900
Eu tenho um computador muito velho em casa, e só usa 32 bits para representar ponteiros.

418
00:26:10,900 --> 00:26:13,900
E assim, se eu fiz tamanho de um tipo de dados, pode ser de 32 bits.

419
00:26:13,900 --> 00:26:18,300
Mas se eu estou usando o meu novo computador fantasia, eu possa voltar um valor de 64 bits

420
00:26:18,300 --> 00:26:20,510
para algo como um endereço.

421
00:26:20,510 --> 00:26:25,400
Portanto, neste caso, apenas para ser seguro super, não vamos a algo rígido código como -

422
00:26:25,400 --> 00:26:28,740
bem, o que é do tamanho de um char de acordo com o que temos dito até agora?

423
00:26:28,740 --> 00:26:34,450
Nós praticamente disse verbalmente que é um byte, e isso é muito bonito verdade através da placa.

424
00:26:34,450 --> 00:26:37,000
Mas, novamente, os pressupostos tendem a ser ruim.

425
00:26:37,000 --> 00:26:40,850
Eles levam a software buggy se as pessoas usam seu software de forma que você não teve a intenção.

426
00:26:40,850 --> 00:26:44,750
Então vamos abstrato esta distância e apenas mais genericamente dizer

427
00:26:44,750 --> 00:26:46,830
Eu preciso disso muitos pedaços de memória

428
00:26:46,830 --> 00:26:50,210
e cada bloco de memória deve ser equivalente ao tamanho de uma personagem,

429
00:26:50,210 --> 00:26:54,870
que é de fato igual a 1 neste caso, mas é uma forma mais genérica de escrevê-lo.

430
00:26:54,870 --> 00:27:00,460
Então, se a palavra é Olá, quantos bytes se malloc aparentemente alocar para Olá?

431
00:27:00,460 --> 00:27:04,980
[Aluno] Six. >> Six. Exatamente como muitos como temos pontos de interrogação na tela.

432
00:27:04,980 --> 00:27:07,800
E depois dar um palpite agora baseada em sua compreensão de GetString

433
00:27:07,800 --> 00:27:12,790
o que malloc provavelmente voltar? >> [Aluno] Um endereço.

434
00:27:12,790 --> 00:27:17,020
Um endereço de quê? Do primeiro pedaço de memória.

435
00:27:17,020 --> 00:27:20,670
>> Nós não temos idéia do que está lá porque alguma outra função

436
00:27:20,670 --> 00:27:23,010
poderia ter sido utilizando a memória anteriormente.

437
00:27:23,010 --> 00:27:28,380
Mas malloc, como GetString, retorna o endereço do primeiro byte de memória

438
00:27:28,380 --> 00:27:30,540
que ele tem reservado para você.

439
00:27:30,540 --> 00:27:38,380
No entanto, o que ele não faz é preencher este vazio com um caractere nulo barra invertida

440
00:27:38,380 --> 00:27:43,030
pois verifica-se que você pode usar malloc para alocar qualquer coisa: ints, strings, arrays,

441
00:27:43,030 --> 00:27:45,700
carros alegóricos, estruturas estudantis.

442
00:27:45,700 --> 00:27:47,750
Você pode usar malloc completamente genericamente.

443
00:27:47,750 --> 00:27:51,470
Ele não se importa ou tem que saber o que você está alocando memória para.

444
00:27:51,470 --> 00:27:55,810
Portanto, seria presunçoso para malloc para colocar um \ 0

445
00:27:55,810 --> 00:27:58,340
no final de cada pedaço de memória que ele está dando a você

446
00:27:58,340 --> 00:28:02,620
porque esta \ 0 coisa é apenas uma convenção para cordas.

447
00:28:02,620 --> 00:28:06,310
Ela não é usada para ints, ela não é usada para carros alegóricos, ela não é usada para os alunos.

448
00:28:06,310 --> 00:28:11,730
E assim a pegadinha com malloc é que o ônus é inteiramente de você o programador

449
00:28:11,730 --> 00:28:16,790
lembrar quantos bytes você alocado e não para nunca usar um laço

450
00:28:16,790 --> 00:28:21,570
ou um loop while e ir além do limite do bloco de memória que você tem dado.

451
00:28:21,570 --> 00:28:23,540
Dito de outra forma, tão logo você alocar memória,

452
00:28:23,540 --> 00:28:28,510
você não pode pedir o sistema operacional, oh, a propósito, o tamanho de um bloco de memória foi isso?

453
00:28:28,510 --> 00:28:32,080
É inteiramente até você se lembrar se você precisa esse valor.

454
00:28:32,080 --> 00:28:34,330
>> Então, vamos ver como eu continuar a usar esta memória.

455
00:28:34,330 --> 00:28:38,430
Na linha 28 e 29, por que estou fazendo isso?

456
00:28:39,850 --> 00:28:42,260
Basta verificar a sanidade total.

457
00:28:42,260 --> 00:28:45,110
Apenas no caso de algo der errado, eu pedir alguma quantidade louca de memória

458
00:28:45,110 --> 00:28:48,690
ou eu tenho tantas coisas em execução no computador que simplesmente não há memória suficiente,

459
00:28:48,690 --> 00:28:51,780
algo assim, eu pelo menos quero para verificar nulo.

460
00:28:51,780 --> 00:28:55,260
Na realidade, a maioria dos computadores vai lhe dar a ilusão de que todos os programas

461
00:28:55,260 --> 00:28:57,080
pode utilizar a totalidade de sua memória RAM,

462
00:28:57,080 --> 00:29:00,740
mas, mesmo assim, se o usuário digita alguma corda louco longa talvez porque é um cara ruim

463
00:29:00,740 --> 00:29:03,440
e eles estão realmente tentando travar o seu programa ou hack para ele,

464
00:29:03,440 --> 00:29:07,300
você quer, pelo menos, verificar o valor de retorno de malloc e se iguala nulo.

465
00:29:07,300 --> 00:29:11,630
E se isso acontecer, vamos parar agora porque eu não sei o que fazer nesse caso.

466
00:29:11,630 --> 00:29:13,950
Como faço para copiar a cadeia? Há algumas maneiras de fazer isso.

467
00:29:13,950 --> 00:29:18,850
Há str copiar funções em C, mas é super simples para nós para fazer isso da maneira old-fashioned.

468
00:29:18,850 --> 00:29:23,110
>> Primeiro deixe-me descobrir o que o comprimento de s é.

469
00:29:23,110 --> 00:29:26,930
Eu poderia ter colocado isso no loop, mas em vez disso, basta colocá-lo aqui para maior clareza.

470
00:29:26,930 --> 00:29:30,610
Então n agora armazena o comprimento da string original, o que aparentemente é 5.

471
00:29:30,610 --> 00:29:35,290
Então, no meu laço para Estou interagindo em 0 até n,

472
00:29:35,290 --> 00:29:40,940
e em cada iteração eu estou colocando s [i] dentro de t [i].

473
00:29:40,940 --> 00:29:45,060
Então é isso que eu implicava com meus dois dedos apontando para as cordas antes.

474
00:29:45,060 --> 00:29:49,260
Como este laço for assim, eu vou estar copiando h em aqui,

475
00:29:49,260 --> 00:29:52,890
e em aqui, eu para aqui porque este é s, este é t.

476
00:29:52,890 --> 00:29:58,770
E então, finalmente, na linha 35, por que estou fazendo isso?

477
00:29:58,770 --> 00:30:03,770
Eu preciso ter certeza de que eu estou terminando o t string.

478
00:30:03,770 --> 00:30:06,170
E eu fiz isso dessa maneira de ser super explícito.

479
00:30:06,170 --> 00:30:09,510
Mas propor, alguém, se você pudesse, uma maneira diferente de fazer isso.

480
00:30:09,510 --> 00:30:13,930
Eu realmente não precisa de linha 35. Há outra maneira de fazer isso.

481
00:30:13,930 --> 00:30:18,880
Sim. >> [Resposta do aluno inaudível] >> Diga mais alto.

482
00:30:18,880 --> 00:30:20,960
[Estudante] Menos do que ou igual a. >> Exatamente.

483
00:30:20,960 --> 00:30:24,450
Poderíamos apenas dizer menos do que ou igual a n, o que em geral tem sido mal

484
00:30:24,450 --> 00:30:28,190
porque quase sempre quando vamos para um igual à coisa estamos contando

485
00:30:28,190 --> 00:30:30,000
vamos um passo longe demais.

486
00:30:30,000 --> 00:30:32,170
Mas lembre-se, quantos bytes que nós alocar?

487
00:30:32,170 --> 00:30:37,210
Alocamos strlen de s, de modo 5 + 1, para um total de 6.

488
00:30:37,210 --> 00:30:39,980
Portanto, neste caso, poderíamos fazer algo assim

489
00:30:39,980 --> 00:30:46,450
de modo que nós estamos copiando não apenas o Olá mas também a 0 \ no final.

490
00:30:46,450 --> 00:30:49,860
Alternativamente, poderíamos usar uma função chamada str cópia, strcpy,

491
00:30:49,860 --> 00:30:51,700
mas isso não seria divertido quase tanto quanto.

492
00:30:51,700 --> 00:30:54,000
Mas isso é tudo que ele faz debaixo do capô.

493
00:30:54,000 --> 00:30:56,050
Então, por fim, fazemos a mesma coisa que antes.

494
00:30:56,050 --> 00:31:01,620
Eu t capitalizar e eu afirmo que o original é assim ea cópia parece assim.

495
00:31:01,620 --> 00:31:08,570
Então, vamos tentar isso agora. Deixe-me ir aqui. Faça copy2. Nós vamos ampliar e executar copy2.

496
00:31:08,570 --> 00:31:13,840
Eu estou indo para digitar Olá em letras minúsculas, e de fato eu fico minúsculas Olá como o original

497
00:31:13,840 --> 00:31:16,930
mas o capital Olá para a cópia.

498
00:31:16,930 --> 00:31:20,300
Mas eu não estou pronto ainda. Eu preciso fazer uma última coisa aqui.

499
00:31:20,300 --> 00:31:28,000
46 e 47 é claramente liberar memória, mas o que isso realmente significa?

500
00:31:28,000 --> 00:31:33,250
O que estou fazendo, você acha que, chamando linha 46 e linha 47?

501
00:31:33,250 --> 00:31:38,900
Qual o efeito que isso tem? Sim.

502
00:31:38,900 --> 00:31:43,140
[Resposta do aluno inaudível] >> Exatamente.

503
00:31:43,140 --> 00:31:46,380
>> Você está apenas dizendo o sistema operacional, hey, obrigado por esta lembrança.

504
00:31:46,380 --> 00:31:48,320
Agora você pode usá-lo para outra pessoa.

505
00:31:48,320 --> 00:31:50,790
E aqui está um exemplo perfeito de valores de lixo.

506
00:31:50,790 --> 00:31:55,430
Acabo de utilizar esta memória para escrever a palavra Olá em 2 lugares,

507
00:31:55,430 --> 00:31:57,490
aqui, aqui, aqui e aqui.

508
00:31:57,490 --> 00:32:00,910
Portanto, este é h-e-l-l-o-\ 0.

509
00:32:00,910 --> 00:32:06,960
Mas, então, eu chamo de linha 46 e linha 47, e você sabe o que acontece lá em termos de imagem?

510
00:32:06,960 --> 00:32:10,010
Na verdade, esperar, esta foto é a antiga.

511
00:32:10,010 --> 00:32:12,550
Uma vez que a cópia, esse cara é realmente apontando aqui,

512
00:32:12,550 --> 00:32:16,110
então vamos remover os números e apenas abstrair como nossas flechas novamente.

513
00:32:16,110 --> 00:32:19,370
O que acontece na foto quando eu chamo livre?

514
00:32:19,370 --> 00:32:22,750
[Resposta do aluno inaudível] >> Nem mesmo.

515
00:32:22,750 --> 00:32:29,510
Se eu ligar gratuitamente em S e T - um tipo de pergunta capciosa - esta imagem não muda em nada

516
00:32:29,510 --> 00:32:33,880
porque chamar s e chamando t apenas diz ao sistema operacional,

517
00:32:33,880 --> 00:32:39,010
hey, você pode usar essa memória de novo, mas isso não muda isso nulo

518
00:32:39,010 --> 00:32:41,840
ou algum caractere especial, não mudar isso,

519
00:32:41,840 --> 00:32:47,350
isso não muda o H ou o e ou o l ou l ou o em qualquer lugar para qualquer outra coisa.

520
00:32:47,350 --> 00:32:51,610
Em termos de imagem, tão logo você ligue grátis mudanças, nada.

521
00:32:51,610 --> 00:32:56,570
E é aí que reside a origem de valores de lixo porque se eu, mais tarde, no programa

522
00:32:56,570 --> 00:33:01,010
pedir ao sistema operacional para mais de memória com GetString ou malloc ou algo parecido

523
00:33:01,010 --> 00:33:04,900
eo sistema operacional, diz, com certeza, eu tenho 12 bytes de memória apenas libertados,

524
00:33:04,900 --> 00:33:08,080
usá-los, o que é que vai ser entregue?

525
00:33:08,080 --> 00:33:10,830
Você vai ser entregue um pedaço de memória que normalmente desenhar

526
00:33:10,830 --> 00:33:13,700
com pontos de interrogação, mas o que são esses pontos de interrogação?

527
00:33:13,700 --> 00:33:17,000
Eles acontecem ser h-e-l-l-o, h-e-l-l-o.

528
00:33:17,000 --> 00:33:20,940
Estes são os nossos valores de lixo novos assim que liberar a memória.

529
00:33:20,940 --> 00:33:22,750
>> Há um mundo real implicação aqui também.

530
00:33:22,750 --> 00:33:24,720
Isso acontece a ver com memória RAM, mas seus computadores

531
00:33:24,720 --> 00:33:26,720
realmente fazer a mesma coisa com o disco.

532
00:33:26,720 --> 00:33:30,620
Nós vamos falar sobre isso em particular com um conjunto de problemas futuros que incide sobre forense.

533
00:33:30,620 --> 00:33:36,170
Mas o que realmente acontece se você tem algum arquivo confidencial financeira em seu desktop

534
00:33:36,170 --> 00:33:39,600
ou algum JPEG esboçado e arrastá-lo para o seu lixo,

535
00:33:39,600 --> 00:33:44,390
o que acontece quando você arrastá-lo para o lixo ou a lixeira?

536
00:33:44,390 --> 00:33:47,240
Você sabia o que eu estava falando. [Risos]

537
00:33:47,240 --> 00:33:52,370
O que acontece quando você arrastou que a evidência em sua lixeira ou lata de lixo?

538
00:33:52,370 --> 00:33:55,920
[Resposta do aluno inaudível]

539
00:33:55,920 --> 00:33:58,000
Bem, então cuidado. O que acontece quando você faz isso?

540
00:33:58,000 --> 00:34:01,030
A resposta curta é nada, certo?

541
00:34:01,030 --> 00:34:04,790
Arquivo esboçado ou sensíveis ainda está apenas sentado em algum lugar no seu disco rígido.

542
00:34:04,790 --> 00:34:07,940
A maioria de nós, pelo menos, ter aprendido da maneira mais difícil que você precisa esvaziar seu lixo

543
00:34:07,940 --> 00:34:10,429
ou a sua lixeira para realmente apagar arquivos.

544
00:34:10,429 --> 00:34:13,440
E, de fato, quando você clique direito ou clique em sua lata de lixo

545
00:34:13,440 --> 00:34:15,580
Lixo ou escolher Arquivo, vazio ou o que quer

546
00:34:15,580 --> 00:34:21,420
e você realmente esvaziar a lata de lixo ou lixeira, o que realmente acontece em seguida, para esta imagem?

547
00:34:22,810 --> 00:34:25,969
Mais nada. Portanto, nada realmente acontece no disco.

548
00:34:25,969 --> 00:34:30,880
>> E se nós apenas temporariamente divagar e escrever - eu só usar a parte de trás do presente.

549
00:34:30,880 --> 00:34:34,639
Então, agora a história está mudando de RAM, que é onde existem programas

550
00:34:34,639 --> 00:34:39,250
enquanto você está executando-os, para o disco, que é onde eles são armazenados a longo prazo

551
00:34:39,250 --> 00:34:42,920
mesmo quando o poder sai, por enquanto - e nós vamos voltar a isso no futuro -

552
00:34:42,920 --> 00:34:46,380
vamos fingir que isto representa o interior do disco rígido do seu computador

553
00:34:46,380 --> 00:34:50,110
porque para trás no dia costumavam ser discos circulares, bem como disquetes.

554
00:34:50,110 --> 00:34:55,130
Então, se você tem algum arquivo do Excel sensível, pode levar até este pedaço de memória

555
00:34:55,130 --> 00:34:59,770
no disco do seu computador, e eu estou apenas desenhando 1s e 0s mesmo arbitrário.

556
00:34:59,770 --> 00:35:03,970
Quando você arrasta o arquivo como que a sua lata de lixo ou lixeira,

557
00:35:03,970 --> 00:35:07,750
literalmente nada acontece porque a Apple ea Microsoft simplesmente decidiu

558
00:35:07,750 --> 00:35:10,450
a lata de lixo e lixeira é realmente apenas um espaço reservado temporário.

559
00:35:10,450 --> 00:35:14,710
Talvez, eventualmente, o sistema operacional irá esvaziá-la para você, mas, normalmente, não faz nada,

560
00:35:14,710 --> 00:35:17,090
pelo menos até que você esteja realmente com pouco espaço.

561
00:35:17,090 --> 00:35:20,870
>> No entanto, quando você vai para o lixo vazio ou lixeira vazia,

562
00:35:20,870 --> 00:35:23,460
da mesma forma, nada acontece com esta imagem.

563
00:35:23,460 --> 00:35:28,590
Tudo o que acontece está em outro lugar no seu computador, existe algum tipo de mesa.

564
00:35:28,590 --> 00:35:35,400
É como uma espécie de folha de fraude pouco que diz que, vamos dizer, RESUME.DOC,

565
00:35:35,400 --> 00:35:40,920
para que o seu currículo em um arquivo do Microsoft Word morava no local 123 no seu disco rígido,

566
00:35:40,920 --> 00:35:43,710
não na memória e não na memória RAM, mas no seu disco rígido,

567
00:35:43,710 --> 00:35:49,050
e suas vidas esboçado JPEG com 456, e seu arquivo de Excel vive em 789 ou em qualquer lugar.

568
00:35:49,050 --> 00:35:53,640
Ao excluir arquivos por realmente esvaziar a lixeira ou a lixeira,

569
00:35:53,640 --> 00:35:59,530
esse quadro não muda. Os 0s e 1s em seu disco rígido não vão a lugar nenhum.

570
00:35:59,530 --> 00:36:03,930
Mas este quadro, este banco de dados pouco de sorte, faz a mudança.

571
00:36:03,930 --> 00:36:08,750
Quando você excluir o seu currículo, é como se o arquivo é apagado em algum sentido,

572
00:36:08,750 --> 00:36:12,790
mas todo o computador faz é esquecer de onde essa coisa vive no seu disco rígido.

573
00:36:12,790 --> 00:36:17,870
Os 0s e 1s que compõem o seu currículo ou qualquer um desses outros arquivos ainda estão intactos.

574
00:36:17,870 --> 00:36:21,960
>> Então, se você fez isso acidentalmente, ainda há uma probabilidade não-zero

575
00:36:21,960 --> 00:36:25,800
que você pode recuperar seus dados usando o Norton Utilities ou algum software comercial

576
00:36:25,800 --> 00:36:29,810
cujo objetivo de vida é encontrar 0s e 1s que tipo de órfãs,

577
00:36:29,810 --> 00:36:33,300
esquecido aqui, mas deixaram aqui, de modo que você pode obter seus dados de volta.

578
00:36:33,300 --> 00:36:38,410
Ou investigadores forenses com a polícia ou o FBI teria realmente ter um disco rígido

579
00:36:38,410 --> 00:36:42,550
e realmente olhar para os padrões de 0s e 1s que olhar como JPEGs, olhar como arquivos do Excel,

580
00:36:42,550 --> 00:36:46,400
e recuperá-los dessa forma, mesmo que o computador tenha esquecido lá.

581
00:36:46,400 --> 00:36:49,820
Então a única maneira realmente para apagar dados, como discutiremos no futuro,

582
00:36:49,820 --> 00:36:54,190
é esfregar ou limpar o arquivo ou disco rígido -

583
00:36:54,190 --> 00:36:56,540
Você realmente não pode se livrar do 0s e 1s

584
00:36:56,540 --> 00:36:59,440
porque senão você ia começar com uma unidade de gigabytes

585
00:36:59,440 --> 00:37:02,380
e você acabar com uma unidade de megabyte difícil se você constantemente se apagar,

586
00:37:02,380 --> 00:37:04,380
literalmente, 0s e 1s.

587
00:37:04,380 --> 00:37:06,310
Então, o que você faria se você realmente queria para cobrir seus rastros

588
00:37:06,310 --> 00:37:10,510
e que o problema fundamental é que ainda há 0s e 1s no disco?

589
00:37:10,510 --> 00:37:14,930
Eu vejo alguém gesticulando que você fisicamente quebrar o dispositivo. Que irá trabalhar.

590
00:37:14,930 --> 00:37:19,600
[Risos] Mas, se esse é o tipo de uma solução cara, o que seria mais razoável?

591
00:37:19,600 --> 00:37:23,270
Sim. >> [Aluno] substituí-los. >> Substituí-los com o quê? >> [Estudante] Outros dados.

592
00:37:23,270 --> 00:37:29,070
Outros dados. Você pode simplesmente substituir o disco com 0s ou 1s ou todos os 0s, todos os 1s.

593
00:37:29,070 --> 00:37:31,230
>> E isso é de fato o que alguns dos softwares faz.

594
00:37:31,230 --> 00:37:33,570
Você pode comprar o software ou até mesmo obter o software livre,

595
00:37:33,570 --> 00:37:36,610
e até mesmo construído no Mac OS estes dias, menos no Windows,

596
00:37:36,610 --> 00:37:38,660
é a capacidade de apagar com segurança.

597
00:37:38,660 --> 00:37:41,960
Na verdade, se você quiser todos os home run hoje, se você tem um Mac e fazer isso,

598
00:37:41,960 --> 00:37:45,740
se você tem alguma coisa na sua lata de lixo, você pode fazer Esvaziamento Seguro do Lixo,

599
00:37:45,740 --> 00:37:47,610
que faz exatamente isso.

600
00:37:47,610 --> 00:37:53,350
Em vez de apagar arquivos apenas aqui, isso não apaga o aqui 0s e 1s,

601
00:37:53,350 --> 00:38:01,240
ao contrário, ela apenas muda todos eles, por exemplo, para 0s e ponto, ponto, ponto.

602
00:38:01,240 --> 00:38:05,330
Então, um de seus futuros Série de Exercícios será realmente intencionalmente recuperar dados -

603
00:38:05,330 --> 00:38:08,430
fotografias que você tirou de pessoas, lugares e coisas no campus

604
00:38:08,430 --> 00:38:12,810
para o qual vamos fazer uma imagem forense de um cartão de memória da câmera digital,

605
00:38:12,810 --> 00:38:17,120
que é a idéia mesma - e você vai ter que ser desafiados a realmente encontrar

606
00:38:17,120 --> 00:38:20,160
os padrões que representam JPEGs em seu disco rígido,

607
00:38:20,160 --> 00:38:23,610
muito parecido com o ex-aluno, cujo e-mail que li há algumas semanas fez

608
00:38:23,610 --> 00:38:25,860
para recuperar fotografias de sua irmã.

609
00:38:25,860 --> 00:38:30,300
Por que não fazemos um intervalo de 5 minutos aqui, e nós vamos reagrupar com mais memória.

610
00:38:33,030 --> 00:38:38,610
Então é aqui que as coisas ficam um pouco alucinante, mas este é um passo muito poderoso

611
00:38:38,610 --> 00:38:40,480
para a compreensão de tudo isso o mais.

612
00:38:40,480 --> 00:38:42,900
Aqui está um programa chamado pointers.c.

613
00:38:42,900 --> 00:38:45,430
É entre código de hoje amostra.

614
00:38:45,430 --> 00:38:51,280
Note que em primeiras linhas, 19 a 22, tudo o que estamos fazendo é algo como GetString

615
00:38:51,280 --> 00:38:54,460
e retornando um endereço, armazenando-o em s.

616
00:38:54,460 --> 00:38:58,380
Doravante para pset mesmo 3 se quiser, mas pset 4 e no

617
00:38:58,380 --> 00:39:01,030
onde você pode começar a tomar essas rodinhas mesmo,

618
00:39:01,030 --> 00:39:04,030
não há razão para fingir que as cordas existe mais.

619
00:39:04,030 --> 00:39:07,030
É certamente bom para apenas começar a dizer * char.

620
00:39:07,030 --> 00:39:12,610
>> Como um aparte, em referências on-line e em livros muitas vezes você pode ver a estrela ao lado da variável.

621
00:39:12,610 --> 00:39:15,600
Você pode até mesmo ver os espaços em torno de ambos os lados.

622
00:39:15,600 --> 00:39:17,680
Todas estas são funcionalmente correcta.

623
00:39:17,680 --> 00:39:21,180
Por enquanto, porém, vamos padronizar essa abordagem para tornar super claro

624
00:39:21,180 --> 00:39:24,000
que char * é como dizer ponteiro personagem.

625
00:39:24,000 --> 00:39:25,680
Isto é o tipo de dados.

626
00:39:25,680 --> 00:39:28,730
E, em seguida, o nome da variável é s no presente caso.

627
00:39:28,730 --> 00:39:31,180
Então, nós temos tido uma corda e nós chamamos ele s.

628
00:39:31,180 --> 00:39:35,180
E então aqui notar que eu estou fazendo, na verdade, um pouco de malandragem.

629
00:39:35,180 --> 00:39:39,080
Isso é chamado de aritmética de ponteiro, que é uma espécie de super simples.

630
00:39:39,080 --> 00:39:41,790
Significa apenas somar e subtrair números para ponteiros.

631
00:39:41,790 --> 00:39:43,660
Mas isso realmente funciona.

632
00:39:43,660 --> 00:39:49,170
Este programa imprime o caráter aparentemente string s 1 por linha de tal forma que o resultado final -

633
00:39:49,170 --> 00:39:54,920
Só assim podemos estragar onde isso vai dar, fazer ponteiros, ponteiros correr, deixe-me fazer zoom in

634
00:39:54,920 --> 00:39:58,940
Agora deixe-me digite algo como OLÁ e digite Enter

635
00:39:58,940 --> 00:40:01,080
e imprime um caráter por linha.

636
00:40:01,080 --> 00:40:04,730
Até um segundo atrás, teria feito isso com a notação de colchete.

637
00:40:04,730 --> 00:40:09,760
Teríamos um loop e nós faríamos printf de s [i] e nós faria isso de novo e de novo e de novo

638
00:40:09,760 --> 00:40:11,950
com a n invertida no fim de cada linha.

639
00:40:11,950 --> 00:40:16,800
Mas este programa é diferente. Este programa está usando, literalmente, aritmética.

640
00:40:16,800 --> 00:40:18,860
Então, o que está acontecendo aqui?

641
00:40:18,860 --> 00:40:24,720
Primeiro de tudo, antes mesmo deste ciclo é executado, o que, só para ficar claro, é realmente s?

642
00:40:24,720 --> 00:40:27,270
S é? >> [Aluno] Um endereço. >> Um endereço.

643
00:40:27,270 --> 00:40:32,980
>> E é o endereço, no caso de Olá, o primeiro caractere em que a palavra, que é h.

644
00:40:32,980 --> 00:40:37,370
Então s é, neste exemplo particular, o endereço de h.

645
00:40:37,370 --> 00:40:41,850
Então, o que isso significa para fazer s + i?

646
00:40:41,850 --> 00:40:46,280
Bem, eu começa em 0 neste loop. Nós fizemos muitas vezes que.

647
00:40:46,280 --> 00:40:49,760
Eu está indo para ir até o comprimento da corda, aparentemente.

648
00:40:49,760 --> 00:40:53,950
Assim, na primeira iteração do loop, i é, obviamente, 0.

649
00:40:53,950 --> 00:41:01,740
Portanto, esta expressão está dizendo s + i - em vez disso, s +0--que é, obviamente, apenas s.

650
00:41:01,740 --> 00:41:04,320
Então, o que é * s aqui?

651
00:41:04,320 --> 00:41:08,530
Agora estamos usando a estrela de uma forma ligeiramente diferente.

652
00:41:08,530 --> 00:41:13,080
Deixe-me ir em frente e se livrar de t, porque estamos falando de t feito e cópias de s.

653
00:41:13,080 --> 00:41:15,540
Agora só quero contar uma história envolvendo s.

654
00:41:15,540 --> 00:41:20,090
E por isso, neste momento, depois de ter tipo string, nosso mundo parece muito como fazia antes

655
00:41:20,090 --> 00:41:26,630
s com apenas armazenar o endereço de h e, mais geralmente apontando para a cadeia Olá.

656
00:41:26,630 --> 00:41:33,170
Se eu agora fazer uma linha como * (s + i), vamos tentar fazer isso.

657
00:41:33,170 --> 00:41:40,140
Então * (s + i). Deixe-me simplificar isso porque este é 0, o que é * (s 0).

658
00:41:40,140 --> 00:41:43,790
Bem, espere um minuto. Simplificar ainda mais. Este é * (s).

659
00:41:43,790 --> 00:41:47,020
Bem, agora os parênteses são uma espécie de idiota, então agora vamos fazer * s.

660
00:41:47,020 --> 00:41:50,540
Assim, na primeira iteração do loop, que a linha que está em destaque, 26,

661
00:41:50,540 --> 00:41:53,650
é muito bonito equivalente a imprimir este.

662
00:41:53,650 --> 00:41:56,040
Qual é o tipo de dados * s?

663
00:41:56,040 --> 00:42:00,770
Neste contexto, uma vez que a estrela passa a ser o lado de si s,

664
00:42:00,770 --> 00:42:04,930
mas, mais especificamente, porque já não estamos declarando s,

665
00:42:04,930 --> 00:42:09,730
não estamos criando uma variável mais, não há nenhuma menção de char * na linha 26,

666
00:42:09,730 --> 00:42:14,280
não há nenhuma menção da string palavra-chave, estamos usando apenas uma variável chamada s,

667
00:42:14,280 --> 00:42:19,650
verifica-se agora a estrela tem um pouco diferente e, reconhecidamente, confundindo significado.

668
00:42:19,650 --> 00:42:26,590
* S, aqui, significa ir para o endereço em s e imprimir o que está lá.

669
00:42:26,590 --> 00:42:33,750
Então s é aqui, * s é - algo como rampas e escadas, siga a seta - aqui.

670
00:42:33,750 --> 00:42:35,850
Portanto, esta é * s.

671
00:42:35,850 --> 00:42:39,060
>> Então, o que é impresso na primeira iteração do loop de que na linha 26?

672
00:42:39,060 --> 00:42:42,170
Eu imprimir% c, que é o espaço reservado para um personagem,

673
00:42:42,170 --> 00:42:48,520
em seguida, um \ n para uma nova linha. * (S + i) onde i é 0 é só isso.

674
00:42:48,520 --> 00:42:53,670
Então, o que de char que eu colocar em para c%? H.

675
00:42:53,670 --> 00:42:56,900
Na próxima iteração do loop - você provavelmente pode ver onde isso vai dar -

676
00:42:56,900 --> 00:43:01,350
a próxima iteração i é, obviamente, um, então isso significa s 1,

677
00:43:01,350 --> 00:43:05,580
e então agora eu preciso dos parênteses porque agora a estrela precisa dizer

678
00:43:05,580 --> 00:43:08,620
ir para o endereço de memória de 1.

679
00:43:08,620 --> 00:43:14,170
O que é s? Vamos reverter no tempo e dizer esta seta agora não está realmente fazendo-nos quaisquer favores.

680
00:43:14,170 --> 00:43:18,450
Vamos, mais especificamente, dizer que este é armazenar o número 123

681
00:43:18,450 --> 00:43:25,110
porque o início desta cadeia Olá, isto é o endereço 123, este é 124, e assim por diante.

682
00:43:25,110 --> 00:43:30,550
Então, na segunda iteração quando eu estou dizendo s 1, que é como dizer que um 123,

683
00:43:30,550 --> 00:43:35,340
também conhecido como 124, então o caractere é impresso na segunda iteração?

684
00:43:35,340 --> 00:43:37,850
E no endereço de memória 124.

685
00:43:37,850 --> 00:43:44,440
Então + novamente, 125, 126, 127, e este laço felizmente parar antes de chegarmos aqui

686
00:43:44,440 --> 00:43:49,040
porque eu estou usando strlen para ter certeza de que eu não conta muito alta.

687
00:43:49,040 --> 00:43:50,810
Então, isso também é isso.

688
00:43:50,810 --> 00:43:55,000
Novamente, isso é como se tivéssemos feito uma semana atrás.

689
00:43:55,000 --> 00:43:59,200
Deixe-me escrever na linha abaixo mesmo que nós não queremos fazer os dois.

690
00:43:59,200 --> 00:44:02,500
Isto é idêntico a este agora.

691
00:44:02,500 --> 00:44:08,310
>> Assim, mesmo que s é uma string, como estamos chamando ele por semanas, s é realmente um char *.

692
00:44:08,310 --> 00:44:13,270
Então, se nós queremos ser anal super, é realmente correta de escrever o carácter específico

693
00:44:13,270 --> 00:44:17,490
no local ith utilizando estes endereços numéricos e este operador estrela,

694
00:44:17,490 --> 00:44:20,470
mas, francamente, este é mais limpo tanta coisa. Então isso não é ruim.

695
00:44:20,470 --> 00:44:26,720
Não há razão para parar de fazer linha 27 aqui, mas 26 é funcionalmente o mesmo,

696
00:44:26,720 --> 00:44:31,570
e é funcionalmente o mesmo para exatamente as razões que estamos discutindo até agora.

697
00:44:31,570 --> 00:44:33,650
E, por último, 29 é prática apenas bom.

698
00:44:33,650 --> 00:44:38,420
Chamando livre s significa que agora você está dando de volta a memória que lhe deu GetString

699
00:44:38,420 --> 00:44:41,630
porque mais uma vez, como mencionei segunda-feira, GetString de semana

700
00:44:41,630 --> 00:44:44,180
foi a introdução de um bug em seu código.

701
00:44:44,180 --> 00:44:46,490
Seu código de semana teve vazamentos de memória

702
00:44:46,490 --> 00:44:49,970
pelo qual você foi perguntando GetString para a memória, mas você nunca foi dando-lhe de volta.

703
00:44:49,970 --> 00:44:53,410
E que foi deliberadamente escolhido por nós pedagogicamente

704
00:44:53,410 --> 00:44:55,880
porque é muito pouco para pensar no início.

705
00:44:55,880 --> 00:44:57,710
Mas agora precisamos de mais simetria.

706
00:44:57,710 --> 00:45:00,830
Se pedir ao computador para a memória, tal como é o caso para GetString,

707
00:45:00,830 --> 00:45:02,820
como é o caso, aparentemente para malloc,

708
00:45:02,820 --> 00:45:07,970
Você deve agora para pset diante 4 também qualquer memória livre tal.

709
00:45:07,970 --> 00:45:11,650
Note que isto é diferente de dizer n int.

710
00:45:11,650 --> 00:45:15,040
Você não precisa liberar isso porque você não chamou GetString

711
00:45:15,040 --> 00:45:16,890
e você não chamar malloc.

712
00:45:16,890 --> 00:45:20,610
>> E mesmo se você chamou GetInt como vai finalmente ver,

713
00:45:20,610 --> 00:45:25,520
GetInt não aloca memória para você, porque você pode realmente passar em torno de números inteiros

714
00:45:25,520 --> 00:45:29,430
e carros alegóricos e chars apenas a forma como temos vindo a fazer para a semana.

715
00:45:29,430 --> 00:45:33,960
Cordas, porém, é especial porque realmente eles são a concatenação de caracteres múltiplos.

716
00:45:33,960 --> 00:45:37,450
Então, eles estão apenas diferente de caracteres e carros alegóricos e ints e similares.

717
00:45:37,450 --> 00:45:39,980
Mas vamos voltar ao que antes do tempo.

718
00:45:39,980 --> 00:45:44,920
Quaisquer perguntas, então neste início de ponteiros? Sim.

719
00:45:44,920 --> 00:45:49,690
[Pergunta estudante inaudível]

720
00:45:49,690 --> 00:45:51,440
Ah, boa pergunta.

721
00:45:51,440 --> 00:45:55,790
Uma das poucas coisas que realmente C faz para você, o que é conveniente,

722
00:45:55,790 --> 00:46:00,110
é ele descobre para você o que é o tamanho do tipo de dados

723
00:46:00,110 --> 00:46:03,060
e depois faz esse tipo de multiplicação para você.

724
00:46:03,060 --> 00:46:06,610
Isso é irrelevante no caso de caracteres, porque quase sempre é char a 1 byte,

725
00:46:06,610 --> 00:46:08,150
então isto funciona.

726
00:46:08,150 --> 00:46:11,220
Mas, por causa da discussão, se você estivesse realmente imprimir inteiros

727
00:46:11,220 --> 00:46:15,500
e você estava tentando imprimir alguns o valor que estava apontando para um número inteiro,

728
00:46:15,500 --> 00:46:20,720
você da mesma forma não teria necessidade de fazer + 4 * i só porque um int é de 4 bytes.

729
00:46:20,720 --> 00:46:25,780
Aritmética de ponteiro significa que o compilador C e fazer toda a matemática que para você.

730
00:46:25,780 --> 00:46:29,190
Tudo que você tem que se preocupar é a contagem em uma espécie de sentido humano. Sim.

731
00:46:29,190 --> 00:46:35,200
[Estudante] Se você declarar uma seqüência dentro de um loop for, você tem que libertá-lo depois?

732
00:46:35,200 --> 00:46:36,760
Boa pergunta.

733
00:46:36,760 --> 00:46:41,390
>> Se você declarou uma corda dentro do loop for, você precisa liberá-lo mais tarde?

734
00:46:41,390 --> 00:46:47,520
Você só precisa de memória livre que você alocar com GetString ou com malloc.

735
00:46:47,520 --> 00:46:53,110
Então, se você acabou de dizer algo como - deixe-me colocar chaves agora assim todo o código está relacionado.

736
00:46:53,110 --> 00:46:58,580
Se você fez alguma coisa, ainda que buggily, como este, char * t = s,

737
00:46:58,580 --> 00:47:03,450
você não precisa de t livres, porque t não envolveu qualquer menção de malloc ou GetString.

738
00:47:03,450 --> 00:47:08,960
Se, pelo contrário você fez isso, GetString, então sim, você precisa t livres.

739
00:47:08,960 --> 00:47:14,350
E, de fato, sua única chance de fazer isso é agora dentro deste laço, para o mesmo problema de âmbito

740
00:47:14,350 --> 00:47:16,060
que temos discutido no passado.

741
00:47:16,060 --> 00:47:18,830
Caso contrário, você seria a alocação de memória, alocação de memória, alocação de memória,

742
00:47:18,830 --> 00:47:21,230
e no final do programa, porque você está fora desse circuito,

743
00:47:21,230 --> 00:47:24,240
t não existe, mas você nunca contou o sistema operacional

744
00:47:24,240 --> 00:47:26,750
que você não precisa mais que a memória.

745
00:47:26,750 --> 00:47:30,430
E em pouco tempo, para pset 4 ou 5 nós vamos equipá-lo com um programa chamado Valgrind,

746
00:47:30,430 --> 00:47:34,160
que é semelhante em espírito a GDB em que ele tem um pouco de uma interface arcano,

747
00:47:34,160 --> 00:47:35,750
mas seu propósito na vida é ajudá-lo.

748
00:47:35,750 --> 00:47:39,380
E Valgrind é um programa que, no futuro, pesquisar seus programas

749
00:47:39,380 --> 00:47:42,550
procurando por vazamentos de memória, seja de GetString ou malloc,

750
00:47:42,550 --> 00:47:47,800
que nós vamos começar a usar tudo o mais que nós parar de usar a biblioteca CS50 tanto.

751
00:47:47,800 --> 00:47:53,030
Finalmente agora temos um tipo do vocabulário e do tipo de modelo mental na teoria

752
00:47:53,030 --> 00:47:55,170
com o qual se resolve este programa quebrado.

753
00:47:55,170 --> 00:47:59,410
>> Portanto, neste programa quebrado, swap funciona dentro de swap,

754
00:47:59,410 --> 00:48:05,280
mas nunca trabalhou realmente no principal porque principal passou em x e y, recall,

755
00:48:05,280 --> 00:48:07,260
e aqueles que foram aprovados em por valores, por assim dizer.

756
00:48:07,260 --> 00:48:09,330
Cópias deles foram dados para trocar.

757
00:48:09,330 --> 00:48:12,520
Até o final de swap, a e b realmente tinha sido trocado,

758
00:48:12,520 --> 00:48:16,120
mas é claro que x e y, como vimos na segunda-feira, não havia sido.

759
00:48:16,120 --> 00:48:19,940
Então proponho em verde aqui que esta é realmente a solução aqui.

760
00:48:19,940 --> 00:48:22,640
E, na verdade, deixe-me passar minhas estrelas apenas para ser coerente

761
00:48:22,640 --> 00:48:24,440
apesar de, novamente, funcionalmente, isso não importa.

762
00:48:24,440 --> 00:48:28,730
Nas semanas futuros vamos explicar quando e por que isso importa.

763
00:48:28,730 --> 00:48:30,600
Então em verde agora é uma solução.

764
00:48:30,600 --> 00:48:33,700
Francamente, parece um monte mais confusa, porque eu tenho todas essas estrelas.

765
00:48:33,700 --> 00:48:35,380
Deixe-me apontar uma única coisa.

766
00:48:35,380 --> 00:48:40,040
A linha de cima aqui onde diz int * a * b e int

767
00:48:40,040 --> 00:48:42,820
é fundamentalmente fazer a mesma coisa que ele sempre tem.

768
00:48:42,820 --> 00:48:47,070
É declarar que dois argumentos ou parâmetros para trocar,

769
00:48:47,070 --> 00:48:49,940
a primeira das quais é um ponteiro int chamado,

770
00:48:49,940 --> 00:48:53,100
a segunda das quais é um ponteiro int chamado b.

771
00:48:53,100 --> 00:48:55,770
A única coisa que há de novo neste ponto é o fato de que há uma estrela lá.

772
00:48:55,770 --> 00:48:59,340
>> O que significa isso? A não é um int, b não é um int.

773
00:48:59,340 --> 00:49:04,100
Um é o endereço de um int e b é o endereço de um int diferente.

774
00:49:04,100 --> 00:49:06,980
Aqui, é aqui que eu admito C fica confuso.

775
00:49:06,980 --> 00:49:09,790
Agora estamos usando uma estrela, mas tem significado diferente neste contexto.

776
00:49:09,790 --> 00:49:13,150
Porque nós não estamos declarar ponteiros como estamos aqui,

777
00:49:13,150 --> 00:49:15,500
aqui estamos dereferencing coisas.

778
00:49:15,500 --> 00:49:21,520
Então, tecnicamente, a estrela neste contexto de primeira linha, segundo e terceiro dentro de swap

779
00:49:21,520 --> 00:49:24,560
é o operador dereference, o que significa apenas ir lá.

780
00:49:24,560 --> 00:49:27,400
Assim como meu dedo seguiu a seta para h,

781
00:49:27,400 --> 00:49:31,100
* Um meio ir para esse endereço e me achar o int que está lá.

782
00:49:31,100 --> 00:49:34,250
* Significa que B vá para o endereço e passar-me o que está lá.

783
00:49:34,250 --> 00:49:40,730
Então, vamos redesenhar a imagem de segunda-feira usando agora uma pilha de quadros,

784
00:49:40,730 --> 00:49:43,130
o fundo do qual vai ser principal,

785
00:49:43,130 --> 00:49:47,600
a superior das quais vai ser de permuta,

786
00:49:47,600 --> 00:49:50,880
para que o nosso mundo olha, assim como segunda-feira, como este.

787
00:49:50,880 --> 00:49:53,620
Aqui é um pedaço da memória principal é que vai usar.

788
00:49:53,620 --> 00:49:56,520
>> Lembre-se de segunda-feira que o programa só tinha duas variáveis,

789
00:49:56,520 --> 00:50:01,930
um chamado x e y um chamado, e eu tinha colocado os números 1 e 2 lá.

790
00:50:01,930 --> 00:50:06,580
Agora, quando eu chamo trocar como eu fiz na segunda-feira,

791
00:50:06,580 --> 00:50:11,000
anteriormente, quando eu usei a versão vermelha deste programa, que se parece com isso,

792
00:50:11,000 --> 00:50:17,470
Eu tenho dois parâmetros, A e B, eo que nós escrevemos aqui e aqui?

793
00:50:17,470 --> 00:50:21,160
Apenas 1 e 2, literalmente copia de x e y.

794
00:50:21,160 --> 00:50:23,070
Hoje nós mudar isso.

795
00:50:23,070 --> 00:50:28,510
Hoje, em vez de passar em ints a e b, vamos passar em dois endereços.

796
00:50:28,510 --> 00:50:34,290
Esses endereços acontecer para apontar para ints, mas esses endereços não são ints si.

797
00:50:34,290 --> 00:50:37,330
Eles são endereços. É como um endereço postal vez.

798
00:50:37,330 --> 00:50:40,580
Então agora precisamos apenas dar a mim mesmo um pouco mais detalhadamente sobre a tela.

799
00:50:40,580 --> 00:50:43,250
Esta é a memória do meu computador como tem sido todos os dias.

800
00:50:43,250 --> 00:50:45,120
Agora precisamos de algum esquema de numeração arbitrária.

801
00:50:45,120 --> 00:50:50,580
Então vamos apenas dizer que, só por acaso, que este é o endereço de memória 123, 124.

802
00:50:50,580 --> 00:50:55,660
Vamos apenas dizer que este é 125, isso é 126, e assim por diante, mas isso é totalmente arbitrário.

803
00:50:55,660 --> 00:50:58,590
Nós só precisamos de algum esquema de numeração em minha memória.

804
00:50:58,590 --> 00:51:04,030
Então agora quando eu realmente passar em x e y, eu não vou passar em x e y;

805
00:51:04,030 --> 00:51:08,400
Vou passar o endereço postal, por assim dizer, de x e de y

806
00:51:08,400 --> 00:51:11,870
de modo que o que fica armazenado aqui e aqui não é 1 e 2,

807
00:51:11,870 --> 00:51:16,030
mas se você pode ver o meu pequeno texto, o que é passado aqui e aqui?

808
00:51:16,030 --> 00:51:23,340
[Resposta do aluno inaudível] >> Exatamente. 123 é colocado aqui e 124 é colocado aqui.

809
00:51:23,340 --> 00:51:28,910
>> Agora, porque eu usei a estrela desta forma primeira linha aqui em cima,

810
00:51:28,910 --> 00:51:34,340
meu programa só sabe que 123 e 124, apesar de serem, obviamente, inteiros

811
00:51:34,340 --> 00:51:40,160
que qualquer humano poderia notar, eles devem ser interpretados como endereços, endereços numéricos.

812
00:51:40,160 --> 00:51:43,250
Eles não são em si mesmas ints, eles são endereços,

813
00:51:43,250 --> 00:51:46,120
e isso é porque eu explicitamente coloca as estrelas lá.

814
00:51:46,120 --> 00:51:51,360
Então agora na minha linha primeiro, segundo e terceiro do código real o que acontece aqui?

815
00:51:51,360 --> 00:51:53,380
Vamos desenhar o resto da imagem.

816
00:51:53,380 --> 00:51:56,980
Tmp é exatamente como era na segunda-feira. Nada de especial sobre tmp.

817
00:51:56,980 --> 00:52:03,060
É apenas um local de 32 bits variável, e dentro do que eu estou aparentemente armazenar o valor de um arquivo *.

818
00:52:03,060 --> 00:52:08,580
Agora, se eu apenas disse tmp = a, o que eu colocar aqui? >> [Aluno] 123.

819
00:52:08,580 --> 00:52:10,370
123. Mas isso não é o que eu estou fazendo.

820
00:52:10,370 --> 00:52:13,670
Eu estou dizendo tmp = * a. Significa estrela ir lá.

821
00:52:13,670 --> 00:52:19,370
Então aqui vai uma, 123. Como posso ir para lá? Fingir que não há uma seta.

822
00:52:19,370 --> 00:52:24,460
Bem, aí está, 1. Então, o que fica armazenado em tmp, aparentemente? Apenas 1.

823
00:52:24,460 --> 00:52:29,620
Portanto, em outras palavras, é tmp * a *, um meio ir para o endereço que está atualmente em uma,

824
00:52:29,620 --> 00:52:31,320
que aparentemente é 123.

825
00:52:31,320 --> 00:52:33,910
>> Ok, aqui estamos na posição 123, eu vejo o número 1,

826
00:52:33,910 --> 00:52:35,670
então eu vou colocar o número 1 lá.

827
00:52:35,670 --> 00:52:39,020
Agora o que eu faço na linha 2, a * = * b?

828
00:52:39,020 --> 00:52:44,570
Este é um pouco mais complicado, porque agora o que é um? É 123.

829
00:52:44,570 --> 00:52:50,220
Então, a * é onde? Exatamente onde eu estava antes. Então, vá lá. Okay.

830
00:52:50,220 --> 00:52:53,420
Agora, finalmente, e então finalmente isso vai começar a fazer sentido, espera-se,

831
00:52:53,420 --> 00:53:00,280
* B significa que está em b? 124. Então eu preciso ir lá, que é 2.

832
00:53:00,280 --> 00:53:03,430
Então, o que faço para colocar onde?

833
00:53:03,430 --> 00:53:10,100
2 entra aqui, porque vai para * b * a. Então, eu vou fazer isso.

834
00:53:10,100 --> 00:53:13,120
E você já pode ver, talvez, de que estamos muito mais perto

835
00:53:13,120 --> 00:53:17,710
para resolver este problema, estúpido simples corretamente pela primeira vez

836
00:53:17,710 --> 00:53:20,920
porque agora nós ainda temos uma lembrança do que foi x,

837
00:53:20,920 --> 00:53:23,230
temos duas cópias, reconhecidamente, de y,

838
00:53:23,230 --> 00:53:25,850
mas a linha 3 agora diz * b.

839
00:53:25,850 --> 00:53:31,080
Então aqui está b. * B meios para lá. Então, onde é o local 124?

840
00:53:31,080 --> 00:53:35,560
É aparentemente aqui. Então o que eu colocar aqui? Obviamente tmp.

841
00:53:35,560 --> 00:53:39,600
Então agora eu faço isso. Então, eu tenho uma aqui e 2 aqui.

842
00:53:39,600 --> 00:53:43,560
E agora o que dizer de tudo isso, o 123, o 124 eo 1?

843
00:53:43,560 --> 00:53:47,910
Assim que retorna de swap, essa memória é tão bom como perdido

844
00:53:47,910 --> 00:53:51,070
porque assim como o retorno de swap, o sistema operacional

845
00:53:51,070 --> 00:53:54,190
é livre para usar a memória novamente no futuro.

846
00:53:54,190 --> 00:53:58,870
Apenas a memória principal, na parte inferior desta pilha de chamada varas em torno.

847
00:53:58,870 --> 00:54:01,470
>> E assim finalmente temos agora uma versão de trabalho.

848
00:54:01,470 --> 00:54:06,310
Deixe-me ir para swap.c, e observe o seguinte.

849
00:54:06,310 --> 00:54:11,280
No topo do programa que eu mudei o meu protótipo para ser int * a * b e int.

850
00:54:11,280 --> 00:54:15,000
Assim, a única coisa que mudou para ir de vermelho, o que foi ruim, para o verde, que é bom,

851
00:54:15,000 --> 00:54:17,350
é que eu adicionei estas estrelas de hoje.

852
00:54:17,350 --> 00:54:21,520
Mas, então, aqui no próprio swap eu tinha que copiar, colar o que era apenas no slide.

853
00:54:21,520 --> 00:54:24,140
Eu tenho uma estrela aqui, estrela aqui - que coincide com o protótipo -

854
00:54:24,140 --> 00:54:27,930
e depois de todas essas coisas agora tem estrelas, exceto para tmp

855
00:54:27,930 --> 00:54:30,680
porque o uso de uma variável temporária, não há nada de novo nisso.

856
00:54:30,680 --> 00:54:33,040
Eu só preciso de armazenamento temporário para um int.

857
00:54:33,040 --> 00:54:34,820
Então, nós não precisamos de uma estrela lá.

858
00:54:34,820 --> 00:54:39,310
Nós só precisamos de uma estrela, para que possamos atravessar esse tipo de limite arbitrário

859
00:54:39,310 --> 00:54:42,900
entre esses dois quadros na memória do meu computador.

860
00:54:42,900 --> 00:54:45,630
Mas uma última coisa que tem de mudar, e você pode ter vislumbrado já.

861
00:54:45,630 --> 00:54:48,810
O que outra linha é obviamente diferente agora? >> [Aluno] & x.

862
00:54:48,810 --> 00:54:53,270
>> Sim, então 25 é a última linha de código que eu preciso mudar para que isso funcione.

863
00:54:53,270 --> 00:54:58,360
Uma semana atrás, e até mesmo na segunda-feira da linha 25 ficou assim, trocar x e y,

864
00:54:58,360 --> 00:55:02,020
e este foi apenas quebrada porque se você diz swap (x, y)

865
00:55:02,020 --> 00:55:05,660
você está dando cópias de X e Y para trocar, então ele está fazendo a sua coisa,

866
00:55:05,660 --> 00:55:09,080
mas você nunca está realmente mudando x e y si.

867
00:55:09,080 --> 00:55:12,880
Assim, mesmo se você nunca viu esse personagem antes com o comercial no código,

868
00:55:12,880 --> 00:55:15,860
apenas dar um palpite. O que faz o comercial fazer, aparentemente?

869
00:55:15,860 --> 00:55:17,890
[Aluno] É de endereço. >> Toma o endereço.

870
00:55:17,890 --> 00:55:21,160
Assim, o comercial está dizendo me dar o endereço de x.

871
00:55:21,160 --> 00:55:25,590
Quem sabe onde é? Ele passa a ser 123. Eu não me importo. Apenas me dê o endereço de x.

872
00:55:25,590 --> 00:55:28,340
& Y significa dar-me o endereço de y.

873
00:55:28,340 --> 00:55:34,450
E nesse ponto a história é perfeitamente consistente com a imagem que desenhou um momento atrás.

874
00:55:34,450 --> 00:55:38,310
>> Então, eu vou admitir ponteiros, certamente para mim, quando eu comecei a aprender isso,

875
00:55:38,310 --> 00:55:40,570
foram definitivamente uma das coisas mais difíceis de envolver minha mente.

876
00:55:40,570 --> 00:55:43,760
Mas perceber, especialmente à medida que continuar a jogar com esses tipos de coisas,

877
00:55:43,760 --> 00:55:48,030
se você decompô-lo para este tipo super simples de intelectualmente desinteressante problemas

878
00:55:48,030 --> 00:55:52,270
de apenas se movendo em torno de números, a resposta a uma grande confusão com ponteiros

879
00:55:52,270 --> 00:55:56,590
realmente pode ser obtido a partir destes mecânica muito básicas.

880
00:55:56,590 --> 00:55:59,070
Aqui está um endereço. Vá com a estrela.

881
00:55:59,070 --> 00:56:03,830
Ou, inversamente, aqui está um e comercial. Descobrir o que o endereço realmente é.

882
00:56:03,830 --> 00:56:06,270
Tudo bem.

883
00:56:06,270 --> 00:56:09,000
Então, onde está toda essa memória vem?

884
00:56:09,000 --> 00:56:12,360
Nós colocamos esta imagem de um par de vezes, e eu continuo promissor vamos voltar a ele,

885
00:56:12,360 --> 00:56:14,920
mas aqui é a representação da memória do seu computador

886
00:56:14,920 --> 00:56:17,420
que é um pouco mais marcado do que o nosso quadro aqui é.

887
00:56:17,420 --> 00:56:21,590
O segmento de texto na parte superior representa o que diz respeito ao seu programa?

888
00:56:21,590 --> 00:56:26,090
[Resposta do aluno inaudível] >> Desculpa? Diga novamente.

889
00:56:26,090 --> 00:56:28,660
[Aluno] O programa real. O programa >> real.

890
00:56:28,660 --> 00:56:32,430
>> Assim, o Clang 0s e 1s que você tenha compilado depois de escrever código C e em seguida, executando

891
00:56:32,430 --> 00:56:35,910
e gerando extremidades 0s e 1s por ficar escondido lá na memória

892
00:56:35,910 --> 00:56:38,570
porque quando você duplo clique em um ícone no seu Mac ou PC

893
00:56:38,570 --> 00:56:43,010
ou executar um comando como mario em seu prompt, seu 0s e 1s do disco

894
00:56:43,010 --> 00:56:45,700
são carregados na memória para que o computador possa manipulá-los

895
00:56:45,700 --> 00:56:47,540
e executá-los mais rapidamente.

896
00:56:47,540 --> 00:56:50,880
Dados para inicializados e os dados não inicializados, não vamos falar muito sobre aqueles,

897
00:56:50,880 --> 00:56:52,420
mas essas são apenas variáveis ​​globais.

898
00:56:52,420 --> 00:56:54,710
Inicializado significa variáveis ​​globais que você deu valores para;

899
00:56:54,710 --> 00:56:59,300
não inicializado significa variáveis ​​globais que você ainda não dão valores para.

900
00:56:59,300 --> 00:57:01,900
Depois, há as variáveis ​​de ambiente que eu vou completamente a minha mão a onda,

901
00:57:01,900 --> 00:57:04,860
mas eles estão lá e que armazena coisas como seu nome de usuário

902
00:57:04,860 --> 00:57:08,090
e outro tipo de detalhes de nível inferior.

903
00:57:08,090 --> 00:57:12,880
Mas os mais suculentos pedaços de layout de sua memória é essa coisa chamada a pilha eo heap.

904
00:57:12,880 --> 00:57:17,470
A pilha de novo, para ser claro, é a memória que é usada sempre que funções são chamadas,

905
00:57:17,470 --> 00:57:19,710
sempre que houver variáveis ​​locais

906
00:57:19,710 --> 00:57:22,120
e sempre que há parâmetros que estão sendo repassados.

907
00:57:22,120 --> 00:57:24,490
Tudo o que acontece na pilha.

908
00:57:24,490 --> 00:57:29,570
A pilha não temos falado, mas dar um palpite que usa a pilha.

909
00:57:31,120 --> 00:57:32,690
Apenas um pedaço diferente de memória.

910
00:57:32,690 --> 00:57:36,620
Ele passa a ser feita aqui em cima, mas isso é uma convenção arbitrária pictórica.

911
00:57:36,620 --> 00:57:41,670
Que aparentemente estava usando a memória da pilha de semana?

912
00:57:41,670 --> 00:57:44,830
É tecnicamente você, mas indiretamente. >> [Aluno] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString e malloc. Então aqui está a diferença fundamental.

914
00:57:47,950 --> 00:57:51,300
>> Você sabe para as últimas semanas que, se você precisa de memória, basta declarar uma variável.

915
00:57:51,300 --> 00:57:54,560
Se você precisa de muita memória, declarar uma matriz direito dentro de sua função.

916
00:57:54,560 --> 00:57:59,620
Mas o problema que nós enfrentamos é mantido se você declarar variáveis ​​locais dentro de funções,

917
00:57:59,620 --> 00:58:05,340
logo que o retorno da função, o que acontece com a memória e aquelas variáveis?

918
00:58:05,340 --> 00:58:09,620
Apenas o tipo de que não é mais seu, certo? Ele simplesmente desaparece tipo de conceitualmente.

919
00:58:09,620 --> 00:58:13,950
Ainda é fisicamente lá, obviamente, mas ele não é mais o seu direito de uso.

920
00:58:13,950 --> 00:58:17,160
Esta é, obviamente, um problema se você quiser escrever funções na vida

921
00:58:17,160 --> 00:58:20,440
que realmente alocar memória e não devolvê-lo imediatamente.

922
00:58:20,440 --> 00:58:24,180
Caso em questão: GetString propósito na vida é não ter idéia de antecedência

923
00:58:24,180 --> 00:58:26,390
como grande de uma corda Eu vou digitar no teclado,

924
00:58:26,390 --> 00:58:30,390
mas ele tem que ser capaz de alocar memória para armazenar David ou Olá

925
00:58:30,390 --> 00:58:32,860
ou ensaio um todo que o usuário pode ter digitado dentro

926
00:58:32,860 --> 00:58:35,280
Então GetString vem usando malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc, portanto, não deve estar usando a pilha;

928
00:58:38,910 --> 00:58:40,770
em vez disso, está usando essa coisa chamada heap.

929
00:58:40,770 --> 00:58:44,430
Não há nada diferente sobre a memória. Não é mais rápido ou mais lento ou qualquer coisa assim.

930
00:58:44,430 --> 00:58:46,570
É apenas fisicamente em um local diferente.

931
00:58:46,570 --> 00:58:50,120
>> Mas a regra é que a memória que está alocada na pilha

932
00:58:50,120 --> 00:58:56,180
nunca ser tirado de você até que você chamar - dar um palpite - livre.

933
00:58:56,180 --> 00:59:00,510
Por outro lado, qualquer memória que você pedir na pilha por apenas declarar uma matriz

934
00:59:00,510 --> 00:59:03,320
ou declarar uma variável como temos vindo a fazer para a semana,

935
00:59:03,320 --> 00:59:05,640
que, por padrão acaba na pilha.

936
00:59:05,640 --> 00:59:09,550
E que funciona 90% grande parte do tempo, mas nessas ocasiões mais raras

937
00:59:09,550 --> 00:59:12,470
onde você quer alocar memória e mantê-lo por perto,

938
00:59:12,470 --> 00:59:14,730
então você precisa usar uma função como malloc.

939
00:59:14,730 --> 00:59:19,370
Ou nós usamos uma função como GetString, que por sua vez usa malloc.

940
00:59:19,370 --> 00:59:23,300
Vamos ver onde isso pode quebrar e, em seguida, dar uma olhada no Binky.

941
00:59:23,300 --> 00:59:25,820
Nós vamos voltar a isso no futuro.

942
00:59:25,820 --> 00:59:29,270
Aqui está um programa super simples que nos primeiros 2 linhas faz o quê?

943
00:59:29,270 --> 00:59:33,460
Em Inglês, o que essas 2 primeiras linhas de código fazer dentro de principal?

944
00:59:33,460 --> 00:59:35,600
[Resposta do aluno inaudível]

945
00:59:35,600 --> 00:59:37,880
Cuidado. Ele não me dá o endereço de x ou y.

946
00:59:37,880 --> 00:59:41,840
[Estudante] dá ponteiros para ints. >> Boa. Dê-me dois ponteiros para inteiros.

947
00:59:41,840 --> 00:59:45,130
Em outras palavras, dá-me dois pedaços de memória que guardo desenho de hoje,

948
00:59:45,130 --> 00:59:46,950
mesmo que eu apaguei-o agora, como quadrados.

949
00:59:46,950 --> 00:59:50,000
Dê-me dois pedaços de memória, um chamado x, y um chamado -

950
00:59:50,000 --> 00:59:54,320
antes eu chamava S e T - e qual é o tipo de que pedaço da memória?

951
00:59:54,320 --> 00:59:57,160
Vai para armazenar um endereço.

952
00:59:57,160 --> 00:59:59,110
É de * tipo int.

953
00:59:59,110 --> 01:00:01,630
>> Assim, o endereço de um int irá eventualmente vivem em x,

954
01:00:01,630 --> 01:00:03,860
o endereço de um int acabará por viver em y,

955
01:00:03,860 --> 01:00:08,460
mas, inicialmente, o que está dentro de X e Y? Quem sabe? Valores de lixo.

956
01:00:08,460 --> 01:00:10,180
Não tem nada a ver com ponteiros.

957
01:00:10,180 --> 01:00:12,720
Se não colocar alguma coisa lá, quem sabe o que realmente está lá?

958
01:00:12,720 --> 01:00:18,950
Agora, x. O que acontece aqui? Isso é legal agora porque x é um ponteiro. É um int *.

959
01:00:18,950 --> 01:00:21,870
Então isso significa que eu posso colocar em x o endereço de algum pedaço de memória.

960
01:00:21,870 --> 01:00:25,120
O que malloc retornar? Perfeito, ele retorna endereços,

961
01:00:25,120 --> 01:00:28,510
o endereço do primeiro byte de um bloco inteiro de memória.

962
01:00:28,510 --> 01:00:31,140
Quantos bytes é o que parece atribuir, por exemplo, no interior do aparelho?

963
01:00:31,140 --> 01:00:33,510
Qual é o tamanho de um int? 4.

964
01:00:33,510 --> 01:00:36,600
Se você acha que volta para uma semana, não é super importante sempre lembrar que,

965
01:00:36,600 --> 01:00:38,870
mas, neste caso, é útil saber, 4 bytes.

966
01:00:38,870 --> 01:00:41,770
Portanto, este é alocar na pilha 4 bytes

967
01:00:41,770 --> 01:00:46,110
e é o endereço de retorno da primeira para me arbitrariamente.

968
01:00:46,110 --> 01:00:47,700
Agora, o que está fazendo x?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 está fazendo o que?

970
01:00:52,200 --> 01:00:57,150
Se neste ponto da história que temos x, que se parece com isso com algum valor de lixo,

971
01:00:57,150 --> 01:01:04,120
este é agora y com algum valor de lixo, agora na linha 3 eu alocados 4 bytes.

972
01:01:04,120 --> 01:01:06,950
Esta imagem essencialmente parecido com este.

973
01:01:06,950 --> 01:01:12,010
Ou, mais especificamente, se esta é arbitrária endereço 123, isso é o que a nossa história agora parece.

974
01:01:12,010 --> 01:01:23,940
* X = 42 agora significa o quê? Isso significa ir para o endereço 123 e colocar o número 42 lá.

975
01:01:23,940 --> 01:01:26,220
Eu não preciso chamar a estas linhas, porque nós não estamos fazendo cordas.

976
01:01:26,220 --> 01:01:29,480
>> Eu deveria ter escrito assim, e apenas por causa da manifestação, o

977
01:01:29,480 --> 01:01:33,240
42 como uma espécie de int ocupa muito espaço, 4 bytes.

978
01:01:33,240 --> 01:01:35,960
Então, isso é o que aconteceu lá, mas há um problema agora.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. O que vai acontecer aqui?

980
01:01:40,580 --> 01:01:46,470
O problema é * y em nosso mundo simplificado significa apenas ir para o endereço em y.

981
01:01:46,470 --> 01:01:48,590
O que está em y? É algum valor lixo.

982
01:01:48,590 --> 01:01:53,150
Então, vamos supor que esse valor de lixo é 5551212, algo louco assim.

983
01:01:53,150 --> 01:01:56,750
Meio * y ir para abordar 5551212.

984
01:01:56,750 --> 01:02:00,450
Isso é como aqui. Não existe, por exemplo.

985
01:02:00,450 --> 01:02:05,310
Então * y recebe 13 significa que eu estou tentando tirar 13 aqui. Ele não existe.

986
01:02:05,310 --> 01:02:08,790
Eu já excedeu o segmento do quadro negro. O que eu ganho?

987
01:02:08,790 --> 01:02:14,930
Essa falha de segmentação enigmática mensagem porque eu estou tentando colocar na memória

988
01:02:14,930 --> 01:02:19,470
um valor como 13 em um lugar que não existe.

989
01:02:19,470 --> 01:02:23,900
O resto do programa pode funcionar bem, mas até que ponto isso não acontece.

990
01:02:23,900 --> 01:02:25,350
Então, vamos tentar contar essa história.

991
01:02:25,350 --> 01:02:27,830
Nós vamos voltar para que, uma vez que falamos de feitiço.

992
01:02:27,830 --> 01:02:30,290
Vamos voltar a este e concluir com essa coisa chamada Binky,

993
01:02:30,290 --> 01:02:33,710
que recall é um professor de Stanford sentado em casa brincando com claymation,

994
01:02:33,710 --> 01:02:36,380
para contar a história exatamente do programa que mesmo.

995
01:02:36,380 --> 01:02:40,580
É apenas cerca de 3 minutos de duração. Aqui temos Binky.

996
01:02:40,580 --> 01:02:45,030
[Orador masculino em vídeo] Hey Binky, acorda. É hora de diversão ponteiro.

997
01:02:45,030 --> 01:02:50,080
[Binky] O que é isso? Saiba mais sobre ponteiros? Ah, bom!

998
01:02:50,080 --> 01:02:53,700
[Orador masculino] Bem, para começar, eu acho que nós vamos precisar de um par de ponteiros.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Okay. Este código aloca dois ponteiros que podem apontar para números inteiros.

1000
01:02:57,890 --> 01:03:02,220
[Orador masculino] Okay. Bem, eu vejo os dois ponteiros, mas eles não parecem estar apontando para qualquer coisa.

1001
01:03:02,220 --> 01:03:05,550
[Binky] Isso mesmo. Inicialmente, os ponteiros não apontam para nada.

1002
01:03:05,550 --> 01:03:09,270
As coisas que eles apontam são chamados pointees, e configurá-los é um passo separado.

1003
01:03:09,270 --> 01:03:12,330
[Orador masculino] Ah, certo, certo. Eu sabia disso. Os pointees são separados.

1004
01:03:12,330 --> 01:03:15,630
Er, assim como você alocar um pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Okay. Este código aloca um novo pointee inteiro, e esta parte define x para apontar para ele.

1006
01:03:21,510 --> 01:03:23,500
[Orador masculino] Ei, isso parece melhor.

1007
01:03:23,500 --> 01:03:26,030
Então ele fazer alguma coisa. >> [Binky] Okay.

1008
01:03:26,030 --> 01:03:30,300
Vou cancelar o ponteiro x para armazenar o número 42 em sua pointee.

1009
01:03:30,300 --> 01:03:34,410
Para este truque eu preciso da minha varinha mágica da dereferencing.

1010
01:03:34,410 --> 01:03:38,610
[Orador masculino] Sua varinha mágica de dereferencing? Isso é ótimo.

1011
01:03:38,610 --> 01:03:44,230
[Binky] Isto é o que o código parece. Eu só vou definir o número e ... [Estalando som]

1012
01:03:44,230 --> 01:03:46,100
[Orador masculino] Ei, olha, lá vai.

1013
01:03:46,100 --> 01:03:50,990
Então, fazendo um dereference em x segue a seta para acessar sua pointee,

1014
01:03:50,990 --> 01:03:53,230
neste caso para armazenar 42 em ali.

1015
01:03:53,230 --> 01:03:57,630
Ei, tente usá-lo para armazenar o número 13 até o outro ponteiro, y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Okay. Eu vou passar por cima aqui para y e obter o número 13 configurar

1017
01:04:03,250 --> 01:04:08,360
e depois tome a varinha de dereferencing e só ... [Zumbido] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[Orador masculino] Oh, hey, isso não funcionou.

1019
01:04:10,980 --> 01:04:14,870
>> Diga, Binky, eu não acho que dereferencing y é uma boa idéia

1020
01:04:14,870 --> 01:04:17,880
que a configuração da pointee é uma etapa separada

1021
01:04:17,880 --> 01:04:19,850
e eu não acho que já fiz isso.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, bom ponto.

1023
01:04:21,770 --> 01:04:26,640
[Orador masculino] Yeah. Alocamos o ponteiro y mas nunca configurá-lo para apontar para uma pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, muito observador.

1025
01:04:28,780 --> 01:04:30,690
[Orador masculino] Ei, você está parecendo boa lá, Binky.

1026
01:04:30,690 --> 01:04:34,160
Você pode corrigi-lo, de modo que y aponta para o pointee mesmo que x? >> [Binky] Claro.

1027
01:04:34,160 --> 01:04:37,100
Eu vou usar a minha varinha mágica da atribuição de ponteiro.

1028
01:04:37,100 --> 01:04:39,070
[Orador masculino] é que vai ser um problema como antes?

1029
01:04:39,070 --> 01:04:40,840
[Binky] Não, isso não toque nos pointees.

1030
01:04:40,840 --> 01:04:44,780
Apenas muda um ponteiro para apontar para a mesma coisa que o outro. [Estalando som]

1031
01:04:44,780 --> 01:04:48,570
[Orador masculino] Oh, eu vejo. Agora y aponta para o mesmo lugar que x.

1032
01:04:48,570 --> 01:04:51,140
Então, espere. Agora y é fixo. Tem um pointee.

1033
01:04:51,140 --> 01:04:54,520
Então você pode tentar a varinha de dereferencing novamente para enviar a mais de 13.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, tudo bem. Aqui vai. [Estalando som]

1035
01:04:58,130 --> 01:05:01,250
[Orador masculino] Ei, olha isso. Agora dereferencing obras sobre y.

1036
01:05:01,250 --> 01:05:05,200
E porque os ponteiros estão a partilhar que pointee um, ambos ver o 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] Sim, partilha. Qualquer que seja.

1038
01:05:06,910 --> 01:05:08,880
>> Então, vamos trocar de lugar agora?

1039
01:05:08,880 --> 01:05:11,420
[Orador masculino] Oh olha, nós estamos fora do tempo. >> [Binky] Mas -

1040
01:05:11,420 --> 01:05:13,880
[Orador masculino] Basta lembrar as três regras de ponteiro.

1041
01:05:13,880 --> 01:05:18,630
Número 1, a estrutura básica é que você tem um ponteiro que aponta mais para um pointee.

1042
01:05:18,630 --> 01:05:23,120
Mas o ponteiro e pointee são separados, e do erro comum é a criação de um ponteiro

1043
01:05:23,120 --> 01:05:25,680
mas esquecer-se de dar-lhe um pointee.

1044
01:05:25,680 --> 01:05:29,580
Número 2, dereferencing ponteiro começa no ponteiro e segue sua seta sobre

1045
01:05:29,580 --> 01:05:31,060
para acessar sua pointee.

1046
01:05:31,060 --> 01:05:34,340
Como todos sabemos, isso só funciona se houver um pointee,

1047
01:05:34,340 --> 01:05:36,460
que tipo de voltar a governar o número 1.

1048
01:05:36,460 --> 01:05:39,870
Número 3, a atribuição de um ponteiro ponteiro assume e muda-

1049
01:05:39,870 --> 01:05:42,390
para apontar para o mesmo pointee outro ponteiro.

1050
01:05:42,390 --> 01:05:45,890
Assim, após a atribuição, os dois ponteiros apontam para o pointee mesmo.

1051
01:05:45,890 --> 01:05:47,800
Às vezes isso é chamado de partilha.

1052
01:05:47,800 --> 01:05:50,910
>> E isso é tudo o que há para realmente. Bye-bye agora.

1053
01:05:50,910 --> 01:05:55,840
Este é Binky. Este é CS50. Vamos ver na próxima semana. [Aplausos]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]