1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [5.pants - ērtāk]

2
00:00:02,500 --> 00:00:04,690
[Rob Bowden - Hārvarda]

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

4
00:00:08,990 --> 00:00:14,250
>> Tāpat kā es teicu manu e-pastu, ir lietas, ko var izmantot daudz

5
00:00:14,250 --> 00:00:17,060
izņemot ierīces, lai faktiski darīt problēmu kopas.

6
00:00:17,060 --> 00:00:19,910
Mēs iesakām darīt to ierīcē tikai tāpēc, tad mēs varam vieglāk jums palīdzēt

7
00:00:19,910 --> 00:00:22,070
un mēs zinām, kā viss iet uz darbu.

8
00:00:22,070 --> 00:00:26,950
Bet kā viens piemērs, kur jūs varat darīt lietas, ja, teiksim, jums nav piekļuves

9
00:00:26,950 --> 00:00:31,570
uz ierīcēm vai vēlaties strādāt Science Center pagrabā -

10
00:00:31,570 --> 00:00:33,090
kas faktiski viņi ir ierīci pārāk -

11
00:00:33,090 --> 00:00:35,150
ja jūs vēlaties strādāt jebkur.

12
00:00:35,150 --> 00:00:42,370
Viens piemērs ir esat redzējuši / dzirdējuši par SSH?

13
00:00:44,380 --> 00:00:47,780
SSH ir būtībā tāpat kā savienot ar kaut ko.

14
00:00:47,780 --> 00:00:51,340
Patiesībā, šobrīd es esmu SSHed ierīcē.

15
00:00:51,340 --> 00:00:54,290
Es nekad strādāt tieši ierīcē.

16
00:00:55,930 --> 00:01:01,060
Šeit ir ierīce, un ja paskatās uz leju šeit jūs redzat šo IP adresi.

17
00:01:01,060 --> 00:01:03,650
Es nekad strādāt pati ierīce;

18
00:01:03,650 --> 00:01:08,840
Es vienmēr nāk vairāk nekā uz iTerm2 loga / termināla logu.

19
00:01:08,840 --> 00:01:15,910
Jūs varat SSH uz šo IP adresi, ssh jharvard@192.168.129.128.

20
00:01:15,910 --> 00:01:20,390
Es atceros, ka vairāki ļoti viegli, jo tas ir tik jauki modelis.

21
00:01:20,390 --> 00:01:24,920
Bet, ka būs man jautā par manu paroli, un tagad es esmu iekārtā.

22
00:01:24,920 --> 00:01:33,060
Būtībā, šajā brīdī, ja jūs atvēra termināla iekšpusē pati ierīce,

23
00:01:33,060 --> 00:01:36,350
Šī saskarne, tomēr jūs varētu to izmantot, ir tieši tāds pats

24
00:01:36,350 --> 00:01:40,010
kā saskarne es esmu, izmantojot vairāk nekā šeit, bet tagad tu esi SSHed.

25
00:01:42,240 --> 00:01:44,920
Jums nav SSH pie ierīces.

26
00:01:44,920 --> 00:01:52,360
Viens piemērs citā vietā jūs varētu SSH ir es esmu diezgan pārliecināts, ka jums ir pēc noklusējuma -

27
00:01:52,360 --> 00:01:55,020
Oh. Lielāks.

28
00:01:55,020 --> 00:02:01,130
Jums visiem vajadzētu būt pēc noklusējuma FAS kontos LKS serveriem.

29
00:02:01,130 --> 00:02:06,840
Par mani, es būtu SSH rbowden@nice.fas.harvard.edu.

30
00:02:06,840 --> 00:02:11,610
Tas notiek, lai jums jautāt, ka pirmo reizi, un jūs sakāt: jā.

31
00:02:11,610 --> 00:02:15,840
Mana parole ir tikai būs mans FAS parole.

32
00:02:15,840 --> 00:02:22,650
Un tāpēc tagad, es esmu SSHed ar jauku serveriem, un es varu darīt kaut ko es gribu šeit.

33
00:02:22,650 --> 00:02:28,560
Klašu jūs varētu veikt, piemēram, 124 daudz, nāksies jums augšupielādēt stuff šeit

34
00:02:28,560 --> 00:02:30,950
faktiski iesniegt savu problēmu kopas.

35
00:02:30,950 --> 00:02:34,100
Bet saku jums nav piekļuves jūsu ierīci.

36
00:02:34,100 --> 00:02:37,910
Tad jūs varat darīt lietas, piemēram, šeit tā teikt -

37
00:02:37,910 --> 00:02:42,160
Tas ir tikai mūsu sadaļā jautājumiem.

38
00:02:42,160 --> 00:02:45,070
Tā lūgs jums to darīt iekārtā.

39
00:02:45,070 --> 00:02:47,790
Tā vietā es ņemšu tikai darīt to uz servera.

40
00:02:47,790 --> 00:02:50,560
Es esmu gatavojas unzip to.

41
00:02:50,560 --> 00:02:55,670
Problēma būs, ka jūs izmantot, lai, izmantojot kaut ko līdzīgu gedit

42
00:02:55,670 --> 00:02:58,160
vai kāds iekšpusē ierīces.

43
00:02:58,160 --> 00:03:01,830
Jūs neesat gatavojas būt, ka uz SKS serverī.

44
00:03:01,830 --> 00:03:04,110
Tas viss tikai būs šis tekstuāli saskarne.

45
00:03:04,110 --> 00:03:09,180
Lai jūs varētu vai nu viens, mēģināt uzzināt teksta redaktoru, kas viņiem ir.

46
00:03:09,180 --> 00:03:12,130
Viņi ir Nano.

47
00:03:12,130 --> 00:03:14,990
Nano parasti ir diezgan viegli izmantot.

48
00:03:14,990 --> 00:03:19,470
Jūs varat izmantot savu bultas un ierakstiet parasti.

49
00:03:19,470 --> 00:03:21,250
Tā ka nav grūti.

50
00:03:21,250 --> 00:03:24,720
Ja jūs vēlaties saņemt tiešām iedomātā jūs varat izmantot Emacs,

51
00:03:24,720 --> 00:03:29,850
ko es droši vien nebūtu atvērti, jo es pat nezinu, kā lai aizvērtu Emacs.

52
00:03:29,850 --> 00:03:32,760
Kontroles X Control C? Yeah.

53
00:03:32,760 --> 00:03:35,310
Vai jūs varat izmantot Spars, kas ir tas, ko es izmantot.

54
00:03:35,310 --> 00:03:37,800
Un tāpēc tie ir jūsu iespējas.

55
00:03:37,800 --> 00:03:43,830
Ja jūs nevēlaties to darīt, jūs varat arī, ja paskatās manual.cs50.net--

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

57
00:03:45,410 --> 00:03:49,920
Datorā, jūs varat SSH izmantojot tepe,

58
00:03:49,920 --> 00:03:51,940
kas jums nāksies lejupielādēt atsevišķi.

59
00:03:51,940 --> 00:03:55,460
Uz Mac, jūs varat vienkārši noklusējuma izmantot Terminal vai jūs varat lejupielādēt iTerm2,

60
00:03:55,460 --> 00:03:58,490
kas ir kā jauka, fancy Terminal.

61
00:03:58,490 --> 00:04:03,780
Ja jūs iet uz manual.cs50.net jūs redzēsiet saiti uz Notepad + +,

62
00:04:03,780 --> 00:04:07,120
kas ir tas, ko jūs varat izmantot datorā.

63
00:04:07,120 --> 00:04:13,340
Tas ļauj jums SFTP no Notepad + +, kas būtībā ir SSH.

64
00:04:13,340 --> 00:04:17,750
Ko tas ļaus jums darīt, ir rediģēt failus lokāli,

65
00:04:17,750 --> 00:04:20,670
un tad, ja jūs vēlaties, lai saglabātu tos, tas ļaus ietaupīt līdz nice.fas,

66
00:04:20,670 --> 00:04:23,670
kur jūs varat palaist tos.

67
00:04:23,670 --> 00:04:26,880
Un uz Mac līdzvērtīgs būs TextWrangler.

68
00:04:26,880 --> 00:04:28,760
Tātad tas ļauj jums darīt to pašu.

69
00:04:28,760 --> 00:04:32,800
Tas ļauj jums rediģēt failus lokāli un saglabāt tos nice.fas,

70
00:04:32,800 --> 00:04:35,730
kur jūs varat palaist tos.

71
00:04:35,730 --> 00:04:40,400
Tātad, ja jūs esat kādreiz iestrēdzis bez ierīces, jums ir šīs iespējas

72
00:04:40,400 --> 00:04:44,230
lai vēl darīt savu problēmu kopas.

73
00:04:44,230 --> 00:04:48,250
Viena problēma būs, ka jūs neesat nāksies CS50 bibliotēka

74
00:04:48,250 --> 00:04:51,580
jo nice.fas nav pēc noklusējuma ir, ka.

75
00:04:51,580 --> 00:04:55,970
Jūs varat vai nu lejupielādēt CS50 bibliotēka -

76
00:04:55,970 --> 00:04:58,470
Es nedomāju, ka man vajag, ka šajā brīdī.

77
00:04:58,470 --> 00:05:03,270
Jūs varat vai nu lejupielādēt CS50 bibliotēku un kopēt to pa nice.fas,

78
00:05:03,270 --> 00:05:07,450
vai es domāju, šajā brīdī mēs neizmantojam to vairs vienalga.

79
00:05:07,450 --> 00:05:12,720
Vai, ja mēs, jūs varat pagaidām aizstāt to ar

80
00:05:12,720 --> 00:05:18,480
plānu ieviešanu par šajā CS50 bibliotēkas funkcijas vienalga.

81
00:05:18,480 --> 00:05:21,370
Tāpēc, ka nedrīkst būt, ka daudz ierobežojumu.

82
00:05:21,370 --> 00:05:23,710
Un tas, ka.

83
00:05:26,460 --> 00:05:29,820
>> Es iešu atpakaļ uz ierīces tagad, mēs darīsim visu, kas ir ierīces.

84
00:05:29,820 --> 00:05:37,510
Aplūkojot mūsu sadaļu jautājumiem, sākumā, tāpat kā es teicu manu e-pastu,

85
00:05:37,510 --> 00:05:43,620
Mums ir jārunā par vienu īsu jums bija paredzēts skatīties.

86
00:05:43,620 --> 00:05:51,980
Mums ir novirzot & Caurules un šiem trim jautājumiem.

87
00:05:51,980 --> 00:05:56,070
>> Uz kuru straume to funkcijas, piemēram printf rakstīt pēc noklusējuma?

88
00:05:56,070 --> 00:05:59,130
Tā straume. Kas ir plūsma?

89
00:06:06,520 --> 00:06:15,100
Plūsma ir būtībā tāpat tas ir tikai dažas -

90
00:06:15,100 --> 00:06:21,450
Tas nav pat avots 1s un 0s.

91
00:06:21,450 --> 00:06:24,920
Straume tas prasot šeit ir standarta out.

92
00:06:24,920 --> 00:06:27,250
Un tā standarts, kas ir plūsma, kas, ja jūs rakstīt uz to,

93
00:06:27,250 --> 00:06:30,940
tā parādās uz ekrāna.

94
00:06:30,940 --> 00:06:36,860
Standarts, kas, pēc straumi, tas nozīmē, ka jūs vienkārši uzrakstīt 1s un 0s uz to,

95
00:06:36,860 --> 00:06:40,220
un otrs gals standarta, kas tikai lasa no šīs plūsmas.

96
00:06:40,220 --> 00:06:43,540
Tas ir tikai virkne 1s un 0s.

97
00:06:43,540 --> 00:06:45,570
Jūs varat rakstīt uz plūsmām vai jūs varat izlasīt no plūsmām

98
00:06:45,570 --> 00:06:47,950
atkarībā no tā, kāda plūsma patiesībā ir.

99
00:06:47,950 --> 00:06:52,800
Pārējie divi Noklusējuma plūsmas ir standarta un standarta kļūda.

100
00:06:52,800 --> 00:06:57,540
Standarta ir, kad tu GetString, tas gaida, lai jūs varētu ievades sīkumi.

101
00:06:57,540 --> 00:07:01,570
Tātad, tas gaida jūs, tas ir faktiski gaida uz standarta,

102
00:07:01,570 --> 00:07:04,880
kas ir patiešām to, ko jūs saņemsiet, ja jūs tipa pie klaviatūras.

103
00:07:04,880 --> 00:07:07,530
Jūs rakstāt par standarta collas

104
00:07:07,530 --> 00:07:10,050
Standarta kļūda ir būtībā atbilst standarta out,

105
00:07:10,050 --> 00:07:13,280
bet tas ir specializējies ka tad, kad jūs drukāt ar standarta kļūdu,

106
00:07:13,280 --> 00:07:16,770
jūs vajadzēja tikai drukas kļūda ziņas, ka

107
00:07:16,770 --> 00:07:20,200
lai jūs varētu atšķirt regulāru ziņojumu iespiestas uz ekrāna

108
00:07:20,200 --> 00:07:24,560
pret kļūdu ziņojumiem atkarībā no tā, vai viņi devās uz standarta out vai standarta kļūda.

109
00:07:24,560 --> 00:07:28,660
Failus too.

110
00:07:28,660 --> 00:07:32,440
Standarts, kas, standarta, un standarta kļūda ir tikai īpašas strautiem,

111
00:07:32,440 --> 00:07:36,810
bet tiešām jebkuru failu, atverot failu, tas kļūst plūsmā baitu

112
00:07:36,810 --> 00:07:40,740
kur jūs varat vienkārši lasīt no šīs plūsmas.

113
00:07:40,740 --> 00:07:47,770
Tu, lai lielākā daļa, var tikai domāt par failu kā plūsmā baitu.

114
00:07:47,770 --> 00:07:51,190
Tātad, ko straumes viņi rakstīt pēc noklusējuma? Standarta out.

115
00:07:51,190 --> 00:07:56,980
>> Kāda ir atšķirība starp> un >> atšķirība?

116
00:07:58,140 --> 00:08:03,710
Vai kāds skatīties video iepriekš? Labi.

117
00:08:03,710 --> 00:08:10,960
> Būs kā jūs novirzīt vērā failus,

118
00:08:10,960 --> 00:08:15,240
un >> ir arī gatavojas novirzīt izejas uz failu,

119
00:08:15,240 --> 00:08:17,820
bet tas tā vietā gatavojas pievienot lietas materiāliem.

120
00:08:17,820 --> 00:08:23,430
Piemēram, pieņemsim, ka es notikt ir dict tieši šeit,

121
00:08:23,430 --> 00:08:27,020
un vienīgais sīkumi iekšā dict ir kaķis, kaķis, suns, zivs, suns.

122
00:08:27,020 --> 00:08:31,530
Viena komanda, kas jums ir pie komandrindas ir kaķis,

123
00:08:31,530 --> 00:08:34,539
kas ir tikai gatavojas drukāt, kas ir failā.

124
00:08:34,539 --> 00:08:40,679
Tātad, kad es saku kaķu dict, tas notiek, lai drukātu kaķis, kaķis, suns, zivs, suns. Tas ir viss, kaķis dara.

125
00:08:40,679 --> 00:08:46,280
Tas nozīmē, ka to iespiež uz standarta ārā kaķis, kaķis, suns, zivs, suns.

126
00:08:46,280 --> 00:08:53,240
Ja es tā vietā vēlas novirzīt kas uz failu, es varētu izmantot> un pārorientēt to, lai neatkarīgi fails.

127
00:08:53,240 --> 00:08:56,460
Es aicinu šo failu failu.

128
00:08:56,460 --> 00:09:00,320
Tāpēc tagad, ja I ls, es redzēsit man ir jaunu failu ar nosaukumu failu.

129
00:09:00,320 --> 00:09:05,700
Un, ja es to atvērtu, tas būs tieši tas, ko kaķis likt pie komandrindas.

130
00:09:05,700 --> 00:09:11,040
Tāpēc tagad, ja man tas atkal, tad tas būs novirzīt izejas uz failu,

131
00:09:11,040 --> 00:09:13,930
un es esmu nāksies to pašu precīzu lieta.

132
00:09:13,930 --> 00:09:17,910
Tātad tehniski, tas pilnīgi neievērot ierobežojumu dēļ, kas mums bija.

133
00:09:17,910 --> 00:09:22,970
Un mēs redzēsim, ja es mainīt dict, es izņēma suns.

134
00:09:22,970 --> 00:09:29,980
Tagad, ja mēs kaķis dict uz failu vēlreiz, mēs esam nāksies jauno versiju ar suni noņemts.

135
00:09:29,980 --> 00:09:32,400
Tātad tas pilnīgi ignorē to.

136
00:09:32,400 --> 00:09:36,640
Tā vietā, ja mēs izmantojam >>, tas būs pievienot failu.

137
00:09:36,640 --> 00:09:40,860
Tagad, atverot failu, mēs redzam mums ir tikai pašu drukāto divreiz

138
00:09:40,860 --> 00:09:44,920
jo tas bija tur vienreiz, tad mēs pievienots oriģināls.

139
00:09:44,920 --> 00:09:48,130
Tātad tas, ko> un >> darīt.

140
00:09:48,130 --> 00:09:50,580
Vai nākamais jautāt - Tas nav jautāt par to.

141
00:09:50,580 --> 00:09:59,050
>> Otrs, kas mums ir, ir <, kas, ja> novirza standarta out,

142
00:09:59,050 --> 00:10:01,970
<Ir būs novirzīt standarta iekšā

143
00:10:01,970 --> 00:10:12,050
Redzēsim, vai mums ir piemērs.

144
00:10:14,750 --> 00:10:16,930
Es varu uzrakstīt viens reāls ātri.

145
00:10:17,870 --> 00:10:25,700
Paņemsim kādu failu, hello.c.

146
00:10:56,060 --> 00:10:59,070
Salīdzinoši vienkārša failu.

147
00:10:59,070 --> 00:11:03,570
Es esmu tikai iegūt virkni un pēc tam izdrukāt "Sveiki" kāds stīgu man tikko ienāca bija.

148
00:11:03,570 --> 00:11:07,990
Lai padarītu sveiki un tad / sveiki..

149
00:11:07,990 --> 00:11:10,720
Tagad tas pamudinot man ievadīt kaut ko,

150
00:11:10,720 --> 00:11:15,070
kas nozīmē, ka gaidīšana uz lietām, kas stājās standarta collas

151
00:11:15,070 --> 00:11:20,450
Lai ievadītu ko gribu savos standarta collas Mēs esam tikai gatavojas teikt Sveiki, Rob!

152
00:11:20,450 --> 00:11:23,310
Tad tas ir drukājot standarta ārā Sveiki, Rob!

153
00:11:23,310 --> 00:11:28,860
Ja man. / Sveiki un pēc tam novirzīt,

154
00:11:30,740 --> 00:11:34,310
tagad jūs varat tikai novirzīt no faila.

155
00:11:34,310 --> 00:11:41,720
Tātad, ja man kaut failā, txt, un man Rob,

156
00:11:41,720 --> 00:11:52,300
ja es palaist sveiki un pēc tam novirzīt failu txt vērā. / sveiki, tas būs teikt Hello, Rob! nekavējoties.

157
00:11:52,300 --> 00:11:57,160
Kad tā pirmo reizi kļūst par GetString un tas gaida uz standarta,

158
00:11:57,160 --> 00:12:01,730
standarts vairs gaida uz tastatūras, lai dati, lai ievadītajiem.

159
00:12:01,730 --> 00:12:05,980
Tā vietā, mēs esam novirzīts standarts lasīt no failu txt.

160
00:12:05,980 --> 00:12:10,290
Un tā tas notiek, lai lasītu no failu txt, kas ir tikai līnija Rob,

161
00:12:10,290 --> 00:12:13,380
un tad tas notiek, lai drukātu Sveiki, Rob!

162
00:12:13,380 --> 00:12:18,180
Un, ja es gribēju, es varētu arī darīt. / Sveiki <TXT

163
00:12:18,180 --> 00:12:21,500
un tad standarta, ka tas ir poligrāfija, kas ir Sveiki, Rob!,

164
00:12:21,500 --> 00:12:24,700
Es varu novirzīt kas stājas savā failā.

165
00:12:24,700 --> 00:12:29,790
Es ņemšu tikai zvanu failu sveiki - nē, es ne, jo tas ir izpildāmā - txt2.

166
00:12:29,790 --> 00:12:40,150
Tagad, txt2 gatavojas ir produkciju. / Sveiki <txt, kas gatavojas būt Sveiki, Rob!

167
00:12:41,370 --> 00:12:43,520
>> Jautājumi?

168
00:12:45,900 --> 00:12:49,090
>> Labi. Tātad, tad šeit mums ir cauruļvadu.

169
00:12:49,090 --> 00:12:53,510
Caurules ir pēdējais vienība redirection.

170
00:12:53,510 --> 00:12:58,750
>> Oh. Es domāju vēl viens vienības redirection ir, ja tā vietā> jums 2>,

171
00:12:58,750 --> 00:13:01,070
kas ir novirzot standarta kļūda.

172
00:13:01,070 --> 00:13:06,280
Tātad, ja kaut kas devās uz standarta kļūdu, tas nav get nodot txt2.

173
00:13:06,280 --> 00:13:12,480
Bet paziņojums, ja man 2>, tad tas vēl drukāšanas Sveiki, Rob! uz komandrindas

174
00:13:12,480 --> 00:13:18,600
jo es esmu tikai novirzot standarta kļūda, es neesmu pārprofilējot standartu out.

175
00:13:18,600 --> 00:13:22,210
Standarta kļūdas un standarta ārā ir atšķirīgas.

176
00:13:24,210 --> 00:13:27,080
Ja jūs vēlētos, lai faktiski rakstīt standarta kļūdu,

177
00:13:27,080 --> 00:13:35,080
tad es varētu mainīt tas ir fprintf stderr.

178
00:13:35,080 --> 00:13:37,850
Tātad printf, pēc noklusējuma, izdrukas uz standarta out.

179
00:13:37,850 --> 00:13:41,720
Ja es gribu, lai izdrukātu standarta kļūdu manuāli, tad man ir izmantot fprintf

180
00:13:41,720 --> 00:13:45,010
un norāda, kāda es gribu, lai izdrukātu.

181
00:13:45,010 --> 00:13:49,720
Ja tā vietā es tomēr fprintf stdout, tad tas būtībā atbilst printf.

182
00:13:49,720 --> 00:13:55,530
Bet fprintf standarta kļūda.

183
00:13:57,790 --> 00:14:03,650
Tāpēc tagad, ja es novirzīt to vērā txt2, Sveiki, Rob! joprojām kļūst izdrukāts pie komandrindas

184
00:14:03,650 --> 00:14:08,270
jo tas kļūst iespiež uz standarta kļūda, un es esmu tikai pārprofilējot standartu out.

185
00:14:08,270 --> 00:14:16,420
Ja es tagad novirzīt standarta kļūda, tagad tā nav get uzdrukāts, un txt2 būs Sveiki, Rob!

186
00:14:16,420 --> 00:14:21,910
Tāpēc tagad, jūs varat izdrukāt savu faktisko kļūdas, lai standarta kļūda

187
00:14:21,910 --> 00:14:24,720
un izdrukāt regulāras ziņas standarta out.

188
00:14:24,720 --> 00:14:31,420
Un tā, kad jūs palaist savu programmu, jūs varat palaist to, kā / sveiki. Šāda veida saistībā ar 2>

189
00:14:31,420 --> 00:14:33,800
lai jūsu programma ir gatavojas palaist normāli,

190
00:14:33,800 --> 00:14:38,400
bet visas kļūdas ziņojumi, ka jums, jūs varat pārbaudīt vēlāk savu kļūdas žurnālā,

191
00:14:38,400 --> 00:14:44,500
tik kļūdas, un tad skatīties vēlāk un jūsu kļūdas fails būs kādas kļūdas, kas notika.

192
00:14:45,200 --> 00:14:47,540
>> Jautājumi?

193
00:14:47,540 --> 00:14:58,070
>> Pēdējais ir caurules, ko jūs varat iedomāties, kā veikt standarta ārā no vienas komandas

194
00:14:58,070 --> 00:15:01,210
un padarot to standartu par nākamo komandu.

195
00:15:01,210 --> 00:15:05,570
Piemērs šeit ir atbalss ir komandrindas lieta

196
00:15:05,570 --> 00:15:11,840
kas ir tikai gatavojas atkārtot kāds man kā tās argumentu. Es ne likts pēdiņas.

197
00:15:11,840 --> 00:15:16,150
Echo blah, blah, blah ir tikai gatavojas drukāt blah, blah, blah.

198
00:15:16,150 --> 00:15:20,600
Pirms tam, kad man teica, man bija likt Rob uz txt failā

199
00:15:20,600 --> 00:15:28,830
jo es varu tikai novirzīt txt failus, nevis, / ja es atkārtoju Rob

200
00:15:28,830 --> 00:15:35,520
un tad caurule to savos / sveiki, ka arī darīt to pašu veida lieta..

201
00:15:35,520 --> 00:15:39,160
Tas ir ņemot izejas šo komandu, ECHO Rob,

202
00:15:39,160 --> 00:15:43,610
un izmanto to kā ievade. / sveiki.

203
00:15:44,790 --> 00:15:49,560
Jūs varat domāt par to kā pirmās novirzīt atbalss Rob failā

204
00:15:49,560 --> 00:15:54,160
un tad ieguldījums. / sveiki šo failu, kas bija tikai izvadīt.

205
00:15:54,160 --> 00:15:57,850
Bet tas aizņem pagaidu failu no attēla.

206
00:16:01,890 --> 00:16:04,460
>> Jautājumi par šo?

207
00:16:04,460 --> 00:16:07,150
>> Nākamais jautājums ir gatavojas iesaistīt šo.

208
00:16:07,150 --> 00:16:15,310
Ko cauruļvads jūs varētu izmantot, lai atrastu vairākas unikālas nosaukumus failu sauc names.txt?

209
00:16:15,310 --> 00:16:24,160
Komandas mēs spēsim vēlaties izmantot šeit ir unikāls, tāpēc Uniq, un tad wc.

210
00:16:24,160 --> 00:16:28,840
Jūs varat darīt vīrieti uniq faktiski apskatīt, kas tas dara,

211
00:16:28,840 --> 00:16:34,840
un tas ir tikai gatavojas, lai filtrētu blakus atbilstošas ​​līnijas no ieejas.

212
00:16:34,840 --> 00:16:40,690
Un cilvēks WC gatavojas drukāt newline, vārdu un baitu skaitu par katru failu.

213
00:16:40,690 --> 00:16:43,760
Un pēdējais, mēs esam gatavojas vēlaties izmantot, ir kārtot,

214
00:16:43,760 --> 00:16:47,410
kas gatavojas tikai sakārtot līnijas txt failu.

215
00:16:47,410 --> 00:16:58,080
Ja es veikt dažas txt failu, names.txt, un tas ir Rob, Tommy, Jāzeps, Tommy, Jāzeps, RJ, Rob,

216
00:16:58,080 --> 00:17:03,910
ko es gribu darīt, šeit ir atrast vairākas unikālas vārdi šajā failā.

217
00:17:03,910 --> 00:17:08,750
Tātad, kādi būtu atbilde būt? >> [Students] 4. >> Jā.

218
00:17:08,750 --> 00:17:13,780
Tas ir 4 jo Rob, Tommy, Jāzeps, RJ ir tikai unikāls vārdi šajā failā.

219
00:17:13,780 --> 00:17:20,180
Pirmais solis, ja es tikai darīt vārdu skaits par names.txt,

220
00:17:20,180 --> 00:17:24,290
tas ir faktiski stāsta man visu.

221
00:17:24,290 --> 00:17:32,560
Tas ir faktiski drukāšanas - pieņemsim redzēt, cilvēks wc - newlines, vārdiem un baitu skaits.

222
00:17:32,560 --> 00:17:38,270
Ja es tikai rūp līnijas, tad es varu tikai darīt WC-l names.txt.

223
00:17:41,730 --> 00:17:44,300
Tā ka ir solis 1.

224
00:17:44,300 --> 00:17:50,510
Bet es negribu, lai WC-l names.txt jo names.txt tikai satur visus vārdus,

225
00:17:50,510 --> 00:17:54,170
un es gribu, lai filtrēt nav unikālas ones.

226
00:17:54,170 --> 00:18:01,200
Tātad, ja man Uniq names.txt, ka nav gluži dod man to, ko es gribu

227
00:18:01,200 --> 00:18:03,760
jo dublēti nosaukumi ir joprojām.

228
00:18:03,760 --> 00:18:07,690
Kāpēc tā? Kāpēc uniq nedara to, ko es gribu?

229
00:18:07,690 --> 00:18:10,500
[Students] dublikāti nav [dzirdams] >> Jā.

230
00:18:10,500 --> 00:18:16,370
Atceros man lapu par Uniq saka filtrs blakus bet saderīgas līnijas.

231
00:18:16,370 --> 00:18:19,680
Viņi nav blakus, tāpēc tas nav filtrēt tos.

232
00:18:19,680 --> 00:18:31,100
Ja es šķirot tos vispirms kārtot names.txt gatavojas nodot visas dublēt rindas kopā.

233
00:18:31,100 --> 00:18:34,450
Tāpēc tagad kārtot names.txt tas ir.

234
00:18:34,450 --> 00:18:40,550
Es esmu gatavojas vēlaties izmantot šo kā ieguldījumu Uniq, kas ir | uniq.

235
00:18:40,550 --> 00:18:43,390
Tas dod man Jāzepu, RJ, Rob, Tommy,

236
00:18:43,390 --> 00:18:49,260
un es vēlos izmantot šo kā ieguldījumu wc-l,

237
00:18:49,260 --> 00:18:52,740
kas gatavojas sniegt man 4.

238
00:18:52,740 --> 00:18:56,930
Tāpat kā tas saka šeit, ko cauruļvads jūs varētu izmantot?

239
00:18:56,930 --> 00:19:01,390
Jūs varat darīt daudzas lietas, piemēram, izmantojot virkni komandu

240
00:19:01,390 --> 00:19:05,130
kur jūs izmantot izejas no vienas komandas kā ievadi uz nākamo komandu.

241
00:19:05,130 --> 00:19:08,780
Jūs varat darīt daudz lietas, daudz gudrs lietām.

242
00:19:08,780 --> 00:19:11,440
>> Jautājumi?

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

244
00:19:14,600 --> 00:19:17,880
Tas ir tas par caurulēm un pārorientācija.

245
00:19:18,370 --> 00:19:24,090
>> Tagad mēs ejam uz faktisko sīkumi, kodēšanas sīkumi.

246
00:19:24,090 --> 00:19:29,100
Iekšpusē šis PDF, jūs redzēsiet šo komandu,

247
00:19:29,100 --> 00:19:32,950
un jūs vēlaties palaist šo komandu savā ierīcē.

248
00:19:36,240 --> 00:19:42,250
wget ir komanda, lai tikai iegūtu kaut ko no interneta, būtībā,

249
00:19:42,250 --> 00:19:45,180
tāpēc wget un šis URL.

250
00:19:45,180 --> 00:19:49,110
Ja jūs devās uz šo URL savā pārlūkprogrammā, tas varētu lejupielādēt šo failu.

251
00:19:49,110 --> 00:19:52,510
Es tikko noklikšķinājuši par to, lai tā lejupielādēt failu par mani.

252
00:19:52,510 --> 00:19:55,650
Bet rakstot wget šī lieta iekšpusē termināla

253
00:19:55,650 --> 00:19:58,620
ir tikai gatavojas lejupielādēt to savā terminālā.

254
00:19:58,620 --> 00:20:02,750
Man ir section5.zip, un jūs vēlaties, lai unzip section5.zip,

255
00:20:02,750 --> 00:20:06,520
kas gatavojas sniegt jums mapi sauc section5,

256
00:20:06,520 --> 00:20:11,550
kas ir nāksies visus failus, mēs ejam, lai, izmantojot šodien iekšpusē no tā.

257
00:20:33,380 --> 00:20:37,710
Tā kā programmas "failu nosaukumi liecina, viņi mazliet buggy,

258
00:20:37,710 --> 00:20:40,990
lai jūsu uzdevums ir izdomāt, kāpēc, izmantojot gdb.

259
00:20:40,990 --> 00:20:44,560
Vai visi ir tos lejupielādēt / zina, kā iegūt tos lejupielādēt

260
00:20:44,560 --> 00:20:47,480
savā iekārtu? Labi.

261
00:20:47,480 --> 00:20:56,400
>> Darbojas ./buggy1, tā teikt segmentāciju vaina (core dempinga cenām),

262
00:20:56,400 --> 00:21:00,500
kas jebkurā laikā jūs saņemsiet segfault, tas slikti.

263
00:21:00,500 --> 00:21:03,810
Kādos apstākļos jūs saņemsiet segfault?

264
00:21:03,810 --> 00:21:08,210
[Students] dereferencing ar null rādītāju. >> Jā. Tāpēc, ka ir viens piemērs.

265
00:21:08,210 --> 00:21:11,580
Dereferencing Null rādītāju jūs gatavojas saņemt segfault.

266
00:21:11,580 --> 00:21:16,720
Kas segfault līdzekļus ir jūs pieskaras atmiņu jums nevajadzētu pieskarties.

267
00:21:16,720 --> 00:21:21,350
Tātad dereferencing Null rādītāju pieskaras adresi 0,

268
00:21:21,350 --> 00:21:28,060
un būtībā, visi datori mūsdienās saka, ka adrese 0 ir atmiņas jums nevajadzētu pieskarties.

269
00:21:28,060 --> 00:21:31,920
Tātad, tāpēc dereferencing Null rādītāju rezultātus segfault.

270
00:21:31,920 --> 00:21:37,210
Ja jums gadās ne inicializēt rādītāju, tad tas ir atkritumu vērtība,

271
00:21:37,210 --> 00:21:41,520
un tad, kad jūs mēģināt dereference tā, visticamāk, jūs esat pieskaras atmiņu

272
00:21:41,520 --> 00:21:43,540
kas ir vidū nekur.

273
00:21:43,540 --> 00:21:45,650
Ja jums gadās saņemt laimīgs un atkritumu vērtības

274
00:21:45,650 --> 00:21:48,440
noticis norādīt uz kaut uz skursteņa vai kaut ko,

275
00:21:48,440 --> 00:21:50,820
tad, kad tu dereference ka rādītāju, kas jums nav inicializēts,

276
00:21:50,820 --> 00:21:52,730
nekas iet greizi.

277
00:21:52,730 --> 00:21:55,480
Bet, ja tas ir norādot uz, teiksim, kaut kur starp kaudze un kaudze,

278
00:21:55,480 --> 00:21:59,850
vai tas ir norādot tikai kaut kas nav ticis izmantots ar savu programmu vēl,

279
00:21:59,850 --> 00:22:02,240
tad jūs pieskaroties atmiņu jums nevajadzētu pieskarties un tu segfault.

280
00:22:02,240 --> 00:22:06,370
Rakstot rekursīvo funkciju un tas recurses pārāk daudz reižu

281
00:22:06,370 --> 00:22:08,720
un jūsu kaudze aug pārāk liels un kaudzīti satiekas vērā lietas

282
00:22:08,720 --> 00:22:12,270
ka to nedrīkst sadurties ar, jūs pieskaras atmiņu jums nevajadzētu pieskarties,

283
00:22:12,270 --> 00:22:14,810
lai jūs segfault.

284
00:22:14,810 --> 00:22:17,010
Tas ir tas segfault ir.

285
00:22:17,010 --> 00:22:21,810
>> Tas ir arī pats iemesls, ka, ja jums ir virkne līdzīgu -

286
00:22:21,810 --> 00:22:23,930
iesim atpakaļ uz iepriekšējo programmu.

287
00:22:23,930 --> 00:22:28,530
Jo hello.c--I'm tikai gatavojas darīt kaut ko citu.

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

289
00:22:33,770 --> 00:22:42,310
Ja es izmantot * s = kaut vai s [0] = "X";

290
00:22:42,310 --> 00:22:47,290
lai padarītu sveiki, / sveiki., kāpēc tas segfault?

291
00:22:48,410 --> 00:22:51,250
Kāpēc tas segfault?

292
00:22:55,660 --> 00:22:57,890
Ko jūs sagaidāt notikt?

293
00:22:57,890 --> 00:23:06,640
Ja man printf ("% s \ n", i); ko jūs sagaida, lai iespiež?

294
00:23:06,640 --> 00:23:09,930
[Students] X sveiki. >> Jā.

295
00:23:09,930 --> 00:23:15,140
Problēma ir tā, ka tad, kad jūs atzīt virkni kā šis,

296
00:23:15,140 --> 00:23:18,190
s ir rādītājs, ka gatavojas doties uz skursteņa,

297
00:23:18,190 --> 00:23:25,880
un ko s ir vērsta uz ir šī virkne, kas ir ietverts tikai lasīšanas atmiņas.

298
00:23:25,880 --> 00:23:30,560
Tik vienkārši ar nosaukumu, lasāmatmiņa, jums vajadzētu saņemt ideja

299
00:23:30,560 --> 00:23:33,010
ka, ja jūs mēģināt mainīt to, kas lasāms tikai atmiņa,

300
00:23:33,010 --> 00:23:36,670
jūs darāt kaut ko jūs nevar darīt ar atmiņu, un jūs segfault.

301
00:23:36,670 --> 00:23:45,360
Tas ir tiešām liela atšķirība starp char * s un char s [].

302
00:23:45,360 --> 00:23:48,790
Tātad char s [], tagad šī virkne būs jāliek uz skursteņa,

303
00:23:48,790 --> 00:23:53,960
un kaudze ir tikai lasāma, kas nozīmē, ka tas ir darbs perfekti labi.

304
00:23:55,500 --> 00:23:57,370
Un tā dara.

305
00:23:57,370 --> 00:24:06,250
Atcerieties, ka tad, kad es to char * s = "Hello World!", I pati uz skursteņa

306
00:24:06,250 --> 00:24:10,390
bet s norāda uz kaut ko citu, un ka kaut kur citur notiek, ir tikai lasāms.

307
00:24:10,390 --> 00:24:15,640
Bet char s [] ir tikai kaut uz skursteņa.

308
00:24:17,560 --> 00:24:21,760
Tātad tas ir vēl viens piemērs segfault notiek.

309
00:24:21,760 --> 00:24:27,820
>> Mēs redzējām, ka ./buggy1 izraisīja segfault.

310
00:24:27,820 --> 00:24:31,810
Teorētiski, jums nevajadzētu apskatīt buggy1.c nekavējoties.

311
00:24:31,810 --> 00:24:35,170
Tā vietā, mēs apskatīt to, izmantojot gdb.

312
00:24:35,170 --> 00:24:37,750
Ievērojiet, ka tad, kad jūs saņemsiet segmentāciju vaina (core dempinga cenām),

313
00:24:37,750 --> 00:24:40,850
Jūs saņemsiet šo failu nekā šeit sauc kodols.

314
00:24:40,850 --> 00:24:45,200
Ja mēs ls-l, mēs redzēsim, ka kodols ir parasti diezgan liels fails.

315
00:24:45,200 --> 00:24:51,580
Tas ir baitu skaits no failu, tāpēc izskatās, ka tas ir 250 kaut kilobaiti.

316
00:24:51,580 --> 00:24:56,120
Iemesls ir tas, kas pamatā izgāztuve patiesībā ir

317
00:24:56,120 --> 00:25:01,410
ir tad, kad jūsu programma avarē, valsts atmiņas par savu programmu

318
00:25:01,410 --> 00:25:05,230
vienkārši kļūst nokopēt un ielīmēt šo failu.

319
00:25:05,230 --> 00:25:07,270
Tas izpaužas aprakta šo failu.

320
00:25:07,270 --> 00:25:13,060
Šī programma, bet tā darbojas, noticis, ir atmiņas izmantošana aptuveni 250 kilobaitiem,

321
00:25:13,060 --> 00:25:17,040
un lai tas, ko saņēmu aprakta šo failu.

322
00:25:17,040 --> 00:25:23,630
Tagad jūs varat apskatīt šo failu, ja mēs GDB buggy1 kodols.

323
00:25:23,630 --> 00:25:30,130
Mēs varam vienkārši darīt gdb buggy1, un kas būs vienkārši uzsākt gdb regulāri,

324
00:25:30,130 --> 00:25:33,800
izmantojot buggy1 kā tās ieejas failu.

325
00:25:33,800 --> 00:25:38,260
Bet, ja jūs GDB buggy1 kodols, tad tas īpaši gatavojas uzsākt gdb

326
00:25:38,260 --> 00:25:40,330
ko meklē, ka kodols failu.

327
00:25:40,330 --> 00:25:45,560
Un tu saki buggy1 līdzekļi gdb zina, ka galvenais fails nāk no buggy1 programmas.

328
00:25:45,560 --> 00:25:49,580
Tātad gdb buggy1 kodols būs nekavējoties jāpārtrauc mums

329
00:25:49,580 --> 00:25:52,060
kur programma notika pārtraukt.

330
00:25:57,720 --> 00:26:02,340
Mēs redzam šeit programma beidzās ar 11 signālu, segmentācija defektu.

331
00:26:02,340 --> 00:26:10,110
Mēs gadās redzēt līniju montāžu, kas, iespējams, nav ļoti noderīga.

332
00:26:10,110 --> 00:26:15,360
Bet, ja jūs tipa BT vai Izcelsme, kas būs funkcija

333
00:26:15,360 --> 00:26:19,430
kas dod mums sarakstu ar mūsu pašreizējo kaudze rāmjiem.

334
00:26:19,430 --> 00:26:23,150
Tā Izcelsme. Izskatās, ka mēs tikai divi kaudze rāmji.

335
00:26:23,150 --> 00:26:26,310
Pirmais ir mūsu galvenais kaudze rāmi,

336
00:26:26,310 --> 00:26:29,810
un otrais ir kaudze rāmis šai funkcijai, ka mēs gadās būt,

337
00:26:29,810 --> 00:26:34,440
kas izskatās, ka mums ir tikai montāžas kodu.

338
00:26:34,440 --> 00:26:38,050
Tāpēc iesim atpakaļ uz mūsu galveno funkciju,

339
00:26:38,050 --> 00:26:42,300
un to darīt, mēs varam darīt rāmi 1, un es domāju, ka mēs varam arī darīt leju,

340
00:26:42,300 --> 00:26:45,160
bet es gandrīz nekad darīt leju - vai uz augšu. Yeah.

341
00:26:45,160 --> 00:26:50,710
Augšu un uz leju. Up parādīs jums uz augšu vienu kaudze rāmi, noteikti parādīs jums uz leju kaudze rāmi.

342
00:26:50,710 --> 00:26:53,240
Man ir tendence nekad izmantot.

343
00:26:53,240 --> 00:26:59,120
Es tikai konkrēti pateikt rāmi 1, kas ir doties uz rāmja nosaukumu 1.

344
00:26:59,120 --> 00:27:01,750
1 kadrs ir gatavojas celt mūs galvenajā kaudze rāmi,

345
00:27:01,750 --> 00:27:05,570
un tas saka šeit līniju kodu mēs gadās būt.

346
00:27:05,570 --> 00:27:07,950
Ja mēs vēlējāmies vēl pāris koda rindiņas, mēs varam teikt sarakstu,

347
00:27:07,950 --> 00:27:11,280
un kas notiek, lai dotu mums visas līnijas koda ap to.

348
00:27:11,280 --> 00:27:13,360
Līnija mēs segfaulted pie bija 6:

349
00:27:13,360 --> 00:27:17,360
ja (strcmp ("CS50 klintis", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
Ja tas nav skaidrs vēl, jūs varat saņemt to tieši no šejienes, vienkārši domāju, kāpēc tā segfaulted.

351
00:27:24,130 --> 00:27:28,800
Bet mēs varam ņemt to vienu soli tālāk un saka, "Kāpēc būtu argv [1] segfault?"

352
00:27:28,800 --> 00:27:38,830
Let 's drukas argv [1], un izskatās, ka tas ir 0x0, kas ir null rādītājs.

353
00:27:38,830 --> 00:27:44,750
Mēs strcmping CS50 akmeņiem un Null, un lai notiek, lai segfault.

354
00:27:44,750 --> 00:27:48,280
Un kāpēc ir argv [1] Null?

355
00:27:48,640 --> 00:27:51,280
[Students] Jo mums nedeva nekādām komandrindas argumentus.

356
00:27:51,280 --> 00:27:53,390
Yeah. Mēs neesam tai būtu iespējams komandrindas argumentus.

357
00:27:53,390 --> 00:27:58,460
Tāpēc ./buggy1 ir tikai nāksies argv [0] būs ./buggy1.

358
00:27:58,460 --> 00:28:02,100
Tas nav gatavojas būt ARGV [1], lai dodas uz segfault.

359
00:28:02,100 --> 00:28:07,450
Bet, ja tā vietā, es tikai CS50, tas gatavojas teikt Jūs saņemsiet D

360
00:28:07,450 --> 00:28:09,950
jo tas, kas tas ir paredzēts darīt.

361
00:28:09,950 --> 00:28:15,240
Aplūkojot buggy1.c, tas ir paredzēts, lai drukātu "Jūs saņemsiet D" -

362
00:28:15,240 --> 00:28:20,820
Ja argv [1] nav "CS50 klintis", "Jūs saņemsiet D", kas cits "Jums!"

363
00:28:20,820 --> 00:28:25,660
Tātad, ja mēs gribam, mums ir nepieciešams šis lai salīdzinātu kā taisnība,

364
00:28:25,660 --> 00:28:28,710
kas nozīmē, ka to var salīdzināt ar 0.

365
00:28:28,710 --> 00:28:31,100
Tātad argv [1] jābūt "CS50 klintis".

366
00:28:31,100 --> 00:28:35,660
Ja jūs vēlaties darīt, ka uz komandrindas, jums ir nepieciešams izmantot \ izvairīties telpu.

367
00:28:35,660 --> 00:28:41,690
Tātad CS50 \ ieži un jūs iegūsiet A!

368
00:28:41,690 --> 00:28:44,060
Ja jums nav darīt to slīpsvītru, kāpēc tas nedarbojas?

369
00:28:44,060 --> 00:28:47,190
[Students] Tas ir divas dažādas argumentus. >> Jā.

370
00:28:47,190 --> 00:28:52,540
Argv [1] būs CS50, un argv [2] būs klintis. Labi.

371
00:28:52,540 --> 00:28:56,470
>> Tagad ./buggy2 gatavojas segfault vēlreiz.

372
00:28:56,470 --> 00:29:01,880
Tā vietā, atverot to ar savu galveno failu, mēs vienkārši atvērt buggy2 tieši,

373
00:29:01,880 --> 00:29:05,000
tā buggy2 gdb.

374
00:29:05,000 --> 00:29:09,590
Tagad, ja mēs vienkārši palaist savu programmu, tad tas būs teikt programma saņēma signālu SIGSEGV,

375
00:29:09,590 --> 00:29:15,530
kas ir segfault signālu, un tas ir, ja tas noticis, lai notikt.

376
00:29:15,530 --> 00:29:21,250
Skatoties uz mūsu Izcelsme, mēs redzam, ka mēs bijām funkciju oh_no,

377
00:29:21,250 --> 00:29:23,900
ko sauc par funkciju skaists, ko sauc par funkciju Binky,

378
00:29:23,900 --> 00:29:26,460
ko sauc par galveno.

379
00:29:26,460 --> 00:29:31,680
Mēs varam redzēt arī argumentus, lai šo funkciju.

380
00:29:31,680 --> 00:29:34,680
Arguments, lai skaists un Binky bija 1.

381
00:29:34,680 --> 00:29:44,390
Ja mēs saraksts funkciju oh_no, mēs redzam, ka oh_no ir tikai dara char ** s = null;

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

383
00:29:47,410 --> 00:29:50,330
Kāpēc tas neizdodas?

384
00:29:54,330 --> 00:29:58,380
[Students] Jūs nevarat dereference Null rādītāju? >> Jā.

385
00:29:58,380 --> 00:30:06,090
Tas ir vienkārši sakot s ir NULL, neatkarīgi, ja tas notiek, ir char **,

386
00:30:06,090 --> 00:30:12,070
kas, atkarībā no tā, kā jūs interpretēt to, tas varētu būt rādītājs, lai rādītāju uz virknes

387
00:30:12,070 --> 00:30:15,550
vai masīvs stīgas.

388
00:30:15,550 --> 00:30:21,430
Tas s ir NULL, tāpēc * s dereferencing Null rādītāju,

389
00:30:21,430 --> 00:30:24,800
un tā tas būs crash.

390
00:30:24,800 --> 00:30:27,540
Tas ir viens no ātrākajiem veidiem, kā jūs varat iespējams segfault.

391
00:30:27,540 --> 00:30:31,300
Tas ir tikai deklarējot null rādītāju un uzreiz segfaulting.

392
00:30:31,300 --> 00:30:34,570
Tas ko oh_no dara.

393
00:30:34,570 --> 00:30:43,400
Ja mēs ejam uz augšu vienu kadru, tad mēs spēsim nokļūt funkciju sauc oh_no.

394
00:30:43,400 --> 00:30:44,830
Man vajag to darīt uz leju.

395
00:30:44,830 --> 00:30:48,610
Ja jums nav ievadīt komandu, un jūs vienkārši hit Enter vēlreiz,

396
00:30:48,610 --> 00:30:52,350
tas būs tikai atkārtot iepriekšējo komandu, kuru vadīja.

397
00:30:52,350 --> 00:30:56,610
Mēs esam 1 rāmī.

398
00:30:56,610 --> 00:31:04,650
Uzskaitot šī rāmja, mēs redzam šeit ir mūsu funkcija.

399
00:31:04,650 --> 00:31:08,520
Jūs varat hit sarakstu atkal, vai jūs varat darīt sarakstu 20 un tas saraksts vairāk.

400
00:31:08,520 --> 00:31:13,640
Funkcija skaists saka, ja man ir 1, tad dodieties uz oh_no funkciju,

401
00:31:13,640 --> 00:31:15,960
cits iet uz slinky funkciju.

402
00:31:15,960 --> 00:31:18,700
Un mēs zinām, i ir 1, jo mēs gadās redzēt šeit

403
00:31:18,700 --> 00:31:22,560
kas skaists sauca ar argumentu 1.

404
00:31:22,560 --> 00:31:27,560
Vai jūs varat vienkārši izdrukāt i un tā teikt man ir 1.

405
00:31:27,560 --> 00:31:33,770
Mēs šobrīd skaists, un, ja mēs iet uz augšu citu rāmi, mēs zinām mēs galu galā Binky.

406
00:31:33,770 --> 00:31:36,600
Augšu. Tagad mēs esam Binky.

407
00:31:36,600 --> 00:31:41,340
Uzskaitot šo funkciju - saraksts, no pirms pusgada samazināt man off -

408
00:31:41,340 --> 00:31:52,670
tas sākās pie kā, ja es ir 0, tad mēs ejam, lai izsauktu to oh_no, cits zvana skaists.

409
00:31:52,670 --> 00:31:57,000
Mēs zinām man bija 1, tā to sauc skaists.

410
00:31:57,000 --> 00:32:05,030
Un tagad mēs esam atpakaļ galvenais, un galvenais ir tikai būs int i = rand ()% 3;

411
00:32:05,030 --> 00:32:08,790
Tas ir tikai gatavojas sniegt jums izlases numuru, kas ir vai nu 0, 1, 2 vai.

412
00:32:08,790 --> 00:32:12,780
Tas notiek, lai izsauktu Binky ar šo numuru, un tas atgriezīsies 0.

413
00:32:12,780 --> 00:32:16,700
Meklē tas,

414
00:32:16,700 --> 00:32:19,880
tikai ejot caur programmu manuāli bez rādīt to nekavējoties,

415
00:32:19,880 --> 00:32:25,400
Jūs noteikt lūzuma punkts pamatdarbā, kas nozīmē, ka tad, kad mēs palaist programmu

416
00:32:25,400 --> 00:32:31,020
jūsu programma darbojas līdz tas hits lūzuma punkts.

417
00:32:31,020 --> 00:32:35,450
Tātad darbojas programma, tas darbosies, un tad tas būs hit galveno funkciju un pārtraukt darboties.

418
00:32:35,450 --> 00:32:44,700
Tagad mēs esam iekšā galvenais, un soli vai blakus gatavojas mūs uz nākamo līniju kodu.

419
00:32:44,700 --> 00:32:47,050
Jūs varat izdarīt soli vai nākamo.

420
00:32:47,050 --> 00:32:51,800
Hitting nākamais, tagad man ir iestatīts uz rand ()% 3, lai mēs varētu drukāt vērtību i,

421
00:32:51,800 --> 00:32:55,280
un tā teikt man ir 1.

422
00:32:55,280 --> 00:32:58,110
Tagad tas nav jautājums, vai mēs izmantojam nākamo vai soli.

423
00:32:58,110 --> 00:33:01,000
Es domāju, tas vienaldzīgs no iepriekšējā, taču mēs vēlamies izmantot nākamo.

424
00:33:01,000 --> 00:33:06,000
Ja mēs izmantojam soli, mēs soli uz funkciju, kas nozīmē apskatīt faktisko lieta

425
00:33:06,000 --> 00:33:07,940
ka notiek iekšpusē Binky.

426
00:33:07,940 --> 00:33:10,510
Ja mēs izmantojam nākamo, tad tas nozīmē iet pa funkciju

427
00:33:10,510 --> 00:33:14,070
un dodieties uz nākamo rindiņu kodu mūsu galvenā funkcija.

428
00:33:14,070 --> 00:33:17,900
Tepat šajā līnijā, es biju kur tā teica rand ()% 3;

429
00:33:17,900 --> 00:33:21,320
ja man soli, tas varētu doties uz īstenošanas randu

430
00:33:21,320 --> 00:33:25,110
un apskatīt to, kas tur notiek, un es varētu soli pa randu funkciju.

431
00:33:25,110 --> 00:33:26,920
Bet es vienalga par randu funkciju.

432
00:33:26,920 --> 00:33:30,190
Es tikai gribu, lai pārietu uz nākamo līniju koda galvenais, lai varu izmantot nākamo.

433
00:33:30,190 --> 00:33:35,800
Bet tagad man rūp Binky funkciju, tāpēc es gribu, lai soli kas.

434
00:33:35,800 --> 00:33:37,730
Tagad es esmu Binky.

435
00:33:37,730 --> 00:33:42,040
Pirmā līnija koda gatavojas teikt, ja (i == 0), es soli,

436
00:33:42,040 --> 00:33:44,930
mēs redzam, mēs galu galā pie skaists.

437
00:33:44,930 --> 00:33:51,620
Ja mēs saraksts lietas, mēs redzam, ka tas pārbaudīts ir i = 0.

438
00:33:51,620 --> 00:33:55,470
Man nav vienāds ar 0, tāpēc devās uz citu nosacījumu,

439
00:33:55,470 --> 00:33:59,540
kas gatavojas aicināt Dinky (i).

440
00:33:59,540 --> 00:34:04,030
Jūs varētu saņemt sajaukt.

441
00:34:04,030 --> 00:34:07,380
Ja jūs paskatieties šo līniju tieši, jūs varētu domāt, ja (i == 0),

442
00:34:07,380 --> 00:34:10,800
labi, tad es spēra soli, un tagad es esmu pie Dinky (i),

443
00:34:10,800 --> 00:34:14,120
Jūs varētu domāt, ka ir nozīmē i = 0 vai kaut.

444
00:34:14,120 --> 00:34:18,980
Nē tikai nozīmē, ka tā zina, tā var pielipt tieši uz līnijas Dinky (i).

445
00:34:18,980 --> 00:34:23,300
Jo man nav 0, nākamais solis nav gatavojas pārtraukt pie cits.

446
00:34:23,300 --> 00:34:26,239
Cits nav līnija tas gatavojas apstāties pie.

447
00:34:26,239 --> 00:34:31,570
Tas ir tikai gatavojas doties uz nākamo līniju tā var reāli izpildīt, kas ir skaists (i).

448
00:34:31,570 --> 00:34:36,090
Pastiprināšanu Dinky (i), mēs redzam, ja (i == 1).

449
00:34:36,090 --> 00:34:42,670
Mēs zinām i = 1, tad, kad mēs soli, mēs zinām, mēs ejam, lai galu galā oh_no

450
00:34:42,670 --> 00:34:46,489
jo es = 1 izsauc funkciju oh_no, ko jūs varat soli,

451
00:34:46,489 --> 00:34:52,969
kas gatavojas noteikt char ** s = uz NULL un uzreiz "bums".

452
00:34:54,270 --> 00:34:59,690
Un tad faktiski meklē īstenošanas buggy2,

453
00:34:59,690 --> 00:35:04,590
Tas, es ir tikai kļūst izlases numuru - 0, 1, 2 vai - zvanot Binky,

454
00:35:04,590 --> 00:35:10,610
kas, ja es ir 0 tas aicina oh_no, cits tā aicina skaists, kas nāk šeit.

455
00:35:10,610 --> 00:35:18,100
Ja es ir 1, zvans oh_no, cits zvana Slinky, kas nāk šeit,

456
00:35:18,100 --> 00:35:20,460
ja es ir 2, zvanīt oh_no.

457
00:35:20,460 --> 00:35:24,720
Man nav pat domāju, ka ir veids, -

458
00:35:24,720 --> 00:35:30,030
Vai kāds redzētu veids, kā padarīt šo programmu, kas nav segfault?

459
00:35:30,030 --> 00:35:37,530
Jo ja es esmu trūkst kaut ko, ja es ir 0, jūs uzreiz segfault,

460
00:35:37,530 --> 00:35:41,250
arī jūs dodaties uz funkciju, kas, ja es ir 1 jums segfault,

461
00:35:41,250 --> 00:35:44,540
cits jums iet līdz funkcijai, kur, ja i ir 2 jums segfault.

462
00:35:44,540 --> 00:35:46,810
Līdz ar to nav svarīgi, ko jūs darāt, jūs segfault.

463
00:35:46,810 --> 00:35:52,380
>> Es domāju viens no veidiem, nosakot, ka būtu nevis darīt char ** s = null,

464
00:35:52,380 --> 00:35:55,610
Jūs varētu malloc vietu šajā virknē.

465
00:35:55,610 --> 00:36:04,230
Mēs varētu darīt malloc (sizeof) - sizeof ko?

466
00:36:09,910 --> 00:36:15,190
[Students] (char) * 5? >> Vai tas šķiet labi?

467
00:36:15,190 --> 00:36:21,060
Es esmu pieņemot, ka tas darbosies, ja es tiešām skrēja, bet tas nav tas, ko es esmu meklē.

468
00:36:24,400 --> 00:36:32,940
Paskaties veida s. Pieņemsim pievienot int *, lai int * x.

469
00:36:32,940 --> 00:36:35,600
Es varētu darīt malloc (sizeof (int)).

470
00:36:35,600 --> 00:36:40,490
Vai, ja es gribēju masīvs 5, es varētu darīt (sizeof (int) * 5);

471
00:36:40,490 --> 00:36:44,210
Ko darīt, ja man ir int **?

472
00:36:46,260 --> 00:36:49,140
Ko es malloc?

473
00:36:49,140 --> 00:36:53,510
[Students] lielums rādītāja. >> Jā. (Sizeof (int *));

474
00:36:53,510 --> 00:36:56,960
Pats uz leju šeit.

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

476
00:37:06,170 --> 00:37:12,840
Tas ir gatavojas piešķirt vietu rādītāja, kas norāda uz "bums".

477
00:37:12,840 --> 00:37:15,330
Man nav nepieciešams piešķirt telpu "bums" pati

478
00:37:15,330 --> 00:37:17,210
jo tas ir būtībā līdzvērtīgs tam, ko es teicu iepriekš

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

480
00:37:20,870 --> 00:37:27,950
"Bums" jau eksistē. Tas notiek ar pastāvēt tikai lasīšanas reģiona atmiņas.

481
00:37:27,950 --> 00:37:35,200
Bet tas jau pastāv, kas nozīmē šo koda rindu, ja s ir char **,

482
00:37:35,200 --> 00:37:43,900
tad * s ir char * un jūs nosakot šo char *, lai norādītu uz "bums".

483
00:37:43,900 --> 00:37:50,040
Ja es gribēju, lai kopētu "bums" uz s, tad es būtu nepieciešams, lai sadalītu telpu s.

484
00:37:55,170 --> 00:38:03,900
Es darīšu * s = malloc (sizeof (char) * 5);

485
00:38:03,900 --> 00:38:06,210
Kāpēc 5?

486
00:38:06,210 --> 00:38:10,860
Kāpēc ne 4? Tā izskatās "bums" ir 4 zīmes. >> [Students] null raksturs.

487
00:38:10,860 --> 00:38:14,580
Yeah. Visas jūsu stīgas būs nepieciešams null raksturs.

488
00:38:14,580 --> 00:38:23,590
Tagad es varu darīt kaut ko līdzīgu strcat - Kāda ir kopēšanas virkni funkciju?

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

490
00:38:28,520 --> 00:38:32,700
Vīrietis strcpy.

491
00:38:36,120 --> 00:38:39,590
Tātad strcpy vai strncpy.

492
00:38:39,590 --> 00:38:43,410
strncpy ir mazliet drošāk, jo jūs var precīzi norādīt, cik rakstzīmes,

493
00:38:43,410 --> 00:38:46,190
bet šeit tas nav svarīgi, jo mēs zinām.

494
00:38:46,190 --> 00:38:50,340
Tik strcpy un meklēt argumentus.

495
00:38:50,340 --> 00:38:53,100
Pirmais arguments ir mūsu galamērķis.

496
00:38:53,100 --> 00:38:56,770
Otrs arguments ir mūsu avots.

497
00:38:56,770 --> 00:39:10,310
Mēs ejam, lai kopētu mūsu mērķa * s rādītājs "bums".

498
00:39:10,310 --> 00:39:19,820
Kāpēc jūs varētu vēlēties to darīt ar strcpy nevis tikai to, ko mums bija pirms

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

500
00:39:22,800 --> 00:39:28,630
Ir iemesls, jūs varētu vēlēties to darīt, bet kas tas ir iemesls?

501
00:39:28,630 --> 00:39:31,940
[Students] Ja jūs vēlaties kaut ko mainīt "bums". >> Jā.

502
00:39:31,940 --> 00:39:37,950
Tagad es varu darīt kaut ko līdzīgu s [0] = "X";

503
00:39:37,950 --> 00:39:48,190
jo s norāda uz kaudze un šī vieta uz kaudzes, ka s ir vērsta uz

504
00:39:48,190 --> 00:39:52,320
ir rādītājs uz lielāku vietu uz kaudzes, kas tiek glabāta "bums".

505
00:39:52,320 --> 00:39:55,150
Tātad šis "bums" kopija tiek saglabāta kaudzē.

506
00:39:55,150 --> 00:39:58,780
Ir tehniski divos eksemplāros "bums" mūsu programmā.

507
00:39:58,780 --> 00:40:03,500
Tur pirmais, kas ir tikai dota šī "bums" stīgu konstante,

508
00:40:03,500 --> 00:40:09,250
un otro kopiju "bums", strcpy radīja kopiju "bums".

509
00:40:09,250 --> 00:40:13,100
Bet par "bums" kopija tiek saglabāta uz kaudzes, un kaudze jūs esat brīvi mainīt.

510
00:40:13,100 --> 00:40:17,250
Kaudze ir tikai lasāma, lai tas nozīmē, ka s [0]

511
00:40:17,250 --> 00:40:20,500
gatavojas ļauj mainīt vērtību "bums".

512
00:40:20,500 --> 00:40:23,130
Tas notiek, lai jums mainīt šos simbolus.

513
00:40:23,130 --> 00:40:26,640
>> Jautājumi?

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

515
00:40:29,290 --> 00:40:35,500
>> Pārvietojas uz buggy3, pieņemsim GDB buggy3.

516
00:40:35,500 --> 00:40:39,840
Mēs vienkārši palaist to, un mēs redzam mēs segfault.

517
00:40:39,840 --> 00:40:46,550
Ja mēs Izcelsme, ir tikai divas funkcijas.

518
00:40:46,550 --> 00:40:52,970
Ja mēs ejam uz augšu mūsu galvenā funkcija, mēs redzam, ka mēs segfaulted šajā līnijā.

519
00:40:52,970 --> 00:41:00,180
Tik vienkārši apskatot šo līniju, uz (int līnija = 0; fgets šī stuff nav vienāds null;

520
00:41:00,180 --> 00:41:03,770
līnija + +).

521
00:41:03,770 --> 00:41:08,010
Mūsu iepriekšējais rāmis tika saukta _IO_fgets.

522
00:41:08,010 --> 00:41:10,720
Jūs redzēsiet, ka partija ar iebūvētu C funkciju,

523
00:41:10,720 --> 00:41:15,350
ka tad, kad jūs saņemsiet segfault, būs patiesi mistisks funkcijas vārdus

524
00:41:15,350 --> 00:41:18,090
Tāpat kā šī _IO_fgets.

525
00:41:18,090 --> 00:41:21,770
Bet kas notiek, lai ir saistīti ar šo fgets aicinājumu.

526
00:41:21,770 --> 00:41:25,850
Kaut kur iekšā šeit, mēs segfaulting.

527
00:41:25,850 --> 00:41:30,340
Ja mēs skatāmies uz argumentiem, lai fgets, mēs varam drukāt buferis.

528
00:41:30,340 --> 00:41:41,180
Pieņemsim drukāt kā - Ak, nē.

529
00:41:48,980 --> 00:41:51,900
Drukas nav dodas uz darbu tieši tā, kā es gribu to.

530
00:41:55,460 --> 00:41:58,000
Apskatīsim faktisko programmu.

531
00:42:02,200 --> 00:42:09,640
Buferis ir raksturs masīvs. Tas ir raksturs masīvs 128 zīmēm.

532
00:42:09,640 --> 00:42:14,980
Tātad, kad es saku drukas buferi, tas notiek, lai drukātu šos 128 rakstzīmēm,

533
00:42:14,980 --> 00:42:18,300
ko es domāju, ir, kas ir gaidāms.

534
00:42:18,300 --> 00:42:21,390
Ko es meklēju ir drukāt adresi bufera,

535
00:42:21,390 --> 00:42:23,680
bet tas nav īsti man pateikt daudz.

536
00:42:23,680 --> 00:42:30,770
Tātad, ja es notikt teikt šeit x buferis, tā rāda man 0xbffff090,

537
00:42:30,770 --> 00:42:38,690
kas, ja jūs atceraties no agrāk vai kādā brīdī, Oxbffff mēdz būt kaudze ish reģionā.

538
00:42:38,690 --> 00:42:46,020
Kaudze tendence sākt kaut nedaudz zem 0xc000.

539
00:42:46,020 --> 00:42:51,890
Tikai redzot šo adresi, es zinu, ka buferis notiek uz skursteņa.

540
00:42:51,890 --> 00:43:04,500
Restartēt savu programmu, palaist, uz augšu, bufera mēs redzējām, bija šo rakstzīmju secību

541
00:43:04,500 --> 00:43:06,530
ka ir diezgan daudz bezjēdzīgi.

542
00:43:06,530 --> 00:43:12,270
Tad drukāšanas failu, ko tas fails izskatās?

543
00:43:15,120 --> 00:43:17,310
[Students] Null. >> Jā.

544
00:43:17,310 --> 00:43:22,610
Fails ir tipa fails *, tāpēc tas ir rādītājs,

545
00:43:22,610 --> 00:43:26,610
un šī rādītāja vērtība ir nulle.

546
00:43:26,610 --> 00:43:33,240
Tāpēc fgets gatavojas, lai mēģinātu lasīt no šī rādītāja netiešā veidā,

547
00:43:33,240 --> 00:43:37,320
bet, lai piekļūtu šo rādītāju, tas ir dereference to.

548
00:43:37,320 --> 00:43:40,550
Vai, lai piekļūtu to, ko tā būtu vērsta uz, tā dereferences IT.

549
00:43:40,550 --> 00:43:43,810
Tātad tas ir dereferencing Null rādītāju un tā segmentācijas kļūdas.

550
00:43:46,600 --> 00:43:48,730
Es varētu būt atsākās to tur.

551
00:43:48,730 --> 00:43:52,170
Ja mēs pārkāpjam mūsu galvenais punkts un palaist,

552
00:43:52,170 --> 00:43:57,320
pirmajā rindā kods ir char * filename = "nonexistent.txt";

553
00:43:57,320 --> 00:44:00,870
Ka vajadzētu dot diezgan liels mājienu par to, kāpēc šī programma neizdodas.

554
00:44:00,870 --> 00:44:06,080
Ierakstot blakus nes mani uz nākamo rindiņu, kur es atvērt šo failu,

555
00:44:06,080 --> 00:44:11,140
un tad es uzreiz nokļūt mūsu līnijā, kur reiz es hit nākamo, tas dodas uz segfault.

556
00:44:11,140 --> 00:44:16,880
Vai kāds vēlas mest ārā iemesls, kāpēc mēs varētu segfaulting?

557
00:44:16,880 --> 00:44:19,130
[Students] Fails nepastāv. >> Jā.

558
00:44:19,130 --> 00:44:22,250
Tas ir vajadzētu būt mājiens

559
00:44:22,250 --> 00:44:29,570
ka ikreiz, kad jūs atvērt failu, jums ir nepieciešams, lai pārbaudītu, ka fails tiešām pastāv.

560
00:44:29,570 --> 00:44:31,510
Tātad šeit, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
Kad mēs fopen filename par lasījumā, mēs pēc tam jāpasaka

562
00:44:34,700 --> 00:44:45,870
ja (fails == NULL) un saka printf ("fails neeksistē!"

563
00:44:45,870 --> 00:44:56,340
vai - vēl labāk - filename), atgriešanās 1;

564
00:44:56,340 --> 00:45:00,300
Tāpēc tagad mēs pārbaudām, vai tas ir NULL

565
00:45:00,300 --> 00:45:03,930
Pirms faktiski turpina un mēģina nolasīt no šī faila.

566
00:45:03,930 --> 00:45:08,800
Mēs varam pārtaisīt to tikai, lai redzētu, ka šis darbi.

567
00:45:11,020 --> 00:45:14,970
Es paredzēts iekļaut jaunu līniju.

568
00:45:21,090 --> 00:45:25,290
Tāpēc tagad nonexistent.txt neeksistē.

569
00:45:26,890 --> 00:45:30,040
Jums vienmēr vajadzētu pārbaudīt šāda veida lieta.

570
00:45:30,040 --> 00:45:33,870
Jums vienmēr vajadzētu pārbaudīt, lai redzētu, vai fopen atgriež null.

571
00:45:33,870 --> 00:45:38,170
Jums vienmēr vajadzētu pārbaudīt, lai pārliecinātos, ka malloc neatgriežas null,

572
00:45:38,170 --> 00:45:41,410
vai arī jūs segfault.

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

574
00:45:49,190 --> 00:45:58,440
Darboties. Es esmu guessing tas gaida ieejas vai iespējams bezgalīgs looping.

575
00:45:58,440 --> 00:46:01,870
Jā, tas ir bezgalīgs looping.

576
00:46:01,870 --> 00:46:05,560
Tā buggy4. Izskatās, ka mēs esam bezgalīgs looping.

577
00:46:05,560 --> 00:46:12,590
Mēs varam pārtraukumu galvenais, palaist mūsu programmu.

578
00:46:12,590 --> 00:46:20,180
Gdb, kamēr saīsinājums jūs izmantojat ir nepārprotams

579
00:46:20,180 --> 00:46:23,420
vai īpašas saīsinājumi, ko tie sniedz jums,

580
00:46:23,420 --> 00:46:29,020
tad jūs varat izmantot n izmantot nākamo vietā, lai tipa no nākamās visu ceļu.

581
00:46:29,020 --> 00:46:33,730
Un tagad, ka es esmu hit n reizi, es varu tikai hit Enter, lai saglabātu notiek nākamo

582
00:46:33,730 --> 00:46:36,640
tā vietā, lai hit n Enter, n Enter, n Enter.

583
00:46:36,640 --> 00:46:44,630
Izskatās, ka es esmu sava veida cilpa, kas ir kurā masīvs [i] uz 0.

584
00:46:44,630 --> 00:46:50,510
Izskatās, es nekad izkļūt no šī cilpa.

585
00:46:50,510 --> 00:46:54,780
Ja es drukāt i, tāpēc es ir 2, tad es iešu nākamo.

586
00:46:54,780 --> 00:46:59,250
Es izdrukāt es, es ir 3, tad es iešu nākamo.

587
00:46:59,250 --> 00:47:05,360
Es izdrukāt i un i ir 3. Nākamais, drukāt es, es ir 4.

588
00:47:05,360 --> 00:47:14,520
Patiesībā, drukas sizeof (masīvs), tāpēc no masīva izmērs ir 20.

589
00:47:16,310 --> 00:47:32,870
Bet izskatās, ka tur ir dažas īpašas gdb komanda dodas līdz kaut kas notiek.

590
00:47:32,870 --> 00:47:37,620
Tas ir tāpat kā nosakot nosacījums par vērtību mainīgā. Bet es neatceros, kas tas ir.

591
00:47:37,620 --> 00:47:44,100
Tātad, ja mēs tur notiek -

592
00:47:44,100 --> 00:47:47,120
Ko jūs sakāt? Ko jūs audzināt?

593
00:47:47,120 --> 00:47:50,500
[Students] Vai parādīt es pievienot - >> jā. Tāpēc displejs i var palīdzēt.

594
00:47:50,500 --> 00:47:54,530
Ja mēs vienkārši parādīt i, tas būs likts šeit kāda no i vērtība ir

595
00:47:54,530 --> 00:47:56,470
tāpēc man nav to izdrukāt katru reizi.

596
00:47:56,470 --> 00:48:02,930
Ja mēs tikai glabāt iet blakus, mēs redzam 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
Kaut kas notiek briesmīgi nepareizi, un es tiek reset uz 0.

598
00:48:13,330 --> 00:48:22,220
Aplūkojot buggy4.c, mēs redzam visu, kas notiek, ir int masīvs [5];

599
00:48:22,220 --> 00:48:26,200
(i = 0, i <= sizeof (masīvs), i + +)

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

601
00:48:28,550 --> 00:48:31,390
Ko mēs redzam, ka ir nepareizi šeit?

602
00:48:31,390 --> 00:48:39,480
Kā mājienu, kad es to gdb buggy4 - pieņemsim pauze galvenais, palaist -

603
00:48:39,480 --> 00:48:45,980
Man drukas sizeof (masīvs), tikai lai redzētu, kas nosacījums ir, ja es būtu beidzot izlauzties.

604
00:48:47,690 --> 00:48:51,100
Kur es esmu? Vai es palaist?

605
00:48:51,100 --> 00:48:54,280
Man nav deklarējis vēl.

606
00:48:54,280 --> 00:48:58,680
Tātad izdrukāt sizeof (masīvs), un tas ir 20,

607
00:48:58,680 --> 00:49:06,690
kas gaidāms jo mans masīvs ir 5 lieluma un tas ir no 5 integers,

608
00:49:06,690 --> 00:49:12,410
tāpēc visa lieta ir 5 * sizeof (int) baiti, ja sizeof (int) mēdz būt 4.

609
00:49:12,410 --> 00:49:14,780
Tātad sizeof (masīvs) ir 20.

610
00:49:14,780 --> 00:49:17,420
Kas būtu tas būtu?

611
00:49:17,420 --> 00:49:21,720
[Students] dalīts ar sizeof (int). >> Jā, / sizeof (int).

612
00:49:21,720 --> 00:49:30,630
Izskatās, ka tur ir vēl problēma šeit. Es domāju, ka tas būtu vienkārši <

613
00:49:30,630 --> 00:49:36,960
jo tas ir diezgan daudz vienmēr <un nekad <=.

614
00:49:36,960 --> 00:49:44,860
Tagad domāju par to, kāpēc tas bija patiešām sadalīti.

615
00:49:44,860 --> 00:49:53,370
Vai kāds ir minējumi, kāpēc bija man reset uz 0 caur katru atkārtojuma no cilpas?

616
00:50:01,300 --> 00:50:09,350
Vienīgā lieta iekšpusē šeit, kas ir noticis, ka masīvs [i] tiek iestatīts uz 0.

617
00:50:09,350 --> 00:50:15,350
Tātad kaut kā, šis koda līnija izraisa mūsu int i var noteikt līdz 0.

618
00:50:16,730 --> 00:50:23,130
[Students] Vai tā varētu būt, jo tas ir sevišķi svarīgi atmiņas par šo daļu no i

619
00:50:23,130 --> 00:50:27,970
ja tas uzskata, ka ir nākamais elements masīva? >> [Bowden] Jā.

620
00:50:27,970 --> 00:50:33,880
Kad mēs ejam tālāk beigās mūsu masīvs,

621
00:50:33,880 --> 00:50:39,870
kaut ka telpa, ka mēs primāri ir svarīgas vērtības i.

622
00:50:39,870 --> 00:50:48,030
Un tāpēc, ja mēs skatāmies uz buggy4, salauzt galvenais, skrien,

623
00:50:48,030 --> 00:50:53,120
pieņemsim drukāt adresi i.

624
00:50:53,120 --> 00:50:57,280
Izskatās, ka tas ir bffff124.

625
00:50:57,280 --> 00:51:03,930
Tagad drukāt adresi masīva [0]. 110.

626
00:51:03,930 --> 00:51:06,290
Kas par [1]? 114.

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

628
00:51:07,920 --> 00:51:14,530
11c, 120. masīvs [5] ir bfff124.

629
00:51:14,530 --> 00:51:26,990
Tāpēc masīvs [5] ir tāda pati adrese kā man, kas nozīmē, ka masīva [5] ir i.

630
00:51:26,990 --> 00:51:30,720
Ja viņi ir viena adrese, tie ir tas pats.

631
00:51:30,720 --> 00:51:38,410
Tātad, kad mēs, kas masīvu [5] uz 0, mēs kurā es uz 0.

632
00:51:38,410 --> 00:51:46,070
Un, ja jūs domājat par šo ziņā kaudze,

633
00:51:46,070 --> 00:51:55,590
int i ir deklarēta pirmais, kas nozīmē, es izpaužas dažas vietas uz skursteņa.

634
00:51:55,590 --> 00:52:04,730
Tad masīvs [5] tiek piešķirta, lai tad 20 baiti tiek piešķirti uz skursteņa.

635
00:52:04,730 --> 00:52:08,400
Tāpēc es izpaužas piešķir vispirms, tad šie 20 baiti get piešķirts.

636
00:52:08,400 --> 00:52:11,400
Tāpēc es notiek tieši pirms masīvs,

637
00:52:11,400 --> 00:52:19,230
un tāpēc, ka tā, tāpat kā es teicu pagājušajā nedēļā, kad tehniski kaudze aug uz leju,

638
00:52:19,230 --> 00:52:28,520
kad tu indekss masīvs, mēs garantēta ka 0. pozīciju masīvā

639
00:52:28,520 --> 00:52:31,970
vienmēr notiek pirms pirmās pozīcijas masīva.

640
00:52:31,970 --> 00:52:35,900
Tas ir veids, kā es vērsa to pagājušajā nedēļā.

641
00:52:35,900 --> 00:52:42,210
Ievērojiet, ka apakšā mums ir adrese 0 un augšpusē mums ir adrese Max.

642
00:52:42,210 --> 00:52:44,880
Kaudze vienmēr pieaug leju.

643
00:52:48,100 --> 00:52:53,500
Teiksim mēs piešķirt i.

644
00:52:53,500 --> 00:52:59,680
Mēs piešķirt skaitlim i, kas nozīmē, pieņemsim tikai teikt, šeit skaitlim es izpaužas piešķirts.

645
00:52:59,680 --> 00:53:06,420
Tad mēs piešķirt mūsu klāstu 5 integers, kas nozīmē, ka zem ka,

646
00:53:06,420 --> 00:53:11,230
jo kaudze aug uz leju, šie 5 skaitļu get piešķirts.

647
00:53:11,230 --> 00:53:15,900
Bet tāpēc, ka kā bloki strādā, mēs esam garantēta ka pirmo pozīciju masīvā

648
00:53:15,900 --> 00:53:22,260
vienmēr ir ņemti mazāk nekā otrajā lieta masīvā.

649
00:53:22,260 --> 00:53:28,270
Tāpēc masīvs pozīcija 0 vienmēr ir jānotiek vispirms atmiņā,

650
00:53:28,270 --> 00:53:30,700
tā masīvs pozīcija 1 ir jānotiek pēc tam

651
00:53:30,700 --> 00:53:33,310
un masīvs pozīcija 2 ir noticis pēc tam,

652
00:53:33,310 --> 00:53:37,900
kas nozīmē, ka masīva pozīcija 0 notiktu kaut kur šeit lejā,

653
00:53:37,900 --> 00:53:40,690
masīvs stāvoklis 1 notiktu augstāk

654
00:53:40,690 --> 00:53:45,530
jo pārvietojas uz augšu nozīmē augstāku adreses jo maksimālais adrese ir šeit.

655
00:53:45,530 --> 00:53:50,490
Tāpēc masīvs [0] noteikti šeit, masīvs [1] šeit, masīvs [2] šeit, masīvs [3] šeit.

656
00:53:50,490 --> 00:53:55,620
Paziņojums, kā pirms mēs piešķirts skaitlis es visu ceļu augšup šeit,

657
00:53:55,620 --> 00:54:01,040
kā mēs virzāmies tālāk un tālāk mūsu masīvs, mēs kļūst tuvāk un tuvāk mūsu skaitlim i.

658
00:54:01,040 --> 00:54:07,640
Tas tikai tā notiek, ka masīvu [5], kas ir viena pozīcija ārpus mūsu masīvs,

659
00:54:07,640 --> 00:54:13,010
ir tieši tur, kur skaitlim es notika piešķīrums.

660
00:54:13,010 --> 00:54:16,920
Tātad tas ir punkts, kur mēs gadās būt hitting vietu uz skursteņa

661
00:54:16,920 --> 00:54:21,680
kas tika piešķirti skaitlim i, un mēs esam nosakot, ka uz 0.

662
00:54:21,680 --> 00:54:26,160
>> Tas ir kā tas darbojas. Jautājumi? Yeah.

663
00:54:26,160 --> 00:54:30,710
[Students] Nekad prātā. Labi.

664
00:54:30,710 --> 00:54:33,090
[Students] Kā jūs izvairītos šos veida kļūdas?

665
00:54:33,090 --> 00:54:41,190
Šie veida kļūdas? Neizmantojiet C kā savu programmēšanas valodu.

666
00:54:41,190 --> 00:54:45,840
Lietot valodu, kas ir masīva robežas pārbaudes.

667
00:54:45,840 --> 00:54:55,900
Kamēr jūs uzmanīgi, jums ir nepieciešams, lai izvairītos no vēršanās pagātnē jūsu masīvs robežas.

668
00:54:55,900 --> 00:54:58,300
[Students] Tātad šeit, kad mēs devāmies agrāk par jūsu masīvs robežas -

669
00:54:58,300 --> 00:55:01,840
[Bowden] Tas ir, ja lietas sāk iet greizi. >> [Students] Ak, labi.

670
00:55:01,840 --> 00:55:05,730
Kamēr jūs uzturēšanās laikā atmiņā atvēlēts jūsu masīvs, viss ir kārtībā.

671
00:55:05,730 --> 00:55:12,400
Bet C nav nekādu kļūdu pārbaudi. Ja man masīvs [1000], tas labprāt vienkārši mainīt arī notiktu -

672
00:55:12,400 --> 00:55:16,500
Tā iet uz sākuma masīvs, tad tas iet 1000 pozīcijas pēc un nosaka to uz 0.

673
00:55:16,500 --> 00:55:20,000
Tas nav jādara visas pārbaudes ka ak, tas nav reāli ir 1000 lietas tajā.

674
00:55:20,000 --> 00:55:22,750
1000 ir veids, kā tikai to, kas man būtu mainās,

675
00:55:22,750 --> 00:55:26,940
bet Java vai kaut ko jūs saņemsiet masīvs no robežas indeksa

676
00:55:26,940 --> 00:55:29,820
vai indekss no robežas izņēmuma.

677
00:55:29,820 --> 00:55:33,950
Tieši tāpēc no augstāka līmeņa valodu daudz ir šīs lietas

678
00:55:33,950 --> 00:55:37,340
kur, ja jūs iet ārpus masīva robežām, jums neizdodas

679
00:55:37,340 --> 00:55:40,070
lai jūs nevarat mainīt lietas no zem jums

680
00:55:40,070 --> 00:55:42,590
un tad lietas iet daudz sliktāk nekā tikai iegūt izņēmumu

681
00:55:42,590 --> 00:55:44,940
saprotams, ka jums gāja pēc projekta beigām masīva.

682
00:55:44,940 --> 00:55:50,970
[Students] Un tā būtu mēs esam tikko mainīts <= tikai <? >> [Bowden] Jā.

683
00:55:50,970 --> 00:55:54,800
Tas būtu <sizeof (masīvs) / sizeof (int);

684
00:55:54,800 --> 00:55:59,560
jo sizeof (masīvs) ir 20, bet mēs tikai vēlamies 5. >> [Students] labi.

685
00:55:59,560 --> 00:56:04,060
Vēl jautājumi? Labi.

686
00:56:04,060 --> 00:56:07,380
>> [Students] Man ir jautājums. >> Jā.

687
00:56:07,380 --> 00:56:16,440
[Students] Kas ir faktiskais masīvs mainīgā?

688
00:56:16,440 --> 00:56:20,000
[Bowden] Tāpat kā to ir masīvs?

689
00:56:20,000 --> 00:56:24,930
Masīvs pati par sevi ir simbols.

690
00:56:24,930 --> 00:56:31,490
Tas ir tikai adrese sākuma 20 baitu ka mēs atsaucēm.

691
00:56:31,490 --> 00:56:38,070
Jūs varat domāt par to kā rādītājs, bet tas ir nemainīgs rādītājs.

692
00:56:38,070 --> 00:56:44,140
Tiklīdz lietas iegūt apkopota, mainīgais masīvs vairs neeksistē.

693
00:56:44,140 --> 00:56:48,210
[Students] Tātad, kā tas atrast izmēru masīva?

694
00:56:48,210 --> 00:56:54,130
Lielumu masīvs attiecas uz izmēru šajā blokā, ka simbols attiecas.

695
00:56:54,130 --> 00:57:01,240
Kad man kaut kas līdzīgs printf ("% p \ n", masīvs);

696
00:57:01,240 --> 00:57:05,140
pieņemsim palaist to.

697
00:57:12,960 --> 00:57:15,530
Ko es tikai darīt nepareizi?

698
00:57:15,530 --> 00:57:19,220
Bloks "masīvs" paziņoja šeit.

699
00:57:20,820 --> 00:57:23,200
Ak, šeit.

700
00:57:23,200 --> 00:57:31,250
Šķindēt ir gudrs, un tas notiek ar pamanīt, ka man paziņoja, ka masīvu kā 5 elementiem

701
00:57:31,250 --> 00:57:34,540
bet es esmu indeksāciju uz 1000 pozīcijā.

702
00:57:34,540 --> 00:57:38,450
To var darīt, jo tie ir tikai konstantes.

703
00:57:38,450 --> 00:57:43,370
To var tikai tik tālu, pamanījusi, ka es esmu gatavojas ārpus masīva robežām.

704
00:57:43,370 --> 00:57:46,880
Bet paziņojums pirms kad mums bija man būt nepareizi,

705
00:57:46,880 --> 00:57:51,040
tas nav iespējams noteikt, cik daudz vērtības es varētu uzņemties,

706
00:57:51,040 --> 00:57:55,540
tāpēc tas nevar noteikt, ka man bija iet pēc projekta beigām masīva.

707
00:57:55,540 --> 00:57:59,430
Tas ir tikai šķindēt ir gudrs.

708
00:57:59,430 --> 00:58:03,340
>> Bet tagad darīt buggy4. Tātad, ko vēl es daru nepareizi?

709
00:58:03,340 --> 00:58:05,970
Netieši atzīstot bibliotēkas funkcija "printf".

710
00:58:05,970 --> 00:58:14,960
Es esmu gatavojas vēlas # ietvert <stdio.h>.

711
00:58:14,960 --> 00:58:18,710
Labi. Tagad darbojas buggy4.

712
00:58:18,710 --> 00:58:24,840
Drukāšanas vērtību masīva piemēram, I did šeit, drukājot to kā rādītājs

713
00:58:24,840 --> 00:58:30,060
izdrukas kaut kas izskatās šādi - bfb8805c - kas ir daži adrese

714
00:58:30,060 --> 00:58:33,450
kas ir ar kaudze ish reģionā.

715
00:58:33,450 --> 00:58:41,820
Masīvs pati ir kā rādītājs, bet tas nav faktiskā rādītājs,

716
00:58:41,820 --> 00:58:45,410
jo regulāri rādītāju mēs varam mainīt.

717
00:58:45,410 --> 00:58:54,700
Masīvs ir tikai daži nemainīgs. Tās 20 bloki atmiņas sākas pēc adreses 0xbfb8805c.

718
00:58:54,700 --> 00:59:09,020
Tātad bfb8805c caur šo adresi +20--vai es domāju -20 -

719
00:59:09,020 --> 00:59:17,400
viss no atmiņas piešķirti šī masīva.

720
00:59:17,400 --> 00:59:20,350
Masīvs, mainīgais pats netiek saglabāta jebkur.

721
00:59:20,350 --> 00:59:27,660
Kad esat apkopojot, kompilators - roku vilnis pie tā -

722
00:59:27,660 --> 00:59:33,060
bet kompilators tikai izmantot, ja tā zina masīvs būt.

723
00:59:33,060 --> 00:59:36,090
Tā zina, kur tas masīvs sākas,

724
00:59:36,090 --> 00:59:40,910
un tā tas vienmēr var vienkārši darīt lietas saistībā ar kompensācijām no šī sākuma.

725
00:59:40,910 --> 00:59:43,960
Tas nav nepieciešams mainīgo pati pārstāvēt masīvs.

726
00:59:43,960 --> 00:59:53,730
Bet, kad man kaut kas līdzīgs int * p = bloku; tagad p ir rādītājs, kas norāda uz šo masīvs,

727
00:59:53,730 --> 00:59:57,830
un tagad p tiešām eksistē uz skursteņa.

728
00:59:57,830 --> 01:00:01,950
Es esmu brīvi mainīt p. Es varu darīt p = malloc.

729
01:00:01,950 --> 01:00:06,500
Tātad tas sākotnēji norādīja uz masīvu, tagad tas norāda uz kādu vietu uz kaudzes.

730
01:00:06,500 --> 01:00:09,620
Es nevaru darīt masīva = malloc.

731
01:00:09,620 --> 01:00:13,710
Ja šķindēt ir gudrs, tas būs bļaut uz mani tiesības pie nūja.

732
01:00:17,000 --> 01:00:21,430
Patiesībā, es esmu diezgan pārliecināts, ka LSP varētu darīt pārāk.

733
01:00:21,430 --> 01:00:25,010
Tāpēc masīvs tipa "int [5]" nav nododamas.

734
01:00:25,010 --> 01:00:28,040
Jūs nevarat kaut ko masīva tipam

735
01:00:28,040 --> 01:00:30,500
jo masīvs ir tikai nemainīgs.

736
01:00:30,500 --> 01:00:34,760
Tas ir simbols, kas atsauces šie 20 baiti. Es nevaru mainīt.

737
01:00:34,760 --> 01:00:37,690
>> [Students] Un kur ir masīva izmēru uzglabāti?

738
01:00:37,690 --> 01:00:40,670
[Bowden] Tas nav uzglabāt jebkur. Tas ir tad, kad tas ir apkopojot.

739
01:00:40,670 --> 01:00:46,310
Tātad, kur ir no masīva izmērs uzglabāti?

740
01:00:46,310 --> 01:00:51,870
Jūs varat izmantot tikai sizeof (masīvs) iekšpusē funkciju ka masīvs ir deklarējusi.

741
01:00:51,870 --> 01:01:03,150
Tātad, ja man dažas funkcijas, foo, un man (int masīvs [])

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

743
01:01:10,450 --> 01:01:21,330
un tad uz leju šeit es aicinu foo (masīvs);

744
01:01:21,330 --> 01:01:24,840
iekšpuses šo funkciju - pieņemsim palaist to.

745
01:01:34,200 --> 01:01:36,840
Tas ir šķindēt to gudrs vēlreiz.

746
01:01:36,840 --> 01:01:43,890
Tas stāsta man, ka sizeof uz masīvu funkcijas parametru

747
01:01:43,890 --> 01:01:46,690
atgriezīsies lielumu "int *".

748
01:01:46,690 --> 01:01:55,150
Tas būtu kļūda, ja tas nav tas, ko es gribēju, lai notikt.

749
01:01:55,150 --> 01:01:58,960
Pieņemsim faktiski izslēgt Werror.

750
01:02:14,950 --> 01:02:17,590
Brīdinājuma. Brīdinājumi ir labi.

751
01:02:17,590 --> 01:02:19,960
Tas joprojām apkopo kamēr tas ir brīdinājums.

752
01:02:19,960 --> 01:02:22,910
. / A.out gatavojas izdrukāt 4.

753
01:02:22,910 --> 01:02:28,650
Brīdinājuma kas tika radīts ir skaidrs rādītājs, kas nogāja greizi.

754
01:02:28,650 --> 01:02:34,120
Šī int masīvs ir tikai gatavojas, lai izdrukātu sizeof (int *).

755
01:02:34,120 --> 01:02:39,790
Pat ja man masīvs [5] šeit, tas joprojām tikai gatavojas drukāt sizeof (int *).

756
01:02:39,790 --> 01:02:47,440
Tā tiklīdz jūs iet to funkciju, atšķirība starp masīvu un norādes

757
01:02:47,440 --> 01:02:49,670
ir neeksistējošā.

758
01:02:49,670 --> 01:02:52,640
Tas notiek, ir masīvs, kas tika atzīts par steku,

759
01:02:52,640 --> 01:02:58,300
bet tiklīdz kā mums iet šo vērtību, kas 0xbf blah, blah, blah par šo funkciju,

760
01:02:58,300 --> 01:03:03,350
tad šis rādītājs norāda uz šo masīvs uz skursteņa.

761
01:03:03,350 --> 01:03:08,310
Tātad tas nozīmē, ka sizeof piemērojams tikai funkcijas, ka masīva tika atzīta,

762
01:03:08,310 --> 01:03:11,230
kas nozīmē, ka tad, kad jums ir apkopot šo funkciju,

763
01:03:11,230 --> 01:03:17,330
kad šķindēt iet cauri šo funkciju, tas redz masīvs ir int masīvs 5 lieluma.

764
01:03:17,330 --> 01:03:20,640
Tātad, tad tas redz sizeof (masīvs). Nu, tas ir 20.

765
01:03:20,640 --> 01:03:26,440
Tas ir tiešām kā sizeof būtībā strādā gandrīz visos gadījumos.

766
01:03:26,440 --> 01:03:31,150
Sizeof nav funkcija, tas ir operators.

767
01:03:31,150 --> 01:03:33,570
Jums nav izsauktu sizeof funkciju.

768
01:03:33,570 --> 01:03:38,280
Sizeof (int), kompilators būs tikai tulkot, ka līdz 4.

769
01:03:41,480 --> 01:03:43,700
Sanāca tā? Labi.

770
01:03:43,700 --> 01:03:47,520
>> [Students] Tātad, kāda ir starp sizeof (masīvs) starpība galvenais un foo?

771
01:03:47,520 --> 01:03:52,840
Tas ir tāpēc, ka mēs esam sakot sizeof (masīvs), kas ir tipa int *,

772
01:03:52,840 --> 01:03:57,120
tā kā masīvs noteikti šeit nav tipa int *, tas int masīvu.

773
01:03:57,120 --> 01:04:04,540
>> [Students] Tātad, ja jums bija parametru masīvā [], nevis int * masīvs,

774
01:04:04,540 --> 01:04:09,230
tas tas nozīmē, ka jūs varētu mainīt masīva, jo tagad tas ir rādītājs?

775
01:04:09,230 --> 01:04:14,250
[Bowden] Tāpat kā šī? >> [Students] Jā. Vai jūs varat nomainīt masīvs ietvaros funkciju tagad?

776
01:04:14,250 --> 01:04:18,420
[Bowden] Jūs varētu mainīt masīva abos gadījumos.

777
01:04:18,420 --> 01:04:23,130
Abos šajos gadījumos jums ir tiesības brīvi teikt masīvs [4] = 0.

778
01:04:23,130 --> 01:04:26,590
[Students] Bet jūs varat veikt masīvu punktu, lai kaut kas cits?

779
01:04:26,590 --> 01:04:30,230
[Bowden] Ak. Yeah. Jebkurā gadījumā - >> [students] Jā.

780
01:04:30,230 --> 01:04:38,410
[Bowden] starp masīvs [] un int * masīvs atšķirība, nav neviens.

781
01:04:38,410 --> 01:04:42,570
Jūs varat arī iegūt kādu daudzdimensiju masīvu šeit

782
01:04:42,570 --> 01:04:47,050
kādu ērtu sintaksi, bet tas joprojām tikai rādītājs.

783
01:04:47,050 --> 01:04:56,400
Tas nozīmē, ka es esmu brīvs darīt masīvs = malloc (sizeof (int)) un tagad norāda kaut kur citur.

784
01:04:56,400 --> 01:04:59,610
Bet tieši tāpat kā tas darbojas uz visiem laikiem, un vienmēr,

785
01:04:59,610 --> 01:05:03,210
mainot šo masīvu, padarot to norāda uz kaut ko citu

786
01:05:03,210 --> 01:05:07,570
nemaina šo masīvu noteikti šeit, jo tas ir kopija argumentu,

787
01:05:07,570 --> 01:05:10,780
tas nav rādītājs, lai šo argumentu.

788
01:05:10,780 --> 01:05:16,070
Un patiesībā, tāpat kā vairāk norādi, ka tas ir tieši tas pats -

789
01:05:16,070 --> 01:05:21,100
mēs jau redzējām to, ko drukāšanas masīvs izdrukas -

790
01:05:21,100 --> 01:05:31,410
Ko darīt, ja mēs drukāt masīva adresi vai adresi masīva adresi

791
01:05:31,410 --> 01:05:36,290
uz kādu no tiem?

792
01:05:41,770 --> 01:05:45,220
Pieņemsim ignorēt šo vienu.

793
01:05:48,140 --> 01:05:51,660
Labi. Tas ir labi. Tas tagad darbojas. / A.out.

794
01:05:51,660 --> 01:06:00,220
Drukāšanas masīvs, tad izdrukāt adresi masīva, ir tas pats.

795
01:06:00,220 --> 01:06:02,870
Masīvs vienkārši neeksistē.

796
01:06:02,870 --> 01:06:08,190
Tā zina, kad jūs drukāšanas masīvs, drukājat simbolu, attiecas uz tiem 20 baiti.

797
01:06:08,190 --> 01:06:11,940
Drukāšanas adresi masīvs, labi, masīvs neeksistē.

798
01:06:11,940 --> 01:06:17,200
Tas nav adreses, tāpēc tas tikai izdrukas adresi šiem 20 baiti.

799
01:06:20,820 --> 01:06:28,150
Tiklīdz jūs sastādīt leju, tāpat kā savu apkopojusi buggy4 / a.out.,

800
01:06:28,150 --> 01:06:30,340
masīvs ir neeksistējošā.

801
01:06:30,340 --> 01:06:33,640
Norādes eksistē. Masīvi nav.

802
01:06:34,300 --> 01:06:38,060
No atmiņas bloki pārstāv masīvs joprojām pastāv,

803
01:06:38,060 --> 01:06:43,270
bet mainīgo masīvs un mainīgie šāda veida nav.

804
01:06:46,260 --> 01:06:50,270
Tie ir, piemēram, galvenās atšķirības starp masīvu un norādes

805
01:06:50,270 --> 01:06:55,590
tiek tiklīdz jūs veicat funkcija zvanus, nav atšķirības.

806
01:06:55,590 --> 01:07:00,460
Bet iekšpusē funkciju, ka masīva pati deklarē, sizeof darbojas atšķirīgi

807
01:07:00,460 --> 01:07:05,190
jo jūs drukāšanas lielumu, nevis no lieluma veida blokiem,

808
01:07:05,190 --> 01:07:08,950
un jūs nevarat mainīt to, jo tas ir simbols.

809
01:07:08,950 --> 01:07:14,370
Drukāšanas lieta un adresi lieta drukā to pašu.

810
01:07:14,370 --> 01:07:18,480
Un tas ir diezgan daudz to.

811
01:07:18,480 --> 01:07:20,820
[Students] Vai jūs teiktu, ka vēl vienu reizi?

812
01:07:21,170 --> 01:07:24,170
Es varētu būt kaut ko palaiduši garām.

813
01:07:24,170 --> 01:07:29,260
Drukāšanas masīvs un adrese masīva izdrukas pats,

814
01:07:29,260 --> 01:07:33,180
tā kā, ja jūs drukāt rādītāju salīdzinot adresi rādītāja,

815
01:07:33,180 --> 01:07:36,010
viena lieta izdrukas adresi, ko jūs norādot uz,

816
01:07:36,010 --> 01:07:40,360
otrs izdrukas adresi rādītāja uz skursteņa.

817
01:07:40,360 --> 01:07:47,040
Jūs varat mainīt rādītāju, jūs nevarat mainīt masīva simbolu.

818
01:07:47,740 --> 01:07:53,270
Un sizeof rādītājs gatavojas drukāt lielumu šī rādītāja veida.

819
01:07:53,270 --> 01:07:57,470
Tātad int * p sizeof (p) gatavojas izdrukāt 4,

820
01:07:57,470 --> 01:08:04,110
bet int masīvs [5] Izdrukas sizeof (masīvs) gatavojas drukāt 20.

821
01:08:04,110 --> 01:08:07,480
[Students] Tātad int masīvs [5] būs drukāt 20? >> Jā.

822
01:08:07,480 --> 01:08:13,300
Tieši tāpēc iekšpusē buggy4 ja to izmanto, lai sizeof (masīvs)

823
01:08:13,300 --> 01:08:16,660
Tas darīja i <20, kas ir tas, ko mēs vēlējāmies.

824
01:08:16,660 --> 01:08:20,880
Mēs vēlamies i <5. >> [Students] Labi.

825
01:08:20,880 --> 01:08:25,569
[Bowden] Un tad, tiklīdz jūs sākat iet pildāmo funkciju,

826
01:08:25,569 --> 01:08:34,340
ja mēs int * p = masīvs;

827
01:08:34,340 --> 01:08:39,779
iekšpuses šo funkciju, mēs varam būtībā izmantot p un masīvs tādos pašos veidos,

828
01:08:39,779 --> 01:08:43,710
izņemot sizeof problēmu un mainīgo problēma.

829
01:08:43,710 --> 01:08:49,810
Bet p [0] = 1; ir tāds pats kā sakot masīvs [0] = 1;

830
01:08:49,810 --> 01:08:55,600
Un tiklīdz mēs sakām foo (masīvs), vai foo (p);

831
01:08:55,600 --> 01:08:59,760
iekšpusē foo funkcija, tas ir tas pats zvans divreiz.

832
01:08:59,760 --> 01:09:03,350
Nav atšķirības starp šiem diviem zvaniem atšķirība.

833
01:09:07,029 --> 01:09:11,080
>> Ikvienam labi uz to? Labi.

834
01:09:14,620 --> 01:09:17,950
Mums ir 10 minūtes.

835
01:09:17,950 --> 01:09:28,319
>> Mēs cenšamies, lai iegūtu, izmantojot šo Hacker Typer programmu,

836
01:09:28,319 --> 01:09:32,350
Šī tīmekļa vietne, kas iznāca pagājušajā gadā, vai kaut ko.

837
01:09:34,149 --> 01:09:41,100
Tas ir tikai vajadzēja būt, piemēram, rakstot nejauši un tā izdrukā -

838
01:09:41,100 --> 01:09:46,729
Neatkarīgi failu tas notiek, ir ievietots ir tas, ko tas izskatās, ka jūs rakstāt.

839
01:09:46,729 --> 01:09:52,069
Tas izskatās kā sava veida operētājsistēmas kodu.

840
01:09:53,760 --> 01:09:56,890
Tas, ko mēs vēlamies īstenot.

841
01:10:08,560 --> 01:10:11,690
Jums ir jābūt binārā izpildāmā nosaukts hacker_typer

842
01:10:11,690 --> 01:10:14,350
kas notiek ar vienu argumentu, failu "hakeru stila."

843
01:10:14,350 --> 01:10:16,480
Darbojas izpildāmā būtu skaidrs ekrānu

844
01:10:16,480 --> 01:10:20,850
un pēc tam izdrukāt vienu rakstzīmi no ieskaitīts-in failu katru reizi, lietotājs nospiež taustiņu.

845
01:10:20,850 --> 01:10:24,990
Tātad, neatkarīgi taustiņu nospiežot, tai vajadzētu mest prom un tā vietā drukāt raksturs no faila

846
01:10:24,990 --> 01:10:27,810
kas ir arguments.

847
01:10:29,880 --> 01:10:34,350
Es diezgan daudz pateikt, ko lietas mēs spēsim jāzina ir.

848
01:10:34,350 --> 01:10:36,440
Bet mēs gribam, lai pārbaudītu termios bibliotēku.

849
01:10:36,440 --> 01:10:44,840
Es nekad neesmu izmantojis šo bibliotēku visu manu dzīvi, tāpēc tas ir ļoti minimāla mērķiem.

850
01:10:44,840 --> 01:10:48,610
Bet tas būs bibliotēkā, mēs varam izmantot, lai mest prom raksturs jums hit

851
01:10:48,610 --> 01:10:52,390
kad jūs rakstāt par standarta collas

852
01:10:56,970 --> 01:11:05,840
Tātad hacker_typer.c, un mēs esam gatavojas vēlaties # ietvert <stdio.h>.

853
01:11:05,840 --> 01:11:12,870
Aplūkojot cilvēks lapā termios - I'm guessing tas ir gala OS vai kaut kas -

854
01:11:12,870 --> 01:11:16,240
Es nezinu, kā lai to izlasītu.

855
01:11:16,240 --> 01:11:21,040
Aplūkojot to, tas saka, lai iekļautu šos 2 failus, tāpēc mēs darīsim tā.

856
01:11:37,620 --> 01:11:46,820
>> Pirmā lieta, pirmkārt, mēs vēlamies veikt vienu argumentu, kas ir fails mums vajadzētu atvērt.

857
01:11:46,820 --> 01:11:52,420
Tātad, ko es gribu darīt? Kā es varu pārbaudīt, lai redzētu man ir viens arguments?

858
01:11:52,420 --> 01:11:56,480
[Students] Ja argc vienāds to. >> [Bowden] Jā.

859
01:11:56,480 --> 01:12:21,250
Tātad, ja (argc = 2!) Printf ("lietojums:% s [failu atvērt]").

860
01:12:21,250 --> 01:12:32,750
Tāpēc tagad, ja man palaist šo bez piedāvājot otru argumentu - ak, man vajag jaunu līniju -

861
01:12:32,750 --> 01:12:36,240
jūs redzēsiet tā saka lietojums: / hacker_typer.

862
01:12:36,240 --> 01:12:39,770
un tad otrais arguments būtu failu es vēlos atvērt.

863
01:12:58,430 --> 01:13:01,260
Tagad ko man darīt?

864
01:13:01,260 --> 01:13:08,490
Es gribu lasīt no šī faila. Kā es varu lasīt no faila?

865
01:13:08,490 --> 01:13:11,920
[Students] Atverot tā pirmo reizi. >> Jā.

866
01:13:11,920 --> 01:13:15,010
Tā fopen. Kāda fopen izskatās?

867
01:13:15,010 --> 01:13:22,980
[Students] attēlu. >> [Bowden] Filename būs argv [1].

868
01:13:22,980 --> 01:13:26,110
[Students] Un tad ko jūs vēlaties darīt ar to, tāpēc - >> [Bowden] Jā.

869
01:13:26,110 --> 01:13:28,740
Tātad, ja jums nav atcerēties, jūs varētu vienkārši darīt vīrieti fopen,

870
01:13:28,740 --> 01:13:32,960
ja tas būs const char * ceļš, kur ceļš ir filename,

871
01:13:32,960 --> 01:13:34,970
const char * režīmā.

872
01:13:34,970 --> 01:13:38,660
Ja jūs notikt ne atcerēties, ko režīms ir, tad jūs varat meklēt režīmā.

873
01:13:38,660 --> 01:13:44,660
Iekšpusē cilvēks lapas, slīpsvītra raksturs ir tas, ko jūs varat izmantot, lai meklētu lietas.

874
01:13:44,660 --> 01:13:49,790
Tāpēc es rakstīt / režīmu, lai meklētu režīmā.

875
01:13:49,790 --> 01:13:57,130
N un N ir tas, ko jūs varat izmantot, lai pārvietotos caur meklēšanas spēlēs.

876
01:13:57,130 --> 01:13:59,800
Te tā saka arguments režīma norāda uz virkni

877
01:13:59,800 --> 01:14:01,930
sākot ar vienu no šādiem sekvences.

878
01:14:01,930 --> 01:14:06,480
Tātad r, Atvērt teksta failu lasīšanai. Tas, ko mēs vēlamies darīt.

879
01:14:08,930 --> 01:14:13,210
Lasīšanai, un es vēlos, lai saglabātu to.

880
01:14:13,210 --> 01:14:18,720
Lieta būs fails *. Tagad to, ko es gribu darīt?

881
01:14:18,720 --> 01:14:21,200
Dodiet man otru.

882
01:14:28,140 --> 01:14:30,430
Labi. Tagad to, ko es gribu darīt?

883
01:14:30,430 --> 01:14:32,940
[Students] Pārbaudiet, vai tas ir NULL. >> [Bowden] Jā.

884
01:14:32,940 --> 01:14:38,690
Katru reizi, kad atverat failu, pārliecinieties, ka esat veiksmīgi var atvērt.

885
01:14:58,930 --> 01:15:10,460
>> Tagad es gribu darīt, ka termios sīkumi, kur es gribu, lai vispirms izlasīt manu pašreizējos iestatījumus

886
01:15:10,460 --> 01:15:14,050
un saglabāt tos uz kaut ko, tad es vēlos mainīt manus iestatījumus

887
01:15:14,050 --> 01:15:19,420
mest prom jebkuru raksturu, kas man tips,

888
01:15:19,420 --> 01:15:22,520
un tad es gribu, lai atjauninātu šos iestatījumus.

889
01:15:22,520 --> 01:15:27,250
Un tad beigās programmas, es vēlos mainīt atpakaļ uz manu sākotnējo uzstādījumu.

890
01:15:27,250 --> 01:15:32,080
Tāpēc struktūrai būs Tipa termios, un es esmu gatavojas vēlas divi no šiem.

891
01:15:32,080 --> 01:15:35,600
Pirmais būs mana current_settings,

892
01:15:35,600 --> 01:15:42,010
un tad viņi būs mana hacker_settings.

893
01:15:42,010 --> 01:15:48,070
Pirmkārt, es esmu gatavojas vēlaties, lai saglabātu manu pašreizējos iestatījumus,

894
01:15:48,070 --> 01:15:53,790
tad es esmu gatavojas vēlas atjaunināt hacker_settings,

895
01:15:53,790 --> 01:16:01,570
un tad kā beigās manā programmā, es gribu atgriezties pie pašreizējiem iestatījumiem.

896
01:16:01,570 --> 01:16:08,660
Tātad taupīšanas pašreizējos iestatījumus, kā tas darbojas, mums cilvēks termios.

897
01:16:08,660 --> 01:16:15,810
Mēs redzam, ka mums ir šis int tcsetattr, int tcgetattr.

898
01:16:15,810 --> 01:16:22,960
Es iet ar termios struct ar tās rādītājs.

899
01:16:22,960 --> 01:16:30,640
Kā tas izskatīsies, ir - I've jau aizmirsuši, ko funkcija sauca.

900
01:16:30,640 --> 01:16:34,930
Kopēt un ielīmēt.

901
01:16:39,150 --> 01:16:45,500
Tātad tcgetattr, tad es gribu iet uz struct ka es esmu ietaupot informāciju,

902
01:16:45,500 --> 01:16:49,650
kas būs current_settings,

903
01:16:49,650 --> 01:16:59,120
un pirmais arguments ir fails deskriptors lieta, ko es gribu, lai saglabātu atribūtus.

904
01:16:59,120 --> 01:17:04,360
Kāds fails deskriptors ir ir tāpat kā jebkurš reizi atverot failu, tā kļūst failu deskriptoru.

905
01:17:04,360 --> 01:17:14,560
Kad es fopen argv [1], tā kļūst failu deskriptoru, kas jums ir norādes

906
01:17:14,560 --> 01:17:16,730
ja jūs vēlaties lasīt vai rakstīt uz to.

907
01:17:16,730 --> 01:17:19,220
Tas nav failu deskriptors es vēlos izmantot šeit.

908
01:17:19,220 --> 01:17:21,940
Ir trīs failu deskriptori jums ir pēc noklusējuma,

909
01:17:21,940 --> 01:17:24,310
kas ir standarta, standarta ārā, un standarta kļūda.

910
01:17:24,310 --> 01:17:29,960
Pēc noklusējuma, es domāju, ka tas standarts ir 0, standarta out ir 1, un standarta kļūda ir 2.

911
01:17:29,960 --> 01:17:33,980
Tātad, ko vēlos mainīt uzstādījumus?

912
01:17:33,980 --> 01:17:37,370
Es vēlos mainīt iestatījumus, kad es hit raksturs,

913
01:17:37,370 --> 01:17:41,590
Es gribu, lai mest šo raksturu prom, nevis izdrukāt to uz ekrāna.

914
01:17:41,590 --> 01:17:45,960
Kas plūsma - standarta, standarta ārā, vai standarta kļūda -

915
01:17:45,960 --> 01:17:52,050
reaģē uz lietām, kad es tipa pie klaviatūras? >> [Students] Standarta iekšā >> Yeah.

916
01:17:52,050 --> 01:17:56,450
Lai es varētu vai nu darīt 0 vai es varu darīt stdin.

917
01:17:56,450 --> 01:17:59,380
Es saņemu current_settings par standarta collas

918
01:17:59,380 --> 01:18:01,720
>> Tagad es gribu, lai atjauninātu šos iestatījumus,

919
01:18:01,720 --> 01:18:07,200
tāpēc vispirms es ņemšu iekopēt hacker_settings ko mani current_settings ir.

920
01:18:07,200 --> 01:18:10,430
Un kā structs darbs tas būs tikai kopija.

921
01:18:10,430 --> 01:18:14,510
Tas kopijas visās jomās, kā jūs varētu gaidīt.

922
01:18:14,510 --> 01:18:17,410
>> Tagad es gribu, lai atjauninātu kādu no jomām.

923
01:18:17,410 --> 01:18:21,670
Aplūkojot termios, jums būtu izlasīt daudz šīs

924
01:18:21,670 --> 01:18:24,110
tikai, lai redzētu to, ko jūs vēlaties meklēt,

925
01:18:24,110 --> 01:18:28,210
bet karogi jūs gatavojas vēlaties meklēt ir atbalss,

926
01:18:28,210 --> 01:18:33,110
tāpēc ECHO Echo ievadi rakstzīmes.

927
01:18:33,110 --> 01:18:37,710
Vispirms es gribu noteikt - I've jau aizmirsuši, ko lauki ir.

928
01:18:45,040 --> 01:18:47,900
Tas ir tas, ko struktūrai izskatās.

929
01:18:47,900 --> 01:18:51,060
Tāpēc ievades režīmus es domāju, ka mēs gribam mainīt.

930
01:18:51,060 --> 01:18:54,210
Mēs apskatīt risinājums, lai pārliecinātos, ka tas, ko mēs gribam mainīt.

931
01:19:04,060 --> 01:19:12,610
Mēs vēlamies mainīt lflag lai novērstu nepieciešams izskatīt visus šos.

932
01:19:12,610 --> 01:19:14,670
Mēs vēlamies mainīt vietējo režīmus.

933
01:19:14,670 --> 01:19:17,710
Jums būtu izlasīt visu šo lietu, lai saprastu, kur viss pieder

934
01:19:17,710 --> 01:19:19,320
ka mēs gribam mainīt.

935
01:19:19,320 --> 01:19:24,120
Bet tas ir iekšā vietējo veidos, kur mēs ejam, vēlas to mainīt.

936
01:19:27,080 --> 01:19:33,110
Tātad hacker_settings.cc_lmode ir tas, ko tā sauc.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
Tas ir, ja mēs nokļūt Bitu līmeņa operatoriem.

939
01:19:52,280 --> 01:19:54,860
Mēs esam veida no laika, bet mēs iesim cauri to reālu ātri.

940
01:19:54,860 --> 01:19:56,600
Tas ir, ja mēs nokļūt Bitu līmeņa operatoriem,

941
01:19:56,600 --> 01:19:59,950
kur es domāju, ka es teicu vienu reizi sen, ka ikreiz, kad jūs sākat, kas nodarbojas ar karogiem,

942
01:19:59,950 --> 01:20:03,370
Jūs esat būs izmantojot Bitu līmeņa operatoram daudz.

943
01:20:03,370 --> 01:20:08,240
Katrs karoga mazliet atbilst sava veida uzvedību.

944
01:20:08,240 --> 01:20:14,090
Tātad šeit, šis karogs ir ķekars dažādas lietas, kur visi no tiem nozīmēt kaut ko citu.

945
01:20:14,090 --> 01:20:18,690
Bet ko es gribu darīt, ir tikai izslēgt mazliet, kas atbilst ECHO.

946
01:20:18,690 --> 01:20:25,440
Tātad, lai ieslēgtu, ka off man & = ¬ ECHO.

947
01:20:25,440 --> 01:20:30,110
Patiesībā, es domāju, ka tas ir tāpat kā techo vai kaut ko. Es esmu tikai gatavojas pārbaudīt vēlreiz.

948
01:20:30,110 --> 01:20:34,050
Es varu termios to. Tas ir tikai ECHO.

949
01:20:34,050 --> 01:20:38,440
ECHO būs viena mazliet.

950
01:20:38,440 --> 01:20:44,230
¬ ECHO gatavojas nozīmē visi biti ir iestatīts uz 1, kas nozīmē, visi karogi ir noteikti patiess

951
01:20:44,230 --> 01:20:47,140
izņemot ECHO bit.

952
01:20:47,140 --> 01:20:53,830
Līdz beidzot manu vietējo karogus ar to, tas nozīmē visiem karogiem, kas šobrīd noteikti ir taisnība

953
01:20:53,830 --> 01:20:56,520
joprojām tiks iestatīts kā patiess.

954
01:20:56,520 --> 01:21:03,240
Ja mana ECHO karodziņš ir iestatīts uz patiess, tad tas ir obligāti iestatīts uz False uz ECHO karoga.

955
01:21:03,240 --> 01:21:07,170
Tāpēc šo kodu līniju vienkārši izslēdz ECHO karogu.

956
01:21:07,170 --> 01:21:16,270
Pārējās rindas kods, es ņemšu tikai kopēt tos interesēs laikā un pēc tam tos izskaidrot.

957
01:21:27,810 --> 01:21:30,180
Šķīdumā, viņš teica 0.

958
01:21:30,180 --> 01:21:33,880
Tas ir iespējams, labāk skaidri pateikt stdin.

959
01:21:33,880 --> 01:21:42,100
>> Ievērojiet, ka es esmu arī dara ECHO | ICANON šeit.

960
01:21:42,100 --> 01:21:46,650
ICANON atsaucas uz kaut ko atsevišķu, kas nozīmē kanonisko režīmā.

961
01:21:46,650 --> 01:21:50,280
Kas kanonisko režīms nozīmē ir parasti, kad jūs rakstāt no komandrindas,

962
01:21:50,280 --> 01:21:54,670
standarts nav procesa nekas, kamēr jūs hit newline.

963
01:21:54,670 --> 01:21:58,230
Tātad, ja jūs GetString, rakstot ķekars lietas, tad jums hit newline.

964
01:21:58,230 --> 01:22:00,590
Tas ir, kad tas ir nosūtīts uz standarta collas

965
01:22:00,590 --> 01:22:02,680
Tas ir noklusējuma.

966
01:22:02,680 --> 01:22:05,830
Kad es izslēgt kanonisko režīmu, tagad katru rakstzīmi, nospiežot

967
01:22:05,830 --> 01:22:10,910
ir tas, ko izpaužas apstrādāti, kas parasti ir sava veida slikti, jo tas ir lēns, lai apstrādātu šīs lietas,

968
01:22:10,910 --> 01:22:14,330
kas ir iemesls, kāpēc tas ir labi, lai buferis to visu līniju.

969
01:22:14,330 --> 01:22:16,810
Bet es gribu katru rakstzīmi jāapstrādā

970
01:22:16,810 --> 01:22:18,810
jo es negribu to gaidīt man, lai sasniegtu newline

971
01:22:18,810 --> 01:22:21,280
pirms tā apstrādā visus burtus es esmu rakstīt.

972
01:22:21,280 --> 01:22:24,760
Tas izslēdz kanonisko režīmā.

973
01:22:24,760 --> 01:22:31,320
Šī stuff tikai nozīmē, kad tas faktiski apstrādā rakstzīmes.

974
01:22:31,320 --> 01:22:35,830
Tas nozīmē, apstrādāt tos nekavējoties; tiklīdz es esmu ierakstot tos, tos apstrādāt.

975
01:22:35,830 --> 01:22:42,510
Un tas ir funkcija, kas atjaunina savus iestatījumus standarta,

976
01:22:42,510 --> 01:22:45,480
un TCSA līdzekļiem darīt to tieši tagad.

977
01:22:45,480 --> 01:22:50,310
Citas opcijas ir gaidīt, kamēr viss, kas pašlaik ir plūsma tiek apstrādāti.

978
01:22:50,310 --> 01:22:52,030
Tas nav īsti jautājums.

979
01:22:52,030 --> 01:22:56,920
Tikai tagad mainīt iestatījumus, lai būtu kāds ir pašlaik hacker_typer_settings.

980
01:22:56,920 --> 01:23:02,210
Es domāju, es to nosauca hacker_settings, tāpēc pieņemsim to mainīt.

981
01:23:09,610 --> 01:23:13,500
Mainīt visu, lai hacker_settings.

982
01:23:13,500 --> 01:23:16,870
>> Tagad beigās mūsu programmu, mēs esam gatavojas vēlaties atgriezties

983
01:23:16,870 --> 01:23:20,210
to, kas ir pašlaik iekšā normal_settings,

984
01:23:20,210 --> 01:23:26,560
kas gatavojas tikai izskatās & normal_settings.

985
01:23:26,560 --> 01:23:30,650
Paziņojums Es neesmu mainījies kāds no maniem normal_settings jo sākotnēji kļūst to.

986
01:23:30,650 --> 01:23:34,520
Tad vienkārši mainīt tos atpakaļ, es nodot tos atpakaļ beigās.

987
01:23:34,520 --> 01:23:38,390
Tas bija atjauninājums. Labi.

988
01:23:38,390 --> 01:23:43,900
>> Tagad iekšā šeit es ņemšu tikai izskaidrot kodu interesēs laiku.

989
01:23:43,900 --> 01:23:46,350
Tas nav tik daudz kodu.

990
01:23:50,770 --> 01:24:03,750
Mēs redzam lasām rakstzīmi no faila. Mēs sauc tā f.

991
01:24:03,750 --> 01:24:07,850
Tagad jūs varat Vīrietis fgetc, bet kā fgetc iet uz darbu

992
01:24:07,850 --> 01:24:11,910
ir tikai tas notiek, lai atgrieztos uz rakstzīmes, tikai lasīt vai EOF,

993
01:24:11,910 --> 01:24:15,680
kas atbilst beigām failu vai kādu kļūdas notiek.

994
01:24:15,680 --> 01:24:19,900
Mēs looping, turpina lasīt vienu rakstzīmi no lietas materiāliem,

995
01:24:19,900 --> 01:24:22,420
kamēr mēs esam palaist no rakstzīmes, lai lasītu.

996
01:24:22,420 --> 01:24:26,650
Un, kamēr mēs darām, ka mums jāgaida uz vienu rakstzīmi no standarta collas

997
01:24:26,650 --> 01:24:29,090
Katru reizi, rakstot kaut ko pie komandrindas,

998
01:24:29,090 --> 01:24:32,820
kas ir lasījumā raksturs no standarta iekšā

999
01:24:32,820 --> 01:24:38,330
Tad putchar ir tikai gatavojas nodot CHAR mēs lasīt šeit no failu standarta out.

1000
01:24:38,330 --> 01:24:42,890
Jūs varat cilvēks putchar, bet tas ir tikai liekot uz standartu ārā, tas drukāšanas ka raksturu.

1001
01:24:42,890 --> 01:24:51,600
Jūs varētu arī vienkārši darīt printf ("% c", c); pati ideja.

1002
01:24:53,330 --> 01:24:56,670
Kas gatavojas darīt lielāko daļu no mūsu darba.

1003
01:24:56,670 --> 01:25:00,300
>> Pēdējā lieta, mēs esam gatavojas vēlaties darīt, ir tikai fclose mūsu failu.

1004
01:25:00,300 --> 01:25:03,310
Ja jums nav fclose, ka ir atmiņas noplūde.

1005
01:25:03,310 --> 01:25:06,680
Mēs vēlamies, lai fclose failu mēs sākotnēji atklāja, un es domāju, ka tas arī viss.

1006
01:25:06,680 --> 01:25:13,810
Ja mēs, kas, es jau saņēmu problēmas.

1007
01:25:13,810 --> 01:25:17,260
Pieņemsim redzēt.

1008
01:25:17,260 --> 01:25:19,960
Ko tas sūdzēties?

1009
01:25:19,960 --> 01:25:30,220
Paredzams "int", bet arguments ir veids "struct _IO_FILE *".

1010
01:25:36,850 --> 01:25:39,370
Redzēsim, vai tas darbojas.

1011
01:25:45,210 --> 01:25:53,540
Atļauta tikai C99. Augh. Labi, padarīt hacker_typer.

1012
01:25:53,540 --> 01:25:57,760
Tagad mēs iegūtu vairāk noderīgas aprakstus.

1013
01:25:57,760 --> 01:25:59,900
Līdz ar to izmantot par nedeklarētu identifikators "normal_settings".

1014
01:25:59,900 --> 01:26:04,170
Man nav to sauc normal_settings. Es to sauca current_settings.

1015
01:26:04,170 --> 01:26:12,090
Tāpēc pieņemsim mainīt visu to.

1016
01:26:17,920 --> 01:26:21,710
Tagad viņa arguments.

1017
01:26:26,290 --> 01:26:29,500
Es ņemšu padara šo 0! Tagad.

1018
01:26:29,500 --> 01:26:36,720
Labi. . / Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
Es arī nav skaidrs ekrānu sākumā.

1020
01:26:39,590 --> 01:26:42,960
Bet jūs varat atskatīties uz pēdējo problēmu kopumu, lai redzētu, kā jūs notīrītu ekrānu.

1021
01:26:42,960 --> 01:26:45,160
Tas ir vienkārši izdrukāt dažas rakstzīmes

1022
01:26:45,160 --> 01:26:47,210
kamēr tas dara to, ko es gribu darīt.

1023
01:26:47,210 --> 01:26:48,900
Labi.

1024
01:26:48,900 --> 01:26:55,280
Un domājot par to, kāpēc tas nepieciešams, lai ir 0 nevis stdin,

1025
01:26:55,280 --> 01:27:00,560
kas būtu # define 0,

1026
01:27:00,560 --> 01:27:03,890
tas sūdzas, ka -

1027
01:27:13,150 --> 01:27:19,360
Pirms kad es teicu, ka tur ir failu deskriptori, bet tad jums ir arī jūsu failu *,

1028
01:27:19,360 --> 01:27:23,210
fails deskriptors ir tikai viens skaitlis,

1029
01:27:23,210 --> 01:27:26,970
tā FILE * ir viss stuff ķekars saistīti ar to.

1030
01:27:26,970 --> 01:27:30,380
Iemesls mums teikt 0 vietā stdin

1031
01:27:30,380 --> 01:27:37,480
ir tas, ka stdin ir Failu *, kas norāda uz to lieta, kas ir atsauces faila deskriptoru 0.

1032
01:27:37,480 --> 01:27:45,070
Tātad pat šeit, kad es to fopen (argv [1], es saņemu failu * atpakaļ.

1033
01:27:45,070 --> 01:27:51,180
Bet kaut kur, ka failu * ir lieta, kas atbilst faila deskriptoru par šo failu.

1034
01:27:51,180 --> 01:27:57,430
Ja paskatās cilvēks lapā atvērt, tāpēc es domāju, ka jums ir jādara man 3 atvērtā - Nē -

1035
01:27:57,430 --> 01:27:59,380
Man 2 atvērts - jā.

1036
01:27:59,380 --> 01:28:06,250
Ja paskatās lapā atvērts, atklāts ir kā zemāka līmeņa fopen,

1037
01:28:06,250 --> 01:28:09,350
un tas atgriežas faktisko failu deskriptoru.

1038
01:28:09,350 --> 01:28:12,050
fopen dara ķekars sīkumi uz augšu vaļā,

1039
01:28:12,050 --> 01:28:17,640
kas tā vietā atgriežoties tikai, ka fails deskriptors atgriež veselu failu * rādītāju

1040
01:28:17,640 --> 01:28:20,590
iekšā kas ir mūsu mazā failu deskriptors.

1041
01:28:20,590 --> 01:28:25,020
Tāpēc standarts attiecas uz failu * lieta,

1042
01:28:25,020 --> 01:28:29,120
tā 0 attiecas uz tikai ar failu deskriptors standartu sevi.

1043
01:28:29,120 --> 01:28:32,160
>> Jautājumi?

1044
01:28:32,160 --> 01:28:35,930
[Smejas] Blew caur to.

1045
01:28:35,930 --> 01:28:39,140
Labi. Mēs esam darīts. [Smejas]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]