1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Преглед] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Рос, Томи MacWilliam, Лукас Freitas, Джоузеф Ong] [Харвардския университет]

3
00:00:05,000 --> 00:00:08,000
>> [Това е CS50. [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Хей, всички.

5
00:00:10,000 --> 00:00:15,000
Добре дошли на сесия за преразглеждане Quiz 0, което ще се проведе тази сряда.

6
00:00:15,000 --> 00:00:19,000
Това, което ние ще направим тази вечер, аз съм с 3 други TFS,

7
00:00:19,000 --> 00:00:24,000
и заедно отиваме да мине през преглед на това, което ние сме направили в хода досега.

8
00:00:24,000 --> 00:00:27,000
Това няма да бъде 100% изчерпателен, но тя трябва да ви даде по-добра идея

9
00:00:27,000 --> 00:00:31,000
на това, което вече имате и какво още трябва да учат преди сряда.

10
00:00:31,000 --> 00:00:34,000
И не се колебайте да вдигнете ръка с въпроси, като ще ни заедно,

11
00:00:34,000 --> 00:00:38,000
но имайте предвид, че също така ще има малко време в края

12
00:00:38,000 --> 00:00:41,000
ако приключа с няколко минути, за да резервни, за да направи общи въпроси,

13
00:00:41,000 --> 00:00:47,000
така че да се има предвид, и така ние ще започнем в началото Седмица 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 мнения!] [Част 0] [Lexi Рос Но преди да правим, че да се говори за

15
00:00:50,000 --> 00:00:53,000
логистиката на теста.

16
00:00:53,000 --> 00:00:55,000
>> [Логистика] [Quiz се проведе в сряда, 10/10 вместо на лекцията]

17
00:00:55,000 --> 00:00:57,000
>> (Виж http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf за подробности) е в сряда, 10 октомври.

18
00:00:57,000 --> 00:01:00,000
>> Това е тази сряда, и ако отидете на този адрес тук,

19
00:01:00,000 --> 00:01:03,000
която е достъпна също от CS50.net има линк към него

20
00:01:03,000 --> 00:01:06,000
можете да видите информация за това къде да отидат на базата на

21
00:01:06,000 --> 00:01:10,000
фамилното си име или принадлежност училището, както и

22
00:01:10,000 --> 00:01:14,000
разказва за какво точно теста ще обхване и видовете въпроси, които ще получите.

23
00:01:14,000 --> 00:01:19,000
Имайте в предвид, че също така ще има възможност да се запознаем за тест в раздел

24
00:01:19,000 --> 00:01:21,000
така че вашите TFS трябва да се над някои практики, проблеми,

25
00:01:21,000 --> 00:01:29,000
и това е още една добра възможност да видите, където все още трябва да учат за теста.

26
00:01:29,000 --> 00:01:32,000
Нека започнем от самото начало с Bytes 'N' Bits.

27
00:01:32,000 --> 00:01:35,000
Не забравяйте, малко е само 0 или 1,

28
00:01:35,000 --> 00:01:38,000
и един байт е колекция на 8 от тези битове.

29
00:01:38,000 --> 00:01:42,000
Нека да разгледаме в тази колекция от бита тук.

30
00:01:42,000 --> 00:01:44,000
Ние трябва да бъдем в състояние да разбера колко бита има.

31
00:01:44,000 --> 00:01:48,000
Когато ние разчитаме само на 8 от тях, осем 0 или 1.

32
00:01:48,000 --> 00:01:51,000
И тъй като има 8 бита, това е един байт,

33
00:01:51,000 --> 00:01:53,000
и да го конвертирате в шестнадесетичен.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal е с основа 16, а това е доста лесно да конвертирате

35
00:01:58,000 --> 00:02:01,000
в двоичен, което е, какво е това, към номер в шестнадесетичен.

36
00:02:01,000 --> 00:02:04,000
Всичко, което правим, е да погледнем към групи от по 4,

37
00:02:04,000 --> 00:02:07,000
и ние да ги конвертирате в съответната цифра шестнадесетичен.

38
00:02:07,000 --> 00:02:11,000
Започваме с най-дясната група от 4, така че 0011.

39
00:02:11,000 --> 00:02:16,000
Това ще бъде 1 и 2, така че заедно, което прави 3.

40
00:02:16,000 --> 00:02:19,000
И тогава нека да погледнем в другия блок 4.

41
00:02:19,000 --> 00:02:24,000
1101. Това ще бъде един милион, един 4 и един 8.

42
00:02:24,000 --> 00:02:28,000
Заедно, че ще бъде 13, което прави D.

43
00:02:28,000 --> 00:02:32,000
И ние ще си спомните, че в шестнадесетичен не просто отидете от 0 до 9.

44
00:02:32,000 --> 00:02:36,000
Отиваме 0 до F, така че след 9, 10 съответства на

45
00:02:36,000 --> 00:02:40,000
11 до точка Б, и т.н., където F е 15.

46
00:02:40,000 --> 00:02:44,000
Ето 13 е D,

47
00:02:44,000 --> 00:02:49,000
така да го конвертирате в знак след десетичната всичко, което правим е, че ние всъщност

48
00:02:49,000 --> 00:02:52,000
лечение на всяка позиция, с мощност от 2.

49
00:02:52,000 --> 00:02:58,000
Това е 1, една 2, нула 4s, нула 8s, един 16, и т.н.,

50
00:02:58,000 --> 00:03:03,000
и това е малко трудно да се изчисли в главата си, но ако отидем на следващия слайд

51
00:03:03,000 --> 00:03:05,000
можем да видим отговора на този въпрос.

52
00:03:05,000 --> 00:03:09,000
>> По същество ние ще намира от дясно на ляво,

53
00:03:09,000 --> 00:03:14,000
и ние сме се умножи всяка цифра от съответната степен на 2.

54
00:03:14,000 --> 00:03:19,000
И не забравяйте, шестнадесетичен означават тези числа с 0x в началото

55
00:03:19,000 --> 00:03:23,000
така че ние не го бъркайте с десетично число.

56
00:03:23,000 --> 00:03:29,000
Продължавайки, това е ASCII таблица,

57
00:03:29,000 --> 00:03:35,000
и това, което ние използваме ASCII е да картографира от героите на числени стойности.

58
00:03:35,000 --> 00:03:39,000
Запомни ме pset криптография широко използване на ASCII таблица

59
00:03:39,000 --> 00:03:43,000
с цел да се използват различни методи за криптография,

60
00:03:43,000 --> 00:03:47,000
Цезар и шифър Vigenère, да конвертирате различни букви

61
00:03:47,000 --> 00:03:52,000
в низ според ключ, зададена от потребителя.

62
00:03:52,000 --> 00:03:56,000
Нека погледнем малко ASCII математика.

63
00:03:56,000 --> 00:04:02,000
Поглед към "P" + 1, под формата на знак, който ще бъде Q,

64
00:04:02,000 --> 00:04:07,000
и не забравяйте, че '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
И как точно бихме конвертиране между тези две форми?

66
00:04:10,000 --> 00:04:13,000
Тя всъщност не е твърде трудно.

67
00:04:13,000 --> 00:04:16,000
За да получите 5 извадим '0 '

68
00:04:16,000 --> 00:04:20,000
защото има 5 места между '0 'и '5.

69
00:04:20,000 --> 00:04:23,000
За да отидете на друг начин, ние просто добавете 0,

70
00:04:23,000 --> 00:04:25,000
така че това е нещо като редовен аритметика.

71
00:04:25,000 --> 00:04:29,000
Само не забравяйте, че когато нещо има кавички около него е герой

72
00:04:29,000 --> 00:04:37,000
и по този начин отговаря на стойност в ASCII таблица.

73
00:04:37,000 --> 00:04:40,000
Преместване в по-общи теми компютърни науки.

74
00:04:40,000 --> 00:04:43,000
Ние научихме какво представлява алгоритъм и как я използваме програмиране

75
00:04:43,000 --> 00:04:45,000
за изпълнение на алгоритми.

76
00:04:45,000 --> 00:04:48,000
Някои примери на алгоритми са нещо наистина просто като

77
00:04:48,000 --> 00:04:51,000
да проверяват дали даден номер е равна или странно.

78
00:04:51,000 --> 00:04:54,000
За това Спомням си, че Министерството на отбраната на броя на 2 и проверете дали резултатът е 0.

79
00:04:54,000 --> 00:04:57,000
Ако е така, това е дори. Ако не, то е странно.

80
00:04:57,000 --> 00:04:59,000
И това е пример за наистина основния алгоритъм.

81
00:04:59,000 --> 00:05:02,000
>> Малко по-голямо участие е двоично търсене,

82
00:05:02,000 --> 00:05:05,000
които ние ще отидем по-късно в рамките на прегледа на сесията.

83
00:05:05,000 --> 00:05:09,000
И програмиране е термин, който ние използваме за алгоритъм

84
00:05:09,000 --> 00:05:15,000
и конвертиране за кодирането на компютъра могат да четат.

85
00:05:15,000 --> 00:05:20,000
2 примери за програмиране е Scratch,

86
00:05:20,000 --> 00:05:22,000
, което е това, което направихме през седмица 0.

87
00:05:22,000 --> 00:05:25,000
Въпреки, че ние не въведете кода това е начин за прилагане на

88
00:05:25,000 --> 00:05:29,000
този алгоритъм, който се отпечатва номера 1-10,

89
00:05:29,000 --> 00:05:32,000
и тук правим същото на езика за програмиране C.

90
00:05:32,000 --> 00:05:41,000
Това са функционално равностоен, просто написани на различни езици или синтаксис.

91
00:05:41,000 --> 00:05:44,000
След това научих за булевите изрази,

92
00:05:44,000 --> 00:05:48,000
и булев е стойност, която е или вярно или невярно,

93
00:05:48,000 --> 00:05:51,000
и тук често булевите изрази

94
00:05:51,000 --> 00:05:55,000
влезем вътре условия, така че ако (х ≤ 5),

95
00:05:55,000 --> 00:06:00,000
Е, ние вече х = 5, така че ще оцени това условие е да е истина.

96
00:06:00,000 --> 00:06:03,000
И ако това е вярно, независимо от кода е под условие

97
00:06:03,000 --> 00:06:08,000
ще бъдат оценявани от компютъра, така че низ ще бъдат отпечатани

98
00:06:08,000 --> 00:06:12,000
на стандартния изход и хронично състояние

99
00:06:12,000 --> 00:06:16,000
се отнася до това, което е вътре в скобите ако изявление.

100
00:06:16,000 --> 00:06:20,000
Запомни всички оператори.

101
00:06:20,000 --> 00:06:26,000
Запомни && и | | когато ние се опитваме да се комбинират два или повече условия,

102
00:06:26,000 --> 00:06:30,000
== = Не, за да се провери дали две неща са равни.

103
00:06:30,000 --> 00:06:36,000
Не забравяйте, че = е за възлагане, докато == е булев оператор.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ и след крайния два са ясни.

105
00:06:41,000 --> 00:06:45,000
Общ преглед на Булева логика тук.

106
00:06:45,000 --> 00:06:48,000
И булеви изрази също са важни в примки,

107
00:06:48,000 --> 00:06:50,000
които ние ще отидем сега.

108
00:06:50,000 --> 00:06:56,000
Научихме около 3 вида вериги досега в CS50,, а и правя, докато.

109
00:06:56,000 --> 00:06:59,000
И това е важно да се знае, че докато за повечето цели

110
00:06:59,000 --> 00:07:02,000
всъщност ние можем да използвате всякакъв вид на линия

111
00:07:02,000 --> 00:07:06,000
има някои видове на цели или общи модели

112
00:07:06,000 --> 00:07:09,000
в програмирането, които конкретно се обадя за една от тези вериги

113
00:07:09,000 --> 00:07:13,000
, които го правят най-ефикасният или елегантно да го кодира по този начин.

114
00:07:13,000 --> 00:07:18,000
Нека вървим по това, което всеки от тези вериги може да се използва за най-често.

115
00:07:18,000 --> 00:07:21,000
>> В контур ние обикновено вече знаете, колко пъти ние искаме да превъртите.

116
00:07:21,000 --> 00:07:24,000
Това е, което ние поставяме в зависимост от състоянието.

117
00:07:24,000 --> 00:07:28,000
За I = 0, I <10, например.

118
00:07:28,000 --> 00:07:31,000
Вече знаем, че искаме да направим нещо 10 пъти.

119
00:07:31,000 --> 00:07:34,000
Сега, за известно време контур, като цяло ние не непременно

120
00:07:34,000 --> 00:07:36,000
знам колко пъти искаш цикъла да тече.

121
00:07:36,000 --> 00:07:39,000
Но ние знаем, някакво условие, че искаме да

122
00:07:39,000 --> 00:07:41,000
винаги е вярно или винаги е невярна.

123
00:07:41,000 --> 00:07:44,000
Например, докато е зададен.

124
00:07:44,000 --> 00:07:46,000
Да кажем, че е булева променлива.

125
00:07:46,000 --> 00:07:48,000
Макар че е вярно, ние искаме код, за да оцени

126
00:07:48,000 --> 00:07:52,000
така че малко по-разтегателен, малко по-общо, отколкото линия

127
00:07:52,000 --> 00:07:55,000
но всеки контур може да се превръща в линия, докато.

128
00:07:55,000 --> 00:08:00,000
Накрая, докато контури, които могат да бъдат най-трудните, за да се разбере веднага,

129
00:08:00,000 --> 00:08:04,000
често се използват, когато искаме да се оцени код първо

130
00:08:04,000 --> 00:08:06,000
преди първият път, когато се провери състоянието.

131
00:08:06,000 --> 00:08:09,000
Общия случай за линия, докато

132
00:08:09,000 --> 00:08:12,000
е, когато искате да получите въвеждане от потребителя, и знаете, че искате да поиска от потребителя

133
00:08:12,000 --> 00:08:15,000
за въвеждане на най-малко веднъж, но ако те не ви даде добър принос веднага

134
00:08:15,000 --> 00:08:18,000
искате да запазите, като иска от тях, докато те ви дават добър вход.

135
00:08:18,000 --> 00:08:21,000
Това е най-честата употреба на линия, докато

136
00:08:21,000 --> 00:08:23,000
и нека погледнем реалната структура на тези вериги.

137
00:08:23,000 --> 00:08:27,000
Те обикновено винаги са склонни да следват тези модели.

138
00:08:27,000 --> 00:08:30,000
>> На за контур вътре има три компонента:

139
00:08:30,000 --> 00:08:35,000
инициализация, обикновено нещо като Int = 0, когато е на тезгяха,

140
00:08:35,000 --> 00:08:40,000
състояние, когато искаме да кажем стартирате тази линия, докато това състояние все още държи,

141
00:08:40,000 --> 00:08:44,000
като <10, и накрая, актуализация, която е как да увеличите

142
00:08:44,000 --> 00:08:47,000
контра променлива във всяка точка във веригата.

143
00:08:47,000 --> 00:08:50,000
Една обща нещо, което трябва да видите, че има само + +

144
00:08:50,000 --> 00:08:52,000
, което означава, че нарастване с 1 всеки път.

145
00:08:52,000 --> 00:08:55,000
Вие също може да се направи нещо като + = 2,

146
00:08:55,000 --> 00:08:58,000
което означава, добавят се 2 всеки път, когато отидете през примката.

147
00:08:58,000 --> 00:09:03,000
И тогава направи това точно се отнася до кода, който всъщност стартира като част от цикъла.

148
00:09:03,000 --> 00:09:09,000
И за известно време контур, този път ние всъщност имат инициализация извън цикъла,

149
00:09:09,000 --> 00:09:12,000
Така например, нека да кажем, че ние се опитваме да направим един и същ тип линия, както току-що описах.

150
00:09:12,000 --> 00:09:16,000
Бихме казали, Int = 0 преди цикъла започва.

151
00:09:16,000 --> 00:09:20,000
Тогава бихме могли да кажем, докато аз <10 направите това,

152
00:09:20,000 --> 00:09:22,000
така същия блок на кода, както и преди,

153
00:09:22,000 --> 00:09:26,000
и този път актуализация на част от кода, например, аз + +,

154
00:09:26,000 --> 00:09:29,000
всъщност става в рамките на цикъла.

155
00:09:29,000 --> 00:09:33,000
И накрая, за време, той е подобен на линия, докато

156
00:09:33,000 --> 00:09:36,000
но ние трябва да помним, че кодът ще оцени веднъж

157
00:09:36,000 --> 00:09:40,000
преди условие се проверява, така че има много повече смисъл

158
00:09:40,000 --> 00:09:44,000
ако го погледнеш по ред от горе до долу.

159
00:09:44,000 --> 00:09:49,000
В правя, докато линия на код оценява преди дори да погледнете, докато условие,

160
00:09:49,000 --> 00:09:55,000
като има предвид, че докато контур, той проверява на първо място.

161
00:09:55,000 --> 00:09:59,000
Отчети и променливи.

162
00:09:59,000 --> 00:10:04,000
Когато искаме да създадем нова променлива, ние първо искам да го инициализира.

163
00:10:04,000 --> 00:10:07,000
>> Например, вътр бар инициализира променлива бар,

164
00:10:07,000 --> 00:10:10,000
но тя не даде стойност, така че това, което е стойността на бара сега?

165
00:10:10,000 --> 00:10:12,000
Ние не знаем.

166
00:10:12,000 --> 00:10:14,000
Тя може да бъде някаква боклук стойност, която е предварително съхраняват в паметта,

167
00:10:14,000 --> 00:10:16,000
и не искате да използвате тази променлива

168
00:10:16,000 --> 00:10:19,000
докато ние всъщност го даде стойност,

169
00:10:19,000 --> 00:10:21,000
така че ние го заявявам тук.

170
00:10:21,000 --> 00:10:24,000
Тогава ние се инициализира тя да бъде 42 по-долу.

171
00:10:24,000 --> 00:10:28,000
Сега, разбира се, знаем, че това може да бъде направено на един ред, вътр бар = 42.

172
00:10:28,000 --> 00:10:30,000
Но само за да се изчистите няколко стъпки, които се случват,

173
00:10:30,000 --> 00:10:34,000
декларацията и инициализация се случват отделно тук.

174
00:10:34,000 --> 00:10:38,000
Това се случва на една стъпка, и следващата, вътр Баз = бар + 1,

175
00:10:38,000 --> 00:10:44,000
това изявление по-долу, че стъпка Баз, така че в края на този кодекс блок

176
00:10:44,000 --> 00:10:48,000
ако бяхме да се отпечатва стойността на Баз би било 44

177
00:10:48,000 --> 00:10:52,000
защото ние заявяваме и да я инициализираме да бъде 1 бар>

178
00:10:52,000 --> 00:10:58,000
и после го увеличите още веднъж с + +.

179
00:10:58,000 --> 00:11:02,000
Минахме през този доста кратко, но е добре да има общ

180
00:11:02,000 --> 00:11:04,000
разбиране на какви теми и събития.

181
00:11:04,000 --> 00:11:06,000
Ние основно се направи това Scratch

182
00:11:06,000 --> 00:11:09,000
така че можеш да се сетиш на теми като няколко поредици от код

183
00:11:09,000 --> 00:11:11,000
в същото време.

184
00:11:11,000 --> 00:11:14,000
В действителност, това вероятно не работи в същото време,

185
00:11:14,000 --> 00:11:17,000
а по-скоро абстрактно можем да мисля за него по този начин.

186
00:11:17,000 --> 00:11:20,000
>> Scratch, например, имахме няколко спрайтове.

187
00:11:20,000 --> 00:11:22,000
Тя може да бъде изпълнителен различен код в същото време.

188
00:11:22,000 --> 00:11:26,000
Човек може да се разхожда, а другият е да кажа нещо

189
00:11:26,000 --> 00:11:29,000
в друга част на екрана.

190
00:11:29,000 --> 00:11:34,000
Събитията са друг начин за отделяне на логиката

191
00:11:34,000 --> 00:11:37,000
между различните елементи на кода си,

192
00:11:37,000 --> 00:11:40,000
и Scratch бяхме в състояние да симулира събития с помощта на излъчване,

193
00:11:40,000 --> 00:11:43,000
и това е всъщност, когато получа, а не, когато чуя,

194
00:11:43,000 --> 00:11:47,000
но по същество това е начин за предаване на информация

195
00:11:47,000 --> 00:11:49,000
от един към друг спрайт.

196
00:11:49,000 --> 00:11:52,000
Например, може да искате да предават играта свърши,

197
00:11:52,000 --> 00:11:56,000
и когато друг спрайт получи играта,

198
00:11:56,000 --> 00:11:58,000
тя реагира по определен начин.

199
00:11:58,000 --> 00:12:03,000
Това е важен модел, за да се разбере за програмиране.

200
00:12:03,000 --> 00:12:07,000
Само да отида над основния седмица 0, това, което ние сме отишли ​​досега,

201
00:12:07,000 --> 00:12:10,000
нека да погледнем на тази проста програма C.

202
00:12:10,000 --> 00:12:14,000
Текстът може да бъде малко по-малък от тук, но аз ще отида над него наистина бързо.

203
00:12:14,000 --> 00:12:20,000
Ние сме две заглавни файлове на върха, cs50.h и stdio.h.

204
00:12:20,000 --> 00:12:23,000
След това определяне на постоянна лимит до 100 години.

205
00:12:23,000 --> 00:12:26,000
След това изпълнението на нашата основна функция.

206
00:12:26,000 --> 00:12:29,000
Тъй като ние не използват аргументи от командния ред тук трябва да се сложи невалидни

207
00:12:29,000 --> 00:12:32,000
като аргументи за основната.

208
00:12:32,000 --> 00:12:38,000
Виждаме INT-горе основни. Това е типът на връщане, следователно върне 0 в долния край.

209
00:12:38,000 --> 00:12:41,000
И ние използваме CS50 библиотека функция се Int

210
00:12:41,000 --> 00:12:45,000
да поиска от потребителя за вход, и ние го съхранява в тази променлива х,

211
00:12:45,000 --> 00:12:51,000
така че ние заявяваме, х-горе, и ние го инициализира с х = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> След това проверете, ако потребителят ни даде добър вход.

213
00:12:53,000 --> 00:12:59,000
Ако това е ≥ LIMIT искаме да се върне код за грешка от 1 и отпечатване на съобщение за грешка.

214
00:12:59,000 --> 00:13:02,000
И накрая, ако потребителят е ни е дал добър вход

215
00:13:02,000 --> 00:13:08,000
ние ще площад броя и отпечатате този резултат.

216
00:13:08,000 --> 00:13:11,000
Просто за да се уверите, че тези, хит у дома

217
00:13:11,000 --> 00:13:17,000
можете да видите етикетите на различни части на код.

218
00:13:17,000 --> 00:13:19,000
Споменах Констант, заглавни файлове.

219
00:13:19,000 --> 00:13:21,000
О, вътр х. Уверете се, че да се помни, че е локална променлива.

220
00:13:21,000 --> 00:13:24,000
Това контрастира от глобална променлива, която ние ще говорим за

221
00:13:24,000 --> 00:13:27,000
малко по-късно в рамките на прегледа на сесията,

222
00:13:27,000 --> 00:13:30,000
и ние призоваваме библиотека функция ФОРМАТ

223
00:13:30,000 --> 00:13:34,000
така че ако не бяхме включени stdio.h заглавен файл

224
00:13:34,000 --> 00:13:37,000
нямаше да сме в състояние да се обадя ФОРМАТ.

225
00:13:37,000 --> 00:13:42,000
И аз вярвам, че стрелката, която се отсече тук е насочена към% г,

226
00:13:42,000 --> 00:13:45,000
форматиране на низ в ФОРМАТ.

227
00:13:45,000 --> 00:13:52,000
Той казва отпечатате тази променлива, тъй като редица% г.

228
00:13:52,000 --> 00:13:58,000
И това е за седмица 0.

229
00:13:58,000 --> 00:14:06,000
Сега Лукас ще продължи.

230
00:14:06,000 --> 00:14:08,000
Хей, момчета. Моето име е Лукас.

231
00:14:08,000 --> 00:14:10,000
Съм второкурсник в най-хубавата къща в колежа, Mather,

232
00:14:10,000 --> 00:14:14,000
и аз отивам да поговорим малко за седмица 1 и 2.1.

233
00:14:14,000 --> 00:14:16,000
[Седмица 1 и 2.1!] [Лукас Freitas]

234
00:14:16,000 --> 00:14:19,000
Като Lexi казваше, когато започнахме превода код от нулата C

235
00:14:19,000 --> 00:14:23,000
едно от нещата, които забелязах е, че можете не само

236
00:14:23,000 --> 00:14:26,000
напишете кода си и да го стартирате с помощта на зелен флаг вече.

237
00:14:26,000 --> 00:14:30,000
Всъщност, вие трябва да използвате някои стъпки, за да направите вашия C програма

238
00:14:30,000 --> 00:14:33,000
се превърне в изпълним файл.

239
00:14:33,000 --> 00:14:36,000
По принцип това, което правите, когато сте написването на програмата е, че

240
00:14:36,000 --> 00:14:40,000
превод идеята си на език, който може да разбере компилатор

241
00:14:40,000 --> 00:14:44,000
така че когато сте написването на програмата в C

242
00:14:44,000 --> 00:14:47,000
какво правиш всъщност пишете нещо, което компилатора няма да разбере,

243
00:14:47,000 --> 00:14:50,000
и след това компилатора ще преведе този код

244
00:14:50,000 --> 00:14:53,000
в нещо, че компютърът ви ще разберат.

245
00:14:53,000 --> 00:14:55,000
>> И това нещо е, че компютърът ви е много тъпо.

246
00:14:55,000 --> 00:14:57,000
Вашият компютър може да разбере 0s и 1s

247
00:14:57,000 --> 00:15:01,000
Така че всъщност в първите компютри хора, които обикновено са програмирани

248
00:15:01,000 --> 00:15:04,000
използване на 0s и 1s, но вече не, благодаря на Бога.

249
00:15:04,000 --> 00:15:07,000
Ние не трябва да запомните последователности за 0s и 1s

250
00:15:07,000 --> 00:15:10,000
за линия или за известно време контур и така нататък.

251
00:15:10,000 --> 00:15:13,000
Ето защо имаме компилатор.

252
00:15:13,000 --> 00:15:17,000
Какво компилатор е основно превежда код C,

253
00:15:17,000 --> 00:15:21,000
в нашия случай, на език, който вашият компютър ще разбере,

254
00:15:21,000 --> 00:15:25,000
, която е обект код и компилатор, който ние използваме

255
00:15:25,000 --> 00:15:30,000
се нарича ехтя, така че това е всъщност символ на ехтя.

256
00:15:30,000 --> 00:15:33,000
Когато имате вашата програма, което трябва да направите две неща.

257
00:15:33,000 --> 00:15:37,000
Първо, вие трябва да компилирате вашата програма, и след това започваш да изпълнявате вашата програма.

258
00:15:37,000 --> 00:15:41,000
За да компилирате програмата, имате много възможности да го направят.

259
00:15:41,000 --> 00:15:44,000
Първата е да се направи program.c ехтя

260
00:15:44,000 --> 00:15:47,000
в коя програма е името на вашата програма.

261
00:15:47,000 --> 00:15:51,000
В този случай можете да видите, те просто казват "Хей, съставя програмата ми."

262
00:15:51,000 --> 00:15:56,000
Ти не си казва: "Искам това име за моята програма" или нещо.

263
00:15:56,000 --> 00:15:58,000
>> Вторият вариант е да се дава име на вашата програма.

264
00:15:58,000 --> 00:16:02,000
Може да се каже ехтя-о, а след това името, което искате

265
00:16:02,000 --> 00:16:06,000
изпълнимия файл да бъде назован както и program.c.

266
00:16:06,000 --> 00:16:11,000
И вие също може да правят програма, и да видим как в първите два случая

267
00:16:11,000 --> 00:16:15,000
Сложих в., и в третия имам само програми?

268
00:16:15,000 --> 00:16:18,000
Да, всъщност не трябва да поставят. В., когато използвате.

269
00:16:18,000 --> 00:16:22,000
В противен случай компилаторът всъщност се случва да ти крещя.

270
00:16:22,000 --> 00:16:24,000
И също така, аз не знам дали вие спомняте,

271
00:16:24,000 --> 00:16:29,000
но много пъти ние също използва lcs50 или LM.

272
00:16:29,000 --> 00:16:31,000
Това се нарича свързване.

273
00:16:31,000 --> 00:16:35,000
Тя просто казва на компилатора, че ще използвате тези библиотеки точно там,

274
00:16:35,000 --> 00:16:39,000
така че, ако искате да използвате cs50.h всъщност трябва да въведете

275
00:16:39,000 --> 00:16:43,000
ехтя program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Ако не направим това, компилаторът няма да знаят

277
00:16:45,000 --> 00:16:50,000
, че използвате тези функции в cs50.h.

278
00:16:50,000 --> 00:16:52,000
А когато искате да изпълнявате вашата програма, имате две възможности.

279
00:16:52,000 --> 00:16:57,000
Ако сте направили ехтя program.c вие не дадете име на вашата програма.

280
00:16:57,000 --> 00:17:01,000
Трябва да го стартирате. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out е стандартен името, ехтя дава програмата си, ако не му се даде име.

282
00:17:06,000 --> 00:17:11,000
В противен случай ти започваш да се направи. / Програма, ако ви е дал име на вашата програма,

283
00:17:11,000 --> 00:17:15,000
а също и ако направи програма на име, че програмата ще да се получи

284
00:17:15,000 --> 00:17:23,000
вече ще бъдат програмирани същото име като файла в.

285
00:17:23,000 --> 00:17:26,000
Тогава говорихме за типове данни и данни.

286
00:17:26,000 --> 00:17:31,000
>> По принцип типове данни са едно и също нещо като малки кутийки, които те използват

287
00:17:31,000 --> 00:17:35,000
за съхранение на ценности, така че типове данни всъщност са точно като Pokemons.

288
00:17:35,000 --> 00:17:39,000
Те идват във всички размери и видове.

289
00:17:39,000 --> 00:17:43,000
Аз не знам дали тази аналогия има смисъл.

290
00:17:43,000 --> 00:17:46,000
Размера на данните всъщност зависи от архитектурата на машината.

291
00:17:46,000 --> 00:17:49,000
Всички данни, размери, че аз ще покажа тук

292
00:17:49,000 --> 00:17:53,000
всъщност са за 32-битова машина, какъвто е случаят на нашия уред,

293
00:17:53,000 --> 00:17:56,000
но ако вие всъщност кодиране на вашия Mac или в Windows

294
00:17:56,000 --> 00:17:59,000
вероятно ти започваш да имат 64-битова машина,

295
00:17:59,000 --> 00:18:03,000
така че не забравяйте, че размера на данните, че аз отивам да се покаже тук

296
00:18:03,000 --> 00:18:06,000
са за 32-битова машина.

297
00:18:06,000 --> 00:18:08,000
Първата, която видяхме беше вътр

298
00:18:08,000 --> 00:18:10,000
което е доста ясен.

299
00:18:10,000 --> 00:18:13,000
Можете да използвате INT за съхранение на цяло число.

300
00:18:13,000 --> 00:18:16,000
Видяхме характера, Чар.

301
00:18:16,000 --> 00:18:20,000
Ако искате да използвате писмо или малък символ, който най-вероятно ще използва Чар.

302
00:18:20,000 --> 00:18:26,000
Чар има един байт, което означава, 8 бита, като Lexi каза.

303
00:18:26,000 --> 00:18:31,000
По принцип имаме ASCII таблица, която има 256

304
00:18:31,000 --> 00:18:34,000
възможни комбинации на 0s и 1s

305
00:18:34,000 --> 00:18:37,000
и след това, когато въвеждате Чар, че ще превежда

306
00:18:37,000 --> 00:18:44,000
характер, че входове номер, който имате в ASCII таблица, като Lexi.

307
00:18:44,000 --> 00:18:48,000
Ние също имаме поплавък, който ние използваме за съхраняване на десетични числа.

308
00:18:48,000 --> 00:18:53,000
Ако искате да изберете 3.14, например, започваш да се използва плувка

309
00:18:53,000 --> 00:18:55,000
или двойно по-голяма прецизност.

310
00:18:55,000 --> 00:18:57,000
Плаващата платформа има 4 байта.

311
00:18:57,000 --> 00:19:01,000
Двойно има 8 байта, така че единствената разлика е прецизността.

312
00:19:01,000 --> 00:19:04,000
Ние също имаме дълго време, че се използва за цели числа,

313
00:19:04,000 --> 00:19:09,000
и можете да видите за 32-битова машина вътр и дълъг са със същия размер,

314
00:19:09,000 --> 00:19:13,000
така че не наистина да има смисъл да се използва дълго време в 32-битова машина.

315
00:19:13,000 --> 00:19:17,000
>> Но ако сте с помощта на Mac и 64-битова машина, всъщност има размер 8,

316
00:19:17,000 --> 00:19:19,000
така че наистина зависи от архитектурата.

317
00:19:19,000 --> 00:19:22,000
За 32-битова машина няма смисъл да се използва дълго наистина.

318
00:19:22,000 --> 00:19:25,000
И тогава много дълго, от друга страна, има 8 байта,

319
00:19:25,000 --> 00:19:30,000
така че е много добре, ако искате да имате по-дълго цяло число.

320
00:19:30,000 --> 00:19:34,000
И накрая, имаме низ, който всъщност е знак *,

321
00:19:34,000 --> 00:19:37,000
което е указател на знака.

322
00:19:37,000 --> 00:19:40,000
Това е много лесно да се мисли, че размерът на низа ще бъде като

323
00:19:40,000 --> 00:19:42,000
броя на символите, които имате там,

324
00:19:42,000 --> 00:19:45,000
но всъщност Чар себе си *

325
00:19:45,000 --> 00:19:49,000
размера на показалеца на знака, който е 4 байта.

326
00:19:49,000 --> 00:19:52,000
Размерът на Чар * е 4 байта.

327
00:19:52,000 --> 00:19:56,000
Няма значение дали имате малък дума или писмо или нещо.

328
00:19:56,000 --> 00:19:58,000
Това ще е 4 байта.

329
00:19:58,000 --> 00:20:01,000
Ние също така научих малко за леене,

330
00:20:01,000 --> 00:20:04,000
така че можете да видите, ако имате, например, една програма, която казва

331
00:20:04,000 --> 00:20:08,000
Int х = 3 и след това ФОРМАТ ("% г", Х / 2)

332
00:20:08,000 --> 00:20:12,000
вие знаете какво ще да отпечатате на екрана?

333
00:20:12,000 --> 00:20:14,000
>> Някой? >> [Студенти] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, да.

335
00:20:16,000 --> 00:20:20,000
Когато направите 3/2 ще получи 1.5,

336
00:20:20,000 --> 00:20:24,000
, но тъй като ние сме с помощта на цяло число, че ще игнорира частта от цялото,

337
00:20:24,000 --> 00:20:26,000
и ти започваш да има една.

338
00:20:26,000 --> 00:20:29,000
Ако не искате това да се случи това, което можете да направите, например,

339
00:20:29,000 --> 00:20:33,000
обяви плувка у = х.

340
00:20:33,000 --> 00:20:40,000
Тогава х, които са били три, сега щеше да бъде 3.000 в г..

341
00:20:40,000 --> 00:20:44,000
И тогава можете да отпечатате г. / 2.

342
00:20:44,000 --> 00:20:50,000
Всъщност, аз трябва да имат два. там.

343
00:20:50,000 --> 00:20:55,000
Ще направи 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
и ти започваш да получите 1.5.

345
00:20:58,000 --> 00:21:06,000
И ние имаме това 0.2 е само да попитам за две десетични единици в десетичната част.

346
00:21:06,000 --> 00:21:12,000
Ако имате 0.3 е, че ще има действително 1,500.

347
00:21:12,000 --> 00:21:16,000
Ако е 2, тя ще бъде 1,50.

348
00:21:16,000 --> 00:21:18,000
Ние също имаме този случай.

349
00:21:18,000 --> 00:21:22,000
Ако го направите плувка х = 3,14 и след това можете ФОРМАТ х

350
00:21:22,000 --> 00:21:24,000
ти започваш да се получи 3,14.

351
00:21:24,000 --> 00:21:29,000
И ако го направите х = Int от х,

352
00:21:29,000 --> 00:21:34,000
което означава лечение на х като едно цяло число и да отпечатате х сега

353
00:21:34,000 --> 00:21:36,000
ти започваш да имат 3.00.

354
00:21:36,000 --> 00:21:38,000
Това прави ли смисъл?

355
00:21:38,000 --> 00:21:41,000
Защото вие сте първият лечение на х като цяло число, така че без да обръща внимание на десетичната част,

356
00:21:41,000 --> 00:21:45,000
и след това сте отпечатване.

357
00:21:45,000 --> 00:21:47,000
И накрая, можете да направите това,

358
00:21:47,000 --> 00:21:52,000
Int х = 65, а след това обяви Чар C = X,

359
00:21:52,000 --> 00:21:56,000
и тогава, ако отпечатате в който всъщност ще се получи

360
00:21:56,000 --> 00:21:59,000
А, така че в общи линии какво правиш тук

361
00:21:59,000 --> 00:22:02,000
превода на цяло число в героя,

362
00:22:02,000 --> 00:22:05,000
точно като ASCII таблица.

363
00:22:05,000 --> 00:22:08,000
Ние също така говорихме за математически оператори.

364
00:22:08,000 --> 00:22:14,000
Повечето от тях са доста ясен, така че +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
, а също и ние говорихме за Министерството на отбраната, който е останалата част на разделяне на две числа.

366
00:22:20,000 --> 00:22:23,000
Ако имате 10% 3, например,

367
00:22:23,000 --> 00:22:27,000
това означава, раздели 10 на 3 и каква е останалата част?

368
00:22:27,000 --> 00:22:30,000
Това ще бъде една, така че това е действително много полезно за много от програмите.

369
00:22:30,000 --> 00:22:38,000
, За Vigenère и Цезар Аз съм сигурен, че всички от вас, момчета използва мод.

370
00:22:38,000 --> 00:22:43,000
За математически оператори, да бъдат много внимателни, когато се комбинират * и /.

371
00:22:43,000 --> 00:22:48,000
>> Така например, ако го направите (3/2) * 2 какво ще да получа?

372
00:22:48,000 --> 00:22:50,000
[Студенти] 2.

373
00:22:50,000 --> 00:22:54,000
Да, две, защото 3/2 ще бъде 1,5,

374
00:22:54,000 --> 00:22:57,000
но тъй като правиш операции между две числа

375
00:22:57,000 --> 00:22:59,000
всъщност сте просто ще разгледа 1,

376
00:22:59,000 --> 00:23:03,000
и след 1 * 2 ще бъде 2, така че бъдете много, много внимателни

377
00:23:03,000 --> 00:23:07,000
когато правиш аритметиката с числа, защото

378
00:23:07,000 --> 00:23:12,000
може да се получи, че 2 = 3, в този случай.

379
00:23:12,000 --> 00:23:14,000
А също да бъдат много внимателни, за предимство.

380
00:23:14,000 --> 00:23:21,000
Обикновено трябва да използвате скоби, за да бъдат сигурни, че знаете какво правите.

381
00:23:21,000 --> 00:23:27,000
Някои полезни клавишни комбинации, разбира се, едно е + + или аз + = 1

382
00:23:27,000 --> 00:23:30,000
или използването + =.

383
00:23:30,000 --> 00:23:34,000
Това е същото нещо като I = I + 1.

384
00:23:34,000 --> 00:23:39,000
Можете също така да правя - или - = 1,

385
00:23:39,000 --> 00:23:42,000
, което е едно и също нещо, както аз = I -1,

386
00:23:42,000 --> 00:23:46,000
нещо, което вие използвате много за електрически вериги, най-малко.

387
00:23:46,000 --> 00:23:52,000
Също така, за *, ако използвате * = и ако го направите, например,

388
00:23:52,000 --> 00:23:57,000
I * = 2 е едно и също нещо да казва, че I = I * 2,

389
00:23:57,000 --> 00:23:59,000
и също нещо за разделяне.

390
00:23:59,000 --> 00:24:08,000
Ако мога / = 2, това е същото нещо като I = I / 2.

391
00:24:08,000 --> 00:24:10,000
>> Сега за функциите.

392
00:24:10,000 --> 00:24:13,000
Вие, момчета, научих, че функции са много добра стратегия, за да спаси код

393
00:24:13,000 --> 00:24:16,000
докато сте програмиране, така че ако искате да изпълняват същата задача

394
00:24:16,000 --> 00:24:20,000
код отново и отново, вероятно искате да използвате функция

395
00:24:20,000 --> 00:24:25,000
така че не е нужно да копирате и поставите кода отново и отново.

396
00:24:25,000 --> 00:24:28,000
Всъщност, основната е функция, и когато ви покаже формата на функция

397
00:24:28,000 --> 00:24:32,000
вие ще видите, че това е доста очевидно.

398
00:24:32,000 --> 00:24:35,000
Ние също използваме функции от някои библиотеки,

399
00:24:35,000 --> 00:24:39,000
например, ФОРМАТ GetIn, което е от библиотеката CS50

400
00:24:39,000 --> 00:24:43,000
и други функции като toupper.

401
00:24:43,000 --> 00:24:46,000
Всички тези функции се прилагат на други библиотеки,

402
00:24:46,000 --> 00:24:49,000
и когато тези връзване на файлове в началото на вашата програма

403
00:24:49,000 --> 00:24:53,000
казваш, може да ви моля, дайте ми код за изпълнението на тези функции

404
00:24:53,000 --> 00:24:57,000
така че аз не трябва да ги изпълнява с себе си?

405
00:24:57,000 --> 00:25:00,000
И вие също може да напишете вашите собствени функции, така че, когато започнете програмирането

406
00:25:00,000 --> 00:25:04,000
ти осъзнаваш, че библиотеките не разполагат с всички функции, от които имате нужда.

407
00:25:04,000 --> 00:25:10,000
За последната pset, например, пише, рисуват, катерене, и търсене,

408
00:25:10,000 --> 00:25:13,000
и това е много, много важно да бъде в състояние да напише функции

409
00:25:13,000 --> 00:25:17,000
защото те са полезни, а ние ги използва през цялото време в програмирането,

410
00:25:17,000 --> 00:25:19,000
и тя спестява много код.

411
00:25:19,000 --> 00:25:21,000
Форматът на функция е тази.

412
00:25:21,000 --> 00:25:24,000
Връщания тип в началото. Какъв е типът на връщане?

413
00:25:24,000 --> 00:25:27,000
Това е просто, когато Ви функция ще се върне.

414
00:25:27,000 --> 00:25:29,000
Ако имате функция, например, факторен,

415
00:25:29,000 --> 00:25:31,000
, който ще се изчислява факториела на цяло число,

416
00:25:31,000 --> 00:25:34,000
вероятно ще се върне цяло число.

417
00:25:34,000 --> 00:25:37,000
Тогава типът на връщане ще бъде Int.

418
00:25:37,000 --> 00:25:41,000
ФОРМАТ всъщност има невалидни връщания тип

419
00:25:41,000 --> 00:25:43,000
защото вие не връщате нищо.

420
00:25:43,000 --> 00:25:45,000
Ти си просто отпечатване неща на екрана

421
00:25:45,000 --> 00:25:48,000
и отказването на функцията след това.

422
00:25:48,000 --> 00:25:51,000
След това имате името на функцията, която можете да избирате.

423
00:25:51,000 --> 00:25:55,000
Трябва да бъде малко по-разумно, като не изберете име като XYZ

424
00:25:55,000 --> 00:25:58,000
или като x2f.

425
00:25:58,000 --> 00:26:02,000
Опитайте се да направите име, което има смисъл.

426
00:26:02,000 --> 00:26:04,000
>> Например, ако това е предпоставки, които казват фактори.

427
00:26:04,000 --> 00:26:08,000
Ако това е функция, която ще нарисуваш нещо, кръстете го привлече.

428
00:26:08,000 --> 00:26:11,000
И тогава ние имаме параметри, които също са наречени аргументи,

429
00:26:11,000 --> 00:26:14,000
които са като ресурсите, които функция трябва

430
00:26:14,000 --> 00:26:17,000
от кода си, за да изпълни своята задача.

431
00:26:17,000 --> 00:26:20,000
Ако искате да изчислите факториела на число

432
00:26:20,000 --> 00:26:23,000
вероятно трябва да има номер, за да се изчисли факториел.

433
00:26:23,000 --> 00:26:27,000
Един от аргументите, че започваш да има, е самото число.

434
00:26:27,000 --> 00:26:31,000
И тогава той ще направи нещо и да се върнете стойност в края

435
00:26:31,000 --> 00:26:35,000
освен ако не е функция празнота.

436
00:26:35,000 --> 00:26:37,000
Нека да видим един пример.

437
00:26:37,000 --> 00:26:40,000
Ако искам да напиша функция, която сумира всички числа в масив от цели числа,

438
00:26:40,000 --> 00:26:43,000
на първо място, типът на връщане ще бъде INT

439
00:26:43,000 --> 00:26:46,000
защото имам масив от цели числа.

440
00:26:46,000 --> 00:26:51,000
И тогава ще се наложи името на функцията като sumArray,

441
00:26:51,000 --> 00:26:54,000
и след това ще вземе със самия масив, за да INT Nums,

442
00:26:54,000 --> 00:26:58,000
и тогава дължината на масива, така че знам колко числа трябва да обобщим.

443
00:26:58,000 --> 00:27:02,000
След това трябва да се инициализира променлива сума, например, до 0,

444
00:27:02,000 --> 00:27:08,000
и всеки път, когато видя елемент в масива трябва да го добави към сумата, така че аз го направих за цикъл.

445
00:27:08,000 --> 00:27:15,000
Точно както Lexi каза, нали Int = 0, I <дължина и аз + +.

446
00:27:15,000 --> 00:27:20,000
И за всеки елемент в масива сума + = Nums [I],

447
00:27:20,000 --> 00:27:24,000
и след това се върнах на сумата, така че е много проста и тя спестява много код

448
00:27:24,000 --> 00:27:28,000
ако използвате тази функция много пъти.

449
00:27:28,000 --> 00:27:32,000
Тогава взехме погледнете условия.

450
00:27:32,000 --> 00:27:38,000
Ние имаме, ако друго, и друго, ако.

451
00:27:38,000 --> 00:27:42,000
Нека видим каква е разликата между тези.

452
00:27:42,000 --> 00:27:45,000
Обърнете внимание на тези две кодове. Каква е разликата между тях?

453
00:27:45,000 --> 00:27:49,000
Първият от тях е основно кодовете искам да кажа

454
00:27:49,000 --> 00:27:51,000
Ако даден номер е +, -, или 0.

455
00:27:51,000 --> 00:27:55,000
Първият казва, че ако е> 0, тогава това е положително.

456
00:27:55,000 --> 00:28:00,000
Ако това е = 0, тогава това е 0, а ако е <0, тогава е отрицателен.

457
00:28:00,000 --> 00:28:04,000
>> А другият се прави, ако, в противен случай, ако друго.

458
00:28:04,000 --> 00:28:07,000
Разликата между двете е, че това всъщност ще

459
00:28:07,000 --> 00:28:13,000
проверите дали> 0 <0 или = 0 три пъти,

460
00:28:13,000 --> 00:28:17,000
така че ако имате 2 броя, например, ще да дойде тук и да каже

461
00:28:17,000 --> 00:28:21,000
ако (х> 0), и тя ще каже "да", така че аз отпечатате положителен.

462
00:28:21,000 --> 00:28:25,000
Но, въпреки че знам, че това е> 0 и това няма да бъде 0 или <0

463
00:28:25,000 --> 00:28:29,000
Аз съм все още ще е 0, то е <0,

464
00:28:29,000 --> 00:28:33,000
така че аз съм всъщност се случва вътре на IFS, че не трябва да

465
00:28:33,000 --> 00:28:38,000
защото аз вече знам, че няма да отговаря на някое от тези условия.

466
00:28:38,000 --> 00:28:41,000
Мога да използвам, ако друго, ако друго изявление.

467
00:28:41,000 --> 00:28:45,000
Това основно се казва, че ако х = 0 отпечатате положителен.

468
00:28:45,000 --> 00:28:48,000
Ако не е, аз отивам да тествате това.

469
00:28:48,000 --> 00:28:51,000
Ако това е два Отивам да направите това.

470
00:28:51,000 --> 00:28:54,000
По принцип, ако имах х = 2 бихте казали

471
00:28:54,000 --> 00:28:57,000
ако (х> 0), да, така отпечатате.

472
00:28:57,000 --> 00:29:00,000
Сега знам, че това е> 0 и че е изпълнил първо, ако

473
00:29:00,000 --> 00:29:02,000
Дори няма да работи този код.

474
00:29:02,000 --> 00:29:09,000
Кодът работи по-бързо, всъщност, три пъти по-бързо, ако използвате тази.

475
00:29:09,000 --> 00:29:11,000
Ние също така научих за и.

476
00:29:11,000 --> 00:29:15,000
Аз няма да мине през това,, защото Lexi вече говорихме за тях.

477
00:29:15,000 --> 00:29:17,000
Това е просто && и | | оператор.

478
00:29:17,000 --> 00:29:21,000
>> Единственото нещо, което ще кажа е, бъдете внимателни, когато има три условия.

479
00:29:21,000 --> 00:29:24,000
Използвайте скоби, защото това е много объркващо, когато имате състояние

480
00:29:24,000 --> 00:29:27,000
и още един или друг.

481
00:29:27,000 --> 00:29:30,000
Използвайте скоби, за да се уверите, че вашите условия имат смисъл

482
00:29:30,000 --> 00:29:34,000
, защото в този случай, например, можете да си представите, че

483
00:29:34,000 --> 00:29:38,000
тя може да бъде първото условие и на една или друга

484
00:29:38,000 --> 00:29:41,000
или две условия, съчетани по

485
00:29:41,000 --> 00:29:45,000
или третия, така че просто бъдете внимателни.

486
00:29:45,000 --> 00:29:48,000
И накрая, ние говорихме за ключове.

487
00:29:48,000 --> 00:29:53,000
Превключвател е много полезно, когато имате променлива.

488
00:29:53,000 --> 00:29:55,000
Да кажем, че имате променлива като N

489
00:29:55,000 --> 00:29:59,000
която може да бъде 0, 1 или 2, както и за всеки от тези случаи

490
00:29:59,000 --> 00:30:01,000
ти започваш да се изпълни дадена задача.

491
00:30:01,000 --> 00:30:04,000
Може да се каже включите променлива, и това показва, че

492
00:30:04,000 --> 00:30:08,000
стойност, то е като value1 аз ще направя това,

493
00:30:08,000 --> 00:30:12,000
и след това се счупи, което означава, че няма да изглежда на някой от останалите случаи

494
00:30:12,000 --> 00:30:15,000
защото ние вече убеден, че делото

495
00:30:15,000 --> 00:30:20,000
и след това стойност2 и така нататък, и аз също да са снабдени с ключ по подразбиране.

496
00:30:20,000 --> 00:30:24,000
Това означава, че ако тя не отговаря на някой от случаите, които имах

497
00:30:24,000 --> 00:30:29,000
че аз отивам да правя нещо друго, но това е задължително.

498
00:30:29,000 --> 00:30:36,000
Това е всичко за мен. Сега нека да Томи.

499
00:30:36,000 --> 00:30:41,000
Добре, това ще бъде Седмица 3-Иш.

500
00:30:41,000 --> 00:30:45,000
Това са някои от темите, които ще се покрива, крипто, обхват, масиви, и т.н..

501
00:30:45,000 --> 00:30:49,000
Само един бърз дума за крипто. Ние няма да чука на този дом.

502
00:30:49,000 --> 00:30:52,000
>> Ние направихме това в pset 2, но за теста се уверете, че знаете разликата

503
00:30:52,000 --> 00:30:54,000
между шифър на Цезар и Vigenère шифър,

504
00:30:54,000 --> 00:30:57,000
как и на тези шифри работа и какво е искал да криптирате

505
00:30:57,000 --> 00:30:59,000
и декриптиране на текст с помощта на тези две шифри.

506
00:30:59,000 --> 00:31:03,000
Не забравяйте, че Цезар шифър просто се върти всеки знак със същата сума,

507
00:31:03,000 --> 00:31:06,000
така че да сте сигурни, че Министерството на отбраната на броя на буквите в азбуката.

508
00:31:06,000 --> 00:31:09,000
И Vigenère шифър, от друга страна, се върти всеки знак

509
00:31:09,000 --> 00:31:12,000
от различно количество, така че вместо да каже

510
00:31:12,000 --> 00:31:15,000
всеки герой завърта с 3 Vigenère ще се върти всеки знак

511
00:31:15,000 --> 00:31:17,000
с различна сума в зависимост от някои ключови думи

512
00:31:17,000 --> 00:31:20,000
където всяка буква в ключовата дума представлява някаква различна сума

513
00:31:20,000 --> 00:31:26,000
за да завъртите ясен текст.

514
00:31:26,000 --> 00:31:28,000
Нека първо да говори за променливи.

515
00:31:28,000 --> 00:31:30,000
Има два различни вида променливи.

516
00:31:30,000 --> 00:31:33,000
Имаме локални променливи, а те ще бъдат определени

517
00:31:33,000 --> 00:31:36,000
извън основната или извън всяка функция или блок,

518
00:31:36,000 --> 00:31:39,000
и те ще бъдат достъпни навсякъде в програмата си.

519
00:31:39,000 --> 00:31:41,000
Ако имате функция и тази функция е линия, докато

520
00:31:41,000 --> 00:31:44,000
голямата глобална променлива е достъпна навсякъде.

521
00:31:44,000 --> 00:31:48,000
Локална променлива, от друга страна, е обхват до мястото, където е дефинирана.

522
00:31:48,000 --> 00:31:53,000
>> Ако имате функция тук, например, ние имаме тази функция грама,

523
00:31:53,000 --> 00:31:56,000
и вътре в гр има променлива наречена г.,

524
00:31:56,000 --> 00:31:58,000
и това означава, че това е локална променлива.

525
00:31:58,000 --> 00:32:00,000
Въпреки, че тази променлива се нарича г.

526
00:32:00,000 --> 00:32:03,000
и тази променлива се нарича ÿ тези две функции

527
00:32:03,000 --> 00:32:06,000
нямат представа какви други локални променливи.

528
00:32:06,000 --> 00:32:10,000
От друга страна, тук ние казваме вътр х = 5,

529
00:32:10,000 --> 00:32:12,000
и това е извън обхвата на всяка функция.

530
00:32:12,000 --> 00:32:16,000
Това е извън обхвата на основния, така че това е глобална променлива.

531
00:32:16,000 --> 00:32:20,000
Това означава, че вътре в тези две функции, когато казвам, х - х + +

532
00:32:20,000 --> 00:32:26,000
Аз съм достъп до един и същ х като този г. и това г. са две различни променливи.

533
00:32:26,000 --> 00:32:30,000
Това е разликата между глобална променлива и локална променлива.

534
00:32:30,000 --> 00:32:33,000
Що се отнася до дизайна, понякога това е може би по-добра идея

535
00:32:33,000 --> 00:32:37,000
да запазите променливи местно, когато евентуално може

536
00:32:37,000 --> 00:32:39,000
тъй като един куп на глобалните променливи може да получите наистина объркващо.

537
00:32:39,000 --> 00:32:42,000
Ако имате куп функции всички модифициране на едно и също нещо

538
00:32:42,000 --> 00:32:45,000
може да забрави, какво ще стане, ако тази функция случайно променя тази глобална,

539
00:32:45,000 --> 00:32:47,000
и това друга функция не знае за това,

540
00:32:47,000 --> 00:32:50,000
и тя не получи доста объркващо, тъй като можете да получите повече код.

541
00:32:50,000 --> 00:32:53,000
Поддържане на променливи местно, когато евентуално може

542
00:32:53,000 --> 00:32:56,000
е просто добър дизайн.

543
00:32:56,000 --> 00:33:00,000
Масивите, не забравяйте, са просто списъци на елементи от един и същи вид.

544
00:33:00,000 --> 00:33:04,000
Inside CI не може да има списък като 1, 2.0, здравей.

545
00:33:04,000 --> 00:33:06,000
Ние просто не можем да направим това.

546
00:33:06,000 --> 00:33:11,000
>> Когато ние заявяваме масив в C всички елементи трябва да са от същия тип.

547
00:33:11,000 --> 00:33:14,000
Тук имам масив от три числа.

548
00:33:14,000 --> 00:33:18,000
Тук имам дължината на масива, но ако аз съм просто обявяване в този синтаксис

549
00:33:18,000 --> 00:33:21,000
където да се уточни какво всички елементи са не технически нужда от това 3.

550
00:33:21,000 --> 00:33:25,000
Компилаторът е достатъчно умен, за да разбера колко голям трябва да бъде масив.

551
00:33:25,000 --> 00:33:28,000
Сега, когато искате да получите или да настроите стойността на масив

552
00:33:28,000 --> 00:33:30,000
това е синтаксис, за да направи това.

553
00:33:30,000 --> 00:33:33,000
Това действително ще промени втория елемент на масива, защото, не забравяйте,

554
00:33:33,000 --> 00:33:36,000
номерацията започва от 0, а не 1.

555
00:33:36,000 --> 00:33:42,000
Ако искам да прочета тази стойност, мога да кажа, нещо като Int х = масив [1].

556
00:33:42,000 --> 00:33:44,000
Или ако искате да настроите тази стойност, като аз правя тук,

557
00:33:44,000 --> 00:33:47,000
Мога да кажа, масив [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Това време достъп до елементи от техния индекс

559
00:33:50,000 --> 00:33:52,000
или си положение или когато те са в масива,

560
00:33:52,000 --> 00:33:57,000
и че включването започва от 0.

561
00:33:57,000 --> 00:34:00,000
Можем също така да има масиви от масиви,

562
00:34:00,000 --> 00:34:03,000
и това се нарича мулти-мерен масив.

563
00:34:03,000 --> 00:34:05,000
Когато имаме много-измерен масив

564
00:34:05,000 --> 00:34:07,000
това означава, че ние можем да имаме нещо като редове и колони,

565
00:34:07,000 --> 00:34:11,000
и това е само един от начините за визуализиране на това или да мисля за това.

566
00:34:11,000 --> 00:34:14,000
Когато имам много-измерен масив, това означава, че ще започна да се налага

567
00:34:14,000 --> 00:34:17,000
повече от една индекс, защото ако имам мрежа

568
00:34:17,000 --> 00:34:19,000
просто казвам какъв ред сте не ни дава номер.

569
00:34:19,000 --> 00:34:22,000
Това е наистина само ще ни даде списък на телефонните номера.

570
00:34:22,000 --> 00:34:25,000
Да кажем, че имам този масив.

571
00:34:25,000 --> 00:34:30,000
Имам масив наречен мрежа, а аз казвам, че е два реда и три колони,

572
00:34:30,000 --> 00:34:32,000
и така това е един от начините да го визуализиране.

573
00:34:32,000 --> 00:34:37,000
Когато казвам, че искате да получите елемент в [1] [2]

574
00:34:37,000 --> 00:34:41,000
това означава, че тъй като това са редове и след това колони

575
00:34:41,000 --> 00:34:44,000
Отивам да скочи до ред 1, тъй като казах 1.

576
00:34:44,000 --> 00:34:49,000
>> Тогава аз ще дойда тук, за да колона 2, и аз отивам да получите стойността 6.

577
00:34:49,000 --> 00:34:51,000
Уверете се, ли смисъл?

578
00:34:51,000 --> 00:34:55,000
Многомерни масиви, не забравяйте, са технически масив от масиви.

579
00:34:55,000 --> 00:34:57,000
Ние можем да имаме масиви от масиви от масиви.

580
00:34:57,000 --> 00:35:00,000
Ние можем да продължим, но наистина един начин да мислим за

581
00:35:00,000 --> 00:35:03,000
това как се определят и какво ще е да се визуализира

582
00:35:03,000 --> 00:35:09,000
в мрежата по този начин.

583
00:35:09,000 --> 00:35:12,000
Когато минаваме масиви към функции, те започват да се държат

584
00:35:12,000 --> 00:35:16,000
малко по-различно, отколкото когато преминават обикновени променливи функции

585
00:35:16,000 --> 00:35:18,000
като полагане на вътр или с плаваща запетая.

586
00:35:18,000 --> 00:35:21,000
Когато преминават в INT или овъгли или която и да е от тези други данни

587
00:35:21,000 --> 00:35:24,000
ние просто се погледнете, ако функцията променя

588
00:35:24,000 --> 00:35:28,000
стойността на тази променлива, че промяната няма да се разпространяват на

589
00:35:28,000 --> 00:35:32,000
викащата функция.

590
00:35:32,000 --> 00:35:35,000
С масив, от друга страна, че ще се случи.

591
00:35:35,000 --> 00:35:39,000
Ако премине в масив до известна функция и тази функция се променя, някои от елементите,

592
00:35:39,000 --> 00:35:43,000
когато се върна до функция, която се нарича

593
00:35:43,000 --> 00:35:47,000
масив ми е сега ще бъде различно, и речник за това

594
00:35:47,000 --> 00:35:50,000
е масиви се предават по референция, както ще видим по-късно.

595
00:35:50,000 --> 00:35:53,000
Това е свързано с как указатели работа, където тези основни типове данни,

596
00:35:53,000 --> 00:35:55,000
от друга страна, се предават по стойност.

597
00:35:55,000 --> 00:35:59,000
>> Ние можем да мислим, че като прави копие на някои променлива и след това преминава в копието.

598
00:35:59,000 --> 00:36:01,000
Няма значение какво ще правим с тази променлива.

599
00:36:01,000 --> 00:36:06,000
Викащата функция няма да бъде наясно, че това е променено.

600
00:36:06,000 --> 00:36:10,000
Масивите са само малко по-различна в това отношение.

601
00:36:10,000 --> 00:36:13,000
Например, както току-що видяхме, основната е просто функция

602
00:36:13,000 --> 00:36:15,000
, които могат да вземат в два аргумента.

603
00:36:15,000 --> 00:36:20,000
Първият аргумент за основната функция е argc, или броя на аргументите,

604
00:36:20,000 --> 00:36:23,000
и на втория аргумент се нарича argv,

605
00:36:23,000 --> 00:36:27,000
и тези, които са реалните стойности на тези аргументи.

606
00:36:27,000 --> 00:36:30,000
Да кажем, че имам една програма, наречена this.c,

607
00:36:30,000 --> 00:36:34,000
и казвам направи това, и аз отивам да тичам в командния ред.

608
00:36:34,000 --> 00:36:38,000
Сега да премине в някои аргументи за моята програма, наречена това,

609
00:36:38,000 --> 00:36:42,000
Бих могъл да кажа нещо подобно / това е CS 50.

610
00:36:42,000 --> 00:36:45,000
Това е, което ние си представяме Дейвид да правя всеки ден в рамките на съответния терминал.

611
00:36:45,000 --> 00:36:48,000
Но сега основната вътрешната функция на тази програма

612
00:36:48,000 --> 00:36:52,000
тези стойности, така argc е 4.

613
00:36:52,000 --> 00:36:56,000
Тя може да е малко объркващо, защото наистина сме само бегло е CS 50.

614
00:36:56,000 --> 00:36:58,000
Това е само 3.

615
00:36:58,000 --> 00:37:02,000
Но не забравяйте, че първият елемент на argv или първият аргумент

616
00:37:02,000 --> 00:37:05,000
е името на самата функция.

617
00:37:05,000 --> 00:37:07,190
Така че това означава, че има четири неща,

618
00:37:07,190 --> 00:37:10,530
и първия елемент ще бъде. / това.

619
00:37:10,530 --> 00:37:12,970
И това ще бъде представена като низ.

620
00:37:12,970 --> 00:37:18,590
Тогава останалите елементи са това, което сме написали след името на програмата.

621
00:37:18,590 --> 00:37:22,720
Така че, точно както настрана, тъй като ние най-вероятно видял в pset 2,

622
00:37:22,720 --> 00:37:28,780
не забравяйте, че низът 50 ≠ цяло число 50.

623
00:37:28,780 --> 00:37:32,520
Така че не можем да кажем нещо като "Int х = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Това просто не се случва да има смисъл, защото това е низ, и това е цяло число.

625
00:37:36,470 --> 00:37:38,510
Така че, ако искате да конвертирате между две, не забравяйте, ние отиваме да

626
00:37:38,510 --> 00:37:40,810
имат тази магия функция, наречена atoi.

627
00:37:40,810 --> 00:37:46,270
Това отнема низ и връща цяло число, представени в рамките на тази струна.

628
00:37:46,270 --> 00:37:48,360
Така че това е един лесен грешка да направи теста,

629
00:37:48,360 --> 00:37:51,590
Просто си мислех, че това ще бъде автоматично правилния тип.

630
00:37:51,590 --> 00:37:53,860
Но просто знам, че те винаги ще бъдат струни

631
00:37:53,860 --> 00:38:00,920
дори ако низът съдържа само цяло число или символ или число с плаваща запетая.

632
00:38:00,920 --> 00:38:03,380
Така че сега, нека поговорим за времето за работа.

633
00:38:03,380 --> 00:38:06,700
Когато имаме всички тези алгоритми, които правят всички тези луди неща,

634
00:38:06,700 --> 00:38:11,580
става наистина полезно да си зададем въпроса: "Колко дълго те вземат?

635
00:38:11,580 --> 00:38:15,500
Ние представляваме, че с нещо, наречено асимптотичната нотация.

636
00:38:15,500 --> 00:38:18,430
Така че това означава, че - добре, нека кажем, че ние даваме нашия алгоритъм

637
00:38:18,430 --> 00:38:20,840
някои наистина, наистина, наистина голям вход.

638
00:38:20,840 --> 00:38:23,840
Ние искаме да си зададем въпроса: "Колко дълго ще да се предприемат?

639
00:38:23,840 --> 00:38:26,370
Колко стъпки ще отнеме нашия алгоритъм да тече

640
00:38:26,370 --> 00:38:29,980
като функция на размера на входа?

641
00:38:29,980 --> 00:38:33,080
Така че първият начин, по който можем да опишем време на изпълнение е с голяма O.

642
00:38:33,080 --> 00:38:35,380
И това е нашият най-лошия случай протичане време.

643
00:38:35,380 --> 00:38:38,590
Така че, ако искаме да сортирате масив и даваме нашия алгоритъм масив

644
00:38:38,590 --> 00:38:41,000
, която е в низходящ ред, когато трябва да бъде във възходящ ред,

645
00:38:41,000 --> 00:38:43,130
че ще бъде най-лошия случай.

646
00:38:43,130 --> 00:38:49,800
Това е нашата горна граница в максималната дължина на нашия алгоритъм ще се.

647
00:38:49,800 --> 00:38:54,740
От друга страна, това Ω ще опишем най-добрия случай времето за работа.

648
00:38:54,740 --> 00:38:58,210
Така че, ако ние даваме вече сортиран масив за сортиране алгоритъм,

649
00:38:58,210 --> 00:39:00,940
колко време ще отнеме да го оправи?

650
00:39:00,940 --> 00:39:06,610
И това, тогава, описва долната граница на времето за работа.

651
00:39:06,610 --> 00:39:10,980
Така че тук са само някои думи, които описват някои общи пъти.

652
00:39:10,980 --> 00:39:13,120
Те са във възходящ ред.

653
00:39:13,120 --> 00:39:16,060
Най-бързо време на работа имаме, се нарича константа.

654
00:39:16,060 --> 00:39:19,800
>> Това означава, че без значение колко елементи даваме нашия алгоритъм,

655
00:39:19,800 --> 00:39:22,280
без значение колко голям масив, сортиране

656
00:39:22,280 --> 00:39:26,510
или правиш това, което правим, за да масива винаги ще взима същия период от време.

657
00:39:26,510 --> 00:39:30,270
Така че можем да декларирате, че само с едно, което е константа.

658
00:39:30,270 --> 00:39:32,410
Ние също погледна логаритмична тече в момента.

659
00:39:32,410 --> 00:39:34,800
Значи нещо като двоично търсене е логаритмична,

660
00:39:34,800 --> 00:39:37,140
където ние нарязани на проблема в рамките на половин всеки път

661
00:39:37,140 --> 00:39:40,970
и след това нещата просто получавате по-висока от там.

662
00:39:40,970 --> 00:39:43,580
И ако сте някога писмено O на всеки факторен алгоритъм,

663
00:39:43,580 --> 00:39:47,850
най-вероятно не трябва да разглеждаме това като деня си работа.

664
00:39:47,850 --> 00:39:53,910
Когато сравним пъти, че е важно да се има предвид тези неща.

665
00:39:53,910 --> 00:39:57,760
Така че, ако имам алгоритъм, който е O (N), а някой друг

666
00:39:57,760 --> 00:40:03,590
е алгоритъм O (2n), те са асимптотично еквивалент.

667
00:40:03,590 --> 00:40:06,590
Така че, ако си представим N да бъде голям брой като eleventy милиарда:

668
00:40:06,590 --> 00:40:13,090
Така че, когато сравнявате eleventy млрд. нещо подобно eleventy милиарда + 3,

669
00:40:13,090 --> 00:40:17,640
внезапно, че 3 не наистина да направи голяма разлика вече.

670
00:40:17,640 --> 00:40:20,980
Ето защо ние ще започнат да мислят за тези неща, за да е равна.

671
00:40:20,980 --> 00:40:24,220
Така че неща като тези константи тук има 2 X Този, или добавяне на 3,

672
00:40:24,220 --> 00:40:27,180
това са само константи, а те няма да се откажа.

673
00:40:27,180 --> 00:40:32,480
Така че това е защо всички три от тези, управлявани пъти са едни и същи, като твърдят, че те са O (N).

674
00:40:32,480 --> 00:40:37,490
По същия начин, ако имаме два други пъти манш, нека кажем, O (N ³ + 2n ²), ние да добавите

675
00:40:37,490 --> 00:40:42,070
+ N + 7, и след това имаме друга тече в момента, това е просто O (N ³).

676
00:40:42,070 --> 00:40:46,290
отново, те са едно и също нещо, защото тях - те не са едни и същи.

677
00:40:46,290 --> 00:40:49,840
Това са същите неща, съжалявам. Така че това са едни и същи, защото

678
00:40:49,840 --> 00:40:53,090
³ N е ще доминират тази 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Какво не е едно и също нещо е, ако ни свършиха пъти, както и O (N ³) и O (N ²)

680
00:40:59,130 --> 00:41:02,820
защото това ³ N е много по-голяма от тази ² N.

681
00:41:02,820 --> 00:41:05,470
Така че, ако имаме експонати, изведнъж започва да има значение,

682
00:41:05,470 --> 00:41:08,280
но когато ние просто се занимават с фактори, тъй като ние сме тук,

683
00:41:08,280 --> 00:41:12,810
след това няма да има значение, защото те просто ще отпаднат.

684
00:41:12,810 --> 00:41:16,760
Нека да разгледаме някои от алгоритмите, които сме виждали досега

685
00:41:16,760 --> 00:41:19,260
и да поговорим за времето си курс.

686
00:41:19,260 --> 00:41:23,850
Първият начин търси число в даден списък, че видяхме, е линейна търсене.

687
00:41:23,850 --> 00:41:26,950
И прилагането на линейно търсене е супер лесно.

688
00:41:26,950 --> 00:41:30,490
Ние просто трябва списък, а ние ще разгледаме всеки един елемент в списъка

689
00:41:30,490 --> 00:41:34,260
докато намерим номер търсим.

690
00:41:34,260 --> 00:41:38,370
Така че това означава, че в най-лошия случай, това O (N).

691
00:41:38,370 --> 00:41:40,860
И най-лошия случай може да бъде, ако елемента е

692
00:41:40,860 --> 00:41:45,710
последният елемент, след това с помощта на линейна търсене ние трябва да погледнем на всеки един елемент

693
00:41:45,710 --> 00:41:50,180
докато стигнем до последния, за да се знае, че всъщност в списъка.

694
00:41:50,180 --> 00:41:52,910
Не можем просто да се откажат по средата и да каже: "Това вероятно не е там."

695
00:41:52,910 --> 00:41:55,980
С линейни търсене ние трябва да погледнем към цялото нещо.

696
00:41:55,980 --> 00:41:59,090
В най-добрия случай протичане на времето, от друга страна, е постоянна

697
00:41:59,090 --> 00:42:04,200
защото в най-добрия случай елемент, който търсим, е първи в списъка.

698
00:42:04,200 --> 00:42:08,930
Така че това ще ни отнеме точно 1 стъпка, без значение колко е голям списъка

699
00:42:08,930 --> 00:42:12,140
Ако гледаме за първия елемент всеки път.

700
00:42:12,140 --> 00:42:15,390
>> Така че, когато търсите, не забравяйте, че не се изисква да бъдат сортирани, че нашият списък.

701
00:42:15,390 --> 00:42:19,430
Защото ние сме просто ще разгледаме всеки един елемент, и това всъщност няма значение

702
00:42:19,430 --> 00:42:23,560
какъв ред тези елементи.

703
00:42:23,560 --> 00:42:28,110
По-интелигентно търсене алгоритъм е нещо като двоично търсене.

704
00:42:28,110 --> 00:42:31,500
Не забравяйте, че изпълнението на двоично търсене е, когато ти започваш да се

705
00:42:31,500 --> 00:42:34,320
продължавайте да търсите в средата на списъка.

706
00:42:34,320 --> 00:42:38,000
И тъй като ние не търсим в средата, ние изискваме, че списъкът е сортиран

707
00:42:38,000 --> 00:42:40,580
или иначе ние не знам къде е средата и ние трябва да погледнем през

708
00:42:40,580 --> 00:42:44,480
целия списък да го намерите, и след това в този момент ние просто губене на време.

709
00:42:44,480 --> 00:42:48,480
Така че, ако имаме сортиран списък и намери средата, отиваме да се сравни средата

710
00:42:48,480 --> 00:42:51,590
до елемента, който търсим.

711
00:42:51,590 --> 00:42:54,640
Ако тя е прекалено висока, тогава можем да забравим дясната половина

712
00:42:54,640 --> 00:42:57,810
защото знаем, че ако нашата елемент е вече твърде високо

713
00:42:57,810 --> 00:43:01,080
и всичко на правото на този елемент е дори по-висок,

714
00:43:01,080 --> 00:43:02,760
тогава ние не трябва да се търси там вече.

715
00:43:02,760 --> 00:43:05,430
Когато от друга страна, ако ни елемент е твърде ниска,

716
00:43:05,430 --> 00:43:08,700
знаем, всичко в ляво на този елемент е твърде ниска,

717
00:43:08,700 --> 00:43:11,390
така че не наистина да има смисъл да се търси там,.

718
00:43:11,390 --> 00:43:15,760
По този начин с всяка стъпка и всеки път, когато погледнем в средата на списъка,

719
00:43:15,760 --> 00:43:19,060
отиваме да ни отрежат проблем в 1/2, защото изведнъж знаем

720
00:43:19,060 --> 00:43:23,040
цял куп номера, които не могат да бъдат търсим.

721
00:43:23,040 --> 00:43:26,950
>> В pseudocode това ще изглежда нещо като това,

722
00:43:26,950 --> 00:43:30,990
и защото сме рязане на списъка в половината всеки път,

723
00:43:30,990 --> 00:43:34,920
нашите най-лошия случай тече в момента скача от линейната логаритмична.

724
00:43:34,920 --> 00:43:39,260
Така изведнъж имаме влизане в стъпки, за да открие елемент в списък.

725
00:43:39,260 --> 00:43:42,460
В най-добрия случай протичане на времето, обаче, все още е постоянна

726
00:43:42,460 --> 00:43:45,180
защото сега, нека просто кажем, че елемент, който търсим, е

727
00:43:45,180 --> 00:43:48,380
винаги точно средата на първоначалния списък.

728
00:43:48,380 --> 00:43:52,080
Така че ние може да расте в нашия списък по-голям, тъй като ние искаме, но ако елемент, който търсим, е в средата,

729
00:43:52,080 --> 00:43:54,910
то тогава само ще ни отнеме 1 стъпка.

730
00:43:54,910 --> 00:44:00,920
Така че това е защо ние сме O (дневник н) и Ω (1) или постоянна.

731
00:44:00,920 --> 00:44:04,510
Нека всъщност тече двоично търсене в този списък.

732
00:44:04,510 --> 00:44:08,020
Така че нека да кажем, че ние не търсим за елемент 164.

733
00:44:08,020 --> 00:44:11,650
Първото нещо, което ще направим е да се намери средата на този списък.

734
00:44:11,650 --> 00:44:15,060
Просто така се случи, че средата ще попадат между тези две числа,

735
00:44:15,060 --> 00:44:18,960
така че нека просто произволно да кажа, всеки път, когато средата попада между две числа,

736
00:44:18,960 --> 00:44:21,150
нека просто да закръгли в посока нагоре.

737
00:44:21,150 --> 00:44:24,330
Ние просто трябва да сме сигурни, че правим това всяка стъпка от пътя.

738
00:44:24,330 --> 00:44:29,040
Така че ние отиваме да закръгли в посока нагоре, и ние ще да кажа, че 161 е в средата на класацията ни.

739
00:44:29,040 --> 00:44:34,640
Така че 161 <164, и всеки елемент в ляво от 161

740
00:44:34,640 --> 00:44:39,120
е <164, така че ние знаем, че това няма да ни помогне на всички

741
00:44:39,120 --> 00:44:42,690
да започнете да търсите тук, тъй като елемент търсим не може да бъде там.

742
00:44:42,690 --> 00:44:47,060
Така че това, което можем да направим, е, че ние може просто да забрави за това цялата лява половина на списъка,

743
00:44:47,060 --> 00:44:51,700
и сега разглеждаме само от дясно на 161 нататък.

744
00:44:51,700 --> 00:44:54,050
>> Така че отново, това е средата, нека просто да закръгли в посока нагоре.

745
00:44:54,050 --> 00:44:56,260
Сега 175 е твърде голям.

746
00:44:56,260 --> 00:44:59,180
Така че ние знаем, че това няма да ни помогне да търсите тук или тук,

747
00:44:59,180 --> 00:45:06,610
така че ние може просто да хвърлят това, и в крайна сметка ще удари 164.

748
00:45:06,610 --> 00:45:10,560
Всякакви въпроси за двоично търсене?

749
00:45:10,560 --> 00:45:14,180
Нека преминем от търсене чрез вече сортиран списък

750
00:45:14,180 --> 00:45:17,660
всъщност се списък на телефонните номера в произволен ред

751
00:45:17,660 --> 00:45:20,960
и този списък във възходящ ред.

752
00:45:20,960 --> 00:45:24,060
Първо алгоритъм погледна се нарича балон вид.

753
00:45:24,060 --> 00:45:27,300
И това ще бъде по-опростена на алгоритмите, които видяхме.

754
00:45:27,300 --> 00:45:32,970
Bubble вид казва, че когато всеки две елементи в списъка са на място,

755
00:45:32,970 --> 00:45:36,500
означава, че има по-голям брой на ляво на по-малък брой,

756
00:45:36,500 --> 00:45:40,190
след това отиваме да ги разменят, защото това означава, че списъкът ще бъде

757
00:45:40,190 --> 00:45:42,860
"По-подредени", отколкото е било преди.

758
00:45:42,860 --> 00:45:45,180
И ние просто ще продължи този процес отново и отново и отново

759
00:45:45,180 --> 00:45:52,100
, докато накрая на елементи тип балон за правилното им място и имаме сортиран списък.

760
00:45:52,100 --> 00:45:57,230
>> Време на изпълнение на това ще бъде O (N ²). Защо?

761
00:45:57,230 --> 00:46:00,370
Ами, защото в най-лошия случай, ние отиваме да вземе всеки елемент и

762
00:46:00,370 --> 00:46:04,570
ние ще се окажете в сравнение с всеки друг елемент в списъка.

763
00:46:04,570 --> 00:46:08,030
Но в най-добрия случай, ние имаме вече сортиран списък, балон вид

764
00:46:08,030 --> 00:46:12,230
просто ще да мине през веднъж, да кажем "Не. не направи никакви суапове, така съм направил."

765
00:46:12,230 --> 00:46:17,410
Така че ние имаме най-добрия случай времето за работа на Ω (N).

766
00:46:17,410 --> 00:46:20,680
Нека тече вид балон в списък.

767
00:46:20,680 --> 00:46:23,560
Или първо, нека просто погледнете в някои pseudocode наистина бързо.

768
00:46:23,560 --> 00:46:28,160
Искаме да кажем, че искаме да следите на всяка итерация на цикъла,

769
00:46:28,160 --> 00:46:32,190
да следите дали трябва или не променя всички елементи.

770
00:46:32,190 --> 00:46:37,610
Така че причината за това е, отиваме да спре, когато не са сменени всички елементи.

771
00:46:37,610 --> 00:46:41,980
Така че в началото на нашата линия не са сменени, нищо, така че ще кажа, че е фалшива.

772
00:46:41,980 --> 00:46:47,170
Сега, ние ще отидем в списъка и сравни елемент на елемент + 1

773
00:46:47,170 --> 00:46:50,310
и ако е вярно, че има по-голям брой на ляво по-малък номер,

774
00:46:50,310 --> 00:46:52,310
тогава просто щяхме да ги разменят.

775
00:46:52,310 --> 00:46:54,490
>> И тогава отиваме да помним, че разменят елемент.

776
00:46:54,490 --> 00:46:58,900
Това означава, че ние трябва да отидем в списъка най-малко още 1 път

777
00:46:58,900 --> 00:47:02,160
защото състоянието, в което спряхме, когато целият списък е вече подредени,

778
00:47:02,160 --> 00:47:04,890
което означава, че не са направили някакви суапове.

779
00:47:04,890 --> 00:47:09,960
Така че защо нашето състояние тук е ", макар някои от елементите са разменени.

780
00:47:09,960 --> 00:47:13,720
Така че нека сега просто погледнете това бягане в списък.

781
00:47:13,720 --> 00:47:16,640
Имам списъка 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble вид ще започне по целия път от лявата страна, и става за сравнение

783
00:47:19,850 --> 00:47:24,700
I елементи, така че 0 до + 1, който е елемент 1.

784
00:47:24,700 --> 00:47:29,020
Той ще каже, добре 5> 0, но точно сега 5 е в ляво,

785
00:47:29,020 --> 00:47:32,500
така че трябва да сменяте 5 и 0.

786
00:47:32,500 --> 00:47:35,470
Когато ги разменят, изведнъж се получи това друг списък.

787
00:47:35,470 --> 00:47:38,260
Сега 5> 1, така че отиваме да ги разменят.

788
00:47:38,260 --> 00:47:42,160
5 не е> 6, така че не е нужно да правите нищо тук.

789
00:47:42,160 --> 00:47:46,690
Но 6> 4, така че ние трябва да се разменят.

790
00:47:46,690 --> 00:47:49,740
Отново, ние трябва да се движат през целия списък, в крайна сметка да открият

791
00:47:49,740 --> 00:47:52,330
, че те са на ред, ние ги разменят,

792
00:47:52,330 --> 00:47:57,120
и в този момент ние трябва да минава през списъка милион повече време

793
00:47:57,120 --> 00:48:05,390
за да се уверите, че всичко е в своето определение, и в този момент вид балон приключи.

794
00:48:05,390 --> 00:48:10,720
Различен алгоритъм за вземане на някои елементи и ги сортира е подборът вид.

795
00:48:10,720 --> 00:48:15,740
Идеята зад избора Сортиране е, че отиваме да се изгради подредени част от списъка

796
00:48:15,740 --> 00:48:18,150
Един елемент в даден момент.

797
00:48:18,150 --> 00:48:23,170
>> И начина, по който отиваме да се направи това е чрез изграждане на левия сегмент на списъка.

798
00:48:23,170 --> 00:48:27,510
И в общи линии, всеки - на всяка стъпка, ние отиваме да се вземат най-малкия елемент, ние оставихме

799
00:48:27,510 --> 00:48:32,310
, която не е била подредени още, и отиваме да го преместите в тази подредени сегмент.

800
00:48:32,310 --> 00:48:35,850
Това означава, че ние трябва непрекъснато да разбера каква е минималната несортирани елемент

801
00:48:35,850 --> 00:48:40,720
и след това приемете, че минималния елемент и да го сменяте с каквото

802
00:48:40,720 --> 00:48:45,090
най-лявата елемент, който не е сортиран.

803
00:48:45,090 --> 00:48:50,890
Време на изпълнение на това ще бъде O (N ²), тъй като в най-лошия случай

804
00:48:50,890 --> 00:48:55,070
ние трябва да се сравни всеки един елемент на всеки друг елемент.

805
00:48:55,070 --> 00:48:59,250
Защото казвате, че ако започне в лявата половина на списъка, ние се нуждаем

806
00:48:59,250 --> 00:49:02,970
да мине през цялата дясна сегмент, за да намерите най-малкия елемент.

807
00:49:02,970 --> 00:49:05,430
И тогава, отново, ние трябва да премине цялата дясна сегмент и

808
00:49:05,430 --> 00:49:08,210
продължавай, че над и отново, и отново.

809
00:49:08,210 --> 00:49:11,350
Това ще бъде н ². Отиваме да се нуждаят от линия вътрешността на друг за контур

810
00:49:11,350 --> 00:49:13,350
, което предполага, N ².

811
00:49:13,350 --> 00:49:16,530
В най-добрия случай мисъл, нека да кажем, че сме го вече сортиран списък;

812
00:49:16,530 --> 00:49:19,270
ние всъщност не правя по-добре от N ².

813
00:49:19,270 --> 00:49:21,730
Тъй като избор на вид няма как да знае, че

814
00:49:21,730 --> 00:49:25,540
минималния елемент е само една, аз се случи да се търсят в.

815
00:49:25,540 --> 00:49:28,970
Тя все още трябва да се уверите, че това е всъщност минимум.

816
00:49:28,970 --> 00:49:31,670
>> И единственият начин да се уверите, че това е минимално, като се използва този алгоритъм,

817
00:49:31,670 --> 00:49:34,640
е отново да разгледаме всеки един елемент.

818
00:49:34,640 --> 00:49:38,420
Така че наистина, ако ти я дам - ​​ако ви даде избор на вид вече сортиран списък

819
00:49:38,420 --> 00:49:42,720
това няма да се направи по-добре, отколкото като списък, който все още не се сортират.

820
00:49:42,720 --> 00:49:46,320
Между другото, ако това се случи да се случи, че нещо не е O (нещо)

821
00:49:46,320 --> 00:49:50,640
и омегата на нещо, ние може просто да се каже, по-накратко, че това е θ на нещо.

822
00:49:50,640 --> 00:49:52,760
Така че, ако видите, че излезе някъде, че това просто означава.

823
00:49:52,760 --> 00:49:57,580
>> Ако нещо е тета на N ², тя е едновременно голяма O (N ²) и Ω (N ²).

824
00:49:57,580 --> 00:49:59,790
Така че най-добрия случай и най-лошия случай, той не прави разлика,

825
00:49:59,790 --> 00:50:04,400
алгоритъма смяташ да правиш едно и също нещо всеки път.

826
00:50:04,400 --> 00:50:06,610
Така че това е какъв pseudocode за избор на сортиране може да изглежда така.

827
00:50:06,610 --> 00:50:10,630
Ние сме основно ще кажа, че искам да обхождане на списъка

828
00:50:10,630 --> 00:50:15,180
от ляво на дясно, и на всяка итерация на цикъла, аз отивам да се движат

829
00:50:15,180 --> 00:50:19,780
минималния елемент в тази сортират част на списъка.

830
00:50:19,780 --> 00:50:23,260
И след като се преместя нещо там, аз никога не трябва отново да разгледаме този елемент.

831
00:50:23,260 --> 00:50:28,600
Защото веднага след като суап елемент в лявата сегмент на списъка, подредени

832
00:50:28,600 --> 00:50:32,600
защото правим всичко, което е във възходящ ред с помощта на минимум.

833
00:50:32,600 --> 00:50:38,740
Така че, добре, ние сме и позиция, и ние трябва да погледнем на всички елементи

834
00:50:38,740 --> 00:50:42,260
правото на АЗ, за да открие минимум.

835
00:50:42,260 --> 00:50:46,150
Така че това означава, че искаме да погледнем от + 1 до края на списъка.

836
00:50:46,150 --> 00:50:51,610
И сега, ако елемент, който сме в момента търси е по-малка от нашата минимум досега,

837
00:50:51,610 --> 00:50:54,190
, която не забравяйте, ние сме началото на минимално разстояние само за да си

838
00:50:54,190 --> 00:50:57,020
каквото елемент сме в момента, ще приемем, че е минималната.

839
00:50:57,020 --> 00:51:00,270
Ако намеря един елемент, който е по-малък от този, тогава аз ще кажа, добре,

840
00:51:00,270 --> 00:51:02,700
добре, аз не съм намерил нов минимум.

841
00:51:02,700 --> 00:51:06,080
Отивам да си спомня къде е този минимум е.

842
00:51:06,080 --> 00:51:09,560
>> Така че сега, след като съм отишъл чрез това право несортирани сегмент,

843
00:51:09,560 --> 00:51:16,690
Мога да кажа, че отивам да сменяте минималния елемент с елемент, който е в позицията.

844
00:51:16,690 --> 00:51:21,100
Това става да изгради моя списък, подредени част от списъка от ляво на дясно,

845
00:51:21,100 --> 00:51:25,190
и ние никога не трябва да се търси елемент отново, след като тя е в тази част.

846
00:51:25,190 --> 00:51:27,930
След като сме го разменят.

847
00:51:27,930 --> 00:51:30,260
Така че нека да стартирате вид избор в този списък.

848
00:51:30,260 --> 00:51:38,220
Синият елемент тук ще бъде I, и червен елемент ще бъде елемент на минимална.

849
00:51:38,220 --> 00:51:41,570
Така че аз се започва всичко в лявата страна на списъка, така че на 5.

850
00:51:41,570 --> 00:51:44,610
Сега ние трябва да намерим минималната несортирани елемент.

851
00:51:44,610 --> 00:51:49,480
Затова ние казваме, 0 <5, така че 0 е моят нов минимум.

852
00:51:49,480 --> 00:51:53,820
>> Но аз не мога да спра там, защото въпреки, че ние можем да признаем, че 0 е най-малкият,

853
00:51:53,820 --> 00:51:59,390
ние трябва да тече през всеки друг елемент от списъка, за да се уверите.

854
00:51:59,390 --> 00:52:01,760
Така че едно е по-голям, шест е по-голям, 4 е по-голям.

855
00:52:01,760 --> 00:52:05,850
Това означава, че след разглеждане на всички тези елементи, аз съм определя 0 е най-малкият.

856
00:52:05,850 --> 00:52:09,800
Така че аз отивам да сменяте 5 и 0.

857
00:52:09,800 --> 00:52:15,480
След като суап, че аз отивам да се получи нов списък, и аз знам, че никога не трябва да се търси отново в този 0

858
00:52:15,480 --> 00:52:19,380
защото след като веднъж съм го разменят, аз съм го сортират и сме готови.

859
00:52:19,380 --> 00:52:22,730
Сега тя просто така се случва, че синята елемент е отново 5,

860
00:52:22,730 --> 00:52:26,030
и ние трябва да погледнем в 1, 6 и 4, за да се определи, че 1

861
00:52:26,030 --> 00:52:31,520
е най-малкият елемент на минимална, така че ние ще прекарат 1 и 5.

862
00:52:31,520 --> 00:52:36,890
Отново, ние трябва да погледнем в сравнение от 5 до 6 и 4,

863
00:52:36,890 --> 00:52:39,830
и отиваме да сменяте 4 и 5, и най-накрая, да сравните

864
00:52:39,830 --> 00:52:45,740
тези две числа и ги разменят, докато ще ни сортиран списък.

865
00:52:45,740 --> 00:52:49,730
Всякакви въпроси относно избор на вид?

866
00:52:49,730 --> 00:52:56,420
Добре. Нека да преминем към последната тема тук, и това е рекурсия.

867
00:52:56,420 --> 00:52:59,810
>> Рекурсия, не забравяйте, това наистина ли е мета нещо функция

868
00:52:59,810 --> 00:53:02,740
многократно нарича себе си.

869
00:53:02,740 --> 00:53:05,620
Така че в някакъв момент, докато нашият fuction е многократно се обажда,

870
00:53:05,620 --> 00:53:10,100
трябва да има някакъв момент, в който ние престанем да се обадите.

871
00:53:10,100 --> 00:53:13,670
Защото, ако ние не направим това, тогава ние просто ще продължим да правим това завинаги,

872
00:53:13,670 --> 00:53:16,660
и нашата програма просто няма да се прекрати.

873
00:53:16,660 --> 00:53:19,200
Ние наричаме това състояние на базата случай.

874
00:53:19,200 --> 00:53:22,570
И на база случай се казва, а не отново призовава функция,

875
00:53:22,570 --> 00:53:25,330
Аз съм просто ще се върне някаква стойност.

876
00:53:25,330 --> 00:53:28,080
Така че след като сме върнали стойност, спряхме да се обадите,

877
00:53:28,080 --> 00:53:32,550
и останалата част от поканите, които сме направили досега, може да се върне.

878
00:53:32,550 --> 00:53:36,050
Обратното на базовия модел е рекурсивен случай.

879
00:53:36,050 --> 00:53:39,050
И това е, когато искаме да извършите друго повикване на функцията, която сме в момента инча

880
00:53:39,050 --> 00:53:44,690
И ние вероятно, макар и не винаги, искам да се използват различни аргументи.

881
00:53:44,690 --> 00:53:48,940
>> Така че, ако имаме функция, наречена е, и е току що се обади 1 аргумент,

882
00:53:48,940 --> 00:53:52,010
и ние просто да се обадите на е (1), F (1), F (1), и то просто така се случва, че

883
00:53:52,010 --> 00:53:56,510
аргумента, 1 попада в рекурсивен случай, ние все още никога не започваш да спре.

884
00:53:56,510 --> 00:54:01,620
Дори ако имаме база случай, ние трябва да се уверите, че в крайна сметка ние ще удари този случай база.

885
00:54:01,620 --> 00:54:04,250
Ние не просто да остане в този рекурсивен случай.

886
00:54:04,250 --> 00:54:09,870
Обикновено, когато ние се наричаме, ние сме най-вероятно ще има друг аргумент всеки път.

887
00:54:09,870 --> 00:54:12,700
Тук е много проста рекурсивна функция.

888
00:54:12,700 --> 00:54:15,090
Така че това ще изчислим факториела на число.

889
00:54:15,090 --> 00:54:17,790
До върха тук имаме нашата база случай.

890
00:54:17,790 --> 00:54:22,330
В случай, че N ≤ 1, ние не отиваме да се обадя факториел отново.

891
00:54:22,330 --> 00:54:26,490
Отиваме да спре, ние просто ще се върне някаква стойност.

892
00:54:26,490 --> 00:54:30,170
Ако това не е вярно, тогава отиваме да удари нашата рекурсивно случай.

893
00:54:30,170 --> 00:54:33,550
Забележете, че ние не просто звъните факториел (N), защото това не би било много полезно.

894
00:54:33,550 --> 00:54:36,810
Отиваме да се обадя факториела на нещо друго.

895
00:54:36,810 --> 00:54:40,850
>> И така, вие виждате, в крайна сметка, ако ние преминаваме факториел (5) или нещо,

896
00:54:40,850 --> 00:54:45,900
отиваме да се обадя факториел (4) и така нататък, и в крайна сметка отиваме да удари този случай база.

897
00:54:45,900 --> 00:54:51,730
Така че това изглежда добре. Нека видим какво се случва, когато ние действително стартирате тази.

898
00:54:51,730 --> 00:54:57,840
Това е стек, и нека да кажем, че основната Ще се обадя на тази функция с аргумент (4).

899
00:54:57,840 --> 00:55:02,200
Така че след като факториел вижда и = 4, факториел ще се нарича.

900
00:55:02,200 --> 00:55:05,010
Сега изведнъж, имаме факториел (3).

901
00:55:05,010 --> 00:55:10,780
Така че тези функции ще продължават да растат, докато в крайна сметка ние удари нашата база случай.

902
00:55:10,780 --> 00:55:17,830
В този момент, връщаната стойност от тази е завръщането (NX връщаната стойност от тази),

903
00:55:17,830 --> 00:55:21,290
връщаната стойност от тази е NX връщаната стойност от тази.

904
00:55:21,290 --> 00:55:23,290
В крайна сметка ние трябва да се удари някакъв номер.

905
00:55:23,290 --> 00:55:26,560
На върха тук, ние казваме връщане 1.

906
00:55:26,560 --> 00:55:30,650
Това означава, че след като се върне този номер, можем да се появи това разстояние стека.

907
00:55:30,650 --> 00:55:36,570
Така че това факториел (1) се прави.

908
00:55:36,570 --> 00:55:41,190
Когато 1 се завръща, този факторни (1) връща, това завръщане към 1.

909
00:55:41,190 --> 00:55:46,910
Връщаната стойност от тази, спомням, беше NX връщаната стойност от тази.

910
00:55:46,910 --> 00:55:50,720
Така внезапно, този човек знае, че искам да се върна две.

911
00:55:50,720 --> 00:55:55,910
>> Така че не забравяйте, върнете стойността на този е само NX върнатата стойност тук.

912
00:55:55,910 --> 00:56:01,160
Така че сега ние може да се каже, 3 х 2, и накрая, тук можем да кажем,

913
00:56:01,160 --> 00:56:04,010
това е просто ще бъде 4 х 3 х 2.

914
00:56:04,010 --> 00:56:09,570
И след това се връща, ще получите един вътре число на основната.

915
00:56:09,570 --> 00:56:15,460
Всякакви въпроси за рекурсия?

916
00:56:15,460 --> 00:56:17,090
Добре. Така че има повече време за въпроси, в края на

917
00:56:17,090 --> 00:56:23,360
но сега Джоузеф ще покрие останалите теми.

918
00:56:23,360 --> 00:56:25,590
>> [Джоузеф Ong] Добре. Така че сега сме говорили за recursions,

919
00:56:25,590 --> 00:56:27,840
нека да поговорим малко за това, което се сливат вид е.

920
00:56:27,840 --> 00:56:31,740
Обединяване груб вид е друг начин за сортиране на списък от номера.

921
00:56:31,740 --> 00:56:36,430
И как тя работи, с вид сливане имате списък, и това, което правим, е

922
00:56:36,430 --> 00:56:39,120
ние казваме, нека се разделим в две половини.

923
00:56:39,120 --> 00:56:42,750
Ще изпълните за първи път се слеят вид отново в лявата половина,

924
00:56:42,750 --> 00:56:45,040
тогава ще тече сливане нещо в дясната половина,

925
00:56:45,040 --> 00:56:50,240
и това ни дава две половини, които са подредени, а сега отиваме да комбинирате тези половини заедно.

926
00:56:50,240 --> 00:56:55,010
Това е малко трудно да се види без пример, така че ние ще вършим и да видим какво ще се случи.

927
00:56:55,010 --> 00:56:59,590
Така че да започнете с този списък, ние го разделя на две половини.

928
00:56:59,590 --> 00:57:02,300
В момента тече сливане нещо в лявата половина първото.

929
00:57:02,300 --> 00:57:06,660
Така че това е лявата половина, а сега ние ги управляват чрез този списък отново

930
00:57:06,660 --> 00:57:09,800
, която получава премина в вид сливане, и след това ние с нетърпение отново,

931
00:57:09,800 --> 00:57:13,270
в лявата страна на този списък и ще свършим сливат нещо върху него.

932
00:57:13,270 --> 00:57:15,880
Сега, ние получаваме списък на две числа,

933
00:57:15,880 --> 00:57:19,010
и сега лявата половина е дълга само 1 елемент, и ние не можем да

934
00:57:19,010 --> 00:57:23,380
разделите списък, който е само 1 елемент в половината, така че можем само да кажа, след като имаме 50,

935
00:57:23,380 --> 00:57:26,400
който е само един елемент, това е вече сортирани.

936
00:57:26,400 --> 00:57:29,860
>> След като сме готови с това, можем да видим, че можем

937
00:57:29,860 --> 00:57:32,230
се движат в дясната половина на този списък,

938
00:57:32,230 --> 00:57:36,480
и 3 се сортират, и сега, когато двете половини на този списък са подредени

939
00:57:36,480 --> 00:57:39,080
можем да се присъединят към тези номера отново заедно.

940
00:57:39,080 --> 00:57:45,320
Така че ние гледаме на 50 и 3; 3 е по-малък от 50, така че той отива в първо и след това 50.

941
00:57:45,320 --> 00:57:49,340
Сега, това е направено, да се върнем до този списък и вид, това е дясната половина.

942
00:57:49,340 --> 00:57:52,440
42 е със собствен номер, така че вече подредени.

943
00:57:52,440 --> 00:57:57,850
Така че сега ние ги сравним 2 и 3 е по-малък от 42, така че получава в първия,

944
00:57:57,850 --> 00:58:02,340
сега на 42 години получава поставени в и 50 получава пуснати инча

945
00:58:02,340 --> 00:58:07,220
Сега, това е сортиран, отиваме по целия път обратно до върха, 1337 и 15.

946
00:58:07,220 --> 00:58:14,560
Е, ние сега погледнете в лявата половина на този списък; 1337 е само по себе си, така че те се сортират и с 15.

947
00:58:14,560 --> 00:58:19,020
Така че сега ние комбинираме тези две числа да сортирате, че първоначалния списък, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
така че отива в първия, а след 1337 отива инча

949
00:58:23,060 --> 00:58:26,640
И сега сме сортирали двете половини на първоначалния списък отгоре.

950
00:58:26,640 --> 00:58:30,440
И всичко, което трябва да направим, е да съчетае и двете.

951
00:58:30,440 --> 00:58:36,890
Очакваме в първите два номера на този списък, 3 <15, така че отива в нещо масив първо.

952
00:58:36,890 --> 00:58:44,460
15 <42, така че той отива. Сега, 42 <1337, който излиза инча

953
00:58:44,460 --> 00:58:51,010
50 <1337, така че той отива. Забележите, че ние просто отне два номера на този списък.

954
00:58:51,010 --> 00:58:53,640
Така че ние не просто се редуват между два списъка.

955
00:58:53,640 --> 00:58:56,050
Ние просто търсим в началото, и ние сме като елемент

956
00:58:56,050 --> 00:59:00,270
че е по-малък, а след това го поставя в нашия масив.

957
00:59:00,270 --> 00:59:04,080
Сега сме обединени всички половини и сме готови.

958
00:59:04,080 --> 00:59:07,780
>> Всякакви въпроси, свързани сливат вид? Да?

959
00:59:07,780 --> 00:59:14,190
[Student] Ако това е разделяне на различни групи, защо не те просто го разделим веднъж

960
00:59:14,190 --> 00:59:19,970
и имате 3 и 2 с група? [Останал въпрос неразбираемо]

961
00:59:19,970 --> 00:59:24,940
Причината - така че въпросът е, защо да не можем просто да ги обедините в тази първа стъпка, след като ние ги имаме?

962
00:59:24,940 --> 00:59:29,530
Причината можем да направим това, да започне в най-лявата елементи и на двете страни,

963
00:59:29,530 --> 00:59:33,040
и тогава се взема по-малка и я сложи в, е, че ние знаем, че това

964
00:59:33,040 --> 00:59:35,290
отделните списъци са в сортирани поръчки.

965
00:59:35,290 --> 00:59:37,290
Така че, ако аз съм в най-лявата елементи от двете полувремена,

966
00:59:37,290 --> 00:59:40,490
Знам, че те ще бъдат най-малките елементи на тези списъци.

967
00:59:40,490 --> 00:59:43,930
Така че мога да ги сложа в най-малките петна елемент от този голям списък.

968
00:59:43,930 --> 00:59:47,810
От друга страна, ако погледнем на тези два списъка във второто ниво там,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 и 15, тези, които не са подредени.

970
00:59:51,640 --> 00:59:55,770
Така че, ако погледнем 50 и 1337, аз ще сложа 50 първи в списъка ми.

971
00:59:55,770 --> 01:00:00,130
Но това не наистина да има смисъл, защото 3 е най-малкият елемент от всички тези.

972
01:00:00,130 --> 01:00:04,390
Така че единствената причина можем да направим това комбиниране стъпка е така, защото нашите списъци вече са подредени.

973
01:00:04,390 --> 01:00:07,010
Ето защо ние трябва да слязат по целия път до дъното

974
01:00:07,010 --> 01:00:09,800
защото когато имаме само един единствен номер, знаете, че един брой

975
01:00:09,800 --> 01:00:14,120
само по себе си вече е сортиран списък.

976
01:00:14,120 --> 01:00:19,360
>> Някакви въпроси? Не?

977
01:00:19,360 --> 01:00:24,260
Сложност? Е, можете да видите, че на всяка крачка има крайните числа,

978
01:00:24,260 --> 01:00:27,590
и можем да разделим списък в полулогаритмични N пъти,

979
01:00:27,590 --> 01:00:31,700
което е мястото, където се получи това N х дневник N сложността.

980
01:00:31,700 --> 01:00:34,940
И ще видите най-добрия случай за вид сливане е н дневник N, и то просто така се случва

981
01:00:34,940 --> 01:00:39,340
, че най-лошия случай, или Ω там, също е N влезете н.

982
01:00:39,340 --> 01:00:42,480
Нещо, което трябва да имате предвид.

983
01:00:42,480 --> 01:00:45,750
Продължаваме да вървим в някои супер основен файл I / O.

984
01:00:45,750 --> 01:00:48,830
Ако сте разглеждали катеря, ще забележите, имахме някаква система

985
01:00:48,830 --> 01:00:51,270
, където можете да напишете в лог файл, ако четете чрез кода.

986
01:00:51,270 --> 01:00:53,730
Нека видим как можете да направите.

987
01:00:53,730 --> 01:00:57,450
Е, имаме fprintf, които можеш да се сетиш само като ФОРМАТ,

988
01:00:57,450 --> 01:01:01,720
но просто отпечатване във файл вместо това, и по този начин е в началото.

989
01:01:01,720 --> 01:01:07,570
Този вид код тук, това, което той прави, е, както може би сте виждали в катеря,

990
01:01:07,570 --> 01:01:12,310
тя преминава през 2-мерен масив печат, ред по ред, какви са цифрите.

991
01:01:12,310 --> 01:01:17,850
В този случай, ФОРМАТ отпечатва до терминала или това, което ние наричаме стандартния изход на раздел.

992
01:01:17,850 --> 01:01:22,170
>> И сега, в този случай, всичко, което трябва да направите, е замени ФОРМАТ с fprintf

993
01:01:22,170 --> 01:01:26,770
кажа, че файла, който искате да отпечатате, и в този случай тя просто го отпечатва до този файл

994
01:01:26,770 --> 01:01:32,230
вместо да ги извежда до терминала.

995
01:01:32,230 --> 01:01:36,500
Е, тогава, че повдига въпроса: Къде сме ние този вид файл от, нали?

996
01:01:36,500 --> 01:01:39,840
Минахме влезте в този fprintf fuction но нямахме представа от къде идва.

997
01:01:39,840 --> 01:01:43,980
Е, в началото на кода, това, което имахме, беше това парче код тук

998
01:01:43,980 --> 01:01:48,340
който основно се казва, че отворите файла призовава log.txt.

999
01:01:48,340 --> 01:01:53,220
Какво правим след това е, трябва да се уверите, че файлът е всъщност отвори успешно.

1000
01:01:53,220 --> 01:01:57,070
Така че може да се провали за няколко причини, не разполагат с достатъчно пространство на вашия компютър, например.

1001
01:01:57,070 --> 01:01:59,790
Така че тя винаги е важно, преди да направи всякакви операции с файла

1002
01:01:59,790 --> 01:02:03,300
че ние проверяваме дали този файл е отворен успешно.

1003
01:02:03,300 --> 01:02:09,330
Така че какво, това е аргумент за fopen, добре, можем да отворите файл по много начини.

1004
01:02:09,330 --> 01:02:13,510
Какво можем да направим, можем да го премине w, което означава предимство файла, ако то излезе вече,

1005
01:02:13,510 --> 01:02:18,070
Ние можем да минем а, които те да приложи към края на файла, вместо да го първостепенен,

1006
01:02:18,070 --> 01:02:22,730
или можем да определим R, което означава, да отворите файла само за четене.

1007
01:02:22,730 --> 01:02:24,890
Така че, ако програмата се опитва да прави всякакви промени във файла,

1008
01:02:24,890 --> 01:02:30,140
крещи към тях и не им позволявайте да го направя.

1009
01:02:30,140 --> 01:02:33,320
Накрая, след като приключите с файла, съставено изпълняваме операции,

1010
01:02:33,320 --> 01:02:35,860
ние трябва да сме сигурни, че затворете файла.

1011
01:02:35,860 --> 01:02:38,830
И така, в края на програмата, ще отново да ги предаде

1012
01:02:38,830 --> 01:02:42,120
този файл, който сте отворили, а просто го затворите.

1013
01:02:42,120 --> 01:02:44,650
Така че това е нещо важно, което трябва да се уверете, че правя.

1014
01:02:44,650 --> 01:02:47,180
Така че, не забравяйте, можете да отворите файл, след това можете да пишете на файла,

1015
01:02:47,180 --> 01:02:51,270
направи операции във файла, но тогава ще трябва да затворите файла в края.

1016
01:02:51,270 --> 01:02:53,270
>> Всякакви въпроси относно основните файл I / O? Да?

1017
01:02:53,270 --> 01:02:58,050
[Student въпрос, неразбираем]

1018
01:02:58,050 --> 01:03:02,480
Точно тук. Въпросът е, откъде идва тази log.txt файл се появи?

1019
01:03:02,480 --> 01:03:07,890
Е, ако просто го даде log.txt, тя създава в същата директория, като изпълним.

1020
01:03:07,890 --> 01:03:10,500
Така че, ако вие сте - >> [Student въпрос, неразбираем]

1021
01:03:10,500 --> 01:03:18,830
Да. В същата папка, или в същата директория, както ти го наричаш.

1022
01:03:18,830 --> 01:03:21,400
Сега памет, стек, и куп.

1023
01:03:21,400 --> 01:03:23,400
Е, как е паметта, в компютъра?

1024
01:03:23,400 --> 01:03:26,270
Е, можете да си представите паметта като нещо на този блок тук.

1025
01:03:26,270 --> 01:03:30,260
И в паметта имаме това, което се нарича купчина остана там, и топчето, че е там.

1026
01:03:30,260 --> 01:03:34,480
И куп расте надолу и стека расте нагоре.

1027
01:03:34,480 --> 01:03:38,620
Така че, както Томи спомена - Е, добре, и ние имаме тези 4 сегменти, които ще получите в секунда -

1028
01:03:38,620 --> 01:03:42,890
Томи каза по-рано, вие знаете как неговите функции, които наричат ​​себе си и наричат ​​помежду си?

1029
01:03:42,890 --> 01:03:44,930
Те изграждат този вид стак рамка.

1030
01:03:44,930 --> 01:03:47,360
Е, ако основните разговори Foo Foo получава на стека.

1031
01:03:47,360 --> 01:03:52,430
Foo призовава бар, бар получите на стека, и че получава в стека след

1032
01:03:52,430 --> 01:03:57,040
И тъй като те се връщат, всеки от тях се вземат стека.

1033
01:03:57,040 --> 01:04:00,140
Какво всяко от тези места и паметта държи?

1034
01:04:00,140 --> 01:04:03,110
Е, на върха, която е текстът сегмент, съдържа самата програма.

1035
01:04:03,110 --> 01:04:06,390
Така машинен код, който е там, след като компилирате вашата програма.

1036
01:04:06,390 --> 01:04:08,520
На следващо място, всеки инициализира глобални променливи.

1037
01:04:08,520 --> 01:04:12,660
>> Така че трябва глобални променливи във вашата програма, а вие казвате, а = 5,

1038
01:04:12,660 --> 01:04:15,260
, които получава в този сегмент, и точно под това,

1039
01:04:15,260 --> 01:04:18,990
имате някакви неинициализирани глобални данни, което е само INT,

1040
01:04:18,990 --> 01:04:20,990
но не казват, че е равно на нищо.

1041
01:04:20,990 --> 01:04:23,870
Осъзнайте, това са глобални променливи, така че те са извън основната.

1042
01:04:23,870 --> 01:04:28,560
Така че това означава всички глобални променливи, които са обявени, но не се инициализира.

1043
01:04:28,560 --> 01:04:32,310
Така че това, което е в купчина? Memory разпределят чрез използването на изчистване, който ние ще стигнем до по малко.

1044
01:04:32,310 --> 01:04:35,990
И накрая, с стека имате някакви локални променливи

1045
01:04:35,990 --> 01:04:39,950
и всички функции, може да се обадите в някоя от техните параметри.

1046
01:04:39,950 --> 01:04:43,720
Последното нещо, което не ми трябва да знам какво правят на околната среда променливи,

1047
01:04:43,720 --> 01:04:46,700
но всеки път, когато стартирате програмата, е свързана с нещо, подобно на

1048
01:04:46,700 --> 01:04:49,550
това е име на човек, който се притекъл на програмата.

1049
01:04:49,550 --> 01:04:51,550
И това ще бъде нещо като в долната част.

1050
01:04:51,550 --> 01:04:54,540
По отношение на адреси от паметта, които са шестнадесетични стойности,

1051
01:04:54,540 --> 01:04:58,170
стойностите на върха започват от 0 и те отиват по целия път надолу към дъното.

1052
01:04:58,170 --> 01:05:00,440
В този случай, ако сте на 32-битова система,

1053
01:05:00,440 --> 01:05:05,390
адреса, на дъното ще бъде 0x, следвана от AF, защото това е 32 бита,

1054
01:05:05,390 --> 01:05:10,890
, което е 8 байта, и в този случай 8 байта съответства на 8 шестнадесетични цифри.

1055
01:05:10,890 --> 01:05:20,110
Така че тук сте ще има, като 0xFFFFFF и там започваш да имате 0.

1056
01:05:20,110 --> 01:05:23,660
Така че това, което са указатели? Някои от вас не може да са покрили това в раздел преди.

1057
01:05:23,660 --> 01:05:26,660
но мина над него в лекцията, така че показалецът е само тип данни

1058
01:05:26,660 --> 01:05:34,030
магазини, вместо на някаква стойност, като 50, тя съхранява адреса на някакво място в паметта.

1059
01:05:34,030 --> 01:05:36,020
Като че паметта неразбираемо.

1060
01:05:36,020 --> 01:05:41,120
Така че в този случай, това, което е, ние имаме указател към цяло число или INT *

1061
01:05:41,120 --> 01:05:46,210
и съдържа този шестнадесетичен адрес на 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Така че това, което имаме, е, сега, този указател точки в някакво място в паметта,

1063
01:05:50,880 --> 01:05:56,020
и това е само една, на стойност 50 е на това място в паметта.

1064
01:05:56,020 --> 01:06:01,810
На някои 32-битови системи, на всички 32-битови системи показалки заемат 32 бита или 4 байта.

1065
01:06:01,810 --> 01:06:06,020
Но, например, на 64-битова система, указатели са 64 бита.

1066
01:06:06,020 --> 01:06:08,040
Така че това е нещо, което ще искате да имате в предвид.

1067
01:06:08,040 --> 01:06:12,310
Така че по-битова система, указател е краят бита дълго.

1068
01:06:12,310 --> 01:06:17,320
Указатели са нещо трудно за храносмилане, без допълнителни неща,

1069
01:06:17,320 --> 01:06:20,300
така че нека продължим чрез пример за динамично разпределение на паметта.

1070
01:06:20,300 --> 01:06:25,130
Какво прави за вас динамично разпределение на паметта, или това, което ние наричаме изчистване,

1071
01:06:25,130 --> 01:06:29,280
тя ви позволява да заделят някакъв вид данни извън снимачната площадка.

1072
01:06:29,280 --> 01:06:31,830
Така че тези данни е нещо по-постоянно за продължителността на програмата.

1073
01:06:31,830 --> 01:06:36,430
Защото както знаете, ако Вие декларирате х рамките на функция и тази функция се връща,

1074
01:06:36,430 --> 01:06:40,910
вече нямате достъп до данни, които са съхранени в х.

1075
01:06:40,910 --> 01:06:44,420
Какво указатели нека направим, е, че те нека съхранява памет или магазин стойности

1076
01:06:44,420 --> 01:06:46,840
в различен сегмент на паметта, а именно на куп.

1077
01:06:46,840 --> 01:06:49,340
Сега, след като се върнем от функция, толкова дълго, тъй като ние имаме показалеца

1078
01:06:49,340 --> 01:06:54,960
на това място в паметта, а след това какво можем да направим, е, че ние може просто да погледнете стойностите там.

1079
01:06:54,960 --> 01:06:58,020
Нека разгледаме един пример: Това е нашата памет оформление отново.

1080
01:06:58,020 --> 01:07:00,050
И ние имаме тази функция, главната.

1081
01:07:00,050 --> 01:07:06,870
Какво го прави е - добре, толкова просто, нали? Вътр х = 5, това е само една променлива в стека в основната.

1082
01:07:06,870 --> 01:07:12,450
>> От друга страна, сега ние заявяваме указател, който нарича функция giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
И така, сега отиваме в тази функция и ние създаваме нова рамка стека за.

1084
01:07:16,800 --> 01:07:20,440
Въпреки това, в тази стека рамка, ние заявяваме INT * темп,

1085
01:07:20,440 --> 01:07:23,210
които в mallocs три числа за нас.

1086
01:07:23,210 --> 01:07:25,880
Така размер на вътр ще ни даде колко байта това число е,

1087
01:07:25,880 --> 01:07:29,620
и изчистване ни дава много байтове пространство на куп.

1088
01:07:29,620 --> 01:07:32,890
Така че в този случай, ние сме създали достатъчно пространство за три числа,

1089
01:07:32,890 --> 01:07:36,830
и грамада е там, поради което съм го изготвя по-нагоре.

1090
01:07:36,830 --> 01:07:42,900
След като сте готови, ще се върнем тук, трябва само да върнат три цели числа,

1091
01:07:42,900 --> 01:07:47,000
и го връща на адреса, в този случай, че паметта е.

1092
01:07:47,000 --> 01:07:51,250
И ние показалеца = ключ, и там имаме само друг показалеца.

1093
01:07:51,250 --> 01:07:54,550
Но какво, че функцията връща се подрежда тук и изчезва.

1094
01:07:54,550 --> 01:07:59,250
Така темп изчезва, но ние все още поддържаме адрес на мястото, където

1095
01:07:59,250 --> 01:08:01,850
тези три числа са вътре в мрежата.

1096
01:08:01,850 --> 01:08:06,180
Така че в този набор, указатели са обхванати локално за нагласената рамка,

1097
01:08:06,180 --> 01:08:09,860
но споменът за които се отнасят, е в куп.

1098
01:08:09,860 --> 01:08:12,190
>> Това прави ли смисъл?

1099
01:08:12,190 --> 01:08:14,960
[Student] Бихте ли повторили? >> [Йосиф] Да.

1100
01:08:14,960 --> 01:08:20,270
Така че, ако се върна само малко, ще видите, че темп разпределени

1101
01:08:20,270 --> 01:08:23,500
някои памет на куп там.

1102
01:08:23,500 --> 01:08:28,680
Така че, когато тази функция, giveMeThreeInts връща, тази стека тук ще изчезне.

1103
01:08:28,680 --> 01:08:35,819
И с някоя от променливите, в този случай, този указател, която е разпределена в стер рамка.

1104
01:08:35,819 --> 01:08:39,649
Това ще изчезнат, но тъй като ние се върнахме темп

1105
01:08:39,649 --> 01:08:46,330
и показалеца = Temp, показалеца сега ще посочим същата памет, на мястото, като температура.

1106
01:08:46,330 --> 01:08:50,370
Така че сега, въпреки че ние губим темп, че местните показалеца,

1107
01:08:50,370 --> 01:08:59,109
ние все още запазват адресната памет на това, което сочи към вътрешността на тази променлива показалеца.

1108
01:08:59,109 --> 01:09:03,740
Въпроси? Това може да бъде вид на объркващо тема, ако не сте отишъл в раздел.

1109
01:09:03,740 --> 01:09:09,240
Ние можем да си TF определено ще премине и разбира се можем да отговорим на въпроса

1110
01:09:09,240 --> 01:09:11,500
в края на прегледа сесия за тази.

1111
01:09:11,500 --> 01:09:14,220
Но това е вид на сложна тема, а аз имам още примери, които предстои да се появи

1112
01:09:14,220 --> 01:09:18,790
, който ще помогне да се изяснят Какво всъщност са указатели.

1113
01:09:18,790 --> 01:09:22,500
>> В този случай, указатели са еквивалентни на масиви,

1114
01:09:22,500 --> 01:09:25,229
така че може просто да използвате този указател като едно и също нещо като INT масив.

1115
01:09:25,229 --> 01:09:29,840
Така че аз съм индексиране на 0, и промяна на първото число 1,

1116
01:09:29,840 --> 01:09:39,689
промяна на второто число на 2 и 3-то число 3.

1117
01:09:39,689 --> 01:09:44,210
Така че по-указатели. Е, припомни Binky.

1118
01:09:44,210 --> 01:09:48,319
В този случай ние сме разпределени показалеца, или обявен за показалеца,

1119
01:09:48,319 --> 01:09:52,760
но първоначално, когато току-що обяви показалеца, това не е насочена навсякъде в паметта.

1120
01:09:52,760 --> 01:09:54,930
Той е само боклук стойности вътре в него.

1121
01:09:54,930 --> 01:09:56,470
Така че аз нямам представа къде този указател сочи към.

1122
01:09:56,470 --> 01:10:01,630
Той има адрес, който е просто изпълнен с 0 и 1, където тя първоначално бе обявено.

1123
01:10:01,630 --> 01:10:04,810
Не мога да направя нищо с това, докато аз наричам изчистване на

1124
01:10:04,810 --> 01:10:08,390
и след това ми дава малко място на куп, където мога да сложа стойности вътре.

1125
01:10:08,390 --> 01:10:11,980
И все пак, аз не знам какво е вътре в тази памет.

1126
01:10:11,980 --> 01:10:16,780
Така че първото нещо, което трябва да направите, е да проверите дали системата има достатъчно памет

1127
01:10:16,780 --> 01:10:20,850
да ми даде 1 число на първо място, поради което аз правя тази проверка.

1128
01:10:20,850 --> 01:10:25,020
Ако показалецът е нула, което означава, че не разполагат с достатъчно пространство или някаква друга станала грешка,

1129
01:10:25,020 --> 01:10:26,320
така че трябва да излезете от програмата ми.

1130
01:10:26,320 --> 01:10:29,400
 Но ако го е направил успее, сега мога да използва тази показалеца

1131
01:10:29,400 --> 01:10:35,020
и какво * показалеца е, когато адресът е

1132
01:10:35,020 --> 01:10:38,480
до мястото, където тази стойност е, и го постави на равна на 1.

1133
01:10:38,480 --> 01:10:41,850
Така че тук, ние сме проверка, ако тази памет.

1134
01:10:41,850 --> 01:10:45,380
>> След като знаем, че съществува, можете да поставите в него

1135
01:10:45,380 --> 01:10:50,460
каква стойност искате да поставите в него, в този случай 1.

1136
01:10:50,460 --> 01:10:53,060
След като сме готови с нея, трябва да освободите че показалеца

1137
01:10:53,060 --> 01:10:57,160
защото ние трябва да се върнем към системата, която памет, която поиска на първо място.

1138
01:10:57,160 --> 01:10:59,690
Тъй като компютърът не знае, когато сме готови с него.

1139
01:10:59,690 --> 01:11:02,510
В този случай ние изрично го казвам, добре, ние сме направили с този спомен.

1140
01:11:02,510 --> 01:11:10,780
Ако някой друг процес се нуждае от някоя друга програма се нуждае от нея, не се колебайте да вървим напред и да го вземе.

1141
01:11:10,780 --> 01:11:15,110
Това, което ние можем да направим, е, че ние може просто да получите адреса на локални променливи на снимачната площадка.

1142
01:11:15,110 --> 01:11:19,080
Така INT х е вътре подредени рамките на главната.

1143
01:11:19,080 --> 01:11:23,060
И когато ние използваме този символ, това и оператор, това, което той прави, е

1144
01:11:23,060 --> 01:11:27,310
е необходимо х и х е само някои данни в паметта, но има адрес.

1145
01:11:27,310 --> 01:11:33,790
Той е разположен някъде. Така че, като се обадите & X, какво прави тя ни дава адреса на х.

1146
01:11:33,790 --> 01:11:38,430
По този начин, ние правим показалеца точка където х е в паметта.

1147
01:11:38,430 --> 01:11:41,710
Сега ние просто нещо като * X, ние отиваме да получите 5 гърба.

1148
01:11:41,710 --> 01:11:43,820
Звездата се нарича го dereferencing.

1149
01:11:43,820 --> 01:11:46,640
Последвайте адреса и можете да получите на стойност от него се съхранява там.

1150
01:11:51,000 --> 01:11:53,310
>> Някакви въпроси? Да?

1151
01:11:53,310 --> 01:11:56,500
[Student] Ако не направите три лъча нещо, не тя все още компилирам?

1152
01:11:56,500 --> 01:11:59,490
Да. Ако не направи 3 тройки нещо, тя все още продължава да съставят,

1153
01:11:59,490 --> 01:12:02,720
но аз ще ви покажа какво се случва в секунда, и без да се прави това,

1154
01:12:02,720 --> 01:12:04,860
това е, което ние наричаме памет течове. Вие не даваме системата

1155
01:12:04,860 --> 01:12:07,850
архивирате паметта си, така че след известно време програмата е да се натрупват

1156
01:12:07,850 --> 01:12:10,940
памет, която не използва, и нищо друго не може да го използвате.

1157
01:12:10,940 --> 01:12:15,750
Ако някога сте виждали Firefox с 1,5 милиона килобайта на вашия компютър,

1158
01:12:15,750 --> 01:12:17,840
в диспечера на задачите, това е какво се случва.

1159
01:12:17,840 --> 01:12:20,760
Имате памет течове в програмата, че те не са работа.

1160
01:12:23,080 --> 01:12:26,240
Е, как показалеца аритметика работа?

1161
01:12:26,240 --> 01:12:29,480
Е, показалецът на аритметиката е нещо като индексиране в масив.

1162
01:12:29,480 --> 01:12:36,370
В този случай, имам указател, и това, което правя е, че показалеца точка за първия елемент

1163
01:12:36,370 --> 01:12:42,100
на този масив на три числа, които съм разпределени.

1164
01:12:42,100 --> 01:12:46,670
Така че сега това, което правя, звезда показалеца просто променя първият елемент в списъка.

1165
01:12:46,670 --> 01:12:49,140
Star показалка една точки тук.

1166
01:12:49,140 --> 01:12:53,140
Така че показалецът е тук, показалецът на един е тук, показалецът 2 е тук.

1167
01:12:53,140 --> 01:12:56,610
>> Така че просто добавяне на 1 е същото като да се движат по този масив.

1168
01:12:56,610 --> 01:12:59,880
Какво правим, когато правим показалеца един можете да получите на адрес тук,

1169
01:12:59,880 --> 01:13:04,180
и, за да получите стойността тук, вие поставяте звезда от целия израз

1170
01:13:04,180 --> 01:13:05,990
да го сочените файлове.

1171
01:13:05,990 --> 01:13:09,940
Така че, в този случай, аз съм за определяне на първото място в този масив 1

1172
01:13:09,940 --> 01:13:13,970
второто място на 2, и трето място 3.

1173
01:13:13,970 --> 01:13:18,180
Тогава какво правя тук е, че аз съм печат показалеца един,

1174
01:13:18,180 --> 01:13:19,970
която току-що ми дава 2.

1175
01:13:19,970 --> 01:13:23,650
Сега увеличаване показалеца, така че показалецът се равнява на показалеца един,

1176
01:13:23,650 --> 01:13:26,780
който се движи напред.

1177
01:13:26,780 --> 01:13:30,810
И така, сега, ако разпечатате показалеца един показалеца едно сега е 3,

1178
01:13:30,810 --> 01:13:33,990
която в този случай се отпечатва 3.

1179
01:13:33,990 --> 01:13:36,560
И с оглед на свободно нещо, показалеца, че аз я давам

1180
01:13:36,560 --> 01:13:40,540
трябва да се посочи в началото на масив, който се върнах от изчистване.

1181
01:13:40,540 --> 01:13:43,430
Така че, в този случай, ако мога да се обадя три тук, това не би било правилно,

1182
01:13:43,430 --> 01:13:45,070
, защото това е в средата на масива.

1183
01:13:45,070 --> 01:13:48,820
Аз трябва да се изважда, за да стигнем до първоначалното местоположение

1184
01:13:48,820 --> 01:13:50,420
първоначалния първото място, преди да мога да го освободи.

1185
01:13:56,300 --> 01:13:58,450
Така че, тук е по-сложен пример.

1186
01:13:58,450 --> 01:14:03,360
В този случай, ние сме разпределяне на 7 герои в герой масив.

1187
01:14:03,360 --> 01:14:06,480
>> И в този случай това, което правим, е, че ние примка през първите 6 от тях,

1188
01:14:06,480 --> 01:14:09,900
и ние сме ги, за да Z.

1189
01:14:09,900 --> 01:14:13,350
Така че, за Int = 0, I> 6, аз + +,

1190
01:14:13,350 --> 01:14:16,220
Така че, показалеца + I просто ще ни даде, в този случай,

1191
01:14:16,220 --> 01:14:20,860
показалеца, една показалка, показалецът 2, показалецът на 3 и така нататък и така нататък във веригата.

1192
01:14:20,860 --> 01:14:24,040
Какво ще направи той получава този адрес, dereferences да получите стойността,

1193
01:14:24,040 --> 01:14:27,440
и промените в тази стойност до Z.

1194
01:14:27,440 --> 01:14:30,350
След това в края не забравяйте, това е низ, нали?

1195
01:14:30,350 --> 01:14:33,560
Всички струни трябва да завършва с нула прекратяване характер.

1196
01:14:33,560 --> 01:14:38,620
Така че, това, което правя, е да показалка 6 Сложих нулевата характер терминатор.

1197
01:14:38,620 --> 01:14:43,980
И сега това, което аз съм основно правиш тук изпълнява ФОРМАТ за низ, нали?

1198
01:14:43,980 --> 01:14:46,190
>> Така че, когато ФОРМАТ сега, когато той е достигнал края на низ?

1199
01:14:46,190 --> 01:14:48,230
Когато го удари нула прекратяване характер.

1200
01:14:48,230 --> 01:14:52,030
Така че, в този случай, моите оригинални показалецът се посочва началото на този масив.

1201
01:14:52,030 --> 01:14:56,410
Отпечатване на първата характер. Го преместите повече от една.

1202
01:14:56,410 --> 01:14:58,420
Отпечатвам този характер. Да го преместите.

1203
01:14:58,420 --> 01:15:02,180
И продължаваш да правиш това, докато не стигнат до края.

1204
01:15:02,180 --> 01:15:07,750
И сега показалеца края * ще сочен и да получите нула прекратяване характер.

1205
01:15:07,750 --> 01:15:11,780
И така моята линия, докато тече само когато тази стойност не е нула прекратяване характер.

1206
01:15:11,780 --> 01:15:13,770
Така че, сега аз излезете от този цикъл.

1207
01:15:18,780 --> 01:15:21,180
И така, ако аз се изважда 6 от този указател

1208
01:15:21,180 --> 01:15:22,860
Отивам назад чак до началото.

1209
01:15:22,860 --> 01:15:27,880
Не забравяйте, че правя това, защото аз трябва да отида в началото, за да го освободи.

1210
01:15:27,880 --> 01:15:30,270
>> Така че, аз знам, че е много. Има ли някакви въпроси?

1211
01:15:30,270 --> 01:15:31,870
Моля, нали?

1212
01:15:31,870 --> 01:15:36,610
[Студентски неразбираем въпрос]

1213
01:15:36,610 --> 01:15:38,190
Може ли да се каже, че по-силно? Извинете.

1214
01:15:38,190 --> 01:15:44,140
[Student] На последния слайд, точно преди да освободи показалеца,

1215
01:15:44,140 --> 01:15:47,300
, където са били действително се променя стойността на показалеца?

1216
01:15:47,300 --> 01:15:50,370
[Йосиф] Така че, точно тук. >> Студентски] О, добре.

1217
01:15:50,370 --> 01:15:51,890
[Йосиф] Така че, имам указател минус минус, нали,

1218
01:15:51,890 --> 01:15:54,140
който се движи нещо назад с едно, а след това го освободи,

1219
01:15:54,140 --> 01:15:57,000
трябва да се подчертае, защото този указател към началото на масива.

1220
01:15:57,000 --> 01:16:00,420
[Student] Но това няма да бъде необходима е спряна, след като тази линия.

1221
01:16:00,420 --> 01:16:03,130
[Йосиф] Така че, ако бях спрял след това, това ще се счита изтичане на памет,

1222
01:16:03,130 --> 01:16:04,810
защото аз не пуснете безплатно.

1223
01:16:04,810 --> 01:16:11,290
[Student] [неразбираемо след първите три реда, където трябваше показалеца един неразбираем].

1224
01:16:11,290 --> 01:16:13,140
[Йосиф] Аха. И така, какво е въпросът там?

1225
01:16:13,140 --> 01:16:14,780
Извинете. Не, не. Давай, давай, моля.

1226
01:16:14,780 --> 01:16:16,870
[Student] Така че, не променя стойността на указатели.

1227
01:16:16,870 --> 01:16:19,130
Може би не трябваше да правя показалеца минус минус.

1228
01:16:19,130 --> 01:16:19,730
[Йосиф] Да, точно така.

1229
01:16:19,730 --> 01:16:21,890
Така че, когато показалеца на една и показалеца 2,

1230
01:16:21,890 --> 01:16:24,410
Аз не правя показалеца се равнява на показалеца едно.

1231
01:16:24,410 --> 01:16:27,260
Така че, показалеца просто остава посочи в началото на масива.

1232
01:16:27,260 --> 01:16:31,460
Това е само, когато правя плюс плюс, че той определя стойността обратно вътре показалеца,

1233
01:16:31,460 --> 01:16:33,550
, че в действителност се премести заедно.

1234
01:16:36,860 --> 01:16:37,780
Добре.

1235
01:16:40,550 --> 01:16:42,030
Още въпроси?

1236
01:16:44,680 --> 01:16:47,790
>> Отново, ако това е нещо огромно, това ще бъдат покрити в сесия.

1237
01:16:47,790 --> 01:16:50,710
Посъветвайте се с Вашия колега учение за него, и да можем да отговорим на въпроса в края.

1238
01:16:53,510 --> 01:16:56,600
И обикновено ние не обичаме да направите това минус нещо.

1239
01:16:56,600 --> 01:16:59,760
Това трябва да изискват от мен следене на колко съм се компенсира в масива.

1240
01:16:59,760 --> 01:17:04,520
Така че, като цяло, това е само за да обясни как работи аритметиката с указатели.

1241
01:17:04,520 --> 01:17:07,970
Но това, което ние обикновено искали да направите, ние бихме искали да се създаде копие на показалеца,

1242
01:17:07,970 --> 01:17:11,640
и след това ще използвате това копие, когато сме се движи в низа.

1243
01:17:11,640 --> 01:17:14,660
Така че, в тези случаи да използвате копието да отпечатате целия низ,

1244
01:17:14,660 --> 01:17:19,040
но ние не трябва да направите, като показалеца минус 6 или да следите колко ние се преместихме в това,

1245
01:17:19,040 --> 01:17:22,700
само защото ние знаем, че нашата отправната точка все още се посочи в началото на списъка

1246
01:17:22,700 --> 01:17:25,340
и всичко, което сме променили това копие.

1247
01:17:25,340 --> 01:17:28,250
Така че, като цяло, да променя копия на оригинални показалеца.

1248
01:17:28,250 --> 01:17:32,350
Не се опитвайте да нещо като - не ... променя оригинални екземпляра.

1249
01:17:32,350 --> 01:17:35,290
Опитвам се да променя само копия на оригиналните ви.

1250
01:17:41,540 --> 01:17:44,870
Така че, можете да забележите, когато минаваме покрай низ в ФОРМАТ

1251
01:17:44,870 --> 01:17:48,990
не е нужно да се сложи звезда пред него, както направихме и с всички други dereferences, нали?

1252
01:17:48,990 --> 01:17:54,180
Така че, ако разпечатате целия низ% S очаква адрес,

1253
01:17:54,180 --> 01:17:57,610
и в този случай указател или в този случай като масив от знаци.

1254
01:17:57,610 --> 01:18:00,330
>> Символи, Чар * и масиви са едно и също нещо.

1255
01:18:00,330 --> 01:18:03,690
Pointer е до знака и характер масиви са едно и също нещо.

1256
01:18:03,690 --> 01:18:05,720
И така, всичко, което трябва да направим, е да премине в показалеца.

1257
01:18:05,720 --> 01:18:08,150
Ние не трябва да мине като * показалеца или нещо подобно.

1258
01:18:13,110 --> 01:18:14,930
Така че, масиви и указатели са едно и също нещо.

1259
01:18:14,930 --> 01:18:19,160
Когато правиш нещо подобно х [Y] тук за масив,

1260
01:18:19,160 --> 01:18:21,960
какво прави под капака е казва, добре, това е знак, масив,

1261
01:18:21,960 --> 01:18:23,690
така че това е показалеца.

1262
01:18:23,690 --> 01:18:26,510
И така, х са едно и също нещо,

1263
01:18:26,510 --> 01:18:28,650
и така това, което прави, е добавя база до х,

1264
01:18:28,650 --> 01:18:31,820
което е същото като да се движи напред в паметта, което много.

1265
01:18:31,820 --> 01:18:34,930
И сега X + Y ни дава някакъв адрес,

1266
01:18:34,930 --> 01:18:37,570
и ние сочените от адреса или следвайте стрелката

1267
01:18:37,570 --> 01:18:41,640
когато това място в паметта и получаваме стойността на това място в паметта.

1268
01:18:41,640 --> 01:18:43,720
Така че, тези двамата са точно едно и също нещо.

1269
01:18:43,720 --> 01:18:45,840
Това е просто една синтактична захар.

1270
01:18:45,840 --> 01:18:48,090
Те правят същото нещо. Те са просто различни дял от математиката един за друг.

1271
01:18:51,500 --> 01:18:57,590
>> И така, какво може да се обърка с указатели? Например, много. Добре. Така че, лоши неща.

1272
01:18:57,590 --> 01:19:02,410
Някои лоши неща, които можете да направите, не се проверка,, ако вашият изчистване повикване връща нула, нали?

1273
01:19:02,410 --> 01:19:06,560
В този случай, аз искам системата да ми дадете - какво е това число?

1274
01:19:06,560 --> 01:19:11,200
Подобно на 2 милиарда пъти 4, тъй като размерът на целите числа е 4 байта.

1275
01:19:11,200 --> 01:19:13,810
Аз го питам като 8 милиард байта.

1276
01:19:13,810 --> 01:19:17,270
Разбира се, компютърът ми не ще да бъде в състояние да ми даде, че много назад с памет.

1277
01:19:17,270 --> 01:19:20,960
И ние не проверите дали това е нищожна, така че, когато ние се опитваме да го сочен там -

1278
01:19:20,960 --> 01:19:24,270
Следвайте стрелката до мястото, където ще - ние не разполагат с тази памет.

1279
01:19:24,270 --> 01:19:27,150
Това е, което ние наричаме dereferencing нулев указател.

1280
01:19:27,150 --> 01:19:29,710
И това същество ви кара да segfault.

1281
01:19:29,710 --> 01:19:31,790
Това е един от начините, можете да segfault.

1282
01:19:34,090 --> 01:19:38,090
Други лошите неща, които можете да направите - о.

1283
01:19:38,090 --> 01:19:40,650
Това беше dereferencing с нулев указател. Добре.

1284
01:19:40,650 --> 01:19:45,160
Други лоши неща - добре, за да се определи, че просто сложете отметка там

1285
01:19:45,160 --> 01:19:46,980
проверява дали показалецът е нищожна

1286
01:19:46,980 --> 01:19:51,000
и да излезете от програмата, ако това се случи, че изчистване връща нулев указател.

1287
01:19:55,110 --> 01:19:59,850
Това е xkcd комикс. Хората го разбират. Донякъде.

1288
01:20:06,120 --> 01:20:09,350
>> Така че, памет. И аз отидох над това.

1289
01:20:09,350 --> 01:20:12,000
Ние призоваваме изчистване в една линия, но всеки път, когато ние наричаме изчистване

1290
01:20:12,000 --> 01:20:14,370
ние губим следите, когато това показалецът сочи,

1291
01:20:14,370 --> 01:20:15,750
защото ние сме го clobbering.

1292
01:20:15,750 --> 01:20:18,410
И така, първоначалната покана за изчистване ми дава памет тук.

1293
01:20:18,410 --> 01:20:19,990
Показалецът указатели за това.

1294
01:20:19,990 --> 01:20:23,020
Сега, аз не го освободи, така че сега аз наричам изчистване отново.

1295
01:20:23,020 --> 01:20:26,070
Сега той посочва тук. Сега моята памет е насочена тук.

1296
01:20:26,070 --> 01:20:27,640
Посочвайки тук. Посочвайки тук.

1297
01:20:27,640 --> 01:20:31,820
Но аз съм изгубил следите на адресите на всички тук, че аз разпределени памет.

1298
01:20:31,820 --> 01:20:35,100
И така, сега аз не всяко позоваване на тях вече.

1299
01:20:35,100 --> 01:20:37,230
Така че, аз не мога да ги освободи извън този цикъл.

1300
01:20:37,230 --> 01:20:39,390
И така, за да се определи нещо подобно,

1301
01:20:39,390 --> 01:20:42,250
ако сте пропуснали да освободите памет и да получите тази памет течове,

1302
01:20:42,250 --> 01:20:45,810
Трябва да освободите памет в рамките на този цикъл, след като сте готови с него.

1303
01:20:45,810 --> 01:20:51,400
Е, това е, което се случва. Знам, че много от вас, мразя това.

1304
01:20:51,400 --> 01:20:55,270
Но сега - Уау! Можете да получите като 44000 килобайта.

1305
01:20:55,270 --> 01:20:57,110
Така че, можете да го освободи в края на цикъла,

1306
01:20:57,110 --> 01:20:59,770
и че просто ще освободи памет всеки път.

1307
01:20:59,770 --> 01:21:03,620
Същество, вашата програма не изтичане на памет вече.

1308
01:21:03,620 --> 01:21:08,150
>> И сега нещо друго, което може да направите, е да освободите памет, която сте поискали за два пъти.

1309
01:21:08,150 --> 01:21:11,060
В този случай, изчистване на нещо, промяна на стойността.

1310
01:21:11,060 --> 01:21:13,140
Го освободи веднага, защото ти каза, че са били извършени с него.

1311
01:21:13,140 --> 01:21:14,940
Но след това го освободил.

1312
01:21:14,940 --> 01:21:16,730
Това е нещо, което е доста лошо.

1313
01:21:16,730 --> 01:21:18,820
Това няма първоначално да segfault,

1314
01:21:18,820 --> 01:21:23,350
но след известно време какво това не е двойно освобождаването това развращава куп структура,

1315
01:21:23,350 --> 01:21:27,200
и вие ще научите малко повече за това, ако решите да се вземе един клас като CS61.

1316
01:21:27,200 --> 01:21:30,000
Но по същество след известно време компютърът ви е да се бърка

1317
01:21:30,000 --> 01:21:33,010
за паметта са там, където и когато той се съхранява -

1318
01:21:33,010 --> 01:21:34,800
когато данните се съхраняват в паметта.

1319
01:21:34,800 --> 01:21:38,080
И така, освобождаването на показалеца два пъти е лошо нещо, което не искам да правя.

1320
01:21:38,080 --> 01:21:41,600
>> Други неща, които могат да се объркат не се използва sizeof.

1321
01:21:41,600 --> 01:21:44,460
Така че, в този случай изчистване 8 байта,

1322
01:21:44,460 --> 01:21:46,700
и това е едно и също нещо като две числа, нали?

1323
01:21:46,700 --> 01:21:49,580
Така, че е напълно безопасно, но е?

1324
01:21:49,580 --> 01:21:52,160
Ами, тъй като Лукас говорихме на различни архитектури,

1325
01:21:52,160 --> 01:21:54,220
числа са с различна дължина.

1326
01:21:54,220 --> 01:21:57,970
Така че, на уреда, че използвате числа са около 4 байта,

1327
01:21:57,970 --> 01:22:02,370
но по някаква друга система може да бъде 8 байта или те могат да бъдат 16 байта.

1328
01:22:02,370 --> 01:22:05,680
Така че, ако аз просто използвайте този номер тук,

1329
01:22:05,680 --> 01:22:07,310
тази програма може да работи на уреда,

1330
01:22:07,310 --> 01:22:10,360
но това няма да се разпределят достатъчно памет на някаква друга система.

1331
01:22:10,360 --> 01:22:14,020
В този случай, това е, което операторът sizeof се използва за.

1332
01:22:14,020 --> 01:22:16,880
Когато ние наричаме sizeof (INT), какво прави това

1333
01:22:16,880 --> 01:22:21,910
 тя ни дава размера на цяло число на системата, която се изпълнява програмата.

1334
01:22:21,910 --> 01:22:25,490
Така че, в този случай, sizeof (INT) ще се върне 4 от нещо подобно на уреда,

1335
01:22:25,490 --> 01:22:29,980
и сега тази воля 4 * 2, което е с 8,

1336
01:22:29,980 --> 01:22:32,330
който е само на размера на пространството, необходимо за две цели числа.

1337
01:22:32,330 --> 01:22:36,710
На друга система, ако число е като 16 байта или 8 байта,

1338
01:22:36,710 --> 01:22:39,380
това е просто ще се върне достатъчно байта за съхраняване на тази сума.

1339
01:22:41,830 --> 01:22:45,310
>> И накрая, structs.

1340
01:22:45,310 --> 01:22:48,340
Така че, ако искате да съхранявате судоку съвет в паметта, как бихме могли да направим това?

1341
01:22:48,340 --> 01:22:51,570
Може би си мислите като променлива за първото нещо,

1342
01:22:51,570 --> 01:22:53,820
променлива за второто нещо, променлива за третото нещо,

1343
01:22:53,820 --> 01:22:56,420
променлива за четвъртото нещо лошо, нали?

1344
01:22:56,420 --> 01:23:00,750
Така че, едно подобрение, което можете да направите в началото на тази е да се направи 9 х 9 масив.

1345
01:23:00,750 --> 01:23:04,480
Това е добре, но какво ще стане, ако искаш да се сдружават с други неща с борда на судоку

1346
01:23:04,480 --> 01:23:06,490
харесва това, което трудността на борда е,

1347
01:23:06,490 --> 01:23:11,740
или, например, каква е вашата оценка е или колко време е взето за решаване на този форум?

1348
01:23:11,740 --> 01:23:14,970
Е, това, което можеш да направиш е да можете да създадете структура.

1349
01:23:14,970 --> 01:23:18,910
Това, което аз съм основно казват, е, че се определи тази структура тук,

1350
01:23:18,910 --> 01:23:23,230
и аз съм определяне на судоку съвет, който се състои от борд, който е 9 х 9.

1351
01:23:23,230 --> 01:23:26,650
>> И какво е има указатели към името на нивото.

1352
01:23:26,650 --> 01:23:30,730
Тя също има X и Y, които са координатите на мястото, където съм сега.

1353
01:23:30,730 --> 01:23:35,980
Той също така е времето, прекарано [неразбираем], и има общия брой ходове съм въведените досега.

1354
01:23:35,980 --> 01:23:40,010
И така, в този случай, мога да групирате цял куп данни само в една структура

1355
01:23:40,010 --> 01:23:42,790
вместо да го сякаш летя около като различни променливи

1356
01:23:42,790 --> 01:23:44,540
че не мога наистина да следите.

1357
01:23:44,540 --> 01:23:49,720
И това ни позволява да има само хубаво синтаксис за нещо на съотнасяне на различни неща вътре в тази структура.

1358
01:23:49,720 --> 01:23:53,430
Мога само да направя board.board, и аз се судоку дъската.

1359
01:23:53,430 --> 01:23:56,320
Board.level, аз се колко е трудно.

1360
01:23:56,320 --> 01:24:00,540
Board.x и board.y ми даде координатите на мястото, където мога да бъда в борда.

1361
01:24:00,540 --> 01:24:04,730
И така, аз съм достъп до това, което ние наричаме полета в структурата.

1362
01:24:04,730 --> 01:24:08,840
Това определя sudokuBoard, която е един вид, че имам.

1363
01:24:08,840 --> 01:24:14,800
И сега сме тук. Имам променлива, наречена "борда" от тип sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
И така, сега мога да получите достъп до всички области, които правят тази структура тук.

1365
01:24:20,830 --> 01:24:22,450
>> Всякакви въпроси за structs? Да?

1366
01:24:22,450 --> 01:24:25,890
[Student] Int X, Y, обявена на един ред? >> [Йосиф] Аха.

1367
01:24:25,890 --> 01:24:27,400
[Student] Така че, може просто направи това с всички тях?

1368
01:24:27,400 --> 01:24:31,200
Като в X, Y запетая пъти, че общо?

1369
01:24:31,200 --> 01:24:34,460
[Йосиф] Да, определено може да направи това, но причината Сложих х и у по същата линия -

1370
01:24:34,460 --> 01:24:36,330
и въпросът е защо можем да го направим по същата линия?

1371
01:24:36,330 --> 01:24:38,600
Защо просто не сложи всичко това на същата линия е

1372
01:24:38,600 --> 01:24:42,090
х и у са свързани един с друг,

1373
01:24:42,090 --> 01:24:44,780
и това е само стилистично по-правилно, в известен смисъл,

1374
01:24:44,780 --> 01:24:46,600
защото това е групиране на две неща по една и съща линия

1375
01:24:46,600 --> 01:24:49,340
, че подобно нещо се отнасят до едно и също нещо.

1376
01:24:49,340 --> 01:24:51,440
И аз просто се разделят тези разпада. Това е просто стил нещо.

1377
01:24:51,440 --> 01:24:53,720
Това функционално прави никаква разлика, каквато.

1378
01:24:58,150 --> 01:24:59,270
Някакви други въпроси на structs?

1379
01:25:03,030 --> 01:25:06,620
Можете да определите Pokédex с структура.

1380
01:25:06,620 --> 01:25:11,720
Pokémon има номер и да го има писмо, собственик, вид.

1381
01:25:11,720 --> 01:25:16,990
И тогава, ако имате набор от Pokémon, можете да направите на Pokédex, нали?

1382
01:25:16,990 --> 01:25:20,810
Добре, готин. Така че, въпроси върху structs. Това са свързани с structs.

1383
01:25:20,810 --> 01:25:25,270
>> И накрая, GDB. Какво GDB ви позволи да направите? Тя ви позволява да отстранявате грешки във вашата програма.

1384
01:25:25,270 --> 01:25:27,650
И ако не сте използвали GDB, бих препоръчва гледане на кратко

1385
01:25:27,650 --> 01:25:31,250
и само над това, което GDB, как се работи с нея, как бихте могли да го използвате,

1386
01:25:31,250 --> 01:25:32,900
и да го тестваме по програма.

1387
01:25:32,900 --> 01:25:37,400
И така, какво GDB ви позволява да направите е, тя позволява пауза [неразбираем] програмата си

1388
01:25:37,400 --> 01:25:38,920
и практически линия.

1389
01:25:38,920 --> 01:25:42,600
Например, аз искам да пауза изпълнение, като линия 3 от моята програма,

1390
01:25:42,600 --> 01:25:46,010
и докато аз съм в ред 3 могат да се изведат всички стойности, които са там.

1391
01:25:46,010 --> 01:25:49,710
И така, това, което ние наричаме като пауза в една линия

1392
01:25:49,710 --> 01:25:52,350
е ние наричаме това сложи точка на прекъсване на този ред

1393
01:25:52,350 --> 01:25:55,920
и след това да отпечатате на променливите на състоянието на програмата по това време.

1394
01:25:55,920 --> 01:25:58,990
>> Ние можем след това от там стъпка чрез програмата ред по ред.

1395
01:25:58,990 --> 01:26:03,200
И тогава ние можем да погледнем състоянието на стека по това време.

1396
01:26:03,200 --> 01:26:08,600
И така, за да използвате GDB, това, което правим, е да се обадя ехтя на файла C,

1397
01:26:08,600 --> 01:26:11,290
но ние трябва да го давате на ggdb флаг.

1398
01:26:11,290 --> 01:26:15,850
И след като сме готови с това, ние просто стартирате GDB върху получения изходния файл.

1399
01:26:15,850 --> 01:26:18,810
И така, можете да получите някои маса на текст като този,

1400
01:26:18,810 --> 01:26:21,990
но наистина всичко, което трябва да направите е да напишете командата в началото.

1401
01:26:21,990 --> 01:26:24,250
Почивка главната поставя точка на прекъсване на главната.

1402
01:26:24,250 --> 01:26:28,470
Списък 400 изброява реда код около линия 400.

1403
01:26:28,470 --> 01:26:31,410
И така, в този случай може просто да се огледам и да кажа, о,

1404
01:26:31,410 --> 01:26:34,360
Искам да зададете точка на прекъсване на линията 397, която е тази линия,

1405
01:26:34,360 --> 01:26:37,170
и след това програмата работи в тази стъпка и че ще ходи да се счупят.

1406
01:26:37,170 --> 01:26:41,120
Това ще пауза там, и можете да отпечатате, например, стойността на ниско или високо.

1407
01:26:41,120 --> 01:26:46,410
И така, има един куп от команди, които трябва да знаете,

1408
01:26:46,410 --> 01:26:48,660
и това слайдшоу ще отидат на сайта,

1409
01:26:48,660 --> 01:26:54,000
така че ако просто искате да се обърнете тях или като ги поставя на вашите мамят листове, не се колебайте.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Това беше Quiz Review 0, и ние ще се придържаме наоколо, ако имате някакви въпроси.

1411
01:27:00,650 --> 01:27:03,850
Добре.

1412
01:27:03,850 --> 01:27:09,030
>>  [Аплодисменти]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]