1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [4. szakasz - További Kényelmes]

2
00:00:02,520 --> 00:00:04,850
[Rob Bowden - Harvard University]

3
00:00:04,850 --> 00:00:07,370
[Ez CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
Van egy kvíz holnap, abban az esetben, ha a srácok nem tudja, hogy.

5
00:00:14,810 --> 00:00:20,970
Ez alapvetően mindent, amit látott az osztályban, vagy kellett volna az osztályban.

6
00:00:20,970 --> 00:00:26,360
Ez magában foglalja a mutató, annak ellenére, hogy egy nagyon friss téma.

7
00:00:26,360 --> 00:00:29,860
Meg kell legalább megértetni a magas szintű őket.

8
00:00:29,860 --> 00:00:34,760
Bármi, ami eltűnt több osztályba meg kell értened a kvíz.

9
00:00:34,760 --> 00:00:37,320
Tehát, ha kérdése van rájuk, akkor kérje meg őket most.

10
00:00:37,320 --> 00:00:43,280
De ez lesz egy nagyon diákok által vezetett ülésen, ahol a srácok kérdéseket feltenni,

11
00:00:43,280 --> 00:00:45,060
így remélhetőleg az emberek kérdéseire.

12
00:00:45,060 --> 00:00:48,020
Van valakinek kérdése?

13
00:00:49,770 --> 00:00:52,090
Igen. >> [Hallgató] Tud megy át mutatókat újra?

14
00:00:52,090 --> 00:00:54,350
Odamegyek mutatók.

15
00:00:54,350 --> 00:00:59,180
Minden a változók szükségszerűen él a memóriában,

16
00:00:59,180 --> 00:01:04,450
de általában ne aggódj, és mondod x + 2 és y + 3

17
00:01:04,450 --> 00:01:07,080
és a fordító fog kitalálni, ahol a dolgok élnek az Ön számára.

18
00:01:07,080 --> 00:01:12,990
Ha dolgunk mutató, most meg kifejezetten használ a memória címeket.

19
00:01:12,990 --> 00:01:19,800
Így egy egyetlen változó csak mindig élőben egyetlen cím bármely adott időben.

20
00:01:19,800 --> 00:01:24,040
Ha azt akarjuk, hogy állapítsa meg a mutató, ami a típus fog kinézni?

21
00:01:24,040 --> 00:01:26,210
>> Azt akarom, hogy állapítsa meg a mutató p. Mit jelent a típus néz ki?

22
00:01:26,210 --> 00:01:33,530
[Hallgató] int * p. >> Igen. Így int * p.

23
00:01:33,530 --> 00:01:38,030
És hogyan teszik mutatni x? >> [Hallgató] jelet.

24
00:01:40,540 --> 00:01:45,300
[Bowden] Szóval jelet szó szerint nevezik címét üzemeltető.

25
00:01:45,300 --> 00:01:50,460
Tehát amikor azt mondom & x ez egyre a memória címét a változó x.

26
00:01:50,460 --> 00:01:56,790
Így most már a mutató p, és bárhol kódomat tudom használni * p

27
00:01:56,790 --> 00:02:02,960
vagy én jönne x és ez lesz pontosan ugyanaz a dolog.

28
00:02:02,960 --> 00:02:09,520
(* P). Mit keres ez? Mit jelent, hogy a csillag jelent?

29
00:02:09,520 --> 00:02:13,120
[Hallgató] Ez azt jelenti, az érték ezen a ponton. >> Igen.

30
00:02:13,120 --> 00:02:17,590
Tehát, ha azt nézzük, akkor nagyon hasznos lehet, hogy dolgozzon ki a diagramok

31
00:02:17,590 --> 00:02:22,230
ha ez egy kis doboz memória x, ami történik, hogy az érték 4,

32
00:02:22,230 --> 00:02:25,980
akkor van egy kis doboz memória p,

33
00:02:25,980 --> 00:02:31,590
és így p pontok x, így felhívni egy nyilat p x.

34
00:02:31,590 --> 00:02:40,270
Tehát amikor azt mondjuk, * p mondunk megy a doboz, p.

35
00:02:40,270 --> 00:02:46,480
Star követi a nyilat, majd csinálsz, amit akarsz, hogy a dobozban ott.

36
00:02:46,480 --> 00:03:01,090
Így azt mondhatom, * p = 7, és hogy fog menni a dobozt, hogy az x és a változás, hogy a 7-re.

37
00:03:01,090 --> 00:03:13,540
Vagy azt is mondhatnám int z = * p * 2; ez zavaró, mert a csillag, star.

38
00:03:13,540 --> 00:03:19,230
Az egyik csillag dereferencing p, a másik csillag megszorozzuk 2-vel.

39
00:03:19,230 --> 00:03:26,780
Figyeljük meg tudtam volna éppúgy helyébe a * p az x.

40
00:03:26,780 --> 00:03:29,430
Használhatod őket ugyanúgy.

41
00:03:29,430 --> 00:03:38,000
Aztán később azt lehet p pont egy teljesen új dolog.

42
00:03:38,000 --> 00:03:42,190
Én csak azt mondom p = &z;

43
00:03:42,190 --> 00:03:44,940
Tehát most már nem p pontok x, ez mutat z.

44
00:03:44,940 --> 00:03:50,510
És minden alkalommal, amikor ezt * p, hogy ez ugyanaz, mint csinál z.

45
00:03:50,510 --> 00:03:56,170
Így a hasznos dolog ez egyszer elkezdünk bekerülni funkciókat.

46
00:03:56,170 --> 00:03:59,790
>> Elég haszontalan, hogy nyilvánítson egy mutató, amely rámutat arra, hogy valami

47
00:03:59,790 --> 00:04:03,140
és akkor még csak azt dereferencing

48
00:04:03,140 --> 00:04:06,060
ha volna használni az eredeti változót kezdeni.

49
00:04:06,060 --> 00:04:18,190
De ha bejutni funkciók - így mondjuk van néhány funkció, int foo,

50
00:04:18,190 --> 00:04:32,810
hogy vesz egy mutató, és csak nem * p = 6;

51
00:04:32,810 --> 00:04:39,990
Mint láttuk, mielőtt a csere, akkor nem hatékony swap és külön funkció

52
00:04:39,990 --> 00:04:45,180
mellett csak múló egész, mert minden a C mindig elhaladó értéket.

53
00:04:45,180 --> 00:04:48,360
Még ha éppen elhaladó pointers te elhaladó értéket.

54
00:04:48,360 --> 00:04:51,940
Ez csak azért történik, hogy ezek az értékek memória címeket.

55
00:04:51,940 --> 00:05:00,770
Tehát amikor azt mondom foo (p) Én halad a mutató a function ize

56
00:05:00,770 --> 00:05:03,910
majd a foo csinál * p = 6;

57
00:05:03,910 --> 00:05:08,600
Szóval belül ilyen funkciót, * p még mindig egyenértékű x,

58
00:05:08,600 --> 00:05:12,720
de én ezért nem használhatja x belsejébe, hogy a funkció, mert nem hatókörű belül funkciót.

59
00:05:12,720 --> 00:05:19,510
Szóval * p = 6 az egyetlen módja tudok hozzá egy helyi változót egy másik funkció.

60
00:05:19,510 --> 00:05:23,600
Vagy, nos, pointerek az egyetlen módja tudok hozzá egy helyi változót egy másik funkció.

61
00:05:23,600 --> 00:05:31,600
[Hallgató] Tegyük fel, hogy vissza akart térni a mutató. Pontosan hogyan csinálod ezt?

62
00:05:31,600 --> 00:05:44,270
[Bowden] vissza a mutatót, mint valami hasonlót int y = 3; visszatérés & y? >> [Hallgató] Igen.

63
00:05:44,270 --> 00:05:48,480
[Bowden] Oké. Soha ne tegye ezt. Ez rossz.

64
00:05:48,480 --> 00:05:59,480
Azt hiszem, láttam ilyen előadás diák elkezdte látni az egész diagram a memória

65
00:05:59,480 --> 00:06:02,880
ahol akár itt megvan memória cím 0

66
00:06:02,880 --> 00:06:09,550
és itt lent van memóriacím 4 koncertek vagy a 2 a 32.

67
00:06:09,550 --> 00:06:15,120
Akkor neked néhány dolgot, és néhány dolgot, és akkor már a stack

68
00:06:15,120 --> 00:06:21,780
és megvan a halom, amit most kezdett tanulni, felnőni.

69
00:06:21,780 --> 00:06:24,390
[Hallgató] Nem a halom felett stack?

70
00:06:24,390 --> 00:06:27,760
>> Igen. A kupac tetején, nem igaz? >> [Hallgató] Nos, tette 0 a tetején.

71
00:06:27,760 --> 00:06:30,320
[Hallgató] Oh, tette 0 a tetején. >> [Hallgató] Ó, oké.

72
00:06:30,320 --> 00:06:36,060
Jogi nyilatkozat: bárhol CS50 fogod látni, hogy ezen a módon. >> [Hallgató] Oké.

73
00:06:36,060 --> 00:06:40,290
Csak arról van szó, amikor 1. látta halom,

74
00:06:40,290 --> 00:06:45,000
szeretném, ha úgy gondolja, egy rakás gondol egymásra dolgokat egymás tetejére.

75
00:06:45,000 --> 00:06:50,810
Ezért hajlamosak vagyunk a flip e körül, így a verem nő fel, mint egy halom a megszokott módon

76
00:06:50,810 --> 00:06:55,940
ahelyett, hogy a köteg lóg le. >> [Hallgató] Ne halmok műszakilag felnőni is, igaz?

77
00:06:55,940 --> 00:07:01,100
Ez attól függ, mit értesz felnőni.

78
00:07:01,100 --> 00:07:04,010
A stack és heap mindig nő ellentétes irányban.

79
00:07:04,010 --> 00:07:09,420
A stack mindig nő fel abban az értelemben, hogy ez felnövő

80
00:07:09,420 --> 00:07:12,940
a magasabb memória címek, és a kupac egyre lefelé

81
00:07:12,940 --> 00:07:17,260
az, hogy ez egyre nagyobb az alacsonyabb memória címeket.

82
00:07:17,260 --> 00:07:20,250
Így a felső értéke 0 és az alsó nagy memória címeket.

83
00:07:20,250 --> 00:07:26,390
Ők mind a növekvő, csak ellentétes irányban.

84
00:07:26,390 --> 00:07:29,230
[Hallgató] Én csak azt jelentette, hogy azért, mert azt mondta, hogy fel stack az alsó

85
00:07:29,230 --> 00:07:33,640
mert úgy tűnik, sokkal intuitívabb mert a köteget kezdeni a tetején egy halom,

86
00:07:33,640 --> 00:07:37,520
kupac van a tetején önmagában is, így ez - >> Igen.

87
00:07:37,520 --> 00:07:44,960
Azt is gondolom, a halom, mint nőnek fel, és nagyobb, de a verem inkább.

88
00:07:44,960 --> 00:07:50,280
Tehát a verem az, hogy mi a fajta akarjuk mutatni felnőni.

89
00:07:50,280 --> 00:07:55,390
De mindenhol nézel másként fog mutatni a 0 címet a tetején

90
00:07:55,390 --> 00:07:59,590
és a legmagasabb memória cím az alján, így ez a szokásos kilátás memória.

91
00:07:59,590 --> 00:08:02,100
>> Van kérdése?

92
00:08:02,100 --> 00:08:04,270
[Hallgató] Elmondanád bővebben a kupac?

93
00:08:04,270 --> 00:08:06,180
Igen. Majd kap, hogy egy második.

94
00:08:06,180 --> 00:08:12,220
Először is, hogy miért megy vissza visszatérő és y egy rossz dolog,

95
00:08:12,220 --> 00:08:18,470
A verem van egy csomó köteg kereteket, amelyek képviselik az összes funkció

96
00:08:18,470 --> 00:08:20,460
amelyeket hívott.

97
00:08:20,460 --> 00:08:27,990
Szóval, figyelmen kívül hagyva a korábbi dolgokat, a tetején a verem mindig lesz a fő funkciója

98
00:08:27,990 --> 00:08:33,090
mivel ez az első funkció ez, hogy hívják.

99
00:08:33,090 --> 00:08:37,130
És amikor hívod másik funkció, a verem fog nőni lefelé.

100
00:08:37,130 --> 00:08:41,640
Tehát, ha hívom néhány funkció, ize, és ez lesz a saját stack frame,

101
00:08:41,640 --> 00:08:47,280
akkor hívhatjuk néhány funkció, bár, ez lesz a saját stack frame.

102
00:08:47,280 --> 00:08:49,840
És bár lehet, rekurzív és ez lehet hívni magát,

103
00:08:49,840 --> 00:08:54,150
és hogy a második hívást, hogy bar fog kapni a saját stack frame.

104
00:08:54,150 --> 00:08:58,880
És így, mi folyik ezeken a stack frame mind a lokális változók

105
00:08:58,880 --> 00:09:03,450
és az összes a függvény érvek -

106
00:09:03,450 --> 00:09:08,730
Minden olyan dolog, ami helyileg hatókörű ezt a funkciót menni ezen stack kereteket.

107
00:09:08,730 --> 00:09:21,520
Tehát ez azt jelenti, amikor azt mondtam, valami hasonlót bár egy olyan funkció,

108
00:09:21,520 --> 00:09:29,270
Én csak úgy állapítsa egész, majd visszatér a mutatót, hogy az egészre.

109
00:09:29,270 --> 00:09:33,790
Szóval, ha nem y él?

110
00:09:33,790 --> 00:09:36,900
[Hallgató] y él bar. >> [Bowden] Igen.

111
00:09:36,900 --> 00:09:45,010
Valahol ebben a kis négyzet memória egy Littler négyzet, amely y benne.

112
00:09:45,010 --> 00:09:53,370
Amikor visszatér és y, én vissza a mutatót ez a kis blokk memória.

113
00:09:53,370 --> 00:09:58,400
De aztán, amikor egy függvény visszatér, a verem kocka bukkant ki a köteget.

114
00:10:01,050 --> 00:10:03,530
És ezért hívják verem.

115
00:10:03,530 --> 00:10:06,570
Ez olyan, mint a verem adatszerkezet, ha tudod, mi az.

116
00:10:06,570 --> 00:10:11,580
Vagy akár, mint egy köteg tálcák mindig a példában

117
00:10:11,580 --> 00:10:16,060
Fő fog menni az alsó, majd az első funkció hívás fog menni a tetején, hogy a

118
00:10:16,060 --> 00:10:20,400
és akkor nem kap vissza a főoldalra, amíg vissza nem tér az összes funkciót, amely már az úgynevezett

119
00:10:20,400 --> 00:10:22,340
hogy kerültek a tetején.

120
00:10:22,340 --> 00:10:28,650
>> [Hallgató] Szóval, ha te ezt vissza és y, ez az érték van kitéve értesítés nélkül változhatnak.

121
00:10:28,650 --> 00:10:31,290
Igen, ez - >> [hallgató] Ez lehet felülírni. >> Igen.

122
00:10:31,290 --> 00:10:34,660
Ez teljesen - Ha megpróbálja, és -

123
00:10:34,660 --> 00:10:38,040
Ez is egy int * bar mert ez visszatérő a mutató,

124
00:10:38,040 --> 00:10:41,310
így a visszatérési típusa int *.

125
00:10:41,310 --> 00:10:46,500
Ha megpróbálja használni a visszatérési értéke ez a funkció, ez nem definiált viselkedést

126
00:10:46,500 --> 00:10:51,770
mert ez a mutató rossz memória. >> [Hallgató] Oké.

127
00:10:51,770 --> 00:11:01,250
Szóval, mi lenne, ha, például, ha bejelentett int * y = malloc (sizeof (int))?

128
00:11:01,250 --> 00:11:03,740
Így már jobb. Igen.

129
00:11:03,740 --> 00:11:07,730
[Hallgató] Beszéltünk arról, hogy hogyan, mikor húzza a dolgokat a kukába

130
00:11:07,730 --> 00:11:11,750
ők valójában nem törlik, mi csak elveszítik a mutatók.

131
00:11:11,750 --> 00:11:15,550
Tehát ebben az esetben tudunk valójában az érték törléséhez, vagy ez még mindig ott van a memóriában?

132
00:11:15,550 --> 00:11:19,130
A legtöbb esetben, ez lesz, hogy még mindig ott van.

133
00:11:19,130 --> 00:11:24,220
De tegyük fel, hogy mi történik, hogy hívja néhány más funkció, BAZ.

134
00:11:24,220 --> 00:11:28,990
Baz fog kapni a saját stack frame itt.

135
00:11:28,990 --> 00:11:31,470
Ez lesz felülírja az összes ezt a cuccot,

136
00:11:31,470 --> 00:11:34,180
majd ha később megpróbálja használni a mutatót, hogy van korábban,

137
00:11:34,180 --> 00:11:35,570
ez nem lesz ugyanaz az értéke.

138
00:11:35,570 --> 00:11:38,150
Ez lesz változott csak azért, mert az úgynevezett funkciót BAZ.

139
00:11:38,150 --> 00:11:43,080
[Hallgató] De még mi nem, akkor még mindig kap 3?

140
00:11:43,080 --> 00:11:44,990
[Bowden] Minden valószínűség szerint, ha lenne.

141
00:11:44,990 --> 00:11:49,670
De nem hivatkozhat erre. C Csak mondja definiált viselkedést.

142
00:11:49,670 --> 00:11:51,920
>> [Hallgató] Ó, igen. Oké.

143
00:11:51,920 --> 00:11:58,190
Tehát, ha vissza akar térni a mutatót, ez az, ahol malloc jön használatban.

144
00:12:00,930 --> 00:12:15,960
Írok valójában csak vissza malloc (3 * sizeof (int)).

145
00:12:17,360 --> 00:12:24,050
Menjünk át malloc látna egy második, de az ötlet malloc minden a helyi változók

146
00:12:24,050 --> 00:12:26,760
mindig megy a verem.

147
00:12:26,760 --> 00:12:31,570
Bármi, ami malloced megy a kupac, és ez örökké, és mindig a heap

148
00:12:31,570 --> 00:12:34,490
amíg kifejezetten nem szabad azt.

149
00:12:34,490 --> 00:12:42,130
Tehát ez azt jelenti, hogy ha malloc valamit, hogy fog túlélni után a függvény.

150
00:12:42,130 --> 00:12:46,800
[Hallgató] Vajon túléli után a program leáll? No. >>

151
00:12:46,800 --> 00:12:53,180
Oké, így lesz, amíg a program végig kész fut. >> Igen.

152
00:12:53,180 --> 00:12:57,510
Mi megy át részleteket, hogy mi történik, amikor a program leáll.

153
00:12:57,510 --> 00:13:02,150
Lehet, hogy emlékeztessen, de ez egy külön dolog teljesen.

154
00:13:02,150 --> 00:13:04,190
[Hallgató] Szóval malloc létrehoz egy pointer? >> Igen.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [hallgató] Azt hiszem malloc kijelöl egy memória blokkot, hogy a mutató használható.

156
00:13:15,400 --> 00:13:19,610
[Bowden] Azt akarom, hogy a diagram újra. >> [Hallgató] Szóval ez a funkció működik, igaz?

157
00:13:19,610 --> 00:13:26,430
[Hallgató] Ja, malloc jelöl egy memóriablokkot, hogy tudod használni,

158
00:13:26,430 --> 00:13:30,470
majd visszatér a címe az első blokk, hogy a memória.

159
00:13:30,470 --> 00:13:36,750
>> [Bowden] Igen. Tehát, ha malloc, akkor megragadta néhány memóriablokkot

160
00:13:36,750 --> 00:13:38,260
ez jelenleg a kupac.

161
00:13:38,260 --> 00:13:43,040
Ha a heap túl kicsi, akkor a halom éppen fog nőni, és ez növekszik ebben az irányban.

162
00:13:43,040 --> 00:13:44,650
Tehát mondjuk a heap túl kicsi.

163
00:13:44,650 --> 00:13:49,960
Akkor ez hamarosan nőni egy kicsit, és térjen vissza a mutatót ebben a mondatban, hogy csak nőtt.

164
00:13:49,960 --> 00:13:55,130
Ha ingyenes cucc, te hogy több hely a halom,

165
00:13:55,130 --> 00:14:00,030
így aztán egy későbbi telefonáljon a malloc tudja használni, hogy a memóriát, amit korábban felszabadította.

166
00:14:00,030 --> 00:14:09,950
Az a fontos dolog malloc és free, hogy ad teljes ellenőrzése

167
00:14:09,950 --> 00:14:12,700
élettartama ezeknek memória blokkokat.

168
00:14:12,700 --> 00:14:15,420
A globális változók mindig életben van.

169
00:14:15,420 --> 00:14:18,500
A helyi változók él e rendelkezések hatálya alá.

170
00:14:18,500 --> 00:14:22,140
Amint megy az elmúlt egy kapcsos zárójel, a helyi változók halott.

171
00:14:22,140 --> 00:14:28,890
Malloced emlékezet életben van, ha azt szeretné, hogy életben

172
00:14:28,890 --> 00:14:33,480
majd szabadul, amikor mondja, hogy fel kell szabadítani.

173
00:14:33,480 --> 00:14:38,420
Ezek valójában csak 3 típusú memória, tényleg.

174
00:14:38,420 --> 00:14:41,840
Van automatikus memória kezelése, ami a verem.

175
00:14:41,840 --> 00:14:43,840
Dolgok történnek automatikusan.

176
00:14:43,840 --> 00:14:46,910
Amikor azt mondja, int x, memóriát int x.

177
00:14:46,910 --> 00:14:51,630
Ha x kimegy a hatálya, memória regenerált az x.

178
00:14:51,630 --> 00:14:54,790
Aztán ott van a dinamikus memória kezelése, ami pedig malloc van,

179
00:14:54,790 --> 00:14:56,740
ami, ha van ellenőrzés.

180
00:14:56,740 --> 00:15:01,290
Ön dönti el, mikor dinamikusan memóriát kell, és nem kell felosztani.

181
00:15:01,290 --> 00:15:05,050
És akkor ott van a statikus, ami éppen azt jelenti, hogy él örökké,

182
00:15:05,050 --> 00:15:06,610
ami pedig a globális változók.

183
00:15:06,610 --> 00:15:10,240
Ők csak mindig a memóriában.

184
00:15:10,960 --> 00:15:12,760
>> Kérdései vannak?

185
00:15:14,490 --> 00:15:17,230
[Hallgató] Tud meg a blokk éppen használatával kapcsos zárójelek

186
00:15:17,230 --> 00:15:21,220
azonban nem rendelkezik, hogy egy if vagy while, vagy ilyesmi?

187
00:15:21,220 --> 00:15:29,130
Megadhatunk egy blokk, mint egy funkció, de ennek kapcsos zárójelek is.

188
00:15:29,130 --> 00:15:32,100
[Hallgató] Szóval nem lehet csak úgy tekintette, mint egy véletlen pár kapcsos zárójel a kódban

189
00:15:32,100 --> 00:15:35,680
amelyek lokális változók? >> Igen, lehet.

190
00:15:35,680 --> 00:15:45,900
Belül int bár tudtuk, hogy {int y = 3;}.

191
00:15:45,900 --> 00:15:48,440
Ez kéne, hogy igaza van.

192
00:15:48,440 --> 00:15:52,450
De ez teljesen hatályát határozza meg int y.

193
00:15:52,450 --> 00:15:57,320
Utána a második göndör merevítő, y nem használható többé.

194
00:15:57,910 --> 00:16:00,630
Majdnem soha nem, hogy mégis.

195
00:16:02,940 --> 00:16:07,370
Visszatérve, hogy mi történik, ha a program véget ér,

196
00:16:07,370 --> 00:16:18,760
van egyfajta tévhit / half hazugságot, hogy adunk ahhoz, hogy csak megkönnyítené a dolgokat.

197
00:16:18,760 --> 00:16:24,410
Azt mondjuk nektek, hogy ha memóriát

198
00:16:24,410 --> 00:16:29,860
Ön elosztásának néhány darabja a RAM, hogy változó.

199
00:16:29,860 --> 00:16:34,190
De te nem igazán közvetlenül érintő RAM valaha a programokat.

200
00:16:34,190 --> 00:16:37,490
Ha belegondolok, hogy én rajzoltam -

201
00:16:37,490 --> 00:16:44,330
És valóban, ha átmegy a GDB látni fogod, ugyanaz a dolog.

202
00:16:51,120 --> 00:16:57,590
Függetlenül attól, hogy hányszor fut a program, illetve milyen programot futtat,

203
00:16:57,590 --> 00:16:59,950
a verem mindig fog kezdeni -

204
00:16:59,950 --> 00:17:06,510
te mindig fog látni változók körül címet oxbffff valamit.

205
00:17:06,510 --> 00:17:09,470
Ez általában valahol a régióban.

206
00:17:09,470 --> 00:17:18,760
De hogyan lehet 2 program esetleg van mutatókat azonos memória?

207
00:17:20,640 --> 00:17:27,650
[Hallgató] Van valami önkényes kijelölése, ahol oxbfff állítólag a RAM

208
00:17:27,650 --> 00:17:31,320
hogy is lehet különböző helyeken attól függően, hogy a funkció nevezték.

209
00:17:31,320 --> 00:17:35,920
Igen. A kifejezés a virtuális memória.

210
00:17:35,920 --> 00:17:42,250
Az elképzelés az, hogy minden egyes folyamat, minden egyes program, amely fut a számítógépen

211
00:17:42,250 --> 00:17:49,450
saját - tegyük fel, 32 bit - teljesen független címtartomány.

212
00:17:49,450 --> 00:17:51,590
Ez a címtartomány.

213
00:17:51,590 --> 00:17:56,220
Megvan a saját teljesen független 4 gigabájt használni.

214
00:17:56,220 --> 00:18:02,220
>> Tehát, ha futtatni 2 programot párhuzamosan, ez a program úgy látja, 4 gigabyte magának,

215
00:18:02,220 --> 00:18:04,870
ez a program úgy látja, 4 gigabyte magának,

216
00:18:04,870 --> 00:18:07,720
és lehetetlen, hogy e program dereference a mutatót

217
00:18:07,720 --> 00:18:10,920
és a végén a memória el ezt a programot.

218
00:18:10,920 --> 00:18:18,200
És mi a virtuális memória egy leképezés a folyamatok címtartomány

219
00:18:18,200 --> 00:18:20,470
tényleges dolgokat RAM.

220
00:18:20,470 --> 00:18:22,940
Tehát akár az operációs rendszer tudni, hogy

221
00:18:22,940 --> 00:18:28,080
Hé, mikor ez a fickó dereferences pointer oxbfff, hogy valójában azt jelenti,

222
00:18:28,080 --> 00:18:31,040
hogy ő akar RAM byte 1000,

223
00:18:31,040 --> 00:18:38,150
mivel ha ez a program dereferences oxbfff, hogy tényleg akar RAM byte 10000.

224
00:18:38,150 --> 00:18:41,590
Lehetnek tetszőlegesen távol egymástól.

225
00:18:41,590 --> 00:18:48,730
Ez még akkor is igaz, a dolgok egyetlen folyamatok címtartomány.

226
00:18:48,730 --> 00:18:54,770
Szóval, mint látja mind a 4 gigabyte magának, hanem mondjuk -

227
00:18:54,770 --> 00:18:57,290
[Hallgató] Vajon minden egyes folyamat -

228
00:18:57,290 --> 00:19:01,350
Tegyük fel, hogy van egy számítógép, csak 4 GB RAM-mal.

229
00:19:01,350 --> 00:19:06,430
Vajon minden egyes folyamat látni az egész 4 gigabyte? >> Igen.

230
00:19:06,430 --> 00:19:13,060
De a 4 gigabájt látja hazugság.

231
00:19:13,060 --> 00:19:20,460
Ez csak azt hiszi, hogy az összes ezt a memóriát, mert nem ismerek más eljárás létezik.

232
00:19:20,460 --> 00:19:28,140
Ez csak használni sok memóriát, mint amilyen valójában szüksége van.

233
00:19:28,140 --> 00:19:32,340
Az operációs rendszer nem fogja adni RAM ennek a folyamatnak

234
00:19:32,340 --> 00:19:35,750
ha ez nem használ semmilyen memória az egész régióban.

235
00:19:35,750 --> 00:19:39,300
Ez nem fog adni neki memóriát a régióban.

236
00:19:39,300 --> 00:19:54,780
De az ötlet, hogy - próbálok arra gondolni - nem tudok gondolni egy hasonlat.

237
00:19:54,780 --> 00:19:56,780
Analógiák nehéz.

238
00:19:57,740 --> 00:20:02,700
Az egyik kérdés a virtuális memória, vagy az egyik dolog, ez megoldás

239
00:20:02,700 --> 00:20:06,810
az, hogy a folyamatok teljesen tisztában egymást.

240
00:20:06,810 --> 00:20:12,140
És így írhatsz bármilyen program, hogy csak dereferences bármely mutató,

241
00:20:12,140 --> 00:20:19,340
mint csak írni egy programot, amely azt mondja, * (ox1234)

242
00:20:19,340 --> 00:20:22,890
és ez dereferencing memória cím 1234.

243
00:20:22,890 --> 00:20:28,870
>> De ez fel az operációs rendszert, majd lefordítani, amit 1234 jelent.

244
00:20:28,870 --> 00:20:33,960
Tehát, ha 1234 történik, hogy egy érvényes memóriacím ezt a folyamatot,

245
00:20:33,960 --> 00:20:38,800
mintha ez a verem, vagy valami, akkor ez vissza fog térni az értékét, hogy a memória cím

246
00:20:38,800 --> 00:20:41,960
amennyire a folyamat tudja.

247
00:20:41,960 --> 00:20:47,520
De ha 1234 nem egy érvényes címet, mint ez történik a partra

248
00:20:47,520 --> 00:20:52,910
néhány kis darab memória itt, hogy túl van a verem, és azon túl a heap

249
00:20:52,910 --> 00:20:57,200
, és még nem igazán használható, hogy akkor ez, ha kap ilyeneket segfaultol

250
00:20:57,200 --> 00:21:00,260
mert te megható memóriát, hogy nem kell érjen.

251
00:21:07,180 --> 00:21:09,340
Ez akkor is igaz -

252
00:21:09,340 --> 00:21:15,440
A 32-bites rendszer, 32 bit azt jelenti, hogy 32 bites, hogy meghatározzák a memória címet.

253
00:21:15,440 --> 00:21:22,970
Ez az, amiért pointers 8 bájt, mert 32 bit 8 bájt - vagy 4 bájt.

254
00:21:22,970 --> 00:21:25,250
Mutatók a 4 byte.

255
00:21:25,250 --> 00:21:33,680
Tehát, ha látsz egy mutatót, mint oxbfffff, azaz -

256
00:21:33,680 --> 00:21:40,080
Keretében adott programban, ha csak építeni tetszőleges mutató,

257
00:21:40,080 --> 00:21:46,330
bárhol ox0 az ökör 8 f's - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[Hallgató] Nem azt mondtad, ők 4 byte? >> Igen.

259
00:21:49,180 --> 00:21:52,730
[Hallgató] Ezután minden byte lesz - >> [Bowden] Hexadecimális.

260
00:21:52,730 --> 00:21:59,360
Hexadecimális - 5, 6, 7, 8. Szóval pointers fogsz mindig látni hexadecimális.

261
00:21:59,360 --> 00:22:01,710
Csak hogyan osztályozzák mutatók.

262
00:22:01,710 --> 00:22:05,240
Minden 2 jegyű hexadecimális értéke 1 byte.

263
00:22:05,240 --> 00:22:09,600
Tehát ott lesz 8 hexadecimális számjegy, 4 bájt.

264
00:22:09,600 --> 00:22:14,190
Tehát minden egyes mutató a 32-bites rendszer lesz 4 byte,

265
00:22:14,190 --> 00:22:18,550
ami azt jelenti, hogy a folyamat lehet építeni önkényes 4 bájt

266
00:22:18,550 --> 00:22:20,550
és egy mutatót belőle,

267
00:22:20,550 --> 00:22:32,730
ami azt jelenti, hogy amennyire ez tudomása, akkor kezelni egy egész 2 a 32 bájt memóriát.

268
00:22:32,730 --> 00:22:34,760
Annak ellenére, hogy nem igazán férhet hozzá, hogy a

269
00:22:34,760 --> 00:22:40,190
még akkor is, ha a számítógép csak 512 megabájt, azt hiszi, hogy van, hogy mennyi memória.

270
00:22:40,190 --> 00:22:44,930
És az operációs rendszer elég okos ahhoz, hogy ez csak akkor nyújtanak amire valójában szüksége van.

271
00:22:44,930 --> 00:22:49,630
Ez nem csak menj, oh, egy új folyamat: 4 koncertek.

272
00:22:49,630 --> 00:22:51,930
>> Igen. >> [Hallgató] Mit jelent az ökör jelent? Miért írsz meg?

273
00:22:51,930 --> 00:22:54,980
Ez csak a szimbólum hexadecimális.

274
00:22:54,980 --> 00:22:59,590
Ha látsz egy számot kezdődik ökör, az egymást követő dolgok hexadecimális.

275
00:23:01,930 --> 00:23:05,760
[Hallgató] Maga elmagyarázza, hogy mi történik akkor, ha a program véget ér. >> Igen.

276
00:23:05,760 --> 00:23:09,480
Mi történik, ha a program véget ér az operációs rendszer

277
00:23:09,480 --> 00:23:13,600
csak törli a leképezések, hogy rendelkezik az ezeket a címeket, és ennyi.

278
00:23:13,600 --> 00:23:17,770
Az operációs rendszer már csak így, hogy a memória egy másik program használja.

279
00:23:17,770 --> 00:23:19,490
[Hallgató] Oké.

280
00:23:19,490 --> 00:23:24,800
Tehát, ha valami kiosztani a halom, vagy a kéményből vagy globális változók, vagy ilyesmi,

281
00:23:24,800 --> 00:23:27,010
ők minden csak eltűnik, amint a program vége

282
00:23:27,010 --> 00:23:32,120
mert az operációs rendszer most szabad adni, hogy a memória más folyamat.

283
00:23:32,120 --> 00:23:35,150
[Hallgató] Annak ellenére, hogy valószínűleg még értékeket írva? >> Igen.

284
00:23:35,150 --> 00:23:37,740
Az értékek valószínűleg még mindig ott van.

285
00:23:37,740 --> 00:23:41,570
Ez csak akkor lesz nehéz, hogy őket.

286
00:23:41,570 --> 00:23:45,230
Ez sokkal nehezebb, hogy őket, mint az, hogy egy törölt fájl

287
00:23:45,230 --> 00:23:51,450
mert a törölt fájl fajta ül ott egy hosszú idő, és a merevlemez-meghajtó sokkal nagyobb.

288
00:23:51,450 --> 00:23:54,120
Így fog felülírni különböző részein a memória

289
00:23:54,120 --> 00:23:58,640
előtt történik, hogy felülírja a darab memória, hogy a fájl alkalmazott lenni.

290
00:23:58,640 --> 00:24:04,520
De a fő memória, RAM, a ciklus egy sokkal gyorsabb,

291
00:24:04,520 --> 00:24:08,040
így fog nagyon gyorsan lehet felülírni.

292
00:24:10,300 --> 00:24:13,340
Kérdések az ezen vagy bármi mást?

293
00:24:13,340 --> 00:24:16,130
[Hallgató] Van kérdése van egy másik téma. >> Oké.

294
00:24:16,130 --> 00:24:19,060
Van valakinek kérdése ezzel kapcsolatban?

295
00:24:20,170 --> 00:24:23,120
>> Oké. Különböző téma. >> [Hallgató] Oké.

296
00:24:23,120 --> 00:24:26,550
Mentem keresztül néhány gyakorlati teszteket,

297
00:24:26,550 --> 00:24:30,480
és az egyik közülük, hogy beszélt a sizeof

298
00:24:30,480 --> 00:24:35,630
és az érték, hogy visszatér, vagy különböző változó típusok. >> Igen.

299
00:24:35,630 --> 00:24:45,060
És azt mondta, hogy mind a két int és a hosszú megtérülési 4, így mindketten 4 byte hosszú.

300
00:24:45,060 --> 00:24:48,070
Van-e különbség az int, és egy hosszú, vagy ez ugyanaz a dolog?

301
00:24:48,070 --> 00:24:50,380
Igen, van egy különbség.

302
00:24:50,380 --> 00:24:52,960
A C standard -

303
00:24:52,960 --> 00:24:54,950
Én valószínűleg meg is összezavar.

304
00:24:54,950 --> 00:24:58,800
A C szabvány, mint amit a C, a hivatalos dokumentáció C.

305
00:24:58,800 --> 00:25:00,340
Ez az, amit mond.

306
00:25:00,340 --> 00:25:08,650
Tehát a C szabvány, csak azt mondja, hogy a char örökre és mindig 1 byte.

307
00:25:10,470 --> 00:25:19,040
Minden, azután, hogy az - a rövid mindig csak a meghatározás szerint nagyobb, vagy egyenlő, mint egy kar.

308
00:25:19,040 --> 00:25:23,010
Erre akkor lehet szigorúan nagyobb, mint, de nem pozitív.

309
00:25:23,010 --> 00:25:31,940
Int éppen meghatározás szerint nagyobb, vagy egyenlő, mint egy rövid.

310
00:25:31,940 --> 00:25:36,210
És hosszú éppen meghatározás szerint nagyobb, vagy egyenlő, mint egy int.

311
00:25:36,210 --> 00:25:41,600
És egy hosszú, hosszú nagyobb vagy egyenlő, mint egy hosszú.

312
00:25:41,600 --> 00:25:46,610
Tehát az egyetlen dolog, amit a C szabvány meghatározza a relatív rendelni mindent.

313
00:25:46,610 --> 00:25:54,880
A tényleges memória, hogy a dolgok megkezdésének általában legfeljebb végrehajtását,

314
00:25:54,880 --> 00:25:57,640
de ez elég jól definiált ezen a ponton. >> [Hallgató] Oké.

315
00:25:57,640 --> 00:26:02,490
Tehát rövidnadrág szinte mindig lesz 2 bájt.

316
00:26:04,920 --> 00:26:09,950
Ints szinte mindig lesz 4 bájt.

317
00:26:12,070 --> 00:26:15,340
Long long szinte mindig lesz 8 bájt.

318
00:26:17,990 --> 00:26:23,160
És arra vágyik, hogy attól függ, hogy te egy 32-bites vagy 64-bites rendszer.

319
00:26:23,160 --> 00:26:27,450
Tehát egy hosszú fog megfelelnek a rendszer típusa.

320
00:26:27,450 --> 00:26:31,920
Ha használja a 32-bites rendszer, mint a gép, ez lesz 4 bájt.

321
00:26:34,530 --> 00:26:42,570
Ha használja a 64-bites, mint egy csomó a legutóbbi számítógépek, ez lesz 8 bájt.

322
00:26:42,570 --> 00:26:45,230
>> Ints szinte mindig 4 bájt ezen a ponton.

323
00:26:45,230 --> 00:26:47,140
Long long szinte mindig 8 bájt.

324
00:26:47,140 --> 00:26:50,300
A múltban, ints használt, hogy csak akkor 2 bájt.

325
00:26:50,300 --> 00:26:56,840
De észre, hogy ez teljes mértékben megfelel mindezen kapcsolatok nagyobb és egyenlő.

326
00:26:56,840 --> 00:27:01,280
Mindaddig, amíg tökéletesen megengedett, hogy az azonos méretű, mint egy egész szám,

327
00:27:01,280 --> 00:27:04,030
és ez is lehetővé tette, hogy az azonos méretű, mint egy hosszú, hosszú.

328
00:27:04,030 --> 00:27:11,070
És ez csak azért történik, hogy lehet, hogy a 99,999%-os rendszerek, ez lesz egyenlő

329
00:27:11,070 --> 00:27:15,800
vagy egy int, vagy egy hosszú, hosszú. Ez csak attól függ, hogy 32-bites vagy 64-bites. >> [Hallgató] Oké.

330
00:27:15,800 --> 00:27:24,600
Az úszók, hogyan tizedespont kijelölt szempontjából bit?

331
00:27:24,600 --> 00:27:27,160
Mint bináris? >> Igen.

332
00:27:27,160 --> 00:27:30,570
Önnek nem kell tudni, hogy a CS50.

333
00:27:30,570 --> 00:27:32,960
Még csak nem is tanulnak, hogy a 61.

334
00:27:32,960 --> 00:27:37,350
Nem tanulnak, hogy tényleg minden tanfolyamot.

335
00:27:37,350 --> 00:27:42,740
Ez csak egy képviseletet.

336
00:27:42,740 --> 00:27:45,440
Elfelejtettem a pontos bit veteményeskertek.

337
00:27:45,440 --> 00:27:53,380
Az az elképzelés, lebegőpontos, hogy te kiosztani egy bizonyos számú bitet, hogy képviselje -

338
00:27:53,380 --> 00:27:56,550
Alapvetően, minden tudományos jelöléssel.

339
00:27:56,550 --> 00:28:05,600
Szóval kiosztani egy bizonyos számú bitet, hogy képviselje a szám maga, mint 1,2345.

340
00:28:05,600 --> 00:28:10,200
Én soha nem képviselnek több számjegy 5-nél.

341
00:28:12,200 --> 00:28:26,300
Akkor is jelöl egy bizonyos számú bitet úgy, hogy inkább legyen, mint

342
00:28:26,300 --> 00:28:32,810
akkor csak megy egy bizonyos számot, mint például ez a legnagyobb kitevő akkor van,

343
00:28:32,810 --> 00:28:36,190
és akkor csak menj le egy bizonyos kitevő

344
00:28:36,190 --> 00:28:38,770
tetszik ez a legkisebb kitev lehetőség van.

345
00:28:38,770 --> 00:28:44,410
>> Nem emlékszem a pontos módját bit hozzárendelve az összes ezeket az értékeket

346
00:28:44,410 --> 00:28:47,940
de egy bizonyos számú bitet szentelt 1,2345,

347
00:28:47,940 --> 00:28:50,930
másik bizonyos számú bit elkötelezett a kitevő

348
00:28:50,930 --> 00:28:55,670
és ez csak akkor lehetséges, hogy képviselje exponens egy bizonyos méretet.

349
00:28:55,670 --> 00:29:01,100
[Hallgató] És egy kettős? Olyan, mint egy extra hosszú float? >> Igen.

350
00:29:01,100 --> 00:29:07,940
Ez ugyanaz, mint a float kivéve, most meg a 8 bájt helyett 4 byte.

351
00:29:07,940 --> 00:29:11,960
Most akkor hogy képes legyen használni 9 számjegy vagy 10 számjegy,

352
00:29:11,960 --> 00:29:16,630
és ez lesz képes menni akár 300 100 helyett. >> [Hallgató] Oké.

353
00:29:16,630 --> 00:29:21,550
És úszók is 4 byte. >> Igen.

354
00:29:21,550 --> 00:29:27,520
Nos, újra, valószínűleg attól átfogó általános végrehajtására,

355
00:29:27,520 --> 00:29:30,610
de úszók a 4 byte, kétágyas Jelenleg 8.

356
00:29:30,610 --> 00:29:33,440
Páros nevezzük dupla, mert dupla méretű úszók.

357
00:29:33,440 --> 00:29:38,380
[Hallgató] Oké. És ott vannak dupla páros? >> Nincsenek.

358
00:29:38,380 --> 00:29:43,660
Azt hiszem - >> [hallgató] Like hosszú long? >> Igen. Nem hiszem. Igen.

359
00:29:43,660 --> 00:29:45,950
[Hallgató] A tavalyi teszt volt egy kérdés, ami a fő funkciója

360
00:29:45,950 --> 00:29:49,490
tekintettel is részt vesz a programban.

361
00:29:49,490 --> 00:29:52,310
A válasz az volt, hogy nem kell részt venni a programban.

362
00:29:52,310 --> 00:29:55,100
Milyen helyzetben? Ez az, amit láttam.

363
00:29:55,100 --> 00:29:59,090
[Bowden] Úgy tűnik - >> [hallgató] Mi helyzet?

364
00:29:59,090 --> 00:30:02,880
Megvan a probléma? >> [Hallgató] Igen, én is határozottan húzza fel.

365
00:30:02,880 --> 00:30:07,910
Nem kell, technikailag, de alapvetően ez lesz.

366
00:30:07,910 --> 00:30:10,030
[Hallgató] láttam egyet egy másik év.

367
00:30:10,030 --> 00:30:16,220
Olyan volt, mint igaz vagy hamis: Egy érvényes - >> Oh, a. C fájlt?

368
00:30:16,220 --> 00:30:18,790
[Hallgató] Minden. C fájlban kell, hogy - [a két beszélő egyszerre - érthetetlen]

369
00:30:18,790 --> 00:30:21,120
Oké. Szóval ez külön.

370
00:30:21,120 --> 00:30:26,800
>> A. C fájl csak tartalmaznia kell funkciókat.

371
00:30:26,800 --> 00:30:32,400
Tudod összeállít egy fájlt gépi kód, bináris, bármi,

372
00:30:32,400 --> 00:30:36,620
anélkül, hogy futtatható még.

373
00:30:36,620 --> 00:30:39,420
Egy érvényes végrehajtható kell a fő funkciója.

374
00:30:39,420 --> 00:30:45,460
Írhat 100 funkciók 1 fájl, de nem fő

375
00:30:45,460 --> 00:30:48,800
majd fordítani, hogy le bináris,

376
00:30:48,800 --> 00:30:54,460
akkor írjunk egy fájlt, csak fő, de felhívja egy csomó ezeket a funkciókat

377
00:30:54,460 --> 00:30:56,720
e bináris fájl itt.

378
00:30:56,720 --> 00:31:01,240
És amikor így végrehajtható, ez az, amit a linker nem

379
00:31:01,240 --> 00:31:05,960
van az, egyesíti ezeket a 2 bináris fájlokat egy futtatható.

380
00:31:05,960 --> 00:31:11,400
Tehát a. C fájl nem kell, hogy a fő funkciója egyáltalán.

381
00:31:11,400 --> 00:31:19,220
És nagy-kód bázisok látni fogod, több ezer. C fájlok és 1 fő fájlt.

382
00:31:23,960 --> 00:31:26,110
További kérdések?

383
00:31:29,310 --> 00:31:31,940
[Hallgató] Volt egy másik kérdés.

384
00:31:31,940 --> 00:31:36,710
Azt mondta, hogy egy fordító. Igaz vagy hamis?

385
00:31:36,710 --> 00:31:42,030
És a válasz hamis volt, és megértettem, hogy miért nem olyan, mint csenget.

386
00:31:42,030 --> 00:31:44,770
De mit nevezünk, hogy ha ez nem?

387
00:31:44,770 --> 00:31:49,990
Győződjön meg alapvetően csak - Látom, mit nevez meg.

388
00:31:49,990 --> 00:31:52,410
De ez csak fut parancsokat.

389
00:31:53,650 --> 00:31:55,650
Győződjön meg.

390
00:31:58,240 --> 00:32:00,870
Tudom húzni ezt. Igen.

391
00:32:10,110 --> 00:32:13,180
Ó, igen. Győződjön meg is csinálja.

392
00:32:13,180 --> 00:32:17,170
Ez azt mondja, a célja a make segédprogram meghatározni automatikusan

393
00:32:17,170 --> 00:32:19,610
amely darab egy nagy program kell újrafordítani

394
00:32:19,610 --> 00:32:22,350
és kiadja a parancsokat újrafordítani őket.

395
00:32:22,350 --> 00:32:27,690
Tudod, hogy hogy a fájlok teljesen hatalmas.

396
00:32:27,690 --> 00:32:33,210
Érezd néz a időbélyegeket fájlok, és mint azt már korábban említettük,

397
00:32:33,210 --> 00:32:36,930
tudja fordítani az egyes fájlokat le, és ez nem, amíg nem kap a linker

398
00:32:36,930 --> 00:32:39,270
hogy ők össze egy futtatható.

399
00:32:39,270 --> 00:32:43,810
Tehát, ha 10 különböző fájlokat, és csinál változás 1 őket,

400
00:32:43,810 --> 00:32:47,870
akkor mi make fog tenni csak újrafordítás, hogy 1 fájl

401
00:32:47,870 --> 00:32:50,640
és utána átszerkeszthesse mindent együtt.

402
00:32:50,640 --> 00:32:53,020
De ez sokkal ostobább, mint ezt.

403
00:32:53,020 --> 00:32:55,690
Ez rajtad múlik, hogy teljesen meg, hogy ez mit kell tennie.

404
00:32:55,690 --> 00:32:59,560
Ez alapértelmezésben a képességét, hogy ismerje el ezt időbélyegző cucc,

405
00:32:59,560 --> 00:33:03,220
de akkor írj egy make fájlt semmit.

406
00:33:03,220 --> 00:33:09,150
Írhatsz egy make fájlt, így amikor begépeli hogy ez csak a CD egy másik könyvtárba.

407
00:33:09,150 --> 00:33:15,560
Kezdtem csalódott, mert mindent tack belsejében az én Appliance

408
00:33:15,560 --> 00:33:21,740
és aztán többet a PDF a Mac.

409
00:33:21,740 --> 00:33:30,720
>> Szóval megy Finder és én nem megy, Connect to Server,

410
00:33:30,720 --> 00:33:36,950
és a szerver I csatlakozni az én Appliance, aztán megnyitja a PDF

411
00:33:36,950 --> 00:33:40,190
hogy lesz összeállított LaTeX.

412
00:33:40,190 --> 00:33:49,320
De én egyre csalódott, mert minden egyes alkalommal, amikor szükség van, hogy frissítse a PDF,

413
00:33:49,320 --> 00:33:53,900
Kellett másolni egy adott könyvtárba lehetett elérni

414
00:33:53,900 --> 00:33:57,710
és azt egyre bosszantó.

415
00:33:57,710 --> 00:34:02,650
Tehát ahelyett, hogy írtam egy make fájlt, amelyben meg kell határozni, hogyan teszi a dolgokat.

416
00:34:02,650 --> 00:34:06,130
Hogyan csinál ebben a PDF LaTeX.

417
00:34:06,130 --> 00:34:10,090
Csakúgy, mint minden más gyártmányt fájlt, vagy - Azt hiszem, még nem látta a make fájlokat,

418
00:34:10,090 --> 00:34:13,510
de van a gép egy globális márka fájlt, hogy csak azt mondja,

419
00:34:13,510 --> 00:34:16,679
ha összeállításának C fájlt, használja csenget.

420
00:34:16,679 --> 00:34:20,960
És itt van az én make fájlban teszek mondom,

421
00:34:20,960 --> 00:34:25,020
ezt a fájlt fogsz kíván fordítani a PDF LaTeX.

422
00:34:25,020 --> 00:34:27,889
És ez így van a PDF LaTeX hogy csinál a fordítás.

423
00:34:27,889 --> 00:34:31,880
Győződjön meg nem összeállításánál. Ez csak futó ezeket a parancsokat a sorozatban I megadva.

424
00:34:31,880 --> 00:34:36,110
Így fut PDF LaTeX, akkor azt bemásolja a könyvtárat Azt akarom, hogy kell másolni,

425
00:34:36,110 --> 00:34:38,270
ez a cd a könyvtárba, és nem más dolog,

426
00:34:38,270 --> 00:34:42,380
de ez nem az elismerését, ha egy fájl megváltozik,

427
00:34:42,380 --> 00:34:45,489
és ha megváltoztatja, akkor fog futni a parancsokat, hogy kéne futtatni

428
00:34:45,489 --> 00:34:48,760
a fájl változásokat. >> [Hallgató] Oké.

429
00:34:50,510 --> 00:34:54,420
Nem tudom, hol a globális márka fájlok nekem, hogy nézd meg.

430
00:34:57,210 --> 00:35:04,290
Egyéb kérdés? Bármi korábbi vetélkedők? Minden mutató dolgokat?

431
00:35:06,200 --> 00:35:08,730
Vannak apró dolgok, mint a mutató -

432
00:35:08,730 --> 00:35:10,220
Én nem lesz képes megtalálni a kvíz kérdés, hogy -

433
00:35:10,220 --> 00:35:16,250
de csak, mint ez a fajta dolog.

434
00:35:19,680 --> 00:35:24,060
Győződjön meg arról, hogy érti, amikor azt mondom int * x * y -

435
00:35:24,890 --> 00:35:28,130
Ez nem éppen itt semmit, azt hiszem.

436
00:35:28,130 --> 00:35:32,140
De mint * x * y, azok 2 változó, amelyek a verem.

437
00:35:32,140 --> 00:35:37,220
Amikor azt mondom, x = malloc (sizeof (int)), x még mindig változó a stack,

438
00:35:37,220 --> 00:35:41,180
malloc van néhány mondat át a halom, és mi tekintettel x ponttól a kupac.

439
00:35:41,180 --> 00:35:43,900
>> Tehát valami a veremben pont a kupac.

440
00:35:43,900 --> 00:35:48,100
Amikor malloc valamit, akkor óhatatlanul tárolja belsejében egy mutató.

441
00:35:48,100 --> 00:35:55,940
Annak érdekében, hogy pointer van a verem, a malloced blokk van a kupac.

442
00:35:55,940 --> 00:36:01,240
Sokan összezavarodnak, és azt mondják int * x = malloc, x van a kupac.

443
00:36:01,240 --> 00:36:04,100
Ne. Mit x mutat van a kupac.

444
00:36:04,100 --> 00:36:08,540
x maga a verem, kivéve, ha valamilyen oknál fogva már x egy globális változó,

445
00:36:08,540 --> 00:36:11,960
ebben az esetben történik, hogy egy másik régióban memória.

446
00:36:13,450 --> 00:36:20,820
Így nyomon követése, ezek a doboz és a nyíl diagramok elég gyakori a kvíz.

447
00:36:20,820 --> 00:36:25,740
Vagy ha ez nem kvíz 0, akkor lesz a kvíz 1.

448
00:36:27,570 --> 00:36:31,940
Tudnia kell, hogy az összes ilyen, a lépések összeállításában

449
00:36:31,940 --> 00:36:35,740
mivel meg kellett, hogy kérdésekre válaszoljon ezekre. Igen.

450
00:36:35,740 --> 00:36:38,940
[Hallgató] sikerült menjünk át ezeket a lépéseket - >> Persze.

451
00:36:48,340 --> 00:36:58,640
Mielőtt lépések és összeállítása van előfeldolgozás,

452
00:36:58,640 --> 00:37:16,750
összeállítása, összeszerelés, és összekapcsolása.

453
00:37:16,750 --> 00:37:21,480
Előfeldolgozó. Mit tegyek?

454
00:37:29,720 --> 00:37:32,290
Ez a legegyszerűbb lépés - nos, nem úgy, mint -

455
00:37:32,290 --> 00:37:35,770
ez nem jelenti azt, hogy nyilvánvalónak kellene lennie, de ez a legegyszerűbb lépés.

456
00:37:35,770 --> 00:37:38,410
Ti is végrehajtja magatokat. Igen.

457
00:37:38,410 --> 00:37:43,410
[Hallgató] Vegyünk mi van a részét, mint ez, és másolja és akkor is meghatározza.

458
00:37:43,410 --> 00:37:49,250
Úgy néz ki a dolgok, mint a # include és # define,

459
00:37:49,250 --> 00:37:53,800
és ez csak másolatok és paszták mik azok valójában jelent.

460
00:37:53,800 --> 00:37:59,240
Tehát, ha azt mondod: # include cs50.h az előfeldolgozó a másolás és beillesztés cs50.h

461
00:37:59,240 --> 00:38:01,030
abba a vonalat.

462
00:38:01,030 --> 00:38:06,640
Amikor azt mondod # define x legyen 4, az előfeldolgozó megy keresztül az egész programot

463
00:38:06,640 --> 00:38:10,400
és felváltja az összes példányait x, 4.

464
00:38:10,400 --> 00:38:17,530
Tehát a előfeldolgozó vesz egy érvényes C fájlt, és kiad egy érvényes C fájl

465
00:38:17,530 --> 00:38:20,300
ahol a dolgok már a vágólapra másolni.

466
00:38:20,300 --> 00:38:24,230
Tehát most összeállításában. Mit tegyek?

467
00:38:25,940 --> 00:38:28,210
[Hallgató] Ez megy C bináris.

468
00:38:28,210 --> 00:38:30,970
>> [Bowden] Ez nem megy egészen a bináris.

469
00:38:30,970 --> 00:38:34,220
[Hallgató] A gépi kódot, majd? >> Ez nem gépi kódot.

470
00:38:34,220 --> 00:38:35,700
[Hallgató] Assembly? >> Közgyűlésnek.

471
00:38:35,700 --> 00:38:38,890
Megy összeszerelés előtt megy egészen a C kód,

472
00:38:38,890 --> 00:38:45,010
és a legtöbb nyelven ilyet.

473
00:38:47,740 --> 00:38:50,590
Válassz olyan magas szintű nyelv, és ha akarsz fordítani,

474
00:38:50,590 --> 00:38:52,390
ez valószínűleg összeállításához lépésenként.

475
00:38:52,390 --> 00:38:58,140
Először fog összeállítani Python a C, akkor fog összeállítani C Közgyűlés

476
00:38:58,140 --> 00:39:01,600
majd a Közgyűlés megy kap lefordítva a bináris.

477
00:39:01,600 --> 00:39:07,800
Szóval összeállítása fogja hozni azt a C és Assembly.

478
00:39:07,800 --> 00:39:12,130
A szó összeállításának általában azt jelenti, így azt egy magasabb szintű

479
00:39:12,130 --> 00:39:14,340
egy alacsonyabb szintű programozási nyelv.

480
00:39:14,340 --> 00:39:19,190
Szóval ez az egyetlen lépés összeállítás, ahol kezdeni egy magas szintű nyelv

481
00:39:19,190 --> 00:39:23,270
és a végén egy alacsony szintű nyelv, és ezért a lépést nevezik összeállításában.

482
00:39:25,280 --> 00:39:33,370
[Hallgató] összeállítása során, mondjuk, hogy tettél # include cs50.h.

483
00:39:33,370 --> 00:39:42,190
Vajon a fordító újrafordítani a cs50.h, mint a funkciók, amelyek ott,

484
00:39:42,190 --> 00:39:45,280
és lefordítani, hogy a közgyűlés kódot is,

485
00:39:45,280 --> 00:39:50,830
vagy fog másolja valamit, ami volt pre-közgyűlés?

486
00:39:50,830 --> 00:39:56,910
cs50.h fog nagyjából soha végén a közgyűlés.

487
00:39:59,740 --> 00:40:03,680
Stuff, mint a függvény prototípusokat, és a dolgok csak az Ön számára, hogy legyen óvatos.

488
00:40:03,680 --> 00:40:09,270
Ez garantálja, hogy a fordító megtekintéséhez dolgokat, mint te hívásfunkciók

489
00:40:09,270 --> 00:40:12,910
a megfelelő visszatérési típusa és a megfelelő érveket, meg ilyesmi.

490
00:40:12,910 --> 00:40:18,350
>> Szóval cs50.h kerül előfeldolgozott a fájlt, majd amikor ez összeállítása

491
00:40:18,350 --> 00:40:22,310
ez gyakorlatilag kidobott miután gondoskodik arról, hogy mindent hívott helyesen.

492
00:40:22,310 --> 00:40:29,410
De a funkciók meghatározott CS50 könyvtár, amelyek elkülönülnek cs50.h,

493
00:40:29,410 --> 00:40:33,610
ezek nem lesznek külön összeállítani.

494
00:40:33,610 --> 00:40:37,270
Ez valóban lejön az összekötő lépésben, így lesz, hogy, hogy egy második.

495
00:40:37,270 --> 00:40:40,100
De először is, mi összeszerelés?

496
00:40:41,850 --> 00:40:44,500
[Hallgató] Assembly bináris? >> Igen.

497
00:40:46,300 --> 00:40:48,190
Összeszerelése.

498
00:40:48,190 --> 00:40:54,710
Nem nevezném összeállításáért mert Assembly nagyjából tiszta fordítását bináris.

499
00:40:54,710 --> 00:41:00,230
Nagyon kevés logika megy a Közgyűlést, hogy bináris.

500
00:41:00,230 --> 00:41:03,180
Olyan, mint keresi fel egy táblában, ó, mi ezt az utasítást;

501
00:41:03,180 --> 00:41:06,290
amely megfelel a bináris 01.110.

502
00:41:10,200 --> 00:41:15,230
És így a fájlok összeszerelés általában kimenetek. O fájlokat.

503
00:41:15,230 --> 00:41:19,020
És. O fájlokat amit mondunk előtt,

504
00:41:19,020 --> 00:41:21,570
, hogy egy fájl nem kell, hogy egy fő funkció.

505
00:41:21,570 --> 00:41:27,640
Minden fájl lehet összeállítani le a. O fájlt, amíg ez egy érvényes C fájl.

506
00:41:27,640 --> 00:41:30,300
Meg lehet összeállítani le. O.

507
00:41:30,300 --> 00:41:43,030
Most össze, ami valójában hoz egy csomó. O fájlokat, és hozza őket, hogy egy végrehajtható.

508
00:41:43,030 --> 00:41:51,110
És akkor mi linking csinál, akkor véleményed a CS50 könyvtár a. O fájlt.

509
00:41:51,110 --> 00:41:56,980
Ez egy már lefordított bináris fájlt.

510
00:41:56,980 --> 00:42:03,530
És amikor fordítod a fájlt, a hello.c, amely felszólítja getString,

511
00:42:03,530 --> 00:42:06,360
hello.c lesz összeállítani le hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o most bináris.

513
00:42:08,910 --> 00:42:12,830
Használ getString, ezért szükséges, hogy menjen át a cs50.o,

514
00:42:12,830 --> 00:42:16,390
és a linker smooshes őket együtt, és másolja getString ebbe a fájlba

515
00:42:16,390 --> 00:42:20,640
és jön ki egy végrehajtható, amely minden funkcióját van szüksége.

516
00:42:20,640 --> 00:42:32,620
Tehát cs50.o valójában nem egy O fájlt, de elég közel, hogy nincs alapvető különbség.

517
00:42:32,620 --> 00:42:36,880
Szóval csak össze hoz egy csomó kép együtt

518
00:42:36,880 --> 00:42:41,390
hogy a külön-külön tartalmazza az összes olyan funkciót szeretnék használni

519
00:42:41,390 --> 00:42:46,120
és létrehozza a futtatható, hogy valóban működik.

520
00:42:48,420 --> 00:42:50,780
>> És így ez is, amit mondunk, mielőtt

521
00:42:50,780 --> 00:42:55,970
ahol lehet 1000. c fájlokat, akkor fordítani őket, hogy. o fájlokat,

522
00:42:55,970 --> 00:43:00,040
ami valószínűleg eltart egy ideig, akkor módosítsa 1. c fájlt.

523
00:43:00,040 --> 00:43:05,480
Csak akkor kell újrafordítani, hogy 1. C fájlt, majd újracsatolása minden mást,

524
00:43:05,480 --> 00:43:07,690
kapcsolja vissza mindent együtt.

525
00:43:09,580 --> 00:43:11,430
[Hallgató] Ha mi össze írunk lcs50?

526
00:43:11,430 --> 00:43:20,510
Igen, úgy lcs50. Ez a zászló jelzi a linker, hogy meg kell összekapcsolása a könyvtárban.

527
00:43:26,680 --> 00:43:28,910
Kérdései vannak?

528
00:43:41,310 --> 00:43:46,860
Már mi ment át bináris eltérő 5 másodperc az első előadás?

529
00:43:50,130 --> 00:43:53,010
Nem hiszem.

530
00:43:55,530 --> 00:43:58,820
Tudnia kell, hogy az összes nagy Os, hogy már elment felett,

531
00:43:58,820 --> 00:44:02,670
és képesnek kell lennie arra, ha adott egy funkciót,

532
00:44:02,670 --> 00:44:09,410
akkor képesnek kell lennie arra, hogy azt mondják, hogy ez nagy O, nagyjából. Vagy jól, nagy O durva.

533
00:44:09,410 --> 00:44:15,300
Szóval, ha látod a beágyazott hurok hurok alatt azonos számú dolog,

534
00:44:15,300 --> 00:44:22,260
mint például int i, i <n, int j, j <n - >> [hallgató] n faragva. >> Úgy látszik, hogy n négyzeten.

535
00:44:22,260 --> 00:44:25,280
Ha háromágyas beágyazott, akkor hajlamos arra, hogy n felkockázva.

536
00:44:25,280 --> 00:44:29,330
Szóval ez a fajta dolog, amit meg kell tenni, hogy rámutatni azonnal.

537
00:44:29,330 --> 00:44:33,890
Tudnod kell, beillesztés sort és buborék rendezés és egyesítése fajta és az összes ilyen.

538
00:44:33,890 --> 00:44:41,420
Ez könnyebb megérteni, hogy miért ők azok n négyzet és n log n, és minden e

539
00:44:41,420 --> 00:44:47,810
mert azt hiszem, volt egy kvíz egyéves, ahol alapvetően adtam neked

540
00:44:47,810 --> 00:44:55,050
végrehajtási buborék sort, és azt mondta: "Mi a futási idejét ezt a funkciót?"

541
00:44:55,050 --> 00:45:01,020
Tehát, ha elismerik, hogy buborék rendezés, akkor azonnal mondani n faragva.

542
00:45:01,020 --> 00:45:05,470
De ha csak megnézzük, akkor nem is kell ismernünk, hogy a buborék rendezés;

543
00:45:05,470 --> 00:45:08,990
akkor csak mondom ezt csinálja ezt és ezt. Ez n faragva.

544
00:45:12,350 --> 00:45:14,710
[Hallgató] Vannak olyan nehéz példákat akkor jön fel,

545
00:45:14,710 --> 00:45:20,370
mint egy hasonló ötlet kitalálni?

546
00:45:20,370 --> 00:45:24,450
>> Nem hiszem, hogy mi lenne Önnek bármilyen kemény példákat.

547
00:45:24,450 --> 00:45:30,180
A buborék fajta dolog körülbelül olyan kemény, mint szeretnénk menni,

548
00:45:30,180 --> 00:45:36,280
sőt, hogy mindaddig, amíg érted, hogy te iterációjával az array

549
00:45:36,280 --> 00:45:41,670
egyes eleme a tömb, ami lesz valami, ami n faragva.

550
00:45:45,370 --> 00:45:49,940
Vannak általános kérdések, mint itt van - Oh.

551
00:45:55,290 --> 00:45:58,530
Csak a minap, Doug azt állította: "Én már kitalált egy algoritmust, amely rendezni egy tömb

552
00:45:58,530 --> 00:46:01,780
"N számok O (log n) idő!"

553
00:46:01,780 --> 00:46:04,900
Akkor honnan tudjuk, hogy ez lehetetlen?

554
00:46:04,900 --> 00:46:08,850
[Hallhatatlan diák válasza] >> Igen.

555
00:46:08,850 --> 00:46:13,710
Legalább meg kell érjen minden elem a tömbben,

556
00:46:13,710 --> 00:46:16,210
így lehetetlen rendezni egy sor -

557
00:46:16,210 --> 00:46:20,850
Ha minden rendben van rendezetlen sorrendben, akkor leszel megható mindent a tömb,

558
00:46:20,850 --> 00:46:25,320
így lehetetlen csinálni kevesebb mint O n.

559
00:46:27,430 --> 00:46:30,340
[Hallgató] Megmutatta nekünk, hogy például, hogy képes csinálni O n

560
00:46:30,340 --> 00:46:33,920
ha olyan sok memóriát. >> Igen.

561
00:46:33,920 --> 00:46:37,970
És ez - Nem emlékszem, mi ez - Vajon számláló sort?

562
00:46:47,360 --> 00:46:51,330
Hmm. Ez egy egész szám válogató algoritmus.

563
00:46:59,850 --> 00:47:05,100
Kerestem a különleges nevet az, hogy én nem emlékszem a múlt héten.

564
00:47:05,100 --> 00:47:13,000
Igen. Ezek a típusok a fajta, amely képes elvégezni a dolgok nagy O n.

565
00:47:13,000 --> 00:47:18,430
De vannak korlátai, mint csak akkor használható, egész egy bizonyos számot.

566
00:47:20,870 --> 00:47:24,560
Plusz, ha akarsz rendezni valamit ez -

567
00:47:24,560 --> 00:47:30,750
Ha a tömb 012, -12, 151, 4 millió

568
00:47:30,750 --> 00:47:35,120
akkor az egyetlen elem lesz, hogy teljesen tönkreteszi az egész válogatás.

569
00:47:42,060 --> 00:47:44,030
>> Kérdései vannak?

570
00:47:49,480 --> 00:47:58,870
[Hallgató] Ha van egy rekurzív függvény, és ez csak teszi a rekurzív hívások

571
00:47:58,870 --> 00:48:02,230
egy return utasítást, ez farok rekurzív,

572
00:48:02,230 --> 00:48:07,360
, és így azt, hogy nem használ több memóriát futás közben

573
00:48:07,360 --> 00:48:12,550
vagy ez legalábbis használni összehasonlítható memória iteratív megoldás?

574
00:48:12,550 --> 00:48:14,530
[Bowden] Igen.

575
00:48:14,530 --> 00:48:19,840
Ez valószínűleg valamivel lassabb, de nem igazán.

576
00:48:19,840 --> 00:48:23,290
Tail rekurzív nagyon jó.

577
00:48:23,290 --> 00:48:32,640
Keresi ismét stack frame, mondjuk mi fő

578
00:48:32,640 --> 00:48:42,920
és mi int bar (int x), vagy ilyesmi.

579
00:48:42,920 --> 00:48:52,310
Ez nem egy tökéletes rekurzív függvény, de a visszatérő bar (x - 1).

580
00:48:52,310 --> 00:48:57,620
Tehát nyilvánvaló, hogy ez a hibás. Be kell, alap esetben, meg ilyesmi.

581
00:48:57,620 --> 00:49:00,360
De az ötlet, hogy ez farok rekurzív,

582
00:49:00,360 --> 00:49:06,020
ami azt jelenti, ha a fő kéri bar ez lesz, hogy a stack frame.

583
00:49:09,550 --> 00:49:12,440
Ebben a stack frame ott lesz egy kis memóriablokkot

584
00:49:12,440 --> 00:49:17,490
amely megfelel az érvelését x.

585
00:49:17,490 --> 00:49:25,840
És így mondjuk fő történik hívni bar (100);

586
00:49:25,840 --> 00:49:30,050
Tehát x fog indulni, mint 100 fő.

587
00:49:30,050 --> 00:49:35,660
Ha a fordító elismeri, hogy ez egy farok rekurzív függvény,

588
00:49:35,660 --> 00:49:38,540
majd amikor bár teszi rekurzív hívás akadályozza,

589
00:49:38,540 --> 00:49:45,490
ahelyett, hogy egy új köteg keret, ott, ahol a köteg kezd nőni nagymértékben,

590
00:49:45,490 --> 00:49:48,220
végül hogy fog futni a halom, és akkor kap segfaultol

591
00:49:48,220 --> 00:49:51,590
mert a memória kezd ütközik.

592
00:49:51,590 --> 00:49:54,830
>> Tehát ahelyett, hogy a saját stack frame, akkor észre,

593
00:49:54,830 --> 00:49:59,080
hé, én soha nem kell, hogy jöjjön vissza erre stack frame,

594
00:49:59,080 --> 00:50:08,040
így ahelyett, hogy én csak cserélni ezt az érvelést a 99 és indítsa el bár az egész.

595
00:50:08,040 --> 00:50:11,810
És akkor majd újra meg újra, és ez eléri visszatérő bar (x - 1),

596
00:50:11,810 --> 00:50:17,320
és ahelyett, hogy egy új stack frame, akkor csak cseréld ki a jelenlegi 98 érv

597
00:50:17,320 --> 00:50:20,740
majd ugorj vissza a legelején bar.

598
00:50:23,860 --> 00:50:30,430
Ezek a műveletek, a helyébe lépő 1 érték a veremben és ugrás vissza az elejére,

599
00:50:30,430 --> 00:50:32,430
elég hatékony.

600
00:50:32,430 --> 00:50:41,500
Tehát nem csak ez ugyanaz memória használat egy külön funkció, amely az iteratív

601
00:50:41,500 --> 00:50:45,390
mert te csak használ 1 verem keret, de te nem szenvednek az árnyoldalai

602
00:50:45,390 --> 00:50:47,240
kelljen hívni funkciókat.

603
00:50:47,240 --> 00:50:50,240
Hívása funkciók némileg drága, mert van, hogy mindezt a telepítést

604
00:50:50,240 --> 00:50:52,470
és teardown és az összes ezt a cuccot.

605
00:50:52,470 --> 00:50:58,160
Tehát ez a farok rekurzió jó.

606
00:50:58,160 --> 00:51:01,170
[Hallgató] Miért nem hoz létre új lépések?

607
00:51:01,170 --> 00:51:02,980
Mert rájön, hogy nem kell.

608
00:51:02,980 --> 00:51:07,800
A hívás bár éppen vissza a rekurzív hívást.

609
00:51:07,800 --> 00:51:12,220
Tehát nem kell semmit a visszatérési érték.

610
00:51:12,220 --> 00:51:15,120
Ez csak megy, hogy azonnal vissza.

611
00:51:15,120 --> 00:51:20,530
Tehát ez csak akarja cserélni a saját érvelését, és indítsa újra.

612
00:51:20,530 --> 00:51:25,780
És azt is, ha nem rendelkezik a farok rekurzív változat,

613
00:51:25,780 --> 00:51:31,460
akkor kap az összes ezeket a bárok, ahol, ha ez bar visszatér

614
00:51:31,460 --> 00:51:36,010
azt vissza annak értékét egy ehhez, akkor a bar azonnal visszatér

615
00:51:36,010 --> 00:51:39,620
és visszatér az értékét egy ehhez, akkor ez csak megy azonnal vissza

616
00:51:39,620 --> 00:51:41,350
és visszatér az érték ezt.

617
00:51:41,350 --> 00:51:45,350
Szóval ez a megtakarítás popping mindezen dolgokat a verem

618
00:51:45,350 --> 00:51:48,730
mivel a visszatérési érték csak fog át egészen vissza egyébként.

619
00:51:48,730 --> 00:51:55,400
Szóval, miért nem helyettesítheti a érv a frissített érvet és kezdjük újra?

620
00:51:57,460 --> 00:52:01,150
Ha a függvény nem rekurzív farok, ha valami ehhez hasonlót -

621
00:52:01,150 --> 00:52:07,530
[Hallgató] ha bar (x + 1). >> Igen.

622
00:52:07,530 --> 00:52:11,770
>> Tehát, ha betette állapotban, akkor csinál valamit a visszatérési érték.

623
00:52:11,770 --> 00:52:16,260
Vagy akkor is, ha csak nem vissza 2 * bar (x - 1).

624
00:52:16,260 --> 00:52:23,560
Így most bar (x - 1) vissza kell annak érdekében, hogy 2-szer kiszámítani ezt az értéket,

625
00:52:23,560 --> 00:52:26,140
így már nincs szüksége saját külön stack frame,

626
00:52:26,140 --> 00:52:31,180
és most, nem számít, milyen keményen próbálkozol, fogsz kell -

627
00:52:31,180 --> 00:52:34,410
Ez nem rekurzív farok.

628
00:52:34,410 --> 00:52:37,590
[Hallgató] Vajon próbálom, hogy egy rekurziót, hogy törekedjen a farok rekurzió -

629
00:52:37,590 --> 00:52:41,450
[Bowden] Egy ideális világban, de CS50 nem kell.

630
00:52:43,780 --> 00:52:49,280
Annak érdekében, hogy farok rekurzió, általában, akkor létrehoz egy további érv

631
00:52:49,280 --> 00:52:53,550
ahol bar veszi figyelembe int x y

632
00:52:53,550 --> 00:52:56,990
és y megegyezik a végső dolog, amit szeretnénk, hogy visszatérjen.

633
00:52:56,990 --> 00:53:03,650
Akkor ezt fogod visszatér bar (x - 1), 2 * y.

634
00:53:03,650 --> 00:53:09,810
Szóval ez csak egy magas szintű, hogyan átalakítani a dolgokat, hogy farok rekurzív.

635
00:53:09,810 --> 00:53:13,790
De az extra érv -

636
00:53:13,790 --> 00:53:17,410
És aztán a végén, amikor eléri a bázis, az esetben, ha csak vissza y

637
00:53:17,410 --> 00:53:22,740
mert már halmozódnak egész idő alatt a visszatérési érték, amit akar.

638
00:53:22,740 --> 00:53:27,280
Te milyen már csinálja iteratív de a rekurzív hívások.

639
00:53:32,510 --> 00:53:34,900
Kérdései vannak?

640
00:53:34,900 --> 00:53:39,890
[Hallgató] Lehet, hogy mintegy mutató számtani, mint amikor a húrok. >> Persze.

641
00:53:39,890 --> 00:53:43,610
Mutató aritmetika.

642
00:53:43,610 --> 00:53:48,440
Ha strings ez könnyű, mert húrok char csillag,

643
00:53:48,440 --> 00:53:51,860
karakter van örökké és mindig egy byte,

644
00:53:51,860 --> 00:53:57,540
és így mutató aritmetika egyenértékű rendszeres számtani ha dolgunk húrok.

645
00:53:57,540 --> 00:54:08,790
Mondjuk char * s = "hello".

646
00:54:08,790 --> 00:54:11,430
Tehát van egy mondat a memóriában.

647
00:54:19,490 --> 00:54:22,380
Van szüksége, 6 byte, mert mindig szükség van a null terminátor.

648
00:54:22,380 --> 00:54:28,620
És char * s fog mutatni az elején ezt a tömb.

649
00:54:28,620 --> 00:54:32,830
Szóval, s mutat ott.

650
00:54:32,830 --> 00:54:36,710
Nos, ez alapvetően, hogy az egyes array működik,

651
00:54:36,710 --> 00:54:40,780
függetlenül attól, hogy volt egy visszatérés a malloc, vagy hogy ez a verem.

652
00:54:40,780 --> 00:54:47,110
Minden tömb alapvetően egy mutató a kezdete a tömb,

653
00:54:47,110 --> 00:54:53,640
majd minden sor művelet, bármilyen indexálás, csak megy abba a tömb egy bizonyos ellensúlyozni.

654
00:54:53,640 --> 00:55:05,360
>> Tehát amikor azt mondom, valami ilyesmit s [3], ez lesz s és a számolás 3 karakter hüvelyk

655
00:55:05,360 --> 00:55:12,490
Így s [3], van 0, 1, 2, 3, így s [3] fog a hivatkozás erre a l.

656
00:55:12,490 --> 00:55:20,460
[Hallgató] És tudtuk elérni ugyanazt az értéket csinál s + 3, majd zárójelben sztár?

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

658
00:55:22,570 --> 00:55:26,010
Ez egyenértékű azzal, hogy * (k + 3);

659
00:55:26,010 --> 00:55:31,240
és ez örökké és mindig azonos nem számít, mit teszel.

660
00:55:31,240 --> 00:55:34,070
Soha nem kell használni a konzol szintaxist.

661
00:55:34,070 --> 00:55:37,770
Bármikor használhatja a * (k + 3) szintaxis.

662
00:55:37,770 --> 00:55:40,180
Az emberek hajlamosak mint a zárójeles formával, mégis.

663
00:55:40,180 --> 00:55:43,860
[Hallgató] Tehát minden tömbök valójában csak mutató.

664
00:55:43,860 --> 00:55:53,630
Van egy kis különbség, amikor azt mondom, int x [4] >> [hallgató]-e, hogy megteremtse a memória?

665
00:55:53,630 --> 00:56:03,320
[Bowden] Ez létre fog hozni 4 ints a veremben, így összességében 16 bájt.

666
00:56:03,320 --> 00:56:05,700
Ez létre fog hozni 16 byte a verem.

667
00:56:05,700 --> 00:56:09,190
x nem tárolja sehol.

668
00:56:09,190 --> 00:56:13,420
Ez csak egy szimbólum utal a kezdete a dolog.

669
00:56:13,420 --> 00:56:17,680
Mert nyilvánította a tömb belsejében ezt a funkciót,

670
00:56:17,680 --> 00:56:22,340
amit a fordító fog tenni éppen helyébe minden esetben a változó x

671
00:56:22,340 --> 00:56:26,400
olyan esetekben, amikor ez történt választani, hogy ezeket 16 bájt.

672
00:56:26,400 --> 00:56:30,040
Ezt nem tehetem meg a char * s, mert s tényleges mutató.

673
00:56:30,040 --> 00:56:32,380
Nem szabad, hogy akkor mutasson más dolog.

674
00:56:32,380 --> 00:56:36,140
x egy konstans. Nem lehet, hogy pont egy másik tömbben. >> [Hallgató] Oké.

675
00:56:36,140 --> 00:56:43,420
De ez a gondolat, ez indexálás, ugyanaz, függetlenül attól, hogy ez egy hagyományos tömb

676
00:56:43,420 --> 00:56:48,230
vagy ha ez egy mutatót valamit, vagy ha ez a mutató egy malloced tömb.

677
00:56:48,230 --> 00:56:59,770
És valóban, ez annyira azonos, hogy ez is ugyanaz a dolog.

678
00:56:59,770 --> 00:57:05,440
Ez valójában csak fordítja, mi van benne a konzolok és mi maradt a konzolok,

679
00:57:05,440 --> 00:57:07,970
hozzáadja őket együtt, és dereferences.

680
00:57:07,970 --> 00:57:14,710
Tehát ez éppen olyan érvényes, * (k + 3), vagy s [3].

681
00:57:16,210 --> 00:57:22,090
[Hallgató] Tud tekintette mutatókat mutat 2-dimenziós tömbök?

682
00:57:22,090 --> 00:57:27,380
>> Ez nehezebb. Hagyományosan, nem.

683
00:57:27,380 --> 00:57:34,720
A 2-dimenziós tömb csak egy 1-dimenziós tömb néhány kényelmes szintaxis

684
00:57:34,720 --> 00:57:54,110
mert amikor azt mondom, int x [3] [3], ez tényleg csak 1 tömb, 9 értékeket.

685
00:57:55,500 --> 00:58:03,000
És így amikor index, a fordító tudja, mire gondolok.

686
00:58:03,000 --> 00:58:13,090
Ha azt mondom, x [1] [2], hogy tudja, hogy én akarom, hogy a második sort, így megy, hogy kihagyja az első 3,

687
00:58:13,090 --> 00:58:17,460
majd azt akarja, a második dolog, hogy így fog kapni ezt.

688
00:58:17,460 --> 00:58:20,480
De ez még mindig csak egy dimenziós tömb.

689
00:58:20,480 --> 00:58:23,660
És így ha akartam rendelni egy mutatót, hogy a tömb,

690
00:58:23,660 --> 00:58:29,770
Azt mondanám, int * p = x;

691
00:58:29,770 --> 00:58:33,220
A típus a x csak -

692
00:58:33,220 --> 00:58:38,280
Ez durva mondván típusú x mivel ez csak egy szimbólum, és ez nem egy valós változó,

693
00:58:38,280 --> 00:58:40,140
de ez csak egy int *.

694
00:58:40,140 --> 00:58:44,840
x csak egy mutató a kezdetétől. >> [Hallgató] Oké.

695
00:58:44,840 --> 00:58:52,560
És így nem lesz képes elérni [1] [2].

696
00:58:52,560 --> 00:58:58,370
Azt hiszem, van speciális szintaxis nyilvánító mutató,

697
00:58:58,370 --> 00:59:12,480
valami nevetséges, mint például int (* p [- valami teljesen nevetséges. Én nem is tudom.

698
00:59:12,480 --> 00:59:17,090
De van egy szintaxis nyilvánító mutatókat, mint a zárójeles és dolgokat.

699
00:59:17,090 --> 00:59:22,960
Lehet, hogy nem is hagyja, hogy ezt teszed.

700
00:59:22,960 --> 00:59:26,640
Tudtam nézni vissza valamit, ami elmondja az igazat.

701
00:59:26,640 --> 00:59:34,160
Fogom keresni, hogy később, ha van egy szintaxis pont. De soha nem fogod látni.

702
00:59:34,160 --> 00:59:39,670
És még a szintaxis annyira archaikus, hogy ha használják, az emberek fogják terelni.

703
00:59:39,670 --> 00:59:43,540
Többdimenziós tömbök elég ritka, ahogy van.

704
00:59:43,540 --> 00:59:44,630
Te nagyon sokat -

705
00:59:44,630 --> 00:59:48,490
Nos, ha csinálsz mátrix dolgokat ez nem lesz ritka,

706
00:59:48,490 --> 00:59:56,730
de a C te ritkán lesz használva többdimenziós tömbök.

707
00:59:57,630 --> 01:00:00,470
Igen. >> [Hallgató] Tegyük fel, hogy van egy nagyon hosszú tömb.

708
01:00:00,470 --> 01:00:03,900
>> Tehát a virtuális memória tűnik, hogy minden egymást követő,

709
01:00:03,900 --> 01:00:05,640
mint az elemek közvetlenül egymás

710
01:00:05,640 --> 01:00:08,770
de a fizikai memória, lehetséges lenne e, hogy szét? >> Igen.

711
01:00:08,770 --> 01:00:16,860
Hogyan virtuális memória működik ez csak elválasztja -

712
01:00:19,220 --> 01:00:24,860
Az egység kiosztásának egy olyan oldalon, ami általában a 4 kilobyte,

713
01:00:24,860 --> 01:00:29,680
és így amikor a folyamat azt mondja, hé, azt akarom, hogy ezt a memóriát,

714
01:00:29,680 --> 01:00:35,970
az operációs rendszer fog kiosztani it 4 kilobyte-e kis blokk memória.

715
01:00:35,970 --> 01:00:39,100
Még ha csak használni egy kis bájt az egész blokk memória,

716
01:00:39,100 --> 01:00:42,850
az operációs rendszer fog adni, hogy a teljes 4 kilobyte.

717
01:00:42,850 --> 01:00:49,410
Szóval mi ez azt jelenti, tudtam, hogy - mondjuk ez az én verem.

718
01:00:49,410 --> 01:00:53,180
Ezt stack elkülöníthetők. A verem lehet megabájt és megabájt.

719
01:00:53,180 --> 01:00:55,020
A verem lehet hatalmas.

720
01:00:55,020 --> 01:01:00,220
De a verem magának kell osztani egyes oldalakat,

721
01:01:00,220 --> 01:01:09,010
ami ha megnézzük ide mondjuk, ez a mi RAM,

722
01:01:09,010 --> 01:01:16,600
ha van 2 GB RAM-mal, ez a tényleges cím 0, mint a 0. byte az én RAM,

723
01:01:16,600 --> 01:01:22,210
és ez a 2 gigabájt egészen ide.

724
01:01:22,210 --> 01:01:27,230
Szóval, ez az oldal is megfelelnek ennek a blokknak ide.

725
01:01:27,230 --> 01:01:29,400
Ez az oldal is megfelel ennek a mondat ide.

726
01:01:29,400 --> 01:01:31,560
Ez is megfelel ez ide.

727
01:01:31,560 --> 01:01:35,540
Így az operációs rendszer szabadon rendelni fizikai memória

728
01:01:35,540 --> 01:01:39,320
minden egyes oldalt önkényesen.

729
01:01:39,320 --> 01:01:46,180
És ez azt jelenti, hogy ha ez a határ történik forma, egy tömb,

730
01:01:46,180 --> 01:01:50,070
tömb történik hagyni e és jobbra a jelen végzés az oldal,

731
01:01:50,070 --> 01:01:54,460
akkor a tömb lesz osztani a fizikai memóriában.

732
01:01:54,460 --> 01:01:59,280
És akkor, amikor kilép a program, amikor a folyamat véget ér,

733
01:01:59,280 --> 01:02:05,690
E leképezések kap törlik, és akkor ez szabadon használhatják ezeket a kis blokkok más dolog.

734
01:02:14,730 --> 01:02:17,410
További kérdések?

735
01:02:17,410 --> 01:02:19,960
[Hallgató] A mutató számtani. >> Ó, igen.

736
01:02:19,960 --> 01:02:28,410
Strings könnyebb volt, de keres valamit, mint a ints,

737
01:02:28,410 --> 01:02:35,000
így hát az int x [4];

738
01:02:35,000 --> 01:02:41,810
Hogy ez egy tömb, vagy hogy ez a mutató egy malloced tömb 4 egészek,

739
01:02:41,810 --> 01:02:47,060
ez lesz ugyanúgy kezeljék.

740
01:02:50,590 --> 01:02:53,340
[Hallgató] Szóval tömbök vannak a halom?

741
01:03:01,400 --> 01:03:05,270
[Bowden] A tömbök nem a kupac. >> [Hallgató] Oh.

742
01:03:05,270 --> 01:03:08,320
>> [Bowden] Ez a típusú tömb általában a a verem

743
01:03:08,320 --> 01:03:12,220
ha kijelentette azt - figyelmen kívül hagyva a globális változókat. Ne használja a globális változókat.

744
01:03:12,220 --> 01:03:16,280
Belül egy függvény mondom int x [4];

745
01:03:16,280 --> 01:03:22,520
Ez lesz egy 4-egész blokk a verem ezen tömb.

746
01:03:22,520 --> 01:03:26,960
De ez a malloc (4 * sizeof (int)); fog menni a kupac.

747
01:03:26,960 --> 01:03:31,870
De miután ezen a ponton tudom használni az x és p-ben nagyjából azonos módon,

748
01:03:31,870 --> 01:03:36,140
más, mint a kivételek korábban mondtam rólad is hozzárendelése p.

749
01:03:36,140 --> 01:03:40,960
Technikailag, a mérete némileg eltérnek, de ez teljesen lényegtelen.

750
01:03:40,960 --> 01:03:43,310
Te soha nem használja a méretben.

751
01:03:48,020 --> 01:03:56,810
A p Mondhatnám p [3] = 2, vagy x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
Használhatod őket, pontosan ugyanolyan módon.

753
01:03:59,680 --> 01:04:01,570
Szóval pointer aritmetikai most - Igen.

754
01:04:01,570 --> 01:04:07,390
[Hallgató] Hát nem kell tennie, p * ha a zárójelben?

755
01:04:07,390 --> 01:04:11,720
A zárójelben szereplő implicit dereference. >> Oké.

756
01:04:11,720 --> 01:04:20,200
Igazából, azt is, amit mondasz az tudsz többdimenziós tömbök

757
01:04:20,200 --> 01:05:02,650
A mutató, amit tehetünk, valami ilyesmit, mondjuk, int ** pp = malloc (sizeof (int *) * 5);

758
01:05:02,650 --> 01:05:06,900
Én csak írni az egészet ki először.

759
01:05:37,880 --> 01:05:41,020
Nem akartam, hogy az egyik.

760
01:05:41,020 --> 01:05:42,550
Oké.

761
01:05:42,550 --> 01:05:48,910
Mit tettem itt - Ez legyen pp [i].

762
01:05:48,910 --> 01:05:53,680
Tehát pp egy mutató egy mutató.

763
01:05:53,680 --> 01:06:02,420
Te mallocing pp, hogy pont egy sor az 5 int csillagok.

764
01:06:02,420 --> 01:06:10,950
Tehát a memóriában van a verem pp

765
01:06:10,950 --> 01:06:20,150
Meg fog mutatni egy sor 5 háztömbnyire amelyek mind maguk mutatók.

766
01:06:20,150 --> 01:06:28,210
És akkor, amikor én malloc idelent, azt malloc hogy minden e egyes mutatók

767
01:06:28,210 --> 01:06:32,080
kell mutatnia, hogy egy külön blokkot 4 bájt a kupac.

768
01:06:32,080 --> 01:06:35,870
Tehát ez rámutat arra, hogy 4 bájt.

769
01:06:37,940 --> 01:06:40,660
És ez pont egy másik 4 bájt.

770
01:06:40,660 --> 01:06:43,200
>> És mindegyik pont a saját 4 bájt.

771
01:06:43,200 --> 01:06:49,080
Ez ad nekem egy módja a többdimenziós dolgokat.

772
01:06:49,080 --> 01:06:58,030
Mondhatnám pp [3] [4], de most ez nem ugyanaz, mint a többdimenziós tömbök

773
01:06:58,030 --> 01:07:05,390
mert többdimenziós tömbök úgy fordította [3] [4] egyetlen ellensúlyozza az x tömb.

774
01:07:05,390 --> 01:07:14,790
Ez dereferences p, hozzáfér a harmadik index, akkor dereferences hogy

775
01:07:14,790 --> 01:07:20,790
és bejáratok - 4 érvénytelenek lennének, - a második index.

776
01:07:24,770 --> 01:07:31,430
Mivel ha mi volt a int x [3] [4] előtt, mint egy többdimenziós tömb

777
01:07:31,430 --> 01:07:35,740
és ha dupla konzollal ez tényleg csak egy dereference,

778
01:07:35,740 --> 01:07:40,490
Ön után egy mutatót, majd egy ofszet,

779
01:07:40,490 --> 01:07:42,850
ez tényleg 2D hivatkozásokat.

780
01:07:42,850 --> 01:07:45,840
Kövesse 2 külön mutató.

781
01:07:45,840 --> 01:07:50,420
Tehát ez technikailag is lehetővé teszi, hogy többdimenziós tömbök

782
01:07:50,420 --> 01:07:53,550
ahol minden egyes tömb különböző méretben.

783
01:07:53,550 --> 01:07:58,000
Tehát úgy gondolom, csipkézett többdimenziós tömbök, amit a neve

784
01:07:58,000 --> 01:08:01,870
mert valóban az első dolog lehetne mutatni valamit, ami már 10 elemet,

785
01:08:01,870 --> 01:08:05,540
A második dolog, amit tudott mutatni valamit, ami összesen 100 elemet.

786
01:08:05,540 --> 01:08:10,790
[Hallgató] Van-e határa a számát mutató akkor lehet

787
01:08:10,790 --> 01:08:14,290
mutató más mutatókat? No. >>

788
01:08:14,290 --> 01:08:17,010
Egyszerre int ***** p.

789
01:08:18,050 --> 01:08:23,760
Vissza a mutató számtani - >> [hallgató] Oh. >> Igen.

790
01:08:23,760 --> 01:08:35,649
[Hallgató] Ha van int *** p, aztán csinál egy dereferencing, és azt mondom, p * egyenlő ez az érték,

791
01:08:35,649 --> 01:08:39,560
nem csak fog tenni 1 szint dereferencing? >> Igen.

792
01:08:39,560 --> 01:08:43,340
Tehát, ha azt akarom, hogy hozzáférjen a dolog, hogy az utolsó mutató mutat -

793
01:08:43,340 --> 01:08:46,210
Akkor te *** p. >> Oké.

794
01:08:46,210 --> 01:08:54,080
Szóval ez a p pont, 1 blokk, pont egy másik blokk, pontok másik blokkra.

795
01:08:54,080 --> 01:09:02,010
Akkor, ha nem * p = valami mást, akkor változik a

796
01:09:02,010 --> 01:09:13,640
hogy most pont egy másik blokk. >> Oké.

797
01:09:13,640 --> 01:09:17,649
>> [Bowden] És ha ezeket malloced, akkor most kiszivárgott memória

798
01:09:17,649 --> 01:09:20,430
kivéve, ha történetesen különböző hivatkozásokat e

799
01:09:20,430 --> 01:09:25,270
mert akkor nem kap vissza azokra is, hogy csak eldobta.

800
01:09:25,270 --> 01:09:29,550
Mutató aritmetika.

801
01:09:29,550 --> 01:09:36,310
int x [4]; fog kiosztani egy sor 4-egészek

802
01:09:36,310 --> 01:09:40,670
ahol x fog mutatni, hogy az elején a tömbben.

803
01:09:40,670 --> 01:09:50,420
Tehát amikor azt mondom, valami ilyesmit x [1], azt akarom, hogy azt jelenti, megy a második egész a tömbben,

804
01:09:50,420 --> 01:09:53,319
ami ezt.

805
01:09:53,319 --> 01:10:04,190
De tényleg, ez 4 bájt a tömb, mivel ez integer vesz fel 4 byte.

806
01:10:04,190 --> 01:10:08,470
Tehát egy offset 1-valójában azt jelenti, eltolt, 1

807
01:10:08,470 --> 01:10:12,030
akkora típusától függetlenül a tömb.

808
01:10:12,030 --> 01:10:17,170
Ez egy tömb egészek, így tudja, hogy nem 1-szer méretét int, ha akarja ellensúlyozni.

809
01:10:17,170 --> 01:10:25,260
A másik szintaxis. Vegye figyelembe, hogy ez ugyanaz, mint a * (x + 1);

810
01:10:25,260 --> 01:10:35,250
Amikor azt mondom, pointer + 1, hogy mi visszatér a cím, hogy a mutató tárolja

811
01:10:35,250 --> 01:10:40,360
plusz 1-szer a méretét típusának a mutató.

812
01:10:40,360 --> 01:10:59,510
Tehát, ha x = ox100, akkor x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
És akkor vissza ezt, és mond valamit, mint a char * c = (char *) x;

814
01:11:19,750 --> 01:11:23,050
és most c lesz ugyanazon a címen, mint x.

815
01:11:23,050 --> 01:11:26,040
c lesz egyenlő ox100,

816
01:11:26,040 --> 01:11:31,490
de c + 1 lesz egyenlő ox101

817
01:11:31,490 --> 01:11:38,030
mivel a mutató aritmetika típusától függ a mutató, hogy a felvenni kívánt.

818
01:11:38,030 --> 01:11:45,390
Tehát c + 1, úgy néz ki, a C, ez egy char mutatót, így fog hozzá 1-szer méretének char,

819
01:11:45,390 --> 01:11:48,110
amely mindig lesz 1, így kap 101,

820
01:11:48,110 --> 01:11:54,890
mivel ha mégis x, amely még mindig 100, x + 1 lesz 104.

821
01:11:56,660 --> 01:12:06,340
[Hallgató] Lehet használni c + +-ban annak érdekében, hogy előre a mutatót 1-jéig?

822
01:12:06,340 --> 01:12:09,810
Igen, lehet.

823
01:12:09,810 --> 01:12:16,180
Ezt nem teheted, hogy az x, mert x csak egy szimbólum, ez egy állandó, nem tudja megváltoztatni x.

824
01:12:16,180 --> 01:12:22,610
>> De c történetesen csak egy mutató, így a c + + tökéletesen érvényes, és ez növelni 1-gyel.

825
01:12:22,610 --> 01:12:32,440
Ha c voltak, csak egy int *, majd a c + + lenne 104.

826
01:12:32,440 --> 01:12:41,250
+ + Nem mutató számtani mint c + 1 volna mutató számtani.

827
01:12:43,000 --> 01:12:48,870
Ez tulajdonképpen, hogy egy csomó dolgot, mint a merge sort -

828
01:12:49,670 --> 01:12:55,710
Ahelyett, hogy a másolatok a dolgok, akkor inkább át -

829
01:12:55,710 --> 01:13:02,400
Mint ha azt akartam, hogy adja át ezt a felét a tömb - Menjünk töröljön néhány e.

830
01:13:04,770 --> 01:13:10,520
Tegyük fel akartam átadni ezt az oldalát a tömb egy funkciót.

831
01:13:10,520 --> 01:13:12,700
Mit is átadni ezt a funkciót?

832
01:13:12,700 --> 01:13:17,050
Ha át x vagyok, tompított ezt a címet.

833
01:13:17,050 --> 01:13:23,780
De azt akarom, hogy adja át az adott címet. Szóval mit kell átadni?

834
01:13:23,780 --> 01:13:26,590
[Hallgató] Pointer + 2?

835
01:13:26,590 --> 01:13:29,350
[Bowden] Tehát x + 2. Igen.

836
01:13:29,350 --> 01:13:31,620
Ez lesz ezt a címet.

837
01:13:31,620 --> 01:13:42,810
Azt is nagyon gyakran jelenik meg, mint x [2], majd a címét.

838
01:13:42,810 --> 01:13:47,850
Szóval meg kell tenniük a címét, mert a konzol egy implicit dereference.

839
01:13:47,850 --> 01:13:53,250
x [2] az az érték, amely ebben a rovatban, és akkor szeretné, hogy a címét mezőbe,

840
01:13:53,250 --> 01:13:56,850
így mondod & x [2].

841
01:13:56,850 --> 01:14:02,880
Szóval így valami merge sort, ahol szeretné, hogy adja át a fél listát valamit

842
01:14:02,880 --> 01:14:08,790
Ön tényleg csak át & x [2], és most egészen a rekurzív hívást illeti,

843
01:14:08,790 --> 01:14:12,510
új tömb kezdődik ott.

844
01:14:12,510 --> 01:14:15,130
Last minute kérdéseket.

845
01:14:15,130 --> 01:14:20,050
[Hallgató] Ha nem teszünk egy jelet, vagy - mi ez hívják? >> Star?

846
01:14:20,050 --> 01:14:23,200
[Hallgató] Star. >> Technikailag dereference üzemeltető, de - >> [hallgató] dereference.

847
01:14:23,200 --> 01:14:29,310
>> Ha nem tesz egy csillag vagy egy jelet, mi történik, ha csak azt mondom y = x és x egy pointer?

848
01:14:29,310 --> 01:14:34,620
Milyen típusú y? >> [Hallgató] Én csak azt mondom, hogy a mutató 2.

849
01:14:34,620 --> 01:14:38,270
Tehát, ha csak annyit y = x, most az x és y pont ugyanaz a dolog. >> [Hallgató] Pont ugyanaz a dolog.

850
01:14:38,270 --> 01:14:45,180
És ha x egy int pointer? >> Lenne panaszkodni, mert nem tudsz rendelni mutatókat.

851
01:14:45,180 --> 01:14:46,540
[Hallgató] Oké.

852
01:14:46,540 --> 01:14:51,860
Ne feledje, hogy a mutatók, még akkor is elkészíti őket nyilak,

853
01:14:51,860 --> 01:15:02,010
Tényleg mindent áruház - int * x - tényleg minden x tárolja valami hasonló ox100,

854
01:15:02,010 --> 01:15:06,490
amit történetesen képviselt, mint rámutatni, hogy a blokk tárolt 100.

855
01:15:06,490 --> 01:15:19,660
Tehát amikor azt mondom, int * y = x, Én csak másol ox100 be y,

856
01:15:19,660 --> 01:15:24,630
amelyet mi csak fogja képviselni, mint y is mutatva ox100.

857
01:15:24,630 --> 01:15:39,810
És ha azt mondom, int i = (int) x, majd én fog tárolni függetlenül értéke ox100 jelentése

858
01:15:39,810 --> 01:15:45,100
belül, de most ez lesz úgy kell értelmezni, mint egy egész helyett egy mutatót.

859
01:15:45,100 --> 01:15:49,310
De szükség van a leadott vagy máshol fog panaszkodni.

860
01:15:49,310 --> 01:15:53,300
[Hallgató] Szóval érted, hogy a leadott -

861
01:15:53,300 --> 01:16:00,290
Vajon lesz casting int x vagy öntéssel int y?

862
01:16:00,290 --> 01:16:03,700
[Bowden] Mi az?

863
01:16:03,700 --> 01:16:07,690
[Hallgató] Oké. Ezek után zárójelben ott van lesz egy x vagy ay ott?

864
01:16:07,690 --> 01:16:11,500
>> [Bowden] Vagy. x és y értéke azonos. >> [Hallgató] Oké.

865
01:16:11,500 --> 01:16:14,390
Mert mindketten mutatók. >> Igen.

866
01:16:14,390 --> 01:16:21,050
[Hallgató] Szóval ez tárolja a hexadecimális 100-integer formában? >> [Bowden] Igen.

867
01:16:21,050 --> 01:16:23,620
De nem az értékét bármit mutat.

868
01:16:23,620 --> 01:16:29,940
[Bowden] Igen. >> [Hallgató] Tehát csak a cím integer formában. Oké.

869
01:16:29,940 --> 01:16:34,720
[Bowden] Ha volna valamilyen bizarr okból,

870
01:16:34,720 --> 01:16:38,900
akkor kizárólag foglalkozni mutatók és soha nem foglalkoznak egészek

871
01:16:38,900 --> 01:16:49,240
és csak olyan, mint int * x = 0.

872
01:16:49,240 --> 01:16:53,000
Akkor fogod igazán zavarba egyszer pointer aritmetikai elindul történik.

873
01:16:53,000 --> 01:16:56,570
Tehát a számok, hogy a tárolni értelmetlenek.

874
01:16:56,570 --> 01:16:58,940
Csak, hogy a végén ezeket értelmezze.

875
01:16:58,940 --> 01:17:02,920
Szóval szabad másolni ox100 egy int * egy int,

876
01:17:02,920 --> 01:17:07,790
és én szabad vagyok rendelni - készen valószínűleg fog kapni kiabált, mert nem casting -

877
01:17:07,790 --> 01:17:18,160
Szabad vagyok rendelni valami hasonló (int *) ox1234 ebbe önkényes int *.

878
01:17:18,160 --> 01:17:25,480
Szóval ox123 éppolyan érvényes egy memória cím mint & y.

879
01:17:25,480 --> 01:17:32,060
& Y lesz visszatérni valamit, ami elég sok ox123.

880
01:17:32,060 --> 01:17:35,430
[Hallgató] lenne ez egy nagyon jó módja annak, hogy megy hexadecimális decimális formában,

881
01:17:35,430 --> 01:17:39,230
szeretem ha van egy mutató, és öntött, mint egy int?

882
01:17:39,230 --> 01:17:44,860
[Bowden] Akkor tényleg csak nyomtathat, mint a printf.

883
01:17:44,860 --> 01:17:50,300
Tegyük fel, hogy van int y = 100.

884
01:17:50,300 --> 01:18:02,700
Szóval printf (% d \ n - ahogy akkor már tudják -, hogy nyomtassa ki, mint egy egész,% x.

885
01:18:02,700 --> 01:18:05,190
Majd csak nyomtatni, mint hexadecimális.

886
01:18:05,190 --> 01:18:10,760
Így a mutató nem tárolja hexadecimális,

887
01:18:10,760 --> 01:18:12,960
és az egész nem tárolja decimális.

888
01:18:12,960 --> 01:18:14,700
Minden tárolt bináris.

889
01:18:14,700 --> 01:18:17,950
Csak annyi, hogy hajlamosak vagyunk megmutatni mutatókat, mint hexadecimális

890
01:18:17,950 --> 01:18:23,260
mert úgy gondolom, a dolgok ezekben a 4-bájtos blokkok,

891
01:18:23,260 --> 01:18:25,390
és a memória címek általában ismerős.

892
01:18:25,390 --> 01:18:28,890
Olyanok vagyunk, mint, ha kezdődik bf, akkor az történik, hogy a verem.

893
01:18:28,890 --> 01:18:35,560
Szóval, ez csak a mi értelmezési mutatók, mint hexadecimális.

894
01:18:35,560 --> 01:18:39,200
Oké. Minden last még kérdése?

895
01:18:39,200 --> 01:18:41,700
>> Itt leszek egy kicsit után, ha van bármi más.

896
01:18:41,700 --> 01:18:46,070
És ez a vége, hogy a.

897
01:18:46,070 --> 01:18:48,360
>> [Hallgató] Yay! [Taps]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]