1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [レビュー] [クイズ0]

2
00:00:03,000 --> 00:00:05,000
>> [レキシー·ロス、トミーMacWilliam、ルーカス·フレイタス、ジョセフ·オング] [ハーバード大学]

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

4
00:00:08,000 --> 00:00:10,000
>> ねえ、みんな。

5
00:00:10,000 --> 00:00:15,000
この水曜日行われているクイズ0の場合、レビューセッションへようこそ。

6
00:00:15,000 --> 00:00:19,000
今夜はやろうとしている、私は、他の3つのTFSと一緒だ

7
00:00:19,000 --> 00:00:24,000
と一緒に、我々はこれまでのコースで何をしたのかを審査を通過しようとしている。

8
00:00:24,000 --> 00:00:27,000
それは100％包括的であることを行っていないが、それはあなたの良いアイデアを与える必要があります

9
00:00:27,000 --> 00:00:31,000
あなたは既にダウンして持っているものの、何あなたはまだ水曜日の前の勉強する必要があります。

10
00:00:31,000 --> 00:00:34,000
そして、私たちは一緒になるだろうとの質問に手を上げて自由に感じる

11
00:00:34,000 --> 00:00:38,000
しかし、我々はまたで少し時間がなければならないということを覚えておいてエンド

12
00:00:38,000 --> 00:00:41,000
我々は、一般的な質問を行う - にスペアするために数分とを介して取得した場合、

13
00:00:41,000 --> 00:00:47,000
そうということを忘れないでください、と私たちは週0で先頭から開始するつもりです。

14
00:00:47,000 --> 00:00:50,000
>> [パート0] [レキシー·ロス] [0レビュー！クイズ]しかし、我々は、やる前にレッツトークに関すること

15
00:00:50,000 --> 00:00:53,000
クイズの物流。

16
00:00:53,000 --> 00:00:55,000
>> [物流] [クイズ講義の代わりに水曜日10月10日に行われます]

17
00:00:55,000 --> 00:00:57,000
>> [（詳細はhttp://cdn.cs50.net/2012/fall/quizzes/0/about0.pdfを参照してください）​​]これは、10月10日（水曜日）にあります。

18
00:00:57,000 --> 00:01:00,000
>> つまり、今週の水曜日だし、ここで次のURLにアクセスしている場合、

19
00:01:00,000 --> 00:01:03,000
これはまたへのリンクCS50.net-そこ 'sからアクセス可能であること、

20
00:01:03,000 --> 00:01:06,000
あなたは、に基づいて、どこに行ったらよいかについての情報を参照することができます

21
00:01:06,000 --> 00:01:10,000
あなたの姓や学校提携と同様に

22
00:01:10,000 --> 00:01:14,000
それは約まさにクイズがカバーする、あなたが得ようとしていることを質問の種類に伝えます。

23
00:01:14,000 --> 00:01:19,000
あなたはまた、セクションでクイズについてのレビューする機会がなければならないということを覚えておいてください

24
00:01:19,000 --> 00:01:21,000
ので、あなたのTFは、いくつかの練習問題の上に行くべきである

25
00:01:21,000 --> 00:01:29,000
そしてそれはあなたがまだクイズを補う勉強する必要がある場所を確認するために別の良い機会です。

26
00:01:29,000 --> 00:01:32,000
ビット 'n'のバイトで最初からスタートしてみましょう。

27
00:01:32,000 --> 00:01:35,000
少しばかりの0または1であることを覚えている

28
00:01:35,000 --> 00:01:38,000
とバイトは、これらのビットの8の集合です。

29
00:01:38,000 --> 00:01:42,000
右ここにこのビットのコレクションを見てみましょう。

30
00:01:42,000 --> 00:01:44,000
我々はいくつあるかのビットを把握することができるはずです。

31
00:01:44,000 --> 00:01:48,000
ここで、我々は、そのうちの8はちょうどそこの8つの0または1台を数える。

32
00:01:48,000 --> 00:01:51,000
それ以来8ビット、1バイトだが、そこ

33
00:01:51,000 --> 00:01:53,000
とのは、16進数に変換してみましょう。

34
00:01:53,000 --> 00:01:58,000
進は、ベース16であり、それは変換するのはとても簡単です

35
00:01:58,000 --> 00:02:01,000
バイナリ内の数字は、これは16進数の数値に、それが何であるかです。

36
00:02:01,000 --> 00:02:04,000
我々が行うすべては、我々は4つのグループを見ている

37
00:02:04,000 --> 00:02:07,000
そして我々は適切な16進数字に変換します。

38
00:02:07,000 --> 00:02:11,000
私たちはそう0011、4の一番右のグループで開始します。

39
00:02:11,000 --> 00:02:16,000
それはとても共に3にかなっている、1 1、1 2になるだろう。

40
00:02:16,000 --> 00:02:19,000
そして、4の他のブロックを見てみましょう。

41
00:02:19,000 --> 00:02:24,000
1101年。つまり、1 1、1 4、1 8になるだろう。

42
00:02:24,000 --> 00:02:28,000
一緒にDを作る13日になるだろうという

43
00:02:28,000 --> 00:02:32,000
そして、我々は、16進数で我々だけで、0〜9を行っていないことを覚えているだろう。

44
00:02:32,000 --> 00:02:36,000
我々は、そう〜9、10に対応した後、Fを介して0に行く

45
00:02:36,000 --> 00:02:40,000
Bに11、Fは15であるとcetera。

46
00:02:40,000 --> 00:02:44,000
ここで13は、Dである

47
00:02:44,000 --> 00:02:49,000
ので、それは我々が行うすべては、我々実際に10進数に変換する

48
00:02:49,000 --> 00:02:52,000
2のべき乗として各位置を扱う。

49
00:02:52,000 --> 00:02:58,000
それは、とcetera、4S 1 1、1 2、ゼロ、ゼロ8S、1つの16だ

50
00:02:58,000 --> 00:03:03,000
そしてそれはあなたの頭の中で計算するのは少し難しいですが、私達は次のスライドに移動した場合

51
00:03:03,000 --> 00:03:05,000
我々はその答えを見ることができます。

52
00:03:05,000 --> 00:03:09,000
>> 基本的に我々は、右から左に戻ってから渡って行っている、

53
00:03:09,000 --> 00:03:14,000
そして我々は2の対応力によって、各桁を乗じている。

54
00:03:14,000 --> 00:03:19,000
そして、覚えている進のために、我々は先頭に0xでこれらの数値を示す

55
00:03:19,000 --> 00:03:23,000
ので、我々は10進数で、それを混同しないでください。

56
00:03:23,000 --> 00:03:29,000
に引き続き、これは、ASCIIテーブルです

57
00:03:29,000 --> 00:03:35,000
そして我々はASCIIを使用する何文字から数値にマッピングすることです。

58
00:03:35,000 --> 00:03:39,000
暗号のpsetで覚えている私たちは、ASCIIテーブルを多用しました

59
00:03:39,000 --> 00:03:43,000
暗号化のさまざまなメソッドを使用するためには、

60
00:03:43,000 --> 00:03:47,000
シーザーとVigenère暗号は、別の文字を変換する

61
00:03:47,000 --> 00:03:52,000
ユーザーによって指定されたキーに応じて文字列インチ

62
00:03:52,000 --> 00:03:56,000
のは、ASCII数学を少し見てみましょう。

63
00:03:56,000 --> 00:04:02,000
Qあろう文字の形で、 "P"に+ 1を見ると、

64
00:04:02,000 --> 00:04:07,000
と'5 '≠5を覚えています。

65
00:04:07,000 --> 00:04:10,000
そして、どのように正確に我々はそれらの2つの形式の間で変換するだろうか？

66
00:04:10,000 --> 00:04:13,000
これは、実際にはあまりにも難しいことではありません。

67
00:04:13,000 --> 00:04:16,000
5を得るために、我々は'0 'を引く'

68
00:04:16,000 --> 00:04:20,000
'0 'の間に5つの場所があるので、'と'5が。 '

69
00:04:20,000 --> 00:04:23,000
、我々は単に0を追加し、他の道を行くために

70
00:04:23,000 --> 00:04:25,000
定期的な算術のようなものだそれはそう。

71
00:04:25,000 --> 00:04:29,000
何かがそれを囲む引用符がある場合、それが文字だということだけを覚えている

72
00:04:29,000 --> 00:04:37,000
したがって、ASCIIコード表の値に対応する。

73
00:04:37,000 --> 00:04:40,000
より一般的なコンピュータ科学のトピックに移動します。

74
00:04:40,000 --> 00:04:43,000
我々は、我々が使用しているものプログラミングアルゴリズムがあり、どのように学んだ

75
00:04:43,000 --> 00:04:45,000
アルゴリズムを実装する。

76
00:04:45,000 --> 00:04:48,000
アルゴリズムのいくつかの例は、のような本当にシンプルな何かです

77
00:04:48,000 --> 00:04:51,000
数値が偶数か奇数かどうかをチェックする。

78
00:04:51,000 --> 00:04:54,000
そのために我々は数を2でMODと結果が0かどうかチェックを忘れないでください。

79
00:04:54,000 --> 00:04:57,000
もしそうなら、それもあります。そうでなければ、それは奇妙だ。

80
00:04:57,000 --> 00:04:59,000
そして、それは本当に基本的なアルゴリズムの例を示します。

81
00:04:59,000 --> 00:05:02,000
>> もっと関わっ1の少しは二分探索であり、

82
00:05:02,000 --> 00:05:05,000
その我々がレビューセッションの後半で上に行くよ。

83
00:05:05,000 --> 00:05:09,000
とプログラミングは、我々はアルゴリズムを取るために使用される用語です

84
00:05:09,000 --> 00:05:15,000
それはコンピュータをコードに変換することは読むことができます。

85
00:05:15,000 --> 00:05:20,000
プログラミングの2つの例は、スクラッチです

86
00:05:20,000 --> 00:05:22,000
これは、我々は0週目にやったことです。

87
00:05:22,000 --> 00:05:25,000
我々は実際にコードを入力していないにもかかわらず、それは実装の方法だ

88
00:05:25,000 --> 00:05:29,000
数字は1から10まで印刷されているこのアルゴリズムは、

89
00:05:29,000 --> 00:05:32,000
そしてここでは、Cプログラミング言語で同じことを行う。

90
00:05:32,000 --> 00:05:41,000
これらは、単に別の言語や構文で書かれた、機能的に同等です。

91
00:05:41,000 --> 00:05:44,000
次に、ブール値表現について学んだ

92
00:05:44,000 --> 00:05:48,000
とbooleanは、trueまたはfalseのいずれかの値です

93
00:05:48,000 --> 00:05:51,000
そしてここにしばしばブール式

94
00:05:51,000 --> 00:05:55,000
もしそうであれば（X≤5）、条件の中に入り、

95
00:05:55,000 --> 00:06:00,000
まあ、我々はすでにその条件がtrueに評価しようとしているx = 5で、ように設定してください。

96
00:06:00,000 --> 00:06:03,000
それが本当なら、どんなコードでは、条件の下にある

97
00:06:03,000 --> 00:06:08,000
コンピュータによって評価されようとしているので、その文字列が印刷されようとしている

98
00:06:08,000 --> 00:06:12,000
標準出力、および長期的条件に

99
00:06:12,000 --> 00:06:16,000
if文の括弧の中にある何を指します。

100
00:06:16,000 --> 00:06:20,000
すべての演算子を忘れないでください。

101
00:06:20,000 --> 00:06:26,000
、我々は2つ​​以上の条件を結合しようとしているとき|それを覚えている&&と|

102
00:06:26,000 --> 00:06:30,000
==しない= 2物事が等しいかどうかを確認する。

103
00:06:30,000 --> 00:06:36,000
==ブール演算子であるのに対し、=は代入のためのものであることを覚えておいてください。

104
00:06:36,000 --> 00:06:41,000
≤、≥、その後最後の2は自明です。

105
00:06:41,000 --> 00:06:45,000
ここでブール論理の全般的な見直し。

106
00:06:45,000 --> 00:06:48,000
とブール式は、ループ内でも重要である

107
00:06:48,000 --> 00:06:50,000
その私たちが今以上行くよ。

108
00:06:50,000 --> 00:06:56,000
私たちはしばらくのために、CS50でこれまでのループの約3種類を学び、やってます。

109
00:06:56,000 --> 00:06:59,000
ほとんどの用途にしながらそれを知っておくことが重要です

110
00:06:59,000 --> 00:07:02,000
私たちは実際に、一般的にループの任意の型を使用することができます

111
00:07:02,000 --> 00:07:06,000
目的の特定の種類、または共通のパターンがあります

112
00:07:06,000 --> 00:07:09,000
具体的には、これらのループの1つのために呼び出すプログラミングに

113
00:07:09,000 --> 00:07:13,000
それを作ることが最も効率的か、その方法でそれを記述するのがエレガント。

114
00:07:13,000 --> 00:07:18,000
のは、これらのループの各々が最も頻繁に使用される傾向にあるものを渡って行こう。

115
00:07:18,000 --> 00:07:21,000
>> forループでは、一般に、すでに我々は反復処理する方法を何度も知っている。

116
00:07:21,000 --> 00:07:24,000
それは我々が条件に入れたものだ。

117
00:07:24,000 --> 00:07:28,000
例えばのために、i = 0のときは、i <10、。

118
00:07:28,000 --> 00:07:31,000
我々はすでに我々が何かを10回やってみたいことを知っています。

119
00:07:31,000 --> 00:07:34,000
さて、whileループのために、一般的に我々は必ずしもない

120
00:07:34,000 --> 00:07:36,000
我々は、ループが実行する方法を何度も知っている。

121
00:07:36,000 --> 00:07:39,000
しかし、我々は、我々はそれがしたいという条件のいくつかの並べ替えを知っていますか

122
00:07:39,000 --> 00:07:41,000
常に真であるか、常にfalseになる。

123
00:07:41,000 --> 00:07:44,000
例えば、一方が設定されます。

124
00:07:44,000 --> 00:07:46,000
レッツは、ブール変数だと言う。

125
00:07:46,000 --> 00:07:48,000
それが本当なら、私たちは、コードを評価する一方で、

126
00:07:48,000 --> 00:07:52,000
もう少し拡張可能で、forループよりも一般的な少しは、そう

127
00:07:52,000 --> 00:07:55,000
しかし、forループはまた、任意のwhileループに変換することができます。

128
00:07:55,000 --> 00:08:00,000
最後に、すぐに理解することが最も難しいかもしれないループ、、やってます

129
00:08:00,000 --> 00:08:04,000
我々は最初のコードを評価したい場合によく使用されている

130
00:08:04,000 --> 00:08:06,000
初めての前に我々は状態を確認してください。

131
00:08:06,000 --> 00:08:09,000
DO WHILEループの一般的なユースケース

132
00:08:09,000 --> 00:08:12,000
あなたがユーザー入力を取得したいときのものであり、あなたがユーザーに聞きたい知っている

133
00:08:12,000 --> 00:08:15,000
入力のため、少なくとも一度は、しかし、彼らはあなたに良い入力を与えていない場合、直ちに

134
00:08:15,000 --> 00:08:18,000
あなたは彼らがあなたに良い入力を与えるまで、それらを求めておきたい。

135
00:08:18,000 --> 00:08:21,000
whileループの中で最も一般的な用途は、それを行うだ

136
00:08:21,000 --> 00:08:23,000
そして、これらのループの実際の構造を見てみましょう。

137
00:08:23,000 --> 00:08:27,000
彼らは通常、常にこれらのパターンに従う傾向がある。

138
00:08:27,000 --> 00:08:30,000
>> 内部用のループ上では、3つのコンポーネントがあります：

139
00:08:30,000 --> 00:08:35,000
初期化、一般的に何かのようにint型私iはカウンタ= 0、

140
00:08:35,000 --> 00:08:40,000
私たちはこの状態がまだ生きていている限り、このforループを実行して言いたい条件、

141
00:08:40,000 --> 00:08:44,000
我々はどのようにインクリメントされ、最終的に次にi <10、かつ、更新、のような

142
00:08:44,000 --> 00:08:47,000
ループ内の各点でのカウンター変数。

143
00:08:47,000 --> 00:08:50,000
そこを見るために、一般的なことは、ちょうど私が+ +は

144
00:08:50,000 --> 00:08:52,000
これは1で毎回iをインクリメントを意味します。

145
00:08:52,000 --> 00:08:55,000
また、私+ = 2のような何かができる

146
00:08:55,000 --> 00:08:58,000
これは、iには、ループを通過するたびに2を加えることを意味します。

147
00:08:58,000 --> 00:09:03,000
そして、これは実際には単なるループの一部として実行される任意のコードを意味しな​​い。

148
00:09:03,000 --> 00:09:09,000
とwhileループのために、この時間は、私たちは実際には、ループの外で初期化を持っている

149
00:09:09,000 --> 00:09:12,000
そう、たとえば、のは、我々は、私が今説明したようループの同じタイプをやろうとしているとしましょう​​。

150
00:09:12,000 --> 00:09:16,000
我々は、intはi = 0のループが始まる前に言うでしょう。

151
00:09:16,000 --> 00:09:20,000
私は<10これを実行しながら、我々は言うことができる、

152
00:09:20,000 --> 00:09:22,000
以前のようにコードのように同じブロック、

153
00:09:22,000 --> 00:09:26,000
そして今回はコードの更新部分を、例えば、i + +は、

154
00:09:26,000 --> 00:09:29,000
実際には、ループの内部に入る。

155
00:09:29,000 --> 00:09:33,000
そして最後に、のために、それはwhileループに似ていながらやる、

156
00:09:33,000 --> 00:09:36,000
しかし、我々はコードが一度評価されることを覚えておく必要があり

157
00:09:36,000 --> 00:09:40,000
条件がチェックされる前なので、それは多くの方が理にかなっています

158
00:09:40,000 --> 00:09:44,000
あなたは上から下への順に見れば。

159
00:09:44,000 --> 00:09:49,000
あなたも、while条件を見る前にループのコードが評価されながらやるで

160
00:09:49,000 --> 00:09:55,000
whileループのに対し、それは最初にチェックします。

161
00:09:55,000 --> 00:09:59,000
ステートメントと変数。

162
00:09:59,000 --> 00:10:04,000
我々は、新しい変数を作成したい場合は、まずそれを初期化したい。

163
00:10:04,000 --> 00:10:07,000
>> たとえば、intバーが可変バーを初期化し、

164
00:10:07,000 --> 00:10:10,000
それが今ではバーの値が何であるかので、値を与えていないのですか？

165
00:10:10,000 --> 00:10:12,000
我々は知らない。

166
00:10:12,000 --> 00:10:14,000
それは、以前にそこにメモリに格納されていたいくつかのゴミ値にすることができます

167
00:10:14,000 --> 00:10:16,000
そして我々は、その変数を使用する必要はありません

168
00:10:16,000 --> 00:10:19,000
我々は実際にそれに値を与えるまで、

169
00:10:19,000 --> 00:10:21,000
ので、我々はそれをここに宣言します。

170
00:10:21,000 --> 00:10:24,000
その後、我々はそれが42以下であることが、初期化します。

171
00:10:24,000 --> 00:10:28,000
さて、もちろん、我々は、これは1行目は、intバー= 42で行うことができます知っている。

172
00:10:28,000 --> 00:10:30,000
しかし、ちょうど、起こっている複数のステップをクリアする

173
00:10:30,000 --> 00:10:34,000
宣言と初期化は、ここでは別々に起こっています。

174
00:10:34,000 --> 00:10:38,000
これは、1つのステップで行われ、次の1、INT = bazにバー+ 1

175
00:10:38,000 --> 00:10:44,000
ので、このコードブロックの末尾に以下のこのステートメントは、その増分bazで、

176
00:10:44,000 --> 00:10:48,000
私たちはバズの値を出力した場合、それは44だろう

177
00:10:48,000 --> 00:10:52,000
我々は1>バーであることがそれを宣言して初期化しているため、

178
00:10:52,000 --> 00:10:58,000
それから私達はでもう一度それをインクリメント+ +。

179
00:10:58,000 --> 00:11:02,000
我々は、この非常に簡潔に渡ったが、それは一般的なを持って良いことだ

180
00:11:02,000 --> 00:11:04,000
何であるスレッドやイベントの理解。

181
00:11:04,000 --> 00:11:06,000
私たちは、主に、スクラッチでこれを使った

182
00:11:06,000 --> 00:11:09,000
そのため、複数のコードシーケンスとしてスレッドと考えることができます

183
00:11:09,000 --> 00:11:11,000
同時に実行されている。

184
00:11:11,000 --> 00:11:14,000
実際には、それはおそらく、同時に実行されていない

185
00:11:14,000 --> 00:11:17,000
しかし抽象的に一種の私たちはそのように考えることができます。

186
00:11:17,000 --> 00:11:20,000
>> スクラッチでは、例えば、我々は複数のスプライトを持っていた。

187
00:11:20,000 --> 00:11:22,000
それは同時に異なるコードを実行する可能性があります。

188
00:11:22,000 --> 00:11:26,000
他の何かを言っている間に一つは歩くことができた

189
00:11:26,000 --> 00:11:29,000
画面の別の部分インチ

190
00:11:29,000 --> 00:11:34,000
イベントには、ロジックを分離する別の方法です

191
00:11:34,000 --> 00:11:37,000
あなたのコードの異なる要素間、

192
00:11:37,000 --> 00:11:40,000
とスクラッチで我々は、ブロードキャストを使用してイベントをシミュレートすることができました

193
00:11:40,000 --> 00:11:43,000
私が受信すると、それは、私が聞こえない場合は、実際の

194
00:11:43,000 --> 00:11:47,000
が、本質的には、情報を送信する方法です

195
00:11:47,000 --> 00:11:49,000
1つのスプライトから別。

196
00:11:49,000 --> 00:11:52,000
たとえば、あなたがゲームを介して送信することもできます

197
00:11:52,000 --> 00:11:56,000
と別のスプライトはゲームオーバーを受信したときに、

198
00:11:56,000 --> 00:11:58,000
それは特定の方法で応答します。

199
00:11:58,000 --> 00:12:03,000
これは、プログラミングのために理解すべき重要なモデルだ。

200
00:12:03,000 --> 00:12:07,000
ただ基本的な週0上に行くために、私たちはこれまで以上に行ってきた、

201
00:12:07,000 --> 00:12:10,000
この簡単なCのプログラムを見てみましょう。

202
00:12:10,000 --> 00:12:14,000
テキストはここから少し小さいかもしれませんが、私はその上に本当に速い行くつもりです。

203
00:12:14,000 --> 00:12:20,000
我々は、上部の2ヘッダファイル、cs50.hとstdio.hをインクルードしている。

204
00:12:20,000 --> 00:12:23,000
次に100と呼ばれる定数上限を定義しています。

205
00:12:23,000 --> 00:12:26,000
次に私たちの主な機能を実装している。

206
00:12:26,000 --> 00:12:29,000
我々はここでコマンドライン引数を使用しないので、私たちはvoidを配置する必要があります

207
00:12:29,000 --> 00:12:32,000
メインの引数として。

208
00:12:32,000 --> 00:12:38,000
我々は、メイン上記のint型を参照してください。戻り値の型だね、それ故に下部に0を返します。

209
00:12:38,000 --> 00:12:41,000
そして、我々はint得るCS50ライブラリ関数を使用している

210
00:12:41,000 --> 00:12:45,000
ユーザに入力を求め、私たちはこの変数xに格納するには、

211
00:12:45,000 --> 00:12:51,000
ので、我々は上記のxを宣言し、そして我々は、x =場合、getIntを使用して初期化します。

212
00:12:51,000 --> 00:12:53,000
>> 我々は、ユーザーが私達によい入力を与えたかどうかを確認します。

213
00:12:53,000 --> 00:12:59,000
それは≥LIMITの場合、私たちは、1のエラーコードを返すとエラー·メッセージを出力したい。

214
00:12:59,000 --> 00:13:02,000
そして最後に、ユーザーが私達に与えられている場合、良好な入力

215
00:13:02,000 --> 00:13:08,000
我々は数を二乗し、その結果をプリントアウトするつもりだ。

216
00:13:08,000 --> 00:13:11,000
ちょうどそれらのすべてのヒットホームていることを確認する

217
00:13:11,000 --> 00:13:17,000
あなたはここでコードの異なる部分のラベルを見ることができます。

218
00:13:17,000 --> 00:13:19,000
私は定数、ヘッダファイルに言及した。

219
00:13:19,000 --> 00:13:21,000
ああ、int型xになります。ローカル変数であることを覚えていることを確認してください。

220
00:13:21,000 --> 00:13:24,000
我々はについて話しますグローバル変数、からそれを対比し、その

221
00:13:24,000 --> 00:13:27,000
少し後でレビューセッションで、

222
00:13:27,000 --> 00:13:30,000
そして我々は、printfライブラリ関数を呼び出している

223
00:13:30,000 --> 00:13:34,000
我々はstdio.hヘッダファイルが含まれていなかったので、もし

224
00:13:34,000 --> 00:13:37,000
我々は、printf呼び出しすることができないだろう。

225
00:13:37,000 --> 00:13:42,000
そして、私は、ここでオフ斬っ矢印は％dを指していると信じて

226
00:13:42,000 --> 00:13:45,000
これは、printf関数の書式文字列です。

227
00:13:45,000 --> 00:13:52,000
それが数％dは、この変数をプリントアウトと言います。

228
00:13:52,000 --> 00:13:58,000
そして、それは0週のためのそれである。

229
00:13:58,000 --> 00:14:06,000
今すぐルーカスは継続する予定です。

230
00:14:06,000 --> 00:14:08,000
ねえ、みんな。私の名前はルーカスです。

231
00:14:08,000 --> 00:14:10,000
私は、キャンパス、マザー上で最高の家の中で二年生だ

232
00:14:10,000 --> 00:14:14,000
そして私は1週目と2.1について少しお話します。

233
00:14:14,000 --> 00:14:16,000
[第1週と2.1！] [ルーカス·フレイタス]

234
00:14:16,000 --> 00:14:19,000
我々はゼロからのC言語にあなたのコードを翻訳し始めたときにレクシーは、言っていたように、

235
00:14:19,000 --> 00:14:23,000
私たちが気づいたことの一つは、あなただけではなくできることです

236
00:14:23,000 --> 00:14:26,000
あなたのコードを書いて、それはもう緑のフラグを使用して実行します。

237
00:14:26,000 --> 00:14:30,000
実際に、あなたのCプログラムを作るためにいくつかの手順を使用する必要が

238
00:14:30,000 --> 00:14:33,000
実行ファイルになります。

239
00:14:33,000 --> 00:14:36,000
基本的には、プログラムを書いているときには何をすべきかというです

240
00:14:36,000 --> 00:14:40,000
あなたは、コンパイラが理解できる言語にあなたのアイデアを翻訳

241
00:14:40,000 --> 00:14:44,000
ので、あなたがC言語でプログラムを書いているときに

242
00:14:44,000 --> 00:14:47,000
あなたが実際にあなたのコンパイラが理解しようとしていることを何かを書いているものをやっている、

243
00:14:47,000 --> 00:14:50,000
その後、コンパイラはそのコードを変換しようとしている

244
00:14:50,000 --> 00:14:53,000
お使いのコンピュータが理解できるものに。

245
00:14:53,000 --> 00:14:55,000
>> との事は、お使いのコンピュータは、実際には非常に間抜けである。

246
00:14:55,000 --> 00:14:57,000
お使いのコンピュータでのみ、0と1を理解することができます

247
00:14:57,000 --> 00:15:01,000
ので、実際には最初のコンピュータで人々は通常、プログラムさ

248
00:15:01,000 --> 00:15:04,000
もう0と1ではなく、使用して、神に感謝します。

249
00:15:04,000 --> 00:15:07,000
我々は、0と1の配列を覚える必要はありません

250
00:15:07,000 --> 00:15:10,000
forループまたはwhileループのためののように。

251
00:15:10,000 --> 00:15:13,000
我々はコンパイラを持っている理由です。

252
00:15:13,000 --> 00:15:17,000
どのコンパイラが行うことは、それは基本的にCのコードを変換している

253
00:15:17,000 --> 00:15:21,000
私たちのケースでは、コンピュータが理解できる言語に、

254
00:15:21,000 --> 00:15:25,000
どのオブジェクトコードであり、我々が使用しているコンパイラ

255
00:15:25,000 --> 00:15:30,000
打ち鳴らすと呼ばれていますので、これは実際に打ち鳴らすためのシンボルです。

256
00:15:30,000 --> 00:15:33,000
あなたのプログラムを持っているときは、2つのことを行う必要があります。

257
00:15:33,000 --> 00:15:37,000
まず、あなたのプログラムをコンパイルする必要がありますし、あなたのプログラムを実行するつもりだ。

258
00:15:37,000 --> 00:15:41,000
あなたのプログラムをコンパイルするには、そのための多くのオプションを持っている。

259
00:15:41,000 --> 00:15:44,000
一つ目はカーンという音は、program.cを行うことです

260
00:15:44,000 --> 00:15:47,000
れているプログラムは、プログラムの名前です。

261
00:15:47,000 --> 00:15:51,000
このケースでは、彼らはちょうど言っている見ることができる "ねえ、私のプログラムをコンパイルします。"

262
00:15:51,000 --> 00:15:56,000
あなたは、または何も "私は私のプログラムのためにこの名前にしたい"と言っていない。

263
00:15:56,000 --> 00:15:58,000
>> 二つ目のオプションは、あなたのプログラムに名前を与えている。

264
00:15:58,000 --> 00:16:02,000
その後、打ち鳴らす-oとすることも、任意の名前と言うことができます

265
00:16:02,000 --> 00:16:06,000
実行ファイルは、ファイルとして、次にprogram.cを名付けられる。

266
00:16:06,000 --> 00:16:11,000
そして、あなたはまた、プログラムを作るのですか、そしてどのように最初の2つのケースでは見ることができます

267
00:16:11,000 --> 00:16:15,000
私はCを入れて、3分の1に私はプログラムを持っている？

268
00:16:15,000 --> 00:16:18,000
ああ、あなたは実際に置くべきではありません。cをあなたが作るを使用するとき。

269
00:16:18,000 --> 00:16:22,000
そうしないと、コンパイラは、実際にあなたに向かって怒鳴り起こっている。

270
00:16:22,000 --> 00:16:24,000
君たちは覚えていれば、また、私は知らないが、

271
00:16:24,000 --> 00:16:29,000
しかし、多くの時間は、我々はまた、または-LM-lcs50を使用していました。

272
00:16:29,000 --> 00:16:31,000
それはリンクと呼ばれています。

273
00:16:31,000 --> 00:16:35,000
それはちょうど、あなたがすぐそこにこれらのライブラリを使用することをコンパイラに指示します

274
00:16:35,000 --> 00:16:39,000
あなたはcs50.hを使用したいので、もしあなたが実際に入力する必要が

275
00:16:39,000 --> 00:16:43,000
カーンという音は、program.c-lcs50。

276
00:16:43,000 --> 00:16:45,000
あなたがそうしない場合、コンパイラは知っているつもりされていません

277
00:16:45,000 --> 00:16:50,000
あなたはcs50.h.でこれらの関数を使用していること

278
00:16:50,000 --> 00:16:52,000
そして、あなたはあなたのプログラムを実行するときに2つのオプションがあります。

279
00:16:52,000 --> 00:16:57,000
あなたはカーンという音は、program.cを行った場合、あなたのプログラムに名前を与えていない。

280
00:16:57,000 --> 00:17:01,000
は。/ a.outを使用して、それを実行する必要があります。

281
00:17:01,000 --> 00:17:06,000
a.outはあなたがそれに名前を付けない場合はカーンという音があなたのプログラムを提供し、標準の名前です。

282
00:17:06,000 --> 00:17:11,000
あなたのプログラムに名前を与えたそれ以外の場合は。/プログラムをやろうとしている、

283
00:17:11,000 --> 00:17:15,000
あなたがやった場合と、プログラムが取得しようとしていることをプログラム名を成す

284
00:17:15,000 --> 00:17:23,000
すでにcファイルと同じ名前をプログラムすることになるだろう。

285
00:17:23,000 --> 00:17:26,000
その後、我々は、データ型とデータについて話しました。

286
00:17:26,000 --> 00:17:31,000
>> 基本的にはデータ·タイプは、彼らが使用する小さな箱と同じものです

287
00:17:31,000 --> 00:17:35,000
値を格納するため、データ·タイプがちょうどPokémonsのように実際にされています。

288
00:17:35,000 --> 00:17:39,000
彼らはすべてのサイズと種類があります。

289
00:17:39,000 --> 00:17:43,000
そのアナロジーは理にかなっているかどうかは分からない。

290
00:17:43,000 --> 00:17:46,000
データサイズは、実際にはマシンのアーキテクチャに依存します。

291
00:17:46,000 --> 00:17:49,000
私がここで紹介するつもりですすべてのデータサイズ

292
00:17:49,000 --> 00:17:53,000
私たちのアプライアンスの場合は32ビットマシン用に実際に

293
00:17:53,000 --> 00:17:56,000
だけでなく、あなたが実際にあなたのMacをコーディングしている場合、またはWindowsで

294
00:17:56,000 --> 00:17:59,000
おそらくあなたは、64ビットのマシンを持っているつもりです

295
00:17:59,000 --> 00:18:03,000
ので、私はここに紹介するつもりですデータサイズということを覚えておいてください

296
00:18:03,000 --> 00:18:06,000
32ビットマシン用です。

297
00:18:06,000 --> 00:18:08,000
我々が見たことが最初のものは、int型であった

298
00:18:08,000 --> 00:18:10,000
これはかなり簡単です。

299
00:18:10,000 --> 00:18:13,000
あなたは、整数を格納するintを使う。

300
00:18:13,000 --> 00:18:16,000
また、文字は、charを見ました。

301
00:18:16,000 --> 00:18:20,000
あなたは手紙や少し記号を使用する場合は、おそらくcharを使用するつもりです。

302
00:18:20,000 --> 00:18:26,000
charは、レキシーが言ったように8ビットを意味し、1バイトを持っています。

303
00:18:26,000 --> 00:18:31,000
基本的に我々は256を持っているASCIIテーブルを持っている

304
00:18:31,000 --> 00:18:34,000
0と1の組み合わせ、

305
00:18:34,000 --> 00:18:37,000
そしてその後は、charを入力したときにそれが翻訳するだろう

306
00:18:37,000 --> 00:18:44,000
文字が入力していますあなたレキシーのように、ASCIIテーブルに持っている数は言った。

307
00:18:44,000 --> 00:18:48,000
また、私たちは小数を格納するために使用するフロートを持っています。

308
00:18:48,000 --> 00:18:53,000
あなたは、例えば、3.14を選択したい場合は、floatを使用するつもりだ

309
00:18:53,000 --> 00:18:55,000
以上の精度を持っている二重。

310
00:18:55,000 --> 00:18:57,000
floatは4バイトを持っています。

311
00:18:57,000 --> 00:19:01,000
doubleは8バイトを持っているので、唯一の違いは精度です。

312
00:19:01,000 --> 00:19:04,000
また、整数に対して使用され、長いを持っている

313
00:19:04,000 --> 00:19:09,000
、あなたは、32ビットマシンintと同じサイズでなければ長い間見ることができます

314
00:19:09,000 --> 00:19:13,000
ので、実際に32ビットマシンでlongを使用する意味がありません。

315
00:19:13,000 --> 00:19:17,000
>> Macと64ビットのマシンを使用している場合でも、実際に長い、サイズ8を持っている

316
00:19:17,000 --> 00:19:19,000
ので、実際にアーキテクチャに依存します。

317
00:19:19,000 --> 00:19:22,000
32ビットマシンの場合、それは本当に長いを使用しても意味がありません。

318
00:19:22,000 --> 00:19:25,000
そして、長い長い間、その一方で、8バイトを持っている

319
00:19:25,000 --> 00:19:30,000
あなたが長い整数を持つようにしたい場合ので、非常に良いです。

320
00:19:30,000 --> 00:19:34,000
そして最後に、我々は、実際にはchar *である、文字列を持っている

321
00:19:34,000 --> 00:19:37,000
これはcharへのポインタです。

322
00:19:37,000 --> 00:19:40,000
これは、文字列のサイズがどのようになるだろうことを考えると非常に簡単です

323
00:19:40,000 --> 00:19:42,000
あなたがそこに持っている文字の数、

324
00:19:42,000 --> 00:19:45,000
しかし実際にはchar *自体

325
00:19:45,000 --> 00:19:49,000
4バイトであるchar型へのポインタのサイズを持っています。

326
00:19:49,000 --> 00:19:52,000
char *のサイズは4バイトです。

327
00:19:52,000 --> 00:19:56,000
あなたは小さな単語または文字か何かを持っているかどうかは関係ありません。

328
00:19:56,000 --> 00:19:58,000
これは、4バイトになるだろう。

329
00:19:58,000 --> 00:20:01,000
我々はまた、キャスティングについて少し学んだ

330
00:20:01,000 --> 00:20:04,000
あなたが持っている場合は、例えば、言うプログラムを見ることができるように

331
00:20:04,000 --> 00:20:08,000
int型のx = 3のその後のprintf（ "％d"は、X / 2）

332
00:20:08,000 --> 00:20:12,000
あなたたちは、それが画面上に印刷するために何が起こっているか知っていますか？

333
00:20:12,000 --> 00:20:14,000
>> 誰か？>> [生徒] 2。

334
00:20:14,000 --> 00:20:16,000
1 >> 1、うん。

335
00:20:16,000 --> 00:20:20,000
あなたは3月2日を行うと、それは、1.5を得るために起こっている

336
00:20:20,000 --> 00:20:24,000
我々は整数を使用しているので、それは、小数部を無視するようになるだろう

337
00:20:24,000 --> 00:20:26,000
、あなたは1点を持っているつもりです。

338
00:20:26,000 --> 00:20:29,000
例えば、あなたが何ができるか起こることを望まないのであれば

339
00:20:29,000 --> 00:20:33,000
floatを宣言されてy = xと。

340
00:20:33,000 --> 00:20:40,000
3次になるために使用さxはyに3.000であることを行っている。

341
00:20:40,000 --> 00:20:44,000
そしてあなたは、y / 2を印刷することができます。

342
00:20:44,000 --> 00:20:50,000
実は、私は2を持っている必要があります。あそこ。

343
00:20:50,000 --> 00:20:55,000
それは、3.00/2.00をやろうとしている

344
00:20:55,000 --> 00:20:58,000
そしてあなたは、1.5を取得するつもりだ。

345
00:20:58,000 --> 00:21:06,000
そして、我々だけ小数部の2進数の単位を求めるために、この0.2 fを持っている。

346
00:21:06,000 --> 00:21:12,000
あなたが0.3 fを持っている場合、それは実際に1.500を持つようになるだろう。

347
00:21:12,000 --> 00:21:16,000
それが2であればそれは1.50になるだろう。

348
00:21:16,000 --> 00:21:18,000
また、ここで、このケースを持っています。

349
00:21:18,000 --> 00:21:22,000
あなたは、floatを行う場合、x = 3.14とその後のprintf X

350
00:21:22,000 --> 00:21:24,000
あなたは3.14を取得するつもりだ。

351
00:21:24,000 --> 00:21:29,000
そして、あなたが行う場合、xのx = int型、

352
00:21:29,000 --> 00:21:34,000
intとしてxを扱うことを意味し、あなたが今、xを印刷先

353
00:21:34,000 --> 00:21:36,000
あなたは3.00を持っているつもりです。

354
00:21:36,000 --> 00:21:38,000
それは意味をなさないか？

355
00:21:38,000 --> 00:21:41,000
あなたは、最初の整数としてxを扱っているので、小数部を無視しているので、

356
00:21:41,000 --> 00:21:45,000
してから、xを印刷している。

357
00:21:45,000 --> 00:21:47,000
そして最後に、あなたはまた、これを行うことができます

358
00:21:47,000 --> 00:21:52,000
int型の場合、x = 65、あなたはchar cを= xを宣言する

359
00:21:52,000 --> 00:21:56,000
その後は、cを印刷する場合は、実際に取得するつもりだ

360
00:21:56,000 --> 00:21:59,000
ので、基本的にここで何をやっている、

361
00:21:59,000 --> 00:22:02,000
、文字に整数を翻訳している

362
00:22:02,000 --> 00:22:05,000
同じようにASCIIテーブルはありません。

363
00:22:05,000 --> 00:22:08,000
また、算術演算子について話しました。

364
00:22:08,000 --> 00:22:14,000
それらのほとんどは非常に簡単ですので、+、 - 、*、/、

365
00:22:14,000 --> 00:22:20,000
また、我々は、2つの数値の除算の余りであるMOD、について話しました。

366
00:22:20,000 --> 00:22:23,000
例えば、あなたが10％3をお持ちの場合

367
00:22:23,000 --> 00:22:27,000
それが3で10を割ることを意味し、残りの部分は何ですか？

368
00:22:27,000 --> 00:22:30,000
それは1になるだろうので、それは多くのプログラムのために実際には非常に便利です。

369
00:22:30,000 --> 00:22:38,000
Vigenèreとシーザーのために私はあなたたちのすべては、modを使用したことをかなり確信している。

370
00:22:38,000 --> 00:22:43,000
*と/を組み合わせたときの数学の演算子については、十分に注意すること。

371
00:22:43,000 --> 00:22:48,000
>> たとえば場合は、（3/2）* 2あなたは何を得ようとしているのですか？

372
00:22:48,000 --> 00:22:50,000
[生徒] 2。

373
00:22:50,000 --> 00:22:54,000
うん、2、3/2は1.5であることを行っているので、

374
00:22:54,000 --> 00:22:57,000
しかし、あなたは2つの整数の間の操作をやっているので、

375
00:22:57,000 --> 00:22:59,000
あなたは実際にちょうど1を検討するつもりだ、

376
00:22:59,000 --> 00:23:03,000
その後1 * 2は2であることを行っているので、非常に、非常に注意してください

377
00:23:03,000 --> 00:23:07,000
ので、整数で演算を行う場合、

378
00:23:07,000 --> 00:23:12,000
あなたは、その場合には、その2 = 3を得る可能性があります。

379
00:23:12,000 --> 00:23:14,000
また、優先順位について非常に注意してください。

380
00:23:14,000 --> 00:23:21,000
あなたは通常、あなたが何をやっているか知っていることを確認するために括弧を使用する必要があります。

381
00:23:21,000 --> 00:23:27,000
いくつかの便利なショートカットは、当然のことながら、1は、i + +やi + = 1である

382
00:23:27,000 --> 00:23:30,000
または使用して+ =。

383
00:23:30,000 --> 00:23:34,000
つまり、I = I + 1をやってと同じものです。

384
00:23:34,000 --> 00:23:39,000
また、私が行うことができます - またはi  -  = 1、

385
00:23:39,000 --> 00:23:42,000
これは、私は= I -1と同じものです

386
00:23:42,000 --> 00:23:46,000
何かあなたたちは、少なくとも、forループで多くを使用します。

387
00:23:46,000 --> 00:23:52,000
また、*のために、あなたが使用している場合* =と、例えば、あなたが行う場合

388
00:23:52,000 --> 00:23:57,000
I * = 2 I = I * 2を言うのと同じことですが、

389
00:23:57,000 --> 00:23:59,000
除算のと同じこと。

390
00:23:59,000 --> 00:24:08,000
あなたは、i / = 2を行う場合、それはI = I / 2と同じことだ。

391
00:24:08,000 --> 00:24:10,000
>> 今関数について。

392
00:24:10,000 --> 00:24:13,000
君たちは関数は、コードを保存するために非常に良い戦略であることを学ん

393
00:24:13,000 --> 00:24:16,000
あなたがプログラミングしている間なので、同じタスクを実行したい場合

394
00:24:16,000 --> 00:24:20,000
コー​​ドの中で何度も何度も、おそらくあなたは、関数を使いたい

395
00:24:20,000 --> 00:24:25,000
ちょうどので、何度も繰り返しのコードをコピー＆ペーストする必要はありません。

396
00:24:25,000 --> 00:24:28,000
実際、メインは関数である、と私はあなたに関数の形式を表示するとき

397
00:24:28,000 --> 00:24:32,000
あなたはそれが非常に明白であることを確認するつもりだ。

398
00:24:32,000 --> 00:24:35,000
我々はまた、いくつかのライブラリの関数を使用

399
00:24:35,000 --> 00:24:39,000
例えば、printfは、CS50ライブラリからですGetIn、

400
00:24:39,000 --> 00:24:43,000
やtoupperなどの他の機能。

401
00:24:43,000 --> 00:24:46,000
これらの機能のすべては、実際には、他のライブラリに実装されています

402
00:24:46,000 --> 00:24:49,000
そして、あなたのプログラムの初めにそれらテザーファイルを置くとき

403
00:24:49,000 --> 00:24:53,000
あなたは私にそれらの関数のコードを記入してくださいすることができますと言っている

404
00:24:53,000 --> 00:24:57,000
ので、私は自分でそれを実装する必要はありませんか？

405
00:24:57,000 --> 00:25:00,000
そして、あなたはまた、あなたがプログラミングを開始するときに、独自の関数を作成することができます

406
00:25:00,000 --> 00:25:04,000
あなたは図書館があなたが必要とするすべての機能を持っていないことを認識しています。

407
00:25:04,000 --> 00:25:10,000
最後のpsetには、例えば、我々は、スクランブルを描画して、ルックアップ書いた

408
00:25:10,000 --> 00:25:13,000
そして、それは関数を記述することができるように、非常に、非常に重要です

409
00:25:13,000 --> 00:25:17,000
彼らは有用であり、我々はプログラミングのすべての時間にそれらを使用しているため、

410
00:25:17,000 --> 00:25:19,000
そしてそれは、多くのコードを保存します。

411
00:25:19,000 --> 00:25:21,000
関数の形式はこの一つです。

412
00:25:21,000 --> 00:25:24,000
我々は最初に戻り値の型を持っています。戻り値の型は何ですか？

413
00:25:24,000 --> 00:25:27,000
それはあなたの関数が返すために起こっているときだけだ。

414
00:25:27,000 --> 00:25:29,000
、階乗、例えば、あなたが機能を持っている場合

415
00:25:29,000 --> 00:25:31,000
つまり、整数の階乗を計算するために起こっている

416
00:25:31,000 --> 00:25:34,000
おそらく、それはまた、整数を返すために起こっている。

417
00:25:34,000 --> 00:25:37,000
戻り値の型はintになるだろう。

418
00:25:37,000 --> 00:25:41,000
printfの実際の戻り値の型voidを

419
00:25:41,000 --> 00:25:43,000
あなたは何を返していないので。

420
00:25:43,000 --> 00:25:45,000
あなただけの画面に物事を印刷している

421
00:25:45,000 --> 00:25:48,000
その後、関数を終了する。

422
00:25:48,000 --> 00:25:51,000
そして、あなたは、あなたが選ぶことができる関数の名前を持っている。

423
00:25:51,000 --> 00:25:55,000
あなたは、xyzのような名前を選択しないように、少し理性的であるべきだ

424
00:25:55,000 --> 00:25:58,000
またはX2Fような。

425
00:25:58,000 --> 00:26:02,000
理にかなって名前を作ることを試みて下さい。

426
00:26:02,000 --> 00:26:04,000
>> 例えば、それは階乗の場合、階乗と言う。

427
00:26:04,000 --> 00:26:08,000
それは何かを描画しようとしている関数とすれば、それを描くという名前を付けます。

428
00:26:08,000 --> 00:26:11,000
そして、我々はまた、引数と呼ばれるパラメータを、持っている

429
00:26:11,000 --> 00:26:14,000
あなたの関数が必要とするリソースと同様にどのアール

430
00:26:14,000 --> 00:26:17,000
独自に作成したコードから、そのタスクを実行することができます。

431
00:26:17,000 --> 00:26:20,000
あなたは、数値の階乗を計算したい場合

432
00:26:20,000 --> 00:26:23,000
おそらくあなたは、階乗を計算するための数値を持っている必要があります。

433
00:26:23,000 --> 00:26:27,000
あなたが持って行っていることのいずれかの引数が数値そのものです。

434
00:26:27,000 --> 00:26:31,000
そしてそれは何かをすると終了時に値を返すことになるだろう

435
00:26:31,000 --> 00:26:35,000
それはvoid関数でない限り。

436
00:26:35,000 --> 00:26:37,000
例を見てみましょう。

437
00:26:37,000 --> 00:26:40,000
私は整数の配列内のすべての数値を合計する関数を記述したい場合は、

438
00:26:40,000 --> 00:26:43,000
まず第一に、戻り値の型はintであることを行っている

439
00:26:43,000 --> 00:26:46,000
私は、整数の配列を持っているからです。

440
00:26:46,000 --> 00:26:51,000
そして私は、sumArrayのような関数の名前を持っているつもりです

441
00:26:51,000 --> 00:26:54,000
そして、次に、それは、int型numsに、配列自体を取るつもりです

442
00:26:54,000 --> 00:26:58,000
その後、私は合計する必要がありますどのように多くの数字知っているので、配列の長さ。

443
00:26:58,000 --> 00:27:02,000
それから私は0に、例えば、和と呼ばれる変数を初期化する必要があり、

444
00:27:02,000 --> 00:27:08,000
と私は、配列内の要素を参照するたびに、私は合計に追加する必要がありますので、私はループのためにした。

445
00:27:08,000 --> 00:27:15,000
レキシーが言ったように、あなたがやるのint i = 0のときは、i <長さとi + +。

446
00:27:15,000 --> 00:27:20,000
と配列のすべての要素のために、私は合計+ = nums [i]のをやった、

447
00:27:20,000 --> 00:27:24,000
その後、私は和を返したので、非常にシンプルだし、それは多くのコードを保存します

448
00:27:24,000 --> 00:27:28,000
あなたは、この関数を多くの時間を使っている場合。

449
00:27:28,000 --> 00:27:32,000
その後、我々は条件を見ていた。

450
00:27:32,000 --> 00:27:38,000
我々は、if、else、および他の場合があります。

451
00:27:38,000 --> 00:27:42,000
それらの間の差であるのか見てみましょう。

452
00:27:42,000 --> 00:27:45,000
これらの2つのコードを見てみましょう。それらの違いは何ですか？

453
00:27:45,000 --> 00:27:49,000
最初のものは、基本的にしているコードは、お伝えしたいと思います

454
00:27:49,000 --> 00:27:51,000
、または0  - 数は+である場合。

455
00:27:51,000 --> 00:27:55,000
最初のものは、それが> 0の場合、それはポジティブだと言う。

456
00:27:55,000 --> 00:28:00,000
それは0〜=の場合、それは0だし、それが<0の場合、それは否定的なのです。

457
00:28:00,000 --> 00:28:04,000
>> そうでなければ、もしそうでなければ、あれば、もう一つはやっている。

458
00:28:04,000 --> 00:28:07,000
両者の違いは、この1つは実際に起こっているということです

459
00:28:07,000 --> 00:28:13,000
チェックした場合> 0、<0または= 0三回、

460
00:28:13,000 --> 00:28:17,000
あなたは数字の2を持っているそうだとすれば、例えば、それはここに来ると言うことになるだろう

461
00:28:17,000 --> 00:28:21,000
（X> 0）場合、それはイエスと言うために起こっているので、私は肯定的な印刷されます。

462
00:28:21,000 --> 00:28:25,000
しかし、私はそれが> 0であることを知って、それが0または<0であることを行っていないにもかかわらず、

463
00:28:25,000 --> 00:28:29,000
私はまだ何をするつもりだ、それが0である、それは、<0である

464
00:28:29,000 --> 00:28:33,000
ので、私は実際に私がする必要がなかったことをIFSの内側に行くよ

465
00:28:33,000 --> 00:28:38,000
私はすでにそれがこれらのいずれかの条件を満たすことはないだろうことを知っているので。

466
00:28:38,000 --> 00:28:41,000
私は他に、他の場合は、if文を使用することができます。

467
00:28:41,000 --> 00:28:45,000
x = 0の私は肯定を印刷する場合、それは基本的に述べています。

468
00:28:45,000 --> 00:28:48,000
それがない場合は、私もこれをテストするつもりです。

469
00:28:48,000 --> 00:28:51,000
それが2なら、私はこれを行うつもりはない。

470
00:28:51,000 --> 00:28:54,000
私はx = 2を持っていた場合、基本的にあなたは言うでしょう

471
00:28:54,000 --> 00:28:57,000
（x> 0の）場合は、[はい]を、ので、これを印刷してください。

472
00:28:57,000 --> 00:29:00,000
今、私はそれは> 0であることを知っていることと、その場合には、まず満足

473
00:29:00,000 --> 00:29:02,000
私もこのコードを実行するつもりはない。

474
00:29:02,000 --> 00:29:09,000
あなたがこれを使用する場合のコードは3倍の速さ、実際には、高速に実行されます。

475
00:29:09,000 --> 00:29:11,000
また知り、かつまたは。

476
00:29:11,000 --> 00:29:15,000
レキシーは既にそれらについて話しましたので、私はこれを通過するつもりはない。

477
00:29:15,000 --> 00:29:17,000
| |演算子それだけで&&とです。

478
00:29:17,000 --> 00:29:21,000
>> 私は言うだろう唯一のことは、3つの条件を持っている場合は注意があります。

479
00:29:21,000 --> 00:29:24,000
それは非常に混乱するだから、条件を持っているときに括弧を使用します

480
00:29:24,000 --> 00:29:27,000
そして別の1つまたは別の1。

481
00:29:27,000 --> 00:29:30,000
ちょうどあなたの条件は意味をなさないことを確認するために、括弧を使用します

482
00:29:30,000 --> 00:29:34,000
その場合には、例えば、あなたが想像できるので、その

483
00:29:34,000 --> 00:29:38,000
それは、最初の条件と1つまたは他のかもしれない

484
00:29:38,000 --> 00:29:41,000
または2に結合された条件と

485
00:29:41,000 --> 00:29:45,000
または3分の1は、これだけは注意してください。

486
00:29:45,000 --> 00:29:48,000
そして最後に、我々はスイッチについて話しました。

487
00:29:48,000 --> 00:29:53,000
変数を持っている場合、スイッチは非常に便利です。

488
00:29:53,000 --> 00:29:55,000
Let 'sは、あなたがnのような変数を持っていることを言う

489
00:29:55,000 --> 00:29:59,000
それは、0,1、または2であり、それらの例ごとにすることができます

490
00:29:59,000 --> 00:30:01,000
してタスクを実行するつもりだ。

491
00:30:01,000 --> 00:30:04,000
あなたは、変数を切り替えると言うことができます、そして、それはことを示しています

492
00:30:04,000 --> 00:30:08,000
次に、この値が、value1のように私はこれを実行するつもりである

493
00:30:08,000 --> 00:30:12,000
そして私は私が他のいずれかの場合を見てするつもりはないことを意味し、破る

494
00:30:12,000 --> 00:30:15,000
我々はすでにそのような場合を満たしているため

495
00:30:15,000 --> 00:30:20,000
その後value2とのように、私もデフォルトのスイッチを持つことができます。

496
00:30:20,000 --> 00:30:24,000
それは私が持っていた場合のいずれかを満たさない場合を意味します

497
00:30:24,000 --> 00:30:29,000
私は何か他のものをするつもりですが、これは必須だということ。

498
00:30:29,000 --> 00:30:36,000
それは私のためにすべてです。今度はトミーを持ってみましょう。

499
00:30:36,000 --> 00:30:41,000
すべての権利は​​、これは3週目っぽいことになるだろう。

500
00:30:41,000 --> 00:30:45,000
これらは私たちがカバーすることでしょうトピックのいくつか、暗号化、スコープ、配列、エトセトラです。

501
00:30:45,000 --> 00:30:49,000
クリプト上だけで簡単に単語。我々は、この家を酷使するつもりはない。

502
00:30:49,000 --> 00:30:52,000
>> 我々は、pset 2でこれを行っていましたがクイズのために、違いを知っていることを確認

503
00:30:52,000 --> 00:30:54,000
シーザー暗号とVigenère暗号の間に、

504
00:30:54,000 --> 00:30:57,000
どのようにこれらの暗号の仕事をどのように処理し、暗号化するようなものだ両方

505
00:30:57,000 --> 00:30:59,000
それらの2つの暗号化方式を使用して復号化テキスト。

506
00:30:59,000 --> 00:31:03,000
覚えておいて、シーザー暗号は単に、同じ量で各文字を回転させる

507
00:31:03,000 --> 00:31:06,000
アルファベットの文字の数でいいMODを作る。

508
00:31:06,000 --> 00:31:09,000
とVigenère暗号は、一方では、各文字を回転させる

509
00:31:09,000 --> 00:31:12,000
異なる量だけ、そうではなく、言って

510
00:31:12,000 --> 00:31:15,000
3Vigenèreですべての文字を回転させ、各文字を回転させます

511
00:31:15,000 --> 00:31:17,000
いくつかのキーワードに応じて、異なる量だけ

512
00:31:17,000 --> 00:31:20,000
キーワードの各文字は、いくつかの異なった量を表し

513
00:31:20,000 --> 00:31:26,000
によってクリアテキストを回転させる。

514
00:31:26,000 --> 00:31:28,000
変数のスコープについての最初の話してみましょう。

515
00:31:28,000 --> 00:31:30,000
変数の2つの異なるタイプがあります。

516
00:31:30,000 --> 00:31:33,000
我々は、ローカル変数を持っており、これらは、定義しようとしている

517
00:31:33,000 --> 00:31:36,000
メインまたは任意の関数やブロックの外側の外、

518
00:31:36,000 --> 00:31:39,000
これらはあなたのプログラムのどこにアクセスできるようになります。

519
00:31:39,000 --> 00:31:41,000
あなたは、関数を持っていて、その関数内でwhileループである場合

520
00:31:41,000 --> 00:31:44,000
大きなグローバル変数はどこでもアクセス可能です。

521
00:31:44,000 --> 00:31:48,000
ローカル変数は、他の一方で、それが定義されている場所にスコープが設定されます。

522
00:31:48,000 --> 00:31:53,000
>> あなたがここに関数がある場合、例えば、我々は、この関数gを持っている

523
00:31:53,000 --> 00:31:56,000
とgの内部にyと呼ばれるここで変数が存在する

524
00:31:56,000 --> 00:31:58,000
そしてそれは、これはローカル変数であることを意味します。

525
00:31:58,000 --> 00:32:00,000
この変数は、yと呼ばれるけれども、

526
00:32:00,000 --> 00:32:03,000
そしてこの変数は、これら2つの関数をYと呼ばれる

527
00:32:03,000 --> 00:32:06,000
お互いのローカル変数が何であるか見当がつかない。

528
00:32:06,000 --> 00:32:10,000
一方、ここまで我々は、int x = 5で言う

529
00:32:10,000 --> 00:32:12,000
これは、任意の関数の範囲外である。

530
00:32:12,000 --> 00:32:16,000
これは、メインの範囲外なので、これはグローバル変数です。

531
00:32:16,000 --> 00:32:20,000
またはx + +は - 私はxを言うとき、それは、これら2つの関数のその内部を意味

532
00:32:20,000 --> 00:32:26,000
私は、このyとこのyは違う変数でありそれによって、同じxにアクセスしています。

533
00:32:26,000 --> 00:32:30,000
グローバル変数とローカル変数の違いはあります。

534
00:32:30,000 --> 00:32:33,000
限り設計が懸念している、時にはそれはおそらく良いアイデアだ

535
00:32:33,000 --> 00:32:37,000
いつでもあなたはおそらく可能な変数をローカルに保持するために

536
00:32:37,000 --> 00:32:39,000
グローバル変数の束を持って以来、本当に混乱して得ることができます。

537
00:32:39,000 --> 00:32:42,000
あなたが関数の束を持っている場合はすべて同じものを修正する

538
00:32:42,000 --> 00:32:45,000
あなたは、この関数が誤ってこの地球を修正した場合にどのような忘れてしまうかもしれません

539
00:32:45,000 --> 00:32:47,000
そしてこの他の機能は、それについては何も知りません

540
00:32:47,000 --> 00:32:50,000
あなたがより多くのコードを取得するように、それはかなり混乱するかもしれません。

541
00:32:50,000 --> 00:32:53,000
いつでもあなたはおそらく可能な変数をローカルに保存する

542
00:32:53,000 --> 00:32:56,000
ちょうど良いデザインです。

543
00:32:56,000 --> 00:33:00,000
アレイは、覚えて、単に同じ型の要素のリストである。

544
00:33:00,000 --> 00:33:04,000
CIの内側には、hello、1、2.0のようなリストを持つことができません。

545
00:33:04,000 --> 00:33:06,000
私達はちょうどそれを行うことはできません。

546
00:33:06,000 --> 00:33:11,000
>> 我々はC言語で配列を宣言するときにすべての要素が同じタイプである必要があります。

547
00:33:11,000 --> 00:33:14,000
ここで私は3つの整数の配列を持っている。

548
00:33:14,000 --> 00:33:18,000
ここでは、配列の長さを持っていますが、私はちょうどこの構文で宣言している場合はどう

549
00:33:18,000 --> 00:33:21,000
ここで私は、すべての要素は、私は技術的にはこの3は必要ありませんが何であるかを指定します。

550
00:33:21,000 --> 00:33:25,000
コンパイラは、配列がどの程度の大きを理解するのに十分スマートです。

551
00:33:25,000 --> 00:33:28,000
今私は、配列の値を取得または設定したいとき

552
00:33:28,000 --> 00:33:30,000
これはそれを行うための構文です。

553
00:33:30,000 --> 00:33:33,000
覚えている、ので、これは実際に、配列の2番目の要素を変更します

554
00:33:33,000 --> 00:33:36,000
番号は1からではなく、0から始まります。

555
00:33:36,000 --> 00:33:42,000
私はその値を読み込みたい場合は私のようなものを言うことができます。int x =配列[1]。

556
00:33:42,000 --> 00:33:44,000
または私はここでやっているように私は、その値を設定したい場合は、

557
00:33:44,000 --> 00:33:47,000
私は、[1] = 4の配列を言うことができます。

558
00:33:47,000 --> 00:33:50,000
それらのインデックスで要素にアクセスするその時

559
00:33:50,000 --> 00:33:52,000
またはそれらの位置やどこが配列内にある、

560
00:33:52,000 --> 00:33:57,000
そのリストには、0から始まります。

561
00:33:57,000 --> 00:34:00,000
我々はまた、配列の配列を持つことができます

562
00:34:00,000 --> 00:34:03,000
これは多次元配列と呼ばれます。

563
00:34:03,000 --> 00:34:05,000
我々は、多次元配列を持っているとき

564
00:34:05,000 --> 00:34:07,000
我々は、行と列のようなものを持つことができることを意味し

565
00:34:07,000 --> 00:34:11,000
これは、これを可視化する、またはそれを考えるのはただ1つの方法です。

566
00:34:11,000 --> 00:34:14,000
私は必要が開始するつもりだ意味の多次元配列を持っているとき

567
00:34:14,000 --> 00:34:17,000
私はグリッドを持っている場合ので、2つ以上のインデックス

568
00:34:17,000 --> 00:34:19,000
ちょうどあなたが何行目にいると言って私達に番号を与えるものではありません。

569
00:34:19,000 --> 00:34:22,000
それは本当にちょうど私達に番号のリストを与えるために起こっている。

570
00:34:22,000 --> 00:34:25,000
Let 'sは、私はここで、この配列を持っていると言う。

571
00:34:25,000 --> 00:34:30,000
私はグリッドと呼ばれる配列を持っている、と私はそれの2行3列を、言っている

572
00:34:30,000 --> 00:34:32,000
ので、これはそれを視覚化するための一つの方法です。

573
00:34:32,000 --> 00:34:37,000
私は[2] [1]にある要素を取得したいと言うとき

574
00:34:37,000 --> 00:34:41,000
これらは、最初の行、次に列であるため、ことを意味します

575
00:34:41,000 --> 00:34:44,000
私は1を言ったので、1行目にジャンプするつもりです。

576
00:34:44,000 --> 00:34:49,000
>> それから私は、列2にこっちに来るつもりです、と私は値6を取得するつもりです。

577
00:34:49,000 --> 00:34:51,000
感覚を作る？

578
00:34:51,000 --> 00:34:55,000
多次元配列は、覚えている、ただ技術的には、配列の配列です。

579
00:34:55,000 --> 00:34:57,000
我々は、配列の配列の配列を持つことができます。

580
00:34:57,000 --> 00:35:00,000
我々は考えるべき本当に一つの方法が、続けることができます

581
00:35:00,000 --> 00:35:03,000
これがレイアウトされていて、何が起こっている方法は、それを視覚化することです。

582
00:35:03,000 --> 00:35:09,000
このようなグリッドインチ

583
00:35:09,000 --> 00:35:12,000
我々は関数に配列を渡すとき、彼らは行動するつもりだ

584
00:35:12,000 --> 00:35:16,000
我々は関数に通常の変数を渡すときよりも少し違った

585
00:35:16,000 --> 00:35:18,000
intやfloatを渡すように。

586
00:35:18,000 --> 00:35:21,000
我々は、intやcharまたはこれらの他のデータ·タイプのいずれかに渡すと

587
00:35:21,000 --> 00:35:24,000
私達はちょうど関数が変更される場合を見てみた

588
00:35:24,000 --> 00:35:28,000
変化が伝播するまでするつもりはないことを、その変数の値

589
00:35:28,000 --> 00:35:32,000
呼び出し元の関数に。

590
00:35:32,000 --> 00:35:35,000
配列を使用して、その一方で、それは起こります。

591
00:35:35,000 --> 00:35:39,000
私はいくつかの関数に配列を渡すと、その関数は、要素のいくつかを変更した場合

592
00:35:39,000 --> 00:35:43,000
私はそれを呼び出した関数まで戻ってくるとき

593
00:35:43,000 --> 00:35:47,000
私の配列には、現在は別のになるだろうし、そのための語彙です

594
00:35:47,000 --> 00:35:50,000
我々は後で見るようである配列は、参照によって渡されます。

595
00:35:50,000 --> 00:35:53,000
これはどのようにポインタの仕事は、これらの基本的なデータ型に関連している

596
00:35:53,000 --> 00:35:55,000
一方、値によって渡されます。

597
00:35:55,000 --> 00:35:59,000
>> 我々は、いくつかの変数のコピーを作成してから、そのコピーを渡すようなことを考えることができます。

598
00:35:59,000 --> 00:36:01,000
それは我々がその変数に何をするかは問題ではありません。

599
00:36:01,000 --> 00:36:06,000
呼び出し元の関数は、それが変更されたことを意識することはありません。

600
00:36:06,000 --> 00:36:10,000
アレイは、その点で少しだけ異なっています。

601
00:36:10,000 --> 00:36:13,000
先ほど見たように、たとえば、メインは、単に関数です

602
00:36:13,000 --> 00:36:15,000
それは2つの引数に取ることができます。

603
00:36:15,000 --> 00:36:20,000
メイン関数の最初の引数はargcであるか、または引数の数、

604
00:36:20,000 --> 00:36:23,000
二番目の引数はargvと呼ばれ

605
00:36:23,000 --> 00:36:27,000
そしてそれらは、これらの引数の実際の値である。

606
00:36:27,000 --> 00:36:30,000
Let 'sは、私がthis.cと呼ばれるプログラムを持っていると言う

607
00:36:30,000 --> 00:36:34,000
そして私はこれを作ると言うと、私は、コマンドラインでこれを実行するつもりです。

608
00:36:34,000 --> 00:36:38,000
今、私のプログラムにいくつかの引数を渡すために、これを呼ばれる

609
00:36:38,000 --> 00:36:42,000
私は何かのように言うことができます/これはCS 50です。

610
00:36:42,000 --> 00:36:45,000
これは、我々は端末で毎日デヴィッドが何を想像するものです。

611
00:36:45,000 --> 00:36:48,000
そのプログラムのしかし、今のmain関数の内部

612
00:36:48,000 --> 00:36:52,000
これらの値を持っているので、argcは4です。

613
00:36:52,000 --> 00:36:56,000
本当に我々はだけで渡しているので、それは少し混乱するかもしれないCS 50です。

614
00:36:56,000 --> 00:36:58,000
それがわずか3です​​。

615
00:36:58,000 --> 00:37:02,000
しかし、覚えているargvの最初の要素または最初の引数

616
00:37:02,000 --> 00:37:05,000
関数自体の名前です。

617
00:37:05,000 --> 00:37:07,190
だから我々はここに4つの事を持っていることを意味し、

618
00:37:07,190 --> 00:37:10,530
最初の要素は、。/このことを行っている。

619
00:37:10,530 --> 00:37:12,970
そして、これを文字列として表現さ​​れます。

620
00:37:12,970 --> 00:37:18,590
その後、残りの要素は、我々はプログラムの名前の後に入力した内容です。

621
00:37:18,590 --> 00:37:22,720
だから余談として、我々は、おそらくpsetの2で見たように、

622
00:37:22,720 --> 00:37:28,780
ストリング50は整数50≠されていることを覚えています。

623
00:37:28,780 --> 00:37:32,520
だから我々は、のような何か言うことはできない 'ます。int x = ARGV 3。'

624
00:37:32,520 --> 00:37:36,470
>> それはちょうど、これは文字列であるため、意味をなさないことはないだろう、これは整数です。

625
00:37:36,470 --> 00:37:38,510
あなたが覚えて、2の間で変換したければ、我々はするつもりだ

626
00:37:38,510 --> 00:37:40,810
atoi関数と呼ばれるこのユニークな機能を持っています。

627
00:37:40,810 --> 00:37:46,270
これは文字列を受け取り、その文字列の内部表現された整数を返します。

628
00:37:46,270 --> 00:37:48,360
だから、クイズにするのは簡単間違いだ

629
00:37:48,360 --> 00:37:51,590
ただ、これは自動的に正しい型であることを考える。

630
00:37:51,590 --> 00:37:53,860
しかし、これらは常に文字列になることだけを知っている

631
00:37:53,860 --> 00:38:00,920
文字列だけで、整数または文字やfloatが含まれている場合でも。

632
00:38:00,920 --> 00:38:03,380
だから今の時間を実行する方法について説明しましょう​​。

633
00:38:03,380 --> 00:38:06,700
我々はすべてのこれらの狂気の事をするすべてのこれらのアルゴリズムを持っている場合、

634
00:38:06,700 --> 00:38:11,580
それは、質問をするのは本当に便利になる "彼らはどのくらい時間がかかりますか？"

635
00:38:11,580 --> 00:38:15,500
我々は、漸近記法と呼ばれるものであることを表しています。

636
00:38:15,500 --> 00:38:18,430
よく、のは、我々は我々のアルゴリズムを与えることとしましょう​​ - だから、これはことを意味します

637
00:38:18,430 --> 00:38:20,840
いくつかの本当に、本当に、本当に大きな入力。

638
00:38:20,840 --> 00:38:23,840
我々はどのくらいの時間がかかるとしている "、質問をしたいですか？

639
00:38:23,840 --> 00:38:26,370
それは、実行する私たちのアルゴリズムをどのように多くの措置を講じます

640
00:38:26,370 --> 00:38:29,980
入力の大きさの関数としての？ "

641
00:38:29,980 --> 00:38:33,080
だから我々は実行時間を記述することができます最初の方法は、ビッグOである

642
00:38:33,080 --> 00:38:35,380
そしてこれが私たちの最悪の場合の実行時間である。

643
00:38:35,380 --> 00:38:38,590
だから我々は配列をソートしたい、と我々は我々のアルゴリズムの配列を与える場合

644
00:38:38,590 --> 00:38:41,000
それは昇順でなければならないときには、降順での

645
00:38:41,000 --> 00:38:43,130
それは最悪のケースになるだろう。

646
00:38:43,130 --> 00:38:49,800
これは、我々のアルゴリズムにかかる時間の最大の長さにバインドされている私たちの上限です。

647
00:38:49,800 --> 00:38:54,740
一方、このΩはベスト·ケースの実行時間を記述するために起こっている。

648
00:38:54,740 --> 00:38:58,210
だから我々はソーティングアルゴリズムにすでにソートされた配列を与えれば、

649
00:38:58,210 --> 00:39:00,940
それをソートするためにどのくらいの時間がかかるのだろうか？

650
00:39:00,940 --> 00:39:06,610
そして、これは、その後、実行時間の下界を説明しています。

651
00:39:06,610 --> 00:39:10,980
そこでここでは、いくつかの一般的な実行時間を記述するだけで単語がいくつかあります。

652
00:39:10,980 --> 00:39:13,120
これらは昇順に並んでいます。

653
00:39:13,120 --> 00:39:16,060
我々が持っている最速の実行時間は一定と呼ばれています。

654
00:39:16,060 --> 00:39:19,800
>> 我々は我々のアルゴリズムを与えるどのように多くの要素に関係なく、意味ないこと

655
00:39:19,800 --> 00:39:22,280
私たちの配列がそれを並べ替え、どのくらいの大きさに関係なく

656
00:39:22,280 --> 00:39:26,510
または我々は配列にやっているものは何でもやって、常に同じ時間がかかります。

657
00:39:26,510 --> 00:39:30,270
だから我々は定数1で、というだけのことを表すことができます。

658
00:39:30,270 --> 00:39:32,410
また、対数の実行時に見えた。

659
00:39:32,410 --> 00:39:34,800
だから二分探索のようなものが対数的である、

660
00:39:34,800 --> 00:39:37,140
ここで我々は半分のたびに問題をカット

661
00:39:37,140 --> 00:39:40,970
その後の事はそこから高くなる。

662
00:39:40,970 --> 00:39:43,580
そして、あなたは今までに何階乗アルゴリズムのOを書いているのであれば、

663
00:39:43,580 --> 00:39:47,850
あなたはおそらく、あなたの一日の仕事としてこれを考慮するべきではありません。

664
00:39:47,850 --> 00:39:53,910
我々は実行時間を比較したときに、それはこれらの事を心に留めておくことが重要です。

665
00:39:53,910 --> 00:39:57,760
私はO（n）のアルゴリズムは、他の誰かを持っている場合

666
00:39:57,760 --> 00:40:03,590
これらは実際に漸近的に等価であるO（2n）のアルゴリズムを持っています。

667
00:40:03,590 --> 00:40:06,590
だから我々は百億兆万のような大きな数になるようにnを想像するなら：

668
00:40:06,590 --> 00:40:13,090
私たちは百億兆万のようなもの+ 3に百億兆万を比較しているときに、

669
00:40:13,090 --> 00:40:17,640
突然その3は本当にもう大きな違いを生むことはありません。

670
00:40:17,640 --> 00:40:20,980
我々はこれらの事が同等であることを考慮して開始しようとしている理由です。

671
00:40:20,980 --> 00:40:24,220
ここで、これらの定数のようなものだから、そこに2×これです、または3を追加

672
00:40:24,220 --> 00:40:27,180
これらは単なる定数であり、これらは、最大ドロップしようとしている。

673
00:40:27,180 --> 00:40:32,480
これらの実行時間のすべての3つは、彼らはO（n）だと言うように同じである理由ようだ。

674
00:40:32,480 --> 00:40:37,490
我々が2つの他の実行時間があれば同様に、はO（n³+2 N²）は、我々が追加することができたとしましょう

675
00:40:37,490 --> 00:40:42,070
+ N、+ 7、それから私達はちょうどはO（n³）の別の実行時間を持っています。

676
00:40:42,070 --> 00:40:46,290
これらの同じではありません - これらがあるため、再び、これらは同じものです。

677
00:40:46,290 --> 00:40:49,840
これらには、申し訳ございませんが、同じものです。したがって、これらは同じであるため、

678
00:40:49,840 --> 00:40:53,090
このn³がこの2n個の²を支配しようとしている。

679
00:40:53,090 --> 00:40:59,130
>> 我々はO（n³）とはO（n²）のように時間を実行した場合はどうすればよいということではありませんすることは、

680
00:40:59,130 --> 00:41:02,820
このn³がこのn²をよりはるかに大きいからです。

681
00:41:02,820 --> 00:41:05,470
我々は指数を持っているなら、突然これは問題を開始し、

682
00:41:05,470 --> 00:41:08,280
しかし、我々はここにアップしているように我々だけの要因を扱っているときに、

683
00:41:08,280 --> 00:41:12,810
それは彼らがちょうどドロップアウトしようとしているので問題ではないだろう。

684
00:41:12,810 --> 00:41:16,760
のは、我々がこれまで見てきたいくつかのアルゴリズムを見てみましょう

685
00:41:16,760 --> 00:41:19,260
とその実行時の話。

686
00:41:19,260 --> 00:41:23,850
我々が見たリストの番号を探しているの最初の方法は、線形探索であった。

687
00:41:23,850 --> 00:41:26,950
と線形探索の実装は超簡単です。

688
00:41:26,950 --> 00:41:30,490
我々は、単にリストを持って、私たちは、リスト内のすべての単一の要素を見ていくつもりです。

689
00:41:30,490 --> 00:41:34,260
我々は我々が探している番号を見つけるまで。

690
00:41:34,260 --> 00:41:38,370
だから、最悪の場合には、これはO（n）のことを意味し。

691
00:41:38,370 --> 00:41:40,860
要素がある場合、ここでは、最悪の場合は次のようになります。

692
00:41:40,860 --> 00:41:45,710
最後の要素は、線形探索を用いて、我々は、一つ一つの要素を見ている

693
00:41:45,710 --> 00:41:50,180
我々はそれがリストに実際にあったことがわかるように、最後の1に到達するまで。

694
00:41:50,180 --> 00:41:52,910
我々は、ちょうど途中あきらめると言うことはできませんが、 "それはおそらくないです。"

695
00:41:52,910 --> 00:41:55,980
線形探索で、我々は全体のことを見なければなりません。

696
00:41:55,980 --> 00:41:59,090
ベストケースの実行時間は、他の一方で、定数である

697
00:41:59,090 --> 00:42:04,200
最良のケースで我々が探している要素は、リストの中の最初のものであるためです。

698
00:42:04,200 --> 00:42:08,930
だから、正確に1ステップ、リストがどんなに大きくて私たちを取るために起こっている

699
00:42:08,930 --> 00:42:12,140
我々は最初の要素のたびに探している場合。

700
00:42:12,140 --> 00:42:15,390
>> ですから、検索、覚えているとき、それは私たちのリストがソートされている必要はありません。

701
00:42:15,390 --> 00:42:19,430
我々は、単に一つ一つの要素を上に見ていくつもりです、そして、それは本当に問題ではないので

702
00:42:19,430 --> 00:42:23,560
どのような順序、それらの要素インチアール

703
00:42:23,560 --> 00:42:28,110
よりインテリジェントな検索アルゴリズムは二分探索のようなものです。

704
00:42:28,110 --> 00:42:31,500
あなたがしようとしているときのことを覚えて、二分探索の実装です

705
00:42:31,500 --> 00:42:34,320
リストの中央を見続ける。

706
00:42:34,320 --> 00:42:38,000
私たちは中央を見ているからと、我々はリストがソートされていることを必要とする

707
00:42:38,000 --> 00:42:40,580
あるいは真ん中がどこにあるか我々は知らない、と我々は上を見ている

708
00:42:40,580 --> 00:42:44,480
それを見つけるために全体のリストと、その時点で我々は、単に時間を無駄にしています。

709
00:42:44,480 --> 00:42:48,480
weは、ソートされたリストを持っていると我々は真ん中を見つけたらそこで、我々は真ん中を比較するつもりだ

710
00:42:48,480 --> 00:42:51,590
私たちが探している要素へ。

711
00:42:51,590 --> 00:42:54,640
それは高すぎるなら、私たちは右半分を忘れることができます

712
00:42:54,640 --> 00:42:57,810
我々は、もし我々の要素が既に高すぎることを知っているので、

713
00:42:57,810 --> 00:43:01,080
そしてこの要素の右側にすべてが、さらに高くなる

714
00:43:01,080 --> 00:43:02,760
それから私達はもうそこに見える必要はありません。

715
00:43:02,760 --> 00:43:05,430
どこでその一方で、我々の要素が低すぎる場合には、

716
00:43:05,430 --> 00:43:08,700
私たちは、その要素の左に、すべてがあまりにも低すぎる知る

717
00:43:08,700 --> 00:43:11,390
ので、実際にどちらか、そこを見ても意味がありません。

718
00:43:11,390 --> 00:43:15,760
このように、リストの中間点で一歩一歩、私たちが見るたびに付き、

719
00:43:15,760 --> 00:43:19,060
突然、私たちが知っているので、我々は半分に我々の問題をカットするつもりだ

720
00:43:19,060 --> 00:43:23,040
我々が探しているものにすることはできません数字の全体の束。

721
00:43:23,040 --> 00:43:26,950
>> 擬似コードでは、これは、このような感じでしょう

722
00:43:26,950 --> 00:43:30,990
そして我々は半分毎回でリストを切断しているため、

723
00:43:30,990 --> 00:43:34,920
対数に対して直線的からの私達の最悪の場合の実行時にジャンプします。

724
00:43:34,920 --> 00:43:39,260
だから、突然、我々は、リスト内の要素を検索するために、ログの手順を持っています。

725
00:43:39,260 --> 00:43:42,460
ベストケースの実行時間は、しかし、まだ一定である

726
00:43:42,460 --> 00:43:45,180
今ので、ちょうど我々が探している要素があるとしましょう

727
00:43:45,180 --> 00:43:48,380
元のリストは、常に正確なミドル。

728
00:43:48,380 --> 00:43:52,080
そこで、我々は我々が望むほどの大きさ私たちのリストを育てることができますが、我々が探している要素は、中間にある場合

729
00:43:52,080 --> 00:43:54,910
それが唯一の問い合わせ1歩を踏み出すことになるだろう。

730
00:43:54,910 --> 00:44:00,920
weはO（log n）とΩ（1）または定数にいる理由ようだ。

731
00:44:00,920 --> 00:44:04,510
実際にこのリスト上のバイナリ検索を実行してみましょう。

732
00:44:04,510 --> 00:44:08,020
だから我々は要素164を探しているとしましょう​​。

733
00:44:08,020 --> 00:44:11,650
我々がやろうとしている最初のものは、このリストの中間点を見つけることです。

734
00:44:11,650 --> 00:44:15,060
それはちょうどので、中間点は、これら2つの数値の間に入るために起こっていることが起こる

735
00:44:15,060 --> 00:44:18,960
ので、中間点が2つの数値の間に入るたびに、ちょうど任意に言ってみましょう

736
00:44:18,960 --> 00:44:21,150
ただ切り上げてみましょう。

737
00:44:21,150 --> 00:44:24,330
私達はちょうど私達がこの方法のあらゆるステップを行うことを確認する必要があります。

738
00:44:24,330 --> 00:44:29,040
だから我々は切り上げするつもりだ、と我々は161が私達のリストの途中であることを言おうとしている。

739
00:44:29,040 --> 00:44:34,640
だから、161 <164と161の左側にあるすべての要素

740
00:44:34,640 --> 00:44:39,120
また、<164であるので、我々はそれがすべてで私たちを助けに行くのではないことを知っている

741
00:44:39,120 --> 00:44:42,690
我々が探している要素が存在することはできませんのでこっちを見て開始します。

742
00:44:42,690 --> 00:44:47,060
ですから、私たちにできることは、我々だけで、リストのその全体の左半分を忘れることができますです

743
00:44:47,060 --> 00:44:51,700
そして今だけ161以降の右側から検討してください。

744
00:44:51,700 --> 00:44:54,050
>> そして再び、これは中点です。のがちょうど切り上げましょう。

745
00:44:54,050 --> 00:44:56,260
今すぐ175は大きすぎます。

746
00:44:56,260 --> 00:44:59,180
だから我々は、それは、私たちはここやここを見て支援するつもりはないと知っている

747
00:44:59,180 --> 00:45:06,610
ので、我々はちょうどその捨てることができ、最終的には164を打つでしょう。

748
00:45:06,610 --> 00:45:10,560
二分探索で何か質問はありますか？

749
00:45:10,560 --> 00:45:14,180
既にソートされたリストを検索してから移動しましょう

750
00:45:14,180 --> 00:45:17,660
実際に任意の順序で番号のリストを取ることに

751
00:45:17,660 --> 00:45:20,960
と昇順に、そのリストを作る。

752
00:45:20,960 --> 00:45:24,060
我々が見た最初のアルゴリズムはバブルソートと呼ばれていました。

753
00:45:24,060 --> 00:45:27,300
そして、これは我々が見たアルゴリズムの単純になるはずだ。

754
00:45:27,300 --> 00:45:32,970
バブルソートは、リスト内の任意の2つの要素が場違いである場合と言う

755
00:45:32,970 --> 00:45:36,500
数値が高いほど、より低い番号の左側にあることを意味し、

756
00:45:36,500 --> 00:45:40,190
その後、我々はそのリストがあることを意味しているので、それらを交換するつもりだ

757
00:45:40,190 --> 00:45:42,860
それは以前より "もっとソート"。

758
00:45:42,860 --> 00:45:45,180
そして、私たちはもう一度、もう一度、もう一度、このプロセスを継続する予定としている

759
00:45:45,180 --> 00:45:52,100
最終的にはそれらの要素が正しい場所にバブルのようなものと我々はソートされたリストを持っているまで。

760
00:45:52,100 --> 00:45:57,230
>> これの実行時間はO（n²）であることを行っている。なぜですか？

761
00:45:57,230 --> 00:46:00,370
まあ、最悪の場合には、我々はすべての要素を取るつもりですので、と

762
00:46:00,370 --> 00:46:04,570
我々はリスト内の他のすべての要素と比較する羽目になるだろう。

763
00:46:04,570 --> 00:46:08,030
しかし、最良のケースでは、我々はすでにソートされたリストを持って、バブルソートの

764
00:46:08,030 --> 00:46:12,230
一度だけ通って行く、と言う "いや、私は、どのスワップを行っていないので、私は終わりだ。"

765
00:46:12,230 --> 00:46:17,410
だから我々はΩ（n）のベスト·ケースの実行時間を持っています。

766
00:46:17,410 --> 00:46:20,680
リスト上のバブルソートを実行してみましょう。

767
00:46:20,680 --> 00:46:23,560
または第一、本当にすぐにいくつかの擬似コードを見てみましょう。

768
00:46:23,560 --> 00:46:28,160
私たちは、ループの反復ごとに、追跡するためにしたいと言いたい

769
00:46:28,160 --> 00:46:32,190
我々は、任意の要素を変更したかどうかを把握しません。

770
00:46:32,190 --> 00:46:37,610
そこらの理由は、我々はすべての要素を交換していないときに停止するつもりされています。

771
00:46:37,610 --> 00:46:41,980
それで、我々のループの開始時に我々は何を交換していないので、我々は偽だと言うでしょう。

772
00:46:41,980 --> 00:46:47,170
今、我々はリストを通過し、iは要素i + 1に要素を比較するつもりだ

773
00:46:47,170 --> 00:46:50,310
それは小さい番号の左側に大きな番号があること事実である場合、

774
00:46:50,310 --> 00:46:52,310
私たちはただそれらを交換するつもりです。

775
00:46:52,310 --> 00:46:54,490
>> そして、我々は、我々はエレメントを交換していることを覚えておくつもりだ。

776
00:46:54,490 --> 00:46:58,900
それは我々がリストを介して少なくとも1つのより多くの時間を移動する必要があることを意味します

777
00:46:58,900 --> 00:47:02,160
全体のリストが既にソートされているときに我々は停止している状態であるため、

778
00:47:02,160 --> 00:47:04,890
我々は任意のスワップ取引を行っていないという意味。

779
00:47:04,890 --> 00:47:09,960
'いくつかの要素が交換されているが。 "だからここになぜ我々のダウン状態ですつまり

780
00:47:09,960 --> 00:47:13,720
だから今はただリストに載っているこのランニングを見てみましょう。

781
00:47:13,720 --> 00:47:16,640
私はリスト5,0,1,6,4を持っています。

782
00:47:16,640 --> 00:47:19,850
バブルソートでは、左側にすべての道を開始しようとしている、それは比較するために起こっている

783
00:47:19,850 --> 00:47:24,700
iは要素なので、0〜I + 1、要素1です。

784
00:47:24,700 --> 00:47:29,020
、それは、よく5> 0を言おうとしているが、今の5は左に

785
00:47:29,020 --> 00:47:32,500
ので、私は5と0を交換する必要があります。

786
00:47:32,500 --> 00:47:35,470
私はそれらを交換するとき、突然、私は、この別のリストを取得します。

787
00:47:35,470 --> 00:47:38,260
今すぐ5> 1、私たちはそれらを交換するつもりです。

788
00:47:38,260 --> 00:47:42,160
5> 6ではないので、我々はここでは何もする必要はありません。

789
00:47:42,160 --> 00:47:46,690
しかし、6> 4ので、交換する必要があります。

790
00:47:46,690 --> 00:47:49,740
再び、我々は最終的に発見するために全体のリストを介して実行する必要が

791
00:47:49,740 --> 00:47:52,330
これらの順序があることを、我々はそれらを交換、

792
00:47:52,330 --> 00:47:57,120
この時点で我々はリスト1を介してより多くの時間を実行する必要が

793
00:47:57,120 --> 00:48:05,390
すべてがそのためにだし、この時点バブルソートで終了したことを確認します。

794
00:48:05,390 --> 00:48:10,720
いくつかの要素を考慮し、それらをソートするための異なったアルゴリズムが選択ソートです。

795
00:48:10,720 --> 00:48:15,740
選択ソートの背後にある考え方は、我々はリストのソートされた部分を構築しようとしているということです

796
00:48:15,740 --> 00:48:18,150
一度に1つの要素。

797
00:48:18,150 --> 00:48:23,170
>> そして、我々はそれをやろうとしている方法は、リストの左側のセグメントを構築することです。

798
00:48:23,170 --> 00:48:27,510
そして、基本的に、すべての - 各ステップで、我々は残されている最小の要素を取るつもりだ

799
00:48:27,510 --> 00:48:32,310
それはまだソートされていない、と私たちは、ソートされたセグメントに移動するつもりです。

800
00:48:32,310 --> 00:48:35,850
つまり、我々は継続的にソートされていない最小の要素を見つける必要があります

801
00:48:35,850 --> 00:48:40,720
し、その最小の要素を取ると何と交換し

802
00:48:40,720 --> 00:48:45,090
ソートされていない最も左の要素。

803
00:48:45,090 --> 00:48:50,890
これの実行時間があるため、最悪の場合にはO（n²）であることを行っている

804
00:48:50,890 --> 00:48:55,070
我々は、他のすべての要素に一つ一つの要素を比較する必要があります。

805
00:48:55,070 --> 00:48:59,250
我々は、リストの左半分で開始した場合、我々が必要と言っているので

806
00:48:59,250 --> 00:49:02,970
最小の要素を見つけるために全体の右のセグメントを通過する可能性があります。

807
00:49:02,970 --> 00:49:05,430
その後、再び、我々は全体の右のセグメント上に行く必要があり、

808
00:49:05,430 --> 00:49:08,210
何度も何度も繰り返していること以上続ける。

809
00:49:08,210 --> 00:49:11,350
つまり、n²となるだろう。我々は、forループの別の内側のforループが必要になるだろう

810
00:49:11,350 --> 00:49:13,350
これは、n個の²を示唆している。

811
00:49:13,350 --> 00:49:16,530
最良のケースの思想では、のは、我々はそれをすでにソートされたリストを与えるとしましょう​​;

812
00:49:16,530 --> 00:49:19,270
我々は実際のn²よりも良くはしない。

813
00:49:19,270 --> 00:49:21,730
選択ソートは、ことを知る方法がありませんので

814
00:49:21,730 --> 00:49:25,540
最小要素は、ちょうど私が見てすることが起こるものです。

815
00:49:25,540 --> 00:49:28,970
それはまだ、これが実際に最小であることを確認する必要があります。

816
00:49:28,970 --> 00:49:31,670
>> そして、このアルゴリズムを使用して、それが最低限だことを確認する唯一の方法は、

817
00:49:31,670 --> 00:49:34,640
再び一つ一つの要素を見ることです。

818
00:49:34,640 --> 00:49:38,420
だから本当に、あなたがそれを与える場合 - あなたが選択ソートをすでにソートされたリストを与えると、

819
00:49:38,420 --> 00:49:42,720
それは、まだソートされていないリストを与えるよりも良い結果を出すことはないだろう。

820
00:49:42,720 --> 00:49:46,320
ところで、それは何かがO（何か）である場合であることを起こる場合

821
00:49:46,320 --> 00:49:50,640
と何かのオメガは、私達はちょうどより簡潔に、それが何かのθだと言うことができます。

822
00:49:50,640 --> 00:49:52,760
あなたがどこでも出てくることがわかりそうだとすれば、それはそれだけで何を意味するかだ。

823
00:49:52,760 --> 00:49:57,580
>> 何かがn²のシータであれば、それはビッグはO（n²）とΩ（nの²）の両方です。

824
00:49:57,580 --> 00:49:59,790
最良のケースと最悪のケースだから、それは、違いを確認していません

825
00:49:59,790 --> 00:50:04,400
アルゴリズムは、同じことをするたびに何をしようとしている。

826
00:50:04,400 --> 00:50:06,610
だから、これは選択ソートの擬似コードのように見えることができるものである。

827
00:50:06,610 --> 00:50:10,630
私たちは基本的に私はリストを反復処理することを言おうとしている

828
00:50:10,630 --> 00:50:15,180
右に、ループの各繰り返しで左から、私は移動するつもりだ

829
00:50:15,180 --> 00:50:19,780
リストのソートされたこの部分に最小要素。

830
00:50:19,780 --> 00:50:23,260
そして、かつて私はそこに何かを移動し、私は再び、その要素を見てする必要はありません。

831
00:50:23,260 --> 00:50:28,600
できるだけ早く私はリストの左側のセグメントにで要素を入れ替えるように、それはソートだから

832
00:50:28,600 --> 00:50:32,600
我々は最小値を使用して昇順ですべてをやっているので。

833
00:50:32,600 --> 00:50:38,740
だから我々は大丈夫、我々は位置iだ、と我々はすべての要素を見る必要がある、と述べた

834
00:50:38,740 --> 00:50:42,260
最小値を見つけるために私の右側にある。

835
00:50:42,260 --> 00:50:46,150
だから、我々はリストの最後にi + 1から見てみたいということです。

836
00:50:46,150 --> 00:50:51,610
そして今、我々が現在見ているという要素は、今のところ私たちの最小値よりも小さい場合

837
00:50:51,610 --> 00:50:54,190
覚えて、我々はちょうどように最小オフを開始している、

838
00:50:54,190 --> 00:50:57,020
どんな要素が我々に現在している、私は最低だと仮定します。

839
00:50:57,020 --> 00:51:00,270
私はそれよりも小さいの要素を見つけるなら、私は、大丈夫、と言うつもりです

840
00:51:00,270 --> 00:51:02,700
まあ、私は、新しい最小値を発見した。

841
00:51:02,700 --> 00:51:06,080
私は、その最小値がどこにあったか覚えているつもりです。

842
00:51:06,080 --> 00:51:09,560
>> だから今、かつて私は、その権利ソートされていないセグメントを経てきました

843
00:51:09,560 --> 00:51:16,690
私は位置iにある要素で最小の要素を入れ替えるつもりだと言うことができます。

844
00:51:16,690 --> 00:51:21,100
それは私のリストを構築するために起こっているのは、左から右にリストの並べ替え私の部分、

845
00:51:21,100 --> 00:51:25,190
そして我々は今までそれがその部分にだから、もう一度要素を見る必要はありません。

846
00:51:25,190 --> 00:51:27,930
かつて我々はそれを交換してきました。

847
00:51:27,930 --> 00:51:30,260
したがって、このリスト上の選択ソートを実行してみましょう。

848
00:51:30,260 --> 00:51:38,220
ここで青色素子は、iであることを行っている、赤の要素は最小の要素になるだろう。

849
00:51:38,220 --> 00:51:41,570
だから私は5でそう、リストの左側にすべての道を開始します。

850
00:51:41,570 --> 00:51:44,610
今、私たちは最小のソートされていない要素を見つける必要があります。

851
00:51:44,610 --> 00:51:49,480
だから我々は<5ので、0は私の新しい最小値である0を言う。

852
00:51:49,480 --> 00:51:53,820
>> 我々は、0が最小であることを認識することができるにもかかわらずので、しかし、私はそこに停止することはできません

853
00:51:53,820 --> 00:51:59,390
我々は確かにするためのリストの他のすべての要素を介して実行する必要があります。

854
00:51:59,390 --> 00:52:01,760
ので、1の方が大きい、6の方が大きい、4は大きいです。

855
00:52:01,760 --> 00:52:05,850
つまり、これらの要素のすべてを見た後、私は0は最小と判断されたことを意味します。

856
00:52:05,850 --> 00:52:09,800
だから私は5と0を交換するつもりです。

857
00:52:09,800 --> 00:52:15,480
かつて私は、それを交換し、私は新しいリストを取得するつもりだ、と私は再びその0を見てする必要はありませんことを知っている

858
00:52:15,480 --> 00:52:19,380
かつて私は、それを交換してきたので、私はそれをソートしてきて終わり。

859
00:52:19,380 --> 00:52:22,730
今度はそれはちょうどので、青の要素が再び5であることを起こる

860
00:52:22,730 --> 00:52:26,030
そして我々はその1を決定するために、1を見て6と4が必要

861
00:52:26,030 --> 00:52:31,520
最小の最小要素であるので、我々は1と5を入れ替えます。

862
00:52:31,520 --> 00:52:36,890
再び、我々は見てする必要がある - 、6、4から5を比較する

863
00:52:36,890 --> 00:52:39,830
そして我々は、比較、最終的に4と5を交換し、するつもりだ

864
00:52:39,830 --> 00:52:45,740
それらの2つの数字と私たちは、ソートされたリストを取得するまで、それらを交換。

865
00:52:45,740 --> 00:52:49,730
選択ソートに何か質問はありますか？

866
00:52:49,730 --> 00:52:56,420
オーケー。のがここでの最後のトピックに移動しましょう​​、それが再帰です。

867
00:52:56,420 --> 00:52:59,810
>> 再帰は、覚えて、これは本当にどこ機能メタ事です

868
00:52:59,810 --> 00:53:02,740
繰り返し自体呼び出します。

869
00:53:02,740 --> 00:53:05,620
そこで、いくつかの時点で、我々のfuctionを繰り返し自分自身を呼び出している間に、

870
00:53:05,620 --> 00:53:10,100
我々は自分自身の呼び出しを止めるれるいくつかのポイントがあるのが必要です。

871
00:53:10,100 --> 00:53:13,670
我々はそれをしないならば、我々だけで永遠にこれを行うには続けていくつもりですので、

872
00:53:13,670 --> 00:53:16,660
私たちのプログラムは、ちょうど終了するつもりはない。

873
00:53:16,660 --> 00:53:19,200
我々は、この条件ベースケースと呼ぶ。

874
00:53:19,200 --> 00:53:22,570
とベースケースは、むしろ関数を再度呼び出すよりも、言う

875
00:53:22,570 --> 00:53:25,330
私はいくつかの値を返すつもりです。

876
00:53:25,330 --> 00:53:28,080
我々は値を返さたらそれで、私たちは、自分自身を呼び出しやめた

877
00:53:28,080 --> 00:53:32,550
我々はこれまでに作ったコールの残りも返すことができます。

878
00:53:32,550 --> 00:53:36,050
ベースケースの反対側では、再帰的なケースです。

879
00:53:36,050 --> 00:53:39,050
そして、これは、我々はインチ現在していることを別の関数への呼び出しを行いたい場合です

880
00:53:39,050 --> 00:53:44,690
そして、我々はおそらく、常にではありませんが、異なる引数を使用したい。

881
00:53:44,690 --> 00:53:48,940
>> だから我々は、fという関数を持っている場合、fはちょうど1つの引数を取ると呼ばれる、

882
00:53:48,940 --> 00:53:52,010
私達はちょうどF（1）において、f（1）において、f（1）を呼び出しておくと、それだけでことが起こる

883
00:53:52,010 --> 00:53:56,510
引数1は、再帰的なケースに落ち、我々はまだ停止するつもりはありませんしている。

884
00:53:56,510 --> 00:54:01,620
weはベースケースを持っている場合でも、我々は最終的に我々はベースケースをヒットしようとしていることを確認する必要があります。

885
00:54:01,620 --> 00:54:04,250
私達はちょうどこの再帰的な場合に滞在し保存していません。

886
00:54:04,250 --> 00:54:09,870
一般的に、我々は自分自身を呼び出すときに、我々は、おそらく別の引数を毎回持っているつもりです。

887
00:54:09,870 --> 00:54:12,700
ここは本当に単純な再帰関数である。

888
00:54:12,700 --> 00:54:15,090
だから、これは数値の階乗を計算します。

889
00:54:15,090 --> 00:54:17,790
我々はベースケースを持ってここにトップアップ。

890
00:54:17,790 --> 00:54:22,330
nは≤1、我々は再び乗コールするつもりはない場合。

891
00:54:22,330 --> 00:54:26,490
私達はやめるつもりです、我々はいくつかの値を返すつもりだ。

892
00:54:26,490 --> 00:54:30,170
これが本当でないなら、私たちは私たちの再帰的なケースをヒットするつもりです。

893
00:54:30,170 --> 00:54:33,550
それは非常に有用ではないので、我々はちょうど、階乗（n）を呼び出していないことに注目してください。

894
00:54:33,550 --> 00:54:36,810
私たちは、何か他の階乗を呼ぶつもりです。

895
00:54:36,810 --> 00:54:40,850
>> そしてあなたは、我々は階乗（5）か何かを渡した場合、最終的には、見ることができます

896
00:54:40,850 --> 00:54:45,900
weは、factorial（4）のように呼び出すつもりだし、最終的に我々は、このベースケースをヒットするつもりです。

897
00:54:45,900 --> 00:54:51,730
だから、これはよさそうだ。我々は実際にこれを実行したときに何が起こるか見てみましょう。

898
00:54:51,730 --> 00:54:57,840
これは、スタックだけですが、メインの引数（4）で、この関数を呼び出すために起こっていることを言わせてください。

899
00:54:57,840 --> 00:55:02,200
だから一度見て、階乗= 4の場合、階乗は自分自身を呼び出します。

900
00:55:02,200 --> 00:55:05,010
さて、突然、我々は、（3）階乗を持っています。

901
00:55:05,010 --> 00:55:10,780
そこで、これらの関数は、最終的に我々はベースケースに当たるまで成長を維持しようとしている。

902
00:55:10,780 --> 00:55:17,830
この時点では、このメソッドの戻り値は、return（NXこのメソッドの戻り値）である

903
00:55:17,830 --> 00:55:21,290
このメソッドの戻り値は、このNXの戻り値です。

904
00:55:21,290 --> 00:55:23,290
最終的に我々はいくつかの数字をヒットする必要があります。

905
00:55:23,290 --> 00:55:26,560
ここで一番上には、我々は1を返すと言う。

906
00:55:26,560 --> 00:55:30,650
かつて我々は、その数を返すことを意味します、我々は、スタックから、これを開くことができます。

907
00:55:30,650 --> 00:55:36,570
ですから、これは階乗は（1）で行われます。

908
00:55:36,570 --> 00:55:41,190
ときに1が返ると、この階乗（1）を返し、1〜このリターン。

909
00:55:41,190 --> 00:55:46,910
このメソッドの戻り値は、覚えて、このメソッドの戻り値NXだった。

910
00:55:46,910 --> 00:55:50,720
そんなに急に、この男は、私は2を返すようにしたいことを知っています。

911
00:55:50,720 --> 00:55:55,910
>> だから、これの値はここで戻り値だけNX次第です戻り、覚えておいてください。

912
00:55:55,910 --> 00:56:01,160
だから今我々は3×2と言うことができ、最終的に、ここで我々は言うことができます

913
00:56:01,160 --> 00:56:04,010
これはちょうど4×3×2であることを行っている。

914
00:56:04,010 --> 00:56:09,570
そして、この復帰後に、私たちは主の単一の整数の内部に取り掛かる。

915
00:56:09,570 --> 00:56:15,460
再帰に何か質問はありますか？

916
00:56:15,460 --> 00:56:17,090
かしこまりました。だから最後に質問のためのより多くの時間があり、

917
00:56:17,090 --> 00:56:23,360
しかし今ヨセフは残りのトピックをカバーしています。

918
00:56:23,360 --> 00:56:25,590
>> [ジョセフ·オング]すべての権利。だから今我々は再帰について話したことを、

919
00:56:25,590 --> 00:56:27,840
ソートされ、マージかについて少し話してみましょう。

920
00:56:27,840 --> 00:56:31,740
マージソートは、基本的に数字のリストをソートする別の方法です。

921
00:56:31,740 --> 00:56:36,430
そして、それはマージソートであり、どのように動作するか、リストを持っており、私たちがやっていることです

922
00:56:36,430 --> 00:56:39,120
我々は、の2等分これを分割してみましょう、と言う。

923
00:56:39,120 --> 00:56:42,750
私たちは最初に、左半分に再びマージソートを実行することになるでしょう

924
00:56:42,750 --> 00:56:45,040
次に我々は、右半分にマージソートを実行することになるでしょう

925
00:56:45,040 --> 00:56:50,240
それが今私たちにソートされている2の半分を与え、そして、今、私たちは一緒にそれらの半分を結合しようとしている。

926
00:56:50,240 --> 00:56:55,010
それは例なしで見るのは少し難しいので、私たちはふりをすると何が起こるかわかります。

927
00:56:55,010 --> 00:56:59,590
ですから、このリストを使用して開始し、我々は2等分に分割します。

928
00:56:59,590 --> 00:57:02,300
我々は最初の左半分にマージソートを実行します。

929
00:57:02,300 --> 00:57:06,660
だから左半分だし、今、私たちは再び、このリストを介してそれらを実行する

930
00:57:06,660 --> 00:57:09,800
マージソートに渡され、それから私達は、再び、見される

931
00:57:09,800 --> 00:57:13,270
このリストの左側にあると我々はそれにマージソートを実行します。

932
00:57:13,270 --> 00:57:15,880
今、私たちには、2つの数値のリストに降り、

933
00:57:15,880 --> 00:57:19,010
そして今、左半分は1要素の長さであり、我々はできません

934
00:57:19,010 --> 00:57:23,380
半分に1つだけの要素のリストに分割するので、我々は一度だけ私たちは50を持っている、と言う、

935
00:57:23,380 --> 00:57:26,400
ただ1つの要素である、それはすでにソートだ。

936
00:57:26,400 --> 00:57:29,860
>> weは、その処理が終わったら、私たちができることがわかります

937
00:57:29,860 --> 00:57:32,230
このリストの右半分に移動、

938
00:57:32,230 --> 00:57:36,480
と3も、今、このリストの両方の半分がソートされているソートされており、

939
00:57:36,480 --> 00:57:39,080
我々は戻って一緒にこれらの番号を参加させることができます。

940
00:57:39,080 --> 00:57:45,320
だから我々は、50と3を見て、3は50よりも小さいので、それは最初にして50になった出番

941
00:57:45,320 --> 00:57:49,340
さて、それが済んだ、我々はそれが右半分だとリストとソートに戻って上がる。

942
00:57:49,340 --> 00:57:52,440
42はそれ自身の番号ですので、すでにソートだ。

943
00:57:52,440 --> 00:57:57,850
だから今我々は、第一​​に置かれるように、これらの2と3は、42よりも小さい比較

944
00:57:57,850 --> 00:58:02,340
今42に入れ取得し、50インチ入れてさ

945
00:58:02,340 --> 00:58:07,220
さて、ソートされている、我々は、トップに戻る、1337年、15〜すべての道を行く。

946
00:58:07,220 --> 00:58:14,560
まあ、我々は今、このリストの左半分を見て、1337年は、それ自体であるので、15でソートと同じだ。

947
00:58:14,560 --> 00:58:19,020
だから今我々は15日、元のリストをソートするために、これら2つの数値を組み合わせる<1337、

948
00:58:19,020 --> 00:58:23,060
ので、それが最初に入り、その後、1337インチ行く

949
00:58:23,060 --> 00:58:26,640
そして今、我々はトップアップ元のリストの両方の半分をソート。

950
00:58:26,640 --> 00:58:30,440
そして、我々がしなければならないすべては、これらを組み合わせることである。

951
00:58:30,440 --> 00:58:36,890
我々は、このリストの最初の2つの数字、3 <15を見ているので、最初のソート配列になります。

952
00:58:36,890 --> 00:58:44,460
15 <42ので、それは、今すぐ行くインチ42 <1337年、それはインチ行く

953
00:58:44,460 --> 00:58:51,010
50 <1337年なので、インチになり、私達はちょうどこのリストの2つの数値を脱いだことがわかります。

954
00:58:51,010 --> 00:58:53,640
だから我々は、ちょうど2つのリストの間で交互にしていない。

955
00:58:53,640 --> 00:58:56,050
私達はちょうど初めに探している、と我々は要素を取っている

956
00:58:56,050 --> 00:59:00,270
小さいし、私達の配列にそれを入れているのです。

957
00:59:00,270 --> 00:59:04,080
今、私たちはすべての半分をマージしたと我々は完了です。

958
00:59:04,080 --> 00:59:07,780
>> マージソートについて何か質問はありますか？はい？

959
00:59:07,780 --> 00:59:14,190
[学生]は、それが別のグループに分割するなら、なぜ彼らは一度だけ、それを分割しない

960
00:59:14,190 --> 00:59:19,970
そしてあなたは、グループ内の3と2を持っている？ [質問の不明朗な休息]

961
00:59:19,970 --> 00:59:24,940
理由は - 私たちはそれらを持って後にそう質問ですが、なぜ私たちはちょうどその最初のステップでそれらをマージすることはできません？

962
00:59:24,940 --> 00:59:29,530
我々がこれを行うことができます理由は、両側の一番左の要素から開始

963
00:59:29,530 --> 00:59:33,040
その後、小さい方を取ると、それを入れる我々はこれらを知っているということです

964
00:59:33,040 --> 00:59:35,290
個々のリストはソート順序になります。

965
00:59:35,290 --> 00:59:37,290
私は両方の半分の左端の要素を見ているのであれば、

966
00:59:37,290 --> 00:59:40,490
私は、彼らがそれらのリストの最小要素であることが分かっている。

967
00:59:40,490 --> 00:59:43,930
だから私はこの大規模なリストの最小の要素のスポットにそれらを置くことができます。

968
00:59:43,930 --> 00:59:47,810
一方、私はあそこに第2レベルにそれらの2つのリストを見れば、

969
00:59:47,810 --> 00:59:51,640
50、3、42、1337、15、それらはソートされません。

970
00:59:51,640 --> 00:59:55,770
私は50と1337を見ればだから、私は最初に私のリストに50を置くつもりです。

971
00:59:55,770 --> 01:00:00,130
しかし、それは本当に3はそれらのすべてのうち、最小の要素であるため、意味をなさない。

972
01:00:00,130 --> 01:00:04,390
だから我々はこの組み合わせステップを行うことができる唯一の​​理由は、私たちのリストがすでにソートされているためです。

973
01:00:04,390 --> 01:00:07,010
我々は底にすべての方法を取得する必要があります理由である

974
01:00:07,010 --> 01:00:09,800
私達はちょうど単一の番号を持っているときは、その単一の番号を知っているので、

975
01:00:09,800 --> 01:00:14,120
それ自体はすでにソートされたリストです。

976
01:00:14,120 --> 01:00:19,360
>> 何か質問？いいえ？

977
01:00:19,360 --> 01:00:24,260
複雑？さて、あなたは、各ステップでの終了番号があることがわかります

978
01:00:24,260 --> 01:00:27,590
そして我々は、ハーフログn回でリストを分割することができます

979
01:00:27,590 --> 01:00:31,700
私たちはこのN xのログn複雑さをどこで取得するそれはある。

980
01:00:31,700 --> 01:00:34,940
そして、あなたは、マージソートのための最良の場合はnログnで表示されます、そして、それはちょうどそう起こる

981
01:00:34,940 --> 01:00:39,340
最悪の場合、またはあそこΩは、もnはnをログに記録すること。

982
01:00:39,340 --> 01:00:42,480
心に留めておくべき何か。

983
01:00:42,480 --> 01:00:45,750
上を移動する、のはいくつかの超基本的なファイルI / Oに進みましょう

984
01:00:45,750 --> 01:00:48,830
あなたはスクランブルを見た場合は、我々はシステムのいくつかの並べ替えを持っていたことがわかります

985
01:00:48,830 --> 01:00:51,270
あなたがコードを通読したとすればどこにログ·ファイルに書き込むことができます。

986
01:00:51,270 --> 01:00:53,730
あなたはそれを行う方法を見てみましょう。

987
01:00:53,730 --> 01:00:57,450
さて、私たちは、あなただけのprintfのように考えることができる、fprintfを持っている

988
01:00:57,450 --> 01:01:01,720
しかし、まだ始まったばかりでfゆえではなく、ファイルに印刷します。

989
01:01:01,720 --> 01:01:07,570
あなたはスクランブルで見てきたかもしれないようにそれが何をするか、ここにこのコードのソートは、、、です

990
01:01:07,570 --> 01:01:12,310
それは数字が何であるかを、行ごとにプリントアウトあなたの2次元配列を通過します。

991
01:01:12,310 --> 01:01:17,850
このケースでは、printfの端末に出力しますか、我々は、セクションの標準出力と呼んでいるもの。

992
01:01:17,850 --> 01:01:22,170
>> そして今、このケースでは、我々がしなければならないすべては、fprintf関数でprintfを置き換えるだけです

993
01:01:22,170 --> 01:01:26,770
は、印刷したいものをファイルにそれを言うと、この場合には、それだけで、そのファイルに出力します

994
01:01:26,770 --> 01:01:32,230
代わりにあなたの端末にそれをプリントアウト。

995
01:01:32,230 --> 01:01:36,500
我々は、右からのファイルのこの種を入手できますか：じゃあ、質問しておきたいこと？

996
01:01:36,500 --> 01:01:39,840
我々は、この関数fprintfのfuctionにログインを渡さしかし我々はそれがどこから来た全くわからなかった。

997
01:01:39,840 --> 01:01:43,980
さて、初期のコードでは、私たちが持っていたことは、こっちのコードの塊であった

998
01:01:43,980 --> 01:01:48,340
基本的に開いているファイルがlog.txtに呼び出すことを言うている。

999
01:01:48,340 --> 01:01:53,220
つまり後に我々は何をすべきか、我々は、ファイルが実際には正常に開かれていることを確認する必要があります。

1000
01:01:53,220 --> 01:01:57,070
だから、複数の理由で失敗することがあります、あなたは、例えば、コンピュータに十分なスペースがありません。

1001
01:01:57,070 --> 01:01:59,790
あなたがファイルを使用して、任意の操作を行う前に、それは常に重要だ

1002
01:01:59,790 --> 01:02:03,300
私たちは、そのファイルが正常に開かれたかどうかを確認すること。

1003
01:02:03,300 --> 01:02:09,330
それでは、それはfopenの引数だと、まあ、我々は多くの方法でファイルを開くことができます。

1004
01:02:09,330 --> 01:02:13,510
我々はあるが何ができるか、私たちは、それが終了した場合、既にファイルを上書きすることを意味し、それをワットを渡すことができます

1005
01:02:13,510 --> 01:02:18,070
我々は、彼らが代わりにそれを上書きするファイルの末尾に追加され、aを渡すことができます。

1006
01:02:18,070 --> 01:02:22,730
または我々が意味rを指定することができます、のは読み取り専用としてファイルを開くことができます。

1007
01:02:22,730 --> 01:02:24,890
このプログラムは、ファイルへの変更を行おうとするのであれば

1008
01:02:24,890 --> 01:02:30,140
それらで叫ぶと彼らはそれを行うことはできません。

1009
01:02:30,140 --> 01:02:33,320
最後に、一度我々は、ファイルを使用して行うことで操作を行って完了です

1010
01:02:33,320 --> 01:02:35,860
我々はファイルを閉じることを確認する必要があります。

1011
01:02:35,860 --> 01:02:38,830
それで、あなたのプログラムの終了時に、それらを再度通過しようとしている

1012
01:02:38,830 --> 01:02:42,120
あなたが開いて、それを閉じることは、このファイル。

1013
01:02:42,120 --> 01:02:44,650
だから、これは、あなたが行うことを確認しなければならないことを何か重要なことです。

1014
01:02:44,650 --> 01:02:47,180
ですから、ファイルを開くことができます覚えて、あなたは、ファイルに書き込むことができます

1015
01:02:47,180 --> 01:02:51,270
ファイル内で操作を行うが、その時には終了時にファイルを閉じる必要があります。

1016
01:02:51,270 --> 01:02:53,270
>> 基本的なファイル上の任意の質問のI / O？はい？

1017
01:02:53,270 --> 01:02:58,050
[学生の質問、不明朗]

1018
01:02:58,050 --> 01:03:02,480
ここ。質問は、このlog.txtファイルはどこに表示されないのですか？

1019
01:03:02,480 --> 01:03:07,890
あなたはちょうどそれをlog.txtを与えればよく、それは実行ファイルと同じディレクトリに作成します。

1020
01:03:07,890 --> 01:03:10,500
だからyou'reなら -  >> [学生の質問、不明朗]

1021
01:03:10,500 --> 01:03:18,830
はい。同じフォルダ内、または同じディレクトリに、あなたがそれを呼び出すように。

1022
01:03:18,830 --> 01:03:21,400
今やメモリ、スタック、およびヒープ。

1023
01:03:21,400 --> 01:03:23,400
だからメモリは、コンピュータでどのようにレイアウトされている？

1024
01:03:23,400 --> 01:03:26,270
さて、あなたはここで、このブロックのようなものとしてメモリを想像することができます。

1025
01:03:26,270 --> 01:03:30,260
し、メモリ内では、我々は立ち往生ヒープ、およびそこにダウンだスタックと呼ば​​れるものを持っています。

1026
01:03:30,260 --> 01:03:34,480
とヒープが下に向かって伸びていくとスタックが上向きに生えています。

1027
01:03:34,480 --> 01:03:38,620
トミーは述べように - ああ、まあ、我々は私が2番目にに着くから、これらの他の4つのセグメントを持っている - 

1028
01:03:38,620 --> 01:03:42,890
トミーは先に述べたように、あなたは彼の関数は、それ自体を呼び出し、互いを呼び出す方法を知っている？

1029
01:03:42,890 --> 01:03:44,930
彼らは、スタックフレームのこの種を構築します。

1030
01:03:44,930 --> 01:03:47,360
さて、メインのコールfoo、fooがスタックに置かれる場合。

1031
01:03:47,360 --> 01:03:52,430
Fooが呼び出しバー、バーのはスタックに置か取得し、後にスタックに置かれることを。

1032
01:03:52,430 --> 01:03:57,040
彼らは返すようにと、彼らはそれぞれのスタックからだまされる。

1033
01:03:57,040 --> 01:04:00,140
これらの各場所とメモリは何を保持するか。

1034
01:04:00,140 --> 01:04:03,110
さて、テキストセグメントでトップは、プログラム自体が含まれています。

1035
01:04:03,110 --> 01:04:06,390
そこのマシンコード、SO、一度プログラムをコンパイルします。

1036
01:04:06,390 --> 01:04:08,520
次に、任意のグローバル変数を初期化しました。

1037
01:04:08,520 --> 01:04:12,660
>> だから、あなたはあなたのプログラムでグローバル変数を持っていて、= 5のように言う

1038
01:04:12,660 --> 01:04:15,260
その下に、そのセグメント、右に置かれることを、

1039
01:04:15,260 --> 01:04:18,990
あなたは、単にintである初期化されていないグローバルデータを持っている

1040
01:04:18,990 --> 01:04:20,990
しかし、あなたはそれが何かに等しいだとは言いません。

1041
01:04:20,990 --> 01:04:23,870
これらはグローバル変数なので、彼らがメインの外にいる実感。

1042
01:04:23,870 --> 01:04:28,560
だから、これは宣言されていますが、初期化されていないすべてのグローバル変数を意味します。

1043
01:04:28,560 --> 01:04:32,310
だからヒープに何があるのか​​？メモリは、我々は少しのに着くから、mallocを使用して、割り当てられた。

1044
01:04:32,310 --> 01:04:35,990
そして最後に、スタックとは、任意のローカル変数を持っている

1045
01:04:35,990 --> 01:04:39,950
任意の関数は、あなたはそれらのいずれかのパラメータで呼び出すことがあります。

1046
01:04:39,950 --> 01:04:43,720
最後のものは、あなたが本当に、環境変数が何をすべきかを知っている必要はありません

1047
01:04:43,720 --> 01:04:46,700
しかし、あなたがプログラムを実行するたびに、同じように、関連するものがある

1048
01:04:46,700 --> 01:04:49,550
これはプログラムを実行した人のユーザー名です。

1049
01:04:49,550 --> 01:04:51,550
そして、それは下部の一種になるだろう。

1050
01:04:51,550 --> 01:04:54,540
16進値ですメモリアドレスの面では、

1051
01:04:54,540 --> 01:04:58,170
0でトップスタート時の値、およびそれらは底にすべての道を下って行く。

1052
01:04:58,170 --> 01:05:00,440
この場合、あなたは、32ビットシステムを使っているのであれば、

1053
01:05:00,440 --> 01:05:05,390
下部のアドレスはそれが32ビットだから、AFが続く0xであることを行っている、

1054
01:05:05,390 --> 01:05:10,890
これは8バイトであり、この場合には8バイトには8桁の16進数に対応しています。

1055
01:05:10,890 --> 01:05:20,110
だからダウンここでは、のように、0xffffffのを持っているつもりですし、そこまでは、0を持っているつもりです。

1056
01:05:20,110 --> 01:05:23,660
だからポインタは何ですか？あなたのいくつかは、前のセクションでこれをカバーしていない可能性があります。

1057
01:05:23,660 --> 01:05:26,660
しかし、我々は講演でその上に行きましたので、ポインタは単にデータタイプです

1058
01:05:26,660 --> 01:05:34,030
どの店が、代わりに50のような値のいくつかの並べ替えのために、それは、メモリ内のいくつかの場所のアドレスを格納します。

1059
01:05:34,030 --> 01:05:36,020
そのメモリのように[理解不能]。

1060
01:05:36,020 --> 01:05:41,120
したがって、このケースでは、我々がしたこと、我々は、整数またはint *へのポインタを持っている

1061
01:05:41,120 --> 01:05:46,210
そしてそれは0xdeadbeefのこの16進アドレスが含まれています。

1062
01:05:46,210 --> 01:05:50,880
>> だから我々が持っているものを、メモリ内のいくつかの場所でこのポインタは、現在、ある

1063
01:05:50,880 --> 01:05:56,020
そしてそれはちょうどですが、値50は、このメモリの場所にあります。

1064
01:05:56,020 --> 01:06:01,810
いくつかの32ビットシステムでは、すべての32ビットシステムでは、ポインタは32ビットまたは4バイトを占有。

1065
01:06:01,810 --> 01:06:06,020
しかし、例えば、64ビットシステム上では、ポインタは64ビットです。

1066
01:06:06,020 --> 01:06:08,040
だから、それはあなたが心に留めておくことをお勧めします何かです。

1067
01:06:08,040 --> 01:06:12,310
だから最後ビットシステム上では、ポインタは長い端ビットです。

1068
01:06:12,310 --> 01:06:17,320
ポインタは、余分なものなしで消化するのは難しいの夫婦です

1069
01:06:17,320 --> 01:06:20,300
それでは、動的メモリ割り当ての例を挙げて行きましょう。

1070
01:06:20,300 --> 01:06:25,130
どのような動的なメモリ割り当てがあなたのために、または私達はmalloc関数と呼んでいるもの、

1071
01:06:25,130 --> 01:06:29,280
それはあなたがセット以外のデータのいくつかの並べ替えを割り当てることができます。

1072
01:06:29,280 --> 01:06:31,830
したがって、このデータはプログラムの期間のためのより永久的なの一種です。

1073
01:06:31,830 --> 01:06:36,430
あなたが知っているようので、あなたが関数の内部でx、およびその関数が復帰を宣言した場合、

1074
01:06:36,430 --> 01:06:40,910
あなたはもはやxに格納されたデータへのアクセスを持っていません。

1075
01:06:40,910 --> 01:06:44,420
私達は何のポインタをやってみましょう彼らは私たちがメモリまたはストアの値を格納できるようになり

1076
01:06:44,420 --> 01:06:46,840
つまりメモリの異なるセグメント、ヒープインチ

1077
01:06:46,840 --> 01:06:49,340
今一度、私たちは、限り、我々には、ポインタを持っているように、関数の外に戻す

1078
01:06:49,340 --> 01:06:54,960
メモリ内のその位置に、それから私達は何ができるかは、我々はちょうどそこの値を見ることができますです。

1079
01:06:54,960 --> 01:06:58,020
例を見てみましょう：これは再び我々のメモリレイアウトです。

1080
01:06:58,020 --> 01:07:00,050
そして、我々は主に、この機能を持っています。

1081
01:07:00,050 --> 01:07:06,870
何をするかが - 大丈夫、そう単純で、右 - ？int型のx = 5で、それはただのメインスタック上の変数です。

1082
01:07:06,870 --> 01:07:12,450
>> 一方、今、私たちは、関数を呼び出すgiveMeThreeIntsポインタを宣言します。

1083
01:07:12,450 --> 01:07:16,800
それで、今、私たちは、この関数に入ると、私たちはそのための新しいスタック·フレームを作成します。

1084
01:07:16,800 --> 01:07:20,440
しかし、このスタック·フレームに、我々はint * tempを宣言し、

1085
01:07:20,440 --> 01:07:23,210
私たちのためにmallocを3つの整数である。

1086
01:07:23,210 --> 01:07:25,880
だからint型の大きさは、このintがどのように多くのバイトを私たちに授けてくれます

1087
01:07:25,880 --> 01:07:29,620
とmallocはヒープ上のスペースの多くのバイトことを私たちに与えます。

1088
01:07:29,620 --> 01:07:32,890
したがって、このケースでは、我々は、3つの整数のための十分なスペースを作成しました

1089
01:07:32,890 --> 01:07:36,830
ヒープとは、私はそれを描いた理由の上位にあるそこまでの方法です。

1090
01:07:36,830 --> 01:07:42,900
我々が終わったら、我々はここに戻ってくるには、わずか3 intが返される必要があり、

1091
01:07:42,900 --> 01:07:47,000
そしてそれは、そのメモリがどこにあるの上に、この場合には、そのアドレスを返します。

1092
01:07:47,000 --> 01:07:51,250
そして、我々はポインタ=スイッチを設定し、そこまで我々はちょうど別のポインタを持っています。

1093
01:07:51,250 --> 01:07:54,550
しかし、どのような関数がリターンはここで積み重ねて消滅していること。

1094
01:07:54,550 --> 01:07:59,250
だからtempは消えますが、我々はまだのアドレスを維持

1095
01:07:59,250 --> 01:08:01,850
それらの3つの整数は、本管の内側にあります。

1096
01:08:01,850 --> 01:08:06,180
だから、このセットでは、ポインタは、積み重ねられたフレームのためにローカルスコープを持ちます

1097
01:08:06,180 --> 01:08:09,860
しかし、それらが参照するメモリがヒープにある。

1098
01:08:09,860 --> 01:08:12,190
>> それは意味をなさないか？

1099
01:08:12,190 --> 01:08:14,960
[学生]繰り返して頂けますか？ >> [ヨセフ]はい。

1100
01:08:14,960 --> 01:08:20,270
私は戻って少しだけ行けばそれで、あなたはtempが割り当てられていることがわかり

1101
01:08:20,270 --> 01:08:23,500
そこまでヒープ上のいくつかのメモリ。

1102
01:08:23,500 --> 01:08:28,680
だからときに、この関数、giveMeThreeIntsが戻るのは、ここでは、このスタックが消えるだろう。

1103
01:08:28,680 --> 01:08:35,819
そしてそれはこの場合の変数のいずれか、積み重ねられたフレームに割り当てられたこのポインタを持つ。

1104
01:08:35,819 --> 01:08:39,649
消えて行くが、我々は、tempを返したためであることを

1105
01:08:39,649 --> 01:08:46,330
そして我々は=気温、ポインタが今tempがあったように場所の同じメモリを指すように起こっているのポインタを設定します。

1106
01:08:46,330 --> 01:08:50,370
だから今、私たちは一時、その地方のポインタを、失うにもかかわらず、

1107
01:08:50,370 --> 01:08:59,109
我々はまだそれがその変数のポインタの内側を指していたもののメモリアドレスを保持します。

1108
01:08:59,109 --> 01:09:03,740
質問はありますか？あなたはセクションでその上に行っていないなら、それは混乱トピックのようなものにすることができます。

1109
01:09:03,740 --> 01:09:09,240
我々は、あなたのタスクフォースは、間違いなくその上を行くことができますし、もちろん我々は質問に答えることができます。

1110
01:09:09,240 --> 01:09:11,500
これについてのレビューセッションの終了時。

1111
01:09:11,500 --> 01:09:14,220
しかし、これは複雑なトピックのようなものである、と私は現れるとしているより多くの例を持っている

1112
01:09:14,220 --> 01:09:18,790
そのポインタが実際に何であるか明確にするのに役立ちます。

1113
01:09:18,790 --> 01:09:22,500
>> この場合、ポインタは、配列に相当します

1114
01:09:22,500 --> 01:09:25,229
ので、私はint型の配列と同じもののように、このポインタを使用することができます。

1115
01:09:25,229 --> 01:09:29,840
だから私は、0にインデックスを付けると、1に最初の整数を変更している

1116
01:09:29,840 --> 01:09:39,689
2番目の整数を変更して、3〜第三整数。

1117
01:09:39,689 --> 01:09:44,210
ポインタに対するので、より多くの。まあ、BINKY思い出す。

1118
01:09:44,210 --> 01:09:48,319
この場合において、我々はポインタを割り当てた、または私達はポインタを宣言

1119
01:09:48,319 --> 01:09:52,760
しかし当初は、私はちょうどポインタを宣言したとき、それはメモリのどこを指しているわけではありません。

1120
01:09:52,760 --> 01:09:54,930
それはそれの内側にちょうどゴミの値です。

1121
01:09:54,930 --> 01:09:56,470
だから私は、このポインタが指して見当がつかない。

1122
01:09:56,470 --> 01:10:01,630
それだけで0と1のそれを最初に宣言された場所で満たされているアドレスを持っています。

1123
01:10:01,630 --> 01:10:04,810
私はそれに、malloc（）を呼び出すまで、私はこれで何もできない

1124
01:10:04,810 --> 01:10:08,390
そしてそれは私に私が内に値を入れることができ、ヒープ上のわずかなスペースを提供します。

1125
01:10:08,390 --> 01:10:11,980
その後、再び、私はこのメモリの中身を知りません。

1126
01:10:11,980 --> 01:10:16,780
だから私がしなければならない最初のことは、システムが十分なメモリを持っていたかどうかチェックすることです

1127
01:10:16,780 --> 01:10:20,850
私がこのチェックをやっている理由は、最初の場所では、1の整数をお返しします。

1128
01:10:20,850 --> 01:10:25,020
ポインタがnullである場合、それは、それは十分なスペースまたは他のエラーが発生しましたを持っていなかったことを意味します

1129
01:10:25,020 --> 01:10:26,320
ので、私は私のプログラムを終了する必要があります。

1130
01:10:26,320 --> 01:10:29,400
 それが成功した場合しかし、今私はそのポインタを使用することができます

1131
01:10:29,400 --> 01:10:35,020
と何*ポインタが行うことは住所がどこにあるか、それが以下の通りである

1132
01:10:35,020 --> 01:10:38,480
その値があり、それは1に等しく、それを設定している場所へ。

1133
01:10:38,480 --> 01:10:41,850
そのメモリが存在していればだからここに、私達はチェックしています。

1134
01:10:41,850 --> 01:10:45,380
>> あなたはそれが存在することを知ったら、あなたはそれに置くことができる

1135
01:10:45,380 --> 01:10:50,460
この場合1で、あなたはそれに入れたいものの値。

1136
01:10:50,460 --> 01:10:53,060
我々はそれに終わったら、そのポインタを解放する必要が

1137
01:10:53,060 --> 01:10:57,160
私たちは、あなたが最初の場所で求めていることをシステムメモリに戻って取得する必要があるためです。

1138
01:10:57,160 --> 01:10:59,690
コンピュータは我々がそれを行っているときにわからないため。

1139
01:10:59,690 --> 01:11:02,510
このケースでは、明示的にそれを言っている、大丈夫、私たちはそのメモリの作業は終了です。

1140
01:11:02,510 --> 01:11:10,780
他のプロセスがそれを必要とする場合、いくつかの他のプログラムがそれを必要とする、先に行くとそれを取ること自由に感じなさい。

1141
01:11:10,780 --> 01:11:15,110
私たちにも出来ることは我々がちょうどセットでのローカル変数のアドレスを取得できています。

1142
01:11:15,110 --> 01:11:19,080
だからint型のxはメインの積層フレームの内側です。

1143
01:11:19,080 --> 01:11:23,060
そして、我々はこのアンパサンドを使用する場合、このオペレータは、それが何をするかである

1144
01:11:23,060 --> 01:11:27,310
それはxを取り、xは、メモリ内のちょうどいくつかのデータですが、それはアドレスを持っています。

1145
01:11:27,310 --> 01:11:33,790
それはどこかに位置している。これが何を呼び出し＆xは、あるので、それによっては、私たちにxのアドレスを与えます。

1146
01:11:33,790 --> 01:11:38,430
これを行うことによって、我々は、xがメモリのどこにあるかへのポインタポイントを作っている。

1147
01:11:38,430 --> 01:11:41,710
今、私たちは、* xが、我々は5バックを得ようとしているような何かを行うだけ。

1148
01:11:41,710 --> 01:11:43,820
星はそれを間接参照と呼ばれます。

1149
01:11:43,820 --> 01:11:46,640
あなたの住所だけに続く、あなたがそこに格納されてそれの値を取得します。

1150
01:11:51,000 --> 01:11:53,310
>> 何か質問？はい？

1151
01:11:53,310 --> 01:11:56,500
あなたは3尖っ事をしない場合は[学生]は、それはまだコンパイルしますか？

1152
01:11:56,500 --> 01:11:59,490
はい。あなたは3ポイントの事をしない場合、それはまだ、コンパイルするために起こっている

1153
01:11:59,490 --> 01:12:02,720
しかし、私は、第二で何が起こるかを示して、それを実行せずによ

1154
01:12:02,720 --> 01:12:04,860
それは我々がメモリリークと呼んでいるものです。は、システムを与えていない

1155
01:12:04,860 --> 01:12:07,850
そのメモリをバックアップしますので、後にプログラムは蓄積しようとしている間に

1156
01:12:07,850 --> 01:12:10,940
それは使用しておらず、他に何もないということメモリがそれを使用することができます。

1157
01:12:10,940 --> 01:12:15,750
あなたがあなたのコンピュータ上の150万キロバイトでFirefoxを見てきた場合は、

1158
01:12:15,750 --> 01:12:17,840
タスクマネージャで、それは何が起こっているのだ。

1159
01:12:17,840 --> 01:12:20,760
あなたは彼らが処理していないことをプログラムでメモリリークが発生している。

1160
01:12:23,080 --> 01:12:26,240
それでは、どのようにポインタ演算の仕組みを教えてください。

1161
01:12:26,240 --> 01:12:29,480
まあ、ポインタ演算は配列に似たインデックスの並べ替えです。

1162
01:12:29,480 --> 01:12:36,370
この場合、私はポインタを持っており、私は何を、私は最初の要素へのポインタポイントを作ることです

1163
01:12:36,370 --> 01:12:42,100
私が割り当てられてきた3つの整数の配列で。

1164
01:12:42,100 --> 01:12:46,670
だから今私は何をすべきか、スターポインタは単にリスト内の最初の要素を変更します。

1165
01:12:46,670 --> 01:12:49,140
こっちスターポインタが1点。

1166
01:12:49,140 --> 01:12:53,140
そのポインタがここの上にある、ポインタ1はこっちですが、ポインタ2はこっちです。

1167
01:12:53,140 --> 01:12:56,610
>> だから1を追加すると、この配列に沿って移動することと同じです。

1168
01:12:56,610 --> 01:12:59,880
我々が行うことであり、我々はポインタ1を行うときには、こっちのアドレスを取得

1169
01:12:59,880 --> 01:13:04,180
そしてここでの値を取得するためには、式全体からのスターを置く

1170
01:13:04,180 --> 01:13:05,990
間接参照してください。

1171
01:13:05,990 --> 01:13:09,940
したがって、この場合、私は、これを1に、配列内の最初の位置を設定してい

1172
01:13:09,940 --> 01:13:13,970
2〜第二の位置、および3に、第3の場所。

1173
01:13:13,970 --> 01:13:18,180
その後、私はこっちのやっていることを、私は私達のポインターを1、印字していますです

1174
01:13:18,180 --> 01:13:19,970
それはちょうど私に2を与える。

1175
01:13:19,970 --> 01:13:23,650
今、私はポインタをインクリメントしているので、ポインタはポインタ1に等しい

1176
01:13:23,650 --> 01:13:26,780
その前方に移動します。

1177
01:13:26,780 --> 01:13:30,810
それで今私はポインタ1をプリントアウトした場合、ポインタ1は、現在3です

1178
01:13:30,810 --> 01:13:33,990
このケースではそれは3を出力します。

1179
01:13:33,990 --> 01:13:36,560
と順番にフリー何か、私はそれを与えるポインタへ

1180
01:13:36,560 --> 01:13:40,540
私はmalloc関数から戻ってきた配列の先頭を指している必要があります。

1181
01:13:40,540 --> 01:13:43,430
私はここ3を呼び出すことがあったので、もしこのケースでは、これは、正しいことではないでしょう

1182
01:13:43,430 --> 01:13:45,070
それは配列の途中のだから。

1183
01:13:45,070 --> 01:13:48,820
私は元の場所に到達するために引き算する必要があり

1184
01:13:48,820 --> 01:13:50,420
私はそれを解放する前に初期の最初のスポット。

1185
01:13:56,300 --> 01:13:58,450
だから、ここにはもっと複雑な例です。

1186
01:13:58,450 --> 01:14:03,360
この場合において、我々は文字配列内の7文字を割り当てています。

1187
01:14:03,360 --> 01:14:06,480
>> この場合には我々がやっていることは、我々は彼らの最初の6をループしている

1188
01:14:06,480 --> 01:14:09,900
そして我々はZにそれらを設定している

1189
01:14:09,900 --> 01:14:13,350
だから、int型のi = 0、i>の6、i + +は、

1190
01:14:13,350 --> 01:14:16,220
だから、ポインタ+ iは、ちょうど私達を与えるだろう、この場合には、

1191
01:14:16,220 --> 01:14:20,860
ポインタ、ポインタ1、ポインタ2、ポインタ3などなどループインチ

1192
01:14:20,860 --> 01:14:24,040
それは何をするつもりなのは、それが値を取得するために、間接参照を、そのアドレスを取得している

1193
01:14:24,040 --> 01:14:27,440
Zにして変化する値

1194
01:14:27,440 --> 01:14:30,350
それから、末尾に右、これは文字列であることを覚えている？

1195
01:14:30,350 --> 01:14:33,560
すべての文字列はNULL終端文字で終了する必要があります。

1196
01:14:33,560 --> 01:14:38,620
だから、私は何をすると、ポインタが6で、私はインチヌル終端文字を入れています

1197
01:14:38,620 --> 01:14:43,980
そして今、私は基本的にはこっちにやっていることは、文字列をprintfの権利を実施しています？

1198
01:14:43,980 --> 01:14:46,190
>> だから、ときにprintfの今では、文字列の末尾に達していない場合？

1199
01:14:46,190 --> 01:14:48,230
それがnull終端文字を打つとき。

1200
01:14:48,230 --> 01:14:52,030
だから、この場合には、この配列の先頭への私の元のポインタを指しています。

1201
01:14:52,030 --> 01:14:56,410
私は、最初の文字をプリントアウト。私はいずれかの上に移動します。

1202
01:14:56,410 --> 01:14:58,420
私はその文字をプリントアウトする。私はそれを上に移動します。

1203
01:14:58,420 --> 01:15:02,180
そして私は私が最後に到達するまでこれを続けさせている。

1204
01:15:02,180 --> 01:15:07,750
そして今、終わり*ポインタデリファレンスこの意志とヌル終端文字を取り戻す。

1205
01:15:07,750 --> 01:15:11,780
ので、私のwhileループは、その値がNULL終端文字でない場合にのみ実行されます。

1206
01:15:11,780 --> 01:15:13,770
だから、今私はこのループの外に出る。

1207
01:15:18,780 --> 01:15:21,180
そして私は、このポインタから6を引く場合

1208
01:15:21,180 --> 01:15:22,860
私は初めに戻ってすべての道を行く。

1209
01:15:22,860 --> 01:15:27,880
私はそれを解放するために先頭に移動する必要があるので覚えておいて、私はこれをやっている。

1210
01:15:27,880 --> 01:15:30,270
>> だから、私はたくさんあったことを知っている。何か質問はありますか？

1211
01:15:30,270 --> 01:15:31,870
はい、お願いします？

1212
01:15:31,870 --> 01:15:36,610
[学生の質問不明朗]

1213
01:15:36,610 --> 01:15:38,190
あなたは大声でそれを言うことができますか？申し訳ありません。

1214
01:15:38,190 --> 01:15:44,140
[学生]は、ポインタを解放する直前に最後のスライドでは、

1215
01:15:44,140 --> 01:15:47,300
どこにあなたが実際にポインタの値を変えていた？

1216
01:15:47,300 --> 01:15:50,370
[ヨセフ]だから、まさにここ。 >> [生徒]ああ、大丈夫。

1217
01:15:50,370 --> 01:15:51,890
[ジョセフ]だから、私は右、ポインタマイナスマイナスを持って、

1218
01:15:51,890 --> 01:15:54,140
これは、私はそれを解放してから再び一つを移動させ、

1219
01:15:54,140 --> 01:15:57,000
このポインタは、配列の先頭に指摘されなければならないので。

1220
01:15:57,000 --> 01:16:00,420
あなたがその行の後に停止していた[学生]しかし、必要とされないであろうこと。

1221
01:16:00,420 --> 01:16:03,130
[ヨセフ]私はこの後に停止していた場合だから、これはメモリリークがあると考えられるでしょう、

1222
01:16:03,130 --> 01:16:04,810
私は自由を実行しなかったため。

1223
01:16:04,810 --> 01:16:11,290
[学生]は、[理解不能]ポインタ1を持っていた最初の三つの行の後に私は[理解不能]。

1224
01:16:11,290 --> 01:16:13,140
[ヨセフ]うーむ。だから、そこの質問は何ですか？

1225
01:16:13,140 --> 01:16:14,780
申し訳ありません。ノー、ノー。してください、行く、行く。

1226
01:16:14,780 --> 01:16:16,870
[学生]だから、あなたは、ポインタの値を変更していない。

1227
01:16:16,870 --> 01:16:19,130
あなたは、ポインタマイナスマイナスをしなければならなかったことはなかっただろう。

1228
01:16:19,130 --> 01:16:19,730
[ヨセフ]はい、その通りです。

1229
01:16:19,730 --> 01:16:21,890
だから、私はポインタ1とポインタ2を実行した場合、

1230
01:16:21,890 --> 01:16:24,410
私はポインタをやっていないよと、ポインタ1に等しい。

1231
01:16:24,410 --> 01:16:27,260
だから、ポインタは単に配列の先頭を指したままです。

1232
01:16:27,260 --> 01:16:31,460
それは、それがポインタの内側に戻って値を設定することを私はプラスやるときだけだプラス

1233
01:16:31,460 --> 01:16:33,550
それは実際に沿ってこれを移動すること。

1234
01:16:36,860 --> 01:16:37,780
かしこまりました。

1235
01:16:40,550 --> 01:16:42,030
多くの質問？

1236
01:16:44,680 --> 01:16:47,790
>> これが圧倒的なの一種である場合は、再度、これは、セッションで説明します。

1237
01:16:47,790 --> 01:16:50,710
それについてあなたのティーチング·フェローを聞いて、私たちは最後に質問に答えることができます。

1238
01:16:53,510 --> 01:16:56,600
そして通常、我々は、このマイナスのことを行うには好きではありません。

1239
01:16:56,600 --> 01:16:59,760
これは私が、私は配列内のオフセット自分がどれほどのを追跡する必要があります。

1240
01:16:59,760 --> 01:17:04,520
だから、一般的に、これは単なるポインタ演算がどのように機能するかを説明することです。

1241
01:17:04,520 --> 01:17:07,970
しかし、私たちが普段やりたいことは、我々はポインタのコピーを作成したいのです

1242
01:17:07,970 --> 01:17:11,640
我々は文字列内での移動しているときに、それから私達は、そのコピーを使用します。

1243
01:17:11,640 --> 01:17:14,660
したがって、これらの場合には、文字列全体を印刷するためにコピーを使用し、

1244
01:17:14,660 --> 01:17:19,040
しかし、我々は、ポインタマイナス6のようにしなければならないか、我々はこれで移動どのくらいを追跡しません

1245
01:17:19,040 --> 01:17:22,700
ちょうど私達が私達の原点がまだリストの最初に指摘されていることを知っているので、

1246
01:17:22,700 --> 01:17:25,340
そして私たちは変更したすべては、このコピーであった。

1247
01:17:25,340 --> 01:17:28,250
だから、一般的には、元のポインタのコピーを変更します。

1248
01:17:28,250 --> 01:17:32,350
等でソートしようとしないでください - 無関心は、元のコピーを変更します。

1249
01:17:32,350 --> 01:17:35,290
あなたのオリジナルのコピーのみを変更しようとしています。

1250
01:17:41,540 --> 01:17:44,870
我々は、printfに文字列を渡すときだから、あなたは気付く

1251
01:17:44,870 --> 01:17:48,990
あなたは、私たちは他のすべての間接参照でやったようにそれの前に星を置く権利を持っていないのですか？

1252
01:17:48,990 --> 01:17:54,180
あなたは全体の文字列％sが期待するプリントアウトでないと、アドレスです

1253
01:17:54,180 --> 01:17:57,610
文字の配列のように、この場合のポインタ、またはこの場合インチ

1254
01:17:57,610 --> 01:18:00,330
>> 文字は、char * s、および配列は同じものです。

1255
01:18:00,330 --> 01:18:03,690
ポインタが文字になり、文字配列は同じものです。

1256
01:18:03,690 --> 01:18:05,720
それで、我々がしなければならないすべては、ポインタを渡している。

1257
01:18:05,720 --> 01:18:08,150
私たちは、*ポインタ、またはそのような何かのように通過する必要はありません。

1258
01:18:13,110 --> 01:18:14,930
だから、配列とポインタは同じものです。

1259
01:18:14,930 --> 01:18:19,160
あなたはこっち配列のx [y]のような何かをやっているときに、

1260
01:18:19,160 --> 01:18:21,960
何それはフードの下でやっているのは大丈夫、それは、文字配列だが、それを言ってるのさ

1261
01:18:21,960 --> 01:18:23,690
ので、それはポインタだ。

1262
01:18:23,690 --> 01:18:26,510
それでxは、同じものです

1263
01:18:26,510 --> 01:18:28,650
ので、それが何をするかは、それがxにyを加算している

1264
01:18:28,650 --> 01:18:31,820
そんなにメモリに前進と同じものはどれですか。

1265
01:18:31,820 --> 01:18:34,930
そして今、x + yは、私達に住所のいくつかの並べ替えを与える

1266
01:18:34,930 --> 01:18:37,570
そして我々はアドレスを間接参照するか、または矢印をたどる

1267
01:18:37,570 --> 01:18:41,640
どこにメモリ内のその場所であり、我々は、メモリ内のその場所から値を取得します。

1268
01:18:41,640 --> 01:18:43,720
だからので、これらの2つはまったく同じものです。

1269
01:18:43,720 --> 01:18:45,840
それはただのシンタックスシュガーです。

1270
01:18:45,840 --> 01:18:48,090
彼らは同じことを行う。彼らはお互いのためにちょうど別の統語論だ。

1271
01:18:51,500 --> 01:18:57,590
>> だから、ポインタで何が間違って行くことができますか？ロット、のような。オーケー。だから、悪い事。

1272
01:18:57,590 --> 01:19:02,410
あなたのmallocコールが右、nullが返された場合、あなたが行うことができますいくつかの悪いことが確認されていません？

1273
01:19:02,410 --> 01:19:06,560
このケースでは、私は私を与えるために、システムを求めている - その数は何ですか？

1274
01:19:06,560 --> 01:19:11,200
整数のサイズが4バイトであるため、2億回4拍手。

1275
01:19:11,200 --> 01:19:13,810
私は8億バイトと同じようにそれを求めています。

1276
01:19:13,810 --> 01:19:17,270
もちろん、私のコンピュータは私に多くのメモリバックを与えることになるではありません。

1277
01:19:17,270 --> 01:19:20,960
これがnullの場合、我々は我々があそこに逆参照しようとするので、チェックしませんでした - 

1278
01:19:20,960 --> 01:19:24,270
それがために起こっている場所にある矢印をたどる - 私たちはそのメモリを持っていない。

1279
01:19:24,270 --> 01:19:27,150
これは、我々はnullポインタを間接参照と呼んでいます。

1280
01:19:27,150 --> 01:19:29,710
そして、これは本質的にはセグメンテーションフォルトします。

1281
01:19:29,710 --> 01:19:31,790
これは、セグメンテーションフォルトができる方法の一つです。

1282
01:19:34,090 --> 01:19:38,090
あなたが行うことができ、他の悪い事 - まあいい。

1283
01:19:38,090 --> 01:19:40,650
それはnullポインタを間接参照しました。オーケー。

1284
01:19:40,650 --> 01:19:45,160
他の悪いことは - まあ、あなたはただそこにチェックを入れてこれを修正するには

1285
01:19:45,160 --> 01:19:46,980
そのポインタがnullであるかどうかをチェック

1286
01:19:46,980 --> 01:19:51,000
それはmallocはNULLポインタを返すことが起こるなら、プログラムを終了する。

1287
01:19:55,110 --> 01:19:59,850
それはXKCD漫画だ。人々は今それを理解する。のようなもの。

1288
01:20:06,120 --> 01:20:09,350
>> だから、メモリ。そして、私はこの上に行きました。

1289
01:20:09,350 --> 01:20:12,000
我々は、ループ内でmallocを呼び出すが、私たちは、malloc（）を呼び出すたびにしている

1290
01:20:12,000 --> 01:20:14,370
我々は、このポインタが指している場所を追跡を失っている

1291
01:20:14,370 --> 01:20:15,750
我々はそれを追い払っているので。

1292
01:20:15,750 --> 01:20:18,410
だから、malloc関数の最初の呼び出しは、私にこっちにメモリを提供します。

1293
01:20:18,410 --> 01:20:19,990
これに対する私のポインタのポインタ。

1294
01:20:19,990 --> 01:20:23,020
今、私はそれを解放しないので、今、私は再び、malloc（）を呼び出します。

1295
01:20:23,020 --> 01:20:26,070
今度はこっちに指摘している。今、私の記憶がこっちに向いている。

1296
01:20:26,070 --> 01:20:27,640
ここに上でポインティング。ここに上でポインティング。

1297
01:20:27,640 --> 01:20:31,820
しかし、私が割り当てられたことをこっちにすべてのメモリのアドレスのトラックを失ってしまった。

1298
01:20:31,820 --> 01:20:35,100
そして今私はもはやそれへの参照を持っていない。

1299
01:20:35,100 --> 01:20:37,230
だから、私はこのループの外にそれらを解放することはできません。

1300
01:20:37,230 --> 01:20:39,390
ので、このような何かを修正するために、

1301
01:20:39,390 --> 01:20:42,250
あなたは、メモリを解放することを忘れており、このメモリリークを得れば、

1302
01:20:42,250 --> 01:20:45,810
あなたは、あなたがそれで終わったら、このループの内側にメモリを解放する必要があります。

1303
01:20:45,810 --> 01:20:51,400
まあ、これは何が起こるかです。私はあなたの多くはこれを嫌い知っている。

1304
01:20:51,400 --> 01:20:55,270
しかし、今 - イェーイ！あなたは44000キロバイトのように得る。

1305
01:20:55,270 --> 01:20:57,110
だから、あなたは、ループの最後でそれを解放

1306
01:20:57,110 --> 01:20:59,770
それは単にメモリを毎回解放するだろう。

1307
01:20:59,770 --> 01:21:03,620
本質的に、あなたのプログラムは、もはやメモリリークを持っていません。

1308
01:21:03,620 --> 01:21:08,150
>> そして今、あなたがすることができる何か他のものを使用すると、二回求めてきたいくつかのメモリを解放しています。

1309
01:21:08,150 --> 01:21:11,060
このケースでは、mallocの何かするときには、その値を変更します。

1310
01:21:11,060 --> 01:21:13,140
あなたはあなたがそれを用いて行われたと言ったので、あなたが一度それを解放します。

1311
01:21:13,140 --> 01:21:14,940
しかし、その後、我々は再びそれを解放した。

1312
01:21:14,940 --> 01:21:16,730
これは非常に残念だ何かである。

1313
01:21:16,730 --> 01:21:18,820
それは、最初にセグメンテーション違反にはならないだろう

1314
01:21:18,820 --> 01:21:23,350
しかし後にこれが何をするかしばらく二重、これが壊れるあなたのヒープ構造を解放している

1315
01:21:23,350 --> 01:21:27,200
あなたはCS61のようなクラスを取ることを選択した場合、あなたはこのことについてもう少し学びます。

1316
01:21:27,200 --> 01:21:30,000
しかし、本質的に後にコンピュータが混乱しようとしている間に

1317
01:21:30,000 --> 01:21:33,010
どことどこでそれが格納されていることについて、メモリの場所は - 

1318
01:21:33,010 --> 01:21:34,800
どこにデータがメモ​​リに保存されます。

1319
01:21:34,800 --> 01:21:38,080
それでポインタの解放は、二回あなたがやりたくないことを悪いことだ。

1320
01:21:38,080 --> 01:21:41,600
>> 間違って行くことができます他のものは、sizeofを使用していません。

1321
01:21:41,600 --> 01:21:44,460
したがって、このケースでは、8バイトのmalloc

1322
01:21:44,460 --> 01:21:46,700
それは2つの整数、右側と同じものですか？

1323
01:21:46,700 --> 01:21:49,580
だから、それは完全に安全だが、それですか？

1324
01:21:49,580 --> 01:21:52,160
まあ、ルーカスが異なったアーキテクチャでの話として、

1325
01:21:52,160 --> 01:21:54,220
整数は長さが異なる。

1326
01:21:54,220 --> 01:21:57,970
だから、あなたが使用しているアプライアンスでは、整数は4バイト程度である、

1327
01:21:57,970 --> 01:22:02,370
しかし、いくつかの他のシステムでは、それらは8バイトになるか、またはそれらは16バイトであるかもしれません。

1328
01:22:02,370 --> 01:22:05,680
だから、私はちょうどここの上にこの番号を使用する場合

1329
01:22:05,680 --> 01:22:07,310
このプログラムは、アプライアンス上で動作するかもしれない

1330
01:22:07,310 --> 01:22:10,360
それはいくつかの他のシステムに十分なメモリを割り当てることはないだろう。

1331
01:22:10,360 --> 01:22:14,020
このケースでは、これはsizeof演算子が何に使用されるかである。

1332
01:22:14,020 --> 01:22:16,880
私たちは、これがされて何をするかはsizeof（int）を呼び出すと、

1333
01:22:16,880 --> 01:22:21,910
 それは私たちにプログラムが実行されているシステム上の整数のサイズを示します。

1334
01:22:21,910 --> 01:22:25,490
したがって、この場合は、sizeof（int）は、アプライアンスのような何かに4を返します

1335
01:22:25,490 --> 01:22:29,980
8で、今、この意志4 * 2、

1336
01:22:29,980 --> 01:22:32,330
これは、ちょうど2つの整数のために必要なスペースの量です。

1337
01:22:32,330 --> 01:22:36,710
異なるシステム上で、intは16バイトまたは8バイトのようであれば、

1338
01:22:36,710 --> 01:22:39,380
それだけでその量を格納するのに十分なバイト数を返すことになるだろう。

1339
01:22:41,830 --> 01:22:45,310
>> そして最後に、構造体。

1340
01:22:45,310 --> 01:22:48,340
だから、あなたは、メモリに数独ボードを保持したい場合、どのように我々はこれを行うのでしょうか？

1341
01:22:48,340 --> 01:22:51,570
あなたは、最初のもののための変数と同じように考えるかもしれない

1342
01:22:51,570 --> 01:22:53,820
第二のもののための変数、第三のもののための変数、

1343
01:22:53,820 --> 01:22:56,420
第四事のための変数 - 悪い、右か？

1344
01:22:56,420 --> 01:23:00,750
だから、あなたがこの上に作ることができる1改善は9×9の配列を作ることです。

1345
01:23:00,750 --> 01:23:04,480
それはいいですが、あなたは数独ボードと他の事を関連付けるために望んでいる場合

1346
01:23:04,480 --> 01:23:06,490
は、ボードの難しさとは何か好き

1347
01:23:06,490 --> 01:23:11,740
または、例えば、あなたのスコアは何であるか、どのくらいの時間、それはあなたがこのボードを解決するために取ってきて？

1348
01:23:11,740 --> 01:23:14,970
さて、何を行うことができます使用すると、構造体を作成できることです。

1349
01:23:14,970 --> 01:23:18,910
私は基本的に言っていることは、私はここの上でこの構造を定義していますです

1350
01:23:18,910 --> 01:23:23,230
と私は、9×9であるオンボードで構成されています数独ボードを定義しています。

1351
01:23:23,230 --> 01:23:26,650
>> そして、何それはレベルの名前へのポインタを持っています。

1352
01:23:26,650 --> 01:23:30,730
また、私は今どこにいるの座標xとyを持っています。

1353
01:23:30,730 --> 01:23:35,980
また、時間が[理解不能]を費やしてきた、そしてそれは私がこれまでに入力した移動操作の総数を持っています。

1354
01:23:35,980 --> 01:23:40,010
ので、この場合には、私はちょうど1つの構造体にデータの全体の束をまとめることができます

1355
01:23:40,010 --> 01:23:42,790
代わりに別の変数のように飛んでのようにそれを持っていることの

1356
01:23:42,790 --> 01:23:44,540
私は本当に幅を把握することはできません。

1357
01:23:44,540 --> 01:23:49,720
そして、これは私たちは、この構造体の内部に別のものを参照するのソートのためだけの素敵な構文を持つことができます。

1358
01:23:49,720 --> 01:23:53,430
私はちょうどboard.boardを行うことができます、そして、私は数独ボードを取り戻す。

1359
01:23:53,430 --> 01:23:56,320
Board.level、私はそれがどのように厳しい態度を取る。

1360
01:23:56,320 --> 01:24:00,540
Board.xとboard.yは私がボー​​ドにあるかもしれない場所の座標を与える。

1361
01:24:00,540 --> 01:24:04,730
そして、私は我々が構造体のフィールドと呼んでいるものにアクセスしています。

1362
01:24:04,730 --> 01:24:08,840
これは私が持っているタイプですsudokuBoardを定義します。

1363
01:24:08,840 --> 01:24:14,800
そして今、我々はここにいる。私はタイプsudokuBoardの "ボード"と呼ばれる変数を持っています。

1364
01:24:14,800 --> 01:24:18,820
それで今、私はこっち、この構造体を構成するすべてのフィールドにアクセスすることができます。

1365
01:24:20,830 --> 01:24:22,450
>> 構造体について何か質問はありますか？はい？

1366
01:24:22,450 --> 01:24:25,890
int型のx、yについては、[学生]は、1行に両方の宣言？ >> [ヨセフ]うーむ。

1367
01:24:25,890 --> 01:24:27,400
[学生]だから、あなたは、単にそれらのすべてでそれを行うことができる？

1368
01:24:27,400 --> 01:24:31,200
x、yのコンマ倍合計で好きですか？

1369
01:24:31,200 --> 01:24:34,460
[ヨセフ]はい、あなたは間違いなくそれを行うが、私は同じ行にxとyを置くことができる理由 - 

1370
01:24:34,460 --> 01:24:36,330
我々だけで、同じ行にこれを行うことができますなぜ、質問はありますか？

1371
01:24:36,330 --> 01:24:38,600
なぜ我々はちょうどある同じ行に、これらのすべてを入れてはいけません

1372
01:24:38,600 --> 01:24:42,090
xとyは互いに関連している、

1373
01:24:42,090 --> 01:24:44,780
これは、ある意味では、単に文体より正しいです

1374
01:24:44,780 --> 01:24:46,600
それは、同じ回線上の2つの事柄をグループ化だので、

1375
01:24:46,600 --> 01:24:49,340
のようなソートは同じ事に関連しています。

1376
01:24:49,340 --> 01:24:51,440
そして私はちょうど離れてこれらを分割します。それはスタイルだけのことだ。

1377
01:24:51,440 --> 01:24:53,720
それは、機能的には全く違いはありません。

1378
01:24:58,150 --> 01:24:59,270
構造体で他に質問は？

1379
01:25:03,030 --> 01:25:06,620
あなたは、structと図鑑を定義することができます。

1380
01:25:06,620 --> 01:25:11,720
ポケモンの数を持っており、それが手紙、所有者、型を持っています。

1381
01:25:11,720 --> 01:25:16,990
あなたはポケモンの配列を持っている場合、その後、あなたは正しい、図鑑を作ることができますか？

1382
01:25:16,990 --> 01:25:20,810
さて、涼しい。だから、構造体についての質問。それらは、構造体に関連しています。

1383
01:25:20,810 --> 01:25:25,270
>> 最後に、GDB。 GDBは、あなたが何をできるのですか？それはあなたのプログラムをデバッグすることができます。

1384
01:25:25,270 --> 01:25:27,650
GDBを使用していないならば、私はショートを見てお勧めしたい

1385
01:25:27,650 --> 01:25:31,250
そしてただ、あなたがそれをどのように動作するか、どのようにそれを使用するかもしれないされているもの、GDB上に行く、

1386
01:25:31,250 --> 01:25:32,900
とプログラムにそれをテストします。

1387
01:25:32,900 --> 01:25:37,400
それで、GDBはあなたが行うことができますどのように処理し、休止[理解不能]アッププログラムで次のことができますです

1388
01:25:37,400 --> 01:25:38,920
そして実用的なライン。

1389
01:25:38,920 --> 01:25:42,600
たとえば、私は、私のプログラムの3行目のように実行を一時停止したい

1390
01:25:42,600 --> 01:25:46,010
私は3行目にいる間、私はそこに存在するすべての値をプリントアウトすることができます。

1391
01:25:46,010 --> 01:25:49,710
そして私たちはラインで一時停止のように呼んでいるもの

1392
01:25:49,710 --> 01:25:52,350
我々は、これはその行にブレークポイントを入れて呼んでいる

1393
01:25:52,350 --> 01:25:55,920
それから私達はその時のプログラムの状態の変数をプリントアウトすることができます。

1394
01:25:55,920 --> 01:25:58,990
>> 我々は、そこからプログラム行ずつステップ実行することができます。

1395
01:25:58,990 --> 01:26:03,200
そして、我々は一度にスタックの状態を調べることができます。

1396
01:26:03,200 --> 01:26:08,600
そして、我々は何をすべきかGDBを、使用するために、我々はCファイルに打ち鳴らすの呼び出しです

1397
01:26:08,600 --> 01:26:11,290
しかし、我々はそれを-GGDBフラグを渡す必要があります。

1398
01:26:11,290 --> 01:26:15,850
そして、かつて我々は我々だけで結果の出力ファイル上でGDBを実行することで行われている。

1399
01:26:15,850 --> 01:26:18,810
そしてあなたは、このようなテキストの一部のような塊を得る

1400
01:26:18,810 --> 01:26:21,990
しかし、あなたがしなければならない本当にすべては初めにコマンドを入力されています。

1401
01:26:21,990 --> 01:26:24,250
ブレイクメインは、メインにブレークポイントを置きます。

1402
01:26:24,250 --> 01:26:28,470
リスト400は、ライン400の周りにコードの行を示しています。

1403
01:26:28,470 --> 01:26:31,410
ので、この場合にはあなただけの、ああ、見て回ると言うことができます

1404
01:26:31,410 --> 01:26:34,360
私はこのラインであるライン397、、目にブレークポイントを設定したい

1405
01:26:34,360 --> 01:26:37,170
その後、プログラムは、そのステップに実行され、それは破るために起こっている。

1406
01:26:37,170 --> 01:26:41,120
それはそこに一時停止するように起こっている、あなたは、例えば、低または高の値をプリントアウトすることができます。

1407
01:26:41,120 --> 01:26:46,410
それで、あなたが知る必要があるコマンドの束があります

1408
01:26:46,410 --> 01:26:48,660
そして、このスライドショーは、ウェブサイト上で上がる

1409
01:26:48,660 --> 01:26:54,000
あなただけのこれらを参照するか、チートシートの上に置きたいので、もし、お気軽に。

1410
01:26:54,000 --> 01:27:00,650
>> クール。それはクイズレビュー0であり、ご質問があれば私たちの周り我慢しましょう​​。

1411
01:27:00,650 --> 01:27:03,850
かしこまりました。

1412
01:27:03,850 --> 01:27:09,030
>>  [拍手]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]