1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [SECTION 5：あまり快適]

2
00:00:02,730 --> 00:00:05,180
[ネイトHardison、ハーバード大学]

3
00:00:05,180 --> 00:00:08,260
[これはCS50です。] [CS50.TV]

4
00:00:08,260 --> 00:00:11,690
だから、戻ってみんなを歓迎します。

5
00:00:11,690 --> 00:00:16,320
第5節へようこそ。

6
00:00:16,320 --> 00:00:20,220
この時点で、クイズに0を完了したとあなたがやった方法を見てきた

7
00:00:20,220 --> 00:00:25,770
私は非常にこのセクションのスコアに感銘を受けましたので、うまくいけば、あなたは本当に良い感じ。

8
00:00:25,770 --> 00:00:28,050
弊社のオンライン視聴者のために、私たちは質問のカップルを見てきた

9
00:00:28,050 --> 00:00:33,680
問題セットの最後の2つの問題について - やクイズで、むしろ。

10
00:00:33,680 --> 00:00:39,690
だから我々は、誰もが何が起こったかを見ているように、本当にすぐにそれらの上で行くつもり

11
00:00:39,690 --> 00:00:45,060
というだけで解決策そのものを見るよりも実際のソリューションを通過する方法。

12
00:00:45,060 --> 00:00:50,330
我々は、本当に迅速に問題の最後のカップル上に行くために32と33を行っている。

13
00:00:50,330 --> 00:00:53,240
ただ、再びので、オンライン視聴者がこれを見ることができる。

14
00:00:53,240 --> 00:00:59,080
>> あなたは、13ページにありますあなたの問題32に回すと、

15
00:00:59,080 --> 00:01:02,730
16のうち13は、問題32は、すべてのスワップについてです。

16
00:01:02,730 --> 00:01:05,010
それは、2つの整数をスワッピングについてのすべてだった。

17
00:01:05,010 --> 00:01:08,740
それは我々が講義中に数回にわたって行っただろうとの問題です。

18
00:01:08,740 --> 00:01:13,590
そして、ここで、我々はあなたが何を求めていたと、クイックメモリートレースです。

19
00:01:13,590 --> 00:01:17,000
彼らがスタック上にあるので、変数の値を入力するには

20
00:01:17,000 --> 00:01:20,250
コー​​ドは、このスワップ機能を通過するとき。

21
00:01:20,250 --> 00:01:24,500
特に、我々が探しているもの - このiPadを鎮圧しようとして - 私 -​​ 

22
00:01:24,500 --> 00:01:29,650
特に、私たちが見ていると、この行は右ここでは6の番号が付けられています。

23
00:01:29,650 --> 00:01:36,740
そして、それは前の問題とだけ隣接の6の番号が付けられている。

24
00:01:36,740 --> 00:01:41,720
私たちがやりたいことは、メモリの状態を表示したり、ラベルである

25
00:01:41,720 --> 00:01:46,090
それは我々がこの行番号6を実行したときの時間である、として

26
00:01:46,090 --> 00:01:52,540
これは、効果的に右ここに私たちのswap関数からの戻りです。

27
00:01:52,540 --> 00:01:59,450
我々がここで下にスクロールした場合、我々は、メモリ内のすべてのアドレスが私たちのために提供されていたことを見た。

28
00:01:59,450 --> 00:02:02,540
これは非常に重要であり、我々はちょうどその瞬間にそれに戻ってくるでしょう。

29
00:02:02,540 --> 00:02:09,240
そして、ダウンここ下部に、我々はを参照しようとしている小さなメモリ図を持っていた。

30
00:02:09,240 --> 00:02:12,490
私は実際に私の計算された上でこれを行っている。

31
00:02:12,490 --> 00:02:20,720
だから、僕は参考のためにiPadと、このコードの間を行ったり来たり交互にするつもりです。

32
00:02:20,720 --> 00:02:26,540
>> 始めましょう。最初は、ここでの主な権利の最初の数行に注目しましょう​​。

33
00:02:26,540 --> 00:02:30,220
開始するために、我々は2から1とyにxを初期化しようとしている。

34
00:02:30,220 --> 00:02:33,040
だから我々は2つ​​の整数変数は、彼らは両方のスタック上に配置することになるだろうしている。

35
00:02:33,040 --> 00:02:36,050
我々は彼らに1と2を入れてするつもりです。

36
00:02:36,050 --> 00:02:43,150
私はiPadに裏返しので、もしうまくいけば、見てみましょう - 

37
00:02:43,150 --> 00:02:48,660
Apple TVのミラーリング、およびそこに私達は行く。オーケー。

38
00:02:48,660 --> 00:02:51,670
私はiPadに裏返しそうだとすれば、

39
00:02:51,670 --> 00:02:56,220
私は2から1とyにxを初期化したい。

40
00:02:56,220 --> 00:03:00,580
我々はXと書かれたボックスに1を書き込むことによって、非常に単純にそれを行う

41
00:03:00,580 --> 00:03:07,730
とyと書かれたボックスに2。かなりシンプル。

42
00:03:07,730 --> 00:03:11,620
だから今度はラップトップに戻りましょう、次に何が起こるかを参照してください。

43
00:03:11,620 --> 00:03:15,810
物事はトリッキー取得する場所だからこの次の行があります。

44
00:03:15,810 --> 00:03:28,110
我々は、パラメータとしてxのアドレスとyのアドレスを渡すスワップ機能にaとb。

45
00:03:28,110 --> 00:03:32,380
xとyのアドレスのアドレスは、我々は計算することができないものです

46
00:03:32,380 --> 00:03:36,360
ここに至るまでこれらの箇条書きを参照することなく。

47
00:03:36,360 --> 00:03:39,750
幸いなことに、最初の2つの箇条書きは、答えが正確に何を教えて下さい。

48
00:03:39,750 --> 00:03:44,740
メモリ内のxのアドレスは10で、メモリ内のyのアドレスは14です。

49
00:03:44,740 --> 00:03:51,870
だから、それらは私たちのswap関数で、aとbがトップとして渡される値です。

50
00:03:51,870 --> 00:04:00,760
だからもう一度、私たちのダイアグラムに切り替え、私は10を書き込むことができます

51
00:04:00,760 --> 00:04:07,400
aとbの14。

52
00:04:07,400 --> 00:04:11,610
我々はスワップを進める今どこに、この点である。

53
00:04:11,610 --> 00:04:14,520
だから、もう一度ラップトップに戻ってひっくり返す

54
00:04:14,520 --> 00:04:21,079
我々は、スワップが動作する方法は、私まずデリファレンスであることを見て、tmpに結果を格納します。

55
00:04:21,079 --> 00:04:27,650
だから、間接参照演算子がねえ "と言う。アドレスとして、変数の内容を扱います。

56
00:04:27,650 --> 00:04:33,830
そのアドレスに格納されているものは何でもに移動し、それをロードします。 "

57
00:04:33,830 --> 00:04:41,720
あなたは何を変数のうちロードは、弊社のTMP変数に格納しようとしている。

58
00:04:41,720 --> 00:04:45,150
iPadにバックフリップ。

59
00:04:45,150 --> 00:04:51,690
我々は10に対処するために行けば、我々はアドレス10がvarible xであることを知っている

60
00:04:51,690 --> 00:04:55,480
我々は、メモリ内のxのアドレスが10であるという我々の箇条書きと言われたので。

61
00:04:55,480 --> 00:05:00,180
だから我々は、我々はiPad上で見るように、そこに行く1であることの価値を得ることができます

62
00:05:00,180 --> 00:05:06,300
そのtmpにロード。

63
00:05:06,300 --> 00:05:08,250
繰り返しますが、これは最終的な内容ではありません。

64
00:05:08,250 --> 00:05:14,350
我々は、ウォークスルーするつもりだと我々は最後に示すプログラムの我々の最終的な状態に到達するでしょう。

65
00:05:14,350 --> 00:05:17,210
しかし、今、私たちは、tmpに格納された値1を持つ。

66
00:05:17,210 --> 00:05:19,210
>> とこっちに簡単な質問があります。

67
00:05:19,210 --> 00:05:23,980
[アレキサンダー]間接参照演算子です - ちょうど変数の前に星の右ですか？

68
00:05:23,980 --> 00:05:27,600
>>はい。 、我々は再び私たちのラップトップに戻ってめくるように、間接参照演算子は、そう

69
00:05:27,600 --> 00:05:33,780
この星は右の前にあります。

70
00:05:33,780 --> 00:05:37,460
その意味で、です - あなたは、乗算演算子とそれを対比

71
00:05:37,460 --> 00:05:42,400
これは、二つのことが必要です。間接参照演算子は、単項演算子です。

72
00:05:42,400 --> 00:05:46,130
二項演算子とは対照的に、ただ、一つの値に適用される

73
00:05:46,130 --> 00:05:48,810
どこに2つの異なる値に適用されます。

74
00:05:48,810 --> 00:05:52,080
だからそれは、この行で何が起こるかです。

75
00:05:52,080 --> 00:05:58,390
我々は1の値をロードし、私たちの一時的な整数変数にそれを格納します。

76
00:05:58,390 --> 00:06:05,800
次の行は、我々にbの内容を保存する - 

77
00:06:05,800 --> 00:06:12,630
または、むしろ、我々は、bが指している場所にを指している内容を保存します。

78
00:06:12,630 --> 00:06:17,690
我々は、右から左に、これを分析する場合、我々は、間接参照Bにしようとしている

79
00:06:17,690 --> 00:06:23,580
我々は14に対処しようとしている、我々はそこにある整数をつかもうとしており、

80
00:06:23,580 --> 00:06:26,900
それから私達は、アドレス10に行くつもりです

81
00:06:26,900 --> 00:06:34,240
そして我々はその空間にbの私達の参照解除の結果をスローしようとしている。

82
00:06:34,240 --> 00:06:40,080
我々は、これはもう少し具体的にすることができます私たちの計算に戻り、反転、

83
00:06:40,080 --> 00:06:44,070
私はここにいるすべてのアドレスの数字を書けばそれが役立つかもしれない。

84
00:06:44,070 --> 00:06:53,820
だから我々はyで、我々はアドレス14であることを知って、xはアドレス10にある。

85
00:06:53,820 --> 00:07:00,180
我々はbで起動したときに、私たちは間接参照bは、我々は値2をつかむつもりだ。

86
00:07:00,180 --> 00:07:08,320
我々は、それがアドレス14に住んでいる値ですので、この値を取得しようとしている。

87
00:07:08,320 --> 00:07:15,700
そして、我々はアドレス10に住んで変数に入れていくつもりですが、

88
00:07:15,700 --> 00:07:19,160
これは、すぐそこに私たちの変数xに対応している。

89
00:07:19,160 --> 00:07:21,810
だから我々はここで上書きするの少しを行うことができます

90
00:07:21,810 --> 00:07:35,380
我々は1を取り除くと、その代わりに我々は2を書き込む場所。

91
00:07:35,380 --> 00:07:39,560
だから、すべては私たちが現在上書きxをしたにも関わらず、よく、世界で良いことだ。

92
00:07:39,560 --> 00:07:44,890
私たちは、TMP変数のxの古い値を格納していた。

93
00:07:44,890 --> 00:07:50,210
だから我々は次の行を使用してスワップを完了することができます。

94
00:07:50,210 --> 00:07:53,030
私たちのラップトップに戻ってめくる。

95
00:07:53,030 --> 00:07:58,150
これで、すべてそのままでは私たちの一時的な整数変数の内容を取り出すことである

96
00:07:58,150 --> 00:08:05,630
aとbが保持しているアドレスに住んで変数に格納します。

97
00:08:05,630 --> 00:08:10,230
だから我々は変数へのアクセスを得るために効果的に間接参照Bに行くんだ

98
00:08:10,230 --> 00:08:14,340
つまり、Bはそれに保持しているアドレスである、

99
00:08:14,340 --> 00:08:19,190
そして我々はtmpがそれに保持している値を詰め込むつもりだ。

100
00:08:19,190 --> 00:08:23,280
もう一度iPadにバックフリップ。

101
00:08:23,280 --> 00:08:31,290
私は、ここに2をこの値を消去することができます

102
00:08:31,290 --> 00:08:41,010
その代わりに、我々はそれに1右をコピーします。

103
00:08:41,010 --> 00:08:43,059
もちろん実行し、次の行、 - 

104
00:08:43,059 --> 00:08:47,150
我々はノートパソコンにバックフリップ - もし、この時点で6です

105
00:08:47,150 --> 00:08:52,500
それは私達が私達の図が完全に記入したかった点である。

106
00:08:52,500 --> 00:08:58,940
だから、完成した図を見ることができるだけので、もう一度iPadに戻って反転、

107
00:08:58,940 --> 00:09:06,610
あなたは私たちがxの中では10、b 14、tmpに1、2、およびyの1となっていることがわかります。

108
00:09:06,610 --> 00:09:11,000
このことについて何か質問はありますか？

109
00:09:11,000 --> 00:09:14,640
これはそれを通って歩いた、より理にかなっていますか？

110
00:09:14,640 --> 00:09:24,850
あまり意味を作る？うまくいけません。オーケー。

111
00:09:24,850 --> 00:09:28,230
>> ポインタは非常にトリッキーなことがあります。

112
00:09:28,230 --> 00:09:33,420
我々は仕事の一人は非常に一般的なことわざがあります：

113
00:09:33,420 --> 00:09:36,590
"ポインタを理解するには、まずポインタを理解する必要があります。"

114
00:09:36,590 --> 00:09:40,530
これは私は非常に本当だと思います。それは、それに慣れるのにしばらく時間がかかりますか。

115
00:09:40,530 --> 00:09:45,360
たくさんの写真を描いて、このようなメモリ·ダイアグラムの抽選は、非常に有用である

116
00:09:45,360 --> 00:09:49,480
、あなたは例の後、例の後で例を歩く後、

117
00:09:49,480 --> 00:09:54,450
それはもう少しセンスともう少しセンスともう少し意味があるように始めましょう。

118
00:09:54,450 --> 00:10:01,560
最後に、ある日、あなたはそれがすべて完全にマスターしているでしょう。

119
00:10:01,560 --> 00:10:13,800
我々は次の問題に移る前に何か質問はありますか？かしこまりました。

120
00:10:13,800 --> 00:10:18,840
だからノートパソコンにバックフリップ。

121
00:10:18,840 --> 00:10:23,300
我々が持っている次の問題は、ファイルI / Oで、問題番号33です

122
00:10:23,300 --> 00:10:26,350
この少しにズームイン。

123
00:10:26,350 --> 00:10:28,710
問題33  - はい？

124
00:10:28,710 --> 00:10:32,110
>> [ダニエル]私はちょうど簡単な質問がありました。この星、またはアスタリスク、

125
00:10:32,110 --> 00:10:35,590
それはあなたが前にアスタリスクを使用するときにデリファレンスと呼ばれています。

126
00:10:35,590 --> 00:10:38,820
あなたが前にアンパサンドを使用する場合、それは何と呼ばれるのですか？

127
00:10:38,820 --> 00:10:43,140
>>アンパサンド前にアドレス演算子です。

128
00:10:43,140 --> 00:10:45,880
それでは、戻って上にスクロールすることができます。

129
00:10:45,880 --> 00:10:49,310
おっと。私は実際にスクロールすることはできませんので、私はズームモードにいるよ。

130
00:10:49,310 --> 00:10:52,780
私たちは右ここでは本当にすぐにこのコードを見れば、

131
00:10:52,780 --> 00:10:54,980
もう一度、同じことが起こって。

132
00:10:54,980 --> 00:10:59,180
我々は、この行に、右ここにこのコードを見れば、我々は、呼び出しがスワップを行う場合には、

133
00:10:59,180 --> 00:11:10,460
アンパサンドは、単に "変数xに住んでアドレスを取得します"と言っている

134
00:11:10,460 --> 00:11:14,460
あなたのコンパイラは、コードをコンパイルするとき、

135
00:11:14,460 --> 00:11:20,590
それは実際に物理的に生きるためにあなたのすべての変数のためのメモリ内の場所をマークする必要があります。

136
00:11:20,590 --> 00:11:24,910
そしてそれはすべてのものをコンパイルしてたら、コンパイラは次に何ができるか、

137
00:11:24,910 --> 00:11:31,110
それは "ああ、私はアドレス10にxを入れた。私はアドレス14でyを入れます。"、知っている

138
00:11:31,110 --> 00:11:34,640
そして、それはあなたのために、これらの値を入力できます。

139
00:11:34,640 --> 00:11:44,740
だから、その後することができます - それは、次に同様で、パス＆yにこれを渡すことができます。

140
00:11:44,740 --> 00:11:50,730
これらの人は、あなたがスワップ機能にそれらを渡すときも、アドレスを取得しますが、それら

141
00:11:50,730 --> 00:11:55,690
右ここでは、このタイプの情報、このint *、コンパイラに指示し、

142
00:11:55,690 --> 00:12:01,350
"さて、私たちは、整数型の変数のアドレスとしてこのアドレスを解釈することになるだろう。"

143
00:12:01,350 --> 00:12:05,900
文字変数のアドレスと異なっているint型のアドレスとして

144
00:12:05,900 --> 00:12:09,930
intは32ビットマシン上で、占有するため、スペースの4バイトを占有します

145
00:12:09,930 --> 00:12:13,310
文字がスペースだけの1バイトを占め、一方。

146
00:12:13,310 --> 00:12:17,310
だからそれは何であるかも知ることが重要だ - 住んでいるのか、値のタイプを

147
00:12:17,310 --> 00:12:20,340
渡されてしまったアドレスに住んでいる

148
00:12:20,340 --> 00:12:22,020
あなたが扱っていること、またはアドレス。

149
00:12:22,020 --> 00:12:29,020
そのように、あなたが実際にあなたのRAMからロードする方法を多くの情報のバイトを知っています。

150
00:12:29,020 --> 00:12:31,780
そして、はい、あなたのようなこの間接参照演算子は、求めていた

151
00:12:31,780 --> 00:12:37,200
なり、特定のアドレスに情報にアクセスします。

152
00:12:37,200 --> 00:12:42,820
だから、ここでは、この変数を使用して、言う、アドレスとしての内容を扱う、

153
00:12:42,820 --> 00:12:47,880
そのアドレスに移動し、引き出し、プロセッサにロード、レジスタへのロード

154
00:12:47,880 --> 00:12:56,340
実際の値またはそのアドレスで暮らす内容。

155
00:12:56,340 --> 00:12:59,620
これ以上の質問は？これらは良い質問です。

156
00:12:59,620 --> 00:13:01,650
それはあまりにも新しい用語がたくさんあり​​ます。

157
00:13:01,650 --> 00:13:09,800
それは別の場所で見て＆と*もファンキーのようなものだ。

158
00:13:09,800 --> 00:13:13,180
>> かしこまりました。

159
00:13:13,180 --> 00:13:18,530
だから戻って問題を33にするには、ファイルI / O

160
00:13:18,530 --> 00:13:22,540
これは、私は物事のカップルが起こったと思うそれらの問題のうちの1つだった。

161
00:13:22,540 --> 00:13:25,400
一つは、それはかなり新しいトピックです。

162
00:13:25,400 --> 00:13:30,590
これは、クイズの前に、もうすぐ発表されました

163
00:13:30,590 --> 00:13:33,400
そして私はそれが数学でそれらの単語のいずれかの問題のような種類のだったと思う

164
00:13:33,400 --> 00:13:39,720
どこに、彼らはあなたに多くの情報を与えるが、実際にそれのトンを使用しなければならなくなることはありません。

165
00:13:39,720 --> 00:13:44,060
この問題の最初の部分では、CSVファイルが何であるかを記述しています。

166
00:13:44,060 --> 00:13:50,620
さて、CSVファイルには、説明によると、カンマ区切り値ファイルです。

167
00:13:50,620 --> 00:13:55,300
これらはすべて面白いが、あなたは今までにそれらを使用する理由である理由、

168
00:13:55,300 --> 00:14:00,800
、なぜなら、どのようにあなたがたの多くは、これまでExcelのようなものを使用しているのですか？

169
00:14:00,800 --> 00:14:03,240
、おそらく、またはあなたの人生の中でいくつかの点で使用されているあなたのほとんどを示しています。

170
00:14:03,240 --> 00:14:06,430
あなたは、Excelのようなものを使用します。

171
00:14:06,430 --> 00:14:10,940
Excelスプレッドシートからデータを取得したり、それを処理の任意の並べ替えを行うために、

172
00:14:10,940 --> 00:14:17,240
あなたは、CプログラムやPythonプログラム、Javaプログラムを書きたい場合

173
00:14:17,240 --> 00:14:20,070
あなたがそこに格納されたデータに対処するため、

174
00:14:20,070 --> 00:14:23,170
それを取得するための最も一般的な方法の一つは、CSVファイルに含まれています。

175
00:14:23,170 --> 00:14:26,850
あなたは、対話 '名前を付けて保存 "に行くときや、Excelを開くことができ

176
00:14:26,850 --> 00:14:32,840
あなたは、実際のCSVファイルを得ることができます。

177
00:14:32,840 --> 00:14:35,890
>> これらの事に対処する方法を知って便利。

178
00:14:35,890 --> 00:14:42,010
それが動作する方法はそれに似ているということです - 私が意味する、それは本質的に、スプレッドシートを模倣している

179
00:14:42,010 --> 00:14:47,590
ここで、我々は非常に、一番左の部分で、ここに見られるように、

180
00:14:47,590 --> 00:14:49,910
我々はすべての最後の名前を持っています。

181
00:14:49,910 --> 00:14:54,670
だから我々はその後、マラン、Hardison、その後ボーデン、MacWilliam、その後チャンを持っています。

182
00:14:54,670 --> 00:14:59,470
すべての姓。そして、コンマは最初の名前から姓を分離します。

183
00:14:59,470 --> 00:15:02,970
デビッド、ネイト、ロブ、トミー、そしてZamyla。

184
00:15:02,970 --> 00:15:06,850
私はいつも、ロビーとトムを混ぜる。

185
00:15:06,850 --> 00:15:10,940
そして、最後に、3番目の列は、電子メールアドレスです。

186
00:15:10,940 --> 00:15:18,500
あなたがそれを理解したら、プログラムの残りの部分を実装するのはかなり簡単です。

187
00:15:18,500 --> 00:15:23,850
私達は私達のCプログラムで、これと同じ構造を模倣するために何をやったか

188
00:15:23,850 --> 00:15:27,510
我々は、構造体を使用してきましたされています。

189
00:15:27,510 --> 00:15:30,520
我々は、同様にこれらのもう少し一緒に遊んでから始めましょう。

190
00:15:30,520 --> 00:15:35,790
私たちは辞書を扱った問題セット3の最初の少しのためにそれらを見た。

191
00:15:35,790 --> 00:15:40,290
しかし、このスタッフのstructは、姓、名、電子メールを保存します。

192
00:15:40,290 --> 00:15:44,500
弊社のCSVファイルなどが格納していました。

193
00:15:44,500 --> 00:15:47,950
だから、これはちょうど、ある形式から別の形式に変換しています。

194
00:15:47,950 --> 00:15:54,630
我々は、ラインに、この場合には、スタッフの構造体を変換する必要が

195
00:15:54,630 --> 00:15:59,060
ちょうどそのようにカンマで区切られた行、。

196
00:15:59,060 --> 00:16:01,500
お分かりでしょうか？あなたたちはすべてのクイズを取った、

197
00:16:01,500 --> 00:16:07,680
ので、私はあなたが、少なくともこのことについて考える時間を持っていた想像してみてください。

198
00:16:07,680 --> 00:16:16,410
>> レンタル機能では、問題は、私たちがでとるように求めます - この少し上でwe'llズーム - 

199
00:16:16,410 --> 00:16:22,480
、名前sで、職員体制、スタッフのstructに取る

200
00:16:22,480 --> 00:16:30,900
と私たちのstaff.csvファイルにその内容を追記します。

201
00:16:30,900 --> 00:16:34,230
これが使用する非常に簡単であることが判明。

202
00:16:34,230 --> 00:16:37,430
今日はもう少し、これらの関数をいじっの一種よ。

203
00:16:37,430 --> 00:16:44,510
しかし、この場合には、fprintf関数は、実際にキーです。

204
00:16:44,510 --> 00:16:51,960
だからfprintfので、我々はあなたたちはprintfのこの全体の用語を使用してきたのと同様に、印刷することができます。

205
00:16:51,960 --> 00:16:55,050
あなたは、ファイルへの行のprintfができます。

206
00:16:55,050 --> 00:16:59,030
だけではなく、通常のprintfの呼び出しを行うので、あなたはそれをフォーマット文字列を与える場所

207
00:16:59,030 --> 00:17:05,380
そして、あなたは、次の引数を使用してすべての変数を置き換える

208
00:17:05,380 --> 00:17:11,290
fprintf関数で、あなたの非常に最初の引数は、代わりにあなたが書き込みたいファイルです。

209
00:17:11,290 --> 00:17:21,170
私たちは、男fprintfを、たとえば、アプライアンスでこれを見た場合

210
00:17:21,170 --> 00:17:25,980
我々は、printfとfprintfの違いを見ることができます。

211
00:17:25,980 --> 00:17:28,960
私はここで少し拡大します。

212
00:17:28,960 --> 00:17:33,140
printf関数とそう、我々はそれをフォーマット文字列を与えると、その後の引数

213
00:17:33,140 --> 00:17:37,580
私達の書式文字列に置換または置換のためのすべての変数です。

214
00:17:37,580 --> 00:17:47,310
fprintfを持つのに対し、最初の引数には、確かに、ストリームと呼ばれるこのファイルは*です。

215
00:17:47,310 --> 00:17:51,800
>> 、私たちの雇用にこっち戻って移動する

216
00:17:51,800 --> 00:17:54,550
我々はすでに私たちのためにオープンしたファイル*ストリームを持っている。

217
00:17:54,550 --> 00:17:57,810
それはのこの最初の行が何をするか、それはstaff.csvファイルを開き、

218
00:17:57,810 --> 00:18:01,690
それを追記モードでそれを開き、私たちが行うためには残っているすべてです

219
00:18:01,690 --> 00:18:08,640
ファイルへのスタッフの構造を記述します。

220
00:18:08,640 --> 00:18:10,870
そして、私はiPadを使用しますか、見てみましょう？

221
00:18:10,870 --> 00:18:17,900
私はiPadを使用します。私たちはvoidを持っている - 私は少し良く書き込めるようにテーブルの上にこれを入れてみましょう - 

222
00:18:17,900 --> 00:18:33,680
レンタルを無効にし、それは1つの引数、sと呼ばれるスタッフの構造にかかる。

223
00:18:33,680 --> 00:18:44,120
私たちのカッコを持って、我々は、ファイルと呼ばれる我々のファイル*を持っている

224
00:18:44,120 --> 00:18:48,380
我々は我々のfopenライン私たちに与えられた、

225
00:18:48,380 --> 00:18:51,890
そして私はちょうどそれがpediaで既になのでドットなど書こうと思います。

226
00:18:51,890 --> 00:19:00,530
そして、私たちの次の行に、我々は、fprintfのに電話をするつもりだ

227
00:19:00,530 --> 00:19:03,700
そして我々は我々が印刷したいファイルを渡すつもりだ、

228
00:19:03,700 --> 00:19:10,290
その後私達の書式文字列、どの - 

229
00:19:10,290 --> 00:19:14,300
私はあなたたちは、それがどのように見えるかを教えてもらおう。

230
00:19:14,300 --> 00:19:20,500
あなたはどう、ステラ？書式文字列の最初の部分がどのようなものか知っていますか？

231
00:19:20,500 --> 00:19:24,270
[ステラ]私はよく分からない。 >>はジミーをお気軽に。

232
00:19:24,270 --> 00:19:27,690
あなたは、ジミーを知っていますか？

233
00:19:27,690 --> 00:19:31,000
[ジミー]は、それだけで最後でしょうか？知りません。私は全くわからない。

234
00:19:31,000 --> 00:19:39,020
オーケー。>>方法について、誰もがこの試験で正しいを取得するのですか？

235
00:19:39,020 --> 00:19:41,770
すべての権利号。

236
00:19:41,770 --> 00:19:47,920
それは、ここで我々が​​しなければならないすべては私達が私達スタッフの構造の各部分を望んであることが判明

237
00:19:47,920 --> 00:19:53,290
我々のファイルに文字列としてプリントアウトすることができます。

238
00:19:53,290 --> 00:19:59,900
我々は姓を持っているので、我々は、ちょうど3つの異なる時点で文字列置換文字使用

239
00:19:59,900 --> 00:20:07,160
続いてコンマ、その後、最初の名前は、続いてコンマ

240
00:20:07,160 --> 00:20:12,430
続いて、そして最後にメールアドレス - ではない

241
00:20:12,430 --> 00:20:15,140
私の画面にフィット - しかし、それは、改行文字が続いている。

242
00:20:15,140 --> 00:20:20,060
だから、僕はダウンしてそこにそれを書くつもりだ。

243
00:20:20,060 --> 00:20:23,560
そして、我々の形式の文字列を次の

244
00:20:23,560 --> 00:20:27,880
私達はちょうど私達がドット表記法を使用してアクセスする置換を、持っている

245
00:20:27,880 --> 00:20:31,370
我々は問題セット3で確認した。

246
00:20:31,370 --> 00:20:48,820
我々はs.last、s.first、とs.emailを使用することができます

247
00:20:48,820 --> 00:20:58,990
私達の書式指定文字列にこれらの3つの値に置換する。

248
00:20:58,990 --> 00:21:06,190
だからそれはどうだった？理にかなって？

249
00:21:06,190 --> 00:21:09,700
はい？いいえ？多分？オーケー。

250
00:21:09,700 --> 00:21:14,180
>> 我々が印刷したと我々はファイルをオープンしたら後に我々が行うことを最終的なもの：

251
00:21:14,180 --> 00:21:17,370
我々は、ファイルを開いたときはいつでも、私たちは常にそれを閉じるために覚えておく必要があります。

252
00:21:17,370 --> 00:21:19,430
さもなければので、我々は、メモリリークが発生してしまいます

253
00:21:19,430 --> 00:21:22,500
ファイル記述子を使用した。

254
00:21:22,500 --> 00:21:25,950
だから我々は、どの関数を使うのですか、それを閉じますか？ダニエル？

255
00:21:25,950 --> 00:21:30,120
[ダニエル] fcloseは？まさに>> fcloseは、。

256
00:21:30,120 --> 00:21:37,520
だから、この問題の最後の部分は、fclose関数を使用して、ファイルを正しく閉じるようだった

257
00:21:37,520 --> 00:21:40,370
これは、ちょうどそのように見えます。

258
00:21:40,370 --> 00:21:43,880
あまりにもクレイジーではない。

259
00:21:43,880 --> 00:21:46,990
クール。

260
00:21:46,990 --> 00:21:49,520
だからクイズでの問題33です。

261
00:21:49,520 --> 00:21:52,480
我々は間違いなく、より多くのファイルがあるでしょうI / Oが出てくる。

262
00:21:52,480 --> 00:21:55,130
今日は今日の講演で、またはセクションでもう少しやる、

263
00:21:55,130 --> 00:22:01,710
それはこの次期psetのバルクを形成するために何が起こっているのだから。

264
00:22:01,710 --> 00:22:05,020
この時点でクイズから移動してみましょう。はい？

265
00:22:05,020 --> 00:22:10,880
>> [シャルロット]]なぜ代わりにfcloseのfcloseを（ファイル）（staff.csv）？

266
00:22:10,880 --> 00:22:19,100
ああ。>>それがあることが判明したので - ので、素晴らしいものです質問、

267
00:22:19,100 --> 00:22:27,800
なぜ、我々は、fcloseを書いた時、fcloseを（ファイル）スター変数を記述しているされている

268
00:22:27,800 --> 00:22:33,680
のようにファイル名、staff.csvに反対？それは正しいですか？うん。

269
00:22:33,680 --> 00:22:39,570
それでは見てみましょう。私は私のラップトップに切り替えた場合、

270
00:22:39,570 --> 00:22:45,040
とfclose関数を見てみましょう。

271
00:22:45,040 --> 00:22:51,460
だから、fclose関数は、ストリームをクローズし、それは我々がクローズするストリームへのポインタを取り

272
00:22:51,460 --> 00:22:57,010
として我々はクローズする実際のファイル名に反対した。

273
00:22:57,010 --> 00:23:01,620
あなたはfopenの呼び出しを行ったとき、これは、背後からである

274
00:23:01,620 --> 00:23:12,020
あなたがファイルを開くときには、実際にファイルの情報を格納するためのメモリを割り当てています。

275
00:23:12,020 --> 00:23:16,380
だからあなたは、ファイルに関する情報が含まれるファイルのポインタを持っている

276
00:23:16,380 --> 00:23:23,080
それは開いているように、ファイルに現在あるその大きさ、

277
00:23:23,080 --> 00:23:29,100
ので、ファイル内の特定の場所への呼び出しを読み書きすることができますことを。

278
00:23:29,100 --> 00:23:38,060
あなたは、ファイル名をクローズするのではなくポインタを閉じてしまう。

279
00:23:38,060 --> 00:23:48,990
>> はい？ [ダニエル]だからレンタルを使用するために、あなたは言うだろう - それはどのようにユーザーの入力を取得するのですか？

280
00:23:48,990 --> 00:23:53,830
fprintfはそれだけでユーザーの入力を待つつもりだという意味で、GetStringメソッドのように動作しません

281
00:23:53,830 --> 00:23:57,180
これを入力するように求める - または、これらの3つのものを入力するように待つ？

282
00:23:57,180 --> 00:24:00,480
それとも、レンタルを実装するために何かを使用する必要がありますか？

283
00:24:00,480 --> 00:24:04,100
>>うん。だから我々はわからない - 質問があったが、どのように我々は、ユーザの入力を取得するのですか

284
00:24:04,100 --> 00:24:09,220
雇用を実現するためには？そして、どのような我々がここにあることは、雇うの発信者である

285
00:24:09,220 --> 00:24:17,690
既に構造体に格納されたデータのすべてとこのスタッフの構造体で渡された。

286
00:24:17,690 --> 00:24:22,990
だから、fprintfはちょうどファイルに直接そのデータを書き込むことができる。

287
00:24:22,990 --> 00:24:25,690
ユーザーの入力を待っているはありません。

288
00:24:25,690 --> 00:24:32,110
ユーザがすでに正しくこのスタッフstructにそれを置くことによって入力を与えてくれた。

289
00:24:32,110 --> 00:24:36,510
これらのポインタのいずれかがnullだった場合、物事は、もちろん、壊してしまう

290
00:24:36,510 --> 00:24:40,370
ので、我々はここに戻って上にスクロールして、我々は我々の構造を見てみましょう。

291
00:24:40,370 --> 00:24:43,640
我々は、最後の文字列、文字列には、まず文字列のメールを持っています。

292
00:24:43,640 --> 00:24:48,530
我々は今、それらの本当にすべてが、ボンネットの下に、char *変数であることを知っている。

293
00:24:48,530 --> 00:24:53,470
つまり、またはNULLを指しているかもしれません。

294
00:24:53,470 --> 00:24:55,800
彼らは、ヒープ上のメモリを指している可能性があり

295
00:24:55,800 --> 00:24:59,650
スタック上の多分メモリ。

296
00:24:59,650 --> 00:25:04,580
私たちは本当に知っているが、これらのポインタのいずれかがnullの場合、または無効である場合、しないでください

297
00:25:04,580 --> 00:25:08,120
間違いなく私たちのレンタル機能をクラッシュさせるだろうということ。

298
00:25:08,120 --> 00:25:11,050
それは試験の範囲を超えてのようなものだったものだった。

299
00:25:11,050 --> 00:25:16,440
我々はそれについて心配していない。

300
00:25:16,440 --> 00:25:22,170
グレート。オーケー。だからクイズから移動。

301
00:25:22,170 --> 00:25:25,760
>> のはこの男を閉じてみましょう、と我々は、pset 4見ていくつもりです。

302
00:25:25,760 --> 00:25:34,700
だから君たちはPSETスペックを見れば、一度それにアクセスすることができ、cs50.net/quizzes、

303
00:25:34,700 --> 00:25:42,730
今日はセクションの問題のいくつかを通過しようとしている。

304
00:25:42,730 --> 00:25:52,240
私は、下にスクロールしている - 質問のセクションは、pset仕様の3ページ目から始まります。

305
00:25:52,240 --> 00:25:57,800
と最初の部分は、リダイレクトやパイプに行くとショートを視聴することが求​​められます。

306
00:25:57,800 --> 00:26:02,820
クールショートのようなものだった、どっちがあなたが使用できるいくつかの新しい、クールなコマンドライントリックを示しています。

307
00:26:02,820 --> 00:26:06,050
そして、我々は、同様にあなたのためのいくつかの質問を持っている。

308
00:26:06,050 --> 00:26:10,860
printfは、デフォルトで書き込むストリーム、約この最初の質問

309
00:26:10,860 --> 00:26:15,920
我々の種類のはちょっと前に少しだけに触れました。

310
00:26:15,920 --> 00:26:22,380
我々だけで議論していたことをこのfprintf関数は、引数としてファイル*ストリームを取り込む。

311
00:26:22,380 --> 00:26:26,580
fcloseは、同様にファイル*ストリームを取り込んで

312
00:26:26,580 --> 00:26:32,660
やfopenの戻り値は、同様にあなたのファイル*ストリームを提供します。

313
00:26:32,660 --> 00:26:36,060
我々はprintfの扱ってきたときに前のものを見たことがない理由

314
00:26:36,060 --> 00:26:39,450
printfのデフ​​ォルトのストリームを持っているためです。

315
00:26:39,450 --> 00:26:41,810
そして、それが書き込む既定のストリーム

316
00:26:41,810 --> 00:26:45,190
あなたは、簡単に言えば知ります。

317
00:26:45,190 --> 00:26:50,080
だから、間違いなく、それを見てみましょう。

318
00:26:50,080 --> 00:26:53,010
>> 今日のセクションでは、私たちは、GDBについて少し話をするつもりだ

319
00:26:53,010 --> 00:26:57,720
、より身近なあなたがそれをしているので、あなたがそれを得るより多くの練習

320
00:26:57,720 --> 00:27:01,390
より良いことができるあなたが実際にあなた自身のコード内のバグを追い詰めるだろう。

321
00:27:01,390 --> 00:27:05,540
これは途方もなくアップデバッグのプロセスをスピードアップします。

322
00:27:05,540 --> 00:27:09,230
だからprintfを使用することにより、毎回あなたは、あなたのコードを再コンパイルしなければならないことをやる

323
00:27:09,230 --> 00:27:13,000
あなたが再びそれを実行する必要があり、時にはあなたは、周りのprintfの呼び出しを移動する必要があります

324
00:27:13,000 --> 00:27:17,100
コー​​ドをコメントアウトして、それだけでしばらく時間がかかります。

325
00:27:17,100 --> 00:27:20,850
私たちの目標は、GDBと、あなたは本質的にできることをしようと説得することである

326
00:27:20,850 --> 00:27:26,810
printfのコード内の任意の時点で何でも、あなたはそれを再コンパイルする必要はありません。

327
00:27:26,810 --> 00:27:35,120
起動および場所printfの隣に推測し続けなければならないことはありません。

328
00:27:35,120 --> 00:27:40,910
最初に行うべきことは、この行をコピーして、ウェブのセクションコードを下車します。

329
00:27:40,910 --> 00:27:47,530
私は、 "wget​​をhttp://cdn.cs50.net言う、"このコード行をコピーしています。

330
00:27:47,530 --> 00:27:49,510
私はそれをコピーするつもりです。

331
00:27:49,510 --> 00:27:55,950
私はあなたが私がやっているかが分かるようにズームアウト、私のアプライアンスの所へ行くつもりだ、

332
00:27:55,950 --> 00:28:01,890
そこにそれを貼り付ける、と私はEnterキーを打ったとき、このwgetコマンドは、文字通りWebはgetです。

333
00:28:01,890 --> 00:28:06,210
それはインターネットのこのファイルをオフ​​プルダウンになるだろう、

334
00:28:06,210 --> 00:28:11,790
そしてそれは、現在のディレクトリに保存するつもりです。

335
00:28:11,790 --> 00:28:21,630
私は、現在のディレクトリの一覧を表示した場合今、あなたは私はすぐそこにこのsection5.zipファイルを持っていることがわかります。

336
00:28:21,630 --> 00:28:25,260
その男に対処する方法は、それを解凍することです

337
00:28:25,260 --> 00:28:27,650
そのあなたがちょうどこのように、コマンドラインで行うことができます。

338
00:28:27,650 --> 00:28:31,880
Section5.zip。

339
00:28:31,880 --> 00:28:36,980
それはそれを解凍してくださいよ、私のためにフォルダを作成し、

340
00:28:36,980 --> 00:28:40,410
すべての内容を膨らませて、そこに入れます。

341
00:28:40,410 --> 00:28:47,410
だから今は、cdコマンドを使用して、私のセクション5のディレクトリに入ることができます。

342
00:28:47,410 --> 00:28:58,310
クリアを使用して画面をクリアします。だから、画面をクリアします。

343
00:28:58,310 --> 00:29:02,280
今、私はに対処するための良いクリーンな端末を持っている。

344
00:29:02,280 --> 00:29:06,200
>> 今私は、私は、このディレクトリに表示されるすべてのファイルを一覧表示する場合、

345
00:29:06,200 --> 00:29:12,270
buggy1、buggy2、buggy3、とbuggy4：あなたは、私が4ファイルを持っていることがわかります。

346
00:29:12,270 --> 00:29:16,180
私もそれに対応する。cファイルを持っている。

347
00:29:16,180 --> 00:29:20,400
私たちは、今のところは。cファイルを見に行くわけではありません。

348
00:29:20,400 --> 00:29:24,140
その代わりに、我々は、GDBを開くときにそれらを使用するつもりです。

349
00:29:24,140 --> 00:29:28,220
私たちは、GDBを使っているときに我々は実際のソースコードへのアクセス権を持っているように、それらの周りを守ってきた

350
00:29:28,220 --> 00:29:32,740
GDBで周りが、セクションのこの部分の目的は、手を加えている

351
00:29:32,740 --> 00:29:40,370
我々は、これらの4つのバギーの各プログラムで間違って何が起こっているのかを把握するためにそれを使用する方法を参照してください。

352
00:29:40,370 --> 00:29:43,380
だから我々は単に、本当に迅速に部屋の周りに行くんだ

353
00:29:43,380 --> 00:29:47,000
と私は、バギーのいずれかのプログラムを実行するために誰かに依頼するつもりです

354
00:29:47,000 --> 00:29:54,730
その後、我々は、GDBを介​​してグループとして行くだろう、と我々は、これらのプログラムを修正するために何ができるのかがわかります

355
00:29:54,730 --> 00:29:58,460
あるいは少なくともそれらの各々に間違った何が起こっているかを識別することができます。

356
00:29:58,460 --> 00:30:04,760
ダニエルと一緒にここからやり直してみましょう。あなたはbuggy1を実行するのだろうか？何が起こるか見てみましょう。

357
00:30:04,760 --> 00:30:09,470
[ダニエル]それは、アプリケーションの障害があると言う。 >>うん。その通りです。

358
00:30:09,470 --> 00:30:12,460
私はbuggy1を実行した場合だから、私はワンセグ障害を取得します。

359
00:30:12,460 --> 00:30:16,210
この時点で、私は、行くとbuggy1.cを開く可能性

360
00:30:16,210 --> 00:30:19,450
試してみて、間違って何が起こっているのかを把握

361
00:30:19,450 --> 00:30:22,000
しかし、このセグメントフォルトエラーについての最も嫌なものの一つ

362
00:30:22,000 --> 00:30:27,610
それは実際に間違っていたと壊したどのようなプログラムの物事の行にあなたを教えていないということです。

363
00:30:27,610 --> 00:30:29,880
あなたのコードを見ているの種類

364
00:30:29,880 --> 00:30:33,990
との推測を使用して把握し、チェックやprintf間違った何が起こっているのを参照してください。

365
00:30:33,990 --> 00:30:37,840
GDBは約クールなものの一つは、それが本当に、本当に簡単だということです

366
00:30:37,840 --> 00:30:42,170
プログラムがクラッシュした時のラインを把握する。

367
00:30:42,170 --> 00:30:46,160
それは完全にそれだけで、そのためにも、それを使用する価値がある。

368
00:30:46,160 --> 00:30:56,190
だから、GDBを起動するために、私はGDBを入力し、[私が実行したい実行可能ファイルへのパスを与える。

369
00:30:56,190 --> 00:31:01,960
ここで私は、gdb ./buggy1を入力している。

370
00:31:01,960 --> 00:31:06,600
ENTERキーを押してください。 、私にすべてのこの著作権情報を提供します

371
00:31:06,600 --> 00:31:13,000
上下ここでは、/ home /からシンボルを読み込む "と言う、この行が表示されます

372
00:31:13,000 --> 00:31:17,680
jharvard/section5/buggy1。 "

373
00:31:17,680 --> 00:31:22,060
すべてがうまくいけば、あなたはそれがこのようなメッセージを出力し表示されます。

374
00:31:22,060 --> 00:31:25,500
それはシンボルを読んでみよう、それは "私は、あなたの実行可能ファイルからシンボルを読んでいる"と言うでしょう

375
00:31:25,500 --> 00:31:29,900
そして、次に、それはこっちにこの "done"メッセージを持つことになります。

376
00:31:29,900 --> 00:31:35,410
この他のいくつかのバリエーションを参照するか、またはあなたはそれがシンボルを見つけられませんでした表示された場合

377
00:31:35,410 --> 00:31:41,460
またはそのような何かは、何を意味するとちょうど正しく実行ファイルをコンパイルしていないということです。

378
00:31:41,460 --> 00:31:49,980
我々は、GDBで使用するためのプログラムをコンパイルするとき、私たちは、その特別な-gフラグを使用する必要が

379
00:31:49,980 --> 00:31:54,540
あなたのプログラムをコンパイルした場合、そのことは単に入力して、デフォルトでは終わった

380
00:31:54,540 --> 00:31:59,320
またはそれらのいずれか、バギーを作るか、または回復させる。

381
00:31:59,320 --> 00:32:07,800
しかし、あなたはClangのを使って手動でコンパイルしているなら、あなたはに行くと、その-gフラグを入れておかなければなりません。

382
00:32:07,800 --> 00:32:10,310
>> この時点で、今我々は、GDBのプロンプトを使用していること、

383
00:32:10,310 --> 00:32:12,310
それは、プログラムを実行するのは非常に簡単です。

384
00:32:12,310 --> 00:32:19,740
我々は、いずれかの実行を入力するか、または私達はちょうどrを入力することができます。

385
00:32:19,740 --> 00:32:22,820
最も多くのGDBコマンドは省略できます。

386
00:32:22,820 --> 00:32:25,940
通常かなりいいですちょうど1またはカップルの手紙、へ。

387
00:32:25,940 --> 00:32:30,980
あなたはタイプRと入力し、Enterを押せばそれで、サアド、何が起こりますか？

388
00:32:30,980 --> 00:32:39,390
[Saadは]私は、SIGSEGV、セグメンテーションフォールトを持って、そして、すべてのこの無意味な言葉。

389
00:32:39,390 --> 00:32:43,650
>>うん。

390
00:32:43,650 --> 00:32:47,990
申し訳画面上で見ているような、とSaadさんが言ったように、

391
00:32:47,990 --> 00:32:53,430
我々は、実行またはrを入力して、Enterを押したとき、我々はまだ同じセグメントフォルトを取得します。

392
00:32:53,430 --> 00:32:55,830
だからGDBを使用して私たちの問題を解決していません。

393
00:32:55,830 --> 00:32:59,120
しかし、それは私たちにいくつかの無意味な言葉を与え、それはこの無意味な言葉が判明

394
00:32:59,120 --> 00:33:03,080
それが起こっている場所を実際に教えてくれる。

395
00:33:03,080 --> 00:33:10,680
この少しを解析するには、この最初のビットはすべてが間違って起こっている機能です。

396
00:33:10,680 --> 00:33:20,270
そこにこの_ strcmp_sse4_2だし、それはそれは、このファイルで何が起こっていることを教えてくれる

397
00:33:20,270 --> 00:33:29,450
sysdeps/i386と呼ばれる、このすべて、再び、混乱の種 - しかし、ライン254。

398
00:33:29,450 --> 00:33:31,670
ことは、解析するのは難しいのようなものだ。通常はこのようなものを見たとき、

399
00:33:31,670 --> 00:33:38,770
それはそれはシステムライブラリのいずれかに断層ワンセグていることを意味します。

400
00:33:38,770 --> 00:33:43,220
strcmp関数とは何かはそう。君たちは前にstrcmpを見てきました。

401
00:33:43,220 --> 00:33:52,730
ではない、あまりにも狂ったが、これはstrcmp関数が壊れているか、strcmp関数に問題があることを意味するのでしょうか？

402
00:33:52,730 --> 00:33:57,110
あなたはアレキサンダー、どう思いますか？

403
00:33:57,110 --> 00:34:04,890
[アレキサンダー]ということです -  254ラインですか？と - しないバイナリが、それは彼らの天井ではないが、

404
00:34:04,890 --> 00:34:10,590
その後、各関数の別の言語があります。その関数内でその254がある、または - ？

405
00:34:10,590 --> 00:34:21,460
>>これは、ライン254です。それはおそらく、この。sファイルでどのように見えるので、それはアセンブリコード。

406
00:34:21,460 --> 00:34:25,949
>> しかし、私は、我々はワンセグ障害を得ているので、より差し迫ったものは、であることを推測する

407
00:34:25,949 --> 00:34:29,960
それはstrcmp関数から来ているように見え、

408
00:34:29,960 --> 00:34:38,030
これはstrcmpが壊れている、その後、意味するものではありません？

409
00:34:38,030 --> 00:34:42,290
それがうまくいけば、するべきではありません。だから、あなたがセグメンテーションフォールトを持っているので、

410
00:34:42,290 --> 00:34:49,480
システム機能の一つで、一般的にあなたがちょうどそれを正しく呼び出していないことを意味すること。

411
00:34:49,480 --> 00:34:52,440
実際に何が起こっているのかを把握するために行うには最速のもの

412
00:34:52,440 --> 00:34:55,500
あなたはワンセグ障害を見るたびに、このような狂気何かを見たとき、

413
00:34:55,500 --> 00:34:59,800
あなただけのメイン以上を使っているプログラムを持っている場合は特に、

414
00:34:59,800 --> 00:35:03,570
バックトレースを使用することです。

415
00:35:03,570 --> 00:35:13,080
私は完全なバックトレース言葉とは対照的に、BTを書き込むことによって、バックトレースを省略できます。

416
00:35:13,080 --> 00:35:16,510
しかしシャーロットは、BTを入力し、エンターを押したときに何が起こるか？

417
00:35:16,510 --> 00:35:23,200
[シャルロット]それは私に2つの行、行0と1行目を示しています。

418
00:35:23,200 --> 00:35:26,150
>>うん。だからライン0と1行目。

419
00:35:26,150 --> 00:35:34,560
これらは、あなたのプログラムがクラッシュしたときインプレーに現在あった実際のスタックフレームです。

420
00:35:34,560 --> 00:35:42,230
最上位のフレーム、フレーム0から開始されて、フレーム1である、一番下に行く。

421
00:35:42,230 --> 00:35:45,140
私たちの一番上のフレームには、strcmpのフレームです。

422
00:35:45,140 --> 00:35:50,080
あなたは、これで我々だけでポインタを使ってクイズにやっていたことが問題に似たものと考えることができます

423
00:35:50,080 --> 00:35:54,890
我々はメインスタックフレームの上にスタックフレームを交換していたところ、

424
00:35:54,890 --> 00:35:59,700
そして我々はスワップがメインで使用されていた変数の上に使用していた変数を持っていた。

425
00:35:59,700 --> 00:36:08,440
私たちのメインの関数から呼び出された私たちのstrcmp関数で起こったここに私たちのクラッシュ、

426
00:36:08,440 --> 00:36:14,370
バックトレースは、私たちに物事は失敗している機能だけでなく、与えている

427
00:36:14,370 --> 00:36:16,440
すべてのものが呼び出された場所が、それはまた、私たちに言っている。

428
00:36:16,440 --> 00:36:18,830
だから私は、右にもう少し上をスクロールした場合、

429
00:36:18,830 --> 00:36:26,110
我々は、ええ、我々はこの関数strcmp-sse4.sファイルの行254にあったことがわかります。

430
00:36:26,110 --> 00:36:32,540
しかし、コールはbuggy1.c、6行目で行われた。

431
00:36:32,540 --> 00:36:35,960
私達はちょうどチェックアウトして、何が起こっていたか見に行くことができている - 私たちにできることを意味するので、

432
00:36:35,960 --> 00:36:39,930
buggy1.c、6行目で。

433
00:36:39,930 --> 00:36:43,780
繰り返しになりますが、これを行うためのいくつかの方法があります。一つは、GDBを終了することである

434
00:36:43,780 --> 00:36:49,460
またはあなたのコードが他のウィンドウとのクロスリファレンスで開く必要があります。

435
00:36:49,460 --> 00:36:54,740
今、あなたはオフィスの営業時間にならないため、それは、それ自体が、かなり便利です

436
00:36:54,740 --> 00:36:57,220
そして、あなたはワンセグ障害を持っていると、すべてが破壊された場所をTFのは不思議

437
00:36:57,220 --> 00:36:59,710
あなただけの "ああ、6行目、と言うことができます。私は、何が起こっているのか分からない

438
00:36:59,710 --> 00:37:03,670
しかし、6行についての何かが私のプログラムが破損する原因となっている。 "

439
00:37:03,670 --> 00:37:10,430
それを行うための他の方法は、GDBのリストと呼ばれる、このコマンドを使用することができます。

440
00:37:10,430 --> 00:37:13,650
またリットルとそれを短縮することができます。

441
00:37:13,650 --> 00:37:18,910
我々はリットルを押せばそれで、私たちはここで何を得るのですか？

442
00:37:18,910 --> 00:37:21,160
我々は奇妙なものの全体の束を取得します。

443
00:37:21,160 --> 00:37:26,030
これは、実際のアセンブリコードです

444
00:37:26,030 --> 00:37:29,860
それはstrcmp_sse4_2になっています。

445
00:37:29,860 --> 00:37:32,440
これは、ファンキーのようなものを探します

446
00:37:32,440 --> 00:37:36,520
そして我々はこれを取得している理由は、今からです

447
00:37:36,520 --> 00:37:40,160
GDBがフレーム0で私たちを持っています。

448
00:37:40,160 --> 00:37:43,070
>> だから、いつでも我々は見ての変数で、我々はソースコードを見て、いつでも、

449
00:37:43,070 --> 00:37:50,530
我々はインチ現在の通貨スタックフレームに関連するソースコードを見ている

450
00:37:50,530 --> 00:37:53,200
だから、意味のある何かを得るために、我々はする必要はあり

451
00:37:53,200 --> 00:37:57,070
より理にかなっているスタック·フレームに移動します。

452
00:37:57,070 --> 00:38:00,180
この場合、メインスタックフレームは、もう少し意味があるだろう

453
00:38:00,180 --> 00:38:02,680
それは実際に我々が書いたコードだったので。

454
00:38:02,680 --> 00:38:05,330
strcmpのコードではない。

455
00:38:05,330 --> 00:38:08,650
我々は2つ​​を持っているので、あなたは、この場合には、フレーム間を移動することができる方法、

456
00:38:08,650 --> 00:38:10,430
我々は、0と1を持っている

457
00:38:10,430 --> 00:38:13,650
あなたは、上下コマンドを使用して行うこと。

458
00:38:13,650 --> 00:38:18,480
私は1つ上のフレームに移動する場合は、

459
00:38:18,480 --> 00:38:21,770
今私はメインスタックフレームにいるよ。

460
00:38:21,770 --> 00:38:24,330
私は、私がいた場所に戻って上下に移動することができます

461
00:38:24,330 --> 00:38:32,830
再び下り、再び上がると、再び上がる。

462
00:38:32,830 --> 00:38:39,750
あなたがこれまでにGDBでプログラムを行う場合には、クラッシュすることでしょう、あなたは、バックトレースを取得

463
00:38:39,750 --> 00:38:42,380
そして、あなたはそれはあなたが何が起こっているか知っていないいくつかのファイルでのことがわかります。

464
00:38:42,380 --> 00:38:45,460
あなたがリストを試して、コードは、あなたに見覚えはありません

465
00:38:45,460 --> 00:38:48,150
あなたのフレームを見て、あなたがどこにいるか把握する。

466
00:38:48,150 --> 00:38:51,010
あなたは間違っているスタック·フレームにはおそらくだ。

467
00:38:51,010 --> 00:38:58,760
あるいは、少なくとも、あなたが本当にデバッグできるものではないスタックフレームにしている。

468
00:38:58,760 --> 00:39:03,110
今、我々は適切なスタック·フレームにしていることを、我々は、メインにしている

469
00:39:03,110 --> 00:39:08,100
今、私たちはラインが何であったかを把握するには、listコマンドを使用することができます。

470
00:39:08,100 --> 00:39:13,590
そして、あなたはそれを見ることができ、それは右ここに私たちのためにそれを印刷した。

471
00:39:13,590 --> 00:39:19,470
しかし、我々はすべて同じで、リストは私たちに、この素​​敵なプリントアウトを与えるリストを打つことができる

472
00:39:19,470 --> 00:39:23,920
ここで起こっている実際のソースコード。

473
00:39:23,920 --> 00:39:26,420
>> 特に、我々は、6行目で見ることができます。

474
00:39:26,420 --> 00:39:29,330
我々はここで何が起こっているかを見ることができます。

475
00:39:29,330 --> 00:39:31,250
そして、我々は文字列の比較を作っているように見える

476
00:39:31,250 --> 00:39:41,050
文字列 "CS50岩"とargv [1]の間。

477
00:39:41,050 --> 00:39:45,700
このことについて何かがクラッシュしていました。

478
00:39:45,700 --> 00:39:54,120
ミッシーだから、あなたはここで何が起こっている可能性があります上の任意の考えを持っていますか？

479
00:39:54,120 --> 00:39:59,400
[ミッシー]私はそれがクラッシュしている理由がわからない。 >>あなたは、それがクラッシュしている理由がわからない？

480
00:39:59,400 --> 00:40:02,700
ジミー、任意の考え？

481
00:40:02,700 --> 00:40:06,240
[ジミー]私は全くわからないんだけど、我々は文字列を使用した最後の時間を比較し、

482
00:40:06,240 --> 00:40:10,260
またはstrcmpの、我々はそれの下の3つの異なる例のようでした。

483
00:40:10,260 --> 00:40:12,800
我々は、==を持っていなかったが、私は右、その最初の行で、とは思わない。

484
00:40:12,800 --> 00:40:16,700
代わりに、それは、3つに分離し、1 == 0だった

485
00:40:16,700 --> 00:40:19,910
1 <0、私が思うに、一つは> 0であった。

486
00:40:19,910 --> 00:40:22,590
そのようなので、多分何か？ >>うん。だから、この問題があります

487
00:40:22,590 --> 00:40:27,200
の我々は、正しく比較をやっている？

488
00:40:27,200 --> 00:40:31,660
ステラ？任意の考え？

489
00:40:31,660 --> 00:40:38,110
[ステラ]私はよく分からない。 >>わからない。ダニエル？考えですか？オーケー。

490
00:40:38,110 --> 00:40:44,770
それは、まさにここで起こっていることが判明し、我々はプログラムを実行したときです

491
00:40:44,770 --> 00:40:48,370
初めて、ダニエルのためのプログラムを実行したとき、我々は、ワンセグ障害を持って

492
00:40:48,370 --> 00:40:50,800
あなたはそれを任意のコマンドライン引数を与えたのでしょうか？

493
00:40:50,800 --> 00:40:58,420
[ダニエル]ナンバー>>第その場合は、argv [1]の値は何ですか？

494
00:40:58,420 --> 00:41:00,920
>>値はありません。 >>は右。

495
00:41:00,920 --> 00:41:06,120
まあ、適当な文字列値はありません。

496
00:41:06,120 --> 00:41:10,780
しかし、いくつかの値があります。そこに格納されている値とは何ですか？

497
00:41:10,780 --> 00:41:15,130
>>ガベージ値はありますか？ >>それは、この場合には、どちらかゴミ値だか

498
00:41:15,130 --> 00:41:19,930
argv配列の終わりは常にnullで終端されています。

499
00:41:19,930 --> 00:41:26,050
それでは、実際に格納されてしまったと、nullがあります。

500
00:41:26,050 --> 00:41:30,810
他のこういった問題を解決することではなく、を介してそれを考えて、

501
00:41:30,810 --> 00:41:33,420
それをプリントアウトしてみることです。

502
00:41:33,420 --> 00:41:35,880
私は、GDBを使用して偉大であることを言っていたところです

503
00:41:35,880 --> 00:41:40,640
あなたは、すべての変数は、必要なすべての値をプリントアウトすることができますので、

504
00:41:40,640 --> 00:41:43,230
この便利で素晴らしいpコマンドを使用します。

505
00:41:43,230 --> 00:41:48,520
私はpを入力し、もしそうなら、私は、変数または変数の名前の値を入力します

506
00:41:48,520 --> 00:41:55,320
、argcを言う、私はargcが1であることがわかります。

507
00:41:55,320 --> 00:42:01,830
私は、argvをプリントアウトしたい場合は[0]が、私はちょうどそのように行うことができます。

508
00:42:01,830 --> 00:42:04,840
そして、我々が見たように、argv [0]は常にあなたのプログラムの名前で、

509
00:42:04,840 --> 00:42:06,910
常に実行可能ファイルの名前。

510
00:42:06,910 --> 00:42:09,740
ここでは、それが完全なパス名を持っている参照してください。

511
00:42:09,740 --> 00:42:15,920
私も、何が起こるか見ARGV [1]プリントアウトすることができます。

512
00:42:15,920 --> 00:42:20,890
>> ここでは、神秘的な価​​値のこの種を得た。

513
00:42:20,890 --> 00:42:23,890
我々は、この0x0を得た。

514
00:42:23,890 --> 00:42:27,850
我々は、16進数の数字の話期首に覚えていますか？

515
00:42:27,850 --> 00:42:34,680
またはhexで50を表現する方法についてPSET 0の終了時に、その少し疑問？

516
00:42:34,680 --> 00:42:39,410
私達はちょうど私達自身を混同しないように、CSで16進数を書く方法

517
00:42:39,410 --> 00:42:46,080
十進数で、我々は常に0xでそれらを接頭辞です。

518
00:42:46,080 --> 00:42:51,420
だから、この0xプレフィックスは常にちょうど、16進数で、次の数字を解釈することを意味

519
00:42:51,420 --> 00:42:57,400
文字列ではなくではなく、10進数ではなく、二進数として。

520
00:42:57,400 --> 00:43:02,820
番号5-0進の有効な数値であるので。

521
00:43:02,820 --> 00:43:06,240
そしてそれは、10進数、50の番号です。

522
00:43:06,240 --> 00:43:10,050
だから、これは私たちがどのように曖昧さをなくすだけです。

523
00:43:10,050 --> 00:43:14,860
だから0x0はまた、10進数の0、2進数の0は16進数の0を意味します。

524
00:43:14,860 --> 00:43:17,030
それだけで値0です。

525
00:43:17,030 --> 00:43:22,630
これは、メモリ内に、実際に、これはnullがあるものであることが判明した。

526
00:43:22,630 --> 00:43:25,940
nullがちょうど0になります。

527
00:43:25,940 --> 00:43:37,010
ここでは、argvに格納されている要素[1]はnullです。

528
00:43:37,010 --> 00:43:45,220
だから我々は、NULL文字列に私たちの "C​​S50岩"という文字列を比較しようとしている。

529
00:43:45,220 --> 00:43:48,130
だから間接参照NULL、NULLで物事をアクセスしようとし、

530
00:43:48,130 --> 00:43:55,050
それらは、一般的に発生するセグメンテーションエラーまたは他の悪い事のいくつかの並べ替えを引き起こすかもしれません。

531
00:43:55,050 --> 00:43:59,350
そして、それはstrcmpを確認してくださいしないことが判明

532
00:43:59,350 --> 00:44:04,340
あなたは、nullの値に渡されたかどうか。

533
00:44:04,340 --> 00:44:06,370
むしろ、それは単に先に行くと、そのことを実行しようとすると、

534
00:44:06,370 --> 00:44:14,640
それは障害をワンセグならば、それは障害をワンセグ、そしてそれはあなたの問題です。あなたはそれを修正するに行かなければならない。

535
00:44:14,640 --> 00:44:19,730
本当にすぐに、我々はこの問題をどのように解決するのでしょうか？シャーロット？

536
00:44:19,730 --> 00:44:23,540
[シャルロット]は次のような場合は、使用して確認できます。

537
00:44:23,540 --> 00:44:32,240
もしそうであればargv [1]がnullの場合、== 0の場合、1を返し、とか[理解不能]。

538
00:44:32,240 --> 00:44:34,590
>>うん。だから、我々は確認することができますように、それを行うための一つの大きな方法だ

539
00:44:34,590 --> 00:44:39,230
我々はstrcmp関数は、argvに合格しようとしている値は、[1]、それはnullになります？

540
00:44:39,230 --> 00:44:45,830
それがnullの場合は、次に我々は、abortを大丈夫と言うことができます。

541
00:44:45,830 --> 00:44:49,450
>> これを行うには、より一般的な方法はargcの値を使用することです。

542
00:44:49,450 --> 00:44:52,040
あなたは、主の初めに右ここに見ることができます

543
00:44:52,040 --> 00:44:58,040
我々は、我々は、コマンドライン引数を使用するときに我々が一般的に行うことをその最初のテストを省略

544
00:44:58,040 --> 00:45:05,240
これは、私たちのargcは値は、我々が期待するものであるかどうかをテストすることです。

545
00:45:05,240 --> 00:45:10,290
この場合において、我々は、少なくとも2つの引数を期待している

546
00:45:10,290 --> 00:45:13,660
プログラムの名前に加え、他の1。

547
00:45:13,660 --> 00:45:17,140
我々はここに第二引数を使用しようとしているから。

548
00:45:17,140 --> 00:45:21,350
だから私たちのstrcmpの呼び出しの前に、あらかじめテストのいくつかの並べ替えを持っ

549
00:45:21,350 --> 00:45:37,390
argvが少なくとも2であるかどうかをテストするには、また同じようなことをするだろう。

550
00:45:37,390 --> 00:45:40,620
そのプログラムを再度実行して動作している場合我々は見ることができます。

551
00:45:40,620 --> 00:45:45,610
あなたはいつも本当にいいですGDBは、内でプログラムを再起動することができます。

552
00:45:45,610 --> 00:45:49,310
、実行することができますし、あなたのプログラムに引数を渡すとき

553
00:45:49,310 --> 00:45:53,060
あなたは、GDBを起動するときは、runをコールするときにそれらを渡しません。

554
00:45:53,060 --> 00:45:57,120
そうすればあなたは、異なる引数を指定して、それぞれの時間をあなたのプログラムを呼び出しておくことができます。

555
00:45:57,120 --> 00:46:08,080
だから、もう一度実行するか、または、私は、rを入力して、我々が "こんにちは"と入力すると何が起こるか見てみましょうことができます。

556
00:46:08,080 --> 00:46:11,140
再度最初からそれを起動したい場合、それは常にあなたを尋ねてきます。

557
00:46:11,140 --> 00:46:17,490
通常は、もう一度最初からそれを起動したいです。

558
00:46:17,490 --> 00:46:25,010
再び、この時点で、それはそれを再起動し、それがプリントアウト

559
00:46:25,010 --> 00:46:28,920
私たちが実行していることをプログラム、buggy1、こんにちは引数を指定して、

560
00:46:28,920 --> 00:46:32,720
そしてそれは、この標準出力を出力し、それは悲しい顔をして "あなたは、Dを得る"と言う。

561
00:46:32,720 --> 00:46:37,610
しかし、我々はseg faultをしませんでした。それは、そのプロセスが正常に終了しましたと述べた。

562
00:46:37,610 --> 00:46:39,900
だからそれはかなりよさそうだ。

563
00:46:39,900 --> 00:46:43,050
これ以上のセグメントフォールト、我々は、それが過去行われません

564
00:46:43,050 --> 00:46:48,190
それは確かに我々が得ていたワンセグ障害のバグだったようなので、それが見えます。

565
00:46:48,190 --> 00:46:51,540
残念なことに、それは我々がDを取得していることを教えてくれる

566
00:46:51,540 --> 00:46:54,090
>> 我々は戻ってコードを見て、そこに何が起こっていたかがわかります

567
00:46:54,090 --> 00:46:57,980
何であったかを把握する - それは我々がDを得たことを告げた理由

568
00:46:57,980 --> 00:47:03,690
ここで、これはprintfのあなたがDを得たことを言っていた、見てみましょう

569
00:47:03,690 --> 00:47:08,540
我々はリストを入力した場合、入力中リストを保持するように、それは、あなたのプログラムを介してダウン繰り返し処理を続け

570
00:47:08,540 --> 00:47:10,940
そうそれはあなたのプログラムの最初の数行をお見せしましょう​​。

571
00:47:10,940 --> 00:47:15,450
それはあなたに次の数行を表示し、次のチャンク、次のチャンクう。

572
00:47:15,450 --> 00:47:18,240
それがダウンして行くことにしようとしておこう。

573
00:47:18,240 --> 00:47:21,180
そして今、我々が買ってあげる "行番号16が範囲外です。"

574
00:47:21,180 --> 00:47:23,940
それだけで15行を持っているので。

575
00:47:23,940 --> 00:47:30,310
この時点までに取得し、あなたの疑問に思った場合は、 "私は何をしますか？"あなたは、helpコマンドを使用することができます。

576
00:47:30,310 --> 00:47:34,340
助けて、その後それをコマンドの名前を与える使用。

577
00:47:34,340 --> 00:47:36,460
そして、あなたは、GDBが私たちのもののすべて、この種を提供してください。

578
00:47:36,460 --> 00:47:43,870
これは、以前上場後または約10以上の行を一覧表示し、引数を指定しないと "と言う。

579
00:47:43,870 --> 00:47:47,920
リスト - 前に10行をリスト -  "

580
00:47:47,920 --> 00:47:52,960
だからリストマイナスを使ってみましょう。

581
00:47:52,960 --> 00:47:57,000
そして、それは10行が前の一覧表示、あなたはリストで少し周りを再生することができます。

582
00:47:57,000 --> 00:48:02,330
このリストは、リストを行うことができます - 、あなたもリスト8のように、番号を一覧与えることができる、

583
00:48:02,330 --> 00:48:07,500
そしてそれは、8行目の周りの10行をリストアップします。

584
00:48:07,500 --> 00:48:10,290
あなたがもし、他の単純なを持っているそして、あなたはここで何が起こっているのか見ることができます。

585
00:48:10,290 --> 00:48:13,980
あなたはCS50岩を入力すると、それは "あなたはAをもらう"プリントアウト

586
00:48:13,980 --> 00:48:16,530
それ以外の場合は、 "あなたはDを得る"プリントアウト

587
00:48:16,530 --> 00:48:23,770
がっかりの町。かしこまりました。はい？

588
00:48:23,770 --> 00:48:26,730
>> だから私は、引用符なしCS50岩をやってみました[ダニエル]

589
00:48:26,730 --> 00:48:29,290
それは "あなたはDを得る"と言う

590
00:48:29,290 --> 00:48:32,560
私はそれを動作させるために引用符を必要とし、その理由は何ですか？

591
00:48:32,560 --> 00:48:38,490
>>うん。これは別の楽しい小さなちらほらです - それは、時が判明 - 

592
00:48:38,490 --> 00:48:47,900
我々はそれを実行し、我々はCS50岩石に入力する場合は、プログラムを実行すると、

593
00:48:47,900 --> 00:48:50,800
同じように、ダニエルは、彼がやったと言っていました、そしてあなたは、Enterキーを押す

594
00:48:50,800 --> 00:48:52,870
それはまだ我々はDを得ると言う

595
00:48:52,870 --> 00:48:55,580
との質問ですが、これはなぜですか？

596
00:48:55,580 --> 00:49:02,120
そしてそれは私たちのターミナルとGDBの両方がこれらの2つの別個の引数として解析することが判明した。

597
00:49:02,120 --> 00:49:04,800
スペースがあるときに、それは次のように暗黙のだから

598
00:49:04,800 --> 00:49:08,730
最初の引数は終了し、次の引数が始まろうとしている。

599
00:49:08,730 --> 00:49:13,260
2にそれらを結合する方法、または申し訳ありませんが、一つの引数に、

600
00:49:13,260 --> 00:49:18,510
引用符を使用することです。

601
00:49:18,510 --> 00:49:29,560
だから今、私たちは、引用符でそれを入れて、再びそれを実行する場合、我々はAを取得

602
00:49:29,560 --> 00:49:38,780
だから要約すると、引用符なし、CS50と岩が2つの別個の引数として解析されていません。

603
00:49:38,780 --> 00:49:45,320
重引用符で、それは完全に一つの引数として解析だ。

604
00:49:45,320 --> 00:49:53,070
>> 私たちは、ブレークポイントでこれを見ることができます。

605
00:49:53,070 --> 00:49:54,920
これまでのところ、我々のプログラムを実行してきた、それが実行されている

606
00:49:54,920 --> 00:49:58,230
どちらかが故障ま​​たはヒット、エラーはsegまで

607
00:49:58,230 --> 00:50:05,930
まで、またはそれが終了している、すべてが完全に罰金となっています。

608
00:50:05,930 --> 00:50:08,360
時にはので、これは必然的に最も有用なものではありません

609
00:50:08,360 --> 00:50:11,840
あなたのプログラムでエラーが発生しているが、それはセグメンテーションフォルトを起こすわけではありません。

610
00:50:11,840 --> 00:50:16,950
それはあなたを停止するためのプログラムまたはそのような何かを起こしていない。

611
00:50:16,950 --> 00:50:20,730
あなたのプログラムが特定のポイントで一時停止するには、GDBを取得する方法

612
00:50:20,730 --> 00:50:23,260
ブレークポイントを設定することです。

613
00:50:23,260 --> 00:50:26,520
あなたは関数名でブレークポイントを設定することによってこれを行うことができます

614
00:50:26,520 --> 00:50:30,770
または、コードの特定の行にブレークポイントを設定することができます。

615
00:50:30,770 --> 00:50:34,450
覚えやすい、 - ので、私は、関数名でブレークポイントを設定したい

616
00:50:34,450 --> 00:50:37,700
そしてあなたが実際に行くと、少しの上のあなたのソースコードを変更した場合、

617
00:50:37,700 --> 00:50:42,020
その後、ブレークポイントは、実際にあなたのコード内の同じ場所にとどまります。

618
00:50:42,020 --> 00:50:44,760
一方、あなたは、行番号を使用していて、行番号が変更した場合

619
00:50:44,760 --> 00:50:51,740
あなたには、いくつかのコードを追加したり削除したりするので、次にあなたのブレークポイントはすべて完全に台無しにされています。

620
00:50:51,740 --> 00:50:58,590
私が行う最も一般的なものの一つは、main関数にブレークポイントを設定しています。

621
00:50:58,590 --> 00:51:05,300
多くの場合、私は、GDBを起動します、私は、Bメインを入力しますEnterキーを押すと、そのブレークポイントを設定します

622
00:51:05,300 --> 00:51:10,630
ただ "あなたが実行を開始するとすぐに、プログラムを一時停止"と言うメイン関数上

623
00:51:10,630 --> 00:51:17,960
私はと言うと、2つの引数としてCS50岩を私のプログラムを実行し、そのように、

624
00:51:17,960 --> 00:51:24,830
そして、Enterキーを押すと、main関数に到達すると、それは右の非常に最初の行で停止します

625
00:51:24,830 --> 00:51:30,620
それはstrcmp関数を評価する直前。

626
00:51:30,620 --> 00:51:34,940
>> 私が一時停止しているので、今私の周りいじくると何が起こっているのを見て起動することができます

627
00:51:34,940 --> 00:51:40,250
私のプログラムに渡され、異なる変数のすべてを持つ。

628
00:51:40,250 --> 00:51:43,670
ここで私はargcをプリントアウトして何が起こっているのか見ることができます。

629
00:51:43,670 --> 00:51:50,030
それはそれで3つの異なる値を持っているので、argcが3であることがわかります。

630
00:51:50,030 --> 00:51:54,060
それはプログラムの名前を持っている、それは第一引数と第二引数を持っている。

631
00:51:54,060 --> 00:52:09,330
我々は、argv [0]、argv [1]に、とargv [2]を見て、それらのうちを印刷することができます。

632
00:52:09,330 --> 00:52:12,030
このstrcmp関数呼び出しが失敗しようとしている理由はだから今も見ることができ、

633
00:52:12,030 --> 00:52:21,650
あなたはそれが2つの別々の引数にCS50や岩を分割しなかったことを見ているから。

634
00:52:21,650 --> 00:52:27,250
ブレークポイントにヒットしたらこの時点で、あなたはあなたのプログラムをステップ実行し続けることができます

635
00:52:27,250 --> 00:52:32,920
行ずつ、などもう一度プログラムを開始することに反対した。

636
00:52:32,920 --> 00:52:35,520
再度、ちょうどあなたのプログラムを起動したくない場合は、だから、ここから続けて

637
00:52:35,520 --> 00:52:41,970
最後に、プログラムを実行するには、continueコマンドを使用して、処理を継続できます。

638
00:52:41,970 --> 00:52:45,010
ちょうどそれは、ここで行ったような。

639
00:52:45,010 --> 00:52:54,880
私はプログラム、CS50岩を再起動した場合しかし、それは、再び私のブレークポイントをヒット

640
00:52:54,880 --> 00:52:59,670
私はプログラムの残りの部分を介してすべての道を行くしたくない場合は、今回は、

641
00:52:59,670 --> 00:53:08,040
私はまた、nと省略する次のコマンドを使用することができます。

642
00:53:08,040 --> 00:53:12,960
そして、これはプログラムを1行ずつステップ実行します。

643
00:53:12,960 --> 00:53:17,530
物事を実行するようにあなたは物事が更新されはじめると、、のような変数の変化を監視することができます。

644
00:53:17,530 --> 00:53:21,550
これはかなりいいです。

645
00:53:21,550 --> 00:53:26,570
他のクールなことは、何度も何度も何度も同じコマンドを繰り返すのではなく、ある

646
00:53:26,570 --> 00:53:30,670
あなたは、単にEnterを押せば - そうここにあなたが私が何かに入力していないを参照してください - 

647
00:53:30,670 --> 00:53:33,780
私は、単にEnterを押した場合、それは、前のコマンドを繰り返すことになります

648
00:53:33,780 --> 00:53:36,900
または私はちょうどインチ置くことを以前のGDBコマンド

649
00:53:36,900 --> 00:53:56,000
私は、Enterを押すと保つことができますし、それはラインで私のコード行をステップ実行しておこう。

650
00:53:56,000 --> 00:53:59,310
私は君たちがなく、他のバギープログラムをチェックアウトしに行くことを勧めます。

651
00:53:59,310 --> 00:54:01,330
我々は今日のセクションでそれらのすべてを介して取得する時間がありません。

652
00:54:01,330 --> 00:54:05,890
ソースコードがあるので、あなたは何が起こっているかの種類を見ることができます

653
00:54:05,890 --> 00:54:07,730
あなたが本当に困ったとき舞台裏で、

654
00:54:07,730 --> 00:54:11,940
しかしせめて、ちょうど、GDBを起動中の練習

655
00:54:11,940 --> 00:54:13,940
それがあなたがたの上に中断するまで、プログラムを実行している

656
00:54:13,940 --> 00:54:18,260
、クラッシュはしていたどのような機能を考え出す、バックトレースを取得

657
00:54:18,260 --> 00:54:24,450
何行には、いくつかの変数の値をプリントアウトしていた

658
00:54:24,450 --> 00:54:30,140
それは本当にあなたが今後に役立つのでちょうどので、それの感触を得る。

659
00:54:30,140 --> 00:54:36,340
この時点で、我々はあなたが終了するか、ただQを使用してください、GDB、外に終了するつもりです。

660
00:54:36,340 --> 00:54:40,460
あなたのプログラムがまだ実行中であり、そしてそれは、終了していない場合

661
00:54:40,460 --> 00:54:43,510
それはいつもあなたを聞いてきます、 "あなたは本当に終了してもよろしいですか？"

662
00:54:43,510 --> 00:54:48,770
あなただけはい打つことができます。

663
00:54:48,770 --> 00:54:55,250
>> 今、私たちは猫のプログラムである我々が持っている次の問題は、見ていくつもりです。

664
00:54:55,250 --> 00:54:59,880
あなたがリダイレクトやパイプの短いのを見れば、あなたは、トミーがこのプログラムを使用することがわかります

665
00:54:59,880 --> 00:55:07,540
それは基本的に画面にファイルのすべての情報を出力します。

666
00:55:07,540 --> 00:55:12,660
私は猫を実行するのであれば、これは、アプライアンスに実際には組み込みのプログラムであり、

667
00:55:12,660 --> 00:55:16,860
あなたがMacを持っている場合は、端​​末を開いた場合、あなたは、あまりにもあなたのMac上でこれを行うことができます。

668
00:55:16,860 --> 00:55:25,630
そして、我々 - 猫、のは、cp.cを言わせて、Enterを押してください。

669
00:55:25,630 --> 00:55:29,640
これが何をしたか、我々は少し上にスクロールし、我々はラインを実行した場所が表示される場合

670
00:55:29,640 --> 00:55:40,440
または我々は、catコマンドを実行したところ、それは文字通り、弊社の画面にcp.cの内容をプリントアウト。

671
00:55:40,440 --> 00:55:44,140
我々は再びそれを実行することができますし、一緒に複数のファイルに置くことができます。

672
00:55:44,140 --> 00:55:49,880
それで、あなたは猫のcp.cを行うことができます、そして、我々はまた、cat.cファイルを連結することができます

673
00:55:49,880 --> 00:55:53,250
それは我々が書き込みしようとしているプログラムであり、

674
00:55:53,250 --> 00:55:58,140
そしてそれは私たちの画面に背中合わせに両方のファイルを印刷します。

675
00:55:58,140 --> 00:56:05,490
私たちは少し上にスクロールした場合そこで、我々は見ている我々は、この猫cp.c、cat.cを実行したとき

676
00:56:05,490 --> 00:56:17,110
最初にそれはcpファイルをプリントアウトしてから、その下に、それは右のダウンここcat.cファイルをプリントアウト。

677
00:56:17,110 --> 00:56:19,650
私達はちょうど私達の足が濡れるためにこれを使用するつもりです。

678
00:56:19,650 --> 00:56:25,930
端末への簡単な印刷で遊んで、その様子を見てください。

679
00:56:25,930 --> 00:56:39,170
君たちが、gedit cat.cで開く場合は、Enterキーを打つ

680
00:56:39,170 --> 00:56:43,760
あなたは私たちが書き込みしようとしていることをプログラムを見ることができます。

681
00:56:43,760 --> 00:56:48,980
我々は、この素敵なボイラープレートを用意しましたので、我々はすべて、アウトを入力する時間を費やす必要はありません。

682
00:56:48,980 --> 00:56:52,310
また、渡された引数の数をチェック

683
00:56:52,310 --> 00:56:56,910
私たちは素敵な使用方法のメッセージを出力します。

684
00:56:56,910 --> 00:57:00,950
>> これは、私たちが話してきたように、再び、ものの一種です

685
00:57:00,950 --> 00:57:04,490
それはほとんど筋肉の記憶のようなものだ。

686
00:57:04,490 --> 00:57:07,190
だけのものと同じ種類のものをやり続けることを忘れないでください

687
00:57:07,190 --> 00:57:11,310
と常に有用なメッセージのいくつかの並べ替えをプリントアウト

688
00:57:11,310 --> 00:57:17,670
ので、人々はあなたのプログラムを実行する方法を知っている。

689
00:57:17,670 --> 00:57:21,630
猫と一緒に、それは非常に簡単です、我々はちょうど別の引数のすべてを通過しようとしている

690
00:57:21,630 --> 00:57:24,300
それが我々のプログラムに渡された、と我々は印刷するつもりだ

691
00:57:24,300 --> 00:57:29,950
一度に1画面にその内容を外に。

692
00:57:29,950 --> 00:57:35,670
画面にファイルをプリントアウトするために、我々は非常によく似た何かをやろうとしている

693
00:57:35,670 --> 00:57:38,120
我々はクイズの最後に行ったのと。

694
00:57:38,120 --> 00:57:45,350
プログラムを雇うクイズの終わりに、我々は、ファイルを開く必要がありました

695
00:57:45,350 --> 00:57:48,490
その後、我々はそれに印刷しなければならなかった。

696
00:57:48,490 --> 00:57:54,660
この場合において、我々はファイルを開くしようとしている、と我々は代わりにそれから読むつもりだ。

697
00:57:54,660 --> 00:58:00,630
その後、我々は、ファイルに出力するのではなく、しようとしている、我々は画面に出力しようとしている。

698
00:58:00,630 --> 00:58:05,830
ですから、すべてのprintfと前やった画面への印刷。

699
00:58:05,830 --> 00:58:08,290
だからそれはあまりにもクレイジーではありません。

700
00:58:08,290 --> 00:58:12,190
しかし、ファイルを読んでいると変なの一種です。

701
00:58:12,190 --> 00:58:17,300
我々は一度その少し通過するでしょう。

702
00:58:17,300 --> 00:58:20,560
あなた達は自分のクイズ、問題33でその最後の問題に戻ると

703
00:58:20,560 --> 00:58:27,280
我々がここでやろうとしていることを最初の行には、ファイルを開いて、私たちはそこに何をしたかと非常に似ています。

704
00:58:27,280 --> 00:58:36,370
ステラだから、我々はファイルを開いたときに、そのようなラインを見ていますか？

705
00:58:36,370 --> 00:58:47,510
[ステラ]キャピタル·FILE *と、ファイル -  >>さて。 >>  -  fopenのと同じです。 >>うん。

706
00:58:47,510 --> 00:58:55,980
このケースではどれですか？それはコメントであります。

707
00:58:55,980 --> 00:59:06,930
>>それはコメントでですか？ ARGV [i]とR？

708
00:59:06,930 --> 00:59:11,300
まさに>>。右に。だからステラは全く正しいです。

709
00:59:11,300 --> 00:59:13,720
これは線のように見えるものです。

710
00:59:13,720 --> 00:59:19,670
我々は、このFILE *に保管しますので、すべてのキャップをファイルストリーム変数を取得するつもりだ、

711
00:59:19,670 --> 00:59:25,720
ファイル、*、この変数の名前がファイルになります。

712
00:59:25,720 --> 00:59:32,250
我々は好きなようにそれを呼び出すことができます。我々は我々が望むものは何でも、それはfirst_file、またはfile_i呼び出すことができます。

713
00:59:32,250 --> 00:59:37,590
し、ファイルの名前は、このプログラムへのコマンドラインに渡された。

714
00:59:37,590 --> 00:59:44,450
だからそれは、argvに格納されているの[i、]、それから私達は、読み取りモードでこのファイルを開くしようとしている。

715
00:59:44,450 --> 00:59:48,100
今我々は、我々は常に行うには覚えなければならないことことだ何、ファイルを開いてしまったことを

716
00:59:48,100 --> 00:59:52,230
我々は、ファイルを開いてしまったときに？それを閉じます。

717
00:59:52,230 --> 00:59:57,220
ミッシーので、どのように我々は、ファイルをクローズするには？

718
00:59:57,220 --> 01:00:01,020
[ミッシー] fcloseを（ファイル）>> fcloseを（ファイル）。その通りです。

719
01:00:01,020 --> 01:00:05,340
グレート。オーケー。私たちは右ここにコメントを行うには、この見れば、

720
01:00:05,340 --> 01:00:11,940
それが "オープンのargv [i]は、標準出力にその内容を印刷します"と言う。

721
01:00:11,940 --> 01:00:15,460
>> 標準出力には、奇妙な名前です。 stdoutは言うちょうど私たちの方法です

722
01:00:15,460 --> 01:00:22,880
我々は、端末にそれを印刷したい、我々は、標準出力ストリームにそれを印刷したい。

723
01:00:22,880 --> 01:00:26,450
我々は、実際に右ここにこのコメントを取り除くことができます。

724
01:00:26,450 --> 01:00:36,480
私はそれをコピーして、それは我々がやったことだから、それを貼り付けるつもりです。

725
01:00:36,480 --> 01:00:41,290
この時点で、今、私たちは少しして、ファイルのビットを読まなければならない。

726
01:00:41,290 --> 01:00:46,300
我々は、ファイルを読み込むのはいくつかの方法について説明してきました。

727
01:00:46,300 --> 01:00:51,830
どれが今のところお気に入りですか？

728
01:00:51,830 --> 01:00:57,960
どの方法があなたが見ているか、ファイルを読むために、覚えていますか？

729
01:00:57,960 --> 01:01:04,870
[ダニエル] freadは？ >> freadは？だから、freadは一つです。ジミーは、任意の他の人を知っていますか？

730
01:01:04,870 --> 01:01:12,150
[ジミー]いいえ>>オーケー。いや。シャーロット？アレクサンダー？すべて他人？オーケー。

731
01:01:12,150 --> 01:01:20,740
だから、他のものは、我々は多くを使用しますので、1 fgetcはされています。

732
01:01:20,740 --> 01:01:26,410
また、fscanfはあります;君たちはここにパターンを参照してください？

733
01:01:26,410 --> 01:01:29,170
彼らはすべてのfで始まります。ファイルとすることを何でも。

734
01:01:29,170 --> 01:01:35,260
freadは、fgetcは、fscanfはあります。これらは、読み取り機能のすべてです。

735
01:01:35,260 --> 01:01:49,120
我々はfwriteを持って書くために、私たちの代わりにfgetcのは、fputcを持っています。

736
01:01:49,120 --> 01:01:58,250
我々はまた、我々はfprintfのクイズで見たように持っている。

737
01:01:58,250 --> 01:02:01,680
これは、ファイルからの読み込み伴う問題ですので、

738
01:02:01,680 --> 01:02:04,940
我々は、これら3つの関数のいずれかを使用するつもりです。

739
01:02:04,940 --> 01:02:10,890
ここでは、これらの機能をダウンを使用するつもりはない。

740
01:02:10,890 --> 01:02:14,880
これらの関数は、すべての標準I / Oライブラリで発見されています。

741
01:02:14,880 --> 01:02:17,510
ですから、このプログラムの先頭を見れば、

742
01:02:17,510 --> 01:02:24,110
あなたは我々がすでに標準I / Oライブラリのヘッダファイルが含まれていたことがわかります。

743
01:02:24,110 --> 01:02:27,120
、我々は我々が使用する1把握したい場合

744
01:02:27,120 --> 01:02:29,690
我々は常に、manページを開くことができます。

745
01:02:29,690 --> 01:02:34,350
だから我々は男がstdio入力することができます

746
01:02:34,350 --> 01:02:43,180
AとCのstdio入出力関数についてのすべてを読み

747
01:02:43,180 --> 01:02:49,870
そして、我々はすでに、ああ、見て確認することができます。それはfgetc関数に言及いる、それは、fputcに言及だ。

748
01:02:49,870 --> 01:02:57,220
だから、fgetcは、少しドリルダウンして、見て、言うことができます

749
01:02:57,220 --> 01:03:00,060
とそのmanページを見てみましょう。

750
01:03:00,060 --> 01:03:03,430
あなたはそれが他の機能の全体の束と一緒に行くことがわかります：

751
01:03:03,430 --> 01:03:12,640
fgetcは、fgetsの場合、getc、getchar関数は、ungetcを取得し、文字や文字列のその入力。

752
01:03:12,640 --> 01:03:19,180
だから、これは、我々は標準入力からファイルから文字や文字列で読む方法です。

753
01:03:19,180 --> 01:03:21,990
これは、ユーザーから本質的になる。

754
01:03:21,990 --> 01:03:24,780
そして、これは我々が実際のC言語でそれを行う方法です。

755
01:03:24,780 --> 01:03:30,850
だから、これはGetStringメソッドとgetchar関数を使用していない

756
01:03:30,850 --> 01:03:36,840
我々は、CS50ライブラリから使用されることを確認します。

757
01:03:36,840 --> 01:03:39,710
我々はいくつかの方法でこの問題をやろうとしている

758
01:03:39,710 --> 01:03:43,430
そのようにあなたはそれを行うための2つの異なる方法を見ることができます。

759
01:03:43,430 --> 01:03:48,490
ダニエルが述べたとfgetcは、両方のfread関数は、それを行うには良い方法です。

760
01:03:48,490 --> 01:03:53,790
ご覧のように私は、それが唯一持っているので、fgetc関数は、少し簡単だと思う、

761
01:03:53,790 --> 01:03:59,660
我々はから文字を読み取るしようとしている一つの引数は、FILE *

762
01:03:59,660 --> 01:04:02,740
その戻り値はintです。

763
01:04:02,740 --> 01:04:05,610
そして、これは右、少し混乱しています？

764
01:04:05,610 --> 01:04:11,450
>> 我々が文字を取得しているので、なぜこれはcharを戻しません？

765
01:04:11,450 --> 01:04:18,700
君たちは、これはchar型を返さない可能性がありますなぜ上の任意のアイデアがありますか？

766
01:04:18,700 --> 01:04:25,510
[ミッシーに答え、理解不能] >>うん。だから、ミッシーは全く正しいです。

767
01:04:25,510 --> 01:04:31,570
それがASCIIの場合、この整数は実際のcharにマップすることができる。

768
01:04:31,570 --> 01:04:33,520
ASCII文字でなければ、それは右である可能性があります。

769
01:04:33,520 --> 01:04:36,220
それは正確に何が起こっているかだ。

770
01:04:36,220 --> 01:04:39,190
我々は、単にそれがより多くのビットを持っているので、int型を使用しています。

771
01:04:39,190 --> 01:04:44,750
私たちのchar型は8ビットのみを有しており、当社の32ビットマシン上で1バイトという、それはchar型よりも大きいです。

772
01:04:44,750 --> 01:04:48,520
とintは宇宙のすべての4バイト分を持っています。

773
01:04:48,520 --> 01:04:50,940
そして、それは方法はfgetc関数が機能していることが判明し、

774
01:04:50,940 --> 01:04:53,940
我々は、このマニュアルページで当社の概要で少し下にスクロールした場合、

775
01:04:53,940 --> 01:05:05,000
すべての方法を下にスクロールします。それは、彼らがEOFと呼ばれるこの特殊な値を使用していることが判明した。

776
01:05:05,000 --> 01:05:09,640
それはfgetc関数の戻り値として特殊な定数です

777
01:05:09,640 --> 01:05:14,570
たびにファイルの終わりをぶつけたり、エラーが発生した場合。

778
01:05:14,570 --> 01:05:18,170
そして、それは、適切にEOFで、これらの比較を行うことが判明

779
01:05:18,170 --> 01:05:24,060
あなたはint型で持っている情報は、余分な量を持つようにしたい

780
01:05:24,060 --> 01:05:28,420
としてchar型の変数を使用するのではなく。

781
01:05:28,420 --> 01:05:32,130
fgetcは、効果的にファイルから文字を取得しているにもかかわらず、

782
01:05:32,130 --> 01:05:38,450
あなたはそれがあなたにint型の何かを返していることを覚えておきたい。

783
01:05:38,450 --> 01:05:41,360
それはそれはかなり使いやすいですが、言った。

784
01:05:41,360 --> 01:05:44,960
それは私達に文字を与えるために起こっている、ので、我々がしなければならないすべては、ファイルを求めておくです

785
01:05:44,960 --> 01:05:48,440
"、私に次の文字を与える、私に次の文字を与える、私に次の文字を与える"

786
01:05:48,440 --> 01:05:51,400
我々は、ファイルの終わりに到達するまで。

787
01:05:51,400 --> 01:05:54,730
そしてそれは、我々のファイルから1文字ずつ引っ張ってくることになり

788
01:05:54,730 --> 01:05:56,250
それから私達は私達がそれと同じようなことを行うことができます。

789
01:05:56,250 --> 01:06:00,160
我々はそれを保存することができます、我々はそれをプリントアウトすることができ、それを文字列に追加することができます。

790
01:06:00,160 --> 01:06:04,630
それのいずれかを実行します。

791
01:06:04,630 --> 01:06:09,600
>> バックアウトズームと私たちのcat.cプログラムに戻って、

792
01:06:09,600 --> 01:06:16,170
我々はfgetc使うつもりなら、

793
01:06:16,170 --> 01:06:21,710
どのように我々はこのコードの次の行に近づくのでしょうか？

794
01:06:21,710 --> 01:06:26,020
我々は、使用しようとしている -  freadはわずかに異なる何かを行います。

795
01:06:26,020 --> 01:06:32,600
そして今回は、我々だけで、一度に1つの文字を取得するにはfgetc関数を使用するつもりです。

796
01:06:32,600 --> 01:06:40,910
ファイル全体を処理するには、何を我々はしなければならないのでしょうか？

797
01:06:40,910 --> 01:06:44,030
そこにファイル内の何文字ですか？

798
01:06:44,030 --> 01:06:47,390
がたくさんあり​​ます。だから、あなたはおそらく1を取得したい

799
01:06:47,390 --> 01:06:49,860
し、別のを取得し、別のを取得し、別のものを得る。

800
01:06:49,860 --> 01:06:53,330
あなたは私たちがここで使用しなければならないことがあり、アルゴリズムのどのようなお考えですか？

801
01:06:53,330 --> 01:06:55,470
どのようなタイプの - ？ forループ[アレキサンダー] A？まさに>>。

802
01:06:55,470 --> 01:06:57,500
ループのいくつかのタイプ。

803
01:06:57,500 --> 01:07:03,380
forループはこのケースでは、実際に素晴らしいです。

804
01:07:03,380 --> 01:07:08,620
あなたは、ファイル全体をループしたいようにし、あなたが言ったように、それは、音

805
01:07:08,620 --> 01:07:11,820
一度に1文字を取得する。

806
01:07:11,820 --> 01:07:13,850
どのようになるか上の任意の提案ですか？

807
01:07:13,850 --> 01:07:22,090
[アレキサンダー、不明朗]

808
01:07:22,090 --> 01:07:30,050
>>さて、ちょうどあなたがやろうとしていることを英語で教えてください？ [アレキサンダー、不明朗]

809
01:07:30,050 --> 01:07:36,270
我々だけで、ファイル全体をループしようとしているようですので、この場合には、それが聞こえる。

810
01:07:36,270 --> 01:07:45,330
[アレキサンダー]それで、i <intのサイズは？の>>大きさ - ？

811
01:07:45,330 --> 01:07:49,290
私は右、ファイルのサイズを推測する？サイズ -  we'llはちょうどそれをこのように書きます。

812
01:07:49,290 --> 01:07:57,470
当分の間、ファイルのサイズは、i + +は。

813
01:07:57,470 --> 01:08:04,610
だから、それは方法は、あなたがこのfgetc関数を使用しないことが判明し、これは新しいです

814
01:08:04,610 --> 01:08:10,460
単にファイルのサイズを取得する簡単な方法はありませんということです

815
01:08:10,460 --> 01:08:16,979
あなたが前に見てきた構築物のこの "sizeof"演算タイプを持つ。

816
01:08:16,979 --> 01:08:20,910
我々はfgetc関数を使用する場合、我々はいくつかの種類を紹介しています

817
01:08:20,910 --> 01:08:29,069
だけではなく、基本的なカウンタを使用してこのforループに新しい、ファンキーな構文、

818
01:08:29,069 --> 01:08:33,920
文字単位で行くために、私たちは一度に1つの文字を引っ張っていくつもりですが、

819
01:08:33,920 --> 01:08:37,120
1文字ずつ、そして我々は終わりにしている知っている方法

820
01:08:37,120 --> 01:08:41,290
我々は特定の文字数をカウントしたときに、ではない

821
01:08:41,290 --> 01:08:49,939
しかし、我々は引き抜くときに文字は、ファイルの文字の特殊なエンドです。

822
01:08:49,939 --> 01:08:58,689
だから我々は、これを行うことができます - 私はこのCHを呼び出して、我々はそれを初期化するつもりだ

823
01:08:58,689 --> 01:09:08,050
ファイルのうち最初の文字を取得するための我々の最初の呼び出しで。

824
01:09:08,050 --> 01:09:14,979
右ここにこの部分ので、これには、ファイルの文字を取得する予定です

825
01:09:14,979 --> 01:09:20,840
と変数chに格納します。

826
01:09:20,840 --> 01:09:25,420
我々は、ファイルの終わりに到達するまで、我々はこれをやり続けるつもりだ、

827
01:09:25,420 --> 01:09:41,170
我々は特別なEOF文字に等しくない文字のためにテストすることによって行うことができる。

828
01:09:41,170 --> 01:09:48,750
代わりにCHをやって、次に+ +どちらただ、値をインクリメントしたい

829
01:09:48,750 --> 01:09:52,710
我々は、ファイルのうち、資本金、言う、読むそうだとすれば

830
01:09:52,710 --> 01:09:56,810
CH + +私たちにbを与えるだろうし、我々は、cとdを得ると思います。

831
01:09:56,810 --> 01:09:59,310
それは我々が望むものをはっきりとではありません。我々はここで何をしたい

832
01:09:59,310 --> 01:10:05,830
この最後のビットを私たちはファイルから次の文字を取得したいです。

833
01:10:05,830 --> 01:10:09,500
>> では、どのようにファイルから次の文字を得るかもしれない？

834
01:10:09,500 --> 01:10:13,470
どのように我々はファイルの最初の文字を取得するのですか？

835
01:10:13,470 --> 01:10:17,200
[学生] fgetfile？ >> fgetcは、または、申し訳ありませんが、あなたは完全に正しかった。

836
01:10:17,200 --> 01:10:20,470
私は右のそれをそこにスペルミス。うんそう。

837
01:10:20,470 --> 01:10:26,240
ここでは代わりにchを行う+ +

838
01:10:26,240 --> 01:10:29,560
私達はちょうど再びfgetc関数（ファイル）を呼び出すつもりだ

839
01:10:29,560 --> 01:10:39,180
と私たちの同じchの結果を変数に格納します。

840
01:10:39,180 --> 01:10:43,730
[学生の質問、不明朗]

841
01:10:43,730 --> 01:10:52,390
これらのFILE *の連中が特殊である場合>>です。

842
01:10:52,390 --> 01:10:59,070
彼らは仕事のやり方は、彼らです - あなたが最初に開いたとき - あなたが最初にfopenの呼び出しを行ったときに、

843
01:10:59,070 --> 01:11:04,260
FILE *とは、効果的に、ファイルの先頭へのポインタとして機能します。

844
01:11:04,260 --> 01:11:12,830
そして、あなたはfgetc関数を呼び出すたびに、そのファイルを介して1つの文字を移動します。

845
01:11:12,830 --> 01:11:23,280
だから、あなたがこれをコールするたびに、あなたは1つの文字でファイルポインタをインクリメントしている。

846
01:11:23,280 --> 01:11:26,210
そして、あなたは再びFGETCたとき、あなたはそれを別の文字を移動している

847
01:11:26,210 --> 01:11:28,910
と別の文字と他の文字と別の文字。

848
01:11:28,910 --> 01:11:32,030
[学生の質問、理解不能] >>そしてthat's  - ええ。

849
01:11:32,030 --> 01:11:34,810
それは、ボンネットの下にこの魔法のようなものだ。

850
01:11:34,810 --> 01:11:37,930
あなただけを介してインクリメント保つ。

851
01:11:37,930 --> 01:11:46,510
この時点では、実際に文字を対象に処理を行うことが可能になりました。

852
01:11:46,510 --> 01:11:52,150
それでは、どのように我々は今、スクリーンにこれをプリントアウトするのでしょうか？

853
01:11:52,150 --> 01:11:58,340
我々は、我々が前に使用したのと同じprintfのものを使用することができます。

854
01:11:58,340 --> 01:12:00,330
我々はすべての学期を使用してきたこと。

855
01:12:00,330 --> 01:12:05,450
我々は、printfを呼び出すことができます。

856
01:12:05,450 --> 01:12:21,300
そして我々はちょうどそのように文字を渡すことができます。

857
01:12:21,300 --> 01:12:27,430
それを行うための別の方法は、むしろprintfを使用していて、この形式の文字列を実行することよりも、ある

858
01:12:27,430 --> 01:12:29,490
我々はまた、他の関数のいずれかを使用することができます。

859
01:12:29,490 --> 01:12:40,090
我々は、画面に文字を出力fputcとを、使用することができます

860
01:12:40,090 --> 01:12:52,580
我々はfputcと見ている場合を除き、 - 私は少しズームアウトしてみましょう。

861
01:12:52,580 --> 01:12:56,430
それは我々はfgetc関数を使用して読み出すことが文字を取り込んでいる私たちは、素敵なものを見る

862
01:12:56,430 --> 01:13:05,100
しかし、我々はそれに印刷するためのストリームを与える必要があります。

863
01:13:05,100 --> 01:13:11,850
我々はまた、標準出力に直接配置しますputchar関数を使用することができます。

864
01:13:11,850 --> 01:13:16,070
だから我々は、印刷のために使用できるさまざまなオプションの全体の束があります。

865
01:13:16,070 --> 01:13:19,580
彼らは、標準I / Oライブラリ内のすべてだ。

866
01:13:19,580 --> 01:13:25,150
印刷したいときはいつでも - だからprintf関数は、デフォルトで、出力ストリームに専用の標準出力されます

867
01:13:25,150 --> 01:13:27,910
そのstdoutはどちらです。

868
01:13:27,910 --> 01:13:41,300
だから我々はちょうどここでstdout、この魔法の値のようなものとしてそれを参照することができます。

869
01:13:41,300 --> 01:13:48,410
おっと。外にセミコロンを置きます。

870
01:13:48,410 --> 01:13:52,790
>> これは、ここで新たな、ファンキーな情報がたくさんある。

871
01:13:52,790 --> 01:13:58,600
これの多くは、これがコードであるという意味で、非常に慣用句です

872
01:13:58,600 --> 01:14:05,700
それは、読みやすいように読んできれいだという理由だけでこのように書かれている。

873
01:14:05,700 --> 01:14:11,520
それを行うには多くの異なる方法では、使用できるさまざまな機能がありますが、

874
01:14:11,520 --> 01:14:14,680
しかし、我々は単に何度も何度も、これらと同じパターンに従う傾向がある。

875
01:14:14,680 --> 01:14:20,180
あなたが何度も何度も出てくるこのようなコードが表示される場合はそう驚くことはありません。

876
01:14:20,180 --> 01:14:25,690
かしこまりました。この時点で、我々はその日のために分割する必要があります。

877
01:14:25,690 --> 01:14:31,300
来てくれてありがとう。あなたがオンラインなら見てくれてありがとう。そして、我々は来週お会いしましょう​​。

878
01:14:31,300 --> 01:14:33,890
[CS50.TV]