1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Огляд] [Вікторина 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Росс, Томмі MacWilliam, Лукас Фрейтас, Йосип Ong] [Harvard University]

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
Ласкаво просимо на розгляд сесії Вікторина 0, яке проходить у середу.

6
00:00:15,000 --> 00:00:19,000
Що ми збираємося робити сьогодні ввечері, я з 3 іншими ТФ,

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
>> [Вікторина 0 Огляд] [Частина 0] [Lexi Ross] Але перш ніж ми це зробимо, давайте поговоримо про

15
00:00:50,000 --> 00:00:53,000
матеріально-технічне забезпечення вікторини.

16
00:00:53,000 --> 00:00:55,000
>> [Логістика] [вікторини відбудеться в середу 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
так що ваші ТФ повинні йти на деякі практики проблеми,

25
00:01:21,000 --> 00:01:29,000
і це ще один хороший шанс, щоб побачити, де ви все ще потрібно вивчити для вікторини.

26
00:01:29,000 --> 00:01:32,000
Давайте почнемо з самого початку з Б-н-біт.

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 біт, це 1 байт,

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

34
00:01:53,000 --> 00:01:58,000
Шістнадцяткові є підставою 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. Це буде одна 1, одна 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 до B, і так далі, де 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
Цезар і шифр Віженер, конвертувати різні букви

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
І як би ми точно конвертувати між цими 2 форми?

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
і тут ми зробити те ж саме на мові програмування Сі.

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
Пам'ятайте, що це && і | |, коли ми намагаємося об'єднати 2 або більше умов,

102
00:06:26,000 --> 00:06:30,000
Чи не === перевірити 2 речі дорівнюють.

103
00:06:30,000 --> 00:06:36,000
Пам'ятайте, що = для призначення в той час як == це логічний оператор.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, а потім остаточний 2 говорять самі за себе.

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
Бо, я = 0, <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
>> На цикл всередині вас є 3 компоненти:

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
і подряпин, ми змогли змоделювати події за допомогою трансляції,

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
давайте подивимося на це просте програми на Сі.

202
00:12:10,000 --> 00:12:14,000
Текст може бути трохи невеликим звідси, але я піду на це дуже швидко.

203
00:12:14,000 --> 00:12:20,000
Ми в тому числі 2 файли заголовків у верхній частині, 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
О, Int х. Переконайтеся в тому, пам'ятайте, що це локальна змінна.

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
і ми закликаємо бібліотечні функції Printf,

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

224
00:13:34,000 --> 00:13:37,000
ми не були б в змозі назвати Printf.

225
00:13:37,000 --> 00:13:42,000
І я вважаю, що стрілка, яка отримала відрізати тут вказує на% D,

226
00:13:42,000 --> 00:13:45,000
яка є форматування рядка в Printf.

227
00:13:45,000 --> 00:13:52,000
Він каже, роздрукуйте цю змінну як число,% D.

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!] [Лукас Фрейтас]

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
Ваш комп'ютер може зрозуміти тільки 0 і 1,

247
00:14:57,000 --> 00:15:01,000
так насправді в перші комп'ютери зазвичай люди запрограмовані

248
00:15:01,000 --> 00:15:04,000
використання 0 і 1, але не більше, слава Богу.

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

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
Якщо у вас є програма, що вам потрібно зробити 2 речі.

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
Можна сказати, брязкіт-O, а потім ім'я, яке ви хочете

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

266
00:16:06,000 --> 00:16:11,000
І ви також можете зробити зробити програму, і подивитися, як у перших 2-х випадках

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-або-лм.

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
І коли ви хочете запустити вашу програму у вас є 2 варіанти.

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
для зберігання значень, так що типи даних насправді так само, як покемонів.

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
Перше, що ми побачили, було INT,

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
Символ має 1 байт, що означає 8 біт, як сказала Лексі.

303
00:18:26,000 --> 00:18:31,000
В основному ми повинні ASCII таблиці, що має 256

304
00:18:31,000 --> 00:18:34,000
можливі комбінації 0 і 1,

305
00:18:34,000 --> 00:18:37,000
, А потім, коли ви вводите символ він збирається переводити

306
00:18:37,000 --> 00:18:44,000
символ, який ви входів номер, який ви маєте в ASCII таблиці, як Лексі сказала.

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-бітної машині Int і довгий мають однаковий розмір,

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, а потім Е ("% D", х / 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
і ви будете мати 1.

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, тепер буде 3,000 в рік.

341
00:20:40,000 --> 00:20:44,000
І тоді ви можете друкувати у / 2.

342
00:20:44,000 --> 00:20:50,000
Насправді, я повинен мати 2. там.

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 F просто питати 2 десяткових одиниць в десятковій частині.

346
00:21:06,000 --> 00:21:12,000
Якщо у вас є 0,3 F, що це буде мати насправді 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, і тоді ви Printf х

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, а потім оголосити символ з = х,

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
а також ми говорили про моду, яка є залишок від ділення 2-х номерів.

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
Це буде 1, так що це насправді дуже корисно для багатьох програм.

369
00:22:30,000 --> 00:22:38,000
Для Віженер і Цезаря я впевнений, що всі ви, хлопці використовували мод.

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
Так, 2, так як 3/2 буде 1,5,

374
00:22:54,000 --> 00:22:57,000
але так як ви робите операції між 2 цілих чисел

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
я * = 2, те ж саме, кажучи, що я = I * 2,

389
00:23:57,000 --> 00:23:59,000
і те ж саме для поділу.

390
00:23:59,000 --> 00:24:08,000
Якщо у вас в / = 2 це те ж саме, що я = я / 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
Наприклад, Printf, 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
Printf насправді має порожнечу возвращаемого типу

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
або як х2.

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
а потім він збирається взяти сам масив, в ціле НУМС,

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
Так само, як Лексі сказала, ви робите Int я = 0, <довжина і я + +.

446
00:27:15,000 --> 00:27:20,000
І для кожного елемента в масиві я зробив суму + = НУМС [я],

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
Погляньте на ці 2 коди. У чому різниця між ними?

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
Якщо (X> 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
Якщо це 2 не я збираюся це зробити.

470
00:28:51,000 --> 00:28:54,000
В принципі, якщо у мене було х = 2 ви могли б сказати

471
00:28:54,000 --> 00:28:57,000
Якщо (X> 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
Код працює швидше, насправді, в 3 рази швидше, якщо ви використовуєте це.

475
00:29:09,000 --> 00:29:11,000
Ми також дізналися про і і або.

476
00:29:11,000 --> 00:29:15,000
Я не збираюся пройти через це, тому що Лексі вже говорили про них.

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

478
00:29:17,000 --> 00:29:21,000
>> Єдине, що я скажу, будьте обережні, коли у вас є 3 умови.

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
або 2 умови об'єднаних в і

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
Давайте припустимо, що у вас є змінна, як п

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
, А потім value2 і так далі, і я також може мати значення за замовчуванням перемикача.

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
між шифр Цезаря і шифр Віженер,

504
00:30:54,000 --> 00:30:57,000
як обидві ці роботи шифрів і що це таке для шифрування

505
00:30:57,000 --> 00:30:59,000
і розшифрувати текст, використовуючи ці 2 шифри.

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
І шифру Віженер, з іншого боку, обертається кожен символ

509
00:31:09,000 --> 00:31:12,000
по іншу суму, так що замість того, щоб говорити

510
00:31:12,000 --> 00:31:15,000
кожен персонаж повернуть на 3 Віженер буде обертати кожен символ

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
Є 2 різних типів змінних.

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
і всередині G є змінна тут називається в,

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
і ця змінна називається у цих 2 функцій

527
00:32:03,000 --> 00:32:06,000
не знаю, що один одного локальних змінних.

528
00:32:06,000 --> 00:32:10,000
З іншого боку, тут ми говоримо Int х = 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
Це означає, що всередині цих 2 функцій, коли я говорю х - або х + +

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
Усередині 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
Тут у мене є масив з 3 цілих чисел.

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
більш ніж на 1 індекс, тому що якщо у мене є сітка

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
У мене є масив називається сітка, і я кажу, що це 2 рядки і 3 стовпці,

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
як передача Int або з плаваючою точкою.

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
що можна взяти в 2 аргументів.

603
00:36:15,000 --> 00:36:20,000
Перший аргумент основною функцією є агдс, або кількість аргументів,

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
має наступні значення, так агдс дорівнює 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
Таким чином, це означає, що у нас є 4 речі тут,

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 X = ARGV 3".

624
00:37:32,520 --> 00:37:36,470
>> От тільки не збирається сенсу, тому що це рядок, і це число.

625
00:37:36,470 --> 00:37:38,510
Так що, якщо ви хочете конвертувати між 2, пам'ятайте, що ми збираємося

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
Отже, перший спосіб, яким ми можемо описати час виконання з великою О.

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
Таким чином, ми можемо уявити, що тільки з 1, який є постійним.

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
І якщо ви коли-небудь письмово про будь факторіал алгоритм,

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
Таким чином, якщо уявити собі, п бути велика кількість, як 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 х це, або додавання 3,

672
00:40:24,220 --> 00:40:27,180
це просто константи, і вони збираються кинути вгору.

673
00:40:27,180 --> 00:40:32,480
Так ось чому всі ці 3 рази перспективі такі ж, як кажуть вони O (N).

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

675
00:40:37,490 --> 00:40:42,070
+ П, + 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
ця ³ п буде домінувати в цьому 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Що не одне і те ж, якщо ми вже запустили час, як O (N ³) і O (N ²)

680
00:40:59,130 --> 00:41:02,820
тому що ця ³ п набагато більше, ніж ця ² н.

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
Ми збираємося скоротити наші проблеми в половину, тому що раптово ми знаємо,

720
00:43:19,060 --> 00:43:23,040
цілу купу цифр, що не може бути той, який ми шукаємо.

721
00:43:23,040 --> 00:43:26,950
>> У псевдокоді це виглядатиме приблизно так,

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 (журнал N) і Ω (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
Просто так вийшло, що середина буде падати між цими 2 номери,

735
00:44:15,060 --> 00:44:18,960
так що давайте просто як завгодно говорити, кожен раз середина знаходиться між 2 номери,

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 роду говорить, що коли будь-які 2 елементи всередині списку не на місці,

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
Чи спочатку, давайте просто подивимося на деякі псевдокод дуже швидко.

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
я елементів, так від 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
і в цей момент нам потрібно запустити через список ще 1 раз

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
1 елемент одночасно.

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
що свідчить про п ².

811
00:49:13,350 --> 00:49:16,530
У кращому випадку думка, скажімо, ми даємо йому вже відсортований список;

812
00:49:16,530 --> 00:49:19,270
ми насправді не роблять краще, ніж ² н.

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
>> Якщо щось тета-н ², це і велика 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
Так це те, що псевдокод для вибору роду могла б виглядати.

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
Сині елементом тут буде я, а червоний елемент буде мінімальним елементом.

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
Таким чином, 1 більше, 6 більше, 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
ці 2 номери і поміняти їх місцями, поки ми не отримаємо наші відсортований список.

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
>> Так що, якщо у нас є функція під назвою F і F щойно подзвонив приймати по 1 аргумент,

882
00:53:48,940 --> 00:53:52,010
і ми просто дзвонять F (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
У випадку, коли п ≤ 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
Зауважте, що тут ми не просто викликом факторіал (п), тому що це було б дуже корисно.

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
Так несподівано, цей хлопець знає, що я хочу повернути 2.

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] Все в порядку. Так що тепер ми говорили про рекурсії,

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
ми говоримо, давайте розділити це на 2 половинки.

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
і це дає нам зараз 2 половинки, які сортуються, і тепер ми збираємося об'єднати ці половинки разом.

926
00:56:50,240 --> 00:56:55,010
Це трохи важко зрозуміти без прикладу, тому ми будемо проходити через рухи і подивитися, що відбувається.

927
00:56:55,010 --> 00:56:59,590
Таким чином, ви починаєте з цього списку, ми розділили його на 2 половинки.

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
Тепер ми перейдемо до списку з 2 цифр,

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
який знаходиться всього в 1 елемент, він вже відсортований.

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
Так що тепер ми об'єднаємо ці 2 номери для сортування, що первісний список, 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
Ми дивимося на перші 2 номери з цього списку, 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, тому вона йде дюйма І зауважив, що ми просто взяли 2 номери з цього списку.

954
00:58:51,010 --> 00:58:53,640
Таким чином, ми не тільки чергуючи 2 списку.

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
[Студент] Якщо це розщеплення в різних групах, чому вони не просто розділити його один раз

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
З іншого боку, якщо я дивлюся на ці 2 списку другого рівня там,

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
і ми можемо розділити список журналу 1/2 п раз,

979
01:00:27,590 --> 01:00:31,700
де ми одержимо цей журнал п х п складності.

980
01:00:31,700 --> 01:00:34,940
І ви побачите, в кращому випадку для сортування злиттям п § п, і так уже сталося,

981
01:00:34,940 --> 01:00:39,340
, Що в гіршому випадку, або Ω там, також п п увійти.

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
Якщо ви подивитеся на Scramble, ви помітите, у нас була якась система

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, які ви можете думати, як тільки Printf,

988
01:00:57,450 --> 01:01:01,720
але тільки друк у файл, а й, отже, F на самому початку.

989
01:01:01,720 --> 01:01:07,570
Такий код тут, що він робить, як ви, можливо, бачили в Scramble,

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
>> І тепер, в цьому випадку, все, що ми повинні зробити, це замінити Printf з 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
Так що це, це аргумент Еореп, добре, ми можемо відкрити файл по-різному.

1004
01:02:09,330 --> 01:02:13,510
Що ми можемо зробити, ми можемо передати його вага, а значить змінити файл, якщо він виходить вже,

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
[Студент питання, нерозбірливо]

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
Так що, якщо ви - >> [Студентський питання, нерозбірливо]

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
Ну, якщо основні виклики Фу, Фу отримує покласти в стек.

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
Так що в купі? Пам'ять розподіляється за допомогою Танос, який ми отримаємо в трохи.

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, а потім А.Ф., тому що це 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
Таким чином, в даному випадку, те, що ми є, ми маємо покажчик на ціле або ціле число *,

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
Що вона робить це - добре, так просто, правда? - Int х = 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 3 цілих для нас.

1086
01:07:23,210 --> 01:07:25,880
Таким чином, розмір Int дасть нам скільки байт цьому Int є,

1087
01:07:25,880 --> 01:07:29,620
і Танос дає нам, що багато байт простору в купі.

1088
01:07:29,620 --> 01:07:32,890
Таким чином, в цьому випадку, ми створили достатньо місця для 3 числа,

1089
01:07:32,890 --> 01:07:36,830
і купа шлях там, тому я намалював її вище.

1090
01:07:36,830 --> 01:07:42,900
Як тільки ми закінчимо, ми повернемося сюди, вам потрібно всього лише 3 цілими повернулися,

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
ці 3 числа знаходяться всередині мережі.

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
[Студент] Не могли б ви повторити? >> [Йосип] Так.

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
і ми покажчика = температура, покажчик тепер буде вказувати ту ж саму згадку про місце, темп був.

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
Так що більше на покажчики. Ну, згадайте Бінки.

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
Вона знаходиться десь. Так, подзвонивши по телефону і х, те, що це робить він дає нам за адресою х.

1146
01:11:33,790 --> 01:11:38,430
Роблячи це, ми робимо покажчик точки, де х знаходиться в пам'яті.

1147
01:11:38,430 --> 01:11:41,710
Тепер ми просто зробити щось подібне * х, ми збираємося, щоб отримати 5 тому.

1148
01:11:41,710 --> 01:11:43,820
Зірка називається разименованія його.

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
[Студент] Якщо ви цього не зробите 3-загострені річ, це все ще скомпілювати?

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
цього масив з 3 цілих чисел, які я виділив.

1164
01:12:42,100 --> 01:12:46,670
Так що тепер мені робити, зірка просто змінює покажчик на перший елемент у списку.

1165
01:12:46,670 --> 01:12:49,140
Зірка покажчик +1 очок тут.

1166
01:12:49,140 --> 01:12:53,140
Таким чином, покажчик миші тут, +1 є покажчиком тут, покажчик +2 є тут.

1167
01:12:53,140 --> 01:12:56,610
>> Так що додавання 1, те ж саме, рухаючись по цьому масиву.

1168
01:12:56,610 --> 01:12:59,880
Що ми робимо, коли ми робимо покажчик +1 Ви отримаєте адресу тут,

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
Потім, що я роблю тут є я друкую наш покажчик +1,

1174
01:13:18,180 --> 01:13:19,970
який просто дає мені 2.

1175
01:13:19,970 --> 01:13:23,650
Тепер я збільшуючи покажчик, тому покажчик одно покажчик +1,

1176
01:13:23,650 --> 01:13:26,780
, Яка рухається вперед.

1177
01:13:26,780 --> 01:13:30,810
І ось тепер, якщо я роздрукувати покажчик +1, покажчик +1 тепер 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
Таким чином, в даному випадку, якщо б я був дзвонити 3 прямо тут, це було б неправильно,

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, г> 6, я + +,

1190
01:14:13,350 --> 01:14:16,220
Таким чином, покажчик + Я просто дати нам, в даному випадку,

1191
01:14:16,220 --> 01:14:20,860
покажчик, покажчик +1, +2 покажчик, покажчик +3, і так далі, і так далі в циклі.

1192
01:14:20,860 --> 01:14:24,040
Що він збирається робити це отримує, що адреса, разименовивает його, щоб отримати значення,

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
А тепер те, що я в основному роблю тут реалізується Printf для рядка, чи не так?

1198
01:14:43,980 --> 01:14:46,190
>> Отже, коли ж Printf тепер, коли вона досягла кінця рядка?

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
[Студент] На останньому слайді право, перш ніж звільнити покажчик,

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
[Студент] Але це був би не потрібен, якщо б ви зупинилися після цього рядка.

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
[Студент] Я [нерозбірливо] після перших трьох лініях, де ви були покажчика +1 [нерозбірливо].

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
[Студент] Таким чином, ви не змінивши значення покажчиків.

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
Так що, коли я роблю покажчик та покажчик +1 +2,

1230
01:16:21,890 --> 01:16:24,410
Я не роблю покажчика одно покажчик +1.

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
Не намагайтеся щось подібне - don't змінити примірниках.

1249
01:17:32,350 --> 01:17:35,290
Спроба змінити тільки копії оригіналу.

1250
01:17:41,540 --> 01:17:44,870
Таким чином, ви помітите, коли ми передаємо рядок в Printf

1251
01:17:44,870 --> 01:17:48,990
Ви не повинні помістити зірку перед ним, як ми робили з усіма іншими разименовивает, вірно?

1252
01:17:48,990 --> 01:17:54,180
Так що, якщо ви друкуєте з усієї рядки з% очікує, що це адреса,

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
Покажчик складається в символи і символьні масиви одне і те ж.

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
Коли ви робите щось подібне X [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
А тепер х + у дає нам якусь адресу,

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
Мені подобається 2000000000 разів 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
Це те, що ми називаємо разименованія нульового покажчика.

1280
01:19:27,150 --> 01:19:29,710
А це суттєво змушує Вас падати.

1281
01:19:29,710 --> 01:19:31,790
Це один із способів сегментації.

1282
01:19:34,090 --> 01:19:38,090
Інші погані речі, які ви можете зробити - да ладно.

1283
01:19:38,090 --> 01:19:40,650
Це було разименованія нульового покажчика. Добре.

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
тому що ми видаливши його.

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
Він не збирався спочатку сегментації,

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
Таким чином, в цьому випадку ви Malloc 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
На іншій системі, якщо Int, як 16 байт або 8 байтів,

1338
01:22:36,710 --> 01:22:39,380
це просто збирається повернутися достатньо байта для зберігання цієї суми.

1339
01:22:41,830 --> 01:22:45,310
>> І, нарешті, структури.

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
Вона також має х і у, які є координатами, де я перебуваю зараз.

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
>> Будь-які питання про структурах? Так?

1366
01:24:22,450 --> 01:24:25,890
[Студент] Для Int х, у, ви оголосили обидві на одній лінії? >> [Йосип] Угу.

1367
01:24:25,890 --> 01:24:27,400
[Студент] Таким чином, ви могли б просто зробити це з ними з усіма?

1368
01:24:27,400 --> 01:24:31,200
Як і в х, у комою раз, що загальне?

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
Будь-які інші питання, що стосуються структури?

1379
01:25:03,030 --> 01:25:06,620
Ви можете визначити з Pokédex структури.

1380
01:25:06,620 --> 01:25:11,720
Покемон має номер і він має листі, власник, тип.

1381
01:25:11,720 --> 01:25:16,990
І потім, якщо у вас є масив з покемонів, ви можете скласти Pokédex, вірно?

1382
01:25:16,990 --> 01:25:20,810
Добре, прохолодно. Таким чином, питання про структур. Це пов'язано з структурам.

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. Це була вікторина відгук 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]