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

2
00:00:02,520 --> 00:00:04,850
[Rob Боуден - Гарвардський університет]

3
00:00:04,850 --> 00:00:07,370
[Це CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
У нас є тест завтра, у випадку, якщо ви, хлопці, не знаю, що.

5
00:00:14,810 --> 00:00:20,970
Це в основному все, що ви могли бачити в класі або повинні були бачити в своєму класі.

6
00:00:20,970 --> 00:00:26,360
Це включає в себе покажчики, навіть якщо вони зовсім недавно тема.

7
00:00:26,360 --> 00:00:29,860
Ви повинні принаймні, зрозуміти високого рівня з них.

8
00:00:29,860 --> 00:00:34,760
Все, що було перейшли в клас ви повинні розуміти, для вікторини.

9
00:00:34,760 --> 00:00:37,320
Так що якщо у вас є питання по ним, ви можете задати їх зараз.

10
00:00:37,320 --> 00:00:43,280
Але це буде дуже студента під керівництвом сесії, де ви, хлопці, задавати питання,

11
00:00:43,280 --> 00:00:45,060
так що сподіваюся, людям є питання.

12
00:00:45,060 --> 00:00:48,020
У кого-небудь є питання?

13
00:00:49,770 --> 00:00:52,090
Так. >> [Студент] Чи можете ви перейти на покажчики знову?

14
00:00:52,090 --> 00:00:54,350
Я піду за покажчиками.

15
00:00:54,350 --> 00:00:59,180
Всі ваші змінні обов'язково жити в пам'яті,

16
00:00:59,180 --> 00:01:04,450
але зазвичай ви не хвилюйтеся про це, і ви просто говорите х + 2, у + 3

17
00:01:04,450 --> 00:01:07,080
і компілятор буде з'ясувати, де живуть речі для вас.

18
00:01:07,080 --> 00:01:12,990
Коли ви маєте справу з покажчиками, тепер ви явно за допомогою цих адрес пам'яті.

19
00:01:12,990 --> 00:01:19,800
Таким чином, однією змінною буде тільки коли жити за однією адресою в будь-який момент часу.

20
00:01:19,800 --> 00:01:24,040
Якщо ми хочемо оголосити покажчик, те, що тип буде виглядати?

21
00:01:24,040 --> 00:01:26,210
>> Я хочу оголосити покажчик р. Що ж типу виглядають?

22
00:01:26,210 --> 00:01:33,530
[Студент] Int * р. >> Да. Так Int * р.

23
00:01:33,530 --> 00:01:38,030
А як зробити, щоб вона вказувала на х? >> [Студент] Ampersand.

24
00:01:40,540 --> 00:01:45,300
[Боуден] Так амперсанд буквально називається адресу оператора.

25
00:01:45,300 --> 00:01:50,460
Тому, коли я кажу, і х він стає адресу пам'яті змінної х.

26
00:01:50,460 --> 00:01:56,790
Так що тепер у мене є покажчик р, і в будь-якому місці в моєму коді я можу використовувати * р

27
00:01:56,790 --> 00:02:02,960
або я міг би використовувати х, і це буде одне і те ж.

28
00:02:02,960 --> 00:02:09,520
(* Р). Що це робиш? Що означає, що зірка на увазі?

29
00:02:09,520 --> 00:02:13,120
[Студент] Це означає значення в цій точці. >> Да.

30
00:02:13,120 --> 00:02:17,590
Так, якщо ми дивимося на нього, він може бути дуже корисно, щоб витягнути діаграм

31
00:02:17,590 --> 00:02:22,230
де це маленька коробочка пам'яті для х, в якому є значення 4,

32
00:02:22,230 --> 00:02:25,980
Потім у нас є маленька коробочка пам'яті для р,

33
00:02:25,980 --> 00:02:31,590
і так з точки х, так що ми малюємо стрілку від р х.

34
00:02:31,590 --> 00:02:40,270
Тому коли ми говоримо * р ми говоримо піти у вікно, р.

35
00:02:40,270 --> 00:02:46,480
Зірка слідуйте за стрілкою, а потім робити все, що ви хочете з цією коробці прямо там.

36
00:02:46,480 --> 00:03:01,090
Тому я можу сказати * р = 7, і що піде на ящик, який є х і зміни, які до 7.

37
00:03:01,090 --> 00:03:13,540
Або я міг би сказати Int г = * р * 2; Це помилка, тому що це зірка, зірка.

38
00:03:13,540 --> 00:03:19,230
Одна зірка разименованія р, інша зірка множенням на 2.

39
00:03:19,230 --> 00:03:26,780
Зверніть увагу, я міг би з таким же успіхом замінили * р з х.

40
00:03:26,780 --> 00:03:29,430
Ви можете використовувати їх таким же чином.

41
00:03:29,430 --> 00:03:38,000
А потім на мене може бути з точки на абсолютно нову річ.

42
00:03:38,000 --> 00:03:42,190
Я можу тільки сказати, р = &z;

43
00:03:42,190 --> 00:03:44,940
Так що тепер P більше не вказує на х; він вказує на р.

44
00:03:44,940 --> 00:03:50,510
І в будь-який час я * р це так само, як робив р.

45
00:03:50,510 --> 00:03:56,170
Таким чином, корисна річ про це як тільки ми починаємо отримувати по функціях.

46
00:03:56,170 --> 00:03:59,790
>> Це свого роду даремні оголосити покажчик, який вказує на те,

47
00:03:59,790 --> 00:04:03,140
а потім ви просто разименованія його

48
00:04:03,140 --> 00:04:06,060
коли ви могли б використовувати оригінальний змінну з самого початку.

49
00:04:06,060 --> 00:04:18,190
Але коли ви отримуєте в функції - так скажемо, у нас є деякі функції, внутр Фу,

50
00:04:18,190 --> 00:04:32,810
, Яка приймає покажчик і просто робить * р = 6;

51
00:04:32,810 --> 00:04:39,990
Як ми бачили раніше з підкачки, ви не можете зробити ефективний обмін і окремі функції

52
00:04:39,990 --> 00:04:45,180
від просто проходили цілі тому що всі в C завжди проходять за значенням.

53
00:04:45,180 --> 00:04:48,360
Навіть тоді, коли ви передаєте покажчик ви передаєте по значенню.

54
00:04:48,360 --> 00:04:51,940
Просто так вийшло, що ці значення адрес пам'яті.

55
00:04:51,940 --> 00:05:00,770
Тому коли я кажу Foo (р); я передаю покажчик у функції Foo

56
00:05:00,770 --> 00:05:03,910
, А потім Foo робить * р = 6;

57
00:05:03,910 --> 00:05:08,600
Таким чином, усередині цієї функції, * р і раніше еквівалентно х,

58
00:05:08,600 --> 00:05:12,720
але я не можу використовувати х усередині цієї функції, тому що це не областю в цій функції.

59
00:05:12,720 --> 00:05:19,510
Так * р = 6 є єдиним способом я можу отримати доступ з локальної змінної іншу функцію.

60
00:05:19,510 --> 00:05:23,600
Або, добре, покажчики є єдиним способом я можу отримати доступ до локальної змінної з іншої функції.

61
00:05:23,600 --> 00:05:31,600
[Студент] Припустимо, ви хотіли повертати покажчик. Як саме ви це зробили?

62
00:05:31,600 --> 00:05:44,270
[Боуден] Повертає покажчик, як в щось на зразок Int у = 3; повернення & Y? >> [Студент] Так.

63
00:05:44,270 --> 00:05:48,480
[Боуден] Добре. Ви ніколи не повинні це робити. Це погано.

64
00:05:48,480 --> 00:05:59,480
Я думаю, що я бачив у ці лекції слайди ви почали бачити всю цю схему пам'яті

65
00:05:59,480 --> 00:06:02,880
де тут у вас є пам'ять адреса 0

66
00:06:02,880 --> 00:06:09,550
і тут у вас є адреса пам'яті, 4 гігабайтами або від 2 до 32.

67
00:06:09,550 --> 00:06:15,120
Таким чином, то у вас є деякі речі і деякі речі, а потім у вас є свій стек

68
00:06:15,120 --> 00:06:21,780
і у вас є ваша купа, яку ви тільки почали вивчення, зростає.

69
00:06:21,780 --> 00:06:24,390
[Студент] не є купою над стеком?

70
00:06:24,390 --> 00:06:27,760
>> Так. Купа знаходиться на вершині, чи не так? >> [Студент] Ну, він поставив 0 на вершині.

71
00:06:27,760 --> 00:06:30,320
[Студент] О, він поставив 0 на вершині. >> [Студент] О, все в порядку.

72
00:06:30,320 --> 00:06:36,060
Відмова від відповідальності: Anywhere з CS50 ви побачите його таким чином. >> [Студент] Добре.

73
00:06:36,060 --> 00:06:40,290
Це тільки, що, коли ви вперше побачивши стеки,

74
00:06:40,290 --> 00:06:45,000
подобається, коли ви думаєте про стек ви думаєте укладання речей один на одного.

75
00:06:45,000 --> 00:06:50,810
Таким чином, ми, як правило, щоб перегорнути цю навколо так стек росте вгору, як це зазвичай стек

76
00:06:50,810 --> 00:06:55,940
замість того, щоб стік висить вниз. >> [Студент] Не купи технічно рости занадто, правда?

77
00:06:55,940 --> 00:07:01,100
Це залежить від того, що ви розумієте під рости.

78
00:07:01,100 --> 00:07:04,010
Стека і купи завжди зростають у протилежному напрямку.

79
00:07:04,010 --> 00:07:09,420
Стек завжди ростуть в тому сенсі, що воно росте

80
00:07:09,420 --> 00:07:12,940
до більш високих адресах пам'яті, і купа росте вниз

81
00:07:12,940 --> 00:07:17,260
в тому, що він росте в бік менших адрес пам'яті.

82
00:07:17,260 --> 00:07:20,250
Таким чином, верхній дорівнює 0, а нижній є висока адрес пам'яті.

83
00:07:20,250 --> 00:07:26,390
Вони обидва росте, тільки в протилежних напрямках.

84
00:07:26,390 --> 00:07:29,230
[Студент] Я просто мав на увазі, що, оскільки ви сказали, поклав стек на дно

85
00:07:29,230 --> 00:07:33,640
бо здається більш інтуїтивним, оскільки для стека для запуску у верхній частині купи,

86
00:07:33,640 --> 00:07:37,520
купа знаходиться на вершині самого теж, так що that's - >> Да.

87
00:07:37,520 --> 00:07:44,960
Ви також думати про купу, як ростуть і більше, але в стеці більше.

88
00:07:44,960 --> 00:07:50,280
Таким чином, стек є той, який ми як би хочуть показати ростуть.

89
00:07:50,280 --> 00:07:55,390
Але куди не глянь в іншому випадку покаже адреса 0 у верхньому

90
00:07:55,390 --> 00:07:59,590
і найвищий адресу пам'яті в нижній, так що це звичайний вид пам'яті.

91
00:07:59,590 --> 00:08:02,100
>> У вас є питання?

92
00:08:02,100 --> 00:08:04,270
[Студент] Чи можете ви розповісти нам більше про купу?

93
00:08:04,270 --> 00:08:06,180
Так. Я повернуся до цього в секунду.

94
00:08:06,180 --> 00:08:12,220
По-перше, повертаючись до повернення і чому у погана річ,

95
00:08:12,220 --> 00:08:18,470
в стеку у вас є купа кадрів стека, які представляють всі функції

96
00:08:18,470 --> 00:08:20,460
які були названі.

97
00:08:20,460 --> 00:08:27,990
Таким чином, ігноруючи попередні речі, у верхній частині стека завжди буде головною функцією

98
00:08:27,990 --> 00:08:33,090
так як це перша функція, яка викликається.

99
00:08:33,090 --> 00:08:37,130
А потім, коли ви дзвоните іншу функцію, стек буде рости вниз.

100
00:08:37,130 --> 00:08:41,640
Так що, якщо я називаю деякі функції, Foo, і він отримує власний фрейм стеку,

101
00:08:41,640 --> 00:08:47,280
він може викликати деякі функції, бар, він отримує власний фрейм стеку.

102
00:08:47,280 --> 00:08:49,840
І бар може бути рекурсивною, і це може викликати саму себе,

103
00:08:49,840 --> 00:08:54,150
і так, що другий виклик барі збирається отримати свій фрейм стеку.

104
00:08:54,150 --> 00:08:58,880
І тому те, що відбувається в цих кадрів стека є всі локальні змінні

105
00:08:58,880 --> 00:09:03,450
і всі аргументи функції, що -

106
00:09:03,450 --> 00:09:08,730
Будь-які речі, які мають локальну область дії цієї функції перейдіть у цих кадрів стека.

107
00:09:08,730 --> 00:09:21,520
Таким чином, це означає, що, коли я сказав щось на кшталт бару є функцією,

108
00:09:21,520 --> 00:09:29,270
Я просто хочу, щоб оголосити ціле, а потім повертає покажчик на це число.

109
00:09:29,270 --> 00:09:33,790
Так де ж у живете?

110
00:09:33,790 --> 00:09:36,900
[Студент] у живе в барі. >> [Боуден] Так.

111
00:09:36,900 --> 00:09:45,010
Десь в цьому маленькому квадраті пам'яті квадратних Літтлер, який має у в ньому.

112
00:09:45,010 --> 00:09:53,370
Коли я повернуся, і у, я повертаю покажчик на цей невеликий блок пам'яті.

113
00:09:53,370 --> 00:09:58,400
Але потім, коли функція повертається, його стек отримує стека.

114
00:10:01,050 --> 00:10:03,530
І саме тому вона називається стеком.

115
00:10:03,530 --> 00:10:06,570
Це як структури даних стека, якщо ви знаєте, що це таке.

116
00:10:06,570 --> 00:10:11,580
Або навіть як стек лотків завжди, наприклад,

117
00:10:11,580 --> 00:10:16,060
Основними збирається піти на дно, то перша функція ви дзвоните збирається піти на вершині, що,

118
00:10:16,060 --> 00:10:20,400
і ви не можете повернутися на головну, поки не повернетеся зі всіх функцій, які були покликані

119
00:10:20,400 --> 00:10:22,340
, Які були розміщені на ньому.

120
00:10:22,340 --> 00:10:28,650
>> [Студент] Так що якщо ви робили повернутися і у, що вартість може бути змінена без попереднього повідомлення.

121
00:10:28,650 --> 00:10:31,290
Так, it's - >> [студент] Це може бути переписана. >> Да.

122
00:10:31,290 --> 00:10:34,660
Це повністю - Якщо ви спробуєте -

123
00:10:34,660 --> 00:10:38,040
Це також було б Int бар *, тому що це повертає покажчик,

124
00:10:38,040 --> 00:10:41,310
так що його повернення типу Int *.

125
00:10:41,310 --> 00:10:46,500
Якщо ви спробуєте використовувати повернене значення цієї функції, це невизначене поведінку

126
00:10:46,500 --> 00:10:51,770
тому що покажчик вказує на погану пам'ять. >> [Студент] Добре.

127
00:10:51,770 --> 00:11:01,250
Так що, якщо, наприклад, ви заявили Int * у = Танос (SizeOf (INT))?

128
00:11:01,250 --> 00:11:03,740
Так-то краще. Так.

129
00:11:03,740 --> 00:11:07,730
[Студент] Ми говорили про те, коли ми перетягнути речі в наші кошики

130
00:11:07,730 --> 00:11:11,750
вони насправді не стираються, ми просто втрачають свої покажчики.

131
00:11:11,750 --> 00:11:15,550
Тому в даному випадку ми насправді видалити значення або це ще там, у пам'яті?

132
00:11:15,550 --> 00:11:19,130
Здебільшого, це буде ще буде там.

133
00:11:19,130 --> 00:11:24,220
Але, припустимо, ми, трапляється, називають деякі інші функції, Баз.

134
00:11:24,220 --> 00:11:28,990
База збирається отримати свій фрейм стеку тут.

135
00:11:28,990 --> 00:11:31,470
Це буде перезаписувати всі ці речі,

136
00:11:31,470 --> 00:11:34,180
, А потім, якщо ви пізніше спробувати використовувати покажчик, який ви отримали раніше,

137
00:11:34,180 --> 00:11:35,570
це не буде те ж значення.

138
00:11:35,570 --> 00:11:38,150
Це буде змінилися тільки тому, що ви викликали функцію Баз.

139
00:11:38,150 --> 00:11:43,080
[Студент] Але якщо б ми не, ми б досі отримати 3?

140
00:11:43,080 --> 00:11:44,990
[Боуден] По всій імовірності, ви б.

141
00:11:44,990 --> 00:11:49,670
Але ви не можете покладатися на це. C просто говорить невизначений поведінку.

142
00:11:49,670 --> 00:11:51,920
>> [Студент] О, це так. Добре.

143
00:11:51,920 --> 00:11:58,190
Отже, коли ви хочете повернути покажчик, це де Танос приходить у використанні.

144
00:12:00,930 --> 00:12:15,960
Я пишу насправді просто повернути Танос (3 * SizeOf (INT)).

145
00:12:17,360 --> 00:12:24,050
Ми пройдемося по Танос ще в секунду, але ідея Танос це все локальні змінні

146
00:12:24,050 --> 00:12:26,760
завжди йдуть в стек.

147
00:12:26,760 --> 00:12:31,570
Нічого, що malloced йде по купі, і він буде вічно і завжди бути в купі

148
00:12:31,570 --> 00:12:34,490
поки ви явно звільнити його.

149
00:12:34,490 --> 00:12:42,130
Таким чином, це означає, що коли ви Танос щось, вона збирається вижити після повернення з функції.

150
00:12:42,130 --> 00:12:46,800
[Студент] Чи буде вона вижити після того, як програма зупиняється? >> Ні.

151
00:12:46,800 --> 00:12:53,180
Гаразд, так що це буде там, поки програма повністю не зробив роботу. >> Да.

152
00:12:53,180 --> 00:12:57,510
Ми можемо піти на деталі того, що відбувається, коли програма зупиняється.

153
00:12:57,510 --> 00:13:02,150
Вам може знадобитися, щоб нагадати мені, але це окрема річ цілком.

154
00:13:02,150 --> 00:13:04,190
[Студент] Так Танос створює покажчик? >> Да.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [студент] Я думаю, що Танос позначає блок пам'яті, який можна використовувати в якості покажчика.

156
00:13:15,400 --> 00:13:19,610
[Боуден] Я хочу, щоб схема знову. >> [Студент] Таким чином, ця функція працює, правда?

157
00:13:19,610 --> 00:13:26,430
[Студент] Так, Танос позначає блок пам'яті, який можна використовувати,

158
00:13:26,430 --> 00:13:30,470
а потім повертає адресу першого блоку цієї пам'яті.

159
00:13:30,470 --> 00:13:36,750
>> [Боуден] Так. Отже, коли ви Танос, ви захоплення деяких блок пам'яті

160
00:13:36,750 --> 00:13:38,260
що в даний час в купі.

161
00:13:38,260 --> 00:13:43,040
Якщо купа занадто мало, то купа всього буде рости, і воно росте в цьому напрямку.

162
00:13:43,040 --> 00:13:44,650
Так скажімо, купа занадто мала.

163
00:13:44,650 --> 00:13:49,960
Тоді мова йде про рости трохи, і повертає покажчик на цей блок тільки росла.

164
00:13:49,960 --> 00:13:55,130
Коли Ви безкоштовно речі, ви робите більше місця в купі,

165
00:13:55,130 --> 00:14:00,030
так, то пізніше подзвонити в Танос може використовувати цю пам'ять, що раніше ви вже звільнені.

166
00:14:00,030 --> 00:14:09,950
Головне про Танос і безкоштовно, що вона дає вам повний контроль

167
00:14:09,950 --> 00:14:12,700
протягом терміну служби цих блоків пам'яті.

168
00:14:12,700 --> 00:14:15,420
Глобальні змінні завжди жива.

169
00:14:15,420 --> 00:14:18,500
Локальні змінні живі в межах своєї компетенції.

170
00:14:18,500 --> 00:14:22,140
Як тільки ви йдете повз фігурною дужкою, локальні змінні мертві.

171
00:14:22,140 --> 00:14:28,890
Malloced пам'ять жива, коли ви хочете, щоб він живий

172
00:14:28,890 --> 00:14:33,480
, А потім вивільняється, коли ви сказати, що це повинен бути звільнений.

173
00:14:33,480 --> 00:14:38,420
Ті, насправді є тільки 3 типів пам'яті, насправді.

174
00:14:38,420 --> 00:14:41,840
Там в автоматичне керування пам'яттю, яка є стек.

175
00:14:41,840 --> 00:14:43,840
Все відбувається автоматично.

176
00:14:43,840 --> 00:14:46,910
Коли ви говорите Int х, пам'яті виділяється для внутр х.

177
00:14:46,910 --> 00:14:51,630
При х виходить з області видимості, пам'ять буде утилізований для х.

178
00:14:51,630 --> 00:14:54,790
Тоді є динамічне управління пам'яттю, що і Танос є,

179
00:14:54,790 --> 00:14:56,740
який є, коли у вас є контроль.

180
00:14:56,740 --> 00:15:01,290
Ви динамічно вирішити, коли пам'ять повинна і не повинна бути виділена.

181
00:15:01,290 --> 00:15:05,050
А тут ще статичні, який просто означає, що він живе вічно,

182
00:15:05,050 --> 00:15:06,610
що і глобальні змінні.

183
00:15:06,610 --> 00:15:10,240
Вони просто завжди в пам'яті.

184
00:15:10,960 --> 00:15:12,760
>> Питання?

185
00:15:14,490 --> 00:15:17,230
[Студент] Чи можете ви визначити блок тільки за допомогою фігурних дужок

186
00:15:17,230 --> 00:15:21,220
але не того, щоб мати, якщо заяву або заяву під час або щось в цьому роді?

187
00:15:21,220 --> 00:15:29,130
Ви можете визначити блок, як у функції, але це не має фігурні дужки теж.

188
00:15:29,130 --> 00:15:32,100
[Студент] Таким чином, ви не можете просто як випадкові пара фігурних дужок в коді

189
00:15:32,100 --> 00:15:35,680
, Які мають локальні змінні? >> Так, можна.

190
00:15:35,680 --> 00:15:45,900
Усередині Int барі ми могли б мати {INT у = 3;}.

191
00:15:45,900 --> 00:15:48,440
Це повинно бути тут.

192
00:15:48,440 --> 00:15:52,450
Але це повністю визначає сферу Int у.

193
00:15:52,450 --> 00:15:57,320
Після того, що другий фігурною дужкою, у не може бути використана більше.

194
00:15:57,910 --> 00:16:00,630
Ви майже ніколи не роблять цього, хоча.

195
00:16:02,940 --> 00:16:07,370
Повертаючись до того, що відбувається, коли програма закінчується,

196
00:16:07,370 --> 00:16:18,760
там ніби оману / половина брехня, що ми даємо для того, щоб просто зробити речі простіше.

197
00:16:18,760 --> 00:16:24,410
Ми говоримо вам, що, коли ви виділити пам'ять

198
00:16:24,410 --> 00:16:29,860
Ви виділенні деяких шматок оперативної пам'яті для цієї змінної.

199
00:16:29,860 --> 00:16:34,190
Але ви дійсно не торкаючись безпосередньо RAM все у ваших програмах.

200
00:16:34,190 --> 00:16:37,490
Якщо ви думаєте про це, як я намалював -

201
00:16:37,490 --> 00:16:44,330
А насправді, якщо ви проходите в GDB ви побачите те ж саме.

202
00:16:51,120 --> 00:16:57,590
Незалежно від того, скільки разів ви запустите програму або якою програмою ви працюєте,

203
00:16:57,590 --> 00:16:59,950
Стек завжди збирається почати -

204
00:16:59,950 --> 00:17:06,510
Ви завжди побачите змінні навколо адресу щось oxbffff.

205
00:17:06,510 --> 00:17:09,470
Це, як правило, десь в цьому регіоні.

206
00:17:09,470 --> 00:17:18,760
Але як 2 програми можливо мати покажчики на ту ж пам'ять?

207
00:17:20,640 --> 00:17:27,650
[Студент] Там деякі довільні позначення, де oxbfff повинна бути на RAM

208
00:17:27,650 --> 00:17:31,320
які дійсно можуть знаходитися в різних місцях, в залежності від того, коли функція була викликана.

209
00:17:31,320 --> 00:17:35,920
Так. Цей термін є віртуальної пам'яті.

210
00:17:35,920 --> 00:17:42,250
Ідея полягає в тому, що кожен процес, кожна програма, яка працює на вашому комп'ютері

211
00:17:42,250 --> 00:17:49,450
має свою власну - припустимо, 32 біт - повністю незалежна адресного простору.

212
00:17:49,450 --> 00:17:51,590
Це адресний простір.

213
00:17:51,590 --> 00:17:56,220
Він має свій власний повністю незалежними 4 гігабайти у використанні.

214
00:17:56,220 --> 00:18:02,220
>> Так що якщо ви запустите 2 програми одночасно, ця програма бачить 4 гігабайти до себе,

215
00:18:02,220 --> 00:18:04,870
ця програма бачить 4 гігабайти до себе,

216
00:18:04,870 --> 00:18:07,720
і неможливо для цієї програми разименовать покажчик

217
00:18:07,720 --> 00:18:10,920
і в підсумку пам'яті з цієї програми.

218
00:18:10,920 --> 00:18:18,200
І те, що віртуальна пам'ять є відображенням з адресного простору процесу

219
00:18:18,200 --> 00:18:20,470
фактичних речей на пам'ять.

220
00:18:20,470 --> 00:18:22,940
Так що до вашій операційній системі знати, що,

221
00:18:22,940 --> 00:18:28,080
агов, коли цей покажчик хлопець разименовивает oxbfff, що насправді означає

222
00:18:28,080 --> 00:18:31,040
що він хоче байт RAM 1000,

223
00:18:31,040 --> 00:18:38,150
а якщо це oxbfff програми разименовивает, що він дійсно хоче байт RAM 10000.

224
00:18:38,150 --> 00:18:41,590
Вони можуть бути як завгодно далеко один від одного.

225
00:18:41,590 --> 00:18:48,730
Це вірно навіть речі в одному адресному просторі процесу.

226
00:18:48,730 --> 00:18:54,770
Так як він бачить всі 4 гігабайти до себе, але, скажімо -

227
00:18:54,770 --> 00:18:57,290
[Студент] Чи кожен процес -

228
00:18:57,290 --> 00:19:01,350
Скажімо, у вас є комп'ютер з 4 гігабайтами оперативної пам'яті.

229
00:19:01,350 --> 00:19:06,430
Чи має кожен процес побачити цілих 4 гігабайти? >> Да.

230
00:19:06,430 --> 00:19:13,060
Але 4 гігабайти він бачить це брехня.

231
00:19:13,060 --> 00:19:20,460
Це просто він думає, що все це має пам'яті, тому що він не знає, і будь-який інший процес існує.

232
00:19:20,460 --> 00:19:28,140
Він буде використовувати тільки стільки пам'яті, скільки насправді потрібно.

233
00:19:28,140 --> 00:19:32,340
Операційна система не дасть RAM в цей процес

234
00:19:32,340 --> 00:19:35,750
якщо він не використовує пам'ять у всій цій області.

235
00:19:35,750 --> 00:19:39,300
Це не збираюся дати йому пам'ять для цього регіону.

236
00:19:39,300 --> 00:19:54,780
Але ідея в тому, що - я намагаюся думати - я не можу думати про аналогія.

237
00:19:54,780 --> 00:19:56,780
Аналогії важко.

238
00:19:57,740 --> 00:20:02,700
Одне з питань, віртуальної пам'яті, або одна з речей, це рішення

239
00:20:02,700 --> 00:20:06,810
є те, що процеси повинні бути в повному невіданні один від одного.

240
00:20:06,810 --> 00:20:12,140
І таким чином, ви можете написати будь-яку програму, яка просто разименовивает будь покажчик,

241
00:20:12,140 --> 00:20:19,340
хотів просто написати програму, яка говорить * (ox1234),

242
00:20:19,340 --> 00:20:22,890
і це разименованія адресу пам'яті 1234.

243
00:20:22,890 --> 00:20:28,870
>> Але це до операційної системи, щоб потім перевести те, що 1234 кошти.

244
00:20:28,870 --> 00:20:33,960
Так, якщо 1234 виявиться дійсну адресу пам'яті для цього процесу,

245
00:20:33,960 --> 00:20:38,800
як він в стек або щось, то це буде повертати значення даного адреси пам'яті

246
00:20:38,800 --> 00:20:41,960
Що стосується процесу знає.

247
00:20:41,960 --> 00:20:47,520
Але якщо 1234 не є дійсною адресою, як це відбувається на землю

248
00:20:47,520 --> 00:20:52,910
У деяких маленький шматочок пам'яті тут, що виходить за межі стека і купи

249
00:20:52,910 --> 00:20:57,200
і ви дійсно не використовували це, то що, коли ви отримуєте щось на зразок сегментації

250
00:20:57,200 --> 00:21:00,260
тому що ти торкаєшся пам'яті, які ви не повинні стосуватися.

251
00:21:07,180 --> 00:21:09,340
Це також вірно -

252
00:21:09,340 --> 00:21:15,440
32-бітова система, 32 біт означає, що у вас є 32 біта для визначення адреси пам'яті.

253
00:21:15,440 --> 00:21:22,970
Ось чому покажчиків 8 байт, оскільки 32 біт 8 байт - або 4 байт.

254
00:21:22,970 --> 00:21:25,250
Покажчики 4 байт.

255
00:21:25,250 --> 00:21:33,680
Тому, коли ви бачите покажчик, як oxbfffff, тобто -

256
00:21:33,680 --> 00:21:40,080
У будь даної програми ви можете просто побудувати будь-який довільний покажчик,

257
00:21:40,080 --> 00:21:46,330
в будь-якому місці від Ох0 ОХ 8 f's - FFFFFFFF.

258
00:21:46,330 --> 00:21:49,180
[Студент] Хіба ви не кажете, що вони 4 байти? >> Да.

259
00:21:49,180 --> 00:21:52,730
[Студент] Тоді кожен байт буде - >> [Боуден] Шістнадцяткові.

260
00:21:52,730 --> 00:21:59,360
Шістнадцяткові - 5, 6, 7, 8. Так покажчиків ви будете завжди бачити в шістнадцятковому вигляді.

261
00:21:59,360 --> 00:22:01,710
Це просто, як ми класифікуємо покажчиків.

262
00:22:01,710 --> 00:22:05,240
Кожні 2 цифри шістнадцятковій 1 байт.

263
00:22:05,240 --> 00:22:09,600
Так що це буде 8 шістнадцятирічних цифр на 4 байти.

264
00:22:09,600 --> 00:22:14,190
Таким чином, кожен покажчик на 32-бітної системі буде 4 байти,

265
00:22:14,190 --> 00:22:18,550
Це означає, що у вашому процесі можна побудувати будь-який довільний 4 байти

266
00:22:18,550 --> 00:22:20,550
і зробити покажчик з нього,

267
00:22:20,550 --> 00:22:32,730
Це означає, що, наскільки він знає, він може звернутися ціла 2 до 32 байт пам'яті.

268
00:22:32,730 --> 00:22:34,760
Навіть якщо це насправді не мають доступу до цієї,

269
00:22:34,760 --> 00:22:40,190
навіть якщо ваш комп'ютер має тільки 512 мегабайт, він думає, що він має багато пам'яті.

270
00:22:40,190 --> 00:22:44,930
І операційна система досить розумна, що вона буде тільки виділити те, що вам дійсно потрібно.

271
00:22:44,930 --> 00:22:49,630
Це не просто йти, ой, новий процес: 4 концертів.

272
00:22:49,630 --> 00:22:51,930
>> Так. >> [Студент] Що бик значить? Чому ви пишете?

273
00:22:51,930 --> 00:22:54,980
Це просто символ шістнадцятковій.

274
00:22:54,980 --> 00:22:59,590
Коли ви бачите номер починається з бика, послідовні речі шістнадцяткове.

275
00:23:01,930 --> 00:23:05,760
[Студент] Ви були пояснити, що відбувається, коли програма закінчується. >> Да.

276
00:23:05,760 --> 00:23:09,480
Що відбувається, коли програма закінчується являє собою операційну систему

277
00:23:09,480 --> 00:23:13,600
просто стирає відображень, що вона має для цих адрес, ось і все.

278
00:23:13,600 --> 00:23:17,770
В якості операційної системи тепер можна просто дати, що пам'ять у іншій програмі використовувати.

279
00:23:17,770 --> 00:23:19,490
[Студент] Добре.

280
00:23:19,490 --> 00:23:24,800
Отже, коли ви виділити щось у купі або в стеці або глобальні змінні або що-небудь,

281
00:23:24,800 --> 00:23:27,010
всі вони просто зникають, як тільки програма закінчується

282
00:23:27,010 --> 00:23:32,120
, Оскільки операційна система тепер може дати, що пам'ять для будь-якого іншого процесу.

283
00:23:32,120 --> 00:23:35,150
[Студент] Навіть якщо Є, ймовірно, ще значення написані на? >> Да.

284
00:23:35,150 --> 00:23:37,740
Значення, ймовірно, все ще там.

285
00:23:37,740 --> 00:23:41,570
Це просто, що це буде важко отримати на них.

286
00:23:41,570 --> 00:23:45,230
Це набагато важче отримати на них, ніж це, щоб дістатися до віддалених файлів

287
00:23:45,230 --> 00:23:51,450
тому що віддалений файл виду сидить там протягом довгого часу і жорсткого диска набагато більше.

288
00:23:51,450 --> 00:23:54,120
Таким чином, він збирається переписати різних частинах пам'яті

289
00:23:54,120 --> 00:23:58,640
перш ніж це відбудеться, щоб замінити шматок пам'яті, що файл, використовуваний щоб бути в.

290
00:23:58,640 --> 00:24:04,520
Але основний пам'яті, RAM, ви циклу через багато швидше,

291
00:24:04,520 --> 00:24:08,040
так що це буде дуже швидко будуть перезаписані.

292
00:24:10,300 --> 00:24:13,340
Питання на цю або щось ще?

293
00:24:13,340 --> 00:24:16,130
[Студент] У мене є питання про іншої теми. >> Добре.

294
00:24:16,130 --> 00:24:19,060
Хто-небудь є питання з цього приводу?

295
00:24:20,170 --> 00:24:23,120
>> Добре. Різні теми. >> [Студент] Добре.

296
00:24:23,120 --> 00:24:26,550
Я йшов через деякі практичні тести,

297
00:24:26,550 --> 00:24:30,480
і в одній з них він говорив про SizeOf

298
00:24:30,480 --> 00:24:35,630
і значення, яке вона повертає або різних типів змінних. >> Да.

299
00:24:35,630 --> 00:24:45,060
І він сказав, що обидва Int і довго, як повернення 4, так що вони обидва 4 байти.

300
00:24:45,060 --> 00:24:48,070
Чи є різниця між Int і довго, або це одне і те ж?

301
00:24:48,070 --> 00:24:50,380
Так, є різниця.

302
00:24:50,380 --> 00:24:52,960
C стандарт -

303
00:24:52,960 --> 00:24:54,950
Я, ймовірно, буде безлад.

304
00:24:54,950 --> 00:24:58,800
C стандарт просто подобається те, що C є офіційна документація C.

305
00:24:58,800 --> 00:25:00,340
Це те, що він говорить.

306
00:25:00,340 --> 00:25:08,650
Таким чином, C стандартна просто говорить, що символ буде вічно і завжди буде 1 байт.

307
00:25:10,470 --> 00:25:19,040
Все, після цього - короткий завжди просто визначити як більше або дорівнює символ.

308
00:25:19,040 --> 00:25:23,010
Це може бути строго більше, але не позитивно.

309
00:25:23,010 --> 00:25:31,940
Int просто визначається як більше або дорівнює короткий.

310
00:25:31,940 --> 00:25:36,210
І довго просто визначається як більшу або рівну Int.

311
00:25:36,210 --> 00:25:41,600
І довго довго, більше або дорівнює довго.

312
00:25:41,600 --> 00:25:46,610
Так що єдине, C стандарт визначає відносний порядок у всьому.

313
00:25:46,610 --> 00:25:54,880
Фактичний обсяг пам'яті, що речі займають, як правило, до реалізації,

314
00:25:54,880 --> 00:25:57,640
але він дуже добре визначена в цій точці. >> [Студент] Добре.

315
00:25:57,640 --> 00:26:02,490
Таким чином, шорти майже завжди буде 2 байти.

316
00:26:04,920 --> 00:26:09,950
Ints майже завжди буде 4 байт.

317
00:26:12,070 --> 00:26:15,340
Довгі довгі, майже завжди буде 8 байт.

318
00:26:17,990 --> 00:26:23,160
І мріє, це залежить від того, чи використовується 32-бітні або 64-бітові системи.

319
00:26:23,160 --> 00:26:27,450
Так довго буде відповідати типу системи.

320
00:26:27,450 --> 00:26:31,920
Якщо ви використовуєте 32-розрядну систему, як Appliance, це буде 4 байт.

321
00:26:34,530 --> 00:26:42,570
Якщо ви використовуєте 64-розрядну, як багато останніх комп'ютерах, це буде 8 байт.

322
00:26:42,570 --> 00:26:45,230
>> Ints майже завжди 4 байти в цій точці.

323
00:26:45,230 --> 00:26:47,140
Довгі довгі, майже завжди 8 байт.

324
00:26:47,140 --> 00:26:50,300
У минулому цілі використані тільки бути 2 байти.

325
00:26:50,300 --> 00:26:56,840
Але зверніть увагу, що це повністю задовольняє всі ці стосунки більше і дорівнює.

326
00:26:56,840 --> 00:27:01,280
До тих пір, прекрасно дозволено бути такого ж розміру, як ціле,

327
00:27:01,280 --> 00:27:04,030
і це також дозволено мати той же розмір, як довго довго.

328
00:27:04,030 --> 00:27:11,070
І так вже трапляється, що в 99,999% систем, буде рівна

329
00:27:11,070 --> 00:27:15,800
або Int або довгий довго. Це залежить тільки від 32-бітної або 64-бітної. >> [Студент] Добре.

330
00:27:15,800 --> 00:27:24,600
У поплавці, яким десяткової крапки, позначеної в плані біт?

331
00:27:24,600 --> 00:27:27,160
Ніби як бінарний? >> Да.

332
00:27:27,160 --> 00:27:30,570
Вам не потрібно знати, що для CS50.

333
00:27:30,570 --> 00:27:32,960
Ви навіть не дізнаєтеся, що в 61.

334
00:27:32,960 --> 00:27:37,350
Ви не дізнаєтеся, що дійсно в будь-який курс.

335
00:27:37,350 --> 00:27:42,740
Це просто уявлення.

336
00:27:42,740 --> 00:27:45,440
Я забув точне наділи небагато.

337
00:27:45,440 --> 00:27:53,380
Ідея з плаваючою точкою є те, що ви виділити певну кількість біт для представлення -

338
00:27:53,380 --> 00:27:56,550
В принципі, все в науковій нотації.

339
00:27:56,550 --> 00:28:05,600
Таким чином, ви виділити певну кількість біт для представлення самого числа, як і 1.2345.

340
00:28:05,600 --> 00:28:10,200
Я ніколи не можуть представляти числа із більш ніж 5 цифр.

341
00:28:12,200 --> 00:28:26,300
Після цього ви також виділити певну кількість бітів, так що він прагне бути схожим на

342
00:28:26,300 --> 00:28:32,810
Ви можете йти тільки до певного числа, як і найбільший показника ви можете мати,

343
00:28:32,810 --> 00:28:36,190
і ви можете йти тільки до певного показника,

344
00:28:36,190 --> 00:28:38,770
як це найменший показник ви можете мати.

345
00:28:38,770 --> 00:28:44,410
>> Я не пам'ятаю точно біти шляху призначаються на всі ці цінності,

346
00:28:44,410 --> 00:28:47,940
але певна кількість бітів присвячений 1.2345,

347
00:28:47,940 --> 00:28:50,930
інший певну кількість бітів призначені для експоненти,

348
00:28:50,930 --> 00:28:55,670
і це тільки можна уявити показником певного розміру.

349
00:28:55,670 --> 00:29:01,100
[Студент] і подвійний? Хіба що, як і подовжені поплавок? >> Да.

350
00:29:01,100 --> 00:29:07,940
Це те ж саме, як поплавок тільки тепер ви використовуєте 8 байт замість 4 байт.

351
00:29:07,940 --> 00:29:11,960
Тепер ви зможете використовувати 9 цифр або 10 цифр,

352
00:29:11,960 --> 00:29:16,630
і це буде в змозі піти до 300 замість 100. >> [Студент] Добре.

353
00:29:16,630 --> 00:29:21,550
І поплавки також 4 байти. >> Да.

354
00:29:21,550 --> 00:29:27,520
Ну, знову ж таки, це, ймовірно, залежить в цілому на загальну реалізацію,

355
00:29:27,520 --> 00:29:30,610
але поплавці 4 байти, двомісні є 8.

356
00:29:30,610 --> 00:29:33,440
Парний називаються подвійними, тому що вони в два рази поплавців.

357
00:29:33,440 --> 00:29:38,380
[Студент] Добре. І є подвійне подвоює? >> Є не так.

358
00:29:38,380 --> 00:29:43,660
Я думаю - >> [студент] Як довго тужить? >> Да. Не думаю. Так.

359
00:29:43,660 --> 00:29:45,950
[Студент] На тесті у минулому році там було питання про основну функції

360
00:29:45,950 --> 00:29:49,490
того, щоб бути частиною вашої програми.

361
00:29:49,490 --> 00:29:52,310
Відповідь була, що вона не повинна бути частиною вашої програми.

362
00:29:52,310 --> 00:29:55,100
В якій ситуації? Це те, що я бачив.

363
00:29:55,100 --> 00:29:59,090
[Боуден] Здається - >> [студент] Яка ситуація?

364
00:29:59,090 --> 00:30:02,880
Чи є у вас проблеми? >> [Студент] Так, я можу виразно потягніть його вгору.

365
00:30:02,880 --> 00:30:07,910
Це не повинні бути технічно, але в основному це буде.

366
00:30:07,910 --> 00:30:10,030
[Студент] Я бачив одного на інший рік.

367
00:30:10,030 --> 00:30:16,220
Це було схоже Вірно чи ні: дійсно - >> О, з файлом.?

368
00:30:16,220 --> 00:30:18,790
. [Студент] Будь С файл повинен мати - [як каже відразу - нерозбірливо]

369
00:30:18,790 --> 00:30:21,120
Добре. Так от окремо.

370
00:30:21,120 --> 00:30:26,800
>> . C файл, просто повинен містити функцій.

371
00:30:26,800 --> 00:30:32,400
Ви можете скомпілювати файл в машинний код, двійковий, що завгодно,

372
00:30:32,400 --> 00:30:36,620
без його виконуваним ще немає.

373
00:30:36,620 --> 00:30:39,420
Дійсний виконуваний файл повинен мати основну функцію.

374
00:30:39,420 --> 00:30:45,460
Ви можете написати 100 функцій в 1 файл, але не основна

375
00:30:45,460 --> 00:30:48,800
, А потім скомпілювати, що аж до двійковий,

376
00:30:48,800 --> 00:30:54,460
Потім ви пишете інший файл, який має тільки головною, але вона викликає купу цих функцій

377
00:30:54,460 --> 00:30:56,720
У цей двійковий файл тут.

378
00:30:56,720 --> 00:31:01,240
І тому, коли ви робите виконуваний файл, ось що робить компонувальник

379
00:31:01,240 --> 00:31:05,960
воно поєднує в собі ці 2 двійкових файлів у виконуваний файл.

380
00:31:05,960 --> 00:31:11,400
Так. У файлі не повинно бути основною функцією на всіх.

381
00:31:11,400 --> 00:31:19,220
І на великих базах коду ви побачите тисячі. Файли з і 1 головний файл.

382
00:31:23,960 --> 00:31:26,110
Ще питання?

383
00:31:29,310 --> 00:31:31,940
[Студент] Існував ще одне питання.

384
00:31:31,940 --> 00:31:36,710
Він сказав, зробити це компілятор. Правда чи Брехня?

385
00:31:36,710 --> 00:31:42,030
І відповідь була помилковою, і я зрозумів, чому це не так, як Clang.

386
00:31:42,030 --> 00:31:44,770
Але те, що ми називаємо зробити, якщо це не так?

387
00:31:44,770 --> 00:31:49,990
Зробити це в основному просто - я бачу саме те, що він це називає.

388
00:31:49,990 --> 00:31:52,410
Але це тільки виконує команди.

389
00:31:53,650 --> 00:31:55,650
Зробити.

390
00:31:58,240 --> 00:32:00,870
Я можу потягнути це. Так.

391
00:32:10,110 --> 00:32:13,180
О, так. Переконайтеся також, що робить.

392
00:32:13,180 --> 00:32:17,170
Це говорить про мету марку утиліта для автоматичного визначення

393
00:32:17,170 --> 00:32:19,610
які частини великої програми повинні бути перекомпілювати

394
00:32:19,610 --> 00:32:22,350
і видає команди потрібні для.

395
00:32:22,350 --> 00:32:27,690
Ви можете зробити файли, які є абсолютно величезне.

396
00:32:27,690 --> 00:32:33,210
Зробити дивиться на штампи часу файлів і, як ми вже говорили,

397
00:32:33,210 --> 00:32:36,930
Ви можете зібрати окремі файли вниз, і це не поки не дійдете до компонувальник

398
00:32:36,930 --> 00:32:39,270
що вони зібрали в виконуваний файл.

399
00:32:39,270 --> 00:32:43,810
Так що якщо у вас є 10 різних файлів, і ви внести зміни в 1 з них,

400
00:32:43,810 --> 00:32:47,870
те, що робить збирається зробити, це просто перекомпиляция, що 1 файл

401
00:32:47,870 --> 00:32:50,640
, А потім повторно зв'язати всі разом.

402
00:32:50,640 --> 00:32:53,020
Але набагато тупіше, ніж це.

403
00:32:53,020 --> 00:32:55,690
Це до вас, щоб повністю визначити, що це те, що він повинен робити.

404
00:32:55,690 --> 00:32:59,560
Це за замовчуванням має здатність розпізнавати цей матеріал штамп часу,

405
00:32:59,560 --> 00:33:03,220
але ви можете написати зробити файл нічого робити.

406
00:33:03,220 --> 00:33:09,150
Ви можете написати зробити файл, так що, коли ви вводите зробити це тільки компакт-диски в інший каталог.

407
00:33:09,150 --> 00:33:15,560
Я розчаровані, тому що я треку усередині всі мої Appliance

408
00:33:15,560 --> 00:33:21,740
а потім переглянути PDF з Mac.

409
00:33:21,740 --> 00:33:30,720
>> Так що я йду в Finder, і я можу дійсно йдете, підключитися до сервера,

410
00:33:30,720 --> 00:33:36,950
і сервер підключитися до моє Appliance, а потім я відкриваю PDF

411
00:33:36,950 --> 00:33:40,190
, Який отримує складений LaTeX.

412
00:33:40,190 --> 00:33:49,320
Але мене спіткало розчарування, тому що кожного разу, коли мені потрібно, щоб оновити PDF,

413
00:33:49,320 --> 00:33:53,900
Мені довелося скопіювати його в певний каталог, що він може отримати доступ до

414
00:33:53,900 --> 00:33:57,710
і це ставало дратує.

415
00:33:57,710 --> 00:34:02,650
Так що замість цього я написав зробити файл, який ви повинні визначити, як він робить речі.

416
00:34:02,650 --> 00:34:06,130
Як ви робите в цей PDF LaTeX.

417
00:34:06,130 --> 00:34:10,090
Так само, як і будь-який інший файл марки - або я думаю, ви ще не бачили марку файлів,

418
00:34:10,090 --> 00:34:13,510
але у нас є в прилад файл глобальних марки, які просто говорить:

419
00:34:13,510 --> 00:34:16,679
якщо ви компілюєте файл C, використовуйте Clang.

420
00:34:16,679 --> 00:34:20,960
І ось тут, в моїй зробити файл, що я роблю я кажу,

421
00:34:20,960 --> 00:34:25,020
Цей файл ви збираєтеся хочете зібрати з PDF LaTeX.

422
00:34:25,020 --> 00:34:27,889
І таким чином, це PDF LaTeX, що робить компіляцію.

423
00:34:27,889 --> 00:34:31,880
Зробити це не компіляція. Це просто виконання наступних команд в послідовності я вказав.

424
00:34:31,880 --> 00:34:36,110
Таким чином, вона працює PDF LaTeX, він копіює його в каталог, я хочу, щоб бути скопійована,

425
00:34:36,110 --> 00:34:38,270
це компакт-дисків в каталозі і робить інші речі,

426
00:34:38,270 --> 00:34:42,380
але все вона робить, це визнають при зміні файлу,

427
00:34:42,380 --> 00:34:45,489
і якщо він змінюється, то вона буде працювати командами, які він повинен виконати

428
00:34:45,489 --> 00:34:48,760
При зміні файлу. >> [Студент] Добре.

429
00:34:50,510 --> 00:34:54,420
Я не знаю, де глобальні файли зробити для мене, щоб перевірити його.

430
00:34:57,210 --> 00:35:04,290
Інші питання? Все, починаючи від минулих тестів? Будь покажчик речі?

431
00:35:06,200 --> 00:35:08,730
Є тонкі речі з покажчиками, як -

432
00:35:08,730 --> 00:35:10,220
Я не збираюся бути в змозі знайти питання вікторини на ньому -

433
00:35:10,220 --> 00:35:16,250
але, як і такого роду речі.

434
00:35:19,680 --> 00:35:24,060
Переконайтеся, що ви розумієте, що, коли я говорю Int * х * у -

435
00:35:24,890 --> 00:35:28,130
Це не зовсім тут нічого, я думаю.

436
00:35:28,130 --> 00:35:32,140
Але, як і * х * у, ті 2 змінні, які знаходяться на стеку.

437
00:35:32,140 --> 00:35:37,220
Коли я кажу, х = Танос (SizeOf (INT)), х і раніше змінної в стек,

438
00:35:37,220 --> 00:35:41,180
Танос деякий блок більш в купу, і ми має точки х до купи.

439
00:35:41,180 --> 00:35:43,900
>> Так щось в стек вказує на купу.

440
00:35:43,900 --> 00:35:48,100
Всякий раз, коли ви Танос небудь, ви неминуче зберігати його всередині миші.

441
00:35:48,100 --> 00:35:55,940
Так що покажчик на стек, malloced блоку в купі.

442
00:35:55,940 --> 00:36:01,240
Багато людей плутають і говорять Int * х = Танос; х в купу.

443
00:36:01,240 --> 00:36:04,100
Кількість х Що вказує на це в купу.

444
00:36:04,100 --> 00:36:08,540
х сама перебуває в стеку, якщо з якихось причин ви х глобальної змінної,

445
00:36:08,540 --> 00:36:11,960
У цьому випадку він опиняється в іншій області пам'яті.

446
00:36:13,450 --> 00:36:20,820
Таким чином відстежувати ці коробки і стрілочні діаграми є досить загальними для вікторини.

447
00:36:20,820 --> 00:36:25,740
Або, якщо це не тест на 0, це буде на тест 1.

448
00:36:27,570 --> 00:36:31,940
Ви повинні знати все це, кроки в складанні

449
00:36:31,940 --> 00:36:35,740
так як ви повинні були відповісти на запитання на них. Так.

450
00:36:35,740 --> 00:36:38,940
[Студент] Чи можемо ми піти на ці кроки - >> Звичайно.

451
00:36:48,340 --> 00:36:58,640
Перед кроків і складання нас є попередня обробка,

452
00:36:58,640 --> 00:37:16,750
компіляції, збирання та компонування.

453
00:37:16,750 --> 00:37:21,480
Попередня обробка. Що ж це зробити?

454
00:37:29,720 --> 00:37:32,290
Це найпростіший крок у - добре, не подобається -

455
00:37:32,290 --> 00:37:35,770
це не означає, повинно бути очевидним, але це найпростіший крок.

456
00:37:35,770 --> 00:37:38,410
Ви, хлопці могли реалізувати себе. Так.

457
00:37:38,410 --> 00:37:43,410
[Студент] Візьміть те, що у вас є у вашій включає в себе, як це і копіює, а потім і визначає.

458
00:37:43,410 --> 00:37:49,250
Він шукає речі, як # # включають в себе і визначити,

459
00:37:49,250 --> 00:37:53,800
і він просто копіює і вставляє те, що ті насправді означає.

460
00:37:53,800 --> 00:37:59,240
Тому, коли ви говорите # включити cs50.h, препроцесор копіювання і вставки cs50.h

461
00:37:59,240 --> 00:38:01,030
в цій лінії.

462
00:38:01,030 --> 00:38:06,640
Коли ви говорите: # визначити х рівним 4, препроцесор проходить через всю програму

463
00:38:06,640 --> 00:38:10,400
і замінює всі екземпляри х з 4.

464
00:38:10,400 --> 00:38:17,530
Таким чином, препроцесор приймає правильний файл C і видає правильний файл C

465
00:38:17,530 --> 00:38:20,300
, Де речі були скопійовані.

466
00:38:20,300 --> 00:38:24,230
Так що тепер компіляції. Що ж це зробити?

467
00:38:25,940 --> 00:38:28,210
[Студент] Це йде від C в двійковий формат.

468
00:38:28,210 --> 00:38:30,970
>> [Боуден] Це не пройти весь шлях в двійковий формат.

469
00:38:30,970 --> 00:38:34,220
[Студент] в машинний код то? >> Це не машинний код.

470
00:38:34,220 --> 00:38:35,700
[Студент] Асамблеї? >> Асамблеї.

471
00:38:35,700 --> 00:38:38,890
Це йде в Асамблеї перш ніж він йде всю дорогу в код C,

472
00:38:38,890 --> 00:38:45,010
і більшість мов зробити щось на зразок цього.

473
00:38:47,740 --> 00:38:50,590
Виберіть будь мова високого рівня, і якщо ви збираєтеся компілювати його,

474
00:38:50,590 --> 00:38:52,390
це, ймовірно, зібрати в кроках.

475
00:38:52,390 --> 00:38:58,140
Спочатку він збирається скласти Python в C, то це буде для компіляції C Асамблеї,

476
00:38:58,140 --> 00:39:01,600
, А потім Асамблея збирається отримати переклад в двійкову.

477
00:39:01,600 --> 00:39:07,800
Таким чином, складання збирається вивести його з C Асамблеї.

478
00:39:07,800 --> 00:39:12,130
Слово компіляції зазвичай означає приведення його від більш високого рівня

479
00:39:12,130 --> 00:39:14,340
в нижній мова програмування високого рівня.

480
00:39:14,340 --> 00:39:19,190
Так що це тільки крок в компіляції, де ви починаєте з мови високого рівня

481
00:39:19,190 --> 00:39:23,270
і в кінцевому підсумку в мову низького рівня, і тому крок називається компіляцією.

482
00:39:25,280 --> 00:39:33,370
[Студент] Під час компіляції, давайте скажемо, що ви зробили # включити cs50.h.

483
00:39:33,370 --> 00:39:42,190
Чи буде перекомпілювати компілятор cs50.h, як і функції, які там,

484
00:39:42,190 --> 00:39:45,280
, І перевести це в асемблерний код, а також,

485
00:39:45,280 --> 00:39:50,830
або це скопіювати і вставити те, що було попередньо збори?

486
00:39:50,830 --> 00:39:56,910
cs50.h буде майже ніколи не виявляються в Асамблеї.

487
00:39:59,740 --> 00:40:03,680
Речі, як прототипи функцій і речей для вас бути обережними.

488
00:40:03,680 --> 00:40:09,270
Це гарантує, що компілятор може перевірити такі речі, як ви викликаєте функції

489
00:40:09,270 --> 00:40:12,910
з правом типи повернення і правильні аргументи та інше.

490
00:40:12,910 --> 00:40:18,350
>> Так cs50.h буде попередню обробку в файл, а потім, коли це компіляція

491
00:40:18,350 --> 00:40:22,310
це в основному викидаються після того, як переконується, що все, що називають правильно.

492
00:40:22,310 --> 00:40:29,410
Але функції, визначені в CS50 бібліотеки, які є окремими від cs50.h,

493
00:40:29,410 --> 00:40:33,610
тих, хто не буде складена окремо.

494
00:40:33,610 --> 00:40:37,270
Що буде насправді спуститися в стадії компонування, тому ми повернемося до цього в секунду.

495
00:40:37,270 --> 00:40:40,100
Але, по-перше, те, що збірка?

496
00:40:41,850 --> 00:40:44,500
[Студент] асамблеї в двійкову? >> Да.

497
00:40:46,300 --> 00:40:48,190
Збірка.

498
00:40:48,190 --> 00:40:54,710
Ми не називаємо його складання, оскільки Асамблея є в значній мірі чиста перекладу двійкового файлу.

499
00:40:54,710 --> 00:41:00,230
Існує дуже мало логіки в переході від Асамблеї в двійковий формат.

500
00:41:00,230 --> 00:41:03,180
Це все одно, дивлячись у таблицю, ой, у нас є ця інструкція;

501
00:41:03,180 --> 00:41:06,290
, Що відповідає двійковим 01110.

502
00:41:10,200 --> 00:41:15,230
І тому файли, які зборки в цілому виходи. Про файлах.

503
00:41:15,230 --> 00:41:19,020
А. Висновку файлів, що ми говорили раніше,

504
00:41:19,020 --> 00:41:21,570
як файл не потрібно мати основну функцію.

505
00:41:21,570 --> 00:41:27,640
Будь-який файл може бути складений до. Файл виводу тих пір, поки це правильний файл C.

506
00:41:27,640 --> 00:41:30,300
Він може бути складений до. °.

507
00:41:30,300 --> 00:41:43,030
Тепер, пов'язуючи це те, що насправді приносить купу. Про файлах і приводить їх до виконуваного файлу.

508
00:41:43,030 --> 00:41:51,110
І те, що компонування робить, ви можете думати про CS50 бібліотеку. Файл виводу.

509
00:41:51,110 --> 00:41:56,980
Це вже скомпільованих двійкових файлів.

510
00:41:56,980 --> 00:42:03,530
І так при компіляції файлу, ваш hello.c, яка закликає GetString,

511
00:42:03,530 --> 00:42:06,360
hello.c компілюється до hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o в даний час в двійковому вигляді.

513
00:42:08,910 --> 00:42:12,830
Він використовує GetString, тому вона повинна перейти до cs50.o,

514
00:42:12,830 --> 00:42:16,390
і компонувальник smooshes їх разом і копіює GetString в цей файл

515
00:42:16,390 --> 00:42:20,640
і виходить з виконуваного файлу, який має всі функції яких вона потребує.

516
00:42:20,640 --> 00:42:32,620
Так cs50.o насправді не про файл, але це досить близько, що немає ніякої принципової різниці.

517
00:42:32,620 --> 00:42:36,880
Таким чином, зв'язок тільки приносить купу файлів разом

518
00:42:36,880 --> 00:42:41,390
що окремо містять всі функції мені потрібно використовувати

519
00:42:41,390 --> 00:42:46,120
і створює виконуваний файл, який буде реально працювати.

520
00:42:48,420 --> 00:42:50,780
>> І таким чином, це також те, що ми говорили до

521
00:42:50,780 --> 00:42:55,970
де ви можете мати 1000. с файлами, ви зібрати їх усі. про файли,

522
00:42:55,970 --> 00:43:00,040
який, ймовірно, займе деякий час, то ви зміните 1. с файлом.

523
00:43:00,040 --> 00:43:05,480
Вам тільки потрібно перекомпілювати, що 1. С файлу, а потім перелінковки все інше,

524
00:43:05,480 --> 00:43:07,690
зв'язати всі разом.

525
00:43:09,580 --> 00:43:11,430
[Студент] Коли ми пишемо зв'язку lcs50?

526
00:43:11,430 --> 00:43:20,510
Так, так lcs50. Цей прапор сигнали в компонувальник, що ви повинні зв'язків в цій бібліотеці.

527
00:43:26,680 --> 00:43:28,910
Питання?

528
00:43:41,310 --> 00:43:46,860
Хіба ми перейшли двійковій інші, ніж 5 секунд в першій лекції?

529
00:43:50,130 --> 00:43:53,010
Не думаю.

530
00:43:55,530 --> 00:43:58,820
Ви повинні знати все більшу Os, що ми перейшли,

531
00:43:58,820 --> 00:44:02,670
і ви повинні бути в змозі, якби ми дали вам функції,

532
00:44:02,670 --> 00:44:09,410
Ви повинні бути в змозі сказати, що це велика O, грубо. Або ж, Big O є приблизними.

533
00:44:09,410 --> 00:44:15,300
Так що якщо ви бачите, вкладені цикли цикли в порівнянні з аналогічною кількістю речей,

534
00:44:15,300 --> 00:44:22,260
Int, як я, я <п; Int J, J <п - >> [студент] п квадрат. >> Він має тенденцію бути вказаний в квадраті.

535
00:44:22,260 --> 00:44:25,280
Якщо ви потрійний вкладений, він, як правило, п кубі.

536
00:44:25,280 --> 00:44:29,330
Так що такого роду речі ви повинні бути в змозі вказати відразу.

537
00:44:29,330 --> 00:44:33,890
Ви повинні знати, роду вставки і бульбашкового сортування та сортування злиттям, і всі з них.

538
00:44:33,890 --> 00:44:41,420
Це легше зрозуміти, чому вони є п квадратів і п § п і все, що

539
00:44:41,420 --> 00:44:47,810
тому що я думаю, що була на тест один рік, де ми в основному дав вам

540
00:44:47,810 --> 00:44:55,050
здійснення бульбашкового сортування і сказав: "Що таке час роботи цієї функції?"

541
00:44:55,050 --> 00:45:01,020
Так що якщо ви визнаєте це, як бульбашкового сортування, то ви можете відразу сказати, п квадрат.

542
00:45:01,020 --> 00:45:05,470
Але якщо ви просто подивіться на неї, вам навіть не потрібно усвідомити, що це бульбашкового сортування;

543
00:45:05,470 --> 00:45:08,990
Ви можете просто сказати, що це робити це і це. Це п квадрат.

544
00:45:12,350 --> 00:45:14,710
[Студент] Чи існують які-небудь жорсткі приклади, які ви можете придумати,

545
00:45:14,710 --> 00:45:20,370
як аналогічна ідея з'ясувати?

546
00:45:20,370 --> 00:45:24,450
>> Я не думаю, що ми хотіли б дати Вам будь-які жорсткі приклади.

547
00:45:24,450 --> 00:45:30,180
Справа в бульбашкового сортування приблизно так само жорстко, як ми ходили,

548
00:45:30,180 --> 00:45:36,280
і те, як довго, як ви розумієте, що ви ітерації по масиву

549
00:45:36,280 --> 00:45:41,670
Для кожного елемента масиву, який буде щось, що п в квадраті.

550
00:45:45,370 --> 00:45:49,940
Є загальні питання, наприклад, прямо тут, у нас - Oh.

551
00:45:55,290 --> 00:45:58,530
Буквально днями, Дуг заявив: "Я винайшов алгоритм, який може сортувати масив

552
00:45:58,530 --> 00:46:01,780
"П чисел в O (журнал N) раз!"

553
00:46:01,780 --> 00:46:04,900
Отже, як ми знаємо, що це неможливо?

554
00:46:04,900 --> 00:46:08,850
[Нерозбірливо відповідь студента] >> Да.

555
00:46:08,850 --> 00:46:13,710
По крайней мере, ви повинні торкнутися кожного елемента в масиві,

556
00:46:13,710 --> 00:46:16,210
так що це неможливо відсортувати масив -

557
00:46:16,210 --> 00:46:20,850
Якщо все в порядку несортоване, то ви будете стосуватися всі, що в масиві,

558
00:46:20,850 --> 00:46:25,320
так що це неможливо зробити це менш ніж за O н.

559
00:46:27,430 --> 00:46:30,340
[Студент] Ви показали нам, що приклад в змозі зробити це в O п

560
00:46:30,340 --> 00:46:33,920
якщо ви використовуєте багато пам'яті. >> Да.

561
00:46:33,920 --> 00:46:37,970
І that's - Я забув, що that's - Хіба підрахунку роду?

562
00:46:47,360 --> 00:46:51,330
Хм. Це ціле алгоритм сортування.

563
00:46:59,850 --> 00:47:05,100
Я шукав спеціальну назву для цього, що я не міг згадати минулого тижня.

564
00:47:05,100 --> 00:47:13,000
Так. Ці типи видів, які можуть виконати речі у великій O н.

565
00:47:13,000 --> 00:47:18,430
Але є обмеження, як ви можете використовувати тільки цілі числа до певного числа.

566
00:47:20,870 --> 00:47:24,560
Плюс, якщо ви намагаєтеся розібратися щось that's -

567
00:47:24,560 --> 00:47:30,750
Якщо ваш масив 012, -12, 151, 4 млн.

568
00:47:30,750 --> 00:47:35,120
те, що один елемент буде повністю зруйнує весь сортування.

569
00:47:42,060 --> 00:47:44,030
>> Питання?

570
00:47:49,480 --> 00:47:58,870
[Студент] Якщо у вас є рекурсивна функція, і він просто робить рекурсивні виклики

571
00:47:58,870 --> 00:48:02,230
в повернення заяви, що це хвіст рекурсивної,

572
00:48:02,230 --> 00:48:07,360
і так би це не використовувати більше пам'яті під час виконання

573
00:48:07,360 --> 00:48:12,550
або, принаймні, використовувати зіставні пам'яті, як ітераційні рішення?

574
00:48:12,550 --> 00:48:14,530
[Боуден] Так.

575
00:48:14,530 --> 00:48:19,840
Це, ймовірно, буде трохи повільніше, але не зовсім.

576
00:48:19,840 --> 00:48:23,290
Хвіст рекурсивних досить добре.

577
00:48:23,290 --> 00:48:32,640
Дивлячись знову на кадри стека, скажімо, у нас є основний

578
00:48:32,640 --> 00:48:42,920
і у нас є Int бар (INT х) або щось ще.

579
00:48:42,920 --> 00:48:52,310
Це не ідеальний рекурсивної функції, але повернення бар (х - 1).

580
00:48:52,310 --> 00:48:57,620
Таким чином, очевидно, що це помилково. Ви повинні базі випадки та інше.

581
00:48:57,620 --> 00:49:00,360
Але ідея тут в тому, що це хвіст рекурсивної,

582
00:49:00,360 --> 00:49:06,020
що означає, коли головний бар дзвінки він збирається отримати свій стек.

583
00:49:09,550 --> 00:49:12,440
У цьому кадрі стека там буде невеликий блок пам'яті

584
00:49:12,440 --> 00:49:17,490
, Що відповідає її аргументу х.

585
00:49:17,490 --> 00:49:25,840
І так скажемо, основний, трапляється, називають Бар (100);

586
00:49:25,840 --> 00:49:30,050
Таким х збирається почати, як 100.

587
00:49:30,050 --> 00:49:35,660
Якщо компілятор визнає, що це хвіст рекурсивної функції,

588
00:49:35,660 --> 00:49:38,540
Потім, коли бару робить його рекурсивний виклик бар,

589
00:49:38,540 --> 00:49:45,490
замість того, щоб новий кадр стека, який є, де стек починає рости в основному,

590
00:49:45,490 --> 00:49:48,220
в кінцевому підсумку він буде працювати в купу і тоді ви отримаєте помилку сегментації

591
00:49:48,220 --> 00:49:51,590
тому що пам'ять починає зіткнення.

592
00:49:51,590 --> 00:49:54,830
>> Таким чином, замість того, щоб його власний кадр стека, він може реалізувати,

593
00:49:54,830 --> 00:49:59,080
Ей, я ніколи не потрібно повертатися до цього кадру стека,

594
00:49:59,080 --> 00:50:08,040
так замість цього я просто замінити цей аргумент з 99, а потім почати барі на всьому протязі.

595
00:50:08,040 --> 00:50:11,810
І тоді вона буде робити це знову і вона досягне повернення бар (х - 1),

596
00:50:11,810 --> 00:50:17,320
і замість того, щоб новий кадр стека, це буде просто замінити свій поточний аргумент з 98

597
00:50:17,320 --> 00:50:20,740
, А потім перейти до самого початку бар.

598
00:50:23,860 --> 00:50:30,430
Ці операції, замінивши, що 1 значення в стеку і стрибає назад до початку,

599
00:50:30,430 --> 00:50:32,430
досить ефективним.

600
00:50:32,430 --> 00:50:41,500
Так що не тільки ця ж використання пам'яті як окрема функція, яка ітераційного

601
00:50:41,500 --> 00:50:45,390
тому що ви використовуєте тільки 1 кадр стека, але ви не страждаєте мінуси

602
00:50:45,390 --> 00:50:47,240
того, щоб викликати функції.

603
00:50:47,240 --> 00:50:50,240
Виклик функції може бути трохи дорожче, тому що він повинен робити все це установка

604
00:50:50,240 --> 00:50:52,470
і демонтажу та всі ці речі.

605
00:50:52,470 --> 00:50:58,160
Так що цей хвостовій рекурсії добре.

606
00:50:58,160 --> 00:51:01,170
[Студент] Чому не створити нові кроки?

607
00:51:01,170 --> 00:51:02,980
Тому що він розуміє, що це не потрібно.

608
00:51:02,980 --> 00:51:07,800
Виклик бар щойно повернувся рекурсивний виклик.

609
00:51:07,800 --> 00:51:12,220
Так що не потрібно нічого робити з повертаним значенням.

610
00:51:12,220 --> 00:51:15,120
Це просто буде негайно повернути його.

611
00:51:15,120 --> 00:51:20,530
Так що це просто збирається замінити свої аргументи і почати все спочатку.

612
00:51:20,530 --> 00:51:25,780
А також, якщо ви не маєте хвіст рекурсивної версії,

613
00:51:25,780 --> 00:51:31,460
, То ви отримаєте всі ці бари, де, коли цей бар повертається

614
00:51:31,460 --> 00:51:36,010
він повинен повернути його значення в цьому, то, що бар відразу ж повертається

615
00:51:36,010 --> 00:51:39,620
і повертає його значення в цьому, то він просто буде негайно повернутися

616
00:51:39,620 --> 00:51:41,350
і повернути його значення на цьому.

617
00:51:41,350 --> 00:51:45,350
Таким чином, ви економите цього з'являються всі ці речі з стека

618
00:51:45,350 --> 00:51:48,730
З значення, що повертається тільки збирається бути переданий весь шлях назад у будь-якому випадку.

619
00:51:48,730 --> 00:51:55,400
Так чому б не замінити нашу суперечку з оновленим аргумент і почати все спочатку?

620
00:51:57,460 --> 00:52:01,150
Якщо функція не є хвостовою рекурсією, якщо ви робите щось подібне -

621
00:52:01,150 --> 00:52:07,530
[Студент], якщо бар (х + 1). >> Да.

622
00:52:07,530 --> 00:52:11,770
>> Так що, якщо ви помістіть його в стан, то ви робите щось з повертаним значенням.

623
00:52:11,770 --> 00:52:16,260
Або навіть якщо ви просто повернення 2 * бар (х - 1).

624
00:52:16,260 --> 00:52:23,560
Так що тепер бар (х - 1) необхідно повернути для того, щоб обчислити, що в 2 рази значення,

625
00:52:23,560 --> 00:52:26,140
так що тепер він дійсно потребує у своєму власному окремому кадрі стека,

626
00:52:26,140 --> 00:52:31,180
і тепер, як не старайся, ви збираєтеся потрібно -

627
00:52:31,180 --> 00:52:34,410
Це не хвіст рекурсивної.

628
00:52:34,410 --> 00:52:37,590
[Студент] Чи буду я намагатися довести рекурсії прагнути до хвостової рекурсії -

629
00:52:37,590 --> 00:52:41,450
[Боуден] В ідеальному світі, але в CS50 вам не доведеться.

630
00:52:43,780 --> 00:52:49,280
Для того щоб отримати хвостовій рекурсії, загалом, ви створили додатковий аргумент

631
00:52:49,280 --> 00:52:53,550
де бар відбудеться Int х в у

632
00:52:53,550 --> 00:52:56,990
і у відповідає кінцева річ, яку ви хочете повернути.

633
00:52:56,990 --> 00:53:03,650
Так ось це ви будете повертатися бар (х - 1), 2 * у.

634
00:53:03,650 --> 00:53:09,810
Так що це тільки на високому рівні, як ви перетворення речей, щоб бути хвостом рекурсивні.

635
00:53:09,810 --> 00:53:13,790
Але додатковий аргумент -

636
00:53:13,790 --> 00:53:17,410
А потім, в кінці кінців, коли ви досягнете своєї бази випадку, ви просто повернути у

637
00:53:17,410 --> 00:53:22,740
тому що у вас накопичується весь час повертається значення, що ви хочете.

638
00:53:22,740 --> 00:53:27,280
Ви начебто робили це багаторазово, але з використанням рекурсивних викликів.

639
00:53:32,510 --> 00:53:34,900
Питання?

640
00:53:34,900 --> 00:53:39,890
[Студент] Може бути, про арифметику покажчиків, наприклад, при використанні рядків. >> Звичайно.

641
00:53:39,890 --> 00:53:43,610
Покажчик арифметика.

642
00:53:43,610 --> 00:53:48,440
При використанні рядків, що це легко, тому що рядки символів зірки,

643
00:53:48,440 --> 00:53:51,860
символи вічні і завжди один байт,

644
00:53:51,860 --> 00:53:57,540
і так арифметики покажчиків еквівалентно регулярні арифметичних коли ви маєте справу з рядками.

645
00:53:57,540 --> 00:54:08,790
Давайте просто скажемо, символ * S = "привіт".

646
00:54:08,790 --> 00:54:11,430
Отже, ми маємо блок в пам'яті.

647
00:54:19,490 --> 00:54:22,380
Вона потребує 6 байт, тому що ви завжди повинні нулем.

648
00:54:22,380 --> 00:54:28,620
І символ * S буде вказувати на початок цього масиву.

649
00:54:28,620 --> 00:54:32,830
Таким чином, з точок.

650
00:54:32,830 --> 00:54:36,710
Тепер, це в основному, як будь-який масив працює,

651
00:54:36,710 --> 00:54:40,780
незалежно від того, чи було це повернення Танос або це в стеці.

652
00:54:40,780 --> 00:54:47,110
Будь масив в основному покажчик на початок масиву,

653
00:54:47,110 --> 00:54:53,640
і тоді будь-який масив операції, будь індексації, тільки збирається в цей масив певного зміщення.

654
00:54:53,640 --> 00:55:05,360
>> Тому, коли я кажу щось подібне до [3], це буде їй і підрахунок 3 символи дюйма

655
00:55:05,360 --> 00:55:12,490
Таким чином, з [3], ми маємо 0, 1, 2, 3, таким чином, з [3] буде посилатися на цю л.

656
00:55:12,490 --> 00:55:20,460
[Студент] І ми могли б досягти такого ж значення, роблячи з + 3, а потім дужки зірки?

657
00:55:20,460 --> 00:55:22,570
Так.

658
00:55:22,570 --> 00:55:26,010
Це еквівалентно * (S + 3);

659
00:55:26,010 --> 00:55:31,240
і це назавжди і завжди еквівалентні незалежно від того, що ви робите.

660
00:55:31,240 --> 00:55:34,070
Ви ніколи не повинні використовувати кронштейн синтаксису.

661
00:55:34,070 --> 00:55:37,770
Ви завжди можете використовувати * (S + 3) синтаксис.

662
00:55:37,770 --> 00:55:40,180
Люди, як правило, подобаються кронштейн синтаксису, однак.

663
00:55:40,180 --> 00:55:43,860
[Студент] Таким чином, всі масиви в дійсності є просто покажчиками.

664
00:55:43,860 --> 00:55:53,630
Існує невелике розходження, коли я говорю Int х [4] >> [студент] Чи означає це, створіть пам'яті?

665
00:55:53,630 --> 00:56:03,320
[Боуден], що збирається створити 4 цілих чисел в стеку, тому 16 байт в цілому.

666
00:56:03,320 --> 00:56:05,700
Він збирається створити 16 байт в стеці.

667
00:56:05,700 --> 00:56:09,190
х ніде не зберігається.

668
00:56:09,190 --> 00:56:13,420
Це просто символ з посиланням на старті річ.

669
00:56:13,420 --> 00:56:17,680
Тому що ви оголосили масив всередині цієї функції,

670
00:56:17,680 --> 00:56:22,340
що компілятор буде зробити, це просто замінити всі входження змінної х

671
00:56:22,340 --> 00:56:26,400
с, де це сталося вибрати, щоб покласти ці 16 байт.

672
00:56:26,400 --> 00:56:30,040
Він не може зробити це за допомогою символів * тому, що їй це фактично покажчик.

673
00:56:30,040 --> 00:56:32,380
Це безкоштовно, щоб потім вказати на інші речі.

674
00:56:32,380 --> 00:56:36,140
х є постійним. Ви не можете мати його точки до іншої масив. >> [Студент] Добре.

675
00:56:36,140 --> 00:56:43,420
Але ця ідея, ця індексація, таке ж, незалежно від того, чи є це традиційним масивом

676
00:56:43,420 --> 00:56:48,230
або, якщо це покажчик на щось або, якщо це покажчик на malloced масиву.

677
00:56:48,230 --> 00:56:59,770
І справді, це так еквівалентної, що це також одне і те ж.

678
00:56:59,770 --> 00:57:05,440
Це насправді просто означає, що всередині дужок і те, що залишилося за дужки,

679
00:57:05,440 --> 00:57:07,970
складає їх, і разименовивает.

680
00:57:07,970 --> 00:57:14,710
Так що це тільки ж силу, як * (S + 3) або з [3].

681
00:57:16,210 --> 00:57:22,090
[Студент] Може у вас є покажчики, що вказують на 2-мірних масивів?

682
00:57:22,090 --> 00:57:27,380
>> Це важче. Традиційно, немає.

683
00:57:27,380 --> 00:57:34,720
2-мірний масив знаходиться всього в 1-мірний масив з деяким зручний синтаксис

684
00:57:34,720 --> 00:57:54,110
тому що, коли я говорю Int х [3] [3], це дійсно тільки 1 масив з 9 значень.

685
00:57:55,500 --> 00:58:03,000
І тому, коли я індексом, компілятор знає, що я маю на увазі.

686
00:58:03,000 --> 00:58:13,090
Якщо я скажу, х [1] [2], він знає, я хочу піти на другому рядку, так що він збирається пропустити перші 3,

687
00:58:13,090 --> 00:58:17,460
, А потім вона хоче Друге в тому, що так воно збирається отримати це.

688
00:58:17,460 --> 00:58:20,480
Але це ще тільки одновимірний масив.

689
00:58:20,480 --> 00:58:23,660
І тому, якщо я хотів привласнити покажчик на цей масив,

690
00:58:23,660 --> 00:58:29,770
Я б сказав Int * р = х;

691
00:58:29,770 --> 00:58:33,220
Тип х просто -

692
00:58:33,220 --> 00:58:38,280
Це грубо кажучи типу х, так як це всього лише символ, і це не фактичної змінної,

693
00:58:38,280 --> 00:58:40,140
Але це всього лише Int *.

694
00:58:40,140 --> 00:58:44,840
х це просто покажчик на початок цього. >> [Студент] Добре.

695
00:58:44,840 --> 00:58:52,560
І тому я не буду мати можливість доступу [1] [2].

696
00:58:52,560 --> 00:58:58,370
Я думаю, що є спеціальний синтаксис для оголошення покажчика,

697
00:58:58,370 --> 00:59:12,480
щось смішне, як Int (* р [-. щось абсолютно смішно, я навіть не знаю.

698
00:59:12,480 --> 00:59:17,090
Але є синтаксис для оголошення покажчиків, як з дужками і речі.

699
00:59:17,090 --> 00:59:22,960
Він не може навіть дозволити вам зробити це.

700
00:59:22,960 --> 00:59:26,640
Я можу озирнутися на те, що б сказати мені правду.

701
00:59:26,640 --> 00:59:34,160
Я буду шукати його пізніше, якщо є синтаксис точки. Але ви ніколи не побачите.

702
00:59:34,160 --> 00:59:39,670
І навіть синтаксис дуже архаїчна, що якщо ви використовуєте його, люди будуть збиті з пантелику.

703
00:59:39,670 --> 00:59:43,540
Багатовимірні масиви є досить рідкими, як це.

704
00:59:43,540 --> 00:59:44,630
Ви в значній мірі -

705
00:59:44,630 --> 00:59:48,490
Ну, а якщо ви робите матрицю речей він не збирається бути рідкісними,

706
00:59:48,490 --> 00:59:56,730
але в C ви рідко будете використовувати багатовимірні масиви.

707
00:59:57,630 --> 01:00:00,470
Так. >> [Студент] Скажімо, у вас є дуже довгий масив.

708
01:00:00,470 --> 01:00:03,900
>> Таким чином, у віртуальній пам'яті, вона, здавалося б, все підряд,

709
01:00:03,900 --> 01:00:05,640
як елементи поруч один з одним,

710
01:00:05,640 --> 01:00:08,770
але й у фізичній пам'яті, це було б можливо, що бути розділені? >> Да.

711
01:00:08,770 --> 01:00:16,860
Як віртуальна пам'ять працює це тільки відокремлює -

712
01:00:19,220 --> 01:00:24,860
Блок розподілу являє собою сторінку, яка має тенденцію бути 4 кілобайти,

713
01:00:24,860 --> 01:00:29,680
і тому, коли процес говорить, агов, я хочу використати цю пам'ять,

714
01:00:29,680 --> 01:00:35,970
Операційна система збирається виділити її 4 кілобайти, що мало блок пам'яті.

715
01:00:35,970 --> 01:00:39,100
Навіть якщо ви використовуєте тільки один маленький байт в цілий блок пам'яті,

716
01:00:39,100 --> 01:00:42,850
Операційна система збираюся дати йому повний 4 кілобайти.

717
01:00:42,850 --> 01:00:49,410
Так що це означає, я міг би - скажімо, це мій стек.

718
01:00:49,410 --> 01:00:53,180
Цей стек можуть бути розділені. Мій стек може бути мегабайти і мегабайти.

719
01:00:53,180 --> 01:00:55,020
Мій стек може бути величезним.

720
01:00:55,020 --> 01:01:00,220
Але сам стек повинен бути розбитий на окремі сторінки,

721
01:01:00,220 --> 01:01:09,010
, Який, якщо ми подивимося на тут скажімо, це наша пам'ять,

722
01:01:09,010 --> 01:01:16,600
якщо у мене є 2 гігабайти оперативної пам'яті, це дійсно адресою 0 як нульовий байт моїй пам'яті,

723
01:01:16,600 --> 01:01:22,210
і це становить 2 гігабайти на всьому шляху сюди.

724
01:01:22,210 --> 01:01:27,230
Так цій сторінці може відповідати цьому блоку тут.

725
01:01:27,230 --> 01:01:29,400
Ця сторінка може відповідати цьому блоку тут.

726
01:01:29,400 --> 01:01:31,560
Це одна може відповідати цим сюди.

727
01:01:31,560 --> 01:01:35,540
Таким чином, операційна система вільна призначити фізичної пам'яті

728
01:01:35,540 --> 01:01:39,320
в окремих сторінок довільно.

729
01:01:39,320 --> 01:01:46,180
А це означає, що якщо це станеться, межа осідлати масиву,

730
01:01:46,180 --> 01:01:50,070
Масив трапляється, залишив це і право цей порядок сторінок,

731
01:01:50,070 --> 01:01:54,460
Потім цей масив буде розділений у фізичній пам'яті.

732
01:01:54,460 --> 01:01:59,280
А потім, коли ви виходите з програми, коли процес закінчиться,

733
01:01:59,280 --> 01:02:05,690
ці відображення отримати стерті, а потім вона вільно використовувати ці маленькі блоки для інших речей.

734
01:02:14,730 --> 01:02:17,410
Ще питання?

735
01:02:17,410 --> 01:02:19,960
[Студент] арифметики покажчиків. >> Ах так.

736
01:02:19,960 --> 01:02:28,410
Струни були легші, але, дивлячись на те, як цілими,

737
01:02:28,410 --> 01:02:35,000
Отже, повернемося до Int х [4];

738
01:02:35,000 --> 01:02:41,810
Чи є це масив або це покажчик на malloced масив з 4 чисел,

739
01:02:41,810 --> 01:02:47,060
це буде розглядатися таким же чином.

740
01:02:50,590 --> 01:02:53,340
[Студент] Так масивів в купі?

741
01:03:01,400 --> 01:03:05,270
[Боуден] Масиви не в купі. >> [Студент] Ох.

742
01:03:05,270 --> 01:03:08,320
>> [Боуден] Цей тип масиву, як правило, в стеці

743
01:03:08,320 --> 01:03:12,220
якщо Ви заявив на - ігнорування глобальних змінних. Не використовуйте глобальні змінні.

744
01:03:12,220 --> 01:03:16,280
Усередині функції Я кажу Int х [4];

745
01:03:16,280 --> 01:03:22,520
Він збирається створити 4-ціле число блоків в стеку для цього масиву.

746
01:03:22,520 --> 01:03:26,960
Але це Танос (4 * SizeOf (INT)); буде йти в купу.

747
01:03:26,960 --> 01:03:31,870
Але після цього моменту я можу використовувати х і р у значній мірі тими ж способами,

748
01:03:31,870 --> 01:03:36,140
крім винятків, я вже говорив про вас можна перепризначити р.

749
01:03:36,140 --> 01:03:40,960
Технічно, їх розміри трохи відрізняються, але це абсолютно не має значення.

750
01:03:40,960 --> 01:03:43,310
Ви ніколи не використовувати їх розмірів.

751
01:03:48,020 --> 01:03:56,810
Р я можу сказати, р [3] = 2, або х [3] = 2;

752
01:03:56,810 --> 01:03:59,680
Ви можете використовувати їх точно так само способами.

753
01:03:59,680 --> 01:04:01,570
Так що арифметика покажчиків тепер - так.

754
01:04:01,570 --> 01:04:07,390
[Студент] Ви не повинні робити р * якщо у вас є дужки?

755
01:04:07,390 --> 01:04:11,720
Дужках неявних посилань. >> Добре.

756
01:04:11,720 --> 01:04:20,200
Насправді, і те, що ви говорите з ви можете отримати багатовимірні масиви

757
01:04:20,200 --> 01:05:02,650
з покажчиками, що ви можете зробити щось подібне, скажімо, Int ** рр = Танос (SizeOf (INT *) * 5);

758
01:05:02,650 --> 01:05:06,900
Я просто написати все це в першу чергу.

759
01:05:37,880 --> 01:05:41,020
Я не хотів цього.

760
01:05:41,020 --> 01:05:42,550
Добре.

761
01:05:42,550 --> 01:05:48,910
Що я зробив тут - Це має бути рр [I].

762
01:05:48,910 --> 01:05:53,680
Так п.п. це покажчик на покажчик.

763
01:05:53,680 --> 01:06:02,420
Ви mallocing п.п. вказує на масив з 5 зірочок Int.

764
01:06:02,420 --> 01:06:10,950
Таким чином, в пам'яті у вас в стеку С.

765
01:06:10,950 --> 01:06:20,150
Це буде вказувати на масив з 5 блоків, які все самі покажчики.

766
01:06:20,150 --> 01:06:28,210
А потім, коли я Танос сюди, я Танос, що кожен з цих окремих покажчиків

767
01:06:28,210 --> 01:06:32,080
повинен вказувати на окремий блок з 4 байт в купі.

768
01:06:32,080 --> 01:06:35,870
Таким чином, це вказує на 4 байти.

769
01:06:37,940 --> 01:06:40,660
А це вказує на іншу 4 байт.

770
01:06:40,660 --> 01:06:43,200
>> І всі вони вказують на своїх 4 байт.

771
01:06:43,200 --> 01:06:49,080
Це дає мені спосіб зробити багатовимірним речі.

772
01:06:49,080 --> 01:06:58,030
Я міг би сказати п.п. [3] [4], але тепер це не те ж саме, багатовимірні масиви

773
01:06:58,030 --> 01:07:05,390
тому що багатовимірні масиви в її перекладі [3] [4] в одну зміщення у масиві х.

774
01:07:05,390 --> 01:07:14,790
Це разименовивает р, доступ до третього індексу, те, що разименовивает

775
01:07:14,790 --> 01:07:20,790
і доступи - 4 будуть вважатися недійсними - другий індекс.

776
01:07:24,770 --> 01:07:31,430
У той час, коли ми були Int х [3] [4] до як багатовимірний масив

777
01:07:31,430 --> 01:07:35,740
і при подвійному кронштейні це дійсно тільки один разименованія,

778
01:07:35,740 --> 01:07:40,490
Ви після одного покажчика, а потім зсув,

779
01:07:40,490 --> 01:07:42,850
це дійсно 2D посилання.

780
01:07:42,850 --> 01:07:45,840
Ви прямуєте 2 окремі покажчики.

781
01:07:45,840 --> 01:07:50,420
Таким чином, це також технічно дозволяє мати багатовимірні масиви

782
01:07:50,420 --> 01:07:53,550
де кожен масиву різних розмірів.

783
01:07:53,550 --> 01:07:58,000
Тому я думаю, зубчасті багатовимірних масивів є те, що вона називається

784
01:07:58,000 --> 01:08:01,870
так як насправді перше, що може вказувати на те, що має 10 елементів,

785
01:08:01,870 --> 01:08:05,540
Друге, що може вказувати на те, що має 100 елементів.

786
01:08:05,540 --> 01:08:10,790
[Студент] Чи є обмеження на кількість покажчиків ви можете мати

787
01:08:10,790 --> 01:08:14,290
вказують на інші покажчики? >> Ні.

788
01:08:14,290 --> 01:08:17,010
Ви можете мати Int ***** р.

789
01:08:18,050 --> 01:08:23,760
Повернутися до арифметики з покажчиками - >> [студент] Ох. >> Да.

790
01:08:23,760 --> 01:08:35,649
[Студент] Якщо у мене є Int *** р а потім я разименованія, і я кажу р * дорівнює цьому значенню,

791
01:08:35,649 --> 01:08:39,560
це тільки збирається зробити 1 рівень разименованія? >> Да.

792
01:08:39,560 --> 01:08:43,340
Так що, якщо я хочу отримати доступ те, що останній покажчик направлений на -

793
01:08:43,340 --> 01:08:46,210
Тоді ви *** р. >> Добре.

794
01:08:46,210 --> 01:08:54,080
Так що це р вказує на 1 блок, який вказує на інший блок, який вказує на інший блок.

795
01:08:54,080 --> 01:09:02,010
Тоді, якщо ви робите * р = щось інше, то ви міняєте цю

796
01:09:02,010 --> 01:09:13,640
Тепер, щоб вказати на інший блок. >> Добре.

797
01:09:13,640 --> 01:09:17,649
>> [Боуден] І якщо вони були malloced, то ви тепер витік пам'яті

798
01:09:17,649 --> 01:09:20,430
якщо вам пощастило мати різні посилання з цих

799
01:09:20,430 --> 01:09:25,270
Оскільки ви не можете повернутися в ті, що ви просто викинули.

800
01:09:25,270 --> 01:09:29,550
Покажчик арифметика.

801
01:09:29,550 --> 01:09:36,310
Int х [4]; збирається виділити масив з 4 чисел

802
01:09:36,310 --> 01:09:40,670
де х буде вказувати на початок масиву.

803
01:09:40,670 --> 01:09:50,420
Тому, коли я кажу щось подібне X [1], я хочу, щоб це означало йти на другий ціле число в масиві,

804
01:09:50,420 --> 01:09:53,319
, Який був би цьому.

805
01:09:53,319 --> 01:10:04,190
Але насправді, це 4 байти в масиві, так як це ціле число займає 4 байти.

806
01:10:04,190 --> 01:10:08,470
Таким чином, зсув 1 на насправді означає зміщення 1

807
01:10:08,470 --> 01:10:12,030
раз розмір незалежно від типу масиву.

808
01:10:12,030 --> 01:10:17,170
Це масив цілих чисел, тому він знає, що потрібно робити 1 раз розмір Int, коли він хоче, щоб компенсувати.

809
01:10:17,170 --> 01:10:25,260
Інший синтаксис. Пам'ятайте, що це еквівалентно * (х + 1);

810
01:10:25,260 --> 01:10:35,250
Коли я кажу покажчик + 1, то, що повертає це адреса, що покажчик зберігання

811
01:10:35,250 --> 01:10:40,360
плюс 1 раз розмір тип покажчика.

812
01:10:40,360 --> 01:10:59,510
Таким чином, якщо х = ox100, то х + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
І ви можете зловживати цим і сказати щось на зразок символ * C = (символ *) х;

814
01:11:19,750 --> 01:11:23,050
і тепер з буде той же адреса, х.

815
01:11:23,050 --> 01:11:26,040
З буде дорівнювати ox100,

816
01:11:26,040 --> 01:11:31,490
але з + 1 буде дорівнює ox101

817
01:11:31,490 --> 01:11:38,030
З арифметикою покажчика залежить від типу покажчик, який ви додаєте в.

818
01:11:38,030 --> 01:11:45,390
Таким чином, з + 1, він дивиться на C, це символьний покажчик, так що він збирається додати 1 разу розмір символів,

819
01:11:45,390 --> 01:11:48,110
який завжди буде на 1, так що ви отримаєте 101,

820
01:11:48,110 --> 01:11:54,890
а якщо я зроблю х, яка також ще 100, х + 1 буде 104.

821
01:11:56,660 --> 01:12:06,340
[Студент] Чи можна використовувати C + +, в цілях просування покажчика на 1?

822
01:12:06,340 --> 01:12:09,810
Так, можна.

823
01:12:09,810 --> 01:12:16,180
Ви не можете зробити цього, тому що з х х це просто символ, це постійна, ви не можете змінити х.

824
01:12:16,180 --> 01:12:22,610
>> Але з відбувається, щоб бути просто покажчик, так що C + + є цілком допустимим, і вона буде збільшуватися на 1.

825
01:12:22,610 --> 01:12:32,440
Якщо з просто Int *, то C + + буде 104.

826
01:12:32,440 --> 01:12:41,250
+ + Робить арифметику покажчиків так само, як з + 1 зробив би арифметики покажчиків.

827
01:12:43,000 --> 01:12:48,870
Насправді, як багато таких речей, як сортування злиттям -

828
01:12:49,670 --> 01:12:55,710
Замість того щоб створювати копії речей, ви можете замість цього пройти -

829
01:12:55,710 --> 01:13:02,400
Як якщо б я хотів передати цю половину масиву - давайте стерти частину цього.

830
01:13:04,770 --> 01:13:10,520
Скажімо, я хотів би передати цю сторону масиву у функцію.

831
01:13:10,520 --> 01:13:12,700
Що б я передати цю функцію?

832
01:13:12,700 --> 01:13:17,050
Якщо я проходжу х, я передаю цю адресу.

833
01:13:17,050 --> 01:13:23,780
Але я хочу, щоб пройти цей конкретний адресу. Так що я повинен пройти?

834
01:13:23,780 --> 01:13:26,590
[Студент] покажчик + 2?

835
01:13:26,590 --> 01:13:29,350
[Боуден] Таким чином, х + 2. Так.

836
01:13:29,350 --> 01:13:31,620
Це буде ця адреса.

837
01:13:31,620 --> 01:13:42,810
Ви також дуже часто бачу це як х [2], а потім адресу цього.

838
01:13:42,810 --> 01:13:47,850
Таким чином, ви повинні взяти на адресу, тому що кронштейн неявних посилань.

839
01:13:47,850 --> 01:13:53,250
х [2] посилається на значення, яке знаходиться в цьому полі, а потім ви хочете адресу цього вікна,

840
01:13:53,250 --> 01:13:56,850
так що ви говорите і х [2].

841
01:13:56,850 --> 01:14:02,880
Так от, як щось сортування злиттям, де ви хочете передати половину списку, щоб щось

842
01:14:02,880 --> 01:14:08,790
Ви дійсно просто передати і х [2], і в даний час, наскільки рекурсивний виклик, то,

843
01:14:08,790 --> 01:14:12,510
мій новий масив починається там.

844
01:14:12,510 --> 01:14:15,130
Останні питання хвилину.

845
01:14:15,130 --> 01:14:20,050
[Студент] Якщо ми не будемо ставити амперсанд або - що, що називається? >> Star?

846
01:14:20,050 --> 01:14:23,200
[Студент] Star. >> Технічно, оператор разименованія, але - >> [студент] Dereference.

847
01:14:23,200 --> 01:14:29,310
>> Якщо ми не ставимо зірки або амперсанд, що станеться, якщо я просто скажу, у = х і х є покажчиком?

848
01:14:29,310 --> 01:14:34,620
Який тип у? >> [Студент] Я просто кажу, що це покажчик 2.

849
01:14:34,620 --> 01:14:38,270
Так що якщо ви тільки що сказали у = х, тепер х і у указують на одне і те ж. >> [Студент] вказують на те ж саме.

850
01:14:38,270 --> 01:14:45,180
І якщо х Int покажчика? >> Було б скаржитися, тому що ви не можете призначити покажчиків.

851
01:14:45,180 --> 01:14:46,540
[Студент] Добре.

852
01:14:46,540 --> 01:14:51,860
Пам'ятайте, що покажчики, хоча ми і залучити їх, як стріли,

853
01:14:51,860 --> 01:15:02,010
насправді все, що вони магазину - Int * х - дійсно все х зберігання щось подібне ox100,

854
01:15:02,010 --> 01:15:06,490
які ми, трапляється, що представляють як вказівку на блоці зберігається 100.

855
01:15:06,490 --> 01:15:19,660
Тому коли я кажу Int * у = х, я просто копіювання ox100 в у,

856
01:15:19,660 --> 01:15:24,630
які ми тільки збираємося представити як у, також вказуючи на ox100.

857
01:15:24,630 --> 01:15:39,810
І якщо я говорю Int я = (INT) х, тоді я маю намір зберігати будь-які значення ox100 є

858
01:15:39,810 --> 01:15:45,100
всередині нього, але тепер це буде інтерпретуватися як ціле, а не покажчик.

859
01:15:45,100 --> 01:15:49,310
Але для цього потрібно литих або ж він буде скаржитися.

860
01:15:49,310 --> 01:15:53,300
[Студент] Таким чином, ви маєте на увазі, щоб кинути -

861
01:15:53,300 --> 01:16:00,290
Це збирається бути лиття Int х або лиття Int у?

862
01:16:00,290 --> 01:16:03,700
[Боуден] Що?

863
01:16:03,700 --> 01:16:07,690
[Студент] Добре. Після цих дужках там буде х або ау там?

864
01:16:07,690 --> 01:16:11,500
>> [Боуден] Або. х та у є еквівалентними. >> [Студент] Добре.

865
01:16:11,500 --> 01:16:14,390
Тому що вони обидва покажчика. >> Да.

866
01:16:14,390 --> 01:16:21,050
[Студент] Тому було б зберігати шістнадцяткове ціле число 100 у формі? >> [Боуден] Так.

867
01:16:21,050 --> 01:16:23,620
Але не значення того, що це вказує.

868
01:16:23,620 --> 01:16:29,940
[Боуден] Так. >> [Студент] Таким чином, тільки адресу в целочисленном вигляді. Добре.

869
01:16:29,940 --> 01:16:34,720
[Боуден] Якщо ви хотіли б за деякою дивної причини,

870
01:16:34,720 --> 01:16:38,900
Ви могли б мати справу виключно з покажчиками і ніколи не мати справу з цілими числами

871
01:16:38,900 --> 01:16:49,240
і просто бути як Int * х = 0.

872
01:16:49,240 --> 01:16:53,000
Тоді ви збираєтеся отримати дійсно плутають раз арифметики покажчиків починає відбуватися.

873
01:16:53,000 --> 01:16:56,570
Так що цифри, які вони зберігають не мають сенсу.

874
01:16:56,570 --> 01:16:58,940
Це просто, як ви в кінцевому підсумку їх інтерпретації.

875
01:16:58,940 --> 01:17:02,920
Так що я вільно копіювати ox100 від Int * в ціле число,

876
01:17:02,920 --> 01:17:07,790
і я вільно призначати - ти, ймовірно, збираюся кричати на що не лиття -

877
01:17:07,790 --> 01:17:18,160
Я вільний призначити щось подібне (Int *) ox1234 в цій довільній * Int.

878
01:17:18,160 --> 01:17:25,480
Так ox123 так само вірний адресу пам'яті, як це і у.

879
01:17:25,480 --> 01:17:32,060
І у трапляється, повернути те, що є в значній мірі ox123.

880
01:17:32,060 --> 01:17:35,430
[Студент] Це було б дійсно здорово шлях від шістнадцятковій в десяткову форму,

881
01:17:35,430 --> 01:17:39,230
подобається, якщо у вас є покажчик, і ви кинули його у вигляді цілого числа?

882
01:17:39,230 --> 01:17:44,860
[Боуден] Ви дійсно можете просто друкувати, використовуючи як Printf.

883
01:17:44,860 --> 01:17:50,300
Скажімо, у мене є Int у = 100.

884
01:17:50,300 --> 01:18:02,700
Таким чином, Е (% г \ п - як ви вже знаєте - друк, що як ціле, х%.

885
01:18:02,700 --> 01:18:05,190
Ми просто роздрукувати його як шістнадцяткове.

886
01:18:05,190 --> 01:18:10,760
Таким чином, покажчик не зберігається в шістнадцятковому,

887
01:18:10,760 --> 01:18:12,960
і ціле не зберігається у вигляді десяткового.

888
01:18:12,960 --> 01:18:14,700
Все зберігається в двійковому вигляді.

889
01:18:14,700 --> 01:18:17,950
Це тільки, що ми, як правило, щоб показати, покажчики, як шістнадцяткове

890
01:18:17,950 --> 01:18:23,260
тому що ми думаємо про речі, в цих 4-байтових блоків,

891
01:18:23,260 --> 01:18:25,390
і адреси пам'яті, як правило, знайомі.

892
01:18:25,390 --> 01:18:28,890
Ми як, якщо він починається з BF, то воно відбудеться, буде в стеці.

893
01:18:28,890 --> 01:18:35,560
Так що це просто наша інтерпретація покажчики, як шістнадцяткове.

894
01:18:35,560 --> 01:18:39,200
Добре. Будь останніх запитань?

895
01:18:39,200 --> 01:18:41,700
>> Я буду тут трохи після, якщо у вас є щось ще.

896
01:18:41,700 --> 01:18:46,070
І це кінець.

897
01:18:46,070 --> 01:18:48,360
>> [Студент] Ура! [Оплески]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]