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
че всички данни, които се минава между
функции в C се предават по стойност.

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
Но дискови устройства, като твърд диск,
един HDD, или твърдотелен диск, на SSD,

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
ние трябва да го преместите
RAM, памет с произволен достъп.

64
00:03:28,800 --> 00:03:31,170
Сега RAM, имате много
по-малко от компютъра.

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
може би дори малко по-
повече, гигабайта RAM.

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
Но когато ние се обръщаме нашия компютър на разстояние,
всички данни в RAM е унищожен.

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
Така че ние работим вътре в RAM.

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

76
00:04:09,210 --> 00:04:15,080
ние не говорим за RAM, а не с твърд диск.

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
заемат различно
количества пространство в RAM.

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

81
00:04:27,600 --> 00:04:30,750
са заделени в RAM, така че
може да работи с това число.

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
Всичко, което трябва да се случи в
RAM, и ще получите четири байта

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
Така че мога да кажа, Чар в равнява на капитала
З. А какво ще се случи?

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
и то се случва, за да съхраните
главната буква H там за мен.

120
00:06:31,310 --> 00:06:34,350
Ако аз кажа, след това скоростта инт
граница се равнява на 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
Те не разбират,
непременно това на капитала H е

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
тъй като на нещо, наречено
един endianness, които ние не сме

138
00:07:24,840 --> 00:07:26,965
ще влязат в предприятието, но
ако сте любопитни за,

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

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
наречено фамилия, и аз искам
да се сложи Lloyd там.

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
Така че, ако можех да сложи Lloyd в моя масив
като това, че съм доста добър, за да отида, нали?

158
00:08:26,230 --> 00:08:28,870
Какво липсва?

159
00:08:28,870 --> 00:08:31,840
>> Не забравяйте, че всеки низ работим
с в C завършва с наклонена черта нула,

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
A показалка е нищо
повече от един адрес.

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
>> Така че, ако кажа, например, вътр к
в моя код, какво се случва?

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
Ако това беше знак I
може да има синя кутия.

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
Така че аз имам една кутия, наречена к,
в които мога да сложа числа.

206
00:10:37,590 --> 00:10:41,070
Така че, когато казвам, вътр к, това е
какво се случва в главата ми.

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
Това е доста ясен, ако
Казвам инт к, създайте кутия, наречена к.

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
Ако кажа, вътр * п.к., и дори и да не го правят
знам какво е това непременно означава,

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
но това не е самото число,
защото това е едно цяло число звезда.

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
Ако кажа, п.к. = & к, чакай,
това, което се случи, нали?

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
Pk ни дава информация
ние трябва да намерим к в паметта.

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
A показалка е елемент от данни, чието
стойност е адрес в паметта.

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
Така че има право на част инт звезда.

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
вие ще направите копие от Xerox
всяка страница от бележника.

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
Така че има един много прост показалка
в C нарича нулев показалеца.

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
ще бъде няколко слайда назад
когато казах п.к. равнява & к,

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

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
след това и X е указател към цяло число.

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

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
Така и X е адресът на х.

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
Ако ARR е масив от двойки, а след това
& ARR квадратна скоба и е указател

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
ARR квадратна скоба аз, ако
ARR е масив от двойки,

328
00:17:12,160 --> 00:17:19,069
След ARR квадратна скоба и е
-тото елемент от този масив,

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

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
нарича набор инт и
функция, наречена набор масив.

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
вие знаете, че когато ти-призива за
набор инт ефективно не прави нищо.

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
до функция, съдържанието на масива
действително се промени както в callee

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
Това се нарича dereferencing.

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, ако кажем * бр = D.

376
00:20:07,040 --> 00:20:10,090
>> Така че ето го отново с
някаква странна C неща, нали.

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
Така че можете просто да кажа инт х; не го направите
всъщност я възлага на нищо

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 * PK например,

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
Ако кажа, вътр * р ;, какво съм просто направи?

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
Така инт * р е в общи линии
казвайки, р е адрес.

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
не е там и тя просто казва инт х, ш, щ ;.

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
един наречените х, една, наречена
у, и една, наречена Z.

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
И така, ако кажа, вътр * пиксела, Ру, ЗЗ, това, което мога
се получи в действителност е показалец към цяло число

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
и звезди, това, което аз всъщност се нуждаят от
да направите е да се каже, вътр * па, * 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
Няма по тип данни, наречен
низ, а в действителност I

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
Така че това е основно синтактично
идентичен на това като рече к = 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
Ако кажа, инт м, създавам
нова променлива, наречена m.

529
00:28:05,510 --> 00:28:08,260
Нова кутия, това е зелена кутия, защото
то се случва да държи цяло число,

530
00:28:08,260 --> 00:28:09,840
и това е белязан m.

531
00:28:09,840 --> 00:28:14,960
Ако кажа, че m = 4, аз се сложи
число в тази кутия.

532
00:28:14,960 --> 00:28:20,290
Ако да речем п.к. = & m, как
тази промяна диаграма?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, направете си спомняте какво по
& Оператор прави или се нарича?

534
00:28:28,760 --> 00:28:34,430
Не забравяйте, че и някои променлива име
е адресът на името на променливата.

535
00:28:34,430 --> 00:28:38,740
Така че това, което казвам е,
PK получава адреса на т.

536
00:28:38,740 --> 00:28:42,010
И така, какво се случва на практика
диаграма е, че вече не п.к. точки

537
00:28:42,010 --> 00:28:46,420
до к, но насочва към m.

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