1
00:00:00,000 --> 00:00:06,030
>> [Играет музыка]

2
00:00:06,030 --> 00:00:08,390
>> ДАГ Lloyd: Указатели, вот мы здесь.

3
00:00:08,390 --> 00:00:11,080
Это, вероятно, будет
наиболее трудная тема

4
00:00:11,080 --> 00:00:12,840
что мы говорим о в CS50.

5
00:00:12,840 --> 00:00:15,060
И если вы читали
что-нибудь о указателей

6
00:00:15,060 --> 00:00:19,080
прежде чем может быть немного
запугать вдаваясь в этом видео.

7
00:00:19,080 --> 00:00:21,260
Это правда указатели
позволяют вам возможность

8
00:00:21,260 --> 00:00:23,740
чтобы, возможно, испортить
очень плохо, когда вы

9
00:00:23,740 --> 00:00:27,450
Для работы с переменными и данными,
и вызывая ваша программа к краху.

10
00:00:27,450 --> 00:00:30,490
Но на самом деле они действительно полезны
и они позволяют нам действительно отличный способ

11
00:00:30,490 --> 00:00:33,340
для передачи данных и обратно
вперед между функциями,

12
00:00:33,340 --> 00:00:35,490
что мы в противном случае не в состоянии сделать.

13
00:00:35,490 --> 00:00:37,750
>> И так, что мы на самом деле
хочу сделать здесь поезд

14
00:00:37,750 --> 00:00:41,060
Вы иметь хорошую указатель дисциплины, так
что вы можете эффективно использовать указатели

15
00:00:41,060 --> 00:00:43,850
чтобы сделать ваши программы, которые намного лучше.

16
00:00:43,850 --> 00:00:48,220
Как я уже сказал указатели дают нам разные
способ передачи данных между функциями.

17
00:00:48,220 --> 00:00:50,270
Теперь, если вы помните из
ранее видео, когда

18
00:00:50,270 --> 00:00:53,720
мы говорим о
Переменная сфера, я упомянул

19
00:00:53,720 --> 00:01:00,610
что все данные, которые мы пройти между
Функции в С передаются по значению.

20
00:01:00,610 --> 00:01:03,070
И я не мог использовать, что
Термин, что я имел в виду там

21
00:01:03,070 --> 00:01:07,170
было то, что мы передаем копии данных.

22
00:01:07,170 --> 00:01:12,252
Когда мы передать переменную в функцию,
мы на самом деле не передавая переменную

23
00:01:12,252 --> 00:01:13,210
функции, не так ли?

24
00:01:13,210 --> 00:01:17,670
Мы передавая копию
что данные функции.

25
00:01:17,670 --> 00:01:20,760
Функция делает то, что он будет
и он вычисляет некоторое значение,

26
00:01:20,760 --> 00:01:23,180
и, возможно, мы используем это значение
когда он дает его обратно.

27
00:01:23,180 --> 00:01:26,700
>> Был одним исключением
это правило передаче по значению,

28
00:01:26,700 --> 00:01:31,210
и мы вернемся к тому, что, что
немного позже в этом видео.

29
00:01:31,210 --> 00:01:34,880
Если мы используем указатели вместо
использования переменных,

30
00:01:34,880 --> 00:01:38,180
или вместо использования переменных
Сами или копии переменных,

31
00:01:38,180 --> 00:01:43,790
Теперь мы можем перейти переменные вокруг
между функциями по-другому.

32
00:01:43,790 --> 00:01:46,550
Это означает, что если мы сделаем
изменение в одной функции,

33
00:01:46,550 --> 00:01:49,827
что изменение будет на самом деле взять
эффект в ином функции.

34
00:01:49,827 --> 00:01:52,160
Опять же, это то, что
мы не могли сделать ранее,

35
00:01:52,160 --> 00:01:56,979
и если вы когда-нибудь пытались поменять местами
Значение двух переменных в функции,

36
00:01:56,979 --> 00:01:59,270
Вы заметили, эту проблему
вроде подкрадывается, верно?

37
00:01:59,270 --> 00:02:04,340
>> Если мы хотим, чтобы поменять X и Y, и мы
передать их функции под названием подкачки,

38
00:02:04,340 --> 00:02:08,680
внутри функции своп
Переменные сделать валютные ценности.

39
00:02:08,680 --> 00:02:12,600
Человек становится два, два становится
, но мы на самом деле не

40
00:02:12,600 --> 00:02:16,890
ничего изменить в оригинале
Функция, в вызывающей.

41
00:02:16,890 --> 00:02:19,550
Потому что мы не можем, мы только
работы с их копий.

42
00:02:19,550 --> 00:02:24,760
С указателями, хотя, мы можем
на самом деле проходят X и Y в функцию.

43
00:02:24,760 --> 00:02:26,960
Эта функция может сделать
что-то с ними.

44
00:02:26,960 --> 00:02:29,250
И эти переменные значения
может реально изменить.

45
00:02:29,250 --> 00:02:33,710
Так что вполне изменение
наша способность работать с данными.

46
00:02:33,710 --> 00:02:36,100
>> Прежде чем мы углубимся в
указатели, я думаю, что это стоит

47
00:02:36,100 --> 00:02:38,580
принимая несколько минут до
вернуться к основам здесь.

48
00:02:38,580 --> 00:02:41,000
И есть посмотрим, как
Работы памяти компьютера

49
00:02:41,000 --> 00:02:45,340
потому что эти две темы идут
на самом деле довольно взаимосвязаны.

50
00:02:45,340 --> 00:02:48,480
Как вы, наверное, знаете,
на вашем компьютере

51
00:02:48,480 --> 00:02:51,310
у вас есть жесткий диск или
возможно, твердотельный накопитель,

52
00:02:51,310 --> 00:02:54,430
своего рода место для хранения файлов.

53
00:02:54,430 --> 00:02:57,950
Это, как правило, где-то в
окрестность 250 гигабайт

54
00:02:57,950 --> 00:02:59,810
, может быть, пару терабайт сейчас.

55
00:02:59,810 --> 00:03:02,270
И это, где все ваши
Файлы в конечном счете, жить,

56
00:03:02,270 --> 00:03:04,870
даже когда ваш компьютер выключен
выключен, вы можете включить его обратно на

57
00:03:04,870 --> 00:03:09,190
и вы найдете ваши файлы есть
снова, когда вы перезагрузите систему.

58
00:03:09,190 --> 00:03:14,820
Но диски, как жесткий диск,
с жесткими, или твердотельный накопитель, твердотельного накопителя,

59
00:03:14,820 --> 00:03:16,050
просто место для хранения.

60
00:03:16,050 --> 00:03:20,400
>> Мы не можем на самом деле ничего общего с
данные, которые на жестком диске,

61
00:03:20,400 --> 00:03:22,080
или твердотельным накопителем.

62
00:03:22,080 --> 00:03:24,950
Для того, чтобы реально изменить
данных или переместить его вокруг,

63
00:03:24,950 --> 00:03:28,800
у нас есть, чтобы переместить его
ОЗУ, оперативное запоминающее устройство.

64
00:03:28,800 --> 00:03:31,170
Теперь ОЗУ, у вас есть много
меньше в вашем компьютере.

65
00:03:31,170 --> 00:03:34,185
Вы можете иметь где-то в
окрестность 512 мегабайт

66
00:03:34,185 --> 00:03:38,850
если у вас есть старый компьютер,
, может быть, два, четыре, восемь, 16,

67
00:03:38,850 --> 00:03:41,820
возможно, даже немного
Более того, гигабайт оперативной памяти.

68
00:03:41,820 --> 00:03:46,390
Так вот гораздо меньше, но это
где все летучие данных существует.

69
00:03:46,390 --> 00:03:48,270
Вот где мы можем что-то изменить.

70
00:03:48,270 --> 00:03:53,350
Но когда мы переходим наш компьютер выключен,
все данные в оперативной памяти разрушается.

71
00:03:53,350 --> 00:03:57,150
>> Так вот почему мы должны иметь жесткий диск
для более постоянного места ней,

72
00:03:57,150 --> 00:03:59,720
так, что она будет exists- он
действительно плохо, если мы каждый раз

73
00:03:59,720 --> 00:04:03,310
Оказалось наш компьютер выключен, каждый
Файл в нашей системе был уничтожен.

74
00:04:03,310 --> 00:04:05,600
Так мы работаем внутри оперативной памяти.

75
00:04:05,600 --> 00:04:09,210
И каждый раз, когда мы говорим о
памяти, в значительной степени, в CS50,

76
00:04:09,210 --> 00:04:15,080
мы говорим о памяти, а не на жестком диске.

77
00:04:15,080 --> 00:04:18,657
>> Поэтому, когда мы переместить вещи в память,
она занимает определенное количество пространства.

78
00:04:18,657 --> 00:04:20,740
Все типы данных, которые
мы работаем с

79
00:04:20,740 --> 00:04:23,480
взять разные
количество пространства в памяти.

80
00:04:23,480 --> 00:04:27,600
Таким образом, каждый раз, когда вы создать целое
переменная, четыре байта памяти

81
00:04:27,600 --> 00:04:30,750
отведены в оперативной памяти, чтобы вы
может работать с этим числом.

82
00:04:30,750 --> 00:04:34,260
Вы можете объявить число,
изменить его, назначить его

83
00:04:34,260 --> 00:04:36,700
до величины 10 увеличенным
одной, так далее и так далее.

84
00:04:36,700 --> 00:04:39,440
Все, что должно произойти в
Оперативной памяти, и вы получите четыре байта

85
00:04:39,440 --> 00:04:42,550
для работы с для каждого
целое число, вы создаете.

86
00:04:42,550 --> 00:04:45,410
>> Каждый персонаж вам
создать получает один байт.

87
00:04:45,410 --> 00:04:48,160
Вот только, сколько пространства
необходимо хранить символ.

88
00:04:48,160 --> 00:04:51,310
Каждый поплавок, реальная
Количество, получает четыре байта

89
00:04:51,310 --> 00:04:53,390
если это не двойной
точности с плавающей точкой

90
00:04:53,390 --> 00:04:56,510
число, которое позволяет
есть более точные или более цифр

91
00:04:56,510 --> 00:04:59,300
после десятичной точки
без потери точности,

92
00:04:59,300 --> 00:05:01,820
которые занимают восемь байт памяти.

93
00:05:01,820 --> 00:05:06,730
Длинные жаждет, действительно большие числа,
также принимать восемь байт памяти.

94
00:05:06,730 --> 00:05:09,000
Сколько байт памяти
у строки занимают?

95
00:05:09,000 --> 00:05:12,990
Ну давайте булавку в этом вопросе
сейчас, но мы вернемся к нему.

96
00:05:12,990 --> 00:05:17,350
>> Итак, вернемся к этой идее памяти как
большой массив байт размером ячеек.

97
00:05:17,350 --> 00:05:20,871
Вот и все, что есть, это
просто огромный массив ячеек,

98
00:05:20,871 --> 00:05:23,370
как и любой другой массив, который
вы знакомы с и посмотреть,

99
00:05:23,370 --> 00:05:26,430
кроме каждый элемент один байт.

100
00:05:26,430 --> 00:05:30,030
И так же, как массив,
каждый элемент имеет адрес.

101
00:05:30,030 --> 00:05:32,120
Каждый элемент массива
имеет индекс, и мы

102
00:05:32,120 --> 00:05:36,302
можно использовать этот индекс, чтобы сделать так называемый
произвольного доступа в массиве.

103
00:05:36,302 --> 00:05:38,510
Мы не должны начать на
начало массива,

104
00:05:38,510 --> 00:05:40,569
перебора каждый
один ее элемент,

105
00:05:40,569 --> 00:05:41,860
чтобы найти то, что мы ищем.

106
00:05:41,860 --> 00:05:45,790
Мы можем только сказать, я хочу, чтобы добраться до
15-элемент или 100-стихия.

107
00:05:45,790 --> 00:05:49,930
А можно просто в тот номер
и получить значение, которое вы ищете.

108
00:05:49,930 --> 00:05:54,460
>> Аналогично каждая локация
в памяти имеет адрес.

109
00:05:54,460 --> 00:05:57,320
Так ваша память может
искать что-то подобное.

110
00:05:57,320 --> 00:06:01,420
Вот очень мало кусок
память, это 20 байт памяти.

111
00:06:01,420 --> 00:06:04,060
Первые 20 байт, потому что мой
адресов есть на дне

112
00:06:04,060 --> 00:06:08,890
0, 1, 2, 3, и так
на всем пути до 19.

113
00:06:08,890 --> 00:06:13,190
И когда я заявляю, переменных и
когда я начинаю работать с ними,

114
00:06:13,190 --> 00:06:15,470
система собирается установить
в сторону некоторое пространство для меня

115
00:06:15,470 --> 00:06:17,595
В этой памяти для работы
с моими переменных.

116
00:06:17,595 --> 00:06:21,610
Так что я мог бы сказать, символ C равна капитал
Х. А что случится?

117
00:06:21,610 --> 00:06:23,880
Ну система будет
отложите для меня одного байта.

118
00:06:23,880 --> 00:06:27,870
В этом случае выбрал номер байта
четыре байта по адресу четырех,

119
00:06:27,870 --> 00:06:31,310
и он собирается хранить
заглавная буква Н в там для меня.

120
00:06:31,310 --> 00:06:34,350
Если я говорю, то скорость INT
предел равен 65, это

121
00:06:34,350 --> 00:06:36,806
собирается выделить четыре
байт памяти для меня.

122
00:06:36,806 --> 00:06:39,180
И это будет относиться к тем,
четыре байта, как единое целое

123
00:06:39,180 --> 00:06:41,305
потому что то, что мы работаем
с представляет собой целое число здесь.

124
00:06:41,305 --> 00:06:44,350
И это будет хранить 65 там.

125
00:06:44,350 --> 00:06:47,000
>> Теперь уже я вроде
говорю вам немного лжи,

126
00:06:47,000 --> 00:06:50,150
правильно, потому что мы знаем, что
компьютеры работают в двоичной системе.

127
00:06:50,150 --> 00:06:53,100
Они не понимают,
обязательно, что столица Н

128
00:06:53,100 --> 00:06:57,110
или то, что 65 есть, они только
понять бинарные, нули и единицы.

129
00:06:57,110 --> 00:06:59,000
И так на самом деле, что
мы там хранить

130
00:06:59,000 --> 00:07:03,450
не буква Н, и число 65,
но скорее двоичные представления

131
00:07:03,450 --> 00:07:06,980
его, что выглядеть
кое-что как это.

132
00:07:06,980 --> 00:07:10,360
И в частности в
контекст целой переменной,

133
00:07:10,360 --> 00:07:13,559
он не собирается просто плевать его в,
он не собирается рассматривать его как один четыре

134
00:07:13,559 --> 00:07:15,350
байт кусок обязательно,
это на самом деле происходит

135
00:07:15,350 --> 00:07:19,570
чтобы рассматривать его как один байт четырех кусков,
которые могли бы выглядеть следующим образом.

136
00:07:19,570 --> 00:07:22,424
И даже это не
совсем верно либо,

137
00:07:22,424 --> 00:07:24,840
из-за чего-то под названием
порядок байт, который мы не

138
00:07:24,840 --> 00:07:26,965
собирается получить в настоящее время, но
если вам интересно, о,

139
00:07:26,965 --> 00:07:29,030
Вы можете прочитать на немного
и большой порядок байт.

140
00:07:29,030 --> 00:07:31,640
Но ради этого аргумента,
ради этого видео,

141
00:07:31,640 --> 00:07:34,860
давайте предположим, что, в
То,, как число 65 будет

142
00:07:34,860 --> 00:07:36,970
быть представлены в
память на каждой системе,

143
00:07:36,970 --> 00:07:38,850
хотя это не совсем верно.

144
00:07:38,850 --> 00:07:41,700
>> Но давайте на самом деле просто получить
избавиться от всех бинарных полностью,

145
00:07:41,700 --> 00:07:44,460
и думать только о качестве H
и 65, это намного проще,

146
00:07:44,460 --> 00:07:47,900
думать о нем, как
что в человеческом существе.

147
00:07:47,900 --> 00:07:51,420
Ладно, так оно и кажется, может быть,
немного случайным, что моя система I've-

148
00:07:51,420 --> 00:07:55,130
не дать мне байт 5, 6, 7,
и 8 для хранения целое число.

149
00:07:55,130 --> 00:07:58,580
Там причина для этого тоже, что
мы не сможем получить в прямо сейчас, но достаточно

150
00:07:58,580 --> 00:08:00,496
сказать, что то, что
Компьютер делает здесь

151
00:08:00,496 --> 00:08:02,810
Вероятно, это хороший ход с его стороны.

152
00:08:02,810 --> 00:08:06,020
Чтобы не дать мне память, что это
обязательно спиной к спине.

153
00:08:06,020 --> 00:08:10,490
Несмотря на то, что это собирается сделать это сейчас
если я хочу, чтобы получить другую строку,

154
00:08:10,490 --> 00:08:13,080
называется фамилия, и я хочу,
положить Ллойда там.

155
00:08:13,080 --> 00:08:18,360
Я собираюсь необходимо установить один
характер, каждая буква, что это

156
00:08:18,360 --> 00:08:21,330
будет требовать один
характер, один байт памяти.

157
00:08:21,330 --> 00:08:26,230
Так что, если я мог бы поставить Ллойда в моей массива
как это я довольно хорошо идти, верно?

158
00:08:26,230 --> 00:08:28,870
Чего не хватает?

159
00:08:28,870 --> 00:08:31,840
>> Помните, что каждая строка мы работаем
с в С заканчивается обратной косой черты нулевой,

160
00:08:31,840 --> 00:08:33,339
и мы не можем опустить, что здесь, либо.

161
00:08:33,339 --> 00:08:36,090
Мы должны отложить один байт
памяти для хранения, что таким образом мы

162
00:08:36,090 --> 00:08:39,130
знаете, когда наша строка закончилась.

163
00:08:39,130 --> 00:08:41,049
Итак, еще раз это соглашение
из, как вещи

164
00:08:41,049 --> 00:08:42,799
появляются в мощи памяти
немного случайным,

165
00:08:42,799 --> 00:08:44,870
но на самом деле, как
большинство систем разработаны.

166
00:08:44,870 --> 00:08:48,330
Для выстроить их по мультипликаторам
из четырех человек, по причинам, снова

167
00:08:48,330 --> 00:08:50,080
что мы не должны
попасть в прямо сейчас.

168
00:08:50,080 --> 00:08:53,060
Но это, так достаточно сказать, что
после этих трех строк кода,

169
00:08:53,060 --> 00:08:54,810
это то, что память может выглядеть.

170
00:08:54,810 --> 00:08:58,930
Если мне нужно ячеек памяти
4, 8 и 12, чтобы держать мои данные,

171
00:08:58,930 --> 00:09:01,100
это то, что моя память может выглядеть.

172
00:09:01,100 --> 00:09:04,062
>> И только быть особенно
педантичный вот, когда

173
00:09:04,062 --> 00:09:06,020
мы говорим о памяти
адреса, как правило, мы

174
00:09:06,020 --> 00:09:08,390
сделать это, используя шестнадцатеричные обозначения.

175
00:09:08,390 --> 00:09:12,030
Так почему бы нам не превратить все это
от десятичной шестнадцатеричной форме

176
00:09:12,030 --> 00:09:15,010
только потому, что, как правило, это
как мы называем памятью.

177
00:09:15,010 --> 00:09:17,880
Таким образом, вместо того, чтобы быть от 0 до
19, что мы имеем нулевой

178
00:09:17,880 --> 00:09:20,340
х от нуля до нуля x1 три.

179
00:09:20,340 --> 00:09:23,790
Те 20 байт памяти, что мы
Иметь или мы смотрим на на этом изображении

180
00:09:23,790 --> 00:09:25,540
Прямо здесь.

181
00:09:25,540 --> 00:09:29,310
>> Таким образом, все, что было сказано, давайте
отойти от памяти на секунду

182
00:09:29,310 --> 00:09:30,490
и обратно к указателям.

183
00:09:30,490 --> 00:09:32,420
Вот самое главное
помнить

184
00:09:32,420 --> 00:09:34,070
как мы начали работать с указателями.

185
00:09:34,070 --> 00:09:36,314
Указатель ничего
более адреса.

186
00:09:36,314 --> 00:09:38,230
Я скажу это снова, потому что
это то, что важно,

187
00:09:38,230 --> 00:09:42,730
указатель ничего
более адреса.

188
00:09:42,730 --> 00:09:47,760
Указатели адреса в местах
в памяти, где переменные жить.

189
00:09:47,760 --> 00:09:52,590
Зная, что она становится, надеюсь,
немного легче работать с ними.

190
00:09:52,590 --> 00:09:54,550
Другое дело, мне нравится
чтобы сделать, это есть своего рода

191
00:09:54,550 --> 00:09:58,510
диаграмм визуально представляющий то, что
происходит с различными строк кода.

192
00:09:58,510 --> 00:10:00,660
И мы будем делать это пару
раз в указатели,

193
00:10:00,660 --> 00:10:03,354
и когда мы говорим о динамической
распределение памяти, а также.

194
00:10:03,354 --> 00:10:06,020
Потому что я думаю, что эти диаграммы
могут быть особенно полезны.

195
00:10:06,020 --> 00:10:09,540
>> Так что, если я говорю, например, INT к
в моем коде, что происходит?

196
00:10:09,540 --> 00:10:12,524
Ну что же происходит в основном в
Я получаю память отведенных для меня,

197
00:10:12,524 --> 00:10:14,690
но я даже не хотел бы
думаю об этом, как, что, я

198
00:10:14,690 --> 00:10:16,300
нравится думать о нем, как ящик.

199
00:10:16,300 --> 00:10:20,090
У меня есть окно, и это
цвета зеленый, потому что я

200
00:10:20,090 --> 00:10:21,750
может поставить целые числа в зеленые коробки.

201
00:10:21,750 --> 00:10:23,666
Если бы это был персонаж, которого я
может иметь синий ящик.

202
00:10:23,666 --> 00:10:27,290
Но я всегда говорю, если я создаю
коробка, которая может держать целые

203
00:10:27,290 --> 00:10:28,950
что коробка окрашена в зеленый цвет.

204
00:10:28,950 --> 00:10:33,020
И я беру постоянный маркер
и я пишу к на стороне.

205
00:10:33,020 --> 00:10:37,590
Так у меня есть коробка под названием K,
в котором я могу положить целые числа.

206
00:10:37,590 --> 00:10:41,070
Поэтому когда я говорю Int K, это
что происходит в моей голове.

207
00:10:41,070 --> 00:10:43,140
Если я говорю, к равна пяти, что я делаю?

208
00:10:43,140 --> 00:10:45,110
Ну, я ставлю пять
в коробке, правильно.

209
00:10:45,110 --> 00:10:48,670
Это довольно просто, если
Я говорю INT к, создать окно под названием K.

210
00:10:48,670 --> 00:10:52,040
Если я говорю, к равна 5,
поставил пять в поле.

211
00:10:52,040 --> 00:10:53,865
Надеюсь, что это не слишком много прыжком.

212
00:10:53,865 --> 00:10:55,990
Вот где дела идут
немного интересно, хотя.

213
00:10:55,990 --> 00:11:02,590
Если я говорю, INT * рк, хорошо, даже если я не
знаю, что это неизбежно означает,

214
00:11:02,590 --> 00:11:06,150
это явно есть что-то
сделать с целым числом.

215
00:11:06,150 --> 00:11:08,211
Так что я собираюсь покрасить
это поле зеленый иш,

216
00:11:08,211 --> 00:11:10,210
Я знаю, что есть что-то
сделать с целым числом,

217
00:11:10,210 --> 00:11:13,400
но это не само по себе целое,
потому что это INT звезда.

218
00:11:13,400 --> 00:11:15,390
Там что-то немного
отличается о нем.

219
00:11:15,390 --> 00:11:17,620
Так участие целое х,
но в противном случае это

220
00:11:17,620 --> 00:11:19,830
не слишком отличается от
то, что мы говорили.

221
00:11:19,830 --> 00:11:24,240
Это коробка, ее получили ярлык,
это носить ярлык рк,

222
00:11:24,240 --> 00:11:27,280
и он способен холдинга
INT звезды, все, что это такое.

223
00:11:27,280 --> 00:11:29,894
Они что-то делать
с целыми числами, ясно.

224
00:11:29,894 --> 00:11:31,060
Вот последняя строка, хотя.

225
00:11:31,060 --> 00:11:37,650
Если я говорю, рк = & K, эй,
что только что произошло, верно?

226
00:11:37,650 --> 00:11:41,820
Так что это случайное число, казалось бы, случайные
Количество, выкинут в коробке.

227
00:11:41,820 --> 00:11:44,930
Все, что есть, рк
получает адрес к.

228
00:11:44,930 --> 00:11:52,867
Так я придерживаюсь, где к живет в памяти,
его адрес, адрес его байт.

229
00:11:52,867 --> 00:11:55,200
Все, что я делаю, я говорю
это значение то, что я собираюсь

230
00:11:55,200 --> 00:11:59,430
положить в моей коробке под названием рк.

231
00:11:59,430 --> 00:12:02,080
И потому, что эти вещи
Указатели и потому ищет

232
00:12:02,080 --> 00:12:04,955
в строке, как нулевой х
восемь нулей с семи четырех восемь

233
00:12:04,955 --> 00:12:07,790
два ноль, вероятно,
не очень значимым.

234
00:12:07,790 --> 00:12:12,390
Когда мы, как правило визуализировать указатели,
мы на самом деле сделать это в качестве указателей.

235
00:12:12,390 --> 00:12:17,000
Рк дает нам информацию
мы должны найти K в памяти.

236
00:12:17,000 --> 00:12:19,120
Так в основном рк имеет стрелку в нем.

237
00:12:19,120 --> 00:12:21,670
И если мы ходим длину
этой стрелкой, представьте себе,

238
00:12:21,670 --> 00:12:25,280
это то, что вы можете ходить по, если мы
ходить вдоль стрелки,

239
00:12:25,280 --> 00:12:29,490
на самом кончике этого стрелки, мы
будет найти место в памяти

240
00:12:29,490 --> 00:12:31,390
где к жизни.

241
00:12:31,390 --> 00:12:34,360
И, что очень важно,
потому что как только мы знаем, где живет к,

242
00:12:34,360 --> 00:12:37,870
мы можем начать работать с данными
внутри этом месте памяти.

243
00:12:37,870 --> 00:12:40,780
Хотя мы получаем маленький
бит впереди себя сейчас.

244
00:12:40,780 --> 00:12:42,240
>> Так что указатель?

245
00:12:42,240 --> 00:12:45,590
Указатель является элемент данных которого
значение адрес памяти.

246
00:12:45,590 --> 00:12:49,740
Это было то, что ноль ноль восемь х вещи
происходит, это было адрес памяти.

247
00:12:49,740 --> 00:12:52,060
Это было место в памяти.

248
00:12:52,060 --> 00:12:55,080
И тип указателя
описывает вид

249
00:12:55,080 --> 00:12:56,930
данных, которые вы найдете в
что адрес памяти.

250
00:12:56,930 --> 00:12:58,810
Так что это INT звезда часть правый.

251
00:12:58,810 --> 00:13:03,690
Если я следовать, что стрелка, это
собирается привести меня к месту.

252
00:13:03,690 --> 00:13:06,980
И, что место, что я
найдете там в моем примере,

253
00:13:06,980 --> 00:13:08,240
зеленый цвета коробка.

254
00:13:08,240 --> 00:13:12,650
Это целое число, это то, что я
найдете, если я иду на этот адрес.

255
00:13:12,650 --> 00:13:14,830
Тип данных для
Указатель описывает то, что

256
00:13:14,830 --> 00:13:17,936
Вы найдете по этому адресу памяти.

257
00:13:17,936 --> 00:13:19,560
Так вот действительно здорово вещь, хотя.

258
00:13:19,560 --> 00:13:25,090
Указатели позволяют перейти
переменные между функциями.

259
00:13:25,090 --> 00:13:28,520
А на самом деле передать переменные
и не пройти их копии.

260
00:13:28,520 --> 00:13:32,879
Потому что, если мы точно знаем, где
в памяти, чтобы найти переменную,

261
00:13:32,879 --> 00:13:35,670
мы не должны сделать копию
это, мы можем просто пойти в это место

262
00:13:35,670 --> 00:13:37,844
и работать с этой переменной.

263
00:13:37,844 --> 00:13:40,260
Таким образом, в сущности указателей рода
из сделать компьютерную среду

264
00:13:40,260 --> 00:13:42,360
намного больше, как в реальном мире, верно.

265
00:13:42,360 --> 00:13:44,640
>> Так вот аналогия.

266
00:13:44,640 --> 00:13:48,080
Давайте предположим, что у меня есть ноутбук,
справа, и он полон заметок.

267
00:13:48,080 --> 00:13:50,230
И я бы хотел, чтобы вы обновите его.

268
00:13:50,230 --> 00:13:53,960
Вы это функция, которая
Обновления отмечает, право.

269
00:13:53,960 --> 00:13:56,390
В пути мы были
работает до сих пор, то, что

270
00:13:56,390 --> 00:14:02,370
происходит, вы будете принимать мой ноутбук,
Вы идете в магазин, копирования,

271
00:14:02,370 --> 00:14:06,410
вы будете делать ксерокопию
каждая страница записной книжки.

272
00:14:06,410 --> 00:14:09,790
Вы оставить свой ноутбук обратно
на моем столе, когда вы закончите,

273
00:14:09,790 --> 00:14:14,600
вы будете идти и вычеркнуть вещи в моем
ноутбук, который устарели или не так,

274
00:14:14,600 --> 00:14:19,280
и тогда вы будете проходить обратно
мне стопку страниц Xerox

275
00:14:19,280 --> 00:14:22,850
что является точной копией моего ноутбука с
изменения, которые вы внесли в него.

276
00:14:22,850 --> 00:14:27,040
И в тот момент, это до меня, как
вызывающая функция, как абоненту,

277
00:14:27,040 --> 00:14:30,582
чтобы решить ваши заметки и
интегрировать их обратно в моем блокноте.

278
00:14:30,582 --> 00:14:32,540
Таким образом, есть много шагов
участие здесь, прямо.

279
00:14:32,540 --> 00:14:34,850
Как это не было бы лучше,
если я просто говорю, эй, вы можете

280
00:14:34,850 --> 00:14:38,370
обновить ноутбук для
мне, вручить вам мой ноутбук,

281
00:14:38,370 --> 00:14:40,440
и вы берете вещи и
буквально пересечь их

282
00:14:40,440 --> 00:14:42,810
и обновлять свои записи в блокноте.

283
00:14:42,810 --> 00:14:45,140
А потом дать мне свой ноутбук обратно.

284
00:14:45,140 --> 00:14:47,320
Это вроде того, что
указатели позволяют сделать,

285
00:14:47,320 --> 00:14:51,320
они делают это окружение много
более нравится, как мы работаем в реальности.

286
00:14:51,320 --> 00:14:54,640
>> Все права, так вот что
указатель, давайте поговорим

287
00:14:54,640 --> 00:14:58,040
о том, как указатели работают в C, и
как мы можем начать работать с ними.

288
00:14:58,040 --> 00:15:02,550
Таким образом, есть очень простой указатель
в С называется нулевой указатель.

289
00:15:02,550 --> 00:15:04,830
Нулевой указатель указывает на ничего.

290
00:15:04,830 --> 00:15:08,310
Это, вероятно, кажется, что это
на самом деле не очень полезная вещь,

291
00:15:08,310 --> 00:15:10,500
но, как мы увидим
Чуть позже на тот факт,

292
00:15:10,500 --> 00:15:15,410
что это нулевой указатель существует
на самом деле очень может пригодиться.

293
00:15:15,410 --> 00:15:19,090
И всякий раз, когда вы создаете указатель, а
вы не установите его значение immediately-

294
00:15:19,090 --> 00:15:21,060
пример установки
его значение сразу

295
00:15:21,060 --> 00:15:25,401
будет несколько слайдов назад
где я сказал рк равна & K,

296
00:15:25,401 --> 00:15:28,740
рк получает адрес K, поскольку
мы увидим, что это значит,

297
00:15:28,740 --> 00:15:32,990
мы увидим, как код, который shortly-
если мы не установите его значение на что-то

298
00:15:32,990 --> 00:15:35,380
смысл сразу,
Вы должны всегда

299
00:15:35,380 --> 00:15:37,480
установить указатель, чтобы указать на нуль.

300
00:15:37,480 --> 00:15:40,260
Вы должны установить это, чтобы указать на нет.

301
00:15:40,260 --> 00:15:43,614
>> Это очень отличается от
просто оставить значение, как это

302
00:15:43,614 --> 00:15:45,530
а затем возможность объявления
Указатель и только при условии,

303
00:15:45,530 --> 00:15:48,042
это нуль, потому что это редко правда.

304
00:15:48,042 --> 00:15:50,000
Таким образом, вы всегда должны устанавливать
значение указателя

305
00:15:50,000 --> 00:15:55,690
до нуля, если вы не установите его значение
чтобы что-то значимое немедленно.

306
00:15:55,690 --> 00:15:59,090
Вы можете проверить, является ли значение указателя в
является недействительным с помощью оператора равенства

307
00:15:59,090 --> 00:16:05,450
(==), Так же, как вы сравните любое целое число
значения или символьные значения, используя (==)

308
00:16:05,450 --> 00:16:06,320
также.

309
00:16:06,320 --> 00:16:10,994
Это особый вид постоянной
значение, которое можно использовать для тестирования.

310
00:16:10,994 --> 00:16:13,160
Так что это было очень просто
указатель, нулевой указатель.

311
00:16:13,160 --> 00:16:15,320
Другой способ создания
указатель является извлечение

312
00:16:15,320 --> 00:16:18,240
адрес переменной
вы уже создали,

313
00:16:18,240 --> 00:16:22,330
и вы делаете это с помощью &
Добыча адрес оператора.

314
00:16:22,330 --> 00:16:26,720
Который мы уже видели ранее
в первом примере схемы я показал.

315
00:16:26,720 --> 00:16:31,450
Так что, если х является переменной, что мы
уже создали целого типа,

316
00:16:31,450 --> 00:16:35,110
то и х является указателем на целое число.

317
00:16:35,110 --> 00:16:39,810
и Х означает помните, и собирается извлечь
адрес вещи справа.

318
00:16:39,810 --> 00:16:45,350
А так как указатель это просто адрес,
чем и х является указателем на целое число

319
00:16:45,350 --> 00:16:48,560
значение которого, где в памяти х жизней.

320
00:16:48,560 --> 00:16:50,460
Это адрес Х.

321
00:16:50,460 --> 00:16:53,296
Так и х является адрес х.

322
00:16:53,296 --> 00:16:55,670
Давайте еще один шаг
дальше и подключить к чему-то

323
00:16:55,670 --> 00:16:58,380
Я ссылался на в предыдущем видео.

324
00:16:58,380 --> 00:17:06,730
Если обр массив двойников, то
и обр квадратная скобка я является указателем

325
00:17:06,730 --> 00:17:08,109
в два раза.

326
00:17:08,109 --> 00:17:08,970
ХОРОШО.

327
00:17:08,970 --> 00:17:12,160
обр квадратную скобку я, если
обр массив двойников,

328
00:17:12,160 --> 00:17:19,069
Затем обр квадратную скобку я это
I-й элемент этого массива,

329
00:17:19,069 --> 00:17:29,270
и & обр квадратную скобку я где в
памяти я-й элемент обр существует.

330
00:17:29,270 --> 00:17:31,790
>> Так в чем же смысл здесь?

331
00:17:31,790 --> 00:17:34,570
Массивы имя, значение
из всей этой вещи,

332
00:17:34,570 --> 00:17:39,290
является то, что имя массива является
на самом деле сам указатель.

333
00:17:39,290 --> 00:17:41,170
Вы работали
с указателями вдоль всего

334
00:17:41,170 --> 00:17:45,290
каждый раз, когда вы использовали массив.

335
00:17:45,290 --> 00:17:49,090
Запомнить на примере
по области определения переменной,

336
00:17:49,090 --> 00:17:53,420
в конце видео я представляю
пример, где мы имеем функцию

337
00:17:53,420 --> 00:17:56,890
называется множество INT и
Функция называется множество массив.

338
00:17:56,890 --> 00:18:00,490
И ваша задача, чтобы определить,
или нет, или то, что

339
00:18:00,490 --> 00:18:03,220
ценности, которые мы распечатанные
конец функции,

340
00:18:03,220 --> 00:18:05,960
В конце основной программы.

341
00:18:05,960 --> 00:18:08,740
>> Если вы помните из этого примера
или если вы смотрели видео,

342
00:18:08,740 --> 00:18:13,080
Вы знаете, что, когда вам-вызов
Набор INT эффективно ничего не делает.

343
00:18:13,080 --> 00:18:16,390
Но вызов, чтобы установить массив делает.

344
00:18:16,390 --> 00:18:19,280
И я вроде умалчивается, почему
что было на то время.

345
00:18:19,280 --> 00:18:22,363
Я просто сказал, хорошо это массив, это
специальное, вы знаете, есть причина.

346
00:18:22,363 --> 00:18:25,020
Причина в том, что массив-х
Название на самом деле просто указатель,

347
00:18:25,020 --> 00:18:28,740
и есть этот особый
Синтаксис квадратная скобка, что

348
00:18:28,740 --> 00:18:30,510
сделать вещи намного лучше работать.

349
00:18:30,510 --> 00:18:34,410
И они делают идею о
указатель много менее пугающим,

350
00:18:34,410 --> 00:18:36,800
и вот почему они вроде
из представленных в этом пути.

351
00:18:36,800 --> 00:18:38,600
Но на самом деле массивы просто указатели.

352
00:18:38,600 --> 00:18:41,580
И вот почему, когда мы
внесли изменения в массиве,

353
00:18:41,580 --> 00:18:44,880
когда мы прошли массив в качестве параметра
на функцию или в качестве аргумента

354
00:18:44,880 --> 00:18:50,110
к функции, содержимое массива
фактически изменили в обоих вызываемого абонента

355
00:18:50,110 --> 00:18:51,160
и в вызывающей функции.

356
00:18:51,160 --> 00:18:55,846
Какой для каждого другого вида
переменная, которую мы видели, было не так.

357
00:18:55,846 --> 00:18:58,970
Так что это просто что-то, чтобы держать в
ум, когда вы работаете с указателями,

358
00:18:58,970 --> 00:19:01,610
является то, что имя
Массив на самом деле указатель

359
00:19:01,610 --> 00:19:04,750
на первый элемент этого массива.

360
00:19:04,750 --> 00:19:08,930
>> ОК, так что теперь у нас есть все эти
факты, давайте продолжать идти, правильно.

361
00:19:08,930 --> 00:19:11,370
Почему мы заботимся о
где-то живет.

362
00:19:11,370 --> 00:19:14,120
Ну, как я уже сказал, это довольно
Полезно знать, где что-то живет

363
00:19:14,120 --> 00:19:17,240
так что вы можете пойти туда и изменить его.

364
00:19:17,240 --> 00:19:19,390
Работа с ней и на самом деле
есть вещь, которую вы

365
00:19:19,390 --> 00:19:23,710
хочу сделать с этой переменной эффекта отбора,
и не вступили в силу на некоторых копии.

366
00:19:23,710 --> 00:19:26,150
Это называется разыменования.

367
00:19:26,150 --> 00:19:28,690
Мы идем к ссылке и
мы меняем значение там.

368
00:19:28,690 --> 00:19:32,660
Так что, если у нас есть указатель, и это называется
шт, и это указывает на характер,

369
00:19:32,660 --> 00:19:40,610
то можно сказать, * * ПК и ПК является
Имя того, что мы найдем, если мы идем

370
00:19:40,610 --> 00:19:42,910
на адрес ПК.

371
00:19:42,910 --> 00:19:47,860
То, что мы найдем там персонаж и
* шт как мы обращаемся к данным на что

372
00:19:47,860 --> 00:19:48,880
место нахождения.

373
00:19:48,880 --> 00:19:54,150
Таким образом, мы могли бы сказать, что-то вроде
* шт = D или что-то подобное,

374
00:19:54,150 --> 00:19:59,280
и это означает, что что бы ни
был на адреса памяти компьютера,

375
00:19:59,280 --> 00:20:07,040
любого характера ранее
там, в настоящее время D, если мы говорим * PC = D.

376
00:20:07,040 --> 00:20:10,090
>> Так вот мы идем снова
некоторые странные вещи С, право.

377
00:20:10,090 --> 00:20:14,560
Таким образом, мы видели ранее * как
то часть с типом данных,

378
00:20:14,560 --> 00:20:17,160
и в настоящее время он используется в
немного другой контекст

379
00:20:17,160 --> 00:20:19,605
для доступа к данным на месте.

380
00:20:19,605 --> 00:20:22,480
Я знаю, это немного запутанным и
что на самом деле часть этого целого

381
00:20:22,480 --> 00:20:25,740
как, почему указатели имеют эту мифологию
вокруг них как настолько сложны,

382
00:20:25,740 --> 00:20:28,250
это своего рода проблемы синтаксиса, честно.

383
00:20:28,250 --> 00:20:31,810
Но * используется в обоих контекстах,
и как часть имени типа,

384
00:20:31,810 --> 00:20:34,100
и мы увидим, немного
позже еще что-то, тоже.

385
00:20:34,100 --> 00:20:36,490
И сейчас это
разыменовать оператор.

386
00:20:36,490 --> 00:20:38,760
Так он идет к ссылке,
это доступ к данным

387
00:20:38,760 --> 00:20:43,000
на месте указателя, и
позволяет манипулировать по своему желанию.

388
00:20:43,000 --> 00:20:45,900
>> Теперь это очень похоже на
посещения вашего соседа, право.

389
00:20:45,900 --> 00:20:48,710
Если вы знаете, что
Сосед живет, вы

390
00:20:48,710 --> 00:20:50,730
не болтаться с вашим соседом.

391
00:20:50,730 --> 00:20:53,510
Вы знаете, случается,
знаю, где они живут,

392
00:20:53,510 --> 00:20:56,870
но это не значит, что
силу того, что знания

393
00:20:56,870 --> 00:20:59,170
Вы взаимодействующих с ними.

394
00:20:59,170 --> 00:21:01,920
Если вы хотите, чтобы взаимодействовать с ними,
Вы должны пойти в их доме,

395
00:21:01,920 --> 00:21:03,760
Вы должны пойти туда, где они живут.

396
00:21:03,760 --> 00:21:07,440
И как только вы это сделаете,
то вы можете взаимодействовать

397
00:21:07,440 --> 00:21:09,420
с ними так же, как вы хотели бы.

398
00:21:09,420 --> 00:21:12,730
И точно так же с переменными,
Вы должны пойти в их адрес

399
00:21:12,730 --> 00:21:15,320
если вы хотите, чтобы взаимодействовать их,
Вы не можете просто знать адрес.

400
00:21:15,320 --> 00:21:21,495
И то, как вы идете на адреса
использовать *, оператор разыменования.

401
00:21:21,495 --> 00:21:23,620
Что вы думаете произойдет
если мы будем пытаться разыменовать

402
00:21:23,620 --> 00:21:25,260
указатель, значение которого равно нулю?

403
00:21:25,260 --> 00:21:28,470
Напомним, что нуль
указатель указывает ничего.

404
00:21:28,470 --> 00:21:34,110
Так что, если вы попробуете и разыменования
ничего или перейти к адресной ничего,

405
00:21:34,110 --> 00:21:36,800
что вы думаете происходит?

406
00:21:36,800 --> 00:21:39,630
Ну, если вы догадались сегментации
вина, вы были бы правы.

407
00:21:39,630 --> 00:21:41,390
Если вы попробуете и разыменования
пустой указатель,

408
00:21:41,390 --> 00:21:43,140
Вы страдаете сегментации
вина. Но ждать,

409
00:21:43,140 --> 00:21:45,820
не говорю вам, что
если вы не собираетесь

410
00:21:45,820 --> 00:21:49,220
чтобы установить значение вашего
указатель на что-то значимое,

411
00:21:49,220 --> 00:21:51,000
Вы должны установить на нуль?

412
00:21:51,000 --> 00:21:55,290
Я сделал, и на самом деле сегментация
неисправность рода хорошее поведение.

413
00:21:55,290 --> 00:21:58,680
>> Вы когда-нибудь объявили переменную и
не сразу присваивается его значение?

414
00:21:58,680 --> 00:22:02,680
Таким образом, вы просто сказать Int х; Вы не
на самом деле присвоить его ни к чему

415
00:22:02,680 --> 00:22:05,340
а затем позже в коде,
Вам распечатать значение х,

416
00:22:05,340 --> 00:22:07,650
имея до сих пор не
назначен его ни к чему.

417
00:22:07,650 --> 00:22:10,370
Часто вы получите
нулю, но иногда вы

418
00:22:10,370 --> 00:22:15,000
может получить случайное число, и
Вы понятия не имеете, где он пришел.

419
00:22:15,000 --> 00:22:16,750
Точно могу вещи
произойдет с указателями.

420
00:22:16,750 --> 00:22:20,110
Когда вы объявляете указатель
INT * рк например,

421
00:22:20,110 --> 00:22:23,490
и вы не назначить его значение,
Вы получаете четыре байта для памяти.

422
00:22:23,490 --> 00:22:25,950
Каковы бы ни были четыре байта
памяти система может

423
00:22:25,950 --> 00:22:28,970
обнаружите, что есть некоторые значимые ценности.

424
00:22:28,970 --> 00:22:31,760
И, возможно, было
то там уже, что

425
00:22:31,760 --> 00:22:34,190
не больше не нужен другой
Функция, так что вы просто должны

426
00:22:34,190 --> 00:22:35,900
все данные там.

427
00:22:35,900 --> 00:22:40,570
>> Что делать, если вы пытались сделать разыменование
некоторые адрес, который вы don't- было

428
00:22:40,570 --> 00:22:43,410
уже байты и информации в
там, что теперь в указатель.

429
00:22:43,410 --> 00:22:47,470
Если вы попробуете и разыменования указателя этого,
Вы могли бы возиться с какой-то памяти

430
00:22:47,470 --> 00:22:49,390
что вы не намерены
возиться со всем этим.

431
00:22:49,390 --> 00:22:51,639
И в самом деле вы могли бы сделать
что-то действительно разрушительным,

432
00:22:51,639 --> 00:22:54,880
как сломать другую программу,
или сломать другую функцию,

433
00:22:54,880 --> 00:22:58,289
или сделать что-то, что вредоносный
Вы не намерены делать вообще.

434
00:22:58,289 --> 00:23:00,080
И вот почему это
на самом деле хорошая идея

435
00:23:00,080 --> 00:23:04,030
установить свои указатели на нуль, если вам
не установлен их что-то осмысленное.

436
00:23:04,030 --> 00:23:06,760
Это, вероятно, лучше на
Конец дня для вашей программы

437
00:23:06,760 --> 00:23:09,840
к краху, то для того, чтобы сделать
то, что винты вверх

438
00:23:09,840 --> 00:23:12,400
другая программа или другая функция.

439
00:23:12,400 --> 00:23:15,207
Такое поведение, возможно, даже
менее идеальным, чем просто сбой.

440
00:23:15,207 --> 00:23:17,040
И вот почему это
на самом деле хорошая привычка

441
00:23:17,040 --> 00:23:20,920
чтобы попасть в ваши установить указатели
до нуля, если вы не установите их

442
00:23:20,920 --> 00:23:24,540
к значимому стоимости
немедленно, значение, что вы знаете

443
00:23:24,540 --> 00:23:27,260
и что вы можете безопасно выполнять разыменования.

444
00:23:27,260 --> 00:23:32,240
>> Итак, давайте вернемся в настоящее время и взглянуть
в общем синтаксисе ситуации.

445
00:23:32,240 --> 00:23:37,400
Если я говорю, INT * р ;, что я только что сделал?

446
00:23:37,400 --> 00:23:38,530
Что я сделал это.

447
00:23:38,530 --> 00:23:43,290
Я знаю, что величина р является адрес
потому что все указатели только

448
00:23:43,290 --> 00:23:44,660
адреса.

449
00:23:44,660 --> 00:23:47,750
Я могу разыменования р
используя оператор *.

450
00:23:47,750 --> 00:23:51,250
В этом контексте здесь, в самом
топ вспомнить * является частью типа.

451
00:23:51,250 --> 00:23:53,510
Int * тип данных.

452
00:23:53,510 --> 00:23:56,150
Но я могу разыменования
р, используя оператор *,

453
00:23:56,150 --> 00:24:01,897
и если я делаю так, если я иду по этому адресу,
то, что я найду по этому адресу?

454
00:24:01,897 --> 00:24:02,855
Я найду целое.

455
00:24:02,855 --> 00:24:05,910
Так INT * р в основном
говоря, р представляет собой адрес.

456
00:24:05,910 --> 00:24:09,500
Я могу разыменования р и если
Я, я найду целое

457
00:24:09,500 --> 00:24:11,920
в этом месте памяти.

458
00:24:11,920 --> 00:24:14,260
>> ОК, так что я сказал, что был еще один
раздражающая вещь со звездами

459
00:24:14,260 --> 00:24:17,060
и вот где, что
раздражающая вещь со звездами есть.

460
00:24:17,060 --> 00:24:21,640
Вы когда-нибудь пытались объявить
несколько переменных одного и того же типа

461
00:24:21,640 --> 00:24:24,409
на той же строке кода?

462
00:24:24,409 --> 00:24:27,700
Таким образом, для второго, делать вид, что линии,
код, который я на самом деле у них там в зеленый

463
00:24:27,700 --> 00:24:29,366
там нет, и он просто говорит INT х, у, г ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
То, что это будет сделать, это на самом деле создать
три целочисленные переменные для вас,

466
00:24:34,550 --> 00:24:36,930
одна называется х, одна называется
у, и один называется г.

467
00:24:36,930 --> 00:24:41,510
Это способ сделать это без
того, чтобы разделить на три линии.

468
00:24:41,510 --> 00:24:43,890
>> Вот где звезды получают
раздражает снова, хотя,

469
00:24:43,890 --> 00:24:49,200
потому что на самом деле * часть является
из имени типа и части

470
00:24:49,200 --> 00:24:50,320
имени переменной.

471
00:24:50,320 --> 00:24:56,430
И поэтому, если я говорю, INT * рх, ру, рг, то, что я
на самом деле получить указатель на целое

472
00:24:56,430 --> 00:25:01,650
называется ПВ и два целых числа, ру и рг.

473
00:25:01,650 --> 00:25:04,950
И это, наверное, не то, что
мы хотим, это не хорошо.

474
00:25:04,950 --> 00:25:09,290
>> Так что, если я хочу, чтобы создать несколько указателей
на той же линии, того же типа,

475
00:25:09,290 --> 00:25:12,140
и звезды, то, что я на самом деле нужно
чтобы сделать, это сказать INT * годовых, * PB * шт.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
Теперь только что сказал, что
и теперь говорю вам это,

478
00:25:20,300 --> 00:25:22,170
вы, вероятно, никогда не будет делать этого.

479
00:25:22,170 --> 00:25:25,170
И это, наверное, хорошо, честно говоря,
потому что вы можете случайно

480
00:25:25,170 --> 00:25:26,544
опустить звезду, что-то вроде этого.

481
00:25:26,544 --> 00:25:29,290
Это, вероятно, лучше, может быть, объявить
указатели на отдельных линиях,

482
00:25:29,290 --> 00:25:31,373
но это просто еще один
из тех раздражающих синтаксиса

483
00:25:31,373 --> 00:25:35,310
вещи со звездами, которые делают
указатели так трудно работать.

484
00:25:35,310 --> 00:25:39,480
Потому что это просто синтаксический это
беспорядок, вы должны работать через.

485
00:25:39,480 --> 00:25:41,600
С практикой это делает
действительно стала второй натурой.

486
00:25:41,600 --> 00:25:45,410
Я до сих пор делают ошибки с ним еще
после программирования в течение 10 лет,

487
00:25:45,410 --> 00:25:49,630
так что не расстраивайтесь, если что-то случится
Вам, это довольно распространено, честно говоря.

488
00:25:49,630 --> 00:25:52,850
Это действительно своего рода
недостаток синтаксиса.

489
00:25:52,850 --> 00:25:54,900
>> ОК, так что я вроде обещал
что мы вновь

490
00:25:54,900 --> 00:25:59,370
понятие, как большая строка.

491
00:25:59,370 --> 00:26:02,750
Ну, если я сказал вам, что
Строка, мы действительно вид

492
00:26:02,750 --> 00:26:04,140
лежал к вам все время.

493
00:26:04,140 --> 00:26:06,181
Там нет тип данных называется
строка, а на самом деле я

494
00:26:06,181 --> 00:26:09,730
упомянул об этом в одном из наших
Первые видео на типы данных,

495
00:26:09,730 --> 00:26:13,820
что строка была типом данных,
был создан для вас в CS50.h.

496
00:26:13,820 --> 00:26:17,050
Вы должны #include
CS50.h для того, чтобы использовать его.

497
00:26:17,050 --> 00:26:19,250
>> Ну строка на самом деле просто
псевдоним на что-то

498
00:26:19,250 --> 00:26:23,600
называется символ *, а
указатель на символ.

499
00:26:23,600 --> 00:26:26,010
Ну указатели, напомним,
просто обращается.

500
00:26:26,010 --> 00:26:28,780
Так что размер
в байтах строки?

501
00:26:28,780 --> 00:26:29,796
Ну, это четыре или восемь.

502
00:26:29,796 --> 00:26:32,170
И почему я говорю четыре или
восемь, потому что есть на самом деле

503
00:26:32,170 --> 00:26:36,730
зависит от системы, если вы используете
CS50 язь, голец * является размер гольца

504
00:26:36,730 --> 00:26:39,340
* Восемь, это 64-разрядная система.

505
00:26:39,340 --> 00:26:43,850
Каждый адрес в памяти 64 бита.

506
00:26:43,850 --> 00:26:48,270
Если вы используете прибор CS50
или с помощью любой 32-битной машины,

507
00:26:48,270 --> 00:26:51,640
и вы слышали, что термин 32-бит
машина, что 32-битные машины?

508
00:26:51,640 --> 00:26:56,090
Ну это просто означает, что каждый
адрес в памяти длиной 32 бита.

509
00:26:56,090 --> 00:26:59,140
И так 32 бит на четыре байта.

510
00:26:59,140 --> 00:27:02,710
Таким образом, символ * четыре или восемь
байт в зависимости от вашей системы.

511
00:27:02,710 --> 00:27:06,100
И в самом деле какие-либо типы данных,
и указатель на любых данных,

512
00:27:06,100 --> 00:27:12,030
типа, так как все указатели только
адреса, четыре или восемь байт.

513
00:27:12,030 --> 00:27:14,030
Итак, давайте вернемся в этом
График и давайте заключить

514
00:27:14,030 --> 00:27:18,130
это видео с небольшого упражнения здесь.

515
00:27:18,130 --> 00:27:21,600
Так вот схема мы остановились с
в самом начале видео.

516
00:27:21,600 --> 00:27:23,110
Так что теперь, если я говорю * рк = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
Так что это значит, когда я говорю, * рк = 35?

519
00:27:30,530 --> 00:27:32,420
Возьмите второй.

520
00:27:32,420 --> 00:27:34,990
* рк.

521
00:27:34,990 --> 00:27:39,890
В контексте здесь, является *
разыменовать оператор.

522
00:27:39,890 --> 00:27:42,110
Поэтому, когда разыменовать
оператор используется,

523
00:27:42,110 --> 00:27:48,520
мы идем в адрес указал
по рк, и мы меняемся, что мы находим.

524
00:27:48,520 --> 00:27:55,270
Так * рк = 35 эффективно
делает это на картинке.

525
00:27:55,270 --> 00:27:58,110
Так что это в основном синтаксически
идентичны в том, сказал K = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> Еще один.

528
00:28:01,930 --> 00:28:05,510
Если я говорю, INT м, я создаю
новая переменная называется м.

529
00:28:05,510 --> 00:28:08,260
Новое поле, это потому, что зеленый ящик
он собирается провести целое,

530
00:28:08,260 --> 00:28:09,840
и это помечены м.

531
00:28:09,840 --> 00:28:14,960
Если я говорю, M = 4, я ставлю
число в этом поле.

532
00:28:14,960 --> 00:28:20,290
Если скажем рк = & м, как же
это изменение схема?

533
00:28:20,290 --> 00:28:28,760
Рк = & м, вы вспомнить, что в
И оператор делает или как называется?

534
00:28:28,760 --> 00:28:34,430
Помните, что некоторые & имя переменной
это адрес переменной имя.

535
00:28:34,430 --> 00:28:38,740
Итак, что мы хотим сказать,
рк получает адрес м.

536
00:28:38,740 --> 00:28:42,010
И так эффективно, что происходит,
схема, что рк дольше без очков

537
00:28:42,010 --> 00:28:46,420
К, но указывает на м.

538
00:28:46,420 --> 00:28:48,470
>> Опять указатели очень
сложно работать

539
00:28:48,470 --> 00:28:50,620
и они занимают много
практика, а потому, что

540
00:28:50,620 --> 00:28:54,150
их способности, чтобы позволить вам
для передачи данных между функциями

541
00:28:54,150 --> 00:28:56,945
и на самом деле есть те
Изменения вступят в силу,

542
00:28:56,945 --> 00:28:58,820
получать вашу головку вокруг
это очень важно.

543
00:28:58,820 --> 00:29:02,590
Это, вероятно, является самым сложным
Эту тему мы обсудим в CS50,

544
00:29:02,590 --> 00:29:05,910
но значение, что вам
получить от использования указателей

545
00:29:05,910 --> 00:29:09,200
значительно перевешивает осложнений
которые приходят от обучения их.

546
00:29:09,200 --> 00:29:12,690
Так что я желаю вам лучше
удачи узнать о указатели.

547
00:29:12,690 --> 00:29:15,760
Я Дуг Ллойд, это CS50.

548
00:29:15,760 --> 00:29:17,447