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, а ние
ги помине на функција наречена swap,

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
iterate преку секоја
еден елемент од него,

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
Ако велам потоа брзина 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
Тие не разбираат
нужно што капитален 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
наречен презиме, и сакам
да се стави Лојд во таму.

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
>> Запомни дека секој стринг ние работиме
со во 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
Покажувач ништо
повеќе од една адреса.

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
>> Значи, ако јас се каже на пример, цел број k
во мојот код, што се случува?

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
Па имам кутија наречена к,
во кои можам да се стави цели броеви.

206
00:10:37,590 --> 00:10:41,070
Значи кога велам int к, тоа е
она што се случува во мојата глава.

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 * PK, добро, дури и ако јас не
знаете што е ова мора да значи,

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
Тоа е една кутија, неговата доби етикета,
таа е облечен во PK етикета,

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
Ако кажам PK = & К, Леле,
што едноставно се случи, нели?

226
00:11:37,650 --> 00:11:41,820
Па овој случаен број, навидум случајни
број, добива фрлени во казнениот простор таму.

227
00:11:41,820 --> 00:11:44,930
Сè што е, е PK
добива на адресата на k.

228
00:11:44,930 --> 00:11:52,867
Па јас сум држејќи каде k живее во меморијата,
адреса, на адресата на неговиот бајти.

229
00:11:52,867 --> 00:11:55,200
Сите правам е јас сум велејќи
таа вредност е она што јас ќе одам

230
00:11:55,200 --> 00:11:59,430
да се стави во внатрешноста на мојата кутија наречена PK.

231
00:11:59,430 --> 00:12:02,080
И затоа што овие работи се
покажувачи, и затоа бараат

232
00:12:02,080 --> 00:12:04,955
на жиците како нула x
осум нула в седум четири осум

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
Значи, во основа има PK стрела во неа.

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
каде k живее.

241
00:12:31,390 --> 00:12:34,360
И тоа е навистина важно
затоа што кога веќе знаеме каде k живее,

242
00:12:34,360 --> 00:12:37,870
ние може да почне да работи со податоците
внатре во тоа мемориска локација.

243
00:12:37,870 --> 00:12:40,780
Иако ние сме добивање на teeny
малку понапред од нас сега за сега.

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
Тоа беше тоа нулта x осум нула работи
случува, тоа беше адреса на меморијата.

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
ќе се направи копија од 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
дали постои оваа null покажувачот
всушност, навистина може да ни се најде.

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
ќе биде неколку слајдови назад
каде што реков PK еднаква & К,

296
00:15:25,401 --> 00:15:28,740
PK добива адреса к, како
ќе видиме што значи дека,

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
Значи, ако x е променлива што имаме
веќе создадени од типот цел број,

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
А од покажувач е само на адреса,
отколку & x е покажувач кон цел број

319
00:16:45,350 --> 00:16:48,560
чија вредност е местото каде што во знак на сеќавање х животи.

320
00:16:48,560 --> 00:16:50,460
Тоа е адреса x е.

321
00:16:50,460 --> 00:16:53,296
Така и x е адресата на 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
Ако ТП е низа на двојки, потоа
& ТП квадратни заградата јас е покажувач

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 квадратни заградата јас, ако
ТП е низа на двојки,

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

329
00:17:19,069 --> 00:17:29,270
и & ARR квадратни заградата јас е местото каде што во
меморија i-тиот елемент на ТП постои.

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
во близина на крајот на видео I презентираат
на пример, каде што имаат функција

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
до некоја функција, содржината на низата
всушност изменета во двете 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
>> OK, па сега ги имаме сите овие
факти, ајде да Продолжувам да одам, во право.

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
тогаш можеме да кажеме * * PC и компјутер е
името на она што ние ќе се најде ако одиме

370
00:19:40,610 --> 00:19:42,910
до адресата PC.

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
Па ние може да се каже нешто како
* PC = 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
И во моментов е на
оператор dereference.

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
И начинот на кој ќе се обратите на адреса е
да се користи *, операторот на dereference.

401
00:21:21,495 --> 00:21:23,620
Што мислите дека се случува
ако се обидеме и dereference

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
Значи, ако се обидете и dereference
ништо или да се врати на адреса што ништо,

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
Ако се обидете и dereference
нулти покажувач,

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 x; ти не
всушност, да ја доделите на ништо

415
00:22:02,680 --> 00:22:05,340
а потоа подоцна во вашиот код,
можете да испечатите на вредноста на x,

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
>> Што ако сте се обиделе да се направи dereference
некои адресата што ја don't- имало

428
00:22:40,570 --> 00:22:43,410
веќе бајти и информации во
таму, тоа е сега во вашиот покажувач.

429
00:22:43,410 --> 00:22:47,470
Ако се обидете и dereference дека покажувач,
може да се Месинг со некои меморија

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
Знам дека вредноста на p е адреса
бидејќи сите покажувачи се само

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

449
00:23:44,660 --> 00:23:47,750
Можам dereference стр
користење на операторот на *.

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
Но, можам да dereference
Па со операторот на *,

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 * р е во основа
велејќи: p е адреса.

456
00:24:05,910 --> 00:24:09,500
Можам dereference p и ако
Јас, јас ќе се најде цело број

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 x, y, z ;.

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
еден вика x, еден вика
y и 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
И така, ако кажам int * пиксели, PY, PZ, она што можам
всушност е покажувач кон цел број

472
00:24:56,430 --> 00:25:01,650
наречен пиксели и два цели броеви, PY и PZ.

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 * Па, * ФБ, * PC.

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
>> Ok, па јас вид на ветената
дека ќе го ревидира

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
наречен char *, односно
Покажувач на карактер.

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 IDE, char * е со големина на знак

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
Значи она што се случува сега, ако кажам * PK = 35?

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

518
00:27:26,370 --> 00:27:30,530
Значи она што значи тоа кога велам, * PK = 35?

519
00:27:30,530 --> 00:27:32,420
Се земе втора.

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

521
00:27:34,990 --> 00:27:39,890
Во контекстот, * е
оператор dereference.

522
00:27:39,890 --> 00:27:42,110
Па кога dereference
оператор се користи,

523
00:27:42,110 --> 00:27:48,520
одиме на адресата посочена да
страна PK, а ние се промени она што го наоѓаме.

524
00:27:48,520 --> 00:27:55,270
Така * PK = 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 m, Јас создавам
нова променлива наречена m.

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
Ако речеме PK = & 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
И така ефикасно да она што се случува на
дијаграм е дека веќе не PK поени

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