1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Частина 6] [більш комфортним]

2
00:00:01,000 --> 00:00:04,000
[Rob Боуден] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[Це CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Ми можемо відправитися в нашому розділі питань.

5
00:00:11,000 --> 00:00:17,000
Я послав URL для космічних раніше.

6
00:00:17,000 --> 00:00:22,000
На початку розділу запитань говорите-

7
00:00:22,000 --> 00:00:26,000
мабуть я не зовсім unsick-це дуже просте питання

8
00:00:26,000 --> 00:00:28,000
всього того, що Valgrind?

9
00:00:28,000 --> 00:00:30,000
Що Valgrind робити?

10
00:00:30,000 --> 00:00:34,000
Будь хочу сказати, що Valgrind робить?

11
00:00:34,000 --> 00:00:36,000
[Студент] Перевірка витоків пам'яті.

12
00:00:36,000 --> 00:00:41,000
Так, Valgrind загальна перевірка пам'яті.

13
00:00:41,000 --> 00:00:44,000
Це, врешті-решт, говорить вам, якщо у вас є якісь витоку пам'яті,

14
00:00:44,000 --> 00:00:49,000
який в основному те, що ми використовуємо його для, тому що, якщо ви хочете

15
00:00:49,000 --> 00:00:54,000
досягти успіху в завданні набору або якщо ви хочете

16
00:00:54,000 --> 00:00:59,000
отримати на великій дошці, ви повинні мати витоків пам'яті взагалі,

17
00:00:59,000 --> 00:01:01,000
і в разі, якщо є витоку пам'яті, які ви не можете знайти,

18
00:01:01,000 --> 00:01:04,000
Також майте на увазі, що всякий раз, коли ви відкриваєте файл

19
00:01:04,000 --> 00:01:07,000
і якщо ви не закриєте його, що це витік пам'яті.

20
00:01:07,000 --> 00:01:10,000
>> Багато людей шукають для деяких вузлів, що вони не звільняючи

21
00:01:10,000 --> 00:01:15,000
коли насправді, вони не закрити словник в самий перший крок.

22
00:01:15,000 --> 00:01:19,000
Він також говорить вам, якщо у вас є якісь недійсним читає або пише,

23
00:01:19,000 --> 00:01:22,000
що означає, якщо ви намагаєтеся встановити значення

24
00:01:22,000 --> 00:01:26,000
що це за кінець купи і це не відбудеться в сегменті вина

25
00:01:26,000 --> 00:01:30,000
але Valgrind ловить його, як ви насправді не повинно бути письмово там,

26
00:01:30,000 --> 00:01:33,000
і таким чином, ви напевне не повинні мати будь-який з цих теж.

27
00:01:33,000 --> 00:01:38,000
Як ви використовуєте Valgrind?

28
00:01:38,000 --> 00:01:42,000
Як ви використовуєте Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Це загальне питання

30
00:01:45,000 --> 00:01:49,000
вид запустіть її і подивіться на виході.

31
00:01:49,000 --> 00:01:51,000
Вихід переважної багато разів.

32
00:01:51,000 --> 00:01:54,000
Там же, де весело помилки, якщо у вас є деякі дуже неправильні речі

33
00:01:54,000 --> 00:01:59,000
відбувається в циклі, то вона буде в кінцевому підсумку сказати: "Занадто багато помилок.

34
00:01:59,000 --> 00:02:03,000
Я збираюся припинити підрахунок зараз ".

35
00:02:03,000 --> 00:02:08,000
Це в основному текстовий вивід, що вам доведеться розібрати.

36
00:02:08,000 --> 00:02:13,000
Зрештою, він скаже вам будь витоку пам'яті, які у вас є,

37
00:02:13,000 --> 00:02:16,000
скільки блоків, які можуть бути корисні, тому що

38
00:02:16,000 --> 00:02:20,000
якщо це один блок unfreed, то вона, як правило, легше знайти

39
00:02:20,000 --> 00:02:23,000
ніж 1.000 блоків unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 блоків unfreed, ймовірно, означає, що ви не звільняючи

41
00:02:26,000 --> 00:02:30,000
ваша зв'язані списки належним чи щось.

42
00:02:30,000 --> 00:02:32,000
Це Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Тепер у нас є розділ питань,

44
00:02:35,000 --> 00:02:38,000
які вам не потрібні для завантаження.

45
00:02:38,000 --> 00:02:41,000
Ви можете натиснути на моє ім'я, і ​​потягнути їх в просторі.

46
00:02:41,000 --> 00:02:44,000
Тепер натисніть на мене.

47
00:02:44,000 --> 00:02:46,000
1-а редакція буде стек, який ми робимо в першу чергу.

48
00:02:46,000 --> 00:02:55,000
Перегляд 2 буде черги, і 3-я редакція буде односпрямованого списку.

49
00:02:55,000 --> 00:02:58,000
Почавши з нашим стеком.

50
00:02:58,000 --> 00:03:02,000
Як сказано тут, стек є одним із самих основних,

51
00:03:02,000 --> 00:03:07,000
фундаментальні структури даних, інформатики.

52
00:03:07,000 --> 00:03:11,000
Сам прототип прикладу

53
00:03:11,000 --> 00:03:13,000
стопку тарілок в їдальні.

54
00:03:13,000 --> 00:03:16,000
Це в основному, коли ви вводяться в стек,

55
00:03:16,000 --> 00:03:20,000
хтось скаже: "О, як стек лотків".

56
00:03:20,000 --> 00:03:22,000
Ви стек лотками.

57
00:03:22,000 --> 00:03:24,000
Потім, коли ви йдете витягнути лоток,

58
00:03:24,000 --> 00:03:31,000
перший лоток, який стає витягнув є останньою, яка була введена в стеці.

59
00:03:31,000 --> 00:03:34,000
Стек також, як він говорить тут-

60
00:03:34,000 --> 00:03:37,000
у нас є сегмент пам'яті, званої стеком.

61
00:03:37,000 --> 00:03:40,000
І чому це називається стеком?

62
00:03:40,000 --> 00:03:42,000
>> Тому що, як структури даних стека,

63
00:03:42,000 --> 00:03:46,000
він штовхає і з'являється кадри стека в стек,

64
00:03:46,000 --> 00:03:53,000
де кадри стека схожі на конкретний виклик функції.

65
00:03:53,000 --> 00:03:57,000
І, як стек, ви завжди будете мати, щоб повернутися

66
00:03:57,000 --> 00:04:03,000
від виклику функції, перш ніж спускатися в нижні кадри стека знову.

67
00:04:03,000 --> 00:04:08,000
Ви не можете мати головний виклик Foo Bar виклику і бар повернення до основного напряму.

68
00:04:08,000 --> 00:04:14,000
Він завжди повинні слідувати правильним стек натискання і з'являються.

69
00:04:14,000 --> 00:04:18,000
Дві операції, як я вже сказав, поштовх і поп-музики.

70
00:04:18,000 --> 00:04:20,000
Це універсальні терміни.

71
00:04:20,000 --> 00:04:26,000
Ви повинні знати, поштовх і поп-музики з точки зору стеки ні на що.

72
00:04:26,000 --> 00:04:28,000
Ми побачимо черзі вид інший.

73
00:04:28,000 --> 00:04:32,000
Це дійсно не має універсального терміна, але поштовх і поп є універсальними для стеків.

74
00:04:32,000 --> 00:04:34,000
Поштовх просто покласти на стек.

75
00:04:34,000 --> 00:04:37,000
Поп-це взяти з стека.

76
00:04:37,000 --> 00:04:43,000
І ми бачимо, тут у нас є ЬурейеЕ стек структури,

77
00:04:43,000 --> 00:04:46,000
тому ми повинні символів рядка **.

78
00:04:46,000 --> 00:04:51,000
Не лякайтеся будь **.

79
00:04:51,000 --> 00:04:54,000
Це буде в кінцевому підсумку масив рядків

80
00:04:54,000 --> 00:04:58,000
або масив покажчиків на символи, де

81
00:04:58,000 --> 00:05:00,000
покажчиків на символи, як правило, рядки.

82
00:05:00,000 --> 00:05:05,000
Це не повинні бути рядками, але тут вони збираються бути рядками.

83
00:05:05,000 --> 00:05:08,000
>> У нас є масив рядків.

84
00:05:08,000 --> 00:05:14,000
У нас є розмір, який представляє, скільки елементів у даний час в стеку,

85
00:05:14,000 --> 00:05:19,000
і у нас є потенціал, який, як багато елементів можуть бути в стеці.

86
00:05:19,000 --> 00:05:22,000
Ємність повинна початися як щось більше, ніж 1,

87
00:05:22,000 --> 00:05:27,000
але розмір буде починатися як 0.

88
00:05:27,000 --> 00:05:36,000
Зараз, в основному існують три різні способи ви можете думати про стек.

89
00:05:36,000 --> 00:05:39,000
Ну, є, ймовірно, більше, але два основних шляхи

90
00:05:39,000 --> 00:05:43,000
Ви можете здійснити це за допомогою масиву, або ви можете реалізувати його за допомогою пов'язаного списку.

91
00:05:43,000 --> 00:05:48,000
Пов'язані списки є свого роду тривіальна, щоб стік с.

92
00:05:48,000 --> 00:05:51,000
Це дуже легко зробити стек за допомогою пов'язаних списків,

93
00:05:51,000 --> 00:05:55,000
так от, ми збираємося зробити стек за допомогою масиву,

94
00:05:55,000 --> 00:05:59,000
а потім за допомогою масивів, є також два шляхи ви можете думати про це.

95
00:05:59,000 --> 00:06:01,000
Раніше, коли я сказав, у нас є потенціал для стека,

96
00:06:01,000 --> 00:06:04,000
так що ми можемо відповідати елементу в стеці.

97
00:06:04,000 --> 00:06:09,000
>> Одного боку, це могло статися, як тільки ви натиснете 10 елементів, то ви зробили.

98
00:06:09,000 --> 00:06:13,000
Можливо, ви знаєте, що є верхня межа з 10 речей в світі

99
00:06:13,000 --> 00:06:16,000
що ви ніколи не будете мати більше, ніж 10 речей, на ваш стек,

100
00:06:16,000 --> 00:06:20,000
У цьому випадку ви можете мати верхню межу розміру вашого стека.

101
00:06:20,000 --> 00:06:23,000
Або ви могли б ваш стек бути необмеженим,

102
00:06:23,000 --> 00:06:27,000
Але якщо ви робите масив, це означає, що кожного разу, коли ви потрапили 10 елементів,

103
00:06:27,000 --> 00:06:29,000
тоді ви будете мати, щоб вирости до 20 елементів, і коли ви потрапили 20 елементів,

104
00:06:29,000 --> 00:06:33,000
Вам доведеться вирощувати масиву до 30 елементів і 40 елементів.

105
00:06:33,000 --> 00:06:37,000
Ви будете потребувати, щоб збільшити пропускну здатність, яка є те, що ми збираємося зробити тут.

106
00:06:37,000 --> 00:06:40,000
Кожен раз, коли ми досягаємо максимального розміру нашого стека,

107
00:06:40,000 --> 00:06:46,000
коли ми натискаємо на щось інше, ми будемо потребувати, щоб збільшити пропускну здатність.

108
00:06:46,000 --> 00:06:50,000
Тут ми поштовх оголошені як BOOL поштовх (символ * вул).

109
00:06:50,000 --> 00:06:54,000
Char * вул являє собою рядок, ми добиваємося в стек,

110
00:06:54,000 --> 00:06:58,000
і BOOL просто говорить чи ми успіху або невдачі.

111
00:06:58,000 --> 00:07:00,000
>> Як ми можемо зазнати невдачі?

112
00:07:00,000 --> 00:07:04,000
Що є єдиною обставиною, що ви можете думати про

113
00:07:04,000 --> 00:07:07,000
де ми повинні були б повернутися помилковим?

114
00:07:07,000 --> 00:07:09,000
Так.

115
00:07:09,000 --> 00:07:12,000
[Студент] Якщо це повна і ми використовуємо обмежену реалізацію.

116
00:07:12,000 --> 00:07:17,000
Так, оскільки ми визначаємо, він відповів

117
00:07:17,000 --> 00:07:23,000
якщо це повна і ми використовуємо обмеженою реалізації.

118
00:07:23,000 --> 00:07:26,000
Тоді ми безумовно повернемося помилковим.

119
00:07:26,000 --> 00:07:31,000
Як тільки ми потрапили 10 речей, які в масиві, ми не може поміститися 11, так що ми повертаємося помилковим.

120
00:07:31,000 --> 00:07:32,000
Що, якщо вона не обмежена? Так.

121
00:07:32,000 --> 00:07:38,000
Якщо ви не можете розширити масив з деяких причин.

122
00:07:38,000 --> 00:07:43,000
Так, так що пам'ять є обмеженим ресурсом,

123
00:07:43,000 --> 00:07:51,000
і врешті-решт, якщо ми продовжуватимемо наполягати речі в стек знову і знову,

124
00:07:51,000 --> 00:07:54,000
Ми збираємося спробувати і виділити більший масив, щоб відповідати

125
00:07:54,000 --> 00:07:59,000
велику ємність, і Танос або будь-який інший ми використовуємо збирається повернутися помилковим.

126
00:07:59,000 --> 00:08:02,000
Ну, Танос поверне NULL.

127
00:08:02,000 --> 00:08:05,000
>> Пам'ятайте, що кожен раз, коли ви дзвоните Танос, ви повинні перевіряти, щоб побачити, якщо вона

128
00:08:05,000 --> 00:08:12,000
повертає нульовий або ще що правильність виведення.

129
00:08:12,000 --> 00:08:17,000
Так як ми хочемо мати необмежений стека,

130
00:08:17,000 --> 00:08:21,000
Єдиний випадок, ми збираємося повертатися хибним, якщо ми спробуємо

131
00:08:21,000 --> 00:08:26,000
збільшити потужність і Танос або що повертає брехня.

132
00:08:26,000 --> 00:08:30,000
Тоді піп не приймає аргументів,

133
00:08:30,000 --> 00:08:37,000
і вона повертає рядок, яка знаходиться на вершині стека.

134
00:08:37,000 --> 00:08:41,000
Яким би не був нещодавно в стек є те, що поп повертається,

135
00:08:41,000 --> 00:08:44,000
і він також видаляється з стека.

136
00:08:44,000 --> 00:08:50,000
І зауважив, що він повертає нульове значення, якщо немає нічого в стек.

137
00:08:50,000 --> 00:08:53,000
Це завжди можливо, що стек порожній.

138
00:08:53,000 --> 00:08:55,000
У Java, якщо ви звикли до цього, або інших мов,

139
00:08:55,000 --> 00:09:01,000
намагаються поп з пустого стека може викликати виключення або щось.

140
00:09:01,000 --> 00:09:09,000
>> Але в C, нульові це свого роду багато випадків, як ми справляємося з цими проблемами.

141
00:09:09,000 --> 00:09:13,000
Повертаючись нульовою, як ми збираємося, щоб показати, що стек був порожній.

142
00:09:13,000 --> 00:09:16,000
Ми надали код, який буде перевіряти функціональність вашого стека,

143
00:09:16,000 --> 00:09:19,000
здійснення штовхати і поп-музики.

144
00:09:19,000 --> 00:09:23,000
Це не буде багато коду.

145
00:09:23,000 --> 00:09:40,000
Я волі насправді, перш ніж ми це зробимо, натяк, підказка-

146
00:09:40,000 --> 00:09:44,000
Якщо ви ще не бачили його, Танос це не єдина функція

147
00:09:44,000 --> 00:09:47,000
, Яка виділяє пам'ять в купі для вас.

148
00:09:47,000 --> 00:09:51,000
Є сім'ї ідентифікатор функції.

149
00:09:51,000 --> 00:09:53,000
Перший Танос, які ви звикли.

150
00:09:53,000 --> 00:09:56,000
Тоді є calloc, яка робить те ж саме, що і Танос,

151
00:09:56,000 --> 00:09:59,000
але це буде нулю все для вас.

152
00:09:59,000 --> 00:10:04,000
Якщо ви коли-небудь хотіли, щоб встановити все до нуля після mallocing щось

153
00:10:04,000 --> 00:10:06,000
Ви повинні просто використовувати calloc, в першу чергу, а не писати

154
00:10:06,000 --> 00:10:09,000
цикл обнулити весь блок пам'яті.

155
00:10:09,000 --> 00:10:15,000
>> Realloc, як Танос і має багато особливих випадків,

156
00:10:15,000 --> 00:10:19,000
але в основному те, що робить перерозподілити

157
00:10:19,000 --> 00:10:24,000
вона приймає покажчик, які вже були виділені.

158
00:10:24,000 --> 00:10:27,000
Realloc є функцією, яку необхідно звертати увагу на тут.

159
00:10:27,000 --> 00:10:31,000
Він приймає покажчик, який вже повернувся з Танос.

160
00:10:31,000 --> 00:10:35,000
Припустимо, ви вимагати від Танос покажчик з 10 байт.

161
00:10:35,000 --> 00:10:38,000
Пізніше ви усвідомлюєте, що ви хотіли 20 байт,

162
00:10:38,000 --> 00:10:42,000
так ви дзвоните перерозподілити на цьому покажчик з 20 байт,

163
00:10:42,000 --> 00:10:47,000
і перерозподілити автоматично скопіювати всі за вас.

164
00:10:47,000 --> 00:10:51,000
Якщо ви тільки що подзвонив Танос знову, як і в мене є блок з 10 байт.

165
00:10:51,000 --> 00:10:53,000
Тепер мені потрібно блок з 20 байт,

166
00:10:53,000 --> 00:10:58,000
так що якщо я Танос 20 байт, то мені доведеться вручну скопіювати 10 байт з першою річчю

167
00:10:58,000 --> 00:11:01,000
у другу річ, а потім звільнити перше.

168
00:11:01,000 --> 00:11:04,000
Realloc буде обробляти це для вас.

169
00:11:04,000 --> 00:11:11,000
>> Зверніть увагу, що підпис буде недійсною *,

170
00:11:11,000 --> 00:11:15,000
який просто повертає покажчик на блок пам'яті,

171
00:11:15,000 --> 00:11:17,000
Потім порожнечі * покажчик.

172
00:11:17,000 --> 00:11:22,000
Ви можете думати про порожнечі * як загальний покажчик.

173
00:11:22,000 --> 00:11:27,000
Взагалі, ви ніколи не мати справу з недійсними *,

174
00:11:27,000 --> 00:11:30,000
але Танос повертається порожнеча *, а потім просто використовувати як

175
00:11:30,000 --> 00:11:34,000
це насправді буде символ *.

176
00:11:34,000 --> 00:11:37,000
* Попередні порожнечу, яка була повернута на Танос

177
00:11:37,000 --> 00:11:41,000
Тепер буде переданий перерозподілити, а потім розмір

178
00:11:41,000 --> 00:11:49,000
це нове число байт ви хочете виділити, так що ваші нові потужності.

179
00:11:49,000 --> 00:11:57,000
Я дам вам кілька хвилин, і зробити це в нашому просторі.

180
00:11:57,000 --> 00:12:02,000
Почніть з перегляду 1.

181
00:12:16,000 --> 00:12:21,000
Я зупиню тебе після сподіваюся, про достатньо часу для здійснення поштовх,

182
00:12:21,000 --> 00:12:24,000
і тоді я дам тобі ще одну перерву, щоб зробити поп-музики.

183
00:12:24,000 --> 00:12:27,000
Але насправді це не так вже багато коду.

184
00:12:27,000 --> 00:12:35,000
Найбільш коду, ймовірно, розширює матеріал, розширення потужностей.

185
00:12:35,000 --> 00:12:39,000
Добре, ніякого тиску, щоб бути повністю зроблено,

186
00:12:39,000 --> 00:12:47,000
але поки ви відчуваєте, що перебуваєте на правильному шляху, це добре.

187
00:12:47,000 --> 00:12:53,000
>> Хто-небудь є код, який вони відчувають себе комфортно зі мною, потягнувши вгору?

188
00:12:53,000 --> 00:12:59,000
Так, я хочу, а не кого-небудь є код я можу потягнути?

189
00:12:59,000 --> 00:13:05,000
Добре, ви можете почати, збережіть його, що це таке?

190
00:13:05,000 --> 00:13:09,000
Я завжди забуваю, що крок.

191
00:13:09,000 --> 00:13:15,000
Гаразд, дивлячись на поштовх,

192
00:13:15,000 --> 00:13:18,000
Ви хочете, щоб пояснити свій код?

193
00:13:18,000 --> 00:13:24,000
[Студент] По-перше, я збільшив розмір.

194
00:13:24,000 --> 00:13:28,000
Я думаю, може бути, я повинен мати що-все одно, я збільшив розмір,

195
00:13:28,000 --> 00:13:31,000
і я не бачу, якщо він менше, ніж ємність.

196
00:13:31,000 --> 00:13:36,000
І якщо це менше, ніж ємність, додати в масив, що ми вже маємо.

197
00:13:36,000 --> 00:13:42,000
А якщо це не так, я помножити потужність на 2,

198
00:13:42,000 --> 00:13:50,000
і я перерозподілити рядків масиву щось з більшою потужністю розмір зараз.

199
00:13:50,000 --> 00:13:55,000
І потім, якщо це не вдається, я кажу користувача і повернутися помилковим,

200
00:13:55,000 --> 00:14:04,000
і якщо все нормально, то я ставлю рядок у новому місці.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Також зверніть увагу, що ми використовували хороший оператор побітового тут

202
00:14:07,000 --> 00:14:09,000
помножити на 2.

203
00:14:09,000 --> 00:14:11,000
Пам'ятайте, що зрушення вліво завжди буде помножити на 2.

204
00:14:11,000 --> 00:14:15,000
Зсув вправо ділиться на 2, поки ви пам'ятаєте, що це означає

205
00:14:15,000 --> 00:14:18,000
ділимо на 2, як в ціле число ділиться на 2.

206
00:14:18,000 --> 00:14:20,000
Це може обрізати на 1 тут або там.

207
00:14:20,000 --> 00:14:26,000
Але зрушення вліво на 1 завжди буде необхідно помножити на 2,

208
00:14:26,000 --> 00:14:32,000
якщо ви переповнення межі цілого, і тоді вона не буде.

209
00:14:32,000 --> 00:14:34,000
Сторони коментаря.

210
00:14:34,000 --> 00:14:39,000
Мені подобається робити-це не збирається змінювати кодування будь-якій формі,

211
00:14:39,000 --> 00:14:48,000
Але я хотів би зробити щось на зразок цього.

212
00:14:48,000 --> 00:14:51,000
Це насправді відбувається, щоб зробити його трохи довше.

213
00:15:04,000 --> 00:15:08,000
Може бути, це не ідеальний випадок, щоб показати це,

214
00:15:08,000 --> 00:15:14,000
але мені подобається сегменті його в ці блоки-

215
00:15:14,000 --> 00:15:17,000
Добре, якщо це, якщо станеться, то я буду щось робити,

216
00:15:17,000 --> 00:15:19,000
, А потім функція виконується.

217
00:15:19,000 --> 00:15:22,000
Мені не потрібно, щоб потім прокрутити мої очі все, аж функції

218
00:15:22,000 --> 00:15:25,000
, Щоб побачити, що відбувається після іншого.

219
00:15:25,000 --> 00:15:27,000
Це, якщо це, якщо станеться, то я просто повернутися.

220
00:15:27,000 --> 00:15:30,000
Вона також має гарне додаткова перевага все, що за цим

221
00:15:30,000 --> 00:15:33,000
В даний час зсувається вліво один раз.

222
00:15:33,000 --> 00:15:40,000
Я більше не потрібно, якщо ви завжди поруч смішного довгі черги,

223
00:15:40,000 --> 00:15:45,000
Потім ці 4 байти може допомогти, а також лівіше щось є,

224
00:15:45,000 --> 00:15:48,000
менше перевантажені ви себе почували, якщо хочете, добре, я повинен пам'ятати,

225
00:15:48,000 --> 00:15:53,000
Я в даний час перебуваю в той час як цикл всередині іншого всередині циклу.

226
00:15:53,000 --> 00:15:58,000
Скрізь ви можете зробити це повернення негайно, я ніби як.

227
00:15:58,000 --> 00:16:05,000
Це зовсім необов'язковим і не очікував ніяк.

228
00:16:05,000 --> 00:16:12,000
>> [Студент] Чи повинні бути розміром - в обов'язковому порядку умови?

229
00:16:12,000 --> 00:16:19,000
Неодмінно умова тут ми не змогли перерозподілити, так що так.

230
00:16:19,000 --> 00:16:22,000
Зверніть увагу, що в обов'язковому порядку умова, мабуть,

231
00:16:22,000 --> 00:16:26,000
якщо ми безкоштовно речі пізніше, ми завжди будемо на провал

232
00:16:26,000 --> 00:16:29,000
незалежно від того, скільки разів ми намагаємося підштовхнути щось.

233
00:16:29,000 --> 00:16:32,000
Якщо ми будемо продовжувати наполягати, ми продовжуємо збільшуючи розмір,

234
00:16:32,000 --> 00:16:36,000
навіть якщо ми не ставить нічого в стек.

235
00:16:36,000 --> 00:16:39,000
Зазвичай ми не збільшуємо розмір до

236
00:16:39,000 --> 00:16:43,000
після того, як ми успішно покласти його в стек.

237
00:16:43,000 --> 00:16:50,000
Ми хотіли б це зробити, скажімо, або тут і тут.

238
00:16:50,000 --> 00:16:56,000
І тоді замість того щоб сказати s.size ≤ потенціал, це менше, ніж потужність,

239
00:16:56,000 --> 00:17:01,000
тільки тому, що ми переїхали, де все було.

240
00:17:01,000 --> 00:17:07,000
>> І пам'ятайте, що єдине місце, де ми могли б повернутися помилковим

241
00:17:07,000 --> 00:17:14,000
Тут, де перерозподілити повертається нуль,

242
00:17:14,000 --> 00:17:19,000
і якщо Ви випадково не пам'ятаєте стандартна помилка,

243
00:17:19,000 --> 00:17:22,000
Може бути, ви могли б розглянути цей випадок, коли ви хочете друкувати стандартні помилки,

244
00:17:22,000 --> 00:17:26,000
так Fprintf STDERR, а не просто друк безпосередньо на стандартний вивід.

245
00:17:26,000 --> 00:17:31,000
Знову ж таки, це не очікування, але якщо це помилка,

246
00:17:31,000 --> 00:17:41,000
Введіть Printf, то ви можете зробити це друк на стандартної помилки, а не стандартний вивід.

247
00:17:41,000 --> 00:17:44,000
>> Будь-який, є що-небудь ще відзначити? Так.

248
00:17:44,000 --> 00:17:47,000
[Студент] Чи можете ви перейти на [нерозбірливо]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Так, фактично binariness це або просто, що це таке?

250
00:17:55,000 --> 00:17:57,000
[Студент] Таким чином, ви помножити на 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Так, в основному.

252
00:17:59,000 --> 00:18:11,000
У двійковій землі, у нас завжди є наш набір цифр.

253
00:18:11,000 --> 00:18:22,000
Перехід цьому ліва на 1 основному вставляє його тут, на правій стороні.

254
00:18:22,000 --> 00:18:25,000
Повернутися до цього, просто пам'ятайте, що все в двійковому

255
00:18:25,000 --> 00:18:28,000
є ступенем 2, так що це являє 2 до 0,

256
00:18:28,000 --> 00:18:30,000
це 2 до 1, це 2 до 2.

257
00:18:30,000 --> 00:18:33,000
Додаючи 0 до правої сторони зараз, ми просто перекласти все скінчено.

258
00:18:33,000 --> 00:18:38,000
Те, що було 2 до 0, в даний час 2 до 1, 2 до 2.

259
00:18:38,000 --> 00:18:41,000
На правій стороні, що ми вставили

260
00:18:41,000 --> 00:18:44,000
обов'язково буде 0,

261
00:18:44,000 --> 00:18:46,000
який має сенс.

262
00:18:46,000 --> 00:18:49,000
Якщо ви коли-небудь помножити число на 2, це не буде в кінцевому підсумку непарних,

263
00:18:49,000 --> 00:18:54,000
так що 2 до 0 місце повинне бути 0,

264
00:18:54,000 --> 00:18:59,000
і це те, що перше півріччя попередив, перш ніж є, якщо ви все-таки перейти

265
00:18:59,000 --> 00:19:01,000
за кількість біт в ціле,

266
00:19:01,000 --> 00:19:04,000
то це 1, буде в кінцевому підсумку йти.

267
00:19:04,000 --> 00:19:10,000
Це єдине занепокоєння, якщо вам трапиться мати справу з дійсно великими можливостями.

268
00:19:10,000 --> 00:19:15,000
Але в цей момент, то ви маєте справу з масивом мільярди речей,

269
00:19:15,000 --> 00:19:25,000
яка може не поміститися у пам'яті в будь-якому випадку.

270
00:19:25,000 --> 00:19:31,000
>> Тепер ми можемо дістатися до поп-музики, яка ще простіше.

271
00:19:31,000 --> 00:19:36,000
Ви можете зробити це подобається, якщо вам трапиться поп ціла купа,

272
00:19:36,000 --> 00:19:38,000
і тепер ви в половину потужності знову.

273
00:19:38,000 --> 00:19:42,000
Ви могли б перерозподілити, щоб зменшити обсяг пам'яті у вас є,

274
00:19:42,000 --> 00:19:47,000
але ви не повинні турбуватися про те, що, таким чином, єдиний випадок, перерозподілити буде

275
00:19:47,000 --> 00:19:50,000
зростаюча пам'яті, ніколи не скорочення пам'яті,

276
00:19:50,000 --> 00:19:59,000
який збирається зробити поп-супер просто.

277
00:19:59,000 --> 00:20:02,000
Зараз в черзі, який буде, як стеки,

278
00:20:02,000 --> 00:20:06,000
але для того, щоб взяти речі на протилежне.

279
00:20:06,000 --> 00:20:10,000
Найпростіший приклад з черги лінії,

280
00:20:10,000 --> 00:20:12,000
тому я думаю, якщо б ви були на англійській, я б сказав,

281
00:20:12,000 --> 00:20:17,000
Найпростіший приклад з черги в чергу.

282
00:20:17,000 --> 00:20:22,000
Так як лінія, якщо ви перша людина в лінії,

283
00:20:22,000 --> 00:20:24,000
Ви очікуєте, щоб бути першою людиною з черги.

284
00:20:24,000 --> 00:20:31,000
Якщо ви останній чоловік у лінії, ви збираєтеся бути останньою людиною в ремонт.

285
00:20:31,000 --> 00:20:35,000
Ми називаємо це FIFO моделі, в той час як стек LIFO шаблоном.

286
00:20:35,000 --> 00:20:40,000
Ці слова є досить універсальними.

287
00:20:40,000 --> 00:20:46,000
>> Як стеки і на відміну від масивів, черг зазвичай не допускають доступ до елементів в середині.

288
00:20:46,000 --> 00:20:50,000
Тут, стек, ми повинні штовхати і поп-музики.

289
00:20:50,000 --> 00:20:54,000
Тут ми, трапляється, називають їх постановки в чергу і видалення з черги.

290
00:20:54,000 --> 00:20:58,000
Крім того, я чув, як вони називають зрушенням і Скасувати заміну.

291
00:20:58,000 --> 00:21:02,000
Я чув, люди говорять, поштовх і поп застосовуються також до черг.

292
00:21:02,000 --> 00:21:05,000
Я чув, вставки, видалення,

293
00:21:05,000 --> 00:21:11,000
так штовхати і поп, якщо ви говорите про стеки, ви штовхаєте і плескати.

294
00:21:11,000 --> 00:21:16,000
Якщо ви говорите про черги, ви могли б вибрати слова, які ви хочете використовувати

295
00:21:16,000 --> 00:21:23,000
для вставки і видалення, і немає єдиної думки про те, що вони повинні бути названі.

296
00:21:23,000 --> 00:21:27,000
Але тут, у нас є поставити в чергу і видалення з черги.

297
00:21:27,000 --> 00:21:37,000
Тепер, структура виглядає майже ідентично стек структури.

298
00:21:37,000 --> 00:21:40,000
Але ми повинні стежити за голову.

299
00:21:40,000 --> 00:21:44,000
Я думаю, це говорить тут, але чому ми потребуємо голову?

300
00:21:53,000 --> 00:21:57,000
Прототипи в основному ідентичні штовхати і поп-музики.

301
00:21:57,000 --> 00:21:59,000
Ви можете думати про це як поштовх і поп-музики.

302
00:21:59,000 --> 00:22:08,000
Різниця лише в тому поп повертається, замість останнього, він повертає перший.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, або щось ще.

304
00:22:12,000 --> 00:22:14,000
І ось старт.

305
00:22:14,000 --> 00:22:17,000
Наша черга повністю заповнена, так що чотири елементи в ньому.

306
00:22:17,000 --> 00:22:21,000
В кінці нашої черги в даний час 2,

307
00:22:21,000 --> 00:22:24,000
і тепер ми йдемо, щоб вставити щось інше.

308
00:22:24,000 --> 00:22:29,000
>> Коли ми хочемо, щоб вставити щось інше, що ми зробили для стека версія

309
00:22:29,000 --> 00:22:36,000
це ми розширили наш блок пам'яті.

310
00:22:36,000 --> 00:22:40,000
У чому проблема з цим?

311
00:22:40,000 --> 00:22:45,000
[Студент] Ви рухаєтеся 2.

312
00:22:45,000 --> 00:22:51,000
Як я вже говорив про кінець черги,

313
00:22:51,000 --> 00:22:57,000
це не має сенсу, що ми починаємо з 1,

314
00:22:57,000 --> 00:23:01,000
Потім ми хочемо, щоб з черги 1, то з черги 3, то з черги 4,

315
00:23:01,000 --> 00:23:05,000
то з черги 2, то з черги цього.

316
00:23:05,000 --> 00:23:08,000
Ми не можемо використовувати перерозподілити зараз,

317
00:23:08,000 --> 00:23:11,000
або, принаймні, ви повинні використовувати перерозподілити по-іншому.

318
00:23:11,000 --> 00:23:15,000
Але ви, мабуть, не слід використовувати тільки перерозподілити.

319
00:23:15,000 --> 00:23:18,000
Ви будете повинні вручну скопіювати пам'яті.

320
00:23:18,000 --> 00:23:21,000
>> Є дві функції для копіювання пам'яті.

321
00:23:21,000 --> 00:23:25,000
Там в memcopy і memmove.

322
00:23:25,000 --> 00:23:29,000
Я зараз читаю людина сторінок, щоб побачити, який ви збираєтеся хочете використовувати.

323
00:23:29,000 --> 00:23:35,000
Добре, memcopy, різниця

324
00:23:35,000 --> 00:23:38,000
що memcopy і memmove, один обробляє випадку правильно

325
00:23:38,000 --> 00:23:41,000
де ви копіюєте в регіоні, що відбувається перекриття регіоні

326
00:23:41,000 --> 00:23:46,000
Ви копіюванні.

327
00:23:46,000 --> 00:23:50,000
Memcopy не впоратися. Memmove робить.

328
00:23:50,000 --> 00:23:59,000
Ви можете думати про проблему, як-

329
00:23:59,000 --> 00:24:09,000
скажімо, я хочу, щоб скопіювати цей хлопець,

330
00:24:09,000 --> 00:24:13,000
ці чотири з цим хлопцем старше.

331
00:24:13,000 --> 00:24:16,000
Зрештою, те, що масив повинен виглядати

332
00:24:16,000 --> 00:24:26,000
після того, як копія 2, 1, 2, 1, 3, 4, а потім деякі речі в кінці.

333
00:24:26,000 --> 00:24:29,000
Але це залежить від порядку, в якому ми насправді копіювати,

334
00:24:29,000 --> 00:24:32,000
оскільки якщо ми не вважаємо той факт, що регіон ми копіювання в

335
00:24:32,000 --> 00:24:35,000
перекривається один ми копіюванні,

336
00:24:35,000 --> 00:24:46,000
Потім ми могли б зробити, як почати тут, копіювання 2 в місце, де ми хочемо піти,

337
00:24:46,000 --> 00:24:52,000
потім перемістити наші покажчики вперед.

338
00:24:52,000 --> 00:24:56,000
>> Тепер ми збираємося бути тут і тут, і тепер ми хочемо, щоб скопіювати

339
00:24:56,000 --> 00:25:04,000
цей хлопець за цим хлопцем, і перемістити наші покажчики вперед.

340
00:25:04,000 --> 00:25:07,000
Те, що ми збираємося в кінцевому підсумку отримати в 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
замість того, щоб відповідні 2, 1, 2, 1, 3, 4, тому що

342
00:25:10,000 --> 00:25:15,000
2, 1 подолав оригінальний 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove обробляє це правильно.

344
00:25:19,000 --> 00:25:23,000
У цьому випадку, в основному завжди використовувати memmove

345
00:25:23,000 --> 00:25:26,000
тому що він працює правильно.

346
00:25:26,000 --> 00:25:29,000
Як правило, він не виконує гірше.

347
00:25:29,000 --> 00:25:32,000
Ідея полягає в тому, а не з початку і копіювання таким чином,

348
00:25:32,000 --> 00:25:35,000
як ми тільки що зробили тут, вона починається з кінця і копіює в,

349
00:25:35,000 --> 00:25:38,000
і в цьому випадку, ви не можете мати проблеми.

350
00:25:38,000 --> 00:25:40,000
Там продуктивність не втратив.

351
00:25:40,000 --> 00:25:47,000
Завжди використовуйте memmove. Ніколи не турбуйтеся про memcopy.

352
00:25:47,000 --> 00:25:51,000
І ось, коли ви будете мати, щоб окремо memmove

353
00:25:51,000 --> 00:26:01,000
обгорнутий навколо частини вашої черги.

354
00:26:01,000 --> 00:26:04,000
Не турбуйтеся, якщо не повністю зроблено.

355
00:26:04,000 --> 00:26:10,000
Це важче, ніж стік, поштовх, і поп-музики.

356
00:26:10,000 --> 00:26:15,000
>> Будь-який, є які-небудь коду ми могли б працювати?

357
00:26:15,000 --> 00:26:21,000
Навіть якщо повністю неповним?

358
00:26:21,000 --> 00:26:23,000
[Студент] Так, це абсолютно неповним, проте.

359
00:26:23,000 --> 00:26:27,000
Повністю неповної чудово до тих пір, як ми, ви можете заощадити перегляду?

360
00:26:27,000 --> 00:26:32,000
Я забуваю, що кожен раз.

361
00:26:32,000 --> 00:26:39,000
Добре, ігноруючи те, що відбувається, коли ми повинні змінити розмір речі.

362
00:26:39,000 --> 00:26:42,000
Повністю ігнорувати зміни розміру.

363
00:26:42,000 --> 00:26:49,000
Пояснити цей код.

364
00:26:49,000 --> 00:26:54,000
Я перевіряю, перш за все, якщо розмір менше, ніж копія, перш за все,

365
00:26:54,000 --> 00:27:01,000
і після цього, я вставляю-я беру голову + розмір,

366
00:27:01,000 --> 00:27:05,000
і я переконатися, що вона оточує ємність масиву,

367
00:27:05,000 --> 00:27:08,000
і я вставити новий рядок в цьому положенні.

368
00:27:08,000 --> 00:27:12,000
Тоді я збільшити розмір і повернути істинний.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Це, безумовно, один з тих випадків, коли ви захочете використовувати мод.

370
00:27:22,000 --> 00:27:25,000
Будь-який випадок, коли ви обтікання, якщо ви думаєте обтікання,

371
00:27:25,000 --> 00:27:29,000
безпосередній думка повинна бути мода.

372
00:27:29,000 --> 00:27:36,000
Як швидко оптимізації / зробити ваш код один рядок коротший,

373
00:27:36,000 --> 00:27:42,000
Ви помітили, що рядки відразу після цього

374
00:27:42,000 --> 00:27:53,000
тільки розмір + +, так що ви поєднуєте, що в цю лінію, розмір + +.

375
00:27:53,000 --> 00:27:58,000
Тепер тут ми маємо випадок

376
00:27:58,000 --> 00:28:01,000
, Де у нас не вистачає пам'яті,

377
00:28:01,000 --> 00:28:05,000
так ми збільшуємо нашу здатність на 2.

378
00:28:05,000 --> 00:28:09,000
Я думаю, ви могли б мати ті ж проблеми, але ми можемо ігнорувати це зараз,

379
00:28:09,000 --> 00:28:13,000
, Де, якщо ви не змогли збільшити потужність,

380
00:28:13,000 --> 00:28:18,000
то ви будете хотіти, щоб зменшити ємність на 2 знову.

381
00:28:18,000 --> 00:28:24,000
Інший коротку записку так само, як ви можете зробити, + =,

382
00:28:24,000 --> 00:28:30,000
Ви також можете зробити << =.

383
00:28:30,000 --> 00:28:43,000
Майже все, що може піти до рівних, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * новий наш новий блок пам'яті.

385
00:28:52,000 --> 00:28:55,000
О, тут.

386
00:28:55,000 --> 00:29:02,000
>> Що люди думають про тип наш новий блок пам'яті?

387
00:29:02,000 --> 00:29:06,000
[Студент] Він повинен бути символ **.

388
00:29:06,000 --> 00:29:12,000
Згадуючи нашу структуру тут,

389
00:29:12,000 --> 00:29:14,000
рядків те, що ми перерозподілу.

390
00:29:14,000 --> 00:29:21,000
Ми робимо абсолютно новий динамічної пам'яті для елементів в черзі.

391
00:29:21,000 --> 00:29:25,000
Те, що ми збираємося призначенні на ваші рядки є те, що ми mallocing прямо зараз,

392
00:29:25,000 --> 00:29:30,000
і так нова буде символ **.

393
00:29:30,000 --> 00:29:34,000
Це буде масив рядків.

394
00:29:34,000 --> 00:29:38,000
Тоді в чому ж справа, по якій ми збираємося повернутися помилковим?

395
00:29:38,000 --> 00:29:41,000
[Студент] ми повинні робити символів *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Так, хороший виклик.

397
00:29:44,000 --> 00:29:46,000
[Студент] Що це було?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Ми хотіли зробити розмір символів *, тому що ми вже не-

399
00:29:49,000 --> 00:29:53,000
це фактично буде дуже велика проблема, тому що SizeOf (Char) буде 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof символ * буде 4,

401
00:29:55,000 --> 00:29:58,000
так багато разів, коли ви маєте справу з цілими,

402
00:29:58,000 --> 00:30:01,000
Ви, як правило, все зійде з рук, тому що розмір Int і розмір Int *

403
00:30:01,000 --> 00:30:04,000
на 32-розрядні системи буде те ж саме.

404
00:30:04,000 --> 00:30:09,000
Але тут, SizeOf (Char) і SizeOf (Char *) тепер буде те ж саме.

405
00:30:09,000 --> 00:30:15,000
>> Що таке обставина, де ми повернутися помилковим?

406
00:30:15,000 --> 00:30:17,000
[Студент] Новий дорівнює нулю.

407
00:30:17,000 --> 00:30:23,000
Так, якщо новий порожній, ми повертаємося помилковими,

408
00:30:23,000 --> 00:30:34,000
і я збираюся кинути тут-

409
00:30:34,000 --> 00:30:37,000
[Студент] [нерозбірливо]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Так, це прекрасно.

411
00:30:39,000 --> 00:30:46,000
Ви можете або робити 2 рази потужність або ємність зсув 1, а потім тільки встановити його тут або будь-який інший.

412
00:30:46,000 --> 00:30:52,000
Ми зробимо це, як у нас було.

413
00:30:52,000 --> 00:30:56,000
Ємність >> = 1.

414
00:30:56,000 --> 00:31:08,000
І ви ніколи не доведеться турбуватися про втрату 1-Місце

415
00:31:08,000 --> 00:31:12,000
тому що ви залишили зрушать на 1, тому 1-Місце обов'язково 0,

416
00:31:12,000 --> 00:31:16,000
так прямо зрушення на 1, ви все ще буде добре.

417
00:31:16,000 --> 00:31:19,000
[Студент] Вам необхідно зробити це до повернення?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Так, це не має абсолютно ніякого сенсу.

419
00:31:29,000 --> 00:31:36,000
>> Тепер припустимо, що ми збираємося в кінцевому підсумку повертається істинним до кінця.

420
00:31:36,000 --> 00:31:39,000
Як ми збираємося зробити це memmoves,

421
00:31:39,000 --> 00:31:45,000
Ми повинні бути обережні з тим, як ми їх робимо.

422
00:31:45,000 --> 00:31:50,000
Хто-небудь є які-небудь пропозиції про те, як ми їх робимо?

423
00:32:17,000 --> 00:32:21,000
Ось наш старт.

424
00:32:21,000 --> 00:32:28,000
Безумовно, ми хочемо почати з самого початку ще раз

425
00:32:28,000 --> 00:32:35,000
і копії речей в Звідти, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Як ви це зробили?

427
00:32:41,000 --> 00:32:52,000
По-перше, я повинен дивитися на чоловіка сторінки для memmove знову.

428
00:32:52,000 --> 00:32:57,000
Memmove, порядок аргументів завжди важливо.

429
00:32:57,000 --> 00:33:01,000
Ми хочемо, щоб наше призначення першого, другого джерела, розміру третього.

430
00:33:01,000 --> 00:33:06,000
Є багато функцій, які зворотному джерела і призначення.

431
00:33:06,000 --> 00:33:11,000
Напрямок, джерело, як правило, відповідає кілька.

432
00:33:17,000 --> 00:33:21,000
Move, що це повернення?

433
00:33:21,000 --> 00:33:27,000
Вона повертає покажчик до місця призначення, з якої причини ви, можливо, захочете цього.

434
00:33:27,000 --> 00:33:32,000
Я можу собі читати, але ми хочемо рухатися в нашому призначення.

435
00:33:32,000 --> 00:33:35,000
>> Те, що наш пункт призначення буде?

436
00:33:35,000 --> 00:33:37,000
[Студент] New.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Так, і де ми копіюванні?

438
00:33:39,000 --> 00:33:43,000
Перше, що ми копіюємо це 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Що таке-це 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Що таке адресу цього 1?

441
00:33:55,000 --> 00:33:58,000
Що це адреса, що 1?

442
00:33:58,000 --> 00:34:01,000
[Студент] [нерозбірливо]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Керівник + адреса першого елемента.

444
00:34:03,000 --> 00:34:05,000
Як ми можемо отримати перший елемент у масиві?

445
00:34:05,000 --> 00:34:10,000
[Студент] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Так, q.strings.

447
00:34:15,000 --> 00:34:20,000
Пам'ятайте, що тут, наші голови 1.

448
00:34:20,000 --> 00:34:24,000
Штопати його. Я просто думаю, що це чарівно-

449
00:34:24,000 --> 00:34:29,000
Тут наші голови 1. Я збираюся змінювати свій колір теж.

450
00:34:29,000 --> 00:34:36,000
А ось рядки.

451
00:34:36,000 --> 00:34:41,000
Це, ми можемо або написати його, як ми зробили тут

452
00:34:41,000 --> 00:34:43,000
з главами + q.strings.

453
00:34:43,000 --> 00:34:51,000
Багато людей також писати і q.strings [глава].

454
00:34:51,000 --> 00:34:55,000
В дійсності це не будь менш ефективним.

455
00:34:55,000 --> 00:34:58,000
Ви можете думати про це, як ви разименованія його, а потім отримати адресу,

456
00:34:58,000 --> 00:35:04,000
але компілятор збирається перевести його на те, що ми були представлені в усякому разі, q.strings + голова.

457
00:35:04,000 --> 00:35:06,000
У будь-якому випадку ви хочете, щоб думати про це.

458
00:35:06,000 --> 00:35:11,000
>> І скільки байт ми хочемо, щоб скопіювати?

459
00:35:11,000 --> 00:35:15,000
[Студент] Потужність - голова.

460
00:35:15,000 --> 00:35:18,000
Місткість - голова.

461
00:35:18,000 --> 00:35:21,000
І тоді ви завжди можете написати приклад

462
00:35:21,000 --> 00:35:23,000
щоб з'ясувати, якщо це так.

463
00:35:23,000 --> 00:35:26,000
[Студент] Вона повинна бути розділена на 2, то.

464
00:35:26,000 --> 00:35:30,000
Так, тому я думаю, ми могли б використовувати розмір.

465
00:35:30,000 --> 00:35:35,000
У нас ще є розмір буття-

466
00:35:35,000 --> 00:35:39,000
з використанням розміру, у нас є розмір, рівний 4.

467
00:35:39,000 --> 00:35:42,000
Наш розмір 4. Наші голови 1.

468
00:35:42,000 --> 00:35:46,000
Ми хочемо, щоб скопіювати ці 3 елементи.

469
00:35:46,000 --> 00:35:54,000
Це розсудливість перевірити, що розмір - голова правильно 3.

470
00:35:54,000 --> 00:35:58,000
І повертатися сюди, як ми вже говорили,

471
00:35:58,000 --> 00:36:00,000
якби ми використовували потенціал, то ми повинні були б поділити на 2

472
00:36:00,000 --> 00:36:04,000
тому що ми вже виросли наші можливості, тому замість цього ми збираємося використовувати розмір.

473
00:36:11,000 --> 00:36:13,000
Це копій цієї частини.

474
00:36:13,000 --> 00:36:18,000
Тепер нам потрібно скопіювати інша частина, частина, що залишилася від самого початку.

475
00:36:18,000 --> 00:36:28,000
>> Це збирається memmove в якому становищі?

476
00:36:28,000 --> 00:36:32,000
[Студент] Великі розміри - голова.

477
00:36:32,000 --> 00:36:38,000
Так, так ми вже скопіювали в розмірі - глава байт,

478
00:36:38,000 --> 00:36:43,000
і тому там, де ми хочемо скопіювати залишилися байти нового

479
00:36:43,000 --> 00:36:48,000
, А потім розмір мінус, ну, кількість байт, ми вже скопіювали дюйма

480
00:36:48,000 --> 00:36:52,000
А потім куди ми копіюванні?

481
00:36:52,000 --> 00:36:54,000
[Студент] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Так, q.strings.

483
00:36:56,000 --> 00:37:02,000
Ми могли або зробити і q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Це значно рідше, ніж це.

485
00:37:05,000 --> 00:37:14,000
Якщо він просто буде 0, то ви будете схильні бачити q.strings.

486
00:37:14,000 --> 00:37:16,000
Ось де ми копіюванні.

487
00:37:16,000 --> 00:37:18,000
Скільки байт в нас залишилося скопіювати? >> [Студент] 10.

488
00:37:18,000 --> 00:37:20,000
Право.

489
00:37:20,000 --> 00:37:25,000
[Студент] Чи повинні ми помножимо 5 - 10 разів більше байта або ще що-небудь?

490
00:37:25,000 --> 00:37:30,000
Так, так це десь, що саме ми копіювання?

491
00:37:30,000 --> 00:37:32,000
[Студент] [нерозбірливо]

492
00:37:32,000 --> 00:37:34,000
Який тип річ, яку ми копіювання?

493
00:37:34,000 --> 00:37:36,000
[Студент] [нерозбірливо]

494
00:37:36,000 --> 00:37:41,000
Так, так що символ * и, що ми копіювання, ми не знаємо, де ті й звідки.

495
00:37:41,000 --> 00:37:47,000
Ну, де вони вказують на, як струни, ми в кінцевому підсумку натиснувши на неї в чергу

496
00:37:47,000 --> 00:37:49,000
або enqueuing на черзі.

497
00:37:49,000 --> 00:37:51,000
Де ті, і звідки, ми поняття не маємо.

498
00:37:51,000 --> 00:37:56,000
Нам просто потрібно стежити за символ * з себе.

499
00:37:56,000 --> 00:38:00,000
Ми не хочемо, щоб скопіювати розміру - начальник байт.

500
00:38:00,000 --> 00:38:03,000
Ми хочемо, щоб скопіювати розміру - начальник символ * с,

501
00:38:03,000 --> 00:38:11,000
так що ми збираємося помножити це на SizeOf (Char *).

502
00:38:11,000 --> 00:38:17,000
Те ж саме тут, внизу, голова * SizeOf (Char *).

503
00:38:17,000 --> 00:38:24,000
>> [Студент] А [нерозбірливо]?

504
00:38:24,000 --> 00:38:26,000
Це прямо тут?

505
00:38:26,000 --> 00:38:28,000
[Студент] Ні, нижче, розмір - голова.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Це прямо тут?

507
00:38:30,000 --> 00:38:32,000
Покажчик арифметика.

508
00:38:32,000 --> 00:38:35,000
Як арифметика покажчиків буде працювати це

509
00:38:35,000 --> 00:38:40,000
він автоматично збільшується на розмір типу, що ми маємо справу з.

510
00:38:40,000 --> 00:38:46,000
Так само, як тут, нова + (розмір - голова)

511
00:38:46,000 --> 00:38:56,000
точно відповідає і нова [розмір - начальник]

512
00:38:56,000 --> 00:39:00,000
поки ми не очікуємо, що працює правильно,

513
00:39:00,000 --> 00:39:04,000
так як якщо ми маємо справу з Int масиву, то ми не робимо індекс INT-

514
00:39:04,000 --> 00:39:07,000
або, якщо це розмір з 5, і ви хочете 4-й елемент, то індекс у

515
00:39:07,000 --> 00:39:10,000
Int масиву [4].

516
00:39:10,000 --> 00:39:14,000
Ви не-[4] * розмір Int.

517
00:39:14,000 --> 00:39:21,000
, Який обробляє його автоматично, і цей випадок

518
00:39:21,000 --> 00:39:29,000
Буквально еквівалентні, тому кронштейн синтаксису

519
00:39:29,000 --> 00:39:34,000
тільки збирається бути перетворений в цьому, як тільки ви компіляції.

520
00:39:34,000 --> 00:39:38,000
Це те, що ви повинні бути обережні, що

521
00:39:38,000 --> 00:39:42,000
при додаванні розмірів - голова

522
00:39:42,000 --> 00:39:45,000
Ви додаєте не один байт.

523
00:39:45,000 --> 00:39:53,000
Ви додаєте один символ *, який може бути одним байт або будь-який інший.

524
00:39:53,000 --> 00:39:56,000
>> Інші питання?

525
00:39:56,000 --> 00:40:04,000
Так, з черги буде легше.

526
00:40:04,000 --> 00:40:11,000
Я дам вам хвилину, щоб реалізувати.

527
00:40:11,000 --> 00:40:18,000
Так, і я припускаю, що це та ж сама ситуація, де

528
00:40:18,000 --> 00:40:21,000
що епдіеіе випадку, якщо ми enqueuing нульовий,

529
00:40:21,000 --> 00:40:24,000
Може бути, ми хочемо впоратися з цим, може бути, ми не знаємо.

530
00:40:24,000 --> 00:40:27,000
Ми не будемо робити це знову тут, але так само, як наш стек випадку.

531
00:40:27,000 --> 00:40:34,000
Якщо поставити в чергу нульові, ми могли б на нього уваги.

532
00:40:34,000 --> 00:40:40,000
Будь-який, є певний код, я можу потягнути?

533
00:40:40,000 --> 00:40:45,000
[Студент] Я просто з черги.

534
00:40:45,000 --> 00:40:56,000
Версія 2 є те, що, все в порядку.

535
00:40:56,000 --> 00:40:59,000
Ви хочете, щоб пояснити?

536
00:40:59,000 --> 00:41:01,000
[Студент] По-перше, ви переконаєтеся, що є щось в черзі

537
00:41:01,000 --> 00:41:07,000
і що розмір знижується на 1.

538
00:41:07,000 --> 00:41:11,000
Ви повинні зробити це, а потім повернути його голову

539
00:41:11,000 --> 00:41:13,000
а потім перемістити голову 1.

540
00:41:13,000 --> 00:41:19,000
Отже, є куточок випадку ми повинні розглянути. Так.

541
00:41:19,000 --> 00:41:24,000
[Студент] Якщо ваша голова знаходиться на останньому елементі,

542
00:41:24,000 --> 00:41:26,000
то ви не хочете голову, щоб вказати межі масиву.

543
00:41:26,000 --> 00:41:29,000
>> Так, так, як тільки голова стосується кінці нашого масиву,

544
00:41:29,000 --> 00:41:35,000
Коли ми з черги, наша голова повинна бути мода на 0.

545
00:41:35,000 --> 00:41:40,000
На жаль, ми не можемо зробити це за один крок.

546
00:41:40,000 --> 00:41:44,000
Я думаю, так, як я б, ймовірно, виправити це

547
00:41:44,000 --> 00:41:52,000
це буде символ *, те, що ми повертаємося,

548
00:41:52,000 --> 00:41:55,000
Незалежно від вашого імені змінної хоче бути.

549
00:41:55,000 --> 00:42:02,000
Потім ми хочемо мода голови наших можливостей

550
00:42:02,000 --> 00:42:10,000
, А потім повернутися у відставці.

551
00:42:10,000 --> 00:42:14,000
Багато людей тут, вони могли б зробити-

552
00:42:14,000 --> 00:42:19,000
це випадок-ви будете бачити, як люди робити, якщо голова

553
00:42:19,000 --> 00:42:29,000
більше місткість, зробити голову - ємність.

554
00:42:29,000 --> 00:42:36,000
І це тільки робоча навколо того, що мод.

555
00:42:36,000 --> 00:42:41,000
Глава МО = ємність набагато чистіше

556
00:42:41,000 --> 00:42:51,000
з обтікання, ніж якщо б голова більше, ніж потужність головою - ємність.

557
00:42:51,000 --> 00:42:56,000
>> Питання?

558
00:42:56,000 --> 00:43:02,000
Гаразд, остання річ, яку ми залишили наш пов'язаного списку.

559
00:43:02,000 --> 00:43:07,000
Ви могли б бути використані для деяких із зв'язаного списку поведінку, якщо ви зробили

560
00:43:07,000 --> 00:43:11,000
пов'язаних списків у вашій хеш-таблиці, якщо ви зробили хеш-таблиці.

561
00:43:11,000 --> 00:43:15,000
Я настійно рекомендую робити хеш-таблиці.

562
00:43:15,000 --> 00:43:17,000
Можливо, ви вже зробили вигляді дерева,

563
00:43:17,000 --> 00:43:23,000
але намагається важче.

564
00:43:23,000 --> 00:43:27,000
У теорії, вони асимптотично краще.

565
00:43:27,000 --> 00:43:30,000
Але подивіться на великій дошці,

566
00:43:30,000 --> 00:43:35,000
і намагається ніколи не робити краще, і вони займають більше пам'яті.

567
00:43:35,000 --> 00:43:43,000
Все про спробу закінчує тим, що ще гірше для додаткової роботи.

568
00:43:43,000 --> 00:43:49,000
Це те, що рішення David Malan завжди є

569
00:43:49,000 --> 00:43:56,000
він завжди свої повідомлення Trie рішення, і давайте подивимося, де він в даний час.

570
00:43:56,000 --> 00:44:00,000
Що він під землею, David J?

571
00:44:00,000 --> 00:44:06,000
Він № 18, так що це не дуже погано,

572
00:44:06,000 --> 00:44:09,000
і що це буде один з кращих намагається Ви можете думати

573
00:44:09,000 --> 00:44:17,000
або одна з кращих намагається з Trie.

574
00:44:17,000 --> 00:44:23,000
Це навіть не його оригінальне рішення?

575
00:44:23,000 --> 00:44:29,000
Я відчуваю, як Trie рішення, як правило, більше в цій області використання оперативної пам'яті.

576
00:44:29,000 --> 00:44:33,000
>> Спустіться на самий верх, і оперативної пам'яті знаходиться в одній цифри.

577
00:44:33,000 --> 00:44:36,000
Спустіться вниз до нижньої, а потім ви починаєте бачити намагається

578
00:44:36,000 --> 00:44:41,000
де ви отримаєте абсолютно масивної оперативної пам'яті,

579
00:44:41,000 --> 00:44:45,000
і намагається важче.

580
00:44:45,000 --> 00:44:53,000
Не зовсім, але варто це освітній досвід, якщо ви зробили один.

581
00:44:53,000 --> 00:44:56,000
Останнє, що наша пов'язаного списку,

582
00:44:56,000 --> 00:45:04,000
і ці три речі, стеки, черги і зв'язані списки,

583
00:45:04,000 --> 00:45:09,000
будь-яка майбутня що можна зробити в області комп'ютерних наук

584
00:45:09,000 --> 00:45:12,000
Припустимо у вас є знайомство з цими речами.

585
00:45:12,000 --> 00:45:19,000
Вони просто таким фундаментальним до всього.

586
00:45:19,000 --> 00:45:25,000
>> Зв'язані списки, і тут ми односпрямованого списку буде наша реалізація.

587
00:45:25,000 --> 00:45:34,000
Що односвязного значить, на відміну від двусвязний? Так.

588
00:45:34,000 --> 00:45:37,000
[Студент] Це тільки вказує на наступний покажчик, а не покажчиків,

589
00:45:37,000 --> 00:45:39,000
як той перед ним і після неї.

590
00:45:39,000 --> 00:45:44,000
Так, так і у форматі зображення, що я тільки що зробив?

591
00:45:44,000 --> 00:45:48,000
У мене є дві речі. У мене є картини і фотографії.

592
00:45:48,000 --> 00:45:51,000
У форматі зображення, наші односпрямованого списку,

593
00:45:51,000 --> 00:45:57,000
Безумовно, у нас є якийсь покажчик на главу нашого списку,

594
00:45:57,000 --> 00:46:02,000
, А потім в наш список, ми просто покажчики,

595
00:46:02,000 --> 00:46:05,000
і, можливо, це вказує на нуль.

596
00:46:05,000 --> 00:46:08,000
Це буде ваш типовий малюнок односпрямованого списку.

597
00:46:08,000 --> 00:46:14,000
Двічі зв'язаний список, ви можете піти в зворотному напрямку.

598
00:46:14,000 --> 00:46:19,000
Якщо я дам вам будь-який вузол в списку, то ви можете завжди отримати в

599
00:46:19,000 --> 00:46:23,000
будь-який інший вузол в список, якщо він двічі зв'язаний список.

600
00:46:23,000 --> 00:46:27,000
Але якщо я вам третього вузла в списку, і це односпрямований список,

601
00:46:27,000 --> 00:46:30,000
жодним чином не ви коли-небудь, щоб дістатися до першого і другого вузлів.

602
00:46:30,000 --> 00:46:34,000
І є переваг і недоліків, і один очевидний

603
00:46:34,000 --> 00:46:42,000
це ви займають більше розміром, і ви повинні відслідковувати, де ці речі повинні бути звернені зараз.

604
00:46:42,000 --> 00:46:49,000
Але ми дбаємо лише про односвязанни.

605
00:46:49,000 --> 00:46:53,000
>> Кілька речей, які ми збираємося мати реалізувати.

606
00:46:53,000 --> 00:47:00,000
Ваша ЬурейеЕ вузла структури, Int I: Структура вузла * наступний; вузла.

607
00:47:00,000 --> 00:47:09,000
Це ЬурейеЕ повинні бути спалені у вашому розумі.

608
00:47:09,000 --> 00:47:14,000
Вікторина 1 слід хотіли дати визначення типу пов'язаного списку вузлів,

609
00:47:14,000 --> 00:47:18,000
і ви повинні бути в змозі негайно строчити, що вниз

610
00:47:18,000 --> 00:47:22,000
навіть не замислюючись про це.

611
00:47:22,000 --> 00:47:27,000
Я думаю, пара питань, чому ми повинні побудуємо тут?

612
00:47:27,000 --> 00:47:32,000
Чому ми не можемо сказати вузла *?

613
00:47:32,000 --> 00:47:35,000
[Студент] [нерозбірливо]

614
00:47:35,000 --> 00:47:38,000
Так.

615
00:47:38,000 --> 00:47:44,000
Єдине, що визначає вузол, як річ

616
00:47:44,000 --> 00:47:47,000
є ЬурейеЕ себе.

617
00:47:47,000 --> 00:47:55,000
Але на даний момент, коли ми начебто розбору через це визначення вузла структури,

618
00:47:55,000 --> 00:48:01,000
Ми ще не закінчили нашу ЬурейеЕ ще, так що з ЬурейеЕ не закінчена,

619
00:48:01,000 --> 00:48:05,000
вузол не існує.

620
00:48:05,000 --> 00:48:12,000
Але структура вузла робить, і цей вузол сюди,

621
00:48:12,000 --> 00:48:14,000
це також можна назвати щось ще.

622
00:48:14,000 --> 00:48:16,000
Це можна назвати с.

623
00:48:16,000 --> 00:48:19,000
Це можна було б назвати зв'язаний список вузлів.

624
00:48:19,000 --> 00:48:21,000
Його можна назвати що завгодно.

625
00:48:21,000 --> 00:48:26,000
Але ця структура вузол повинен бути названо ж саме, що ця структура вузла.

626
00:48:26,000 --> 00:48:29,000
Що ви називаєте це має бути тут,

627
00:48:29,000 --> 00:48:32,000
і так, що також відповідає на другій точці питання

628
00:48:32,000 --> 00:48:37,000
Саме тому-багато разів, коли ви бачите структур і визначення типів із структури,

629
00:48:37,000 --> 00:48:42,000
Ви побачите, анонімні структури, де ви побачите тільки ЬурейеЕ структури,

630
00:48:42,000 --> 00:48:47,000
реалізація структури, словник, або Що завгодно.

631
00:48:47,000 --> 00:48:51,000
>> Чому тут ми повинні сказати вузла?

632
00:48:51,000 --> 00:48:54,000
Чому вона не може бути анонімною структури?

633
00:48:54,000 --> 00:48:56,000
Це майже той же відповідь.

634
00:48:56,000 --> 00:48:58,000
[Студент] Вам потрібно посилатися на нього в межах структури.

635
00:48:58,000 --> 00:49:04,000
Так, в межах структури, необхідно звернутися до структури самого.

636
00:49:04,000 --> 00:49:10,000
Якщо ви не даєте структури імені, якщо це анонімна структура, ви не можете посилатися на нього.

637
00:49:10,000 --> 00:49:17,000
І останнє, але не менш всі вони повинні бути дещо прямолінійно,

638
00:49:17,000 --> 00:49:20,000
і вони повинні допомогти вам зрозуміти, якщо ви пишете це вниз

639
00:49:20,000 --> 00:49:24,000
що ви робите щось неправильно, якщо такого роду речі не мають сенсу.

640
00:49:24,000 --> 00:49:28,000
Останнє, але не менш важливо, чому це повинна бути структура вузла *?

641
00:49:28,000 --> 00:49:34,000
Чому це не може бути просто будуємо вузла далі?

642
00:49:34,000 --> 00:49:37,000
[Студент] Покажчик на наступну структуру.

643
00:49:37,000 --> 00:49:39,000
Це неминуче, що ми хочемо.

644
00:49:39,000 --> 00:49:42,000
Чому б це ніколи не буде структура вузла далі?

645
00:49:42,000 --> 00:49:50,000
Чому це має бути структура вузла * далі? Так.

646
00:49:50,000 --> 00:49:53,000
[Студент] Це як нескінченний цикл.

647
00:49:53,000 --> 00:49:55,000
Так.

648
00:49:55,000 --> 00:49:57,000
[Студент], що все буде в одному.

649
00:49:57,000 --> 00:50:02,000
Так, просто думаю про те, як ми будемо робити розміру або щось.

650
00:50:02,000 --> 00:50:08,000
Розмір структури в основному + або - деякі картини тут або там.

651
00:50:08,000 --> 00:50:15,000
Це в основному буде сума розміри речей в структурі.

652
00:50:15,000 --> 00:50:18,000
Це прямо тут, нічого не змінюючи, розмір буде легко.

653
00:50:18,000 --> 00:50:24,000
Розмір структури вузла буде розміром я + розмір наступного.

654
00:50:24,000 --> 00:50:27,000
Розмір мені буде 4. Розмір наступний буде 4.

655
00:50:27,000 --> 00:50:30,000
Розмір структури вузла буде 8.

656
00:50:30,000 --> 00:50:34,000
Якщо ми не будемо мати *, думаючи про SizeOf,

657
00:50:34,000 --> 00:50:37,000
Потім SizeOf (I) буде 4.

658
00:50:37,000 --> 00:50:43,000
Розмір структури вузла наступний буде розміром я + розмір структури вузла наступного

659
00:50:43,000 --> 00:50:46,000
+ Розмір я + розмір структури вузла наступного.

660
00:50:46,000 --> 00:50:55,000
Було б нескінченною рекурсії вузлів.

661
00:50:55,000 --> 00:51:00,000
Ось чому все це так має бути.

662
00:51:00,000 --> 00:51:03,000
>> Знову ж, обов'язково запам'ятайте, що,

663
00:51:03,000 --> 00:51:06,000
або, принаймні, зрозуміти, достатньо того, що ви можете бути в змозі

664
00:51:06,000 --> 00:51:12,000
Причиною через те, що вона має виглядати.

665
00:51:12,000 --> 00:51:14,000
Те, що ми збираємося хочемо реалізувати.

666
00:51:14,000 --> 00:51:18,000
Якщо довжина списку

667
00:51:18,000 --> 00:51:21,000
Ви можете обманювати і тримати навколо

668
00:51:21,000 --> 00:51:24,000
глобальні довжини або щось, але ми не збираємося цього робити.

669
00:51:24,000 --> 00:51:28,000
Ми збираємося, щоб підрахувати довжину списку.

670
00:51:28,000 --> 00:51:34,000
Ми міститься, так що це в основному, як пошук,

671
00:51:34,000 --> 00:51:41,000
тому у нас є зв'язаний список цілих чисел, щоб побачити, якщо це число знаходиться у зв'язаному списку.

672
00:51:41,000 --> 00:51:44,000
Приєднання буде вставити на початку списку.

673
00:51:44,000 --> 00:51:46,000
Append збирається включити в кінці.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted буде вставити в впорядковані позиції в списку.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted вид припускає, що ви ніколи не використовували початок або кінець в поганих стосунках.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted, коли ви реалізуєте insert_sorted-

677
00:52:09,000 --> 00:52:13,000
скажімо, у нас є зв'язаний список.

678
00:52:13,000 --> 00:52:18,000
Це те, що в даний час він виглядає, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Я хочу, щоб вставити 3, так як поки сам список вже відсортований,

680
00:52:24,000 --> 00:52:27,000
легко знайти, де 3 належить.

681
00:52:27,000 --> 00:52:29,000
Я починаю в 2.

682
00:52:29,000 --> 00:52:32,000
Гаразд, 3 більше, ніж 2, тому я хочу, щоб продовжувати йти.

683
00:52:32,000 --> 00:52:35,000
Ах, 4 занадто великий, так що я знаю 3 буде йти між 2 і 4,

684
00:52:35,000 --> 00:52:39,000
і у мене є, щоб виправити вказівники і все таке.

685
00:52:39,000 --> 00:52:43,000
Але якщо ми не будемо використовувати строго insert_sorted,

686
00:52:43,000 --> 00:52:50,000
хотілося давайте просто скажемо, я випереджати 6,

687
00:52:50,000 --> 00:52:55,000
Потім мій пов'язаного списку стане цим.

688
00:52:55,000 --> 00:53:01,000
В даний час вона не має ніякого сенсу, тому для insert_sorted, можна тільки припустити,

689
00:53:01,000 --> 00:53:04,000
що список відсортований, хоча існують операції

690
00:53:04,000 --> 00:53:09,000
які можуть призвести до не бути відсортовані, ось і все.

691
00:53:09,000 --> 00:53:20,000
Знайти корисним вставка-так це ті основні речі, які ви будете мати реалізувати.

692
00:53:20,000 --> 00:53:24,000
>> Зараз, знайдіть хвилинку, щоб зробити довжину і містить,

693
00:53:24,000 --> 00:53:30,000
і ті повинні бути відносно швидко.

694
00:53:41,000 --> 00:53:48,000
Наближається час закриття, так що у кого нічого довжину або містить?

695
00:53:48,000 --> 00:53:50,000
Вони збираються, щоб бути майже ідентичними.

696
00:53:50,000 --> 00:53:57,000
[Студент] Довжина.

697
00:53:57,000 --> 00:54:01,000
Давайте подивимося, перегляд.

698
00:54:01,000 --> 00:54:04,000
Добре.

699
00:54:12,000 --> 00:54:15,000
Ви хочете, щоб пояснити?

700
00:54:15,000 --> 00:54:21,000
[Студент] Я просто створити покажчик вузлів і ініціалізувати його до першого, який є нашою глобальної змінної,

701
00:54:21,000 --> 00:54:27,000
а потім перевірити, якщо це нульовий, тому я не отримую сегменті вина і повертати 0, якщо це так.

702
00:54:27,000 --> 00:54:34,000
В іншому випадку, я циклі, відстеження протягом цілого

703
00:54:34,000 --> 00:54:38,000
Скільки разів я звертався до наступного елементу списку

704
00:54:38,000 --> 00:54:43,000
і в тому ж операцію прирощення також доступу до цієї фактичної елемент,

705
00:54:43,000 --> 00:54:47,000
і тоді я безперервно зробити перевірку, щоб побачити, якщо це NULL,

706
00:54:47,000 --> 00:54:56,000
і якщо він нульовий, то він перериває і просто повертає кількість елементів я доступний.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Хто-небудь є які-небудь коментарі на що-небудь?

708
00:55:01,000 --> 00:55:06,000
Це виглядає чудово правильність мудро.

709
00:55:06,000 --> 00:55:10,000
[Студент] Я не думаю, що вам потрібно вузла == NULL.

710
00:55:10,000 --> 00:55:13,000
Так, так що якщо вузол == NULL 0 поверненню.

711
00:55:13,000 --> 00:55:18,000
Але якщо вузол == NULL, то це-о-о, є коректності питання.

712
00:55:18,000 --> 00:55:23,000
Це було просто ви поверненні я, але це не входить в комплект прямо зараз.

713
00:55:23,000 --> 00:55:30,000
Вам просто потрібно Int я, так що я = 0.

714
00:55:30,000 --> 00:55:34,000
Але якщо вузол є нульовим, то я як і раніше буде 0,

715
00:55:34,000 --> 00:55:39,000
і ми збираємося повертати 0, так що цей випадок є однаковим.

716
00:55:39,000 --> 00:55:48,000
Інша поширена річ, щоб зберегти декларацію

717
00:55:48,000 --> 00:55:51,000
вузлів всередині циклу.

718
00:55:51,000 --> 00:55:54,000
Можна сказати, що-о-о, немає.

719
00:55:54,000 --> 00:55:56,000
Давайте тримати це як це.

720
00:55:56,000 --> 00:55:59,000
Я б, напевно покласти Int = 0 тут,

721
00:55:59,000 --> 00:56:05,000
Потім вузол * = перший вузол тут.

722
00:56:05,000 --> 00:56:11,000
І це, напевно, як-позбутися цього зараз.

723
00:56:11,000 --> 00:56:14,000
Це, напевно, як би я написав.

724
00:56:14,000 --> 00:56:21,000
Крім того, можна-зважаючи на це, як це.

725
00:56:21,000 --> 00:56:25,000
Цей цикл структура прямо тут

726
00:56:25,000 --> 00:56:30,000
повинна бути майже настільки ж природно для вас, як і для Int я = 0

727
00:56:30,000 --> 00:56:33,000
Я менше, ніж довжина масиву я + +.

728
00:56:33,000 --> 00:56:38,000
Якщо це, як ви ітерації по масиву, це, як ви ітерацію по списку.

729
00:56:38,000 --> 00:56:45,000
>> Це повинно бути другою натурою в деякій точці.

730
00:56:45,000 --> 00:56:50,000
Маючи це на увазі, це буде майже те ж саме.

731
00:56:50,000 --> 00:56:57,000
Ви збираєтеся хочете перебрати пов'язаного списку.

732
00:56:57,000 --> 00:57:02,000
Якщо вузол-я поняття не маю, що величина називається.

733
00:57:02,000 --> 00:57:04,000
Я вузла.

734
00:57:04,000 --> 00:57:15,000
Якщо значення в цьому вузлі = я повернуся, правда, і це все.

735
00:57:15,000 --> 00:57:18,000
Зверніть увагу, що тільки так ми коли-небудь повернутися помилковим

736
00:57:18,000 --> 00:57:23,000
, Якщо ми перебору всієї зв'язаний список і ніколи не повертатися правда,

737
00:57:23,000 --> 00:57:29,000
так це те, що вона робить.

738
00:57:29,000 --> 00:57:36,000
Як примітка боку, ми, ймовірно, не отримаєте, щоб додати початку або в кінці.

739
00:57:36,000 --> 00:57:39,000
>> Швидкий останньої ноти.

740
00:57:39,000 --> 00:57:52,000
Якщо Ви бачите статичну ключовими словами, так скажемо статичного кількість Int = 0,

741
00:57:52,000 --> 00:57:56,000
Потім ми робимо фото + +, ви можете в основному думають про нього як про глобальної змінної,

742
00:57:56,000 --> 00:58:00,000
хоча я тільки що сказав, що це не так, як ми збираємося реалізувати довжини.

743
00:58:00,000 --> 00:58:06,000
Я роблю це тут, а потім розраховувати + +.

744
00:58:06,000 --> 00:58:11,000
У будь-якому випадку, ми можемо увійти вузла в нашому пов'язаного списку ми збільшуючи наш рахунок.

745
00:58:11,000 --> 00:58:15,000
Суть цього є те, що статична ключове слово означає.

746
00:58:15,000 --> 00:58:20,000
Якби я тільки що соіпЬ = 0, що буде регулярно старих глобальних змінних.

747
00:58:20,000 --> 00:58:25,000
Що статичного Int кількість коштів є те, що глобальна змінна за цей файл.

748
00:58:25,000 --> 00:58:28,000
Це неможливо для деяких інших файлів,

749
00:58:28,000 --> 00:58:34,000
хотілося думати про PSET 5, якщо ви почали.

750
00:58:34,000 --> 00:58:39,000
Ви обоє speller.c, і у вас є dictionary.c,

751
00:58:39,000 --> 00:58:42,000
і якщо ви просто оголосити глобальну річ, то нічого в speller.c

752
00:58:42,000 --> 00:58:45,000
можна отримати в dictionary.c і навпаки.

753
00:58:45,000 --> 00:58:48,000
Глобальні змінні доступні будь-кому. Файл с,

754
00:58:48,000 --> 00:58:54,000
але статичні змінні доступні тільки усередині самого файлу,

755
00:58:54,000 --> 00:59:01,000
так що всередині перевірку орфографії або всередині dictionary.c,

756
00:59:01,000 --> 00:59:06,000
це ніби як би я заявляю про свій змінної для розміру моєї масиву

757
00:59:06,000 --> 00:59:10,000
або розмір мого кількість слів у словнику.

758
00:59:10,000 --> 00:59:15,000
Так як я не хочу, щоб оголосити глобальну змінну, що хтось має доступ,

759
00:59:15,000 --> 00:59:18,000
Я дійсно піклуються тільки про нього для моїх власних цілей.

760
00:59:18,000 --> 00:59:21,000
>> Гарна річ про це також весь матеріал зіткнення ім'я.

761
00:59:21,000 --> 00:59:27,000
Якщо деякий інший файл намагається використовувати глобальну змінну з ім'ям графа, все йде дуже, дуже неправильно,

762
00:59:27,000 --> 00:59:33,000
так що це добре тримає речі безпечні, і тільки ви можете отримати до нього доступ,

763
00:59:33,000 --> 00:59:38,000
і ніхто інший не може, і якщо хтось заявляє, глобальна змінна називається граф,

764
00:59:38,000 --> 00:59:43,000
то він не буде втручатися у вашу статичної змінної кол.

765
00:59:43,000 --> 00:59:47,000
Це те, що є статичним. Це файл глобальних змінних.

766
00:59:47,000 --> 00:59:52,000
>> Питання про щось?

767
00:59:52,000 --> 00:59:59,000
Все готово. Поки.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]