1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [第4週]

2
00:00:03,000 --> 00:00:05,000
[デビッド·J·マラン] [ハーバード大学]

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

4
00:00:08,000 --> 00:00:12,000
>> すべての権利は​​、これはCS50であり、これは第4週の始まりです

5
00:00:12,000 --> 00:00:16,000
これは最も遅い可能ソートアルゴリズムの一つである。

6
00:00:16,000 --> 00:00:19,000
どちらが私達がちょうどそこに見ていることでしたか？

7
00:00:19,000 --> 00:00:24,000
それはビッグはO（n ^ 2）+和、順番にバブルソートであった

8
00:00:24,000 --> 00:00:28,000
そして実際に、我々は知っているように見えるために、この世界で唯一のものではありません

9
00:00:28,000 --> 00:00:30,000
どんなバブルソートであるか、またはその実行時間。

10
00:00:30,000 --> 00:00:33,000
確かに、これはGoogleのエリック·シュミットとのインタビューだった

11
00:00:33,000 --> 00:00:45,000
ほんの数年前と元上院議員バラク·オバマ。

12
00:00:45,000 --> 00:00:48,000
>> 今では、上院議員は、Googleでここにいる、

13
00:00:48,000 --> 00:00:54,000
と私は、就職の面接のように大統領職を考えるのが好きです。

14
00:00:54,000 --> 00:00:58,000
さて、それは社長として仕事を得るのは難しい、とあなたは今厳し通過している。

15
00:00:58,000 --> 00:01:00,000
これは、Googleでの仕事を得ることも難しい。

16
00:01:00,000 --> 00:01:05,000
、我々は疑問を持っており、我々は我々の候補者の質問をする

17
00:01:05,000 --> 00:01:10,000
そしてこれはラリー·シュワイマーからです。

18
00:01:10,000 --> 00:01:14,000
君たちは私をからかっていると思う？それは右ここにあるのです。

19
00:01:14,000 --> 00:01:18,000
万人の32ビット整数をソートするための最も効率的な方法は何ですか？

20
00:01:18,000 --> 00:01:21,000
[笑い]

21
00:01:21,000 --> 00:01:24,000
よく

22
00:01:24,000 --> 00:01:26,000
ごめんなさい。>>いや、いや、いや、いや。

23
00:01:26,000 --> 00:01:34,000
私は、バブルソートは、移動するための間違った方法だと思う。

24
00:01:34,000 --> 00:01:39,000
>> 彼にこのことを告げた人々、上に来る？

25
00:01:39,000 --> 00:01:43,000
先週、我々は少なくとも1日、コードから休憩を取ったリコール

26
00:01:43,000 --> 00:01:46,000
そしてより一般的に解くいくつかのより高いレベルのアイデアや問題に焦点を当て始めた

27
00:01:46,000 --> 00:01:49,000
検索やソートの文脈では、

28
00:01:49,000 --> 00:01:53,000
そして我々は、我々は最後の週に、この名前を平手打ちしなかったものを導入

29
00:01:53,000 --> 00:01:56,000
しかし漸近記法、ビッグオー、ビッグオメガ、

30
00:01:56,000 --> 00:02:00,000
そして時にはビッグシータ表記、これらは単純な方法であった

31
00:02:00,000 --> 00:02:02,000
アルゴリズムの実行時間を記述するための、

32
00:02:02,000 --> 00:02:05,000
それを実行するためのアルゴリズムのためにかかった時間。

33
00:02:05,000 --> 00:02:08,000
>> そして、あなたは、大きさの点では、実行時間について話しましたことを思い出して

34
00:02:08,000 --> 00:02:11,000
我々は一般的に問題があるかもしれないものは何でも、nを呼び出す入力、の、

35
00:02:11,000 --> 00:02:13,000
ここで、nは、部屋にいる人々の数です

36
00:02:13,000 --> 00:02:17,000
電話帳のページ数、そして我々は物事を書き始めました

37
00:02:17,000 --> 00:02:21,000
はO（n ^ 2）またはO（n）またはO（n log n）のような

38
00:02:21,000 --> 00:02:24,000
と数学はそれほど完璧にうまくいかなかった場合でも、

39
00:02:24,000 --> 00:02:28,000
n / 2個、またはそのような何か - そしてそれは、n²だった

40
00:02:28,000 --> 00:02:31,000
我々だけではなく、下位の用語のいくつかを捨てるでしょう

41
00:02:31,000 --> 00:02:34,000
私たちが本当に求めているがあるとモチベーション

42
00:02:34,000 --> 00:02:37,000
評価の客観的な方法のようなもの

43
00:02:37,000 --> 00:02:39,000
プログラムのパフォーマンスやアルゴリズムの性能

44
00:02:39,000 --> 00:02:42,000
一日の終わりに、例えば何の関係もないことを、

45
00:02:42,000 --> 00:02:45,000
お使いのコンピュータの速度今日と。

46
00:02:45,000 --> 00:02:47,000
>> たとえば、あなたはバブルソートを実装する場合、

47
00:02:47,000 --> 00:02:50,000
またはあなたは、今日のコンピュータ上で並べ替えや選択マージソートを実装する

48
00:02:50,000 --> 00:02:53,000
2 GHzのコンピュータ、そして、あなたはそれを実行し、

49
00:02:53,000 --> 00:02:56,000
そしてそれは3ギガヘルツがある来年、秒のいくつかの番号を取る

50
00:02:56,000 --> 00:02:59,000
または4 GHzのコンピュータ、あなたはその "うわー、私のアルゴリズムを主張する可能性があります

51
00:02:59,000 --> 00:03:03,000
現実には明らかにそうではありませんその時、 "今、2倍の速さである。

52
00:03:03,000 --> 00:03:06,000
それは単にハードウェアが速くなったのですが、お使いのコンピュータ

53
00:03:06,000 --> 00:03:10,000
ので、私たちは本当にのようなものを捨てたくなかった

54
00:03:10,000 --> 00:03:13,000
2の倍数または3の倍数、それが説明に来る

55
00:03:13,000 --> 00:03:17,000
どのくらいの速またはどのように遅いアルゴリズムがあり、実際にちょうど焦点を合わせる

56
00:03:17,000 --> 00:03:20,000
nまたはそのいくつかの因子に

57
00:03:20,000 --> 00:03:24,000
先週からのソートの場合、そのようないくつかのパワー。

58
00:03:24,000 --> 00:03:27,000
とマージソートの助けを借りていることを思い出す

59
00:03:27,000 --> 00:03:31,000
私たちは、バブルソートと選択ソートよりもはるかにうまくやることができました

60
00:03:31,000 --> 00:03:33,000
さらには挿入ソート。

61
00:03:33,000 --> 00:03:36,000
>> 我々は、nログnに降りて、再び

62
00:03:36,000 --> 00:03:39,000
ログnは、一般的に育つ何かを参照していることを思い出す

63
00:03:39,000 --> 00:03:43,000
もっとゆっくりと、nので、nログnこれまで良好であった

64
00:03:43,000 --> 00:03:45,000
それは、n²未満であったため。

65
00:03:45,000 --> 00:03:47,000
しかし、マージソートとnを達成するn個のログに

66
00:03:47,000 --> 00:03:51,000
私たちが活用していたという考え方の基本胚芽何だった

67
00:03:51,000 --> 00:03:54,000
我々はまた、0週に戻って活用している？

68
00:03:54,000 --> 00:03:58,000
どのように我々はマージソートでソート巧み問題に取り組むたのですか？

69
00:03:58,000 --> 00:04:04,000
たぶん、キーの洞察力は何でしたか？

70
00:04:04,000 --> 00:04:07,000
誰も全然。

71
00:04:07,000 --> 00:04:09,000
さて、のは一歩下がってみましょう。

72
00:04:09,000 --> 00:04:11,000
あなた自身の言葉でマージソートを説明してください。

73
00:04:11,000 --> 00:04:15,000
それはどのように動作したのですか？

74
00:04:15,000 --> 00:04:17,000
さて、私たちは週に0に戻って行う。

75
00:04:17,000 --> 00:04:19,000
大丈夫、うん。

76
00:04:19,000 --> 00:04:22,000
[聞き取れない - 学生]

77
00:04:22,000 --> 00:04:26,000
さて、良いので、我々は2ピースに数字の配列を分けた。

78
00:04:26,000 --> 00:04:29,000
我々は、それらの部分のそれぞれをソートした後、我々はそれらをマージ

79
00:04:29,000 --> 00:04:33,000
この大きいです問題を取る前に、我々はこのアイデアを見てきました

80
00:04:33,000 --> 00:04:36,000
そしてこの大きなまたはこの大きいです問題にそれを刻んで。

81
00:04:36,000 --> 00:04:38,000
>> 電話帳の例を思い出してください。

82
00:04:38,000 --> 00:04:42,000
、数週間前から自己計数アルゴリズムを思い出す

83
00:04:42,000 --> 00:04:45,000
ので、マージソートはここでこの擬似コードでまとめた。

84
00:04:45,000 --> 00:04:48,000
あなたはn個の要素を与えている場合、最初のそれは健全性チェックであった。

85
00:04:48,000 --> 00:04:51,000
N <2はその後まったく何もしていない場合

86
00:04:51,000 --> 00:04:55,000
N <2、nは明らかに0または1の場合、なぜなら、

87
00:04:55,000 --> 00:04:57,000
それが0または1のいずれかの場合とそうソートするものは何もありません。

88
00:04:57,000 --> 00:04:59,000
あなたは完了です。

89
00:04:59,000 --> 00:05:01,000
あなたのリストは既に自明にソートされます。

90
00:05:01,000 --> 00:05:04,000
しかし、あなたが2つ以上の要素を持っているそうでなければ先に行くと、それらを分割

91
00:05:04,000 --> 00:05:06,000
2半分に、左と右。

92
00:05:06,000 --> 00:05:09,000
それらの半分のそれぞれをソートしてから、ソートの半分をマージします。

93
00:05:09,000 --> 00:05:13,000
しかし、ここで問題は、我々がけっているように一見しただけで、これは感じているということです。

94
00:05:13,000 --> 00:05:17,000
私はこれらのn個の要素をソートすることが求​​められてきた場合、これはその中で循環定義です

95
00:05:17,000 --> 00:05:22,000
、あなたは、 "よし、大丈夫です、我々はそれらのn / 2にし、それらのn / 2個の要素を並べ替えましょう"私は言っている

96
00:05:22,000 --> 00:05:27,000
その後、私の次の質問は "どのようにしてn / 2個の要素を並べ替えるには？、ファイン"になるだろう

97
00:05:27,000 --> 00:05:30,000
>> しかし、このためにプログラムの構造を、

98
00:05:30,000 --> 00:05:33,000
このベースケースはありますので、いわば、

99
00:05:33,000 --> 00:05:39,000
nは直ちに2リターンのようないくつかの固定値を<されている場合は言うこの特殊なケース。

100
00:05:39,000 --> 00:05:42,000
その同じ円形の答えに応答しません。

101
00:05:42,000 --> 00:05:46,000
このプロセスは、この周期性は、最終的に終了します。

102
00:05:46,000 --> 00:05:50,000
私はあなたに言わせれば "ファイン、これらのn / 2を並べ替える"、 "これらのn個の要素を並べ替え"とあなたは言う

103
00:05:50,000 --> 00:05:53,000
次にあなたが言う、 "ファイン、これらのn / 4、π/ 8、N/16を並べ替える"

104
00:05:53,000 --> 00:05:56,000
最終的には十分に大きな数で割ります

105
00:05:56,000 --> 00:05:59,000
あなたは、あなたが言うことができた時点で、わずか1要素の左を持っているだろう

106
00:05:59,000 --> 00:06:02,000
"ここ、ここにソート単一の要素です。"

107
00:06:02,000 --> 00:06:06,000
次にこのアルゴリズムの輝きがここまで事実から派生することです

108
00:06:06,000 --> 00:06:09,000
一度は、これらの個別にソートされたリストがすべて揃っていること、

109
00:06:09,000 --> 00:06:12,000
無用と思われるサイズ1、であるこれらは全て、

110
00:06:12,000 --> 00:06:15,000
一度あなたがそれらをマージし、それらをマージし始めた

111
00:06:15,000 --> 00:06:19,000
ロブは、ビデオで最後にソートされたリストを行ったように、あなたは最終的にビルドアップ。

112
00:06:19,000 --> 00:06:22,000
>> しかし、この考え方は、はるかにソートを超えて延びている。

113
00:06:22,000 --> 00:06:26,000
再帰と呼ばれるこのプログラムに組み込まれたこのアイデアは、あります

114
00:06:26,000 --> 00:06:29,000
あなたがプログラムであることによりアイデア、

115
00:06:29,000 --> 00:06:32,000
そして、あなた自身を呼び出すいくつかの問題を解決するために

116
00:06:32,000 --> 00:06:36,000
または、あなたが機能しているプログラミング言語のコンテキストに配置

117
00:06:36,000 --> 00:06:39,000
と問題を解決するためには、関数が自分自身を呼び出す

118
00:06:39,000 --> 00:06:42,000
何度も何度もくり返しますが、機能

119
00:06:42,000 --> 00:06:44,000
自分自身に無限に多くの時間を呼び出すことはできません。

120
00:06:44,000 --> 00:06:47,000
最終的には、いわば底打ちしなければならない

121
00:06:47,000 --> 00:06:49,000
と言って、いくつかのハードコードされた基本条件を持っている

122
00:06:49,000 --> 00:06:53,000
この時点では、そうあなた自身の呼び出しを止める、そのプロセス全体

123
00:06:53,000 --> 00:06:56,000
最後に、実際には停止はない。

124
00:06:56,000 --> 00:06:58,000
これは本当に再帰的に、どういう意味ですか？

125
00:06:58,000 --> 00:07:01,000
>> 我々は、言う、の、単純な、簡単な例を行うことができれば、見てみましょう

126
00:07:01,000 --> 00:07:03,000
ここまでの段階で私と一緒に3人、誰かが快適であれば。

127
00:07:03,000 --> 00:07:06,000
まで、2と3で1を、来る。

128
00:07:06,000 --> 00:07:09,000
あなたは3がここに来たい場合。

129
00:07:09,000 --> 00:07:12,000
あなたがラインにここに私の隣に立って右側にする場合は、手でその問題を仮定

130
00:07:12,000 --> 00:07:15,000
非常に些細なことにここにいる人々の数を数えています。

131
00:07:15,000 --> 00:07:18,000
しかし、率直に言って、私はこれらすべてのカウント例の疲れ。

132
00:07:18,000 --> 00:07:21,000
これは、いくつかの時間、1、2、ドット、ドット、ドットを取るために起こっている。

133
00:07:21,000 --> 00:07:23,000
それは永遠に取るつもりです。

134
00:07:23,000 --> 00:07:25,000
私はただ助けを借りて、完全パントこの問題の、何あなたの名前ですか？むしろほしいの

135
00:07:25,000 --> 00:07:27,000
サラ。>>サラ、大丈夫。

136
00:07:27,000 --> 00:07:29,000
ケリー。>>ケリーと？

137
00:07:29,000 --> 00:07:31,000
>> ウィリー。>>ウィリー、サラ、ケリー、ウィリー。

138
00:07:31,000 --> 00:07:34,000
今、私は、誰かが質問をさ​​れました

139
00:07:34,000 --> 00:07:37,000
どのように多くの人がこのステージに上がっており、私にはわかりません。

140
00:07:37,000 --> 00:07:40,000
これは本当に長いリストですので、代わりに私はこのトリックをするつもりです。

141
00:07:40,000 --> 00:07:43,000
私はほとんどの作業を行うために私の隣の人に依頼するつもりですが、

142
00:07:43,000 --> 00:07:46,000
そして一度、彼女はほとんどの作業をやって行われ

143
00:07:46,000 --> 00:07:49,000
私はできるだけ少ない操作を行うと、わずか1を追加するつもり

144
00:07:49,000 --> 00:07:51,000
ので、ここで我々が​​行っているものは何でも彼女の答えに。

145
00:07:51,000 --> 00:07:54,000
私は、ステージ上にあるどのように多くの人が求めてきた。

146
00:07:54,000 --> 00:07:57,000
あなたの左にステージ上で何人ですか？

147
00:07:57,000 --> 00:08:00,000
オーケー？>>私の左が、カンニングしないでください。

148
00:08:00,000 --> 00:08:04,000
それが正しいだと、良いことだが、我々はこのロジックを続行するかどうか

149
00:08:04,000 --> 00:08:08,000
、あなたは同様にあなたの左にパントこの問題をすると仮定してみましょう

150
00:08:08,000 --> 00:08:11,000
そうではなく答えより直接先に行くと、ちょうど責任転嫁。

151
00:08:11,000 --> 00:08:14,000
ああ、私の左側には何人ですか？

152
00:08:14,000 --> 00:08:16,000
左には何人ですか？

153
00:08:16,000 --> 00:08:18,000
1。

154
00:08:18,000 --> 00:08:27,000
[笑い]

155
00:08:27,000 --> 00:08:30,000
さて、0、だから何今ウィリーが行っている

156
00:08:30,000 --> 00:08:33,000
あなたはこの方向が0を言っ答えを返されました。

157
00:08:33,000 --> 00:08:36,000
さて、あなたは何をすべきでしょうか？>> 1。

158
00:08:36,000 --> 00:08:39,000
さて、あなたは1だので、あなたが言う、 "すべての権利、私は1を追加するつもり

159
00:08:39,000 --> 00:08:41,000
にどのようなウィリーのカウントだった "ので、1 + 0。

160
00:08:41,000 --> 00:08:43,000
右にあなたの答えがあるように、今や1だ今では

161
00:08:43,000 --> 00:08:45,000
1 >>と鉱山は2になります。

162
00:08:45,000 --> 00:08:48,000
、良いので、1の前の回答を取っている

163
00:08:48,000 --> 00:08:51,000
あなたがやりたい仕事の最小限の量を追加して、1である。

164
00:08:51,000 --> 00:08:55,000
これで、2を持っていて、その後、私の値を渡す？

165
00:08:55,000 --> 00:08:57,000
3、私は、申し訳ありませんが、2を意味する。

166
00:08:57,000 --> 00:08:59,000
グッド。

167
00:08:59,000 --> 00:09:02,000
>> まあ、我々は左側に0を持っていた。

168
00:09:02,000 --> 00:09:05,000
、その後、我々は1を持っていたし、我々は2を追加

169
00:09:05,000 --> 00:09:07,000
そして今、あなたは私の2番を渡している、

170
00:09:07,000 --> 00:09:10,000
そして私は3、1、大丈夫、と言っている。

171
00:09:10,000 --> 00:09:13,000
この段階で私の隣に立っている3人は、確かにありま​​す

172
00:09:13,000 --> 00:09:16,000
ので、我々は明らかに、非常に直線的にこれを行っている可能性が

173
00:09:16,000 --> 00:09:19,000
明白な方法で非常に多く、私たちは本当に何をしましたか？

174
00:09:19,000 --> 00:09:21,000
当初はサイズが3の問題を取った。

175
00:09:21,000 --> 00:09:24,000
次に、サイズ2の問題にそれを壊した

176
00:09:24,000 --> 00:09:27,000
その後、サイズ1の問題、そして最後に、ベースケース

177
00:09:27,000 --> 00:09:29,000
本当に、ああ、そこに誰もありませんでした

178
00:09:29,000 --> 00:09:33,000
その時点でウィリーは、数回効果的にハードコードされた答えを返さ

179
00:09:33,000 --> 00:09:36,000
そして2つ目は、その後、バブルアップバブルアップ、バブルアップされました

180
00:09:36,000 --> 00:09:39,000
その後追加のこの1 1に追加することによって、

181
00:09:39,000 --> 00:09:41,000
我々は、再帰のこの基本的な考え方を実装しました。

182
00:09:41,000 --> 00:09:44,000
>> さて、このケースでは、それは本当に問題を解決しなかった

183
00:09:44,000 --> 00:09:46,000
任意のより効果的に、我々はこれまで見てきました。

184
00:09:46,000 --> 00:09:48,000
しかし、我々はこれまで、ステージ上で行われてきたアルゴリズムを考える。

185
00:09:48,000 --> 00:09:51,000
私たちは、黒板に紙の8個を持っていた

186
00:09:51,000 --> 00:09:55,000
ビデオにショーンは7番を探していた、と彼は本当に何をしたとき？

187
00:09:55,000 --> 00:09:58,000
まあ、彼は、除算のどんなことをして征服しなかった。

188
00:09:58,000 --> 00:10:01,000
彼は、再帰のどんなことをしませんでした。

189
00:10:01,000 --> 00:10:03,000
むしろ、彼はちょうどこの線形アルゴリズムをやった。

190
00:10:03,000 --> 00:10:07,000
しかし、私たちがステージ上でソートされた数字の考え方を導入したとき、先週暮らす

191
00:10:07,000 --> 00:10:09,000
次に我々は、真ん中に行くのこの本能を持っていた

192
00:10:09,000 --> 00:10:13,000
その時点で我々は、サイズ4またはサイズ4の別のリストの小さいリストを持っていた

193
00:10:13,000 --> 00:10:17,000
その後、我々は正確に同じ問題を抱えていたので、私たちは繰り返し、繰り返し、繰り返し。

194
00:10:17,000 --> 00:10:19,000
言い換えれば、私たちは再帰。

195
00:10:19,000 --> 00:10:24,000
私達と再帰を実証するためにここに私たち3人のボランティアにどうもありがとうございます。

196
00:10:24,000 --> 00:10:28,000
>> 、我々は今、もう少し具体的なこれを作ることができないかどうかを確認してみましょう

197
00:10:28,000 --> 00:10:30,000
再び我々は非常に簡単に行うことがあった問題を解決するため、

198
00:10:30,000 --> 00:10:34,000
しかし、我々はこの基本的な考え方を実装するための足がかりとして、それを使用します。

199
00:10:34,000 --> 00:10:37,000
私は数字の束の総和を計算する場合は、

200
00:10:37,000 --> 00:10:39,000
例えば、あなたが3番で合格した場合、

201
00:10:39,000 --> 00:10:42,000
私はあなたにシグマ3の値を与えたい

202
00:10:42,000 --> 00:10:46,000
SO 3の合計+ 2 + 1 + 0。

203
00:10:46,000 --> 00:10:48,000
私は、答え6戻って取得したい

204
00:10:48,000 --> 00:10:51,000
ので、我々はこのシグマ関数、この総和関数を実装します

205
00:10:51,000 --> 00:10:54,000
つまり、もう一度、入力を取り込み、その後総和を返す

206
00:10:54,000 --> 00:10:57,000
その番号0までのすべての方法の。

207
00:10:57,000 --> 00:10:59,000
我々は、右、非常に簡単にこれを行うことができる？

208
00:10:59,000 --> 00:11:01,000
我々は、ループ構造のいくつかの種類でこれを行うことができます

209
00:11:01,000 --> 00:11:04,000
ので、私は先に行くと、これは始めましょう。

210
00:11:04,000 --> 00:11:07,000
>> stdio.hをインクルードします。

211
00:11:07,000 --> 00:11:09,000
ここで動作するように私は主に自分自身を取得しましょう​​。

212
00:11:09,000 --> 00:11:12,000
sigma.cとしてこれを保存してみましょう。

213
00:11:12,000 --> 00:11:14,000
それから私は、ここに行くつもりです、と私は、int型のnを宣言するつもりだ

214
00:11:14,000 --> 00:11:18,000
そして私は、ユーザーが協力しないしながら次のことを行うつもりです。

215
00:11:18,000 --> 00:11:22,000
ユーザーは私に正番号を与えられていないものの

216
00:11:22,000 --> 00:11:26,000
私が先に行くとn =の場合、getIntのためにそれらを促すことができ、

217
00:11:26,000 --> 00:11:28,000
そして、私は彼らに何をすべきかなど、いくつかの手順を示すことができ

218
00:11:28,000 --> 00:11:33,000
そうのprintf（ "正の整数ください"）。

219
00:11:33,000 --> 00:11:39,000
時間によって我々は14行目にヒットするように、このような比較的単純なだけで何か

220
00:11:39,000 --> 00:11:42,000
我々は今のnおそらく正の整数があります。

221
00:11:42,000 --> 00:11:44,000
>> 今それを使って何かをしてみましょう。

222
00:11:44,000 --> 00:11:50,000
ので、int型の合計=Σ（n）は、私が先に行くと、総和を計算しましょう​​。

223
00:11:50,000 --> 00:11:54,000
シグマは単なる総和であるので、私は手の込んだ方法でそれを書いています。

224
00:11:54,000 --> 00:11:56,000
我々は、ちょうどそこには、シグマと呼ぶことにします。

225
00:11:56,000 --> 00:11:58,000
それは和だし、今私は、結果をプリントアウトするつもりだ

226
00:11:58,000 --> 00:12:08,000
のprintf（ "和は％dは、\ n"の合計）。

227
00:12:08,000 --> 00:12:11,000
そして私は良い測定のために0を返しています。

228
00:12:11,000 --> 00:12:15,000
我々は、面白い部分を除き、このプログラムが必要とするすべてのものをやった

229
00:12:15,000 --> 00:12:18,000
これは、実際にシグマ関数を実装することです。

230
00:12:18,000 --> 00:12:22,000
>> 私は底にここに降りて行き、私はシグマ関数を宣言してみましょうましょう。

231
00:12:22,000 --> 00:12:26,000
これは、整数型の変数を取るようになっている

232
00:12:26,000 --> 00:12:30,000
どのようなデータ型は、私はシグマからおそらく返すようにしたいのですか？

233
00:12:30,000 --> 00:12:34,000
int型、私はそれが15行目で私の期待を一致させたいので。

234
00:12:34,000 --> 00:12:37,000
ここで私が先に行くと、これを実装してみましょう

235
00:12:37,000 --> 00:12:41,000
かなり簡単な方法で。

236
00:12:41,000 --> 00:12:45,000
>> 先に進み、intの和= 0を言わせて、

237
00:12:45,000 --> 00:12:47,000
そして今、私はここでループのために少しを持って行くつもりです

238
00:12:47,000 --> 00:12:50,000
それは、このような何かを言おうとしている

239
00:12:50,000 --> 00:13:01,000
合計+ = I（;、I <=番号i + +のint i = 0のとき）のために。

240
00:13:01,000 --> 00:13:05,000
そして私は和を返すつもりです。

241
00:13:05,000 --> 00:13:07,000
私は、任意の数の方法でこれを実装している可能性があります。

242
00:13:07,000 --> 00:13:09,000
私は、whileループを使用することもできました。

243
00:13:09,000 --> 00:13:11,000
私は、私が本当にしたい場合はsum変数を使用して、スキップしたかもしれない

244
00:13:11,000 --> 00:13:15,000
しかし、一言で言えば、我々はちょうど私がしなかったらへまは和が0であることを宣言している関数を持っています。

245
00:13:15,000 --> 00:13:18,000
それは、数字を通って0からの繰り返し処理

246
00:13:18,000 --> 00:13:23,000
し、反復のたびに、それは合計にその現在の値を追加し、合計を返します。

247
00:13:23,000 --> 00:13:25,000
>> さて、ここで若干の最適化あり。

248
00:13:25,000 --> 00:13:29,000
これはおそらく、無駄なステップですが、そのためである。今のところ、それで結構です。

249
00:13:29,000 --> 00:13:32,000
我々は、少なくともしている徹底していると、最大で0すべての道を行く。

250
00:13:32,000 --> 00:13:34,000
非常に硬く、非常に簡単ではない、

251
00:13:34,000 --> 00:13:37,000
それはシグマ関数と我々は同じ機会を持っていることが判明

252
00:13:37,000 --> 00:13:39,000
私たちはステージ上でここで行ったように。

253
00:13:39,000 --> 00:13:42,000
ステージ上で私達はちょうど、私の隣にいたどのように多くの人々にカウント

254
00:13:42,000 --> 00:13:47,000
その代わりに、我々は数3 + 2 + 1を数えたい場合

255
00:13:47,000 --> 00:13:51,000
0までに我々は関数と同様にパントする可能性

256
00:13:51,000 --> 00:13:55,000
私の代わりに再帰的なものとして説明しますことを。

257
00:13:55,000 --> 00:13:57,000
ここでは簡単なサニティチェック、私がへまをしなかったことを確認してみましょうか。

258
00:13:57,000 --> 00:14:00,000
>> 私が間違ってたんだ、このプログラムの少なくとも1つの事があると知っている。

259
00:14:00,000 --> 00:14:04,000
私は入力を打ったとき、私は私に叫んでの任意の種類を取得するつもりです？

260
00:14:04,000 --> 00:14:06,000
何私は約怒鳴らするつもりです？

261
00:14:06,000 --> 00:14:11,000
ええ、私はプロトタイプを忘れたので、私は15行目でシグマと呼ばれる機能を使用しています

262
00:14:11,000 --> 00:14:16,000
しかしそれは22行まで宣言なので、私は積極的にここで最高の上がらないだ

263
00:14:16,000 --> 00:14:22,000
とプロトタイプを宣言し、私は（int型数値）int型シグマを言うよ、とそれはそれだ。

264
00:14:22,000 --> 00:14:24,000
これは、下部に実装されています。

265
00:14:24,000 --> 00:14:27,000
>> 私はこれを解決することができ、または別の方法、

266
00:14:27,000 --> 00:14:30,000
私は、悪くなっていない、そこに機能を移動することができます

267
00:14:30,000 --> 00:14:32,000
しかし、少なくとも、あなたのプログラムは、率直に言って、長く得るために起動したとき

268
00:14:32,000 --> 00:14:35,000
私はいつも一番上にメインを持っていることのいくつかの価値があると思う

269
00:14:35,000 --> 00:14:38,000
あなたはリーダーでファイルを開き、その直後に見ることができるように

270
00:14:38,000 --> 00:14:40,000
プログラムは、それを介して検索しなくてもやっていること

271
00:14:40,000 --> 00:14:42,000
その主な機能を探しています。

272
00:14:42,000 --> 00:14:49,000
、のはシグマはシグマを作る作ってみて、ここに私の端末ウィンドウにダウンして行こう

273
00:14:49,000 --> 00:14:51,000
と私はここにもしくじった。

274
00:14:51,000 --> 00:14:55,000
関数の場合、getIntの暗黙的な宣言は、私は他に何を行うのを忘れたことを意味？

275
00:14:55,000 --> 00:14:57,000
[聞き取れない - 学生]

276
00:14:57,000 --> 00:15:00,000
良いので、明らかに一般的な間違い、それでは、ここで、このアップを入れてみましょう

277
00:15:00,000 --> 00:15:04,000
cs50.h、今の私の端末ウィンドウに戻りましょう。

278
00:15:04,000 --> 00:15:08,000
>> 私は、画面をクリアします、そして、私はシグマを行い再実行します。

279
00:15:08,000 --> 00:15:11,000
これは、コンパイルされているようだ。私は今、シグマを実行してみましょう。

280
00:15:11,000 --> 00:15:15,000
私は3番で入力しますと、私は6を手に入れた、そうではない厳密なチェック

281
00:15:15,000 --> 00:15:18,000
少なくともそれは一見しただけでは動作しているようだが、今度はそれをバラバラにすることができ、

282
00:15:18,000 --> 00:15:21,000
としましょう​​、実際には、再度、再帰の考え方を活用

283
00:15:21,000 --> 00:15:24,000
非常に単純な文脈でそのように数週間の時間内に

284
00:15:24,000 --> 00:15:27,000
私たちは、配列よりもより複雑なデータ構造の探索を開始するとき

285
00:15:27,000 --> 00:15:30,000
我々は、にしてツールキット内の別のツールを持っている

286
00:15:30,000 --> 00:15:33,000
我々がわかるように、これらのデータ構造を操作する。

287
00:15:33,000 --> 00:15:36,000
これは、反復的なアプローチは、ループベースのアプローチです。

288
00:15:36,000 --> 00:15:39,000
>> 今これを行う代わりにさせて頂いております。

289
00:15:39,000 --> 00:15:44,000
数の総和と言う代わりに私を聞かせて

290
00:15:44,000 --> 00:15:48,000
0までに本当にと同じものです

291
00:15:48,000 --> 00:15:53,000
番号+シグマ（数 -  1）。

292
00:15:53,000 --> 00:15:57,000
言い換えれば、ただステージ上のように私は、私の隣の人のそれぞれにパント

293
00:15:57,000 --> 00:16:00,000
そして、彼らは順番に、我々は最終的にウィリーを底までパントに保た

294
00:16:00,000 --> 00:16:03,000
誰が0のような、ハードコーディングされた答えを返すことがありました。

295
00:16:03,000 --> 00:16:07,000
ここで今、私たちは同様にシグマにパントしている

296
00:16:07,000 --> 00:16:10,000
ここで最初に呼び出された場合と同じ機能ですが、キーの洞察力

297
00:16:10,000 --> 00:16:12,000
我々は同じようにシグマを呼び出していないことです。

298
00:16:12,000 --> 00:16:14,000
我々は、nを渡していない。

299
00:16:14,000 --> 00:16:17,000
我々は明らかに数を渡している -  1、

300
00:16:17,000 --> 00:16:20,000
そうわずかに小さい問題、若干小さい問題。

301
00:16:20,000 --> 00:16:23,000
>> 残念ながら、これはまだかなりのソリューションではありません、我々は修正前

302
00:16:23,000 --> 00:16:26,000
あなた方のうちの何人かははっきりと何が飛び出すかもしれません

303
00:16:26,000 --> 00:16:28,000
私が先に行くとmakeを再実行してみましょう。

304
00:16:28,000 --> 00:16:30,000
それは大丈夫コンパイルするようです。

305
00:16:30,000 --> 00:16:32,000
私は6でシグマを再実行してみましょう。

306
00:16:32,000 --> 00:16:37,000
おっと、私は6でシグマを再実行してみましょう。

307
00:16:37,000 --> 00:16:42,000
我々としても誤って前回とはいえ、前にこれを見てきました。

308
00:16:42,000 --> 00:16:48,000
なぜ私はこの不可解なセグメンテーションフォールトを取得するのですか？うん。

309
00:16:48,000 --> 00:16:50,000
[聞き取れない - 学生]

310
00:16:50,000 --> 00:16:53,000
おそらく何が起こったのか、より具体的にはそこにはベースケースはありません、と？

311
00:16:53,000 --> 00:16:58,000
これは何の行動の症状ですか？

312
00:16:58,000 --> 00:17:00,000
もう少し大きな声でそれを言う。

313
00:17:00,000 --> 00:17:02,000
[聞き取れない - 学生]

314
00:17:02,000 --> 00:17:05,000
それは効果的に無限ループだし、無限ループに問題がある

315
00:17:05,000 --> 00:17:08,000
自分自身を呼び出し、彼らがこのケースでは再帰を含む、関数、

316
00:17:08,000 --> 00:17:10,000
何は、関数を呼び出すたびに起こりますか？

317
00:17:10,000 --> 00:17:13,000
まあ、我々はコンピュータのメモリを打ち出した方法に戻すと思います。

318
00:17:13,000 --> 00:17:16,000
我々は、最下部のスタックと呼ば​​れるメモリのこの塊があることを言った

319
00:17:16,000 --> 00:17:19,000
もう少しメモリが置かれる関数を呼び出すと、毎回

320
00:17:19,000 --> 00:17:24,000
その関数のローカル変数やパラメータを含むこのいわゆるスタック上で、

321
00:17:24,000 --> 00:17:27,000
シグマはシグマ·コールを呼び出すので、もしシグマはシグマ呼び出し

322
00:17:27,000 --> 00:17:29,000
 この物語の終わりを行いどこシグマコールします？

323
00:17:29,000 --> 00:17:31,000
>> まあ、それは最終的にオーバーラン総額

324
00:17:31,000 --> 00:17:33,000
お使いのコンピュータに使用可能であることメモリの。

325
00:17:33,000 --> 00:17:37,000
あなたは、あなたが内に滞在することになっているセグメントを、オーバーラン

326
00:17:37,000 --> 00:17:40,000
そしてあなたはこのセグメンテーションフォールトを取得、コアは、ダンプ

327
00:17:40,000 --> 00:17:43,000
とダンプ何コア意味は、私はコアと呼ばれるファイルを持っているということです

328
00:17:43,000 --> 00:17:46,000
これは、0と1を含むファイルです

329
00:17:46,000 --> 00:17:49,000
ことは、実際には将来における診断に有用であろう。

330
00:17:49,000 --> 00:17:52,000
あなたのバグがどこにあるか、それはあなたに明らかではない場合

331
00:17:52,000 --> 00:17:54,000
あなたは実際に、いわば、法医学的分析のビットを行うことができます

332
00:17:54,000 --> 00:17:58,000
再び、ちょうどゼロとものの全体の束であり、このコアダンプファイル、上

333
00:17:58,000 --> 00:18:02,000
本質的に、メモリ内のプログラムの状態を表す

334
00:18:02,000 --> 00:18:05,000
瞬間、それはこのように墜落した。

335
00:18:05,000 --> 00:18:11,000
>> ここで修正は、我々はただやみくもに、シグマを返すことができないということです

336
00:18:11,000 --> 00:18:14,000
数+若干小さい問題のシグマ。

337
00:18:14,000 --> 00:18:16,000
我々はここで、ベースケースのいくつかの種類を持っている必要があり、

338
00:18:16,000 --> 00:18:19,000
とベースケースは、おそらく何すべきですか？

339
00:18:19,000 --> 00:18:22,000
[聞き取れない - 学生]

340
00:18:22,000 --> 00:18:25,000
わかりましたので、長い数値が正であるとして、我々は実際に、これを返すべき

341
00:18:25,000 --> 00:18:29,000
あるいは別の言い方をすれば、数であれば、言う、<= 0〜

342
00:18:29,000 --> 00:18:32,000
あなたは、私が先に行くと0を返します何、知っている

343
00:18:32,000 --> 00:18:36,000
ウィリーがやったのと同じように、そしてそれ以外に、私は先に行くつもりです

344
00:18:36,000 --> 00:18:41,000
これを返すので、それはそれほど短くないです

345
00:18:41,000 --> 00:18:44,000
我々は最初のforループを使って手早くことを反復バージョンより、

346
00:18:44,000 --> 00:18:48,000
それにエレガンスのこの種があることがわかります。

347
00:18:48,000 --> 00:18:51,000
代わりにいくつかの数を返し、すべてこの演算を行うの

348
00:18:51,000 --> 00:18:54,000
とローカル変数で物事を加算

349
00:18:54,000 --> 00:18:57,000
これは超簡単な問題である場合は、代わりに、オーケー "と言っている、

350
00:18:57,000 --> 00:19:01,000
数が<0であるように、私はすぐに0を返すようにしてください。 "

351
00:19:01,000 --> 00:19:03,000
>> 我々は、支持負の数を気にするつもりはない

352
00:19:03,000 --> 00:19:05,000
ので、私はハードコードに0の値をつもりです。

353
00:19:05,000 --> 00:19:08,000
しかし、そうでなければ、加算のこのアイデアを実装する

354
00:19:08,000 --> 00:19:11,000
あなたが効果的に小さな一口を取ることができます一緒にこれらの数字のすべて

355
00:19:11,000 --> 00:19:14,000
外の問題、私たちがステージ上でここでやったのと同じように、

356
00:19:14,000 --> 00:19:18,000
その後パント次の人に問題の残りの部分、

357
00:19:18,000 --> 00:19:20,000
しかしこのケースでは次の人が自分自身である。

358
00:19:20,000 --> 00:19:22,000
これは、同じ名前の関数です。

359
00:19:22,000 --> 00:19:25,000
ちょうどそれは、小さく、小さく問題を毎回渡す

360
00:19:25,000 --> 00:19:28,000
そして我々はここに、コード内ではない非常に形式化されたものを持っているにもかかわらず、

361
00:19:28,000 --> 00:19:33,000
これは、電話帳で0週目に何が起こっていたかを正確になります。

362
00:19:33,000 --> 00:19:36,000
これはショーンとの過去数週間で起こっていたとおりのものである

363
00:19:36,000 --> 00:19:39,000
と番号を検索私たちのデモンストレーション。

364
00:19:39,000 --> 00:19:42,000
それは問題を取って、何度も何度もそれを分割だ。

365
00:19:42,000 --> 00:19:44,000
>> 言い換えれば、翻訳の今方法がある

366
00:19:44,000 --> 00:19:47,000
この現実世界の構造物、このような高いレベルの構成

367
00:19:47,000 --> 00:19:51,000
分割統治と何度も何度も何かをする

368
00:19:51,000 --> 00:19:56,000
コー​​ドの中で、これは我々が時間をかけて再び表示されます何かである。

369
00:19:56,000 --> 00:20:00,000
あなたは再帰に慣れていないさて、余談として、あなたは、少なくとも今理解しておく必要があります

370
00:20:00,000 --> 00:20:02,000
なぜこれが面白いです。

371
00:20:02,000 --> 00:20:05,000
私は、google.comに行くつもりです

372
00:20:05,000 --> 00:20:17,000
と私は再帰のいくつかのヒントやトリックを検索するつもりだ、と入力します。

373
00:20:17,000 --> 00:20:21,000
彼らはちょうど今笑っていなかった場合、あなたの隣の人を教えてください。

374
00:20:21,000 --> 00:20:23,000
あなたは、再帰を意味しましたか？

375
00:20:23,000 --> 00:20:25,000
あなたがしたことを意味 - ああ、そこに私達は行く。

376
00:20:25,000 --> 00:20:28,000
さて、それは皆の残りです。

377
00:20:28,000 --> 00:20:30,000
グーグルでどこかに埋め込まれた小さなイースターエッグ。

378
00:20:30,000 --> 00:20:33,000
余談ですが、私たちはもちろんのウェブサイトに置くのいずれかのリンク

379
00:20:33,000 --> 00:20:36,000
今日のために、単に様々なソートアルゴリズムのこのグリッドです

380
00:20:36,000 --> 00:20:39,000
我々は先週見ましたが、何がこの可視化についての素晴らしいですそのうちのいくつか

381
00:20:39,000 --> 00:20:43,000
あなたは、アルゴリズムに関連する様々な物事の周りにあなたの心をラップしようとして

382
00:20:43,000 --> 00:20:46,000
あなたは非常に簡単になりました、異なるタイプの入力で開始できることを知っている。

383
00:20:46,000 --> 00:20:50,000
入力はすべての入力がランダムなど、入力はほとんどソートされ、逆転した。

384
00:20:50,000 --> 00:20:53,000
あなたがしようとして、もう一度、あなたの心にこれらのものを区別する

385
00:20:53,000 --> 00:20:57,000
講義ページでコースのウェブサイトにこのURLを実現

386
00:20:57,000 --> 00:21:00,000
もしそれらのいくつかを理由に役立つかもしれない。

387
00:21:00,000 --> 00:21:05,000
>> 今日、我々は最終的に、しばらく前から、この問題を解決するために取得

388
00:21:05,000 --> 00:21:08,000
これは、このスワップ機能がうまく動作しなかったということでした

389
00:21:08,000 --> 00:21:12,000
そして、この関数swapを持つ根本的な問題は何だった

390
00:21:12,000 --> 00:21:15,000
の目標は、こことここに値をやりとりするために、再び、でした

391
00:21:15,000 --> 00:21:17,000
これが発生するような？

392
00:21:17,000 --> 00:21:20,000
これは実際には動作しませんでした。なぜですか？

393
00:21:20,000 --> 00:21:22,000
うん。

394
00:21:22,000 --> 00:21:28,000
[聞き取れない - 学生]

395
00:21:28,000 --> 00:21:31,000
まさに、このbugginessの説明

396
00:21:31,000 --> 00:21:34,000
あなたがC言語の関数を呼び出すときというだけの理由だった

397
00:21:34,000 --> 00:21:38,000
それらの関数は、aとbここのように、引数を取る

398
00:21:38,000 --> 00:21:42,000
あなたはその関数に提供している任意の値のコピーを渡しています。

399
00:21:42,000 --> 00:21:46,000
あなたは、元の値自体を提供していない

400
00:21:46,000 --> 00:21:49,000
ので、我々は、buggycの文脈でこれを見た

401
00:21:49,000 --> 00:21:52,000
このような少し何かを見てbuggy3.c、。

402
00:21:52,000 --> 00:21:57,000
>> 我々はxとyがそれぞれ1と2に初期化していたことを思い出してください。

403
00:21:57,000 --> 00:21:59,000
我々は、彼らが何であったかをプリントアウト。

404
00:21:59,000 --> 00:22:03,000
私はその後、私はx、yのスワップを呼び出すことによって、それらをスワッピングされたと主張した。

405
00:22:03,000 --> 00:22:06,000
しかし、問題は、スワッピングが働いていたということでした

406
00:22:06,000 --> 00:22:10,000
だけスワップ機能自体の範囲インチ

407
00:22:10,000 --> 00:22:13,000
我々は、40行目これらスワップの値を打つとすぐに

408
00:22:13,000 --> 00:22:16,000
捨てられた、など何もない

409
00:22:16,000 --> 00:22:21,000
元の関数でメインは実際にはまったく変更されました、

410
00:22:21,000 --> 00:22:26,000
ので、これは私たちの記憶の面でどのように見えるかのように当時と思われる場合

411
00:22:26,000 --> 00:22:29,000
このボードの左側を表している場合、

412
00:22:29,000 --> 00:22:33,000
と私は見て皆のために全力を尽くしますこの-IFボードのこの左側

413
00:22:33,000 --> 00:22:37,000
表し、あなたのRAMを言うと、スタックは、この上昇途中で成長しようとしている

414
00:22:37,000 --> 00:22:43,000
私たちは主のような関数を呼び出すと、メインは、2つのローカル変数xとyを持っています

415
00:22:43,000 --> 00:22:48,000
、ここでxとしてそれらを記述し、これらのヒアyなどを記述してみましょう

416
00:22:48,000 --> 00:22:55,000
そして、そう、これはここのメインですが、値1と2を入れてみましょう

417
00:22:55,000 --> 00:22:58,000
そしてメインは、オペレーティングシステムのスワップ関数を呼び出すときに

418
00:22:58,000 --> 00:23:02,000
スタックにスワップ機能、メモリの独自スワスを与える

419
00:23:02,000 --> 00:23:04,000
スタック上の独自のフレームは、いわば。

420
00:23:04,000 --> 00:23:08,000
また、これらの整数のための32ビットを割り当てます。

421
00:23:08,000 --> 00:23:11,000
それは彼らとbを呼び出すことになりますが、それは全くの自由です。

422
00:23:11,000 --> 00:23:13,000
それはそれは望んでいるものは何でもそれらを呼ばれるかもしれないが、ときにメイン何が起こる

423
00:23:13,000 --> 00:23:19,000
通話スワップは、それが、この1を取りそこにコピーを置き、そこにコピーを置きです。

424
00:23:19,000 --> 00:23:23,000
>> スワップの1他のローカル変数があります、しかし、何と呼ばれる？>> tmpです。

425
00:23:23,000 --> 00:23:27,000
tmpは、だから、私は自分自身にここで別の32ビットを与えることができます

426
00:23:27,000 --> 00:23:29,000
と私は、この関数の中で何をしましたか？

427
00:23:29,000 --> 00:23:34,000
私はint tmpが取得言ったので1を持っているので、我々が最後にこの例でプレイした時、私はこれをしなかった。

428
00:23:34,000 --> 00:23:39,000
次にbを取得するので、bが2であるので、今、これは2になり、

429
00:23:39,000 --> 00:23:42,000
そして今、bは温度を取得するので、一時は1です

430
00:23:42,000 --> 00:23:44,000
ので、今bがこのになります。

431
00:23:44,000 --> 00:23:46,000
それは素晴らしいことだ。うまくいった。

432
00:23:46,000 --> 00:23:49,000
しかし、その後、できるだけ早く関数が戻ったとして

433
00:23:49,000 --> 00:23:52,000
スワップのメモリを効果的にそれを再利用できるように消える

434
00:23:52,000 --> 00:23:58,000
将来的には他のいくつかの関数によって、メインは明らかに完全に変更されていません。

435
00:23:58,000 --> 00:24:00,000
我々は、この問題を根本的に解決するための方法が必要

436
00:24:00,000 --> 00:24:03,000
今日我々は最終的にそれによってこれを行う方法があるでしょう

437
00:24:03,000 --> 00:24:06,000
我々は、ポインタと呼ばれるものを導入することができます。

438
00:24:06,000 --> 00:24:09,000
それは、我々はこの問題を解決することができることが判明

439
00:24:09,000 --> 00:24:12,000
xとyのコピーを渡していないことによって

440
00:24:12,000 --> 00:24:18,000
その代わりに何かを渡すことによって、スワップ機能に、思いますか？

441
00:24:18,000 --> 00:24:20,000
うん、何のアドレスでしょうか？

442
00:24:20,000 --> 00:24:22,000
私たちは本当に、はるかに詳細にアドレスについて話をしていない

443
00:24:22,000 --> 00:24:25,000
しかし、この黒板は私のコンピュータのメモリを表す場合

444
00:24:25,000 --> 00:24:28,000
我々は確かに私のRAMにバイトに番号を開始することができます

445
00:24:28,000 --> 00:24:31,000
そして、これは第1バイトであると言う、これはバイト＃3、＃2バイトです

446
00:24:31,000 --> 00:24:35,000
バイト＃4、バイト＃...20億私は2 GBのRAMを持っている場合、

447
00:24:35,000 --> 00:24:38,000
ので、我々は確かにいくつかの任意のナンバリングスキームを考え出すこと

448
00:24:38,000 --> 00:24:41,000
私のコンピュータのメモリ内のすべての個々のバイトのために。

449
00:24:41,000 --> 00:24:43,000
>> 私はスワップを呼び出したときに代わりになら

450
00:24:43,000 --> 00:24:47,000
xとyのコピーを渡すのではなく、

451
00:24:47,000 --> 00:24:51,000
なぜ私が代わりに、ここでxのアドレスを渡さない

452
00:24:51,000 --> 00:24:55,000
基本的にここでyのアドレス、住所

453
00:24:55,000 --> 00:24:59,000
xとyの彼は知らされている場合、その後、スワップので

454
00:24:59,000 --> 00:25:01,000
xとyのメモリ内のアドレスの、

455
00:25:01,000 --> 00:25:04,000
我々は彼を少し訓練した場合、その後、スワップ

456
00:25:04,000 --> 00:25:07,000
彼は潜在的に、いわば、そのアドレスに運転できる

457
00:25:07,000 --> 00:25:11,000
xおよびyのアドレスにドライブしてから、そこに番号を変更し、

458
00:25:11,000 --> 00:25:16,000
実際にそれらの値自身のコピーを取得していないながらも、そこに番号を変更し、

459
00:25:16,000 --> 00:25:19,000
我々は、メインのメモリであるとして、このことについて話しましたようにもかかわらず、

460
00:25:19,000 --> 00:25:23,000
そしてこれであるスワップのメモリのようなCの強力かつ危険な部分

461
00:25:23,000 --> 00:25:28,000
どの関数でも、どこでもコンピュータのメモリに触れることができるということです

462
00:25:28,000 --> 00:25:32,000
そしてこれはあなたがC言語でコンピュータプログラムで非常に派手なことを行うことができるという点で強力​​です

463
00:25:32,000 --> 00:25:36,000
あなたは、非常に簡単に台無しにすることができますので、これは危険です。

464
00:25:36,000 --> 00:25:39,000
実際には、これらの日のプログラムのための最も一般的な方法のいずれかが悪用される

465
00:25:39,000 --> 00:25:42,000
まだ実現していないプログラマです

466
00:25:42,000 --> 00:25:45,000
彼または彼女はデータを許可されていること

467
00:25:45,000 --> 00:25:49,000
意図していなかったメモリ内の場所に書き込まれるようになります。

468
00:25:49,000 --> 00:25:51,000
>> 例えば、彼または彼女はサイズ10の配列を宣言

469
00:25:51,000 --> 00:25:56,000
しかしその後誤って、メモリの配列に11バイトを入れよう

470
00:25:56,000 --> 00:25:59,000
そしてあなたは、もはや有効ではないメモリの部分に触れ始める。

471
00:25:59,000 --> 00:26:02,000
ちょうどこの文脈に、あなた方のうちの何人かは知っているかもしれない

472
00:26:02,000 --> 00:26:06,000
ソフトウェアは、多くの場合、シリアル番号または登録キーの入力を求めるプロンプトが表示さ

473
00:26:06,000 --> 00:26:08,000
PhotoshopやWordやこのようなプログラム。

474
00:26:08,000 --> 00:26:12,000
あなた方のうちの何人かが知っているように、あなたは少しプログラムを実行することができますオンラインの場合には、亀裂が存在する

475
00:26:12,000 --> 00:26:14,000
と出来上がり、シリアル番号のためのこれ以上の要求。

476
00:26:14,000 --> 00:26:16,000
それはどのように機能しているか？

477
00:26:16,000 --> 00:26:21,000
多くの場合、これらの事は、単にコンピュータで発見している

478
00:26:21,000 --> 00:26:24,000
コンピュータの実際のゼロともののテキスト·セグメント

479
00:26:24,000 --> 00:26:28,000
シリアル番号が要求され、その機能は、どこにあるの

480
00:26:28,000 --> 00:26:31,000
プログラムが実行されている間、あなたはその領域を上書きするか、または

481
00:26:31,000 --> 00:26:33,000
キーが実際に格納されている場所は把握することができます

482
00:26:33,000 --> 00:26:37,000
何かを使用すると、デバッガと呼ばれ、あなたは、ソフトウェアをそのように解くことができます。

483
00:26:37,000 --> 00:26:40,000
これは、この数日の次のカップルのための私達の目的であると言っているわけではない

484
00:26:40,000 --> 00:26:42,000
それは非常に現実世界の影響を及ぼす。

485
00:26:42,000 --> 00:26:45,000
1つはソフトウェアの窃盗を巻き込むことが起こることを、

486
00:26:45,000 --> 00:26:47,000
しかし、全体のマシンの妥協も用意されている。

487
00:26:47,000 --> 00:26:50,000
>> このごろWebサイトが悪用されている事実では、

488
00:26:50,000 --> 00:26:53,000
と妥協し、データが流出され、パスワードが盗まれて

489
00:26:53,000 --> 00:26:58,000
これは非常に多くの場合、1つのメモリの貧弱な管理に関し

490
00:26:58,000 --> 00:27:01,000
または、データベースの場合には、障害が予測する

491
00:27:01,000 --> 00:27:03,000
来て数週間で、その上で非常に多くの敵対入力、

492
00:27:03,000 --> 00:27:07,000
しかし、今のあなたが行うことができます損傷の一種のちょうどスニークプレビュー

493
00:27:07,000 --> 00:27:11,000
かなり物事はフードの下にどのように動作するか理解していないことによって。

494
00:27:11,000 --> 00:27:14,000
これが壊れた理由の理解については、行ってみよう

495
00:27:14,000 --> 00:27:17,000
ますます便利になるツールを使って

496
00:27:17,000 --> 00:27:19,000
我々のプログラムは、より複雑になるとして。

497
00:27:19,000 --> 00:27:21,000
これまでのところ、あなたのプログラムのバグを持っていたとき

498
00:27:21,000 --> 00:27:23,000
どのようにあなたはそれをデバッグする方法行った？

499
00:27:23,000 --> 00:27:25,000
何があなたのテクニックは、あなたのタスクフォースによって教えかどうか、これまであった

500
00:27:25,000 --> 00:27:27,000
それとも独学？

501
00:27:27,000 --> 00:27:29,000
[生徒]のPrintf。

502
00:27:29,000 --> 00:27:31,000
あなたが見たい場合はprintfのため、printfはおそらくその中にあなたの友人であった

503
00:27:31,000 --> 00:27:33,000
あなたのプログラムの内部で何が起こっているのか

504
00:27:33,000 --> 00:27:36,000
あなただけのprintfここでは、printfここ、ここのprintf置く。

505
00:27:36,000 --> 00:27:38,000
あなたはそれを実行し、あなたは、画面上のものの全体の束を得る

506
00:27:38,000 --> 00:27:43,000
あなたは、実際にあなたのプログラムの中で間違っているものを推測するために使用できる。

507
00:27:43,000 --> 00:27:45,000
>> printfは、非常に強力なものになる傾向がある

508
00:27:45,000 --> 00:27:47,000
それは非常に手動プロセスです。

509
00:27:47,000 --> 00:27:49,000
あなたは、printfはここ、ここのprintfを入れている

510
00:27:49,000 --> 00:27:51,000
あなたは、ループの中にそれを置けば、あなたは100行を取得する可能性があり

511
00:27:51,000 --> 00:27:53,000
あなたは、取捨選択する必要がある出力の。

512
00:27:53,000 --> 00:27:58,000
それは、プログラムをデバッグするための非常にユーザーフレンドリーまたは対話メカニズムではありません

513
00:27:58,000 --> 00:28:00,000
しかしありがたいことに代替案が存在する。

514
00:28:00,000 --> 00:28:03,000
GDBというインスタンスのためのプログラム、、、GNUデバッガは、あり

515
00:28:03,000 --> 00:28:06,000
それはあなたがそれを使用する方法で少し難解です。

516
00:28:06,000 --> 00:28:08,000
それは、少し複雑ですが、率直に言って

517
00:28:08,000 --> 00:28:11,000
これはあなたがこの週に置けばそれらのものの一つであり、次の

518
00:28:11,000 --> 00:28:14,000
GDBのような何かを理解するために余分な時間

519
00:28:14,000 --> 00:28:18,000
それは長期的には、おそらく数十時間を節約します、

520
00:28:18,000 --> 00:28:21,000
そうということで、私はあなたにこの事はどのように動作するかのティーザーを与えることができます。

521
00:28:21,000 --> 00:28:23,000
>> 私は、ターミナルウィンドウにいるよ。

522
00:28:23,000 --> 00:28:26,000
私が先に行くと、このプログラム、buggy3をコンパイルしてみましょう。

523
00:28:26,000 --> 00:28:28,000
これは既に最新です。

524
00:28:28,000 --> 00:28:31,000
我々はしばらくバックを行なったし、確かに、それが壊れているだけのように私はそれを実行してみましょう。

525
00:28:31,000 --> 00:28:34,000
しかし、これはなぜですか？たぶん私はスワップ機能を台無しに。

526
00:28:34,000 --> 00:28:37,000
たぶんそれは、aとbです。私は非常にそれらを正しく周りに引っ越すわけではない。

527
00:28:37,000 --> 00:28:39,000
私が先に行くとこれをやってみましょう。

528
00:28:39,000 --> 00:28:43,000
だけではなく、私が代わりにこのGDBというプログラムを実行してみましょうbuggy3実行

529
00:28:43,000 --> 00:28:48,000
と私は、buggy3を実行するためにそれを言うつもりです

530
00:28:48,000 --> 00:28:52,000
と私は、コマンドライン引数、-tuiを、含めるつもりです

531
00:28:52,000 --> 00:28:55,000
私たちは忘れないようにスペックで将来の問題でこれを置くことにしましょう​​。

532
00:28:55,000 --> 00:28:57,000
そして今、この黒と白のインターフェイスは、再び、それをポップアップ

533
00:28:57,000 --> 00:28:59,000
このすべてがあるので、最初は少し圧倒される

534
00:28:59,000 --> 00:29:02,000
ここに保証情報が、少なくともおなじみのものがあるように感じる。

535
00:29:02,000 --> 00:29:04,000
ウィンドウの上部には、私の実際のコードです。

536
00:29:04,000 --> 00:29:08,000
私が上にスクロールした場合、ここで、私は私のファイルの最上部にスクロールしてみましょう

537
00:29:08,000 --> 00:29:11,000
そして実際に、このウィンドウの下部にbuggy3.c、予告あり

538
00:29:11,000 --> 00:29:13,000
私はこのGDBはプロンプトを使用している。

539
00:29:13,000 --> 00:29:16,000
>> これは私の通常のジョンハーバードプロンプトと同じではありません。

540
00:29:16,000 --> 00:29:19,000
これは私がGDBを制御できるように起こっているプロンプトです。

541
00:29:19,000 --> 00:29:21,000
GDBはデバッガです。

542
00:29:21,000 --> 00:29:24,000
デバッガでは、ウォークスルーできるプログラムです

543
00:29:24,000 --> 00:29:27,000
行ずつ付けて、プログラム行の実行、

544
00:29:27,000 --> 00:29:30,000
プログラムしたい何もして道に沿って、

545
00:29:30,000 --> 00:29:33,000
でも、もっと重要なのは、関数の呼び出し、または探し

546
00:29:33,000 --> 00:29:35,000
さまざまな変数の値で。

547
00:29:35,000 --> 00:29:37,000
先に進み、これをやってみましょう。

548
00:29:37,000 --> 00:29:40,000
私は先に行くと、GDBのプロンプトで実行で入力するつもりだ、

549
00:29:40,000 --> 00:29:43,000
ので、私が入力し実行した画面の左下に気付く、

550
00:29:43,000 --> 00:29:45,000
と私は入力を打ちました、それは何をしましたか？

551
00:29:45,000 --> 00:29:50,000
それは文字通り私のプログラムを実行しましたが、私は実際にははるかにここに行くのを見ませんでした

552
00:29:50,000 --> 00:29:55,000
私は実際にデバッガを語っていないので、

553
00:29:55,000 --> 00:29:57,000
特定の時点で一時停止する。

554
00:29:57,000 --> 00:29:59,000
ただランを入力すると、プログラムを実行します。

555
00:29:59,000 --> 00:30:01,000
私は実際には何も表示されません。私はそれを操作することはできません。

556
00:30:01,000 --> 00:30:03,000
>> 代わりに私はこれを行うことができます。

557
00:30:03,000 --> 00:30:08,000
このgdbプロンプトで私が代わりに入力して、改行を入力してみましょう。

558
00:30:08,000 --> 00:30:10,000
それは私が入力するどのような意味ではありません。

559
00:30:10,000 --> 00:30:13,000
代わりにメイン破る入力してみましょう。

560
00:30:13,000 --> 00:30:15,000
言い換えれば、私はブレークポイントと呼ばれるものを設定したい、

561
00:30:15,000 --> 00:30:18,000
それが壊れる、または一時停止するので、適切に命名される

562
00:30:18,000 --> 00:30:21,000
その特定の場所であなたのプログラムの実行。

563
00:30:21,000 --> 00:30:23,000
主は、私の関数の名前です。

564
00:30:23,000 --> 00:30:25,000
GDBはかなりスマートであることに注意してください。

565
00:30:25,000 --> 00:30:28,000
これは、メインは18行で約開始に起こることを考え出し

566
00:30:28,000 --> 00:30:32,000
buggy3.cから、次に左上にここに気が付く

567
00:30:32,000 --> 00:30:34,000
B + 18行目のすぐ隣にあります。

568
00:30:34,000 --> 00:30:38,000
それは私が18行目にブレークポイントを設定していることを思い出させてくれている。

569
00:30:38,000 --> 00:30:42,000
この時間は、私が実行を入力したとき、私は私のプログラムを実行するつもりです

570
00:30:42,000 --> 00:30:45,000
までそれがそのブレークポイントに達するまで、

571
00:30:45,000 --> 00:30:48,000
ので、プログラムは18行目で、私のために一時停止します。

572
00:30:48,000 --> 00:30:50,000
ここに私達は行く、実行します。

573
00:30:50,000 --> 00:30:53,000
何が起こっているように見えませんが、左下の予告

574
00:30:53,000 --> 00:30:58,000
起動プログラム、buggy3、buggy3.cライン18でメインにブレークポイント1。

575
00:30:58,000 --> 00:31:00,000
私は今何ができるのか？

576
00:31:00,000 --> 00:31:03,000
>> 私は、印刷のようなものを入力して起動することができます注意してください

577
00:31:03,000 --> 00:31:08,000
不思議だ今ではないのprintf、プリントx、および。

578
00:31:08,000 --> 00:31:11,000
これから見るように$ 1は、単に好奇心です

579
00:31:11,000 --> 00:31:14,000
あなたが何かを印刷するたびに、新しい$値を取得します。

580
00:31:14,000 --> 00:31:18,000
つまり、あなたは、念のために以前の値に戻って参照することができるようだ

581
00:31:18,000 --> 00:31:21,000
しかし今ではプリントが私に言っている何のために物語の中で、この時点でxの値ということです

582
00:31:21,000 --> 00:31:26,000
どうやら134514032です。

583
00:31:26,000 --> 00:31:29,000
何ですか？それもどこから来たのか？

584
00:31:29,000 --> 00:31:31,000
[聞き取れない - 学生]

585
00:31:31,000 --> 00:31:34,000
確かに、これは我々がゴミ値と呼んでいるものであり、我々は、まだこのことについて話していませんでした

586
00:31:34,000 --> 00:31:37,000
しかし、変数を初期化している理由

587
00:31:37,000 --> 00:31:40,000
明らかに、彼らはあなたがそれらを持っているしたいいくつかの値を持っているということです。

588
00:31:40,000 --> 00:31:44,000
しかし、漁獲量は、変数を宣言することができることを思い出している

589
00:31:44,000 --> 00:31:46,000
私はシグマの例では少し前やったように

590
00:31:46,000 --> 00:31:48,000
実際にそれらに価値を与えることなく。

591
00:31:48,000 --> 00:31:50,000
私はシグマでこっちにやったことを思い出してください。

592
00:31:50,000 --> 00:31:52,000
私は、nを宣言したが、私はそれをどのような価値を与えましたか？

593
00:31:52,000 --> 00:31:56,000
なし、私は知っていたので、その次の数行で

594
00:31:56,000 --> 00:31:59,000
getIntは、nの値を内部に入れての問題の世話をするだろう。

595
00:31:59,000 --> 00:32:02,000
>> しかし、この時点で11行目の物語

596
00:32:02,000 --> 00:32:05,000
およびライン12およびライン13とライン14

597
00:32:05,000 --> 00:32:08,000
それらのいくつかの行全体でnの値は何ですか？

598
00:32:08,000 --> 00:32:10,000
C言語では、あなただけ知らない。

599
00:32:10,000 --> 00:32:14,000
これは、一般的にいくつかのゴミの値は、いくつかの完全にランダムな数だ

600
00:32:14,000 --> 00:32:17,000
以前のいくつかの関数から本質的に上に残っている

601
00:32:17,000 --> 00:32:21,000
あなたのプログラムが実行されるように、実行された

602
00:32:21,000 --> 00:32:24,000
関数は、関数、関数、関数を取得することを思い出す。

603
00:32:24,000 --> 00:32:27,000
これらのすべてのフレームは、それらの関数の戻り値をメモリに格納され、その取得

604
00:32:27,000 --> 00:32:31,000
と同じように私は自分のメモリが再利用され、最終的に消しゴムで示唆された。

605
00:32:31,000 --> 00:32:37,000
まあ、それはちょうどので、このプログラムでは、この変数xが起こる

606
00:32:37,000 --> 00:32:41,000
134514032のようないくつかのゴミの値が含まれていたようだ

607
00:32:41,000 --> 00:32:44,000
以前のいくつかの機能ではなく、私が書いたものから。

608
00:32:44,000 --> 00:32:47,000
これは、オペレーティングシステムと効果的に来るものかもしれない

609
00:32:47,000 --> 00:32:49,000
ボンネットの下にいくつかの機能。

610
00:32:49,000 --> 00:32:52,000
>> さて、それは大丈夫ですが、今は次の行に進みましょう。

611
00:32:52,000 --> 00:32:55,000
私はgdbプロンプトで "次へ"を入力した場合、私は、ENTERキーを押して

612
00:32:55,000 --> 00:32:58,000
上下線19に強調表示が移動する予告、

613
00:32:58,000 --> 00:33:01,000
しかし、論理的な含意は18行目です

614
00:33:01,000 --> 00:33:06,000
"×プリント"私再びタイプ場合は、ここで、実行が終了した

615
00:33:06,000 --> 00:33:10,000
私は今、1が表示されるはずですし、実際、私はありません。

616
00:33:10,000 --> 00:33:14,000
繰り返しになりますが、$のものはあなたを思い出させてGDBの方法です

617
00:33:14,000 --> 00:33:17,000
版画の歴史はあなたがやったことは何です。

618
00:33:17,000 --> 00:33:21,000
、今私は先に行くとyをプリントアウトしてみましょう、そして実際に、yは同様にいくつかのクレイジーな値です

619
00:33:21,000 --> 00:33:24,000
しかし、大したことない、我々はそれを代入しようとしている19行目にあるので、

620
00:33:24,000 --> 00:33:27,000
値2は、ので、私は再び "次へ"を入力してみましょう。

621
00:33:27,000 --> 00:33:29,000
そして今、我々は、printfの行にしている。

622
00:33:29,000 --> 00:33:31,000
私はプリントXをやってみましょう。

623
00:33:31,000 --> 00:33:34,000
私はプリントyをやってみましょう。率直に言って、私はこれを印刷したのにちょっと飽きたよ。

624
00:33:34,000 --> 00:33:38,000
私が代わりに "ディスプレイx"と "ディスプレイyを、"入力しましょう

625
00:33:38,000 --> 00:33:41,000
そして今、すべての時間は、私は、将来的にコマンドを入力します。

626
00:33:41,000 --> 00:33:45,000
私は何のことを思い出したことでしょう何、xとyは、xとyは、xとyは何でしょう。

627
00:33:45,000 --> 00:33:48,000
>> 私がすることができますまた、余談で、タイプとして "info localsを。"

628
00:33:48,000 --> 00:33:50,000
infoは、特殊なコマンドです。

629
00:33:50,000 --> 00:33:52,000
地元の人々はそれが私にローカル変数を示していますを意味します。

630
00:33:52,000 --> 00:33:55,000
私は忘れてしまったり、これはクレイジー、複雑な関数であり、念のために

631
00:33:55,000 --> 00:33:57,000
私や他の誰かが地元の人々はあなたを教えてくれる情報を書いた

632
00:33:57,000 --> 00:34:00,000
このローカル関数内に存在するすべてのローカル変数は何ですか

633
00:34:00,000 --> 00:34:03,000
あなたはつつくしたい場合は気かもしれない。

634
00:34:03,000 --> 00:34:07,000
さて、printfは実行しようとしているので、私が先に行くとだけ入力してみましょう "次。"

635
00:34:07,000 --> 00:34:10,000
我々はこのような環境にいるので、我々は実際にそれを見ていない

636
00:34:10,000 --> 00:34:14,000
ここに実行されますが、それはここで少し台無しにされたなってきて気づく。

637
00:34:14,000 --> 00:34:17,000
しかし、それはそこに画面を上書きして気付く

638
00:34:17,000 --> 00:34:21,000
ので、ここで完璧なプログラムではありませんが、私はいつも周りをウロウロすることができるので、それは大丈夫だ

639
00:34:21,000 --> 00:34:23,000
私が欲しい場合は、プリントを使用しています。

640
00:34:23,000 --> 00:34:26,000
>> 私は次回、もう一度入力してみましょうと、今ここには面白い部分です。

641
00:34:26,000 --> 00:34:29,000
物語のこの時点では、yは2であり、xは1です

642
00:34:29,000 --> 00:34:32,000
ここで示唆したように、再度、

643
00:34:32,000 --> 00:34:35,000
私は、コマンドを使用しているので、これは自動的に今表示している理由は、

644
00:34:35,000 --> 00:34:40,000
ディスプレイのxとyのディスプレイ、私は次のように入力した瞬間

645
00:34:40,000 --> 00:34:43,000
理論xとyでスワップになる必要があります。

646
00:34:43,000 --> 00:34:45,000
今、我々はすでにケースであることを行っていないことを知って、

647
00:34:45,000 --> 00:34:49,000
しかし、我々は、我々はそれが本当だ理由を把握し深くダイブする方法瞬間にわかります。

648
00:34:49,000 --> 00:34:54,000
次に、残念ながら、yは2のままであり、xは1のままである、と私は同じくらいを確認することができます。

649
00:34:54,000 --> 00:34:56,000
プリントのx、yをプリント。

650
00:34:56,000 --> 00:34:59,000
確かに、スワッピングは、実際に起こっているので、これは最初からやり直してみましょうん。

651
00:34:59,000 --> 00:35:01,000
明らかにスワップが壊れています。

652
00:35:01,000 --> 00:35:04,000
代わりに、再度 "実行"と入力してみましょう。

653
00:35:04,000 --> 00:35:07,000
私は、はい、私は最初からそれを再開したいとしましょう​​、次のように入力します。

654
00:35:07,000 --> 00:35:09,000
>> 今、私は背中のラインアップ18時だ。

655
00:35:09,000 --> 00:35:11,000
今では、xとyに気づく再びゴミの値です。

656
00:35:11,000 --> 00:35:15,000
次の、次の、次の、次の。

657
00:35:15,000 --> 00:35:17,000
私が退屈なら、私もちょうど次のためにnを入力することができます。

658
00:35:17,000 --> 00:35:21,000
あなたは文字の最短のシーケンスに短縮することができます。

659
00:35:21,000 --> 00:35:23,000
スワップは現在壊れています。

660
00:35:23,000 --> 00:35:25,000
代わりに次の入力するので、でのダイビングをしましょう​​、

661
00:35:25,000 --> 00:35:30,000
今私はこの関数の内部ステッピングてるようにステップを入力するつもりです

662
00:35:30,000 --> 00:35:33,000
ので、私はそれを歩くことができるので、私はステップをヒットしてから入力してください。

663
00:35:33,000 --> 00:35:37,000
36行目に、私のプログラムでダウン強調ジャンプ低いことに注意してください。

664
00:35:37,000 --> 00:35:39,000
これで、ローカル変数は何ですか？

665
00:35:39,000 --> 00:35:41,000
info localsを。

666
00:35:41,000 --> 00:35:43,000
我々はそのラインに到達していませんでしたので、今はまだ何もありません、

667
00:35:43,000 --> 00:35:47,000
それでは、先に行くと言わせて "次。"

668
00:35:47,000 --> 00:35:50,000
今、私たちは、tmp、プリントtmpを持っているように思われる。

669
00:35:50,000 --> 00:35:52,000
ガベージ値、右か？そう思います。

670
00:35:52,000 --> 00:35:55,000
方法については、プリントB、1と2を印刷しますか？

671
00:35:55,000 --> 00:35:58,000
一瞬にして、できるだけ早く、私は次のように入力し、もう一度

672
00:35:58,000 --> 00:36:02,000
tmpは、うまくいけば、1の値をとることになるだろう

673
00:36:02,000 --> 00:36:05,000
tmpに値を割り当てることが起こっているからです。

674
00:36:05,000 --> 00:36:08,000
>> さて、プリントBを印刷できますかしてみましょう

675
00:36:08,000 --> 00:36:11,000
しかし今tmpを印刷して、それは確かに1です。

676
00:36:11,000 --> 00:36:14,000
私は次に何をしましょう​​。私は次に何をしましょう​​。

677
00:36:14,000 --> 00:36:16,000
私はスワップ機能を終えたところです。

678
00:36:16,000 --> 00:36:19,000
私は40行目でその中にまだだので、私はプリントでき、

679
00:36:19,000 --> 00:36:22,000
bを印刷して、私はtmpが何であるかを気にしないでください。

680
00:36:22,000 --> 00:36:27,000
それはaとbを入れ替えることになるとスワップが正しいように見えます。

681
00:36:27,000 --> 00:36:31,000
しかし、私は今、次の入力した場合、私は、25行目にジャンプ

682
00:36:31,000 --> 00:36:34,000
そしてもちろん、私は、xとyに印刷と入力した場合

683
00:36:34,000 --> 00:36:38,000
彼らはまだ変わらないなら、私たちは問題を修正していない。

684
00:36:38,000 --> 00:36:41,000
しかし、診断的に今、おそらくこのGDBのプログラムと

685
00:36:41,000 --> 00:36:44,000
我々は少なくとも理解に一歩近づく得てきた

686
00:36:44,000 --> 00:36:47,000
何がここにprintfを入れてゴミに我々のコードを持たずに間違っただろう、

687
00:36:47,000 --> 00:36:50,000
printfはここでは、printfここをチェックして何度も何度もそれを実行している

688
00:36:50,000 --> 00:36:52,000
間違って何が起こっているのかを把握しよう。

689
00:36:52,000 --> 00:36:55,000
>> 私はやめるとまとめて先に行くとこの途中で辞めたいと思います。

690
00:36:55,000 --> 00:36:57,000
それは言うだろう "終了しますか？"はい。

691
00:36:57,000 --> 00:37:00,000
さて、私の通常のプロンプトに戻っている、と私は、GDBを使用して行われています。

692
00:37:00,000 --> 00:37:03,000
余談ですが、この-tuiコマンド·フラグを使用する必要はありません。

693
00:37:03,000 --> 00:37:07,000
あなたはそれを省略した場合は実際には、本質的に、画面の下半分を取得します。

694
00:37:07,000 --> 00:37:11,000
私はその後、壊すメインを入力し、実行した場合

695
00:37:11,000 --> 00:37:15,000
私はまだ私のプログラムを実行しますが、それが何を行いますと、より字面であることができます

696
00:37:15,000 --> 00:37:18,000
ちょうど時間で私に現在の回線1を示しています。

697
00:37:18,000 --> 00:37:21,000
-tuiコマンド、テキストユーザーインターフェース、

698
00:37:21,000 --> 00:37:25,000
ただおそらく少し概念的に簡単である、あなたに一度プログラムの詳細を示しています。

699
00:37:25,000 --> 00:37:27,000
しかし、確かに、私はちょうど、次の、次の、次に何をすることができます

700
00:37:27,000 --> 00:37:30,000
そして、私は、一度に1つの行を見に行くつもりだし、私は実際に何が起こっているか確認したい場合

701
00:37:30,000 --> 00:37:35,000
私はリストを入力し、隣接するラインの全体の束を見ることができます。

702
00:37:35,000 --> 00:37:39,000
>> 我々は問題は3を設定するためには、見ることを尋ねてきたビデオがあります

703
00:37:39,000 --> 00:37:43,000
たネイトは、GDBの複雑さの一部をカバー

704
00:37:43,000 --> 00:37:46,000
これは、正直なところ、ものの一つがどこにあるのいくつかの非自明な割合

705
00:37:46,000 --> 00:37:49,000
GDBには決して手を触れないようになり、それは悪いことであろう

706
00:37:49,000 --> 00:37:53,000
文字通り今学期は後で多くの時間を費やしてしまいますので、

707
00:37:53,000 --> 00:37:56,000
バグを追跡し、あなたにはその半分の時間/時間に入れたい場合

708
00:37:56,000 --> 00:38:00,000
今週とGDBに慣れるための学習の隣。

709
00:38:00,000 --> 00:38:02,000
printfのあなたの友人だった。

710
00:38:02,000 --> 00:38:05,000
GDBはあなたの友人である必要があります。

711
00:38:05,000 --> 00:38:08,000
>> GDB上で何か質問はありますか？

712
00:38:08,000 --> 00:38:12,000
そして、ここでは最も強力で、有用ないくつかのコマンドの簡単なリストです。

713
00:38:12,000 --> 00:38:15,000
うん。>>は、文字列を印刷することはできますか？

714
00:38:15,000 --> 00:38:17,000
あなたは、文字列を印刷することができますか？絶対に。

715
00:38:17,000 --> 00:38:19,000
それはただの整数である必要はありません。

716
00:38:19,000 --> 00:38:22,000
変数sは、印刷sに入力するだけの文字列である場合。

717
00:38:22,000 --> 00:38:24,000
それは、その文字列変数が何であるかを紹介します。

718
00:38:24,000 --> 00:38:26,000
[聞き取れない - 学生]

719
00:38:26,000 --> 00:38:28,000
それはあなたのアドレスや文字列自体を与える。

720
00:38:28,000 --> 00:38:32,000
それはあなたの両方が表示されます。

721
00:38:32,000 --> 00:38:34,000
これらはあまりにも知って良いという理由だけと最後にひとつ。

722
00:38:34,000 --> 00:38:37,000
バックトレースおよびフレームは、私は、この最後の一時間に飛び込むことができ

723
00:38:37,000 --> 00:38:39,000
GDBでまったく同じプログラム。

724
00:38:39,000 --> 00:38:44,000
私が先に行くとテキストユーザインタフェースのバージョンを実行してみましょう、

725
00:38:44,000 --> 00:38:46,000
メイン破る。

726
00:38:46,000 --> 00:38:49,000
私が先に行くと、再び実行してみましょう。私はここに。

727
00:38:49,000 --> 00:38:55,000
今私は、次の、次の、次の、次の、次の、ステップを手放すように入力します。

728
00:38:55,000 --> 00:39:00,000
>> そして今は、私が意図的にスワップに今だと仮定しますが、私はのようだ "くそー、xの値は何だったの？"

729
00:39:00,000 --> 00:39:02,000
私はもうxを行うことはできません。

730
00:39:02,000 --> 00:39:05,000
彼らは範囲にいないので、私はyを行うことはできません。

731
00:39:05,000 --> 00:39:07,000
彼らは、文脈が、問題なしではないね。

732
00:39:07,000 --> 00:39:09,000
私は、バックトレースを入力することができます。

733
00:39:09,000 --> 00:39:13,000
それは私に、この時点までに実行したすべての関数を示しています。

734
00:39:13,000 --> 00:39:16,000
底面に1つ、メインとメイン、ラインアップすることに注意してください

735
00:39:16,000 --> 00:39:18,000
ここに私たちの絵の下部にある。

736
00:39:18,000 --> 00:39:22,000
スワップは、スワップがここにメモリにそれより上であることと、それまでの線の上にあるという事実は、

737
00:39:22,000 --> 00:39:26,000
と私は一時的にメインに戻って取得したい場合、私は "フレーム"を言うことができる

738
00:39:26,000 --> 00:39:30,000
何番？メインフレームでは、＃1です。

739
00:39:30,000 --> 00:39:32,000
私は先に行くと言うつもりだ "フレーム1"

740
00:39:32,000 --> 00:39:36,000
>> 今、私はメインに戻っている、と私はxを出力することができます、と私は、yを印刷することができます

741
00:39:36,000 --> 00:39:40,000
しかし、私はaまたはbを印刷することはできません。

742
00:39:40,000 --> 00:39:43,000
私が言う場合、私は、 "よし、ちょっと待って。どこスワップでしたか？"することができます

743
00:39:43,000 --> 00:39:46,000
私が先に行くと言わせて "フレーム0"になります。

744
00:39:46,000 --> 00:39:48,000
今私はなりたいところ戻ってきた、と余談ですが、

745
00:39:48,000 --> 00:39:52,000
あなたが本当に、次の次の、次の、次のように入力退屈になってしまった場合のような他のコマンドでは、あまりにもあり

746
00:39:52,000 --> 00:39:56,000
あなたは一般的には "次の10"のようなものを言うことができる、それが次の10行をステップ実行します。

747
00:39:56,000 --> 00:39:59,000
また、あなたが本当にそれをステップにうんざりしたら、 "続ける"を書くことができる。

748
00:39:59,000 --> 00:40:05,000
それは別のブレークポイントに達するまで継続するが、中断せずにプログラムを実行します

749
00:40:05,000 --> 00:40:07,000
ループ内かどうか、プログラムで下げる。

750
00:40:07,000 --> 00:40:11,000
>> この場合、我々は最後まで継続され、プログラムが正常に終了しました。

751
00:40:11,000 --> 00:40:13,000
これは空想方法、下位プロセスである。

752
00:40:13,000 --> 00:40:16,000
ちょうどあなたのプログラムが正常に終了しました。

753
00:40:16,000 --> 00:40:24,000
ビデオの中と来てセッションをデバッグするときに、その方法の詳細。

754
00:40:24,000 --> 00:40:26,000
それがたくさんあった。

755
00:40:26,000 --> 00:40:35,000
レッツは、ここで我々の5分間の休憩を取り、我々は、構造体やファイルを返しています。

756
00:40:35,000 --> 00:40:38,000
>> あなたはすでに、今週のpsetに飛び込んしている場合

757
00:40:38,000 --> 00:40:41,000
あなたは私たちが配布コードで使用することを知っているよ、

758
00:40:41,000 --> 00:40:45,000
我々が出発点としてあなたに提供するソースコードは、いくつかの新しい技術。

759
00:40:45,000 --> 00:40:50,000
特に、我々は、構造のため、構造体と呼ばれるこの新しいキーワードが導入されました

760
00:40:50,000 --> 00:40:53,000
ので、我々はあらゆる種類のカスタマイズされた変数を作成することができます。

761
00:40:53,000 --> 00:40:57,000
我々はまた、ファイルI / O、ファイル入出力の概念を導入

762
00:40:57,000 --> 00:41:00,000
そしてこれは我々が状態を保存できるようになり

763
00:41:00,000 --> 00:41:03,000
あなたのスクランブルボードのディスク上のファイルへ

764
00:41:03,000 --> 00:41:06,000
ティーチングフェローと私は理解できるように、

765
00:41:06,000 --> 00:41:09,000
手動で再生することなく、あなたのプログラムの内部で何が起こっているの

766
00:41:09,000 --> 00:41:11,000
スクランブルのゲームの数十。

767
00:41:11,000 --> 00:41:13,000
我々は、より多くautomatedlyこれを行うことができます。

768
00:41:13,000 --> 00:41:18,000
>> 構造体のこのアイデアはかなり説得力のある問題を解決します。

769
00:41:18,000 --> 00:41:21,000
我々はいくつかのプログラムを実装したいとし

770
00:41:21,000 --> 00:41:25,000
何とかして学生に情報を追跡している、

771
00:41:25,000 --> 00:41:28,000
と学生は、例えば、名前をIDをお持ちかもしれません

772
00:41:28,000 --> 00:41:31,000
とハーバード大学のような場所での家なので、これらは、情報の3作品です

773
00:41:31,000 --> 00:41:34,000
私たちの周りを維持したいので、私が先に行くと、ここで少しプログラムを書き始めることができ、

774
00:41:34,000 --> 00:41:38,000
stdio.hをインクルード。

775
00:41:38,000 --> 00:41:42,000
私はcs50.h.を含めるやってみましょう

776
00:41:42,000 --> 00:41:44,000
そして、私の主な機能を起動します。

777
00:41:44,000 --> 00:41:46,000
私は、任意のコマンドライン引数を気にしないでしょう

778
00:41:46,000 --> 00:41:49,000
そしてここで私は学生を持つようにしたいので、私は言うつもりです

779
00:41:49,000 --> 00:41:54,000
学生は名前を持っているので、私は言うつもりです "という文字列の名前を。"

780
00:41:54,000 --> 00:41:59,000
それから私はまた、IDを持っているので、int型のID学生を言おうとしてんだけど、

781
00:41:59,000 --> 00:42:03,000
と学生が家を持っているので、私も言うつもりです "という文字列の家を。"

782
00:42:03,000 --> 00:42:06,000
それから私はこのようにもう少しきれいにこれらを注文します。

783
00:42:06,000 --> 00:42:11,000
さて、私は "学生"を生徒に表現すると3つの変数があるので、

784
00:42:11,000 --> 00:42:15,000
>> そして今、私はこれらの値を移入したいので、私が先に行くと何かのように言わせて

785
00:42:15,000 --> 00:42:18,000
"ID = 123。"

786
00:42:18,000 --> 00:42:21,000
名前はダビデを取得する予定です。

787
00:42:21,000 --> 00:42:24,000
、家はメイザーを得ようとしていると言ってみましょう

788
00:42:24,000 --> 00:42:31,000
そして私は任意のprintf（ "％sのような何かをするつもりだ、

789
00:42:31,000 --> 00:42:37,000
は、ID％dですが、％sに住んでいます。

790
00:42:37,000 --> 00:42:41,000
そして今、私は、ここにプラグインするために、他の後に1が何をしたいですか？

791
00:42:41,000 --> 00:42:47,000
名前、ID、家、0を返します。

792
00:42:47,000 --> 00:42:50,000
さて私はどこかここで、台無しにしない限り、

793
00:42:50,000 --> 00:42:54,000
私たちは一人の学生を格納かなり良いプログラムを持っていると思う。

794
00:42:54,000 --> 00:42:57,000
もちろん、これはすべてが面白くありません。私は2名を持つようにしたい場合はどうなりますか？

795
00:42:57,000 --> 00:42:59,000
それは大したことない。私は2人をサポートすることができます。

796
00:42:59,000 --> 00:43:03,000
私が先に行くと、これをハイライト表示して、ここに行ってみよう、

797
00:43:03,000 --> 00:43:09,000
と私はカークランドに住んでいるロブのような誰かのための "id = 456"と言うことができます。

798
00:43:09,000 --> 00:43:12,000
>> さて、、待って、私はこれらの同じものを呼び出すことはできません

799
00:43:12,000 --> 00:43:15,000
と私はこれをコピーする必要がありますするつもりのように見える、

800
00:43:15,000 --> 00:43:19,000
ので、私はこれらはダビデの変数になることを言わせて、

801
00:43:19,000 --> 00:43:23,000
と私はロブのためにこれらのいくつかのコピーを取得してみましょう。

802
00:43:23,000 --> 00:43:27,000
我々は、これらのロブのを呼ぶことにしますが、これは今では仕事に行くのではない

803
00:43:27,000 --> 00:43:33,000
私はウェイトを持っているので、私ID1、name1とhouse1に変更してみましょう。

804
00:43:33,000 --> 00:43:35,000
ロブは、2になります。

805
00:43:35,000 --> 00:43:42,000
私はここ、ここ、ここ、ここ、ここ、ここ、これを変更するんだ。

806
00:43:42,000 --> 00:43:45,000
待って、何トミーはどうですか？再びこれを行うにしてみましょう。

807
00:43:45,000 --> 00:43:49,000
それでも、これはこれを行うための良い方法だと思う場合、明らかに、それはありません

808
00:43:49,000 --> 00:43:52,000
そんなに悪いコピー/ペーストする。

809
00:43:52,000 --> 00:43:55,000
しかし、我々は一週間前にこの問題を解決しました。

810
00:43:55,000 --> 00:43:59,000
>> 我々は、同じデータ型の複数のインスタンスを持っていると思ったときに私たちのソリューションは何でしたか？

811
00:43:59,000 --> 00:44:01,000
[学生]配列。

812
00:44:01,000 --> 00:44:03,000
アレイは、ので、私はこの上をきれいにしてみましょう。

813
00:44:03,000 --> 00:44:07,000
私は一番上に自分のためにいくつかの部屋を作ってみましょう、と私は代わりにここでこれを行うことができます。

814
00:44:07,000 --> 00:44:12,000
"で、int idを"我々は、これらの人を呼ぶことにし、代わりに私が言おうとしてる

815
00:44:12,000 --> 00:44:14,000
と私は今の私たちの3をサポートするつもりです。

816
00:44:14,000 --> 00:44:18,000
私は、 "文字列の名前"と言うと私は、私たちの3をサポートしますつもりですが、

817
00:44:18,000 --> 00:44:22,000
そして私は、 "文字列の家"を言おうとしていると私は私達の3をサポートするつもりです。

818
00:44:22,000 --> 00:44:26,000
今ここに代わりにダビデの年に彼自身のローカル変数を取得

819
00:44:26,000 --> 00:44:28,000
我々はそれらを取り除くことができます。

820
00:44:28,000 --> 00:44:30,000
それは我々がこれをクリーンアップしていることを良い感じ。

821
00:44:30,000 --> 00:44:35,000
私はその後、デイヴィッドは[0]と名前が[0]であることを行っていると言うことができます

822
00:44:35,000 --> 00:44:38,000
や住宅[0]。

823
00:44:38,000 --> 00:44:41,000
そして、我々は同様にこれを保存することができますロブ。

824
00:44:41,000 --> 00:44:46,000
のは、この下にここに置いてみましょうので、彼は勝手にIDを[1]になるだろう。

825
00:44:46,000 --> 00:44:50,000
彼は名前になるだろう[1]

826
00:44:50,000 --> 00:44:53,000
その後最後に、家[1]。

827
00:44:53,000 --> 00:44:57,000
>> 私はこれを理解しなければ、まだ少し退屈な、そして今、

828
00:44:57,000 --> 00:45:03,000
そう言ってみましょう "の名前[0]、ID [0]、ハウス[0]、

829
00:45:03,000 --> 00:45:06,000
これを複数形にしてみましょう。

830
00:45:06,000 --> 00:45:09,000
IDS、IDS、イド。

831
00:45:09,000 --> 00:45:12,000
そして再び、私はそれをやっているので、もう一度、私はすでに、再びコピー/ペーストに頼るよ

832
00:45:12,000 --> 00:45:14,000
そうオッズは別の解決策がここにありです。

833
00:45:14,000 --> 00:45:18,000
私はおそらく、そのようなループか何かでアップ、さらにこれをきれいにすることができる

834
00:45:18,000 --> 00:45:21,000
そう簡単に言えば、それは少しましだけど、まだのような感じ

835
00:45:21,000 --> 00:45:24,000
私は、コピー/ペーストに頼るんだけど、この場合でも、私は主張する

836
00:45:24,000 --> 00:45:27,000
本当に根本的に正しい解決法ではないので、

837
00:45:27,000 --> 00:45:29,000
いつか私たちは、あなたが何を知っていると判断した場合でしょうか？

838
00:45:29,000 --> 00:45:32,000
私たちは本当にダビデとロブの電子メールアドレスを格納されている必要があります

839
00:45:32,000 --> 00:45:34,000
そして、このプログラムの皆。

840
00:45:34,000 --> 00:45:36,000
また、電話番号を格納する必要があります。

841
00:45:36,000 --> 00:45:39,000
また、緊急連絡先の電話番号を格納する必要があります。

842
00:45:39,000 --> 00:45:41,000
私たちは、格納するデータのすべてのこれらの部分を持っている

843
00:45:41,000 --> 00:45:43,000
ので、どのようにあなたはそれをやって行くのですか？

844
00:45:43,000 --> 00:45:46,000
>> あなたは、一番上にある別の配列を宣言してから、手動で追加

845
00:45:46,000 --> 00:45:49,000
メールアドレス[0]は、電子メールアドレス[1]

846
00:45:49,000 --> 00:45:51,000
デイビッドとロブのためになど。

847
00:45:51,000 --> 00:45:56,000
しかし、この設計の基礎となる仮定は本当にあり

848
00:45:56,000 --> 00:45:59,000
私はそれを知っている名誉のシステムを使用していること

849
00:45:59,000 --> 00:46:03,000
[i]はいくつかの配列のそれぞれの

850
00:46:03,000 --> 00:46:06,000
ちょうどので、同じ人物を参照するために起こる

851
00:46:06,000 --> 00:46:10,000
ので、[0] idsに数123、です

852
00:46:10,000 --> 00:46:13,000
と私はその名前を仮定するつもりです[0]

853
00:46:13,000 --> 00:46:16,000
ある同じ人の名前や住宅[0]

854
00:46:16,000 --> 00:46:21,000
私が作成したさまざまなアレイのすべてのための同じ人の家などである。

855
00:46:21,000 --> 00:46:24,000
しかし、どんな基本的なリンケージがないことに気付く

856
00:46:24,000 --> 00:46:27,000
情報、ID、名前、家のそれら3個のうち、

857
00:46:27,000 --> 00:46:32,000
にもかかわらず、我々はこのプログラムでモデルにしようとしている実体は配列ではありません。

858
00:46:32,000 --> 00:46:35,000
配列は、これを行うだけで、このプログラム的な方法です。

859
00:46:35,000 --> 00:46:38,000
私たちは本当に我々のプログラムでモデル化したいのは人である

860
00:46:38,000 --> 00:46:41,000
デビッドは、その内部のロブのような人のような

861
00:46:41,000 --> 00:46:46,000
またはカプセル化は、名前とIDと家です。

862
00:46:46,000 --> 00:46:49,000
>> 我々は何とかカプセル化のこの考えを表現することができます

863
00:46:49,000 --> 00:46:52,000
それによって人は、ID、名前、家を持っている

864
00:46:52,000 --> 00:46:55,000
そして本当にこのハックに頼ることができる我々だけ

865
00:46:55,000 --> 00:46:58,000
そのブラケット何かを信頼

866
00:46:58,000 --> 00:47:02,000
これらの異種配列の各々に同じ人間の実体を指す？

867
00:47:02,000 --> 00:47:04,000
我々は、実際にこれを行うことができます。

868
00:47:04,000 --> 00:47:08,000
私は今のところ、上記のメインに行く、と私は私自身のデータ型を作成させてみましょう

869
00:47:08,000 --> 00:47:10,000
初めて本当にために。

870
00:47:10,000 --> 00:47:14,000
我々は、スクランブルでこのテクニックを使用

871
00:47:14,000 --> 00:47:17,000
しかしここで私は、先に行くとデータ型を作成するつもりです

872
00:47:17,000 --> 00:47:19,000
、あなたは何を、私は、それを学生や人呼ぶつもりだ知っている

873
00:47:19,000 --> 00:47:23,000
と私は型を定義するためにtypedefを使用するつもりです。

874
00:47:23,000 --> 00:47:25,000
私は、これは構造体であることを言おうとしてんだけど、

875
00:47:25,000 --> 00:47:29,000
その後この構造はタイプの学生であることを行っている、我々は言うだろう

876
00:47:29,000 --> 00:47:31,000
それは私のために今付け少しは言っても。

877
00:47:31,000 --> 00:47:33,000
我々は "int idを。"と言うでしょう

878
00:47:33,000 --> 00:47:35,000
私たちは、 "文字列名を"言うよ

879
00:47:35,000 --> 00:47:37,000
その後、我々は "文字列の家を、"言うよ

880
00:47:37,000 --> 00:47:40,000
ので、今の数行のコードの終わりまで

881
00:47:40,000 --> 00:47:45,000
私はただそこに存在することを打ち鳴らすを教えてきました

882
00:47:45,000 --> 00:47:49,000
文字列以外にint型以外のデータ型には、ほかに山車のほかに、倍になります。

883
00:47:49,000 --> 00:47:54,000
>> タイムライン11のこの瞬間のように、学生と呼ばれる新しいデータ型は、今がある

884
00:47:54,000 --> 00:47:58,000
そして今、私は、どこにも私が欲しい学生の変数を宣言することができます

885
00:47:58,000 --> 00:48:01,000
ので、私は人々にここまでスクロールダウンしてみましょう。

886
00:48:01,000 --> 00:48:05,000
、今私はこれを取り除くことができ、私はここでダビデに戻ってダウン状態になることができます

887
00:48:05,000 --> 00:48:10,000
とデビッドのために私は実際にダビデ、と言うことができます

888
00:48:10,000 --> 00:48:13,000
我々は、文字通り、自分の後に変数に名前を付けることができます

889
00:48:13,000 --> 00:48:16,000
タイプの学生であることを行っている。

890
00:48:16,000 --> 00:48:18,000
これは少し奇妙に見えるかもしれませんが、これはすべてその違いはありません

891
00:48:18,000 --> 00:48:22,000
intやstringやfloatとして何かを宣言してから。

892
00:48:22,000 --> 00:48:24,000
それはちょうどので、今では学生と呼ばれるようなことが起こる

893
00:48:24,000 --> 00:48:28,000
と私は、この構造体の内部に何かを入れたい場合

894
00:48:28,000 --> 00:48:31,000
、私は今、構文の新しい部分を使用する必要がありますが、それは非常に簡単だ

895
00:48:31,000 --> 00:48:39,000
david.id = 123、Dの資本david.name = "デビッド"、

896
00:48:39,000 --> 00:48:42,000
とdavid.house = "マザー"

897
00:48:42,000 --> 00:48:46,000
そして今、私はここでこのようなものを取り除くことができます。

898
00:48:46,000 --> 00:48:51,000
私たちが今本当に多くの、より良い方法で我々のプログラムを再設計しました注意してください

899
00:48:51,000 --> 00:48:54,000
という点で、今私たちのプログラムは、現実の世界を反映しています。

900
00:48:54,000 --> 00:48:57,000
>> 人や学生の現実世界の概念があります。

901
00:48:57,000 --> 00:49:02,000
ここで我々は今、人またはより具体的に学生のCバージョンを持っています。

902
00:49:02,000 --> 00:49:05,000
その人の内側には、これらの関連する特性である

903
00:49:05,000 --> 00:49:10,000
ID、名前、家なので、ロブは、本質的にダウンしてここに同じことになり、

904
00:49:10,000 --> 00:49:14,000
、学生奪うので、今= 456 rob.id

905
00:49:14,000 --> 00:49:17,000
rob.name = "ロブ。"

906
00:49:17,000 --> 00:49:20,000
変数はロブと呼ばれているという事実は無意味のようなものです。

907
00:49:20,000 --> 00:49:22,000
我々はそれをxまたはyまたはzということがありました。

908
00:49:22,000 --> 00:49:25,000
私たちはただ、それが意味的に矛盾しないようにロブ名前

909
00:49:25,000 --> 00:49:28,000
しかし実際の名前には、そのフィールド自体の内部にある

910
00:49:28,000 --> 00:49:30,000
今私はこれを持っている。

911
00:49:30,000 --> 00:49:33,000
これは、あまりにも私が一生懸命、ダビデをコーディングしましたという点で最高のデザインのような気がしない。

912
00:49:33,000 --> 00:49:35,000
私は懸命にロブをコーディングしました。

913
00:49:35,000 --> 00:49:39,000
そして、私はまだいくつかのコピーに頼ると私は、新しい変数をするたびに貼り付ける必要があります。

914
00:49:39,000 --> 00:49:43,000
また、私は、明らかにこれらの各変数に名前を付ける必要がある

915
00:49:43,000 --> 00:49:46,000
私はむしろ、これらの変数を記述したい場合でも、

916
00:49:46,000 --> 00:49:48,000
 より一般的に学生として。

917
00:49:48,000 --> 00:49:52,000
>> 今、私たちは私たちのためによく働いているアイデアをマージすることができます

918
00:49:52,000 --> 00:49:56,000
その代わりに、あなたは私と呼ばれる変数の学生を与えるもの、知っている "と言う。

919
00:49:56,000 --> 00:50:01,000
そして今、私はこれがさらに絞り込むことができますように "、のそれのサイズが3であることが持ってみましょう、

920
00:50:01,000 --> 00:50:04,000
手動で宣言されたデビッドを取り除く、

921
00:50:04,000 --> 00:50:08,000
と私の代わりに[0]ここの学生のようなものを言うことができます。

922
00:50:08,000 --> 00:50:11,000
私はその後、[0]ここの学生を言うことができます

923
00:50:11,000 --> 00:50:14,000
学生[0]ここなど、そして私の周りに行くことができます

924
00:50:14,000 --> 00:50:16,000
とロブのためにそれをクリーンアップします。

925
00:50:16,000 --> 00:50:19,000
私も今、多分ループを追加することについて行け

926
00:50:19,000 --> 00:50:23,000
そして実際にユーザーからこれらの値を取得するGetStringメソッドとgetIntを使用。

927
00:50:23,000 --> 00:50:27,000
これは一般的に悪い習慣であるので、私は定数を追加することについて行け

928
00:50:27,000 --> 00:50:29,000
右ここでは3のようにハードコードするいくつかの任意の番号

929
00:50:29,000 --> 00:50:33,000
その後、ちょうどあなたがそれで3つ以下の学生を置くべきであることを覚えておいてください。

930
00:50:33,000 --> 00:50:36,000
それはおそらく私のファイルの先頭に＃defineを使用する方が良いだろう

931
00:50:36,000 --> 00:50:40,000
と出ますので、確かに、私が先に行くと、これを一般化させている要因。

932
00:50:40,000 --> 00:50:43,000
>> 私は今日の間の例を開けてみよう

933
00:50:43,000 --> 00:50:46,000
事前に例structs1。

934
00:50:46,000 --> 00:50:49,000
これは、＃ここまで定義し使用するより完全なプログラムです

935
00:50:49,000 --> 00:50:51,000
我々は、デフォルトでは3人の学生を持っているとしていると言っている。

936
00:50:51,000 --> 00:50:54,000
ここで私は、学生のクラスの価値を宣言しています

937
00:50:54,000 --> 00:50:57,000
生徒の教室はそうしましたが、今は、ループを使用しています

938
00:50:57,000 --> 00:51:00,000
ただ、コードがもう少しエレガントにするために、クラスを生成する

939
00:51:00,000 --> 00:51:05,000
ユーザの入力と、そうまでのi = 0〜3である学生に反復します。

940
00:51:05,000 --> 00:51:07,000
そして私はこのバージョンではユーザにプロンプ​​トを表示

941
00:51:07,000 --> 00:51:10,000
 何学生のIDだ、と私は場合、getIntでそれを取得します。

942
00:51:10,000 --> 00:51:13,000
何が学生の名前だし、私はそれGetStringメソッドと取得。

943
00:51:13,000 --> 00:51:15,000
学生の家とは何ですか？私がGetStringメソッドとそれを得る。

944
00:51:15,000 --> 00:51:19,000
そして、ここで一番下に私はちょうど変更することを決めた

945
00:51:19,000 --> 00:51:22,000
私はこれらをプリントアウトしているし、実際にループを使用する方法、

946
00:51:22,000 --> 00:51:24,000
そして、私は誰を印刷しています？

947
00:51:24,000 --> 00:51:27,000
コメントによると、私は、マザーの誰を印刷しています

948
00:51:27,000 --> 00:51:30,000
それはそれそうロブとトミーなど、実際にトミーのマザーでだ。

949
00:51:30,000 --> 00:51:34,000
トミーとデビッドは、この場合に印刷されるでしょうが、これはどのように機能しているか？

950
00:51:34,000 --> 00:51:40,000
私たちは前に、この関数を見ますが、これはどんなことをしている推測を取るていない。

951
00:51:40,000 --> 00:51:42,000
文字列を比較します。

952
00:51:42,000 --> 00:51:45,000
>> それが判明したので、それが文字列を比較する方法を少し非は明らかだ

953
00:51:45,000 --> 00:51:49,000
それは、文字列が等しいことを意味し、0を返します。

954
00:51:49,000 --> 00:51:53,000
それは、一方が他方よりもアルファベット順で前に来ることを意味し、-1を返した場合

955
00:51:53,000 --> 00:51:57,000
そしてそれは他の単語がアルファベット順に来る意味1を返した場合

956
00:51:57,000 --> 00:52:00,000
他の前に、あなたは、オンラインまたはmanページを見ることができます

957
00:52:00,000 --> 00:52:04,000
今やっているされているが、このすべてを正確に確認する方法と、それは言っている

958
00:52:04,000 --> 00:52:09,000
[i]とする。家は "マザー"に等しい場合

959
00:52:09,000 --> 00:52:13,000
その後、先に行くと云メイザーにあるプリントアウト。

960
00:52:13,000 --> 00:52:16,000
しかし、ここで我々は前に見たことがない何かである、と我々はこれに戻ってくる。

961
00:52:16,000 --> 00:52:21,000
私が今まで私のプログラムのいずれかでこれをしなければならないことは覚えていません。

962
00:52:21,000 --> 00:52:24,000
フリーは明らかに、メモリを解放し、メモリを参照している

963
00:52:24,000 --> 00:52:31,000
しかし、私は明らかに、このプログラムの一番下に、このループで何メモリを解放していますか？

964
00:52:31,000 --> 00:52:34,000
私は人の名前を解放しているように見えます

965
00:52:34,000 --> 00:52:37,000
その人の家が、なぜそれがですか？

966
00:52:37,000 --> 00:52:41,000
>> それはあなたがGetStringメソッドを使用してきたことが、これらのすべての週判明

967
00:52:41,000 --> 00:52:45,000
私達は種類のあなたのプログラムの一つ一つにバグを導入してきました。

968
00:52:45,000 --> 00:52:51,000
それはあなたの文字列に戻すことができるように設計がメモリを割り当てることによってgetStringは、

969
00:52:51,000 --> 00:52:55,000
デビッド、またはロブ様、あなたはそれからあなたが好きなことを行うことができ

970
00:52:55,000 --> 00:52:59,000
私たちはあなたのためのメモリを確保してきたので、あなたのプログラム内でその文字列を持つ。

971
00:52:59,000 --> 00:53:02,000
問題は、GetStringメソッドを呼び出すたびにこのすべての時間です

972
00:53:02,000 --> 00:53:05,000
我々は、GetStringの著者は、オペレーティング·システムを求めてきた

973
00:53:05,000 --> 00:53:07,000
私たちは、この文字列のためのRAMのビットを得た。

974
00:53:07,000 --> 00:53:09,000
私たちは、この次の文字列のためのRAMのビットを与える。

975
00:53:09,000 --> 00:53:11,000
私たちは、この次の文字列のためのいくつかのより多くのRAMを与える。

976
00:53:11,000 --> 00:53:13,000
あなたは、プログラマは、何をやったことがない

977
00:53:13,000 --> 00:53:15,000
私たちにそのメモリバックを与えている

978
00:53:15,000 --> 00:53:17,000
あなたの書いたプログラムのため、これらの数週間のためのすべて

979
00:53:17,000 --> 00:53:20,000
彼らが使用し続けることにより、メモリの飛躍と呼ばれるものを持っていた

980
00:53:20,000 --> 00:53:24,000
より多くのメモリをあなたがGetStringメソッドを呼び出すと、それは大丈夫です毎回。

981
00:53:24,000 --> 00:53:27,000
それは面白いではありませんので、我々は意図的に最初の数週間でそれを行う

982
00:53:27,000 --> 00:53:29,000
文字列がどこから来ていることを心配する必要はあります。

983
00:53:29,000 --> 00:53:34,000
あなたが欲しいのは単語は、ユーザーの入力時に、それをインチ戻ってきてロブです

984
00:53:34,000 --> 00:53:38,000
>> しかし、前進して我々は今、このことについて、より洗練された取得を開始する必要があります。

985
00:53:38,000 --> 00:53:42,000
我々は我々がより良い最終的に戻ってそれを渡してメモリを割り当てることがいつでも。

986
00:53:42,000 --> 00:53:45,000
そうでなければ、時折経験しているかもしれないあなたのMacまたはPC上で現実の世界では

987
00:53:45,000 --> 00:53:50,000
お使いのコンピュータは、最終的に停止して研削される症状

988
00:53:50,000 --> 00:53:54,000
または愚か紡績ビーチボールは、ちょうどコンピュータのを占めている

989
00:53:54,000 --> 00:53:56,000
全体の注意を、あなたが何かを行うことはできない。

990
00:53:56,000 --> 00:54:00,000
そのバグは、任意の数によって説明するが、それらのバグの可能性の間ですることができます

991
00:54:00,000 --> 00:54:03,000
それによってそのソフトウェアを書いた誰かのものはメモリリークと呼ばれています

992
00:54:03,000 --> 00:54:07,000
あなたは、メモリを解放するために覚えていませんでした使用している

993
00:54:07,000 --> 00:54:10,000
彼または彼女はのためにオペレーティング·システムを求めていること、

994
00:54:10,000 --> 00:54:14,000
それはCS50の事だから、GetStringメソッドを使用しますが、同様の機能を使用していない

995
00:54:14,000 --> 00:54:16,000
メモリ用のオペレーティングシステムに依頼すること。

996
00:54:16,000 --> 00:54:19,000
あなたまたは彼らは台無しにした場合、実際にそのメモリを返すことはありません

997
00:54:19,000 --> 00:54:24,000
プログラムが遅くなり、遅くなり、遅くなるということであるかもしれませんの症状

998
00:54:24,000 --> 00:54:26,000
あなたは自由を呼び出すことを覚えていない限り。

999
00:54:26,000 --> 00:54:28,000
>> 私たちは、いつ、なぜ、あなたがフリー呼ぶように戻るでしょう

1000
00:54:28,000 --> 00:54:32,000
しかし、ここでは単に良い測定のために先に行くと、この特定のプログラムを実行してみましょう。

1001
00:54:32,000 --> 00:54:35,000
これはstructs1と呼ばれていた、次のように入力します。

1002
00:54:35,000 --> 00:54:40,000
デビッド·メイザー、私が先に行くとstructs1、123を実行してみましょう、

1003
00:54:40,000 --> 00:54:47,000
456、ロブカークランド、789

1004
00:54:47,000 --> 00:54:50,000
トミー·メイザー、私たちはマザー、マザーでトミーのでDavidのを参照してください。

1005
00:54:50,000 --> 00:54:53,000
これは、プログラムが動作していることを、ほんの少しの健全性チェックです。

1006
00:54:53,000 --> 00:54:56,000
さて、残念なことに、このプログラムは、以下の点で少しイライラさせられる

1007
00:54:56,000 --> 00:55:00,000
私はすべての仕事は、私が9つの異なる文字列で入力し、ENTERキーを押してなかった、

1008
00:55:00,000 --> 00:55:04,000
メイザーにあった人たちに語った、まだ明らかに私はそれを入力したために、すでにメイザーで誰か知っていたしました。

1009
00:55:04,000 --> 00:55:07,000
このプログラムは、より多くのデータベースのようであれば、それは少なくともいいだろう

1010
00:55:07,000 --> 00:55:10,000
そしてそれは実際に私がタイプしたものを覚えている

1011
00:55:10,000 --> 00:55:12,000
ので、私は再び入力これらの生徒の記録をする必要はありません。

1012
00:55:12,000 --> 00:55:15,000
多分それはregistrarialシステムのようなものだ。

1013
00:55:15,000 --> 00:55:21,000
>> 我々は、ファイルI / O、ファイルの入出力として知られているこの技術を用いてこれを行うことができます

1014
00:55:21,000 --> 00:55:24,000
あなたがファイルを読み取ったり、ファイルを作成したい任意の時間を言うのは非常に一般的な方法

1015
00:55:24,000 --> 00:55:26,000
あなたは、関数の特定のセットでこれを行うことができます。

1016
00:55:26,000 --> 00:55:29,000
私が先に行くと、この例のstructs2.cを開いてみましょう、

1017
00:55:29,000 --> 00:55:33,000
これはほぼ同じですが、それが今では何をするか見てみましょう。

1018
00:55:33,000 --> 00:55:36,000
ファイルの先頭に、私は学生のクラスを宣言します。

1019
00:55:36,000 --> 00:55:38,000
私はその後、ユーザーの入力を持つクラスを移入

1020
00:55:38,000 --> 00:55:41,000
これらのコード行を正確に前に似ているので。

1021
00:55:41,000 --> 00:55:45,000
メイザーである誰もが勝手に以前のように私はここにスクロールダウンする場合、私は、印刷、

1022
00:55:45,000 --> 00:55:47,000
しかし、これは興味深い新機能です。

1023
00:55:47,000 --> 00:55:51,000
、これらのコード行は、新規であり、彼らはここで何かを紹介

1024
00:55:51,000 --> 00:55:55,000
FILE、すべて大文字、それもここに*を持っています。

1025
00:55:55,000 --> 00:55:58,000
ここでも同様にオーバー*、私はここにこれを移動することができます。

1026
00:55:58,000 --> 00:56:00,000
>> 我々は前に見たことがないこの関数は、fopen、

1027
00:56:00,000 --> 00:56:03,000
それは開いているファイルを意味しますので、これらを介してのは脱脂せ、

1028
00:56:03,000 --> 00:56:05,000
これは、我々は将来のpsetにに戻ってくるものです

1029
00:56:05,000 --> 00:56:10,000
しかしここでこの行は、本質的には、データベースと呼ばれるファイルを開きます

1030
00:56:10,000 --> 00:56:13,000
そして、それは具体的にそれはそれに何をすることができるような方法でそれを開きますか？

1031
00:56:13,000 --> 00:56:15,000
[聞き取れない - 学生]

1032
00:56:15,000 --> 00:56:19,000
右ので、 "w"は、ちょうどそれがオペレーティングシステムを語っていることを意味

1033
00:56:19,000 --> 00:56:21,000
私はそれに書き込むことができるような方法でこのファイルを開きます。

1034
00:56:21,000 --> 00:56:23,000
私はそれを読みたくありません。私はちょうどそれを見たくありません。

1035
00:56:23,000 --> 00:56:26,000
私は、それを変更し、それに潜在的なものを追加したい

1036
00:56:26,000 --> 00:56:28,000
とファイルには、データベースと呼ばれようとしています。

1037
00:56:28,000 --> 00:56:30,000
これは、何かを呼び出すことができます。

1038
00:56:30,000 --> 00:56:32,000
これはdatabase.txtである可能性があります。これは可能性があります。デシベル。

1039
00:56:32,000 --> 00:56:37,000
これはfooのような言葉かもしれないが、私は勝手にファイルデータベースに名前を付けることにしました。

1040
00:56:37,000 --> 00:56:42,000
これは、我々は時間をかけて丹念にに戻ってくることはほとんど正気チェックです

1041
00:56:42,000 --> 00:56:47,000
fpは、ファイルポインタの場合、NULLを等しくない場合、それはすべてが順調であることを意味します。

1042
00:56:47,000 --> 00:56:51,000
>> 手短には、fopenのような関数が失敗することがあります。

1043
00:56:51,000 --> 00:56:53,000
たぶん、ファイルが存在しません。たぶんあなたは、ディスク容量が不足している。

1044
00:56:53,000 --> 00:56:55,000
たぶん、あなたは、そのフォルダへのアクセス権がありません

1045
00:56:55,000 --> 00:56:58,000
fopenがない場合はnullが返されますので、何か悪いことが起こった。

1046
00:56:58,000 --> 00:57:02,000
fopenはnullを返さない場合は逆に、すべてが順調です

1047
00:57:02,000 --> 00:57:04,000
そして私は、このファイルへの書き込みを開始することができます。

1048
00:57:04,000 --> 00:57:06,000
ここでは、新しいトリックだ。

1049
00:57:06,000 --> 00:57:08,000
これは、私の生徒のそれぞれの繰り返し処理を行うのはのためのループです

1050
00:57:08,000 --> 00:57:10,000
これは、我々は前にやったことに非常に似ている

1051
00:57:10,000 --> 00:57:15,000
しかし、この関数は、printfのファイルにfprintf関数と呼ばれるprintfのいとこです

1052
00:57:15,000 --> 00:57:18,000
それが唯一の2つの方法で異なることに気づく。

1053
00:57:18,000 --> 00:57:20,000
一つは、それは、代わりに電話のfで始まる

1054
00:57:20,000 --> 00:57:23,000
しかし、その最初の引数は明らかに何ですか？

1055
00:57:23,000 --> 00:57:25,000
[学生]ファイル。>>それはファイルです。

1056
00:57:25,000 --> 00:57:30,000
我々は最終的にファイルポインタが何であるかを離れていじめるよFPと呼ばれるこの事、、

1057
00:57:30,000 --> 00:57:35,000
しかし、今のfpは単に、私が開いているファイルを表す

1058
00:57:35,000 --> 00:57:41,000
そうfprintfをここにファイルにではなく、画面にこのユーザーのIDを表示と言っている。

1059
00:57:41,000 --> 00:57:44,000
ファイルへのユーザの名前ではなく、画面に、印刷

1060
00:57:44,000 --> 00:57:47,000
ファイルにではなく、明らかに、ここでダウンし、画面に、家

1061
00:57:47,000 --> 00:57:50,000
ファイルを閉じてから、ダウンここでメモリを解放する。

1062
00:57:50,000 --> 00:57:53,000
>> このバージョン2とバージョン1の唯一の違い

1063
00:57:53,000 --> 00:57:58,000
fopenの導入と、*このファイルです

1064
00:57:58,000 --> 00:58:01,000
とfprintfのこの概念は、その最終的な結果が何であるかを見てみましょう。

1065
00:58:01,000 --> 00:58:03,000
私は私の端末ウィンドウに行こう。

1066
00:58:03,000 --> 00:58:06,000
私はstructs2を実行してみましょう、次のように入力します。

1067
00:58:06,000 --> 00:58:09,000
すべてが順調であるように見えます。 structs2を再実行してみましょう。

1068
00:58:09,000 --> 00:58:15,000
123、デビッド·メイザー、456、ロブカークランド、

1069
00:58:15,000 --> 00:58:19,000
789、トミー·メイザーは、次のように入力。

1070
00:58:19,000 --> 00:58:23,000
それは同じように行儀のように見えますが、私は今、lsを行う場合

1071
00:58:23,000 --> 00:58:28,000
すべての私のコードの中で、ここにあるものに気付くファイル、データベース、

1072
00:58:28,000 --> 00:58:32,000
それでは、データベースと、geditを開いてみましょう、そしてそれを見て。

1073
00:58:32,000 --> 00:58:34,000
それは、ファイルフォーマットの最もセクシーではありません。

1074
00:58:34,000 --> 00:58:38,000
それは本当に、行ごとに行あたりのデータ行の1枚です

1075
00:58:38,000 --> 00:58:42,000
しかし、ExcelまたはCSVファイルを使用してあなたの人々の、コンマで区切られた値、

1076
00:58:42,000 --> 00:58:47,000
私は確かに代わりに多分このような何かをするfprintfを使用することもできました

1077
00:58:47,000 --> 00:58:50,000
私は実際にExcelファイルと同等のものを作成することができますように

1078
00:58:50,000 --> 00:58:53,000
コンマだけでなく、新しい行で物事を分離することによって。

1079
00:58:53,000 --> 00:58:56,000
>> この場合において、私は代わりにコンマの代わりに新しい行を使用した場合

1080
00:58:56,000 --> 00:59:01,000
私が代わりにそれはこのように見えた場合、私は文字通りExcelでこのデータベースファイルを開くことができます。

1081
00:59:01,000 --> 00:59:03,000
要するに、今、我々はファイルへの書き込みをする力を持っていること

1082
00:59:03,000 --> 00:59:07,000
我々は今、ディスク上でそれを周りに保ち、永続データを起動することができます

1083
00:59:07,000 --> 00:59:10,000
我々は何度も何度も周りの情報を保持できるようにします。

1084
00:59:10,000 --> 00:59:14,000
今ではもう少し慣れている他のいくつかの点に注意してください。

1085
00:59:14,000 --> 00:59:16,000
このCファイルの先頭に、我々は、typedefを持っている

1086
00:59:16,000 --> 00:59:21,000
我々はその言葉を表すデータ型を作成したかったので、

1087
00:59:21,000 --> 00:59:25,000
このタイプはワードと呼ばれるように、内部にこの構造体の

1088
00:59:25,000 --> 00:59:27,000
それが今では少し手の込んだ。

1089
00:59:27,000 --> 00:59:30,000
なぜ言葉は明らかに配列で構成されています？

1090
00:59:30,000 --> 00:59:33,000
ただ直感的に言葉は何ですか？

1091
00:59:33,000 --> 00:59:35,000
>> それは文字の配列です。

1092
00:59:35,000 --> 00:59:37,000
これは、バックアップする背中合わせに一連の文字です。

1093
00:59:37,000 --> 00:59:41,000
すべて大文字の文字は、私たちが勝手に言うことを起こる最大長

1094
00:59:41,000 --> 00:59:44,000
我々はスクランブルのために使用している辞書に載っているような単語の。

1095
00:59:44,000 --> 00:59:46,000
なぜ私は1を持っていますか？

1096
00:59:46,000 --> 00:59:48,000
ヌル文字。

1097
00:59:48,000 --> 00:59:51,000
我々は特別な値を必要としてBananagrams例をやったときを思い出してください

1098
00:59:51,000 --> 00:59:55,000
を追跡するために、単語の末尾に

1099
00:59:55,000 --> 00:59:59,000
言葉が実際に終了したところの、問題セット仕様が言うように

1100
00:59:59,000 --> 01:00:03,000
ここでは、与えられた単語とブール値を関連付けるしている

1101
01:00:03,000 --> 01:00:05,000
いわば、trueまたはfalseのフラグ。

1102
01:00:05,000 --> 01:00:09,000
私たちは実現するためには、すでにこの言葉を発見した

1103
01:00:09,000 --> 01:00:13,000
私たちは本当に言葉がスクランブルにあるものだけでなく、覚えるの方法が必要

1104
01:00:13,000 --> 01:00:15,000
しかし、あなたかどうかにかかわらず、人間は、それを発見した

1105
01:00:15,000 --> 01:00:20,000
あなたが見つけられた場合に、単語は ""あなただけ入力できないように、次のように入力し、入力し、入力します。

1106
01:00:20,000 --> 01:00:23,000
と3点、3点、3点、3ポイントを取得します。

1107
01:00:23,000 --> 01:00:26,000
我々はboolを設定することで、その単語をブラックリストに登録できるようにしたい

1108
01:00:26,000 --> 01:00:29,000
あなたはすでにそれを見つけたなら、なぜtrueにし、その結果は私たちです

1109
01:00:29,000 --> 01:00:31,000
この構造体にカプセル化された。

1110
01:00:31,000 --> 01:00:35,000
>> さて、ここでダウンしてスクランブルに入っている辞書と呼ばれるこの他の構造体があります。

1111
01:00:35,000 --> 01:00:39,000
ここに欠席この場合のための単語typedefです

1112
01:00:39,000 --> 01:00:43,000
私たちは、辞書のアイデアをカプセル化するために必要な

1113
01:00:43,000 --> 01:00:46,000
と辞書には、単語の全体の束が含まれています

1114
01:00:46,000 --> 01:00:49,000
としてこの配列によって暗示、そしてどのようにそれらの単語のいくつあるのですか？

1115
01:00:49,000 --> 01:00:51,000
さて、この変数と呼ばれるサイズが何を言おう。

1116
01:00:51,000 --> 01:00:53,000
しかし、我々は一つの辞書を必要としています。

1117
01:00:53,000 --> 01:00:55,000
私たちは辞書と呼ばれるデータ型を必要としません。

1118
01:00:55,000 --> 01:00:58,000
私達はちょうどそれらのいずれかを必要とするので、それはC言語で判明

1119
01:00:58,000 --> 01:01:03,000
あなたはtypedefを言わないのであれば、あなただけのstr​​uctを言うことは、中カッコ内の

1120
01:01:03,000 --> 01:01:05,000
あなたが名前を入れた後、あなたの変数を置く。

1121
01:01:05,000 --> 01:01:09,000
これは、辞書と呼​​ばれる一つの変数を宣言している

1122
01:01:09,000 --> 01:01:11,000
それはこのようになります。

1123
01:01:11,000 --> 01:01:16,000
これとは対照的に、これらの行はワードと呼ばれる再利用可能なデータ構造を作成している

1124
01:01:16,000 --> 01:01:19,000
あなたは私たちが作成したのと同じように、複数のコピーを作成することができます

1125
01:01:19,000 --> 01:01:22,000
学生の複数のコピー。

1126
01:01:22,000 --> 01:01:24,000
>> これは、最終的に私たちは何ができるのでしょうか？

1127
01:01:24,000 --> 01:01:30,000
、私はシンプルな時代から簡単な例、みましょうと言う、に戻ってみましょう

1128
01:01:30,000 --> 01:01:34,000
とcompare1.c、としましょう​​、私は開くことができます。

1129
01:01:34,000 --> 01:01:38,000
ここでの問題は、手元に戻って剥がしに実際にある

1130
01:01:38,000 --> 01:01:41,000
文字列の層と、これらの補助輪を外して起動する

1131
01:01:41,000 --> 01:01:44,000
それは、文字列、すべてのこの時間を判明ので

1132
01:01:44,000 --> 01:01:47,000
私たちは本当に週1でニックネームのみを約束した通りである、

1133
01:01:47,000 --> 01:01:51,000
もう少し不可解に見える何かのためにCS50ライブラリからシノニム、

1134
01:01:51,000 --> 01:01:53,000
char *は、そして我々は前にこの星を見てきました。

1135
01:01:53,000 --> 01:01:55,000
我々は、ファイルのコンテキストでそれを見た。

1136
01:01:55,000 --> 01:01:59,000
>> 我々はいくつかの時間が今のこの詳細を隠してきた理由を今見てみましょう。

1137
01:01:59,000 --> 01:02:02,000
ここcompare1.cというファイルがあり、

1138
01:02:02,000 --> 01:02:07,000
そしてそれは明らかに、2つの文字列、sとtをユーザーに要求

1139
01:02:07,000 --> 01:02:11,000
そして、次に、それは、ライン26の平等のためにそれらの文字列を比較しよう

1140
01:02:11,000 --> 01:02:14,000
それらが等しいなら、それは "あなたが同じことを入力した"と言う。

1141
01:02:14,000 --> 01:02:17,000
そして、それらが等しくないなら、それは "あなたは別のものを入力した"と言う。

1142
01:02:17,000 --> 01:02:19,000
私が先に行くと、このプログラムを実行してみましょう。

1143
01:02:19,000 --> 01:02:23,000
私は私のソースディレクトリに移動してみましょう、compare1を作る。それは大丈夫コンパイル。

1144
01:02:23,000 --> 01:02:25,000
私はcompare1を実行してみましょう。

1145
01:02:25,000 --> 01:02:27,000
私は、にズームイン入力します。

1146
01:02:27,000 --> 01:02:29,000
何かを言う。こんにちは。

1147
01:02:29,000 --> 01:02:32,000
私は再び何かを言うでしょう。こんにちは。

1148
01:02:32,000 --> 01:02:34,000
私は間違いなく別のものを入力されていません。

1149
01:02:34,000 --> 01:02:37,000
>> 私は再びこれを試してみましょう。バイバイ。

1150
01:02:37,000 --> 01:02:40,000
間違いなく異なるので、ここで何が起こっているのですか？

1151
01:02:40,000 --> 01:02:44,000
まあ、本当に26行目で比較されているのか？

1152
01:02:44,000 --> 01:02:46,000
[聞き取れない - 学生]

1153
01:02:46,000 --> 01:02:49,000
はい、だからそれは、文字列、データ型は、白い嘘の一種であることが判明した。

1154
01:02:49,000 --> 01:02:53,000
文字列はchar *ですが、char *型は何ですか？

1155
01:02:53,000 --> 01:02:56,000
char *は、彼らが言うように、ポインタである

1156
01:02:56,000 --> 01:03:00,000
ポインタは、事実上のアドレスです

1157
01:03:00,000 --> 01:03:05,000
合計メモリ内​​の場所、およびあなたはHELLOのようなワードで入力したために起こる場合、

1158
01:03:05,000 --> 01:03:08,000
文字列の過去の議論を思い出して

1159
01:03:08,000 --> 01:03:16,000
これはHELLO言葉のようなものです。

1160
01:03:16,000 --> 01:03:19,000
ハローのような単語が表現​​できることを覚えておいてください

1161
01:03:19,000 --> 01:03:22,000
このような文字の配列として

1162
01:03:22,000 --> 01:03:25,000
その後末尾には、特殊文字とヌル文字と呼ばれ、

1163
01:03:25,000 --> 01:03:27,000
\で囲まれている。

1164
01:03:27,000 --> 01:03:29,000
実際には文字列とは何ですか？

1165
01:03:29,000 --> 01:03:32,000
これはメモリの複数の塊であることに注意して、

1166
01:03:32,000 --> 01:03:36,000
あなたが文字列全体に目を通した後、実際に、それの終わりにのみ知られている

1167
01:03:36,000 --> 01:03:38,000
特別なNULL文字を探しています。

1168
01:03:38,000 --> 01:03:41,000
しかし、これは私のコンピュータのメモリからメモリの塊である場合、

1169
01:03:41,000 --> 01:03:44,000
任意に、この文字列は、単に幸運と言ってみましょう

1170
01:03:44,000 --> 01:03:47,000
そしてそれは私のコンピュータのRAMの冒頭に置かれてしまった。

1171
01:03:47,000 --> 01:03:54,000
これは、バイト0、1、2、3、4、5、6です...

1172
01:03:54,000 --> 01:04:02,000
>> 私は、GetStringメソッドのようなものを言うと私は、文字列s = GetStringを行うと

1173
01:04:02,000 --> 01:04:04,000
本当に何が返されるのですか？

1174
01:04:04,000 --> 01:04:08,000
これらの過去数週間のために、何が本当にsに格納されている

1175
01:04:08,000 --> 01:04:13,000
この文字列は、それ自体ではありませんが、このケースに格納されているものです

1176
01:04:13,000 --> 01:04:18,000
GetStringメソッドは、実際に何をするか理由番号0

1177
01:04:18,000 --> 01:04:20,000
それは物理的に文字列を返していないことです。

1178
01:04:20,000 --> 01:04:22,000
それも本当に概念的な意味をなさない。

1179
01:04:22,000 --> 01:04:24,000
それはリターンが数値である何。

1180
01:04:24,000 --> 01:04:28,000
その数は、メモリ内のHELLOのアドレスです。

1181
01:04:28,000 --> 01:04:32,000
と文字列sはその後、我々は戻って剥がし、この層は、文字列は実際に存在しない場合。

1182
01:04:32,000 --> 01:04:35,000
それだけCS50ライブラリの簡素化です。

1183
01:04:35,000 --> 01:04:38,000
>> これは実際にはchar *と呼ばれているものです。

1184
01:04:38,000 --> 01:04:41,000
何がHELLOのような単語だからcharは理にかなっている？

1185
01:04:41,000 --> 01:04:44,000
まあ、それは文字のシリーズは、一連の文字です。

1186
01:04:44,000 --> 01:04:47,000
char *は、文字のアドレスを意味します

1187
01:04:47,000 --> 01:04:50,000
だから何それが文字列を返すためにどういう意味ですか？

1188
01:04:50,000 --> 01:04:53,000
文字列を返すの素敵な、簡単な方法

1189
01:04:53,000 --> 01:04:57,000
というより、私が5または6の異なるバイトに戻す方法を把握しよう

1190
01:04:57,000 --> 01:05:01,000
私はバイトのアドレスに戻りましょう？

1191
01:05:01,000 --> 01:05:03,000
最初の1つ。

1192
01:05:03,000 --> 01:05:06,000
言い換えれば、私はあなたに、メモリ内の文字のアドレスを与えることができます。

1193
01:05:06,000 --> 01:05:10,000
つまり、char *は何を表しているか、メモリ内の1つの文字のアドレスです。

1194
01:05:10,000 --> 01:05:12,000
その変数sを呼び出します。

1195
01:05:12,000 --> 01:05:15,000
私が勝手に言った特定のアドレスは、0であることをsの店舗、

1196
01:05:15,000 --> 01:05:19,000
物事をシンプルに保つことが、現実には、一般的に大きい数字です。

1197
01:05:19,000 --> 01:05:21,000
>> ちょっと待ってください。

1198
01:05:21,000 --> 01:05:23,000
あなたは私だけに最初の文字のアドレスを与えている場合、どのようにアドレスを知っていますか

1199
01:05:23,000 --> 01:05:25,000
二番目の文字、第三、第四及び第五の？

1200
01:05:25,000 --> 01:05:27,000
[聞き取れない - 学生]

1201
01:05:27,000 --> 01:05:31,000
文字列の終わりは、この便利なトリックを介してどこにあるかだけ知っている、

1202
01:05:31,000 --> 01:05:35,000
ので、あなたは、printf文字通りその引数として取るものprintfのようなものを、使用する場合、

1203
01:05:35,000 --> 01:05:39,000
我々はこの％sプレースホルダを使用することを思い出して、その後、に渡す

1204
01:05:39,000 --> 01:05:41,000
文字列を格納している変数。

1205
01:05:41,000 --> 01:05:47,000
あなたが本当に渡していると、その文字列の最初の文字のアドレスです。

1206
01:05:47,000 --> 01:05:50,000
printfはその後、そのアドレスを受信したときにループまたはwhileループのために使用

1207
01:05:50,000 --> 01:05:53,000
例えば、0、そう、私は今これをやらせる

1208
01:05:53,000 --> 01:06:02,000
のprintf（ "％sを\ n"、S）;

1209
01:06:02,000 --> 01:06:07,000
私は実際にprintfを提供しているものを、私は、printf（ "％sは\ n"のS）を呼び出したとき

1210
01:06:07,000 --> 01:06:13,000
この任意の場合にはHであるsの最初の文字のアドレスであり、

1211
01:06:13,000 --> 01:06:16,000
>> どのようにprintfを画面に表示するかを正確に知るのでしょうか？

1212
01:06:16,000 --> 01:06:19,000
実装者は、printfのforループ、whileループまたは実装

1213
01:06:19,000 --> 01:06:23,000
この文字は特別なnull文字が等しくないことは言う？

1214
01:06:23,000 --> 01:06:25,000
ていない場合は、それを印刷してください。どのようにこの1はどうですか？

1215
01:06:25,000 --> 01:06:28,000
それを印刷していない場合は、それを印刷し、それを印刷し、それを印刷してください。

1216
01:06:28,000 --> 01:06:32,000
ああ、この人は特別です。印刷を停止し、ユーザに戻ります。

1217
01:06:32,000 --> 01:06:35,000
そして、それは、文字通りフードの下に起こっていることすべてだ

1218
01:06:35,000 --> 01:06:38,000
それは、クラスの初日に消化するために多くのです

1219
01:06:38,000 --> 01:06:43,000
しかし今のところ、それは本当にすべてのものを理解するのビルディングブロックです

1220
01:06:43,000 --> 01:06:46,000
私たちのコンピュータのメモリの内側に起こっていること、

1221
01:06:46,000 --> 01:06:49,000
そして最終的に、我々は少しの助けを借りて、これを離れていじめるよ

1222
01:06:49,000 --> 01:06:51,000
スタンフォード大学の我々の友人の一人から。

1223
01:06:51,000 --> 01:06:56,000
>> スタンフォード大学教授ニックParlanteこの素晴らしいビデオシーケンスを行っている

1224
01:06:56,000 --> 01:06:58,000
導入された異なる言語のすべての種類から

1225
01:06:58,000 --> 01:07:00,000
この小さなクレイ文字BINKY。

1226
01:07:00,000 --> 01:07:03,000
あなただけの数秒のスニーク·プレビューで聞いている声について

1227
01:07:03,000 --> 01:07:05,000
スタンフォード大学教授のことであり、あなたが取得している

1228
01:07:05,000 --> 01:07:07,000
今、この権利のわずか5〜6秒、

1229
01:07:07,000 --> 01:07:09,000
しかし、これは我々が今日結論を出すでしょうしているノートです

1230
01:07:09,000 --> 01:07:11,000
そして水曜日に始まる。

1231
01:07:11,000 --> 01:07:15,000
私はあなたにBINKY、プレビュー付きのポインターの楽しみを与える。

1232
01:07:15,000 --> 01:07:18,000
[♪音楽♪] [教授Parlante]ねえ、BINKY。

1233
01:07:18,000 --> 01:07:21,000
目を覚まして。これは、ポインタの楽しみのための時間です。

1234
01:07:21,000 --> 01:07:24,000
[BINKY]それは何ですか？ポインタについて学ぶのか？

1235
01:07:24,000 --> 01:07:26,000
ああ、すごーい！

1236
01:07:26,000 --> 01:07:29,000
>> 私たちは、水曜日にお会いしましょう​​。

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]