1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [Дел 4 - поудобно]

2
00:00:02,520 --> 00:00:04,850
[Роб Бауден - Универзитетот Харвард]

3
00:00:04,850 --> 00:00:07,370
[Ова е CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
Имаме квиз утре, во случај да сте момци не го знаев тоа.

5
00:00:14,810 --> 00:00:20,970
Тоа е основа на сè што можеше да се види во класа или треба да се гледа во класата.

6
00:00:20,970 --> 00:00:26,360
Тоа вклучува совети, иако тие се многу свежи тема.

7
00:00:26,360 --> 00:00:29,860
Вие најмалку треба да се разбере високи нивоа на нив.

8
00:00:29,860 --> 00:00:34,760
Нешто што немаше повеќе во класа треба да се разбере за квиз.

9
00:00:34,760 --> 00:00:37,320
Значи, ако имате прашања во врска со нив, можете да ги прашате сега.

10
00:00:37,320 --> 00:00:43,280
Но, ова ќе биде многу предводени од студентите сесија каде вие ​​момци поставуваат прашања,

11
00:00:43,280 --> 00:00:45,060
па се надевам дека луѓето имаат прашања.

12
00:00:45,060 --> 00:00:48,020
Дали некој има прашања?

13
00:00:49,770 --> 00:00:52,090
Да. >> [Студент] можете да одите преку покажувачи повторно?

14
00:00:52,090 --> 00:00:54,350
Јас ќе одам преку покажувачи.

15
00:00:54,350 --> 00:00:59,180
Сите ваши променливи мора да се живее во меморијата,

16
00:00:59,180 --> 00:01:04,450
но обично не се грижите за тоа и ќе речеме x + 2 и y + 3

17
00:01:04,450 --> 00:01:07,080
и компајлерот ќе дознаам каде работите се живее за вас.

18
00:01:07,080 --> 00:01:12,990
Откако ќе бидете занимаваат со покажувачи, сега сте експлицитно користење на овие мемориски адреси.

19
00:01:12,990 --> 00:01:19,800
Значи една променлива ќе само некогаш живее во една адреса во било кое дадено време.

20
00:01:19,800 --> 00:01:24,040
Ако сакаме да се изјасни за покажувач, што е од типот ќе изгледа?

21
00:01:24,040 --> 00:01:26,210
>> Сакам да прогласи покажувачот стр. Што значи типот изгледа?

22
00:01:26,210 --> 00:01:33,530
[Студент] int * стр. >> Да. Значи int * стр.

23
00:01:33,530 --> 00:01:38,030
И како можам да го прават тоа точка да х? >> [Студент] симболот.

24
00:01:40,540 --> 00:01:45,300
[Бауден] Значи симболот е буквално вика адреса на операторот.

25
00:01:45,300 --> 00:01:50,460
Значи, кога велам & х станува меморија адресата на променливата x.

26
00:01:50,460 --> 00:01:56,790
Па сега имам покажувачот p, и насекаде во мојот код можам да користам * P

27
00:01:56,790 --> 00:02:02,960
или би можел да го користите X и тоа ќе биде иста работа.

28
00:02:02,960 --> 00:02:09,520
(* М). Што е тоа го прават? Што значи дека ѕвездата значи?

29
00:02:09,520 --> 00:02:13,120
[Студент] Тоа значи вредност во тој момент. >> Да.

30
00:02:13,120 --> 00:02:17,590
Значи, ако ние се погледне во него, тоа може да биде многу корисно да се извлече дијаграми

31
00:02:17,590 --> 00:02:22,230
кога тоа е мала кутија на меморија за x, што се случува да имаат вредност 4,

32
00:02:22,230 --> 00:02:25,980
тогаш имаме мала кутија на меморија за P,

33
00:02:25,980 --> 00:02:31,590
и така стр поени за x, па ние привлече стрела од стр до x.

34
00:02:31,590 --> 00:02:40,270
Значи, кога велиме * p ние велиме одат во кутија која е p.

35
00:02:40,270 --> 00:02:46,480
Ѕвезда е да се следат стрелките, а потоа правите што сакате со таа кутија право таму.

36
00:02:46,480 --> 00:03:01,090
Па можам да кажам * P = 7; и дека ќе оди во кутија која е x и промена која до 7.

37
00:03:01,090 --> 00:03:13,540
Или би можел да каже int z = * P * 2, тоа е збунувачки, бидејќи тоа е ѕвезда, ѕвезда.

38
00:03:13,540 --> 00:03:19,230
На една ѕвезда е dereferencing стр, другата ѕвезда се размножуваат со 2.

39
00:03:19,230 --> 00:03:26,780
Забележиш јас би можеле да имаат исто како и заменува * P со x.

40
00:03:26,780 --> 00:03:29,430
Можете да ги користите на ист начин.

41
00:03:29,430 --> 00:03:38,000
А потоа подоцна можам да стр точка за нешто сосема ново.

42
00:03:38,000 --> 00:03:42,190
Јас само може да се каже p = &z;

43
00:03:42,190 --> 00:03:44,940
Па сега p повеќе не укажува на x, тоа укажува на ●.

44
00:03:44,940 --> 00:03:50,510
И во секое време јас * P тоа е исто како прави z.

45
00:03:50,510 --> 00:03:56,170
Па корисна работа за ова е еднаш ние започне да добива во функции.

46
00:03:56,170 --> 00:03:59,790
>> Тоа е вид на бескорисни да се изјасни покажувач што укажува на нешто

47
00:03:59,790 --> 00:04:03,140
а потоа сте само да го dereferencing

48
00:04:03,140 --> 00:04:06,060
кога ќе може да се користат оригиналната променлива да почне.

49
00:04:06,060 --> 00:04:18,190
Но кога ќе влезат во функции - па да речеме имаме некои функција, int foo,

50
00:04:18,190 --> 00:04:32,810
кој ги зема покажувач и само не * P = 6;

51
00:04:32,810 --> 00:04:39,990
Како што видовме досега со трампа, не можете да направите ефективен swap и посебна функција

52
00:04:39,990 --> 00:04:45,180
од само поминува цели броеви, бидејќи сè во C е секогаш поминува вредност.

53
00:04:45,180 --> 00:04:48,360
Дури и кога сте донесување совети сте праќање по вредност.

54
00:04:48,360 --> 00:04:51,940
Тоа само така се случува, дека тие вредности се мемориски адреси.

55
00:04:51,940 --> 00:05:00,770
Значи, кога велам foo (P), јас сум полагање на покажувачот во функција foo

56
00:05:00,770 --> 00:05:03,910
а потоа foo е тоа * P = 6;

57
00:05:03,910 --> 00:05:08,600
Па внатрешноста на таа функција, * p е уште еквивалентно на x,

58
00:05:08,600 --> 00:05:12,720
но не можам да го користите X внатрешноста на таа функција, бидејќи тоа не е scoped во рамките на таа функција.

59
00:05:12,720 --> 00:05:19,510
Значи * P = 6 е единствениот начин можам да влезам во локална променлива од друга функција.

60
00:05:19,510 --> 00:05:23,600
Или, добро, показалки се единствениот начин можам да влезам во локална променлива од друга функција.

61
00:05:23,600 --> 00:05:31,600
[Студент] Да речеме дека сака да се врати на покажувачот. Како точно правиш тоа?

62
00:05:31,600 --> 00:05:44,270
[Бауден] Врати покажувач како и во нешто како int y = 3; враќање & Y? >> [Студент] Да.

63
00:05:44,270 --> 00:05:48,480
[Бауден] Во ред. Никогаш не треба да го направите тоа. Ова е лошо.

64
00:05:48,480 --> 00:05:59,480
Мислам дека го видов во овие предавање слајдови сте почнале да гледаат целата оваа дијаграм на меморија

65
00:05:59,480 --> 00:06:02,880
каде се тука имаш меморија адреса 0

66
00:06:02,880 --> 00:06:09,550
и овде имаш меморија адреса 4 свирки или 2 до 32.

67
00:06:09,550 --> 00:06:15,120
Па тогаш имаш некои работи и некои работи, а потоа имате вашиот магацинот

68
00:06:15,120 --> 00:06:21,780
и имаш вашиот грамада, која само што почнав учење за, растат.

69
00:06:21,780 --> 00:06:24,390
[Студент] не е грамада над магацинот?

70
00:06:24,390 --> 00:06:27,760
>> Да. Грамада е на врвот, не е тоа? >> [Студент] Па, тој ја стави 0 на врвот.

71
00:06:27,760 --> 00:06:30,320
[Студент] Ох, тој ја стави 0 на врвот. >> [Студент] О, во ред.

72
00:06:30,320 --> 00:06:36,060
Општи услови: Насекаде со CS50 си оди за да се види тоа на овој начин. >> [Студент] Во ред.

73
00:06:36,060 --> 00:06:40,290
Тоа е само дека кога сте првото гледање Купишта,

74
00:06:40,290 --> 00:06:45,000
како кога ќе помислите на магацинот мислите за редење работи на врвот на една со друга.

75
00:06:45,000 --> 00:06:50,810
Значи ние се стремат да флип оваа околу толку магацинот расте како оџак нормално би

76
00:06:50,810 --> 00:06:55,940
наместо на магацинот виси надолу. >> [Студент] Не купишта технички пораснат премногу, иако?

77
00:06:55,940 --> 00:07:01,100
Тоа зависи од она што го подразбираме под порасне.

78
00:07:01,100 --> 00:07:04,010
Магацинот и грамада секогаш расте во спротивни насоки.

79
00:07:04,010 --> 00:07:09,420
Комплет е секогаш растат во смисла дека тоа е растат

80
00:07:09,420 --> 00:07:12,940
кон повисоки мемориски адреси, и грамада расте надолу

81
00:07:12,940 --> 00:07:17,260
по тоа што постојано расте кон пониска мемориски адреси.

82
00:07:17,260 --> 00:07:20,250
Значи, на врвот е 0 и на дното е висок меморија адреси.

83
00:07:20,250 --> 00:07:26,390
Тие се двете расте, само во спротивни насоки.

84
00:07:26,390 --> 00:07:29,230
[Студент] Јас само значеше дека бидејќи ти рече да се стави магацинот на дното

85
00:07:29,230 --> 00:07:33,640
бидејќи се чини дека повеќе интуитивна, бидејќи за оџакот да се започне на врвот на грамада,

86
00:07:33,640 --> 00:07:37,520
грамада е на врвот на себе, па that's - >> Да.

87
00:07:37,520 --> 00:07:44,960
Можете исто така мислам на грамада како растат и поголеми, но на магацинот повеќе.

88
00:07:44,960 --> 00:07:50,280
Така магацинот е онаа која ние вид на посакате да ја прикажете растат.

89
00:07:50,280 --> 00:07:55,390
Но, насекаде барате друг начин ќе покаже адреса 0 на врвот

90
00:07:55,390 --> 00:07:59,590
и највисока меморија адреса на дното, така што ова е вашата вообичаена слика на меморијата.

91
00:07:59,590 --> 00:08:02,100
>> Дали имате некое прашање?

92
00:08:02,100 --> 00:08:04,270
[Студент] Може ли да ни кажете нешто повеќе за грамада?

93
00:08:04,270 --> 00:08:06,180
Да. Ќе дојдеме до тоа во една секунда.

94
00:08:06,180 --> 00:08:12,220
Прво, да се вратам зошто враќање и y е лоша работа,

95
00:08:12,220 --> 00:08:18,470
на магацинот имате еден куп на магацинот рамки кои претставуваат сите функции

96
00:08:18,470 --> 00:08:20,460
кој се нарекува.

97
00:08:20,460 --> 00:08:27,990
Па игнорирајќи претходните нешта, на врвот на вашиот оџакот е секогаш ќе биде главната функција

98
00:08:27,990 --> 00:08:33,090
бидејќи тоа е првата функција и тоа е се нарекува.

99
00:08:33,090 --> 00:08:37,130
И тогаш кога ќе се јавите друга функција, на магацинот ќе растат надолу.

100
00:08:37,130 --> 00:08:41,640
Значи, ако јас го нарекувам некои функција, foo, а тоа добива свој магацинот рамка,

101
00:08:41,640 --> 00:08:47,280
тоа може да се јавите некоја функција, бар, таа добива свој магацинот рамка.

102
00:08:47,280 --> 00:08:49,840
И бар може да биде рекурзивен а тоа би можело да се јавите,

103
00:08:49,840 --> 00:08:54,150
и така што вториот повик за бар ќе добие свој магацинот рамка.

104
00:08:54,150 --> 00:08:58,880
И така она што се случува во овие магацинот рамки се сите локални променливи

105
00:08:58,880 --> 00:09:03,450
и сите на функцијата аргументи дека -

106
00:09:03,450 --> 00:09:08,730
Секое работи кои се локално scoped на оваа функција одат во овие магацинот рамки.

107
00:09:08,730 --> 00:09:21,520
Па тоа значи дека кога реков нешто како бар е функција,

108
00:09:21,520 --> 00:09:29,270
Јас сум само ќе прогласи цел број, а потоа се врати на покажувачот во тој број.

109
00:09:29,270 --> 00:09:33,790
Значи каде y живеат?

110
00:09:33,790 --> 00:09:36,900
[Студент] y живее во бар. >> [Бауден] Да.

111
00:09:36,900 --> 00:09:45,010
Некаде во оваа мала квадратна на меморија е квадратен littler дека има y во неа.

112
00:09:45,010 --> 00:09:53,370
Кога ќе се вратам & Y, јас сум враќа покажувач кон овој мал блок од меморија.

113
00:09:53,370 --> 00:09:58,400
Но, тогаш кога функцијата се враќа, неговите магацинот рамка добива појави надвор од магацинот.

114
00:10:01,050 --> 00:10:03,530
И затоа се вика оџак.

115
00:10:03,530 --> 00:10:06,570
Тоа е како на магацинот податочна структура, ако знаеш што е тоа.

116
00:10:06,570 --> 00:10:11,580
Или дури и како магацинот на пепелниците е секогаш пример,

117
00:10:11,580 --> 00:10:16,060
Главната се случува да одам на дното, а потоа на првата функција ти се јавам се случува да одам на врвот на тоа,

118
00:10:16,060 --> 00:10:20,400
и не можете да се вратите назад на главната додека не се врати од сите функции кои се нарекуваат

119
00:10:20,400 --> 00:10:22,340
кои биле сместени на врвот на неа.

120
00:10:22,340 --> 00:10:28,650
>> [Студент] Па ако не го правел врати и y, таа вредност е предмет на промена без најава.

121
00:10:28,650 --> 00:10:31,290
Да, it's - >> [студент] Тоа може да бидат препишани. >> Да.

122
00:10:31,290 --> 00:10:34,660
Тоа е целосно - Ако се обидете и -

123
00:10:34,660 --> 00:10:38,040
Ова исто така ќе биде int * бар, бидејќи тоа е враќање на покажувачот,

124
00:10:38,040 --> 00:10:41,310
па нејзиното враќање тип е int *.

125
00:10:41,310 --> 00:10:46,500
Ако се обидете да го користите на повратната вредност на оваа функција, тоа е недефинирано однесување

126
00:10:46,500 --> 00:10:51,770
затоа што покажувач укажува на лоша меморија. >> [Студент] Во ред.

127
00:10:51,770 --> 00:11:01,250
Па што ако, на пример, ќе прогласи int * y = Примерок (sizeof (int))?

128
00:11:01,250 --> 00:11:03,740
Тоа е подобро. Да.

129
00:11:03,740 --> 00:11:07,730
[Студент] Ние разговаравме за тоа како кога ќе повлечете работи на нашите ѓубрето

130
00:11:07,730 --> 00:11:11,750
тие не се всушност избришани, ние само ги загубат своите совети.

131
00:11:11,750 --> 00:11:15,550
Значи во овој случај ние всушност ги избрише вредноста или тоа е сè уште таму во меморијата?

132
00:11:15,550 --> 00:11:19,130
За најголем дел, тоа се случува дека сè уште се таму.

133
00:11:19,130 --> 00:11:24,220
Но, ајде да речеме дека ние се случи да се јавам на некои други функции, Баз.

134
00:11:24,220 --> 00:11:28,990
Баз ќе добие свој магацинот рамка за тука.

135
00:11:28,990 --> 00:11:31,470
Тоа се случува да се пребрише сите на овој материјал,

136
00:11:31,470 --> 00:11:34,180
а потоа ако подоцна се обиде и да ги користите покажувачот што сте ја добиле пред,

137
00:11:34,180 --> 00:11:35,570
тоа нема да биде иста вредност.

138
00:11:35,570 --> 00:11:38,150
Тоа се случува да се промени само поради тоа што се нарекува функцијата baz.

139
00:11:38,150 --> 00:11:43,080
[Студент], но не и ние ќе можеме уште се 3?

140
00:11:43,080 --> 00:11:44,990
[Бауден] Во сите веројатноста, ќе.

141
00:11:44,990 --> 00:11:49,670
Но вие не може да се потпре на тоа. Ц само вели недефинирано однесување.

142
00:11:49,670 --> 00:11:51,920
>> [Студент] О, тоа го прави. Во ред.

143
00:11:51,920 --> 00:11:58,190
Па кога ќе сакаат да се вратат покажувач, ова е местото каде Примерок доаѓа во употреба.

144
00:12:00,930 --> 00:12:15,960
Го пишувам всушност само се врати Примерок (3 * sizeof (int)).

145
00:12:17,360 --> 00:12:24,050
Ние ќе одиме во текот Примерок повеќе во секунда, но идејата за Примерок е сите на вашите локални променливи

146
00:12:24,050 --> 00:12:26,760
секогаш одат на магацинот.

147
00:12:26,760 --> 00:12:31,570
Нешто што е malloced оди на куп, и тоа засекогаш и секогаш ќе биде на грамада

148
00:12:31,570 --> 00:12:34,490
додека не се експлицитно го ослободи.

149
00:12:34,490 --> 00:12:42,130
Значи ова значи дека кога ќе Примерок нешто, тоа се случува да преживее по функција се враќа.

150
00:12:42,130 --> 00:12:46,800
[Студент] Ќе преживее по завршување на програмата ќе престане да работи? >> Бр

151
00:12:46,800 --> 00:12:53,180
Океј, па тоа нема да биде таму до програмата е целиот пат направено трчање. >> Да.

152
00:12:53,180 --> 00:12:57,510
Можеме да одиме над детали за она што се случува кога на програмата ќе престане да работи.

153
00:12:57,510 --> 00:13:02,150
Можеби треба да ме потсетува, но тоа е посебна работа целосно.

154
00:13:02,150 --> 00:13:04,190
[Студент] Значи Примерок создава покажувачот? >> Да.

155
00:13:04,190 --> 00:13:13,030
Примерок - >> [студент] Мислам Примерок означува блок на меморијата која покажувач може да се користи.

156
00:13:15,400 --> 00:13:19,610
[Бауден] Сакам дијаграм повторно. >> [Студент] Значи оваа функција работи, иако?

157
00:13:19,610 --> 00:13:26,430
[Студент] Да, Примерок означува блок од меморија, која може да се користи,

158
00:13:26,430 --> 00:13:30,470
а потоа се враќа на адреса на првиот блок на таа меморија.

159
00:13:30,470 --> 00:13:36,750
>> [Бауден] Да. Па кога ќе Примерок, ти си грабање некои блок од меморија

160
00:13:36,750 --> 00:13:38,260
кој во моментов е во грамада.

161
00:13:38,260 --> 00:13:43,040
Ако грамада е премногу мал, тогаш грамада е само ќе расте и расте во оваа насока.

162
00:13:43,040 --> 00:13:44,650
Па да речеме грамада е премногу мал.

163
00:13:44,650 --> 00:13:49,960
Тогаш тоа е за да расте малку и да се врати покажувач на овој блок кој едноставно се зголеми.

164
00:13:49,960 --> 00:13:55,130
Кога ќе бесплатни работи, ти си прави повеќе простор во грамада,

165
00:13:55,130 --> 00:14:00,030
па потоа подоцна се јавите за да Примерок да повторна употреба дека меморијата што претходно ослободени.

166
00:14:00,030 --> 00:14:09,950
Најважно за Примерок и слободен е во тоа што ви дава комплетна контрола

167
00:14:09,950 --> 00:14:12,700
во текот на животот на овие мемориски блокови.

168
00:14:12,700 --> 00:14:15,420
Глобални променливи се секогаш жив.

169
00:14:15,420 --> 00:14:18,500
Локалните променливи се живи во нивниот делокруг.

170
00:14:18,500 --> 00:14:22,140
Веднаш штом ќе одат минатото голема заграда кадрава, на локални променливи се мртви.

171
00:14:22,140 --> 00:14:28,890
Malloced меморија е жив, кога сакате да се биде жив

172
00:14:28,890 --> 00:14:33,480
а потоа е ослободен кога ќе го кажам да бидат објавени.

173
00:14:33,480 --> 00:14:38,420
Тоа се всушност само 3 типа на меморија, навистина.

174
00:14:38,420 --> 00:14:41,840
Има автоматско управување со меморијата, која е на магацинот.

175
00:14:41,840 --> 00:14:43,840
Работите да се случат за вас автоматски.

176
00:14:43,840 --> 00:14:46,910
Кога ќе се каже int x, меморија се доделува за int x.

177
00:14:46,910 --> 00:14:51,630
Кога x оди надвор од опсегот, меморија е рекултивираните за x.

178
00:14:51,630 --> 00:14:54,790
Потоа, тука е динамичка меморија за управување, што е она што Примерок е,

179
00:14:54,790 --> 00:14:56,740
што е кога имате контрола.

180
00:14:56,740 --> 00:15:01,290
Можете динамички одлучи кога меморија треба и не треба да се распределени.

181
00:15:01,290 --> 00:15:05,050
А потоа, тука е статична, што само значи дека живее засекогаш,

182
00:15:05,050 --> 00:15:06,610
што е она што глобални променливи се.

183
00:15:06,610 --> 00:15:10,240
Тие се само секогаш во меморијата.

184
00:15:10,960 --> 00:15:12,760
>> Прашања?

185
00:15:14,490 --> 00:15:17,230
[Студент] можете да дефинирате блок само со помош на големи загради

186
00:15:17,230 --> 00:15:21,220
но не мора да имаат, ако изјавата или додека изјава или нешто слично?

187
00:15:21,220 --> 00:15:29,130
Можете да дефинирате блок, како и во функција, но кој има кадрави загради премногу.

188
00:15:29,130 --> 00:15:32,100
[Студент] Значи не само да имаат како случаен пар на тркалезните загради во вашиот код

189
00:15:32,100 --> 00:15:35,680
кои имаат локални променливи? >> Да, можеш.

190
00:15:35,680 --> 00:15:45,900
Внатрешноста на int бар може да имаме {int y = 3;}.

191
00:15:45,900 --> 00:15:48,440
Тоа би требало да биде во право тука.

192
00:15:48,440 --> 00:15:52,450
Но, тоа целосно го дефинира обемот на int y.

193
00:15:52,450 --> 00:15:57,320
По тој втор кадрава голема заграда, y не може да се користи веќе.

194
00:15:57,910 --> 00:16:00,630
Можете речиси никогаш не го направи тоа, иако.

195
00:16:02,940 --> 00:16:07,370
Прв назад кон она што се случува кога некоја програма завршува,

196
00:16:07,370 --> 00:16:18,760
таму е вид на заблуда / половина лага дека ние даде со цел само да ги олесни работите.

197
00:16:18,760 --> 00:16:24,410
Ние ти кажам дека кога ќе алоцира меморија

198
00:16:24,410 --> 00:16:29,860
сте распределба некои парче на RAM меморија за таа променлива.

199
00:16:29,860 --> 00:16:34,190
Но вие не сте навистина директно допирање на RAM меморија некогаш во вашите програми.

200
00:16:34,190 --> 00:16:37,490
Ако мислите дека за тоа, како што го изведов -

201
00:16:37,490 --> 00:16:44,330
И всушност, ако одите преку во GDB ќе видите истото.

202
00:16:51,120 --> 00:16:57,590
Без оглед на тоа колку пати ќе се кандидира на вашиот програма или она што програмата си работи,

203
00:16:57,590 --> 00:16:59,950
магацинот е секогаш ќе започне -

204
00:16:59,950 --> 00:17:06,510
ти си секогаш ќе видите променливи околу адреса oxbffff нешто.

205
00:17:06,510 --> 00:17:09,470
Тоа е обично некаде во тој регион.

206
00:17:09,470 --> 00:17:18,760
Но, како може 2 програми можеби имаат совети за истата меморија?

207
00:17:20,640 --> 00:17:27,650
[Студент] Има некои произволни ознаки од каде oxbfff би требало да биде на RAM меморија

208
00:17:27,650 --> 00:17:31,320
кои, всушност, може да биде во различни места во зависност од кога функцијата се нарекува.

209
00:17:31,320 --> 00:17:35,920
Да. Терминот е виртуелна меморија.

210
00:17:35,920 --> 00:17:42,250
Идејата е дека секој процес, секој програма која се извршува на Вашиот компјутер

211
00:17:42,250 --> 00:17:49,450
има свои - да претпоставиме 32 битови - целосно независна просторот за адреси.

212
00:17:49,450 --> 00:17:51,590
Ова е адресата простор.

213
00:17:51,590 --> 00:17:56,220
Таа има своја сосема независни 4 гигабајти за употреба.

214
00:17:56,220 --> 00:18:02,220
>> Значи, ако се кандидира 2 програми истовремено, оваа програма ја гледа 4 гигабајти за себе,

215
00:18:02,220 --> 00:18:04,870
оваа програма го гледа 4 гигабајти за себе,

216
00:18:04,870 --> 00:18:07,720
и тоа е невозможно за оваа програма да Dereference покажувач

217
00:18:07,720 --> 00:18:10,920
и завршуваат со меморија од оваа програма.

218
00:18:10,920 --> 00:18:18,200
И она што виртуелната меморија е е мапирање од процесите на просторот за адреси

219
00:18:18,200 --> 00:18:20,470
на вистинските нешта на RAM меморија.

220
00:18:20,470 --> 00:18:22,940
Па тоа е до вашиот оперативен систем да се знае дека,

221
00:18:22,940 --> 00:18:28,080
еј, кога овој човек dereferences покажувачот oxbfff, тоа навистина значи

222
00:18:28,080 --> 00:18:31,040
дека сака RAM меморија бајт 1000,

223
00:18:31,040 --> 00:18:38,150
а ако оваа програма dereferences oxbfff, тој навистина сака RAM меморија бајт 10000.

224
00:18:38,150 --> 00:18:41,590
Тие можат да бидат произволно далеку.

225
00:18:41,590 --> 00:18:48,730
Ова важи дури и работи во рамките на еден процес на просторот за адреси.

226
00:18:48,730 --> 00:18:54,770
Па како го гледа сите 4 гигабајти за себе, но да речеме -

227
00:18:54,770 --> 00:18:57,290
[Студент] Дали секој процес -

228
00:18:57,290 --> 00:19:01,350
Да речеме имате компјутер со само 4 гигабајти на RAM меморија.

229
00:19:01,350 --> 00:19:06,430
Дали секој процес видите целата 4 гигабајти? >> Да.

230
00:19:06,430 --> 00:19:13,060
Но, 4 гигабајти го гледа е лага.

231
00:19:13,060 --> 00:19:20,460
Тоа е само тоа мисли дека има сето ова меморија, бидејќи таа не знае кој било друг процес постои.

232
00:19:20,460 --> 00:19:28,140
Тоа само ќе го користи како многу меморија, како тоа всушност треба.

233
00:19:28,140 --> 00:19:32,340
Оперативниот систем не се случува да им даде на RAM меморија на овој процес

234
00:19:32,340 --> 00:19:35,750
ако тоа не е користење на било меморија во оваа целиот регион.

235
00:19:35,750 --> 00:19:39,300
Тоа нема да го даде меморија за тој регион.

236
00:19:39,300 --> 00:19:54,780
Но, идејата е дека - Јас се обидувам да мислам на - Јас не можат да мислат на аналогија.

237
00:19:54,780 --> 00:19:56,780
Аналогии се тешки.

238
00:19:57,740 --> 00:20:02,700
Едно од прашањата на виртуелна меморија или една од работите тоа е решавање на

239
00:20:02,700 --> 00:20:06,810
е дека процесите треба да биде свесен за една со друга.

240
00:20:06,810 --> 00:20:12,140
И така можете да напишете било програма со која само dereferences било покажувач,

241
00:20:12,140 --> 00:20:19,340
како само напише програма која се вели * (ox1234)

242
00:20:19,340 --> 00:20:22,890
и тоа е dereferencing меморија адреса 1234.

243
00:20:22,890 --> 00:20:28,870
>> Но тоа е до оперативниот систем за да потоа се преведе она што 1234 средство.

244
00:20:28,870 --> 00:20:33,960
Значи, ако 1234 случува да биде валидна меморија адреса за овој процес,

245
00:20:33,960 --> 00:20:38,800
како што е на магацинот или нешто, тогаш тоа ќе се врати вредноста на таа меморија адреса

246
00:20:38,800 --> 00:20:41,960
што се однесува до процесот знае.

247
00:20:41,960 --> 00:20:47,520
Но, ако 1234 не е валидна адреса, како што тоа се случува да слета

248
00:20:47,520 --> 00:20:52,910
во некои малку парче од меморијата тука дека е надвор од оџакот и надвор од грамада

249
00:20:52,910 --> 00:20:57,200
и не сте навистина се користи тоа, тогаш тоа е кога ќе се работи како segfaults

250
00:20:57,200 --> 00:21:00,260
затоа што ти си допирање меморија дека не треба да се допира.

251
00:21:07,180 --> 00:21:09,340
Ова е исто така точно -

252
00:21:09,340 --> 00:21:15,440
А 32-битен систем, 32 бита значи дека имате 32 бита за да се дефинира мемориска адреса.

253
00:21:15,440 --> 00:21:22,970
Тоа е зошто покажувачи се 8 бајти, бидејќи 32 бита се 8 бајти - 4 бајти.

254
00:21:22,970 --> 00:21:25,250
Покажувачи се 4 бајти.

255
00:21:25,250 --> 00:21:33,680
Па кога ќе видите покажувач како oxbfffff, тоа е -

256
00:21:33,680 --> 00:21:40,080
Во рамките на секоја програма што само може да се изгради какво било произволно покажувач,

257
00:21:40,080 --> 00:21:46,330
насекаде од ox0 да вол 8 f's - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[Студент] не ви велат дека тие се 4 бајти? >> Да.

259
00:21:49,180 --> 00:21:52,730
[Студент] Тогаш секој бајт ќе има - >> [Бауден] Хексадецимално.

260
00:21:52,730 --> 00:21:59,360
Хексадецимален - 5, 6, 7, 8. Значи совети ви се случува да секогаш се види во хексадецимално.

261
00:21:59,360 --> 00:22:01,710
Тоа е само како се класифицираат совети.

262
00:22:01,710 --> 00:22:05,240
Секои 2 цифри од хексадецимални е 1 бајт.

263
00:22:05,240 --> 00:22:09,600
Па таму ќе биде 8 хексадецимални цифри за 4 бајти.

264
00:22:09,600 --> 00:22:14,190
Значи секој покажувач на 32-битен систем ќе биде 4 бајти,

265
00:22:14,190 --> 00:22:18,550
што значи дека во вашиот процес, можете да конструирате какво било произволно 4 бајти

266
00:22:18,550 --> 00:22:20,550
и да се направи покажувачот надвор од неа,

267
00:22:20,550 --> 00:22:32,730
што значи дека колку што е познато, таа може да разреши една цела 2 до 32 бајти меморија.

268
00:22:32,730 --> 00:22:34,760
Иако тоа не навистина имаат пристап до тоа,

269
00:22:34,760 --> 00:22:40,190
дури и ако вашиот компјутер има само 512 мегабајти, тоа мисли дека тоа е дека многу меморија.

270
00:22:40,190 --> 00:22:44,930
И на оперативниот систем е доволно паметни за тоа што само ќе одвои она што всушност треба.

271
00:22:44,930 --> 00:22:49,630
Тоа не само одат, ох, нов процес: 4 свирки.

272
00:22:49,630 --> 00:22:51,930
>> Да. >> [Студент] Што значи вол значи? Зошто ви го пишувам?

273
00:22:51,930 --> 00:22:54,980
Тоа е само симбол за хексадецимален.

274
00:22:54,980 --> 00:22:59,590
Кога ќе видите голем број на проектот со вол, последователни работи се хексадецимален.

275
00:23:01,930 --> 00:23:05,760
[Студент] Вие беа објаснување за она што се случува кога некоја програма завршува. >> Да.

276
00:23:05,760 --> 00:23:09,480
Што се случува кога некоја програма завршува е оперативен систем

277
00:23:09,480 --> 00:23:13,600
само брише мапирање тоа што има за овие адреси, и тоа е тоа.

278
00:23:13,600 --> 00:23:17,770
Оперативниот систем може сега само му даде на меморија на друга програма да го користите.

279
00:23:17,770 --> 00:23:19,490
[Студент] Во ред.

280
00:23:19,490 --> 00:23:24,800
Па кога ќе одвои нешто на грамада или магацинот или глобални променливи или ништо,

281
00:23:24,800 --> 00:23:27,010
сите тие само исчезне штом програмата завршува

282
00:23:27,010 --> 00:23:32,120
затоа што оперативниот систем е сега слободен да му даде на меморија за кој било друг процес.

283
00:23:32,120 --> 00:23:35,150
[Студент] Иако постојат веројатно уште вредностите напишани во? >> Да.

284
00:23:35,150 --> 00:23:37,740
Вредностите се веројатно уште таму.

285
00:23:37,740 --> 00:23:41,570
Тоа е само дека ќе биде тешко да се добие во нив.

286
00:23:41,570 --> 00:23:45,230
Тоа е многу потешко да се добие во нив отколку што е да се добие на избришани датотеки

287
00:23:45,230 --> 00:23:51,450
бидејќи избришани датотеки вид на седи таму за долго време и на хард дискот е многу поголем.

288
00:23:51,450 --> 00:23:54,120
Па затоа се случува да запишувате врз различни делови на меморија

289
00:23:54,120 --> 00:23:58,640
пред тоа се случува да се замени дел од меморија што таа датотека се користи да биде.

290
00:23:58,640 --> 00:24:04,520
Но, главната меморија, RAM меморија, кружите низ многу побрзо,

291
00:24:04,520 --> 00:24:08,040
па затоа се случува да многу брзо да бидат препишани.

292
00:24:10,300 --> 00:24:13,340
Прашања во врска со овој или нешто друго?

293
00:24:13,340 --> 00:24:16,130
[Студент] Имам прашања во врска со различна тема. >> Океј.

294
00:24:16,130 --> 00:24:19,060
Дали некој има прашања за тоа?

295
00:24:20,170 --> 00:24:23,120
>> Во ред. Различна тема. >> [Студент] Во ред.

296
00:24:23,120 --> 00:24:26,550
Ќе одам преку некои од пракса тестови,

297
00:24:26,550 --> 00:24:30,480
а во една од нив беше зборуваме за sizeof

298
00:24:30,480 --> 00:24:35,630
и вредноста која ја враќа или различни променлива видови. >> Да.

299
00:24:35,630 --> 00:24:45,060
И таа рече дека двете int и долго и враќање 4, па и тие се двете 4 бајти долго.

300
00:24:45,060 --> 00:24:48,070
Има ли разлика меѓу int и долго, или тоа е иста работа?

301
00:24:48,070 --> 00:24:50,380
Да, постои разлика.

302
00:24:50,380 --> 00:24:52,960
С стандард -

303
00:24:52,960 --> 00:24:54,950
Јас сум веројатно нема да се плеткаш.

304
00:24:54,950 --> 00:24:58,800
С стандард е исто како она што C е, официјалната документација на В

305
00:24:58,800 --> 00:25:00,340
Ова е она што го кажува.

306
00:25:00,340 --> 00:25:08,650
Значи C стандард само вели дека знак засекогаш и секогаш ќе биде 1 бајт.

307
00:25:10,470 --> 00:25:19,040
Сè што после тоа - краток е секогаш само се дефинирани како е поголема или еднаква на знак.

308
00:25:19,040 --> 00:25:23,010
Ова може да биде строго поголем од, но не и позитивни.

309
00:25:23,010 --> 00:25:31,940
Еден int е само дефинирани како е поголема или еднаква на кратко.

310
00:25:31,940 --> 00:25:36,210
И долго е само дефинирани како е поголема или еднаква на инт.

311
00:25:36,210 --> 00:25:41,600
И долго долго е поголема или еднаква на долг.

312
00:25:41,600 --> 00:25:46,610
Значи единственото нешто на C стандардот дефинира е релативна нарачување на сè.

313
00:25:46,610 --> 00:25:54,880
На реалниот износ на меморија што работи потрае генерално е до имплементација,

314
00:25:54,880 --> 00:25:57,640
но тоа е прилично добро дефинирани во овој момент. >> [Студент] Во ред.

315
00:25:57,640 --> 00:26:02,490
Значи шорцеви се речиси секогаш ќе биде 2 бајти.

316
00:26:04,920 --> 00:26:09,950
Ints се речиси секогаш ќе биде 4 бајти.

317
00:26:12,070 --> 00:26:15,340
Долго копнее се речиси секогаш ќе биде 8 бајти.

318
00:26:17,990 --> 00:26:23,160
И копнее, тоа зависи од тоа дали сте со користење на 32-битна или 64-битен систем.

319
00:26:23,160 --> 00:26:27,450
Па долго ќе одговараат на типот на системот.

320
00:26:27,450 --> 00:26:31,920
Ако користите 32-битен систем како апарати, тоа ќе биде 4 бајти.

321
00:26:34,530 --> 00:26:42,570
Ако сте со користење на 64-битна како многу последниве компјутери, тоа ќе биде 8 бајти.

322
00:26:42,570 --> 00:26:45,230
>> Ints се скоро секогаш 4 бајти во овој момент.

323
00:26:45,230 --> 00:26:47,140
Долго копнее се скоро секогаш 8 бајти.

324
00:26:47,140 --> 00:26:50,300
Во минатото, ints користи за да биде само 2 бајти.

325
00:26:50,300 --> 00:26:56,840
Но забележите дека ова целосно ги задоволува сите овие односи на поголема од и еднаков.

326
00:26:56,840 --> 00:27:01,280
Толку долго се совршено дозволено да бидат со иста големина како цел број,

327
00:27:01,280 --> 00:27:04,030
и тоа е, исто така, е дозволено да бидат со иста големина како долго долго.

328
00:27:04,030 --> 00:27:11,070
И тоа само така се случува да биде дека во 99,999% од системи, тоа ќе биде еднаква на

329
00:27:11,070 --> 00:27:15,800
ниту една int или долго долго. Тоа само зависи од 32-bit или 64-битна. >> [Студент] Во ред.

330
00:27:15,800 --> 00:27:24,600
Во плови, како е на децимална точка назначени во однос на битови?

331
00:27:24,600 --> 00:27:27,160
Како што се бинарни? >> Да.

332
00:27:27,160 --> 00:27:30,570
Вие не треба да се знае дека за CS50.

333
00:27:30,570 --> 00:27:32,960
Вие дури и не научат дека во 61.

334
00:27:32,960 --> 00:27:37,350
Вие не научат дека навистина во секој курс.

335
00:27:37,350 --> 00:27:42,740
Тоа е само претстава.

336
00:27:42,740 --> 00:27:45,440
Заборавам точната малку allotments.

337
00:27:45,440 --> 00:27:53,380
Идејата на подвижна точка е дека доделат одреден број на битови да претставуваат -

338
00:27:53,380 --> 00:27:56,550
Во суштина, сè е во научна нотација.

339
00:27:56,550 --> 00:28:05,600
Така да доделат одреден број на битови да претставува број себе, како 1,2345.

340
00:28:05,600 --> 00:28:10,200
Јас никогаш не може да претставува број со повеќе цифри од 5.

341
00:28:12,200 --> 00:28:26,300
Тогаш исто така додели одреден број на битови, така што тоа се стреми да биде како

342
00:28:26,300 --> 00:28:32,810
можете само да одите до одреден број, како што е најголемиот показател ќе може да има,

343
00:28:32,810 --> 00:28:36,190
а вие само може да оди надолу до одреден степен,

344
00:28:36,190 --> 00:28:38,770
како што е најмалиот експонент можете да го имаат.

345
00:28:38,770 --> 00:28:44,410
>> Јас не се сеќавам на точниот начин битови се доделуваат на сите овие вредности,

346
00:28:44,410 --> 00:28:47,940
но одреден број на битови се посветени на 1,2345,

347
00:28:47,940 --> 00:28:50,930
друг одреден број на битови се посветени на експонент,

348
00:28:50,930 --> 00:28:55,670
и тоа е можно само да се претставува експонент на одредена големина.

349
00:28:55,670 --> 00:29:01,100
[Студент] и двојно? Е дека како екстра долго плови? >> Да.

350
00:29:01,100 --> 00:29:07,940
Тоа е истото како рационален освен сега сте со користење 8 бајти, наместо на 4 бајти.

351
00:29:07,940 --> 00:29:11,960
Сега ќе можете да го користите 9 цифри, или 10 цифри,

352
00:29:11,960 --> 00:29:16,630
и тоа ќе биде во можност да одат до 300 наместо 100. >> [Студент] Во ред.

353
00:29:16,630 --> 00:29:21,550
И плови уште 4 бајти. >> Да.

354
00:29:21,550 --> 00:29:27,520
Па, повторно, тоа веројатно зависи целокупната на општата имплементација,

355
00:29:27,520 --> 00:29:30,610
но плови се 4 бајти, двојки се 8.

356
00:29:30,610 --> 00:29:33,440
Двојки се нарекуваат двојно бидејќи тие се двојно големината на плови.

357
00:29:33,440 --> 00:29:38,380
[Студент] Во ред. И се има двојно двојки? >> Не постојат.

358
00:29:38,380 --> 00:29:43,660
Мислам - >> [студент] Како долго копнее? >> Да. Јас не мислам така. Да.

359
00:29:43,660 --> 00:29:45,950
[Студент] На тест минатата година имаше прашање за главната функција

360
00:29:45,950 --> 00:29:49,490
мора да биде дел од вашата програма.

361
00:29:49,490 --> 00:29:52,310
Одговорот беше дека тоа не мора да биде дел од вашата програма.

362
00:29:52,310 --> 00:29:55,100
Во она ситуација? Тоа е она што го видов.

363
00:29:55,100 --> 00:29:59,090
[Бауден] Се чини - >> [студент] Што ситуација?

364
00:29:59,090 --> 00:30:02,880
Имате проблем? >> [Студент] Да, јас дефинитивно може да го повлече.

365
00:30:02,880 --> 00:30:07,910
Тоа не мора да биде технички, но во основа тоа се случува да биде.

366
00:30:07,910 --> 00:30:10,030
[Студент] видов една на друга година.

367
00:30:10,030 --> 00:30:16,220
Тоа беше како Вистински или лажни: Валидна - >> О, в датотека.?

368
00:30:16,220 --> 00:30:18,790
. [Студент] Секое в датотеката мора да имаат - [двете зборува одеднаш - неразбирливо]

369
00:30:18,790 --> 00:30:21,120
Во ред. Значи тоа е посебен.

370
00:30:21,120 --> 00:30:26,800
>> А. В датотека само треба да содржи функции.

371
00:30:26,800 --> 00:30:32,400
Можете да состави датотека во машина код, бинарен, што,

372
00:30:32,400 --> 00:30:36,620
без да биде извршна уште.

373
00:30:36,620 --> 00:30:39,420
Валидна извршна мора да имаат главната функција.

374
00:30:39,420 --> 00:30:45,460
Можете да напишете 100 функции во 1 датотеки, но не главен

375
00:30:45,460 --> 00:30:48,800
а потоа ги собира дека до бинарни,

376
00:30:48,800 --> 00:30:54,460
потоа напишете друга датотека која има само главните, но тоа бара еден куп на овие функции

377
00:30:54,460 --> 00:30:56,720
во оваа бинарна датотека овде.

378
00:30:56,720 --> 00:31:01,240
И така, кога сте правење на извршна, тоа е она што на linker не

379
00:31:01,240 --> 00:31:05,960
е тоа е комбинација од овие 2 бинарни датотеки во извршна.

380
00:31:05,960 --> 00:31:11,400
Значи. В датотеката не треба да имаат главната функција на сите.

381
00:31:11,400 --> 00:31:19,220
И на големи кодот основи ќе видите илјадници. В датотеки и 1 главната датотека.

382
00:31:23,960 --> 00:31:26,110
Повеќе прашања?

383
00:31:29,310 --> 00:31:31,940
[Студент] Имаше едно друго прашање.

384
00:31:31,940 --> 00:31:36,710
Таа рече направи е компајлерот. Вистински или лажни?

385
00:31:36,710 --> 00:31:42,030
А одговорот беше лажна, а јас разбрав зошто тоа не е како ѕвекот.

386
00:31:42,030 --> 00:31:44,770
Но, она што ние го нарекуваме направи ако тоа не е?

387
00:31:44,770 --> 00:31:49,990
Направи е во основа, само - можам да се види точно она што го нарекува.

388
00:31:49,990 --> 00:31:52,410
Но, тоа само работи команди.

389
00:31:53,650 --> 00:31:55,650
Направи.

390
00:31:58,240 --> 00:32:00,870
Јас може да се повлече ова. Да.

391
00:32:10,110 --> 00:32:13,180
О, да. Направи, исто така, го прави тоа.

392
00:32:13,180 --> 00:32:17,170
Овој вели дека целта на изработка алатка е да се утврди автоматски

393
00:32:17,170 --> 00:32:19,610
кои парчиња голема програма треба да биде recompiled

394
00:32:19,610 --> 00:32:22,350
и издаде команди за да ги прекомпајлирате.

395
00:32:22,350 --> 00:32:27,690
Можете да направите се направи датотеки, кои се апсолутно огромна.

396
00:32:27,690 --> 00:32:33,210
Направете изгледа во времето марки на датотеки и, како што рековме порано,

397
00:32:33,210 --> 00:32:36,930
можете да ги собира поединечни фајлови надолу, и тоа не е се додека не се дојде до linker

398
00:32:36,930 --> 00:32:39,270
дека тие се стави заедно во една извршна.

399
00:32:39,270 --> 00:32:43,810
Значи, ако имате 10 различни фајлови и ќе се направи промена до 1 од нив,

400
00:32:43,810 --> 00:32:47,870
тогаш што марка се случува да направите е само прекомпајлирате дека 1 датотека

401
00:32:47,870 --> 00:32:50,640
а потоа relink сето заедно.

402
00:32:50,640 --> 00:32:53,020
Но тоа е многу dumber од тоа.

403
00:32:53,020 --> 00:32:55,690
Тоа е до вас за да целосно се дефинира дека тоа е она што треба да се прави.

404
00:32:55,690 --> 00:32:59,560
Тоа по правило ја има способноста да го признае ова време печат работи,

405
00:32:59,560 --> 00:33:03,220
но може да се напише направи датотека да се направи нешто.

406
00:33:03,220 --> 00:33:09,150
Можете да напишете направи датотека, така што кога ќе напишете го прават тоа само ЦД-а во друг директориум.

407
00:33:09,150 --> 00:33:15,560
Бев добивање фрустрирани бидејќи јас тактика што во внатрешноста на мојата апарати

408
00:33:15,560 --> 00:33:21,740
а потоа ги видите PDF од Мак.

409
00:33:21,740 --> 00:33:30,720
>> Па одам да Пронаоѓач и јас не може да оди, се поврзам со серверот,

410
00:33:30,720 --> 00:33:36,950
и серверот јас се поврзете со е мојот апарати, а потоа се отвори PDF

411
00:33:36,950 --> 00:33:40,190
кој добива составена од латекс.

412
00:33:40,190 --> 00:33:49,320
Но, јас бев добивање фрустрирани бидејќи секој пат кога ми требаше да се освежи PDF,

413
00:33:49,320 --> 00:33:53,900
Морав да го копирате дадена Директориум дека тоа би можело да пристапите

414
00:33:53,900 --> 00:33:57,710
и тоа беше добивање досадно.

415
00:33:57,710 --> 00:34:02,650
Така, наместо напишав направи датотека, која треба да се дефинира како тоа го прави нештата.

416
00:34:02,650 --> 00:34:06,130
Како да се направи во оваа е PDF LaTeX.

417
00:34:06,130 --> 00:34:10,090
Само како и секој друг направи датотека или - Претпоставувам дека не сте го виделе марка датотеки,

418
00:34:10,090 --> 00:34:13,510
но ние имаме во апаратот глобална марка датотеката која само вели,

419
00:34:13,510 --> 00:34:16,679
Ако сте составувањето на датотека C, користете ѕвекот.

420
00:34:16,679 --> 00:34:20,960
И така тука што можам да направам што велам во мојата направи датотека,

421
00:34:20,960 --> 00:34:25,020
оваа датотека ви се случува да сакаат да ги собере со PDF LaTeX.

422
00:34:25,020 --> 00:34:27,889
И така тоа е PDF LaTeX што го прави на составувањето.

423
00:34:27,889 --> 00:34:31,880
Направете не е составувањето. Тоа е само водење на овие команди во низа јас назначено.

424
00:34:31,880 --> 00:34:36,110
Значи бега PDF LaTeX, го копира во директориумот што сакате тоа да бидат копирани,

425
00:34:36,110 --> 00:34:38,270
тоа ЦД во директориумот и врши други работи,

426
00:34:38,270 --> 00:34:42,380
но сите тоа го прави е признае кога датотека промени,

427
00:34:42,380 --> 00:34:45,489
и ако тоа се менува, тогаш тоа ќе се кандидира на команди кои што би требало да се кандидира

428
00:34:45,489 --> 00:34:48,760
кога датотека промени. >> [Студент] Во ред.

429
00:34:50,510 --> 00:34:54,420
Не знам каде глобалната направи додадени фајлови се за мене да го провериш.

430
00:34:57,210 --> 00:35:04,290
Други прашања? Нешто од минатото квизови? Било покажувач работи?

431
00:35:06,200 --> 00:35:08,730
Постојат суптилни работи со покажувачи како -

432
00:35:08,730 --> 00:35:10,220
Јас не одам за да бидат во можност да се најде квиз прашање на неа -

433
00:35:10,220 --> 00:35:16,250
Но, исто како овој вид на работа.

434
00:35:19,680 --> 00:35:24,060
Бидете сигурни дека ќе се разбере дека кога велам int * x * y -

435
00:35:24,890 --> 00:35:28,130
Ова не е точно ништо тука, претпоставувам.

436
00:35:28,130 --> 00:35:32,140
Но, како и * x * y, тоа се 2 променливи кои се на магацинот.

437
00:35:32,140 --> 00:35:37,220
Кога велам x = Примерок (sizeof (int)), x е уште една променлива на магацинот,

438
00:35:37,220 --> 00:35:41,180
Примерок некои блок над во грамада, и ние сме со х точка за грамада.

439
00:35:41,180 --> 00:35:43,900
>> Значи нешто на магацинот укажува на грамада.

440
00:35:43,900 --> 00:35:48,100
Секогаш кога ќе Примерок ништо, ти си неизбежно чување на тоа во внатрешноста на покажувачот.

441
00:35:48,100 --> 00:35:55,940
Така што покажувачот е на магацинот, на malloced блок е на грамада.

442
00:35:55,940 --> 00:36:01,240
Многу луѓе се збунети и велат int * x = Примерок; x е на грамада.

443
00:36:01,240 --> 00:36:04,100
Па што x укажува е на грамада.

444
00:36:04,100 --> 00:36:08,540
x себе е на магацинот, освен ако за која било причина сте x биде глобална променлива,

445
00:36:08,540 --> 00:36:11,960
во кој случај тоа се случува да биде во друг регион на меморија.

446
00:36:13,450 --> 00:36:20,820
Значи следење, овие кутија и стрела дијаграми се прилично заеднички за квиз.

447
00:36:20,820 --> 00:36:25,740
Или ако тоа не е на квизот 0, тоа ќе биде на квизот 1.

448
00:36:27,570 --> 00:36:31,940
Треба да знаете сите овие, чекорите во составувањето на

449
00:36:31,940 --> 00:36:35,740
бидејќи ќе мораше да одговори на прашања за нив. Да.

450
00:36:35,740 --> 00:36:38,940
[Студент] можеме да одиме над оние чекори - >> Секако.

451
00:36:48,340 --> 00:36:58,640
Пред чекори и составувањето имаме препроцесирачка,

452
00:36:58,640 --> 00:37:16,750
составувањето, монтажа и поврзување.

453
00:37:16,750 --> 00:37:21,480
Препроцесирачка. Што значи дека направам?

454
00:37:29,720 --> 00:37:32,290
Тоа е најлесниот чекор во - добро, а не како -

455
00:37:32,290 --> 00:37:35,770
тоа не значи дека треба да биде очигледна, но тоа е најлесниот чекор.

456
00:37:35,770 --> 00:37:38,410
Вие момци може да се имплементира себе. Да.

457
00:37:38,410 --> 00:37:43,410
[Студент] Земете она што го имате во вашиот вклучува вака и копии, а потоа, исто така, се дефинира.

458
00:37:43,410 --> 00:37:49,250
Изгледа за нешта како # вклучуваат и # define,

459
00:37:49,250 --> 00:37:53,800
и тоа само копии и пасти за она што тие всушност значат.

460
00:37:53,800 --> 00:37:59,240
Значи, кога ќе се каже # вклучуваат cs50.h, на препроцесори е копирање и вметнување cs50.h

461
00:37:59,240 --> 00:38:01,030
во таа линија.

462
00:38:01,030 --> 00:38:06,640
Кога ќе се каже # define на X да биде 4, препроцесори оди преку целата програма

463
00:38:06,640 --> 00:38:10,400
и ги заменува сите случаи на x со 4.

464
00:38:10,400 --> 00:38:17,530
Па препроцесори зема валидна C датотеката и излези валидна Ц датотека

465
00:38:17,530 --> 00:38:20,300
каде работите се копирани и атипичен.

466
00:38:20,300 --> 00:38:24,230
Па сега составувањето. Што значи дека направам?

467
00:38:25,940 --> 00:38:28,210
[Студент] Тоа оди од C до бинарни.

468
00:38:28,210 --> 00:38:30,970
>> [Бауден] Тоа не одат сите на начин да се бинарни.

469
00:38:30,970 --> 00:38:34,220
[Студент] Да машина код тогаш? >> Тоа не е машински код.

470
00:38:34,220 --> 00:38:35,700
[Студент] собрание? >> Собранието.

471
00:38:35,700 --> 00:38:38,890
Тоа оди до Собранието пред да оди на целиот пат до C код,

472
00:38:38,890 --> 00:38:45,010
и повеќето јазици се направи нешто како ова.

473
00:38:47,740 --> 00:38:50,590
Изберете било на високо ниво јазик, и ако ви се случува да го компајлирате,

474
00:38:50,590 --> 00:38:52,390
тоа е веројатно да ги собере во чекори.

475
00:38:52,390 --> 00:38:58,140
Прво тоа се случува да ги собере Пајтон на C, тогаш тоа се случува да ги собере C до Собранието,

476
00:38:58,140 --> 00:39:01,600
а потоа Собранието се случува да се преведени на бинарни.

477
00:39:01,600 --> 00:39:07,800
Па составувањето ќе го донесе од C до Собранието.

478
00:39:07,800 --> 00:39:12,130
Зборот составувањето обично значи доведување од повисоко ниво

479
00:39:12,130 --> 00:39:14,340
на пониско ниво програмскиот јазик.

480
00:39:14,340 --> 00:39:19,190
Значи ова е само чекор во компилација каде што ќе почнете со високо ниво јазик

481
00:39:19,190 --> 00:39:23,270
и завршуваат во ниско ниво на јазикот, и тоа е зошто чекор се нарекува составувањето.

482
00:39:25,280 --> 00:39:33,370
[Студент] За време на составувањето, да речеме дека сте го направиле # вклучуваат cs50.h.

483
00:39:33,370 --> 00:39:42,190
Ќе компајлерот прекомпајлирате cs50.h, како функциите кои се таму,

484
00:39:42,190 --> 00:39:45,280
и да се преведат дека во асемблерски код, како и,

485
00:39:45,280 --> 00:39:50,830
или тоа ќе копирајте го и ставете нешто што беше пред Собранието?

486
00:39:50,830 --> 00:39:56,910
cs50.h ќе прилично никогаш не многу заврши во Собранието.

487
00:39:59,740 --> 00:40:03,680
Работи како функција прототипи и работите се само за тебе да се биде внимателен.

488
00:40:03,680 --> 00:40:09,270
Тоа гарантира дека компајлерот може да се провери работи како сте функции за повикување

489
00:40:09,270 --> 00:40:12,910
со право на враќање видови и правото аргументи и работи.

490
00:40:12,910 --> 00:40:18,350
>> Значи cs50.h ќе биде preprocessed во датотека, а потоа кога е составувањето

491
00:40:18,350 --> 00:40:22,310
Тоа е во основа фрлен по тоа го прави сигурни дека сè е доведена правилно.

492
00:40:22,310 --> 00:40:29,410
Но функции дефинирани во CS50 библиотека, која се одвоени од cs50.h,

493
00:40:29,410 --> 00:40:33,610
оние кои не се посебно ќе се состави.

494
00:40:33,610 --> 00:40:37,270
Кои, всушност, ќе слезе во поврзување чекор, па ние ќе дојдеме до тоа во една секунда.

495
00:40:37,270 --> 00:40:40,100
Но, прво, тоа што е монтажа?

496
00:40:41,850 --> 00:40:44,500
[Студент] собрание на бинарни? >> Да.

497
00:40:46,300 --> 00:40:48,190
Монтажа.

498
00:40:48,190 --> 00:40:54,710
Ние не го нарекуваат составувањето бидејќи Собранието е доста чиста превод на бинарни.

499
00:40:54,710 --> 00:41:00,230
Постои многу малку логика во одење од Собранието на бинарни.

500
00:41:00,230 --> 00:41:03,180
Тоа е исто како да барате во табела, о, имаме оваа настава;

501
00:41:03,180 --> 00:41:06,290
што одговара на бинарни 01110.

502
00:41:10,200 --> 00:41:15,230
И така на датотеки кои монтажа генерално излези се. O датотеки.

503
00:41:15,230 --> 00:41:19,020
И. O датотеки се она што го велеа порано,

504
00:41:19,020 --> 00:41:21,570
како датотеката не треба да имаат главната функција.

505
00:41:21,570 --> 00:41:27,640
Секоја датотека може да биде компајлирана сведува на. O датотека колку што е валидна Ц датотека.

506
00:41:27,640 --> 00:41:30,300
Тоа може да биде компајлирана до. O.

507
00:41:30,300 --> 00:41:43,030
Сега, поврзување е она што всушност носи еден куп. O датотеки и ги доведува до извршната датотека.

508
00:41:43,030 --> 00:41:51,110
И така она што ги поврзува не е може да се мисли на CS50 библиотека како. O датотека.

509
00:41:51,110 --> 00:41:56,980
Тоа е веќе Составувач бинарна датотека.

510
00:41:56,980 --> 00:42:03,530
И така, кога ќе компајлирате вашиот датотеки, вашиот hello.c, која повикува GetString,

511
00:42:03,530 --> 00:42:06,360
hello.c добива Составувач до hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o е сега во бинарна.

513
00:42:08,910 --> 00:42:12,830
Таа користи GetString, па затоа треба да се оди во текот на cs50.o,

514
00:42:12,830 --> 00:42:16,390
и линкерот ги smooshes заедно и копии GetString во оваа датотека

515
00:42:16,390 --> 00:42:20,640
и излегува со извршна кој ги има сите функции што треба.

516
00:42:20,640 --> 00:42:32,620
Значи cs50.o не е всушност O датотека, но тоа е доволно блиску дека не постои фундаментална разлика.

517
00:42:32,620 --> 00:42:36,880
Значи поврзува само носи еден куп на датотеки заедно

518
00:42:36,880 --> 00:42:41,390
кои одделно содржат сите функции што треба да се користи

519
00:42:41,390 --> 00:42:46,120
и создава извршна кои, всушност, ќе се кандидира.

520
00:42:48,420 --> 00:42:50,780
>> И така тоа е, исто така, она што велеа пред

521
00:42:50,780 --> 00:42:55,970
каде што може да има 1000. в датотеки, можете собере сите нив да. o датотеки,

522
00:42:55,970 --> 00:43:00,040
која, најверојатно, ќе потрае некое време, а потоа го промените 1. в датотека.

523
00:43:00,040 --> 00:43:05,480
Вие само треба да го прекомпајлирате дека 1. В датотека, и потоа relink сè друго,

524
00:43:05,480 --> 00:43:07,690
линк се врати заедно.

525
00:43:09,580 --> 00:43:11,430
[Студент] Кога ние ги поврзува ние пишуваме lcs50?

526
00:43:11,430 --> 00:43:20,510
Да, така lcs50. Тоа знаме сигнали до linker дека треба да се поврзува во таа библиотека.

527
00:43:26,680 --> 00:43:28,910
Прашања?

528
00:43:41,310 --> 00:43:46,860
Дали сме поминале над бинарни освен дека 5 секунди во првата лекција?

529
00:43:50,130 --> 00:43:53,010
Јас не мислам така.

530
00:43:55,530 --> 00:43:58,820
Треба да знаете сите големи Os дека ние сме поминале над,

531
00:43:58,820 --> 00:44:02,670
и треба да бидете во можност да се, ако ви даде функција,

532
00:44:02,670 --> 00:44:09,410
треба да бидете во можност да се каже дека е голема О, грубо. Или добро, големи O е грубо.

533
00:44:09,410 --> 00:44:15,300
Така да ако гледате вгнездени јамки looping во текот на истиот број на нештата,

534
00:44:15,300 --> 00:44:22,260
како int i, i <n; int j, ѕ <n - >> [студент] n квадрат. >> Тоа се стреми да биде n квадрат.

535
00:44:22,260 --> 00:44:25,280
Ако имате тројно вгнездени, се стреми да биде n коцки.

536
00:44:25,280 --> 00:44:29,330
Значи тој вид на работа треба да бидат способни да се истакне веднаш.

537
00:44:29,330 --> 00:44:33,890
Вие треба да знаете вметнување сортирање и меур сортирање и спојување сортирање и сите од нив.

538
00:44:33,890 --> 00:44:41,420
Тоа е полесно да се разбере зошто тие се оние n квадрат и n се најавите n и сето тоа

539
00:44:41,420 --> 00:44:47,810
бидејќи мислам дека беше на квизот една година каде што во основа ќе даде

540
00:44:47,810 --> 00:44:55,050
имплементација на меурот вид и рече: "Што е трчање време на оваа функција?"

541
00:44:55,050 --> 00:45:01,020
Значи, ако го признае како меур вид, тогаш веднаш може да се каже n квадрат.

542
00:45:01,020 --> 00:45:05,470
Но, ако само погледнете во него, можете дури и не треба да се реализира тоа е балон вид;

543
00:45:05,470 --> 00:45:08,990
можете само да кажеме дека ова го прави ова и ова. Ова е N квадрат.

544
00:45:12,350 --> 00:45:14,710
[Студент] Дали има некои тешки примери може да излезе со,

545
00:45:14,710 --> 00:45:20,370
како слична идеја на пронајдат?

546
00:45:20,370 --> 00:45:24,450
>> Јас не мислам дека ние ќе ви даде тешки примери.

547
00:45:24,450 --> 00:45:30,180
Меур вид работа е толку тешко како што ние би оделе,

548
00:45:30,180 --> 00:45:36,280
па дури и дека, колку што ви е јасно дека сте процесирањето преку низа

549
00:45:36,280 --> 00:45:41,670
за секој елемент во низата, која ќе биде нешто што е n квадрат.

550
00:45:45,370 --> 00:45:49,940
Постојат општи прашања, како право тука имаме - О.

551
00:45:55,290 --> 00:45:58,530
Само пред некој ден, Даг тврди, "Јас сум измислил алгоритам што може да се најде низа

552
00:45:58,530 --> 00:46:01,780
"На n броеви во О (log n) време!"

553
00:46:01,780 --> 00:46:04,900
Па, како да знаеме дека е невозможно?

554
00:46:04,900 --> 00:46:08,850
[Нечујни студент одговор] >> Да.

555
00:46:08,850 --> 00:46:13,710
Во најмала рака, треба да допре секој елемент во низа,

556
00:46:13,710 --> 00:46:16,210
така што е невозможно да го решите низа на -

557
00:46:16,210 --> 00:46:20,850
Ако се е во несортиран цел, тогаш ви се случува да се допира сè во низа,

558
00:46:20,850 --> 00:46:25,320
така што е невозможно да го направи тоа за помалку од О од n.

559
00:46:27,430 --> 00:46:30,340
[Студент] Вие ни покажа дека пример за да бидат во можност да го стори тоа во О од n

560
00:46:30,340 --> 00:46:33,920
ако се користи многу меморија. >> Да.

561
00:46:33,920 --> 00:46:37,970
И that's - го заборавам она што that's - Дали е пребројување вид?

562
00:46:47,360 --> 00:46:51,330
Hmm. Тоа е цел број сортирање алгоритам.

563
00:46:59,850 --> 00:47:05,100
Јас барав за посебно име за ова што не можев да се сетам минатата недела.

564
00:47:05,100 --> 00:47:13,000
Да. Тоа се видови на сорти кои може да се оствари нешто во голема О од n.

565
00:47:13,000 --> 00:47:18,430
Но, постојат ограничувања, како можете да користите само цели броеви до одреден број.

566
00:47:20,870 --> 00:47:24,560
Плус ако сте се обидува да најде нешто that's -

567
00:47:24,560 --> 00:47:30,750
Ако вашиот низа е 012, 12, 151, 4 милиони евра,

568
00:47:30,750 --> 00:47:35,120
тогаш тоа еден елемент се случува да целосно го уништи целиот сортирање.

569
00:47:42,060 --> 00:47:44,030
>> Прашања?

570
00:47:49,480 --> 00:47:58,870
[Студент] Ако имаш рекурзивен функција и тоа само прави рекурзивен повици

571
00:47:58,870 --> 00:48:02,230
во враќање изјава, тоа е опашка рекурзивен,

572
00:48:02,230 --> 00:48:07,360
и така не би кои користат повеќе меморија за време на траење

573
00:48:07,360 --> 00:48:12,550
или барем ќе се користи споредливи меморија како итеративен решение?

574
00:48:12,550 --> 00:48:14,530
[Бауден] Да.

575
00:48:14,530 --> 00:48:19,840
Тоа, најверојатно, ќе биде малку побавен, но навистина не.

576
00:48:19,840 --> 00:48:23,290
Опашка рекурзивен е прилично добар.

577
00:48:23,290 --> 00:48:32,640
Овде сум повторно во магацинот рамки, да речеме имаме главните

578
00:48:32,640 --> 00:48:42,920
и ние имаме int бар (int x) или нешто.

579
00:48:42,920 --> 00:48:52,310
Ова не е совршен рекурзивен функција, но се врати бар (x - 1).

580
00:48:52,310 --> 00:48:57,620
Значи очигледно, тоа е недостатоци. Ви треба база случаи и работи.

581
00:48:57,620 --> 00:49:00,360
Но, идејата е дека ова е опашка рекурзивен,

582
00:49:00,360 --> 00:49:06,020
што значи кога главната повици бар тоа се случува да добие магацинот рамка.

583
00:49:09,550 --> 00:49:12,440
Во овој магацинот рамка таму ќе биде малку блок од меморија

584
00:49:12,440 --> 00:49:17,490
која одговара на нејзиниот аргумент x.

585
00:49:17,490 --> 00:49:25,840
И така да речеме главната случува да се јавите бар (100);

586
00:49:25,840 --> 00:49:30,050
Значи x се случува да се започне како 100.

587
00:49:30,050 --> 00:49:35,660
Доколку компајлерот признава дека ова е опашката рекурзивна функција,

588
00:49:35,660 --> 00:49:38,540
тогаш кога бар прави своите рекурзивен повик да се забрани,

589
00:49:38,540 --> 00:49:45,490
наместо за правење на нова магацинот рамка, која е местото каде што магацинот почнува да расте во голема мера,

590
00:49:45,490 --> 00:49:48,220
на крајот таа ќе се кандидира во грамада, а потоа ќе добиете segfaults

591
00:49:48,220 --> 00:49:51,590
бидејќи меморија започнува судир.

592
00:49:51,590 --> 00:49:54,830
>> Така, наместо за правење на своја магацинот рамка, тоа може да се реализира,

593
00:49:54,830 --> 00:49:59,080
еј, никогаш не сум навистина треба да се врати на оваа магацинот рамка,

594
00:49:59,080 --> 00:50:08,040
па наместо јас само ќе го замени овој аргумент со 99, а потоа започнете бар цела.

595
00:50:08,040 --> 00:50:11,810
И тогаш тоа ќе го направи тоа повторно и ќе стигнат до враќање бар (x - 1),

596
00:50:11,810 --> 00:50:17,320
и наместо за правење на нова магацинот рамка, тоа само ќе ја замени сегашната расправија со 98

597
00:50:17,320 --> 00:50:20,740
а потоа скок назад во самиот почеток на бар.

598
00:50:23,860 --> 00:50:30,430
Овие операции, заменувајќи дека 1 вредноста на магацинот и скокање назад кон почетокот,

599
00:50:30,430 --> 00:50:32,430
се доста ефикасни.

600
00:50:32,430 --> 00:50:41,500
Затоа, не само што е ова истиот употребата на меморијата како посебна функција која е итеративен

601
00:50:41,500 --> 00:50:45,390
затоа што ти си само со користење на 1 магацинот рамка, но вие не сте болни од downsides

602
00:50:45,390 --> 00:50:47,240
на да се јавите функции.

603
00:50:47,240 --> 00:50:50,240
Повикувајќи функции може да биде малку скапи, бидејќи тоа треба да го направите сето ова подесување

604
00:50:50,240 --> 00:50:52,470
и teardown и сето тоа работи.

605
00:50:52,470 --> 00:50:58,160
Значи ова опашка рекурзија е добро.

606
00:50:58,160 --> 00:51:01,170
[Студент] Зошто не ја креирате нови чекори?

607
00:51:01,170 --> 00:51:02,980
Поради тоа што сфатил дека тоа не треба да се.

608
00:51:02,980 --> 00:51:07,800
Повикот за бар е само враќање на рекурзивен повик.

609
00:51:07,800 --> 00:51:12,220
Така што не треба да правите ништо со враќањето вредност.

610
00:51:12,220 --> 00:51:15,120
Тоа е само случува веднаш да се врати.

611
00:51:15,120 --> 00:51:20,530
Значи тоа е само ќе го замени свој аргумент и да почне одново.

612
00:51:20,530 --> 00:51:25,780
И, исто така, ако немаат опашка рекурзивен верзија,

613
00:51:25,780 --> 00:51:31,460
тогаш ќе ги добиете сите овие барови, каде, кога овој бар се враќа

614
00:51:31,460 --> 00:51:36,010
таа мора да се врати на неговата вредност на оваа, тогаш тоа бар веднаш се враќа

615
00:51:36,010 --> 00:51:39,620
и го враќа неговата вредност со нив, тогаш тоа е само ќе веднаш се врати

616
00:51:39,620 --> 00:51:41,350
и да се врати на неговата вредност на оваа.

617
00:51:41,350 --> 00:51:45,350
Па ти си заштеда на овој пукање сите овие работи надвор од магацинот

618
00:51:45,350 --> 00:51:48,730
од вратената вредност е само ќе биде усвоен по целиот пат назад до секој случај.

619
00:51:48,730 --> 00:51:55,400
Па зошто да не само замени нашиот аргумент со ажурирани аргумент и да почне одново?

620
00:51:57,460 --> 00:52:01,150
Ако функцијата не е опашка рекурзивен, ако се направи нешто како -

621
00:52:01,150 --> 00:52:07,530
[Студент] ако бар (x + 1). >> Да.

622
00:52:07,530 --> 00:52:11,770
>> Значи, ако го стави во состојба, тогаш правиш нешто со враќањето вредност.

623
00:52:11,770 --> 00:52:16,260
Или дури и ако само се враќа 2 * бар (x - 1).

624
00:52:16,260 --> 00:52:23,560
Па сега бар (x - 1) треба да се вратат во цел таа да се пресмета 2 пати поголема од таа вредност,

625
00:52:23,560 --> 00:52:26,140
па сега тоа не треба свој посебен магацинот рамка,

626
00:52:26,140 --> 00:52:31,180
и сега, без разлика колку е тешко да се обиде, сте ќе треба да -

627
00:52:31,180 --> 00:52:34,410
Ова не е опашка рекурзивен.

628
00:52:34,410 --> 00:52:37,590
[Студент] јас ќе се обиде да донесе рекурзија да се стремите кон опашка рекурзија -

629
00:52:37,590 --> 00:52:41,450
[Бауден] Во еден идеален свет, но во CS50 немате да.

630
00:52:43,780 --> 00:52:49,280
Со цел да се добие опашка рекурзија, генерално, ќе постави дополнителен аргумент

631
00:52:49,280 --> 00:52:53,550
каде бар ќе се int x во y

632
00:52:53,550 --> 00:52:56,990
и y одговара на крајната нешто што сакате да се вратат.

633
00:52:56,990 --> 00:53:03,650
Па тогаш ова ви се случува да се врати бар (x - 1), 2 * y.

634
00:53:03,650 --> 00:53:09,810
Значи тоа е само на високо ниво, како ви се трансформира работите да бидат опашка рекурзивен.

635
00:53:09,810 --> 00:53:13,790
Но на дополнителен аргумент -

636
00:53:13,790 --> 00:53:17,410
А потоа на крајот кога ќе стигнат до својата база случај, само се вратат y

637
00:53:17,410 --> 00:53:22,740
бидејќи сте се акумулира за целото време на повратната вредност што сакате.

638
00:53:22,740 --> 00:53:27,280
Можете вид на се тоа го правам iteratively но со користење на рекурзивен повици.

639
00:53:32,510 --> 00:53:34,900
Прашања?

640
00:53:34,900 --> 00:53:39,890
[Студент] Можеби за покажувачот аритметика, како при користење на жици. >> Секако.

641
00:53:39,890 --> 00:53:43,610
Покажувачот аритметика.

642
00:53:43,610 --> 00:53:48,440
Кога се користи низи тоа е лесно, бидејќи жиците се знак ѕвезди,

643
00:53:48,440 --> 00:53:51,860
знаци се засекогаш и секогаш еден бајт,

644
00:53:51,860 --> 00:53:57,540
и така покажувачот аритметичка е еквивалентно на редовна аритметички кога си имаш работа со стрингови.

645
00:53:57,540 --> 00:54:08,790
Да речеме char * s = "здраво".

646
00:54:08,790 --> 00:54:11,430
Значи имаме еден блок во меморија.

647
00:54:19,490 --> 00:54:22,380
Потребно е 6 бајти затоа што секогаш треба на нула терминатор.

648
00:54:22,380 --> 00:54:28,620
И char * s ќе укаже на почетокот на оваа низа.

649
00:54:28,620 --> 00:54:32,830
Па ги упатува таму.

650
00:54:32,830 --> 00:54:36,710
Сега, ова е во основа како било низа работи,

651
00:54:36,710 --> 00:54:40,780
без оглед на тоа дали станува збор за враќање од Примерок или дали тоа е на магацинот.

652
00:54:40,780 --> 00:54:47,110
Секоја низа е всушност покажувачот на почетокот на низата,

653
00:54:47,110 --> 00:54:53,640
а потоа било низа операција, било индексирање, е само случува во таа низа одредена офсет.

654
00:54:53,640 --> 00:55:05,360
>> Па кога ќе кажам нешто како на [3]; ова ќе ги и пребројување на гласовите 3 карактери внатре

655
00:55:05,360 --> 00:55:12,490
Значи s [3], имаме 0, 1, 2, 3, па и [3] се случува да се однесуваат на оваа л.

656
00:55:12,490 --> 00:55:20,460
[Студент] И ние би можел да достигне истата вредност со тоа и + 3, а потоа загради ѕвезда?

657
00:55:20,460 --> 00:55:22,570
Да.

658
00:55:22,570 --> 00:55:26,010
Ова е еквивалентно на * (а + 3);

659
00:55:26,010 --> 00:55:31,240
а тоа е засекогаш и секогаш еквивалент без разлика што правиш.

660
00:55:31,240 --> 00:55:34,070
Вие никогаш не треба да се користи заграда синтакса.

661
00:55:34,070 --> 00:55:37,770
Секогаш можете да го користите * (а + 3) синтакса.

662
00:55:37,770 --> 00:55:40,180
Луѓето имаат тенденција да ја сакам заградата синтакса, иако.

663
00:55:40,180 --> 00:55:43,860
[Студент] Па сите низи се всушност само покажувачи.

664
00:55:43,860 --> 00:55:53,630
Постои мала разлика кога велам int x [4]; >> [студент] Дали тоа создаде меморија?

665
00:55:53,630 --> 00:56:03,320
[Бауден] Тоа се случува да се создаде 4 ints на магацинот, па 16 бајти во целина.

666
00:56:03,320 --> 00:56:05,700
Тоа се случува да се создаде 16 бајти на магацинот.

667
00:56:05,700 --> 00:56:09,190
x не е зачувана насекаде.

668
00:56:09,190 --> 00:56:13,420
Тоа е само симбол се однесува на почетокот на работа.

669
00:56:13,420 --> 00:56:17,680
Затоа што прогласи низа во внатрешноста на оваа функција,

670
00:56:17,680 --> 00:56:22,340
што компајлерот ќе направите е само да ги замени сите случаи на променливата x

671
00:56:22,340 --> 00:56:26,400
со, каде што се случи да изберат да се стави овие 16 бајти.

672
00:56:26,400 --> 00:56:30,040
Тоа не може да го направи тоа со char * s, бидејќи s е вистински покажувач.

673
00:56:30,040 --> 00:56:32,380
Тоа е слободен да потоа се упати на други работи.

674
00:56:32,380 --> 00:56:36,140
x е константа. Вие не може да го имаат точка на различни низа. >> [Студент] Во ред.

675
00:56:36,140 --> 00:56:43,420
Но оваа идеја, оваа индексирање, е иста без оглед на тоа дали тоа е традиционален низа

676
00:56:43,420 --> 00:56:48,230
или ако тоа е покажувач кон нешто или ако е покажувач кон malloced низа.

677
00:56:48,230 --> 00:56:59,770
И всушност, тоа е толку еквивалент дека тоа е исто така истото.

678
00:56:59,770 --> 00:57:05,440
Тоа, всушност, само преведува она што е внатре во заградите и она што остана од голема заграда,

679
00:57:05,440 --> 00:57:07,970
додава нив заедно, и dereferences.

680
00:57:07,970 --> 00:57:14,710
Значи ова е само како валиден како * (а + 3) или S [3].

681
00:57:16,210 --> 00:57:22,090
[Студент] Дали можете да имате совети укажува на 2-димензионални низи?

682
00:57:22,090 --> 00:57:27,380
>> Тоа е потешко. Традиционално, бр.

683
00:57:27,380 --> 00:57:34,720
А 2-димензионална низа е само 1-димензионална низа со некои практични синтакса

684
00:57:34,720 --> 00:57:54,110
бидејќи кога велам int x [3] [3], ова е навистина само 1 низа со 9 вредности.

685
00:57:55,500 --> 00:58:03,000
И така, кога јас индекс, компајлерот знае што мислам.

686
00:58:03,000 --> 00:58:13,090
Ако кажам x [1] [2], таа знае дека сакаат да одат на вториот ред, па затоа се случува да го прескокнете првите 3,

687
00:58:13,090 --> 00:58:17,460
а потоа сака Втората работа во тоа, па затоа се случува да се добие оваа.

688
00:58:17,460 --> 00:58:20,480
Но, тоа е уште само еден-димензионална низа.

689
00:58:20,480 --> 00:58:23,660
И така, ако сакав да доделите покажувачот во тој низа,

690
00:58:23,660 --> 00:58:29,770
Јас би рекол int * P = x;

691
00:58:29,770 --> 00:58:33,220
Тип на x е само -

692
00:58:33,220 --> 00:58:38,280
Тоа е груба велејќи тип на x, бидејќи тоа е само симбол и тоа не е вистински променлива,

693
00:58:38,280 --> 00:58:40,140
но тоа е само int *.

694
00:58:40,140 --> 00:58:44,840
x е само покажувач на почетокот на оваа. >> [Студент] Во ред.

695
00:58:44,840 --> 00:58:52,560
И така јас не ќе бидат во можност да пристапите [1] [2].

696
00:58:52,560 --> 00:58:58,370
Мислам дека постои специјална синтакса за прогласување покажувач,

697
00:58:58,370 --> 00:59:12,480
нешто смешно како int (* P [-. нешто апсолутно смешно јас дури и не знаат.

698
00:59:12,480 --> 00:59:17,090
Но, постои синтакса за прогласување совети како со голема заграда и работи.

699
00:59:17,090 --> 00:59:22,960
Тоа дури и не може да го направите тоа.

700
00:59:22,960 --> 00:59:26,640
Јас би можеле да се погледне назад на нешто што ќе ми кажеш вистината.

701
00:59:26,640 --> 00:59:34,160
Јас ќе се погледне за неа подоцна, ако постои синтакса за точка. Но, вие никогаш не ќе го видите.

702
00:59:34,160 --> 00:59:39,670
Па дури и синтаксата е толку архаични дека ако го користиш, луѓето ќе бидат збунети.

703
00:59:39,670 --> 00:59:43,540
Мултидимензионална низа се доста ретки како што е.

704
00:59:43,540 --> 00:59:44,630
Можете доста -

705
00:59:44,630 --> 00:59:48,490
Па, ако правиш матрица работите не се случува да се ретки,

706
00:59:48,490 --> 00:59:56,730
но во C си ретко ќе биде со користење мултидимензионална низа.

707
00:59:57,630 --> 01:00:00,470
Да. >> [Студент] Да речеме дека имаат навистина долго низа.

708
01:00:00,470 --> 01:00:03,900
>> Значи во виртуелна меморија би се чини дека се сите последователни,

709
01:00:03,900 --> 01:00:05,640
како елементи веднаш до едни со други,

710
01:00:05,640 --> 01:00:08,770
но во физичката меморија, тоа ќе биде можно тоа да се подели? >> Да.

711
01:00:08,770 --> 01:00:16,860
Како виртуелна меморија работи тоа е само дели -

712
01:00:19,220 --> 01:00:24,860
Единицата на распределба е страница, која има тенденција да биде 4 килобајти,

713
01:00:24,860 --> 01:00:29,680
и така кога процесот вели, еј, сакам да го користите овој меморија,

714
01:00:29,680 --> 01:00:35,970
оперативниот систем ќе го распредели 4 килобајти за тоа малку блок од меморија.

715
01:00:35,970 --> 01:00:39,100
Дури и ако само ги користат еден малку бајт во целиот блок од меморија,

716
01:00:39,100 --> 01:00:42,850
оперативниот систем ќе го даде целосна 4 килобајти.

717
01:00:42,850 --> 01:00:49,410
Значи она што ова значи јас би можеле да имаат - да речеме ова е мојот оџак.

718
01:00:49,410 --> 01:00:53,180
Оваа оџакот може да се одвојат. Мој оџакот може да биде мегабајти и мегабајти.

719
01:00:53,180 --> 01:00:55,020
Мој оџакот може да биде огромна.

720
01:00:55,020 --> 01:01:00,220
Но магацинот себе треба да се подели на одделни страници,

721
01:01:00,220 --> 01:01:09,010
кој ако гледаме овде да речеме ова е нашата RAM меморија,

722
01:01:09,010 --> 01:01:16,600
ако имам 2 гигабајти RAM меморија, ова е вистинската адреса 0 како 0. бајт од моите RAM меморија,

723
01:01:16,600 --> 01:01:22,210
и ова е 2 гигабајти на целиот пат овде.

724
01:01:22,210 --> 01:01:27,230
Значи оваа страница може да одговараат на овој блок овде.

725
01:01:27,230 --> 01:01:29,400
Оваа страница може да одговараат на овој блок овде.

726
01:01:29,400 --> 01:01:31,560
Ова би можело да одговараат на овој овде.

727
01:01:31,560 --> 01:01:35,540
Така што оперативниот систем е слободен да доделите виртуелна меморија

728
01:01:35,540 --> 01:01:39,320
на било кој поединец страница произволно.

729
01:01:39,320 --> 01:01:46,180
А тоа значи дека ако оваа граница се случува да разкрачвам низа,

730
01:01:46,180 --> 01:01:50,070
низа се случува да бидат оставени на овој и правото на оваа цел на страницата,

731
01:01:50,070 --> 01:01:54,460
тогаш таа низа ќе бидат поделени во физичка меморија.

732
01:01:54,460 --> 01:01:59,280
И тогаш кога ќе ја завршите програмата, кога процесот завршува,

733
01:01:59,280 --> 01:02:05,690
овие мапирање се избришани, а потоа тоа е бесплатно да ги користат овие малку блокови за други работи.

734
01:02:14,730 --> 01:02:17,410
Повеќе прашања?

735
01:02:17,410 --> 01:02:19,960
[Студент] На покажувачот аритметика. >> Oh yeah.

736
01:02:19,960 --> 01:02:28,410
Стрингови се полесно, но гледајќи нешто како ints,

737
01:02:28,410 --> 01:02:35,000
па назад кон int x [4];

738
01:02:35,000 --> 01:02:41,810
Дали ова е низа или дали тоа е покажувач кон malloced низа од 4 броеви,

739
01:02:41,810 --> 01:02:47,060
тоа се случува да бидат третирани на ист начин.

740
01:02:50,590 --> 01:02:53,340
[Студент] Значи низи се на куп?

741
01:03:01,400 --> 01:03:05,270
[Бауден] низи не се на куп. >> [Студент] О.

742
01:03:05,270 --> 01:03:08,320
>> [Бауден] Овој вид на низа има тенденција да биде на магацинот

743
01:03:08,320 --> 01:03:12,220
освен ако не го прогласи во - игнорирање на глобални променливи. Не користете глобални променливи.

744
01:03:12,220 --> 01:03:16,280
Внатрешноста на функција велам int x [4];

745
01:03:16,280 --> 01:03:22,520
Тоа ќе создаде 4-број блок на магацинот за оваа низа.

746
01:03:22,520 --> 01:03:26,960
Но, ова Примерок (4 * sizeof (int)); се случува да одам на грамада.

747
01:03:26,960 --> 01:03:31,870
Но, по овој момент можам да користам x и стр во прилично ист начин,

748
01:03:31,870 --> 01:03:36,140
освен исклучоците што реков пред околу можете да преназначаване стр.

749
01:03:36,140 --> 01:03:40,960
Технички, нивните големини се малку различни, но тоа е сосема неважно.

750
01:03:40,960 --> 01:03:43,310
Вие никогаш всушност ги користат нивните големини.

751
01:03:48,020 --> 01:03:56,810
На стр можев да кажам p [3] = 2; или x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
Можете да ги користите токму на ист начин.

753
01:03:59,680 --> 01:04:01,570
Значи покажувачот аритметички сега - Да.

754
01:04:01,570 --> 01:04:07,390
[Студент] Не што треба да направите p * ако имате голема заграда?

755
01:04:07,390 --> 01:04:11,720
Во загради се имплицитно Dereference. >> Океј.

756
01:04:11,720 --> 01:04:20,200
Всушност, исто така, она што си ти што зборуваш со можете да добиете мултидимензионална низа

757
01:04:20,200 --> 01:05:02,650
со покажувачи, што можете да направите е нешто како, да речеме, int ** п.п. = Примерок (sizeof (int *) * 5);

758
01:05:02,650 --> 01:05:06,900
Јас само ќе напише сето тоа во прв план.

759
01:05:37,880 --> 01:05:41,020
Јас не сакам таа една.

760
01:05:41,020 --> 01:05:42,550
Во ред.

761
01:05:42,550 --> 01:05:48,910
Она што го правеше тука е - Тоа треба да биде п.п. [i].

762
01:05:48,910 --> 01:05:53,680
Значи п.п. е покажувач кон покажувач.

763
01:05:53,680 --> 01:06:02,420
Ти си mallocing п.п. укажуваат на низа од 5 int ѕвезди.

764
01:06:02,420 --> 01:06:10,950
Значи во меморија имате на магацинот стр

765
01:06:10,950 --> 01:06:20,150
Тоа се случува да укажуваат на низа од 5 блокови кои се самите совети.

766
01:06:20,150 --> 01:06:28,210
И тогаш кога ќе Примерок долу тука, јас Примерок дека секој од тие поединечни совети

767
01:06:28,210 --> 01:06:32,080
треба да укажуваат на посебен блок од 4 бајти на грамада.

768
01:06:32,080 --> 01:06:35,870
Значи ова поени до 4 бајти.

769
01:06:37,940 --> 01:06:40,660
И ова укажува на различните 4 бајти.

770
01:06:40,660 --> 01:06:43,200
>> И сите од нив укажуваат на своите 4 бајти.

771
01:06:43,200 --> 01:06:49,080
Ова ми дава начин на вршење на мултидимензионална работи.

772
01:06:49,080 --> 01:06:58,030
Јас може да се каже п.п. [3] [4], но сега тоа не е истото како мултидимензионална низа

773
01:06:58,030 --> 01:07:05,390
бидејќи мултидимензионална низа го преведе [3] [4] во единечен свиткан во низа х.

774
01:07:05,390 --> 01:07:14,790
Ова dereferences p, пристапи третиот индекс, потоа dereferences дека

775
01:07:14,790 --> 01:07:20,790
и пристапи - 4 ќе биде валиден - вториот индекс.

776
01:07:24,770 --> 01:07:31,430
Каде што, кога имавме int x [3] [4] пред како мултидимензионална низа

777
01:07:31,430 --> 01:07:35,740
и кога ќе се удвои заграда тоа е навистина само еден Dereference,

778
01:07:35,740 --> 01:07:40,490
ти си по еден покажувач, а потоа офсет,

779
01:07:40,490 --> 01:07:42,850
ова е навистина 2D референци.

780
01:07:42,850 --> 01:07:45,840
Ќе го следат 2 одделни совети.

781
01:07:45,840 --> 01:07:50,420
Па ова, исто така, технички ви овозможува да имате мултидимензионална низа

782
01:07:50,420 --> 01:07:53,550
каде што секој поединец низа е различни големини.

783
01:07:53,550 --> 01:07:58,000
Па мислам дека грапав мултидимензионална низа е она што се вика

784
01:07:58,000 --> 01:08:01,870
бидејќи навистина првото нешто може да укаже на нешто што има 10 елементи,

785
01:08:01,870 --> 01:08:05,540
втората работа може да укаже на нешто што има 100 елементи.

786
01:08:05,540 --> 01:08:10,790
[Студент] Дали има ограничување на бројот на покажувачи ќе може да има

787
01:08:10,790 --> 01:08:14,290
што укажува на други совети? >> Бр

788
01:08:14,290 --> 01:08:17,010
Можете да имаат int ***** стр.

789
01:08:18,050 --> 01:08:23,760
Вратете се на покажувачот аритметички - >> [студент] О. >> Да.

790
01:08:23,760 --> 01:08:35,649
[Студент] Ако имам int *** p и тогаш јас се направи dereferencing и велам p * е еднакво на оваа вредност,

791
01:08:35,649 --> 01:08:39,560
Дали е тоа само ќе направи 1 ниво на dereferencing? >> Да.

792
01:08:39,560 --> 01:08:43,340
Значи, ако сакам да пристапите на нешто што последните покажувачот е да се покажува во -

793
01:08:43,340 --> 01:08:46,210
Тогаш го правите *** стр. >> Океј.

794
01:08:46,210 --> 01:08:54,080
Значи ова е p поени 1 блок, укажува на друга блок, поени на друг блок.

795
01:08:54,080 --> 01:09:02,010
Тогаш ако не * P = нешто друго, тогаш се менуваат овој

796
01:09:02,010 --> 01:09:13,640
до сега укажуваат на различни блок. >> Океј.

797
01:09:13,640 --> 01:09:17,649
>> [Бауден] И ако тие беа malloced, тогаш сте сега протекоа меморија

798
01:09:17,649 --> 01:09:20,430
освен ако не се случи да имаат различни референци од овие

799
01:09:20,430 --> 01:09:25,270
бидејќи не можете да се вратам на оние кои само фрли.

800
01:09:25,270 --> 01:09:29,550
Покажувачот аритметика.

801
01:09:29,550 --> 01:09:36,310
int x [4]; ќе одвои низа од 4 броеви

802
01:09:36,310 --> 01:09:40,670
каде што x се случува да се укаже на почетокот на низата.

803
01:09:40,670 --> 01:09:50,420
Па кога ќе кажам нешто како x [1]; Сакам да значи одат во вториот број во низа,

804
01:09:50,420 --> 01:09:53,319
која ќе биде оваа.

805
01:09:53,319 --> 01:10:04,190
Но, навистина, тоа е 4 бајти во низа од овој број зазема 4 бајти.

806
01:10:04,190 --> 01:10:08,470
Значи офсет од 1 навистина значи поместување од 1

807
01:10:08,470 --> 01:10:12,030
пати поголема од големината на она што тип на низата е.

808
01:10:12,030 --> 01:10:17,170
Ова е низа од цели броеви, па тоа знае да се направи 1 пати големината на int кога сака да надомести.

809
01:10:17,170 --> 01:10:25,260
Од друга синтакса. Запомнете дека ова е еквивалент на * (x + 1);

810
01:10:25,260 --> 01:10:35,250
Кога велам покажувач + 1, она што се враќа е адресата која покажувачот се чување

811
01:10:35,250 --> 01:10:40,360
плус 1 пати поголема од големината на типот на покажувачот.

812
01:10:40,360 --> 01:10:59,510
Значи, ако x = ox100, тогаш x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
И можете да го злоупотребуваат ова и каже нешто како char * C = (char *) x;

814
01:11:19,750 --> 01:11:23,050
и сега в ќе биде иста адреса како x.

815
01:11:23,050 --> 01:11:26,040
в ќе биде еднаква на ox100,

816
01:11:26,040 --> 01:11:31,490
но в + 1 ќе биде еднаква на ox101

817
01:11:31,490 --> 01:11:38,030
од покажувачот аритметички зависи од типот на покажувачот дека сте додавање.

818
01:11:38,030 --> 01:11:45,390
Значи C + 1, изгледа во в, тоа е знак покажувач, па затоа се случува да додадете 1 пати големина на знак,

819
01:11:45,390 --> 01:11:48,110
кој секогаш ќе биде 1, па ќе го добиете 101,

820
01:11:48,110 --> 01:11:54,890
а ако го правам X, кој е исто така уште 100, x + 1 ќе биде 104.

821
01:11:56,660 --> 01:12:06,340
[Студент] можете да го користите C + +, со цел да ги унапредат својата покажувачот од 1?

822
01:12:06,340 --> 01:12:09,810
Да, можеш.

823
01:12:09,810 --> 01:12:16,180
Вие не може да го направи тоа со x бидејќи x е само симбол, тоа е постојана, вие не можат да сменат х.

824
01:12:16,180 --> 01:12:22,610
>> Но в случува да биде само покажувач, па C + + е совршено валидни и ќе прираст од 1.

825
01:12:22,610 --> 01:12:32,440
Ако в беа само int *, тогаш C + + ќе биде 104.

826
01:12:32,440 --> 01:12:41,250
+ + Прави покажувачот аритметички само како C + 1 би го сторил покажувачот аритметика.

827
01:12:43,000 --> 01:12:48,870
Ова е всушност како многу нешта како логирате вид -

828
01:12:49,670 --> 01:12:55,710
Наместо за создавање копии на нештата, наместо да помине -

829
01:12:55,710 --> 01:13:02,400
Како и ако сакав да го помине овој половина од низа - Да се ​​избрише некои од ова.

830
01:13:04,770 --> 01:13:10,520
Да речеме дека сакав да помине оваа страна на низа во функција.

831
01:13:10,520 --> 01:13:12,700
Што би се пренесат и на таа функција?

832
01:13:12,700 --> 01:13:17,050
Ако јас помине x, јас сум минува оваа адреса.

833
01:13:17,050 --> 01:13:23,780
Но јас сакам да помине оваа адреса. Значи она што треба да помине?

834
01:13:23,780 --> 01:13:26,590
[Студент] Покажувач + 2?

835
01:13:26,590 --> 01:13:29,350
[Бауден] Значи x + 2. Да.

836
01:13:29,350 --> 01:13:31,620
Тоа ќе биде оваа адреса.

837
01:13:31,620 --> 01:13:42,810
Ќе исто така многу често го гледаат како x [2], а потоа и адресата на тоа.

838
01:13:42,810 --> 01:13:47,850
Значи треба да се земе адресата на него, бидејќи заградата е имплицитна Dereference.

839
01:13:47,850 --> 01:13:53,250
x [2] се однесува на вредност која е во ова поле, а потоа ќе сакате адресата на тоа поле,

840
01:13:53,250 --> 01:13:56,850
така да се каже и x [2].

841
01:13:56,850 --> 01:14:02,880
Значи тоа е тоа како нешто логирате вид, каде што сакате да помине половина од листата на нешто

842
01:14:02,880 --> 01:14:08,790
навистина, само поминуваат и x [2], а сега колку што е рекурзивен повик е загрижен,

843
01:14:08,790 --> 01:14:12,510
мојата нова низа почнува таму.

844
01:14:12,510 --> 01:14:15,130
Последен момент прашања.

845
01:14:15,130 --> 01:14:20,050
[Студент] Ако ние не се стави симболот или - што е тоа вика? >> Star?

846
01:14:20,050 --> 01:14:23,200
[Студент] ѕвезда. >> Технички, Dereference оператор, но - >> [студент] Dereference.

847
01:14:23,200 --> 01:14:29,310
>> Ако ние не се стави една ѕвезда или симболот, она што се случува ако речеме y = x и x е покажувачот?

848
01:14:29,310 --> 01:14:34,620
Што е тип на y? >> [Студент] јас само ќе кажам тоа е покажувачот 2.

849
01:14:34,620 --> 01:14:38,270
Значи, ако речеме y = x, сега x и y точка за истото. >> [Студент] Точка до истото.

850
01:14:38,270 --> 01:14:45,180
И ако x е int покажувачот? >> Тоа ќе се жалат бидејќи не можете да доделите совети.

851
01:14:45,180 --> 01:14:46,540
[Студент] Во ред.

852
01:14:46,540 --> 01:14:51,860
Запомнете дека покажувачи, иако ние ги привлече како стрели,

853
01:14:51,860 --> 01:15:02,010
навистина сите тие продавница - int * x - навистина сите x е чување е нешто како ox100,

854
01:15:02,010 --> 01:15:06,490
кои се случи да претставуваат како укажува на блок чуваат на 100.

855
01:15:06,490 --> 01:15:19,660
Значи, кога велам int * y = x, јас сум само копирање ox100 во y,

856
01:15:19,660 --> 01:15:24,630
кои ние сме само ќе претставуваат како y, исто така, укажува на ox100.

857
01:15:24,630 --> 01:15:39,810
И ако кажам int i = (int) x; тогаш јас ќе ја запази она што вредноста на ox100 е

858
01:15:39,810 --> 01:15:45,100
во него, но сега тоа се случува да се толкува како цел број, наместо на покажувачот.

859
01:15:45,100 --> 01:15:49,310
Но, вие треба леано или на друго место ќе се жалат.

860
01:15:49,310 --> 01:15:53,300
[Студент] Значи сакаш да кажеш да го дадат -

861
01:15:53,300 --> 01:16:00,290
Е тоа ќе биде кастинг int на x или кастинг int на y?

862
01:16:00,290 --> 01:16:03,700
[Бауден] Што?

863
01:16:03,700 --> 01:16:07,690
[Студент] Во ред. По овие загради е таму ќе биде x или ay таму?

864
01:16:07,690 --> 01:16:11,500
>> [Бауден] или. x и y се еквивалентни. >> [Студент] Во ред.

865
01:16:11,500 --> 01:16:14,390
Бидејќи тие се двете насоки. >> Да.

866
01:16:14,390 --> 01:16:21,050
[Студент] Значи тоа ќе ја зачувате хексадецимален 100 во цел број форма? >> [Бауден] Да.

867
01:16:21,050 --> 01:16:23,620
Но не и вредноста на она што укажува.

868
01:16:23,620 --> 01:16:29,940
[Бауден] Да. >> [Студент] Па само ја адресата во цел број форма. Во ред.

869
01:16:29,940 --> 01:16:34,720
[Бауден] Ако си сакал да за некои бизарни причини,

870
01:16:34,720 --> 01:16:38,900
можете само може да се справи со покажувачи и никогаш не се справи со цели броеви

871
01:16:38,900 --> 01:16:49,240
и само да биде како int * x = 0.

872
01:16:49,240 --> 01:16:53,000
Тогаш ви се случува да се навистина збунета еднаш покажувачот аритметички започнува случува.

873
01:16:53,000 --> 01:16:56,570
Значи броеви кои тие се чуваат се бесмислени.

874
01:16:56,570 --> 01:16:58,940
Тоа е само како ќе заврши толкување нив.

875
01:16:58,940 --> 01:17:02,920
Па јас сум слободен да го копирате ox100 од int * до int,

876
01:17:02,920 --> 01:17:07,790
и јас сум слободен да доделите - Ти си веројатно нема да се викна на за да не леење -

877
01:17:07,790 --> 01:17:18,160
Јас сум слободен да доделите нешто како (int *) ox1234 во оваа произволна int *.

878
01:17:18,160 --> 01:17:25,480
Значи ox123 е само како валиден меморија адреса како што е и y.

879
01:17:25,480 --> 01:17:32,060
И y се случува да се врати нешто што е доста ox123.

880
01:17:32,060 --> 01:17:35,430
[Студент] Тоа ќе биде навистина кул начин да се оди од хексадецимални во децимална форма,

881
01:17:35,430 --> 01:17:39,230
како ако имате покажувач и ќе го фрли како int?

882
01:17:39,230 --> 01:17:44,860
[Бауден] Вие навистина само да печатите со користење како printf.

883
01:17:44,860 --> 01:17:50,300
Да речеме дека имам int y = 100.

884
01:17:50,300 --> 01:18:02,700
Значи printf (% d \ n - како што веќе треба да знаете - печати дека како цел број,% х.

885
01:18:02,700 --> 01:18:05,190
Ние само ќе печати како хексадецимални.

886
01:18:05,190 --> 01:18:10,760
Значи покажувач не се чуваат како хексадецимален,

887
01:18:10,760 --> 01:18:12,960
и број не се чуваат како децимална.

888
01:18:12,960 --> 01:18:14,700
Сè што се чуваат како бинарни.

889
01:18:14,700 --> 01:18:17,950
Тоа е само дека ние се стремат да ја прикажете совети како хексадецимални

890
01:18:17,950 --> 01:18:23,260
затоа што мислам на нештата во овие 4-бајт блокови,

891
01:18:23,260 --> 01:18:25,390
и мемориски адреси имаат тенденција да бидат запознаени.

892
01:18:25,390 --> 01:18:28,890
Ние сме како, ако тоа започнува со bf, тогаш тоа се случува да биде на магацинот.

893
01:18:28,890 --> 01:18:35,560
Значи тоа е само наша интерпретација на совети како хексадецимални.

894
01:18:35,560 --> 01:18:39,200
Во ред. Последни прашања?

895
01:18:39,200 --> 01:18:41,700
>> Јас ќе бидам тука за малку по ако имате било што друго.

896
01:18:41,700 --> 01:18:46,070
И тоа е крајот на тоа.

897
01:18:46,070 --> 01:18:48,360
>> [Студент] Yay! [Аплауз]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]