1
00:00:00,000 --> 00:00:02,420
>> [Играет музыка]

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

3
00:00:05,189 --> 00:00:05,980
СЛУШАЛИ: Ладно.

4
00:00:05,980 --> 00:00:08,540
Итак, давайте поговорим о другом
что это своего рода уникальным для C,

5
00:00:08,540 --> 00:00:10,010
который типы данных и переменные.

6
00:00:10,010 --> 00:00:12,340
Когда я говорю, уникальный для С, я действительно
означать только в контексте,

7
00:00:12,340 --> 00:00:14,470
если вы были программистом
в течение действительно долгого времени,

8
00:00:14,470 --> 00:00:16,270
вы, вероятно, не
работал с типами данных

9
00:00:16,270 --> 00:00:18,470
если вы использовали современный
языки программирования.

10
00:00:18,470 --> 00:00:20,432
Современные языки, такие как
PHP и JavaScript,

11
00:00:20,432 --> 00:00:22,640
который мы также будем видеть немного
в дальнейшем в ходе,

12
00:00:22,640 --> 00:00:25,550
Вы на самом деле не нужно указывать
тип данных переменной

13
00:00:25,550 --> 00:00:26,270
когда вы используете его.

14
00:00:26,270 --> 00:00:28,067
>> Вы просто объявить его и начать использовать его.

15
00:00:28,067 --> 00:00:29,900
Если это целое, его
знаю, что это целое число.

16
00:00:29,900 --> 00:00:31,960
Если это символ, это
знает, что это персонаж.

17
00:00:31,960 --> 00:00:35,320
Если это слово, он знает,
это строка, так называемые.

18
00:00:35,320 --> 00:00:37,300
>> Однако в C, который является
старый язык, мы должны

19
00:00:37,300 --> 00:00:39,420
указать данные
тип каждой переменной

20
00:00:39,420 --> 00:00:42,990
что мы создаем в первый раз
что мы используем эту переменную.

21
00:00:42,990 --> 00:00:45,030
Так C поставляется с некоторыми
встроенных типов данных.

22
00:00:45,030 --> 00:00:46,972
И давайте знакомиться
с некоторыми из них.

23
00:00:46,972 --> 00:00:50,180
А потом после этого мы также поговорим
немного о некоторых из типов данных

24
00:00:50,180 --> 00:00:54,450
что мы написали для вас,
так что вы можете использовать их в CS50.

25
00:00:54,450 --> 00:00:56,130
>> Во-первых, Int.

26
00:00:56,130 --> 00:00:59,110
Тип INT данные используются для переменных
что будет хранить целые значения.

27
00:00:59,110 --> 00:01:03,210
Так 1, 2, 3, отрицательный 1, 2, 3, и так далее.

28
00:01:03,210 --> 00:01:05,960
Целые, что то, что вы
Следует иметь в виду, для викторины,

29
00:01:05,960 --> 00:01:09,590
всегда занимают четыре байта
памяти, который составляет 32 бита.

30
00:01:09,590 --> 00:01:11,620
Существуют восемь битов в байте.

31
00:01:11,620 --> 00:01:14,470
>> Так это означает, что в диапазоне
ценит, что число может хранить

32
00:01:14,470 --> 00:01:19,130
ограничен тем, что может поместиться в
32 бита на сумму информации.

33
00:01:19,130 --> 00:01:21,850
Теперь, как выясняется,
Это было давно решено

34
00:01:21,850 --> 00:01:24,310
что мы расстались
что диапазон 32 бит

35
00:01:24,310 --> 00:01:26,650
в отрицательных целых
и положительные целые числа,

36
00:01:26,650 --> 00:01:28,390
каждый становится половине диапазона.

37
00:01:28,390 --> 00:01:32,230
Так диапазоне значений, которые мы представляем
с целочисленным диапазоне от отрицательного 2

38
00:01:32,230 --> 00:01:36,520
31-й власти 2 до
31-мощность минус 1,

39
00:01:36,520 --> 00:01:38,190
привести вам также необходимо место для 0.

40
00:01:38,190 --> 00:01:41,650
>> Так в основном половина из возможных значений
Вы можете приспособить в междунар отрицательны,

41
00:01:41,650 --> 00:01:42,610
и половина являются положительными.

42
00:01:42,610 --> 00:01:47,270
И примерно здесь, это о отрицательный
2 млрд до 2 млрд положительной.

43
00:01:47,270 --> 00:01:50,207
Дайте или взять пару сотен миллионов.

44
00:01:50,207 --> 00:01:52,290
Так что то, что вы можете поместить
в целой переменной.

45
00:01:52,290 --> 00:01:55,490
Теперь у нас есть что-то
называется целое число без знака.

46
00:01:55,490 --> 00:01:59,220
Теперь без знака Интс являются не
отдельный тип переменной.

47
00:01:59,220 --> 00:02:01,590
Скорее всего, это без знака
то, что называется классификатор.

48
00:02:01,590 --> 00:02:04,990
Это изменяет данные
тип целого незначительно.

49
00:02:04,990 --> 00:02:07,850
>> И в этом случае, то, что без знака
означает: а вы также можете

50
00:02:07,850 --> 00:02:11,530
использовать неподписанные другие типы данных,
число это не только один.

51
00:02:11,530 --> 00:02:15,310
Что это эффективно делает удваивается
положительный диапазон значений

52
00:02:15,310 --> 00:02:19,350
что число может принимать на
расход больше не позволяет

53
00:02:19,350 --> 00:02:21,140
Вам принимать отрицательные значения.

54
00:02:21,140 --> 00:02:25,400
Так что, если у вас есть номера, которые вы знаете
получите больше чем 2 млрд, но меньше

55
00:02:25,400 --> 00:02:31,280
чем 4 млрд, за example--
который составляет от 2 до 32-го power--

56
00:02:31,280 --> 00:02:33,330
Вы можете использовать
без знака INT если вы

57
00:02:33,330 --> 00:02:35,050
знать ваше значение никогда не будет отрицательным.

58
00:02:35,050 --> 00:02:37,216
>> Вы будете иногда есть
используется для неподписанных переменных

59
00:02:37,216 --> 00:02:39,460
в CS50, который является, почему я упоминаю его здесь.

60
00:02:39,460 --> 00:02:43,830
Но, опять же, диапазон значений, которые вы
может представлять с целого числа без знака

61
00:02:43,830 --> 00:02:48,240
а Т регулярное целое число, от 0
до 2 к власти 32-го минус 1,

62
00:02:48,240 --> 00:02:50,840
или примерно от 0 до 4 млрд.

63
00:02:50,840 --> 00:02:53,730
Итак, вы эффективно удвоилось
положительных значений, что вы можете поместить,

64
00:02:53,730 --> 00:02:56,270
но вы отказались все
отрицательные значения.

65
00:02:56,270 --> 00:03:00,040
>> Теперь, как в сторону, без знака
не только классификатор

66
00:03:00,040 --> 00:03:01,790
что для нас может увидеть
типы переменных данных.

67
00:03:01,790 --> 00:03:05,779
Есть также вещи, называемые
короткие и длинные, и строительства.

68
00:03:05,779 --> 00:03:07,820
Строительства, мы увидим немного
Чуть позже в курсе.

69
00:03:07,820 --> 00:03:10,830
Короткие и длинные, мы, вероятно, не будет.

70
00:03:10,830 --> 00:03:12,830
>> Но точно знаю, что есть
другие отборочные.

71
00:03:12,830 --> 00:03:14,080
Без подписи не только один.

72
00:03:14,080 --> 00:03:16,596
Но это только один мы
поговорим о прямо сейчас.

73
00:03:16,596 --> 00:03:17,310
Таким образом, все в порядке.

74
00:03:17,310 --> 00:03:18,393
Таким образом, мы уже рассмотрели целых чисел.

75
00:03:18,393 --> 00:03:19,200
Что дальше?

76
00:03:19,200 --> 00:03:20,130
>> Символов.

77
00:03:20,130 --> 00:03:23,620
Так символы используются для переменных
что будет хранить отдельные символы.

78
00:03:23,620 --> 00:03:24,850
Чар короток для характера.

79
00:03:24,850 --> 00:03:27,870
А иногда вы можете услышать
люди произносят его как автомобиль.

80
00:03:27,870 --> 00:03:32,020
>> Так герои всегда занимают одну
байт памяти, который находится всего в 8 бит.

81
00:03:32,020 --> 00:03:35,700
Таким образом, это означает, что они могут установить только
Значения в диапазоне от негатива 2

82
00:03:35,700 --> 00:03:42,430
в седьмой степени, или отрицательный 128,
до 2 в степени минус 7 1, или 127.

83
00:03:42,430 --> 00:03:45,710
>> Благодаря ASCII, было
давно решил способ

84
00:03:45,710 --> 00:03:50,805
чтобы сопоставить эти положительные числа от
0 до 127 различных символов

85
00:03:50,805 --> 00:03:52,182
что все существует на нашей клавиатуре.

86
00:03:52,182 --> 00:03:54,640
Так как мы увидим позже, в
курс, и вы, вероятно,

87
00:03:54,640 --> 00:03:57,700
пришел, чтобы запомнить на некоторые
точка, капитал А для example--

88
00:03:57,700 --> 00:04:00,732
характер капитал A--
отображает на номер 65.

89
00:04:00,732 --> 00:04:02,940
И причина в том,
потому что это то, что это

90
00:04:02,940 --> 00:04:05,490
был назначен в соответствии со стандартом ASCII.

91
00:04:05,490 --> 00:04:07,850
>> Строчные А 97.

92
00:04:07,850 --> 00:04:11,900
Характер 0, когда вам
на самом деле введите характер, не

93
00:04:11,900 --> 00:04:13,532
представляющий число ноль, 48.

94
00:04:13,532 --> 00:04:15,240
Вы узнаете пару
из них, как вы идете.

95
00:04:15,240 --> 00:04:17,990
И вы, конечно, нужно прийти к
их немного позже в CS50.

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

97
00:04:20,450 --> 00:04:23,390
>> Следующим крупным тип данных
в числа с плавающей запятой.

98
00:04:23,390 --> 00:04:26,100
Так число с плавающей точкой
также известный как действительных чисел.

99
00:04:26,100 --> 00:04:28,850
Они в основном номера, которые
есть десятичную точку в них.

100
00:04:28,850 --> 00:04:33,360
С плавающей запятой
как целые числа также

101
00:04:33,360 --> 00:04:36,090
содержащиеся в течение 4 байт памяти.

102
00:04:36,090 --> 00:04:37,580
Теперь нет схема здесь.

103
00:04:37,580 --> 00:04:40,890
Там нет номер строки, потому что
описывая круг поплавка

104
00:04:40,890 --> 00:04:44,550
Не совсем ясно, или интуитивно.

105
00:04:44,550 --> 00:04:47,350
>> Достаточно сказать, вам
есть 32 бита для работы с.

106
00:04:47,350 --> 00:04:49,730
И если у вас есть номер
как пи, который имеет

107
00:04:49,730 --> 00:04:55,510
целая часть 3 и плавающей
Точка часть, или дробная часть 0,14159,

108
00:04:55,510 --> 00:04:58,735
и так далее, вы должны быть
возможность представлять все it--

109
00:04:58,735 --> 00:05:02,420
целая часть и дробная часть.

110
00:05:02,420 --> 00:05:04,550
>> Так что вы думаете, что может означать?

111
00:05:04,550 --> 00:05:08,180
Одна вещь, что если десятичной
часть становится больше и больше,

112
00:05:08,180 --> 00:05:10,660
если у меня есть очень большой
Целая часть, я не мог

113
00:05:10,660 --> 00:05:13,090
сможет быть настолько точной,
с десятичной части.

114
00:05:13,090 --> 00:05:15,280
И это на самом деле
ограничение поплавка.

115
00:05:15,280 --> 00:05:17,229
>> Поплавки есть проблемы точности.

116
00:05:17,229 --> 00:05:19,270
У нас есть только 32 бита на
работать, поэтому мы можем только

117
00:05:19,270 --> 00:05:22,510
быть настолько точны, с нашей десятичной части.

118
00:05:22,510 --> 00:05:27,300
Мы не можем обязательно десятичной
часть точным на 100 или 200 цифр,

119
00:05:27,300 --> 00:05:29,710
потому что у нас есть только
32 бита для работы с.

120
00:05:29,710 --> 00:05:31,590
Так что это ограничение поплавка.

121
00:05:31,590 --> 00:05:33,590
>> Теперь, к счастью, есть
другой тип данных называется

122
00:05:33,590 --> 00:05:36,530
дважды, что несколько
занимается этой проблемой.

123
00:05:36,530 --> 00:05:39,980
Парный, как поплавки, которые также используются для
хранить вещественные числа или с плавающей точкой

124
00:05:39,980 --> 00:05:40,840
значения.

125
00:05:40,840 --> 00:05:44,340
Разница в том, что
Дубли двойной точности.

126
00:05:44,340 --> 00:05:48,177
Они могут соответствовать 64 бит
Данные, или восемь байт.

127
00:05:48,177 --> 00:05:49,010
Что это значит?

128
00:05:49,010 --> 00:05:51,801
Ну, это означает, что мы можем быть намного больше
точная с запятой.

129
00:05:51,801 --> 00:05:54,830
Вместо того, пи до семи
места, может быть, с поплавком,

130
00:05:54,830 --> 00:05:56,710
мы можем, возможно, есть его до 30 мест.

131
00:05:56,710 --> 00:05:59,824
Если это важно, вы, возможно, захотите
использовать двойной вместо поплавка.

132
00:05:59,824 --> 00:06:01,740
В принципе, если вы
работает на что-нибудь где

133
00:06:01,740 --> 00:06:06,540
имеющие очень долго десятичного
и многое точности важно,

134
00:06:06,540 --> 00:06:08,630
Вы, вероятно, хотите, чтобы
использовать двойной overfloat.

135
00:06:08,630 --> 00:06:11,250
Теперь большую часть работы в
CS50, поплавок должен быть достаточным.

136
00:06:11,250 --> 00:06:15,340
Но знаю, что существуют двойники в виде
способ несколько дело с точностью

137
00:06:15,340 --> 00:06:20,980
Проблема, давая вам дополнительный 32
Биты для работы с для чисел.

138
00:06:20,980 --> 00:06:23,650
>> Теперь это не тип данных.

139
00:06:23,650 --> 00:06:24,390
Это тип.

140
00:06:24,390 --> 00:06:25,340
И это называется недействительными.

141
00:06:25,340 --> 00:06:27,506
И я говорю об этом
здесь, потому что мы уже, наверное

142
00:06:27,506 --> 00:06:29,520
видел его несколько раз уже в CS50.

143
00:06:29,520 --> 00:06:32,020
И вы можете быть удивлены,
то, что это все о.

144
00:06:32,020 --> 00:06:33,390
>> Так пустота тип.

145
00:06:33,390 --> 00:06:34,097
Это действительно существует.

146
00:06:34,097 --> 00:06:35,180
Но это не является типом данных.

147
00:06:35,180 --> 00:06:39,350
>> Мы не можем создать переменную типа
аннулированию и назначить ей значение.

148
00:06:39,350 --> 00:06:42,519
Но функции, например,
может иметь тип возвращаемого недействительным.

149
00:06:42,519 --> 00:06:45,060
В принципе, если вы видите функцию
который имеет тип возвращаемого недействительным,

150
00:06:45,060 --> 00:06:46,970
это означает, что не возвращает значение.

151
00:06:46,970 --> 00:06:49,440
Можете ли вы общий
Функция, которую мы использовали до сих пор

152
00:06:49,440 --> 00:06:52,780
в CS50, которая не возвращает значение?

153
00:06:52,780 --> 00:06:54,700
>> Printf один.

154
00:06:54,700 --> 00:06:56,820
Printf на самом деле не
ничего возвращать к вам.

155
00:06:56,820 --> 00:06:59,850
Он печатает что-то на
экран, и это в основном

156
00:06:59,850 --> 00:07:01,650
побочный эффект, что делает Printf.

157
00:07:01,650 --> 00:07:03,620
Но это не дает вам значение обратно.

158
00:07:03,620 --> 00:07:08,419
Вы не захватить результат и магазин
это в какой-то переменной, чтобы использовать его в дальнейшем.

159
00:07:08,419 --> 00:07:10,710
Это просто что-то печатает
экран, и вы сделали.

160
00:07:10,710 --> 00:07:14,360
>> Поэтому мы говорим, что Printf
является функцией недействительными.

161
00:07:14,360 --> 00:07:16,450
Это ничего не возвращает.

162
00:07:16,450 --> 00:07:18,580
>> Список периметру
Функция также может быть недействительным.

163
00:07:18,580 --> 00:07:21,410
И вы также видели, что
совсем немного в CS50 тоже.

164
00:07:21,410 --> 00:07:22,300
Int основной недействительными.

165
00:07:22,300 --> 00:07:23,260
Что звонит колокол ли?

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

167
00:07:24,080 --> 00:07:27,220
В основном то, что это означает, что
Основной не принимает никаких параметров.

168
00:07:27,220 --> 00:07:29,520
Там нет аргумент, что
получить прошло в главном.

169
00:07:29,520 --> 00:07:32,780
Теперь в дальнейшем мы увидим, что есть
способ передачи аргументов в основном,

170
00:07:32,780 --> 00:07:36,189
но до сих пор, что мы
видел это INT основной недействительными.

171
00:07:36,189 --> 00:07:37,730
Главная просто не принимать какие-либо аргументы.

172
00:07:37,730 --> 00:07:40,236
И так мы указываем, что, говоря недействительными.

173
00:07:40,236 --> 00:07:42,110
Мы просто будучи очень
явное о том,

174
00:07:42,110 --> 00:07:44,430
что он не принимает никаких аргументов.

175
00:07:44,430 --> 00:07:47,160
>> Так что сейчас, достаточно, чтобы его
сказать, что в основном пустоту

176
00:07:47,160 --> 00:07:50,789
должны просто служить в качестве заполнителя
для вас, как думать о ничто.

177
00:07:50,789 --> 00:07:52,080
Это ничего не делает.

178
00:07:52,080 --> 00:07:53,550
Там нет возвращаемого значения здесь.

179
00:07:53,550 --> 00:07:54,770
Там нет никаких параметров тут.

180
00:07:54,770 --> 00:07:55,709
Это пустота.

181
00:07:55,709 --> 00:07:57,250
Это немного сложнее, чем это.

182
00:07:57,250 --> 00:08:00,640
Но это должно быть достаточно для
лучшая часть курса.

183
00:08:00,640 --> 00:08:05,010
И, надеюсь, теперь у вас есть немного
немного больше о том, что концепция пустота.

184
00:08:05,010 --> 00:08:08,460
>> Так что те пять типов вы будете
Встреча, которые встроены в С

185
00:08:08,460 --> 00:08:10,670
Но в CS50 у нас также есть библиотека.

186
00:08:10,670 --> 00:08:13,550
CS50.h, которые вы можете включить.

187
00:08:13,550 --> 00:08:15,930
И который обеспечит вам
с двумя дополнительными типами

188
00:08:15,930 --> 00:08:18,280
что вы, вероятно, сможете
для использования на ваших заданий,

189
00:08:18,280 --> 00:08:21,210
или просто работать, как правило программирования.

190
00:08:21,210 --> 00:08:23,030
>> Первый из них является BOOL.

191
00:08:23,030 --> 00:08:26,780
Таким образом, логический тип,
BOOL, используется для переменных

192
00:08:26,780 --> 00:08:28,114
что будет хранить логическое значение.

193
00:08:28,114 --> 00:08:29,863
Если вы когда-либо слышал
этот термин и раньше, вам

194
00:08:29,863 --> 00:08:31,960
могли знать, что логическое значение
Значение способен только

195
00:08:31,960 --> 00:08:34,440
проведение двух различных различные значения.

196
00:08:34,440 --> 00:08:35,872
Истинные и ложные.

197
00:08:35,872 --> 00:08:37,580
Теперь это кажется довольно
фундаментальная, верно?

198
00:08:37,580 --> 00:08:40,496
Это своего рода сюрпризом, что это
не существует в C, как это встроенный в.

199
00:08:40,496 --> 00:08:42,640
И во многих современных языках,
конечно, логические

200
00:08:42,640 --> 00:08:45,390
являются стандартный тип данных по умолчанию.

201
00:08:45,390 --> 00:08:47,192
Но в C, они на самом деле нет.

202
00:08:47,192 --> 00:08:48,400
Но мы создали его для вас.

203
00:08:48,400 --> 00:08:51,910
Так что, если вы когда-нибудь нужно создать
переменная, тип BOOL,

204
00:08:51,910 --> 00:08:55,230
только убедитесь, что #include CS50.h
в начале вашей программы,

205
00:08:55,230 --> 00:08:57,800
и вы сможете создать
переменные типа BOOL.

206
00:08:57,800 --> 00:09:02,095
>> Если вы забыли #include CS50.h, и
вы начинаете использовать переменные типа Boolean,

207
00:09:02,095 --> 00:09:04,970
Вы могли бы столкнуться с некоторыми проблемами
когда вы компилируете программу.

208
00:09:04,970 --> 00:09:06,490
Так что будьте начеку для этого.

209
00:09:06,490 --> 00:09:11,180
И, может быть, вы можете просто исправить
проблемы по фунту в том числе CS50.h.

210
00:09:11,180 --> 00:09:14,590
>> Другой основной тип данных, которые мы
обеспечить для вас в библиотеке CS50

211
00:09:14,590 --> 00:09:15,670
строка.

212
00:09:15,670 --> 00:09:17,130
Так что это строка?

213
00:09:17,130 --> 00:09:18,520
Строки действительно просто слова.

214
00:09:18,520 --> 00:09:20,000
Они коллекции символов.

215
00:09:20,000 --> 00:09:20,640
Они слов.

216
00:09:20,640 --> 00:09:21,390
Они приговоры.

217
00:09:21,390 --> 00:09:22,480
Они абзацы.

218
00:09:22,480 --> 00:09:25,850
Может быть целые книги, даже.

219
00:09:25,850 --> 00:09:29,690
>> Очень короткая, чтобы очень долго
последовательность символов.

220
00:09:29,690 --> 00:09:34,310
Если вам нужно использовать струны,
например, для хранения слова,

221
00:09:34,310 --> 00:09:37,609
только не забудьте включить CS50.h
в начале вашей программы

222
00:09:37,609 --> 00:09:38,900
так что вы можете использовать строковый тип.

223
00:09:38,900 --> 00:09:43,910
И тогда вы можете создавать переменные
Тип данных которого является строка.

224
00:09:43,910 --> 00:09:46,160
Теперь позже в ходе,
мы также увидим, что это

225
00:09:46,160 --> 00:09:47,752
не вся история, либо.

226
00:09:47,752 --> 00:09:49,460
Мы сталкиваемся вещи
называемые структуры,

227
00:09:49,460 --> 00:09:54,249
которые позволяют группировать, что может быть
целое число, а строка в один блок.

228
00:09:54,249 --> 00:09:56,290
И мы можем использовать это для
некоторые цели, которые могли бы

229
00:09:56,290 --> 00:09:57,750
пригодится в дальнейшем в ходе.

230
00:09:57,750 --> 00:09:59,500
>> И мы также узнаем
о определенных типов,

231
00:09:59,500 --> 00:10:01,720
которые позволяют создать
Ваши собственные типы данных.

232
00:10:01,720 --> 00:10:03,060
Мы не должны волноваться
о том, что в настоящее время.

233
00:10:03,060 --> 00:10:04,550
Но точно знаю, что это
что-то на горизонте,

234
00:10:04,550 --> 00:10:07,633
что есть намного больше к этому целом
тип вещь, чем я вам говорю только

235
00:10:07,633 --> 00:10:08,133
Теперь.

236
00:10:08,133 --> 00:10:10,591
Так что теперь мы узнали
немного об основных данных

237
00:10:10,591 --> 00:10:14,230
виды и типы данных CS50, давайте
говорить о том, чтобы работать с переменными

238
00:10:14,230 --> 00:10:18,530
и создавать их с помощью них
типы данных в наших программах.

239
00:10:18,530 --> 00:10:22,670
Если вы хотите создать переменную,
все, что вам нужно сделать, это две вещи.

240
00:10:22,670 --> 00:10:24,147
>> Во-первых, вы должны дать ему тип.

241
00:10:24,147 --> 00:10:26,230
Второе, что вы должны
сделать, это дать ему имя.

242
00:10:26,230 --> 00:10:28,740
После того как вы это сделали, и ударил
запятой в конце этой строки,

243
00:10:28,740 --> 00:10:29,830
Вы создали переменную.

244
00:10:29,830 --> 00:10:32,370
>> Так вот два примера.

245
00:10:32,370 --> 00:10:35,744
Int номер; символ письмо ;.

246
00:10:35,744 --> 00:10:36,660
Что я сделал здесь?

247
00:10:36,660 --> 00:10:38,110
Я создал две переменные.

248
00:10:38,110 --> 00:10:40,190
>> Во-первых, значений переменной
имя номер.

249
00:10:40,190 --> 00:10:44,830
И число способен удерживать целое
введите значения, потому что его тип Int.

250
00:10:44,830 --> 00:10:48,040
Письмо другая переменная
который может содержать символы

251
00:10:48,040 --> 00:10:50,240
так как ее тип данных CHAR.

252
00:10:50,240 --> 00:10:51,772
>> Довольно просто, не так ли?

253
00:10:51,772 --> 00:10:53,480
Если вы окажетесь
в ситуации, когда

254
00:10:53,480 --> 00:10:56,250
Вы должны создать несколько
переменные того же типа,

255
00:10:56,250 --> 00:10:58,740
Вы должны только указать
имя типа один раз.

256
00:10:58,740 --> 00:11:01,600
Тогда просто перечислить столько переменных,
этого типа, как вам нужно.

257
00:11:01,600 --> 00:11:04,230
>> Так что я мог, например, здесь
в этом третьей строке кода,

258
00:11:04,230 --> 00:11:07,420
говорят высоты INT ;, новую строку.

259
00:11:07,420 --> 00:11:08,291
Int ширина ;.

260
00:11:08,291 --> 00:11:09,290
И, что бы работать тоже.

261
00:11:09,290 --> 00:11:12,039
Я все еще получаю две переменные называются
высота и ширина, каждый из которых

262
00:11:12,039 --> 00:11:12,730
является целым числом.

263
00:11:12,730 --> 00:11:16,970
Но я позволил, вещи синтаксиса C,
консолидировать его в одной строке.

264
00:11:16,970 --> 00:11:20,230
Высота Int, ширина; Это то же самое.

265
00:11:20,230 --> 00:11:23,900
Я создал две переменные, одна называется
Высота одна называется ширина, оба из которых

266
00:11:23,900 --> 00:11:26,730
способны холдинга
целые значения типа.

267
00:11:26,730 --> 00:11:30,920
>> Точно здесь, я могу создать три
с плавающей запятой за один раз.

268
00:11:30,920 --> 00:11:33,350
Я могу, может быть, создать переменную
называется квадратный корень из 2--

269
00:11:33,350 --> 00:11:35,766
которые, предположительно, в конечном счете
удерживайте плавающей point--

270
00:11:35,766 --> 00:11:39,222
что представление на площади
корень 2-- квадратный корень из 3, и пи.

271
00:11:39,222 --> 00:11:41,180
Я мог бы сделать это
на трех отдельных линий.

272
00:11:41,180 --> 00:11:47,690
Поплавок, квадратный корень 2; Поплавок квадратный корень
3; плавать пи; и что будет работать тоже.

273
00:11:47,690 --> 00:11:50,590
>> Но, опять же, я могу только объединить
это в одной строке кода.

274
00:11:50,590 --> 00:11:54,050
Делает вещи немного
короче, а не как неуклюжим.

275
00:11:54,050 --> 00:11:57,259
>> В настоящее время в общем, это хороший дизайн, чтобы только
объявить переменную, когда вам это нужно.

276
00:11:57,259 --> 00:11:59,050
И мы будем говорить немного
немного больше о том, что

277
00:11:59,050 --> 00:12:00,945
позже в ходе
когда мы будем обсуждать масштабы.

278
00:12:00,945 --> 00:12:03,320
Так что не обязательно должны
создать все ваши переменные

279
00:12:03,320 --> 00:12:05,990
в начале программы, которая
некоторые люди могли бы сделать прошлое,

280
00:12:05,990 --> 00:12:08,700
или, конечно, очень распространенная
практика кодирования много лет назад

281
00:12:08,700 --> 00:12:11,700
при работе с С. Вы можете просто
хотите создать переменную прав, когда

282
00:12:11,700 --> 00:12:13,140
Вы нуждаетесь в этом.

283
00:12:13,140 --> 00:12:13,640
Все в порядке.

284
00:12:13,640 --> 00:12:15,150
Таким образом, мы создали переменные.

285
00:12:15,150 --> 00:12:16,790
Как мы их использовать?

286
00:12:16,790 --> 00:12:18,650
После того как мы объявить
Переменная, мы не должны

287
00:12:18,650 --> 00:12:21,237
указать тип данных
этой переменной больше.

288
00:12:21,237 --> 00:12:24,070
В самом деле, если вы делаете это, вы могли бы
в конечном итоге с некоторыми странными последствиями

289
00:12:24,070 --> 00:12:25,490
что мы вроде замалчивать сейчас.

290
00:12:25,490 --> 00:12:27,365
Но достаточно сказать,,
странные вещи идут

291
00:12:27,365 --> 00:12:30,740
чтобы начать происходит если вы нечаянно
вновь объявлять переменные с таким же именем

292
00:12:30,740 --> 00:12:32,210
вновь и вновь.

293
00:12:32,210 --> 00:12:33,882
>> Так вот у меня есть четыре строки.

294
00:12:33,882 --> 00:12:36,090
И у меня есть пару
комментарии там просто указывающие

295
00:12:36,090 --> 00:12:37,840
что происходит на
каждая строка просто, чтобы помочь

296
00:12:37,840 --> 00:12:40,520
вы получаете расположен в то, что происходит.

297
00:12:40,520 --> 00:12:41,520
Так INT номер ;.

298
00:12:41,520 --> 00:12:42,520
Вы видели, что ранее.

299
00:12:42,520 --> 00:12:44,000
Это объявление переменной.

300
00:12:44,000 --> 00:12:46,670
>> Я теперь создали переменную
называется число, это

301
00:12:46,670 --> 00:12:48,970
способен удерживать целые значения типа.

302
00:12:48,970 --> 00:12:50,210
Я объявил его.

303
00:12:50,210 --> 00:12:53,770
>> Следующая строка я задаю
значение на номер.

304
00:12:53,770 --> 00:12:54,992
Количество равна 17.

305
00:12:54,992 --> 00:12:55,950
Что там происходит?

306
00:12:55,950 --> 00:12:58,880
Я ставлю количество 17
внутри этой переменной.

307
00:12:58,880 --> 00:13:02,760
>> Так что, если я когда-либо затем распечатать то, что
содержимое числа являются позже,

308
00:13:02,760 --> 00:13:04,030
они скажут мне, что это 17.

309
00:13:04,030 --> 00:13:07,030
Так что я объявил переменную,
а затем я назначен его.

310
00:13:07,030 --> 00:13:10,570
>> Мы можем повторить процесс
снова полукокса письме ;.

311
00:13:10,570 --> 00:13:11,640
Это заявление.

312
00:13:11,640 --> 00:13:14,010
Письмо равна капитал
Х. Это назначение.

313
00:13:14,010 --> 00:13:16,030
Довольно просто, слишком.

314
00:13:16,030 --> 00:13:18,319
>> Сейчас этот процесс может
кажется глупо.

315
00:13:18,319 --> 00:13:20,110
Зачем мы это делаем
в двух строк кода?

316
00:13:20,110 --> 00:13:21,401
Есть ли лучший способ сделать это?

317
00:13:21,401 --> 00:13:22,250
На самом деле, есть.

318
00:13:22,250 --> 00:13:24,375
Иногда вы можете увидеть
это называется инициализации.

319
00:13:24,375 --> 00:13:28,446
Это когда вы объявляете переменную
и присвоить значение, в то же время.

320
00:13:28,446 --> 00:13:30,320
Это на самом деле довольно
общая вещь, чтобы сделать.

321
00:13:30,320 --> 00:13:32,870
Когда вы создаете переменную, вы, как правило
хочу, чтобы иметь некоторые базовые ценности.

322
00:13:32,870 --> 00:13:34,330
Даже если это 0 или что-то.

323
00:13:34,330 --> 00:13:36,180
Вы просто даете ему значение.

324
00:13:36,180 --> 00:13:38,360
>> Вы можете инициализировать переменную.

325
00:13:38,360 --> 00:13:42,320
Int число равно 17 так же, как
первые две строки кода наверху.

326
00:13:42,320 --> 00:13:46,829
Символьное письмо равен ч то же самое, как
Третья и четвертая строки кода выше.

327
00:13:46,829 --> 00:13:49,620
Наиболее важным здесь вынос
когда мы декларирования и присвоения

328
00:13:49,620 --> 00:13:51,740
переменных после того как мы
заявил, уведомление

329
00:13:51,740 --> 00:13:53,700
Я не раз с использованием типа данных.

330
00:13:53,700 --> 00:13:57,916
Я не говорю, INT число равно 17 на
вторая строка кода, к примеру.

331
00:13:57,916 --> 00:13:59,290
Я просто говорю, число которых равно 17.

332
00:13:59,290 --> 00:14:02,537
>> Опять же, повторно объявив переменную после
Вы уже заявил, что может привести

333
00:14:02,537 --> 00:14:03,620
в какой-то странной следствие.

334
00:14:03,620 --> 00:14:05,950
Так что будьте осторожны, что.

335
00:14:05,950 --> 00:14:06,660
>> Я Дуг Ллойд.

336
00:14:06,660 --> 00:14:08,870
И это CS50.

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