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
SPEAKER: Добре.

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
Когато казвам, уникални за C, аз наистина
означава само в контекста на,

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
>> Но в С, което е
по-стар език, ние се нуждаем

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
Типът на инт данни се използват за променливи
който ще съхранява целочислени стойности.

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
>> И в този случай, какво неподписан
means-- и можете също

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
може да искате да използвате
неподписан инт ако

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-4000000000.

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
Unsigned не е единственият.

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
дойде да запомня в някакъв
точка, капитали A, за 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
>> Малки букви A е 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
>> ФОРМАТ е една.

154
00:06:54,700 --> 00:06:56,820
ФОРМАТ всъщност не
върнете ли ти нещо.

155
00:06:56,820 --> 00:06:59,850
Той отпечатва нещо на
скрининг, и това е основно

156
00:06:59,850 --> 00:07:01,650
страничен ефект от това, което прави ФОРМАТ.

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
>> Така че ние казваме, че ФОРМАТ
е функция за невалидни.

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
но засега това, което сме
видял е инт основната невалидни.

171
00:07:36,189 --> 00:07:37,730
Main просто не взема никакви аргументи.

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
>> Така че тези, които са петте вида ви ще
среща, която се вградени в C.

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
>> Първият от тях е булев.

191
00:08:23,030 --> 00:08:26,780
Така Булев тип данни,
булев, се използва за променливи

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
Така че, ако някога ви се наложи да създадете
променлива, чийто тип е булев,

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

205
00:08:55,230 --> 00:08:57,800
и вие ще бъдете в състояние да създаде
променливи от тип булев.

206
00:08:57,800 --> 00:09:02,095
>> Ако сте пропуснали да #include CS50.h, и
да започнете да използвате Булев тип променливи,

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
Strings са наистина само думи.

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
И номер е в състояние да задържа число
Типове стойности, тъй като неговия вид е инт.

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

251
00:10:48,040 --> 00:10:50,240
тъй като неговата тип данни е Чар.

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
казват височина инт ;, нов ред.

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
Float, квадратен корен от 2; Float квадратен корен
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
при работа с C. може би просто
искате да създадете полето променлива, когато

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
Така инт номер ;.

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
Писмо равнява на капитала
H. Това е една задача.

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
Char писмо равнява ч е същият като
трети и четвърти реда код по-горе.

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
Аз не казвам, инт брой се равнява на 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