1
00:00:00,000 --> 00:00:02,440
[Powered by Google Translate] [Показивачи]

2
00:00:02,440 --> 00:00:05,000
[Роб Бовден] [Универзитет Харвард]

3
00:00:05,000 --> 00:00:07,360
[Ово је ЦС50] [ЦС50.ТВ]

4
00:00:07,360 --> 00:00:08,820
>> Хајде да причамо о показивача.

5
00:00:08,820 --> 00:00:13,710
До сада смо увек само из стварима у меморији изричито имену.

6
00:00:13,710 --> 00:00:22,610
Рекли смо инт н = 42, и онда када желимо да користимо променљиву н,

7
00:00:22,610 --> 00:00:30,640
ми смо само га зову по имену смо га дати пишући нешто Н * 2.

8
00:00:30,640 --> 00:00:34,790
Али, то мора да живи негде променљива у меморији.

9
00:00:34,790 --> 00:00:37,790
Када желите да користите вредност која је тренутно ускладиштена у н,

10
00:00:37,790 --> 00:00:40,730
или ажурирате вредност која н се држи,

11
00:00:40,730 --> 00:00:44,180
Ваш програм треба да зна где у меморији да траже н.

12
00:00:44,180 --> 00:00:48,320
Где у меморији променљивој живи зове се њена адреса.

13
00:00:48,320 --> 00:00:49,940
То је као кућну адресу.

14
00:00:49,940 --> 00:00:53,080
Ја могу наћи нечију кућу док ја знам њихову кућну адресу,

15
00:00:53,080 --> 00:00:58,110
и компјутерски програм може да нађе променљиву док она зна своју меморијску адресу.

16
00:00:58,110 --> 00:01:02,660
Шта показивачи дају је начин директно баве овим меморијским адресама.

17
00:01:02,660 --> 00:01:06,860
>> Много снаге у Ц долази од могућности да манипулише меморију овако.

18
00:01:06,860 --> 00:01:09,960
Али, са великом снагом долази и велика одговорност.

19
00:01:09,960 --> 00:01:14,670
Показивачи се може користити опасно довољно да много програмских језика

20
00:01:14,670 --> 00:01:16,460
сакрити показиваче у потпуности.

21
00:01:16,460 --> 00:01:19,440
Па, зашто нам укаже Ц онда?

22
00:01:19,440 --> 00:01:22,680
Као што знате, аргументи у Ц функцији

23
00:01:22,680 --> 00:01:25,370
увек копирају у параметрима функције.

24
00:01:25,370 --> 00:01:33,260
Дакле, називајући нешто свап на неким променљивих Кс и И

25
00:01:33,260 --> 00:01:38,840
Не могу да петља вредности кии у функцији позива,

26
00:01:38,840 --> 00:01:40,810
иако би то могао бити при руци.

27
00:01:40,810 --> 00:01:46,430
Као што ћемо видети касније, преписивање своп да показивачи на локације којима је потребна да се замени

28
00:01:46,430 --> 00:01:49,690
омогућава да утиче на променљиве свог саговорника.

29
00:01:49,690 --> 00:01:54,150
>> Прошетајмо кроз релативно једноставан пример онога показивачи могу да ураде.

30
00:01:54,150 --> 00:02:15,550
Рецимо имамо инт н = 4 и инт * поинтер_то_н = & н.

31
00:02:15,550 --> 00:02:18,990
Вау! Мало нову синтаксу за покривање.

32
00:02:18,990 --> 00:02:22,600
Прво, хајде да тумачите & н.

33
00:02:22,600 --> 00:02:27,260
Сетите се да је све у меморији има неку адресу.

34
00:02:27,260 --> 00:02:30,800
Амперсендом се зове "адреса" оператера.

35
00:02:30,800 --> 00:02:36,470
Дакле, & Н се односи на адресу у меморији где се налазе н.

36
00:02:36,470 --> 00:02:41,560
Сада смо складиштење ову адресу у новој променљивој, поинтер_то_н.

37
00:02:41,560 --> 00:02:43,870
Шта је тип ове нове променљиве?

38
00:02:43,870 --> 00:02:47,410
Звездица је део типа варијабле,

39
00:02:47,410 --> 00:02:49,880
а ми ћемо читати као тип инт *.

40
00:02:49,880 --> 00:02:56,500
Инт * значи да поинтер_то_н је променљива која складишти адресу цео број.

41
00:02:56,500 --> 00:03:02,970
Знамо да је и н инт * јер је н цео број, а водимо адресу н.

42
00:03:02,970 --> 00:03:06,660
Међ * је пример показивач типа.

43
00:03:06,660 --> 00:03:10,150
Чим почнете да видите звездицу у врсти,

44
00:03:10,150 --> 00:03:11,950
Ви знате да имате посла са тројке.

45
00:03:11,950 --> 00:03:16,520
Као што можемо прогласити променљиву као инт и цхар и,

46
00:03:16,520 --> 00:03:20,410
можемо рећи инт * З и знак * ж.

47
00:03:20,410 --> 00:03:25,190
Инт * и цхар су само нове врсте за нас да користимо.

48
00:03:25,190 --> 00:03:29,430
Положај * могу нигде да оде пре него што име променљиве.

49
00:03:29,430 --> 00:03:34,730
Дакле, и инт * поинтер_то_н - са * поред ИНТ, јер ми овде имамо -

50
00:03:34,730 --> 00:03:45,210
и инт * поинтер_то_н са * поред поинтер_то_н важе.

51
00:03:45,210 --> 00:03:56,470
Али овде, ја ћу поставити * поред Инт.

52
00:03:56,470 --> 00:04:00,600
Није битно који волите, само будите доследни.

53
00:04:00,600 --> 00:04:02,810
>> Хајде да нацртате дијаграм за ово.

54
00:04:02,810 --> 00:04:07,590
Ми прво морамо променљиву н, што ћемо извући као малу кутију меморије.

55
00:04:07,590 --> 00:04:15,400
За овај пример, рецимо да је ово поље се налази на адреси 100.

56
00:04:15,400 --> 00:04:18,820
Унутар овог оквира, ми чување вредности 4.

57
00:04:18,820 --> 00:04:23,730
Сада имамо нову променљиву поинтер_то_н.

58
00:04:23,730 --> 00:04:27,030
Она има своју кутију у меморији,

59
00:04:27,030 --> 00:04:32,900
што ћемо рећи је на адреси 200.

60
00:04:32,900 --> 00:04:37,220
Унутар овог оквира, ми смо складиштење адресу н,

61
00:04:37,220 --> 00:04:39,890
који смо раније рекао да је 100.

62
00:04:39,890 --> 00:04:44,710
Често у дијаграмима, видећете ово показало као дословном стрелице

63
00:04:44,710 --> 00:04:48,730
остављајући поинтер_то_н кутија указујући на поље које складишти н.

64
00:04:48,730 --> 00:04:54,620
Дакле, шта можемо урадити са поинтер_то_н заправо?

65
00:04:54,620 --> 00:05:10,400
Па, ако кажемо нешто слично * поинтер_то_н = 8, ово је другачија употреба за звездицу

66
00:05:10,400 --> 00:05:14,830
која је потпуно одвојена од коришћења звездицом у проглашења променљиву

67
00:05:14,830 --> 00:05:16,790
од показивача типа.

68
00:05:16,790 --> 00:05:21,130
Овде звездицу назива се дереференце оператера.

69
00:05:21,130 --> 00:05:26,860
У нашем дијаграму, оно * поинтер_то_н = 8 значи,

70
00:05:26,860 --> 00:05:32,220
идите на поље садржи поинтер_то_н, следите стрелицу,

71
00:05:32,220 --> 00:05:38,160
а затим доделити поље на крају стрелице вредност 8.

72
00:05:38,160 --> 00:05:45,960
То значи да после ове линије, ако покушамо да користимо н она ће имати вредност 8.

73
00:05:45,960 --> 00:05:51,600
Реч "показивач" се користи у многим различитим контекстима.

74
00:05:51,600 --> 00:05:54,380
Овде ћемо покушати да буде доследна.

75
00:05:54,380 --> 00:05:58,330
Показивач тип је нешто као инт *.

76
00:05:58,330 --> 00:06:04,630
У овом видеу, показивач ће се користити само да значи вредност са показивачем типа,

77
00:06:04,630 --> 00:06:08,180
као поинтер_то_н који има типа инт *.

78
00:06:08,180 --> 00:06:15,140
Било где смо навикли да само кажем н, сада можемо рећи, уместо * поинтер_то_н,

79
00:06:15,140 --> 00:06:18,020
и све ће радити као добро.

80
00:06:18,020 --> 00:06:21,120
>> Прошетајмо кроз другу једноставан пример.

81
00:06:21,120 --> 00:06:50,390
Рецимо имамо инт н = 14; инт * показивац = &н; н + + и (* поентер) + +.

82
00:06:50,390 --> 00:06:59,830
Прва линија креира нову кутију у меморији са ознаком Н.

83
00:06:59,830 --> 00:07:05,400
Овај пут, нећемо обележи кутију са експлицитним адресу, али још увек има.

84
00:07:05,400 --> 00:07:11,810
Унутар кутије, ми складиштење број 14.

85
00:07:11,810 --> 00:07:22,290
Следећа линија ствара другу кутију са ознаком показивач.

86
00:07:22,290 --> 00:07:27,210
И унутар тог оквира, ми складиштење показивач на поље са ознаком Н.

87
00:07:27,210 --> 00:07:33,170
Дакле, хајде да нацртате стрелицу од казаљке на н.

88
00:07:33,170 --> 00:07:37,790
Сада, н + + увећава вредност у пољу са ознаком н

89
00:07:37,790 --> 00:07:45,420
па идемо од 14 до 15 година.

90
00:07:45,420 --> 00:07:53,330
Коначно, (* поинтер) + + иде у кутији са ознаком показивача,

91
00:07:53,330 --> 00:08:02,660
дереференцес вредност у пољу, што значи пратити стрелицу где поена,

92
00:08:02,660 --> 00:08:11,690
и повећава вредност ускладиштена тамо, па идемо од 15 до 16 година.

93
00:08:11,690 --> 00:08:13,480
И то је то.

94
00:08:13,480 --> 00:08:18,480
Није сада чува број 16, након што је два пута увећава -

95
00:08:18,480 --> 00:08:25,050
некада директно помоћу име променљиве н, а други кроз поинтер_то_н.

96
00:08:25,050 --> 00:08:33,360
>> Брзо квиз. Шта мислиш да значи да ако покушам да кажем нешто слично && н?

97
00:08:33,360 --> 00:08:41,350
Па, хајде да преправи ово као и (& Н) који остварује исту ствар.

98
00:08:41,350 --> 00:08:47,030
Је (& Н) враћа адресу променљиве Н у меморији.

99
00:08:47,030 --> 00:08:53,110
Али онда онда спољни амперсанд покушава да врати адресу адресу.

100
00:08:53,110 --> 00:08:56,600
То је као да покушавате да урадите и 2.

101
00:08:56,600 --> 00:09:00,550
То нема смисла да добије адресу само одредјени број

102
00:09:00,550 --> 00:09:03,260
јер га не чувају у меморији.

103
00:09:03,260 --> 00:09:07,090
Коришћење два амперсандс заредом није никада праву идеју.

104
00:09:07,090 --> 00:09:28,960
Али сада, шта значи ако покушам да кажем инт ** доубле_поинтер = & показивач?

105
00:09:28,960 --> 00:09:40,750
Сада сам стварајући нову кутију означену доубле_поинтер,

106
00:09:40,750 --> 00:09:44,590
и унутар тог оквира сам складиштење адресу показивача,

107
00:09:44,590 --> 00:09:50,810
што значи да извучемо једну стрелицу из доубле_поинтер кутије на показивач кутији.

108
00:09:50,810 --> 00:09:56,640
Обратите пажњу на тип доубле_поинтер, инт **.

109
00:09:56,640 --> 00:10:03,700
Није био цео, показивач складишти адресу н, па има типа инт *.

110
00:10:03,700 --> 00:10:10,550
Сада, доубле_поинтер складишти адресу показивача, тако да има тип инт **.

111
00:10:10,550 --> 00:10:15,070
>> Па, шта мислимо, то значи -

112
00:10:15,070 --> 00:10:24,490
** Доубле_поинтер = 23?

113
00:10:24,490 --> 00:10:28,630
Приметићете да сам сада ја два пута дереференцинг.

114
00:10:28,630 --> 00:10:32,030
Само пратите бокс и стрелице дијаграм смо већ поставили.

115
00:10:32,030 --> 00:10:36,400
Прво, идемо у поље са ознаком доубле_поинтер.

116
00:10:36,400 --> 00:10:40,550
Први * значи следити једном стрелицу.

117
00:10:40,550 --> 00:10:44,110
Сада смо у биоскопима са ознаком показивача.

118
00:10:44,110 --> 00:10:49,940
Друга звезда каже да прати стрелицу,

119
00:10:49,940 --> 00:10:58,230
и сада смо на табели са ознаком Н, а ми смо поставили вредност овог поља на 23 године.

120
00:10:58,230 --> 00:11:05,940
Обратите пажњу да су дереференце и 'адреса' оператера су инверзни једне другима.

121
00:11:05,940 --> 00:11:16,990
То ми омогућава да радим нешто слично * & * & н = 42.

122
00:11:16,990 --> 00:11:22,550
Док ово ради, никада не треба да урадите нешто овако у пракси.

123
00:11:22,550 --> 00:11:24,840
Шта ми заправо радимо овде?

124
00:11:24,840 --> 00:11:28,700
Први амперсанд хвата адресу променљиве н.

125
00:11:28,700 --> 00:11:34,660
Затим, имамо дереференце оператера, што значи да ће на ту адресу у меморији,

126
00:11:34,660 --> 00:11:36,910
тако да смо се вратили на н.

127
00:11:36,910 --> 00:11:40,910
Сада смо зграби адресу н поново и одмах дереференце,

128
00:11:40,910 --> 00:11:50,780
тако да смо се вратили у н и продавница 42.

129
00:11:50,780 --> 00:11:55,490
Дакле, сваки пар * & једноставно поништава.

130
00:11:55,490 --> 00:11:59,980
>> Постоји посебан показивач зове нулл показивач.

131
00:11:59,980 --> 00:12:03,140
Ово је показивач да ми никада требало дереференце.

132
00:12:03,140 --> 00:12:07,130
Таква Показивач је важно јер нам пружа начин да направе разлику између

133
00:12:07,130 --> 00:12:10,220
Показивач који треба и не треба дереференцед.

134
00:12:10,220 --> 00:12:13,050
Ако покушате да дереференце нулл показивач,

135
00:12:13,050 --> 00:12:17,150
обично је ваш програм ће се срушити са сегментације квара,

136
00:12:17,150 --> 00:12:19,210
које сте можда видели раније.

137
00:12:19,210 --> 00:12:30,490
Дакле, хајде да кажемо да имамо код инт * к = нулл; * к = 4.

138
00:12:30,490 --> 00:12:36,190
У овом примеру, може изгледати очигледно да радимо нешто лоше,

139
00:12:36,190 --> 00:12:40,650
али запамтите да ништаван бити стварно вредност вратио из позива на функцији

140
00:12:40,650 --> 00:12:45,930
као маллоц, ако маллоц није у могућности да издвоји меморију тражене од стране корисника.

141
00:12:45,930 --> 00:12:50,200
Из тог разлога, ако се уместо тога смо поставили вредност к од позива да маллоц,

142
00:12:50,200 --> 00:13:12,050
као у инт * к = маллоц (сизеоф (инт)), онда увек треба експлицитно провери

143
00:13:12,050 --> 00:13:15,280
да видим да ли нула враћена.

144
00:13:15,280 --> 00:13:43,250
Иф (к == нулл); / / ухох! повратак елсе можемо наставити даље и кажу * к = 4.

145
00:13:43,250 --> 00:13:47,780
>> Дакле, опет, зашто би смо икада користити показиваче?

146
00:13:47,780 --> 00:13:51,910
Погледајмо пример програма, где морамо да користимо показиваче -

147
00:13:51,910 --> 00:13:54,110
једноставна свап функција.

148
00:13:54,110 --> 00:14:08,270
Рецимо да имате два цела броја, инт к = 4 и инт и = 15;

149
00:14:08,270 --> 00:14:21,220
и желим да напишем неку функцију зове своп да могу да користе овако: свап (к, и).

150
00:14:21,220 --> 00:14:28,270
После овој линији, вредности унутар променљиве к треба да буде 15,

151
00:14:28,270 --> 00:14:32,360
и вредност у променљиву и треба да буде 4.

152
00:14:32,360 --> 00:14:36,510
Вредности унутар од к и и су заменили.

153
00:14:36,510 --> 00:14:53,040
Без тројке, можда ћемо покушати нешто слично воид свап (инт, инт б);

154
00:14:53,040 --> 00:15:09,750
инт тмп = б, б =; = тмп.

155
00:15:09,750 --> 00:15:12,960
Али, да ли сте приметили проблем са овим?

156
00:15:12,960 --> 00:15:19,000
Запамтите да вредност чува у променљивој је само копија вредности к,

157
00:15:19,000 --> 00:15:22,000
и вредност у БиХ се копира са и.

158
00:15:22,000 --> 00:15:28,000
Све промене извршене на А и Б неће се одразити на кии.

159
00:15:28,000 --> 00:15:32,050
Дакле, док су вредности А и Б су правилно замењен

160
00:15:32,050 --> 00:15:35,810
Кс и И нису променили уопште.

161
00:15:35,810 --> 00:15:38,480
Сада, хајде да промените функцију свап, тако да њени аргументи

162
00:15:38,480 --> 00:15:42,180
су показивачи на променљиве треба свап, овако:

163
00:15:42,180 --> 00:15:56,880
воид свап (инт *, инт * б); инт тмп = * б, б * = *, * = тмп.

164
00:15:56,880 --> 00:16:00,140
Запамтите да свопови аргументи су сада показивачи,

165
00:16:00,140 --> 00:16:05,670
па ми треба да прође адресу кии у позиву да мењају, овако:

166
00:16:05,670 --> 00:16:15,280
свап (& к, & и).

167
00:16:15,280 --> 00:16:20,520
Ово је сада исправно свопови вредностима к и и.

168
00:16:20,520 --> 00:16:24,310
>> Хајде да нацртате оквир и стрелице дијаграм да видим зашто се ово ради.

169
00:16:24,310 --> 00:16:28,520
Ми смо започели са нашим две кутије у меморији, Кс и И.

170
00:16:28,520 --> 00:16:35,780
Унутар кутије за к је број 4, а унутар оквира за и имамо 15.

171
00:16:35,780 --> 00:16:41,200
Сада, унутар позива на замену функције, имамо још две кутије

172
00:16:41,200 --> 00:16:45,140
за аргументе и б;

173
00:16:45,140 --> 00:16:50,960
а указује на кутији за к, а Б указује на кутији за и.

174
00:16:50,960 --> 00:16:58,070
Нова кутија је направљен за променљиве тмп,

175
00:16:58,070 --> 00:17:01,470
и унутар њега чувамо резултат дереференцинг б,

176
00:17:01,470 --> 00:17:04,980
што значи "прати стрелицу из кутије са ознаком Б".

177
00:17:04,980 --> 00:17:09,880
Дакле, чувамо 15 унутрашњост тмп.

178
00:17:09,880 --> 00:17:20,560
Затим пратимо стрелицу на б и складиште овде резултат дереференцинг,

179
00:17:20,560 --> 00:17:24,569
која је вредност 4.

180
00:17:24,569 --> 00:17:35,590
Коначно, пратимо стрелицу у продавници и оно што је тренутно унутар тмп, који је 15.

181
00:17:35,590 --> 00:17:42,440
Обратите пажњу да су кутије са ознаком Кс и И правилно замењен вредности.

182
00:17:42,440 --> 00:17:46,290
>> Када смо сазнали више о маллоц и динамичан управљање меморијом,

183
00:17:46,290 --> 00:17:49,610
ћемо видети да ми немамо избора него да користе показиваче.

184
00:17:49,610 --> 00:17:52,690
Шетајући кутија и стрелицом дијаграму за било који програм

185
00:17:52,690 --> 00:17:55,980
може да вам помогне да схватите шта програм заправо ради.

186
00:17:55,980 --> 00:17:59,680
>> Моје име је Роб Бовден, а ово је ЦС50.

187
00:18:00,000 --> 00:18:02,500
[ЦС50.ТВ]

188
00:18:02,500 --> 00:18:06,070
>> Ово је другачија употреба за звездицом - блеах, мрзим ту реч.

189
00:18:06,070 --> 00:18:13,960
Било где смо навикли да само кажем н, сада можемо рећи поинтер_то_н - не можете Зар не - * поинтер_то_н.