1
00:00:00,000 --> 00:00:06,180

2
00:00:06,180 --> 00:00:07,820
>> JASONハーシュホーン：ようこそ
A5に、誰もが。

3
00:00:07,820 --> 00:00:11,270
我々は我々の前にエキサイティングな一週間を持っている、
非常に多くの新機能がある主な理由

4
00:00:11,270 --> 00:00:12,350
この部屋に直面している。

5
00:00:12,350 --> 00:00:12,920
それは素晴らしいです。

6
00:00:12,920 --> 00:00:15,740
あなた方の多くは、偶然ここにいる、
そのさらに良いです。

7
00:00:15,740 --> 00:00:18,220
だから、うまくいけば、私たちに参加しておこう。

8
00:00:18,220 --> 00:00:20,220
>> 今週は費やすつもりだ
セクションの大部分

9
00:00:20,220 --> 00:00:21,870
クイズの準備。

10
00:00:21,870 --> 00:00:26,580
だから私たちの議題ごとに、我々は話をするつもりだ
クラスのリソースについて少し、

11
00:00:26,580 --> 00:00:30,350
だけでなく、クイズの後、再度、
クラス話すの大半を過ごす

12
00:00:30,350 --> 00:00:31,390
質問について。

13
00:00:31,390 --> 00:00:33,900
私たちはあなたのに答え終わったら
質問場合、またはご質問

14
00:00:33,900 --> 00:00:39,010
当然私は、いくつかのコーディングに私たちを導く
中間試験のサンプル問題を抱えている

15
00:00:39,010 --> 00:00:43,180
我々はここでのライブコーディングします過去
一緒にまた、いくつかの他のを持ち出すこと

16
00:00:43,180 --> 00:00:45,420
カバーするために良いのトピック。

17
00:00:45,420 --> 00:00:48,280
>> 我々が経てきたようなので、最初の
あなたを思い出させるために数週間

18
00:00:48,280 --> 00:00:51,700
みんな、資源のトンがあります
このコースで利用可能。

19
00:00:51,700 --> 00:00:55,020
彼らの多くは非常に参考になります
あなたにあなたがし続けている

20
00:00:55,020 --> 00:00:57,280
クイズ0のための研究、なぜなら
それは火曜日の午後です。

21
00:00:57,280 --> 00:00:59,630
だから、すべてがされている
少し勉強。

22
00:00:59,630 --> 00:01:02,640
>> 講義ノートとソースがあります。
コー​​ド、そのことを行う必要があります

23
00:01:02,640 --> 00:01:04,050
間違いなくチェックしてください。

24
00:01:04,050 --> 00:01:05,019
ショーツを見る。

25
00:01:05,019 --> 00:01:07,470
study.cs50.netをチェックしてください。

26
00:01:07,470 --> 00:01:11,770
そして、数、以下に示す
他のリソースである。

27
00:01:11,770 --> 00:01:14,020
>> ここでも、クイズ0は明日です
1時に。

28
00:01:14,020 --> 00:01:18,230
まだ行っていない場合は、確認してください
で約クイズ0文書外

29
00:01:18,230 --> 00:01:21,370
把握するコースのホームページ
どこでクイズを取っている。

30
00:01:21,370 --> 00:01:25,770
クイズ1:10から始まり、
70分後に終了します。

31
00:01:25,770 --> 00:01:29,610
あなた1:10後に現れるのであれば、あなたがしている
多くの少数の分を取得するつもり

32
00:01:29,610 --> 00:01:30,940
70は、クイズを取ることよりも。

33
00:01:30,940 --> 00:01:33,570
ですから、時間通りにそこにいることを確認してください。

34
00:01:33,570 --> 00:01:38,690
あなたが拡張の学生なら、またはお持ちの場合
他のいくつかのテストの考慮、それ

35
00:01:38,690 --> 00:01:40,400
1時に明日ではないかもしれません。

36
00:01:40,400 --> 00:01:43,540
しかし、再び、についてクイズを確認してください0
あなたはときに知っ作るために文書化

37
00:01:43,540 --> 00:01:44,760
あなたがクイズを取っている。

38
00:01:44,760 --> 00:01:46,440
私はここまで75分を書きました。

39
00:01:46,440 --> 00:01:48,580
私は70、右ではないと思います。

40
00:01:48,580 --> 00:01:53,420
>> それは0週からすべての材料をカバーしてい
水曜日の先週の講義を。

41
00:01:53,420 --> 00:01:59,350
そして再び、このクイズでは、そのあたりの
ドキュメントには、1つの両面を取得し、8

42
00:01:59,350 --> 00:02:03,770
あなたが得るの紙11枚ずつ1月2日
クイズ中にメモとして使用する。

43
00:02:03,770 --> 00:02:08,570
多くの人々は、ほとんどの人が持っている場合ではない
らは、単一の最も便利な方法

44
00:02:08,570 --> 00:02:11,970
クイズの勉強をすることである
調査シートを作成、A

45
00:02:11,970 --> 00:02:13,730
自分自身の1サイダー、。

46
00:02:13,730 --> 00:02:17,710
もしそうであれば、過去のものを見て
あなたは過去のものを見てきました。

47
00:02:17,710 --> 00:02:19,960
何を参照するには、友達に手を差し伸べる
彼らは彼らのものに入れている。

48
00:02:19,960 --> 00:02:23,610
>> しかし、ハンズダウン、あなたができる最善の方法
研究では、すべてのものを通過することですし、

49
00:02:23,610 --> 00:02:26,530
何をすべきか、すべきに削るそれを下
の用紙に属してい

50
00:02:26,530 --> 00:02:30,570
紙、それは本当にただだから
あなたが確認するための便利な方法

51
00:02:30,570 --> 00:02:33,620
あなたはすべてを通過するとしている
それにある程度の知識を持っている。

52
00:02:33,620 --> 00:02:36,690
ほとんどの人は、私たちは、見つけるにもかかわらず、彼ら
紙のシートが右に座っている

53
00:02:36,690 --> 00:02:39,840
クイズにそれらの隣に、オンにしないでください
それには、もう一度、まさにその、理由

54
00:02:39,840 --> 00:02:43,290
情報を通過する過程
彼らはそれを学ぶ助けている。

55
00:02:43,290 --> 00:02:45,370
>> 誰もが疑問を持っていますか
クイズ0はどうでしょうか？

56
00:02:45,370 --> 00:02:50,120

57
00:02:50,120 --> 00:02:51,450
誰もを持っています - 

58
00:02:51,450 --> 00:02:53,230
私は挙手をするつもりはありません。

59
00:02:53,230 --> 00:02:53,550
気にしないで。

60
00:02:53,550 --> 00:02:54,790
私は誰に依頼するつもりだった
勉強し始めました。

61
00:02:54,790 --> 00:02:58,360
しかし、私はあなたをしたくない
すべての手を上げない。

62
00:02:58,360 --> 00:03:01,290
だから私は言ったように - はい、AVIは、先に行く。

63
00:03:01,290 --> 00:03:04,205
>> AVIファイル：何が便利なものになるだろう
1  - ポケットベルを置くために？

64
00:03:04,205 --> 00:03:05,875
>> 学生：それはあなた次第です。

65
00:03:05,875 --> 00:03:08,210
>> JASONハーシュホーン：あなたが得る
あなたの判断を使用します。

66
00:03:08,210 --> 00:03:13,220
1  - ポケットベルを置くために有用なもの、
あなたはビッグオーについて混乱している場合は、

67
00:03:13,220 --> 00:03:17,510
検索の異なるタイプのランタイム
やソート、でそこにそれを置く

68
00:03:17,510 --> 00:03:18,760
便利なダンディチャート。

69
00:03:18,760 --> 00:03:22,250
そのように、あなたは上のことを尋ねられた場合
クイズ、あなたは試してみて、図にする必要はありません

70
00:03:22,250 --> 00:03:23,560
そのうちまたはランタイム経由理由。

71
00:03:23,560 --> 00:03:24,730
あなたはそれを下にコピーすることができます。

72
00:03:24,730 --> 00:03:28,320
あなたがクイズの過去、たくさんのを見ると
時間は、時間の問題が実行している。

73
00:03:28,320 --> 00:03:34,150
だから、それは良いの一例になります
あなたのワンポケットベルを置くために事。

74
00:03:34,150 --> 00:03:37,450
>> 君がいるなら、装着するために他の良いもの
宣言する方法について混乱

75
00:03:37,450 --> 00:03:40,570
関数やどのような様々な部分の
関数宣言は、ある書き込み

76
00:03:40,570 --> 00:03:43,400
そのそこに、一般的なバージョン
そして、多分例。

77
00:03:43,400 --> 00:03:47,290
あなたは、ポインタについて混乱している場合は、
ポインターの仕事がいかにの図

78
00:03:47,290 --> 00:03:48,660
おそらく本当に便利。

79
00:03:48,660 --> 00:03:52,440
あなたは再帰について混乱している場合は、A
そこに再帰関数をサンプリング

80
00:03:52,440 --> 00:03:54,980
また、本当に便利になるかもしれない。

81
00:03:54,980 --> 00:03:57,290
それはあなたにいくつかのアイデアを与えるのでしょうか？

82
00:03:57,290 --> 00:04:01,820
>> AVIファイル：あなたが理解する必要があります
のような全体のコンパイル処理、

83
00:04:01,820 --> 00:04:03,220
どのようにすべての作品という？

84
00:04:03,220 --> 00:04:06,620
>> JASONハーシュホーン：すべて
それはカバーされている可能性

85
00:04:06,620 --> 00:04:08,060
クイズに表示。

86
00:04:08,060 --> 00:04:08,930
質問 - 

87
00:04:08,930 --> 00:04:11,300
しかしここでも、いくつかのものがあることでしょう
他のものよりも重く重み付け。

88
00:04:11,300 --> 00:04:14,330
いくつかのものが再び出ている
そして再びクラスで、中

89
00:04:14,330 --> 00:04:15,590
講演、およびセクション。

90
00:04:15,590 --> 00:04:17,220
他のものはそうではありません
多くの場合、その出てくる。

91
00:04:17,220 --> 00:04:22,900
>> 私たちは、＃includeおよびについて多くのことを話した
-L何か、どのようなものの平均

92
00:04:22,900 --> 00:04:24,390
コンパイルプロセス。

93
00:04:24,390 --> 00:04:29,120
我々は、しがみつく、GDBについて多くのことを話した
我々が使用するこれらの異なるフラグとき

94
00:04:29,120 --> 00:04:33,100
我々は何かをコンパイルし、どのような
make15、例えば、実際に

95
00:04:33,100 --> 00:04:34,510
を意味し、実際に行います。

96
00:04:34,510 --> 00:04:38,110
私たちは約限り話をしていない
内のすべての単一のステップ

97
00:04:38,110 --> 00:04:39,240
コンパイルプロセス。

98
00:04:39,240 --> 00:04:40,410
我々はまだそれについて話をしました。

99
00:04:40,410 --> 00:04:42,550
だから、まだあなた何か
精通している必要があります。

100
00:04:42,550 --> 00:04:44,610
しかし、再び、我々はあることを行っていない - 

101
00:04:44,610 --> 00:04:49,140
クラスでより頻繁に出てくるもの
もっと出てくる可能性が高くなります

102
00:04:49,140 --> 00:04:52,495
多くの場合、より重くなる
クイズの加重。

103
00:04:52,495 --> 00:04:53,280
>> 涼しい。

104
00:04:53,280 --> 00:04:54,580
クイズ0に関するその他のご質問？

105
00:04:54,580 --> 00:04:57,660

106
00:04:57,660 --> 00:05:00,050
>> [OK]を、私はリストを入れる
ボード上のトピック。

107
00:05:00,050 --> 00:05:01,550
私はシラバスを通り抜けた。

108
00:05:01,550 --> 00:05:07,340
私は、口コミセクションを経て
最後の夜と考え出すもののスライド

109
00:05:07,340 --> 00:05:13,710
トピックの非網羅的なリストで
我々はCS50でこれまでにカバーされていること

110
00:05:13,710 --> 00:05:16,800
との事、その可能性がある
クイズに表示されます。

111
00:05:16,800 --> 00:05:19,900
だから私は通過するつもりはない
これらのひとつひとつの1。

112
00:05:19,900 --> 00:05:22,370
それははるかにかかるだろう
我々は今持っているよりも時間。

113
00:05:22,370 --> 00:05:26,880
しかし、私はうまくいけばジョグためにここにこれを置く
それかもしれないものに、あなたの記憶

114
00:05:26,880 --> 00:05:28,420
またはあなたと同じように慣れていない場合があります。

115
00:05:28,420 --> 00:05:32,850
>> そして私はの大半を過ごすのが大好きです
に関するご質問に答えるセクション

116
00:05:32,850 --> 00:05:35,130
これらのトピック、トピック、その
ここでは説明しません。

117
00:05:35,130 --> 00:05:36,130
私たちは、擬似コードを書くことができます。

118
00:05:36,130 --> 00:05:40,010
私たちは、実際のコードを書くことができます
あなたのことを確保するため - 

119
00:05:40,010 --> 00:05:44,280
私は、あなたの質問に答えると、助けることができる
誰もが基本的に理解する

120
00:05:44,280 --> 00:05:48,330
これらのトピックの多くに感じますので、
準備と入る快適な

121
00:05:48,330 --> 00:05:50,150
クイズは明日。

122
00:05:50,150 --> 00:05:52,300
だから、リスト上でお読みください。

123
00:05:52,300 --> 00:05:54,780
あなたは、うまくいけばセクションになってきた
いくつかの質問でも同様。

124
00:05:54,780 --> 00:05:58,480
準備ができたら、手を挙げて
私たちは始めるでしょう。

125
00:05:58,480 --> 00:06:01,590

126
00:06:01,590 --> 00:06:05,200
>> 覚えておいて、質問はあなたが持っている、
全く愚かな質問はありません。

127
00:06:05,200 --> 00:06:06,250
私たちは、たくさんのことを聞いたことがあります。

128
00:06:06,250 --> 00:06:09,490
そして、あなたが持っている質問は、私は喜んで
賭けて、他の多くの人々の両方

129
00:06:09,490 --> 00:06:11,740
ここに座って見ている
オンラインだけでなく、持っている。

130
00:06:11,740 --> 00:06:13,770
だから、唯一の人々を助けることができる
質問をすることによって。

131
00:06:13,770 --> 00:06:15,070
マーカス。

132
00:06:15,070 --> 00:06:18,040
>> MARCUS：スタックとの間で
ヒープは、事前に割り当てがあります

133
00:06:18,040 --> 00:06:22,880
として定義されているメモリの割合（％）
これにより、スタックまたはヒープにある？

134
00:06:22,880 --> 00:06:25,010
またはどのように正確に、その動作しますか？

135
00:06:25,010 --> 00:06:26,230
>> JASONハーシュホーン：良い質問。

136
00:06:26,230 --> 00:06:28,640
私は少しをトレースバックするつもりです。

137
00:06:28,640 --> 00:06:30,910
誰もしていますか - 

138
00:06:30,910 --> 00:06:31,660
ここに正直にしてください。

139
00:06:31,660 --> 00:06:34,130
私はあなたを高めるためにあなたを求めている知っている
あなたの仲間の前で手。

140
00:06:34,130 --> 00:06:38,510
しかし感じる人がいる
スタックとヒープと不快

141
00:06:38,510 --> 00:06:42,980
その上に行くしたいと思います
それらは何を意味する？

142
00:06:42,980 --> 00:06:43,880
場合は、手を挙げ - 

143
00:06:43,880 --> 00:06:44,420
[OK]をクリックします。

144
00:06:44,420 --> 00:06:45,120
ありがとう。

145
00:06:45,120 --> 00:06:48,420
だから我々は、スタック上に行くつもりだと
ヒープ本当にすぐにしてから

146
00:06:48,420 --> 00:06:50,370
あなたの質問に答えるに移動。

147
00:06:50,370 --> 00:06:58,250
>> だから我々は表現するボックスを引き出す場合は、
お使いのコンピュータ上のメモリ、いくつかは何ですか

148
00:06:58,250 --> 00:07:02,160
このボックスに行くもの？

149
00:07:02,160 --> 00:07:03,630
メイン。

150
00:07:03,630 --> 00:07:04,020
主な機能。

151
00:07:04,020 --> 00:07:05,890
どこの主は行くのですか？

152
00:07:05,890 --> 00:07:08,090
>> 学生：[聞こえない]。

153
00:07:08,090 --> 00:07:09,390
>> JASONハーシュホーン：だから我々はよ
ダウンここでの主な置く。

154
00:07:09,390 --> 00:07:12,180

155
00:07:12,180 --> 00:07:13,430
他に何がこのボックスに行く？

156
00:07:13,430 --> 00:07:16,000

157
00:07:16,000 --> 00:07:18,140
>> 学生：あなたが呼び出す関数。

158
00:07:18,140 --> 00:07:19,020
>> JASONハーシュホーン：機能
我々は呼び出すことを。

159
00:07:19,020 --> 00:07:20,440
そして彼らはどこに行くのですか？

160
00:07:20,440 --> 00:07:21,300
>> 学生：スタック内。

161
00:07:21,300 --> 00:07:22,380
>> JASONハーシュホーン：彼ら
スタックに移動します。

162
00:07:22,380 --> 00:07:27,350
だから我々はこれをコールするつもりだ
ダウンここに事のスタック。

163
00:07:27,350 --> 00:07:31,880
そして一番上まで、私たちは、ヒープを持っています。

164
00:07:31,880 --> 00:07:35,450
だから、メモリはちょうどこのようなボックスではありません。

165
00:07:35,450 --> 00:07:37,330
しかし、それは実際にはかなり似ています。

166
00:07:37,330 --> 00:07:40,840
それは上の箱がたくさんになるだろう
度も、どのように大きなあなたに依存

167
00:07:40,840 --> 00:07:43,730
コンピュータがあるか、メモリがどのくらいである。

168
00:07:43,730 --> 00:07:46,950
>> 俗に言う「下」で
スタックがある。

169
00:07:46,950 --> 00:07:50,880
と複数のものがあります
つまり、スタックに移動します。

170
00:07:50,880 --> 00:07:53,840
そして、それらは機能によって異なります
あなたはあなたのコードを持っている。

171
00:07:53,840 --> 00:07:57,780
あなたはいつも、あなたの中で一つの機能を持っている
コー​​ドは、メインと呼ばれるので、常にある

172
00:07:57,780 --> 00:08:00,480
ダウンここでのセクション
主に専念スタック。

173
00:08:00,480 --> 00:08:03,980
>> スタック内のこれらのセクション
スタックフレームと呼ばれます。

174
00:08:03,980 --> 00:08:09,580
あなたが別の関数を呼び出すと、メインと言う
バイナリ検索機能を呼び出し、

175
00:08:09,580 --> 00:08:11,075
私たちは、スタック上に別のフレームを置く。

176
00:08:11,075 --> 00:08:13,830

177
00:08:13,830 --> 00:08:17,320
具体的には、我々はしようとしている
私たちの上のメモリチャンクを寄付

178
00:08:17,320 --> 00:08:22,960
バイナリ·サーチのローカルに格納するためのコンピュータ
変数とバイナリを実行するには

179
00:08:22,960 --> 00:08:24,150
検索コード。

180
00:08:24,150 --> 00:08:26,810
>> だから我々は二分探索を呼び出します。

181
00:08:26,810 --> 00:08:30,440

182
00:08:30,440 --> 00:08:33,340
このメモリの塊では、つもりだ
そのローカル変数を格納する。

183
00:08:33,340 --> 00:08:35,270
私たちは、そのprintfの呼び出しを格納するつもりだ。

184
00:08:35,270 --> 00:08:38,159
何が起きても、その関数がある
すぐそこに格納される予定。

185
00:08:38,159 --> 00:08:40,350
バイナリサーチは、実行しようとしている。

186
00:08:40,350 --> 00:08:42,210
これは、実行を完了しようとしている。

187
00:08:42,210 --> 00:08:47,450
C言語での単語は何であることを示します
機能は必要があること

188
00:08:47,450 --> 00:08:49,306
その実行を完了？

189
00:08:49,306 --> 00:08:50,040
>> 学生：リターン。

190
00:08:50,040 --> 00:08:50,870
>> JASONハーシュホーン：リターン。

191
00:08:50,870 --> 00:08:53,230
ですから、return文を見るたびに、
関数が終了

192
00:08:53,230 --> 00:08:54,350
それはその当たったとき。

193
00:08:54,350 --> 00:08:56,740
だから、二分探索は、そのリターンをヒットします。

194
00:08:56,740 --> 00:09:01,360
メモリのこの部分は、基本的になります
解放され。

195
00:09:01,360 --> 00:09:03,510
そして主は戻って、実行に行きます。

196
00:09:03,510 --> 00:09:07,240
、呼び出しがあった場所に、主が一時停止します
バイナリサーチは、いくつかの戻り値を取得、

197
00:09:07,240 --> 00:09:08,700
して実行を継続。

198
00:09:08,700 --> 00:09:10,840
このスタックフレームは消えます。

199
00:09:10,840 --> 00:09:14,810
>> 我々は再帰関数を呼び出す場合、その
上の自分自身を呼び出す関数である

200
00:09:14,810 --> 00:09:18,480
そしてにわたって、我々は得るかもしれない - 私たちは言う
再帰的に二分探索を行いました。

201
00:09:18,480 --> 00:09:21,520
私たちは、二分探索バージョン1を得るかもしれない
バイナリサーチ2、バイナリサーチ

202
00:09:21,520 --> 00:09:24,090
3、バイナリサーチ4、
二分探索5。

203
00:09:24,090 --> 00:09:27,950
そして、この最終的なバイナリサーチ5
ベースケース、およびスタックにヒットする

204
00:09:27,950 --> 00:09:31,010
フレームが戻って閉鎖を維持します
我々は戻って主に到達するまで。

205
00:09:31,010 --> 00:09:32,530
私たちは少しで、再帰の上に行くことができます。

206
00:09:32,530 --> 00:09:35,530
あなたがしている場合しかし、このすべては、言うことです
一度に複数の機能を呼び出して、

207
00:09:35,530 --> 00:09:39,250
複数のスタックがあります
スタックにあったフレーム。

208
00:09:39,250 --> 00:09:42,900
>> ヒープ、​​他方では、アップ
ここでは、機能のためではありません、

209
00:09:42,900 --> 00:09:44,380
ていないローカル変数のための。

210
00:09:44,380 --> 00:09:48,920
これは、動的に割り当てられたためだ
変数。

211
00:09:48,920 --> 00:09:57,210
したがって、これらは可能な変数である
メインまたはどちらかで初期化

212
00:09:57,210 --> 00:09:58,640
その主な通話機能。

213
00:09:58,640 --> 00:10:00,790
どこでもあなたのコードでは、彼らは
初期化することができます。

214
00:10:00,790 --> 00:10:04,360
を動的に初期化する
割り当てられた変数。

215
00:10:04,360 --> 00:10:06,970
我々は、C言語でどのような機能を使っていますか？

216
00:10:06,970 --> 00:10:07,600
>> 学生：mallocに。

217
00:10:07,600 --> 00:10:09,240
>> JASONハーシュホーン：mallocに。

218
00:10:09,240 --> 00:10:10,800
あなたは、malloc関数を呼び出します。

219
00:10:10,800 --> 00:10:12,260
あなたは、メモリの容量を取得する。

220
00:10:12,260 --> 00:10:15,020
そしてメモリのスペース
ヒープ上にある。

221
00:10:15,020 --> 00:10:18,840
そしてメモリのスペースが留まる
そこにあなたが自由呼び出すまで。

222
00:10:18,840 --> 00:10:22,670
>> で非常に動的に割り当てられた変数
ヒープは限り、あなたのようなのために存在します

223
00:10:22,670 --> 00:10:25,250
彼らが存在するか、そして、彼らはないでしょう
明示的になるまで離れて行く

224
00:10:25,250 --> 00:10:26,760
離れて行くように言う。

225
00:10:26,760 --> 00:10:29,670
あなたは、一つの関数でそれらを作成することができます。

226
00:10:29,670 --> 00:10:31,930
その関数のスタック
フレームが消えてしまいます。

227
00:10:31,930 --> 00:10:35,490
しかし、その変数がまだ存在します
ヒープ内にそれが解放されるまで、

228
00:10:35,490 --> 00:10:39,650
潜在的に呼び出された関数
二分探索または何でも。

229
00:10:39,650 --> 00:10:42,580
>> ので、これらのヒープ変数がそこに滞在
限り、あなたは好きな用

230
00:10:42,580 --> 00:10:43,490
彼らはそこに滞在する。

231
00:10:43,490 --> 00:10:46,090
そして、彼らはここに置か取得します。

232
00:10:46,090 --> 00:10:47,450
し、[次へ1がそこに置かれます。

233
00:10:47,450 --> 00:10:50,210
彼らは記入くるだけだ、と彼ら
あなたが無料呼ぶまでそこにとどまる。

234
00:10:50,210 --> 00:10:52,870
>> そして、基本的に、ヒープとスタック、
マーカスの質問になって、

235
00:10:52,870 --> 00:10:54,500
互いに向かって成長する。

236
00:10:54,500 --> 00:10:57,730
彼らはお互いに実行する場合、あなたはしました
あなたの内のすべてのメモリを使用

237
00:10:57,730 --> 00:11:01,330
コンピュータ、そしてあなたのプログラムが終了します
あなたはこれ以上のメモリを持っていないため、

238
00:11:01,330 --> 00:11:02,420
使用することを残しました。

239
00:11:02,420 --> 00:11:07,290
それらの間では、あります
潜在的に他のもの。

240
00:11:07,290 --> 00:11:10,980
しかし、このコースの範囲については、
そのことについて心配する必要はありません。

241
00:11:10,980 --> 00:11:12,020
>> だから、答えだった
ご質問に。

242
00:11:12,020 --> 00:11:13,520
ご心配なく。

243
00:11:13,520 --> 00:11:15,550
しかし、それは長い答えだった。

244
00:11:15,550 --> 00:11:17,800
あなたが知る必要があるのはある
ヒープとスタックします - 

245
00:11:17,800 --> 00:11:18,900
1は、下部に開始されます。

246
00:11:18,900 --> 00:11:19,570
スタックしていますか。

247
00:11:19,570 --> 00:11:20,790
ヒープはそこまでだ。

248
00:11:20,790 --> 00:11:21,990
彼らはお互いに近く成長します。

249
00:11:21,990 --> 00:11:23,110
>> 彼らが触れた場合に、それが問題だ。

250
00:11:23,110 --> 00:11:24,500
あなたは、メモリ不足になりました。

251
00:11:24,500 --> 00:11:28,760
しかし、また、どこで知ることに加え
それらは、何の両方に格納されている

252
00:11:28,760 --> 00:11:30,512
スタックとヒープ。

253
00:11:30,512 --> 00:11:31,410
カーティス。

254
00:11:31,410 --> 00:11:33,570
>> CURTIS：彼らは衝突すると、
そのスタックオーバーフローがある？

255
00:11:33,570 --> 00:11:35,670
>> JASONハーシュホーン：彼らは衝突し、
つまり、スタックオーバーフローではありません。

256
00:11:35,670 --> 00:11:38,340
スタックオーバーフローは、別の領域である
あなたがしたい場合は、我々は以上行くことができる。

257
00:11:38,340 --> 00:11:40,020
[OK]を、我々は少しでバックアップすることに来る。

258
00:11:40,020 --> 00:11:42,730
>> 学生：単語は何と呼ばれています
彼らは、互いを打ったとき

259
00:11:42,730 --> 00:11:44,450
スタックとヒープ？

260
00:11:44,450 --> 00:11:46,640
>> JASONハーシュホーン：今のところ、
心配しないでください。

261
00:11:46,640 --> 00:11:47,750
ただ知っている - 

262
00:11:47,750 --> 00:11:50,530
私はその質問にお答えします
授業の後。

263
00:11:50,530 --> 00:11:52,680
彼らはお互いに実行する場合は、走った
メモリのため、これ以上はありませんので、

264
00:11:52,680 --> 00:11:53,330
そこにスペース。

265
00:11:53,330 --> 00:11:55,450
>> 学生：申し訳ありませんが、SEGの障害は何ですか？

266
00:11:55,450 --> 00:11:58,710
>> JASONハーシュホーン：セグメント
障害がために呼び出すことができます - 

267
00:11:58,710 --> 00:12:02,240
ワンセグのせいですと呼ばれる理由は異なります。

268
00:12:02,240 --> 00:12:06,260
時々、あなたのスタックオーバーフローは、よ
SEGエラーとして障害を言う。

269
00:12:06,260 --> 00:12:08,180
>> 学生：何デリファレンスについて
NULL変数？

270
00:12:08,180 --> 00:12:10,040
そのワンセグ障害がある？

271
00:12:10,040 --> 00:12:11,480
>> JASONハーシュホーン：間接参照
NULLポインタ - 

272
00:12:11,480 --> 00:12:17,850
[OK]を、あなたは、ポインタを持っているので、もし
ヌルポインタ、リコールに等しくなるように設定

273
00:12:17,850 --> 00:12:20,270
ストア·メモリ·アドレス
その値として。

274
00:12:20,270 --> 00:12:23,660
そしてnullポインタは、本質的に
0を記憶し、第0

275
00:12:23,660 --> 00:12:26,670
その変数のアドレス。

276
00:12:26,670 --> 00:12:30,010
そうに0x、0,0,0,0等といった。

277
00:12:30,010 --> 00:12:35,030
ではありませんメモリ内の0番目のアドレス
私たちの絵で、それはそこまでだ

278
00:12:35,030 --> 00:12:38,800
どこかで、そのは予約だ
コンピュータの。

279
00:12:38,800 --> 00:12:40,130
我々は、それに触れることを許されていない。

280
00:12:40,130 --> 00:12:44,680
>> だからあなたのプログラムの実行だとき、もし
何かがメモリに行くしようとしています

281
00:12:44,680 --> 00:12:48,990
アドレス0、それが知っている
つまり、空の値である。

282
00:12:48,990 --> 00:12:50,820
それは何もないはずです知っている。

283
00:12:50,820 --> 00:12:53,420
だから、そこに何かをしようと使用している場合
そこのようなものを扱うか、

284
00:12:53,420 --> 00:12:58,355
その場所に移動しよう、あなたがしている
ワンセグ障害やエラーを取得するつもり。

285
00:12:58,355 --> 00:13:00,520
それがあなたの質問に答えるのでしょうか？

286
00:13:00,520 --> 00:13:03,170
>> そして今、我々は戻って行くよ
スタックオーバーフロー。

287
00:13:03,170 --> 00:13:09,560
あなたたちは持っているように、スタック内のもの、
それでは近い描いてみ - で、前に見た

288
00:13:09,560 --> 00:13:11,966
スタックフレームのアップ。

289
00:13:11,966 --> 00:13:15,050
誰もがそれを見ることはできますか？

290
00:13:15,050 --> 00:13:16,650
だから我々は我々のスタックフレームを持っている。

291
00:13:16,650 --> 00:13:23,260
私たちは地元のように配列を保存している
この関数内の変数。

292
00:13:23,260 --> 00:13:29,510
だから私たちの配列が5つのスポットを持っていると言う。

293
00:13:29,510 --> 00:13:33,230
それらはすべて、5が保存されます
そのスタック·フレームに。

294
00:13:33,230 --> 00:13:37,540
>> 我々は超えて書き込みを開始した場合
この配列の境界 - 

295
00:13:37,540 --> 00:13:43,990
私たちはへの書き込みを開始した場合、
のはそれが0だとしましょう​​。

296
00:13:43,990 --> 00:13:46,800
それらは5インデックスです
私たちの配列の。

297
00:13:46,800 --> 00:13:50,980
我々は、インデックス5への書き込みを開始した場合、その
我々が持っているときに我々は持っていない

298
00:13:50,980 --> 00:13:55,900
サイズ5の配列、我々はへの書き込みを開始
インデックス6、7、8、9、我々は、スタックを得ることができ

299
00:13:55,900 --> 00:13:57,960
オーバーフローエラー。

300
00:13:57,960 --> 00:14:00,510
>> 一般的にはそうではありません - 

301
00:14:00,510 --> 00:14:04,910
おそらくトラブルに巻き込まれます
あなたは1に引き継が進みます。

302
00:14:04,910 --> 00:14:08,640
しかし、一般的に、あなたが入るでしょう
あなたはたくさんによって引き継が行けばほとんどのトラブル

303
00:14:08,640 --> 00:14:12,770
あなたは、これまで以上のあなたが書くことを行く
それのリターンアドレスの上

304
00:14:12,770 --> 00:14:16,080
に位置している機能、
スタックフレームの一番下。

305
00:14:16,080 --> 00:14:16,520
>> 右から？

306
00:14:16,520 --> 00:14:17,670
あなた - 中 - 申し訳ありません。

307
00:14:17,670 --> 00:14:18,550
しない「右から」

308
00:14:18,550 --> 00:14:20,470
>> スタック·フレームには、次のものが
あなたのローカル変数。

309
00:14:20,470 --> 00:14:27,090
スタックの最下部に
フレームは、リターンアドレスです。

310
00:14:27,090 --> 00:14:28,790
どこで機能することです
それが終わった時になります。

311
00:14:28,790 --> 00:14:33,750
そして、あなたはそのリターンを上書きした場合
アドレスは、このスタックフレーム、

312
00:14:33,750 --> 00:14:36,680
あなたはスタックを経由しているとき
フレームと各ラインを実行すると、あなたがしている

313
00:14:36,680 --> 00:14:40,350
新しいリターンアドレスに行くつもり
それは、代わりにそこに書かれている

314
00:14:40,350 --> 00:14:40,910
実際1。

315
00:14:40,910 --> 00:14:45,050
そして、それは我々が見てきた方法です
いくつかのセキュリティ侵害

316
00:14:45,050 --> 00:14:46,780
コンピュータと発生する可能性があります。

317
00:14:46,780 --> 00:14:52,760
>> とき、スタックオーバーフローが、要するに、ある
あなたは、スタック内の一部が上書きされ

318
00:14:52,760 --> 00:14:55,440
あなたは、ローカルを使用することになっている
あなたが使うことになっている変数、および

319
00:14:55,440 --> 00:14:58,070
特にあなたが、上書きの起動時に
のような重要な事柄

320
00:14:58,070 --> 00:14:59,100
アドレスを返す。

321
00:14:59,100 --> 00:15:00,090
あなたはエラーになりますどこからだ。

322
00:15:00,090 --> 00:15:03,980
または多分あなたが始めることができた
でもへの書き込み - 

323
00:15:03,980 --> 00:15:05,370
二分探索であったと言う
右のメイン上。

324
00:15:05,370 --> 00:15:07,790
あなたは多くのことを上書きする場合は、
主に書くことができます。

325
00:15:07,790 --> 00:15:10,230
しかし、一般的には、前にエラーが表示されます
そして、コンピュータは知っているので、

326
00:15:10,230 --> 00:15:12,270
あなたはあなたが何かをやっている
やってはいけません。

327
00:15:12,270 --> 00:15:12,560
うん。

328
00:15:12,560 --> 00:15:13,910
>> 学生：違いは何ですか
スタックオーバーフローの間

329
00:15:13,910 --> 00:15:16,940
およびバッファオーバーフロー？

330
00:15:16,940 --> 00:15:19,420
>> JASONハーシュホーン：バッファオーバーフロー
より一般的なタイプである

331
00:15:19,420 --> 00:15:20,395
私は、今説明したもの。

332
00:15:20,395 --> 00:15:22,610
>> 学生：そうスタックオーバーフローがある
バッファオーバーフローの例。

333
00:15:22,610 --> 00:15:23,420
>> JASONハーシュホーン：その通りです。

334
00:15:23,420 --> 00:15:28,700
これは、我々のように考えることができます配列です
バッファ、入った旅のためのスペース

335
00:15:28,700 --> 00:15:30,600
これは、スタックバッファオーバーフローである。

336
00:15:30,600 --> 00:15:33,210
私たちは、ヒープバッファオーバーフローを持つことができます。

337
00:15:33,210 --> 00:15:36,870
そこに多くの場合、バッファがあった場合
配列はヒープであり、我々

338
00:15:36,870 --> 00:15:40,600
それらの境界を上書きし、その後、我々はだろう
ヒープバッファオーバーフローがあります。

339
00:15:40,600 --> 00:15:44,870
>> そしてこのコースの範囲を超えて、
それらは少し異なる検出されています。

340
00:15:44,870 --> 00:15:48,040
コンパイラは、特別な持って
それぞれを検出する方法。

341
00:15:48,040 --> 00:15:50,660
しかし、バッファオーバーフローは、より汎用的である
私が説明したものの種類、

342
00:15:50,660 --> 00:15:54,090
そのスタックバッファオーバーフローた。

343
00:15:54,090 --> 00:15:56,240
その回答はお役に立ちましたか？

344
00:15:56,240 --> 00:15:57,910
甘い。

345
00:15:57,910 --> 00:16:01,850
>> 他の質問の関連があった
スタックやヒープに？

346
00:16:01,850 --> 00:16:04,920

347
00:16:04,920 --> 00:16:05,510
うん。

348
00:16:05,510 --> 00:16:08,220
>> 学生：私は、文字列を解放する必要があります知っている
彼らは、ヒープにいるので、

349
00:16:08,220 --> 00:16:09,305
あなたはメモリリークが発生しないように。

350
00:16:09,305 --> 00:16:12,240
しかし、あなたはグローバル変数を解放しなければならないの
そのようなもの？

351
00:16:12,240 --> 00:16:14,335
またはそれらは自動的に解放される？

352
00:16:14,335 --> 00:16:15,700
>> JASONハーシュホーン：良い質問。

353
00:16:15,700 --> 00:16:22,340
そうCS50.Hに、私たちはこの事を作成する
文字列と呼ばれるため。

354
00:16:22,340 --> 00:16:23,800
文字列は、本当に何ですか？

355
00:16:23,800 --> 00:16:24,810
>> 学生：チャースター。

356
00:16:24,810 --> 00:16:29,180
>> JASONハーシュホーン：char型のスター、ポインタ
文字へのポインタ

357
00:16:29,180 --> 00:16:30,650
文字の配列。

358
00:16:30,650 --> 00:16:32,210
つまり、文字列があるものだ。

359
00:16:32,210 --> 00:16:36,050
だから我々は、それを解放する必要があるため、
我々は多くのことを使用のgetString、 - 

360
00:16:36,050 --> 00:16:38,370
文字列名は、getStringをに等しい - 

361
00:16:38,370 --> 00:16:43,560
それが私たちのためにいくつかのメモリをmallocは
ヒープ、​​その後へのポインタを返す

362
00:16:43,560 --> 00:16:47,230
それの最初の文字
文字列、char型のスター。

363
00:16:47,230 --> 00:16:52,760
>> だから表向きは、あなたがされていない場合は
あなたの文字列のいずれかに自由に書き込み

364
00:16:52,760 --> 00:16:55,600
あなたは、これまでと呼んでいることを、あなたが持っている
いくつかのメモリリークが発生して。

365
00:16:55,600 --> 00:16:57,430
もちろん、我々は話をしていない
それなので、誰もに得ていないだ

366
00:16:57,430 --> 00:16:58,520
それを行うためのトラブル。

367
00:16:58,520 --> 00:16:59,980
しかし、はい、今後。

368
00:16:59,980 --> 00:17:03,990
あなたがにgetStringを呼び出すときに、だ
ヒープ上にいくつかのスペースをmallocing。

369
00:17:03,990 --> 00:17:07,640
そして、あなたはその上で、後で自由に呼び出していない場合
文字列には、メモリリークがあります。

370
00:17:07,640 --> 00:17:09,440
それはあなたの質問に答える？

371
00:17:09,440 --> 00:17:10,606
>> うん

372
00:17:10,606 --> 00:17:15,020
>> 学生：だからそのためには、私たちが使っています
復帰の前に無料の権利？

373
00:17:15,020 --> 00:17:18,510
のような、の範囲内で、私は推測する場合
我々は内、メインint型のような、と言う

374
00:17:18,510 --> 00:17:24,410
それらの内のコードの範囲
中括弧、右の前に - 

375
00:17:24,410 --> 00:17:26,140
あなたが知っているどこにしたい
通常、リターンを置く。

376
00:17:26,140 --> 00:17:27,950
あなたはその前に無料で置くのですか？

377
00:17:27,950 --> 00:17:31,000
>> JASONハーシュホーン：だから、自由に置くことができます
あなたが自由に置きたいところ。

378
00:17:31,000 --> 00:17:33,810
これらは動的に割り当てられるため
変数、彼らがすることができますので、

379
00:17:33,810 --> 00:17:39,170
特定の範囲を超えて生きる
あなたはAのmalloc関数を呼び出すと、関数、

380
00:17:39,170 --> 00:17:44,140
別の関数、例えば、
GetStringメソッドは、主に無料で呼び出すことができます。

381
00:17:44,140 --> 00:17:46,050
あなたはそれを呼び出す必要はありません
特定の機能の

382
00:17:46,050 --> 00:17:47,570
malloc関数が呼び出される場合。

383
00:17:47,570 --> 00:17:50,340
しかし、あなたはそれを呼び出す必要があります
主が戻る前に。

384
00:17:50,340 --> 00:17:51,120
>> そしてそれは実際に依存します。

385
00:17:51,120 --> 00:17:54,960
それはあなたがいることにmalloc理由に依存
最初の場所での空間。

386
00:17:54,960 --> 00:17:57,320
一部の人々は呼びます
かなり迅速に解放する。

387
00:17:57,320 --> 00:17:59,220
一部の人々が自由になるまで呼び出すことはありません
そのプログラムの終わり。

388
00:17:59,220 --> 00:18:00,660
そして、彼らは通過するだろう
無料のすべてのもの。

389
00:18:00,660 --> 00:18:03,597
それはあなたがmalloc関数と呼ばれる理由によります。

390
00:18:03,597 --> 00:18:11,270
>> 学生：そして、あなたは何を言うだろう
あなたが使用にgetStringを呼び出した場合？

391
00:18:11,270 --> 00:18:13,320
あなたはどのような無料のでしょうね？

392
00:18:13,320 --> 00:18:20,040
>> JASONハーシュホーン：だからの構文は無料
単純に近く、無料、フリー、オープン括弧、ある

393
00:18:20,040 --> 00:18:22,130
括弧、ポインタの名前。

394
00:18:22,130 --> 00:18:26,410
あなたは、文字列の名前を書くのであれば等しく
GetStringメソッドは、ここに名前を入れた。

395
00:18:26,410 --> 00:18:27,760
つまり、ポインタの名前です。

396
00:18:27,760 --> 00:18:30,570
そして、それはそのメモリを解放するために知っている。

397
00:18:30,570 --> 00:18:33,920
>> 学生：だから、そのメモリを解放し、
ポインタはまだその場所を指す

398
00:18:33,920 --> 00:18:34,970
メモリ内の？

399
00:18:34,970 --> 00:18:39,020
またはポインタはまた、空になった
それが指すアドレス。

400
00:18:39,020 --> 00:18:40,290
>> JASONハーシュホーン：私たちはそれを試してみてください。

401
00:18:40,290 --> 00:18:41,430
我々はそれをコーディングする必要があります。

402
00:18:41,430 --> 00:18:43,880
我々が取得するときに戻ってきてみましょう
コー​​ディング、およびのはそれをコーディングしてみましょう。

403
00:18:43,880 --> 00:18:46,000
そして、あなたはその答えを把握したい場合に
そのためには、また、それをコーディングすることができます

404
00:18:46,000 --> 00:18:46,690
その間に。

405
00:18:46,690 --> 00:18:49,100
しかし、それは素晴らしい質問ですね。

406
00:18:49,100 --> 00:18:53,480
>> 学生：それはすることはできますか
あまりにも早く無料で何か？

407
00:18:53,480 --> 00:18:58,530
だから、あなたはまだ、あなたのプログラムのためにそれを必要とする
あなたは、そのメモリ領域を解放？

408
00:18:58,530 --> 00:18:59,200
>> JASONハーシュホーン：はい。

409
00:18:59,200 --> 00:19:03,020
それは、可能な場合、あなたは無料のもの
あなたは再びそれを使用してから、あなたは意志

410
00:19:03,020 --> 00:19:06,890
エラーに遭遇する。

411
00:19:06,890 --> 00:19:10,810
あなたは解放されたので、しかし、それは、あなたにだ
何かして、後でそれを呼んだ。

412
00:19:10,810 --> 00:19:13,940
だから、プログラマの間違いだった。

413
00:19:13,940 --> 00:19:14,780
しかし、はい。

414
00:19:14,780 --> 00:19:17,760
あなたはそれを書くことができます。

415
00:19:17,760 --> 00:19:19,240
>> 上の任意のより多くの質問 - 

416
00:19:19,240 --> 00:19:19,760
はい。

417
00:19:19,760 --> 00:19:22,820
>> 学生：だからをすることになっている場合は、単に
前に、一般的にそれを解放

418
00:19:22,820 --> 00:19:25,490
プログラムが終了した場合、それはどういう意味ですか
プログラムが終了し、あなたはそれを解放してはなりません、

419
00:19:25,490 --> 00:19:27,580
そのメモリはまだ割り当てられている？

420
00:19:27,580 --> 00:19:31,330
>> JASONハーシュホーン：あなたのプログラムが終了した場合
そしてその後、何かを解放することを忘れ

421
00:19:31,330 --> 00:19:34,390
そのメモリは、全体に配分された
あなたのプログラムの有効期間。

422
00:19:34,390 --> 00:19:37,670
あなたのプログラムを完全に閉じると、
そのメモリは行っていない

423
00:19:37,670 --> 00:19:39,490
いつまでもそこに滞在する。

424
00:19:39,490 --> 00:19:42,080
コンピュータが知っているのに十分スマートです
そのプログラムが終了すると、

425
00:19:42,080 --> 00:19:46,440
メモリのすべてを取り除く必要があります
そのプログラムに関連していた。

426
00:19:46,440 --> 00:19:51,240
>> ただし、あなたが実行できるツールがあります
もし、検出するためのプログラム上の

427
00:19:51,240 --> 00:19:54,720
プログラムは、あなたが忘れてしまった、仕上げ
いくつかのメモリを解放する。

428
00:19:54,720 --> 00:19:57,960
そして、あなたの次の問題のためにどこで設定
あなたはmallocを使用して使用することがあります

429
00:19:57,960 --> 00:20:02,610
ポインタは、これを実行され
かどうかを確認するために、プログラム上のプログラム、

430
00:20:02,610 --> 00:20:06,530
と、メインに戻り、いくつかを持っていた
未解放残されたもの。

431
00:20:06,530 --> 00:20:09,130
>> そこで、彼らはmallocで割り当て滞在するつもりはない
永遠にあなたのコンピュータにある。

432
00:20:09,130 --> 00:20:11,720
つまり、無駄になるので
非常に迅速に、コンピュータ

433
00:20:11,720 --> 00:20:12,960
メモリ不足になります。

434
00:20:12,960 --> 00:20:16,450
しかし、彼らはあなたの最後まで実行した場合
プログラムは、それらが解放され、あなたのしていない

435
00:20:16,450 --> 00:20:20,260
プログラムが終了、それはまだ問題だ
つまり、このツールを使用すると、対処するのに役立ちます。

436
00:20:20,260 --> 00:20:21,520
>> 学生：Valgrindのことをされていますか？

437
00:20:21,520 --> 00:20:22,910
>> JASONハーシュホーン：それは
Valgrindは呼びかけた。

438
00:20:22,910 --> 00:20:23,520
そして、あなたはなるだろう - 

439
00:20:23,520 --> 00:20:25,780
>> 学生：しかし、我々は知っている必要はありません
クイズのこと、しかし？

440
00:20:25,780 --> 00:20:27,600
私が意味する、それが語られました
講演で少し。

441
00:20:27,600 --> 00:20:33,600
>> JASONハーシュホーン：だからValgrindの
そのツールの名前です。

442
00:20:33,600 --> 00:20:37,180
それが何をするか知っていることはある
クイズには十分。

443
00:20:37,180 --> 00:20:40,200
しかし、あなたはあなたの上で、まだそれを使用していない
我々は持っていなかったため、問題が設定され

444
00:20:40,200 --> 00:20:43,520
明示的に述べた問題セット
mallocでか、mallocを使用。

445
00:20:43,520 --> 00:20:45,330
だから、まだValgrindのを使用していない。

446
00:20:45,330 --> 00:20:47,760
しかし、あなたはすぐにそれを使用します
むしろより後。

447
00:20:47,760 --> 00:20:48,710
>> 学生：あなたは繰り返すことができます
Valgrindのは何ですか？

448
00:20:48,710 --> 00:20:49,190
>> JASONハーシュホーン：申し訳ありませんが？

449
00:20:49,190 --> 00:20:51,240
>> 学生：あなたは何を繰り返すことができます
Valgringの目的は何ですか？

450
00:20:51,240 --> 00:20:53,100
>> JASONハーシュホーン：Valgrindの
名前は - 

451
00:20:53,100 --> 00:20:59,890
GDBは、ユーザ·プログラムをデバッグするのに役立ちますように
Valgrindのは、あなたがどうかを把握に役立ちます

452
00:20:59,890 --> 00:21:03,210
物事は解放されていない
あなたのプログラムが終了したとき。

453
00:21:03,210 --> 00:21:05,110
つまり、あなたのプログラムにそれを実行することになるでしょう。

454
00:21:05,110 --> 00:21:09,230
そして、あなたのプログラムが終了し、それは言うよ
あなたのプログラムは、malloc関数は、この多くと呼ばれる

455
00:21:09,230 --> 00:21:13,670
このバイトのための時間、あなたは
これだけ多くの時間が自由と呼ばれる。

456
00:21:13,670 --> 00:21:16,520
だからあなたはこれらの多くのバイトを残した
解放されない。

457
00:21:16,520 --> 00:21:18,050
それとも、あなたがすべてを解放したとします。

458
00:21:18,050 --> 00:21:19,070
よくできました。

459
00:21:19,070 --> 00:21:19,480
>> 学生：わかりました。

460
00:21:19,480 --> 00:21:21,060
そして、それはValgringと呼ばれています？

461
00:21:21,060 --> 00:21:24,940
>> JASONハーシュホーン：V-A-L-G-R-I-N-D。

462
00:21:24,940 --> 00:21:25,970
>> 学生：ポインタについての質問。

463
00:21:25,970 --> 00:21:30,080
ですから、n個の星を持っていると言う
xが何かに等しい。

464
00:21:30,080 --> 00:21:33,330
それはあなたが入れているものは何でも、等しい
そこには、どのような内部置かれてあるということです

465
00:21:33,330 --> 00:21:36,120
どのようなxが指している、
またはXのポインタ？

466
00:21:36,120 --> 00:21:37,690
>> JASONハーシュホーン：次のことができます
質問を繰り返す？

467
00:21:37,690 --> 00:21:39,340
あなたがそれを言うながら、我々はそれを描くことができますか？

468
00:21:39,340 --> 00:21:42,710
>> 学生：クイズでは、実際には、
あなたは私たちを送っ1は、それは、CHARのようだった

469
00:21:42,710 --> 00:21:46,520
スターの真実は右、CS50岩に等しい？

470
00:21:46,520 --> 00:21:52,190
だから、そのことCS50岩を意味するのか
真実がポイントしている何ですか？

471
00:21:52,190 --> 00:21:55,810
>> JASONハーシュホーン：だから、話をしている
文字列内の文字の星について、どのように

472
00:21:55,810 --> 00:21:56,460
それは動作します？

473
00:21:56,460 --> 00:21:56,890
うん。

474
00:21:56,890 --> 00:21:57,700
[OK]をクリックします。

475
00:21:57,700 --> 00:21:59,140
それではこっちこれを描画してみましょう。

476
00:21:59,140 --> 00:22:07,100
>> [サイド会話]

477
00:22:07,100 --> 00:22:11,130
>> JASONハーシュホーン：だから、この変数
char型の星のことを行っている。

478
00:22:11,130 --> 00:22:14,580
変数は、大きさとは
char型の星の？

479
00:22:14,580 --> 00:22:15,510
何バイト？

480
00:22:15,510 --> 00:22:16,450
>> 学生：四。

481
00:22:16,450 --> 00:22:18,210
>> JASONハーシュホーン：これは、4バイトです。

482
00:22:18,210 --> 00:22:21,420
変数には、どのように多くの権利である
int型の星の？

483
00:22:21,420 --> 00:22:22,210
>> 学生：四。

484
00:22:22,210 --> 00:22:24,910
>> JASONハーシュホーン：4バイト。

485
00:22:24,910 --> 00:22:28,280
それは、ポインタの場合、それは常に
4バイト、なぜならポインタ、その

486
00:22:28,280 --> 00:22:30,070
値はメモリアドレスです。

487
00:22:30,070 --> 00:22:35,160
CS50上とメモリアドレス
アプライアンスは、4バイト長である。

488
00:22:35,160 --> 00:22:42,900
だから我々はのgetStringや、ときに我々を呼び出すとき
と言う、<Stringname>がに等しいし、次に中

489
00:22:42,900 --> 00:22:46,140
二重引用符は、文字列を入れて、
我々は入れている - 

490
00:22:46,140 --> 00:22:46,920
まあ、それは少し違う。

491
00:22:46,920 --> 00:22:48,630
ここでは、例としてのgetStringやります。

492
00:22:48,630 --> 00:22:52,150
またはCHARスターの何か
文字列に相当します。

493
00:22:52,150 --> 00:22:54,360
申し訳ありませんが、私に例を与える
あなたが読むことを？

494
00:22:54,360 --> 00:22:57,590
>> 学生：CHARスターの真実に等しい
二重引用符で「CS50岩」。

495
00:22:57,590 --> 00:23:02,260
>> JASONハーシュホーン：だからこの星、この
我々は我々のために、この変数Xと呼ぶことにします

496
00:23:02,260 --> 00:23:04,060
一般的な目的。

497
00:23:04,060 --> 00:23:05,970
我々はXという変数を作成しました。

498
00:23:05,970 --> 00:23:07,610
これは、char型のスターだ。

499
00:23:07,610 --> 00:23:10,950
これは、シリーズへのポインタである
文字の。

500
00:23:10,950 --> 00:23:12,200
だからここにダウン - 

501
00:23:12,200 --> 00:23:23,710

502
00:23:23,710 --> 00:23:25,890
>> だから、これはこれだろうかです
メモリ上のワーク。

503
00:23:25,890 --> 00:23:27,410
これは、メモリアドレスを記憶するであろう。

504
00:23:27,410 --> 00:23:31,770
これは、メモリアドレスを記憶するのであろう
配列の最初の文字。

505
00:23:31,770 --> 00:23:33,830
そして、あなたが続く場合
ポインタは、だろう

506
00:23:33,830 --> 00:23:35,200
最初の文字を取得します。

507
00:23:35,200 --> 00:23:38,780
>> そして、あなたがどの​​ようにこの事を読んでいる場合は、
文字列は、お使いのコンピュータがスマートです

508
00:23:38,780 --> 00:23:42,930
知っているのに十分な、この全体のことを読んで
それはバックラッシュ0になるまで。

509
00:23:42,930 --> 00:23:45,530
しかし、あなたはそれをある文字を読んでいる場合は、
あなたが繰り返し処理しているため、時間、

510
00:23:45,530 --> 00:23:49,910
この文字列は、あなただけ読み取られます
当時の文字あなたが表示されるまで

511
00:23:49,910 --> 00:23:50,850
バックスラッシュ0。

512
00:23:50,850 --> 00:23:52,335
それはあなたに答えない可能性があります
質問、しかし。

513
00:23:52,335 --> 00:23:55,610
>> 学生：ええ、しかし、あなたはそうではありません
その領域をmallocさ

514
00:23:55,610 --> 00:23:58,400
まだそのポインタのため。

515
00:23:58,400 --> 00:24:02,510
>> JASONハーシュホーン：だから私はかなりわからないんだけど
まさにあなたが見ている、

516
00:24:02,510 --> 00:24:03,640
私はそのクイズをしなかったからです。

517
00:24:03,640 --> 00:24:06,370
それが役立つことになっていた
別のタスクフォースからのリソース。

518
00:24:06,370 --> 00:24:11,380
あなたは上の文字列を作成する場合
積み重ねたり、ローカル変数として、それはよ

519
00:24:11,380 --> 00:24:16,920
ただ料金の配列ではなく、
を指し、一般的にchar型のスター

520
00:24:16,920 --> 00:24:18,600
別の文字列。

521
00:24:18,600 --> 00:24:20,550
しかし、私は知らない。

522
00:24:20,550 --> 00:24:25,065
それはまた別のへのポインタ可能性
スタック上の文字列だけでなく。

523
00:24:25,065 --> 00:24:27,240
うん。

524
00:24:27,240 --> 00:24:31,116
>> 学生：私はあなたがする必要があることを知っている
ポインタの場合メモリを割り当てる

525
00:24:31,116 --> 00:24:33,360
内部宣言したばかり
別の関数の。

526
00:24:33,360 --> 00:24:36,740
それはだ場合には、同じことをする必要がありますか
メイン内で宣言されている、

527
00:24:36,740 --> 00:24:39,570
あなたは、メインの内側に使用している？

528
00:24:39,570 --> 00:24:43,590
>> JASONハーシュホーン：そうです。

529
00:24:43,590 --> 00:24:46,670
任意のポインタを宣言することができます
メモリ内のメモリアドレス。

530
00:24:46,670 --> 00:24:51,440
これは、ローカルのメモリアドレスを指定できます
変数、しばしば、しかし、

531
00:24:51,440 --> 00:24:55,760
人々は、メモリアドレスを宣言していない
彼らが行くので、ローカル変数へ

532
00:24:55,760 --> 00:24:59,890
離れているその関数が戻ると、一度
我々は、一般的に物事をのmalloc理由です。

533
00:24:59,890 --> 00:25:04,630
しかし、はい、あなたは、ポインタを宣言することができ
別のローカル変数へ。

534
00:25:04,630 --> 00:25:06,360
それは、単に一般的に行われていないだ。

535
00:25:06,360 --> 00:25:09,480
しかし、私はそれを見てみることができます
クラス後の比のこと。

536
00:25:09,480 --> 00:25:10,650
うん。

537
00:25:10,650 --> 00:25:12,350
>> 学生：私はこれは一種だと思う
求められているのかの。

538
00:25:12,350 --> 00:25:16,930
それが初期化されるように奇妙に思えます
ないように、ポインタ

539
00:25:16,930 --> 00:25:20,760
アドレスが、何として
値のように思える。

540
00:25:20,760 --> 00:25:25,970
CS50は、中身をあるように思える
ものが指されていると

541
00:25:25,970 --> 00:25:28,820
実際のアドレスは、右？

542
00:25:28,820 --> 00:25:30,520
>> JASONハーシュホーン：だからそれはです
いない場合、しかし。

543
00:25:30,520 --> 00:25:32,470
つまり、何が起こっているかではありません。

544
00:25:32,470 --> 00:25:35,910
あなたはchar型の星を宣言すると、
それはメモリアドレスです。

545
00:25:35,910 --> 00:25:38,860
ポインタは、すべてのメモリアドレスである
何か他のものを指す。

546
00:25:38,860 --> 00:25:41,480
他に、何かが上に置くことができます
スタックが、ほとんどの場合である

547
00:25:41,480 --> 00:25:43,440
我々はそれが使用され表示されます方法でヒープ。

548
00:25:43,440 --> 00:25:46,860

549
00:25:46,860 --> 00:25:53,500
しかし<Stringname>が二重引用符に等しい
我々は、我々を見ることができる」、getStringを "

550
00:25:53,500 --> 00:25:55,010
それに目を通すと、それをコーディングすることができます。

551
00:25:55,010 --> 00:26:01,190
GetStringメソッド文字列は、内に保存されていない
その変数、または何列

552
00:26:01,190 --> 00:26:04,580
名前はその中に保存されていないされている
変数、それがどのようにではないので

553
00:26:04,580 --> 00:26:06,070
ポインターの仕事。

554
00:26:06,070 --> 00:26:06,770
それは理にかなっていますか？

555
00:26:06,770 --> 00:26:07,170
>> 学生：うん。

556
00:26:07,170 --> 00:26:08,570
>> JASONハーシュホーン：わかりました。

557
00:26:08,570 --> 00:26:11,690
うまくいけば、それはありませんでした
誰にも分かりにくい。

558
00:26:11,690 --> 00:26:15,732
それがあったなら、我々は再びそれを見ることができます
ビットでは、実際に行っているので、

559
00:26:15,732 --> 00:26:19,240
うまくいけば何かをコーディングする
文字列を操作すると、あなたが感じる手助け

560
00:26:19,240 --> 00:26:22,170
彼らとより快適に。

561
00:26:22,170 --> 00:26:24,869
>> これらに関連した他の質問
トピックや他のトピック

562
00:26:24,869 --> 00:26:26,119
私は、バックアップを置くことにしましょう​​？

563
00:26:26,119 --> 00:26:32,280

564
00:26:32,280 --> 00:26:34,840
そして - 

565
00:26:34,840 --> 00:26:36,310
今。

566
00:26:36,310 --> 00:26:37,630
はい、オールデン。

567
00:26:37,630 --> 00:26:39,860
>> ALDEN：これは完全に無関係である、
しかし、我々はわずかに行くことができます

568
00:26:39,860 --> 00:26:42,760
本当にすぐに我々が知っておくべきこと
32との違いについて

569
00:26:42,760 --> 00:26:46,345
64ビットマシン？

570
00:26:46,345 --> 00:26:47,740
>> JASONハーシュホーン：はい。

571
00:26:47,740 --> 00:26:52,111
だから、32ビットは何バイトですか？

572
00:26:52,111 --> 00:26:53,060
>> ALDEN：それは4バイトです。

573
00:26:53,060 --> 00:26:54,360
>> JASONハーシュホーン：これは、4バイトです。

574
00:26:54,360 --> 00:26:58,420
そして64ビットは何バイトですか？

575
00:26:58,420 --> 00:26:59,112
>> 学生：エイト。

576
00:26:59,112 --> 00:27:00,610
>> JASONハーシュホーン：8バイト。

577
00:27:00,610 --> 00:27:03,980
だからもう一度、8ビットが1バイトである。

578
00:27:03,980 --> 00:27:08,340
あなたCS50アプライアンスです
32ビットマシン。

579
00:27:08,340 --> 00:27:13,650
そのように、メモリアドレスは、
4バイト長。

580
00:27:13,650 --> 00:27:17,460
2は32にあります。
メモリアドレス。

581
00:27:17,460 --> 00:27:21,310
0〜32のマイナス1から2へ。

582
00:27:21,310 --> 00:27:27,630
そして、私は肯定的ではないけど、それはです
おそらくあなたがする必要があるものの範囲を

583
00:27:27,630 --> 00:27:35,230
そのメモリ、32ビットマシンのために知って
アドレスは、再度、4バイト長である

584
00:27:35,230 --> 00:27:39,620
それが最大量だ
メモリアドレスの。

585
00:27:39,620 --> 00:27:41,680
>> また、データの種類 - 

586
00:27:41,680 --> 00:27:45,020
これは、何かあるかもしれない
よくそれは注目に値します。

587
00:27:45,020 --> 00:27:49,610
データ型のサイズが依存
あなたが作業しているマシン。

588
00:27:49,610 --> 00:27:56,760
そうCHAR、単一の文字は、どのように
私たちのCS50アプライアンス上の何バイト？

589
00:27:56,760 --> 00:27:57,980
1バイト。

590
00:27:57,980 --> 00:28:02,310
そしてそれは実際には1バイトとしてだ
64ビットマシン上で十分。

591
00:28:02,310 --> 00:28:05,920
>> そして、ほとんどのデータ型は、同じ数である
両方のマシンでバイト。

592
00:28:05,920 --> 00:28:11,620
しかし、いくつかのデータ·タイプは異なるであろう
両方のマシンで。

593
00:28:11,620 --> 00:28:14,590
だから、潜在的になります
あなたが知る必要がある唯一のもの。

594
00:28:14,590 --> 00:28:16,710
>> それでも、それは、私が思うに、
境界を超えている - 

595
00:28:16,710 --> 00:28:20,990
あなたが戻って見れば、私は、ほとんど肯定的だ
古いクイズで、それによると、用を前提と

596
00:28:20,990 --> 00:28:24,090
あなたが使用しているコーディングの問題
32ビットマシン。

597
00:28:24,090 --> 00:28:26,620

598
00:28:26,620 --> 00:28:30,620
しかし、その中で一緒に行くために、ある
あなたが興味を持っているケースがある

599
00:28:30,620 --> 00:28:35,920
同じであるデータ·タイプ
すべてのマシン上のサイズ。

600
00:28:35,920 --> 00:28:42,670
>> あなたのような何かを見てきた場合
のuint32_t、あなたは月か5月

601
00:28:42,670 --> 00:28:43,260
それを見てきていない。

602
00:28:43,260 --> 00:28:44,290
つまり、データ·タイプです。

603
00:28:44,290 --> 00:28:47,570
つまり、どんなに32ビットとすることが、言っている
これは何のマシン上にある。

604
00:28:47,570 --> 00:28:50,350
だから、人々は、ポータブルを書いているとき
コー​​ド、彼らはおそらくint型を使用することはありません。

605
00:28:50,350 --> 00:28:53,260
彼らは代わりにこれらの他のデータを使用します
彼らが知っているタイプは同じになります

606
00:28:53,260 --> 00:28:54,780
すべての単一のマシン上のサイズ。

607
00:28:54,780 --> 00:28:58,080

608
00:28:58,080 --> 00:28:58,250
マデュ。

609
00:28:58,250 --> 00:29:00,150
>> マデュ：私は疑問を持っていた
コンパイルプロセス。

610
00:29:00,150 --> 00:29:04,110
だから、使用するプログラムを書いている場合は、
CS50か何かのようなライブラリ

611
00:29:04,110 --> 00:29:06,840
そのように、私が知っているそのライブラリ
ある時点で、でなければならない

612
00:29:06,840 --> 00:29:08,590
コンパイルされ、リンクされたインチ

613
00:29:08,590 --> 00:29:13,380
しかし、どのくらいそれの最中に発生
あなたのプログラムのコンパイル？

614
00:29:13,380 --> 00:29:15,880
そのライブラリ·プロセスのどの部分
あなたがしている場合に発生します

615
00:29:15,880 --> 00:29:18,560
独自のプログラムをコンパイルする？

616
00:29:18,560 --> 00:29:24,020
>> JASONハーシュホーン：それでは見ていきましょう
このプロセスの一般的手順。

617
00:29:24,020 --> 00:29:26,280
あなたの。Cファイルを記述します。

618
00:29:26,280 --> 00:29:33,530
あなたのcファイルでは、＃が含まれ、あなたの
ヘッダ·ライブラリーは、例えば、cs50.h.

619
00:29:33,530 --> 00:29:39,480
シャープが含まれていることを何をする
行は、プログラムに何？

620
00:29:39,480 --> 00:29:40,525
Akchar。

621
00:29:40,525 --> 00:29:43,350
>> AKCHAR：それはのプロトタイプを追加します
ヘッダからの機能

622
00:29:43,350 --> 00:29:45,120
ライブラリ内のファイル。

623
00:29:45,120 --> 00:29:45,600
>> JASONハーシュホーン：その通りです。

624
00:29:45,600 --> 00:29:49,870
それは、これらの関数プロトタイプを追加します
あなたのコードに。

625
00:29:49,870 --> 00:29:55,230
だからあなたのコードは、コンパイルされているとき
初期段階は、コンパイラは知っている

626
00:29:55,230 --> 00:29:59,250
これらの機能は実際に存在していること、および
どこかでそれらが定義されていること。

627
00:29:59,250 --> 00:30:02,460
hファイルには含まれていません
これらの関数の定義や方法

628
00:30:02,460 --> 00:30:03,950
彼らは実際に動作します。

629
00:30:03,950 --> 00:30:07,960
Cs50.hはちょうど言う何かを含んでいる
のgetStringは本物です

630
00:30:07,960 --> 00:30:09,270
発生する可能性があります。

631
00:30:09,270 --> 00:30:14,240
そしてstandardio.hは、printfがあると言います
発生する可能性が本物。

632
00:30:14,240 --> 00:30:23,190
>> だから、これを使ってC言語のヘッダ
ファイルがいくつかになって取得

633
00:30:23,190 --> 00:30:27,750
最終的には機械読み取り可能なコードは、
バイナリになって取得

634
00:30:27,750 --> 00:30:30,030
コー​​ド、0と1。

635
00:30:30,030 --> 00:30:33,590
そして、それは最終的にコードを示します
実行されます。

636
00:30:33,590 --> 00:30:38,550
-L CS50ライン - 例えば、
あなたはクラングを書いているとき - 

637
00:30:38,550 --> 00:30:41,830
そしてその後には、-LをCS50を、
あなたはそれをインチタイプ

638
00:30:41,830 --> 00:30:42,180
そして、あなたはそれを参照してください。

639
00:30:42,180 --> 00:30:43,890
あなたが作る記述するときは、よ
ここまで、その行を参照してください。

640
00:30:43,890 --> 00:30:47,740
そして、我々はときに、第2に、その表示されます
私たちは、コードまたはそれ以降のときに我々のコードに。

641
00:30:47,740 --> 00:30:50,390
>> しかし、それの-l CS50ラインは何かを
より少し異なる

642
00:30:50,390 --> 00:30:52,440
第cs50.h.を含む

643
00:30:52,440 --> 00:30:56,300
その-L CS50ラインは何をするのでしょうか？

644
00:30:56,300 --> 00:30:56,820
AVI？

645
00:30:56,820 --> 00:31:00,310
>> AVIファイル：私はそれがリンクしていることを言いたい
関数のライブラリ

646
00:31:00,310 --> 00:31:02,710
。oファイルと同じように、呼び出します。

647
00:31:02,710 --> 00:31:08,200
>> JASONハーシュホーン：だから、非常に
近くに、スポットオンされていない場合。

648
00:31:08,200 --> 00:31:16,220
-LのCS50は、バイナリファイルを取得し、
あなたのバイナリファイルとそれをマージします。

649
00:31:16,220 --> 00:31:21,410
そうcs50.h、旋回しても意味がありません
あらゆるをバイナリにC言語からcs50.h

650
00:31:21,410 --> 00:31:23,130
それが使われている単一の時間。

651
00:31:23,130 --> 00:31:26,650
それだから、愚かなことだろう
多くの時間を浪費することになる。

652
00:31:26,650 --> 00:31:30,420
だから、すでにコンパイルされている
および実行可能になった。

653
00:31:30,420 --> 00:31:35,430
そして今、それがマージされようとしている
最後に、あなたのファイルを使用して。

654
00:31:35,430 --> 00:31:38,370
ので、これらの1のと0をしようとしている
お使いのものと合併する

655
00:31:38,370 --> 00:31:39,150
そして最後に0の。

656
00:31:39,150 --> 00:31:43,670
だから今は、実際には、実際のがあるでしょう
1と0の方法は、getStringを定義する、

657
00:31:43,670 --> 00:31:47,890
例えば、機能する、またはどのようにprintf関数
例えば、動作します。

658
00:31:47,890 --> 00:31:52,750
>> および詳細については、あります
ネイトがいることを示します短いコンパイラ

659
00:31:52,750 --> 00:31:55,410
あなたはそれが行くチェックアウトする必要があります
こうした工程を経て。

660
00:31:55,410 --> 00:31:56,050
しかし - 

661
00:31:56,050 --> 00:31:56,560
はい。

662
00:31:56,560 --> 00:32:01,700
>> 学生：彼らはで常にOファイル。
彼らは、ライブラリ形式にいるとき、

663
00:32:01,700 --> 00:32:06,764
のように - リンク、マージする準備ができて
彼らは、バイナリコードにしている？

664
00:32:06,764 --> 00:32:07,600
>> JASONハーシュホーン：わかりました。

665
00:32:07,600 --> 00:32:08,420
何が - 

666
00:32:08,420 --> 00:32:11,780
>> 学生：それはいつもの場合である
あなたがそれらをリンクライブラリ？

667
00:32:11,780 --> 00:32:12,500
>> JASONハーシュホーン：はい。

668
00:32:12,500 --> 00:32:17,300
そう。Sはされるファイルは、あります
また、になりますマシンコード、

669
00:32:17,300 --> 00:32:17,975
あなたに不可解。

670
00:32:17,975 --> 00:32:19,410
あなたがそれらを心配する必要はありません。

671
00:32:19,410 --> 00:32:24,930
しかし、一般的には、そう、彼らはよ
Oは行く準備ができてファイルをインチであること。

672
00:32:24,930 --> 00:32:27,170
>> 学生：あなたはに出荷
ライブラリには、あなただけ出荷します

673
00:32:27,170 --> 00:32:28,880
。時間と。O？

674
00:32:28,880 --> 00:32:32,210
あなたは。cまたは。Sを出荷しないでください。

675
00:32:32,210 --> 00:32:33,070
>> JASONハーシュホーン：だから - 

676
00:32:33,070 --> 00:32:36,260
これがあれば、同様に、この短いです
この情報は来ているようです

677
00:32:36,260 --> 00:32:36,700
少し迅速。

678
00:32:36,700 --> 00:32:39,870
しかし、コンパイラで短い
だけでなく、このことについて話しています。

679
00:32:39,870 --> 00:32:43,290
あなたが出荷している場合は、ライブラリを出荷するとき
。H、ヘッダファイル、それらの

680
00:32:43,290 --> 00:32:46,290
関数のプロトタイプ、および1のと
0年代、それはあなたが与える必要がすべてです。

681
00:32:46,290 --> 00:32:50,640
あなたはどのように与える必要はありません。
この関数は、。Cファイルを動作します。

682
00:32:50,640 --> 00:32:56,360
抽象化のポイント、または理由
APIを指し、このSPLでのポイント、

683
00:32:56,360 --> 00:32:59,650
スタンフォードポータブルなライブラリ、それはだ
あなたが心配しないようにするにはどのように新しい

684
00:32:59,650 --> 00:33:04,220
GRectに動作するか、どのように作品を移動し、
またはどのように作品を追加します。

685
00:33:04,220 --> 00:33:06,520
あなたが知る必要があるのは、その追加するだけです
あなたができる機能です

686
00:33:06,520 --> 00:33:08,880
使用しており、それがこれを行います。

687
00:33:08,880 --> 00:33:12,760
だから、実際にどのように知っている必要はありません
それはちょうどする必要がであなたの中に書かれている

688
00:33:12,760 --> 00:33:15,460
ここでは、知っている関数であり、彼らは何
行って、ここに1と0である

689
00:33:15,460 --> 00:33:18,870
あなたが実際にそれらを使用したい場合。

690
00:33:18,870 --> 00:33:19,530
>> 涼しい。

691
00:33:19,530 --> 00:33:26,980
コンパイラで、それ以上の質問
またはボード上の他のトピック？

692
00:33:26,980 --> 00:33:30,300
>> 学生：私は疑問を持っている
再帰関数を実装する。

693
00:33:30,300 --> 00:33:31,170
再帰についての質問。

694
00:33:31,170 --> 00:33:33,030
私は出てくるだろう気持ちを持っていた。

695
00:33:33,030 --> 00:33:38,310
それでは、すぐに通す
特定した再帰

696
00:33:38,310 --> 00:33:40,690
たとえば、階乗関数。

697
00:33:40,690 --> 00:33:44,920
これは一例ですので、
頻繁にアップするか、使用されている

698
00:33:44,920 --> 00:33:46,170
再帰を説明するために。

699
00:33:46,170 --> 00:33:52,390

700
00:33:52,390 --> 00:33:56,410
>> だから、「4！ " 4の階乗として読み込まれます。

701
00:33:56,410 --> 00:33:59,120
そして4階乗とは何を意味するのでしょうか？

702
00:33:59,120 --> 00:34:00,696
それは何をしますか？

703
00:34:00,696 --> 00:34:02,235
どのようにして4の階乗を計算するのですか？

704
00:34:02,235 --> 00:34:05,250

705
00:34:05,250 --> 00:34:07,960
4回3回2回1。

706
00:34:07,960 --> 00:34:11,889
>> 4の階乗を書くためのそう別の方法
これを書くことです。

707
00:34:11,889 --> 00:34:16,780

708
00:34:16,780 --> 00:34:19,022
4回3階乗。

709
00:34:19,022 --> 00:34:22,080
3階乗であるため、
3回2回1。

710
00:34:22,080 --> 00:34:27,580
だから、4回3階乗は4です
回3回2回1。

711
00:34:27,580 --> 00:34:32,679
階乗が大きいのはこのためです
再帰の候補、それはだから

712
00:34:32,679 --> 00:34:36,630
その何かがあることが明らか
に何度も繰り返し起こる

713
00:34:36,630 --> 00:34:39,820
物事の数が少ない時まで
あなたが最後に到達する。

714
00:34:39,820 --> 00:34:42,570
あなたが1に達すると、1階乗は1である。

715
00:34:42,570 --> 00:34:43,719
あなたは、はるかに先に進むことはできません。

716
00:34:43,719 --> 00:34:47,219
0階乗も1として定義されています。

717
00:34:47,219 --> 00:34:50,679
あなたは1か0に到達したときだから、あなたがしている
最後には、あなたのことができます

718
00:34:50,679 --> 00:34:53,219
バック上がって起動してください。

719
00:34:53,219 --> 00:34:59,540
だから我々は、再帰的に書きたい場合は、
階乗を計算する関数、

720
00:34:59,540 --> 00:35:02,170
我々はいくつかの書き込みを行っている
今そのための擬似コード。

721
00:35:02,170 --> 00:35:03,300
我々はその擬似コードを書く前に - 

722
00:35:03,300 --> 00:35:05,660
私はあなたたちに数分を差し上げます
擬似コードを書くか、単に考えること

723
00:35:05,660 --> 00:35:09,600
それについて - あらゆる2つあります
再帰関数を必要とします。

724
00:35:09,600 --> 00:35:12,530
これら二点は何ですか？

725
00:35:12,530 --> 00:35:13,220
>> ジャック：それは自分自身を呼び出す必要があります。

726
00:35:13,220 --> 00:35:13,680
>> JASONハーシュホーン：ノア？

727
00:35:13,680 --> 00:35:14,460
ああ、ジャック。

728
00:35:14,460 --> 00:35:15,100
どうぞ召しあがれ。

729
00:35:15,100 --> 00:35:16,640
>> ジャック：それは自分自身を呼び出す必要があります。

730
00:35:16,640 --> 00:35:19,220
>> JASONハーシュホーン：だから再帰
この関数は、再帰呼び出しを必要とします

731
00:35:19,220 --> 00:35:20,220
自身に呼び出します。

732
00:35:20,220 --> 00:35:20,770
それは一つだ。

733
00:35:20,770 --> 00:35:21,510
そして他の事は何ですか？

734
00:35:21,510 --> 00:35:22,250
>> ジャック：ベースケース。

735
00:35:22,250 --> 00:35:23,780
>> JASONハーシュホーン：ベースケース。

736
00:35:23,780 --> 00:35:26,940
ベースケースは、我々が停止したときにここにいる。

737
00:35:26,940 --> 00:35:29,510
だからあなたの関数が呼び出されます。

738
00:35:29,510 --> 00:35:31,410
ベースケースは最初に来る。

739
00:35:31,410 --> 00:35:33,710
あなたが最後にいるかどうかを知りたい。

740
00:35:33,710 --> 00:35:37,110
そして、あなたが最後にいないのであれば、あなた
あなたの再帰呼び出しを行います。

741
00:35:37,110 --> 00:35:39,880
そして、あなたは、もう一度この関数を通じて、
もう一度基本ケースを確認してください。

742
00:35:39,880 --> 00:35:42,575
あなたは終わりではないなら、あなたは作る
別の再帰呼び出し、

743
00:35:42,575 --> 00:35:44,130
エトセトラ、エトセトラ。

744
00:35:44,130 --> 00:35:47,110
>> だからこそ、再帰関数は常にです
これらの基本ケースを必要とし、これらの

745
00:35:47,110 --> 00:35:48,210
再帰呼び出し。

746
00:35:48,210 --> 00:35:51,280
あなたは再帰呼び出しを持っていない場合は、
再帰関数ではないでしょう。

747
00:35:51,280 --> 00:35:53,210
あなたはベースケースを持っていなかった場合は、
あなたは永遠に行くだろうし、

748
00:35:53,210 --> 00:35:54,780
何結末はないだろう。

749
00:35:54,780 --> 00:35:57,870
そしてベースケースは、常に最初に来る、
あなたは常にチェックすることになるでしょうので

750
00:35:57,870 --> 00:36:00,420
あなたが最初に最後にしている場合。

751
00:36:00,420 --> 00:36:04,770
だから我々は、いくつかの擬似コードを実行する前に、なぜ
あなたが考えるように分を取ることはありません

752
00:36:04,770 --> 00:36:09,360
どのように再帰的な階乗関数
書かれたのでしょうか？

753
00:36:09,360 --> 00:36:23,340

754
00:36:23,340 --> 00:36:26,010
>> また、あなたがやっていると同じ数の書き込み
そのうちの紙のシート上にある

755
00:36:26,010 --> 00:36:27,960
何をする必要があるとしている
明日のクイズで行う。

756
00:36:27,960 --> 00:36:32,160
にするので、おそらく良いプラクティス
あなたが書いているコードを確認してください

757
00:36:32,160 --> 00:36:34,420
用紙上にダウン - 

758
00:36:34,420 --> 00:36:35,160
またはあなたがそれを行うことができます。

759
00:36:35,160 --> 00:36:36,710
セミコロンがどこにあなたが知っている。

760
00:36:36,710 --> 00:36:37,660
次の構文を覚えています。

761
00:36:37,660 --> 00:36:40,400
あなたが持つことができるようにしていないため、
コンパイラはエラーをした言う。

762
00:36:40,400 --> 00:37:02,356

763
00:37:02,356 --> 00:37:07,240
>> また、それらの線に沿って、明日、とき
あなた場合は、問題をコード化している

764
00:37:07,240 --> 00:37:11,490
時間急いで、またはあなたは非常になられている
あなたがことになっているかのように混乱

765
00:37:11,490 --> 00:37:16,030
それは、C内の特定の事を書く
擬似コードを書くことができます当然であるだろう

766
00:37:16,030 --> 00:37:18,160
または同様にコメントを書き込む。

767
00:37:18,160 --> 00:37:21,940
のための部分的な信用がありますので、
クイズに多くの質問。

768
00:37:21,940 --> 00:37:24,840
だから、あなたが急いで、または可能性があります
ちょうど混同される可能性があります。

769
00:37:24,840 --> 00:37:28,030
コメントや擬似コードで書く
多くの場合の方法としていること

770
00:37:28,030 --> 00:37:29,360
部分的な信用を得ることができます。

771
00:37:29,360 --> 00:37:31,440
>> だから、何かを残していない
クイズの空白。

772
00:37:31,440 --> 00:37:33,490
には罰則はありません
インチのものを入れて

773
00:37:33,490 --> 00:37:37,650
実際には、擬似コードでパッティングまたは
コメントは、年生を助けるために起こっている

774
00:37:37,650 --> 00:37:40,410
あなたが実際に何を知っていれば把握
あなたは多分賞について話しています

775
00:37:40,410 --> 00:37:42,030
もし、そのためのいくつかの部分的な信用。

776
00:37:42,030 --> 00:37:44,510
>> また、それらの線に沿って、明確に記述します。

777
00:37:44,510 --> 00:37:47,650
私たちは本当にあなたが書いていることができないものであれば、
私たちはあなたを呼び出すするつもりはない

778
00:37:47,650 --> 00:37:49,900
図のように、深夜、明日の
あなたが書いたのかを。

779
00:37:49,900 --> 00:37:51,520
我々だけでポイントを取るつもりです。

780
00:37:51,520 --> 00:37:56,570
私たちが聞くことができる、というより、明らかに書き込み、
我々はあなたが書いたものを読むことができます。

781
00:37:56,570 --> 00:38:00,230
>> そして、それは2文を言えば、
段落を書いてはいけません。

782
00:38:00,230 --> 00:38:02,280
指示に従ってください。

783
00:38:02,280 --> 00:38:03,500
はっきりと書きます。

784
00:38:03,500 --> 00:38:07,720
そして、それらのコメントに書いたり、
その可能性の質問のための擬似コード

785
00:38:07,720 --> 00:38:10,270
賞部分信用。

786
00:38:10,270 --> 00:38:12,520
>> さあ、階乗に行きましょう。

787
00:38:12,520 --> 00:38:15,000
だから我々は、関数階乗を持っている。

788
00:38:15,000 --> 00:38:18,400

789
00:38:18,400 --> 00:38:21,550
私は実際にC言語でこれを書くとしたら、
どのような私は名前の前に配置する必要があります

790
00:38:21,550 --> 00:38:22,800
関数の？

791
00:38:22,800 --> 00:38:24,880

792
00:38:24,880 --> 00:38:30,060
この中で、戻り値の型、
場合、我々はそれにINTを与えるでしょう。

793
00:38:30,060 --> 00:38:35,450
した後、中括弧内で、
何のために中括弧の内部に入る

794
00:38:35,450 --> 00:38:36,850
機能？

795
00:38:36,850 --> 00:38:37,950
>> 学生：引数の型。

796
00:38:37,950 --> 00:38:39,150
>> JASONハーシュホーン：その引数。

797
00:38:39,150 --> 00:38:42,680
そう階乗うおそらく
引数を取る。

798
00:38:42,680 --> 00:38:44,500
それはおそらく唯一の引数を取るよ。

799
00:38:44,500 --> 00:38:49,450
そして、我々はそれが取るよ言うよ
整数Xと呼ばれる。

800
00:38:49,450 --> 00:38:52,770
そして再び、のプロトタイプを書くとき
関数や関数を書く

801
00:38:52,770 --> 00:38:57,110
それを定義する前に、あなたのコードでは、
データ型との名前を書く

802
00:38:57,110 --> 00:39:01,370
のみ、その関数のその変数。

803
00:39:01,370 --> 00:39:06,350
だから、この中に、いくつかの番号を渡すことができます
関数は、xと呼ぶこともできます

804
00:39:06,350 --> 00:39:07,340
内部的。

805
00:39:07,340 --> 00:39:08,755
>> 私たちは、階乗関数を持っている。

806
00:39:08,755 --> 00:39:12,030

807
00:39:12,030 --> 00:39:15,850
私たちは、基本ケースの2つが必要
と再帰呼び出し。

808
00:39:15,850 --> 00:39:20,900
階乗のための基本ケースとは何ですか？

809
00:39:20,900 --> 00:39:24,850
それを書いていないがあります誰か
まだ話され、ベースは何ですか

810
00:39:24,850 --> 00:39:26,100
階乗のためのケース？

811
00:39:26,100 --> 00:39:28,400

812
00:39:28,400 --> 00:39:30,930
>> 学生：nが小さい場合
2よりも、1を返す。

813
00:39:30,930 --> 00:39:33,520
>> JASONハーシュホーン：nがある場合
2未満、1を返します。

814
00:39:33,520 --> 00:39:37,216
そのため、私は、それが好きです
0と1の面倒を見る。

815
00:39:37,216 --> 00:39:45,290
だから我々は、X <2を行う1を返します。

816
00:39:45,290 --> 00:39:47,870
我々が得る場合、我々は、0が渡されたら
1を通過し、この関数は、意志

817
00:39:47,870 --> 00:39:49,790
すぐに1を返す。

818
00:39:49,790 --> 00:39:54,020
我々はいくつかの数字以降を渡されたら
以上または2に等しく、我々はするつもりだ

819
00:39:54,020 --> 00:39:55,370
私たちの再帰呼び出しを持っている。

820
00:39:55,370 --> 00:39:57,855
>> だからどのようにそれが仕事に行くのですか？

821
00:39:57,855 --> 00:40:01,070
することができますこのに取り組んだ他の誰か
誰がまだ語られていないことは私与える

822
00:40:01,070 --> 00:40:07,380
この関数の再帰呼び出し
擬似コード？

823
00:40:07,380 --> 00:40:10,770
我々は、数xで渡されたら
それが2よりも大きいですが、どのような

824
00:40:10,770 --> 00:40:13,370
私たちは何をしたいのですか？

825
00:40:13,370 --> 00:40:17,930
我々はまた、に書かれた例があります
あなたにヒントを与えるかもしれない側。

826
00:40:17,930 --> 00:40:20,770
>> 学生：x回コール
Xマイナス1の階乗？

827
00:40:20,770 --> 00:40:22,020
>> JASONハーシュホーン：まったく正しい。

828
00:40:22,020 --> 00:40:24,610

829
00:40:24,610 --> 00:40:37,750
我々はX回を返すつもりだ
Xマイナス1の階乗。

830
00:40:37,750 --> 00:40:41,810
そして、私が書いたとしても、その
基本的に、何を英語で言った、

831
00:40:41,810 --> 00:40:44,580
この階乗関数
再び呼び出されます。

832
00:40:44,580 --> 00:40:46,320
それは、xから1を引いた上で実行します。

833
00:40:46,320 --> 00:40:49,320
これは、いくつかの整数で戻りますし、
次いで、これら2つを乗算よ

834
00:40:49,320 --> 00:40:52,050
一緒に、その値は次のようになります
これを呼び出したところに戻った

835
00:40:52,050 --> 00:40:55,010
階乗関数、そのマイト
別のインスタンスであること

836
00:40:55,010 --> 00:40:58,420
この階乗関数。

837
00:40:58,420 --> 00:41:01,360
>> だから、再帰の一例です
機能、非常に

838
00:41:01,360 --> 00:41:02,530
簡単な再帰関数。

839
00:41:02,530 --> 00:41:04,530
それらのほとんどは、このようになる。

840
00:41:04,530 --> 00:41:11,170
あなたは良い再帰を希望
コー​​ディングしようとすると、クイズに挑戦

841
00:41:11,170 --> 00:41:13,230
再帰的に二分探索。

842
00:41:13,230 --> 00:41:18,950
あなたがバイナリ検索をした場合、以下の原因
問題は3に設定し、おそらくそれをやった

843
00:41:18,950 --> 00:41:21,730
反復してwhileループ内。

844
00:41:21,730 --> 00:41:23,700
>> しかし、それはまた書くことができます
再帰的に。

845
00:41:23,700 --> 00:41:26,310
あなた自身を書くことが必要になるだろう
いくつかを取る別の関数

846
00:41:26,310 --> 00:41:29,020
異なるコマンドライン引数 - または
ていないコマンドライン引数、いくつかの

847
00:41:29,020 --> 00:41:30,910
別の普通の引数。

848
00:41:30,910 --> 00:41:33,870
しかし、あなたはバイナリ検索を書くことができます
再帰的にも。

849
00:41:33,870 --> 00:41:36,190
>> 学生：だからあなたも書いたかもしれない、
代わりに、Xマイナス1、あなたの

850
00:41:36,190 --> 00:41:39,502
また、Xのマイナスを書かれている可能性が
マイナス、あるいは、あなたは可能性があります

851
00:41:39,502 --> 00:41:40,830
書かれたマイナスマイナスX。

852
00:41:40,830 --> 00:41:44,740
あなただけの本当にすぐに理由を説明することができます
それらは異なるものとなり、

853
00:41:44,740 --> 00:41:49,510
違いが間にあるもののように
XマイナスマイナスマイナスマイナスX？

854
00:41:49,510 --> 00:41:51,320
>> JASONハーシュホーン：いいえ、私ではない
それに行くつもり。

855
00:41:51,320 --> 00:41:55,500
しかし、私は後にそれについてあなたにお話します
クラス。 XマイナスマイナスマイナスマイナスX

856
00:41:55,500 --> 00:41:57,780
1で、Xをデクリメント。

857
00:41:57,780 --> 00:41:59,090
しかし、彼らは少し違ったそれを行う。

858
00:41:59,090 --> 00:42:00,340
しかし、私はそれに行きたくない。

859
00:42:00,340 --> 00:42:04,330

860
00:42:04,330 --> 00:42:09,090
再帰についてのその他の質問
またはこの機能？

861
00:42:09,090 --> 00:42:10,140
それは本当にさえ擬似コードではありません。

862
00:42:10,140 --> 00:42:15,060
つまり、基本的にはコードです
Cは、あなたがこれを記述します。

863
00:42:15,060 --> 00:42:19,393
>> [OK]を、他の質問
ここでのトピックまではどうでしょうか？

864
00:42:19,393 --> 00:42:19,864
うん。

865
00:42:19,864 --> 00:42:23,130
>> 学生：私は簡単に説明してい
浮動小数点および精度。

866
00:42:23,130 --> 00:42:24,260
>> JASONハーシュホーン：フローティング
ポイントと精度。

867
00:42:24,260 --> 00:42:26,920
誰か本当にすぐにできます
私の要約を与える

868
00:42:26,920 --> 00:42:28,210
浮動小数点および精度？

869
00:42:28,210 --> 00:42:30,420
あなたのすべては、あなたのためにこれをしなければならなかった
問題が設定されているので、すべてのね

870
00:42:30,420 --> 00:42:31,700
それに慣れ。

871
00:42:31,700 --> 00:42:35,090
またはそうでないかもしれないすべてのあなたの。

872
00:42:35,090 --> 00:42:36,602
誰ですか？

873
00:42:36,602 --> 00:42:39,530
私に開始したスポットを与える。

874
00:42:39,530 --> 00:42:40,750
浮動小数点および精度。

875
00:42:40,750 --> 00:42:42,380
何が問題なの？

876
00:42:42,380 --> 00:42:42,960
はい。

877
00:42:42,960 --> 00:42:43,680
ビクトリア？

878
00:42:43,680 --> 00:42:44,480
>> ヴァネッサ：ヴァネッサ。

879
00:42:44,480 --> 00:42:45,285
>> JASONハーシュホーン：ヴァネッサ。

880
00:42:45,285 --> 00:42:45,680
申し訳ありません。

881
00:42:45,680 --> 00:42:51,550
>> ヴァネッサ：有限個しかがあります
表すことのできる数の

882
00:42:51,550 --> 00:42:57,930
あなたは私たちの中で、にしているので、
場合、32ビットシステム。

883
00:42:57,930 --> 00:43:03,080
だから、ちょっとする必要が
いくつかの数字を構成しています。

884
00:43:03,080 --> 00:43:03,910
>> JASONハーシュホーン：だからそれはです
まったく正しい。

885
00:43:03,910 --> 00:43:08,110
の唯一の一定量があります
表すことのできる数。

886
00:43:08,110 --> 00:43:11,770
あなたは2の非常に大きな数を掛けると、
それは量がオーバーフローする可能性があります

887
00:43:11,770 --> 00:43:13,950
スペースであなたが表現するために持っている
整数。

888
00:43:13,950 --> 00:43:17,930
時には我々が使用する理由です
長い長いintの代わりに。

889
00:43:17,930 --> 00:43:19,210
つまり、より多くのスペースを持っています。

890
00:43:19,210 --> 00:43:21,210
つまり、より多くを保持することができます。

891
00:43:21,210 --> 00:43:24,310
>> 浮動小数点精度が関係しています
それだけでなく、関係しています

892
00:43:24,310 --> 00:43:29,300
小数であるという事実
常に表現されていない。

893
00:43:29,300 --> 00:43:29,540
申し訳ありません。

894
00:43:29,540 --> 00:43:31,280
私は、このバックアップを置いてみましょう。

895
00:43:31,280 --> 00:43:36,610
小数1.0は常にではありません
あなたが期待するような表現、

896
00:43:36,610 --> 00:43:40,770
1.000000000。

897
00:43:40,770 --> 00:43:50,360
それは時々のように表される
1.000000001または0.999999999。

898
00:43:50,360 --> 00:43:52,780
それも、89がスローされる可能性があり
どこかにある。

899
00:43:52,780 --> 00:43:56,560
ので、これらの小数ではありません
正確に行うのと同じよう表さ

900
00:43:56,560 --> 00:43:58,430
彼らが表現することを期待しています。

901
00:43:58,430 --> 00:44:00,010
>> だから、問題に設定 - 

902
00:44:00,010 --> 00:44:00,860
それは2だったか - 

903
00:44:00,860 --> 00:44:05,290
問題は、私たちが扱っ2を設定
我々が望んでいた、浮動小数点数、

904
00:44:05,290 --> 00:44:08,690
彼らは我々が望んで正確に表現するために
それらを表現するために、数

905
00:44:08,690 --> 00:44:12,860
ペニーの、またはセントの数が、
我々は、100でそれらを掛けます。

906
00:44:12,860 --> 00:44:14,750
我々はそれらを丸め。

907
00:44:14,750 --> 00:44:18,660
そして、我々はすべてを断つ
小数点以下の背後にある。

908
00:44:18,660 --> 00:44:22,020
すなわち、それらはだろうことを保証することであった
実際に我々が望んで正確に等しく

909
00:44:22,020 --> 00:44:22,410
それらが等しくなるように。

910
00:44:22,410 --> 00:44:26,870
>> あなたが何かを取るときですので、
floatと、int型へとあなたをそれを回す

911
00:44:26,870 --> 00:44:29,860
右のすべてを断つ
小数点の。

912
00:44:29,860 --> 00:44:33,900
いくつかの浮動小数点がありますので、
不正確、100.000は次のようになります。

913
00:44:33,900 --> 00:44:37,440
99.999999999として表現。

914
00:44:37,440 --> 00:44:40,350
とするだけにすべてを遮断した場合
すぐ右には、あなたがしようとしている

915
00:44:40,350 --> 00:44:41,600
間違った番号を取得します。

916
00:44:41,600 --> 00:44:44,050

917
00:44:44,050 --> 00:44:44,180
うん。

918
00:44:44,180 --> 00:44:45,290
>> 学生：私は疑問を持っていた
キャスティングについて。

919
00:44:45,290 --> 00:44:47,500
どのような順序でそれが起こるのでしょうか？

920
00:44:47,500 --> 00:44:54,480
あなたは、float、ブラケット、1分割を行いたい場合
10で、それは10で1を割ったのですか、

921
00:44:54,480 --> 00:44:58,910
0.1を入手して、それから回し
フロートにそれ？

922
00:44:58,910 --> 00:45:01,470
>> JASONハーシュホーン：あなたが行うと
10で割ったフロート1  - 

923
00:45:01,470 --> 00:45:02,550
>> 学生：うん、次に等しい - 

924
00:45:02,550 --> 00:45:04,240
まあ、それは通常どおり
、それは等しく持っている - 

925
00:45:04,240 --> 00:45:04,690
うん。

926
00:45:04,690 --> 00:45:06,760
あなたはそれフロートにしたいですよね？

927
00:45:06,760 --> 00:45:12,790
>> JASONハーシュホーン：[OK]を、私たちはするつもりだ
考え出すにセグエすることを使用

928
00:45:12,790 --> 00:45:15,390
これらの質問に対する答え
コー​​ディングを通して。

929
00:45:15,390 --> 00:45:18,180
おそらくたくさんあるだろうから
これらの微小な質問、および良い方法

930
00:45:18,180 --> 00:45:19,100
それらを解決するために、コードを介して行われます。

931
00:45:19,100 --> 00:45:21,320
だから我々は今、この権利をコーディングするつもりだ、
そして、我々は戻って行くつもりだ

932
00:45:21,320 --> 00:45:24,020
あなたが持っていた質問をコーディングします。

933
00:45:24,020 --> 00:45:24,950
>> だから、最初の行 - 

934
00:45:24,950 --> 00:45:29,390
私はそれを書かれているべきではありません - 何です
私たちはときに我々やりたい最初のこと

935
00:45:29,390 --> 00:45:32,250
geditの中で新しいファイルを開く？

936
00:45:32,250 --> 00:45:34,190
>> 学生：含めます。

937
00:45:34,190 --> 00:45:35,920
>> JASONハーシュホーン：何が含まれ？

938
00:45:35,920 --> 00:45:37,952
>> 学生：CS50ライブラリ。

939
00:45:37,952 --> 00:45:39,920
>> JASONハーシュホーン：わかりました。

940
00:45:39,920 --> 00:45:42,590
私たちは、他に何を含めるべきか？

941
00:45:42,590 --> 00:45:46,820
私達はちょうど何が起こるかを確認するつもりだ
あなたはフロートに何かをキャストする。

942
00:45:46,820 --> 00:45:48,605
しかし、私たちは、私たちがしているかどう含める必要があります
Cプログラムを書くつもり？

943
00:45:48,605 --> 00:45:49,300
>> 学生：標準I / O

944
00:45:49,300 --> 00:45:50,625
>> JASONハーシュホーン：stdio.hの。

945
00:45:50,625 --> 00:45:54,880
私たちは、実際に、このために、必要はありません
このプログラムは、cs50.h、それは言っても

946
00:45:54,880 --> 00:45:55,920
それを含めるようにして、常にいます。

947
00:45:55,920 --> 00:45:58,260
しかし、我々は常に、stdio.hのが必要なのでしょう。

948
00:45:58,260 --> 00:45:59,660
>> 学生：C言語でコーディング？

949
00:45:59,660 --> 00:46:15,770
>> JASONハーシュホーン：Cでのコーディング

950
00:46:15,770 --> 00:46:17,090
>> だから私はこのcファイルとして保存します。

951
00:46:17,090 --> 00:46:18,590
私はいくつかの素晴らしい構文の強調表示を取得します。

952
00:46:18,590 --> 00:46:22,890
私は、メインの内側に空洞を書きました。

953
00:46:22,890 --> 00:46:24,792
ボイドが何を意味するのか？

954
00:46:24,792 --> 00:46:26,740
>> 学生：任意のをとりません
コマンドライン引数。

955
00:46:26,740 --> 00:46:28,900
>> JASONハーシュホーン：このボイド手段、
場合、メインはいずれも取りません

956
00:46:28,900 --> 00:46:29,700
コマンドライン引数。

957
00:46:29,700 --> 00:46:32,720
他の場合には、機​​能手段
コマンドライン引数をとりません。

958
00:46:32,720 --> 00:46:36,560
または関数が、私がいた場合は、無効を書き込む
メインのだと思います、メイン（無効）、

959
00:46:36,560 --> 00:46:38,460
何も返さない。

960
00:46:38,460 --> 00:46:39,960
だから、ボイドがちょうど何の意味もない。

961
00:46:39,960 --> 00:46:42,510
私はとしたら、私は何を書くだろう
コマンドライン引数を取る？

962
00:46:42,510 --> 00:46:45,250

963
00:46:45,250 --> 00:46:47,150
>> 学生：int型のアークC文字列アークV.

964
00:46:47,150 --> 00:46:49,055
>> JASONハーシュホーン：INT
ARGC文字列ARGV。

965
00:46:49,055 --> 00:46:54,050

966
00:46:54,050 --> 00:46:55,572
その権利はありますか？

967
00:46:55,572 --> 00:46:58,720
>> 学生：それは、charスターARGVブラケットです。

968
00:46:58,720 --> 00:47:01,730
>> JASONハーシュホーン：だから、書くことができます
文字列ARGVブラケットまたはcharスターARGV

969
00:47:01,730 --> 00:47:03,710
括弧はできますが、括弧を必要としています。

970
00:47:03,710 --> 00:47:06,290
argvは配列であるため、
文字列で、覚えています。

971
00:47:06,290 --> 00:47:07,360
それはちょうど1文字列ではありません。

972
00:47:07,360 --> 00:47:10,350
だから、文字列argvはここ、だである
ARGVと呼ばれる1文字列。

973
00:47:10,350 --> 00:47:13,630
文字列ARGVブラケット、ここにある
文字列の配列。

974
00:47:13,630 --> 00:47:17,865
だから、int型ARGC列ARGVブラケット
私ものになるだろう

975
00:47:17,865 --> 00:47:18,810
おそらく書くでしょう。

976
00:47:18,810 --> 00:47:23,050
>> だから、整数で保存したいですか？

977
00:47:23,050 --> 00:47:24,285
>> 学生：ええ、整数。

978
00:47:24,285 --> 00:47:25,840
またはフロート中。

979
00:47:25,840 --> 00:47:26,710
>> JASONハーシュホーン：フロート？

980
00:47:26,710 --> 00:47:30,790
同様に、フロートxは10で割った1に相当します。

981
00:47:30,790 --> 00:47:32,040
>> JASONハーシュホーン：わかりました。

982
00:47:32,040 --> 00:47:40,160

983
00:47:40,160 --> 00:47:42,240
どのように私は、printfでフロートを印刷しますか？

984
00:47:42,240 --> 00:47:45,100

985
00:47:45,100 --> 00:47:46,714
何が？

986
00:47:46,714 --> 00:47:47,560
>> 学生：％F。

987
00:47:47,560 --> 00:47:48,300
>> JASONハーシュホーン：％F。

988
00:47:48,300 --> 00:47:50,810
整数は何ですか？

989
00:47:50,810 --> 00:47:52,110
DまたはI。

990
00:47:52,110 --> 00:47:53,000
文字列は何ですか？

991
00:47:53,000 --> 00:47:54,240
>> 学生：S。

992
00:47:54,240 --> 00:47:56,140
>> JASONハーシュホーン：S。

993
00:47:56,140 --> 00:47:57,550
どのように新しい行を取得するのですか？

994
00:47:57,550 --> 00:47:58,800
>> 学生：バックスラッシュN。

995
00:47:58,800 --> 00:48:04,610

996
00:48:04,610 --> 00:48:07,100
>> JASONハーシュホーン：私が何を返すか
メインラン正しくたら？

997
00:48:07,100 --> 00:48:08,360
>> 学生：0。

998
00:48:08,360 --> 00:48:09,430
私も、その行を記述する必要がありますか？

999
00:48:09,430 --> 00:48:10,170
>> 学生：いいえ。

1000
00:48:10,170 --> 00:48:11,513
[OK]を、我々はそれから、それを書くことはありません。

1001
00:48:11,513 --> 00:48:16,450

1002
00:48:16,450 --> 00:48:17,190
誰もがそれを読むことはできますか？

1003
00:48:17,190 --> 00:48:18,485
それは少し小さく見える。

1004
00:48:18,485 --> 00:48:20,160
誰もが参照するか、または必要がありますすることができ
私はそれを大きくする？

1005
00:48:20,160 --> 00:48:23,480

1006
00:48:23,480 --> 00:48:25,100
私はカメラのために、我々が作ると思う
しかし、それは少し大きめ。

1007
00:48:25,100 --> 00:48:35,750

1008
00:48:35,750 --> 00:48:38,410
>> JASONハーシュホーン：私はこれをオンにする場合
。何を、実行可能ファイルにcファイル

1009
00:48:38,410 --> 00:48:39,260
私が書くのですか？

1010
00:48:39,260 --> 00:48:41,610
>> 学生：テストを行う。

1011
00:48:41,610 --> 00:48:42,080
>> JASONハーシュホーン：申し訳ありませんが？

1012
00:48:42,080 --> 00:48:42,790
>> 学生：テストを行う。

1013
00:48:42,790 --> 00:48:44,040
>> JASONハーシュホーン：テストを行う。

1014
00:48:44,040 --> 00:48:46,700

1015
00:48:46,700 --> 00:48:48,410
私たちは話していた
今年のライン。

1016
00:48:48,410 --> 00:48:49,140
打ち鳴らす。

1017
00:48:49,140 --> 00:48:51,270
打ち鳴らすとは何ですか？

1018
00:48:51,270 --> 00:48:52,200
コンパイラの名前。

1019
00:48:52,200 --> 00:48:53,920
この行は何ですか？

1020
00:48:53,920 --> 00:48:55,580
>> 学生：GDBの使用のためにそれを設定します。

1021
00:48:55,580 --> 00:48:59,230
>> JASONハーシュホーン：セット
それまでGDBの使用について。

1022
00:48:59,230 --> 00:49:02,338
この行は、その何ですか？

1023
00:49:02,338 --> 00:49:03,290
>> 学生：ソースコード。

1024
00:49:03,290 --> 00:49:06,010
>> JASONハーシュホーン：それです。
ソースファイル、。cファイル。

1025
00:49:06,010 --> 00:49:08,150
この2行は何をしますか？

1026
00:49:08,150 --> 00:49:10,245
またはこれらの2行ではない。

1027
00:49:10,245 --> 00:49:12,300
>> 学生：それ名は、テスト。

1028
00:49:12,300 --> 00:49:15,410
>> JASONハーシュホーン：だからダッシュOによると、
違った何かという名前を付けます。

1029
00:49:15,410 --> 00:49:16,790
そしてここでは、テスト、それを呼び出している。

1030
00:49:16,790 --> 00:49:18,900
私はそれを中に持っていなかった場合は、
何がこの名前を付けるのでしょうか？

1031
00:49:18,900 --> 00:49:20,260
>> 学生：a.outの。

1032
00:49:20,260 --> 00:49:22,340
>> JASONハーシュホーン：a.outの。

1033
00:49:22,340 --> 00:49:25,366
これは何をしますか？

1034
00:49:25,366 --> 00:49:27,670
>> 学生は：数学ライブラリをリンクします。

1035
00:49:27,670 --> 00:49:29,550
>> JASONハーシュホーン：これは、リンク
数学ライブラリにある。

1036
00:49:29,550 --> 00:49:32,880
私たちは、数学ライブラリが含まれていませんでしたが、
それは非常に一般的なので、彼らはき

1037
00:49:32,880 --> 00:49:35,780
常に含めるように書かれメイク
数学ライブラリ。

1038
00:49:35,780 --> 00:49:39,050
同様に、これは、
CS50ライブラリ。

1039
00:49:39,050 --> 00:49:43,010
>> 我々はリストもOK、そう、我々は今持っている
テストと呼ばれる実行。

1040
00:49:43,010 --> 00:49:45,150
それを実行するために、私はテストを書く。

1041
00:49:45,150 --> 00:49:48,330
私は自分が浮動小数点ことがわかり、
期待どおり、0に等しい。

1042
00:49:48,330 --> 00:49:50,890

1043
00:49:50,890 --> 00:49:51,590
それをする - 

1044
00:49:51,590 --> 00:49:52,060
そう - 

1045
00:49:52,060 --> 00:49:55,210
>> 学生：次に、あなたが今フロートを置く場合、
あなたはfloatとしてキャストのように - 

1046
00:49:55,210 --> 00:49:56,870
>> JASONハーシュホーン：鋳鉄
フロートに1？

1047
00:49:56,870 --> 00:49:59,180
>> 学生：いいえ、完全なものをキャスト - 

1048
00:49:59,180 --> 00:49:59,500
うん。

1049
00:49:59,500 --> 00:50:02,460
あなただけのことをした場合、だろう
つまり、0.1にする？

1050
00:50:02,460 --> 00:50:07,170
>> JASONハーシュホーン：[OK]を、そう本当にすぐ、
10、であるそれらで割った1

1051
00:50:07,170 --> 00:50:08,690
整数は、分割されている。

1052
00:50:08,690 --> 00:50:13,580
あなたは、整数を分割するときだから、彼らがしている
0、あなたは保存していること0

1053
00:50:13,580 --> 00:50:17,170
スラッシュがあるため、フロート
ちょうど整数の除算。

1054
00:50:17,170 --> 00:50:19,180
だから今、私たちは、何かを回しています
フロートへ。

1055
00:50:19,180 --> 00:50:21,650
>> 何が起こるか見てみましょう。

1056
00:50:21,650 --> 00:50:22,900
我々はテストを作ってあげる。

1057
00:50:22,900 --> 00:50:25,870

1058
00:50:25,870 --> 00:50:31,090
だから今我々はスラッシュがなかったことを参照してください。
整数の割り算は、浮いていた

1059
00:50:31,090 --> 00:50:32,640
小数点除算。

1060
00:50:32,640 --> 00:50:35,700
、その引数の1
floatにキャストされていた。

1061
00:50:35,700 --> 00:50:38,380
だから、今ではこれを扱う、言っていた
我々が扱っているような分裂

1062
00:50:38,380 --> 00:50:40,140
整数と浮動小数点ではない。

1063
00:50:40,140 --> 00:50:42,760
だから我々は我々が期待する答えを得る。

1064
00:50:42,760 --> 00:50:44,620
>> 何が起こるか見てみましょう - 

1065
00:50:44,620 --> 00:50:47,103
おっと。

1066
00:50:47,103 --> 00:50:51,646
私は以上の10進を印刷したい場合
スポット、私はそれをどのように行うか？

1067
00:50:51,646 --> 00:50:55,550
>> 学生：ポイントドットF、またはできるだけ多く
あなたが望むように小数点以下の桁。

1068
00:50:55,550 --> 00:51:02,280

1069
00:51:02,280 --> 00:51:04,440
>> JASONハーシュホーン：だから私は印刷
10進数のスポット。

1070
00:51:04,440 --> 00:51:06,610
そして、我々は今我々が取得している参照してください。
いくつかの奇妙なもの。

1071
00:51:06,610 --> 00:51:09,650
そして、それは戻ってあなたの質問に戻ります
約小数点不正確浮動。

1072
00:51:09,650 --> 00:51:10,950
ここに格納されている奇妙なものがあります。

1073
00:51:10,950 --> 00:51:13,650

1074
00:51:13,650 --> 00:51:15,275
>> [OK]を、それがあなたの質問に答えるのでしょうか？

1075
00:51:15,275 --> 00:51:18,550

1076
00:51:18,550 --> 00:51:20,200
あなたは他に何を望んでなかった
すぐにコーディングしますか？

1077
00:51:20,200 --> 00:51:25,470
>> 学生：私はちょうどかどうか見てみたかった
ていない、あなたには、いくつかのポインタを解放した場合、

1078
00:51:25,470 --> 00:51:30,410
そのポインタは、まだ中に格納していたかどうか
それそれがされていたもののアドレス

1079
00:51:30,410 --> 00:51:32,170
以前を指す。

1080
00:51:32,170 --> 00:51:34,100
>> JASONハーシュホーン：OK、
それでは、それをしてみましょう。

1081
00:51:34,100 --> 00:51:38,030
CHARスターptrが、これは変数を作成
char型の星のptrを呼んだ。

1082
00:51:38,030 --> 00:51:39,280
どのように私はmalloc関数を書きますか？

1083
00:51:39,280 --> 00:51:40,550
オールデン？

1084
00:51:40,550 --> 00:51:41,800
>> ALDEN：ちょうどmalloc関数。

1085
00:51:41,800 --> 00:51:44,820

1086
00:51:44,820 --> 00:51:51,040
しかし、それはのサイズである必要があり、
この場合、私はあなたがしたいと思います

1087
00:51:51,040 --> 00:51:52,465
CHARを指している。

1088
00:51:52,465 --> 00:51:54,450
だから、CHARなるだろう。

1089
00:51:54,450 --> 00:51:57,520
>> JASONハーシュホーン：[OK]を、ので、より多くの
一般的に、インサイド - 

1090
00:51:57,520 --> 00:51:58,770
の編集ができます。

1091
00:51:58,770 --> 00:52:05,100

1092
00:52:05,100 --> 00:52:09,260
malloc関数の内部では、番号が欲しい
ヒープ上のバイト数。

1093
00:52:09,260 --> 00:52:12,320
一般的に、私たちは私たちがしていることを見てきました
そう、我々はmalloc関数としているです

1094
00:52:12,320 --> 00:52:14,940
例えば、文字列、または
整数の配列。

1095
00:52:14,940 --> 00:52:21,600
だから我々は10の整数、または10が必要な場合
文字、10は私たちに10を与える。

1096
00:52:21,600 --> 00:52:24,370
して、文字のサイズが与えるだろう
弊社で文字のサイズ、

1097
00:52:24,370 --> 00:52:25,120
この場合は1バイトです。

1098
00:52:25,120 --> 00:52:26,250
私たちは、10バイトを取得。

1099
00:52:26,250 --> 00:52:28,540
我々はintのサイズを記述した場合、
それは私たちに40バイトを与えるだろう。

1100
00:52:28,540 --> 00:52:31,520
>> ので、より多くの一般的に、malloc関数の内部
希望するバイト数です。

1101
00:52:31,520 --> 00:52:34,620
このケースでは、1バイトを取得している。

1102
00:52:34,620 --> 00:52:36,900
奇妙な使用のように思われる
malloc関数のが、私たちのために

1103
00:52:36,900 --> 00:52:38,470
目的は、理にかなっています。

1104
00:52:38,470 --> 00:52:40,420
だからがあります。

1105
00:52:40,420 --> 00:52:43,420
>> 我々は自由を呼び出すつもりです。

1106
00:52:43,420 --> 00:52:47,040
我々はそれを取り除くと、我々は再びPTRを使用しています。

1107
00:52:47,040 --> 00:52:48,750
そして、あなたがチェックし、何をしたいのですか？

1108
00:52:48,750 --> 00:52:50,550
>> 学生：私はちょうどかどうかを確認したかった
か何かがあったではない

1109
00:52:50,550 --> 00:52:51,900
その中の。

1110
00:52:51,900 --> 00:52:53,050
>> JASONハーシュホーン：どうだから
それは何も指さ？

1111
00:52:53,050 --> 00:52:57,740
>> 学生：ええ、正確に、どうか
それでもメモリアドレスを有していた。

1112
00:52:57,740 --> 00:53:02,220
>> JASONハーシュホーン：だからしたい
PTRの値を確認するには？

1113
00:53:02,220 --> 00:53:03,470
>> 学生：ええ、その通りです。

1114
00:53:03,470 --> 00:53:07,940

1115
00:53:07,940 --> 00:53:10,160
>> JASONハーシュホーン：私はここで何を書くか
私は、の値を確認したい場合

1116
00:53:10,160 --> 00:53:11,880
ポイント - 何であるか、ヨルダン
値は、言った？

1117
00:53:11,880 --> 00:53:13,720
または何がPTRの内部に格納されている？

1118
00:53:13,720 --> 00:53:14,620
>> 学生：メモリアドレス。

1119
00:53:14,620 --> 00:53:16,330
>> JASONハーシュホーン：メモリアドレス。

1120
00:53:16,330 --> 00:53:20,520
私はこれを書くのであれば、それはよ
私にPTRの値を与える。

1121
00:53:20,520 --> 00:53:22,800
そして、どのように私はプリントアウトしない
メモリアドレス？

1122
00:53:22,800 --> 00:53:26,470
フォーマット文字列は何ですか
メモリ·アドレスのための？

1123
00:53:26,470 --> 00:53:27,430
>> 学生：％pは。

1124
00:53:27,430 --> 00:53:28,050
>> JASONハーシュホーンます。％P。

1125
00:53:28,050 --> 00:53:29,500
％sは文字列です。

1126
00:53:29,500 --> 00:53:30,750
ポインタの％P。

1127
00:53:30,750 --> 00:53:40,820

1128
00:53:40,820 --> 00:53:43,540
その権利はありますか？

1129
00:53:43,540 --> 00:53:44,790
その通りです。

1130
00:53:44,790 --> 00:53:49,450

1131
00:53:49,450 --> 00:53:51,040
だから、ptrは等しい - 

1132
00:53:51,040 --> 00:53:53,350
それはまだそれに何かを持っています。

1133
00:53:53,350 --> 00:53:56,110

1134
00:53:56,110 --> 00:53:57,645
これはおそらく、もっとある
興味深い質問。

1135
00:53:57,645 --> 00:53:59,198
その行は何をしますか？

1136
00:53:59,198 --> 00:54:00,830
>> 学生：ワンセグ障害。

1137
00:54:00,830 --> 00:54:01,310
>> JASONハーシュホーン：何？

1138
00:54:01,310 --> 00:54:02,678
>> 学生：私はそれが障害をセグメンテーション·と思います。

1139
00:54:02,678 --> 00:54:03,574
>> JASONハーシュホーン：フム？

1140
00:54:03,574 --> 00:54:04,920
>> 学生：私はそれはseg faultをだしと思います。

1141
00:54:04,920 --> 00:54:08,265
>> JASONハーシュホーン：だから、この行
コー​​ド、スターPTRの、どのような

1142
00:54:08,265 --> 00:54:10,152
星が意味するのでしょうか？

1143
00:54:10,152 --> 00:54:11,240
>> 学生：内容。

1144
00:54:11,240 --> 00:54:11,560
>> JASONハーシュホーン：うん。

1145
00:54:11,560 --> 00:54:13,910
のコンテンツを取得するために行く。

1146
00:54:13,910 --> 00:54:16,830
だから、これはメモリに行くために起こっている
そこに対処し、私にそれを与える。

1147
00:54:16,830 --> 00:54:21,030
私はここ％cを使用しているのでそこに
そこに格納された文字である。

1148
00:54:21,030 --> 00:54:23,390
だから我々は、そのアドレスを、我々に行くつもりです
ちょうど見た - またはそれはおそらくだろう

1149
00:54:23,390 --> 00:54:25,190
一味違うこの
我々はプログラムを実行する時間。

1150
00:54:25,190 --> 00:54:28,010
しかし、我々はそのアドレスに行くよ
その我々はまだ存在することがわかっている

1151
00:54:28,010 --> 00:54:29,260
そこにあるものを参照してください。

1152
00:54:29,260 --> 00:54:35,640

1153
00:54:35,640 --> 00:54:37,110
>> だから、seg faultをだしていませんでした。

1154
00:54:37,110 --> 00:54:38,970
それはちょうど私たちに何も与えていませんでした。

1155
00:54:38,970 --> 00:54:43,350
これは、実際に私たちに与えられたかもしれない
何かが、我々はそれを見ることはできません。

1156
00:54:43,350 --> 00:54:45,110
そして、それは戻って、このアイデアに行く - 

1157
00:54:45,110 --> 00:54:47,270
そして我々は中にあまりにも多くを取得するつもりはない
これ、それは超えていないため

1158
00:54:47,270 --> 00:54:48,460
このコースの範囲。

1159
00:54:48,460 --> 00:54:51,260
我しかし、もし我々は、ちょうどここの話
によって配列の範囲を超えていた

1160
00:54:51,260 --> 00:54:54,890
1、我々はトラブルに巻き込まれない可能性があります。

1161
00:54:54,890 --> 00:54:58,550
>> 時には、あなただけの1でオフに行くとき、
あなたはあなたが何か間違ったことをしている

1162
00:54:58,550 --> 00:54:59,220
トラブルに巻き込まれる可能性があります。

1163
00:54:59,220 --> 00:55:00,820
しかし、あなたはいつもトラブルに得ることはありません。

1164
00:55:00,820 --> 00:55:05,170
それがどれだけ悪いことをあなたは依存
行うと、トラブルに取得するつもりだ。

1165
00:55:05,170 --> 00:55:07,790
ずさんなこと、言っているではありません
あなたのコードで。

1166
00:55:07,790 --> 00:55:12,080
しかし、それはプログラムがないので、言うことです
いつもあなたがどこかに行っ​​ても、終了

1167
00:55:12,080 --> 00:55:14,130
あなたが行くことになっていない。

1168
00:55:14,130 --> 00:55:18,170
>> その良い例が、たくさんのである
彼らの問題の人々は、3を設定した

1169
00:55:18,170 --> 00:55:22,350
15は、チェックしませんでした
ボードの境界です。

1170
00:55:22,350 --> 00:55:25,860
だから、に見えたが、左に見えた
右を見て、一番上に見えた

1171
00:55:25,860 --> 00:55:27,000
下へ。

1172
00:55:27,000 --> 00:55:31,540
しかし、あなたはトップかどうかをチェックしませんでした
実際にボード上になる予定だった。

1173
00:55:31,540 --> 00:55:35,220
そして、それをした多くの人々と
、で自分のプログラムが動作したことになって

1174
00:55:35,220 --> 00:55:38,960
完璧に、どこにそのボードがあったため、
あなたが1を行った場合、メモリに格納されている

1175
00:55:38,960 --> 00:55:42,300
その上またはそのメモリをチェックする
住所、何でもありませんでした

1176
00:55:42,300 --> 00:55:44,870
そのことについては特に恐ろしい、
ので、あなたのプログラムではありませんでした

1177
00:55:44,870 --> 00:55:45,970
あなたに叫ぶつもり。

1178
00:55:45,970 --> 00:55:48,870
>> しかし、もし我々はまだポイントを脱ぐだろう
あなたので、あなたは、それをチェックしませんでした

1179
00:55:48,870 --> 00:55:50,850
あなたがいなかった何かをしていた
行うことになって、あなたは可能性があります

1180
00:55:50,850 --> 00:55:51,860
困って頂いております。

1181
00:55:51,860 --> 00:55:54,040
オッズは、おそらくいない、しかし、である。

1182
00:55:54,040 --> 00:55:57,790
これは、はい、それを示すようになっています
我々はまだそれに行くことができます。

1183
00:55:57,790 --> 00:55:59,010
そして、我々は中に取得していない
この場合のトラブル。

1184
00:55:59,010 --> 00:56:04,000
我々は読んで実行しようとしました場合には
次の100文字は、と思います

1185
00:56:04,000 --> 00:56:06,000
おそらくトラブルに巻き込まれる。

1186
00:56:06,000 --> 00:56:09,400
そして、あなたは、次の100を読んでコーディングすることができます
文字は、いくつかの操作を実行して欲しい場合は、

1187
00:56:09,400 --> 00:56:10,110
forループのようなもの。

1188
00:56:10,110 --> 00:56:10,850
うん。

1189
00:56:10,850 --> 00:56:16,250
>> 学生：私たちは、その割り当てられていたので
スペース実際の値は、ないでしょう

1190
00:56:16,250 --> 00:56:17,050
実際には何も見ることができ。

1191
00:56:17,050 --> 00:56:21,740
我々はそれを設定している状態で試してみてください
Cか何かを好きに等しい？

1192
00:56:21,740 --> 00:56:22,640
>> JASONハーシュホーン：良い質問。

1193
00:56:22,640 --> 00:56:25,340
どうすればその値を設定するのです - 

1194
00:56:25,340 --> 00:56:28,980
コー​​ドのどの行私はライン上に書くのですか
7は、あなたが言ったことを行うには？

1195
00:56:28,980 --> 00:56:34,040
>> 学生：スターptrはシングル等しい
引用Cは、単一引用符を終了します。

1196
00:56:34,040 --> 00:56:36,970
>> JASONハーシュホーン：だから入れている
文字あり、c、その位置で、

1197
00:56:36,970 --> 00:56:40,200
再び、その星のため
そこに行くことを意味します。

1198
00:56:40,200 --> 00:56:43,320
との左側に使用された場合
代入演算子は、それに等しい

1199
00:56:43,320 --> 00:56:47,270
サインインして我々は取得するつもりはないこと
値にその値を設定したほど。

1200
00:56:47,270 --> 00:56:48,520
それでは、何が起こるか見てみましょう。

1201
00:56:48,520 --> 00:56:54,700

1202
00:56:54,700 --> 00:56:56,770
>> 我々はそこに何かを置く
それがあった。

1203
00:56:56,770 --> 00:56:58,000
私たちは、自由と呼ばれる。

1204
00:56:58,000 --> 00:57:00,100
いくつかのものは、おそらく何が起こっ
ヒープ上。

1205
00:57:00,100 --> 00:57:01,890
だから、もうそこにはない。

1206
00:57:01,890 --> 00:57:07,440
しかし、再び、我々は取得していない
そこに行くためのトラブルで。

1207
00:57:07,440 --> 00:57:10,260
>> 私が説明するために、コード内でこれをやっている
これらの多くは、その

1208
00:57:10,260 --> 00:57:12,410
あなたが持っている疑問は、彼らがしている
本当に面白い

1209
00:57:12,410 --> 00:57:13,650
多くの時間を応答します。

1210
00:57:13,650 --> 00:57:15,260
そして、彼らは本当に良い質問だ。

1211
00:57:15,260 --> 00:57:19,010
そして、あなたはそれらを把握することができます
自分の場合、例えば、

1212
00:57:19,010 --> 00:57:19,990
我々はここにいない。

1213
00:57:19,990 --> 00:57:20,940
うん。

1214
00:57:20,940 --> 00:57:24,430
>> 学生：あなたが送信していないので
どこポインタあなたがする必要がありますか

1215
00:57:24,430 --> 00:57:26,530
malloc関数を使うのか？

1216
00:57:26,530 --> 00:57:28,400
>> JASONハーシュホーン：だから、これは戻り
あなたの最初の質問へ。

1217
00:57:28,400 --> 00:57:28,620
[？ ？]

1218
00:57:28,620 --> 00:57:29,980
それだけで、ローカル変数ですか？

1219
00:57:29,980 --> 00:57:32,280
ここでのmallocはその説得力はありません。

1220
00:57:32,280 --> 00:57:35,260
ここmalloc関数を使用することはありません
それはだから、その魅力的な

1221
00:57:35,260 --> 00:57:36,500
ただローカル変数。

1222
00:57:36,500 --> 00:57:40,970
>> 学生：だから、CHAR行うことができます
スターptrはハロー等しい？

1223
00:57:40,970 --> 00:57:41,400
>> JASONハーシュホーン：ああ。

1224
00:57:41,400 --> 00:57:43,300
だから我々はすぐに戻って取得するつもりだ
あなたの最初の質問へ。

1225
00:57:43,300 --> 00:57:46,885
私はあなたが満足していなかったと思います
私の答えを持つ。

1226
00:57:46,885 --> 00:57:48,220
OK？

1227
00:57:48,220 --> 00:57:49,226
そのような？

1228
00:57:49,226 --> 00:57:49,682
>> 学生：うん。

1229
00:57:49,682 --> 00:57:50,932
待つ。

1230
00:57:50,932 --> 00:57:54,090

1231
00:57:54,090 --> 00:57:57,850
>> JASONハーシュホーン：そしてここで
あなたが印刷したいのですか？

1232
00:57:57,850 --> 00:58:00,026
だから我々はそのような文字列を出力します？

1233
00:58:00,026 --> 00:58:06,380

1234
00:58:06,380 --> 00:58:07,630
>> 学生：興味深い。

1235
00:58:07,630 --> 00:58:09,900

1236
00:58:09,900 --> 00:58:14,285
>> JASONハーシュホーン：だから、これはこのことを言う
引数には、文字の種類があります。

1237
00:58:14,285 --> 00:58:17,200

1238
00:58:17,200 --> 00:58:18,620
だから、これは文字に​​する必要があります。

1239
00:58:18,620 --> 00:58:25,170

1240
00:58:25,170 --> 00:58:26,280
>> 学生：ちょうど最初の1をとります。

1241
00:58:26,280 --> 00:58:28,610
>> JASONハーシュホーン：だからこの
私が前に言ったことである。

1242
00:58:28,610 --> 00:58:34,240
私はそれが保存されないのは、言ったように
変数のポインタの中の文字列。

1243
00:58:34,240 --> 00:58:35,120
これは、収納だ - 

1244
00:58:35,120 --> 00:58:36,350
>> 学生：最初の値
文字列の。

1245
00:58:36,350 --> 00:58:40,810
>> JASONハーシュホーン：のアドレス
文字列の最初の値。

1246
00:58:40,810 --> 00:58:46,940
我々はこれをプリントアウトした場合、我々はしている
ポインタの内部で値を取得する。

1247
00:58:46,940 --> 00:58:51,005
そして、我々は、それは確かに、ある表示されます
メモリアドレス。

1248
00:58:51,005 --> 00:58:53,595

1249
00:58:53,595 --> 00:58:56,440
>> それは理にかなっていますか？

1250
00:58:56,440 --> 00:58:56,940
申し訳ありません。

1251
00:58:56,940 --> 00:58:58,996
それがあなたに答えない、待つ
質問は、しかし？

1252
00:58:58,996 --> 00:58:59,790
>> 学生：うん。

1253
00:58:59,790 --> 00:59:05,830
>> JASONハーシュホーン：このコード行である
文字列を作成し、別の

1254
00:59:05,830 --> 00:59:09,115
指している変数のポインタ
その文字列に、その配列。

1255
00:59:09,115 --> 00:59:14,320

1256
00:59:14,320 --> 00:59:14,980
うん。

1257
00:59:14,980 --> 00:59:19,200
>> 我々は一つのメモリに行きましたそうであれば学生
さらに対処する、我々は時間になるだろう？

1258
00:59:19,200 --> 00:59:21,990

1259
00:59:21,990 --> 00:59:23,150
それは文字列として格納されていませんか？

1260
00:59:23,150 --> 00:59:24,400
>> JASONハーシュホーン：同様に、私たちはやった - 

1261
00:59:24,400 --> 00:59:28,540

1262
00:59:28,540 --> 00:59:30,790
ので、これを行うのは価値がある。

1263
00:59:30,790 --> 00:59:33,780
これは小数点演算、君たちです
前に見てきたし、あるべき

1264
00:59:33,780 --> 00:59:35,550
比較的快適に。

1265
00:59:35,550 --> 00:59:36,905
これは書き込みに似ている - 

1266
00:59:36,905 --> 00:59:41,980

1267
00:59:41,980 --> 00:59:46,350
我々はこのコード行を記述した場合、
我々は以前に配列表記を見てきました。

1268
00:59:46,350 --> 00:59:55,900
これは私たちに第二を与える必要があります
この配列、Hの値。

1269
00:59:55,900 --> 01:00:05,010
>> 我々はこれを行った場合、これも与えるべきである
私たち、その配列の2番目の値。

1270
01:00:05,010 --> 01:00:08,320
それがメモリにいないだろうので、
まず最初のアドレスが、

1271
01:00:08,320 --> 01:00:10,530
事1以上のメモリアドレス。

1272
01:00:10,530 --> 01:00:14,360
して、スターのオペレータデリファレンス
そのポインタ。

1273
01:00:14,360 --> 01:00:16,940
そして再び、見てみましょう。

1274
01:00:16,940 --> 01:00:18,664
我々は再びHを得る。

1275
01:00:18,664 --> 01:00:20,980
>> 学生：何が正確に行います
デリファレンスの意味は？

1276
01:00:20,980 --> 01:00:23,650
>> JASONハーシュホーン：逆参照
に行くための豪華な単語である。

1277
01:00:23,650 --> 01:00:26,390
それに移動して、そこに何を得る
ポインタを間接参照しています。

1278
01:00:26,390 --> 01:00:28,240
それは、そのためだけの派手な言葉だ。

1279
01:00:28,240 --> 01:00:29,986
>> 学生：私たちは、印刷したい場合
文字列全体は、私たちでし

1280
01:00:29,986 --> 01:00:31,930
アンパサンドポインタをする？

1281
01:00:31,930 --> 01:00:33,490
>> JASONハーシュホーン：[OK]を、私たちは
ここで一時停止する予定。

1282
01:00:33,490 --> 01:00:35,480
我々はここで終了する予定です。

1283
01:00:35,480 --> 01:00:41,760
アンパサンドは、あなたのアドレスを提供します
場所、その時には、アンパサンドを行う

1284
01:00:41,760 --> 01:00:44,080
変数は、それはあなたの住所を提供します
その変数が格納されている場所。

1285
01:00:44,080 --> 01:00:48,580
アンパサンドポインタが得られます
ptrがメモリ内にあるPTRのアドレス。

1286
01:00:48,580 --> 01:00:50,140
>> 我々は上に行くつもりはない
この例で。

1287
01:00:50,140 --> 01:00:52,640
あなたはこれらを把握することができます
自分で物事。

1288
01:00:52,640 --> 01:00:55,740
しかし、繰り返しますが、これはあってもフェルゲンツ可能性があります
あなたが知っておくべきことを超えてビット

1289
01:00:55,740 --> 01:00:58,000
この中期の範囲 - 

1290
01:00:58,000 --> 01:00:59,070
またはこのクイズではなく。

1291
01:00:59,070 --> 01:01:00,270
申し訳ありません。

1292
01:01:00,270 --> 01:01:03,770
>> 私はなぜなら私たちは、上に移動しようとしている
1のコーディングの問題をやりたい

1293
01:01:03,770 --> 01:01:05,100
時間の前にアップしている。

1294
01:01:05,100 --> 01:01:09,340
そして、我々は、私が何を考えてコーディングしようとしている
これらの中で最も説得力がある

1295
01:01:09,340 --> 01:01:11,020
例、atoi関数。

1296
01:01:11,020 --> 01:01:14,520
だから、これは上の問題だった
2年前にクイズ。

1297
01:01:14,520 --> 01:01:17,810
そして、私はここに、ボードの上に持っている。

1298
01:01:17,810 --> 01:01:20,680
>> 人々は、クイズに求めていた - 

1299
01:01:20,680 --> 01:01:23,640
それらはもう少しtesxtを与えられた
質問が、私は排除さ

1300
01:01:23,640 --> 01:01:26,640
テキストには、不必要であったため
現在、私たちの目的のために。

1301
01:01:26,640 --> 01:01:29,180
それだけでいくつかの背景だった
何をしたかはatoiに。

1302
01:01:29,180 --> 01:01:31,425
しかし、あなたはすべて知っているとされ、非常に
atoi関数に精通。

1303
01:01:31,425 --> 01:01:35,620
>> 私はあなたがこれをコーディング示唆
用紙上に。

1304
01:01:35,620 --> 01:01:39,310
私はまた、戦略を使用することをお勧め
我々は終わってしまったので

1305
01:01:39,310 --> 01:01:41,040
私たちのセクションにたくさん。

1306
01:01:41,040 --> 01:01:44,130
まず、あなたが理解し
何をしているatoi関数の。

1307
01:01:44,130 --> 01:01:47,580
絵を描くか、いくつかを思い付く
あなたの頭の中でその精神的なイメージ。

1308
01:01:47,580 --> 01:01:51,120
次に、このための擬似コードを書き出す。

1309
01:01:51,120 --> 01:01:53,120
クイズでは、あなたが得るすべての場合に
擬似コード、少なくともあなた

1310
01:01:53,120 --> 01:01:54,550
何かを置く。

1311
01:01:54,550 --> 01:02:00,070
そして、その後に、その擬似コードをマッピング
C.あなたにチェックがある場合

1312
01:02:00,070 --> 01:02:03,760
擬似コードのような確認もし何か
1、それは場合にマップされている

1313
01:02:03,760 --> 01:02:05,750
などの条件や。

1314
01:02:05,750 --> 01:02:07,850
そして最後に、C言語でプログラムをコーディングする

1315
01:02:07,850 --> 01:02:15,000
>> だから、戻っatoi関数に戻り、5分かかる
のシートでこれをコーディングする

1316
01:02:15,000 --> 01:02:19,480
約おそらく紙、
あなたが上にかかる時間の量

1317
01:02:19,480 --> 01:02:21,260
atoi関数をコーディングするクイズ。

1318
01:02:21,260 --> 01:02:27,060
5〜15分間、5つ、5つ、12個
10分量の程度である

1319
01:02:27,060 --> 01:02:30,150
あなたはこれに費やすだろう時間
クイズに質問。

1320
01:02:30,150 --> 01:02:31,670
だから、今5分かかりください。

1321
01:02:31,670 --> 01:02:35,957
ご質問がある場合には、調達
あなたの手と私の周り来る。

1322
01:02:35,957 --> 01:06:39,570

1323
01:06:39,570 --> 01:06:41,066
>> [SIDE会話]

1324
01:06:41,066 --> 01:08:35,279

1325
01:08:35,279 --> 01:08:37,580
>> JASONハーシュホーン：[OK]を、そう
それは5分であった。

1326
01:08:37,580 --> 01:08:39,880
つまり、量の約おそらくだった
時間はあなたが、クイズに、その上で過ごすと思います

1327
01:08:39,880 --> 01:08:42,120
その時間の多分ローエンド。

1328
01:08:42,120 --> 01:08:44,010
私たちは少しでおさらいします。

1329
01:08:44,010 --> 01:08:45,740
私たちは、このコーディングを始めましょう。

1330
01:08:45,740 --> 01:08:49,479
そして、我々はすべての方法を介して取得しない場合は、
これとこれへの回答

1331
01:08:49,479 --> 01:08:54,189
クイズの質問が再び、利用可能です、
2011年秋には、この質問するときです

1332
01:08:54,189 --> 01:08:54,913
クイズに登場した。

1333
01:08:54,913 --> 01:08:57,830
>> そして、それは8ポイントの価値があった
クイズにして。

1334
01:08:57,830 --> 01:09:01,140
8点の上限である
ポイント何かの量は価値がある。

1335
01:09:01,140 --> 01:09:04,790
ほとんどの質問では、範囲内にある
一から六までの点の。

1336
01:09:04,790 --> 01:09:08,500
だから、これはより困難である
確かに質問。

1337
01:09:08,500 --> 01:09:09,750
私は誰を始めることができますか？

1338
01:09:09,750 --> 01:09:13,260

1339
01:09:13,260 --> 01:09:15,380
>> 一般的に、我々は何をしようとしている
これで何をしたいために

1340
01:09:15,380 --> 01:09:17,550
論理的に、関数はatoi、？

1341
01:09:17,550 --> 01:09:19,569
我々は何をすべきかをしたいですか？

1342
01:09:19,569 --> 01:09:22,279
だから我々は書くつもりだ
いくつかの擬似コード。

1343
01:09:22,279 --> 01:09:24,090
>> 学生：文字を変換
整数に変換する。

1344
01:09:24,090 --> 01:09:26,700
>> JASONハーシュホーン：文字を変換
整数に変換する。

1345
01:09:26,700 --> 01:09:27,479
[OK]をクリックします。

1346
01:09:27,479 --> 01:09:30,870
だから我々はどのように多くの文字
通過する必要があるとして？

1347
01:09:30,870 --> 01:09:32,295
>> 学生：それらのすべて。

1348
01:09:32,295 --> 01:09:34,100
>> 学生：すべての文字
文字列中。

1349
01:09:34,100 --> 01:09:35,540
>> JASONハーシュホーン：すべて
文字列内の文字。

1350
01:09:35,540 --> 01:09:42,180
だから我々は、すべての通過したい場合
文字列内の文字、ものは何ですか

1351
01:09:42,180 --> 01:09:44,560
C言語で、我々は許可されていることを見てきました
私たちは、すべてを通過する

1352
01:09:44,560 --> 01:09:45,939
文字列内の文字？

1353
01:09:45,939 --> 01:09:46,819
>> 学生：forループA。

1354
01:09:46,819 --> 01:09:48,069
>> JASONハーシュホーン：forループ。

1355
01:09:48,069 --> 01:09:52,020

1356
01:09:52,020 --> 01:09:55,330
だから我々は、をループするつもりだ
s内のすべての文字。

1357
01:09:55,330 --> 01:10:00,940
>> その後、私たちは何をしたいとしている
我々は特定の文字を取得するとき？

1358
01:10:00,940 --> 01:10:02,480
我々は90を通過したばかりだと言う。

1359
01:10:02,480 --> 01:10:03,460
私たちは、9を​​得る。

1360
01:10:03,460 --> 01:10:04,240
それはキャラクターだ。

1361
01:10:04,240 --> 01:10:07,440
私たちは、で何をしたいか
その文字9？

1362
01:10:07,440 --> 01:10:10,082
>> 学生：文字0からそれを引く？

1363
01:10:10,082 --> 01:10:11,860
>> 学生：0を追加しますか？

1364
01:10:11,860 --> 01:10:13,350
>> JASONハーシュホーン：減算
文字0から？

1365
01:10:13,350 --> 01:10:13,800
>> 学生：うん。

1366
01:10:13,800 --> 01:10:15,573
>> JASONハーシュホーン：なぜ
あなたはそれをやってみたい？

1367
01:10:15,573 --> 01:10:16,560
>> 学生：[聞こえない]

1368
01:10:16,560 --> 01:10:17,010
値。

1369
01:10:17,010 --> 01:10:18,380
そのint値。

1370
01:10:18,380 --> 01:10:21,580
>> JASONハーシュホーン：[OK]を、私たちは取る
文字9、からそれを引く

1371
01:10:21,580 --> 01:10:25,820
文字0取得する
実際の整数9。

1372
01:10:25,820 --> 01:10:27,070
甘い。

1373
01:10:27,070 --> 01:10:31,255

1374
01:10:31,255 --> 01:10:37,000
そして、どのようにその文字を知っていますか
9 0マイナス文字が9である？

1375
01:10:37,000 --> 01:10:39,222
あなたはどのような時に、チャートを見たのですか？

1376
01:10:39,222 --> 01:10:43,130
>> 学生：9は、論理的にあります。
9と0の間の場所。

1377
01:10:43,130 --> 01:10:44,620
または、ASCIIテーブルを見て可能性があります。

1378
01:10:44,620 --> 01:10:45,120
>> JASONハーシュホーン：ASCIIテーブル。

1379
01:10:45,120 --> 01:10:46,490
しかし、はい、あなたにも正しいよ。

1380
01:10:46,490 --> 01:10:47,780
だから我々は0を減算します。

1381
01:10:47,780 --> 01:10:49,010
だから今、私たちは、整数9を持っている。

1382
01:10:49,010 --> 01:10:49,970
そして我々はそれで何をしたいのですか？

1383
01:10:49,970 --> 01:10:54,970
我々は90を持っているなら、それは最初の整数です
我々は我々が何をしたいのか、持っている？

1384
01:10:54,970 --> 01:10:58,180
>> 学生：私は一時的な整数に置くところ
配列は、それに数学を行う

1385
01:10:58,180 --> 01:11:02,088
後で最後にそれを作るために。

1386
01:11:02,088 --> 01:11:03,020
>> JASONハーシュホーン：わかりました。

1387
01:11:03,020 --> 01:11:06,990
>> 学生：あなたは、終了時に起動することができます
その配列とはとても前進

1388
01:11:06,990 --> 01:11:10,350
そのあなたが前方に移動するたびに、
あなたは10を掛け。

1389
01:11:10,350 --> 01:11:10,830
>> JASONハーシュホーン：わかりました。

1390
01:11:10,830 --> 01:11:12,250
これはかなりのように聞こえる
説得力のある考え方。

1391
01:11:12,250 --> 01:11:16,040
私たちは、配列の末尾に始めることができ、
そして我々はstrlengを使用することができます。

1392
01:11:16,040 --> 01:11:17,030
我々はここでstrlengを使用することができます。

1393
01:11:17,030 --> 01:11:18,870
私たちは、文字列の長さを取得します。

1394
01:11:18,870 --> 01:11:20,100
私たちは、最後に開始します。

1395
01:11:20,100 --> 01:11:29,170
そして+最初のものを、私たちは取ること
整数、そして多分私達は次のように作成します

1396
01:11:29,170 --> 01:11:32,270
新しい整数型の変数までトップ場所
我々はすべてを保存している。

1397
01:11:32,270 --> 01:11:37,340
からのS内のすべての文字を通してだからループ
後ろから前に、我々は0を減算し、

1398
01:11:37,340 --> 01:11:42,790
その後、我々はそれを取る、とに応じて、
それがどこにあるか、我々はそれを掛け

1399
01:11:42,790 --> 01:11:45,860
10の力で。

1400
01:11:45,860 --> 01:11:50,644
ので、最初の1、私たちがやる
右端の文字を掛ける？

1401
01:11:50,644 --> 01:11:51,440
>> 学生：10から0。

1402
01:11:51,440 --> 01:11:53,170
>> JASONハーシュホーン：10から0。

1403
01:11:53,170 --> 01:11:56,010
我々は、第二​​は何を掛けない
右端の文字による？

1404
01:11:56,010 --> 01:11:57,450
>> 学生：[聞こえない]。

1405
01:11:57,450 --> 01:11:57,960
>> JASONハーシュホーン：何？

1406
01:11:57,960 --> 01:11:59,150
>> 学生：10から1。

1407
01:11:59,150 --> 01:12:00,420
>> JASONハーシュホーン：10から1。

1408
01:12:00,420 --> 01:12:03,754
サード右端の文字？

1409
01:12:03,754 --> 01:12:04,580
>> 学生：10から2。

1410
01:12:04,580 --> 01:12:05,350
>> JASONハーシュホーン：10から2。

1411
01:12:05,350 --> 01:12:07,200
>> 学生：申し訳ありませんが、私は理解していない
我々はここで何をやっている。

1412
01:12:07,200 --> 01:12:08,640
>> JASONハーシュホーン：OK、
それでは次に、戻りましょう。

1413
01:12:08,640 --> 01:12:12,500
だから我々は取得するつもりだ
文字列で渡され。

1414
01:12:12,500 --> 01:12:14,470
私たちは、atoi関数を書いているからです。

1415
01:12:14,470 --> 01:12:15,260
だから我々は、文字列で渡されます。

1416
01:12:15,260 --> 01:12:17,640
我々は渡さ取得していると言う
文字列90。

1417
01:12:17,640 --> 01:12:19,930
>> 私たちがやろうとしている最初のものが設定されている
我々はしている新たな整数変数

1418
01:12:19,930 --> 01:12:22,150
ちょうど作成しよう
私たちの新しい整数として。

1419
01:12:22,150 --> 01:12:24,630
それは我々が行っているものです
最後に戻ります。

1420
01:12:24,630 --> 01:12:30,110
我々は内のすべての文字を通過する必要が
文字列我々が決定しましたので、

1421
01:12:30,110 --> 01:12:34,430
私たちは、それぞれの1に触れる必要があるとし、
その後、私たちの新しい整数に追加します。

1422
01:12:34,430 --> 01:12:36,330
>> しかし、我々は単に数として追加することはできません。

1423
01:12:36,330 --> 01:12:38,270
私達はちょうど9を取ることができないと
私たちの整数に9を追加します。

1424
01:12:38,270 --> 01:12:40,560
それは、どのような場所に依存
それが文字列である。

1425
01:12:40,560 --> 01:12:42,960
私たちは、乗算する必要になるだろう
その10の力で。

1426
01:12:42,960 --> 01:12:45,580
そのためにはどのようにベース10の作品だ。

1427
01:12:45,580 --> 01:12:49,050
>> だから我々は、実際に取得するつもりだ
文字、または実際の整数

1428
01:12:49,050 --> 01:12:53,860
数値、文字0を減算することにより
文字9我々が行ったようで

1429
01:12:53,860 --> 01:12:57,560
から文字大文字のAを差し引く
我々は1で持っていたどのような文字

1430
01:12:57,560 --> 01:12:58,120
これらの問題。

1431
01:12:58,120 --> 01:13:04,190
だから我々は、実際には0から番号を取得します
9実数として保存し、我々はよ

1432
01:13:04,190 --> 01:13:07,590
応じて10の力を掛け
我々は、文字列のどこにいるかに。

1433
01:13:07,590 --> 01:13:19,430

1434
01:13:19,430 --> 01:13:22,575
そして、我々はそれを再度追加しようとしている
私たちの新しい整数型の変数に変換する。

1435
01:13:22,575 --> 01:13:32,840

1436
01:13:32,840 --> 01:13:37,890
>> それでは、これはなりようになります。
も - 私たちはこっちに描画します。

1437
01:13:37,890 --> 01:13:40,086
我々は、文字列90で渡されたら - 

1438
01:13:40,086 --> 01:13:41,336
>> 学生：[聞こえない]。

1439
01:13:41,336 --> 01:13:43,190

1440
01:13:43,190 --> 01:13:45,540
>> JASONハーシュホーン：しかし、
atoi関数は、文字列を取ります。

1441
01:13:45,540 --> 01:13:46,350
だから我々は通過するつもりだ
保持。

1442
01:13:46,350 --> 01:13:49,900
我々は90で渡された取得します。

1443
01:13:49,900 --> 01:13:51,540
我々は、フロントに戻ってから行く。

1444
01:13:51,540 --> 01:13:53,920
我々は0になります。

1445
01:13:53,920 --> 01:13:55,080
>> 学生：私は申し訳ありません。

1446
01:13:55,080 --> 01:13:55,880
多分これはばかげている。

1447
01:13:55,880 --> 01:13:59,440
我々は、文字列で渡された取得している場合は、
なぜ我々はしているもの90である

1448
01:13:59,440 --> 01:14:00,260
渡されたばかり？

1449
01:14:00,260 --> 01:14:03,160
90は整数ですから。

1450
01:14:03,160 --> 01:14:06,820
>> JASONハーシュホーン：atoi関数がかかるので
文字列と整数に変換します

1451
01:14:06,820 --> 01:14:08,320
その文字列の表現。

1452
01:14:08,320 --> 01:14:13,650
しかし、文字列90は整数ではありません
90または数90。

1453
01:14:13,650 --> 01:14:17,920
文字列90は2の配列で、か
3文字ではなく、9

1454
01:14:17,920 --> 01:14:22,740
文字、0文字、および
バックスラッシュ0文字。

1455
01:14:22,740 --> 01:14:26,260
>> そして我々は、理由のためatoi関数を書いている
たとえば、次のコマンドを撮るとき

1456
01:14:26,260 --> 01:14:30,230
ライン引数、それは内に保存だ
ARGV、それが文字列として保存さだ。

1457
01:14:30,230 --> 01:14:32,940
しかし、あなたは数としてそれを扱いたい場合には、
あなたは、ANに変換する必要があり

1458
01:14:32,940 --> 01:14:34,700
実際の整数。

1459
01:14:34,700 --> 01:14:37,210
その我々は我々の問題のセットのいずれかを行った。

1460
01:14:37,210 --> 01:14:38,800
我々は数でやっている
我々の問題セット。

1461
01:14:38,800 --> 01:14:41,690
整数を取ったすべての人
コマンドライン引数として。

1462
01:14:41,690 --> 01:14:46,490
だから、だからこそ私たちatoi関数は
文字列を取ります。

1463
01:14:46,490 --> 01:14:51,910
>> だからもう一度、ここで我々の例では、ね
最後の1を取るつもり。

1464
01:14:51,910 --> 01:14:55,050
私たちは、文字を減算するつもりだ
文字それのための0、0

1465
01:14:55,050 --> 01:14:58,810
文字0を差し引いたあなたに与えます
によると、実際の数は0、

1466
01:14:58,810 --> 01:15:00,950
我々が行うのASCII数学。

1467
01:15:00,950 --> 01:15:04,870
>> 文字は、次のように表現されているので
実際のとは異なる - 

1468
01:15:04,870 --> 01:15:08,830
文字aは、例えば、
小文字のaは97である。

1469
01:15:08,830 --> 01:15:10,260
そうではありません - おっと！

1470
01:15:10,260 --> 01:15:13,290
それはあなたが期待する何でもありません
それは、例えば、0である。

1471
01:15:13,290 --> 01:15:16,200
だから、減算する必要があります
文字0を取得します。

1472
01:15:16,200 --> 01:15:18,950
>> だから我々は、ここでそれをやろうとしている
実際の数を取得します。

1473
01:15:18,950 --> 01:15:22,560
そして、我々を掛けしようとしている
10の力はどこにに応じて、

1474
01:15:22,560 --> 01:15:27,030
文字列であり、その後、それを取る
我々のプレースホルダに追加

1475
01:15:27,030 --> 01:15:32,520
変数ので、思い付くことができます
私たちの最終的な新しい整数。

1476
01:15:32,520 --> 01:15:35,080
それはすべての人に理にかなっていますか？

1477
01:15:35,080 --> 01:15:37,730
>> だから我々は、これをコーディングするつもりはない
今、私たちはだから

1478
01:15:37,730 --> 01:15:38,830
時間に短い取得。

1479
01:15:38,830 --> 01:15:40,860
私はそのタイミングをお詫び申し上げます。

1480
01:15:40,860 --> 01:15:44,620
しかし、これがうまくいけば、あなたがどうなるか、です
クイズに行うことができる - で

1481
01:15:44,620 --> 01:15:47,710
最低限、この擬似コードを取得する
書き出さ。

1482
01:15:47,710 --> 01:15:50,840
>> そして、我々はなかった場合に書き込む
擬似コードは、実際には、我々はこれを行うことができます

1483
01:15:50,840 --> 01:15:51,490
かなり迅速に。

1484
01:15:51,490 --> 01:15:55,230
私たちが書いたコメントの各行
ここに約に変換

1485
01:15:55,230 --> 01:15:56,970
Cコードの1行。

1486
01:15:56,970 --> 01:16:01,780
新しい変数、書き込みの宣言
ループ、いくつかの減算、いくつかの

1487
01:16:01,780 --> 01:16:07,070
乗算、およびいくつかの割り当て。

1488
01:16:07,070 --> 01:16:09,020
我々は、おそらくもしたいと思う
戻りラインを記述します。

1489
01:16:09,020 --> 01:16:12,040
また、配置したい場合があります
ここでのいくつかのチェック。

1490
01:16:12,040 --> 01:16:12,655
うん。

1491
01:16:12,655 --> 01:16:15,720
>> 学生：だから我々は扱うことができます
実際の文字列としてのS？

1492
01:16:15,720 --> 01:16:18,730
私が知っているので、それだけでアドレスです。

1493
01:16:18,730 --> 01:16:22,090
同様に、どのようにして、長さになるだろう
文字列がそのまま渡されて？

1494
01:16:22,090 --> 01:16:25,310
>> JASONハーシュホーン：それでは、どのようでした
文字列の長さ？

1495
01:16:25,310 --> 01:16:25,830
STRLEN。

1496
01:16:25,830 --> 01:16:26,660
>> 学生：strlen関数、うん。

1497
01:16:26,660 --> 01:16:30,550
しかし、あなたのようにSを置くことができます
そのための議論？

1498
01:16:30,550 --> 01:16:34,620
>> JASONハーシュホーン：だからstrlen関数
char型の星を取る。

1499
01:16:34,620 --> 01:16:38,090
そして、それは、その文字のスターに追従し、それ
それがAに到達するまでカウントを続ける

1500
01:16:38,090 --> 01:16:41,865
バックスラッシュ0。 strlen関数は、実際にあった
他のプログラムの1、私たち

1501
01:16:41,865 --> 01:16:42,850
コー​​ドに行っていた。

1502
01:16:42,850 --> 01:16:44,560
つまり、コードに別の良い1だ。

1503
01:16:44,560 --> 01:16:47,270
その1は、少し簡単だ場合、以下の原因
あなたはそれについて考えるつもりだ

1504
01:16:47,270 --> 01:16:47,830
概念的には - 

1505
01:16:47,830 --> 01:16:51,620
私はちょうどそれを大声で言った -  strlen関数は、以下の
ポインタといっていると

1506
01:16:51,620 --> 01:16:54,210
カウントとなるまで追跡する
あなたは、バックスラッシュ0に達する。

1507
01:16:54,210 --> 01:16:56,530
>> 学生：はい、それを得た。

1508
01:16:56,530 --> 01:17:00,200
>> JASONハーシュホーン：のだから、最高の
クイズ0明日に運。

1509
01:17:00,200 --> 01:17:03,170
ご質問があれば、私はよ
この後に外にしてください。

1510
01:17:03,170 --> 01:17:05,610
私に電子メールを送ること自由に感じ。

1511
01:17:05,610 --> 01:17:08,480
君がいるなら、自分のTFに手を差し伸べる
私のセクションで、または私の得られない

1512
01:17:08,480 --> 01:17:10,005
あなたはそれをしたい場合は、電子メールで送信。

1513
01:17:10,005 --> 01:17:13,140
>> あなたが陥るだけ送信したい場合
私のメール、FREAKOUTのメール、私はよ

1514
01:17:13,140 --> 01:17:16,710
、スマイリーフェイスのように、戻ってを送信
または、のように、冗談か何か。

1515
01:17:16,710 --> 01:17:18,190
だからだけでなく、それを行うにはお気軽に。

1516
01:17:18,190 --> 01:17:20,750
幸運を再び、と私はよ
すべて来週お会いしましょう​​。

1517
01:17:20,750 --> 01:17:23,435