1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVIDマラン：すべての権利、戻って歓迎します。

3
00:00:12,580 --> 00:00:13,290
これはCS50です。

4
00:00:13,290 --> 00:00:15,130
これは、週7の始まりです。

5
00:00:15,130 --> 00:00:18,890
だから、それは久しぶりですので、私は、我々がしようと思いました
ここで我々の旋風ツアーに参加

6
00:00:18,890 --> 00:00:20,760
中断し、どこ私たちが今行っている。

7
00:00:20,760 --> 00:00:23,310
>> この事はここにあるかもしれませんので、
最初はいくつかの不安を引き起こした。

8
00:00:23,310 --> 00:00:27,680
しかし、うまくいけば、あなたがし始めている
これはここに示したものに順応 - 

9
00:00:27,680 --> 00:00:32,670
ポインタを表す星であり、
もっと普通の言葉でちょうど何？

10
00:00:32,670 --> 00:00:33,400
だから、アドレスです。

11
00:00:33,400 --> 00:00:35,490
>> だから、のアドレスだ
メモリ内の何か。

12
00:00:35,490 --> 00:00:38,260
そして、我々は戻って皮層に開始
数週間前に、物事が好き

13
00:00:38,260 --> 00:00:41,800
GetStringメソッドと他のこのような機能
すべてのこの時間は戻ってきた

14
00:00:41,800 --> 00:00:46,010
のようなメモリ内のもののアドレス、
の最初の文字のアドレス

15
00:00:46,010 --> 00:00:46,990
いくつかのシーケンス。

16
00:00:46,990 --> 00:00:50,360
>> だから、我々はまた、valgrindのを導入している
あなたは、この問題のために使用することから始めましょう

17
00:00:50,360 --> 00:00:53,380
特に次のために、セット
問題は、同様に設定します。

18
00:00:53,380 --> 00:00:54,980
とvalgrindのは、私たちのために何をしますか？

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
これは、メモリリークをチェックし、それ
また、メモリの乱用をチェック。

21
00:01:01,020 --> 00:01:05,890
>> それは、いくつかの確率で検出できる場合
あなたのコードがメモリに触れるために起こっている

22
00:01:05,890 --> 00:01:07,100
それは単にべきではないこと。

23
00:01:07,100 --> 00:01:10,410
だから漏れは必ずしも、あなたではない場合
いくつかの境界を越えて行く

24
00:01:10,410 --> 00:01:14,730
配列、あなたが実際にvalgrindの実行
とその動作をしながら誘導

25
00:01:14,730 --> 00:01:17,870
valgrindのは、あなたのプログラムの中で実行されている
それの内部で実行すると、買ってあげる

26
00:01:17,870 --> 00:01:21,460
このようなメッセージ -  "無効な書き込みの
のカップルを思い出し、サイズ4、 "

27
00:01:21,460 --> 00:01:25,880
数週間前、私が誤っていたことを意味
遠すぎる1 int型に好き

28
00:01:25,880 --> 00:01:27,250
配列の境界を越えて。

29
00:01:27,250 --> 00:01:30,790
そしてサイズ4は、ここでサイズを意味
その特定のint型の。

30
00:01:30,790 --> 00:01:35,260
>> だから実際には安心を取ること
valgrindのの出力、その形式、

31
00:01:35,260 --> 00:01:36,170
ただ凶悪です。

32
00:01:36,170 --> 00:01:40,180
それは混乱を見抜くのは本当に難しい
興味深い情報のために。

33
00:01:40,180 --> 00:01:42,910
それでは、私たちがここでやったことはただの抜粋です
より多くのカップルのいくつか

34
00:01:42,910 --> 00:01:43,850
興味深いライン。

35
00:01:43,850 --> 00:01:46,760
しかし、valgrindの年代のその80％を実現
出力はのビットになるだろう

36
00:01:46,760 --> 00:01:47,650
気晴らし。

37
00:01:47,650 --> 00:01:52,820
>> ただ、これらのようなパターンを探して - 
右の無効、無効、40バイトを読み取る

38
00:01:52,820 --> 00:01:56,690
とブロックのいくつか数は間違いなくある
そのようなキーワードは、失った。

39
00:01:56,690 --> 00:02:01,920
そして、何あなたがうまくいけば表示されますと、一部である
どの機能のトレースの種類

40
00:02:01,920 --> 00:02:03,340
間違いが入っ実際

41
00:02:03,340 --> 00:02:07,195
この場合、ここでの何行目で
私のコードは明らかに誤りでしたか？

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> だっmemory.cのと呼ばれるファイルに26
私たちが遊んでいた例

44
00:02:14,130 --> 00:02:14,890
一度。

45
00:02:14,890 --> 00:02:16,460
だから、malloc関数ではおそらくありません。

46
00:02:16,460 --> 00:02:18,630
それは代わりに私のコードはおそらくあった。

47
00:02:18,630 --> 00:02:20,910
だから我々は再びこれを見るだろう
と再び前に長い。

48
00:02:20,910 --> 00:02:24,080
>> これで思いついたので、scanf関数、
これまでのフォームのカップル。

49
00:02:24,080 --> 00:02:26,410
我々は簡単にsscanf関数を見ました。

50
00:02:26,410 --> 00:02:28,330
それは何かの数だった
あなたの中に飛び込んだ

51
00:02:28,330 --> 00:02:29,535
クイズの準備。

52
00:02:29,535 --> 00:02:33,130
とscanfは実際に何であるかCS50
ライブラリは、下に使用しています

53
00:02:33,130 --> 00:02:36,560
順番にかなりの時間のためのフード
ユーザーからの入力を取得します。

54
00:02:36,560 --> 00:02:40,420
>> 例えば、私はCS50に上に移動する場合
アプライアンスここで、私が開くう

55
00:02:40,420 --> 00:02:45,315
scanf関数-0.cと呼ばれています例えば今日
そしてそれは超簡単です。

56
00:02:45,315 --> 00:02:46,590
それはちょうど、数行のコードです。

57
00:02:46,590 --> 00:02:50,880
しかし、それは示して実際にどの場合、getInt
今回のすべてを取り組んできました。

58
00:02:50,880 --> 00:02:54,710
>> ここで、このプログラムでは、16行目で
、私はint型を宣言することに気づく。

59
00:02:54,710 --> 00:02:57,270
無ポインタ、魔法の何がそう
そこには、単にint型。

60
00:02:57,270 --> 00:03:00,330
次に17行目では、私が促す
数のユーザーが、お願いします。

61
00:03:00,330 --> 00:03:02,930
その後、後半18で、私はここでscanf関数を使用しています。

62
00:03:02,930 --> 00:03:06,910
そして私は、一種のprintfのように、指定された
私は引用符を期待していることに

63
00:03:06,910 --> 00:03:08,110
パーセント私を引用終わり。

64
00:03:08,110 --> 00:03:10,920
>> パーセントのIだから、もちろん、
int型を表す。

65
00:03:10,920 --> 00:03:14,580
しかし、何番目に気付く
scanf関数の引数です。

66
00:03:14,580 --> 00:03:17,350
どのように秒を説明しますか
カンマの後の引数？

67
00:03:17,350 --> 00:03:19,450
それは何ですか？

68
00:03:19,450 --> 00:03:20,670
>> それはxのアドレスです。

69
00:03:20,670 --> 00:03:25,490
により提供するため、だから、これは便利です
Xのアドレスをscanfのか、何をしない

70
00:03:25,490 --> 00:03:29,560
行うために、その機能に力を与えるのか？

71
00:03:29,560 --> 00:03:33,010
だけではなく、そこに行くだけでなく、何をする？

72
00:03:33,010 --> 00:03:34,060
>> それに変更を加える。

73
00:03:34,060 --> 00:03:38,080
あなたがそこに行くことができますので、ソートのだ
メモリ内の場所への地図のよう。

74
00:03:38,080 --> 00:03:41,900
そして限り、あなたが提供するようにscanf関数、または
このようなマップを持つ任意の関数は、その

75
00:03:41,900 --> 00:03:45,840
この関数は、そこに行く、とすることができますだけでなく、
値を見て、それはまたできます

76
00:03:45,840 --> 00:03:49,670
場合に便利です、その値を変更
scanf関数の人生の目的は、ある

77
00:03:49,670 --> 00:03:53,060
具体的には、ユーザからの入力をスキャンする
キーボードから。

78
00:03:53,060 --> 00:03:57,830
fは同じように、フォーマットされた意味
printfは、fはフォーマットさを示し

79
00:03:57,830 --> 00:03:58,930
印刷したい文字列を指定します。

80
00:03:58,930 --> 00:04:04,430
>> 要するにだから、このライン18は単に言う、
ユーザーのからint型を読み取ろう

81
00:04:04,430 --> 00:04:10,420
キーボードとのでは、xの中にそれを保存
xが住んでたまたま何アドレス。

82
00:04:10,420 --> 00:04:14,860
そして最後に、19行目がちょうど言う、
この場合はint型のおかげで、。

83
00:04:14,860 --> 00:04:15,940
>> だから私は先に行くと、これを作ってみましょう。

84
00:04:15,940 --> 00:04:18,570
だからscanf関数0を加える。

85
00:04:18,570 --> 00:04:20,130
私が先に行くと、ズームインしましょう

86
00:04:20,130 --> 00:04:22,960
私は一緒に行くと、これを実行することになるでしょう
ドットはscanf関数は0をスラッシュ。

87
00:04:22,960 --> 00:04:24,020
数は、してください？

88
00:04:24,020 --> 00:04:24,720
50。

89
00:04:24,720 --> 00:04:25,730
50ありがとうございました。

90
00:04:25,730 --> 00:04:27,270
だから、それはかなり簡単です。

91
00:04:27,270 --> 00:04:28,160
>> 今では何をしていないですか？

92
00:04:28,160 --> 00:04:29,940
これは、全体の束をやっていない
エラーチェックの。

93
00:04:29,940 --> 00:04:33,000
例えば、私が協力しない場合、
と私は、番号を入力しませんが、

94
00:04:33,000 --> 00:04:37,860
代わりに私は、 "こんにちは"のような何かを書く
それはただ奇妙なのようなものだ。

95
00:04:37,860 --> 00:04:41,130
物事のそして1 CS50
ライブラリには、いくつかのために私たちのために行ってきた

96
00:04:41,130 --> 00:04:43,440
時間はその何回でもプロンプトが再表示され
と再プロンプト。

97
00:04:43,440 --> 00:04:49,320
>> リトライフレーズリコールは、cs50.cにあった
それはその場合、getIntで理由です

98
00:04:49,320 --> 00:04:51,670
CS50ライブラリは実際に全体です
長い行の束、私たちがしているので、

99
00:04:51,670 --> 00:04:53,190
このような愚かなものをチェックする。

100
00:04:53,190 --> 00:04:55,730
ユーザーは与えていない
私たちは、実際には、int型？

101
00:04:55,730 --> 00:04:57,910
彼または彼女は私たちに何かを与えるでした
アルファベットのような？

102
00:04:57,910 --> 00:05:01,410
もしそうであれば、我々は検出したい
そのと彼らに叫ぶ。

103
00:05:01,410 --> 00:05:03,915
>> しかし、物事はもっと面白く
この次の例である。

104
00:05:03,915 --> 00:05:09,840
私はscanf関数-1.Cに行けば、何が一つです
根本的に変更されるもの

105
00:05:09,840 --> 00:05:11,135
この次の例では？

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
私は、もちろん、char *型を使用しています
intの代わりに。

108
00:05:16,010 --> 00:05:19,210
>> だから、これは、char *のため、興味深いです
リコールは、本当にただです

109
00:05:19,210 --> 00:05:20,190
文字列と同じもの。

110
00:05:20,190 --> 00:05:23,840
だから、それは多分、これがスーパーですように感じる
GetStringメソッドの簡単な実装。

111
00:05:23,840 --> 00:05:26,010
しかし、私はレイヤーを後ろむいた
CS50ライブラリの、私はそう

112
00:05:26,010 --> 00:05:27,550
今、このchar *型を呼び出す。

113
00:05:27,550 --> 00:05:30,070
それでは見てみましょうどこで、どこでもあれば、
我々は間違って行く。

114
00:05:30,070 --> 00:05:30,840
>> 17行目 - 

115
00:05:30,840 --> 00:05:33,950
私は再び、私に何かを記入してください、と言う
この場合、文字列を指定します。

116
00:05:33,950 --> 00:05:37,940
そして、次の行に、私は、scanf関数を呼び出す
再度、それをフォーマットコードを与える

117
00:05:37,940 --> 00:05:39,310
しかし今回は、パーセントの。

118
00:05:39,310 --> 00:05:41,900
そして今回、私がよ
それにバッファを与える。

119
00:05:41,900 --> 00:05:43,550
>> 今、私が使用していないよ、気付く
アンパサンド。

120
00:05:43,550 --> 00:05:47,120
しかし、なぜ、それはここでOKでしょうか？

121
00:05:47,120 --> 00:05:49,760
既にバッファは何ですので？

122
00:05:49,760 --> 00:05:50,770
既にポインタだ。

123
00:05:50,770 --> 00:05:51,650
それはすでにアドレスです。

124
00:05:51,650 --> 00:05:54,510
>> としましょう​​、この言葉が私を聞かせて、 "混同"だ
だけのために、例えば、それの呼び出し

125
00:05:54,510 --> 00:05:55,050
シンプル。

126
00:05:55,050 --> 00:05:58,250
しかし、私はそれがであるためバッファと呼んでいる
一般的には、プログラミングでは、次のものがあれば

127
00:05:58,250 --> 00:06:02,130
メモリのチャンク、文字列本当に
ただ、あなたはそれバッファ呼ぶ場合がございます。

128
00:06:02,130 --> 00:06:04,460
これは、情報を格納する場所である。

129
00:06:04,460 --> 00:06:07,400
>> ときは、YouTubeのようなものに似て
彼らは、いわば、バッファリングしていること

130
00:06:07,400 --> 00:06:10,270
ちょうどそれからビットをダウンロードであることを意味し
インターネットとに格納

131
00:06:10,270 --> 00:06:14,160
ローカル配列なので、メモリの局所チャンク
後でなしでそれを見ることができる

132
00:06:14,160 --> 00:06:16,830
それはスキップまたはに掛かっ
あなたの再生中。

133
00:06:16,830 --> 00:06:20,930
>> だから問題は、しかしここにあり
私はscanf関数を言っているので、期待してい

134
00:06:20,930 --> 00:06:22,320
ユーザから文字列。

135
00:06:22,320 --> 00:06:24,410
ここのアドレスです
メモリのチャンク。

136
00:06:24,410 --> 00:06:26,180
そこに、その文字列を入れて。

137
00:06:26,180 --> 00:06:31,230
なぜ、それが与えるバインドされ
私たちは、しかし、トラブル？

138
00:06:31,230 --> 00:06:33,490
>> 何それ？

139
00:06:33,490 --> 00:06:35,510
私は、アクセスさせて頂いております
そのメモリの一部？

140
00:06:35,510 --> 00:06:36,250
あなたが知っている、私は知らない。

141
00:06:36,250 --> 00:06:39,210
バッファが初期化されているので、
何か？

142
00:06:39,210 --> 00:06:39,820
いまいち。

143
00:06:39,820 --> 00:06:43,090
そしてそれは我々が求めてきたものだ
そのゴミの価値、

144
00:06:43,090 --> 00:06:44,040
正式な言葉ではない。

145
00:06:44,040 --> 00:06:49,200
それはちょうど私たちが何のビット見当がつかないことを意味し
その4バイトの内部です

146
00:06:49,200 --> 00:06:51,240
私はバッファとして割り当てている。

147
00:06:51,240 --> 00:06:52,450
>> 私は、malloc関数と呼ばれていない。

148
00:06:52,450 --> 00:06:53,940
私は間違いなくGetStringメソッドと呼ばれていませんでした。

149
00:06:53,940 --> 00:06:56,380
だから実際に何であるか知っている人
バッファの内側？

150
00:06:56,380 --> 00:07:00,550
そして、まだscanf関数を伝えることは盲目的に、そこに行く
そして、ユーザが入力したものは何でも置く。

151
00:07:00,550 --> 00:07:04,460
>> だから、発生する可能性があるもの
我々のコードでは我々はそれを実行した場合？

152
00:07:04,460 --> 00:07:05,700
おそらくセグメンテーション。

153
00:07:05,700 --> 00:07:07,970
そうでないかもしれないが、おそらくセグメンテーション。

154
00:07:07,970 --> 00:07:10,620
と私は言ってないかもしれないので、時々
あなたは時々、やる

155
00:07:10,620 --> 00:07:11,380
あなたは、セグメンテーション違反を得ることはありません。

156
00:07:11,380 --> 00:07:14,280
時には、あなただけの幸運を得るが、
それにもかかわらずになるだろう

157
00:07:14,280 --> 00:07:15,340
私たちのプログラムのバグ。

158
00:07:15,340 --> 00:07:17,060
>> だから私は先に行くと、これをコンパイルしてみましょう。

159
00:07:17,060 --> 00:07:18,280
私は古い学校のようにするつもりです。

160
00:07:18,280 --> 00:07:23,825
だから打ち鳴らすダッシュ0、scanf関数-1、
scanf関数-1.C、入力します。

161
00:07:23,825 --> 00:07:24,720
おっと、あまりにも古い学校。

162
00:07:24,720 --> 00:07:26,550
見てみましょう。

163
00:07:26,550 --> 00:07:28,440
私はどこに行ったのですか？

164
00:07:28,440 --> 00:07:29,700
ああ、char *のバッファ。

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
ああ、ありがとうございました - 

167
00:07:35,130 --> 00:07:36,930
[OK]を、保存する - 

168
00:07:36,930 --> 00:07:37,690
非常に古い学校。

169
00:07:37,690 --> 00:07:38,900
すべての権利、それは久しぶりです。

170
00:07:38,900 --> 00:07:41,720
>> だから、僕は後にファイルを保存した
その一時を作る

171
00:07:41,720 --> 00:07:42,700
一瞬前に変更してください。

172
00:07:42,700 --> 00:07:46,090
そして今、私はそれをコンパイルしている
手動Clangのと。

173
00:07:46,090 --> 00:07:49,500
そして今、私は先に行くつもりです
と入力し、scanf関数-1を実行します。

174
00:07:49,500 --> 00:07:50,290
文字列ください。

175
00:07:50,290 --> 00:07:51,600
私は、を入力します "こんにちは。"

176
00:07:51,600 --> 00:07:54,070
>> そして今、ここではprintfは、率直に言って、どこだ
少し面倒ですができます。

177
00:07:54,070 --> 00:07:56,020
それは実際にはないだろう
このケースではセグメンテーション。

178
00:07:56,020 --> 00:07:59,860
printfは少し特殊ですので、
それは、一般的に使用されるので、スーパーだ

179
00:07:59,860 --> 00:08:03,570
本質的にはprintfをやっている
私たちは好意と実現

180
00:08:03,570 --> 00:08:04,830
それが有効なポインタではありません。

181
00:08:04,830 --> 00:08:09,080
私はただ印刷する際に自分自身それを見てみましょう
外であってもヌル括弧内

182
00:08:09,080 --> 00:08:13,340
それは必ずしもではないけれども何
我々自身が期待した。

183
00:08:13,340 --> 00:08:16,940
>> だから、私たちは本当に簡単に誘導することはできません
これでセグメンテーションが、明らかにこの

184
00:08:16,940 --> 00:08:18,600
私が望んでいた動作ではありません。

185
00:08:18,600 --> 00:08:19,800
だから、簡単な解決策は何ですか？

186
00:08:19,800 --> 00:08:25,650
まあ、scanf関数-2で、私はあることを提案してみましょう
の代わりに実際には割り当て

187
00:08:25,650 --> 00:08:30,100
char *型では、私は少し賢くなりましょうについて
これは、と私はバッファを割り当ててみましょう

188
00:08:30,100 --> 00:08:32,940
16文字のシーケンスとして。

189
00:08:32,940 --> 00:08:34,200
>> だから私はいくつかの方法でこれを行うことができます。

190
00:08:34,200 --> 00:08:35,610
私は絶対に、mallocを使用することができます。

191
00:08:35,610 --> 00:08:38,980
しかし、私は週2に戻ることができたとき
私はただの全体の束を必要としてい

192
00:08:38,980 --> 00:08:39,620
文字。

193
00:08:39,620 --> 00:08:40,860
それはちょうど配列だ。

194
00:08:40,860 --> 00:08:44,870
だから私は、代わりにバッファを再定義してみましょう
16文字の配列であることが。

195
00:08:44,870 --> 00:08:47,340
>> そして今、私はバッファを渡すとき - 

196
00:08:47,340 --> 00:08:49,940
そしてこれは我々がなかったものです
週2での話 - 

197
00:08:49,940 --> 00:08:53,730
しかし、あなたは配列として扱うことができます
それはアドレスですが。

198
00:08:53,730 --> 00:08:56,390
我々は見てきたように、技術的に、彼らがしている
少し異なる。

199
00:08:56,390 --> 00:09:01,290
あなたはそれを渡した場合でも、scanf関数は気にしません
なぜなら配列の名前、何

200
00:09:01,290 --> 00:09:05,030
打ち鳴らすには、私たちのために尽くします本質的に
としてその配列の名前を扱う

201
00:09:05,030 --> 00:09:08,280
16バイトの塊のアドレス。

202
00:09:08,280 --> 00:09:09,550
>> だから、これは良いです。

203
00:09:09,550 --> 00:09:12,110
これは今、私はうまくいけばできることを意味します
次の手順を実行します。

204
00:09:12,110 --> 00:09:16,800
私は一瞬ズームアウトしましょう​​と
OKコンパイルscanf関数-2を作るか。

205
00:09:16,800 --> 00:09:19,390
今私はスラッシュscanf関数-2を持ってやってみましょう。

206
00:09:19,390 --> 00:09:22,430
文字列ください。 "こんにちは。"そしてそれ
この時間を動作するように見えた。

207
00:09:22,430 --> 00:09:26,020
>> 誰かがシナリオを提案することができます
たそれはまだ動作しない可能性があります？

208
00:09:26,020 --> 00:09:28,550
うん？

209
00:09:28,550 --> 00:09:30,640
16文字より長いもの。

210
00:09:30,640 --> 00:09:32,020
そして実際に、私たちはすることができます
もう少し正確に。

211
00:09:32,020 --> 00:09:36,540
その後長い何か15文字、
本当に我々は心に留めておく必要があるため

212
00:09:36,540 --> 00:09:39,920
私たちは、そのバックスラッシュゼロを必要とすることを
暗黙的に文字列の末尾に、

213
00:09:39,920 --> 00:09:42,950
それはさておきscanf関数は、一般意志である
私たちのための世話をする。

214
00:09:42,950 --> 00:09:46,210
>> だから私のような何かをやらせる - 

215
00:09:46,210 --> 00:09:48,040
時には我々は単にすることができます
そのようにそれを残す。

216
00:09:48,040 --> 00:09:50,630
[OK]を、ので、我々は今、誘発された
当社のセグメンテーションフォールト。

217
00:09:50,630 --> 00:09:51,000
なぜですか？

218
00:09:51,000 --> 00:09:54,940
私は15以上に入力しているので
私たちが実際にしたので文字、および

219
00:09:54,940 --> 00:09:58,280
私は実際にそれに触れた記憶
必要はありません。

220
00:09:58,280 --> 00:10:00,180
>> だからここに解決策は本当に何ですか？

221
00:10:00,180 --> 00:10:02,210
まあ、我々は長い文字列を必要とする場合はどうでしょうか。

222
00:10:02,210 --> 00:10:03,960
さて、私たちは多分それ32バイトにする。

223
00:10:03,960 --> 00:10:05,160
まあ、それは十分な長さではない場合はどうでしょうか。

224
00:10:05,160 --> 00:10:06,040
どのように約64バイト？

225
00:10:06,040 --> 00:10:07,080
何が十分な長さではありません、もし？

226
00:10:07,080 --> 00:10:09,640
約128または200バイトの方法は？

227
00:10:09,640 --> 00:10:12,660
何が本当にここでのソリューションです
私たちがわからない場合は一般的なケースで、

228
00:10:12,660 --> 00:10:14,460
ユーザが入力する何が起こっている進める？

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> それは、ただお尻に大きな痛みのようなものだ
正直に言うと、これは、ある理由

231
00:10:23,050 --> 00:10:29,050
CS50ライブラリは、数十ラインを持って
総称して実装するコード

232
00:10:29,050 --> 00:10:32,390
我々はしないような方法で文字列をGetStringメソッド
事前に知っているか

233
00:10:32,390 --> 00:10:33,430
ユーザーが入力しようとしている。

234
00:10:33,430 --> 00:10:37,370
具体的には、場合は、振り返る
cs50.c二週間前から、次のように表示されます

235
00:10:37,370 --> 00:10:40,480
そのGetStringメソッドは、実際にはありません
このようにscanf関数を使用しない。

236
00:10:40,480 --> 00:10:43,720
むしろ、それは1つの文字を読む
一度。

237
00:10:43,720 --> 00:10:46,010
>> そのため約1素晴らしい事
一つの文字を読むことは私たちができることです

238
00:10:46,010 --> 00:10:48,490
常に自分自身を保証
少なくとも一つのcharを持っている。

239
00:10:48,490 --> 00:10:51,740
私はただのcharを宣言してから、取ることができます
ただこれらの本当に赤ちゃんのステップ

240
00:10:51,740 --> 00:10:54,380
での1つの文字を読んで
キーボードからの時間。

241
00:10:54,380 --> 00:10:58,240
そして、何をGetStringメソッドが表示されます
ん、それはうち実行されるたびです

242
00:10:58,240 --> 00:11:02,280
、16バイトのメモリを言い、それ用途
malloc関数、またはいとこのそのへ

243
00:11:02,280 --> 00:11:06,810
古いコピーを、より多くのメモリを割り当てる
新しい、次にクロールにメモリ

244
00:11:06,810 --> 00:11:09,900
に沿って、1文字ずつ取得する
そのからそれを実行したとき

245
00:11:09,900 --> 00:11:13,370
メモリの塊、それを捨て、グラブ
メモリの大きな塊、古いコピー

246
00:11:13,370 --> 00:11:14,750
新しい、そして繰り返しに。

247
00:11:14,750 --> 00:11:18,480
そしてそれは実際に本当に痛みです
のように単純なものを実装する

248
00:11:18,480 --> 00:11:19,710
ユーザからの入力を取得。

249
00:11:19,710 --> 00:11:21,090
>> だからscanf関数を使用することができます。

250
00:11:21,090 --> 00:11:22,430
あなたは他の同様の機能を使用することができます。

251
00:11:22,430 --> 00:11:25,420
や教科書の多くは、オンライン
例は行うが、それらはすべてしている

252
00:11:25,420 --> 00:11:27,210
このような問題に対して脆弱。

253
00:11:27,210 --> 00:11:29,550
そして最終的に、セグメンテーション違反なっ
一種の迷惑である。

254
00:11:29,550 --> 00:11:30,680
これは、ユーザのためによくないです。

255
00:11:30,680 --> 00:11:33,560
>> しかし、最悪の場合には、どういう
それは根本的に自分を置く

256
00:11:33,560 --> 00:11:37,160
リスクのあるコード？

257
00:11:37,160 --> 00:11:39,250
攻撃のいくつかの種類、潜在的に。

258
00:11:39,250 --> 00:11:41,680
我々はそのような攻撃について話しました - 
スタックがあふれ。

259
00:11:41,680 --> 00:11:44,660
しかし、一般的には、あなたがに許可している場合
我々が行ったように、バッファをオーバーフローさせ、

260
00:11:44,660 --> 00:11:48,070
ただ書いた数週間前、
スタック上の "こんにちは"よりも、あなた

261
00:11:48,070 --> 00:11:52,330
確かに、潜在的に、引き継ぐことができます
コンピュータ、または少なくともそのデータを取得

262
00:11:52,330 --> 00:11:53,510
あなたに属していません。

263
00:11:53,510 --> 00:11:55,970
>> 我々は持っている理由だから要するに、これは
それらの補助輪。

264
00:11:55,970 --> 00:11:59,090
しかし、今、我々は、それらを脱いで始める
我々のプログラムは、もはや必要ないので、

265
00:11:59,090 --> 00:12:00,610
ユーザーから必ずしも、入力。

266
00:12:00,610 --> 00:12:03,960
しかし、問題の場合には、6に設定
あなたの入力が巨大から来る

267
00:12:03,960 --> 00:12:07,520
150一部と辞書ファイル
奇数千の言葉。

268
00:12:07,520 --> 00:12:10,330
>> だから、心配する必要はありません
ユーザの任意の入力。

269
00:12:10,330 --> 00:12:13,720
私たちはあなたにいくつかの仮定を与える
そのファイルについて。

270
00:12:13,720 --> 00:12:20,340
ポインタやscanf関数の質問
または一般的に、ユーザーの入力？

271
00:12:20,340 --> 00:12:24,450
>> すべての権利なので、1で、その後簡単に見
二週間前から話題を引きずる。

272
00:12:24,450 --> 00:12:28,590
そして、それは、構造体のこの概念であった。

273
00:12:28,590 --> 00:12:34,180
ていないこと - のこの概念
何だった構造体、？

274
00:12:34,180 --> 00:12:35,430
構造体は、私たちのために何をした？

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> 定義 - 

277
00:12:39,860 --> 00:12:41,710
申し訳ありません？

278
00:12:41,710 --> 00:12:42,820
変数の型を定義します。

279
00:12:42,820 --> 00:12:44,410
だから一種の。

280
00:12:44,410 --> 00:12:46,180
私たちは、実際には2つのトピックを組み合わせています。

281
00:12:46,180 --> 00:12:49,510
typedefのとそう、私たちができることを思い出してください
同じように、私たち自身の型を宣言する

282
00:12:49,510 --> 00:12:51,500
char *型の文字列のような同義語、。

283
00:12:51,500 --> 00:12:56,200
しかし、typedefのと構造体を使用して、我々はできる
本当に私たちの独自のデータ構造を作成します。

284
00:12:56,200 --> 00:12:59,600
>> 例えば、私はgeditのに戻った場合
ここでちょっと、私は先に行く

285
00:12:59,600 --> 00:13:08,230
と私は保存​​させ、のような何かを
このように、structs.c、のは言わせて

286
00:13:08,230 --> 00:13:10,840
一時的に、私はちょうど行くよ
先に行くと、含まれるように

287
00:13:10,840 --> 00:13:14,360
standardio.h、int型メイン無効。

288
00:13:14,360 --> 00:13:18,960
そしてここでは、私が欲しいと仮定
格納するプログラムを書くこと

289
00:13:18,960 --> 00:13:21,840
複数から複数の生徒
例えば家、。

290
00:13:21,840 --> 00:13:24,430
だからregistrarialようなものだ
ある種のデータベース。

291
00:13:24,430 --> 00:13:29,550
>> 私は名前の一人の学生を必要とするのであれば、I
、char *の名のように何かをするかもしれません

292
00:13:29,550 --> 00:13:31,570
そして私のような何かをやる - 

293
00:13:31,570 --> 00:13:34,410
実際に、のはCS50ライブラリを使用してみましょう
ちょっとこのようにし

294
00:13:34,410 --> 00:13:38,380
少し単純なので、借りることができます
コー​​ドの行数十もの。

295
00:13:38,380 --> 00:13:39,340
そして、ちょうどそれをシンプルに保つてみましょう。

296
00:13:39,340 --> 00:13:42,610
我々は、それが文字列でおこう
そして今GetStringメソッド。

297
00:13:42,610 --> 00:13:47,420
>> だから私は、私が名前を保存したことを今主張
いくつかの学生、との家の

298
00:13:47,420 --> 00:13:50,240
単に変数を使用して、いくつかの学生、
我々がやったように、週1インチ

299
00:13:50,240 --> 00:13:52,370
しかし、私は今、支援したいとし
複数の学生。

300
00:13:52,370 --> 00:13:58,460
すべての権利なので、私の本能がやっています
文字列NAME2、GetStringメソッドは、文字列を取得します

301
00:13:58,460 --> 00:14:01,370
house2は、GetStringメソッドを取得します。

302
00:14:01,370 --> 00:14:05,850
そして、我々の第三の学生、
NAME3 GetStringメソッドを実行してみましょう。

303
00:14:05,850 --> 00:14:09,170
>> すべての権利は​​、これがうまくいけば印象的です
愚かなの一種として、あなた、

304
00:14:09,170 --> 00:14:11,580
このプロセスは実際になることがないため
終わろうとして、そしてそれだけに起こっている

305
00:14:11,580 --> 00:14:13,130
私のコードは悪く見えるように
と悪化し、悪化。

306
00:14:13,130 --> 00:14:14,810
しかし、我々は週2であまりにこれを解決しました。

307
00:14:14,810 --> 00:14:19,450
当社の比較的きれいな解決策は何だった
我々は、複数の変数を持っていたとき

308
00:14:19,450 --> 00:14:23,580
同じデータすべて関連しているタイプが、
私たちは、この凶悪な混乱をしたくなかった

309
00:14:23,580 --> 00:14:26,870
同じような名前の変数？

310
00:14:26,870 --> 00:14:30,060
我々は、代わりに何をした？

311
00:14:30,060 --> 00:14:31,260
>> だから私は、私はいくつかの場所を聞いたと思います。

312
00:14:31,260 --> 00:14:32,590
私たちは、配列を持っていた。

313
00:14:32,590 --> 00:14:37,110
あなたは、複数のインスタンスをしたい場合
何か、なぜ我々はこのすべてをきれいにしないでください

314
00:14:37,110 --> 00:14:39,540
アップとちょうど私を与える、と言う
配列には、名前と呼ばれる？

315
00:14:39,540 --> 00:14:41,640
>> そして今では、ハードコード3みましょう。

316
00:14:41,640 --> 00:14:44,450
そして、私に別の配列を与える
家と呼ばれ、のために私を聞かせて

317
00:14:44,450 --> 00:14:45,800
今ハードコード3。

318
00:14:45,800 --> 00:14:49,220
そして、私は大規模なクリーンアップしました
私が作成した混乱。

319
00:14:49,220 --> 00:14:52,400
さて、私はまだハード3コーディングされ、それでもき
3動的にから来ることができました

320
00:14:52,400 --> 00:14:54,350
ユーザー、またはARGVなど。

321
00:14:54,350 --> 00:14:55,720
だから、これはすでにクリーナーです。

322
00:14:55,720 --> 00:15:00,100
>> しかし、これについては迷惑なんだと、ということです
今、名前は何とかであっても

323
00:15:00,100 --> 00:15:02,280
基本的にリンク
学生の家 - 

324
00:15:02,280 --> 00:15:04,720
それは本当に私が学生の
表現したい - 

325
00:15:04,720 --> 00:15:08,080
私は今、平行な二つの配列を持っている
彼らがしているという意味で、

326
00:15:08,080 --> 00:15:13,930
同じサイズ、名前ブラケット0
住宅ブラケット0〜おそらくマップ

327
00:15:13,930 --> 00:15:16,600
と名前ブラケット1マップ
家屋へのブラケット1。

328
00:15:16,600 --> 00:15:19,280
で言い換えれば、その生徒は生活
その家、そのほかの生徒

329
00:15:19,280 --> 00:15:20,530
そのほかの家に住んでいる。

330
00:15:20,530 --> 00:15:23,720
しかし、確かに、これは可能性があります
さらにきれいに行わ。

331
00:15:23,720 --> 00:15:24,990
>> まあ、それは実際には、することができます。

332
00:15:24,990 --> 00:15:28,730
そして、私が先に行くと開いてみましょう
structs.hまで、あなたはよ

333
00:15:28,730 --> 00:15:31,130
ここでこのアイデアを参照してください。

334
00:15:31,130 --> 00:15:34,905
私はあなたのように、typedefを使ってきたことに注意してください
前に宣言する瞬間に触れた私たちの

335
00:15:34,905 --> 00:15:35,570
独自のデータ型。

336
00:15:35,570 --> 00:15:39,660
しかし、私はまた、この他のキーワードを使用しています
私に新しいを与えると呼ばれる構造体

337
00:15:39,660 --> 00:15:40,790
データ構造。

338
00:15:40,790 --> 00:15:43,980
>> そして、私は主張する、このデータ構造が起こっている
内二つを持っている

339
00:15:43,980 --> 00:15:47,060
それ -  nameという文字列、および
家と呼ばれる文字列。

340
00:15:47,060 --> 00:15:49,820
私は与えるつもりだと名前
このデータ構造は、起こっている

341
00:15:49,820 --> 00:15:51,005
学生と呼ばれていました。

342
00:15:51,005 --> 00:15:54,030
私はそれを私が欲しいものを呼び出すことができ、
しかし、これは意味的に作る

343
00:15:54,030 --> 00:15:55,810
私の心の中で私には意味。

344
00:15:55,810 --> 00:15:59,160
>> だから今、私はより良いバージョンを開く場合
プログラムを私が書き始めた

345
00:15:59,160 --> 00:16:00,390
そこに、私が先頭にスクロールしてみましょう。

346
00:16:00,390 --> 00:16:03,190
コー​​ドのいくつかの詳細行があり
ここでは、しかし、私を集中させ

347
00:16:03,190 --> 00:16:04,160
1上の瞬間。

348
00:16:04,160 --> 00:16:07,790
私は定数と呼ばれる学生を宣言した
とハード今の3コード化。

349
00:16:07,790 --> 00:16:11,110
しかし、今、どのようにきれいに気づく
私のコードは、取得を開始します。

350
00:16:11,110 --> 00:16:15,030
>> 22行目では、私は宣言します
学生の配列。

351
00:16:15,030 --> 00:16:18,760
と学生が明らかであることに気付く
今データ型。

352
00:16:18,760 --> 00:16:23,360
このファイルの先頭にあるため、予告
私はそのヘッダファイルを用意しました

353
00:16:23,360 --> 00:16:24,820
私はちょっと前にプルアップされていること。

354
00:16:24,820 --> 00:16:28,820
そして、そのヘッダファイルは非常に単純に持っていた
学生のこの定義。

355
00:16:28,820 --> 00:16:32,470
>> だから今、私は自分のカスタムデータを作成しました
型は、C年の作者

356
00:16:32,470 --> 00:16:33,890
前に、事前に考えていなかった。

357
00:16:33,890 --> 00:16:34,570
しかし、問題ありません。

358
00:16:34,570 --> 00:16:35,870
私はそれを自分自身を作ることができる。

359
00:16:35,870 --> 00:16:39,050
だから、これは、学生と呼ばれる配列である
そのメンバーの各

360
00:16:39,050 --> 00:16:41,100
学生構造です。

361
00:16:41,100 --> 00:16:44,270
そして、私はそれらの3が欲しい
配列である。

362
00:16:44,270 --> 00:16:46,030
>> そして今、何が残りを行い
このプログラムのでしょうか？

363
00:16:46,030 --> 00:16:47,550
私は少し任意の何かを必要としていた。

364
00:16:47,550 --> 00:16:51,450
だからオンラインで24以降、
私は、0〜3の反復。

365
00:16:51,450 --> 00:16:54,000
私はその後をユーザーに尋ねる
学生の名前。

366
00:16:54,000 --> 00:16:56,110
そして私は前と同じようにGetStringメソッドを使用します。

367
00:16:56,110 --> 00:16:59,410
それから私は、生徒の家を求める
と私は以前のようにGetStringメソッドを使用しています。

368
00:16:59,410 --> 00:17:01,780
>> しかし予告 - ちょっと新しい
構文のピース - 

369
00:17:01,780 --> 00:17:07,010
私は、i番目の生徒へのインデックスまだすることができ、
しかし、私は、特定のデータをどのように入手できますか

370
00:17:07,010 --> 00:17:08,354
構造体の内部のフィールド？

371
00:17:08,354 --> 00:17:11,770
まあ、明らかに何
新しい構文の一部？

372
00:17:11,770 --> 00:17:13,339
それはちょうどドット演算子です。

373
00:17:13,339 --> 00:17:14,510
>> 私たちは本当にこの前に見ていませんでした。

374
00:17:14,510 --> 00:17:17,819
あなたがした場合は、PSET 5でそれを見てきました
ビットマップファイルをすでに潜っ。

375
00:17:17,819 --> 00:17:22,372
しかし、ドットはちょうどこの内部の意味
構造体または複数のフィールドには、ドットを与える

376
00:17:22,372 --> 00:17:24,510
名前、または私にドットの家を与える。

377
00:17:24,510 --> 00:17:28,690
構造体の中に入ることを意味する
そしてそれらの特定のフィールドを取得します。

378
00:17:28,690 --> 00:17:30,200
>> このプログラムの他の部分は何をしますか？

379
00:17:30,200 --> 00:17:31,190
それは、そのセクシーなすべてではない。

380
00:17:31,190 --> 00:17:34,640
私は再び0から3までの反復ことに注意してください、
と私は単純に英語を作成

381
00:17:34,640 --> 00:17:40,500
そうとそうのようなフレーズは、このようになっていると
からドット名前を渡すような家、

382
00:17:40,500 --> 00:17:43,320
i番目の生徒とその
家だけでなく、。

383
00:17:43,320 --> 00:17:47,560
>> そして最後に、今、私たちは、取得することから始めましょう
今我々がしていることをこのことについて肛門、

384
00:17:47,560 --> 00:17:49,580
何mallocと精通
他の機能がされている

385
00:17:49,580 --> 00:17:50,570
すべてのこの時間をやって。

386
00:17:50,570 --> 00:17:54,220
なぜ、私は両方の名前を解放しなければならないの
にもかかわらず、私は、家、

387
00:17:54,220 --> 00:17:56,960
malloc関数を呼び出していませんでした？

388
00:17:56,960 --> 00:17:58,020
>> GetStringメソッドはなかった。

389
00:17:58,020 --> 00:18:00,930
そして、それはのために汚い小さな秘密だった
数週間が、GetStringメソッド持って

390
00:18:00,930 --> 00:18:03,530
上のすべてのメモリをリークされて
これまですべての学期を配置。

391
00:18:03,530 --> 00:18:05,990
とvalgrandはついに意志
私たちにこれを明らかにする。

392
00:18:05,990 --> 00:18:10,730
>> しかし、私は知っているので、それは大したことではありません
私は単に名前を解放することができます

393
00:18:10,730 --> 00:18:15,750
と家、しかし技術的には、へ
スーパー、超安全で、私は次のようになります

394
00:18:15,750 --> 00:18:17,890
ここにいくつかのエラーチェックを行う。

395
00:18:17,890 --> 00:18:19,040
あなたの本能はあなたに何を言っている？

396
00:18:19,040 --> 00:18:22,480
私は何をチェックすべきである
私が何か解放する前に

397
00:18:22,480 --> 00:18:25,470
文字列、char *の別名？

398
00:18:25,470 --> 00:18:33,460
>> 私は本当に学生かどうかをチェックすべきである
ブラケットiのドット名にはありません

399
00:18:33,460 --> 00:18:34,840
等しいヌル。

400
00:18:34,840 --> 00:18:40,400
それは先に、自由に行きOKだろう
そのポインタ、および同じまたは他の

401
00:18:40,400 --> 00:18:41,160
同様に1。

402
00:18:41,160 --> 00:18:46,860
学生ブラケット私ドット家がされていない場合
ヌルに等しい、これは今では保護されます

403
00:18:46,860 --> 00:18:52,520
でコーナーケースに対して
GetStringメソッドがnullのようなものを返します。

404
00:18:52,520 --> 00:18:57,310
そして、私たちはprintfの意志、一瞬前に見た
ただ言ってここで私たちを守る

405
00:18:57,310 --> 00:18:58,990
奇妙に見​​えるとしているヌル、。

406
00:18:58,990 --> 00:19:02,340
しかし、少なくともそれは、セグメンテーション違反はありません
我々は見てきたように。

407
00:19:02,340 --> 00:19:05,990
>> まあ、私はここでもう一つのことを行うことができます。
構造-0愚かなプログラムの一種である

408
00:19:05,990 --> 00:19:09,700
私はその後、このすべてのデータを入力し、ため
プログラムが終了したら、それは失われている。

409
00:19:09,700 --> 00:19:10,940
しかし、私が先に行くと、これを行うことができます。

410
00:19:10,940 --> 00:19:12,830
私はターミナルを作ってみましょう
少し大きめの窓。

411
00:19:12,830 --> 00:19:17,000
その、私は構造体A-1を作ろう
この新バージョンである。

412
00:19:17,000 --> 00:19:18,520
>> 私は少しにズームインします。

413
00:19:18,520 --> 00:19:21,620
そして今、私はドットを実行してみましょう
構造体A-1を大幅に削減。

414
00:19:21,620 --> 00:19:22,590
学生の名前 - 

415
00:19:22,590 --> 00:19:31,500
デビッド·メイザー、ロブカークランドをしてみましょう、
ローレンLeverettをしてみましょう。

416
00:19:31,500 --> 00:19:33,650
面白いのは、今では予告です - 

417
00:19:33,650 --> 00:19:35,540
そして私はこのことを知っているので、
私はプログラムを書いた - 

418
00:19:35,540 --> 00:19:38,930
ファイルには、私の現在の今そこ
students.csvというディレクトリ。

419
00:19:38,930 --> 00:19:40,420
皆さんの中には見たことがあるかもしれませ
現実の世界では、これらの。

420
00:19:40,420 --> 00:19:42,980
>> CSVファイルとは何ですか？

421
00:19:42,980 --> 00:19:44,170
カンマ区切り値。

422
00:19:44,170 --> 00:19:46,670
それは貧乏人のようなソートのだ
Excelファイルのバージョン。

423
00:19:46,670 --> 00:19:50,580
これは、行と列のテーブルだ
あなたは、Excelなどのプログラムで開くことができます

424
00:19:50,580 --> 00:19:51,800
Mac上または番号。

425
00:19:51,800 --> 00:19:55,180
>> そして、私はgeditの上でここにこのファイルを開くと、
通知 - と数字は存在しません。

426
00:19:55,180 --> 00:19:57,360
それはちょうど言ってgeditのだ
私行番号。

427
00:19:57,360 --> 00:19:59,740
これの最初の行に注目してください
ファイルには、ダビデとマザーです。

428
00:19:59,740 --> 00:20:01,450
次の行はロブコンマカークランドです。

429
00:20:01,450 --> 00:20:04,170
と三行目はローレンです
コンマLeverett。

430
00:20:04,170 --> 00:20:05,480
>> だから私は何を作成している？

431
00:20:05,480 --> 00:20:09,580
私は今、Cプログラムを書いたこと
効果的にスプレッドシートを生成することができます

432
00:20:09,580 --> 00:20:11,840
で開くことができる
エクセルのようなプログラム。

433
00:20:11,840 --> 00:20:15,520
すべてではないという説得力のあるデータセットが、
あなたは、はるかに大きな塊を持っている場合

434
00:20:15,520 --> 00:20:18,440
あなたが実際にしたいデータ
操作し、グラフにすると

435
00:20:18,440 --> 00:20:21,260
同じように、これは、おそらく一つです
そのデータを作成する方法。

436
00:20:21,260 --> 00:20:25,370
また、CSVを、実際にはスーパー共通です
単純なデータを格納するための - 

437
00:20:25,370 --> 00:20:28,940
ヤフー·ファイナンス、例えば、あなたが得る場合
彼らのいわゆる経由株価

438
00:20:28,940 --> 00:20:33,180
API、することができます無料サービス
現在のアップに最新の株式を取得

439
00:20:33,180 --> 00:20:35,650
企業のための引用文は、それら
後ろにデータを与える

440
00:20:35,650 --> 00:20:37,800
スーパーシンプルなCSV形式。

441
00:20:37,800 --> 00:20:39,380
>> だから我々はどのようにそれをやったの？

442
00:20:39,380 --> 00:20:42,530
さて、このプログラムのほとんどのに気づく
ほぼ同じ。

443
00:20:42,530 --> 00:20:46,870
しかし、ここでダウンして気づくのではなく、プリント
ライン35上の学生のうち、

444
00:20:46,870 --> 00:20:51,040
以降は、私が保存していると主張している
ディスクへの学生なので、ファイルを保存する。

445
00:20:51,040 --> 00:20:53,630
>> だから私はFILE *を宣言しているに気づく - 

446
00:20:53,630 --> 00:20:57,260
今、これはCの異常の一種である
何らかの理由で、ファイルは、すべて大文字です。

447
00:20:57,260 --> 00:21:00,690
これは、ほとんどの他のデータ型のようではありません
Cでしかし、これは、組み込みの

448
00:21:00,690 --> 00:21:02,320
データ·タイプ、ファイル*。

449
00:21:02,320 --> 00:21:05,900
そして、私は、ファイルへのポインタを宣言しています
あなたはそれについて考えることができる方法です。

450
00:21:05,900 --> 00:21:08,070
>> fopenの開いているファイルを指します。

451
00:21:08,070 --> 00:21:09,470
あなたはどのようなファイルが開くようにしたいですか？

452
00:21:09,470 --> 00:21:12,620
私は意志、そのファイルを開きたい
任意students.csvを呼び出します。

453
00:21:12,620 --> 00:21:14,480
私は私が望むことは何を呼び出すことができます。

454
00:21:14,480 --> 00:21:15,200
>> そして推測を取る。

455
00:21:15,200 --> 00:21:18,960
第二引数は何を行います
fopenのおそらく意味ですか？

456
00:21:18,960 --> 00:21:21,480
右、書き込みのためにW、可能性
読み取りのためにRである。

457
00:21:21,480 --> 00:21:24,120
あなたの場合、追記用あり
行を追加したいとしない

458
00:21:24,120 --> 00:21:25,200
全部を上書きします。

459
00:21:25,200 --> 00:21:28,005
>> しかし、私はちょうどこのファイルを作成したい
かつて、私は引用引用終わりWを使用します。

460
00:21:28,005 --> 00:21:31,880
と私は読んでたからその唯一知っている
ドキュメント、またはマニュアルページを参照してください。

461
00:21:31,880 --> 00:21:35,100
ファイルがnullでない場合 - つまり、
何も間違っていない場合 - 

462
00:21:35,100 --> 00:21:37,820
私はイテレートう
0〜3の学生。

463
00:21:37,820 --> 00:21:40,410
>> そして今、何かが気づく
ほんの少し異なる

464
00:21:40,410 --> 00:21:42,110
ここでは約41行。

465
00:21:42,110 --> 00:21:42,960
これは、printfのではありません。

466
00:21:42,960 --> 00:21:46,530
これは、printfのファイルに対してfprintfのだ。

467
00:21:46,530 --> 00:21:47,790
だから、ファイルに書き込むために起こっている。

468
00:21:47,790 --> 00:21:48,860
どのファイル？

469
00:21:48,860 --> 00:21:53,630
そのポインタは、指定した1
最初の引数として。

470
00:21:53,630 --> 00:21:55,940
>> 次に我々は、フォーマット文字列を指定します。

471
00:21:55,940 --> 00:21:59,660
その後、我々は我々が何をしたい文字列を指定
最初パーセントsのプラグイン、および

472
00:21:59,660 --> 00:22:04,320
その後、別の変数または
第二パーセントの。

473
00:22:04,320 --> 00:22:06,760
その後、我々はfcloseを使ってファイルを閉じます。

474
00:22:06,760 --> 00:22:09,380
でも、私は以前のようにメモリを解放するよりも、
私はに戻って追加する必要があります

475
00:22:09,380 --> 00:22:10,540
ヌルのためのいくつかのチェック。

476
00:22:10,540 --> 00:22:12,090
>> そして、それはそれだ。

477
00:22:12,090 --> 00:22:16,960
FOPENは、関数fprintf、fcloseを私に与える
テキストフ​​ァイルを作成する機能。

478
00:22:16,960 --> 00:22:19,640
さて、あなたは、問題セット5で表示されます
画像が含まれている、あなたが使うことになるでしょう

479
00:22:19,640 --> 00:22:20,990
バイナリファイルの代わりに。

480
00:22:20,990 --> 00:22:24,200
しかし、根本的に、考え方は同じですが、
もかかわらず、あなたはよ機能

481
00:22:24,200 --> 00:22:28,710
少し異なっていますを参照してください。

482
00:22:28,710 --> 00:22:32,580
>> 駆け足はそうですが、あなたが得る
ファイルのすべての余りに精通I/O--

483
00:22:32,580 --> 00:22:34,960
入力と出力 -  PSET 5と。

484
00:22:34,960 --> 00:22:38,607
とについてのご質問
ここで最初の基本？

485
00:22:38,607 --> 00:22:39,857
うん？

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> 何がnull値を解放しようとした場合？

488
00:22:43,710 --> 00:22:48,880
自由は得ていない限り、私は信じている
もう少しユーザーフレンドリーな、次のことができます

489
00:22:48,880 --> 00:22:49,890
潜在的にセグメンテーション。

490
00:22:49,890 --> 00:22:54,160
私はしないので、それをnullを渡すと悪いです
自由に信じて、あなたのためにチェックするように気になる

491
00:22:54,160 --> 00:22:57,330
それは、潜在的に無駄になるので
それがために自分自身を行うための時間の

492
00:22:57,330 --> 00:22:59,022
世界中の人々。

493
00:22:59,022 --> 00:23:00,590
良い質問です、しかし。

494
00:23:00,590 --> 00:23:04,300
>> そうすべての権利は​​、この種の取得
私たちの興味深いトピックに。

495
00:23:04,300 --> 00:23:07,010
問題セットのテーマ
5人がフォレンジックです。

496
00:23:07,010 --> 00:23:08,420
少なくともそれは部分
問題セット。

497
00:23:08,420 --> 00:23:12,030
フォレンジックは一般を指し
可能性や情報の回復

498
00:23:12,030 --> 00:23:14,110
削除されていない可能性があります
意図的に。

499
00:23:14,110 --> 00:23:18,680
そして、私はあなたに迅速を与えるだろうと思って
本当に何が起こっているの味

500
00:23:18,680 --> 00:23:21,230
下に、この時間
お使いのコンピュータのボンネット。

501
00:23:21,230 --> 00:23:23,960
>> 例えば、あなたがあなたの内側に持っている場合
ラップトップまたはデスクトップコンピュータ

502
00:23:23,960 --> 00:23:28,040
ハードドライブは、それはどちらか、機械的だ
実際にスピンデバイス - 

503
00:23:28,040 --> 00:23:31,650
プラッタと呼ばれる円形のものがあり
非常にどのように見えるかI

504
00:23:31,650 --> 00:23:34,540
ただけれども、ここで画面上に持っていた
これはますます古い学校です。

505
00:23:34,540 --> 00:23:37,370
これは、3つの半インチである
ハードドライブ。

506
00:23:37,370 --> 00:23:40,070
三半インチの指し
あなたがそれをインストールするものの持つ

507
00:23:40,070 --> 00:23:40,890
コンピュータである。

508
00:23:40,890 --> 00:23:44,890
>> 今、あなたのラップトップで君たちの多くは
ソリッドステートドライブ、又はSSDを有する

509
00:23:44,890 --> 00:23:46,260
どの可動部品を持たない。

510
00:23:46,260 --> 00:23:49,170
彼らは、RAMのようなより少ないようにしている
これらの機械装置。

511
00:23:49,170 --> 00:23:51,450
しかし、アイデアは、まだ同じです
確かに彼らが関係するように

512
00:23:51,450 --> 00:23:52,790
問題は、5を設定します。

513
00:23:52,790 --> 00:23:57,400
>> そして、あなたは、ハードドライブ今考えてみれば
サークルであることを表し、その

514
00:23:57,400 --> 00:23:58,930
私はここで、このように描画します。

515
00:23:58,930 --> 00:24:02,290
あなたのコンピュータ上のファイルを作成するときは、
それはSSDだかどうか、または内

516
00:24:02,290 --> 00:24:06,610
この場合は、古い学校のハードディスクドライブ、
そのファイルには、複数のビットを含む。

517
00:24:06,610 --> 00:24:10,510
それはこの0と1だと言うてみましょう
0と1の全体の束。

518
00:24:10,510 --> 00:24:11,660
だから、これは私の全体のハードドライブです。

519
00:24:11,660 --> 00:24:13,225
これは明らかにかなり大きなファイルです。

520
00:24:13,225 --> 00:24:18,080
そしてそれはその時点で0と1を使用しています
物理プラッタの一部。

521
00:24:18,080 --> 00:24:19,750
>> まあ、その物理的な部分は何ですか？

522
00:24:19,750 --> 00:24:25,310
まあ、それは、ハードドライブ上にあることが判明
このタイプの少なくともあり

523
00:24:25,310 --> 00:24:27,340
これらの小さな小さな磁性粒子。

524
00:24:27,340 --> 00:24:32,630
そして、彼らは本質的に北とを持っている
それらへの南極ので、もしあなた

525
00:24:32,630 --> 00:24:35,710
これらの磁性粒子のいずれかを回す
この方法では、あなたはそれがだと言うかもしれません

526
00:24:35,710 --> 00:24:36,720
1を表す。

527
00:24:36,720 --> 00:24:39,340
そしてそれは逆さまに南だ場合
北、あなたはそれがだと言うかもしれません

528
00:24:39,340 --> 00:24:40,390
0を表す。

529
00:24:40,390 --> 00:24:43,660
>> だから、現実の物理的な世界で、そのう
あなたは、で何かを表現することができる方法

530
00:24:43,660 --> 00:24:45,670
バイナリ0の状態と1。

531
00:24:45,670 --> 00:24:46,720
だから、すべてのファイルがあるのです。

532
00:24:46,720 --> 00:24:49,300
磁気の全体の束があります
彼らのこのようかの粒子

533
00:24:49,300 --> 00:24:51,920
この方法で、パターンを作成
0と1の。

534
00:24:51,920 --> 00:24:56,760
>> しかし、それは、あなたがファイルを保存するときに判明
一部の情報が別々に保存されます。

535
00:24:56,760 --> 00:25:00,000
だから、これは、小さなテーブルである
ディレクトリには、いわば。

536
00:25:00,000 --> 00:25:05,810
と私は、この列名を呼ぶと、よ
私は、このコラムの場所を呼ぶことにします。

537
00:25:05,810 --> 00:25:08,850
>> と私は考えます、と言うつもりです
これは私の履歴書です。

538
00:25:08,850 --> 00:25:14,050
私resume.docはに格納され
場所、123を言ってみましょう。

539
00:25:14,050 --> 00:25:15,390
私はいつも、その番号のために行く。

540
00:25:15,390 --> 00:25:18,810
しかし、単に好きなことを言えば十分
RAMには、ハードドライブを取ることができます

541
00:25:18,810 --> 00:25:22,350
それはギガバイトまたは200ギガバイトだ
またはテラバイト、とのことができます

542
00:25:22,350 --> 00:25:23,750
数バイトのすべて。

543
00:25:23,750 --> 00:25:26,480
あなたは、8ビットのすべてのチャンクに番号をすることができます。

544
00:25:26,480 --> 00:25:29,030
>> だから私たちはこのことを言うよ
場所123です。

545
00:25:29,030 --> 00:25:32,070
だから、私のオペレーティングシステムの、このディレクトリの中
システムは、私のことを覚えている

546
00:25:32,070 --> 00:25:34,250
履歴書は、位置123にあります。

547
00:25:34,250 --> 00:25:36,850
しかし、それはときに面白い
あなたは、ファイルを削除します。

548
00:25:36,850 --> 00:25:37,820
>> 例えばそう - 

549
00:25:37,820 --> 00:25:40,790
そしてありがたいことに、世界のほとんどは持って
この上にキャッチ - 何が起こる

550
00:25:40,790 --> 00:25:45,040
お使いのMac OSのファイルをゴミ箱にドラッグする
か、Windowsのごみ箱？

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
ことを行う目的は何ですか？

553
00:25:50,510 --> 00:25:53,860
それは、ファイルを取り除くためには明らかだ
しかし、何をドラッグする行為は行い、

554
00:25:53,860 --> 00:25:57,550
あなたのゴミ箱かに落下
ごみ箱には、コンピュータ上で行う？

555
00:25:57,550 --> 00:25:59,230
>> 本当に絶対に何も、。

556
00:25:59,230 --> 00:26:00,320
それだけでフォルダのようなものだ。

557
00:26:00,320 --> 00:26:01,800
それは確かであるためには、特別なフォルダです。

558
00:26:01,800 --> 00:26:04,460
しかし、それは実際にファイルを削除しますか？

559
00:26:04,460 --> 00:26:06,780
>> いや、まあ、あなたのいくつかは、おそらく
いまいましいああ、あなたはしなかった、のようになっている

560
00:26:06,780 --> 00:26:07,420
それを行うことを意味します。

561
00:26:07,420 --> 00:26:09,130
だから、ダブルクリック
ゴミ箱やごみ箱。

562
00:26:09,130 --> 00:26:11,630
あなたの周りつついてきた、あなたは回復してきた
それをドラッグしてファイル

563
00:26:11,630 --> 00:26:12,110
そこの外。

564
00:26:12,110 --> 00:26:14,420
だから明らかに、それは必ずしもありません
それを削除する。

565
00:26:14,420 --> 00:26:15,990
>> [OK]を、あなたは賢くそれよりもだ。

566
00:26:15,990 --> 00:26:18,860
あなたが知っているだけにそれをドラッグする
ゴミ箱やごみ箱という意味ではありません

567
00:26:18,860 --> 00:26:19,930
あなたはゴミ箱を空にしている。

568
00:26:19,930 --> 00:26:24,110
だから、メニューに上がると、あなたが言う
ゴミ箱を空にするか、ごみ箱を空に。

569
00:26:24,110 --> 00:26:25,360
次に何が起こる？

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> うん、そうそれはなおさら削除されます。

572
00:26:32,530 --> 00:26:37,660
しかし、起こることすべてはこれです。

573
00:26:37,660 --> 00:26:45,350
コンピュータはどこに忘れてしまった
resume.docでした。

574
00:26:45,350 --> 00:26:47,400
>> しかし、何が明らかに変わっていません
絵の中の？

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
ビットは、私があると主張する0と1
いくつかの物理的な側面のサイト上

577
00:26:55,570 --> 00:26:56,280
ハードウェア。

578
00:26:56,280 --> 00:26:57,110
彼らはまだそこにいる。

579
00:26:57,110 --> 00:26:58,930
それはちょうど、コンピュータが持っているだ
彼らが何であるか忘れてしまった。

580
00:26:58,930 --> 00:27:03,160
>> だから、それは本質的に解放されているファイルの
それらは再利用できるようにビット。

581
00:27:03,160 --> 00:27:06,940
しかし、あなたは、より多くのファイルを作成しないまで
およびファイル以上、より多くのファイル意志

582
00:27:06,940 --> 00:27:12,150
確率的に、これらの0と1、
それらの磁性粒子、再取得、

583
00:27:12,150 --> 00:27:16,220
ための逆さままたは右側アップ、
他のファイル、0と1。

584
00:27:16,220 --> 00:27:17,980
>> だから、時間のこのウィンドウを持っている。

585
00:27:17,980 --> 00:27:19,860
そしてそれは予測可能なのではありません
長さは、本当に。

586
00:27:19,860 --> 00:27:22,240
それはあなたのハードディスクのサイズに依存
ドライブとどのように多くのファイルがあなたが持っていると

587
00:27:22,240 --> 00:27:23,490
どのように迅速に新しいものを作る。

588
00:27:23,490 --> 00:27:27,050
しかし、時間のこのウィンドウでは、中にあり
そのファイルは完全にまだある

589
00:27:27,050 --> 00:27:27,770
回復可能。

590
00:27:27,770 --> 00:27:31,050
>> だから、あなたは今までマカフィーのようなプログラムを使用する場合
またはノートンを回復しようとする

591
00:27:31,050 --> 00:27:35,680
データは、彼らがやっていることすべてがしようとしています
このいわゆるディレクトリに回復する

592
00:27:35,680 --> 00:27:37,340
あなたのファイルがあった場所を見つけ出す。

593
00:27:37,340 --> 00:27:40,605
そして、時にはノートンと言うだろう、
ファイルには、93％回復可能です。

594
00:27:40,605 --> 00:27:42,020
まあ、それはどういう意味ですか？

595
00:27:42,020 --> 00:27:45,690
ただいくつかの他のファイルことを意味します
偶然、と言う、使用して終了

596
00:27:45,690 --> 00:27:48,920
元のファイルのうち、それらのビット。

597
00:27:48,920 --> 00:27:51,950
>> だから、実際に関与しているのか
データを回復するに？

598
00:27:51,950 --> 00:27:55,720
さて、あなたはのようなものを持っていない場合
ノートンは、お使いのコンピュータにプリインストール

599
00:27:55,720 --> 00:27:59,510
あなたは時々できる最善の外観です
探しているハードドライブ全体で

600
00:27:59,510 --> 00:28:00,510
ビットのパターン。

601
00:28:00,510 --> 00:28:05,350
と問題セットのテーマの一つ
5は、あなたが検索されますということです

602
00:28:05,350 --> 00:28:09,570
ハードドライブと同等の、法医学
からコンパクトフラッシュカードの画像

603
00:28:09,570 --> 00:28:13,660
デジタルカメラ、0を捜し
その通常と1、高いと

604
00:28:13,660 --> 00:28:16,720
確率、表す
JPEG画像の開始。

605
00:28:16,720 --> 00:28:21,120
>> そして君たちはによってそれらのイメージを回復することができます
私はこのパターンを見れば、仮定

606
00:28:21,120 --> 00:28:24,380
法医学画像上のビットと
高い確率で、マーク

607
00:28:24,380 --> 00:28:25,650
JPEGの開始。

608
00:28:25,650 --> 00:28:29,520
そして、私は再び同じパターンを見れば、
それはおそらくの開始をマーク

609
00:28:29,520 --> 00:28:32,440
別のJPEG、および他の
JPEG、および他のJPEG。

610
00:28:32,440 --> 00:28:34,970
そして、これは、典型的にはどのように
データ復旧は動作します。

611
00:28:34,970 --> 00:28:37,870
何JPEGファイルについての素晴らしいのは、にもかかわらずです
ファイルフォーマット自体は多少ある

612
00:28:37,870 --> 00:28:44,400
すべてのそのような複雑な、初め
ファイルは、実際にはかなり識別可能である

613
00:28:44,400 --> 00:28:47,370
あなたが見るように、シンプルで、
あなたは既にいないしている場合。

614
00:28:47,370 --> 00:28:50,270
>> それでは、下に詳しく見てみましょう
てきているかを正確にとしてボンネット

615
00:28:50,270 --> 00:28:53,360
起こって、そしてこれらの0と1のか
あなたのもう少しを与えることであり、

616
00:28:53,360 --> 00:28:55,330
この特定の課題のコンテキスト。

617
00:28:55,330 --> 00:28:55,510
>> [ビデオの再生]

618
00:28:55,510 --> 00:28:58,700
>> あなたのPCはほとんどの店 - どこ
その永続的なデータを。

619
00:28:58,700 --> 00:29:03,390
そのために、データはRAMから移動
教えソフトウェア信号とともに

620
00:29:03,390 --> 00:29:06,110
どのようにデータを保存するためにハードディスク·ドライブ。

621
00:29:06,110 --> 00:29:09,410
ハードドライブ回路は変換
電圧に変換し、これらの信号

622
00:29:09,410 --> 00:29:10,870
変動。

623
00:29:10,870 --> 00:29:14,970
これらは、順番に、ハードドライブのを制御する
可動部品、少数の一部

624
00:29:14,970 --> 00:29:17,910
に残された可動部品
現代のコンピュータ。

625
00:29:17,910 --> 00:29:22,130
>> 信号の一部は、モータを制御する
どの金属被覆プラッタを回転させる。

626
00:29:22,130 --> 00:29:25,470
あなたのデータが実際に格納されている
これらのプラッタ上。

627
00:29:25,470 --> 00:29:28,610
他の信号は、読み出し/書き込み移動
読み取りまたはヘッド

628
00:29:28,610 --> 00:29:30,710
プラッタ上のデータを書き込む。

629
00:29:30,710 --> 00:29:35,450
人間、この機械はとても精密な
髪があっても間を渡すことができませんでした

630
00:29:35,450 --> 00:29:37,280
ヘッド、スピニングプラッタ。

631
00:29:37,280 --> 00:29:40,316
しかし、それはすべて素晴らしい速度で動作します。

632
00:29:40,316 --> 00:29:40,660
>> [ENDビデオ再生]

633
00:29:40,660 --> 00:29:42,190
>> DAVIDマラン：少しでズーム
深い今何時

634
00:29:42,190 --> 00:29:44,360
実際にそれらのプラッタ上。

635
00:29:44,360 --> 00:29:44,720
>> [ビデオの再生]

636
00:29:44,720 --> 00:29:47,660
>> まさに我々を見てみましょう - 
スローモーションで見ました。

637
00:29:47,660 --> 00:29:51,710
電気の短いパルスである場合
反転している場合、読み取り/書き込みヘッドへ送ら

638
00:29:51,710 --> 00:29:54,650
のための小さい電磁上
ほんの一瞬。

639
00:29:54,650 --> 00:29:58,970
磁石はどのフィールドを作成
小さな、小さなの極性を変更し

640
00:29:58,970 --> 00:30:02,850
金属粒子の一部は
コー​​ト各プラッタ表面を。

641
00:30:02,850 --> 00:30:05,940
>> これらの小さなのパターンシリーズ、
ディスク上の帯電アップ領域

642
00:30:05,940 --> 00:30:08,470
の単一ビットを表す
進数のデータ

643
00:30:08,470 --> 00:30:10,530
コンピュータによって使用されるシステム。

644
00:30:10,530 --> 00:30:13,775
ここで、電流が一方向に送信された場合
読み出し/書き込みヘッドを、地域を通じ

645
00:30:13,775 --> 00:30:15,970
一方向に偏光される。

646
00:30:15,970 --> 00:30:17,950
電流に送信された場合
反対方向、

647
00:30:17,950 --> 00:30:19,930
分極が反転する。

648
00:30:19,930 --> 00:30:22,370
>> あなたは、ハードディスクからデータを取得する方法は？

649
00:30:22,370 --> 00:30:24,090
ただ、プロセスを逆に実行します。

650
00:30:24,090 --> 00:30:26,550
だから、ディスク上の粒子です
の電流を得ること

651
00:30:26,550 --> 00:30:27,960
頭が動いて読み取り/書き込み。

652
00:30:27,960 --> 00:30:30,700
これらの何百万人をまとめる
磁化されたセグメント、および

653
00:30:30,700 --> 00:30:32,160
このファイルを持っている。

654
00:30:32,160 --> 00:30:36,060
>> さて、単一のファイルの断片月
すべてのドライブのに散在する

655
00:30:36,060 --> 00:30:39,970
混乱のような種類の大皿、
あなたの机の上の書類の。

656
00:30:39,970 --> 00:30:43,500
だから特別な余分なファイルが追跡し
すべてのものがどこにあるの。

657
00:30:43,500 --> 00:30:45,985
あなたが持っていたくない
そのような何か？

658
00:30:45,985 --> 00:30:46,470
>> [ENDビデオ再生]

659
00:30:46,470 --> 00:30:47,820
>> DAVIDマラン：OK、おそらくありません。

660
00:30:47,820 --> 00:30:52,070
それでは、どのように多くの人
これらで育った？

661
00:30:52,070 --> 00:30:53,970
[OK]を、ので、それは少なくなります
手毎年。

662
00:30:53,970 --> 00:30:56,550
しかし、私はあなたが、少なくとも、慣れてくれてうれしい
彼らと、このために私たち自身の

663
00:30:56,550 --> 00:31:00,520
本デモでは、悲しいことに、非常に死んでいる
馴染みのここで死を遅らせる。

664
00:31:00,520 --> 00:31:04,010
>> しかし、これはどのような私は、少なくとも、後ろにある
高校、バックアップに使用使用。

665
00:31:04,010 --> 00:31:08,110
そして、それは驚くべきものだった、なぜならあなた
に1.4メガバイトを格納することができ

666
00:31:08,110 --> 00:31:08,930
この特定のディスク。

667
00:31:08,930 --> 00:31:12,260
そして、これは、高密度であったバージョン
HD有し、によって示されるように

668
00:31:12,260 --> 00:31:14,240
今日のHDビデオの前に意味。

669
00:31:14,240 --> 00:31:16,400
>> 標準密度は800キロバイトだった。

670
00:31:16,400 --> 00:31:18,640
とその前に、そこにあった
400キロバイトのディスク。

671
00:31:18,640 --> 00:31:23,120
とその前に、5と1/4があった
本当にフロッピーだっインチディスク、

672
00:31:23,120 --> 00:31:25,680
と少し広いと背
ここではこれらの事より。

673
00:31:25,680 --> 00:31:29,150
しかし、あなたは実際に、いわゆる見ることができます
これらのディスクのフロッピー側面。

674
00:31:29,150 --> 00:31:32,630
>> そして機能的に、彼らは実際にしている
でのハードドライブにかなり似て

675
00:31:32,630 --> 00:31:33,570
少なくともこのタイプ。

676
00:31:33,570 --> 00:31:37,270
繰り返しになりますが、新しいコンピュータでSSDを
少し異なる動作します。

677
00:31:37,270 --> 00:31:41,530
しかし、あなたはその小さな金属製のタブを移動した場合、
実際には、少しのクッキーを見ることができます

678
00:31:41,530 --> 00:31:42,560
または大皿。

679
00:31:42,560 --> 00:31:43,830
>> それは、このような金属ではありません。

680
00:31:43,830 --> 00:31:46,000
こちらは、実際にいくつかの安価だ
プラスチック材料。

681
00:31:46,000 --> 00:31:46,750
そして、あなたは小刻みに動くの種類、それをすることができます。

682
00:31:46,750 --> 00:31:50,310
そして、あなたはtrully単にいくつかを拭き取った
ビット又は磁性粒子の数

683
00:31:50,310 --> 00:31:51,220
このディスクから。

684
00:31:51,220 --> 00:31:52,710
>> だからありがたい、その上には何もありません。

685
00:31:52,710 --> 00:31:55,790
そのことが邪魔になら - とカバー
あなたの目とあなたの隣人のもの - 

686
00:31:55,790 --> 00:31:58,865
あなただけの種類のこれを引っ張ることができる
そのような全体のシースオフ。

687
00:31:58,865 --> 00:32:01,900
しかし、少しバネがあり、そうである
あなたの目でその意識。

688
00:32:01,900 --> 00:32:03,620
だから今は本当にフロッピーディスクを持っている。

689
00:32:03,620 --> 00:32:07,090
>> そして、これについて注目すべき何
これはそのまま、それは同じくらいである

690
00:32:07,090 --> 00:32:10,830
大きいの小規模な表現
ハードドライブは、これらの事は、スーパーです

691
00:32:10,830 --> 00:32:11,590
超簡単。

692
00:32:11,590 --> 00:32:15,170
あなたは今、それの底をつまむ場合は、その
金属製のものはオフだし、皮

693
00:32:15,170 --> 00:32:20,990
彼らは開く、そこにあるすべてが二枚ある
感じ、いわゆるフロッピーディスク

694
00:32:20,990 --> 00:32:22,930
内側に金属片と。

695
00:32:22,930 --> 00:32:25,990
>> との半分はそこに行く
私のディスクの内容。

696
00:32:25,990 --> 00:32:27,540
それらの別の半分はそこに行く。

697
00:32:27,540 --> 00:32:31,375
しかし、それは内側に回転したことすべてです
往年におけるコンピュータの。

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> そして再び、大局的にこれを置くためには、
あなたのほとんどは、どのように大きなです

700
00:32:38,310 --> 00:32:39,560
ハードは、これらの日ドライブ？

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500ギガバイト、テラバイト、多分に
デスクトップコンピュータ、2テラバイト、3

703
00:32:46,230 --> 00:32:47,630
テラバイト、4テラバイト、右？

704
00:32:47,630 --> 00:32:52,480
これは、与えるか、または取る、1メガバイトです
でも典型的なMP3に適合しないことができ

705
00:32:52,480 --> 00:32:55,310
もはや、これらの日、またはいくつかの
類似した音楽ファイル。

706
00:32:55,310 --> 00:32:59,500
>> だから、少しのあなたのためのお土産今日、と
また何を文脈に役立つ

707
00:32:59,500 --> 00:33:03,570
私たちは当たり前の取ることでしょう
今問題に5を設定します。

708
00:33:03,570 --> 00:33:04,820
だから、それらは維持するためにあなたのものとなります。

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
だからされる場所に私は移行せ
同様に次のPSETを費やす。

711
00:33:13,370 --> 00:33:18,470
だから我々は、今のところこのページを設定している - ああ、
すぐに発表のカップル。

712
00:33:18,470 --> 00:33:21,730
>> ご希望の場合は今週の金曜日、CS50に参加
昼食のために、いつもの場所に移動し、

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp。

714
00:33:23,610 --> 00:33:25,100
そして最終的なプロジェクト - 

715
00:33:25,100 --> 00:33:28,520
そうシラバスあたり、我々が投稿されました
すでに最終的なプロジェクトの仕様。

716
00:33:28,520 --> 00:33:31,410
それが意味するものではないことを認識
それは特に、すぐに原因です。

717
00:33:31,410 --> 00:33:33,990
それは、単に取得するには、実際には、掲載されている
君たちはそれについて考える。

718
00:33:33,990 --> 00:33:37,620
そして実際、超重要
あなたの割合が取り組むれる

719
00:33:37,620 --> 00:33:40,780
材料の最終プロジェクト我々
でもクラスでにもらっていない、

720
00:33:40,780 --> 00:33:42,730
しかし来週早けれう。

721
00:33:42,730 --> 00:33:45,530
>> specはを求めていることに注意してください、しかし、
いくつかの異なるコンポーネント

722
00:33:45,530 --> 00:33:46,190
最終的なプロジェクト。

723
00:33:46,190 --> 00:33:49,590
最初は、数週間であり、
プレ提案にかなりカジュアルなメール

724
00:33:49,590 --> 00:33:52,760
あなたの彼に言うにTFか何をしている
で、あなたのプロジェクトのために考える

725
00:33:52,760 --> 00:33:53,650
確約はありません。

726
00:33:53,650 --> 00:33:56,710
提案は、特定されます
コミットメントは、と言って、ここで、これは何ですか

727
00:33:56,710 --> 00:33:57,770
私は自分のプロジェクトのためにやりたい。

728
00:33:57,770 --> 00:33:58,250
どう思う？

729
00:33:58,250 --> 00:33:58,650
大きすぎる？

730
00:33:58,650 --> 00:33:59,145
小さすぎる？

731
00:33:59,145 --> 00:34:00,330
それは扱いやすいでしょうか？

732
00:34:00,330 --> 00:34:02,230
そして、あなたはそれ以上の詳細については、仕様を参照してください。

733
00:34:02,230 --> 00:34:05,060
>> ステータスですその後数週間
同様にある報告書、

734
00:34:05,060 --> 00:34:08,260
どれだけ言ってもあなたのTFにカジュアルメール
ずっとあなたが最終的にあるの背後に

735
00:34:08,260 --> 00:34:12,360
続いて、プロジェクトの実施、
CS50ハッカソンみんなに

736
00:34:12,360 --> 00:34:17,520
からのイベントになるだろう、これ招待され
7時00分まで一晩で午後8時

737
00:34:17,520 --> 00:34:19,150
翌朝午前。

738
00:34:19,150 --> 00:34:22,560
私は週に言及した可能性があるのでピザ、
ゼロ、ウィル午後9で提供される、

739
00:34:22,560 --> 00:34:24,120
1:00中華料理はAM。

740
00:34:24,120 --> 00:34:27,929
そして、あなたは5時にまだ目を覚ましている場合は、AM、
私たちは朝食のためにIHOPに連れて行きます。

741
00:34:27,929 --> 00:34:31,310
>> ハッカソンは、より多くの一つですので、
クラスの思い出に残る体験を。

742
00:34:31,310 --> 00:34:35,290
その後、実装が原因であり、
その後クライマックスCS50フェア。

743
00:34:35,290 --> 00:34:38,070
これらのすべての詳細
週間で来ています。

744
00:34:38,070 --> 00:34:40,739
>> しかしみましょう何かに戻る
古い学校 - 

745
00:34:40,739 --> 00:34:41,920
再び、配列。

746
00:34:41,920 --> 00:34:45,040
それが解決するので、それで配列が、よかったよ
我々のような問題は、ちょうど見た

747
00:34:45,040 --> 00:34:49,290
学生の構造を持つ前に瞬間
コントロールの少し外を取得した場合、私たち

748
00:34:49,290 --> 00:34:52,405
、生徒1、生徒2を持ちたい
学生3、学生ドットドットドット、

749
00:34:52,405 --> 00:34:54,400
学生のいくつかの任意の数。

750
00:34:54,400 --> 00:34:58,850
>> だから配列は、数週間前に急襲
とではない私たちのすべての問題を解決しました

751
00:34:58,850 --> 00:35:03,340
いかに多くのことを事前に知っている
私たちが望むかもしれないいくつかのタイプの。

752
00:35:03,340 --> 00:35:07,390
そして我々は、構造体が私たちを助けることができることを見てきました
さらに我々のコードを整理し続ける

753
00:35:07,390 --> 00:35:11,660
のような概念的に類似した変数は、
名前、家、一緒に、そのように我々

754
00:35:11,660 --> 00:35:15,570
内部に1つのエンティティとして扱うことができます
そのうちの小さな部分があります。

755
00:35:15,570 --> 00:35:17,810
>> しかし、配列はいくつかの欠点を持っている。

756
00:35:17,810 --> 00:35:19,780
欠点のいくつかは何ですか
我々は遭遇した

757
00:35:19,780 --> 00:35:22,320
配列でこれまで？

758
00:35:22,320 --> 00:35:23,450
何それ？

759
00:35:23,450 --> 00:35:28,130
固定サイズ - そうであってもあなたがかもしれないが
用のメモリを割り当てることができる

760
00:35:28,130 --> 00:35:32,310
配列には、かつてあなたが知っているどのように多くの学生が
あなたが持っているどのように多くの文字が、持っている

761
00:35:32,310 --> 00:35:35,460
ユーザから、一度割り当てられた
配列には、どのような種類の塗装しました

762
00:35:35,460 --> 00:35:36,740
自分のコーナーへ。

763
00:35:36,740 --> 00:35:40,600
>> あなたは、新しい要素を挿入することはできませんので、
配列の真ん中に。

764
00:35:40,600 --> 00:35:43,660
あなたがより多くの要素を挿入することはできません
配列の末尾に。

765
00:35:43,660 --> 00:35:47,750
本当に、あなたの作成に頼らなければならない
私たちが議論してきたように、全く新しい配列、

766
00:35:47,750 --> 00:35:49,320
新たに古いのコピー。

767
00:35:49,320 --> 00:35:52,610
そして再び、それは頭痛の種である
あなたのために情報をGetStringメソッド。

768
00:35:52,610 --> 00:35:56,170
>> しかし、再び、あなたも挿入することはできません
配列の真ん中に何か

769
00:35:56,170 --> 00:35:58,200
レートが完全に満たされていない場合。

770
00:35:58,200 --> 00:36:03,010
たとえば、この配列であれば、ここでサイズの
6は、その中に5つのものを持っている

771
00:36:03,010 --> 00:36:06,080
さて、あなたは単にタックできた
末尾に何か。

772
00:36:06,080 --> 00:36:08,200
しかし、あなたが何かを挿入したい場合
の真ん中に

773
00:36:08,200 --> 00:36:11,280
配列は、それが持っている場合でも
その中の6物事のうち、5？

774
00:36:11,280 --> 00:36:14,250
>> まあ、我々は、我々はすべてを持っていたとき何をした
私たち人間のボランティアのステージ上で

775
00:36:14,250 --> 00:36:15,110
過去数週間？

776
00:36:15,110 --> 00:36:18,710
我々はここで誰かを入れたいと思った場合は、どちらか
これらの人々はどのようにこれを移動する

777
00:36:18,710 --> 00:36:22,540
方法、またはこれを移動する方法をこれらの人々
方法、そして高価になりました。

778
00:36:22,540 --> 00:36:26,950
内部の人のシフト
配列には、加算と原価計算終了

779
00:36:26,950 --> 00:36:31,240
当方故に時間、私たちの多くのN乗
挿入ソートのように時間を実行して、用

780
00:36:31,240 --> 00:36:32,550
最悪の場合には、インスタンス、。

781
00:36:32,550 --> 00:36:36,520
だから、配列は素晴らしいですが、あなたはする必要があります
あなたがそれらをしたいどのように大きな事前に知っている。

782
00:36:36,520 --> 00:36:38,030
>> だからOK、ここでは、ソリューションです。

783
00:36:38,030 --> 00:36:43,860
私が事前にわからない場合はどのように多くの
私が持っているかもしれない、と私は、一度知っている学生

784
00:36:43,860 --> 00:36:47,870
私が決める、しかし、私はそれにこだわっている
私はいつもしない理由の多くの学生が、

785
00:36:47,870 --> 00:36:51,740
倍の多くのスペースを割り当てる
私は必要だと思うかもしれないとして？

786
00:36:51,740 --> 00:36:54,450
それが合理的な解決策はありませんか？

787
00:36:54,450 --> 00:36:58,240
>> 現実的に、私たちがしていることはないと思う
50以上のスロットが必要になるだろ

788
00:36:58,240 --> 00:37:02,190
中型クラスの配列で、
これだけ切り上げてみましょう。

789
00:37:02,190 --> 00:37:07,040
私はちょうど、私の配列に100スロットを作ってあげる
我々は間違いなく得ることができるよう

790
00:37:07,040 --> 00:37:10,330
私が期待する学生数
いくつかの中規模クラスになる。

791
00:37:10,330 --> 00:37:14,320
なぜただ切り上げと割り当てられない
アレイの一般的に多くのメモリ、、

792
00:37:14,320 --> 00:37:16,290
あなたがあっても必要とするかもしれないと思うよりも、？

793
00:37:16,290 --> 00:37:20,190
この単純なプッシュは何です
そのアイデアに？

794
00:37:20,190 --> 00:37:21,440
>> あなただけのメモリを無駄にしています。

795
00:37:21,440 --> 00:37:25,350
あなたがして書き、文字通りすべてのプログラム
多分二倍のメモリとして使用しています

796
00:37:25,350 --> 00:37:26,680
あなたが実際に必要とする。

797
00:37:26,680 --> 00:37:28,990
そして、それはただのような気がしない
特に洗練されたソリューション。

798
00:37:28,990 --> 00:37:31,990
また、それだけで減少
問題の確率。

799
00:37:31,990 --> 00:37:35,300
あなたは、人気のコースを持ってしまった場合
1学期、あなたは101を持っている

800
00:37:35,300 --> 00:37:39,610
学生は、あなたのプログラムが残っている
根本的に同じ問題に直面して。

801
00:37:39,610 --> 00:37:44,280
>> だからありがたい、解決策はあり
フォーム内の​​この広告は、すべて私たちの問題

802
00:37:44,280 --> 00:37:46,790
次のデータ構造
ものよりも複雑

803
00:37:46,790 --> 00:37:47,970
我々はこれまで見てきました。

804
00:37:47,970 --> 00:37:50,530
これは、私が主張し、リンクされたリストです。

805
00:37:50,530 --> 00:37:51,920
これは数値のリストです - 

806
00:37:51,920 --> 00:37:54,970
9、17、22、26、および34  - 

807
00:37:54,970 --> 00:38:00,120
ところで一緒にリンクされていること
何で私が矢印で描かれてきました。

808
00:38:00,120 --> 00:38:03,580
>> 言い換えれば、私が表現したい場合
アレイは、私が行うことができます

809
00:38:03,580 --> 00:38:04,910
このような何か。

810
00:38:04,910 --> 00:38:07,310
そして、私はオーバーヘッドでこれを出してあげる
ほんの一瞬である。

811
00:38:07,310 --> 00:38:09,970
私が行うことができます - 

812
00:38:09,970 --> 00:38:12,520
こんにちは、大丈夫。

813
00:38:12,520 --> 00:38:14,470
スタンバイ。

814
00:38:14,470 --> 00:38:17,360
ここで新しいコンピュータ、明確な - 

815
00:38:17,360 --> 00:38:18,090
わかりました。

816
00:38:18,090 --> 00:38:21,730
>> だから私は、配列にこれらの番号を持っている場合 - 

817
00:38:21,730 --> 00:38:28,880
9、17、22、26、24  - 

818
00:38:28,880 --> 00:38:30,530
スケーリングするとは限らない。

819
00:38:30,530 --> 00:38:33,730
すべての権利なので、ここに私の配列です - 

820
00:38:33,730 --> 00:38:34,980
オーマイゴッド。

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
すべての権利なので、ここに私の配列です。

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
なんてこった。

825
00:38:45,050 --> 00:38:48,820
>> [笑い]

826
00:38:48,820 --> 00:38:49,440
>> DAVIDマラン：ふりをする。

827
00:38:49,440 --> 00:38:52,330
それは戻ってあまりにも多くの努力だ
とそうそこ、それを修正 - 

828
00:38:52,330 --> 00:38:54,290
26。

829
00:38:54,290 --> 00:38:57,650
だから私たちは、この配列を持っている
9、17、22、26、および34。

830
00:38:57,650 --> 00:39:00,260
あなたのそれらのために見ることができます
恥ずかしい間違い私はただ作った

831
00:39:00,260 --> 00:39:00,830
そこにそれがある。

832
00:39:00,830 --> 00:39:04,490
>> だから私は、これがあると主張
非常に効率的なソリューション。

833
00:39:04,490 --> 00:39:07,310
私はできるだけ多くの整数として割り当てた
私が必要とする - 一、二、三、

834
00:39:07,310 --> 00:39:09,100
四、五、または6  - 

835
00:39:09,100 --> 00:39:11,660
そして私は、番号を保存しました
この配列の内部。

836
00:39:11,660 --> 00:39:15,220
しかし仮定し、その後、私が挿入したい
8番のような値はありますか？

837
00:39:15,220 --> 00:39:16,100
まあ、それはどこに行くのでしょうか？

838
00:39:16,100 --> 00:39:18,530
私が挿入したいとしましょう
20のような数字。

839
00:39:18,530 --> 00:39:19,790
まあ、それはどこに行くのでしょうか？

840
00:39:19,790 --> 00:39:23,160
どこか途中で、
または番号35は、行かなければならない

841
00:39:23,160 --> 00:39:24,010
どこかで終わりに。

842
00:39:24,010 --> 00:39:25,320
しかし、私はすべての領域外だ。

843
00:39:25,320 --> 00:39:29,120
>> そして、これは基本的な課題である
ソリューションですん配列の。

844
00:39:29,120 --> 00:39:32,280
私がGetStringメソッド、一瞬前に主張した
この問題を解決します。

845
00:39:32,280 --> 00:39:37,380
あなたは、第六番号を挿入する場合
この配列に、少なくとも一つのものです

846
00:39:37,380 --> 00:39:40,090
ソリューションあなたは、確かに頼ることができます
ただ私たちは、GetStringメソッドで行うように？

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
何それ？

849
00:39:46,030 --> 00:39:48,190
>> まあ、それは大きくされていることを確認
言うは易し、行うは難たし。

850
00:39:48,190 --> 00:39:52,810
我々は必然的に配列を作ることができない
大きく、しかし、我々は何ができますか？

851
00:39:52,810 --> 00:39:56,570
サイズの大きいです新しい配列を作る
多分6、サイズ10、我々はしたい場合

852
00:39:56,570 --> 00:40:00,490
先んじて物事の取得し、コピーする
古い新しいに配列し、次に

853
00:40:00,490 --> 00:40:01,680
古い配列を解放する。

854
00:40:01,680 --> 00:40:05,770
>> しかし、実行時間は何ですか
今、そのプロセスの？

855
00:40:05,770 --> 00:40:09,870
これは、n個のビッグOだからコピー
あなたにいくつかの単位の費用としている

856
00:40:09,870 --> 00:40:13,480
我々がしなければならない場合、時間、まあまあ理想的ではありません
起こっている新しい配列を割り当て、

857
00:40:13,480 --> 00:40:15,610
二倍消費する
一時的にメモリ。

858
00:40:15,610 --> 00:40:16,660
新たに古いコピー - 

859
00:40:16,660 --> 00:40:18,800
私が意味する、それだけで頭痛、だた
、再び、なぜ我々は書いている

860
00:40:18,800 --> 00:40:19,920
あなたにGetStringメソッド。

861
00:40:19,920 --> 00:40:21,380
>> だから私たちは、代わりに何をするのでしょうか？

862
00:40:21,380 --> 00:40:25,000
さて、どのような場合は、当社のデータ構造
実際のギャップを持っている？

863
00:40:25,000 --> 00:40:30,790
私が持っていることの私の目標を緩和したとし
メモリの連続チャンク、どこ9

864
00:40:30,790 --> 00:40:34,500
である17、すぐ隣です
右22の隣に、というように。

865
00:40:34,500 --> 00:40:39,570
>> と9がここで終わることができると仮定
RAM、および17は、RAMにこっちにすることができます

866
00:40:39,570 --> 00:40:40,990
及び22は、RAMにこっちにすることができます。

867
00:40:40,990 --> 00:40:43,610
言い換えれば、私はそれらを必要としない
でももう背中合わせに。

868
00:40:43,610 --> 00:40:47,850
私はちょうど何とか針に糸を通すように持っている
これらの数字のそれぞれ、または各を通じて

869
00:40:47,850 --> 00:40:51,010
これらのノードの、として我々は呼ぶことにします
私は、それらを集めてきたように長方形

870
00:40:51,010 --> 00:40:55,670
最後に取得する方法を覚えている
最初からそのようなノード。

871
00:40:55,670 --> 00:40:59,940
>> だからプログラミングコンストラクトものです
私たちは、ごく最近見てきたと私は

872
00:40:59,940 --> 00:41:03,030
そのスレッドを実装する、またはすることができます
私はことのできる、ここに描かれた

873
00:41:03,030 --> 00:41:05,430
これらの矢印を実装する？

874
00:41:05,430 --> 00:41:06,500
だからポインタ、右？

875
00:41:06,500 --> 00:41:09,560
私だけではない割り当てる場合
int型が、ノード - とによって

876
00:41:09,560 --> 00:41:10,810
ノードには、私はちょうどコンテナを意味する。

877
00:41:10,810 --> 00:41:12,900
視覚的に、私は長方形を意味します。

878
00:41:12,900 --> 00:41:16,420
ノードには、明らかに必要であるので、
 -  2つの値を格納する

879
00:41:16,420 --> 00:41:21,490
int型自体が、その後は、などによって暗示
四角形の下半分、

880
00:41:21,490 --> 00:41:23,010
int型のための十分なスペース。

881
00:41:23,010 --> 00:41:26,130
>> だから、ここで先に考える
このノードは、この、どの大きさ

882
00:41:26,130 --> 00:41:27,170
問題のコンテナ？

883
00:41:27,170 --> 00:41:29,250
int型のためにどのように多くのバイト？

884
00:41:29,250 --> 00:41:31,310
おそらく4、それがあれば
いつもと同じ。

885
00:41:31,310 --> 00:41:33,270
そして、どのように多くのバイト
ポインタ？

886
00:41:33,270 --> 00:41:33,650
4。

887
00:41:33,650 --> 00:41:37,940
だからこのコンテナ、またはこのノードが、ある
8バイトの構造体になるだろう。

888
00:41:37,940 --> 00:41:41,760
ああ、それは幸せな偶然だ
我々だけでは、この概念を導入しました

889
00:41:41,760 --> 00:41:44,400
構造体、またはC構造。

890
00:41:44,400 --> 00:41:48,890
>> だから私は、私が一歩を踏み出すために必要と主張している
これより洗練された方へ

891
00:41:48,890 --> 00:41:52,560
数のリストの実装
数値のリンクリスト、私が行う必要があります

892
00:41:52,560 --> 00:41:56,920
もう少しアップフロント思考と
だけではなく、int型ですが、構造体を宣言する

893
00:41:56,920 --> 00:41:58,620
私が呼ぶだろうことは、従来
ここで、ノード。

894
00:41:58,620 --> 00:42:01,630
我々はそれを私たちが欲しいものを呼び出すこともできますが、
ノードには、たくさんのテーマになるだろう

895
00:42:01,630 --> 00:42:03,560
我々は今を見て始めるものの。

896
00:42:03,560 --> 00:42:06,480
>> そのノードの内部のデータ型はint nです。

897
00:42:06,480 --> 00:42:09,350
そしてこの構文は、少し
一見奇妙な - 

898
00:42:09,350 --> 00:42:12,960
構造ノード*次。

899
00:42:12,960 --> 00:42:16,900
まあ画像で、それは何ですか？

900
00:42:16,900 --> 00:42:21,000
それはの下半分です。
我々が見た長方形

901
00:42:21,000 --> 00:42:22,730
ちょっと前に。

902
00:42:22,730 --> 00:42:27,600
>> しかし、なぜ私は、*構造のノードを言っている
と同じノード*に反対？

903
00:42:27,600 --> 00:42:31,370
そのポインタが指している場合があるため
別のノードでは、それだけだ

904
00:42:31,370 --> 00:42:32,760
ノードのアドレス。

905
00:42:32,760 --> 00:42:35,630
私たちがしたものと一致だね
これまでポインタについて議論した。

906
00:42:35,630 --> 00:42:39,690
私が主張した場合しかし、なぜ、この構造は
ノードと呼ばれ、私は構造体を言わなければならない

907
00:42:39,690 --> 00:42:42,660
ここで内部ノード？

908
00:42:42,660 --> 00:42:43,190
>> まさに。

909
00:42:43,190 --> 00:42:46,490
これは、Cの愚かな現実のようなものだ
typedefのは、いわば、ではないがある

910
00:42:46,490 --> 00:42:47,220
まだ起こった。

911
00:42:47,220 --> 00:42:48,510
Cは超リテラルです。

912
00:42:48,510 --> 00:42:51,050
それはあなたのコードの先頭に読み込む
右へ左下、。

913
00:42:51,050 --> 00:42:54,930
そして、それは上のそのセミコロンを打つまで
一番下の行ではなく、何をするかと思います

914
00:42:54,930 --> 00:42:57,590
データ型として存在？

915
00:42:57,590 --> 00:42:59,060
ノード、引用引用終わりノード。

916
00:42:59,060 --> 00:43:03,050
>> しかし、ために、より詳細に
宣言私は、最初の行にしました - 

917
00:43:03,050 --> 00:43:05,340
ます。typedef structノード - 

918
00:43:05,340 --> 00:43:08,790
その前に、最初に来たので
中括弧のようなものだ

919
00:43:08,790 --> 00:43:11,800
つまり、あらかじめ教育Clangの
何を知っている、私に構造を与える

920
00:43:11,800 --> 00:43:13,570
構造ノードと呼ば。

921
00:43:13,570 --> 00:43:16,270
率直に言って、私は物事を呼び出して好きではありません
構造ノード、構造ノードすべて

922
00:43:16,270 --> 00:43:17,090
私のコード全体。

923
00:43:17,090 --> 00:43:20,660
しかし、私は唯一の、すぐ内側、一度それを使用します
ように私は効果的にすることができます

924
00:43:20,660 --> 00:43:25,010
、循環参照のようなものをしない作成
それ自体が自分自身へのポインタが、

925
00:43:25,010 --> 00:43:29,400
別の体へのポインタ
同じタイプ。

926
00:43:29,400 --> 00:43:32,330
>> だから、結局、そのデータ構造に
このように、いくつかはあり

927
00:43:32,330 --> 00:43:34,470
かもしれない操作
私たちに興味のある。

928
00:43:34,470 --> 00:43:37,460
私たちは、挿入したい場合があり
このようなリストに変換します。

929
00:43:37,460 --> 00:43:39,850
我々は削除する場合があります
このようなリストから。

930
00:43:39,850 --> 00:43:43,490
我々のためにリストを検索したい場合があり
値、またはより一般的には、トラバース。

931
00:43:43,490 --> 00:43:46,410
とトラバースはただの空想の方法です
左から開始し、すべてを動かすと言って

932
00:43:46,410 --> 00:43:47,650
右への道。

933
00:43:47,650 --> 00:43:52,640
>> でも、これで、予告、もう少し
洗練されたデータ構造は、割り当て

934
00:43:52,640 --> 00:43:56,510
私は、我々はいくつかのを借りることができることを提案
過去二週間のアイデアと、

935
00:43:56,510 --> 00:43:58,410
という関数を実装する
このような検索。

936
00:43:58,410 --> 00:44:01,360
これは、またはtrueを返すために起こっている
、偽を示す、yesまたは

937
00:44:01,360 --> 00:44:03,390
いや、nがリストに含まれている。

938
00:44:03,390 --> 00:44:05,960
その二番目の引数はポインタである
リスト自体に、そう

939
00:44:05,960 --> 00:44:07,920
ノードへのポインタ。

940
00:44:07,920 --> 00:44:10,350
>> 私は次に何をするつもりだすべてが宣言され
一時変数。

941
00:44:10,350 --> 00:44:12,730
我々は、慣例によりそれPTRと呼ぶことにします
ポインタ。

942
00:44:12,730 --> 00:44:15,220
そして、私はと等しく割り当てる
リストの先頭。

943
00:44:15,220 --> 00:44:16,680
>> そして今、whileループに気づく。

944
00:44:16,680 --> 00:44:20,640
だから長いポインタが等しくないとして
nullに、私がチェックするつもりです。

945
00:44:20,640 --> 00:44:24,520
あるポインタ矢印nに等しい
渡されたnの？

946
00:44:24,520 --> 00:44:26,410
とちょっと待って - 新しい
構文の一部。

947
00:44:26,410 --> 00:44:29,324
矢印が突然何ですか？

948
00:44:29,324 --> 00:44:30,574
うん？

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> まさに。

951
00:44:34,810 --> 00:44:38,860
だから一方で、数分前に、我々は、使用される
何かにアクセスするためのドット記法

952
00:44:38,860 --> 00:44:43,080
構造体の内部に、変数であれば
あなたは、構造体ではないた

953
00:44:43,080 --> 00:44:47,420
そのものではなく、構造体へのポインタ、
ありがたいことに、構文の一部その

954
00:44:47,420 --> 00:44:48,620
ついに直感的理にかなっています。

955
00:44:48,620 --> 00:44:52,360
矢印は、ポインタに追従する手段
我々の矢印は、一般的に意味のように

956
00:44:52,360 --> 00:44:56,570
画像で、とで行く
データフィールドの内部。

957
00:44:56,570 --> 00:44:59,700
だから矢印はドットと同じものですが、
ポインタを持っているとき、あなたはそれを使用する。

958
00:44:59,700 --> 00:45:05,270
>> だから、次に要約する場合、n個のフィールド
ポインタと呼ばれる構造体の内部に

959
00:45:05,270 --> 00:45:07,760
nは等しい等しく、trueを返します。

960
00:45:07,760 --> 00:45:11,970
ここではそれ以外の場合は、この行 - ポインタ
次のポインタに等しい。

961
00:45:11,970 --> 00:45:17,540
だから、これが何をしているか、通知がある場合、I
現在の構造体を指しています

962
00:45:17,540 --> 00:45:21,430
9、および9を含有する数ではありません
私が探しています - 私が探していたとし

963
00:45:21,430 --> 00:45:22,830
nは、50に等しい - 

964
00:45:22,830 --> 00:45:25,930
私は一時的なポインタを更新するつもりです
このノードで指していないため

965
00:45:25,930 --> 00:45:31,190
もうが、どのポインタ矢印の隣、
ここに私を置くために起こっている。

966
00:45:31,190 --> 00:45:34,270
>> 今、私は旋風で実現
紹介。

967
00:45:34,270 --> 00:45:37,380
水曜日に、我々は実際にこれをやる
いくつかの人間とし、いくつかの詳細と

968
00:45:37,380 --> 00:45:38,900
遅いペースでコード。

969
00:45:38,900 --> 00:45:42,990
しかし、実現する、我々は今我々のデータを作っている
構造は、より複雑なように私たちの

970
00:45:42,990 --> 00:45:45,780
アルゴリズムがより効率的に得ることができ、その
のために必要になるだろう

971
00:45:45,780 --> 00:45:50,500
PSET 6、我々は再び、でロードすると、それらの
15万言葉が、そうする必要があります

972
00:45:50,500 --> 00:45:55,650
効率的に、理想的には、作成
我々のユーザーではないために実行するプログラム

973
00:45:55,650 --> 00:46:00,460
乗が、中のnの線形ではなく、
理想的に時定数、。

974
00:46:00,460 --> 00:46:02,300
>> 私たちは、水曜日にお会いしましょう​​。

975
00:46:02,300 --> 00:46:07,240
>> SPEAKER：次回のCS50、デービッドで
彼のベースケースを忘れた。

976
00:46:07,240 --> 00:46:12,770
>> DAVIDマラン：そして、それはあなたが送る方法です
何Cとテキストメッセージ - 

977
00:46:12,770 --> 00:46:14,020
>> [さまざまなテキストメッセージ
通知はSOUNDS]

978
00:46:14,020 --> 00:46:19,734