1
00:00:00,000 --> 00:00:02,420
>> [Música tocando]

2
00:00:02,420 --> 00:00:05,189

3
00:00:05,189 --> 00:00:05,980
COLUNA: Tudo bem.

4
00:00:05,980 --> 00:00:08,540
Então, vamos falar de outro
coisa que é meio único para C,

5
00:00:08,540 --> 00:00:10,010
que é tipos de dados e variáveis.

6
00:00:10,010 --> 00:00:12,340
Quando eu digo exclusivo para C, eu realmente
significa apenas no contexto de,

7
00:00:12,340 --> 00:00:14,470
se você foi um programador
por muito tempo,

8
00:00:14,470 --> 00:00:16,270
você provavelmente não tenho
trabalhou com os tipos de dados

9
00:00:16,270 --> 00:00:18,470
se você já usou moderno
linguagens de programação.

10
00:00:18,470 --> 00:00:20,432
Linguagens modernas como
PHP e JavaScript,

11
00:00:20,432 --> 00:00:22,640
que nós também vamos ver um pouco
mais tarde no curso,

12
00:00:22,640 --> 00:00:25,550
na verdade você não tem que especificar
o tipo de uma variável de dados

13
00:00:25,550 --> 00:00:26,270
quando você usá-lo.

14
00:00:26,270 --> 00:00:28,067
>> Você só declará-lo e começar a usá-lo.

15
00:00:28,067 --> 00:00:29,900
Se for um número inteiro,
sei que é um inteiro.

16
00:00:29,900 --> 00:00:31,960
Se ele é um personagem, é
sabe que é um personagem.

17
00:00:31,960 --> 00:00:35,320
Se é uma palavra, ele sabe
é uma string, assim chamada.

18
00:00:35,320 --> 00:00:37,300
>> Mas em C, que é uma
linguagem mais antiga, precisamos

19
00:00:37,300 --> 00:00:39,420
para especificar os dados
tipo de cada variável

20
00:00:39,420 --> 00:00:42,990
que criamos pela primeira vez
que usamos essa variável.

21
00:00:42,990 --> 00:00:45,030
Então C vem com alguns
built-in tipos de dados.

22
00:00:45,030 --> 00:00:46,972
E vamos começar familiar
com algumas delas.

23
00:00:46,972 --> 00:00:50,180
E então depois vamos também falar um
pouco sobre alguns dos tipos de dados

24
00:00:50,180 --> 00:00:54,450
que nós escrevemos para você,
para que você possa usá-los em CS50.

25
00:00:54,450 --> 00:00:56,130
>> O primeiro é int.

26
00:00:56,130 --> 00:00:59,110
O tipo de dados int é usada para variáveis
que irá armazenar valores inteiros.

27
00:00:59,110 --> 00:01:03,210
Assim, 1, 2, 3, negativo 1, 2, 3, e assim por diante.

28
00:01:03,210 --> 00:01:05,960
Inteiros, o que é algo que você
deve ter em mente para o teste,

29
00:01:05,960 --> 00:01:09,590
sempre levar até quatro bytes
da memória, que é de 32 bits.

30
00:01:09,590 --> 00:01:11,620
Há oito bits em um byte.

31
00:01:11,620 --> 00:01:14,470
>> Assim, isto significa que o intervalo de
Valores que pode armazenar um número inteiro

32
00:01:14,470 --> 00:01:19,130
é limitado pelo que pode se encaixar dentro
32 bits no valor de informação.

33
00:01:19,130 --> 00:01:21,850
Agora, como se vê,
foi há muito tempo decidiu

34
00:01:21,850 --> 00:01:24,310
que iríamos dividir
que gama de 32 bits

35
00:01:24,310 --> 00:01:26,650
em inteiros negativos
e inteiros positivos,

36
00:01:26,650 --> 00:01:28,390
ficando cada metade do intervalo.

37
00:01:28,390 --> 00:01:32,230
Assim, a gama de valores que representam
com um intervalo inteiro de negativo 2

38
00:01:32,230 --> 00:01:36,520
à potência 31 para 2 a
o poder 31 menos 1,

39
00:01:36,520 --> 00:01:38,190
fazer com que você também precisa de um local para 0.

40
00:01:38,190 --> 00:01:41,650
>> Então, basicamente a metade dos valores possíveis
você pode caber em um int são negativos,

41
00:01:41,650 --> 00:01:42,610
e metade são positivos.

42
00:01:42,610 --> 00:01:47,270
E mais ou menos aqui, trata-se negativa
2 bilhões para cerca de 2 bilhões positivo.

43
00:01:47,270 --> 00:01:50,207
Dar ou tomar algumas centenas de milhões.

44
00:01:50,207 --> 00:01:52,290
Então é isso que você pode caber
em uma variável inteiro.

45
00:01:52,290 --> 00:01:55,490
Agora nós também temos algo
chamado um inteiro sem sinal.

46
00:01:55,490 --> 00:01:59,220
Agora ints não assinados não são um
tipo separado de variável.

47
00:01:59,220 --> 00:02:01,590
Pelo contrário, sem sinal é
o que é chamado um qualificador.

48
00:02:01,590 --> 00:02:04,990
Ele modifica os dados
tipo de inteiro ligeiramente.

49
00:02:04,990 --> 00:02:07,850
>> E, neste caso, o que não assinado
means-- e você também pode

50
00:02:07,850 --> 00:02:11,530
usar não assinados outros tipos de dados,
integer não é o único.

51
00:02:11,530 --> 00:02:15,310
O que ele efetivamente faz é duplos
a gama de valores positivos

52
00:02:15,310 --> 00:02:19,350
um inteiro que pode assumir a
à custa de não permitindo

53
00:02:19,350 --> 00:02:21,140
você para assumir valores negativos.

54
00:02:21,140 --> 00:02:25,400
Então se você tem números que você conhece
vai ficar maior do que 2 bilhões, mas menos

55
00:02:25,400 --> 00:02:31,280
de 4 bilhões, para example--
que é de 2 a 32 power--

56
00:02:31,280 --> 00:02:33,330
você pode querer usar
um unsigned int se

57
00:02:33,330 --> 00:02:35,050
conhecer o seu valor nunca será negativo.

58
00:02:35,050 --> 00:02:37,216
>> Ocasionalmente você vai ter
usado para variáveis ​​não assinados

59
00:02:37,216 --> 00:02:39,460
em CS50, que é por isso que eu mencioná-lo aqui.

60
00:02:39,460 --> 00:02:43,830
Mas, novamente, a gama de valores que você
pode representar com um inteiro sem sinal

61
00:02:43,830 --> 00:02:48,240
como a t inteiro regulares, são 0
a 2 à potência de menos de 1 32,

62
00:02:48,240 --> 00:02:50,840
ou aproximadamente 0 a 4 bilhões.

63
00:02:50,840 --> 00:02:53,730
Então você efetivamente dobrou o
faixa positiva que você pode caber,

64
00:02:53,730 --> 00:02:56,270
mas você desistiu tudo
os valores negativos.

65
00:02:56,270 --> 00:03:00,040
>> Agora, como um aparte, sem assinatura
Não é o único qualificador

66
00:03:00,040 --> 00:03:01,790
para que possamos ver para
tipos de dados variáveis.

67
00:03:01,790 --> 00:03:05,779
Há também coisas chamadas
curto e longo e const.

68
00:03:05,779 --> 00:03:07,820
Const vamos ver um pouco
pouco mais tarde no curso.

69
00:03:07,820 --> 00:03:10,830
Curto e longo, nós provavelmente não irá.

70
00:03:10,830 --> 00:03:12,830
>> Mas só sei que há
são outros qualificadores.

71
00:03:12,830 --> 00:03:14,080
Sem sinal não é o único.

72
00:03:14,080 --> 00:03:16,596
Mas é o único que está
vai falar sobre agora.

73
00:03:16,596 --> 00:03:17,310
Então tudo bem.

74
00:03:17,310 --> 00:03:18,393
Então, nós cobrimos inteiros.

75
00:03:18,393 --> 00:03:19,200
Qual é o próximo?

76
00:03:19,200 --> 00:03:20,130
>> Chars.

77
00:03:20,130 --> 00:03:23,620
Assim caracteres são usados ​​para variáveis
que irá armazenar caracteres simples.

78
00:03:23,620 --> 00:03:24,850
Char é curto para o personagem.

79
00:03:24,850 --> 00:03:27,870
E às vezes você pode ouvir
pessoas pronunciá-lo como carro.

80
00:03:27,870 --> 00:03:32,020
>> Então personagens sempre ocupam um
byte de memória, que fica a apenas 8 bits.

81
00:03:32,020 --> 00:03:35,700
Então isso significa que eles só podem caber
valores na gama de 2 negativo

82
00:03:35,700 --> 00:03:42,430
para a sétima potência, ou negativo 128,
a 2 para o 7 de potência menos 1, ou 127.

83
00:03:42,430 --> 00:03:45,710
>> Graças a ASCII, foi
há muito tempo decidiu de forma

84
00:03:45,710 --> 00:03:50,805
para mapear os números de positivos
0 a 127 para vários personagens

85
00:03:50,805 --> 00:03:52,182
que existem em todo o nosso teclado.

86
00:03:52,182 --> 00:03:54,640
Então, como veremos mais tarde, em
o curso, e você, provavelmente,

87
00:03:54,640 --> 00:03:57,700
vir a memorizar em algum
ponto, o capital A, para example--

88
00:03:57,700 --> 00:04:00,732
a capital caráter A--
mapeia para o número 65.

89
00:04:00,732 --> 00:04:02,940
E a razão para isso é
porque é o que é que é

90
00:04:02,940 --> 00:04:05,490
sido atribuído pela norma ASCII.

91
00:04:05,490 --> 00:04:07,850
>> Minúsculas A é 97.

92
00:04:07,850 --> 00:04:11,900
O caractere 0 para quando você
realmente digitar o caractere, não

93
00:04:11,900 --> 00:04:13,532
representa o número zero, é 48.

94
00:04:13,532 --> 00:04:15,240
Você vai aprender um casal
desses que você vá.

95
00:04:15,240 --> 00:04:17,990
E você vai certamente vir a precisar
-los um pouco mais tarde na CS50.

96
00:04:17,990 --> 00:04:20,450

97
00:04:20,450 --> 00:04:23,390
>> O próximo grande tipo de dados
É números de ponto flutuante.

98
00:04:23,390 --> 00:04:26,100
Então, números de ponto flutuante são
também conhecido como números reais.

99
00:04:26,100 --> 00:04:28,850
Eles são basicamente números que
ter um ponto decimal neles.

100
00:04:28,850 --> 00:04:33,360
Valores de ponto flutuante
como inteiros são também

101
00:04:33,360 --> 00:04:36,090
contidos 4 bytes de memória.

102
00:04:36,090 --> 00:04:37,580
Agora não há nenhuma carta aqui.

103
00:04:37,580 --> 00:04:40,890
Não há nenhuma linha de número, porque
que descreve a gama de um flutuador

104
00:04:40,890 --> 00:04:44,550
não é exatamente clara ou intuitiva.

105
00:04:44,550 --> 00:04:47,350
>> Basta dizer que você
ter 32 bits para trabalhar.

106
00:04:47,350 --> 00:04:49,730
E se você tem um número
como pi, que tem

107
00:04:49,730 --> 00:04:55,510
uma parte inteira 3, e uma flutuante
parte ponto, ou parte decimal 0,14159,

108
00:04:55,510 --> 00:04:58,735
e assim por diante, você precisa ser
capaz de representar todos ele--

109
00:04:58,735 --> 00:05:02,420
a parte inteira ea parte decimal.

110
00:05:02,420 --> 00:05:04,550
>> Então, o que você acha que isso pode significar?

111
00:05:04,550 --> 00:05:08,180
Uma coisa é que, se o decimal
parte fica mais e mais,

112
00:05:08,180 --> 00:05:10,660
se eu tenho um muito grande
parte inteira, eu não poderia

113
00:05:10,660 --> 00:05:13,090
ser capaz de ser tão precisa
com a parte decimal.

114
00:05:13,090 --> 00:05:15,280
E isso é realmente o
limitação de um float.

115
00:05:15,280 --> 00:05:17,229
>> Flutuadores têm um problema de precisão.

116
00:05:17,229 --> 00:05:19,270
Nós temos somente 32 bits para
trabalhar, por isso só podemos

117
00:05:19,270 --> 00:05:22,510
ser tão precisos com a nossa parte decimal.

118
00:05:22,510 --> 00:05:27,300
Nós não podemos ter necessariamente um decimal
parte preciso para 100 ou 200 dígitos,

119
00:05:27,300 --> 00:05:29,710
porque só temos
32 bits para trabalhar.

120
00:05:29,710 --> 00:05:31,590
Então essa é uma limitação de um float.

121
00:05:31,590 --> 00:05:33,590
>> Agora, felizmente, há
outro tipo de dados chamado

122
00:05:33,590 --> 00:05:36,530
duplo, que pouco
lida com este problema.

123
00:05:36,530 --> 00:05:39,980
Doubles, como carros alegóricos, também são usados ​​para
armazenar números reais ou ponto flutuante

124
00:05:39,980 --> 00:05:40,840
valores.

125
00:05:40,840 --> 00:05:44,340
A diferença é que
duplos são precisão dupla.

126
00:05:44,340 --> 00:05:48,177
Eles podem caber 64 bits de
dados ou oito bytes.

127
00:05:48,177 --> 00:05:49,010
O que isso significa?

128
00:05:49,010 --> 00:05:51,801
Bem, isso significa que podemos ser muito mais
preciso com o ponto decimal.

129
00:05:51,801 --> 00:05:54,830
Em vez de ter pi a sete
lugares talvez, com um flutuador,

130
00:05:54,830 --> 00:05:56,710
talvez possamos tê-lo para 30 lugares.

131
00:05:56,710 --> 00:05:59,824
Se isso é importante, você pode querer
a utilização de um casal em vez de uma bóia.

132
00:05:59,824 --> 00:06:01,740
Basicamente, se você estiver
trabalhando em qualquer coisa onde

133
00:06:01,740 --> 00:06:06,540
ter um tempo muito longo casa decimal
e muita precisão é importante,

134
00:06:06,540 --> 00:06:08,630
você provavelmente vai querer
usar um Overfloat dupla.

135
00:06:08,630 --> 00:06:11,250
Agora, para a maior parte de seu trabalho em
CS50, um flutuador deve ser suficiente.

136
00:06:11,250 --> 00:06:15,340
Mas sei que existem duplas como um
maneira de lidar com um pouco a precisão

137
00:06:15,340 --> 00:06:20,980
problema, dando-lhe um extra de 32
bits para trabalhar com para os seus números.

138
00:06:20,980 --> 00:06:23,650
>> Agora, isso não é um tipo de dados.

139
00:06:23,650 --> 00:06:24,390
Este é um tipo.

140
00:06:24,390 --> 00:06:25,340
E é chamado de vazio.

141
00:06:25,340 --> 00:06:27,506
E eu estou falando sobre isso
aqui, porque nós temos provavelmente

142
00:06:27,506 --> 00:06:29,520
visto que algumas vezes já em CS50.

143
00:06:29,520 --> 00:06:32,020
E você pode estar se perguntando
o que é toda sobre.

144
00:06:32,020 --> 00:06:33,390
>> Então vazio é um tipo.

145
00:06:33,390 --> 00:06:34,097
Ele existe.

146
00:06:34,097 --> 00:06:35,180
Mas isso não é um tipo de dados.

147
00:06:35,180 --> 00:06:39,350
>> Não podemos criar uma variável do tipo
anular e atribuir um valor a ela.

148
00:06:39,350 --> 00:06:42,519
Mas as funções, por exemplo,
pode ter um tipo de retorno void.

149
00:06:42,519 --> 00:06:45,060
Basicamente, se você vê uma função
que tem um tipo de retorno void,

150
00:06:45,060 --> 00:06:46,970
isso significa que ele não retorna um valor.

151
00:06:46,970 --> 00:06:49,440
Você pode pensar em um comum
função que usei até agora

152
00:06:49,440 --> 00:06:52,780
em CS50 que não retorna um valor?

153
00:06:52,780 --> 00:06:54,700
>> Printf é um deles.

154
00:06:54,700 --> 00:06:56,820
Printf na verdade não
retornar nada para você.

155
00:06:56,820 --> 00:06:59,850
Ela imprime algo para o
tela, e é, basicamente,

156
00:06:59,850 --> 00:07:01,650
um efeito colateral do que printf.

157
00:07:01,650 --> 00:07:03,620
Mas não dar-lhe um valor de volta.

158
00:07:03,620 --> 00:07:08,419
Você não capturar o resultado e armazenar
-lo de alguma variável para usá-lo mais tarde.

159
00:07:08,419 --> 00:07:10,710
Ele só imprime algo para
a tela e você está feito.

160
00:07:10,710 --> 00:07:14,360
>> Assim, dizemos que printf
é uma função nula.

161
00:07:14,360 --> 00:07:16,450
Ele retorna nada.

162
00:07:16,450 --> 00:07:18,580
>> A lista perímetro de um
função também pode ser nulo.

163
00:07:18,580 --> 00:07:21,410
E você também vi que
um pouco em CS50 também.

164
00:07:21,410 --> 00:07:22,300
Void main Int.

165
00:07:22,300 --> 00:07:23,260
Será que isso soa um sino?

166
00:07:23,260 --> 00:07:24,080

167
00:07:24,080 --> 00:07:27,220
Basicamente o que isto significa é que
O principal não tomar quaisquer parâmetros.

168
00:07:27,220 --> 00:07:29,520
Não há nenhum argumento que
se passou para principal.

169
00:07:29,520 --> 00:07:32,780
Agora, mais tarde, vamos ver que há
uma maneira de passar argumentos em principal,

170
00:07:32,780 --> 00:07:36,189
mas até agora o que nós temos
vi é void main int.

171
00:07:36,189 --> 00:07:37,730
Principal apenas não toma nenhum argumento.

172
00:07:37,730 --> 00:07:40,236
E por isso, especificar que dizendo vazio.

173
00:07:40,236 --> 00:07:42,110
Nós apenas estamos sendo muito
explícita sobre o fato

174
00:07:42,110 --> 00:07:44,430
que ele não leva quaisquer argumentos.

175
00:07:44,430 --> 00:07:47,160
>> Então, por enquanto, é suficiente
dizer que basicamente vazio

176
00:07:47,160 --> 00:07:50,789
deve apenas servir como um espaço reservado
para você como pensar em como nada.

177
00:07:50,789 --> 00:07:52,080
Não está fazendo nada.

178
00:07:52,080 --> 00:07:53,550
Não há nenhum valor de retorno aqui.

179
00:07:53,550 --> 00:07:54,770
Não há parâmetros aqui.

180
00:07:54,770 --> 00:07:55,709
É nula.

181
00:07:55,709 --> 00:07:57,250
É um pouco mais complexo do que isso.

182
00:07:57,250 --> 00:08:00,640
Mas isso deve ser suficiente para
a melhor parte do curso.

183
00:08:00,640 --> 00:08:05,010
E espero que agora você tem um pouco
pouco mais de um conceito do que é vazio.

184
00:08:05,010 --> 00:08:08,460
>> Então esses são os cinco tipos você vai
encontro que são internos ao C.

185
00:08:08,460 --> 00:08:10,670
Mas em CS50 temos também uma biblioteca.

186
00:08:10,670 --> 00:08:13,550
CS50.h, que você pode incluir.

187
00:08:13,550 --> 00:08:15,930
E que irá fornecer-lhe
com dois tipos adicionais

188
00:08:15,930 --> 00:08:18,280
que você provavelmente vai ser capaz
para usar em suas atribuições,

189
00:08:18,280 --> 00:08:21,210
ou apenas trabalhando geral de programação.

190
00:08:21,210 --> 00:08:23,030
>> O primeiro destes é booleano.

191
00:08:23,030 --> 00:08:26,780
Assim, o tipo de dados booleano,
bool, é utilizado para variáveis

192
00:08:26,780 --> 00:08:28,114
que irá armazenar um valor booleano.

193
00:08:28,114 --> 00:08:29,863
Se você nunca ouviu falar
este termo antes, você

194
00:08:29,863 --> 00:08:31,960
pode saber que um booleano
valor é capaz de apenas

195
00:08:31,960 --> 00:08:34,440
segurando dois valores distintos diferentes.

196
00:08:34,440 --> 00:08:35,872
Verdadeiro e falso.

197
00:08:35,872 --> 00:08:37,580
Agora, isso parece bastante
fundamentais, certo?

198
00:08:37,580 --> 00:08:40,496
É uma espécie de uma surpresa que esta
não existe no C como é built-in.

199
00:08:40,496 --> 00:08:42,640
E em muitas línguas modernas,
é claro, Booleans

200
00:08:42,640 --> 00:08:45,390
são um tipo de dados padrão standard.

201
00:08:45,390 --> 00:08:47,192
Mas em C, eles realmente não são.

202
00:08:47,192 --> 00:08:48,400
Mas nós criamos isso para você.

203
00:08:48,400 --> 00:08:51,910
Então, se você precisar criar
uma variável cujo tipo é bool,

204
00:08:51,910 --> 00:08:55,230
apenas a certeza de #include CS50.h
no início de seu programa,

205
00:08:55,230 --> 00:08:57,800
e você vai ser capaz de criar
variáveis ​​do tipo bool.

206
00:08:57,800 --> 00:09:02,095
>> Se você esquecer de #include CS50.h, e
você começar a usar variáveis ​​do tipo Boolean,

207
00:09:02,095 --> 00:09:04,970
você pode encontrar alguns problemas
quando você está compilando seu programa.

208
00:09:04,970 --> 00:09:06,490
Então, ser apenas à procura de que.

209
00:09:06,490 --> 00:09:11,180
E talvez você pode apenas corrigir o
problemas por libra incluindo CS50.h.

210
00:09:11,180 --> 00:09:14,590
>> O outro grande tipo de dados que nós
fornecer para você na biblioteca CS50

211
00:09:14,590 --> 00:09:15,670
é string.

212
00:09:15,670 --> 00:09:17,130
Então, o que é uma cadeia?

213
00:09:17,130 --> 00:09:18,520
Strings são realmente apenas palavras.

214
00:09:18,520 --> 00:09:20,000
Eles são coleções de caracteres.

215
00:09:20,000 --> 00:09:20,640
Eles são palavras.

216
00:09:20,640 --> 00:09:21,390
Eles são frases.

217
00:09:21,390 --> 00:09:22,480
Eles são parágrafos.

218
00:09:22,480 --> 00:09:25,850
Pode ser livros inteiros, mesmo.

219
00:09:25,850 --> 00:09:29,690
>> Muito curto para muito longo
série de caracteres.

220
00:09:29,690 --> 00:09:34,310
Se você precisa usar cordas,
por exemplo, para armazenar uma palavra,

221
00:09:34,310 --> 00:09:37,609
só não se esqueça de incluir CS50.h
no início de seu programa

222
00:09:37,609 --> 00:09:38,900
assim você pode usar o tipo string.

223
00:09:38,900 --> 00:09:43,910
E então você pode criar variáveis
cujo tipo de dados é string.

224
00:09:43,910 --> 00:09:46,160
Agora mais tarde no curso,
nós também vamos ver que isso é

225
00:09:46,160 --> 00:09:47,752
não toda a história, qualquer um.

226
00:09:47,752 --> 00:09:49,460
Nós vamos encontrar coisas
estruturas, chamadas

227
00:09:49,460 --> 00:09:54,249
que permitem que você agrupe o que pode ser
um inteiro e uma corda em uma unidade.

228
00:09:54,249 --> 00:09:56,290
E podemos usar isso para
algum propósito, o que pode

229
00:09:56,290 --> 00:09:57,750
vir a calhar mais tarde no curso.

230
00:09:57,750 --> 00:09:59,500
>> E nós também vai aprender
sobre tipos definidos,

231
00:09:59,500 --> 00:10:01,720
que permitem que você crie
seus próprios tipos de dados.

232
00:10:01,720 --> 00:10:03,060
Nós não precisa se preocupar
sobre isso por enquanto.

233
00:10:03,060 --> 00:10:04,550
Mas só sei que isso é
algo sobre o horizonte,

234
00:10:04,550 --> 00:10:07,633
que há muito mais a este conjunto
Tipo de coisa do que eu estou dizendo a você apenas

235
00:10:07,633 --> 00:10:08,133
agora.

236
00:10:08,133 --> 00:10:10,591
Portanto, agora que aprendemos
pouco sobre os dados básicos

237
00:10:10,591 --> 00:10:14,230
tipos e os tipos de dados CS50, vamos
falar sobre como trabalhar com variáveis

238
00:10:14,230 --> 00:10:18,530
e criá-las usando estes
tipos de dados em nossos programas.

239
00:10:18,530 --> 00:10:22,670
Se você quiser criar uma variável,
tudo que você precisa fazer é duas coisas.

240
00:10:22,670 --> 00:10:24,147
>> Primeiro, você precisa dar-lhe um tipo.

241
00:10:24,147 --> 00:10:26,230
A segunda coisa que você precisa
a fazer é dar-lhe um nome.

242
00:10:26,230 --> 00:10:28,740
Uma vez que você tenha feito isso e bateu um
ponto e vírgula no final da linha,

243
00:10:28,740 --> 00:10:29,830
você criou uma variável.

244
00:10:29,830 --> 00:10:32,370
>> Então aqui está dois exemplos.

245
00:10:32,370 --> 00:10:35,744
Número Int; Char carta ;.

246
00:10:35,744 --> 00:10:36,660
O que eu fiz aqui?

247
00:10:36,660 --> 00:10:38,110
Eu criei duas variáveis.

248
00:10:38,110 --> 00:10:40,190
>> A primeira, a variável de
nome é número.

249
00:10:40,190 --> 00:10:44,830
E o número é capaz de manter inteiro
digite valores, porque seu tipo é int.

250
00:10:44,830 --> 00:10:48,040
Carta é outra variável
que pode conter caracteres

251
00:10:48,040 --> 00:10:50,240
porque seu tipo de dados é char.

252
00:10:50,240 --> 00:10:51,772
>> Bastante simples, certo?

253
00:10:51,772 --> 00:10:53,480
Se você se encontra
em uma situação onde

254
00:10:53,480 --> 00:10:56,250
você precisa criar múltiplos
variáveis ​​do mesmo tipo,

255
00:10:56,250 --> 00:10:58,740
você só precisa especificar
o nome do tipo uma vez.

256
00:10:58,740 --> 00:11:01,600
Em seguida, basta listar tantas variáveis
daquele tipo que você precisar.

257
00:11:01,600 --> 00:11:04,230
>> Então, eu poderia, por exemplo, aqui
nesta terceira linha de código,

258
00:11:04,230 --> 00:11:07,420
dizer altura int ;, nova linha.

259
00:11:07,420 --> 00:11:08,291
Int largura ;.

260
00:11:08,291 --> 00:11:09,290
E que iria trabalhar muito.

261
00:11:09,290 --> 00:11:12,039
Eu ainda sou chamado duas variáveis
altura e largura, cada uma das quais

262
00:11:12,039 --> 00:11:12,730
é um número inteiro.

263
00:11:12,730 --> 00:11:16,970
Mas eu estou autorizado a, coisas para C sintaxe,
consolidá-lo em uma única linha.

264
00:11:16,970 --> 00:11:20,230
Int altura, largura; É a mesma coisa.

265
00:11:20,230 --> 00:11:23,900
Eu criei duas variáveis, uma chamada
altura largura de um chamado, sendo que ambos

266
00:11:23,900 --> 00:11:26,730
são capazes de exploração
digite valores inteiros.

267
00:11:26,730 --> 00:11:30,920
>> Da mesma forma aqui, posso criar três
valores de ponto flutuante de uma vez.

268
00:11:30,920 --> 00:11:33,350
Talvez eu possa criar uma variável
chamado raiz quadrada de 2--

269
00:11:33,350 --> 00:11:35,766
que presumivelmente acabará
segure o ponto-- flutuante

270
00:11:35,766 --> 00:11:39,222
que a representação da praça
raiz de 2-- raiz quadrada de 3, e pi.

271
00:11:39,222 --> 00:11:41,180
Eu poderia ter feito isso
em três linhas separadas.

272
00:11:41,180 --> 00:11:47,690
Float, raiz quadrada 2; Float raiz quadrada
3; flutuar pi; e que iria trabalhar muito.

273
00:11:47,690 --> 00:11:50,590
>> Mas, novamente, eu posso apenas consolidar
isso em uma única linha de código.

274
00:11:50,590 --> 00:11:54,050
Torna as coisas um pouco
mais curto, não como desajeitado.

275
00:11:54,050 --> 00:11:57,259
>> Agora, em geral, é bom projeto apenas
declarar uma variável quando você precisar dele.

276
00:11:57,259 --> 00:11:59,050
E vamos falar um pouco
pouco mais sobre isso

277
00:11:59,050 --> 00:12:00,945
mais tarde no curso
quando discutimos escopo.

278
00:12:00,945 --> 00:12:03,320
Portanto, não precisa necessariamente
criar todas as suas variáveis

279
00:12:03,320 --> 00:12:05,990
no início do programa, o que
algumas pessoas podem ter feito no passado,

280
00:12:05,990 --> 00:12:08,700
ou foi, certamente, um muito comum
prática de codificação muitos anos atrás

281
00:12:08,700 --> 00:12:11,700
quando se trabalha com C. Você pôde apenas
quer criar um direito variável quando

282
00:12:11,700 --> 00:12:13,140
você precisa disso.

283
00:12:13,140 --> 00:12:13,640
Tudo certo.

284
00:12:13,640 --> 00:12:15,150
Então nós criamos variáveis.

285
00:12:15,150 --> 00:12:16,790
Como é que podemos usá-los?

286
00:12:16,790 --> 00:12:18,650
Depois de se declarar um
variável, não precisamos

287
00:12:18,650 --> 00:12:21,237
para especificar o tipo de dados
dessa variável mais.

288
00:12:21,237 --> 00:12:24,070
De fato, se você fizer isso, você pode
acabar com algumas consequências estranhas

289
00:12:24,070 --> 00:12:25,490
que vamos tipo de encobrir por enquanto.

290
00:12:25,490 --> 00:12:27,365
Mas basta dizer,
coisas estranhas vão

291
00:12:27,365 --> 00:12:30,740
começar a acontecer se você inadvertidamente
re-declarar variáveis ​​com o mesmo nome

292
00:12:30,740 --> 00:12:32,210
de novo e de novo.

293
00:12:32,210 --> 00:12:33,882
>> Então aqui eu tenho quatro linhas de código.

294
00:12:33,882 --> 00:12:36,090
E eu tenho um par de
Comentários Não apenas indicando

295
00:12:36,090 --> 00:12:37,840
o que está acontecendo em
cada linha apenas para ajudar

296
00:12:37,840 --> 00:12:40,520
você se situado em o que está acontecendo.

297
00:12:40,520 --> 00:12:41,520
Assim número int ;.

298
00:12:41,520 --> 00:12:42,520
Você viu que anteriormente.

299
00:12:42,520 --> 00:12:44,000
Essa é uma declaração de variável.

300
00:12:44,000 --> 00:12:46,670
>> Eu criei agora uma variável
isso é chamado de número

301
00:12:46,670 --> 00:12:48,970
capaz de manter valores de tipo inteiro.

302
00:12:48,970 --> 00:12:50,210
Eu já declarou ele.

303
00:12:50,210 --> 00:12:53,770
>> A próxima linha Eu estou atribuindo
um valor de número.

304
00:12:53,770 --> 00:12:54,992
Número é igual a 17.

305
00:12:54,992 --> 00:12:55,950
O que está acontecendo lá?

306
00:12:55,950 --> 00:12:58,880
Eu estou colocando o número 17
dentro dessa variável.

307
00:12:58,880 --> 00:13:02,760
>> Então, se eu nunca, em seguida, imprimir o que
o conteúdo do número são, mais tarde,

308
00:13:02,760 --> 00:13:04,030
eles vão me dizer que é 17.

309
00:13:04,030 --> 00:13:07,030
Então, eu tenho declarado uma variável,
e então eu tenho que lhe é atribuído.

310
00:13:07,030 --> 00:13:10,570
>> Podemos repetir o processo
novamente com o caractere carta ;.

311
00:13:10,570 --> 00:13:11,640
Essa é uma declaração.

312
00:13:11,640 --> 00:13:14,010
Carta de capital é igual a
H. Isso é uma atribuição.

313
00:13:14,010 --> 00:13:16,030
Bastante simples, também.

314
00:13:16,030 --> 00:13:18,319
>> Agora, este processo pode
Parece meio bobo.

315
00:13:18,319 --> 00:13:20,110
Por que estamos fazendo isso
em duas linhas de código?

316
00:13:20,110 --> 00:13:21,401
Existe uma maneira melhor de fazer isso?

317
00:13:21,401 --> 00:13:22,250
Na verdade, não existe.

318
00:13:22,250 --> 00:13:24,375
Às vezes você pode ver
esta chamada de inicialização.

319
00:13:24,375 --> 00:13:28,446
É quando você declarar uma variável
e atribuir um valor ao mesmo tempo.

320
00:13:28,446 --> 00:13:30,320
Esta é realmente uma bonita
coisa comum de se fazer.

321
00:13:30,320 --> 00:13:32,870
Quando você cria uma variável, você normalmente
deseja que ele tem algum valor básico.

322
00:13:32,870 --> 00:13:34,330
Mesmo que seja 0 ou algo assim.

323
00:13:34,330 --> 00:13:36,180
Você só você dar-lhe um valor.

324
00:13:36,180 --> 00:13:38,360
>> Você pode inicializar uma variável.

325
00:13:38,360 --> 00:13:42,320
Int número é igual a 17 é o mesmo que
as duas primeiras linhas de código em cima.

326
00:13:42,320 --> 00:13:46,829
Char carta é igual a h é o mesmo que o
terceira e quarta linhas de código acima.

327
00:13:46,829 --> 00:13:49,620
O takeaway mais importante aqui
quando estamos declarando e atribuindo

328
00:13:49,620 --> 00:13:51,740
variáveis ​​é depois que tivermos
declarou ele, aviso

329
00:13:51,740 --> 00:13:53,700
Eu não estou usando o tipo de dados novamente.

330
00:13:53,700 --> 00:13:57,916
Eu não estou dizendo número int igual a 17 na
a segunda linha de código, por exemplo.

331
00:13:57,916 --> 00:13:59,290
Só estou dizendo que é igual a número 17.

332
00:13:59,290 --> 00:14:02,537
>> Mais uma vez, re-declarar uma variável depois
você já declarou que pode levar

333
00:14:02,537 --> 00:14:03,620
para alguma conseqüência estranho.

334
00:14:03,620 --> 00:14:05,950
Então, basta ter cuidado com isso.

335
00:14:05,950 --> 00:14:06,660
>> Eu sou Doug Lloyd.

336
00:14:06,660 --> 00:14:08,870
E este é CS50.

337
00:14:08,870 --> 00:14:10,499