1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [5. szakasz - További Comfortable]

2
00:00:02,500 --> 00:00:04,690
[Rob Bowden - Harvard University]

3
00:00:04,690 --> 00:00:07,250
[Ez CS50. - CS50.TV]

4
00:00:08,990 --> 00:00:14,250
>> Mint mondtam az én e-mail, van egy csomó dolog, amit használni

5
00:00:14,250 --> 00:00:17,060
más, mint a készüléket ténylegesen a probléma készletek.

6
00:00:17,060 --> 00:00:19,910
Javasoljuk, hogy csinálnád a készüléket csak azért, mert akkor könnyebben tudnak segíteni

7
00:00:19,910 --> 00:00:22,070
, és tudjuk, hogyan mindent fog működni.

8
00:00:22,070 --> 00:00:26,950
De egy példa arra, ahol meg tudod csinálni a dolgokat, ha, mondjuk, ha nem fér hozzá

9
00:00:26,950 --> 00:00:31,570
egy készülék vagy szeretne dolgozni a Science Center alagsorában -

10
00:00:31,570 --> 00:00:33,090
amely valójában ezek a készülék is -

11
00:00:33,090 --> 00:00:35,150
ha azt szeretnénk, hogy bárhol dolgozni.

12
00:00:35,150 --> 00:00:42,370
Egy példa láttad / hallott SSH?

13
00:00:44,380 --> 00:00:47,780
SSH alapvetően, mint csatlakozni a valamit.

14
00:00:47,780 --> 00:00:51,340
Igazából, most én SSHed a készülékbe.

15
00:00:51,340 --> 00:00:54,290
Soha nem dolgozik közvetlenül a készülékbe.

16
00:00:55,930 --> 00:01:01,060
Itt van a készülék, és ha megnézi itt lent látod ezt az IP címet.

17
00:01:01,060 --> 00:01:03,650
Soha nem dolgoznak a készüléken;

18
00:01:03,650 --> 00:01:08,840
Mindig jön át egy iTerm2 ablakhoz / terminál ablakot.

19
00:01:08,840 --> 00:01:15,910
Tudod SSH e IP-címet, ssh jharvard@192.168.129.128.

20
00:01:15,910 --> 00:01:20,390
Emlékszem, ez a szám nagyon könnyen, mert ez egy ilyen szép mintát.

21
00:01:20,390 --> 00:01:24,920
De ez meg fogja kérdezni tőlem a jelszót, és most én vagyok a készüléket.

22
00:01:24,920 --> 00:01:33,060
Alapvetően ezen a ponton, ha megnyitotta a terminál a készülék belsejét is,

23
00:01:33,060 --> 00:01:36,350
ezt a felületet, de akkor használni, pontosan ugyanaz

24
00:01:36,350 --> 00:01:40,010
mivel a felület Én használ ide, de most te SSHed.

25
00:01:42,240 --> 00:01:44,920
Nem kell SSH a készüléket.

26
00:01:44,920 --> 00:01:52,360
Egy példa a másik hely, amit lehetett SSH Most biztos vagyok benne, akkor alapértelmezés szerint -

27
00:01:52,360 --> 00:01:55,020
Oh. Bigger.

28
00:01:55,020 --> 00:02:01,130
Minden akkor kell alapértelmezett FAS beszámoló a FAS szervereket.

29
00:02:01,130 --> 00:02:06,840
Számomra, szeretném, hogy SSH rbowden@nice.fas.harvard.edu.

30
00:02:06,840 --> 00:02:11,610
Meg fog kérni, hogy az első alkalommal, és azt mondod: igen.

31
00:02:11,610 --> 00:02:15,840
A jelszó csak lesz a FAS jelszót.

32
00:02:15,840 --> 00:02:22,650
És így most, én SSHed a szép szerverek, és meg tudom csinálni, amit akarok itt.

33
00:02:22,650 --> 00:02:28,560
Sok osztályok lehet venni, mint például a 124, kell majd töltesz cucc ide

34
00:02:28,560 --> 00:02:30,950
hogy ténylegesen be a probléma készletek.

35
00:02:30,950 --> 00:02:34,100
De azt mondják, hogy nem férnek hozzá a készüléket.

36
00:02:34,100 --> 00:02:37,910
Akkor meg tudod csinálni a dolgokat, mint itt, azt fogja mondani -

37
00:02:37,910 --> 00:02:42,160
Ez csak a mi szakasza kérdésekre.

38
00:02:42,160 --> 00:02:45,070
Azt fogja kérni, hogy ezt a készüléket.

39
00:02:45,070 --> 00:02:47,790
Ehelyett én csak csinálni a kiszolgálón.

40
00:02:47,790 --> 00:02:50,560
Megyek unzip ezt.

41
00:02:50,560 --> 00:02:55,670
A probléma az lesz, hogy te vagy használt használ valami ilyesmit gedit

42
00:02:55,670 --> 00:02:58,160
vagy bármi a készülék belsejét.

43
00:02:58,160 --> 00:03:01,830
Ugye nem megy, hogy, hogy a FAS kiszolgálón.

44
00:03:01,830 --> 00:03:04,110
Ez az egész csak lesz ennek szöveges felület.

45
00:03:04,110 --> 00:03:09,180
Szóval akkor vagy az egyik, próbálja megtanulni egy szövegszerkesztőbe, hogy azok rendelkeznek.

46
00:03:09,180 --> 00:03:12,130
Ezek Nano.

47
00:03:12,130 --> 00:03:14,990
Nano általában nagyon könnyen használható.

48
00:03:14,990 --> 00:03:19,470
Használhatja a nyilakat, és írja be a szokásos módon.

49
00:03:19,470 --> 00:03:21,250
Szóval ez nem nehéz.

50
00:03:21,250 --> 00:03:24,720
Ha azt szeretnénk, hogy valóban képzelet segítségével Emacs,

51
00:03:24,720 --> 00:03:29,850
amit talán nem kellett volna megnyitni, mert nem is tudom, hogyan zárja Emacs.

52
00:03:29,850 --> 00:03:32,760
Ellenőrző X, Control C? Igen.

53
00:03:32,760 --> 00:03:35,310
Vagy használhatja Vim, ami az, amit használ.

54
00:03:35,310 --> 00:03:37,800
És ezek a lehetőségek.

55
00:03:37,800 --> 00:03:43,830
Ha nem akarom, akkor is, ha megnézi manual.cs50.net--

56
00:03:43,830 --> 00:03:45,410
Oh.

57
00:03:45,410 --> 00:03:49,920
Egy PC segítségével SSH segítségével PuTTY,

58
00:03:49,920 --> 00:03:51,940
amely fogsz kell letölteni külön-külön.

59
00:03:51,940 --> 00:03:55,460
Egy Mac, akkor csak alapértelmezésben használat Terminal, vagy letölthető iTerm2,

60
00:03:55,460 --> 00:03:58,490
ami olyan, mint egy szép, díszes Terminal.

61
00:03:58,490 --> 00:04:03,780
Ha megy manual.cs50.net látni fog egy linket Notepad + +,

62
00:04:03,780 --> 00:04:07,120
ami az, amit tud használni a PC-n.

63
00:04:07,120 --> 00:04:13,340
Ez lehetővé teszi, SFTP honnan Notepad + +, ami alapvetően SSH.

64
00:04:13,340 --> 00:04:17,750
Mi ez engedi tennie, szerkesztheti a fájlokat a helyi,

65
00:04:17,750 --> 00:04:20,670
majd, amikor csak akarja, hogy megmentse őket, akkor mentés nice.fas,

66
00:04:20,670 --> 00:04:23,670
ahol lehet majd futtatni őket.

67
00:04:23,670 --> 00:04:26,880
És a megfelelője a Mac lesz TextWrangler.

68
00:04:26,880 --> 00:04:28,760
Így lehetővé teszi, hogy nem ugyanaz a dolog.

69
00:04:28,760 --> 00:04:32,800
Ez lehetővé teszi a fájlok szerkesztéséhez helyi és mentse őket nice.fas,

70
00:04:32,800 --> 00:04:35,730
ahol lehet majd futtatni őket.

71
00:04:35,730 --> 00:04:40,400
Szóval, ha valaha megragadt nélküli készüléket, akkor ezeket a lehetőségeket

72
00:04:40,400 --> 00:04:44,230
hogy még mindig nem a probléma készletek.

73
00:04:44,230 --> 00:04:48,250
Az egyik probléma az lesz, hogy nem fogod, hogy a CS50 könyvtár

74
00:04:48,250 --> 00:04:51,580
mert nice.fas nem alapértelmezés szerint van, hogy.

75
00:04:51,580 --> 00:04:55,970
Akkor vagy le a CS50 könyvtár -

76
00:04:55,970 --> 00:04:58,470
Azt hiszem, nem kell, hogy ezen a ponton.

77
00:04:58,470 --> 00:05:03,270
Akkor vagy le a CS50 könyvtárat, és másolja át nice.fas,

78
00:05:03,270 --> 00:05:07,450
vagy azt hiszem, ezen a ponton nem használja többé egyébként.

79
00:05:07,450 --> 00:05:12,720
Vagy ha igen, akkor az időt, hogy a helyébe

80
00:05:12,720 --> 00:05:18,480
Az implementáció a funkciók CS50 könyvtárban egyébként.

81
00:05:18,480 --> 00:05:21,370
Tehát nem kell, hogy sok korlátozást.

82
00:05:21,370 --> 00:05:23,710
És ennyi.

83
00:05:26,460 --> 00:05:29,820
>> Megyek vissza a készülék most, és mi mindent megteszünk a készülékbe.

84
00:05:29,820 --> 00:05:37,510
Keresi a mi szakaszán kérdések az elején, mint mondtam az én e-mail,

85
00:05:37,510 --> 00:05:43,620
meg kell beszélni egy rövid akkor kellett volna nézni.

86
00:05:43,620 --> 00:05:51,980
Megvan az átirányító & csövek és e három kérdésre.

87
00:05:51,980 --> 00:05:56,070
>> Mely patak nem úgy működik, mint printf levelet alapértelmezés szerint?

88
00:05:56,070 --> 00:05:59,130
Szóval stream. Mi az a patak?

89
00:06:06,520 --> 00:06:15,100
A patak alapvetően mintha ez csak néhány -

90
00:06:15,100 --> 00:06:21,450
Ez még csak nem is a forrás 1 és 0.

91
00:06:21,450 --> 00:06:24,920
A patak ez kér itt szabványos ki.

92
00:06:24,920 --> 00:06:27,250
És így szabvány meg egy patak, hogy amikor írsz rá,

93
00:06:27,250 --> 00:06:30,940
úgy tűnik a képernyőn.

94
00:06:30,940 --> 00:06:36,860
Szabványos ki, a patak, ez azt jelenti, hogy csak annyit írj 1 és 0 rá,

95
00:06:36,860 --> 00:06:40,220
és a másik végét a szabványos ki csak olvas az patak.

96
00:06:40,220 --> 00:06:43,540
Ez csak egy húr a 1 és 0.

97
00:06:43,540 --> 00:06:45,570
Írhat a folyamok vagy tudod olvasni patakok

98
00:06:45,570 --> 00:06:47,950
attól függően, hogy mi a patak valójában.

99
00:06:47,950 --> 00:06:52,800
A másik két alapértelmezett stream standard és standard hiba.

100
00:06:52,800 --> 00:06:57,540
Standard az, amikor te getString, ez vár rád a bemenő dolgokat.

101
00:06:57,540 --> 00:07:01,570
Tehát ez vár rád, ez valójában vár szabvány,

102
00:07:01,570 --> 00:07:04,880
amely valójában mit kapunk, ha beírja a billentyűzeten.

103
00:07:04,880 --> 00:07:07,530
Maga írja a szabványos be

104
00:07:07,530 --> 00:07:10,050
Standard hiba alapvetően egyenértékű a szabványos ki,

105
00:07:10,050 --> 00:07:13,280
de szakosodott, hogy ha nyomtatni standard hiba,

106
00:07:13,280 --> 00:07:16,770
kéne, hogy csak nyomtatni hibaüzeneteket e

107
00:07:16,770 --> 00:07:20,200
így különbséget tenni a normál üzenet kerül a képernyőre

108
00:07:20,200 --> 00:07:24,560
versus hibaüzenetek attól függően, hogy mentek a standard, vagy standard hibája.

109
00:07:24,560 --> 00:07:28,660
Fájlok is.

110
00:07:28,660 --> 00:07:32,440
Szabványos ki, standard, és a standard hiba csak különleges patakok,

111
00:07:32,440 --> 00:07:36,810
de tényleg bármilyen fájlt, ha megnyit egy fájlt, ez lesz a patak bájt

112
00:07:36,810 --> 00:07:40,740
ahol csak olvasni, hogy a patak.

113
00:07:40,740 --> 00:07:47,770
Te, a legtöbb, akkor gondolj egy fájlt patak bájt.

114
00:07:47,770 --> 00:07:51,190
Szóval mit patakok nem írnak, hogy alapértelmezés szerint? Szabványos ki.

115
00:07:51,190 --> 00:07:56,980
>> Mi a különbség a> és >>?

116
00:07:58,140 --> 00:08:03,710
Volt valaki nézze meg a videót előre? Oké.

117
00:08:03,710 --> 00:08:10,960
> Lesz, hogyan átirányítás a fájlokat,

118
00:08:10,960 --> 00:08:15,240
és >> nem fogja átirányítani kimenetet kép,

119
00:08:15,240 --> 00:08:17,820
de ez inkább fog hozzáfűzni a fájl.

120
00:08:17,820 --> 00:08:23,430
Például, mondjuk én véletlenül dict itt,

121
00:08:23,430 --> 00:08:27,020
és az egyetlen anyag belseje dict jelentése macska, macska, kutya, hal, kutya.

122
00:08:27,020 --> 00:08:31,530
Egy parancs, hogy van a parancssorban is macska,

123
00:08:31,530 --> 00:08:34,539
ami csak nyomdába, mi van a fájlban.

124
00:08:34,539 --> 00:08:40,679
Tehát amikor azt mondom macska dict, ez nyomdába macska, macska, kutya, hal, kutya. Ez minden macska nem.

125
00:08:40,679 --> 00:08:46,280
Ez azt jelenti, hogy a nyomtatott szabványos ki macska, macska, kutya, hal, kutya.

126
00:08:46,280 --> 00:08:53,240
Ha azt szeretnénk, hogy ahelyett, hogy az átirányítást egy fájlra, tudom használni>, és átirányítja azt amit a fájl.

127
00:08:53,240 --> 00:08:56,460
Hívom a file.

128
00:08:56,460 --> 00:09:00,320
Tehát most ha én ls, meglátom, van egy új fájlt nevű fájlt.

129
00:09:00,320 --> 00:09:05,700
És ha én nyisd ki, ez megy, hogy pontosan milyen macskát helyezni a parancssorban.

130
00:09:05,700 --> 00:09:11,040
Tehát most ha megteszem újra, akkor fogja átirányítani a kimenetet fájlba,

131
00:09:11,040 --> 00:09:13,930
és megyek, hogy pontosan ugyanolyan dolog.

132
00:09:13,930 --> 00:09:17,910
Szóval technikailag, teljesen nyíltságot felülírhatják amink volt.

133
00:09:17,910 --> 00:09:22,970
És majd meglátjuk, ha tudom megváltoztatni dict, Kivettem kutya.

134
00:09:22,970 --> 00:09:29,980
Most, ha macska dict fájlba újra megyünk, hogy az új verzió kutya eltávolították.

135
00:09:29,980 --> 00:09:32,400
Tehát teljesen felülírja azt.

136
00:09:32,400 --> 00:09:36,640
Ehelyett, ha az általunk használt >>, ez lesz hozzáfűzni fájlt.

137
00:09:36,640 --> 00:09:40,860
Most, fájl megnyitásakor, látjuk már csak ugyanaz a dolog nyomtatott kétszer

138
00:09:40,860 --> 00:09:44,920
mert ott egyszer, akkor csatolni kell az eredeti.

139
00:09:44,920 --> 00:09:48,130
Szóval, ez az, amit> és >> csinálni.

140
00:09:48,130 --> 00:09:50,580
Vajon a következő egy kérdezze - Ez nem kérdez rá.

141
00:09:50,580 --> 00:09:59,050
>> A másik, hogy van-e <, ami ha> átirányítja a szabványos ki,

142
00:09:59,050 --> 00:10:01,970
<Lesz átirányítani szabványos be

143
00:10:01,970 --> 00:10:12,050
Lássuk, van egy példa.

144
00:10:14,750 --> 00:10:16,930
Tudok írni egy igazi gyors.

145
00:10:17,870 --> 00:10:25,700
Vessünk bármilyen fájlt, hello.c.

146
00:10:56,060 --> 00:10:59,070
Viszonylag egyszerű fájl.

147
00:10:59,070 --> 00:11:03,570
Én csak arra, hogy egy sor, majd a nyomtatás "Hello", amit a string csak be volt.

148
00:11:03,570 --> 00:11:07,990
Tehát, hogy helló, majd a. / Hello.

149
00:11:07,990 --> 00:11:10,720
Most ez arra kéri, hogy adjon valamit,

150
00:11:10,720 --> 00:11:15,070
ami azt jelenti, hogy vár a dolgokat bevitt szabványos be

151
00:11:15,070 --> 00:11:20,450
Így írja, amit akarok a szabványos be Mi csak azt fogja mondani Hello, Rob!

152
00:11:20,450 --> 00:11:23,310
Akkor ez a nyomtatás szabványos ki Hello, Rob!

153
00:11:23,310 --> 00:11:28,860
Ha megteszem. / Hello, majd átirányítás,

154
00:11:30,740 --> 00:11:34,310
most akkor csak átirányítani fájlból.

155
00:11:34,310 --> 00:11:41,720
Tehát, ha tettem néhány fájl, txt, és tettem Rob,

156
00:11:41,720 --> 00:11:52,300
ha futok helló majd irányítsa át a fájlt txt bele. / hello, ez fogja mondani Hello, Rob! azonnal.

157
00:11:52,300 --> 00:11:57,160
Amikor először kerül getString és ez vár szabvány,

158
00:11:57,160 --> 00:12:01,730
szabvány már nem elérhető a billentyűzeten adatok kap be.

159
00:12:01,730 --> 00:12:05,980
Ehelyett már átirányított standard olvasni a fájlból txt.

160
00:12:05,980 --> 00:12:10,290
És ez így megy, hogy olvassa el a fájlt txt, ami csak a vonal Rob,

161
00:12:10,290 --> 00:12:13,380
és akkor fog nyomtatni Hello, Rob!

162
00:12:13,380 --> 00:12:18,180
És ha én akartam, én is csinálni. / Hello <txt

163
00:12:18,180 --> 00:12:21,500
majd a szokásos, hogy ez nyomtatást, ami Hello, Rob!,

164
00:12:21,500 --> 00:12:24,700
Tudom irányítani, hogy a saját fájlt.

165
00:12:24,700 --> 00:12:29,790
Én csak hívni a fájlt hello - Nem, nem fogok, mert ez a futtatható - txt2.

166
00:12:29,790 --> 00:12:40,150
Most txt2 megy, hogy a kimeneti. / Hello <txt, ami lesz Hello, Rob!

167
00:12:41,370 --> 00:12:43,520
>> Kérdései vannak?

168
00:12:45,900 --> 00:12:49,090
>> Oké. Akkor itt van gázvezeték.

169
00:12:49,090 --> 00:12:53,510
Pipes az utolsó egység átirányítást.

170
00:12:53,510 --> 00:12:58,750
>> Oh. Azt hiszem, még egy egység átirányítás, ha ahelyett, hogy> te 2>,

171
00:12:58,750 --> 00:13:01,070
ez átirányítása standard hibája.

172
00:13:01,070 --> 00:13:06,280
Tehát, ha valami elment standard hiba, akkor nem kap helyezett txt2.

173
00:13:06,280 --> 00:13:12,480
De észre, ha én 2>, akkor még mindig nyomtatás Hello, Rob! a parancssorba

174
00:13:12,480 --> 00:13:18,600
mert én csak átirányításával standard hiba, nem vagyok átirányítása szabványos ki.

175
00:13:18,600 --> 00:13:22,210
Standard hiba és standard out különböző.

176
00:13:24,210 --> 00:13:27,080
Ha akarta, hogy ténylegesen írni a standard hiba,

177
00:13:27,080 --> 00:13:35,080
akkor tudtam változtatni, hogy ez fprintf az stderr.

178
00:13:35,080 --> 00:13:37,850
Szóval printf alapértelmezés szerint kiírja a szabványos ki.

179
00:13:37,850 --> 00:13:41,720
Ha azt szeretnénk, hogy nyomtatni standard hiba manuálisan, akkor azt kell használni fprintf

180
00:13:41,720 --> 00:13:45,010
és meghatározza, hogy mit akarok nyomtatni.

181
00:13:45,010 --> 00:13:49,720
Ha ehelyett tettem fprintf stdout, akkor ez lényegében egyenértékű a printf.

182
00:13:49,720 --> 00:13:55,530
De fprintf a standard hiba.

183
00:13:57,790 --> 00:14:03,650
Tehát most, ha én irányítani ezt figyelembe txt2, Hello, Rob! még mindig egyre nyomtatva a parancssorban

184
00:14:03,650 --> 00:14:08,270
mivel ez kezd nyomtatni a szabványos hiba, és én csak átirányítása szabványos ki.

185
00:14:08,270 --> 00:14:16,420
Ha most átirányítás standard hiba, most már nem kap nyomtatott, és txt2 lesz Hello, Rob!

186
00:14:16,420 --> 00:14:21,910
Tehát most, akkor nyomtassa ki a tényleges hibák standard hiba

187
00:14:21,910 --> 00:14:24,720
és nyomtassa ki a rendszeres üzeneteket a szabványos ki.

188
00:14:24,720 --> 00:14:31,420
És így, amikor futtatja a programot, futtathatja azt. / Hello ilyen típusú, a 2>

189
00:14:31,420 --> 00:14:33,800
úgy, hogy a program fog futni rendesen,

190
00:14:33,800 --> 00:14:38,400
de minden hibaüzeneteket kapsz akkor megtekintéséhez később a error log,

191
00:14:38,400 --> 00:14:44,500
olyan hibákat, majd nézze meg később, és a hibák fájl bármilyen hiba történt.

192
00:14:45,200 --> 00:14:47,540
>> Kérdései vannak?

193
00:14:47,540 --> 00:14:58,070
>> Az utolsó egy cső, amit lehet gondolni, mint vevő a szabványos ki egy parancsot

194
00:14:58,070 --> 00:15:01,210
, és ezzel a szabvány a következő parancsot.

195
00:15:01,210 --> 00:15:05,570
Egy példa itt echo egy parancssori dolog

196
00:15:05,570 --> 00:15:11,840
hogy csak megy, echo, amit tettem, mint érvelését. Nem fogom idézetek.

197
00:15:11,840 --> 00:15:16,150
Echo bla, bla, bla éppen nyomdába bla, bla, bla.

198
00:15:16,150 --> 00:15:20,600
Előtt, amikor azt mondtam, el kellett halasztania Rob egy txt fájlba

199
00:15:20,600 --> 00:15:28,830
mert én csak átirányítani txt fájlokat, ahelyett, / ha én echo Rob

200
00:15:28,830 --> 00:15:35,520
majd a cső be. / hello, amely szintén nem ugyanaz a típusú dolog.

201
00:15:35,520 --> 00:15:39,160
Ezt figyelembe a parancs kimenete, echo Rob,

202
00:15:39,160 --> 00:15:43,610
és használja, mint a bemenet. / hello.

203
00:15:44,790 --> 00:15:49,560
Azt hiszem, hogy ez egy elsőnek echo Rob fájlba

204
00:15:49,560 --> 00:15:54,160
majd viszi be. / hello, hogy a fájl az éppen kimeneten.

205
00:15:54,160 --> 00:15:57,850
De azon az ideiglenes fájlt ki a képet.

206
00:16:01,890 --> 00:16:04,460
>> Kérdések az?

207
00:16:04,460 --> 00:16:07,150
>> A következő kérdés az lesz, hogy vonják ezt.

208
00:16:07,150 --> 00:16:15,310
Mit csővezeték használja, hogy megtalálja a számos egyedi nevek nevű fájlt names.txt?

209
00:16:15,310 --> 00:16:24,160
A parancsok fogunk használni kívánt itt egyedi, így uniq, majd a wc.

210
00:16:24,160 --> 00:16:28,840
Meg tudod csinálni ember uniq, hogy ténylegesen nézni, hogy ez mit jelent,

211
00:16:28,840 --> 00:16:34,840
és ez csak úgy, hogy kiszűrje szomszédos megfelelő sorokat a bemenet.

212
00:16:34,840 --> 00:16:40,690
És a férfi wc fog nyomtatni az új sor, szó, és a byte számít minden fájlt.

213
00:16:40,690 --> 00:16:43,760
És az utolsó fogunk használni kívánt egyfajta,

214
00:16:43,760 --> 00:16:47,410
ami majd csak egyfajta vonalak txt fájl.

215
00:16:47,410 --> 00:16:58,080
Ha azt, hogy néhány txt fájl, names.txt, és ez Rob, Tommy, Joseph, Tommy, Joseph, RJ, Rob,

216
00:16:58,080 --> 00:17:03,910
hogy mit akarok itt találja a számos egyedi nevek ebben a fájlban.

217
00:17:03,910 --> 00:17:08,750
Szóval, mi legyen a válasz lenni? >> [Hallgató] 4. >> Igen.

218
00:17:08,750 --> 00:17:13,780
Meg kell 4 óta Rob, Tommy, Joseph, RJ az egyetlen egyedi nevek ebben a fájlban.

219
00:17:13,780 --> 00:17:20,180
Az első lépés, ha csak nem szóból on names.txt,

220
00:17:20,180 --> 00:17:24,290
ez tényleg mond el mindent.

221
00:17:24,290 --> 00:17:32,560
Ez valójában nyomtatás - Lássuk, férfi wc - újsor, szavak és Bájtszám.

222
00:17:32,560 --> 00:17:38,270
Ha csak érdekel a sorok, akkor én is csak csináld wc-l names.txt.

223
00:17:41,730 --> 00:17:44,300
Szóval ez az 1. lépést.

224
00:17:44,300 --> 00:17:50,510
De én nem akarok wc-l names.txt mert names.txt csak tartalmazza mindazokat a neveket,

225
00:17:50,510 --> 00:17:54,170
és azt akarom, hogy kiszűrje a nem egyedi is.

226
00:17:54,170 --> 00:18:01,200
Szóval, ha én uniq names.txt, hogy nem egészen add nekem, amit akarok

227
00:18:01,200 --> 00:18:03,760
mert a duplikált nevek még mindig ott vannak.

228
00:18:03,760 --> 00:18:07,690
Miért van ez? Miért uniq nem azt teszi, amit akarok?

229
00:18:07,690 --> 00:18:10,500
[Hallgató] A másolatok nem [hallható] >> Igen.

230
00:18:10,500 --> 00:18:16,370
Ne feledje, a man oldalt a uniq mondja szűrő szomszédos illeszkedő sorokat.

231
00:18:16,370 --> 00:18:19,680
Ők nem szomszédos, így nem fogja kiszűrni őket.

232
00:18:19,680 --> 00:18:31,100
Ha rendezni őket először, egyfajta names.txt megy, hogy az összes ismétlődő sorok együtt.

233
00:18:31,100 --> 00:18:34,450
Tehát most sort names.txt hogy.

234
00:18:34,450 --> 00:18:40,550
Fogom használni kívánt, hogy mivel a bemeneti uniq, ami | uniq.

235
00:18:40,550 --> 00:18:43,390
Ez ad nekem Joseph, RJ, Rob, Tommy,

236
00:18:43,390 --> 00:18:49,260
és szeretném használni, hogy a bemeneti wc-l,

237
00:18:49,260 --> 00:18:52,740
amely fog adni nekem 4.

238
00:18:52,740 --> 00:18:56,930
Mint azt mondja itt, mit csővezeték használ?

239
00:18:56,930 --> 00:19:01,390
Meg tudod csinálni egy csomó dolgot, mint egy sor parancs

240
00:19:01,390 --> 00:19:05,130
ha használja a kimenet egyik parancs a bemenet a következő parancsot.

241
00:19:05,130 --> 00:19:08,780
Meg tudod csinálni egy csomó dolgot, sok okos dolgot.

242
00:19:08,780 --> 00:19:11,440
>> Kérdései vannak?

243
00:19:12,910 --> 00:19:14,600
Oké.

244
00:19:14,600 --> 00:19:17,880
Ennyi csövek és átirányítása.

245
00:19:18,370 --> 00:19:24,090
>> Most megy a tényleges dolgokat, a kódolási dolgokat.

246
00:19:24,090 --> 00:19:29,100
Belül a PDF, látni fogod ezt a parancsot,

247
00:19:29,100 --> 00:19:32,950
és akkor szeretné futtatni ezt a parancsot a készülékben.

248
00:19:36,240 --> 00:19:42,250
wget a parancs csak arra, hogy valamit az interneten, alapjában véve,

249
00:19:42,250 --> 00:19:45,180
így wget és URL.

250
00:19:45,180 --> 00:19:49,110
Ha ment az URL a böngészőben, akkor letölteni ezt a fájlt.

251
00:19:49,110 --> 00:19:52,510
Én csak kattintott rá, így a letöltött fájlt nekem.

252
00:19:52,510 --> 00:19:55,650
De írásban wget e dolog belsejében a terminál

253
00:19:55,650 --> 00:19:58,620
csak megy letöltéséhez be terminál.

254
00:19:58,620 --> 00:20:02,750
Én section5.zip, és akkor szeretnénk unzip section5.zip,

255
00:20:02,750 --> 00:20:06,520
amely majd kapsz egy mappát nevű 5. pontjának,

256
00:20:06,520 --> 00:20:11,550
ami megy, hogy az összes fájlt fogunk használni ma benne.

257
00:20:33,380 --> 00:20:37,710
Mivel ezek a programok "fájlneveket sugallják, ők egy kicsit bugos,

258
00:20:37,710 --> 00:20:40,990
így a küldetése, hogy kitaláljuk, miért használ gdb.

259
00:20:40,990 --> 00:20:44,560
Mindenki azt nekik Letöltött / tudják, hogyan kell kérni őket Letöltött

260
00:20:44,560 --> 00:20:47,480
be a készülék? Oké.

261
00:20:47,480 --> 00:20:56,400
>> Futás ./buggy1, azt fogja mondani Segmentation fault (core dump),

262
00:20:56,400 --> 00:21:00,500
amely minden alkalommal, amikor kap egy segfault, ez egy rossz dolog.

263
00:21:00,500 --> 00:21:03,810
Milyen körülmények között nem kapja segfault?

264
00:21:03,810 --> 00:21:08,210
[Hallgató] Dereferencing egy null pointer. >> Igen. Annak érdekében, hogy csak egy példa.

265
00:21:08,210 --> 00:21:11,580
Dereferencing null pointer fogsz kapni a segfault.

266
00:21:11,580 --> 00:21:16,720
Milyen segfault azt jelenti, amit megható memória nem kell érjen.

267
00:21:16,720 --> 00:21:21,350
Tehát dereferencing null pointer hozzáér cím 0,

268
00:21:21,350 --> 00:21:28,060
és lényegében az összes számítógép manapság azt mondják, hogy a 0 címet a memória nem kell érjen.

269
00:21:28,060 --> 00:21:31,920
Szóval ezért dereferencing null pointer eredményez segfault.

270
00:21:31,920 --> 00:21:37,210
Ha történetesen nem inicializálja a mutatót, akkor egy szemét érték,

271
00:21:37,210 --> 00:21:41,520
és így, amikor megpróbál dereference azt minden valószínűség amit megható memória

272
00:21:41,520 --> 00:21:43,540
ez a semmi közepén.

273
00:21:43,540 --> 00:21:45,650
Ha történetesen szerencsés, és a szemetet érték

274
00:21:45,650 --> 00:21:48,440
történt, hogy pont valahol a verem, vagy valami,

275
00:21:48,440 --> 00:21:50,820
majd amikor dereference hogy pointer, amelyek még nem inicializált,

276
00:21:50,820 --> 00:21:52,730
semmi baj.

277
00:21:52,730 --> 00:21:55,480
De ha ez mutat, mondjuk, valahol a stack és a heap,

278
00:21:55,480 --> 00:21:59,850
vagy ez mutat csak valahol, hogy nem használja a program még

279
00:21:59,850 --> 00:22:02,240
akkor már megható memória nem kell érjen, és segfault.

280
00:22:02,240 --> 00:22:06,370
Amikor leír egy rekurzív függvény, és ez recurses túl sokszor

281
00:22:06,370 --> 00:22:08,720
és a stack nő túl nagy, és a köteget ütközik a dolgok

282
00:22:08,720 --> 00:22:12,270
hogy nem kell az ütközést, te megható memória nem kell megható,

283
00:22:12,270 --> 00:22:14,810
így segfault.

284
00:22:14,810 --> 00:22:17,010
Ez az, amit egy segfault van.

285
00:22:17,010 --> 00:22:21,810
>> Ez is ugyanebből az okból, hogy ha van egy string, mint -

286
00:22:21,810 --> 00:22:23,930
menjünk vissza az előző programhoz.

287
00:22:23,930 --> 00:22:28,530
In hello.c--Én csak megy, hogy valami mást.

288
00:22:28,530 --> 00:22:33,770
char * s = "hello world!";

289
00:22:33,770 --> 00:22:42,310
Ha valaki használja a * s = vagy valami s [0] = 'X';

290
00:22:42,310 --> 00:22:47,290
úgyhogy győződjön hello,. / hello, miért azt segfault?

291
00:22:48,410 --> 00:22:51,250
Miért ez a segfault?

292
00:22:55,660 --> 00:22:57,890
Mit vársz történni?

293
00:22:57,890 --> 00:23:06,640
Ha én tettem printf ("% s \ n", s), mit vársz a nyomtatandó?

294
00:23:06,640 --> 00:23:09,930
[Hallgató] X hello. >> Igen.

295
00:23:09,930 --> 00:23:15,140
A probléma az, hogy amikor nyilvánítja egy string, mint ez,

296
00:23:15,140 --> 00:23:18,190
s egy mutató, hogy fog menni a stack,

297
00:23:18,190 --> 00:23:25,880
és mi s mutat ez a szöveg, amely tartalmazza a csak olvasható memória.

298
00:23:25,880 --> 00:23:30,560
Tehát csak a neve, csak olvasható memória, akkor az ötlet

299
00:23:30,560 --> 00:23:33,010
hogy ha megpróbál változtatni, mi van a csak olvasható memória,

300
00:23:33,010 --> 00:23:36,670
csinál valamit, amit nem kellene ezzel a memória és segfault.

301
00:23:36,670 --> 00:23:45,360
Ez valójában egy nagy különbség char * s és char s [].

302
00:23:45,360 --> 00:23:48,790
Szóval char s [], most ez a sztring fog tenni a stack,

303
00:23:48,790 --> 00:23:53,960
és a verem, nem csak olvasható, ami azt jelenti, hogy ez működik tökéletesen.

304
00:23:55,500 --> 00:23:57,370
És igen.

305
00:23:57,370 --> 00:24:06,250
Ne feledje, hogy amikor én char * s = "hello world!", S maga a verem

306
00:24:06,250 --> 00:24:10,390
de s rámutat arra, hogy valahol máshol, és hogy valahol máshol történik, hogy csak olvasható.

307
00:24:10,390 --> 00:24:15,640
De char s [] csak valami a verem.

308
00:24:17,560 --> 00:24:21,760
Szóval ez egy másik példa a segfault történik.

309
00:24:21,760 --> 00:24:27,820
>> Láttuk, hogy ./buggy1 eredményezett segfault.

310
00:24:27,820 --> 00:24:31,810
Elméletileg, nem kell nézni buggy1.c azonnal.

311
00:24:31,810 --> 00:24:35,170
Ehelyett, akkor nézd meg a gdb.

312
00:24:35,170 --> 00:24:37,750
Figyelje meg, hogy amikor megkapja Segmentation fault (core dump),

313
00:24:37,750 --> 00:24:40,850
Önnek ezt a fájlt ide nevezett mag.

314
00:24:40,850 --> 00:24:45,200
Ha ls-l, látni fogjuk, hogy a mag általában elég nagy fájlt.

315
00:24:45,200 --> 00:24:51,580
Ez a bájtok száma a fájl, így úgy néz ki, ez 250-valami kilobyte.

316
00:24:51,580 --> 00:24:56,120
Ennek az az oka, hogy amit az veremkiíratást valójában

317
00:24:56,120 --> 00:25:01,410
amikor a program lefagy, az állam a memória a program

318
00:25:01,410 --> 00:25:05,230
Csak kap illesztenie ezt a fájlt.

319
00:25:05,230 --> 00:25:07,270
Ez lesz dömpingelt figyelembe, hogy a fájl.

320
00:25:07,270 --> 00:25:13,060
Ez a program, miközben azt is fut, történt, hogy egy memóriahasználat mintegy 250 kilobyte,

321
00:25:13,060 --> 00:25:17,040
és így ez az, amit kaptam dömpingelt ebbe a fájlba.

322
00:25:17,040 --> 00:25:23,630
Most nézd meg ezt a fájlt, ha nem teszünk gdb buggy1 mag.

323
00:25:23,630 --> 00:25:30,130
Mi csak ezt gdb buggy1, és hogy majd csak elindul gdb rendszeresen,

324
00:25:30,130 --> 00:25:33,800
használja buggy1 mint a bemeneti fájl.

325
00:25:33,800 --> 00:25:38,260
De ha gdb buggy1 mag, akkor ez kifejezetten fog indítani gdb

326
00:25:38,260 --> 00:25:40,330
megnézi, hogy a core fájlt.

327
00:25:40,330 --> 00:25:45,560
És mondja buggy1 eszközök gdb tudja, hogy core fájlt származik buggy1 program.

328
00:25:45,560 --> 00:25:49,580
Szóval gdb buggy1 mag fog azonnal hoz nekünk

329
00:25:49,580 --> 00:25:52,060
, ahol a programot történt megszüntetésére.

330
00:25:57,720 --> 00:26:02,340
Látunk itt Program szüntetni jel 11-Segmentation fault.

331
00:26:02,340 --> 00:26:10,110
Mi történik, ha egy sor szerelvény, amely valószínűleg nem nagyon hasznos.

332
00:26:10,110 --> 00:26:15,360
De ha beírja bt vagy backtrace, ez lesz a függvény

333
00:26:15,360 --> 00:26:19,430
hogy megadja nekünk a lista a jelenlegi verem kereteket.

334
00:26:19,430 --> 00:26:23,150
Szóval backtrace. Úgy néz ki, már csak két verem kereteket.

335
00:26:23,150 --> 00:26:26,310
Az első fő stack frame,

336
00:26:26,310 --> 00:26:29,810
a második pedig a verem keret ezt a funkciót, hogy mi történik, hogy legyen,

337
00:26:29,810 --> 00:26:34,440
amely úgy néz ki, mint mi csak a szerelvény kód.

338
00:26:34,440 --> 00:26:38,050
Akkor menjünk vissza a fő funkciója,

339
00:26:38,050 --> 00:26:42,300
és erre tehetünk keret 1, és azt hiszem, mi is ezt le,

340
00:26:42,300 --> 00:26:45,160
de én szinte soha nem le - vagy felfelé. Igen.

341
00:26:45,160 --> 00:26:50,710
Fel és le. Up hozza létre egy verem keret megállapításáról hozza le egy verem keret.

342
00:26:50,710 --> 00:26:53,240
Én inkább nem használni.

343
00:26:53,240 --> 00:26:59,120
Csak kifejezetten mondom 1. keret, amely a megy a keret jelölése 1.

344
00:26:59,120 --> 00:27:01,750
Keret 1 fog hozni minket fő stack frame,

345
00:27:01,750 --> 00:27:05,570
és azt mondja, itt a sorban a kódot, történetesen a.

346
00:27:05,570 --> 00:27:07,950
Ha volna még egy pár sornyi kódot, azt mondhatjuk, lista,

347
00:27:07,950 --> 00:27:11,280
és ez fog adni nekünk minden sornyi kódot körül.

348
00:27:11,280 --> 00:27:13,360
A vonal amit segfaulted at 6 volt:

349
00:27:13,360 --> 00:27:17,360
if (strcmp ("CS50 sziklák", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
Ha nem egyértelmű még, akkor kap egyenesen az itt csak a gondolkodás, hogy miért segfaulted.

351
00:27:24,130 --> 00:27:28,800
De vehetjük, hogy egy lépéssel tovább, és azt mondják: "Miért argv [1] segfault?"

352
00:27:28,800 --> 00:27:38,830
Nézzük print argv [1], és úgy néz ki ez az 0x0, ami a null mutató.

353
00:27:38,830 --> 00:27:44,750
Mi strcmping CS50 sziklák és null, és hogy fog segfault.

354
00:27:44,750 --> 00:27:48,280
És miért argv [1] null?

355
00:27:48,640 --> 00:27:51,280
[Hallgató] Mivel nem adja meg semmilyen parancssori argumentumok.

356
00:27:51,280 --> 00:27:53,390
Igen. Mi nem adja meg semmilyen parancssori argumentumok.

357
00:27:53,390 --> 00:27:58,460
Tehát ./buggy1 csak megy, hogy argv [0] lesz ./buggy1.

358
00:27:58,460 --> 00:28:02,100
Ez nem megy, hogy egy argv [1], hogy fog segfault.

359
00:28:02,100 --> 00:28:07,450
De ha ehelyett én csak CS50, ez fog mondani Kapsz egy D

360
00:28:07,450 --> 00:28:09,950
mert ez az, amit kéne csinálni.

361
00:28:09,950 --> 00:28:15,240
Nézve buggy1.c, ez állítólag print "Kapsz egy D" -

362
00:28:15,240 --> 00:28:20,820
Ha az argv [1] A nem "CS50 sziklákat", "Kapsz egy D", más "Kapsz egy A!"

363
00:28:20,820 --> 00:28:25,660
Szóval, ha azt szeretné, hogy A, szükségünk van erre összehasonlítani, mint igaz,

364
00:28:25,660 --> 00:28:28,710
ami azt jelenti, hogy összehasonlítja 0-ra.

365
00:28:28,710 --> 00:28:31,100
Szóval, argv [1] kell "CS50 sziklák".

366
00:28:31,100 --> 00:28:35,660
Ha azt akarod, hogy a parancssorban, akkor kell használni, \, hogy elkerülje a helyet.

367
00:28:35,660 --> 00:28:41,690
Szóval CS50 \ sziklák és kapsz egy A!

368
00:28:41,690 --> 00:28:44,060
Ha nem teszed a backslash, miért ez nem működik?

369
00:28:44,060 --> 00:28:47,190
[Hallgató] Ez két különböző érveket. >> Igen.

370
00:28:47,190 --> 00:28:52,540
Argv [1] lesz CS50, és argv [2] lesz sziklák. Oké.

371
00:28:52,540 --> 00:28:56,470
>> Most ./buggy2 fog segfault újra.

372
00:28:56,470 --> 00:29:01,880
Ahelyett, hogy kinyitotta a core fájlt, akkor csak megnyitja buggy2 közvetlenül,

373
00:29:01,880 --> 00:29:05,000
így gdb buggy2.

374
00:29:05,000 --> 00:29:09,590
Most, ha csak fut a program, akkor ez fog mondani Program vett jelet SIGSEGV,

375
00:29:09,590 --> 00:29:15,530
amely a segfault jel, és ez az, ahol az történt, hogy megtörténjen.

376
00:29:15,530 --> 00:29:21,250
Keresi a mi backtrace, azt látjuk, hogy mi volt a funkció oh_no,

377
00:29:21,250 --> 00:29:23,900
amely által hívott függvény Dinky, amit hívott függvény Muci,

378
00:29:23,900 --> 00:29:26,460
amit hívott fő.

379
00:29:26,460 --> 00:29:31,680
Azt is látni az érveket, hogy ezeket a funkciókat.

380
00:29:31,680 --> 00:29:34,680
Az az érv, hogy takaros és Muci 1. volt.

381
00:29:34,680 --> 00:29:44,390
Ha sorolja a funkciót oh_no, azt látjuk, hogy oh_no éppen csinál char ** s = NULL;

382
00:29:44,390 --> 00:29:47,410
* S = "BOOM";

383
00:29:47,410 --> 00:29:50,330
Miért, hogy nem?

384
00:29:54,330 --> 00:29:58,380
[Hallgató] Nem lehet feloldani a null pointer? >> Igen.

385
00:29:58,380 --> 00:30:06,090
Ez csak azt mondom, s NULL, függetlenül attól, hogy ez történik, hogy egy char **,

386
00:30:06,090 --> 00:30:12,070
amely, attól függően, hogy hogyan értelmezzük azt, lehet, hogy a mutató egy mutató egy string

387
00:30:12,070 --> 00:30:15,550
vagy egy sor húrok.

388
00:30:15,550 --> 00:30:21,430
Ez s NULL, tehát * s dereferencing egy null pointer,

389
00:30:21,430 --> 00:30:24,800
és így ez fog zuhanni.

390
00:30:24,800 --> 00:30:27,540
Ez az egyik leggyorsabb módon lehet esetleg segfault.

391
00:30:27,540 --> 00:30:31,300
Ez csak nyilvánító null pointer és azonnal segfaulting.

392
00:30:31,300 --> 00:30:34,570
Ez az, amit oh_no csinál.

393
00:30:34,570 --> 00:30:43,400
Ha felmegyünk egy keret, akkor fogunk bejutni a funkció hívott oh_no.

394
00:30:43,400 --> 00:30:44,830
Azt kell csinálni, hogy le.

395
00:30:44,830 --> 00:30:48,610
Ha nem adja meg a parancsot, és csak nyomja meg újra az Enter,

396
00:30:48,610 --> 00:30:52,350
akkor csak ismételje meg az előző parancsot, hogy futott.

397
00:30:52,350 --> 00:30:56,610
Mi vagyunk a keretben 1.

398
00:30:56,610 --> 00:31:04,650
Lista ez a keret, azt látjuk, itt a mi funkció.

399
00:31:04,650 --> 00:31:08,520
A találati lista újra, vagy meg tudod csinálni listát 20 és kiírja tovább.

400
00:31:08,520 --> 00:31:13,640
A funkció Dinky mondja, ha i = 1, akkor megy a oh_no funkció

401
00:31:13,640 --> 00:31:15,960
más megy a feszes funkciót.

402
00:31:15,960 --> 00:31:18,700
És tudjuk, i = 1, mert megtörténhet, hogy ide

403
00:31:18,700 --> 00:31:22,560
hogy Dinky hívták azzal az érvvel 1.

404
00:31:22,560 --> 00:31:27,560
Vagy csak nem nyomtatni i és azt fogja mondani i 1 lehet.

405
00:31:27,560 --> 00:31:33,770
Jelenleg is takaros, és ha elmegyünk egy másik frame, tudjuk, mi a végén Muci.

406
00:31:33,770 --> 00:31:36,600
Up. Most vagyunk Muci.

407
00:31:36,600 --> 00:31:41,340
Felsorolása ezt a funkciót - a lista előtti 1/2 vágott le engem -

408
00:31:41,340 --> 00:31:52,670
úgy indult, mint ha én 0, akkor fogjuk hívni oh_no, különben hívja takaros.

409
00:31:52,670 --> 00:31:57,000
Tudjuk, hogy voltam 1, ezért úgynevezett takaros.

410
00:31:57,000 --> 00:32:05,030
És most újra itt vagyunk a fő, és fontosabb éppen lesz int i = rand ()% 3;

411
00:32:05,030 --> 00:32:08,790
Ez csak megy, hogy ön egy véletlen számot, amely vagy 0, 1, vagy 2.

412
00:32:08,790 --> 00:32:12,780
Meg fog hívni Muci ezzel a számmal, és vissza fog térni 0.

413
00:32:12,780 --> 00:32:16,700
Nézi most ezt,

414
00:32:16,700 --> 00:32:19,880
Csak séta a program kézi nélkül fut, hogy azonnal,

415
00:32:19,880 --> 00:32:25,400
akkor be egy töréspontot a fő, ami azt jelenti, hogy amikor a program futtatásához

416
00:32:25,400 --> 00:32:31,020
A program fut, amíg eléri a töréspontot.

417
00:32:31,020 --> 00:32:35,450
Így fut a program, akkor fog futni, és akkor majd nyomja meg a fő funkciója, és leáll.

418
00:32:35,450 --> 00:32:44,700
Most bent vagyunk a fő, és a lépést vagy mellette fog hozni minket a következő sort.

419
00:32:44,700 --> 00:32:47,050
Meg tudod csinálni, vagy a következő lépést.

420
00:32:47,050 --> 00:32:51,800
Következő slágere, most már van állítva rand ()% 3, így tudjuk nyomtatni az i értékét,

421
00:32:51,800 --> 00:32:55,280
és azt fogja mondani, i 1 lehet.

422
00:32:55,280 --> 00:32:58,110
Most nem számít, hogy az általunk használt vagy következő lépés.

423
00:32:58,110 --> 00:33:01,000
Azt hiszem, ez számít az előző, de azt szeretnénk használni a következő.

424
00:33:01,000 --> 00:33:06,000
Ha az általunk használt lépésben, belépünk a funkció, ami azt jelenti, nézd meg a tényleges dolog

425
00:33:06,000 --> 00:33:07,940
ez történik belül Muci.

426
00:33:07,940 --> 00:33:10,510
Ha az általunk használt mellett, akkor az azt jelenti, megy át a függvény

427
00:33:10,510 --> 00:33:14,070
és csak megy a következő sort a mi fő funkciója.

428
00:33:14,070 --> 00:33:17,900
Itt ezen a vonalon, voltam, ahol azt mondta, rand ()% 3;

429
00:33:17,900 --> 00:33:21,320
ha mégis lépést, akkor menj be a végrehajtását rand

430
00:33:21,320 --> 00:33:25,110
és nézd meg, mi történik ott, és én végig a rand függvény.

431
00:33:25,110 --> 00:33:26,920
De nem érdekel a rand függvényt.

432
00:33:26,920 --> 00:33:30,190
Csak azt akarom, hogy ugorjon a következő sort a fő, ezért használja a következő.

433
00:33:30,190 --> 00:33:35,800
De most már nem érdekel a Muci funkciót, ezért szeretném, hogy belépjünk ezt.

434
00:33:35,800 --> 00:33:37,730
Most vagyok Muci.

435
00:33:37,730 --> 00:33:42,040
Az első sort fog mondani, ha (i == 0), én egy lépést,

436
00:33:42,040 --> 00:33:44,930
azt látjuk, hogy a végén a takaros.

437
00:33:44,930 --> 00:33:51,620
Ha lista dolgokat, azt látjuk, hogy ellenőrzött i = 0.

438
00:33:51,620 --> 00:33:55,470
i nem egyenlő 0-val, így elment a más feltételt,

439
00:33:55,470 --> 00:33:59,540
amely a fog hívni takaros (i).

440
00:33:59,540 --> 00:34:04,030
Lehet, hogy összezavarodnak.

441
00:34:04,030 --> 00:34:07,380
Ha csak nézd meg ezeket a sorokat közvetlenül, akkor hiszem, ha (i == 0),

442
00:34:07,380 --> 00:34:10,800
oké, aztán tett egy lépést, és most én vagyok a takaros (i),

443
00:34:10,800 --> 00:34:14,120
azt gondolhatja, hogy azt jelenti i = 0, vagy ilyesmi.

444
00:34:14,120 --> 00:34:18,980
Nem, csak azt jelenti, hogy tudja, akkor ragaszkodni közvetlenül a hálózati takaros (i).

445
00:34:18,980 --> 00:34:23,300
Mert én nem 0, a következő lépés nem fog véget a mást.

446
00:34:23,300 --> 00:34:26,239
Különben nem egy sort, hogy fog megállni.

447
00:34:26,239 --> 00:34:31,570
Ez csak fog menni a következő sorra, hogy ténylegesen végre, ami takaros (i).

448
00:34:31,570 --> 00:34:36,090
Lépve Dinky (i), azt látjuk, hogy (i == 1).

449
00:34:36,090 --> 00:34:42,670
Tudjuk, i = 1, így amikor belépünk, tudjuk, mi lesz a vége fel oh_no

450
00:34:42,670 --> 00:34:46,489
mert i = 1 meghívja a függvényt oh_no, amelyek segítségével belép,

451
00:34:46,489 --> 00:34:52,969
amely a fog beállítani char ** s = NULL és azonnal "BOOM".

452
00:34:54,270 --> 00:34:59,690
És akkor tényleg nézi most végrehajtásának buggy2,

453
00:34:59,690 --> 00:35:04,590
ezt, az i csak most egy véletlen szám - 0, 1, vagy 2 - hívás Muci,

454
00:35:04,590 --> 00:35:10,610
amelyek, ha i értéke 0 szólít oh_no, különben arra kéri Dinky, ami jön ide.

455
00:35:10,610 --> 00:35:18,100
Ha én 1, hívás oh_no, különben hívja feszes, ami jön ide,

456
00:35:18,100 --> 00:35:20,460
ha i = 2, hívja oh_no.

457
00:35:20,460 --> 00:35:24,720
Nem is hiszem, hogy van egy módja -

458
00:35:24,720 --> 00:35:30,030
Látja valaki egy módja annak, hogy ezt a programot, amely nem segfault?

459
00:35:30,030 --> 00:35:37,530
Mert hacsak nem én vagyok hiányzik valami, ha én értéke 0, akkor azonnal segfault,

460
00:35:37,530 --> 00:35:41,250
mást elmész egy függvény, amely, ha én az 1 ha segfault,

461
00:35:41,250 --> 00:35:44,540
mást elmész egy függvény, ahol ha az i 2-t segfault.

462
00:35:44,540 --> 00:35:46,810
Tehát nem számít, mit teszel, segfault.

463
00:35:46,810 --> 00:35:52,380
>> Azt hiszem, az egyik módja a rögzítés lenne, ahelyett, hogy char ** s = NULL,

464
00:35:52,380 --> 00:35:55,610
akkor malloc helyet adott string.

465
00:35:55,610 --> 00:36:04,230
Megtehetjük malloc (sizeof) - sizeof mi?

466
00:36:09,910 --> 00:36:15,190
[Hallgató] (char) * 5? >> Vajon ez úgy tűnik, nem igaz?

467
00:36:15,190 --> 00:36:21,060
Én feltételezve, hogy ez működni fog, ha én valóban futott, de ez nem az, amit én keresek.

468
00:36:24,400 --> 00:36:32,940
Nézd típusának s. Adjunk hozzá int *, így int * x.

469
00:36:32,940 --> 00:36:35,600
Én megtenném malloc (sizeof (int)).

470
00:36:35,600 --> 00:36:40,490
Vagy ha akartam egy sor 5, megtenném (sizeof (int) * 5);

471
00:36:40,490 --> 00:36:44,210
Mit tegyek, ha egy int **?

472
00:36:46,260 --> 00:36:49,140
Mit tettem volna malloc?

473
00:36:49,140 --> 00:36:53,510
[Hallgató] mérete a mutatót. >> Igen. (Sizeof (int *));

474
00:36:53,510 --> 00:36:56,960
Ugyanaz itt lent.

475
00:36:56,960 --> 00:37:01,280
Azt akarom, (sizeof (char *));

476
00:37:06,170 --> 00:37:12,840
Ez fog kiosztani hely a mutató, amely rámutat, hogy "BOOM".

477
00:37:12,840 --> 00:37:15,330
Nem kell kiosztani hely "BOOM" maga

478
00:37:15,330 --> 00:37:17,210
mert ez alapvetően megegyezik azzal, amit korábban mondtam

479
00:37:17,210 --> 00:37:20,870
A char * x = "BOOM".

480
00:37:20,870 --> 00:37:27,950
"BOOM" már létezik. Előfordul, hogy létezik a csak olvasható régió memória.

481
00:37:27,950 --> 00:37:35,200
De ez már létezik, ami ezt a kódsort, ha s egy char **,

482
00:37:35,200 --> 00:37:43,900
akkor * s egy char * és te ha ezt char * hogy pont a "BOOM".

483
00:37:43,900 --> 00:37:50,040
Ha akartam másolni "BOOM" be s, akkor azt kell, hogy fordítsanak helyet s.

484
00:37:55,170 --> 00:38:03,900
Megteszek * s = malloc (sizeof (char) * 5);

485
00:38:03,900 --> 00:38:06,210
Miért 5?

486
00:38:06,210 --> 00:38:10,860
Miért nem 4? Úgy néz ki, mint a "boom" a 4 karakter. >> [Hallgató] A null karakter.

487
00:38:10,860 --> 00:38:14,580
Igen. Minden a húrok lesz szüksége a null karakter.

488
00:38:14,580 --> 00:38:23,590
Most már meg tudom csinálni valami hasonlót strcat - Mi a szerepe a másoláshoz karakterlánc?

489
00:38:23,590 --> 00:38:28,520
[Hallgató] cpy? >> Strcpy.

490
00:38:28,520 --> 00:38:32,700
man strcpy.

491
00:38:36,120 --> 00:38:39,590
Szóval strcpy vagy strncpy.

492
00:38:39,590 --> 00:38:43,410
strncpy egy kicsit biztonságosabb, mert megadhatja, hogy pontosan hány karakter,

493
00:38:43,410 --> 00:38:46,190
de itt ez nem számít, mert tudjuk.

494
00:38:46,190 --> 00:38:50,340
Szóval strcpy és nézz az érvek.

495
00:38:50,340 --> 00:38:53,100
Az első érv az úti célunk.

496
00:38:53,100 --> 00:38:56,770
A második érv a forrás.

497
00:38:56,770 --> 00:39:10,310
Fogunk másolni úti célunk * s mutató "BOOM".

498
00:39:10,310 --> 00:39:19,820
Miért is akarod, hogy ezt a strcpy ahelyett, hogy csak amit azelőtt

499
00:39:19,820 --> 00:39:22,800
A * s = "BOOM"?

500
00:39:22,800 --> 00:39:28,630
Van egy ok, amiért érdemes ezt tenni, de mi az, hogy oka?

501
00:39:28,630 --> 00:39:31,940
[Hallgató] Ha szeretne valamit változtatni a "BOOM". >> Igen.

502
00:39:31,940 --> 00:39:37,950
Most már meg tudom csinálni valami hasonlót s [0] = 'X';

503
00:39:37,950 --> 00:39:48,190
mert s rámutat arra, hogy a halom, és hely a heap hogy s mutat

504
00:39:48,190 --> 00:39:52,320
egy mutató több helyet a heap, amely tárolja "BOOM".

505
00:39:52,320 --> 00:39:55,150
Szóval ezt a példányt a "boom" van tárolva a kupac.

506
00:39:55,150 --> 00:39:58,780
Van technikailag két példányban a "boom" a mi program.

507
00:39:58,780 --> 00:40:03,500
Itt az első, hogy ez csak az ebben az "BOOM" string állandó,

508
00:40:03,500 --> 00:40:09,250
, a második példányt a "BOOM" strcpy létrehozta a másolatát "BOOM".

509
00:40:09,250 --> 00:40:13,100
De a másolatot a "boom" alatt tárolja a halom, és a kupac nyugodtan változtatni.

510
00:40:13,100 --> 00:40:17,250
A kupac nem csak olvasható, így azt jelenti, hogy s [0]

511
00:40:17,250 --> 00:40:20,500
nem hagyom, hogy módosítsa az értéket a "BOOM".

512
00:40:20,500 --> 00:40:23,130
Ez engedem, hogy változtatni ezeket a karaktereket.

513
00:40:23,130 --> 00:40:26,640
>> Kérdései vannak?

514
00:40:27,740 --> 00:40:29,290
Oké.

515
00:40:29,290 --> 00:40:35,500
>> Továbblépve a buggy3, menjünk gdb buggy3.

516
00:40:35,500 --> 00:40:39,840
Mi csak futtatni, és látjuk, kapunk egy segfault.

517
00:40:39,840 --> 00:40:46,550
Ha backtrace, már csak két funkciója van.

518
00:40:46,550 --> 00:40:52,970
Ha felmegyünk a mi fő funkciója, azt látjuk, hogy mi segfaulted most ezt a sort.

519
00:40:52,970 --> 00:41:00,180
Tehát csak nézi most ezt a vonalat, for (int vonal = 0; fgets ez a cucc nem egyenlő NULL;

520
00:41:00,180 --> 00:41:03,770
vonal + +).

521
00:41:03,770 --> 00:41:08,010
Korábbi frame hívták _IO_fgets.

522
00:41:08,010 --> 00:41:10,720
Látni fogod, hogy sok beépített C függvények,

523
00:41:10,720 --> 00:41:15,350
hogy ha kap a segfault, nem lesz igazán rejtélyes függvény nevek

524
00:41:15,350 --> 00:41:18,090
mint ez _IO_fgets.

525
00:41:18,090 --> 00:41:21,770
De hogy fog ehhez az fgets hívást.

526
00:41:21,770 --> 00:41:25,850
Valahol belül itt vagyunk segfaulting.

527
00:41:25,850 --> 00:41:30,340
Ha megnézzük az érvek fgets tudunk nyomtatni puffer.

528
00:41:30,340 --> 00:41:41,180
Nézzünk kinyomtatni - Oh, nem.

529
00:41:48,980 --> 00:41:51,900
Nyomtatás nem fog működni pontosan úgy, ahogy azt jónak látja.

530
00:41:55,460 --> 00:41:58,000
Nézzük meg az aktuális program.

531
00:42:02,200 --> 00:42:09,640
Buffer egy karakter tömb. Ez egy karakter tömb 128 karakter.

532
00:42:09,640 --> 00:42:14,980
Tehát amikor azt mondom nyomtatási puffer, ez fog nyomtatni e 128 karakter,

533
00:42:14,980 --> 00:42:18,300
ami azt hiszem, mi várható.

534
00:42:18,300 --> 00:42:21,390
Mit kerestem a kinyomtatni címe puffer,

535
00:42:21,390 --> 00:42:23,680
de ez nem igazán mondani sokat.

536
00:42:23,680 --> 00:42:30,770
Szóval, amikor azt történetesen mondom ide x puffer, azt mutatja nekem 0xbffff090,

537
00:42:30,770 --> 00:42:38,690
amely, ha emlékszel a korábbi vagy néhány pont Oxbffff inkább egy stack-szerű régióban.

538
00:42:38,690 --> 00:42:46,020
A stack hajlamos kezdeni valahol majdnem 0xc000.

539
00:42:46,020 --> 00:42:51,890
Csak az látja ezt a címet, tudom, hogy puffer történik a verem.

540
00:42:51,890 --> 00:43:04,500
Újraindítása a program fut, feláll, tompítása láttuk volt ez karaktersor

541
00:43:04,500 --> 00:43:06,530
hogy elég sok értelmetlen.

542
00:43:06,530 --> 00:43:12,270
Aztán nyomtatás fájl, mit jelent a fájl néz ki?

543
00:43:15,120 --> 00:43:17,310
[Hallgató] Null. >> Igen.

544
00:43:17,310 --> 00:43:22,610
Fájl olyan típusú FILE *, így a mutató,

545
00:43:22,610 --> 00:43:26,610
és az érték e mutató null.

546
00:43:26,610 --> 00:43:33,240
Szóval fgets fog próbálni, hogy olvassa el, hogy a mutató közvetett módon,

547
00:43:33,240 --> 00:43:37,320
hanem azért, hogy elérje az adott mutató, meg dereference azt.

548
00:43:37,320 --> 00:43:40,550
Vagy, hogy hozzáférhessen mit kell mutasson, akkor dereferences azt.

549
00:43:40,550 --> 00:43:43,810
Szóval ez dereferencing egy null pointer és segfaultol.

550
00:43:46,600 --> 00:43:48,730
Tudtam volna újra ott.

551
00:43:48,730 --> 00:43:52,170
Ha szünet a mi fő szempont és fuss,

552
00:43:52,170 --> 00:43:57,320
az első sorban a kód char * filename = "nonexistent.txt";

553
00:43:57,320 --> 00:44:00,870
Ez kell adnia egy elég nagy tipp, hogy miért ezt a programot nem sikerül.

554
00:44:00,870 --> 00:44:06,080
Beírás mellett elvezet a következő sorba, ahol én megnyitni ezt a fájlt,

555
00:44:06,080 --> 00:44:11,140
és aztán rögtön bejutni a vonal, ahol valaha megütöttem a következő, hogy fog segfault.

556
00:44:11,140 --> 00:44:16,880
Valaki akar kidobni egy ok, amiért lehet segfaulting?

557
00:44:16,880 --> 00:44:19,130
[Hallgató] fájl nem létezik. >> Igen.

558
00:44:19,130 --> 00:44:22,250
Ezt állítólag egy csipetnyi

559
00:44:22,250 --> 00:44:29,570
hogy ha te a file megnyitásakor ellenőrizni kell, hogy a fájl valóban létezik.

560
00:44:29,570 --> 00:44:31,510
Tehát itt, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
Amikor fopen fájlnév olvasatra, akkor majd meg kell mondani,

562
00:44:34,700 --> 00:44:45,870
if (fájl == NULL), és azt mondják printf ("A fájl nem létezik!"

563
00:44:45,870 --> 00:44:56,340
vagy - ami még jobb - filename); return 1;

564
00:44:56,340 --> 00:45:00,300
Így most nézze meg, ha ez NULL

565
00:45:00,300 --> 00:45:03,930
mielőtt ténylegesen folytatja és próbál olvasni a fájlt.

566
00:45:03,930 --> 00:45:08,800
Mi lehet a remake nem csak hogy lássa, hogy működik.

567
00:45:11,020 --> 00:45:14,970
Akartam, hogy egy új vonal.

568
00:45:21,090 --> 00:45:25,290
Tehát most nonexistent.txt nem létezik.

569
00:45:26,890 --> 00:45:30,040
Mindig ellenőrizze, hogy ez a fajta dolog.

570
00:45:30,040 --> 00:45:33,870
Mindig ellenőrizze, hogy ha fopen NULL.

571
00:45:33,870 --> 00:45:38,170
Mindig győződjön meg róla, hogy a malloc nem tér vissza NULL,

572
00:45:38,170 --> 00:45:41,410
vagy máshol segfault.

573
00:45:42,200 --> 00:45:45,930
>> Most buggy4.c.

574
00:45:49,190 --> 00:45:58,440
Futás. Azt hiszem ez a vár input esetleg végtelen hurok.

575
00:45:58,440 --> 00:46:01,870
Igen, ez végtelen hurok.

576
00:46:01,870 --> 00:46:05,560
Szóval buggy4. Úgy néz ki, mi vagyunk végtelen hurok.

577
00:46:05,560 --> 00:46:12,590
Mi lehet törni a főbb, futtassa a programot.

578
00:46:12,590 --> 00:46:20,180
A gdb, amíg a rövidítés használata egyértelmű

579
00:46:20,180 --> 00:46:23,420
vagy speciális rövidítéseket nyújtanak az Ön számára,

580
00:46:23,420 --> 00:46:29,020
akkor használd n használata mellett ahelyett, hogy írja ki a következő módon.

581
00:46:29,020 --> 00:46:33,730
És most, hogy már hit n egyszer, én is csak Enter, hogy folytassam következő

582
00:46:33,730 --> 00:46:36,640
ahelyett, hogy megüt n Enter, Enter n, n az Enter billentyűt.

583
00:46:36,640 --> 00:46:44,630
Úgy néz ki, mint én vagyok valamilyen for ciklus, ami beállítás array [i]-0-ra.

584
00:46:44,630 --> 00:46:50,510
Úgy néz ki, én soha kitörésre ezt hurok.

585
00:46:50,510 --> 00:46:54,780
Ha nyomtatni i, tehát én 2, akkor én megyek legközelebb.

586
00:46:54,780 --> 00:46:59,250
Én nyomtatni i, i = 3, akkor én megyek legközelebb.

587
00:46:59,250 --> 00:47:05,360
Majd nyomtassa i és i 3 lehet. Ezután nyomtassa i, i 4 lehet.

588
00:47:05,360 --> 00:47:14,520
Igazából, print sizeof (array), így a mérete tömb 20.

589
00:47:16,310 --> 00:47:32,870
De úgy néz ki, van néhány különleges gdb parancsot megy, amíg valami nem történik.

590
00:47:32,870 --> 00:47:37,620
Ez olyan, mint amelyben a feltétel értéke a változó. De nem emlékszem, hogy mi ez.

591
00:47:37,620 --> 00:47:44,100
Tehát ha tartani fog -

592
00:47:44,100 --> 00:47:47,120
Mit mondott? Mit hoztál fel?

593
00:47:47,120 --> 00:47:50,500
[Hallgató] Vajon megjelenítéséhez adhatok - >> Igen. Így jelenik meg tudok segíteni.

594
00:47:50,500 --> 00:47:54,530
Ha csak megjeleníti én, akkor tegye fel itt, mi az értéke i

595
00:47:54,530 --> 00:47:56,470
így nem kell nyomtassa ki minden alkalommal.

596
00:47:56,470 --> 00:48:02,930
Ha csak menj következő, látjuk 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5.

597
00:48:02,930 --> 00:48:08,530
Valami megy borzasztóan rossz, és én éppen visszaáll 0-ra.

598
00:48:13,330 --> 00:48:22,220
Keresi buggy4.c, azt látjuk, minden, ami történik, int array [5];

599
00:48:22,220 --> 00:48:26,200
for (i = 0; i <= sizeof (array); i + +)

600
00:48:26,200 --> 00:48:28,550
array [i] = 0;

601
00:48:28,550 --> 00:48:31,390
Mit látunk, hogy baj van?

602
00:48:31,390 --> 00:48:39,480
Mint egy tipp, mikor csinál a gdb buggy4 - Nézzük main, run -

603
00:48:39,480 --> 00:48:45,980
Én print sizeof (array), hogy lássam, mi a feltétel, ahol kéne végre kitörni.

604
00:48:47,690 --> 00:48:51,100
Hol vagyok? Mondtam futni?

605
00:48:51,100 --> 00:48:54,280
Én nem nyilvánítja még.

606
00:48:54,280 --> 00:48:58,680
Szóval nyomtatása sizeof (array), és ez 20,

607
00:48:58,680 --> 00:49:06,690
ami várhatóan mióta tömb mérete 5 és ez 5-egészek,

608
00:49:06,690 --> 00:49:12,410
így az egész dolog, legyen az 5 * sizeof (int) bájt, ahol a sizeof (int) általában 4 legyen.

609
00:49:12,410 --> 00:49:14,780
Szóval sizeof (array) 20.

610
00:49:14,780 --> 00:49:17,420
Mit kell ez?

611
00:49:17,420 --> 00:49:21,720
[Hallgató] Osztva sizeof (int). >> Igen / sizeof (int).

612
00:49:21,720 --> 00:49:30,630
Úgy tűnik, még mindig van egy kis problémánk. Azt hiszem, ez kéne legyen <

613
00:49:30,630 --> 00:49:36,960
mivel ez nagyjából mindig <és soha <=.

614
00:49:36,960 --> 00:49:44,860
Most úgy gondolja, hogy miért ez a ténylegesen megszakadt.

615
00:49:44,860 --> 00:49:53,370
Tudja valaki, hogy kitalálja, miért én vissza 0-át minden iteráció a hurok?

616
00:50:01,300 --> 00:50:09,350
Az egyetlen dolog, belsejében van, ami történik, hogy array [i] van állítva 0-ra.

617
00:50:09,350 --> 00:50:15,350
Szóval valahogy, ezt a kódsort okoz mi int i kell beállítani 0-ra.

618
00:50:16,730 --> 00:50:23,130
[Hallgató] Lehet, hogy azért, mert ez nyomós emlékére ezen részének i

619
00:50:23,130 --> 00:50:27,970
ha azt hiszi, hogy a következő elem tömb? >> [Bowden] Igen.

620
00:50:27,970 --> 00:50:33,880
Mikor megyünk vége után a tömb,

621
00:50:33,880 --> 00:50:39,870
valahogy ezt a helyet, hogy mi van nyomós nyomós értéke i.

622
00:50:39,870 --> 00:50:48,030
És ha megnézzük a buggy4, törés fő, futás,

623
00:50:48,030 --> 00:50:53,120
hadd nyomtassa ki a címét i.

624
00:50:53,120 --> 00:50:57,280
Úgy néz ki, hogy ez bffff124.

625
00:50:57,280 --> 00:51:03,930
Most nyomtassa ki a címét array [0]. 110.

626
00:51:03,930 --> 00:51:06,290
Mi a helyzet a [1]? 114.

627
00:51:06,290 --> 00:51:07,920
[2], 118.

628
00:51:07,920 --> 00:51:14,530
11c, 120. array [5] bfff124.

629
00:51:14,530 --> 00:51:26,990
Szóval array [5] is ugyanazt a címet, mint én, ami azt jelenti, hogy az array [5] i.

630
00:51:26,990 --> 00:51:30,720
Ha ugyanaz a címe, ezek ugyanaz a dolog.

631
00:51:30,720 --> 00:51:38,410
Tehát, ha mi meg array [5], 0 állítunk i 0-ra.

632
00:51:38,410 --> 00:51:46,070
És ha úgy gondolja, erről szempontjából a verem,

633
00:51:46,070 --> 00:51:55,590
int i nyilvánították először, ami azt jelenti, hogy lesz egy kis hely a veremben.

634
00:51:55,590 --> 00:52:04,730
Aztán array [5] osztják, így aztán 20 byte osztják a verem.

635
00:52:04,730 --> 00:52:08,400
Tehát én lesz kiosztott első, majd a 20 byte kap különítettek el.

636
00:52:08,400 --> 00:52:11,400
Tehát én történik, mielőtt a tömb,

637
00:52:11,400 --> 00:52:19,230
és mert az út, mint mondtam a múlt héten, ahol ez technikailag a verem lefelé növekszik,

638
00:52:19,230 --> 00:52:28,520
amikor index egy tömb, mi garantálja, hogy a 0. pozícióját a tömbben

639
00:52:28,520 --> 00:52:31,970
mindig történik, mielőtt az első helyét a tömbben.

640
00:52:31,970 --> 00:52:35,900
Ez a fajta, hogyan húzta a múlt héten.

641
00:52:35,900 --> 00:52:42,210
Figyelje meg, hogy az alján van a 0 címet, és a tetején van címe max.

642
00:52:42,210 --> 00:52:44,880
A verem mindig növekszik meg.

643
00:52:48,100 --> 00:52:53,500
Mondjuk kiosztani i.

644
00:52:53,500 --> 00:52:59,680
Mi osztja integer i, ami azt jelenti, mondjuk, ide integer i gets különítettek el.

645
00:52:59,680 --> 00:53:06,420
Aztán osztja meg sor 5 egész számok, ami azt jelenti, hogy az alatta,

646
00:53:06,420 --> 00:53:11,230
mivel a verem növekszik meg, az 5 egészek kap különítettek el.

647
00:53:11,230 --> 00:53:15,900
De mivel, hogyan tömbök működik, mi garantálja, hogy az első helyen a tömbben

648
00:53:15,900 --> 00:53:22,260
mindig van egy címet kevesebb, mint a második dolog a tömbben.

649
00:53:22,260 --> 00:53:28,270
Szóval array 0 helyzetbe mindig történik először memóriában,

650
00:53:28,270 --> 00:53:30,700
mivel a tömb 1. pozícióban kell történnie azt követően, hogy a

651
00:53:30,700 --> 00:53:33,310
és a tömb 2. pozíció meg kell történnie azt követően, hogy a

652
00:53:33,310 --> 00:53:37,900
ami azt jelenti, hogy a tömb 0 helyzetbe fog történni, valahol itt lent,

653
00:53:37,900 --> 00:53:40,690
array pozíció 1 történne felett

654
00:53:40,690 --> 00:53:45,530
mert feljebb azt jelenti, magasabb cím, mivel a maximális cím itt.

655
00:53:45,530 --> 00:53:50,490
Szóval array [0] itt lent, array [1] itt, array [2] itt, array [3] itt.

656
00:53:50,490 --> 00:53:55,620
Figyeljük meg, hogy mielőtt kiosztott integer i egészen itt,

657
00:53:55,620 --> 00:54:01,040
ahogy haladunk tovább és tovább a tömb, mi egyre közelebb és közelebb a mi integer i.

658
00:54:01,040 --> 00:54:07,640
Ez csak azért történik, hogy a array [5], amely az egyik álláspont túl tömb,

659
00:54:07,640 --> 00:54:13,010
pontosan hol történt integer i kell felosztani.

660
00:54:13,010 --> 00:54:16,920
Szóval ez az a pont, ahol történetesen üti a hely a stack

661
00:54:16,920 --> 00:54:21,680
amit kiutalt integer i, és mi beállítás, hogy 0-ra.

662
00:54:21,680 --> 00:54:26,160
>> Ez az, hogy hogyan működik. Kérdései vannak? Igen.

663
00:54:26,160 --> 00:54:30,710
[Hallgató] Nem baj. Oké.

664
00:54:30,710 --> 00:54:33,090
[Hallgató] Hogyan kerüljük ilyen fajta hibákat?

665
00:54:33,090 --> 00:54:41,190
Ezek a fajta hibákat? Ne használja, mint a C programozási nyelv.

666
00:54:41,190 --> 00:54:45,840
Használjon olyan nyelv, amely tömb határain ellenőrzés.

667
00:54:45,840 --> 00:54:55,900
Amíg te vagy óvatos, akkor csak meg kell kerülni, hogy az elmúlt határait a tömb.

668
00:54:55,900 --> 00:54:58,300
[Hallgató] Szóval itt, amikor elmentünk az elmúlt határait a tömb -

669
00:54:58,300 --> 00:55:01,840
[Bowden] Ez az, ahol a dolgok kezdenek rosszra. >> [Hallgató] Ó, oké.

670
00:55:01,840 --> 00:55:05,730
Amíg marad a lefoglalt memória a tömb, akkor minden rendben.

671
00:55:05,730 --> 00:55:12,400
De a C nem tesz hibaellenőrzés. Ha megteszem array [1000], akkor szívesen, csak módosítani bármi történjék is -

672
00:55:12,400 --> 00:55:16,500
Ez megy az elején a tömb, akkor megy 1000 pozíciók után, és beállítja azt a 0-ra.

673
00:55:16,500 --> 00:55:20,000
Ez nem csinál semmi ellenőrzésére, hogy ó, ez nem ténylegesen 1000 dolgok benne.

674
00:55:20,000 --> 00:55:22,750
1000-módon túl mit kell a változó,

675
00:55:22,750 --> 00:55:26,940
mivel a Java vagy valami kapsz array tilos index

676
00:55:26,940 --> 00:55:29,820
vagy indexet a határokat kivétel.

677
00:55:29,820 --> 00:55:33,950
Ezért nagyon sok magasabb szintű nyelvben ezek a dolgok

678
00:55:33,950 --> 00:55:37,340
ahol ha megy túl a tömb, akkor nem

679
00:55:37,340 --> 00:55:40,070
úgy, hogy nem lehet megváltoztatni a dolgokat alulról Ön

680
00:55:40,070 --> 00:55:42,590
majd a dolgok sokkal rosszabb, mint csak arra, hogy kivételt

681
00:55:42,590 --> 00:55:44,940
mondván, hogy túlment a végén a tömb.

682
00:55:44,940 --> 00:55:50,970
[Hallgató] És így kell már csak megváltozott a <=, hogy csak <? >> [Bowden] Igen.

683
00:55:50,970 --> 00:55:54,800
Meg kell <sizeof (array) / sizeof (int);

684
00:55:54,800 --> 00:55:59,560
mivel sizeof (array) 20, de mi csak szeretnénk 5. >> [Hallgató] Rendben.

685
00:55:59,560 --> 00:56:04,060
További kérdések? Oké.

686
00:56:04,060 --> 00:56:07,380
>> [Hallgató] Van egy kérdésem. >> Igen.

687
00:56:07,380 --> 00:56:16,440
[Hallgató] Mi a tényleges tömb változó?

688
00:56:16,440 --> 00:56:20,000
[Bowden] Mint mi a tömb?

689
00:56:20,000 --> 00:56:24,930
Array maga is szimbólum.

690
00:56:24,930 --> 00:56:31,490
Ez csak a címe a kezdete a 20 byte, hogy mi hivatkozik.

691
00:56:31,490 --> 00:56:38,070
Azt hiszem, hogy ez egy mutató, de ez egy állandó mutató.

692
00:56:38,070 --> 00:56:44,140
Amint dolgok összeállított, a változó tömb nem létezik többé.

693
00:56:44,140 --> 00:56:48,210
[Hallgató] Szóval hogyan találja a mérete tömb?

694
00:56:48,210 --> 00:56:54,130
Méret tömb méretére utal az, hogy a mondat, hogy ez a jel utal.

695
00:56:54,130 --> 00:57:01,240
Amikor ilyet printf ("% p \ n", array);

696
00:57:01,240 --> 00:57:05,140
hadd futtatni.

697
00:57:12,960 --> 00:57:15,530
Amit csak én csináltam rosszul?

698
00:57:15,530 --> 00:57:19,220
Array "array" bejelentett itt.

699
00:57:20,820 --> 00:57:23,200
Oh, itt.

700
00:57:23,200 --> 00:57:31,250
Zengés okos, és ez történik észre, hogy én nyilvánította a tömb 5 elem

701
00:57:31,250 --> 00:57:34,540
de én indexelni helyére 1000.

702
00:57:34,540 --> 00:57:38,450
Meg lehet csinálni, mert ezek csak állandók.

703
00:57:38,450 --> 00:57:43,370
Ez csak megy eddig észre, hogy én megyek határain túl a tömb.

704
00:57:43,370 --> 00:57:46,880
Ám mielőtt észre, amikor már én hibásak,

705
00:57:46,880 --> 00:57:51,040
nem tudja esetleg hány értéket tudtam vállalni,

706
00:57:51,040 --> 00:57:55,540
így nem tudja megállapítani, hogy túlmutat a végén a tömb.

707
00:57:55,540 --> 00:57:59,430
Ez csak csenget, hogy okos.

708
00:57:59,430 --> 00:58:03,340
>> De most, hogy buggy4. Szóval, mit csinálok rosszul?

709
00:58:03,340 --> 00:58:05,970
Értelemszerűen nyilvánító könyvtári funkció "printf".

710
00:58:05,970 --> 00:58:14,960
Megyek szeretnénk # include <stdio.h>.

711
00:58:14,960 --> 00:58:18,710
Oké. Most futó buggy4.

712
00:58:18,710 --> 00:58:24,840
Nyomtatása az érték a tömb, mint én itt, a nyomtatás, mint egy pointer

713
00:58:24,840 --> 00:58:30,060
Plakátok valami, ami úgy néz ki, mint ez - bfb8805c - ami némi címe

714
00:58:30,060 --> 00:58:33,450
ez a stack-ish régióban.

715
00:58:33,450 --> 00:58:41,820
Array maga olyan, mint egy mutató, de ez nem a tényleges mutató,

716
00:58:41,820 --> 00:58:45,410
mivel a rendszeres mutatót tudunk változtatni.

717
00:58:45,410 --> 00:58:54,700
Array mindössze néhány állandó. A 20 blokkok memória kezdődik címen 0xbfb8805c.

718
00:58:54,700 --> 00:59:09,020
Szóval bfb8805c át ezt a címet +20- vagy azt hiszem, -20 -

719
00:59:09,020 --> 00:59:17,400
minden a memória kiosztott ezt a tömböt.

720
00:59:17,400 --> 00:59:20,350
Array, a változó maga nem tárolja sehol.

721
00:59:20,350 --> 00:59:27,660
Amikor összeállítása, a fordító - kézzel hullám rajta -

722
00:59:27,660 --> 00:59:33,060
de a fordító csak használja, ha tudja, tömb legyen.

723
00:59:33,060 --> 00:59:36,090
Tudja, ha ez a tömb kezdődik,

724
00:59:36,090 --> 00:59:40,910
, és így mindig csak a dolgok tekintetében kompenzáció ebből elején.

725
00:59:40,910 --> 00:59:43,960
Nem kell egy változót magát képviselje tömb.

726
00:59:43,960 --> 00:59:53,730
De ha valami ilyesmit int * p = array, most p egy mutató, amely rámutat arra, hogy a tömb,

727
00:59:53,730 --> 00:59:57,830
és most p ténylegesen létezik a verem.

728
00:59:57,830 --> 01:00:01,950
Szabad vagyok változtatni p. Meg tudom csinálni p = malloc.

729
01:00:01,950 --> 01:00:06,500
Így az eredetileg mutatott tömb, most azt hangsúlyozza, hogy egy kis helyet a kupac.

730
01:00:06,500 --> 01:00:09,620
Nem tudom array = malloc.

731
01:00:09,620 --> 01:00:13,710
Ha csenget okos, akkor kiabálj velem rögtön a denevér.

732
01:00:17,000 --> 01:00:21,430
Igazából, biztos vagyok benne, gcc tenne ilyet is.

733
01:00:21,430 --> 01:00:25,010
Szóval array típusú "int [5]" nem átruházható.

734
01:00:25,010 --> 01:00:28,040
Nem lehet rendelni valamit egy tömb típusú

735
01:00:28,040 --> 01:00:30,500
mert a tömb csak egy konstans.

736
01:00:30,500 --> 01:00:34,760
Ez a szimbólum, amely találat a 20 bájt. Nem tudom megváltoztatni.

737
01:00:34,760 --> 01:00:37,690
>> [Hallgató] És hol van a méret a tömb tárolják?

738
01:00:37,690 --> 01:00:40,670
[Bowden] Ez nem tárolja sehol. Ez az, amikor ez összeállításánál.

739
01:00:40,670 --> 01:00:46,310
Szóval, hol van a méret tömb tárolják?

740
01:00:46,310 --> 01:00:51,870
Csak akkor használhatja a sizeof (array) belsejében a funkció, hogy a tömb nyilvánította magát.

741
01:00:51,870 --> 01:01:03,150
Szóval, ha nem néhány funkció, ize, és én (int array [])

742
01:01:03,150 --> 01:01:10,450
printf ("% d \ n", sizeof (array));

743
01:01:10,450 --> 01:01:21,330
majd ide hívom ize (array);

744
01:01:21,330 --> 01:01:24,840
belül ez a funkció - mondjuk futtatni.

745
01:01:34,200 --> 01:01:36,840
Ez csenget, hogy okos újra.

746
01:01:36,840 --> 01:01:43,890
Ez azt mondja, hogy a tömb sizeof függvény paraméter

747
01:01:43,890 --> 01:01:46,690
visszatér mérete "int *".

748
01:01:46,690 --> 01:01:55,150
Ez lenne a hiba, ha ez nem az, amit akartam, hogy megtörténjen.

749
01:01:55,150 --> 01:01:58,960
Nézzük ténylegesen kikapcsol Werror.

750
01:02:14,950 --> 01:02:17,590
Figyelmeztetés. Figyelmeztetések rendben vannak.

751
01:02:17,590 --> 01:02:19,960
Ez továbbra is fordítani, amíg van egy figyelmeztetést.

752
01:02:19,960 --> 01:02:22,910
. / A.out fog nyomtatni 4.

753
01:02:22,910 --> 01:02:28,650
A figyelmeztetés, hogy a keletkezett egyértelműen jelzi, hogy mit rontottam el.

754
01:02:28,650 --> 01:02:34,120
Ez az int tömb éppen nyomdába sizeof (int *).

755
01:02:34,120 --> 01:02:39,790
Még ha tettem array [5] itt, ez még mindig csak a nyomdába sizeof (int *).

756
01:02:39,790 --> 01:02:47,440
Szóval, amint át be egy függvény közötti különbségtétel tömbök és mutatók

757
01:02:47,440 --> 01:02:49,670
nem létezik.

758
01:02:49,670 --> 01:02:52,640
Ez történik, hogy egy tömb, amely nyilvánította a stack,

759
01:02:52,640 --> 01:02:58,300
de amint átadjuk ezt az értéket, hogy 0xbf bla, bla, bla be ezt a funkciót,

760
01:02:58,300 --> 01:03:03,350
akkor ez a mutató, hogy a tömb a verem.

761
01:03:03,350 --> 01:03:08,310
Tehát ez azt jelenti, hogy sizeof kizárólag a funkció, hogy a tömb nyilvánították,

762
01:03:08,310 --> 01:03:11,230
ami azt jelenti, hogy amikor összeállításakor ezt a funkciót,

763
01:03:11,230 --> 01:03:17,330
amikor csenget megy keresztül ez a funkció, látja tömb int tömb méret 5.

764
01:03:17,330 --> 01:03:20,640
Akkor lát sizeof (array). Nos, ez 20.

765
01:03:20,640 --> 01:03:26,440
Ez tulajdonképpen hogyan sizeof alapvetően működik, szinte minden esetben.

766
01:03:26,440 --> 01:03:31,150
Sizeof nem egy függvény, ez az üzemben.

767
01:03:31,150 --> 01:03:33,570
Nem hívja a sizeof funkciót.

768
01:03:33,570 --> 01:03:38,280
Sizeof (int), a fordító csak lefordítani, hogy 4-re.

769
01:03:41,480 --> 01:03:43,700
Megvan? Oké.

770
01:03:43,700 --> 01:03:47,520
>> [Hallgató] Akkor mi a különbség a sizeof (array), a fő és az ize?

771
01:03:47,520 --> 01:03:52,840
Ez azért van, mert azt mondja sizeof (array), mely típusú int *

772
01:03:52,840 --> 01:03:57,120
mivel a tömb idelent nem típusú int *, ez egy int tömb.

773
01:03:57,120 --> 01:04:04,540
>> [Hallgató] Szóval ha már a paramétert array [] helyett int * array,

774
01:04:04,540 --> 01:04:09,230
lenne ez azt jelenti, hogy még mindig megváltoztathatja array, mert most ez a mutató?

775
01:04:09,230 --> 01:04:14,250
[Bowden] Tetszik ez? >> [Hallgató] Igen. Meg tudod változtatni tömb a funkciót most?

776
01:04:14,250 --> 01:04:18,420
[Bowden] Lehet változtatni tömb mindkét esetben.

777
01:04:18,420 --> 01:04:23,130
Mindkét esetben nyugodtan mondani array [4] = 0.

778
01:04:23,130 --> 01:04:26,590
[Hallgató] De lehet, hogy array pont valami mást?

779
01:04:26,590 --> 01:04:30,230
[Bowden] Oh. Igen. Mindkét esetben - >> [hallgató] Igen.

780
01:04:30,230 --> 01:04:38,410
[Bowden] közötti különbségtétel array [] és int * tömb, nincs.

781
01:04:38,410 --> 01:04:42,570
Ön is kap némi többdimenziós tömb itt

782
01:04:42,570 --> 01:04:47,050
néhány kényelmes szintaxist, de ez még mindig csak egy mutató.

783
01:04:47,050 --> 01:04:56,400
Ez azt jelenti, hogy szabad vagyok megtenni array = malloc (sizeof (int)), és most pont valahol máshol.

784
01:04:56,400 --> 01:04:59,610
De ugyanúgy, mint, hogy ez működik, örökké és mindig,

785
01:04:59,610 --> 01:05:03,210
megváltoztassák ezt a tömb azáltal, hogy mutasson valami másra

786
01:05:03,210 --> 01:05:07,570
nem változtatja meg ezt a tömböt ide, mert ez egy példányát az érv,

787
01:05:07,570 --> 01:05:10,780
ez nem egy mutatót ezt az érvet.

788
01:05:10,780 --> 01:05:16,070
És valóban, ahogy több jelzés, hogy ez pontosan ugyanaz -

789
01:05:16,070 --> 01:05:21,100
már látta, mi Nyomtatásra array nyomatok -

790
01:05:21,100 --> 01:05:31,410
mi lenne, ha kinyomtatja a címét a tömb vagy címe címét a tömb

791
01:05:31,410 --> 01:05:36,290
hogy akár e?

792
01:05:41,770 --> 01:05:45,220
Nézzük figyelmen kívül hagyják ezt.

793
01:05:48,140 --> 01:05:51,660
Oké. Ez rendben van. Ez már fut. / A.out.

794
01:05:51,660 --> 01:06:00,220
Nyomtatás tömb, majd a nyomtatás címét a tömb, az ugyanaz a dolog.

795
01:06:00,220 --> 01:06:02,870
Array egyszerűen nem létezik.

796
01:06:02,870 --> 01:06:08,190
Tudja, amikor nyomtat tömb, akkor kinyomtatja a szimbólum, amely utal a 20 bájt.

797
01:06:08,190 --> 01:06:11,940
Nyomtatása címét a tömb, nos, tömb nem létezik.

798
01:06:11,940 --> 01:06:17,200
Ez nincs címe, így csak kiírja a címét a 20 bájt.

799
01:06:20,820 --> 01:06:28,150
Amint összeállítására le, mint a lefordított buggy4. / A.out,

800
01:06:28,150 --> 01:06:30,340
tömb nem létezik.

801
01:06:30,340 --> 01:06:33,640
Mutatók létezik. Arrays nem.

802
01:06:34,300 --> 01:06:38,060
A blokkok memória képviselő a tömb továbbra is fennállnak,

803
01:06:38,060 --> 01:06:43,270
hanem a változó tömb és a változók az ilyen típusú nem léteznek.

804
01:06:46,260 --> 01:06:50,270
Ezek olyanok, mint a főbb különbségek a tömbök és mutatók

805
01:06:50,270 --> 01:06:55,590
kerülnek, amint csinál függvényhívásokat, nincs különbség.

806
01:06:55,590 --> 01:07:00,460
De belsejében a függvény a tömb maga kijelentette, sizeof másképp működik

807
01:07:00,460 --> 01:07:05,190
mert te nyomtat a méret a blokkok helyett a méret a típus,

808
01:07:05,190 --> 01:07:08,950
és nem lehet megváltoztatni, mert ez egy szimbólum.

809
01:07:08,950 --> 01:07:14,370
Nyomtatás a dolog és címét a dolog kinyomtatja ugyanaz a dolog.

810
01:07:14,370 --> 01:07:18,480
És ez nagyjából azt.

811
01:07:18,480 --> 01:07:20,820
[Hallgató] tudnád mondani, hogy még egyszer?

812
01:07:21,170 --> 01:07:24,170
Én lehet, hogy kimaradt valami.

813
01:07:24,170 --> 01:07:29,260
Nyomtatási sor és címe tömb kinyomtatja ugyanaz a dolog,

814
01:07:29,260 --> 01:07:33,180
mivel ha nyomtat egy mutatót versus címét a mutatót,

815
01:07:33,180 --> 01:07:36,010
az egyetlen dolog, kiírja a címét, amit mutat,

816
01:07:36,010 --> 01:07:40,360
A többi kiírja a címét a mutató a verem.

817
01:07:40,360 --> 01:07:47,040
Meg lehet változtatni a pointer, akkor nem lehet megváltoztatni egy tömb szimbólum.

818
01:07:47,740 --> 01:07:53,270
És sizeof mutató nyomdába méretét, hogy a mutató típus.

819
01:07:53,270 --> 01:07:57,470
Így int * p sizeof (p) fog nyomtatni 4,

820
01:07:57,470 --> 01:08:04,110
de int array [5] print sizeof (array) fog nyomtatni 20.

821
01:08:04,110 --> 01:08:07,480
[Hallgató] Szóval int array [5] kiírja 20? >> Igen.

822
01:08:07,480 --> 01:08:13,300
Ezért belsejében buggy4 mikor szokott lenni sizeof (array)

823
01:08:13,300 --> 01:08:16,660
ez csinál i <20, ami nem az, amit akartunk.

824
01:08:16,660 --> 01:08:20,880
Szeretnénk, i <5. >> [Hallgató] Oké.

825
01:08:20,880 --> 01:08:25,569
[Bowden], majd amint elkezd halad a funkciók,

826
01:08:25,569 --> 01:08:34,340
ha volt int * p = array;

827
01:08:34,340 --> 01:08:39,779
belül ezt a funkciót, akkor alapvetően a P és a tömb pontosan ugyanolyan módon,

828
01:08:39,779 --> 01:08:43,710
kivéve a sizeof problémát, és a változó probléma.

829
01:08:43,710 --> 01:08:49,810
De p [0] = 1, ugyanaz, mint mondás array [0] = 1;

830
01:08:49,810 --> 01:08:55,600
És amint mondjuk foo (array), vagy foo (p);

831
01:08:55,600 --> 01:08:59,760
belsejében a foo függvény, ez ugyanaz a hívás kétszer.

832
01:08:59,760 --> 01:09:03,350
Nincs különbség a két hívás között.

833
01:09:07,029 --> 01:09:11,080
>> Mindenki jó e? Oké.

834
01:09:14,620 --> 01:09:17,950
Van 10 perc.

835
01:09:17,950 --> 01:09:28,319
>> Megpróbáljuk átvészelni ezt a Hacker Typer program,

836
01:09:28,319 --> 01:09:32,350
ezt a weboldalt, amely kijött elmúlt évben, vagy ilyesmi.

837
01:09:34,149 --> 01:09:41,100
Ez csak kéne lenni, mint te írja véletlenszerűen és kiírja -

838
01:09:41,100 --> 01:09:46,729
Bármi fájlt, ez történik van-e töltve, amit úgy néz ki, mint te gépelés.

839
01:09:46,729 --> 01:09:52,069
Úgy néz ki, mint valami operációs rendszer kódját.

840
01:09:53,760 --> 01:09:56,890
Ez az, amit szeretnénk megvalósítani.

841
01:10:08,560 --> 01:10:11,690
Meg kell egy bináris futtatható nevű hacker_typer

842
01:10:11,690 --> 01:10:14,350
hogy vesz egy érv a fájlt "hacker típus."

843
01:10:14,350 --> 01:10:16,480
Futás a végrehajtható kell tisztítania a képernyőn

844
01:10:16,480 --> 01:10:20,850
majd nyomtassa ki az egyik karakter a recirkulált-fájlban minden alkalommal, amikor a felhasználó megnyomja a gombot.

845
01:10:20,850 --> 01:10:24,990
Tehát bármilyen gombot megnyomja, meg kell dobni, és helyette nyomtatni egy karaktert a fájlból

846
01:10:24,990 --> 01:10:27,810
ez az érv.

847
01:10:29,880 --> 01:10:34,350
Én elég sokat mondani, hogy mi a dolgokat fogunk tudni vannak.

848
01:10:34,350 --> 01:10:36,440
De mi szeretnénk, hogy nézd meg a termios könyvtár.

849
01:10:36,440 --> 01:10:44,840
Én még soha nem használta ezt a könyvtár egész életemben, ezért nagyon minimális célokra.

850
01:10:44,840 --> 01:10:48,610
De ez lesz a könyvtár tudjuk használni, hogy dobja el a karaktert eléred

851
01:10:48,610 --> 01:10:52,390
ha gépelés a szabványos be

852
01:10:56,970 --> 01:11:05,840
Szóval hacker_typer.c, és fogunk szeretnénk # include <stdio.h>.

853
01:11:05,840 --> 01:11:12,870
Keresi a man oldal termios - Én találgatás, hogy a terminál operációs rendszer, vagy valami -

854
01:11:12,870 --> 01:11:16,240
Nem tudom, hogyan kell olvasni.

855
01:11:16,240 --> 01:11:21,040
Nézi most ezt, azt mondja, hogy ezeket 2 kép, úgyhogy csinálni.

856
01:11:37,620 --> 01:11:46,820
>> Az első dolog az első, azt akarom, hogy egyetlen érv, amely a fájl kellene nyitni.

857
01:11:46,820 --> 01:11:52,420
Szóval, mit szeretnél csinálni? Hogyan lehet ellenőrizni, hogy van egy érv?

858
01:11:52,420 --> 01:11:56,480
[Hallgató] Ha argc egyenlő azt. >> [Bowden] Igen.

859
01:11:56,480 --> 01:12:21,250
Tehát, ha (argc! = 2) printf ("Használat:% s [file megnyitása]").

860
01:12:21,250 --> 01:12:32,750
Tehát most, ha futtatni ezt anélkül, hogy a második érv - ó, szükségem van az új vonal -

861
01:12:32,750 --> 01:12:36,240
látni fogod azt mondja használat:. / hacker_typer,

862
01:12:36,240 --> 01:12:39,770
majd a második érv kell a fájlt akarok megnyitni.

863
01:12:58,430 --> 01:13:01,260
Most mit tegyek?

864
01:13:01,260 --> 01:13:08,490
Azt akarom, hogy olvassa el ezt a fájlt. Hogyan kell olvasni egy fájlt?

865
01:13:08,490 --> 01:13:11,920
[Hallgató] You nyissa meg először. >> Igen.

866
01:13:11,920 --> 01:13:15,010
Szóval fopen. Mit jelent a fopen néz ki?

867
01:13:15,010 --> 01:13:22,980
[Hallgató] fájlnév. >> [Bowden] fájlnév lesz argv [1].

868
01:13:22,980 --> 01:13:26,110
[Hallgató] És akkor mit akar kezdeni vele, így a - >> [Bowden] Igen.

869
01:13:26,110 --> 01:13:28,740
Szóval, ha nem emlékszik, akkor csak nem férfi fopen,

870
01:13:28,740 --> 01:13:32,960
ahol ez lesz a const char * path ahol a path fájlnév,

871
01:13:32,960 --> 01:13:34,970
const char * módban.

872
01:13:34,970 --> 01:13:38,660
Ha történetesen nem emlékszem, milyen állapotban van, akkor keresni módban.

873
01:13:38,660 --> 01:13:44,660
Belül man oldalak, a perjel karakter, amit segítségével keresni dolgokat.

874
01:13:44,660 --> 01:13:49,790
Szóval írja / mode keresni módba.

875
01:13:49,790 --> 01:13:57,130
n és N, amit segítségével körbe a keresési mérkőzések.

876
01:13:57,130 --> 01:13:59,800
Itt azt mondja az érvet módot mutat egy string

877
01:13:59,800 --> 01:14:01,930
kezdve az alábbi szekvenciák.

878
01:14:01,930 --> 01:14:06,480
Szóval r, Open szöveges fájlt olvasásra. Ez az, amit mi akarunk.

879
01:14:08,930 --> 01:14:13,210
Az olvasás, és azt akarom, hogy a tárolni.

880
01:14:13,210 --> 01:14:18,720
A dolog lesz a FILE *. Most mit akarok csinálni?

881
01:14:18,720 --> 01:14:21,200
Adj egy percet.

882
01:14:28,140 --> 01:14:30,430
Oké. Most mit akarok csinálni?

883
01:14:30,430 --> 01:14:32,940
[Hallgató] Ellenőrizze ha ez NULL. >> [Bowden] Igen.

884
01:14:32,940 --> 01:14:38,690
Minden alkalommal, amikor megnyit egy fájlt, győződjön meg arról, hogy te sikeresen tudja nyitni azt.

885
01:14:58,930 --> 01:15:10,460
>> Most azt akarom, hogy termios dolgokat, ahol szeretnék először olvastam a jelenlegi beállítások

886
01:15:10,460 --> 01:15:14,050
és mentse a valami, akkor én akarom megváltoztatni a beállításokat

887
01:15:14,050 --> 01:15:19,420
eldobni minden olyan képességgel, hogy én írja,

888
01:15:19,420 --> 01:15:22,520
majd szeretnék frissíteni ezeket a beállításokat.

889
01:15:22,520 --> 01:15:27,250
És akkor a végén a program, azt akarom, hogy állítsa vissza az eredeti beállításokat.

890
01:15:27,250 --> 01:15:32,080
Tehát a struct lesz típusú termios, és megyek, hogy szeretne két ilyen.

891
01:15:32,080 --> 01:15:35,600
Az első lesz a current_settings,

892
01:15:35,600 --> 01:15:42,010
, és akkor ők lesznek az én hacker_settings.

893
01:15:42,010 --> 01:15:48,070
Először fogok menteni szeretné a jelenlegi beállításokat,

894
01:15:48,070 --> 01:15:53,790
akkor megyek a frissíteni kívánt hacker_settings,

895
01:15:53,790 --> 01:16:01,570
majd így a végén az én program, szeretnék visszaállítani az aktuális beállításokat.

896
01:16:01,570 --> 01:16:08,660
Szóval aktuális beállítások mentése, az is, hogy működik, akkor ember termios.

897
01:16:08,660 --> 01:16:15,810
Látjuk, hogy itt van ez a tcsetattr int, int tcgetattr.

898
01:16:15,810 --> 01:16:22,960
Elmegyek egy termios struct annak mutató.

899
01:16:22,960 --> 01:16:30,640
Az, hogy ez fog kinézni jelentése - I've már elfelejtette, mi a függvény neve.

900
01:16:30,640 --> 01:16:34,930
Másolja és illessze be.

901
01:16:39,150 --> 01:16:45,500
Szóval tcgetattr, akkor én szeretnék átadni a struct, hogy én vagyok megtakarítás az információt,

902
01:16:45,500 --> 01:16:49,650
ami lesz current_settings,

903
01:16:49,650 --> 01:16:59,120
és az első argumentum a fájl leíró a dolog, szeretnék menteni a tulajdonságait.

904
01:16:59,120 --> 01:17:04,360
Mi a fájl leíró olyan, mint minden alkalommal, amikor megnyit egy fájlt, akkor kap egy fájl leíró.

905
01:17:04,360 --> 01:17:14,560
Amikor fopen argv [1], hogy kap egy fájl leíró, ahol Ön hivatkozó

906
01:17:14,560 --> 01:17:16,730
ha el szeretnénk olvasni, vagy írni.

907
01:17:16,730 --> 01:17:19,220
Ez nem az a fájl leíró szeretnék használni itt.

908
01:17:19,220 --> 01:17:21,940
Három fájlleíró van alapértelmezés szerint,

909
01:17:21,940 --> 01:17:24,310
amelyek a standard, standard ki, és a standard hiba.

910
01:17:24,310 --> 01:17:29,960
Alapértelmezés szerint, azt hiszem, standard értéke 0, standard out 1, és a standard hiba 2 lehet.

911
01:17:29,960 --> 01:17:33,980
Szóval mit akarok változtatni a beállításait?

912
01:17:33,980 --> 01:17:37,370
Szeretném megváltoztatni a beállításokat, amikor elütöttem egy karaktert,

913
01:17:37,370 --> 01:17:41,590
Azt akarom, hogy dobja el, hogy a karakter nyomtatás helyett a képernyőn.

914
01:17:41,590 --> 01:17:45,960
Mi stream - standard, standard ki, vagy standard hiba -

915
01:17:45,960 --> 01:17:52,050
reagál a dolgokat, amikor azt írja a billentyűzet? >> [Hallgató] Standard in >> Igen.

916
01:17:52,050 --> 01:17:56,450
Szóval lehet csinálni akár 0 vagy tehetek stdin.

917
01:17:56,450 --> 01:17:59,380
Kezdek a current_settings standard be

918
01:17:59,380 --> 01:18:01,720
>> Most azt akarom, hogy frissíteni ezeket a beállításokat,

919
01:18:01,720 --> 01:18:07,200
Tehát először fogok másolni hacker_settings mi a current_settings vannak.

920
01:18:07,200 --> 01:18:10,430
És milyen struktúrákat munka akkor csak másolja.

921
01:18:10,430 --> 01:18:14,510
Ez átmásolja az összes területen, ahogy az elvárható.

922
01:18:14,510 --> 01:18:17,410
>> Most azt akarom, hogy frissíteni néhány területen.

923
01:18:17,410 --> 01:18:21,670
Keresi termios, meg kellett volna, hogy olvassa el a sok e

924
01:18:21,670 --> 01:18:24,110
csak hogy lássa, mit szeretne keresni,

925
01:18:24,110 --> 01:18:28,210
de a zászlók fogsz szeretnénk keresni a visszhang,

926
01:18:28,210 --> 01:18:33,110
így ECHO Echo input karakter.

927
01:18:33,110 --> 01:18:37,710
Először is szeretnék beállítani - I've már elfelejtette, milyen területeken vannak.

928
01:18:45,040 --> 01:18:47,900
Ez az, amit a struct néz ki.

929
01:18:47,900 --> 01:18:51,060
Szóval bemeneti üzemmódok úgy gondolom, szeretnénk változtatni.

930
01:18:51,060 --> 01:18:54,210
Majd nézd meg a megoldást, hogy győződjön meg arról, hogy az, amit mi szeretnénk változtatni.

931
01:19:04,060 --> 01:19:12,610
Meg akarja változtatni lflag elkerülése érdekében szüksége, hogy nézze át ezeket.

932
01:19:12,610 --> 01:19:14,670
Meg akarja változtatni a helyi módok.

933
01:19:14,670 --> 01:19:17,710
Meg kellett volna, hogy olvassa el ezt az egész dolgot, hogy megértsük, ahol minden tartozik

934
01:19:17,710 --> 01:19:19,320
hogy meg akarjuk változtatni.

935
01:19:19,320 --> 01:19:24,120
De ez benne a helyi módok hová megyünk akar változtatni.

936
01:19:27,080 --> 01:19:33,110
Szóval hacker_settings.cc_lmode, amit a neve.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
Ez az, ahol bejutni bitenkénti operátorok.

939
01:19:52,280 --> 01:19:54,860
Mi vagyunk a fajta az, de megyünk át rajta gyorsan.

940
01:19:54,860 --> 01:19:56,600
Ez az, ahol bejutni bitenkénti operátorok,

941
01:19:56,600 --> 01:19:59,950
Azt hiszem, ha azt mondtam, egyszer régen, hogy amikor elkezd foglalkozó zászlókkal,

942
01:19:59,950 --> 01:20:03,370
fogsz használni bitenkénti operátor sokat.

943
01:20:03,370 --> 01:20:08,240
Minden bit a zászló megfelel valamilyen magatartás.

944
01:20:08,240 --> 01:20:14,090
Tehát itt, ez a zászló egy csomó különböző dolgot, ahol mindegyik jelent valami mást.

945
01:20:14,090 --> 01:20:18,690
De amit akarok éppen kikapcsolni a bit, amely megfelel az ECHO.

946
01:20:18,690 --> 01:20:25,440
Tehát kapcsold ki tudom & = ¬ ECHO.

947
01:20:25,440 --> 01:20:30,110
Igazából, azt hiszem, ez olyan, mint techo vagy ilyesmi. Én csak megy ellenőrizze újra.

948
01:20:30,110 --> 01:20:34,050
Én termios azt. Ez csak ECHO.

949
01:20:34,050 --> 01:20:38,440
ECHO lesz egy kicsit.

950
01:20:38,440 --> 01:20:44,230
¬ ECHO fog minden olyan bit értéke 1, ami azt jelenti, az összes zászló van állítva true

951
01:20:44,230 --> 01:20:47,140
kivéve az ECHO kicsit.

952
01:20:47,140 --> 01:20:53,830
Ezzel véget a helyi zászlók ezzel, az azt jelenti, hogy valamennyi lobogó alatt hajózó jelenleg true

953
01:20:53,830 --> 01:20:56,520
továbbra is kell beállítani, hogy igaz.

954
01:20:56,520 --> 01:21:03,240
Ha az én ECHO flag értéke true, akkor ez szükségszerűen false az ECHO zászlót.

955
01:21:03,240 --> 01:21:07,170
Szóval ezt a kódsort, csak kikapcsolja a ECHO zászlót.

956
01:21:07,170 --> 01:21:16,270
A másik sornyi kódot, én csak másolja őket az érdeke az idő, majd magyarázni.

957
01:21:27,810 --> 01:21:30,180
A megoldás, mondta 0.

958
01:21:30,180 --> 01:21:33,880
Ez talán jobb, hogy kifejezetten mondani stdin.

959
01:21:33,880 --> 01:21:42,100
>> Figyeljük meg, hogy én is csinál ECHO | icanon itt.

960
01:21:42,100 --> 01:21:46,650
Icanon jelentése valamit külön, ami azt jelenti, kanonikus mód.

961
01:21:46,650 --> 01:21:50,280
Mi kanonikus mód azt jelenti, általában amikor gépelés ki a parancssorban,

962
01:21:50,280 --> 01:21:54,670
szabvány nem dolgozza fel semmit, amíg bejön újsor.

963
01:21:54,670 --> 01:21:58,230
Szóval, ha nem getString, beír egy csomó dolgot, akkor bejön újsor.

964
01:21:58,230 --> 01:22:00,590
Ez az, amikor ez küldött szabványos be

965
01:22:00,590 --> 01:22:02,680
Ez az alapértelmezett.

966
01:22:02,680 --> 01:22:05,830
Amikor kikapcsolja kanonikus mód, most már minden egyes karakter megnyomásakor

967
01:22:05,830 --> 01:22:10,910
az, amit kap feldolgozásra, mely általában olyan rossz, mert lassan feldolgozni ezeket a dolgokat,

968
01:22:10,910 --> 01:22:14,330
ezért is jó, hogy puffer be egész sorokat.

969
01:22:14,330 --> 01:22:16,810
De azt akarom, minden egyes karakter kell feldolgozni

970
01:22:16,810 --> 01:22:18,810
mert én nem akarom, hogy várjon rám a hit újsor

971
01:22:18,810 --> 01:22:21,280
előtt dolgozza fel az összes karakter voltam gépelni.

972
01:22:21,280 --> 01:22:24,760
Ez kikapcsolja egyházjogi módot.

973
01:22:24,760 --> 01:22:31,320
Ez a cucc csak azt jelenti, amikor valójában dolgozza karakter.

974
01:22:31,320 --> 01:22:35,830
Ez azt jelenti, feldolgozzák azokat, azonnal, amint én gépelési őket feldolgozni.

975
01:22:35,830 --> 01:22:42,510
És ez az a funkció, amely frissíti a beállításokat a szabvány,

976
01:22:42,510 --> 01:22:45,480
és TCSA eszközök csinálni most.

977
01:22:45,480 --> 01:22:50,310
A többi opció várjon, amíg minden, ami jelenleg a patak kerül feldolgozásra.

978
01:22:50,310 --> 01:22:52,030
Ez nem igazán számít.

979
01:22:52,030 --> 01:22:56,920
Csak most megváltoztatni a beállításokat, hogy bármi jelenleg hacker_typer_settings.

980
01:22:56,920 --> 01:23:02,210
Azt hiszem nevezte hacker_settings, úgyhogy változtatni.

981
01:23:09,610 --> 01:23:13,500
Változás mindent hacker_settings.

982
01:23:13,500 --> 01:23:16,870
>> Most, a végén a program megyünk vissza akar térni

983
01:23:16,870 --> 01:23:20,210
hogy milyen jelenleg belül normal_settings,

984
01:23:20,210 --> 01:23:26,560
ami megy, hogy csak kinézni & normal_settings.

985
01:23:26,560 --> 01:23:30,650
Megjegyzés Én nem változtak sem az én normal_settings mivel eredetileg szerzés ez.

986
01:23:30,650 --> 01:23:34,520
Aztán, hogy csak megváltoztatni őket vissza, én át őket a végén.

987
01:23:34,520 --> 01:23:38,390
Ez volt a frissítés. Oké.

988
01:23:38,390 --> 01:23:43,900
>> Most belseje itt én csak elmagyarázni a kód a kamat az idő.

989
01:23:43,900 --> 01:23:46,350
Ez nem olyan sok kódot.

990
01:23:50,770 --> 01:24:03,750
Látjuk azt olvassuk egy karaktert a fájlból. Úgy hívják, hogy f.

991
01:24:03,750 --> 01:24:07,850
Most már férfi fgetc, de hogyan fgetc fog dolgozni

992
01:24:07,850 --> 01:24:11,910
éppen ez megy vissza a karakter, hogy csak olvasni, vagy EOF,

993
01:24:11,910 --> 01:24:15,680
amely megfelel az a fájl végére, vagy valamilyen hiba történik.

994
01:24:15,680 --> 01:24:19,900
Mi hurok, továbbra is olvasni egy karaktert a fájl,

995
01:24:19,900 --> 01:24:22,420
amíg mi már elfogyott karakterek olvasni.

996
01:24:22,420 --> 01:24:26,650
És miközben csinálunk, hogy várunk egyetlen karaktert a standard be

997
01:24:26,650 --> 01:24:29,090
Minden egyes alkalommal, amikor írja be valamit a parancssorban,

998
01:24:29,090 --> 01:24:32,820
hogy olvas egy karaktert a standard be

999
01:24:32,820 --> 01:24:38,330
Aztán putchar éppen megy, hogy a char olvasunk fel ide a fájlt a szabványos ki.

1000
01:24:38,330 --> 01:24:42,890
Tudod férfi putchar, de ez csak üzembe a standard ki, ez kinyomtatná a karaktert.

1001
01:24:42,890 --> 01:24:51,600
Te is tedd printf ("% c", c); Same ötlet.

1002
01:24:53,330 --> 01:24:56,670
Ez fog csinálni a nagy részét a munkánkat.

1003
01:24:56,670 --> 01:25:00,300
>> Az utolsó dolog, fogunk akarok csak fclose a fájlt.

1004
01:25:00,300 --> 01:25:03,310
Ha nem fclose, ez a memóriavesztés.

1005
01:25:03,310 --> 01:25:06,680
Azt akarjuk, hogy a fájl fclose amit eredetileg nyitott, és úgy gondolom, hogy ez az.

1006
01:25:06,680 --> 01:25:13,810
Ha ezt teszik, hogy már megvan a problémákat.

1007
01:25:13,810 --> 01:25:17,260
Lássuk.

1008
01:25:17,260 --> 01:25:19,960
Mit nem panaszkodnak?

1009
01:25:19,960 --> 01:25:30,220
A várt "int", hanem az érvelés típusú "struct _IO_FILE * '.

1010
01:25:36,850 --> 01:25:39,370
Majd meglátjuk, ha ez működik.

1011
01:25:45,210 --> 01:25:53,540
Csak engedélyezett C99. Augh. Oké, hogy hacker_typer.

1012
01:25:53,540 --> 01:25:57,760
Most még több hasznos leírásokat.

1013
01:25:57,760 --> 01:25:59,900
Így használja a be nem jelentett azonosító "normal_settings".

1014
01:25:59,900 --> 01:26:04,170
Én nem nevezném normal_settings. Hívtam current_settings.

1015
01:26:04,170 --> 01:26:12,090
Szóval változtatni az egésznek.

1016
01:26:17,920 --> 01:26:21,710
Most tompított érv.

1017
01:26:26,290 --> 01:26:29,500
Én ezt 0 most.

1018
01:26:29,500 --> 01:26:36,720
Oké. . / Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
Én is nem törli a képernyőt az elején.

1020
01:26:39,590 --> 01:26:42,960
De nézd vissza az utolsó probléma állítva látni, hogyan törölje a képernyőt.

1021
01:26:42,960 --> 01:26:45,160
Ez csak néhány karaktert nyomtat

1022
01:26:45,160 --> 01:26:47,210
míg ez csinál, amit akarok.

1023
01:26:47,210 --> 01:26:48,900
Oké.

1024
01:26:48,900 --> 01:26:55,280
És gondoltam, hogy ez miért szükséges, hogy 0 helyett stdin,

1025
01:26:55,280 --> 01:27:00,560
amelyet be kell # define 0,

1026
01:27:00,560 --> 01:27:03,890
ez panaszkodik, hogy -

1027
01:27:13,150 --> 01:27:19,360
Előtt, amikor azt mondtam, hogy van fájlleíró, de akkor is a FILE *

1028
01:27:19,360 --> 01:27:23,210
Egy fájl-leíró csak egy egész szám,

1029
01:27:23,210 --> 01:27:26,970
mivel a FILE * van egy csomó cucc társul hozzá.

1030
01:27:26,970 --> 01:27:30,380
Az ok, azt kell mondani, 0 helyett stdin

1031
01:27:30,380 --> 01:27:37,480
az, hogy stdin egy FILE *, amely rámutat a dolog, hogy a hivatkozó fájl leíró 0.

1032
01:27:37,480 --> 01:27:45,070
Tehát akár itt, amikor én fopen (argv [1], kapok egy FILE * vissza.

1033
01:27:45,070 --> 01:27:51,180
De valahol, hogy a FILE * a dolog megfelelő fájl leíró adott fájlt.

1034
01:27:51,180 --> 01:27:57,430
Ha megnézzük a man oldalt nyitott, így azt hiszem, neked kell csinálni man 3 nyitott - nope -

1035
01:27:57,430 --> 01:27:59,380
man 2 nyitott - igen.

1036
01:27:59,380 --> 01:28:06,250
Ha megnézzük az oldal nyitott, nyílt, mint egy alacsonyabb szintű fopen,

1037
01:28:06,250 --> 01:28:09,350
és ez visszatérés az aktuális fájl leíró.

1038
01:28:09,350 --> 01:28:12,050
fopen csinál egy csomó dolgot a tetején nyitott,

1039
01:28:12,050 --> 01:28:17,640
amely visszatérés helyett csak azt a fájlt leíró vissza egész FILE * pointer

1040
01:28:17,640 --> 01:28:20,590
belül, ami a mi kis fájl leíró.

1041
01:28:20,590 --> 01:28:25,020
Tehát szabvány hivatkozik a FILE * dolog,

1042
01:28:25,020 --> 01:28:29,120
mivel a 0 jelenti, hogy csak a fájl leíró szabvány is.

1043
01:28:29,120 --> 01:28:32,160
>> Kérdései vannak?

1044
01:28:32,160 --> 01:28:35,930
[Nevet] Blew ezen keresztül.

1045
01:28:35,930 --> 01:28:39,140
Rendben van. Végeztünk. [Nevet]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]