1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [Неделя 4, продолжение]

2
00:00:02,310 --> 00:00:04,240
[David J. Малан - Гарвардский университет]

3
00:00:04,240 --> 00:00:07,290
[Это CS50. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> Это CS50, и это в конце недели 4.

5
00:00:11,290 --> 00:00:14,030
Таким образом, некоторые хорошие новости и плохие новости.

6
00:00:14,030 --> 00:00:26,240
Нет лекции в понедельник, не проблема установить на следующей неделе. [Аплодисменты студентов]

7
00:00:26,240 --> 00:00:28,680
Вы не понравится, где это происходит.

8
00:00:28,680 --> 00:00:31,590
Но у нас есть это, а в следующую среду,

9
00:00:31,590 --> 00:00:37,740
и есть также в программе 1 лекция пятницу в следующую пятницу, так что мы можем остаться на трассе.

10
00:00:37,740 --> 00:00:40,580
Но все будет снят, как обычно, так что не беспокойтесь.

11
00:00:40,580 --> 00:00:44,100
>> И в связи с викторину 0 Что мы будем делать ближе к концу недели

12
00:00:44,100 --> 00:00:47,140
будет размещать на домашней странице cs50.net курса объяснений

13
00:00:47,140 --> 00:00:50,160
, какого рода ожидания вы должны иметь, когда дело доходит до первой викторины.

14
00:00:50,160 --> 00:00:55,100
В общем, это будет множественный выбор, верно-неверно, короткий ответ, короткий кодирования проблемы.

15
00:00:55,100 --> 00:00:57,360
Вы не будете ожидать для реализации эквивалентных

16
00:00:57,360 --> 00:01:00,030
проблемы, которые вы видите на PSET, для которых у вас есть компьютер

17
00:01:00,030 --> 00:01:03,240
и отладчик и тому подобное, но там будет небольшая кодирования проблемы.

18
00:01:03,240 --> 00:01:06,900
>> И действительно, лучшее руководство, чтобы получить представление о том, что CS50 викторины, как

19
00:01:06,900 --> 00:01:09,180
это зайти на cs50.net, перейдите на ссылку викторины,

20
00:01:09,180 --> 00:01:11,920
и вы можете увидеть последние несколько лет стоит викторины.

21
00:01:11,920 --> 00:01:16,600
Просто понимаю, что учебные программы не всегда было неизменным на протяжении многих лет.

22
00:01:16,600 --> 00:01:18,510
Иногда мы добавим, иногда вычитать,

23
00:01:18,510 --> 00:01:20,670
поэтому если вы видите какую-то тему на одном из тех старых викторины

24
00:01:20,670 --> 00:01:25,380
что вы понятия не имеете, что это говорит о том, что это либо то, что мы не покрыть ее

25
00:01:25,380 --> 00:01:27,210
или что мы не покрывает его.

26
00:01:27,210 --> 00:01:31,110
Но в виде отзывов, в это воскресенье, понедельник и вторник

27
00:01:31,110 --> 00:01:34,770
а также ход всей сессии по проведению обзора в ночь на воскресенье -

28
00:01:34,770 --> 00:01:37,500
Время и место будут объявлены на домашней странице курса -

29
00:01:37,500 --> 00:01:40,120
Вы все имеете возможность ознакомиться с преподаванием курса стипендиаты

30
00:01:40,120 --> 00:01:44,830
Материал в этом году, как и в разделе качестве полноправного класса,

31
00:01:44,830 --> 00:01:48,400
, и они будут сняты, как обычно, а также.

32
00:01:48,400 --> 00:01:53,380
>> Хорошо. Итак, без дальнейших церемоний, в одном из комментариев на зачет / незачет и ввода / вывода.

33
00:01:53,380 --> 00:01:57,980
Возможно, вы видели мои заметки прошлой ночью, и это действительно просто некоторые дополнительные заверения

34
00:01:57,980 --> 00:02:01,250
что если вы принадлежите к числу тех, кто особенно менее комфортно или где-то посередине

35
00:02:01,250 --> 00:02:04,870
и вы чувствуете себя просто немного более чем в вашей голове,

36
00:02:04,870 --> 00:02:08,430
понимают, что на самом деле вполне нормально, и есть достаточное структуры поддержки на месте,

37
00:02:08,430 --> 00:02:13,530
один из которых приемные часы были намерения по улучшению тем более за мою электронную почту прошлой ночью,

38
00:02:13,530 --> 00:02:16,520
и понимаю, что тоже вариант, как годен / не годен для класса, как это

39
00:02:16,520 --> 00:02:21,540
на самом деле имеется в виду в качестве механизма, снять остроту курса, как это,

40
00:02:21,540 --> 00:02:24,200
так что опять, если вы тратите те 10, 15, 20 часов

41
00:02:24,200 --> 00:02:28,160
просто пытаюсь получить некоторые PSET работать и вы знаете, что 90-95% от туда

42
00:02:28,160 --> 00:02:32,100
но вы не можете найти проклятую ошибку, в зачет / незачет модель, которая вроде нормально.

43
00:02:32,100 --> 00:02:36,230
>> Идея состоит в том, что с этим механизмом вы можете пойти внимания на других psets

44
00:02:36,230 --> 00:02:39,530
или спать или что это такое, что вы хотите, чтобы сосредоточиться.

45
00:02:39,530 --> 00:02:43,390
Так понимаю, что у вас есть, пока это ближайший вторник - технически 5-й понедельник,

46
00:02:43,390 --> 00:02:50,840
но это праздник, так что это ближайший вторник - перейти от годен / не годен к градуированная или наоборот.

47
00:02:50,840 --> 00:02:54,450
И если вы действительно на краю пропасти, и думает падения в целом,

48
00:02:54,450 --> 00:02:56,440
Пожалуйста, поймай меня после лекции или напишите мне записку.

49
00:02:56,440 --> 00:02:59,990
Мы хотели бы, по крайней мере чата перед вами попрощаться.

50
00:02:59,990 --> 00:03:03,470
Хорошо. Таким образом, мы начали принимать подготовки колес в прошлый раз.

51
00:03:03,470 --> 00:03:06,030
В частности, мы обратили внимание на строку.

52
00:03:06,030 --> 00:03:09,740
Струнный является то, что объявленные в библиотеке CS50,

53
00:03:09,740 --> 00:03:14,340
в частности в том, что файл с именем cs50.h которых мы начнем смотреть на эту неделю и следующую.

54
00:03:14,340 --> 00:03:17,250
Но строка на самом деле просто упрощение что-то

55
00:03:17,250 --> 00:03:20,980
, что немного больше arcanely описано как символ *.

56
00:03:20,980 --> 00:03:24,090
Char, что мы знакомы. Это всего лишь один символ.

57
00:03:24,090 --> 00:03:28,010
Но * по состоянию на понедельник обозначается как? >> [Студент] указатель.

58
00:03:28,010 --> 00:03:31,290
Указателя. И что указатель? >> [Студент] адрес.

59
00:03:31,290 --> 00:03:33,420
>> Это все равно, адрес, место в памяти.

60
00:03:33,420 --> 00:03:35,910
Что адрес или место или память?

61
00:03:35,910 --> 00:03:40,290
Опять же, у всех нас есть ноутбуки с концерта или 2 гигабайта оперативной памяти, скорее всего, в эти дни,

62
00:03:40,290 --> 00:03:44,160
и это означает, что у вас есть миллиард или 2 млрд. байт стоит памяти.

63
00:03:44,160 --> 00:03:46,240
И это действительно не имеет значения, что это физически выглядит,

64
00:03:46,240 --> 00:03:51,220
но принять на веру, что вы можете сосчитать все отдельные байты, что ваш собственный ноутбук -

65
00:03:51,220 --> 00:03:54,580
это байт 0, это 1 байт, это байт 2 млрд. -

66
00:03:54,580 --> 00:03:56,100
и это именно то, что компьютер делает.

67
00:03:56,100 --> 00:04:00,030
Когда вы выделить место для одного символа, например,

68
00:04:00,030 --> 00:04:02,480
он, очевидно, должен жить где-то в памяти компьютера,

69
00:04:02,480 --> 00:04:05,860
и может быть, это на номер 12345 байт,

70
00:04:05,860 --> 00:04:08,470
и что где-то здесь, в памяти компьютера.

71
00:04:08,470 --> 00:04:12,630
И адрес, то этого символа 12345.

72
00:04:12,630 --> 00:04:16,140
>> Теперь, в неделю от 0 до теперь до сих пор, мы действительно не заботились

73
00:04:16,140 --> 00:04:19,170
, где в памяти хранятся вещи, потому что мы обычно используют символы,

74
00:04:19,170 --> 00:04:22,540
Переменные и массивы на самом деле получить на нашем данных.

75
00:04:22,540 --> 00:04:24,950
Но, как в понедельник, а тем более сегодня, вы теперь будете иметь

76
00:04:24,950 --> 00:04:27,710
Тем более выразительные возможности при написании программ

77
00:04:27,710 --> 00:04:31,330
чтобы действительно управлять памятью компьютера как вы считаете нужным,

78
00:04:31,330 --> 00:04:33,720
как для благих целей и плохо,

79
00:04:33,720 --> 00:04:39,620
ошибки быть очень общий результат на данный момент в изучении этого материала.

80
00:04:39,620 --> 00:04:42,460
Но что это на самом деле значит быть символ *?

81
00:04:42,460 --> 00:04:46,140
Давайте пойдем дальше обратно в - и мы вернемся к Бинки как и обещал сегодня.

82
00:04:46,140 --> 00:04:48,670
Пойдем простым примером здесь.

83
00:04:48,670 --> 00:04:53,060
Позвольте мне сохранить этот файл как compare.c, и позвольте мне просто получить код шаблона здесь

84
00:04:53,060 --> 00:05:00,490
поэтому включать stdio.h, позвольте мне также отдать себя включать cs50.h. Я увеличить там.

85
00:05:00,490 --> 00:05:05,850
Позвольте мне начать писать основные INT, основных (недействительными), и теперь я хочу сделать что-то вроде этого:

86
00:05:05,850 --> 00:05:13,520
Е ("Дайте мне строки:"), а затем я буду использовать строки с получает GetString

87
00:05:13,520 --> 00:05:16,750
, чтобы получить строку от пользователя, то я собираюсь спросить пользователя на другой.

88
00:05:16,750 --> 00:05:21,870
("Дайте мне еще строки:"), и я собираюсь попросить их через GetString, чтобы получить это.

89
00:05:21,870 --> 00:05:27,020
Я буду называть его, потому что т т приходит после с и с это хорошее название для строки, если это довольно общий характер.

90
00:05:27,020 --> 00:05:30,030
Так GetString, и теперь я просто хочу сделать общий контроль, и я собираюсь сказать,

91
00:05:30,030 --> 00:05:39,770
Если (S == т), то я просто хочу, чтобы сообщить пользователю Е ("Вы ввели то же самое, \ п");

92
00:05:39,770 --> 00:05:45,520
еще я хочу, чтобы распечатать что-то вроде ("Вы ввели что-то другое! \ п")

93
00:05:45,520 --> 00:05:48,460
или что приговор будет. Таким образом, что-то вроде этого.

94
00:05:48,460 --> 00:05:52,200
Затем, как обычно, я буду возвращать 0, который просто означал, что ничего плохого не случилось,

95
00:05:52,200 --> 00:05:54,400
и я собираюсь идти вперед и скомпилировать и запустить эту программу.

96
00:05:54,400 --> 00:05:56,540
>> Но в понедельник мы запустили эту программу,

97
00:05:56,540 --> 00:06:00,420
и на самом деле было сказано, что ПРИВЕТ не Здравствуй и прощай не прощай.

98
00:06:00,420 --> 00:06:03,140
Поведение, которое мы видели, было немного больше, как это.

99
00:06:03,140 --> 00:06:11,450
Отпустите меня в мой исходный каталог, увеличить здесь, и давайте сделаем сделать сравнение.

100
00:06:11,450 --> 00:06:14,570
Составитель порядке. Позвольте мне выполнить сравнение. Дайте мне строки: Здравствуйте.

101
00:06:14,570 --> 00:06:16,300
Дайте мне другую строку: Здравствуйте.

102
00:06:16,300 --> 00:06:18,000
Вы ввели что-то другое!

103
00:06:18,000 --> 00:06:22,650
Ну, давайте я попробую что-нибудь попроще, как 50, 50. Вы ввели что-то другое!

104
00:06:22,650 --> 00:06:25,740
привет, привет. Таким образом, ясно, что что-то здесь происходит.

105
00:06:25,740 --> 00:06:28,440
Но каково же было объяснение, почему?

106
00:06:28,440 --> 00:06:33,850
Видимо, линия 12 полностью функционирует.

107
00:06:34,300 --> 00:06:39,430
Какая основная проблема здесь? Да. >> [Студент] Это сравнение адресов.

108
00:06:39,430 --> 00:06:41,850
Да, именно так. Это на самом деле сравнения адресов

109
00:06:41,850 --> 00:06:44,580
, в котором ПРИВЕТ ПРИВЕТ и хранятся.

110
00:06:44,580 --> 00:06:48,290
Это не сравнение букв ПРИВЕТ снова и снова,

111
00:06:48,290 --> 00:06:52,370
потому что то, что произошло на самом деле, все это время мы использовали GetString -

112
00:06:52,370 --> 00:06:56,130
Это доске снова памяти нашего компьютера,

113
00:06:56,130 --> 00:07:00,100
и скажем, я называю GetString после объявления переменной с.

114
00:07:00,100 --> 00:07:01,930
Что означает моя память похожа?

115
00:07:01,930 --> 00:07:07,070
Давайте произвольно сказать, что с выглядит следующим образом. Это квадрат.

116
00:07:07,070 --> 00:07:09,040
И в значительной степени любое время я нарисовал кусок памяти на экране

117
00:07:09,040 --> 00:07:12,860
если это 32 бит, я был рисунок квадратов, как это, потому что действительно в прибор,

118
00:07:12,860 --> 00:07:17,380
указатель, адрес, составляет 32 бит. Это так же, как Int.

119
00:07:17,380 --> 00:07:19,420
Это может варьироваться в зависимости от компьютерной системы.

120
00:07:19,420 --> 00:07:24,630
Те из вас, кто смутно знакомы с тем фактом, что ваш Mac или PC составляет 64 бит,

121
00:07:24,630 --> 00:07:28,120
что на самом деле означает, что ваш компьютер использует 64-разрядные указатели,

122
00:07:28,120 --> 00:07:33,730
64-разрядные адреса, а среди расквитаться этого ваш компьютер

123
00:07:33,730 --> 00:07:35,560
может иметь гораздо больше памяти, чем прошлого.

124
00:07:35,560 --> 00:07:39,240
Короче говоря, еще в тот день, когда компьютеры используются только 32 бит

125
00:07:39,240 --> 00:07:42,740
для представления адресов, наибольшее количество байт вы могли бы представлять

126
00:07:42,740 --> 00:07:46,280
В этом случае было то, что если у вас есть 32 бит?

127
00:07:46,280 --> 00:07:49,590
Таким образом, 4 млрд, правы, потому что от 2 до 32, 4 миллиарда долларов.

128
00:07:49,590 --> 00:07:51,370
Это число было повторения в курсе.

129
00:07:51,370 --> 00:07:55,240
>> Так что если у вас есть только 32 бита, наибольшее число вы можете рассчитывать на примерно 4 миллиарда долларов.

130
00:07:55,240 --> 00:07:58,750
Но это было фундаментальное ограничение компьютеров, пока несколько лет назад

131
00:07:58,750 --> 00:08:01,180
потому что если вы можете рассчитывать только достигать 4 млрд.

132
00:08:01,180 --> 00:08:05,270
это не имеет значения, если вы покупаете 8 гигабайт оперативной памяти или даже 5 гигабайт оперативной памяти;

133
00:08:05,270 --> 00:08:07,780
Вы не можете рассчитывать, что высокий, так что это было бесполезно.

134
00:08:07,780 --> 00:08:11,430
Вы можете получить доступ только к первым 3 или 4 гигабайтами памяти компьютера.

135
00:08:11,430 --> 00:08:14,410
Это менее важной проблемой в настоящее время, и вы можете купить MacBook Pros и Dells

136
00:08:14,410 --> 00:08:17,680
с 8 гигабайтами оперативной памяти или даже больше в эти дни.

137
00:08:17,680 --> 00:08:24,100
Но если я просто выделить в этой программе указатель, указатель называется S,

138
00:08:24,100 --> 00:08:28,370
это может выглядеть это на экране, потому что действительно нам нужно отогните этот слой.

139
00:08:28,370 --> 00:08:33,520
Я постоянно говорю строки, но по состоянию на понедельник, строка действительно символ *,

140
00:08:33,520 --> 00:08:35,590
Адрес некоторый характер.

141
00:08:35,590 --> 00:08:39,280
Так что давайте считать, что обучение колеса отключается, даже если мы будем продолжать использовать GetString на данный момент.

142
00:08:39,280 --> 00:08:42,600
Так что я объявил ей, и это часть памяти, 32 бит.

143
00:08:42,600 --> 00:08:47,370
Что здесь в память по умолчанию? >> [Неразборчиво ответ студента]

144
00:08:47,370 --> 00:08:50,040
Что это? >> [Студент] Garbage. >> Garbage. Именно так.

145
00:08:50,040 --> 00:08:54,610
Если вы программист не ставим значение в переменной, кто знает, что это такое?

146
00:08:54,610 --> 00:08:57,990
Иногда вам везет, и это 0, которая является своеобразной хороший, чистый значения по умолчанию,

147
00:08:57,990 --> 00:09:00,310
но, как мы видели понедельник, иногда это полный бред,

148
00:09:00,310 --> 00:09:04,130
некоторые действительно большие положительные или отрицательные числа, которые пришли из где?

149
00:09:05,350 --> 00:09:07,010
Да. >> [Студент] Функция раньше. >> Да.

150
00:09:07,010 --> 00:09:10,170
>> Часто функции, которые получил колл раньше, потому что помню,

151
00:09:10,170 --> 00:09:13,920
как вы называете функции в памяти, они занимают все больше и больше пространства снизу вверх,

152
00:09:13,920 --> 00:09:17,040
и как только функция возвращает, что память получает повторно

153
00:09:17,040 --> 00:09:20,890
на следующий парень, который вызывается, кто использует ваши же кусок памяти.

154
00:09:20,890 --> 00:09:23,450
И если вы оставили мусор там, предыдущие значения,

155
00:09:23,450 --> 00:09:28,190
мы могли бы перепутать с как имеющий некоторое значение, когда на самом деле мы не кладите ничего нет.

156
00:09:28,190 --> 00:09:30,960
Таким образом, наши оперативной памяти на данный момент выглядит следующим образом.

157
00:09:30,960 --> 00:09:36,030
Теперь на правой стороне строки 7 мы называем GetString,

158
00:09:36,030 --> 00:09:40,150
которые мы делаем сейчас в течение недель, а то, что GetString самом деле?

159
00:09:40,150 --> 00:09:43,350
GetString написано CS50 персонал немного интеллектуального

160
00:09:43,350 --> 00:09:46,500
в том, что, как только пользователь начинает вводить ключи и хитов Enter,

161
00:09:46,500 --> 00:09:50,010
GetString цифры, сколько нажатий клавиш сделал пользователь хит,

162
00:09:50,010 --> 00:09:53,360
сколько символов я должен выделить RAM для.

163
00:09:53,360 --> 00:09:55,660
А где, что RAM приходит, кто знает?

164
00:09:55,660 --> 00:09:58,930
Это где-то в 2 компьютера гигабайт и еще много чего из памяти.

165
00:09:58,930 --> 00:10:05,200
Но давайте предположим, что компьютер нашел место для слова ПРИВЕТ прямо здесь.

166
00:10:05,200 --> 00:10:08,710
Я набрал слово было Н-Е-Л-Л-О.

167
00:10:08,710 --> 00:10:13,510
И если мы проведем это как последовательность символов, мы могли бы сделать это так.

168
00:10:13,510 --> 00:10:17,860
Но мне нужно сделать 1 дополнительную вещь. То, что принадлежит в конце любой строки в C?

169
00:10:17,860 --> 00:10:20,710
Нулевой символ, который мы пишем, как \ 0.

170
00:10:20,710 --> 00:10:23,980
Это технически число 0, а обратная косая черта делает все четко

171
00:10:23,980 --> 00:10:28,150
что это буквально число 0, целое число 0;

172
00:10:28,150 --> 00:10:32,440
это не так, например, цитата-конец цитаты 0, что можно ввести с клавиатуры.

173
00:10:32,440 --> 00:10:33,940
Так что это HELLO.

174
00:10:33,940 --> 00:10:36,350
>> И что же мы говорим в понедельник, что функции, как GetString

175
00:10:36,350 --> 00:10:39,580
на самом деле возвращаются все эти недели?

176
00:10:39,580 --> 00:10:43,960
Это не возвращаются строки как таковой, потому что на самом деле не имеют смысл

177
00:10:43,960 --> 00:10:47,710
Поскольку строки не существует. Они вроде изготовления в CS50 библиотеки.

178
00:10:47,710 --> 00:10:51,300
Что на самом деле является строкой, более технически? >> [Студент] Это первый символ.

179
00:10:51,300 --> 00:10:55,950
Именно так. Это довольно просто адрес первого символа, который пользователь ввел дюйма

180
00:10:55,950 --> 00:11:02,810
Так что, если мои слова ПРИВЕТ заканчивает его в байт 123 номера, а затем с байта номер 124,

181
00:11:02,810 --> 00:11:08,320
125, 126, и так далее, если я просто мой номер байта от 0 до о,

182
00:11:08,320 --> 00:11:12,650
что на самом деле GetString возвращается буквально номер 123.

183
00:11:12,650 --> 00:11:19,270
Таким образом, то, что можно положить в ы это номер 123, а не буква H, не то слово HELLO,

184
00:11:19,270 --> 00:11:23,130
просто адрес, по которому я могу найти первую букву HELLO.

185
00:11:23,130 --> 00:11:26,500
Но это не кажется достаточно. Я спросил вас за строкой, а не характер.

186
00:11:26,500 --> 00:11:32,970
Так как же нам или компьютер знаем, что ELLO вида приходят вместе с H?

187
00:11:35,760 --> 00:11:37,460
Что рода соглашения у нас есть? Да.

188
00:11:37,460 --> 00:11:40,100
[Студент] Он продолжает говорить сам найти еще несколько символов. >> Именно так.

189
00:11:40,100 --> 00:11:44,570
>> Там есть человек-компьютер конвенции которой когда вы имеете дело со строками,

190
00:11:44,570 --> 00:11:49,410
иначе известный теперь как символ звезды, вы просто должны выяснить,

191
00:11:49,410 --> 00:11:54,350
где в конце каждой строки в жизни является на самом деле просто итерации по его цикл,

192
00:11:54,350 --> 00:11:57,820
время цикла, что угодно, так что, когда вы находите конце строки

193
00:11:57,820 --> 00:12:02,160
Теперь вы можете заключить из этого, ой, целое слово было HELLO.

194
00:12:02,160 --> 00:12:04,820
Те из вас, с опытом программирования может знать в Java

195
00:12:04,820 --> 00:12:09,880
Вы можете просто позвонить. длину и на других языках можно назвать длину или аналогичный.

196
00:12:09,880 --> 00:12:14,060
Это потому, что во многих языках, в частности, что называется объектно-ориентированных языков,

197
00:12:14,060 --> 00:12:18,580
Длина что-то вроде инкапсулированные внутри части самих данных,

198
00:12:18,580 --> 00:12:24,000
много, как мы инкапсулированные идентификаторы и имена и дома внутри студента в понедельник.

199
00:12:24,000 --> 00:12:28,700
Но C гораздо более низком уровне. Есть никаких объектов или классов, если вы слышали эти термины раньше.

200
00:12:28,700 --> 00:12:31,490
Все, что вам действительно адресов памяти.

201
00:12:31,490 --> 00:12:35,540
Так что это своего рода старомодным способом представления интересной структуры данных.

202
00:12:35,540 --> 00:12:38,760
У вас есть начальное значение, как адрес первого символа

203
00:12:38,760 --> 00:12:42,340
, а затем лишь некоторые произвольные конвенции, что все согласны с тем, чтобы следовать.

204
00:12:42,340 --> 00:12:46,420
Итак, как длина строки реализованы, не мы предлагаем?

205
00:12:46,420 --> 00:12:51,360
STRLEN, StrLen, что некоторые из вас уже использовали несколько раз. Это довольно просто, не так ли?

206
00:12:51,360 --> 00:12:53,060
Это как 2 строки кода.

207
00:12:53,060 --> 00:12:56,140
Это в значительной степени за цикл какой-то, может быть, с дополнительной локальной переменной.

208
00:12:56,140 --> 00:13:00,540
Но StrLen просто должен взять указатель, а затем начинают искать \ 0.

209
00:13:00,540 --> 00:13:05,190
>> И как только он находит его, он может возвращать общее количество шагов, которые он взял в этой строке.

210
00:13:05,190 --> 00:13:07,150
Таким образом, мы можем заключить из этого, что происходит дальше.

211
00:13:07,150 --> 00:13:11,850
Пусть тогда я заявляю, т как я сделал в строке 10.

212
00:13:11,850 --> 00:13:14,280
Это какая-то фигня значение. Кто знает, в первую очередь?

213
00:13:14,280 --> 00:13:18,490
Но на правой стороне линии 10 я звоню GetString снова.

214
00:13:18,490 --> 00:13:20,050
Кто знает, где это заканчивается?

215
00:13:20,050 --> 00:13:23,830
Давайте сколь угодно говорить о том, что операционная система нашла место для него пути сюда.

216
00:13:23,830 --> 00:13:28,610
Я, случается, случайно типа Н-Е-Л-Л-О снова,

217
00:13:28,610 --> 00:13:31,260
и таким образом, мы можем сделать такую ​​же картину.

218
00:13:31,260 --> 00:13:34,290
Но то, что у меня перерисовать эту картину преднамеренного

219
00:13:34,290 --> 00:13:37,720
потому что это другой ПРИВЕТ, чем этот.

220
00:13:37,720 --> 00:13:43,920
Так вот, это может быть расположение 456, это 457, и так далее.

221
00:13:43,920 --> 00:13:47,170
Таким образом, то, что можно поставить, где знак вопроса было раньше?

222
00:13:47,170 --> 00:13:50,190
В этом случае 456.

223
00:13:50,190 --> 00:13:53,540
Мы выбирая эти цифры произвольно, потому что на самом деле после того, как сегодня

224
00:13:53,540 --> 00:13:57,110
Мы не собираемся так беспокоиться о том, что адрес ничего.

225
00:13:57,110 --> 00:14:02,690
Все, что мы заботимся о том, что мы можем выяснить адрес некоторой части данных, как HELLO.

226
00:14:02,690 --> 00:14:07,100
>> Так на самом деле то, что большинство людей в области компьютерной науки, когда речь идет о памяти адреса

227
00:14:07,100 --> 00:14:10,210
и говорить о указателей в частности,

228
00:14:10,210 --> 00:14:14,220
, а не беспокоиться выясняя 123 - кого это волнует, где эти вещи на самом деле,

229
00:14:14,220 --> 00:14:17,440
мы просто знаем, что это в некоторой числовой адрес -

230
00:14:17,440 --> 00:14:22,180
мы упрощаем мир и просто сказать, что с указывает на этого персонажа

231
00:14:22,180 --> 00:14:25,080
и т указывает на этого персонажа.

232
00:14:25,080 --> 00:14:27,430
А то, что это стрелка вполне преднамеренной

233
00:14:27,430 --> 00:14:31,610
потому что буквально сейчас с указывает на H и T указывает на другую H

234
00:14:31,610 --> 00:14:34,720
потому что в конце концов, это не имеет значения, что адрес,

235
00:14:34,720 --> 00:14:40,240
но это не дело, что у нас есть возможность, чтобы выразить, что адрес с некоторыми кусок кода.

236
00:14:40,240 --> 00:14:42,730
Мы действительно не манипулировал этими адресами только пока

237
00:14:42,730 --> 00:14:47,770
так что посмотрим, где мы можем вставлять и как бы делать вещи с указателями,

238
00:14:47,770 --> 00:14:52,030
но сейчас в строке 12 буквальном какие ценности мы сравнению

239
00:14:52,030 --> 00:14:55,500
в соответствии с этой историей в строке 12?

240
00:14:56,570 --> 00:15:01,290
Мы говорим, что составляет 123 равных равными до 456? И это определенно не тот случай.

241
00:15:01,290 --> 00:15:05,320
И даже концептуально, этот указатель, безусловно, не так же, как это

242
00:15:05,320 --> 00:15:09,500
потому что вы называли GetString дважды, и GetString не пытаться быть супер умным,

243
00:15:09,500 --> 00:15:12,470
она не пытается понять, ой, вы набрали ПРИВЕТ 5 минут назад;

244
00:15:12,470 --> 00:15:15,090
Позвольте мне дать вам тот же указатель, как я дал тебе раньше,

245
00:15:15,090 --> 00:15:18,450
он просто выделяет новый блок памяти каждый раз, когда вы это называете.

246
00:15:18,450 --> 00:15:20,350
>> Так как же нам решить эту проблему?

247
00:15:20,350 --> 00:15:24,270
Если высоком уровне я хочу сравнить строки привет и привет -

248
00:15:24,270 --> 00:15:28,680
Я не забочусь о указатели - как я могу идти о отвечая на вопрос,

249
00:15:28,680 --> 00:15:31,980
же пользователь введите то же самое? Что здесь необходима? Да.

250
00:15:31,980 --> 00:15:35,200
[Студент] Используйте функцию. >> Я могу использовать функции из коробки.

251
00:15:35,200 --> 00:15:38,170
Я могу использовать функцию под названием STRCMP, с-т-р-с-т-р,

252
00:15:38,170 --> 00:15:41,190
только сокращенную версию говоря сравнения строк.

253
00:15:41,190 --> 00:15:45,070
И если мы идем в, например, сравнить 2, который является одним из раздаточных материалов сегодняшнем

254
00:15:45,070 --> 00:15:46,690
Я делаю именно это.

255
00:15:46,690 --> 00:15:51,750
Я держал все остальное то же самое от линии 1 на до 26 или около того,

256
00:15:51,750 --> 00:15:54,360
и теперь замечаю эту часть изменилась лишь немного.

257
00:15:54,360 --> 00:15:57,690
Давайте игнорировать линии 28 на мгновение и сосредоточиться только на этом.

258
00:15:57,690 --> 00:16:00,410
Что мы говорим в понедельник, что, ул сравнения делает?

259
00:16:00,410 --> 00:16:05,200
Он отвечает за процесс принятия 2 указателей, с и т в этом случае,

260
00:16:05,200 --> 00:16:08,480
рода практически положив руку на эти 2 письма,

261
00:16:08,480 --> 00:16:11,530
и что он должен сделать что-то вроде петли во время или цикл,

262
00:16:11,530 --> 00:16:16,050
и он говорит эти же самое? Если это так, она движется пальцев или указателей вперед.

263
00:16:16,050 --> 00:16:17,970
Это те же, это то же самое, это то же самое,

264
00:16:17,970 --> 00:16:22,710
это то же самое, это то же самое? И ох, я в конце строки на обоих с и т.

265
00:16:22,710 --> 00:16:26,780
Я не нашел никаких противоречий. Да, эти строки одинаковы.

266
00:16:26,780 --> 00:16:31,940
А что значит ул сравнить возвращения, если 2 строки те же, по-видимому? Zero.

267
00:16:31,940 --> 00:16:35,900
Таким образом, 0 хороша в этом случае, потому что если он возвращает -1 или +1,

268
00:16:35,900 --> 00:16:40,560
это означает, что просто происходит предстать перед т в алфавитном порядке или после т.

269
00:16:40,560 --> 00:16:43,760
И почему бы, что бы полезно иметь функцию, которая говорит вам, какие строки предшествует

270
00:16:43,760 --> 00:16:46,720
или после того, как в словаре?

271
00:16:46,720 --> 00:16:48,740
[Студент] Поиск. >> Поиска и сортировки.

272
00:16:48,740 --> 00:16:51,730
>> Так что вы можете делать вещи, как двоичный поиск или пузырьковой сортировки и сортировки слиянием

273
00:16:51,730 --> 00:16:53,230
где вы должны сравнить вещи.

274
00:16:53,230 --> 00:16:56,420
До сих пор мы вроде сократить некоторые углы и говорили только о сортировке

275
00:16:56,420 --> 00:16:59,430
в контексте номера, потому что это легко и приятно поговорить,

276
00:16:59,430 --> 00:17:02,430
но можно, конечно, сравнивать строки, яблоко и банан,

277
00:17:02,430 --> 00:17:05,349
потому что, если яблоко, как известно, приходят до банана, аналогично,

278
00:17:05,349 --> 00:17:09,319
Вы можете перемещаться по всему строк в памяти так же, как Роб сделал с сортировки слиянием в видео

279
00:17:09,319 --> 00:17:15,880
и мы сделали здесь, на сцене с выбором сортировки, сортировки вставкой, и пузырьковой сортировки.

280
00:17:15,880 --> 00:17:18,710
Так где же еще мы можем принять это? Давайте попробуем это.

281
00:17:18,710 --> 00:17:23,980
Давайте рода забывать, что урок на минуту и ​​попробуйте сейчас и скопировать 1.c сделать следующее.

282
00:17:23,980 --> 00:17:26,800
В строке 21 Я говорю то, печати,

283
00:17:26,800 --> 00:17:28,520
Затем я получаю строку от пользователя,

284
00:17:28,520 --> 00:17:30,690
Затем я проверяю это.

285
00:17:30,690 --> 00:17:33,620
Мы еще не получили в этой привычке нет, но давайте теперь сделать это.

286
00:17:33,620 --> 00:17:40,990
Давайте на самом деле отогните этот слой. Это действительно символ *. Этот парень действительно символ *.

287
00:17:40,990 --> 00:17:45,690
Итак, что же значит быть проверка, если с == NULL?

288
00:17:45,690 --> 00:17:48,380
Оказывается, что при вызове функции, как GetString

289
00:17:48,380 --> 00:17:51,540
или вообще просто спросить компьютера, чтобы дать вам некоторое количество памяти,

290
00:17:51,540 --> 00:17:53,030
что-то может пойти не так.

291
00:17:53,030 --> 00:17:56,630
Вы могли бы быть сумасшедшим, и попросить компьютер на терабайт памяти

292
00:17:56,630 --> 00:18:01,780
, прося триллионов байт памяти, которые просто не существуют в компьютере,

293
00:18:01,780 --> 00:18:05,130
но GetString и другие функции нужно каким-то образом кричать на вас

294
00:18:05,130 --> 00:18:06,820
если вы просили слишком много.

295
00:18:06,820 --> 00:18:10,450
И то, как GetString делает это, если вы попросили больше памяти

296
00:18:10,450 --> 00:18:14,250
, чем имеется в компьютере, даже если это супер, супер низкой вероятности

297
00:18:14,250 --> 00:18:17,730
потому что никто из нас не собирается вводить трлн символов, а затем нажмите Enter,

298
00:18:17,730 --> 00:18:21,980
но низкая вероятность хотя это может быть, я все еще хочу, чтобы проверить его на всякий случай,

299
00:18:21,980 --> 00:18:26,120
и специальное значение, которое GetString, ответ, и другие функции возвращается

300
00:18:26,120 --> 00:18:30,630
если что-то пошло не является NULL заглавными буквами.

301
00:18:30,630 --> 00:18:36,520
>> А что такое NULL? NULL просто так случается представляют собой указатель. Это 0 адрес памяти.

302
00:18:36,520 --> 00:18:40,800
Мир решил, что произвольно, если это память моего компьютера - вы знаете, что? -

303
00:18:40,800 --> 00:18:46,260
мы собираемся, чтобы украсть только 1 байт памяти каждого компьютера, и это положение 0.

304
00:18:46,260 --> 00:18:49,560
Мы собираемся дать ему прозвище NULL, и мы собираемся обещать

305
00:18:49,560 --> 00:18:52,660
что мы никогда не будут ставить реальные данные есть

306
00:18:52,660 --> 00:18:56,770
потому что мы просто произвольно нужно специальное значение 0, иначе NULL,

307
00:18:56,770 --> 00:19:00,230
так что мы можем кричать на пользователей, если что-то пойдет не так.

308
00:19:00,230 --> 00:19:03,590
В противном случае вы можете не знать вовсе 0 означают, положить что-то здесь

309
00:19:03,590 --> 00:19:05,490
или это значит что-то пошло не так?

310
00:19:05,490 --> 00:19:09,190
Мы должны все согласиться, что NULL ничего средств была возвращена,

311
00:19:09,190 --> 00:19:11,700
нет фактического адреса были возвращены.

312
00:19:11,700 --> 00:19:15,210
Теперь, вот, я просто приняв мое человеческое съезде я возвращаюсь 1 от основной

313
00:19:15,210 --> 00:19:17,040
если что-то пойдет не так.

314
00:19:17,040 --> 00:19:20,650
Это потому, что возврат основной конвенции в том, чтобы возвращать 0, если хорошо,

315
00:19:20,650 --> 00:19:22,990
1 или другое значение, если плохое.

316
00:19:22,990 --> 00:19:28,200
Но GetString и любая функция, которая занимается в память возвращает NULL, если что-то идет плохо.

317
00:19:28,200 --> 00:19:33,480
>> Хорошо. Поэтому, к сожалению, строка 27, супер просто, хотя это, совершенно не скопировать строку.

318
00:19:33,480 --> 00:19:35,740
Почему? В этом можно убедиться следующим образом.

319
00:19:35,740 --> 00:19:40,120
Я утверждая, в строке 27 следует сделать копию с и т называя его.

320
00:19:40,120 --> 00:19:45,790
Так что я не прошу у пользователя 2 строки на этот раз, я просто говорю значение в ы

321
00:19:45,790 --> 00:19:47,870
должен быть помещен в т а.

322
00:19:47,870 --> 00:19:52,890
Так что теперь просто чтобы продемонстрировать, как сломанные это, в строке 29 вперед то, что я делаю?

323
00:19:52,890 --> 00:19:56,980
Первый я проверяю, если длина т больше, чем 0.

324
00:19:56,980 --> 00:19:59,330
Там какая-то строка там. Пользователь ввел что-то дюйма

325
00:19:59,330 --> 00:20:03,410
Что такое линия 32 делают, по-видимому?

326
00:20:03,410 --> 00:20:08,910
[Неразборчиво ответ студента] >> праве. Вы можете виды вывести его из того, что я сказал, что это делает.

327
00:20:08,910 --> 00:20:13,200
Но технически, то, что это делает? T [0] представляет то, что?

328
00:20:13,200 --> 00:20:15,140
[Студент] характер нулевой. >> [Малан] характер нулевой.

329
00:20:15,140 --> 00:20:19,620
Или, что более человеческого типа, первый символ в т, что бы это, H, может быть, в этом случае.

330
00:20:19,620 --> 00:20:24,990
И ToUpper делает то, что он говорит. Он капитализирует нулевого символа т, и это меняет его.

331
00:20:24,990 --> 00:20:28,430
Таким образом, это означает взять на нулевом характером т, сделать ее верхний регистр,

332
00:20:28,430 --> 00:20:30,320
и положил его обратно в том же месте.

333
00:20:30,320 --> 00:20:35,540
Так что, если я типа привет в нижнем регистре, это должно изменить строчные ч до столицы H.

334
00:20:35,540 --> 00:20:41,400
Но проблема в том, что в строках 35 и 36, что я собираюсь сделать, это распечатать для нас с и т.

335
00:20:41,400 --> 00:20:43,120
А что ваши догадки?

336
00:20:43,120 --> 00:20:47,250
Что я на самом деле происходит, чтобы увидеть, если я набрал в привет в нижнем регистре?

337
00:20:47,250 --> 00:20:52,280
Что будет напечатана? >> [Неразборчиво ответ студента] >> Что это такое?

338
00:20:52,280 --> 00:20:58,360
[Студент] Big H, а остальные маленькие. >> Большого H и остальные небольшие, для которых, с или т?

339
00:20:58,360 --> 00:21:03,170
[Студент], и другое. >> Другое. Именно так. Итак, давайте посмотрим, что происходит здесь.

340
00:21:03,170 --> 00:21:08,380
>> Позвольте мне идти дальше и собрать это. Это copy1, так что copy1. Хорошо.

341
00:21:08,380 --> 00:21:14,840
Увеличить масштаб Позвольте мне идти вперед и работать copy1, Enter Сказать что-нибудь: привет в нижнем регистре.

342
00:21:14,840 --> 00:21:19,570
Это капитализируются копию, но он, очевидно, капитализируются оригинальные, а также,

343
00:21:19,570 --> 00:21:22,070
потому что то, что сейчас происходит в этой истории?

344
00:21:22,070 --> 00:21:27,030
В строке 27 я на самом деле не кажется, копирование строки,

345
00:21:27,030 --> 00:21:30,450
но даже если вы, возможно, интуитивно надеялась, что будет так,

346
00:21:30,450 --> 00:21:33,680
если вы думаете об этой картине, что на самом деле я сделал?

347
00:21:33,680 --> 00:21:35,410
Половина картина та же.

348
00:21:35,410 --> 00:21:39,390
Так что давайте откат во времени, так что т еще не существует в истории.

349
00:21:39,390 --> 00:21:43,160
S может существовать в истории, но давайте нижний привет в этот раз.

350
00:21:43,160 --> 00:21:46,710
Итак, позвольте мне исправить то, что я на самом деле ввели дюйма

351
00:21:46,710 --> 00:21:51,280
В этом случае здесь мы имеем ч-е-л-л-о.

352
00:21:51,280 --> 00:21:58,050
Мы будем рисовать его как последовательность символов, положил разделительные линии здесь, и моя \ 0.

353
00:21:58,050 --> 00:22:05,980
Так что это, где мы находимся, как только линия от 1 до 24-иш, плюс-минус, выполнили.

354
00:22:05,980 --> 00:22:07,800
Это фотография моей памяти.

355
00:22:07,800 --> 00:22:10,800
Когда я добираюсь до линии 27, что происходит?

356
00:22:10,800 --> 00:22:14,730
Как и раньше, я получаю указатель, который я нарисую, как эту площадь.

357
00:22:14,730 --> 00:22:19,740
Это называется тонн. И то, что его значение по умолчанию? Кто знает? Некоторые мусора значение.

358
00:22:19,740 --> 00:22:22,060
>> Так что я буду абстрактным, что далеко, как знак вопроса.

359
00:22:22,060 --> 00:22:27,670
И как только правую сторону линии 27 выполняет, что я положить внутрь т?

360
00:22:27,670 --> 00:22:30,770
То же самое, что находится в с.

361
00:22:30,770 --> 00:22:34,120
Поэтому, если мы на мгновение удалить эту абстракцию, указанном стрелкой, и мы говорим,

362
00:22:34,120 --> 00:22:40,330
О, это память адрес загрузки 123, когда вы говорите т получает с, точка с запятой,

363
00:22:40,330 --> 00:22:42,700
Вы буквально положить 123 здесь.

364
00:22:42,700 --> 00:22:45,200
Теперь, если мы как-то упростить наш мир снова с фотографиями,

365
00:22:45,200 --> 00:22:48,750
то, что вы действительно сделали просто добавляется еще одну стрелу в свой мир

366
00:22:48,750 --> 00:22:52,910
который указывает с т в точно такой же строку.

367
00:22:52,910 --> 00:22:59,730
Поэтому, когда в строке 31 и 32 я на самом деле идти об изменении т [0]

368
00:22:59,730 --> 00:23:05,580
что T [0] по-видимому синонимом сейчас? с [0]

369
00:23:05,580 --> 00:23:07,030
Так что все, что происходит.

370
00:23:07,030 --> 00:23:09,900
И хотя этот вид чувствует себя немного низком уровне и тайные

371
00:23:09,900 --> 00:23:12,760
и такого рода чувство, что, возможно, интуитивно это должно было бы просто работал -

372
00:23:12,760 --> 00:23:15,410
Я сделал копии раньше, и он просто работал -

373
00:23:15,410 --> 00:23:18,590
если вы на самом деле думаете о том, что строка на самом деле, это символ *.

374
00:23:18,590 --> 00:23:21,700
Ну, что это такое? Это адрес некоторых характера.

375
00:23:21,700 --> 00:23:24,930
Тогда, возможно, имеет смысл, когда вы пытаетесь сделать что-то

376
00:23:24,930 --> 00:23:29,220
Супер казалось бы, простой, как это, все, что вы делаете, копирование адреса памяти.

377
00:23:29,220 --> 00:23:32,530
Вы на самом деле не делают ничего с самой строки.

378
00:23:32,530 --> 00:23:37,500
Так что даже если вы понятия не имеете, как бы вы решить эту проблему в коде,

379
00:23:37,500 --> 00:23:45,080
высоком уровне, концептуально, что мы должны сделать для того, чтобы та подлинная копия с, по-видимому?

380
00:23:46,670 --> 00:23:48,820
Да. >> [Студент] дать ему новое место? >> Именно так.

381
00:23:48,820 --> 00:23:50,800
>> Мы должны дать т новом месте.

382
00:23:50,800 --> 00:23:55,230
Нам нужно каким-то образом создать мир, в котором мы получаем новый кусок памяти,

383
00:23:55,230 --> 00:24:00,090
которые просто для ясности я буду рисовать прямо под этим, но это не должны быть там.

384
00:24:00,090 --> 00:24:04,880
Но она должна быть того же размера, так что я буду рисовать эти вертикальные линии в том же месте.

385
00:24:04,880 --> 00:24:09,720
Это нормально, если это все фигня на начальном этапе. Кто знает, что там было?

386
00:24:09,720 --> 00:24:13,850
Но шаг 1 будет нужно, дайте мне столько памяти, сколько мне нужно

387
00:24:13,850 --> 00:24:18,630
, чтобы соответствовать копию привет, а затем выяснить, как скопировать ч здесь, электронную здесь,

388
00:24:18,630 --> 00:24:20,390
л Здесь и так далее.

389
00:24:20,390 --> 00:24:24,880
Но это уже должны чувствовать себя немного очевидна, даже если некоторые детали все еще абстрактно.

390
00:24:24,880 --> 00:24:28,690
Чтобы скопировать эту строку в этом, это просто цикл или время цикла

391
00:24:28,690 --> 00:24:31,580
или то, с чем вы стали все более знакомым.

392
00:24:31,580 --> 00:24:35,970
Так давайте попробуем это. Отпустите меня в copy2.c.

393
00:24:35,970 --> 00:24:43,270
В copy2.c мы имеем почти ту же программу, за исключением линии 27.

394
00:24:43,270 --> 00:24:47,260
Это выглядит немного сложным, но если мы разбить его по частям,

395
00:24:47,260 --> 00:24:48,950
левая сторона то же самое.

396
00:24:48,950 --> 00:24:52,790
Char * т создает эту вещь в памяти, хотя и со знаком вопроса

397
00:24:52,790 --> 00:24:54,680
потому что мы понятия не имеем, что там по умолчанию.

398
00:24:54,680 --> 00:24:57,920
На правой стороне мы сейчас внедряют новые функции, таНос,

399
00:24:57,920 --> 00:25:00,640
на память выделить, дай мне памяти,

400
00:25:00,640 --> 00:25:06,900
и он, очевидно, берет, сколько аргументов, сколько вещей в скобках?

401
00:25:09,660 --> 00:25:12,130
Я услышал ропот 1 и 2, но это всего лишь 1.

402
00:25:12,130 --> 00:25:15,320
Там нет запятой, которая означает, что есть только 1 вещь в круглых скобках.

403
00:25:15,320 --> 00:25:17,720
Хотя есть другие скобки, позвольте мне подчеркнуть

404
00:25:17,720 --> 00:25:21,460
то, что внутри самой внешней скобки, и именно это выражение:

405
00:25:21,460 --> 00:25:25,880
(StrLen (ы) + 1) * SizeOf (Char).

406
00:25:25,880 --> 00:25:29,190
Таким образом, если мы на самом деле думаю, что это до конца, это говорит мне длины с.

407
00:25:29,190 --> 00:25:34,440
Почему я, правда, добавив 1 на длине? >> [Неразборчиво ответ студента]

408
00:25:34,440 --> 00:25:40,200
Именно так. Нам нужно место для этого парня в хвост, шестой символ, который не имеет смысла английском

409
00:25:40,200 --> 00:25:42,250
но есть специальные программные смысл.

410
00:25:42,250 --> 00:25:46,800
>> Так что нам нужно + 1 за это, потому StrLen возвращает человека ожидание длины,

411
00:25:46,800 --> 00:25:50,890
привет или 5, это не дает вам дополнительные нулевого символа.

412
00:25:50,890 --> 00:25:52,980
Так что я вручную добавить это с + 1.

413
00:25:52,980 --> 00:25:56,060
И тогда это, * размер (символ), мы не видели этого раньше.

414
00:25:56,060 --> 00:25:57,480
Это технически не является функцией.

415
00:25:57,480 --> 00:26:04,150
Это специальное ключевое слово, которое просто говорит вам, что размер некоторых типов данных на компьютере

416
00:26:04,150 --> 00:26:06,980
потому что в действительности, некоторые из нас имеют 32-разрядных компьютерах.

417
00:26:06,980 --> 00:26:10,900
У меня довольно старый компьютер дома, и он использует только 32 бита для представления указателей.

418
00:26:10,900 --> 00:26:13,900
И поэтому, если я сделал размер типа данных, это может быть 32 бит.

419
00:26:13,900 --> 00:26:18,300
Но если я использую мой новый модный компьютер, я мог бы вернуть значение 64 бит

420
00:26:18,300 --> 00:26:20,510
что-то вроде адреса.

421
00:26:20,510 --> 00:26:25,400
Таким образом, в этом случае, просто, чтобы быть супер безопасно, мы не собираемся на жестком что-то вроде кода -

422
00:26:25,400 --> 00:26:28,740
Ну, что размер символов в зависимости от того, что мы говорили до сих пор?

423
00:26:28,740 --> 00:26:34,450
Мы в значительной степени сказал устно, что это 1 байт, и, что очень много истинных через борт.

424
00:26:34,450 --> 00:26:37,000
Но, опять же, предположения, как правило, плохой.

425
00:26:37,000 --> 00:26:40,850
Они приводят к ошибки в программном обеспечении, если люди используют программное обеспечение таким образом, вы не намерены.

426
00:26:40,850 --> 00:26:44,750
Так что давайте это абстрактное, и прямо говорить в более общем

427
00:26:44,750 --> 00:26:46,830
Мне это нужно много участков памяти

428
00:26:46,830 --> 00:26:50,210
и каждый кусок памяти должна быть эквивалентна размеру характера,

429
00:26:50,210 --> 00:26:54,870
который на самом деле равна 1 в этом случае, но это более общий способ написания.

430
00:26:54,870 --> 00:27:00,460
Таким образом, если слово привет, сколько байт делает таНос видимо выделить на что-нибудь?

431
00:27:00,460 --> 00:27:04,980
[Студент] Six. >> Шесть. Ровно столько, сколько мы имеем знаки вопроса на экране.

432
00:27:04,980 --> 00:27:07,800
А потом сделать предположение теперь основана на ваше понимание GetString

433
00:27:07,800 --> 00:27:12,790
Что же таНос, вероятно, вернутся? >> [Студент] адрес.

434
00:27:12,790 --> 00:27:17,020
Адрес какой? Из первого блока памяти.

435
00:27:17,020 --> 00:27:20,670
>> Мы понятия не имеем, что там, потому что некоторые другие функции

436
00:27:20,670 --> 00:27:23,010
можно было бы с помощью этой памяти ранее.

437
00:27:23,010 --> 00:27:28,380
Но таНос, как GetString, возвращает адрес первого байта памяти

438
00:27:28,380 --> 00:27:30,540
что он выделил для вас.

439
00:27:30,540 --> 00:27:38,380
Однако то, что оно не сделать, это заполнить этот пробел с нулевого символа обратной косой черты

440
00:27:38,380 --> 00:27:43,030
потому что оказывается, можно использовать таНос выделить все: целые, строки, массивы,

441
00:27:43,030 --> 00:27:45,700
поплавки, студент структур.

442
00:27:45,700 --> 00:27:47,750
Вы можете использовать таНос полностью в общих чертах.

443
00:27:47,750 --> 00:27:51,470
Он не заботится или должны знать, что вы выделение памяти для.

444
00:27:51,470 --> 00:27:55,810
Поэтому было бы самонадеянно таНос поставить \ 0

445
00:27:55,810 --> 00:27:58,340
В конце каждого блока памяти это дает вам

446
00:27:58,340 --> 00:28:02,620
потому что это \ 0 вещь просто конвенцию для строк.

447
00:28:02,620 --> 00:28:06,310
Она не используется для целых чисел, он не используется для поплавков, он не используется для студентов.

448
00:28:06,310 --> 00:28:11,730
И так Гоча с таНос в том, что бремя полностью на вас программист

449
00:28:11,730 --> 00:28:16,790
вспомнить, сколько байтов выделяются и не когда-нибудь использовать для цикла

450
00:28:16,790 --> 00:28:21,570
или петлю, и пройти мимо границы блока памяти вы получили.

451
00:28:21,570 --> 00:28:23,540
Иными словами, как только вы выделить память,

452
00:28:23,540 --> 00:28:28,510
Вы не можете спросить операционной системы, ой, кстати, насколько большой кусок памяти это было?

453
00:28:28,510 --> 00:28:32,080
Это полностью зависит от вас, чтобы помнить, если вы нуждаетесь в этом ценность.

454
00:28:32,080 --> 00:28:34,330
>> Итак, давайте посмотрим, как я приступить к использованию этой памяти.

455
00:28:34,330 --> 00:28:38,430
В строке 28 и 29, почему я это делаю?

456
00:28:39,850 --> 00:28:42,260
Только общая проверка вменяемости.

457
00:28:42,260 --> 00:28:45,110
Только в случае, если что-то пошло не так, я прошу какой-то сумасшедший объем памяти

458
00:28:45,110 --> 00:28:48,690
или я так много работает на компьютере, что там просто не хватает памяти,

459
00:28:48,690 --> 00:28:51,780
что-то вроде этого, я по крайней мере хотите проверить на NULL.

460
00:28:51,780 --> 00:28:55,260
В действительности, большинство компьютеров даст вам иллюзию, что все программы

461
00:28:55,260 --> 00:28:57,080
Можно использовать совокупность оперативной памяти,

462
00:28:57,080 --> 00:29:00,740
но даже в этом случае, если пользователь вводит некоторые сумасшедшие длинную строку, может быть, потому, что они плохого парня

463
00:29:00,740 --> 00:29:03,440
и они на самом деле пытаются привести к сбою программы или взломать его,

464
00:29:03,440 --> 00:29:07,300
Вы хотите, чтобы по крайней мере проверить возвращаемое значение таНос и будет ли она равна нулю.

465
00:29:07,300 --> 00:29:11,630
И если это так, давайте просто бросить прямо сейчас, потому что я не знаю, что делать в этом случае.

466
00:29:11,630 --> 00:29:13,950
Как скопировать строку? Там есть несколько способов сделать это.

467
00:29:13,950 --> 00:29:18,850
Есть ул скопировать функции в C, но это супер просто для нас, чтобы сделать это старомодным способом.

468
00:29:18,850 --> 00:29:23,110
>> Прежде всего позвольте мне выяснить, что длина ы есть.

469
00:29:23,110 --> 00:29:26,930
Я мог бы сделать это в цикле, но вместо этого я просто положил его здесь для ясности.

470
00:29:26,930 --> 00:29:30,610
Таким образом, п теперь хранит длину исходной строки, по-видимому, 5.

471
00:29:30,610 --> 00:29:35,290
Тогда в моей цикла я итерации от 0 о до п,

472
00:29:35,290 --> 00:29:40,940
и на каждой итерации я ставлю с [я] внутри т [I].

473
00:29:40,940 --> 00:29:45,060
Так вот что я подразумевал с моими 2-мя пальцами, указывая на строк до.

474
00:29:45,060 --> 00:29:49,260
Как это цикл итерации, как это, я собираюсь быть копирования ч в здесь,

475
00:29:49,260 --> 00:29:52,890
е в здесь, я здесь, потому что в это с, это т.

476
00:29:52,890 --> 00:29:58,770
И тогда, наконец, в строке 35, почему я это делаю?

477
00:29:58,770 --> 00:30:03,770
Мне нужно, чтобы убедиться, что я в конечном строку тонн.

478
00:30:03,770 --> 00:30:06,170
И я сделал это таким образом, чтобы быть супер явным.

479
00:30:06,170 --> 00:30:09,510
Но предлагаю, кто-то, если бы вы могли, различных способов сделать это.

480
00:30:09,510 --> 00:30:13,930
Я действительно не нужна строка 35. Там еще один способ сделать это.

481
00:30:13,930 --> 00:30:18,880
Да. >> [Неразборчиво ответ студента] >> Скажи это громче.

482
00:30:18,880 --> 00:30:20,960
[Студент] меньше или равно. >> Именно так.

483
00:30:20,960 --> 00:30:24,450
Мы могли бы просто сказать, меньше или равно N, которое вообще было плохо

484
00:30:24,450 --> 00:30:28,190
потому что почти всегда, когда мы идем в равной вещи мы рассчитываем

485
00:30:28,190 --> 00:30:30,000
мы идем 1 шаг слишком далеко.

486
00:30:30,000 --> 00:30:32,170
Но помните, сколько байтов ли мы выделить?

487
00:30:32,170 --> 00:30:37,210
Мы выделили из StrLen с, поэтому 5 + 1 на общую сумму 6.

488
00:30:37,210 --> 00:30:39,980
Так что в этом случае мы могли бы сделать что-то вроде этого

489
00:30:39,980 --> 00:30:46,450
так что мы копирования не только привет, но и \ 0 в самом конце.

490
00:30:46,450 --> 00:30:49,860
Кроме того, мы могли бы использовать функцию ул копия, зЬгсру,

491
00:30:49,860 --> 00:30:51,700
но это не было бы почти так же весело.

492
00:30:51,700 --> 00:30:54,000
Но это все, что он делает под капотом.

493
00:30:54,000 --> 00:30:56,050
Тогда, наконец, мы делаем то же самое, что и раньше.

494
00:30:56,050 --> 00:31:01,620
Я капитализировать т, а затем я утверждаю, что оригинальная выглядит следующим образом и копия выглядит так.

495
00:31:01,620 --> 00:31:08,570
Так давайте попробуем это сейчас. Отпусти меня здесь. Сделать copy2. Мы будем увеличивать и запустить copy2.

496
00:31:08,570 --> 00:31:13,840
Я собираюсь ввести привет в нижнем регистре, да и я получаю нижний привет, как оригинал

497
00:31:13,840 --> 00:31:16,930
но капитал Здравствуйте для копирования.

498
00:31:16,930 --> 00:31:20,300
Но я не сделал только пока. Мне нужно сделать 1 последняя вещь здесь.

499
00:31:20,300 --> 00:31:28,000
46 и 47 четко освобождая оперативную память, но что это на самом деле означает?

500
00:31:28,000 --> 00:31:33,250
Что я делаю, как ты думаешь, позвонив по телефону линии 46 и линии 47?

501
00:31:33,250 --> 00:31:38,900
Какие последствия это имеет? Да.

502
00:31:38,900 --> 00:31:43,140
[Неразборчиво ответ студента] >> Именно так.

503
00:31:43,140 --> 00:31:46,380
>> Вы просто говорите операционной системы, привет, спасибо за эту память.

504
00:31:46,380 --> 00:31:48,320
Теперь вы можете использовать его для кого-то еще.

505
00:31:48,320 --> 00:31:50,790
А вот прекрасный пример мусор значения.

506
00:31:50,790 --> 00:31:55,430
Я только что использовал эту память, чтобы записать слово привет в 2 местах,

507
00:31:55,430 --> 00:31:57,490
здесь, здесь, здесь, и здесь.

508
00:31:57,490 --> 00:32:00,910
Таким образом, это ч-е-л-л-о-\ 0.

509
00:32:00,910 --> 00:32:06,960
Но потом я называть линией 46 и линией 47, и вы знаете, что там происходит, с точки зрения картина?

510
00:32:06,960 --> 00:32:10,010
На самом деле, подождите, эта картина старого.

511
00:32:10,010 --> 00:32:12,550
Как только мы сделать копию, этот парень на самом деле указывает здесь,

512
00:32:12,550 --> 00:32:16,110
так что давайте удалить цифры и просто абстрагироваться от, как наши стрелки снова.

513
00:32:16,110 --> 00:32:19,370
Что происходит в этой картине, когда я звоню бесплатно?

514
00:32:19,370 --> 00:32:22,750
[Неразборчиво ответ студента] >> Не четными.

515
00:32:22,750 --> 00:32:29,510
Если я позвоню бесплатно на с и т - своего рода вопрос с подвохом - это картина не меняется на всех

516
00:32:29,510 --> 00:32:33,880
потому, что вызов и вызов с т просто говорит операционной системе,

517
00:32:33,880 --> 00:32:39,010
эй, вы можете использовать эту память снова, но это не меняет этого до нуля

518
00:32:39,010 --> 00:32:41,840
или специальными символами, это не изменить,

519
00:32:41,840 --> 00:32:47,350
это не меняет ч или электронной или л или л или вывода в любом месте ни с чем.

520
00:32:47,350 --> 00:32:51,610
С точки зрения картину, как только Вы звоните бесплатно, ничего не меняется.

521
00:32:51,610 --> 00:32:56,570
И в этом заключается происхождение мусора значения, потому что если я потом в этой программе

522
00:32:56,570 --> 00:33:01,010
спросите операционной системы для дополнительной памяти с GetString или таНос или что-то вроде того

523
00:33:01,010 --> 00:33:04,900
и операционная система говорит, конечно, у меня есть 12 байт памяти только освободили,

524
00:33:04,900 --> 00:33:08,080
использовать их, что вы собираетесь быть переданы?

525
00:33:08,080 --> 00:33:10,830
Вы собираетесь быть передана часть памяти, что мы обычно используют

526
00:33:10,830 --> 00:33:13,700
с вопросительными знаками, но то, что эти знаки вопроса?

527
00:33:13,700 --> 00:33:17,000
Они, оказывается, ч-е-л-л-о, ч-е-л-л-о.

528
00:33:17,000 --> 00:33:20,940
Это наши новые значения мусором, как только вы освободить эту память.

529
00:33:20,940 --> 00:33:22,750
>> Там в реальном мире импликации здесь.

530
00:33:22,750 --> 00:33:24,720
Это происходит, делать с оперативной памятью, но ваши компьютеры

531
00:33:24,720 --> 00:33:26,720
на самом деле сделать то же самое с диска.

532
00:33:26,720 --> 00:33:30,620
Мы поговорим об этом, в частности, с будущим поставленной задачи, которая фокусируется на судебной экспертизы.

533
00:33:30,620 --> 00:33:36,170
Но то, что происходит на самом деле если у вас есть некоторые чувствительные финансовые файл на рабочем столе

534
00:33:36,170 --> 00:33:39,600
или некоторые отрывочные JPEG, и вы перетащите его в мусор,

535
00:33:39,600 --> 00:33:44,390
что происходит, когда вы перетащите его в мусорное ведро или корзину?

536
00:33:44,390 --> 00:33:47,240
Вы знали, что я говорю. [Смех]

537
00:33:47,240 --> 00:33:52,370
Что происходит, когда вы вытащили, что доказательства в корзины или мусорное ведро?

538
00:33:52,370 --> 00:33:55,920
[Неразборчиво ответ студента]

539
00:33:55,920 --> 00:33:58,000
Ну, так что осторожнее. Что происходит, когда вы это делаете?

540
00:33:58,000 --> 00:34:01,030
Короткий ответ: ничего, верно?

541
00:34:01,030 --> 00:34:04,790
Эскизные или чувствительной файл по-прежнему просто сидел там где-то на вашем жестком диске.

542
00:34:04,790 --> 00:34:07,940
Большинство из нас хотя бы научились на горьком опыте, что вам нужно, чтобы очистить ваш мусор

543
00:34:07,940 --> 00:34:10,429
или корзины на самом деле удаления файлов.

544
00:34:10,429 --> 00:34:13,440
И в самом деле, когда вы щелкните правой кнопкой мыши или щелкните на управление вашим мусорное ведро

545
00:34:13,440 --> 00:34:15,580
или выберите Файл, Empty Trash или любой другой

546
00:34:15,580 --> 00:34:21,420
и вы на самом деле очистить мусорную корзину или корзины, что на самом деле происходит, то в этой картине?

547
00:34:22,810 --> 00:34:25,969
Больше ничего. Так что ничего на самом деле происходит на диске.

548
00:34:25,969 --> 00:34:30,880
>> И если мы просто временно отвлечься и писать - I'll просто использовать заднюю этого.

549
00:34:30,880 --> 00:34:34,639
Так что теперь история меняется от RAM, который является, где существуют программы

550
00:34:34,639 --> 00:34:39,250
в то время как вы работаете них, на диске, который является, где они хранятся долгосрочные

551
00:34:39,250 --> 00:34:42,920
даже тогда, когда власть уходит, на данный момент - и мы вернемся к этому в будущем -

552
00:34:42,920 --> 00:34:46,380
давайте просто делать вид, что это представляет собой жесткий диск внутри компьютера

553
00:34:46,380 --> 00:34:50,110
потому что еще в тот день они привыкли быть круглыми дисками, так же, как дискеты.

554
00:34:50,110 --> 00:34:55,130
Так что если у вас есть некоторые чувствительные файлов Excel, он может взять на себя эту часть памяти

555
00:34:55,130 --> 00:34:59,770
на диске вашего компьютера, и я просто рисование же произвольного 1 и 0.

556
00:34:59,770 --> 00:35:03,970
Когда вы перетащите файл так, чтобы ваше мусорное ведро или корзины,

557
00:35:03,970 --> 00:35:07,750
буквально ничего не происходит потому, что компании Apple и Microsoft только что решили

558
00:35:07,750 --> 00:35:10,450
мусорное ведро и корзины самом деле это просто временные рамки.

559
00:35:10,450 --> 00:35:14,710
Может быть, в конце концов ОС будет очистить его для вас, но, как правило, он ничего не делает,

560
00:35:14,710 --> 00:35:17,090
по крайней мере, до тех пор пока вы действительно мало места.

561
00:35:17,090 --> 00:35:20,870
>> Тем не менее, когда вы идете в пустые мусор или пустые корзины,

562
00:35:20,870 --> 00:35:23,460
Аналогично, ничего не происходит в этой картине.

563
00:35:23,460 --> 00:35:28,590
Все, что происходит в другом месте на вашем компьютере, есть своего рода таблице.

564
00:35:28,590 --> 00:35:35,400
Это вроде как маленькая шпаргалка, которая говорит, что, скажем, resume.doc,

565
00:35:35,400 --> 00:35:40,920
так что ваше резюме в файл Microsoft Word жили на месте 123 на жестком диске,

566
00:35:40,920 --> 00:35:43,710
не в памяти, а не в памяти, а на жестком диске,

567
00:35:43,710 --> 00:35:49,050
и вашим отрывочным жизни JPEG на 456, и ваш файл Excel живет на 789 или где угодно.

568
00:35:49,050 --> 00:35:53,640
Когда вы удаляете файлы на самом деле опорожнения корзины или корзины,

569
00:35:53,640 --> 00:35:59,530
эта картина не меняется. 0 и 1 на жестком диске никуда не хожу.

570
00:35:59,530 --> 00:36:03,930
Но эта таблица, эта маленькая база данных сортов, меняется.

571
00:36:03,930 --> 00:36:08,750
При удалении вашего резюме, это как если бы файл удаляется, в некотором смысле,

572
00:36:08,750 --> 00:36:12,790
но компьютер не будет забывать, где эта штука живет на вашем жестком диске.

573
00:36:12,790 --> 00:36:17,870
0 и 1, которые составляют ваше резюме или любой из этих других файлов остаются нетронутыми.

574
00:36:17,870 --> 00:36:21,960
>> Так что если вы сделали это случайно, еще есть ненулевая вероятность

575
00:36:21,960 --> 00:36:25,800
что вы можете восстановить данные с помощью Нортон Утилиты и некоторые коммерческие программы

576
00:36:25,800 --> 00:36:29,810
чьи цели в жизни, чтобы найти 0 и 1, которые вроде сироты,

577
00:36:29,810 --> 00:36:33,300
забыли здесь, но оставил здесь, так что вы можете получить ваши данные обратно.

578
00:36:33,300 --> 00:36:38,410
Или судебных следователей полиции или ФБР будет на самом деле взять жесткий диск

579
00:36:38,410 --> 00:36:42,550
а на самом деле искать образцы из 0 и 1, которые выглядят как JPEG, выглядят как файлы Excel,

580
00:36:42,550 --> 00:36:46,400
и восстановить их таким образом, даже если компьютер забыла их там.

581
00:36:46,400 --> 00:36:49,820
Поэтому единственный способ действительно удалить данные, как мы будем обсуждать в будущем,

582
00:36:49,820 --> 00:36:54,190
это, чтобы вычистить или стереть файл или жесткий диск -

583
00:36:54,190 --> 00:36:56,540
Вы не можете реально избавиться от 0 и 1

584
00:36:56,540 --> 00:36:59,440
потому что иначе вы бы начать с гигабайтный жесткий диск

585
00:36:59,440 --> 00:37:02,380
и вы в конечном итоге с мегабайта жесткого диска, если вы постоянно были удаления,

586
00:37:02,380 --> 00:37:04,380
буквально, 0 и 1.

587
00:37:04,380 --> 00:37:06,310
Итак, что бы вы сделали, если бы вы действительно хотели, чтобы замести следы

588
00:37:06,310 --> 00:37:10,510
и основной проблемой является то, что еще есть 0 и 1 на диске?

589
00:37:10,510 --> 00:37:14,930
Я вижу, кто-то жестикулируя, что вы физически сломать устройство. Это будет работать.

590
00:37:14,930 --> 00:37:19,600
[Смеется] Но если это своего рода дорогое решение, что было бы более разумным?

591
00:37:19,600 --> 00:37:23,270
Да. >> [Студент] переписать их. >> Перезаписать их что ли? >> [Студент] Другие данные.

592
00:37:23,270 --> 00:37:29,070
Другие данные. Вы можете просто перезаписать диск с 0s и 1s или все 0s, все 1s.

593
00:37:29,070 --> 00:37:31,230
>> И это действительно то, что некоторые программы делает.

594
00:37:31,230 --> 00:37:33,570
Вы можете купить программное обеспечение или даже получить бесплатное программное обеспечение,

595
00:37:33,570 --> 00:37:36,610
и даже встроенную в Mac OS в эти дни, в меньшей степени в Windows,

596
00:37:36,610 --> 00:37:38,660
является способность надежно стирать.

597
00:37:38,660 --> 00:37:41,960
На самом деле, если вы хотите, чтобы все бегут домой сегодня, если у вас есть Mac и сделать это,

598
00:37:41,960 --> 00:37:45,740
если у вас есть некоторые вещи в вашей мусорное ведро, вы можете сделать Безопасность Empty Trash,

599
00:37:45,740 --> 00:37:47,610
который делает именно это.

600
00:37:47,610 --> 00:37:53,350
Вместо того чтобы просто стереть файлы здесь, она не стирает 0 и 1 здесь,

601
00:37:53,350 --> 00:38:01,240
скорее, он просто меняет их, например, на 0 и точка, точка, точка.

602
00:38:01,240 --> 00:38:05,330
Поэтому одной из ваших будущих psets на самом деле будет намеренно восстановления данных -

603
00:38:05,330 --> 00:38:08,430
фотографии, которые мы взяли людей, мест и вещей на территории кампуса

604
00:38:08,430 --> 00:38:12,810
, для которого мы будем делать судебно изображение карты памяти цифровой камеры,

605
00:38:12,810 --> 00:38:17,120
который является точно такой же идеей - и вы будете иметь, чтобы быть оспорены на самом деле найти

606
00:38:17,120 --> 00:38:20,160
моделей, которые представляют собой изображения в формате JPEG на жесткий диск,

607
00:38:20,160 --> 00:38:23,610
так же, как, что бывший студент, письмо, которое я прочитал несколько недель назад сделал

608
00:38:23,610 --> 00:38:25,860
восстановить фотографии своей сестры.

609
00:38:25,860 --> 00:38:30,300
Почему бы нам не взять 5-минутный перерыв здесь, и мы перегруппироваться более на память.

610
00:38:33,030 --> 00:38:38,610
Так вот где все становится немного галлюциногенный, но это очень мощный шаг

611
00:38:38,610 --> 00:38:40,480
к пониманию этого все больше.

612
00:38:40,480 --> 00:38:42,900
Вот программа под названием pointers.c.

613
00:38:42,900 --> 00:38:45,430
Он является одним из образцов кода сегодня.

614
00:38:45,430 --> 00:38:51,280
Обратите внимание, что в первые несколько строк, с 19 по 22, все, что мы делаем что-то вроде GetString

615
00:38:51,280 --> 00:38:54,460
и возвращение адреса, хранение в с.

616
00:38:54,460 --> 00:38:58,380
В дальнейшем для PSET даже 3, если вы хотите, но PSET 4 и на

617
00:38:58,380 --> 00:39:01,030
где вы можете начать принимать эти учебные колес от себя,

618
00:39:01,030 --> 00:39:04,030
нет никаких причин делать вид, что строки существует.

619
00:39:04,030 --> 00:39:07,030
Это, конечно, хорошо, чтобы просто начать говорить символ *.

620
00:39:07,030 --> 00:39:12,610
>> Как в стороне, в онлайн-справочниках и книгах вы можете часто видеть на звездочку рядом с переменной.

621
00:39:12,610 --> 00:39:15,600
Вы даже можете видеть пространство вокруг обе стороны от него.

622
00:39:15,600 --> 00:39:17,680
Все эти функционально правильно.

623
00:39:17,680 --> 00:39:21,180
Сейчас, однако, мы будем стандартизировать этот подход, чтобы сделать Super Clear

624
00:39:21,180 --> 00:39:24,000
, что символ *, как говорят указатель на символ.

625
00:39:24,000 --> 00:39:25,680
Это тип данных.

626
00:39:25,680 --> 00:39:28,730
А затем имя переменной с в этом случае.

627
00:39:28,730 --> 00:39:31,180
Таким образом, мы получили строку, и мы назвали ее с.

628
00:39:31,180 --> 00:39:35,180
А потом сюда, заметили, что я делаю на самом деле немного хитрости.

629
00:39:35,180 --> 00:39:39,080
Это называется арифметика указателей, которая является своего рода супер просто.

630
00:39:39,080 --> 00:39:41,790
Это просто означает, складывать и вычитать номера указателей.

631
00:39:41,790 --> 00:39:43,660
Но это на самом деле работает.

632
00:39:43,660 --> 00:39:49,170
Эта программа по-видимому печатает 1 символ строки с на линию таким образом, что конечный результат -

633
00:39:49,170 --> 00:39:54,920
Точно так же мы можем испортить, где это происходит, сделать указатели, указатели работать, позвольте мне изменить масштаб изображения

634
00:39:54,920 --> 00:39:58,940
Теперь позвольте мне типа в нечто вроде привет и тип Enter

635
00:39:58,940 --> 00:40:01,080
и он печатает 1 символа в строке.

636
00:40:01,080 --> 00:40:04,730
До секунду назад, мы бы сделали это с квадратными обозначение кронштейна.

637
00:40:04,730 --> 00:40:09,760
Мы бы цикл, и мы будем делать Printf с [я], и мы будем делать это снова и снова и снова

638
00:40:09,760 --> 00:40:11,950
с обратной косой чертой п в конце каждой строки.

639
00:40:11,950 --> 00:40:16,800
Но эта программа отличается. Эта программа используется, в буквальном смысле, арифметика.

640
00:40:16,800 --> 00:40:18,860
Так что же здесь происходит?

641
00:40:18,860 --> 00:40:24,720
Прежде всего, до этого цикл выполняет даже то, что, просто чтобы быть ясно, является на самом деле?

642
00:40:24,720 --> 00:40:27,270
S есть? >> [Студент] адрес. >> Адрес.

643
00:40:27,270 --> 00:40:32,980
>> И это адрес, в случае здравствуй, первый символ в том, что слово, которое час.

644
00:40:32,980 --> 00:40:37,370
Так что с есть, в данном конкретном примере, адрес час.

645
00:40:37,370 --> 00:40:41,850
Так что же это значит сделать с + я?

646
00:40:41,850 --> 00:40:46,280
Ну, я начинается с 0 в этом цикл. Мы делали это много раз.

647
00:40:46,280 --> 00:40:49,760
Я намерен идти до длины строки, видимо.

648
00:40:49,760 --> 00:40:53,950
Таким образом, на первой итерации этого цикла, я, очевидно, 0.

649
00:40:53,950 --> 00:41:01,740
Таким образом, это выражение говорил с + я - скорее, с +0--это, очевидно, только с.

650
00:41:01,740 --> 00:41:04,320
Так что же такое * с здесь?

651
00:41:04,320 --> 00:41:08,530
Сейчас мы используем звезда в несколько иной путь.

652
00:41:08,530 --> 00:41:13,080
Позвольте мне идти вперед и избавиться от т, потому что мы сделали говорим о т и копии с.

653
00:41:13,080 --> 00:41:15,540
Сейчас мы просто хотим, чтобы рассказать историю с участием с.

654
00:41:15,540 --> 00:41:20,090
И вот в этот момент, после того, как тип строки, наш мир выглядит совсем как это было раньше

655
00:41:20,090 --> 00:41:26,630
всего с хранением адрес ч и в более общем указывая на строку привет.

656
00:41:26,630 --> 00:41:33,170
Если я сейчас делаю такую ​​строку * (S + I), давайте попробуем это.

657
00:41:33,170 --> 00:41:40,140
Так * (S + I). Позвольте мне упростить это, потому что это 0, так что это * (S +0).

658
00:41:40,140 --> 00:41:43,790
Ну, подожди минутку. Упрощение дальше. Это * (с).

659
00:41:43,790 --> 00:41:47,020
Ну, а теперь скобках являются своего рода глупым, так что теперь давайте просто делать * с.

660
00:41:47,020 --> 00:41:50,540
Таким образом, в первой итерации этого цикла, что линия которая подчеркнула, 26,

661
00:41:50,540 --> 00:41:53,650
в значительной степени эквивалентно печати этом.

662
00:41:53,650 --> 00:41:56,040
Что такое тип данных * с?

663
00:41:56,040 --> 00:42:00,770
В этом контексте, потому что звезда окажется рядом с себя,

664
00:42:00,770 --> 00:42:04,930
но более конкретно, потому что мы больше не объявив ей,

665
00:42:04,930 --> 00:42:09,730
Мы не создаем переменную больше, нет никакого упоминания символ * в строке 26,

666
00:42:09,730 --> 00:42:14,280
нет никакого упоминания ключевого слова строки, мы просто с помощью переменной с,

667
00:42:14,280 --> 00:42:19,650
Оказывается теперь звезда имеет несколько иной и, надо признать, путая смысл.

668
00:42:19,650 --> 00:42:26,590
* Ы здесь означает перейти по адресу в с и печати все, что есть.

669
00:42:26,590 --> 00:42:33,750
Таким образом, с здесь, * S есть - вроде как желоба и лестницы, следуйте за стрелкой - здесь.

670
00:42:33,750 --> 00:42:35,850
Так что это * с.

671
00:42:35,850 --> 00:42:39,060
>> Так что же получает напечатан на первой итерации этого цикла в строке 26?

672
00:42:39,060 --> 00:42:42,170
Я распечатать% C, который является прототипом для символа,

673
00:42:42,170 --> 00:42:48,520
Затем \ п для новой строки. * (S + I), где я = 0 является именно это.

674
00:42:48,520 --> 00:42:53,670
Так что символ нужно поместить в% для C? H.

675
00:42:53,670 --> 00:42:56,900
В следующей итерации цикла - можно, вероятно, увидеть, где это происходит -

676
00:42:56,900 --> 00:43:01,350
Следующая итерация я, очевидно, 1, так что это означает с +1,

677
00:43:01,350 --> 00:43:05,580
и теперь мне нужно скобки, потому что теперь звезда должна сказать

678
00:43:05,580 --> 00:43:08,620
перейдите по адресу памяти с +1.

679
00:43:08,620 --> 00:43:14,170
Что такое S? Давайте вернуться в прошлое и сказать, что это стрелка сейчас на самом деле не делают нам никаких одолжений.

680
00:43:14,170 --> 00:43:18,450
Давайте более конкретно сказать, что это хранении номер 123

681
00:43:18,450 --> 00:43:25,110
потому что в начале этой строки Здравствуйте, это адрес 123, это 124, и так далее.

682
00:43:25,110 --> 00:43:30,550
Таким образом, на второй итерации, когда я говорю с +1, это, как говорят 123 +1,

683
00:43:30,550 --> 00:43:35,340
иначе известная как 124, так что символ получает напечатан на второй итерации?

684
00:43:35,340 --> 00:43:37,850
E на адрес памяти, 124.

685
00:43:37,850 --> 00:43:44,440
Затем снова +, 125, 126, 127, и эта петля к счастью останавливается, прежде чем мы получим здесь

686
00:43:44,440 --> 00:43:49,040
потому что я использую StrLen чтобы убедиться, что я не считает слишком высокой.

687
00:43:49,040 --> 00:43:50,810
Так что это тоже его.

688
00:43:50,810 --> 00:43:55,000
Опять же, это как если бы мы сделали неделю назад.

689
00:43:55,000 --> 00:43:59,200
Позвольте мне написать его на строку ниже, хотя мы не хотим, чтобы сделать оба.

690
00:43:59,200 --> 00:44:02,500
Это идентично теперь к этому.

691
00:44:02,500 --> 00:44:08,310
>> Поэтому, даже если с собой строку, как мы называем его на недели, а на самом деле символ *.

692
00:44:08,310 --> 00:44:13,270
Поэтому если мы хотим, чтобы быть супер анал, это действительно правильный написать специфика

693
00:44:13,270 --> 00:44:17,490
на г-м месте с помощью этих числовых адресов и эта звезда оператора,

694
00:44:17,490 --> 00:44:20,470
но, честно говоря, это просто так гораздо чище. Таким образом, это не плохо.

695
00:44:20,470 --> 00:44:26,720
Нет причин, чтобы перестать делать линию 27 здесь, но 26 является функционально то же самое,

696
00:44:26,720 --> 00:44:31,570
и это функционально то же ровно причин того, что мы обсуждали до сих пор.

697
00:44:31,570 --> 00:44:33,650
И, наконец, 29 просто хорошая практика.

698
00:44:33,650 --> 00:44:38,420
Вызов бесплатно с означает, что теперь вы даете задний памяти, которая дала вам GetString

699
00:44:38,420 --> 00:44:41,630
потому что снова, как я уже говорил понедельник, GetString недели

700
00:44:41,630 --> 00:44:44,180
внедряет ошибка в коде.

701
00:44:44,180 --> 00:44:46,490
Ваш код недель была утечка памяти

702
00:44:46,490 --> 00:44:49,970
которых вы спрашивали GetString для памяти, но вы никогда не давал его обратно.

703
00:44:49,970 --> 00:44:53,410
И это была сознательно выбрана нами педагогически

704
00:44:53,410 --> 00:44:55,880
потому что это просто слишком много, чтобы думать о начале.

705
00:44:55,880 --> 00:44:57,710
Но теперь нам нужно больше симметрии.

706
00:44:57,710 --> 00:45:00,830
Если вы спросите компьютер для памяти, как и в случае с GetString,

707
00:45:00,830 --> 00:45:02,820
как и в случае видимому таНос,

708
00:45:02,820 --> 00:45:07,970
Вы должны теперь PSET 4 и в последующих также бесплатно любой такой памяти.

709
00:45:07,970 --> 00:45:11,650
Заметьте, что это отличается от того, Int N.

710
00:45:11,650 --> 00:45:15,040
Вам не нужно, чтобы освободить это потому, что вы не звоните GetString

711
00:45:15,040 --> 00:45:16,890
и вы не звоните таНос.

712
00:45:16,890 --> 00:45:20,610
>> И даже если вы называли GetInt, как мы видим в конечном итоге,

713
00:45:20,610 --> 00:45:25,520
GetInt не выделить память для вас, потому что вы можете обойти целых чисел

714
00:45:25,520 --> 00:45:29,430
и плавает и буквы так, как мы делали в течение недели.

715
00:45:29,430 --> 00:45:33,960
Струны, однако, являются особенными, потому что на самом деле они конкатенации нескольких символов.

716
00:45:33,960 --> 00:45:37,450
Таким образом, они просто отличаются от символов и поплавки и целыми и тому подобное.

717
00:45:37,450 --> 00:45:39,980
Но мы вернемся к этому в скором времени.

718
00:45:39,980 --> 00:45:44,920
Любые вопросы, то на этом начале указатели? Да.

719
00:45:44,920 --> 00:45:49,690
[Неразборчиво вопрос студента]

720
00:45:49,690 --> 00:45:51,440
Ах, очень хороший вопрос.

721
00:45:51,440 --> 00:45:55,790
Одна из немногих вещей, C самом деле делает для вас, что удобно,

722
00:45:55,790 --> 00:46:00,110
оно выясняет, для вас то, что размер типа данных

723
00:46:00,110 --> 00:46:03,060
, а затем делает такой умножения для вас.

724
00:46:03,060 --> 00:46:06,610
Это не имеет никакого значения в случае символов, потому что почти всегда символ занимает 1 байт,

725
00:46:06,610 --> 00:46:08,150
так что это просто работает.

726
00:46:08,150 --> 00:46:11,220
Но ради обсуждения, если бы вы были на самом деле печатать целые

727
00:46:11,220 --> 00:46:15,500
и вы пытались распечатать некоторые значения с, что указывало на целое число,

728
00:46:15,500 --> 00:46:20,720
Вам также не нужно будет делать + 4 * я только потому, что Int составляет 4 байта.

729
00:46:20,720 --> 00:46:25,780
Арифметика с указателями означает, что C и компилятор делать все, что математика для вас.

730
00:46:25,780 --> 00:46:29,190
Все, что вы должны заботиться о том, подсчет рода в человеческом смысле. Да.

731
00:46:29,190 --> 00:46:35,200
[Студент] Если вы объявляете строки внутри цикла, вы должны освободить его позже?

732
00:46:35,200 --> 00:46:36,760
Хороший вопрос.

733
00:46:36,760 --> 00:46:41,390
>> Если вы объявили строки внутри цикла, вы должны освободить его позже?

734
00:46:41,390 --> 00:46:47,520
Вам нужно всего лишь свободной памятью, что вы выделяете с GetString или с таНос.

735
00:46:47,520 --> 00:46:53,110
Так что если вы только что сказали что-то вроде - позвольте мне фигурные скобки теперь так весь код связаны между собой.

736
00:46:53,110 --> 00:46:58,580
Если вы сделали что-то, хотя buggily, как эта, символ * T = S,

737
00:46:58,580 --> 00:47:03,450
Вам не нужно, чтобы бесплатно т т потому, что не связано с каким-либо упоминанием таНос или GetString.

738
00:47:03,450 --> 00:47:08,960
Если, напротив, вы сделали это, GetString, то да, вам нужно будет бесплатным тонн.

739
00:47:08,960 --> 00:47:14,350
И в самом деле, ваш единственный шанс сделать это сейчас внутри этой петли, по тому же вопросу за рамки

740
00:47:14,350 --> 00:47:16,060
, которые мы обсуждали в прошлом.

741
00:47:16,060 --> 00:47:18,830
В противном случае вы будете выделения памяти, выделение памяти, выделение памяти,

742
00:47:18,830 --> 00:47:21,230
и в конце программы, потому что вы находитесь за пределами этого цикла,

743
00:47:21,230 --> 00:47:24,240
т не существует, но вы никогда не говорили операционной системы

744
00:47:24,240 --> 00:47:26,750
что вам не нужно, что память больше.

745
00:47:26,750 --> 00:47:30,430
И вскоре, к PSET 4 или 5 мы вооружить вас с программой под названием Valgrind,

746
00:47:30,430 --> 00:47:34,160
которые близки по духу GDB в том, что он получил своего рода тайное интерфейс,

747
00:47:34,160 --> 00:47:35,750
но его цель в жизни, чтобы помочь вам.

748
00:47:35,750 --> 00:47:39,380
И Valgrind это программа, которая в будущем будет искать ваши программы

749
00:47:39,380 --> 00:47:42,550
искать утечки памяти, то ли от GetString или таНос,

750
00:47:42,550 --> 00:47:47,800
которые мы начнем, используя все больше, как мы прекратить использование CS50 библиотеке столько же.

751
00:47:47,800 --> 00:47:53,030
Мы, наконец, теперь есть своего рода словаря и своего рода ментальной модели в теории

752
00:47:53,030 --> 00:47:55,170
с которым для решения этой сломанной программе.

753
00:47:55,170 --> 00:47:59,410
>> Так что в этом сломанной программы, своп работает внутри подкачки,

754
00:47:59,410 --> 00:48:05,280
но он никогда не работал в основном потому, что основная прошло в х и у, напомним,

755
00:48:05,280 --> 00:48:07,260
и те были приняты в ценностями, так сказать.

756
00:48:07,260 --> 00:48:09,330
Копии из них были даны поменять.

757
00:48:09,330 --> 00:48:12,520
К концу подкачки, и б действительно были обменены,

758
00:48:12,520 --> 00:48:16,120
но, конечно, х и у, как мы обсуждали в понедельник, не было.

759
00:48:16,120 --> 00:48:19,940
Поэтому я предлагаю в зеленом здесь, что это на самом деле решение здесь.

760
00:48:19,940 --> 00:48:22,640
А на самом деле, позвольте мне двигать звезды просто быть последовательным

761
00:48:22,640 --> 00:48:24,440
хотя, опять же, функционально это не имеет значения.

762
00:48:24,440 --> 00:48:28,730
В будущем недель мы будем объяснять, когда и почему это имеет значение.

763
00:48:28,730 --> 00:48:30,600
Таким образом, в зеленом сейчас является решением.

764
00:48:30,600 --> 00:48:33,700
Честно говоря, это выглядит намного грязнее, потому что у меня есть все эти звезды.

765
00:48:33,700 --> 00:48:35,380
Позвольте мне отметить одну вещь.

766
00:48:35,380 --> 00:48:40,040
Верхняя строка здесь, где он говорит Int * и Int * б

767
00:48:40,040 --> 00:48:42,820
принципиально делает то же самое, как это было всегда.

768
00:48:42,820 --> 00:48:47,070
Он заявляет, 2 аргументы или параметры поменять,

769
00:48:47,070 --> 00:48:49,940
первым из которых является Int указателя называется,

770
00:48:49,940 --> 00:48:53,100
второй из которых является Int указателя называется б.

771
00:48:53,100 --> 00:48:55,770
Единственное, что нового на данный момент является то, что там есть звезды.

772
00:48:55,770 --> 00:48:59,340
>> Что это значит? Не INT, б не является Int.

773
00:48:59,340 --> 00:49:04,100
Это адрес Int и б это адрес другого Int.

774
00:49:04,100 --> 00:49:06,980
Здесь, внизу, это где я признаю C сбивает с толку.

775
00:49:06,980 --> 00:49:09,790
Сейчас мы используем звездой, но он имеет разное значение в этом контексте.

776
00:49:09,790 --> 00:49:13,150
Потому что мы не объявляем указатели, как мы здесь,

777
00:49:13,150 --> 00:49:15,500
Здесь мы разыменования вещи.

778
00:49:15,500 --> 00:49:21,520
Таким образом, технически, звезды в этом контексте первой, второй и третьей линии внутри своп

779
00:49:21,520 --> 00:49:24,560
является оператором разыменования, который просто означает, что идти туда.

780
00:49:24,560 --> 00:49:27,400
Так же, как мой палец последовал за стрелками часов,

781
00:49:27,400 --> 00:49:31,100
* Средства идут на этот адрес и найти меня Int, что есть.

782
00:49:31,100 --> 00:49:34,250
* В означает, перейти по адресу и передать мне, что там.

783
00:49:34,250 --> 00:49:40,730
Так что давайте перерисовывать изображение с понедельника теперь используется стек кадров,

784
00:49:40,730 --> 00:49:43,130
нижний, один из которых будет основным,

785
00:49:43,130 --> 00:49:47,600
верхняя, одна из которых будет своп,

786
00:49:47,600 --> 00:49:50,880
так что наш мир выглядит, как понедельник, как это.

787
00:49:50,880 --> 00:49:53,620
Вот кусок памяти, что основной собирается использовать.

788
00:49:53,620 --> 00:49:56,520
>> Напомним, с понедельника, что программа просто было 2 переменных,

789
00:49:56,520 --> 00:50:01,930
одна называется х и одна называется у, и я положил числа 1 и 2.

790
00:50:01,930 --> 00:50:06,580
Теперь, когда я называю поменять, как я сделал в понедельник,

791
00:50:06,580 --> 00:50:11,000
Ранее, когда я использовал красную версию этой программы, которая выглядит так,

792
00:50:11,000 --> 00:50:17,470
Я получил 2 параметра, а, б, и что же мы пишем здесь и здесь?

793
00:50:17,470 --> 00:50:21,160
Только 1 и 2, буквально копирует х и у.

794
00:50:21,160 --> 00:50:23,070
Сегодня мы это изменить.

795
00:50:23,070 --> 00:50:28,510
Сегодня вместо передачи в целых а и б мы собираемся передать в 2-адресов.

796
00:50:28,510 --> 00:50:34,290
Эти адреса случиться, чтобы указать на целые, но эти адреса не целыми себя.

797
00:50:34,290 --> 00:50:37,330
Они адресов. Это как почтовый адрес.

798
00:50:37,330 --> 00:50:40,580
Так что теперь нам нужно просто дать себе немного более подробно на экране.

799
00:50:40,580 --> 00:50:43,250
Это моя память компьютера, как это было весь день.

800
00:50:43,250 --> 00:50:45,120
Теперь нам нужно произвольной схемы нумерации.

801
00:50:45,120 --> 00:50:50,580
Так что давайте просто скажем, просто случайно, что это адрес памяти, 123, 124.

802
00:50:50,580 --> 00:50:55,660
Давайте просто скажем, что это 125, это 126, и так далее, но это совершенно произвольными.

803
00:50:55,660 --> 00:50:58,590
Нам просто нужно некоторое схемы нумерации в моей памяти.

804
00:50:58,590 --> 00:51:04,030
Так что теперь, когда я на самом деле проходят в х и у, я не собираюсь переходить в х и у;

805
00:51:04,030 --> 00:51:08,400
Я собираюсь перейти в почтовый адрес, так сказать, х и у

806
00:51:08,400 --> 00:51:11,870
так что то, что получает хранится здесь и здесь не 1 и 2,

807
00:51:11,870 --> 00:51:16,030
Но если вы можете увидеть мои мелкий текст, то, что прошло в здесь и здесь?

808
00:51:16,030 --> 00:51:23,340
[Неразборчиво ответ студента] >> Именно так. 123 получает положить здесь, и 124 получает положить здесь.

809
00:51:23,340 --> 00:51:28,910
>> Теперь, потому что я использовал звезда в этой самой первой строке путь здесь, на вершине,

810
00:51:28,910 --> 00:51:34,340
моя программа просто знает, что 123 и 124, хотя они, очевидно, целые

811
00:51:34,340 --> 00:51:40,160
что любой человек мог заметить, они должны быть интерпретированы как адреса, числовые адреса.

812
00:51:40,160 --> 00:51:43,250
Они не являются сами по себе целыми, они адресов,

813
00:51:43,250 --> 00:51:46,120
и это потому, что я явно поставил звезды там.

814
00:51:46,120 --> 00:51:51,360
Так что теперь в моей первой, второй и третьей линии фактического кода, что здесь происходит?

815
00:51:51,360 --> 00:51:53,380
Давайте нарисуем остальной части картины.

816
00:51:53,380 --> 00:51:56,980
Tmp так же, как это было в понедельник. Ничего особенного TMP.

817
00:51:56,980 --> 00:52:03,060
Это просто местный 32 бит переменной, так и внутри, что я видимо хранения значения *.

818
00:52:03,060 --> 00:52:08,580
Теперь, если я только что сказал, TMP =, что бы я здесь? >> [Студент] 123.

819
00:52:08,580 --> 00:52:10,370
123. Но это не то, что я делаю.

820
00:52:10,370 --> 00:52:13,670
Я говорю TMP = *. Звезда средства идут туда.

821
00:52:13,670 --> 00:52:19,370
Так вот, 123. Как мне туда идти? Притворитесь, что есть стрелка.

822
00:52:19,370 --> 00:52:24,460
Ну, так и есть, 1. Так что же получает хранится в TMP, по-видимому? Просто 1.

823
00:52:24,460 --> 00:52:29,620
Итак, другими словами, TMP является *, * средства идут на адрес, который является в настоящее время,

824
00:52:29,620 --> 00:52:31,320
по-видимому, 123.

825
00:52:31,320 --> 00:52:33,910
>> Ну, вот мы и на месте 123, я вижу, № 1,

826
00:52:33,910 --> 00:52:35,670
так что я собираюсь поставить номер 1 там.

827
00:52:35,670 --> 00:52:39,020
Теперь то, что я делаю в строке 2, * = * б?

828
00:52:39,020 --> 00:52:44,570
Это одна немного сложнее, потому что теперь это? Это 123.

829
00:52:44,570 --> 00:52:50,220
Так что * это где? Там, где я был раньше. Так что идите туда. Хорошо.

830
00:52:50,220 --> 00:52:53,420
Теперь, наконец, и, наконец, это начнет иметь смысл, надеюсь,

831
00:52:53,420 --> 00:53:00,280
* Б означает, что в б? 124. Так что мне нужно пойти туда, что на 2.

832
00:53:00,280 --> 00:53:03,430
Так что я ставлю где?

833
00:53:03,430 --> 00:53:10,100
2 идет в здесь, потому что * б * переходит в. Так что я буду делать.

834
00:53:10,100 --> 00:53:13,120
И вы уже можете видеть, пожалуй, что мы гораздо ближе

835
00:53:13,120 --> 00:53:17,710
к решению этой глупой, простая задача правильно в первый раз

836
00:53:17,710 --> 00:53:20,920
потому что теперь у нас еще есть воспоминание о том, что х был,

837
00:53:20,920 --> 00:53:23,230
у нас есть 2-х экземплярах, по общему признанию, у,

838
00:53:23,230 --> 00:53:25,850
но линия 3 теперь говорит, * б.

839
00:53:25,850 --> 00:53:31,080
Так вот б. * В означает пойти туда. Так где же расположение 124?

840
00:53:31,080 --> 00:53:35,560
Это видимо здесь. Итак, что же я здесь? Очевидно, TMP.

841
00:53:35,560 --> 00:53:39,600
Так что теперь я это делаю. Так что у меня есть 1 и 2 здесь здесь.

842
00:53:39,600 --> 00:53:43,560
И что теперь обо всем этом, 123, 124 и 1?

843
00:53:43,560 --> 00:53:47,910
Как только своп возвращается, эта память так хорошо, как потеряли

844
00:53:47,910 --> 00:53:51,070
потому что как только своп возвращается, операционная система

845
00:53:51,070 --> 00:53:54,190
имеет право использовать эту память в будущем.

846
00:53:54,190 --> 00:53:58,870
Только основной памяти в нижней этого так называемого стеком слоняется поблизости.

847
00:53:58,870 --> 00:54:01,470
>> И вот мы, наконец, сейчас рабочая версия.

848
00:54:01,470 --> 00:54:06,310
Отпустите меня в swap.c, и обратите внимание на следующее.

849
00:54:06,310 --> 00:54:11,280
В верхней части программы я изменил мой прототип, чтобы быть Int * и * б Int.

850
00:54:11,280 --> 00:54:15,000
Так что единственное, что я изменилась, чтобы перейти от красного, который был плох, на зеленый, и это хорошо,

851
00:54:15,000 --> 00:54:17,350
это я добавил эти звезды сегодня.

852
00:54:17,350 --> 00:54:21,520
Но здесь, в самой поменять мне пришлось скопировать, вставить то, что было только на слайде.

853
00:54:21,520 --> 00:54:24,140
У меня есть звезда здесь, звезда здесь - что соответствует прототипу -

854
00:54:24,140 --> 00:54:27,930
и тогда все эти вещи теперь имеют звезды, за исключением TMP

855
00:54:27,930 --> 00:54:30,680
потому, что использование временных переменных, нет ничего нового.

856
00:54:30,680 --> 00:54:33,040
Мне просто нужно временное хранилище для внутр.

857
00:54:33,040 --> 00:54:34,820
Таким образом, нам не нужны звезды там.

858
00:54:34,820 --> 00:54:39,310
Нам просто нужно звезде, чтобы мы могли пересечь такого рода произвольные границы

859
00:54:39,310 --> 00:54:42,900
Между этими 2 кадра в памяти моего компьютера.

860
00:54:42,900 --> 00:54:45,630
Но последнее, что должно измениться, и вы, возможно, увидел его уже.

861
00:54:45,630 --> 00:54:48,810
Какие другие линии, очевидно, отличается теперь? >> [Студент] & х.

862
00:54:48,810 --> 00:54:53,270
>> Да, так что 25 является последней строке кода мне нужно изменить, чтобы это работало.

863
00:54:53,270 --> 00:54:58,360
Неделю назад, и даже в понедельник линии 25 выглядела так, поменяйте местами х и у,

864
00:54:58,360 --> 00:55:02,020
и это было просто сломана, потому что если вы говорите свопа (х, у)

865
00:55:02,020 --> 00:55:05,660
Вы даете копии х и у поменять, то он делает свое дело,

866
00:55:05,660 --> 00:55:09,080
но вы никогда не меняется х и у себя.

867
00:55:09,080 --> 00:55:12,880
Так что даже если вы никогда не видели этот символ, прежде чем с амперсанд в коде,

868
00:55:12,880 --> 00:55:15,860
просто взять предположение. Что делать амперсанд, по-видимому?

869
00:55:15,860 --> 00:55:17,890
[Студент] принимает адрес. >> Принимает адрес.

870
00:55:17,890 --> 00:55:21,160
Таким образом, амперсанд говорит, дайте мне адрес х.

871
00:55:21,160 --> 00:55:25,590
Кто знает, где это? Это случается, 123. Мне все равно. Просто дайте мне адрес х.

872
00:55:25,590 --> 00:55:28,340
И у означает дать мне адрес у.

873
00:55:28,340 --> 00:55:34,450
И в этот момент история вполне согласуется с картиной мы сделали минуту назад.

874
00:55:34,450 --> 00:55:38,310
>> Таким образом, я признаю, указатели, конечно, для меня, когда я впервые начал Узнав об этом,

875
00:55:38,310 --> 00:55:40,570
был определенно одним из самых трудных вещей, чтобы обернуть свой ум вокруг.

876
00:55:40,570 --> 00:55:43,760
Но понимаете, тем более, что мы продолжаем играть с этими вещами,

877
00:55:43,760 --> 00:55:48,030
Если вы разбить его на эти супер простой вид интеллектуально неинтересны проблемы

878
00:55:48,030 --> 00:55:52,270
всего движущегося вокруг номера, ответ на много путаницы с указателями

879
00:55:52,270 --> 00:55:56,590
действительно может быть получена из этих самых основных механики.

880
00:55:56,590 --> 00:55:59,070
Вот адрес. Пойди туда со звездой.

881
00:55:59,070 --> 00:56:03,830
Или наоборот, вот амперсанд. Выяснить, что адрес на самом деле.

882
00:56:03,830 --> 00:56:06,270
Хорошо.

883
00:56:06,270 --> 00:56:09,000
Так где же все это память приходят?

884
00:56:09,000 --> 00:56:12,360
Мы нарисовали эту картину несколько раз, и я держу перспективным, мы вернемся к нему,

885
00:56:12,360 --> 00:56:14,920
но вот представление памяти компьютера

886
00:56:14,920 --> 00:56:17,420
, что немного больше, чем наши помечены доске здесь.

887
00:56:17,420 --> 00:56:21,590
Текст в верхнем сегменте представляет то, что по отношению к вашей программе?

888
00:56:21,590 --> 00:56:26,090
[Неразборчиво ответ студента] >> Простите? Скажите еще раз.

889
00:56:26,090 --> 00:56:28,660
[Студент] Фактическое программы. >> Фактической программой.

890
00:56:28,660 --> 00:56:32,430
>> Таким образом, 0 и 1, что вы собрали после написания кода C и затем запустить Clang

891
00:56:32,430 --> 00:56:35,910
и генерирующих 0 и 1 концах тем, что были там скрываются в памяти

892
00:56:35,910 --> 00:56:38,570
потому что, когда вы дважды щелкните значок на вашем Mac или PC

893
00:56:38,570 --> 00:56:43,010
или выполните команду, как Марио на ваше приглашение, ваше 0 и 1 с диска

894
00:56:43,010 --> 00:56:45,700
загружаются в память, так что компьютер может управлять ими

895
00:56:45,700 --> 00:56:47,540
и выполнять их быстрее.

896
00:56:47,540 --> 00:56:50,880
Так инициализированные данные и неинициализированные данные, мы не будем много говорить о тех,

897
00:56:50,880 --> 00:56:52,420
но это только глобальные переменные.

898
00:56:52,420 --> 00:56:54,710
Initialized означает глобальные переменные, которые вы дали значения;

899
00:56:54,710 --> 00:56:59,300
неинициализированные означает глобальные переменные, которые вы еще не дают значения.

900
00:56:59,300 --> 00:57:01,900
Тогда есть эти переменные окружения, которые я полностью махнуть рукой на,

901
00:57:01,900 --> 00:57:04,860
но они есть, и что магазины вещи, как имя пользователя

902
00:57:04,860 --> 00:57:08,090
и другого рода нижний уровень подробности.

903
00:57:08,090 --> 00:57:12,880
Но самые сочные куски макет вашей памяти является то, что называется стека и кучи.

904
00:57:12,880 --> 00:57:17,470
Стек снова, чтобы было ясно, это память, которая используется всякий раз, когда функции вызываются,

905
00:57:17,470 --> 00:57:19,710
всякий раз, когда есть локальные переменные

906
00:57:19,710 --> 00:57:22,120
а также при наличии параметров, передаваемых вокруг.

907
00:57:22,120 --> 00:57:24,490
Все, что происходит в стеке.

908
00:57:24,490 --> 00:57:29,570
Куча мы не говорили об этом, но сделать предположение, кто использует кучу.

909
00:57:31,120 --> 00:57:32,690
Просто другой кусок памяти.

910
00:57:32,690 --> 00:57:36,620
Бывает, который можно сделать здесь, на вершине, но это произвольное живописной конвенции.

911
00:57:36,620 --> 00:57:41,670
Кто-видимому, использование памяти из кучи недели?

912
00:57:41,670 --> 00:57:44,830
Это технически вас, но косвенно. >> [Студент] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString и таНос. Так вот принципиальная разница.

914
00:57:47,950 --> 00:57:51,300
>> Вы знаете, в течение последних нескольких недель, что если вам нужна память, просто объявить переменную.

915
00:57:51,300 --> 00:57:54,560
Если вам нужно много памяти, объявить массив прямо внутри вашей функции.

916
00:57:54,560 --> 00:57:59,620
Но проблема мы сохранили столкнулась, если вы объявите переменные локально внутри функции,

917
00:57:59,620 --> 00:58:05,340
Как только функция возвращает значение, что происходит с памятью и эти переменные?

918
00:58:05,340 --> 00:58:09,620
Только вроде это уже не ваш, не так ли? Он просто исчезает рода концептуально.

919
00:58:09,620 --> 00:58:13,950
Это все еще физически существует, очевидно, но это уже не ваше право на использование.

920
00:58:13,950 --> 00:58:17,160
Очевидно, что это проблематично, если вы хотите написать функции в жизни

921
00:58:17,160 --> 00:58:20,440
что на самом деле выделяет память и не дают его обратно.

922
00:58:20,440 --> 00:58:24,180
Дело в точку: GetString цели в жизни, понятия не имеют заранее

923
00:58:24,180 --> 00:58:26,390
как большой из строки Я собираюсь ввести на клавиатуре,

924
00:58:26,390 --> 00:58:30,390
но он должен быть в состоянии выделить память для хранения Давида или привет

925
00:58:30,390 --> 00:58:32,860
или целую статью о том, что пользователь, возможно, ввели дюйма

926
00:58:32,860 --> 00:58:35,280
Так GetString использует таНос.

927
00:58:35,280 --> 00:58:38,910
Malloc поэтому необходимо использовать не стек;

928
00:58:38,910 --> 00:58:40,770
Вместо этого, используя то, что называется кучей.

929
00:58:40,770 --> 00:58:44,430
Там нет ничего другое о памяти. Это не быстрее или медленнее или что-нибудь подобное.

930
00:58:44,430 --> 00:58:46,570
Это просто физически в другом месте.

931
00:58:46,570 --> 00:58:50,120
>> Но правило, что память которая выделяется в куче

932
00:58:50,120 --> 00:58:56,180
никогда не будет отнято у вас, пока вы не позвоните - сделать предположение - бесплатно.

933
00:58:56,180 --> 00:59:00,510
С другой стороны, любая память вы просите в стек просто объявлении массива

934
00:59:00,510 --> 00:59:03,320
или объявления переменной, как мы делали в течение недели,

935
00:59:03,320 --> 00:59:05,640
, что по умолчанию заканчивается в стеке.

936
00:59:05,640 --> 00:59:09,550
И это прекрасно работает 90% времени, а на тех редких случаях

937
00:59:09,550 --> 00:59:12,470
где вы хотите выделить память, и держать его вокруг,

938
00:59:12,470 --> 00:59:14,730
Затем вы должны использовать функции, как таНос.

939
00:59:14,730 --> 00:59:19,370
Или мы использовали функцию, как GetString, который в свою очередь использует таНос.

940
00:59:19,370 --> 00:59:23,300
Давайте посмотрим, где это может сломать, а затем взглянуть на Бинки.

941
00:59:23,300 --> 00:59:25,820
Мы вернемся к этому в будущем.

942
00:59:25,820 --> 00:59:29,270
Вот это супер простую программу, которая в первые 2 строки что делает?

943
00:59:29,270 --> 00:59:33,460
В английском языке, то, что эти первые 2 строки кода сделать внутри основного?

944
00:59:33,460 --> 00:59:35,600
[Неразборчиво ответ студента]

945
00:59:35,600 --> 00:59:37,880
Осторожно. Это не дает мне адрес х или у.

946
00:59:37,880 --> 00:59:41,840
[Студент] Дает указателей на целые. >> Хорошо. Дайте мне 2 указателей на целые числа.

947
00:59:41,840 --> 00:59:45,130
Иными словами, дайте мне 2 участков памяти, что я держу чертеж сегодня,

948
00:59:45,130 --> 00:59:46,950
хотя я стер его сейчас, как квадраты.

949
00:59:46,950 --> 00:59:50,000
Дайте мне 2 участков памяти, одна называется х, одна называется у -

950
00:59:50,000 --> 00:59:54,320
Ранее я называл их с и т - а что это тип, что часть памяти?

951
00:59:54,320 --> 00:59:57,160
Это будет хранить адрес.

952
00:59:57,160 --> 00:59:59,110
Это типа * Int.

953
00:59:59,110 --> 01:00:01,630
>> Таким образом, адрес Int в конечном итоге жить в х,

954
01:00:01,630 --> 01:00:03,860
Адрес Int в конечном итоге жить в у,

955
01:00:03,860 --> 01:00:08,460
но изначально, что внутри х и у? Кто знает? Мусор значения.

956
01:00:08,460 --> 01:00:10,180
Это не имеет ничего общего с указателями.

957
01:00:10,180 --> 01:00:12,720
Если мы не успели что-то там, кто знает, что на самом деле существует?

958
01:00:12,720 --> 01:00:18,950
Теперь, х. Что здесь происходит? Это законно, потому х является указателем. Это Int *.

959
01:00:18,950 --> 01:00:21,870
Таким образом, это означает, что я могу положить в X в адрес некоторых кусок памяти.

960
01:00:21,870 --> 01:00:25,120
Что таНос вернуться? Perfect, он возвращает адрес,

961
01:00:25,120 --> 01:00:28,510
адрес первого байта в целый кусок памяти.

962
01:00:28,510 --> 01:00:31,140
Сколько байт это, очевидно выделение, например, в холодильнике?

963
01:00:31,140 --> 01:00:33,510
Какой размер Int? 4.

964
01:00:33,510 --> 01:00:36,600
Если вы вспомните неделе 1, это не супер важно всегда помнить, что,

965
01:00:36,600 --> 01:00:38,870
но в данном случае это полезно знать, 4 байт.

966
01:00:38,870 --> 01:00:41,770
Итак, это выделение в куче 4 байта

967
01:00:41,770 --> 01:00:46,110
и он возвращался в адрес первого ко мне произвольно.

968
01:00:46,110 --> 01:00:47,700
Теперь, что х делаете?

969
01:00:47,700 --> 01:00:52,200
* Х = 42, что делает?

970
01:00:52,200 --> 01:00:57,150
Если в этот момент в истории мы имеем х, который выглядит, как это с некоторыми мусора значение,

971
01:00:57,150 --> 01:01:04,120
это сейчас у некоторых мусора значение, теперь в строке 3 Я выделил 4 байт.

972
01:01:04,120 --> 01:01:06,950
Эта картина существенно выглядит следующим образом.

973
01:01:06,950 --> 01:01:12,010
Или, более точно, если это произвольный адрес 123, это то, что наша история выглядит теперь.

974
01:01:12,010 --> 01:01:23,940
* Х = 42 означает теперь, что? Это означает, что переход на адрес 123 и положил число 42 там.

975
01:01:23,940 --> 01:01:26,220
Мне не нужно, чтобы сделать эти строки, потому что мы не делаем строк.

976
01:01:26,220 --> 01:01:29,480
>> Я только что написал это так, и только ради демонстрации, в

977
01:01:29,480 --> 01:01:33,240
42, внутр вид занимает много места, 4 байт.

978
01:01:33,240 --> 01:01:35,960
Так вот что там произошло, но есть проблема.

979
01:01:35,960 --> 01:01:40,580
* У = 13. Что произойдет здесь?

980
01:01:40,580 --> 01:01:46,470
Проблема в том, * у в нашем упрощенном мире означает лишь перейти по адресу у.

981
01:01:46,470 --> 01:01:48,590
Что в Y? Это какая-то фигня значение.

982
01:01:48,590 --> 01:01:53,150
Итак, давайте предположим, что мусор значение 5551212, что-то сумасшедший, как это.

983
01:01:53,150 --> 01:01:56,750
* У средства идут на решение 5551212.

984
01:01:56,750 --> 01:02:00,450
Это все равно здесь. Он не существует, например.

985
01:02:00,450 --> 01:02:05,310
Таким образом, у * получает 13 означает, что я пытаюсь сделать здесь 13. Она не существует.

986
01:02:05,310 --> 01:02:08,790
Я превысили сегмент доске. Что я получу?

987
01:02:08,790 --> 01:02:14,930
Это загадочное вине сегментации сообщение, потому что я пытаюсь поставить в памяти

988
01:02:14,930 --> 01:02:19,470
значения, как 13 в месте, которое не существует.

989
01:02:19,470 --> 01:02:23,900
Остальная часть программы может работать хорошо, но до этого момента он не делает.

990
01:02:23,900 --> 01:02:25,350
Так давайте попробуем рассказать эту историю.

991
01:02:25,350 --> 01:02:27,830
Мы вернемся к этому, когда мы говорили о шестигр.

992
01:02:27,830 --> 01:02:30,290
Давайте вернемся к этому и заключить с этой вещью, называемой Бинки,

993
01:02:30,290 --> 01:02:33,710
Напомним которой является профессор Стэнфордского сидя у себя дома, играя с Claymation,

994
01:02:33,710 --> 01:02:36,380
чтобы рассказать историю именно той же программы.

995
01:02:36,380 --> 01:02:40,580
Это всего лишь около 3 минут. Здесь мы имеем Бинки.

996
01:02:40,580 --> 01:02:45,030
[Мужской динамика на видео] Эй, Бинки, проснись. Это время для указателя весело.

997
01:02:45,030 --> 01:02:50,080
[Бинки] Что это? Узнать о указателей? О, сентиментальный!

998
01:02:50,080 --> 01:02:53,700
[Мужской динамик] Ну, для начала, я думаю, мы будем нуждаться в нескольких указателей.

999
01:02:53,700 --> 01:02:57,890
>> [Бинки] Хорошо. Этот код выделяет 2 указатели, которые могут указывать на целые числа.

1000
01:02:57,890 --> 01:03:02,220
[Мужской динамик] Хорошо. Ну, я вижу 2 указателей, но они, похоже, не указывая ни к чему.

1001
01:03:02,220 --> 01:03:05,550
[Бинки] Это верно. Первоначально, указатели не указывают ни к чему.

1002
01:03:05,550 --> 01:03:09,270
То, что они указывают называют pointees, а их создания является отдельным шагом.

1003
01:03:09,270 --> 01:03:12,330
[Мужской динамик] Ах, да, да. Я знал, что. Pointees отдельно.

1004
01:03:12,330 --> 01:03:15,630
Э-э, так как вы выделить pointee?

1005
01:03:15,630 --> 01:03:21,510
[Бинки] Хорошо. Этот код создает новый целое pointee, и эта часть множества Х, чтобы указать на это.

1006
01:03:21,510 --> 01:03:23,500
[Мужской динамик] Эй, это выглядит лучше.

1007
01:03:23,500 --> 01:03:26,030
Так что это что-то делать. >> [Бинки] Хорошо.

1008
01:03:26,030 --> 01:03:30,300
Я буду разыменовать х, чтобы сохранить номер 42 в своем pointee.

1009
01:03:30,300 --> 01:03:34,410
Для этого трюка мне нужна моя волшебная палочка разыменование.

1010
01:03:34,410 --> 01:03:38,610
[Мужской динамик] Ваша волшебная палочка разыменования? Это здорово.

1011
01:03:38,610 --> 01:03:44,230
[Бинки] Это то, что код выглядит следующим образом. Я просто настроить количество и ... [Отрывистый звук]

1012
01:03:44,230 --> 01:03:46,100
[Мужской динамик] Эй, посмотрите, там она идет.

1013
01:03:46,100 --> 01:03:50,990
Так делают разыменование на х следует стрелку, чтобы открыть ее pointee,

1014
01:03:50,990 --> 01:03:53,230
В этом случае для хранения 42 в там.

1015
01:03:53,230 --> 01:03:57,630
Эй, попробуйте использовать его, чтобы сохранить номер 13 через другой указатель, у.

1016
01:03:57,630 --> 01:04:03,250
[Бинки] Хорошо. Я пойду сюда, чтобы у и получим число 13 создан

1017
01:04:03,250 --> 01:04:08,360
, а затем взять палочку разыменования и просто ... [Жужжащий звук] Ух ты!

1018
01:04:08,360 --> 01:04:10,980
[Мужской динамик] О, эй, это не работает.

1019
01:04:10,980 --> 01:04:14,870
>> Скажем, Бинки, я не думаю, что у разыменования это хорошая идея

1020
01:04:14,870 --> 01:04:17,880
потому что создание pointee отдельный шаг

1021
01:04:17,880 --> 01:04:19,850
и я не думаю, что мы когда-либо делали это.

1022
01:04:19,850 --> 01:04:21,770
[Бинки] Хм, хороший вопрос.

1023
01:04:21,770 --> 01:04:26,640
[Мужской динамик] Да. Мы выделили указатель у, но мы никогда не установите его, чтобы указать на pointee.

1024
01:04:26,640 --> 01:04:28,780
[Бинки] Хм, очень наблюдательны.

1025
01:04:28,780 --> 01:04:30,690
[Мужской динамик] Эй, вы ищете там хорошо, Бинки.

1026
01:04:30,690 --> 01:04:34,160
Вы можете это исправить, так что у указывает на тот же pointee как х? >> [Бинки] Конечно.

1027
01:04:34,160 --> 01:04:37,100
Я буду использовать мою волшебную палочку указателя назначения.

1028
01:04:37,100 --> 01:04:39,070
[Мужской динамик], что будет проблема, как раньше?

1029
01:04:39,070 --> 01:04:40,840
[Бинки] Нет, это не касается pointees.

1030
01:04:40,840 --> 01:04:44,780
Это просто меняет один указатель, чтобы указать на то же самое другим. [Отрывистый звук]

1031
01:04:44,780 --> 01:04:48,570
[Мужской динамик] О, я вижу. Теперь у указывает на то же место, х.

1032
01:04:48,570 --> 01:04:51,140
Так что ждите. Теперь у фиксировано. Он имеет pointee.

1033
01:04:51,140 --> 01:04:54,520
Таким образом, вы можете попробовать палочку разыменования снова отправить на 13 старше.

1034
01:04:54,520 --> 01:04:58,130
[Бинки] Ну, ладно. Здесь идет. [Отрывистый звук]

1035
01:04:58,130 --> 01:05:01,250
[Мужской динамик] Эй, посмотри на это. Теперь разыменования работ по у.

1036
01:05:01,250 --> 01:05:05,200
И потому, что указатели обмена, что одна pointee, они оба видят 13.

1037
01:05:05,200 --> 01:05:06,910
[Бинки] Да, обмен. Неважно.

1038
01:05:06,910 --> 01:05:08,880
>> Таким образом, мы собираемся, чтобы поменяться местами сейчас?

1039
01:05:08,880 --> 01:05:11,420
[Мужской динамик] О, смотрите, мы вне времени. >> [Бинки] Но -

1040
01:05:11,420 --> 01:05:13,880
[Мужской динамик] Только помните, 3 положения указателя.

1041
01:05:13,880 --> 01:05:18,630
Номер 1, базовая структура является то, что у вас есть указатель и он указывает к pointee.

1042
01:05:18,630 --> 01:05:23,120
Но указатель и pointee отдельно, а распространенная ошибка заключается в создании указателя

1043
01:05:23,120 --> 01:05:25,680
но забыть дать ему pointee.

1044
01:05:25,680 --> 01:05:29,580
Номер 2, разыменования указателя начинается с указателя и следует его стрелки над

1045
01:05:29,580 --> 01:05:31,060
Для доступа к pointee.

1046
01:05:31,060 --> 01:05:34,340
Как мы все знаем, это работает только, если есть pointee,

1047
01:05:34,340 --> 01:05:36,460
какой вид возвращается в Правило № 1.

1048
01:05:36,460 --> 01:05:39,870
Номер 3, указатель назначении принимает один указатель и изменяет его

1049
01:05:39,870 --> 01:05:42,390
указывают на то же pointee как еще один указатель.

1050
01:05:42,390 --> 01:05:45,890
Таким образом, после назначения, 2 указатели будут указывать на тот же pointee.

1051
01:05:45,890 --> 01:05:47,800
Иногда это называется обмен.

1052
01:05:47,800 --> 01:05:50,910
>> И это все, что есть на самом деле. Прощай сейчас.

1053
01:05:50,910 --> 01:05:55,840
Это Бинки. Это CS50. Увидимся на следующей неделе. [Аплодисменты]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]