1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> スピーカー1：皆さん、こんにちは。

3
00:00:05,680 --> 00:00:07,530
私たちは始めるつもりです。

4
00:00:07,530 --> 00:00:09,330
私は人々がまだ起こっていると思う
でフィルタリングされる。

5
00:00:09,330 --> 00:00:12,840
しかし、時間の利益のために、私達ができるので、
時間通りにここからあなたたちを取得するには、

6
00:00:12,840 --> 00:00:14,110
私たちは開始する予定だ。

7
00:00:14,110 --> 00:00:18,780
だからCS50クイズ0件へようこそ。

8
00:00:18,780 --> 00:00:23,020
実現していない人のために
まだ、あなたは水曜日に質問があります。

9
00:00:23,020 --> 00:00:25,700
ウー·ホー。

10
00:00:25,700 --> 00:00:29,780
>> あなたはまだ勉強を始めていない場合、または
これはまだ存在していることを実現していない、

11
00:00:29,780 --> 00:00:34,070
過去のクイズとに関するすべての情報
クイズcs50.net/quizzesにあります。

12
00:00:34,070 --> 00:00:38,090
いくつかの非常に良いものがそこにあります、
最後の10から過去のクイズ

13
00:00:38,090 --> 00:00:43,760
年だけでなく、情報
このクイズや話題について

14
00:00:43,760 --> 00:00:46,250
それはカバーされる。

15
00:00:46,250 --> 00:00:48,980
それでは始めましょう。

16
00:00:48,980 --> 00:00:54,240
>> だからみんな、最初のを覚えているかもしれません
クラスデビッドの日は、これらのランプの上に持っていた。

17
00:00:54,240 --> 00:00:59,650
だから基本的に、すべてのものになる
あるコンピュータのボンネットの下に上

18
00:00:59,650 --> 00:01:00,860
バイナリで行わ。

19
00:01:00,860 --> 00:01:04,080
バイナリは、それが聞こえる何を意味し
のような、0と1。

20
00:01:04,080 --> 00:01:09,290
それは2つの値を有している
表現することができる。

21
00:01:09,290 --> 00:01:14,675
>> だからセクションの最初の日のよう
ダビデは光になったとき

22
00:01:14,675 --> 00:01:21,990
に表現するために、電球、または1、当社のコンピュータ
0のバイナリを理解し、

23
00:01:21,990 --> 00:01:24,110
1の、オンまたはオフにします。

24
00:01:24,110 --> 00:01:25,360
バイナリの基本。

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
すべての場所が表されている
ベース2内。

27
00:01:32,470 --> 00:01:36,260
だから、0〜2を追加
2すべての方法の最大1。

28
00:01:36,260 --> 00:01:41,970
>> あなたのバイナリがにあるかを計算するために、
小数、あなただけのこの方程式に従う

29
00:01:41,970 --> 00:01:42,840
タイプの事。

30
00:01:42,840 --> 00:01:49,510
あなたはそれらの場所のいずれかに1がある場合は、
あなたはどのようなを掛け

31
00:01:49,510 --> 00:01:53,820
それは中のベース、それを追加し、
あなたは、小数点を得る。

32
00:01:53,820 --> 00:01:57,930
だから、これはあなたが数える方法です
バイナリ5。

33
00:01:57,930 --> 00:02:01,400
ちょうど私たちが何をしていたかのように
最後のスライド、これはあなたがする方法である

34
00:02:01,400 --> 00:02:02,650
1〜5を表す。

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> 同様に、追加することができます同じようにと
10進数または10を底に引くか、

37
00:02:09,660 --> 00:02:13,040
追加できる上、本当に任意の塩基、
バイナリに引く。

38
00:02:13,040 --> 00:02:18,400
ときに、あなたが期待するかを正確に
それは大きい等しい場合二つアップを追加

39
00:02:18,400 --> 00:02:24,220
1よりも、あなたは、それ0にする、1を運ぶ
ちょうど、またそのように行う

40
00:02:24,220 --> 00:02:29,910
あなたが定期的に期待されるように
10進数またはいずれかの他の塩基。

41
00:02:29,910 --> 00:02:30,970
クール。

42
00:02:30,970 --> 00:02:35,140
>> 私はそのすべてが、前に述べたようなので、
当社のコンピュータのフードの下に進む

43
00:02:35,140 --> 00:02:37,560
0と1、またはバイナリで行われます。

44
00:02:37,560 --> 00:02:43,470
では、どのように、たとえば、表現するか、
文字、または数字、あるいは文字？

45
00:02:43,470 --> 00:02:45,560
そして、それに対する答えはASCIIです。

46
00:02:45,560 --> 00:02:49,380
>> ASCIIは文字間のマッピングです。
私たちは通常で見るだろうと

47
00:02:49,380 --> 00:02:53,360
Aさん、Bさんのような英語、
C言語の、アンダースコア、ダッシュ、および

48
00:02:53,360 --> 00:02:54,910
そのような何か。

49
00:02:54,910 --> 00:02:57,260
そして、それはASCII値にそれをマッピングします。

50
00:02:57,260 --> 00:03:03,080
ASCII値は単なる数であること
お使いのコンピュータが理解できる。

51
00:03:03,080 --> 00:03:07,430
そして、あなたは追加を行うことができます同じようにと
番号の減算、あなたが行うことができます

52
00:03:07,430 --> 00:03:10,890
ASCII値を持つ彼ら。

53
00:03:10,890 --> 00:03:14,050
>> したがって、この例では、どのような
これは出力します？

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
うん、これだけ空間B空間Cスペース
D.どこ私のマウスは行きましたか？

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
あなたが65でint型を定義することができます注意してください。

58
00:03:43,380 --> 00:03:47,080
そして、あなたが使用してそれをプリントアウトするとき
％のCは、それは、それを解釈しよう

59
00:03:47,080 --> 00:03:49,330
キャラクターとAを出力します

60
00:03:49,330 --> 00:03:52,800
>> 同様に、宣言することができます
それcharとして。

61
00:03:52,800 --> 00:03:56,860
そして、あなたはパーセントを使用してそれをプリントアウトするとき
Cは、それがそのように解釈よ

62
00:03:56,860 --> 00:04:05,240
パーセントD.そして、あなたは追加することができます同じように
番号には、文字を追加することができている

63
00:04:05,240 --> 00:04:06,878
この場合のASCII値、。

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> 皆のためにこれほど少ないのポインタ。

66
00:04:16,130 --> 00:04:19,610
5、文字列として、していない
実際に5に等しい。

67
00:04:19,610 --> 00:04:26,610
だから、私たちはどのように変換することがあります
整数5弦5？

68
00:04:26,610 --> 00:04:28,930
任意のアイデア？

69
00:04:28,930 --> 00:04:31,630
うん。

70
00:04:31,630 --> 00:04:36,720
>> だから私たちは文字列として5を持っている場合、
私たちは0を引くことができます。

71
00:04:36,720 --> 00:04:37,820
そして、それは私たちに5を与えるでしょう。

72
00:04:37,820 --> 00:04:41,670
同様に、私たちのように5を持っている場合
整数、文字列0にそれを追加します。

73
00:04:41,670 --> 00:04:43,112
そして、それは私たちに、文字列5を与えます。

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
クール。

76
00:04:48,350 --> 00:04:52,940
>> さて、1どこ講義に戻ってリコール
私たちはアルゴリズムについて話しました。

77
00:04:52,940 --> 00:04:57,260
では、どのように実際にコンピュータをしたいですか
面白いことを行うには？

78
00:04:57,260 --> 00:05:00,460
あなただけの加減算、知っている
数字と印刷物事アウトはありません

79
00:05:00,460 --> 00:05:01,730
そのエキサイティング。

80
00:05:01,730 --> 00:05:04,620
通常、私たちは私たちのコンピュータにしたい
アルゴリズムのいくつかの種類を実行します。

81
00:05:04,620 --> 00:05:07,820
少し複雑なもの
単純な算術より。

82
00:05:07,820 --> 00:05:11,930
>> このアルゴリズムは、ステップセットでわずかなステップである
実行する方法のための指示

83
00:05:11,930 --> 00:05:14,640
特定のtask--

84
00:05:14,640 --> 00:05:15,660
ただレシピが好きです。

85
00:05:15,660 --> 00:05:19,990
あなたが最初の日を覚えているかもしれません
デビッドは、私たちは部屋を数えていたクラス

86
00:05:19,990 --> 00:05:22,550
人々の、どのように多くの人
部屋にいた。

87
00:05:22,550 --> 00:05:24,480
あなたは、カウントに使用されるかもしれない
一つずつ。

88
00:05:24,480 --> 00:05:25,860
1、2、3、4。

89
00:05:25,860 --> 00:05:28,010
その場合、線形時間アルゴリズム。

90
00:05:28,010 --> 00:05:31,710
>> しかし、ダビデはアルゴリズムを導入
あなたの部屋で人を数える

91
00:05:31,710 --> 00:05:37,340
誰もが立ち上がるところ、あなたの言う
他の人の数、ということを付け加え

92
00:05:37,340 --> 00:05:39,200
数アップ、そして一人が座る。

93
00:05:39,200 --> 00:05:40,410
そして、あなたはそれを繰り返します。

94
00:05:40,410 --> 00:05:42,910
つまり、アルゴリズムの一種だ。

95
00:05:42,910 --> 00:05:47,520
私たちは、どのように効率的なANを分析することができます
このアルゴリズムは、それが実行時だ基づいている。

96
00:05:47,520 --> 00:05:49,680
しかし、私たちは少し話をしましょう
そのことについてもっと後で。

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> だから、すべてのアルゴリズムがすることもできます
擬似コードで記述する。

99
00:05:57,090 --> 00:06:01,120
擬似コードはただのような英語です
構文が表現するために使用

100
00:06:01,120 --> 00:06:02,420
プログラミング言語。

101
00:06:02,420 --> 00:06:06,070
例えば、私たちはユーザーに確認したい場合
私のお気に入りの数を推測するために、私たち

102
00:06:06,070 --> 00:06:08,390
のような擬似コードがあるかもしれません。

103
00:06:08,390 --> 00:06:09,850
>> ユーザーは推測取得します。

104
00:06:09,850 --> 00:06:13,570
推測が正しい場合、それらを教え
が正しいか、そうでなければ、それらを伝える

105
00:06:13,570 --> 00:06:15,560
彼らは正しくありませんね。

106
00:06:15,560 --> 00:06:22,530
そして、擬似コードを簡単にする方法です
アイデアやアルゴリズムを表す。

107
00:06:22,530 --> 00:06:26,910
だから今私たちは実際に書きたいと思うかもしれません
この言語では、そのコンピュータ

108
00:06:26,910 --> 00:06:27,980
理解可能性があります。

109
00:06:27,980 --> 00:06:35,660
だから私たちは私たちの擬似コードを書くことができ、
ソースコードにそれを解釈する。

110
00:06:35,660 --> 00:06:41,320
>> これまでのところ、ソースコードが準拠する必要があります
の特定の構文に

111
00:06:41,320 --> 00:06:42,490
プログラミング言語。

112
00:06:42,490 --> 00:06:45,430
そして、これまでのところ、CS50に、私たちがした
主にC＃を使用して。

113
00:06:45,430 --> 00:06:48,320
だから、これは、cのソースコードがある可能性があります。

114
00:06:48,320 --> 00:06:51,440
その後過程で、あなたが夜来る
他のプログラミングに接触させる

115
00:06:51,440 --> 00:06:52,480
PHPのような言語。

116
00:06:52,480 --> 00:06:57,540
それともあなたも、あなたを他のクラスを取る場合
JavaやPythonの、あるいはOCMLをするかもしれない。

117
00:06:57,540 --> 00:07:01,570
しかし、私たちのCプログラム言語で、これは
どのようにするためのソースコードを書くかもしれません

118
00:07:01,570 --> 00:07:04,760
擬似コードアルゴリズムその
私は先に説明した。

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> それでは、どのようにコンピュータが実際に行います
それを理解できますか？

121
00:07:11,430 --> 00:07:14,490
私は本当に、その前に言ったように
0と1を理解しています。

122
00:07:14,490 --> 00:07:17,880
それでは、どのように、ソースから得るん
ことができます何かにコード

123
00:07:17,880 --> 00:07:18,960
理解？

124
00:07:18,960 --> 00:07:22,920
さて、私たちは何かを持っている
コンパイラと呼ばれる。

125
00:07:22,920 --> 00:07:28,450
>> あなたのほとんどのには思い出して
のpset、プログラムのいくつかの種類を持っていた

126
00:07:28,450 --> 00:07:30,370
ドットcのファイルに書き込まれる。

127
00:07:30,370 --> 00:07:32,550
そして、あなたは、makeと入力します。

128
00:07:32,550 --> 00:07:35,970
それでは、makeはしているのですか？

129
00:07:35,970 --> 00:07:39,970
>> あなたのをコンパイルするmakeと入力することができます
プログラムsomeone--理由

130
00:07:39,970 --> 00:07:42,730
あなたのページセットを書いた人は誰でも、
おそらくDavid--

131
00:07:42,730 --> 00:07:44,190
メイクファイルを作成した。

132
00:07:44,190 --> 00:07:51,320
そして、それはあなたを実行するために知って作るに指示
打ち鳴らすと呼ばれるコンパイラと、その意志

133
00:07:51,320 --> 00:07:55,560
その後objectにソースコードをコンパイルする
0と1のコード、

134
00:07:55,560 --> 00:07:57,720
お使いのコンピュータが理解している。

135
00:07:57,720 --> 00:08:01,610
しかし、少し後に、私たちは行きます
コンパイラについての深さ以上である。

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> だから、そうwhere--、PSET 0をリコール
あなたが質問がありますか？

138
00:08:10,800 --> 00:08:11,620
>> 聴衆：[聞き取れない]？

139
00:08:11,620 --> 00:08:12,490
>> スピーカー1：はい。

140
00:08:12,490 --> 00:08:14,960
私は、彼らは実際に考えて
オンラインである必要があります。

141
00:08:14,960 --> 00:08:15,120
うん。

142
00:08:15,120 --> 00:08:16,572
>> 聴衆：それは[聞き取れない]のようですか？

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> SPEAKER 1：それはありません。

145
00:08:20,830 --> 00:08:25,810
ザはcs50.net/quizzesにあります。

146
00:08:25,810 --> 00:08:32,900
>> 聴衆：2013スラッシュ、クイズスラッシュ、
0を大幅に削減し、単にクリックスルー

147
00:08:32,900 --> 00:08:35,956
クイズ2013クイズ0、
切片スライドを確認してください。

148
00:08:35,956 --> 00:08:40,380
>> スピーカー1：うん、君たちがしたいので、もし
それを引き出し、あなたにそれを見て

149
00:08:40,380 --> 00:08:42,740
自分のコンピュータは、それもいいのよ。

150
00:08:42,740 --> 00:08:43,130
もう一度言う。

151
00:08:43,130 --> 00:08:44,546
>> 聴衆：[聞こえない]。

152
00:08:44,546 --> 00:08:48,780
>> スピーカー1：うん、[聞き取れない]
ダミー変数である。

153
00:08:48,780 --> 00:08:49,644
ああ、そう？

154
00:08:49,644 --> 00:08:51,372
>> 聴衆：[聞き取れない]？

155
00:08:51,372 --> 00:08:54,300
>> スピーカー1：いいえ、ストライキ
試験ではありません。

156
00:08:54,300 --> 00:08:55,950
申し訳ありませんが、彼女の質問があったた
試験でストライキ。

157
00:08:55,950 --> 00:08:59,530
そして、それはありません。

158
00:08:59,530 --> 00:09:05,780
だからPSET 0、君たちは、すべてを持っている必要があります
スクラッチを使って何かを実装しました。

159
00:09:05,780 --> 00:09:13,100
そして、私たちはいくつかの基本的なプログラミングを学んだ
スクラッチを使用してビルディングブロック。

160
00:09:13,100 --> 00:09:15,590
>> それでは、いくつか見てみましょう
これらのビルディングブロックの

161
00:09:15,590 --> 00:09:18,170
それは、プログラムを構成している。

162
00:09:18,170 --> 00:09:20,570
まずブール式です。

163
00:09:20,570 --> 00:09:24,540
ブール式がものであり、
持つ0のか何か

164
00:09:24,540 --> 00:09:25,700
2可能な値。

165
00:09:25,700 --> 00:09:30,320
この場合には、trueまたはfalse、
オンまたはオフにし、yesまたはno。

166
00:09:30,320 --> 00:09:35,390
非常に単純な、簡単な一例、
ブールを使用するプログラム

167
00:09:35,390 --> 00:09:39,140
表現ここまで。

168
00:09:39,140 --> 00:09:43,220
>> だから、ブール式のために
有用であることが、私たちはブール演算子を持っている。

169
00:09:43,220 --> 00:09:48,920
これらは使用することができる演算子である
特定の値を比較した。

170
00:09:48,920 --> 00:09:52,820
そこで、以下、持っているかに等しくない
以上よりも大きい、等しい、または

171
00:09:52,820 --> 00:09:55,130
に等しく、そしてより少ない
またはより大きい。

172
00:09:55,130 --> 00:09:59,060
しかし、これらの事業者は、非常に有用ではありません
私達はにそれらを組み合わせることができない限り、

173
00:09:59,060 --> 00:10:00,320
条件。

174
00:10:00,320 --> 00:10:04,370
>> だから、あなたたちは一から覚えているかもしれません
その私たち、あなたのページセットから

175
00:10:04,370 --> 00:10:05,400
条件を持っていた。

176
00:10:05,400 --> 00:10:09,710
彼らは中にフォークのように、本質的に、ある
あなたのプログラムのロジックという

177
00:10:09,710 --> 00:10:12,670
かどうかに応じて実行する
条件が満たされます。

178
00:10:12,670 --> 00:10:18,150
だから私たちが持っていたのいずれかの条件に
この過程で何度も使用され

179
00:10:18,150 --> 00:10:21,470
もし、そうでなければ、もし、それ以外の条件。

180
00:10:21,470 --> 00:10:24,060
>> ここでは方法の例です
あなたはそれを使用することがあります。

181
00:10:24,060 --> 00:10:28,430
誰の違いを知っていますか
ちょうど文すべての場合に使用して

182
00:10:28,430 --> 00:10:32,530
もし、他の詩ダウンの方法、
あれば、それ以外を合わせ？

183
00:10:32,530 --> 00:10:33,013
はい？

184
00:10:33,013 --> 00:10:34,263
>> 聴衆：[聞こえない]。

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> スピーカー1：その通りです。

187
00:10:42,160 --> 00:10:50,210
だから私は持っていた場合であれば、この全押し
道も、この状態が戻る場合

188
00:10:50,210 --> 00:10:52,800
真、それはまだ継続します
次の二つのテスト。

189
00:10:52,800 --> 00:11:00,120
、一方、他 - もし、そうで
文1がtrueを返す場合、

190
00:11:00,120 --> 00:11:02,640
他のものはテストされていません。

191
00:11:02,640 --> 00:11:05,955
そのことについてご質問？

192
00:11:05,955 --> 00:11:06,890
クール。

193
00:11:06,890 --> 00:11:12,240
>> だから、他ののif-elseを使用
あなたがそれをできるだけ知っていれば声明

194
00:11:12,240 --> 00:11:14,470
これらのケースのいずれかである。

195
00:11:14,470 --> 00:11:21,550
そこで、xが0未満である場合、それは知っている
間違いであることを行っていない

196
00:11:21,550 --> 00:11:22,890
0よりも大きい。

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> 次に、他のビルディングブロック
私たちが学んだことのループがある。

199
00:11:31,480 --> 00:11:33,310
私たちは、ループの3つのタイプを持っている。

200
00:11:33,310 --> 00:11:35,830
ループの場合、whileループ、
ループしながら行います。

201
00:11:35,830 --> 00:11:38,730
そして、あなたが座って、一般的に、時
何かを書く、あなたが決定する必要があります

202
00:11:38,730 --> 00:11:40,060
使用したい3のどれ。

203
00:11:40,060 --> 00:11:41,900
では、どのようにそのいずれかを決めるのですか？

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> 私たちが知っていれば私たちは一般的に、forループを使用する
私たちは反復処理する方法を何回

206
00:11:48,790 --> 00:11:53,650
何かを通して、または何回
私たちは、タスクを実行したい。

207
00:11:53,650 --> 00:11:58,830
私たちはいくつかが必要な場合は、当社は、ループ中に使用
稼働を維持するために真であるための条件。

208
00:11:58,830 --> 00:12:03,730
そして、私たちは非常によく似ている間何使用
ながら、私たちは私たちのコードがで実行したい

209
00:12:03,730 --> 00:12:04,880
少なくとも1つの時間。

210
00:12:04,880 --> 00:12:09,410
>> 道には何でもそうしながら、意志
常に少なくとも1回実行します。

211
00:12:09,410 --> 00:12:13,120
しばらくして、一方、それ
あれば、まったく実行されないことがあります

212
00:12:13,120 --> 00:12:15,490
条件が満たされていない。

213
00:12:15,490 --> 00:12:16,740
それとご質問？

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> forループの構造がそう。

216
00:12:22,860 --> 00:12:23,620
君たちは、このすべてを見てきました。

217
00:12:23,620 --> 00:12:25,320
あなたはそれを初期化します。

218
00:12:25,320 --> 00:12:26,600
あなたは、条件のいくつかの種類があります。

219
00:12:26,600 --> 00:12:32,340
したがって、たとえば、私たちは、初期化可能性があります
に関しては、私は0に等しい。

220
00:12:32,340 --> 00:12:34,040
iが10未満である。

221
00:12:34,040 --> 00:12:35,442
そして私は+ +。

222
00:12:35,442 --> 00:12:39,010
私たちがやった非常にシンプルなもの。

223
00:12:39,010 --> 00:12:42,210
>> whileループの場合は、同様に、あなたが持っている
初期のいくつかの種類を持っている、

224
00:12:42,210 --> 00:12:44,980
条件のいくつかの種類、および
アップデートのいくつかの種類。

225
00:12:44,980 --> 00:12:51,990
だから私たちはまた、私たちのためのループを実装することができます
whileループとしてこれを使用した。

226
00:12:51,990 --> 00:12:56,000
同じく京畿whileループで、
私たちはいくつかの初期設定があるかもしれません、

227
00:12:56,000 --> 00:12:58,640
何かを実行し、それを更新し、
その後の状態を確認してください。

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> だから今機能している。

230
00:13:05,140 --> 00:13:06,460
私たちは一緒にすべてをかける。

231
00:13:06,460 --> 00:13:10,140
私たちは、いくつかを書きたいかもしれません
関数の種類。

232
00:13:10,140 --> 00:13:12,790
そのあなたは可能性のある一般的な機能
すでにメインで見てきました。

233
00:13:12,790 --> 00:13:13,770
主な機能である。

234
00:13:13,770 --> 00:13:16,160
これは、戻り値の型、int型を持っています。

235
00:13:16,160 --> 00:13:18,470
これは主に、関数名を持っています。

236
00:13:18,470 --> 00:13:20,810
そしてそれは、引数、argcとargvをしています。

237
00:13:20,810 --> 00:13:24,040
だから、メインだけの機能です。

238
00:13:24,040 --> 00:13:27,230
>> あなたが使用している可能性がありますその他の機能、
printf--のprintfはfunction--です

239
00:13:27,230 --> 00:13:29,330
GetIntで、TOUPPER。

240
00:13:29,330 --> 00:13:32,010
しかし、これらはされているために起こる
で私たちのために実装

241
00:13:32,010 --> 00:13:33,270
ライブラリのいくつかの種類。

242
00:13:33,270 --> 00:13:37,400
あなたたちには覚えている場合
このCS50.hライブラリまたは

243
00:13:37,400 --> 00:13:38,510
標準I / Oライブラリ。

244
00:13:38,510 --> 00:13:39,200
はい、質問？

245
00:13:39,200 --> 00:13:41,610
>> 聴衆：C言語でちょうど固有のメインですか？

246
00:13:41,610 --> 00:13:44,740
それだけの種類の[聞き取れない]していますか？

247
00:13:44,740 --> 00:13:47,370
>> スピーカー1：質問です
メインをcに固有のものである場合。

248
00:13:47,370 --> 00:13:51,460
そして、はい、すべての機能
主な機能を持っています。

249
00:13:51,460 --> 00:13:55,290
これは、コンピュータのようなものの必要なだ
どこを開始するために理解する

250
00:13:55,290 --> 00:13:55,993
コー​​ドを実行する。

251
00:13:55,993 --> 00:13:58,108
>> 聴衆：だから、[聞こえない]と思いませんか？

252
00:13:58,108 --> 00:13:59,480
>> スピーカー1：いいえ。

253
00:13:59,480 --> 00:14:00,760
他の質問は？

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
クール。

256
00:14:04,770 --> 00:14:08,050
ですから、関数を使用することができます同じように
それは、あなたはまた、あなたのためにすることができます書かれている

257
00:14:08,050 --> 00:14:10,380
独自の関数を記述します。

258
00:14:10,380 --> 00:14:17,050
これは誰かが可能性があることを関数で
体積を計算するために書かれている

259
00:14:17,050 --> 00:14:18,395
qは、例えば。

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
戻り値の型は、この場合には、ここにあります
int型、私たちの関数名qと私たち

262
00:14:29,500 --> 00:14:31,360
パラメータのリスト。

263
00:14:31,360 --> 00:14:34,550
>> そして、あなたは、データを記述する必要があることに注意
あなたがしたいパラメータの型

264
00:14:34,550 --> 00:14:38,660
使用したり、他の機能にはありません
どのような種類の知っている

265
00:14:38,660 --> 00:14:41,650
パラメータには、私は受け入れるべきである。

266
00:14:41,650 --> 00:14:48,110
そこで、この場合には、必要
私たちの入力として整数。

267
00:14:48,110 --> 00:14:50,390
では、なぜ私たちは関数を使用することをお勧めします？

268
00:14:50,390 --> 00:14:52,800
>> まず第一に、組織のための素晴らしい。

269
00:14:52,800 --> 00:14:56,350
彼らはにコードを分割助ける
より多くのチャンクを組織し、作る

270
00:14:56,350 --> 00:14:57,960
それ読みやすく。

271
00:14:57,960 --> 00:14:59,760
簡素化。

272
00:14:59,760 --> 00:15:01,740
これは設計に適しています。

273
00:15:01,740 --> 00:15:04,570
あなたは、コードの一部を読んでいるときに
main関数は、実際に

274
00:15:04,570 --> 00:15:07,750
本当に長い、それはに難しいかもしれません
何が起こっているのかについての理由。

275
00:15:07,750 --> 00:15:11,710
だから、関数にそれを打破した場合、
それが読みやすくなるかもしれません。

276
00:15:11,710 --> 00:15:12,750
そして、再利用·能力を。

277
00:15:12,750 --> 00:15:16,940
あなたがされています、コードの塊を持っている場合
と呼ばれる、または複数回実行し、

278
00:15:16,940 --> 00:15:20,690
代わりに、そのコードを10回書き換え
あなたの主な機能は、あなたがかもしれない

279
00:15:20,690 --> 00:15:21,440
それを再利用したいと思います。

280
00:15:21,440 --> 00:15:25,740
あなたがそれを使用する必要がある。そして毎回
コー​​ドの一部は、関数を呼び出します。

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> だから今私たちが戻ってスクラッチを覚えていれば、
私たちはまた、いくつかの概念について話しました

283
00:15:35,380 --> 00:15:37,680
の一つは、ねじ切りされている。

284
00:15:37,680 --> 00:15:41,120
スレッドには、複数の概念である
コー​​ドのシーケンス

285
00:15:41,120 --> 00:15:43,040
同時に実行する。

286
00:15:43,040 --> 00:15:47,490
ダビデが持っていた初日に戻って考える
あなたたちは、数をカウントオフ

287
00:15:47,490 --> 00:15:48,440
部屋の中の人。

288
00:15:48,440 --> 00:15:50,550
>> 基本的に、何が起こっていた
上君たちのすべてがありました

289
00:15:50,550 --> 00:15:52,370
別のスレッドを実行している。

290
00:15:52,370 --> 00:15:55,540
そして、これらのスレッドは、一緒に来ていた
その答えのいくつかの種類を取得します。

291
00:15:55,540 --> 00:15:58,890
同様に、スクラッチでの、ときに持っている
複数のスプライト、あなたは可能性があります

292
00:15:58,890 --> 00:16:01,070
猫と犬を飼っている。

293
00:16:01,070 --> 00:16:08,770
そして、彼らは同時になります
独自のスクリプトを実行している。

294
00:16:08,770 --> 00:16:10,020
つまり、スレッドの例です。

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> そして、他のコンセプトであったこと
スクラッチで導入されたイベントでした。

297
00:16:18,000 --> 00:16:22,550
そしてイベントは、複数の部品である
あなたのコードは、相互に通信します。

298
00:16:22,550 --> 00:16:26,840
あなたが使用された場合、スクラッチでは、これだった
ブロードキャスト制御とすると、I

299
00:16:26,840 --> 00:16:29,500
ブロックを受信します。

300
00:16:29,500 --> 00:16:35,170
>> そしてまた、問題セット4で、私達は見た
同様に、イベントの少し。

301
00:16:35,170 --> 00:16:38,250
君たちは使用した可能性があります
Geventライブラリ。

302
00:16:38,250 --> 00:16:42,450
そして、機能があったwaitForClick
これであなたが待っていた

303
00:16:42,450 --> 00:16:44,300
ユーザーがクリックしてください。

304
00:16:44,300 --> 00:16:47,870
そして、あなたのクリックが、この場合には、だろう
イベントとのクリックを待つ、あなたです

305
00:16:47,870 --> 00:16:49,120
イベントハンドラ。

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> そしてまた、あなたのpsetを実行を通じて
そしてあなたは、あなたのpsetに取り組んで

308
00:16:58,630 --> 00:17:01,920
と接触した可能性があります
これらのコマンドの一部。

309
00:17:01,920 --> 00:17:05,579
これは、あなたの中に入力した内容です。
ターミナルウィンドウまたは何窓

310
00:17:05,579 --> 00:17:12,119
それはへのG編集に現れ、
基本的に、コンピュータを移動します。

311
00:17:12,119 --> 00:17:19,440
>> したがって、たとえば、LSが一覧表示されます
ディレクトリの内容。

312
00:17:19,440 --> 00:17:22,510
ディレクトリが新しいフォルダが作成されてください。

313
00:17:22,510 --> 00:17:24,819
CD、ディレクトリ変更。

314
00:17:24,819 --> 00:17:28,400
RMは、削除し、ファイルを削除します
またはいくつかのディレクトリ。

315
00:17:28,400 --> 00:17:31,050
そして、ディレクトリを削除する
ディレクトリを削除します。

316
00:17:31,050 --> 00:17:32,300
>> 聴衆：[聞き取れない]？

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> スピーカー1：うん、確かに。

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
あなたあれば申し訳ありませんが、質問があった
これを入れてお勧めします

321
00:17:46,040 --> 00:17:48,840
チートシート上。

322
00:17:48,840 --> 00:17:49,440
それは助けることができる。

323
00:17:49,440 --> 00:17:51,490
あなたが部屋を持っている場合は、それを置くことができます。

324
00:17:51,490 --> 00:17:56,170
また、十分なだけで、一般的に良いことだ
あなたがそれを使用するときので、覚えておく

325
00:17:56,170 --> 00:17:59,060
あなただけにお勧めします
それは覚えている。

326
00:17:59,060 --> 00:18:02,750
それはあなたの人生がずっと楽にするでしょう。

327
00:18:02,750 --> 00:18:04,000
私は、あなたの質問に答えるしましたか？

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> だから今、私たちは少し話した
ライブラリに関する簡潔に。

330
00:18:14,290 --> 00:18:18,570
私たちがしてきたが、2つの主なもの
これまでの過程である使用して

331
00:18:18,570 --> 00:18:20,860
標準I / OおよびCS50。

332
00:18:20,860 --> 00:18:25,410
物事はどのような含まれています
標準I / Oライブラリにある？

333
00:18:25,410 --> 00:18:28,410
>> うん、これまで私たちはprintfのを使用しました。

334
00:18:28,410 --> 00:18:31,150
CS50では、GetIntで使用しました
とのGetString。

335
00:18:31,150 --> 00:18:37,200
そして、データ型は文字列にも起こります
このCS50ライブラリ内で宣言される。

336
00:18:37,200 --> 00:18:40,250
私たちは、約深さに少し詳しく説明します
どのライブラリが動作し、どのように

337
00:18:40,250 --> 00:18:41,870
あなたのコードの残りの部分と相互作用する。

338
00:18:41,870 --> 00:18:46,220
しかし、これらは、主に2つのものであることを私たち
これまでの中で接触してきた

339
00:18:46,220 --> 00:18:48,430
もちろん。

340
00:18:48,430 --> 00:18:50,050
>> タイプ。

341
00:18:50,050 --> 00:18:58,120
これらは、どれだけ覚えてもいいです
各タイプは、どのようにするか、または表現される

342
00:18:58,120 --> 00:19:02,840
何バイトタイプの各requires--

343
00:19:02,840 --> 00:19:04,990
int型は4バイト; char型、1バイト。

344
00:19:04,990 --> 00:19:06,550
フロートは4バイトです。

345
00:19:06,550 --> 00:19:07,782
二重とは何ですか？

346
00:19:07,782 --> 00:19:09,032
>> 聴衆：[聞こえない]。

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> スピーカー1：うん、そうフロート
しかしサイズを2倍に。

349
00:19:16,240 --> 00:19:17,150
どのような長さ約？

350
00:19:17,150 --> 00:19:18,400
>> 聴衆：[聞こえない]。

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> スピーカー1：わかりました。

353
00:19:24,680 --> 00:19:25,410
長いとは何ですか？

354
00:19:25,410 --> 00:19:26,660
>> 聴衆：[聞こえない]。

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> スピーカー1：うん、int型を倍増。

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
はい。

359
00:19:34,705 --> 00:19:36,100
>> 聴衆：[聞こえない]。

360
00:19:36,100 --> 00:19:38,030
>> スピーカー1：ロング[聞き取れない]。

361
00:19:38,030 --> 00:19:41,860
そして、長い長い、その二重です。

362
00:19:41,860 --> 00:19:42,814
>> 聴衆：いや、いや。

363
00:19:42,814 --> 00:19:47,107
長いだけのintです。

364
00:19:47,107 --> 00:19:50,910
これは、アーキテクチャに依存
前[聞き取れない]

365
00:19:50,910 --> 00:19:52,922
で、intは、同じサイズを有している。

366
00:19:52,922 --> 00:19:54,172
[聞き取れない]。

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> スピーカー1：だから長く
int値は同じである。

369
00:20:00,920 --> 00:20:02,943
そして、長い長い
ダブルintです。

370
00:20:02,943 --> 00:20:03,910
クール。

371
00:20:03,910 --> 00:20:05,550
そして、最後のタイプは何ですか？

372
00:20:05,550 --> 00:20:06,510
>> 聴衆：ポインタ。

373
00:20:06,510 --> 00:20:10,350
>> スピーカー1：うん、私たちは学んだ
ポインタについて少し。

374
00:20:10,350 --> 00:20:14,015
とにかかわらず、ポインタが何であるかの
それto--指し示すことはchar型のスターになる可能性が

375
00:20:14,015 --> 00:20:15,880
またはint型star--

376
00:20:15,880 --> 00:20:20,530
それは常に、ポインタは4バイトです。

377
00:20:20,530 --> 00:20:21,633
そのことについての質問？

378
00:20:21,633 --> 00:20:22,116
はい？

379
00:20:22,116 --> 00:20:24,531
>> 聴衆：[聞き取れない]？

380
00:20:24,531 --> 00:20:29,530
>> スピーカー1：だから長いとint型である
このCS50アプライアンスで同じ。

381
00:20:29,530 --> 00:20:32,302
>> 聴衆：アプライアンスは、完全である
交換可能。

382
00:20:32,302 --> 00:20:33,510
>> スピーカー1：うん。

383
00:20:33,510 --> 00:20:36,610
それでは、長い長い二重intです。

384
00:20:36,610 --> 00:20:39,250
>> 聴衆：これは32ビットです？

385
00:20:39,250 --> 00:20:40,620
>> スピーカー1：32ビット、うん。

386
00:20:40,620 --> 00:20:43,572
>> 聴衆：だから[聞き取れない]？

387
00:20:43,572 --> 00:20:46,790
>> スピーカー1：はい、そうでない場合は
明示的に、あなたを言う

388
00:20:46,790 --> 00:20:47,870
32ビットを想定する必要があります。

389
00:20:47,870 --> 00:20:50,040
>> 聴衆：それは何かを言うだろう
仮定するような

390
00:20:50,040 --> 00:20:51,498
アプライアンスのようなアーキテクチャ。

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64ビットの場合、唯一のものは、その
変更は、long型とポインタである。

393
00:21:01,710 --> 00:21:05,614
これらは両方とも[聞き取れない]。

394
00:21:05,614 --> 00:21:06,590
>> スピーカー1：はい？

395
00:21:06,590 --> 00:21:07,566
>> 聴衆：質問。

396
00:21:07,566 --> 00:21:10,982
だから練習クイズのいずれかで、
それはunsigned int型について尋ね。

397
00:21:10,982 --> 00:21:15,374
それでは、どのように決定されるであろう
INT [聞き取れない]から？

398
00:21:15,374 --> 00:21:18,140
>> スピーカー1：符号なし
にも4バイトです。

399
00:21:18,140 --> 00:21:21,172
しかし、何が署名した約異なっている
intおよびunsigned int型？

400
00:21:21,172 --> 00:21:22,422
>> 聴衆：[聞こえない]。

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> スピーカー1：右。

403
00:21:25,630 --> 00:21:27,570
一つは負の値を表すことができる。

404
00:21:27,570 --> 00:21:28,580
しかし、どのようにそれはそれを行うのですか？

405
00:21:28,580 --> 00:21:30,536
>> 聴衆：[聞こえない]。

406
00:21:30,536 --> 00:21:36,370
>> スピーカー1：ええ、それは1が保存されます
ビットは符号を表します。

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
署名された1ビットを有していること
符号を表す。

409
00:21:45,040 --> 00:21:48,886
そして、符号なしはただ、すべて陽性である。

410
00:21:48,886 --> 00:21:50,365
>> 聴衆：わかりました。

411
00:21:50,365 --> 00:21:54,230
ですから、二重であることを言う
フロートの倍のサイズ？

412
00:21:54,230 --> 00:21:58,202
>> スピーカー1：ダブル2倍である
フロートの大きさ、はい。

413
00:21:58,202 --> 00:22:01,639
>> 聴衆：どのようにポインタが何
長い長い[聞こえない]？

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> スピーカー1：だから問題はない方法です
長いlong--へのポインタ

416
00:22:10,870 --> 00:22:13,800
4バイトしかときにはどのように
その8バイト長い長い。

417
00:22:13,800 --> 00:22:17,310
だからポインタであることを覚えて、
基本的に、非常に基本値で。

418
00:22:17,310 --> 00:22:19,046
>> 聴衆：[聞こえない]。

419
00:22:19,046 --> 00:22:22,670
>> スピーカー1：うん、そうポインタ
単にメモリロケーションである。

420
00:22:22,670 --> 00:22:28,040
だから、どのくらいのスペースが問題ではありません
そのポインタが指しています。

421
00:22:28,040 --> 00:22:32,060
それだけを追跡するために4バイトを必要とする
そのメモリ位置の。

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
他の質問は？

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
クール。

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> 私が持っているので、最後の事
標準出力されます。

428
00:22:47,460 --> 00:22:51,020
あなたが頻繁に使用する必要があります
あなたが覚えていることは十分。

429
00:22:51,020 --> 00:22:54,800
私たちが使用している場合でも、これは
printfの、例えば。

430
00:22:54,800 --> 00:22:59,260
そして、私たちはこれらのプレースホルダを持っている
書式コードと呼ばれていました。

431
00:22:59,260 --> 00:23:03,910
>> だからパーセントのCのchar、int型のパーセントiの、
そして私達はまたパーセントdを使用することができます。

432
00:23:03,910 --> 00:23:05,130
それは同じことだ。

433
00:23:05,130 --> 00:23:08,200
しかし、一般的には、CS50の私たちにある
パーセントiを使用するようにしてください。

434
00:23:08,200 --> 00:23:09,860
フロートのパーセントF。

435
00:23:09,860 --> 00:23:15,620
長い長いためパーセントLDと
パーセントの文字列。

436
00:23:15,620 --> 00:23:18,550
>> 同様に、私たちはいくつかを使用してきた
これらのエスケープシーケンス。

437
00:23:18,550 --> 00:23:22,431
たとえば、バックスラッシュnの新しい行のために。

438
00:23:22,431 --> 00:23:26,910
これは、書式設定しているときのためだけである
印刷fのあなたのコード。

439
00:23:26,910 --> 00:23:27,260
はい？

440
00:23:27,260 --> 00:23:28,906
>> 聴衆：パーセントdは何のためにあるの？

441
00:23:28,906 --> 00:23:31,850
>> スピーカー1：そこで質問
パーセントdは何のためにあるのかでしょうか？

442
00:23:31,850 --> 00:23:33,270
パーセントdはint型です。

443
00:23:33,270 --> 00:23:37,392
パーセントdおよび％は私も同じです。

444
00:23:37,392 --> 00:23:41,130
>> 聴衆：違いは何ですか
バックスラッシュnとバックスラッシュrは？

445
00:23:41,130 --> 00:23:45,300
>> スピーカー1：だから問題は何である
バックラッシュnとの間の差

446
00:23:45,300 --> 00:23:48,615
バックラッシュR？

447
00:23:48,615 --> 00:23:50,906
私は、バックスラッシュrを考えるis--

448
00:23:50,906 --> 00:23:54,340
>> 聴衆：だからバックスラッシュrは単に暗示
行の先頭に戻ります

449
00:23:54,340 --> 00:23:56,670
実際に新しい行に行かなくても。

450
00:23:56,670 --> 00:24:01,000
だから、バックスラッシュrを印刷した場合
行の先頭に戻る

451
00:24:01,000 --> 00:24:04,005
あなたはあなたが上書き、より多くのものを印刷
すでに上のもの

452
00:24:04,005 --> 00:24:04,390
[聞き取れない]。

453
00:24:04,390 --> 00:24:06,725
一方、nは実際に新しいに行く
ラインと[聞こえない]に移動します。

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> スピーカー1：まあ、他の質問？

456
00:24:13,915 --> 00:24:15,430
かしこまりました。

457
00:24:15,430 --> 00:24:18,617
を切った私はそれを手にするつもりだ
継続するダン。

458
00:24:18,617 --> 00:24:25,078
>> [拍手]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN：すべての右腕投手。

461
00:25:09,720 --> 00:25:18,590
だから私は別の広いについて話されます
あるクラスからのアイデアの範囲

462
00:25:18,590 --> 00:25:23,220
週2のおおよその代表と
週3の開始はオフ開始

463
00:25:23,220 --> 00:25:28,690
のだけの方法で鋳造、と
などの特定の型の値を処理する

464
00:25:28,690 --> 00:25:30,830
異なるタイプの値。

465
00:25:30,830 --> 00:25:34,110
だから私たちはに文字でこれを行うことができます
int型、int型に浮かぶし、

466
00:25:34,110 --> 00:25:35,360
長いlong型は倍増する。

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> これらのことはすべて、方法として使用することができ
いくつかの数値を処置する

469
00:25:44,500 --> 00:25:48,370
他のいくつかのようなマイナスのchar
数値。

470
00:25:48,370 --> 00:25:54,480
だから、このいくつかの問題が存在し、
あなたはキャスト時に来るもちろん、

471
00:25:54,480 --> 00:25:57,860
int型へのフロートのようなもの。

472
00:25:57,860 --> 00:26:00,500
だから、これは少し奇妙です。

473
00:26:00,500 --> 00:26:03,170
私たちは、1.31であるフロートを持っている。

474
00:26:03,170 --> 00:26:05,220
私たちは、万を掛け。

475
00:26:05,220 --> 00:26:08,380
そして、私たちはintとしてそれを印刷。

476
00:26:08,380 --> 00:26:09,630
この出力は何でしょうか？

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000回1.31。

479
00:26:14,020 --> 00:26:18,761
だから13000、推測ということです？

480
00:26:18,761 --> 00:26:20,685
>> 聴衆：私はそれが万だと思う。

481
00:26:20,685 --> 00:26:24,234
>> DAN：だから私は万を乗じています
私はそれをキャストしています前に。

482
00:26:24,234 --> 00:26:25,202
>> 聴衆：ああ。

483
00:26:25,202 --> 00:26:27,622
1 9があると思いませんか
そして、いくつかの0の数字？

484
00:26:27,622 --> 00:26:29,270
>> DAN：あなたはいくつかの奇妙な数字があるかもしれません。

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
だから右、それは1.3倍万だ。

487
00:26:37,670 --> 00:26:40,040
だから、13000です。

488
00:26:40,040 --> 00:26:41,313
そして、この余分なweird--

489
00:26:41,313 --> 00:26:42,160
>> 聴衆：13,100。

490
00:26:42,160 --> 00:26:42,650
>> DAN：13,100。

491
00:26:42,650 --> 00:26:44,910
、ロブ、ありがとうございました。

492
00:26:44,910 --> 00:26:46,610
そして、この余分なweirdness--

493
00:26:46,610 --> 00:26:48,060
この9,9--

494
00:26:48,060 --> 00:26:53,860
単純にこの鋳造からです
ここで切り捨ててしまった

495
00:26:53,860 --> 00:26:55,394
それは持つべきではない。

496
00:26:55,394 --> 00:26:55,871
うん。

497
00:26:55,871 --> 00:26:58,256
>> 聴衆：キャスティングが起こる
何か他のものの後に？

498
00:26:58,256 --> 00:27:03,865
>> DAN：だから私は印刷物でこれを持っているので、それが
その前にこの乗算を行う

499
00:27:03,865 --> 00:27:05,230
このキャスティングを行います。

500
00:27:05,230 --> 00:27:06,140
>> 聴衆：[聞こえない]。

501
00:27:06,140 --> 00:27:11,350
>> DAN：私は、それが最初にキャストだと思う
うん、これ万になります。

502
00:27:11,350 --> 00:27:12,610
何か他には？

503
00:27:12,610 --> 00:27:13,330
クール。

504
00:27:13,330 --> 00:27:16,344
だから、これは13099です。

505
00:27:16,344 --> 00:27:17,840
これはなぜ起こるのでしょうか？

506
00:27:17,840 --> 00:27:18,900
不正確。

507
00:27:18,900 --> 00:27:21,020
>> フロートは完璧ではあり​​ません。

508
00:27:21,020 --> 00:27:27,550
彼らはの数を表現でき
有効数字の特定の数。

509
00:27:27,550 --> 00:27:35,120
だから私たちは8 SIGのイチジクをプリントアウトした場合
このフロート、私たちはの種類を取得

510
00:27:35,120 --> 00:27:36,800
醜い探し番号。

511
00:27:36,800 --> 00:27:45,580
そして、それはだから1.31を正確にすることはできません
単純で表すこと

512
00:27:45,580 --> 00:27:49,000
機械内の2のべき乗。

513
00:27:49,000 --> 00:27:53,530
だから、最も近いを取ってしまう
アップ終了する、推測する

514
00:27:53,530 --> 00:27:55,710
少し低いという。

515
00:27:55,710 --> 00:27:57,730
意味が？

516
00:27:57,730 --> 00:27:59,110
[OK]をクリックします。

517
00:27:59,110 --> 00:28:05,840
>> さて、切り替えは別の方法である
条件文のすべてをやって

518
00:28:05,840 --> 00:28:09,900
私たちは、単一の変数です気に。

519
00:28:09,900 --> 00:28:16,570
したがって、この特定の例では、私たちはしている
ユーザから整数を取得する。

520
00:28:16,570 --> 00:28:21,070
そして、私たちは見ている
その整数は何ですか。

521
00:28:21,070 --> 00:28:23,500
おそらく、それは数だ
1と4の間。

522
00:28:23,500 --> 00:28:24,800
つまり、私たちが求めているものだ。

523
00:28:24,800 --> 00:28:28,450
>> だから、の切り替えを行う
変数名。

524
00:28:28,450 --> 00:28:34,290
その後、可能性の症例を設定
それができる値。

525
00:28:34,290 --> 00:28:37,730
したがって、1つの小文字は、それが低いと言う。

526
00:28:37,730 --> 00:28:41,080
そして、あなたは外に出て破る
スイッチ状態のため、

527
00:28:41,080 --> 00:28:43,270
あなたが続けるされません。

528
00:28:43,270 --> 00:28:44,830
>> 次case--で

529
00:28:44,830 --> 00:28:46,940
、ケース2とケースthree--

530
00:28:46,940 --> 00:28:51,920
それはケース2の場合は、それだけに低下
それはのように見ているコードの最初の行

531
00:28:51,920 --> 00:28:55,400
それは休憩を見るまでケース3。

532
00:28:55,400 --> 00:29:00,430
だから、その理由は、あなたがする場合1を得る
低のみを印刷する私からです

533
00:29:00,430 --> 00:29:01,890
ここにこの休憩があります。

534
00:29:01,890 --> 00:29:05,360
私は、言う、このbreak--を無視した場合
私はこのbreakaway--を投げた場合は、

535
00:29:05,360 --> 00:29:09,740
低印刷う、そしてそれはだろ
中央を印刷し、それが壊れる。

536
00:29:09,740 --> 00:29:12,200
>> 休憩は重要な部分ですので、
スイッチ条件と

537
00:29:12,200 --> 00:29:14,340
彼らはそこにあるべきである。

538
00:29:14,340 --> 00:29:20,070
明示的に指定されていないすべてのケース
デフォルトで処理されます

539
00:29:20,070 --> 00:29:26,645
スイッチの場合とはキャストする必要があります。

540
00:29:26,645 --> 00:29:31,363
>> 聴衆：だから1、2、3、
そして図4は、n個のでしょうか？

541
00:29:31,363 --> 00:29:33,310
>> DAN：nの可能な値。

542
00:29:33,310 --> 00:29:34,654
はい。

543
00:29:34,654 --> 00:29:35,146
うん？

544
00:29:35,146 --> 00:29:37,606
>> 聴衆：だからあなたが持っている
[聞き取れない]のか？

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN：あなたは、低印刷したい
それが中央を印刷したい

547
00:29:46,830 --> 00:29:47,400
それは壊れる。

548
00:29:47,400 --> 00:29:50,244
>> 聴衆：なぜそれが印刷したい
中央の場合[聞き取れない]？

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN：ケースの下だからすべてのもの
ブレークが該当する前に。

551
00:30:00,550 --> 00:30:09,390
だから、ケース1のプリントは、下にケースです
のような1つは、この次のプリントである。

552
00:30:09,390 --> 00:30:09,890
うん？

553
00:30:09,890 --> 00:30:11,140
>> 聴衆：[聞き取れない]？

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN：だからこの数は単なる特定のです
値、この変数

556
00:30:22,170 --> 00:30:23,420
右、取ることができますか？

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
それは理にかなっていますか？

559
00:30:28,490 --> 00:30:28,990
うん。

560
00:30:28,990 --> 00:30:31,490
>> 聴衆：[聞き取れない]？

561
00:30:31,490 --> 00:30:34,130
>> DAN：はい、ケース2が印刷だろう
真ん中、次に破る。

562
00:30:34,130 --> 00:30:35,380
>> 聴衆：[聞き取れない]？

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN：私は思いますか？

565
00:30:40,050 --> 00:30:43,855
他にどのようなデータ型
あなたは切り替えることができますか？

566
00:30:43,855 --> 00:30:46,320
>> 聴衆：あなたは切り替えることができます
任意のデータタイプより。

567
00:30:46,320 --> 00:30:50,905
しかし、それは唯一の文字の上にものをいう
とintとそのようなもの、なぜなら

568
00:30:50,905 --> 00:30:55,600
あなたは、ポインタを切り替えるしている場合
それは本当に意味がない、

569
00:30:55,600 --> 00:30:59,555
それものを許可すれば、負荷をかけてスイッチング
あなたが原因浮動小数点のことを行います

570
00:30:59,555 --> 00:31:02,840
精度、あなたは本当にないだろう
とにかくそれをやってみたい。

571
00:31:02,840 --> 00:31:07,320
だからかなり、単にintと
そのような文字とか。

572
00:31:07,320 --> 00:31:12,360
>> DAN：明示的な持っている場合ええ、それはだ
あなたが知っている値が、私が思うに、することができ

573
00:31:12,360 --> 00:31:14,250
スイッチは実際に有用である。

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
良い？

576
00:31:18,990 --> 00:31:21,370
[OK]をクリックします。

577
00:31:21,370 --> 00:31:26,180
>> 適用範囲は、宣言された範囲である
変数が伸びている。

578
00:31:26,180 --> 00:31:32,190
だから、このコードの小さなチャンクに私が持っている、
それがエラーの完全なだろう。

579
00:31:32,190 --> 00:31:41,450
そしてその理由は、私はこのint型として宣言されている
私forループこれの範囲内である。

580
00:31:41,450 --> 00:31:46,390
そして私はあることを参照しようとしている
外側のループスコープのそのiの。

581
00:31:46,390 --> 00:31:50,330
>> そこで、基本的には、スコープについて考えることができます
あなたが宣言し、何として

582
00:31:50,330 --> 00:31:59,750
中括弧のセットの内部でのみ
これらの中括弧内に存在する。

583
00:31:59,750 --> 00:32:04,990
そして、あなたは試してみて、その変数を使用している場合
これらの中括弧の外には、よ

584
00:32:04,990 --> 00:32:08,356
コンパイラからのエラーが表示されます。

585
00:32:08,356 --> 00:32:08,812
うん？

586
00:32:08,812 --> 00:32:09,724
>> 聴衆：だからこの1つは動作しません？

587
00:32:09,724 --> 00:32:11,790
>> DAN：これは、はい、動作しません。

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
ストリングス。

590
00:32:18,660 --> 00:32:19,780
文字列のchar *。

591
00:32:19,780 --> 00:32:22,250
彼らはまったく同じだ。

592
00:32:22,250 --> 00:32:25,540
彼らはただの文字へのポインタである。

593
00:32:25,540 --> 00:32:33,000
そして、あなたが持っている任意の文字列を終了する必要があります
ただでバックスラッシュゼロ、と

594
00:32:33,000 --> 00:32:34,410
C大会。

595
00:32:34,410 --> 00:32:36,680
>> これは、NULLターミネータと呼ばれています。

596
00:32:36,680 --> 00:32:39,050
そしてNULL--

597
00:32:39,050 --> 00:32:41,670
首都N、資本U、資本
L、資本L--

598
00:32:41,670 --> 00:32:44,290
と同じではありません
NULLターミネータ。

599
00:32:44,290 --> 00:32:46,640
これはポインタです。

600
00:32:46,640 --> 00:32:48,280
これは文字です。

601
00:32:48,280 --> 00:32:49,530
彼らは非常に異なっている。

602
00:32:49,530 --> 00:32:50,200
それを忘れないでください。

603
00:32:50,200 --> 00:32:52,320
それはおそらく、クイズになります。

604
00:32:52,320 --> 00:32:54,040
私はクイズを見ていない。

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
うん？

607
00:32:58,840 --> 00:33:01,232
>> 聴衆：だから、NULLポインタ、たとえば、ある？

608
00:33:01,232 --> 00:33:01,995
>> DAN：はい。

609
00:33:01,995 --> 00:33:05,170
>> 聴衆：[聞こえない]は何？

610
00:33:05,170 --> 00:33:10,050
>> DANは：、と言う場合は、malloc関数が呼び出されたときに
取得するのに十分なメモリを持っていない

611
00:33:10,050 --> 00:33:14,400
何でもあなたが求めているサイズは、
malloc関数は、NULLを返します。

612
00:33:14,400 --> 00:33:19,550
関数であるときはいつでもそれは、基本的に、だ
あなたは、ポインタを返すことになって

613
00:33:19,550 --> 00:33:22,600
ので、NULLに対してチェックする必要があります
NULLはかなりgood--です

614
00:33:22,600 --> 00:33:25,260
それは、一種の、ガベージ値です。

615
00:33:25,260 --> 00:33:27,050
それは限りポインタが行くようにゼロです。

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> あなたは関数を呼び出すたびに、
それがポインタを返す。

618
00:33:32,250 --> 00:33:35,960
あなたがあることを確認するつもりだ
そのポインタがNULLでないことを確認してください

619
00:33:35,960 --> 00:33:37,760
NULLは非常に一般的であるからである。

620
00:33:37,760 --> 00:33:40,160
それは、ごみの戻りのようなものです。

621
00:33:40,160 --> 00:33:44,902
何かが右行かなかったのであれば、
だけではなく、NULLを返す。

622
00:33:44,902 --> 00:33:45,898
>> 聴衆：[聞き取れない]？

623
00:33:45,898 --> 00:33:48,922
>> DAN：はい、それはこれだ。

624
00:33:48,922 --> 00:33:51,750
>> 聴衆：[聞き取れない]？

625
00:33:51,750 --> 00:33:52,800
>> DAN：このとしてそれをスペル。

626
00:33:52,800 --> 00:33:54,150
これは、NULL終端です。

627
00:33:54,150 --> 00:33:56,560
これは、小文字のN-U-L-Lの場合です
あなたはそれをスペルだ。

628
00:33:56,560 --> 00:33:59,860
>> 聴衆：そして私はちょうど行きました
背中とそれをテスト。

629
00:33:59,860 --> 00:34:03,010
そして、あなたは、浮動小数点を入れしようとした場合
スイッチに値が、それはあなたに叫ぶよ

630
00:34:03,010 --> 00:34:05,916
と言って、文は、式が必要です
整数型。

631
00:34:05,916 --> 00:34:07,166
>> DAN：そこに行きます。

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
しかし、ええ、再び質問何でしたか？

634
00:34:12,246 --> 00:34:13,496
>> 聴衆：[聞き取れない]？

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN：だから資本N、資本U、資本
Lは、資本Lは実際のCの事である。

637
00:34:23,679 --> 00:34:29,719
これは、NULLポインタであり、意志
みそのように扱われる。

638
00:34:29,719 --> 00:34:33,530
あなたは今までに試してみて、スペルはありません
NULL文字と任意のものを参照してください。

639
00:34:33,530 --> 00:34:35,630
これ以外の方法で。

640
00:34:35,630 --> 00:34:36,610
うん？

641
00:34:36,610 --> 00:34:42,490
>> 観客は：だから最大charに戻ったり
ノートの何か、それだろう

642
00:34:42,490 --> 00:34:43,960
同じ機能を具現化する
[聞き取れない]として？

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> 聴衆：だからあなたが参照している
getcharがからchar型の最大値を返すか、

645
00:34:54,949 --> 00:34:55,444
何それは何ですか？

646
00:34:55,444 --> 00:34:55,940
>> 聴衆：うん。

647
00:34:55,940 --> 00:34:58,620
>> 聴衆：うん、そう一般
すべてのそれらの事を表す用語

648
00:34:58,620 --> 00:34:59,920
センチネル値です。

649
00:34:59,920 --> 00:35:03,640
だから、GetIntでからint型の最大値を返すように
とgetcharがからチャーmaxが、それはだ

650
00:35:03,640 --> 00:35:06,010
あれば、大丈夫のようであると考え
これらのことは、私たちに戻ってきている

651
00:35:06,010 --> 00:35:07,210
何かが間違っていた。

652
00:35:07,210 --> 00:35:09,950
>> ポインタの場合、私たちは持っていたりする
その誰もが、この標識値

653
00:35:09,950 --> 00:35:10,750
時に同意します。

654
00:35:10,750 --> 00:35:13,210
そして、これはあなたが返すものです
物事がうまくいかないとき。

655
00:35:13,210 --> 00:35:15,910
だから、char型の最大は、私たちが使用しているものです
何かを表現する

656
00:35:15,910 --> 00:35:18,100
NULLまたはgetcharがなどがある。

657
00:35:18,100 --> 00:35:23,420
>> 聴衆：だからにgetcharをテストしている場合には、
あなただけのNULLを入れることができます？

658
00:35:23,420 --> 00:35:23,910
それが違いを生むか？

659
00:35:23,910 --> 00:35:25,400
>> DAN：あなたは単にNULLをチェックしませんでした。

660
00:35:25,400 --> 00:35:30,130
あなたが原因のchar maxをチェックする必要があるだろう
関数からの戻り値は

661
00:35:30,130 --> 00:35:35,416
文字ではないポインタ。

662
00:35:35,416 --> 00:35:35,888
うん？

663
00:35:35,888 --> 00:35:38,248
>> 聴衆：この質問は尋ね
文字列の長さ。

664
00:35:38,248 --> 00:35:40,136
NULL文字が含まれないことに？

665
00:35:40,136 --> 00:35:41,000
>> DAN：いいえ

666
00:35:41,000 --> 00:35:45,930
そして、それは実際にどのように文字列の長さです
それは通過しますので、停止することを知っている

667
00:35:45,930 --> 00:35:49,070
文字の使用しているアレイまで、
それはNULL文字を見ている。

668
00:35:49,070 --> 00:35:51,030
そしてそれは、すべて、様だ
右、私は終わりだ。

669
00:35:51,030 --> 00:35:52,130
>> 聴衆：[聞こえない] 5？

670
00:35:52,130 --> 00:35:53,990
>> DAN：こんにちは、5つになります。

671
00:35:53,990 --> 00:35:55,240
うん。

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
そうアレイは連続している
メモリのブロック。

674
00:36:02,880 --> 00:36:08,480
彼らは言って瞬時にアクセスを持っている
カーリーの配列の名前と、その後、

675
00:36:08,480 --> 00:36:16,720
どこに行きたいどのような指標ブレース、
、それらが通ってゼロからインデックスさだします

676
00:36:16,720 --> 00:36:20,100
1を引いた配列の長さ。

677
00:36:20,100 --> 00:36:23,070
>> そして、彼らはのタイプによって宣言されている
あなたが保存しているもの

678
00:36:23,070 --> 00:36:29,750
アレイは、アレイの名前を入力し、
どんな大きさは、その配列のものである。

679
00:36:29,750 --> 00:36:36,660
だから、これは長さのchar配列である
これらの値を持つ6。

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
うん？

682
00:36:42,700 --> 00:36:43,950
>> 聴衆：[聞き取れない]？

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN：ええ。

685
00:36:48,460 --> 00:36:51,340
>> 聴衆：[聞き取れない]？

686
00:36:51,340 --> 00:36:56,700
>> DAN：あなたは何が起こっているかをお持ちの場合
配列に既に作った。

687
00:36:56,700 --> 00:37:02,260
だから、代わりにこれを指定することができるように、
あなたの任意の名前、チャーと言う

688
00:37:02,260 --> 00:37:12,200
配列は空括弧は中括弧に等しいです
HコンマEコンマLコンマLカンマを引き締める

689
00:37:12,200 --> 00:37:16,290
OコンマNULL文字
と中括弧。

690
00:37:16,290 --> 00:37:18,180
それはまた、宣言として働くだろう。

691
00:37:18,180 --> 00:37:20,886
>> 聴衆：[聞き取れない]？

692
00:37:20,886 --> 00:37:23,110
>> DAN：次に、あなたが持っている必要があります
サイズがすでに作った。

693
00:37:23,110 --> 00:37:23,896
>> 聴衆：[聞き取れない]？

694
00:37:23,896 --> 00:37:25,146
>> DAN：はい。

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
すべての右腕投手。

697
00:37:32,420 --> 00:37:36,430
コマンドライン引数は、方法です
ユーザーからの入力を取得するように

698
00:37:36,430 --> 00:37:39,380
主への引数。

699
00:37:39,380 --> 00:37:40,600
主な2つの引数を取ります。

700
00:37:40,600 --> 00:37:47,680
されている引数の数
コマンドラインであり、aに沿って通過

701
00:37:47,680 --> 00:37:55,340
文字列のベクトルまたは文字列配列
すべての引数の。

702
00:37:55,340 --> 00:38:07,840
>> だから私は、言う、のような関数を呼び出した場合は、
1スペース、2スペース、3アウトドット、

703
00:38:07,840 --> 00:38:10,110
argcが4になります。

704
00:38:10,110 --> 00:38:17,370
とargv 0アウトドットになります。

705
00:38:17,370 --> 00:38:19,130
Argv1は1になります。

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3は次のようになりますでしょう
3、その特定の場合には。

707
00:38:23,030 --> 00:38:23,310
うん？

708
00:38:23,310 --> 00:38:25,400
>> 聴衆：[聞き取れない]？

709
00:38:25,400 --> 00:38:34,010
>> DAN：配列の最後の要素
アレイは、長さのargcであるため、プラス

710
00:38:34,010 --> 00:38:41,050
ARGBの一つ、最後の要素
NULLポインタがある。

711
00:38:41,050 --> 00:38:42,580
それは、argcはプラス1です。

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
私は、それを言った場合にはそう
0アウトドットであるとargvされるであろう。

714
00:38:52,150 --> 00:38:56,330
argvは1が1 argv2が2 argvの3は3である。

715
00:38:56,330 --> 00:39:03,490
1大きくなっているのargv 4、
argcはなくNULLになります。

716
00:39:03,490 --> 00:39:04,870
>> そして、それはNULLポインタです。

717
00:39:04,870 --> 00:39:06,590
はい。

718
00:39:06,590 --> 00:39:11,250
文字列であるため、そして、それはだ
char型の星がポインタである。

719
00:39:11,250 --> 00:39:14,102
だから、同じ型である必要があります。

720
00:39:14,102 --> 00:39:14,595
うん？

721
00:39:14,595 --> 00:39:16,074
>> 聴衆：二つの質問。

722
00:39:16,074 --> 00:39:21,004
したがって、1つ、違いは何ですか
1型以外これとのGetString

723
00:39:21,004 --> 00:39:22,483
ユーザエンジンで？

724
00:39:22,483 --> 00:39:25,934
二、それは内格納されている
あなたの最近の記憶？

725
00:39:25,934 --> 00:39:28,399
だから様、のGetStringう
[聞き取れない]であること？

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN：それはどこに保存されている？

728
00:39:33,650 --> 00:39:34,905
それが保存されている場所私は知らない。

729
00:39:34,905 --> 00:39:40,000
>> 聴衆：だから、実際には、あなたがどの​​ようにいずれかの知っている
あなたはそれが引数の呼び出し機能

730
00:39:40,000 --> 00:39:42,170
スタックに格納されていますか？

731
00:39:42,170 --> 00:39:46,610
だから、argcとargvはmainの引数です
彼らは、スタック上にある、または実際に

732
00:39:46,610 --> 00:39:49,131
ちょうどあなたのように何を考えて上記の
スタックの開始。

733
00:39:49,131 --> 00:39:53,490
他の部分は何でしたか
質問の？

734
00:39:53,490 --> 00:39:56,821
>> 聴衆：だから何だ[聞き取れない]？

735
00:39:56,821 --> 00:40:00,990
>> DAN：ええ、それは単に別の方法です
ユーザからの入力を取得する。

736
00:40:00,990 --> 00:40:06,030
この1つは少し、より効率的で
それはあなたのためのスクリプトの手軽だ

737
00:40:06,030 --> 00:40:10,070
ちょうどあなたのメインに引数を渡すことができます
機能ではなく待つことよりも

738
00:40:10,070 --> 00:40:13,400
ユーザーのためにあなたはすべてのユーザーを持っていない場合。

739
00:40:13,400 --> 00:40:16,280
>> 聴衆：そして、ええ、文字列を取得する
[聞き取れない]になります。

740
00:40:16,280 --> 00:40:17,922
それはあなたが必要なものを保存するようにします。

741
00:40:17,922 --> 00:40:18,834
>> DAN：そうですか？

742
00:40:18,834 --> 00:40:21,114
>> 聴衆：[聞き取れない]？

743
00:40:21,114 --> 00:40:27,545
>> DAN：はい、argvの0は常に含まれてい
関数呼び出しのドットスラッシュ。

744
00:40:27,545 --> 00:40:28,042
うん？

745
00:40:28,042 --> 00:40:29,292
>> 聴衆：[聞き取れない]？

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN：はい、各引数である
彼らので、NULL文字で終了

748
00:40:37,310 --> 00:40:38,310
文字列です。

749
00:40:38,310 --> 00:40:40,892
>> 聴衆：[聞き取れない]？

750
00:40:40,892 --> 00:40:44,116
>> DAN：はい、のargv argcがNULLポインタである。

751
00:40:44,116 --> 00:40:45,112
>> 聴衆：[聞き取れない]？

752
00:40:45,112 --> 00:40:47,104
>> DAN：そうそう。

753
00:40:47,104 --> 00:40:48,100
ええ、申し訳ありません。

754
00:40:48,100 --> 00:40:49,594
>> 聴衆：だから[聞き取れない]？

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN：あなたが持っていたのであれば問題である
コマンド·ライン·ドットは、2、1からドットをスラッシュ

757
00:41:16,340 --> 00:41:20,410
れるコマンドライン数
引数が2であるか、それが3でしょうか？

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> 聴衆：私は、そうでないと思う
本当に問題。

760
00:41:28,240 --> 00:41:31,370
私が言う傾向があり、ああ、あなたは合格しなかった
任意のコマンドライン引数と、

761
00:41:31,370 --> 00:41:32,730
明らかに、あなたは関数を呼び出した。

762
00:41:32,730 --> 00:41:37,950
だから私は声に出して除外する傾向がある
コマンドラインから関数

763
00:41:37,950 --> 00:41:40,350
それはだにもかかわらず、引数
ARGVに含まれています。

764
00:41:40,350 --> 00:41:42,600
>> DAN：しかし、それはtest--上に存在していた場合

765
00:41:42,600 --> 00:41:46,550
yeah--、またあなたが何かを言うなら
argcは同様に、3に等しい

766
00:41:46,550 --> 00:41:48,512
あなたは安全な地位にいる。

767
00:41:48,512 --> 00:41:49,416
うん？

768
00:41:49,416 --> 00:41:50,666
>> 聴衆：[聞き取れない]？

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN：これを呼び出した場合は、代わりに私は思う
argcと文字列のargv括弧内の

771
00:42:09,510 --> 00:42:14,350
同じ型を維持し、単にと呼ばれる
のような別のそれらは何か

772
00:42:14,350 --> 00:42:16,640
aとb、それはまだ動作します？

773
00:42:16,640 --> 00:42:18,790
そして、それはまだ動作します、
あなたがjust--う

774
00:42:18,790 --> 00:42:21,520
代わりにargc--使う
あなたはaとbを使用すると思います。

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
うん？

777
00:42:25,408 --> 00:42:26,658
>> 聴衆：[聞き取れない]？

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN：そこで質問のGetStringです
ヒープでメモリを保存するために行く

780
00:42:38,850 --> 00:42:42,280
のGetStringがcharであるため、*。

781
00:42:42,280 --> 00:42:47,530
それは、ヒープでメモリを保存する
実際の内の今のmallocの呼び出し

782
00:42:47,530 --> 00:42:49,258
のGetStringの実装です。

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
[OK]を、先に進む。

785
00:42:55,090 --> 00:42:55,950
>> セキュリティ。

786
00:42:55,950 --> 00:43:01,090
だから、本当に安全であるとは、noに頼る
1、あなたはいずれにも誰もアクセスを許可しない

787
00:43:01,090 --> 00:43:04,540
なぜあなたの情報の
誰もが自分のマシンを構築し、

788
00:43:04,540 --> 00:43:09,580
独自のオペレーティングシステム、すべての
明らかに最初からプログラム、および

789
00:43:09,580 --> 00:43:13,410
他のマシンに接続しないでください
インターネットを介して。

790
00:43:13,410 --> 00:43:17,350
だから、コンピュータが安全ではありません。

791
00:43:17,350 --> 00:43:19,200
彼らは実際にある。

792
00:43:19,200 --> 00:43:20,940
私たちは他の人を信頼しなければならない。

793
00:43:20,940 --> 00:43:26,500
>> そして、セキュリティの考え方は、あなたがしているということです
の量を制限しようとする

794
00:43:26,500 --> 00:43:27,540
あなたが必要とする信頼。

795
00:43:27,540 --> 00:43:32,080
そして、あなたはそれを行う手段の一つに
暗号を介して行われます。

796
00:43:32,080 --> 00:43:34,950
暗号化は、本質的に、であり、
私たちは秘密を持っている。

797
00:43:34,950 --> 00:43:38,880
>> 時には私たちは私たちの秘密を渡す必要が
に沿って通って、たとえば、インターネットや

798
00:43:38,880 --> 00:43:39,980
他のもの。

799
00:43:39,980 --> 00:43:43,180
そして、私たちは人を望んでいない
これらの秘密を知っている。

800
00:43:43,180 --> 00:43:50,100
だから私たちは道に私達の秘密を暗号化する
私たちは誰も把握することができないことを願って。

801
00:43:50,100 --> 00:43:51,600
>> だから私たちはused--

802
00:43:51,600 --> 00:43:54,340
このclass--のコースを通して

803
00:43:54,340 --> 00:44:00,750
シーザー暗号のようなものと
非常に、非常にともに[聞こえない]は、

804
00:44:00,750 --> 00:44:03,200
物事を暗号化する安全でない方法。

805
00:44:03,200 --> 00:44:07,930
彼らはどのような彼らを理解するのは簡単だ
で、あなたの秘密は何ですか。

806
00:44:07,930 --> 00:44:12,130
現実の世界は、はるかにを使用しています
複雑な暗号化方式。

807
00:44:12,130 --> 00:44:13,880
そして、私たちは入ることはありません
それよりもはるか。

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> デバッグ。

810
00:44:19,430 --> 00:44:20,785
GDBは最高です。

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
私は再びこれを強調するつもりです。

813
00:44:25,810 --> 00:44:30,920
すべてのGDBのすべての時間を使用してください
時間は、あなたが問題を抱えている。

814
00:44:30,920 --> 00:44:36,030
GDBにおいて有用なコマンドがある
あなたが行のいずれかを通過する、破る

815
00:44:36,030 --> 00:44:41,330
番号、関数名、本質的に
ここで、コード内で停止する、

816
00:44:41,330 --> 00:44:45,600
と制御を取ることができる。

817
00:44:45,600 --> 00:44:54,140
>> 印刷は、変数を取得し、出力します
その変数は、その時には何でも

818
00:44:54,140 --> 00:44:55,990
あなたの実行のポイント。

819
00:44:55,990 --> 00:45:00,130
次に、あなたの実行が移動します
一歩沿い。

820
00:45:00,130 --> 00:45:05,050
そして、関数内のステップを進む
あなたの実行中。

821
00:45:05,050 --> 00:45:10,480
>> 他のものはどのようにある、経営されています
あなたが実際にあなたのコードを実行します。

822
00:45:10,480 --> 00:45:16,630
続行は必要なすべての措置を講じ
次のブレークポイントに到達します。

823
00:45:16,630 --> 00:45:18,300
そして、多くの、多くの他がある。

824
00:45:18,300 --> 00:45:19,040
それらを検索します。

825
00:45:19,040 --> 00:45:19,901
彼らは偉大だ。

826
00:45:19,901 --> 00:45:20,863
うん？

827
00:45:20,863 --> 00:45:22,113
>> 聴衆：[聞き取れない]？

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN：はい、デバッガです。

830
00:45:28,200 --> 00:45:34,230
だから、デバッガはそのプログラムです
あなたがプログラムをデバッグすることができます。

831
00:45:34,230 --> 00:45:39,931
それはのためにバグを見つけたプログラムではありません
あなたは、しかしそれは素晴らしいことだ。

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> そして、私の最後の検索である。

834
00:45:46,040 --> 00:45:51,470
だから私たちが話した検索の種類は
このクラスの約線形探索であり、

835
00:45:51,470 --> 00:45:55,960
これは、各目を通すことだけである
探索空間の要素、1

836
00:45:55,960 --> 00:46:00,410
当時の要素、あなたは何を見つけるまで
あなたは、またはあなたが到達するまで、探している

837
00:46:00,410 --> 00:46:03,350
あなたの探索空間の終わりに
あなたが見つけることができなかったと言う点

838
00:46:03,350 --> 00:46:06,360
あなたが探していた要素。

839
00:46:06,360 --> 00:46:13,450
これは最高の状態で一定時間がかかり、
その1の0であり、最悪の線形で

840
00:46:13,450 --> 00:46:16,070
nは0である時、。

841
00:46:16,070 --> 00:46:19,250
>> 必要バイナリ検索、
浅ましい要素。

842
00:46:19,250 --> 00:46:24,230
あなたの要素の真ん中に移動し、
要素は、あなたが探しているかどうかを確認

843
00:46:24,230 --> 00:46:30,120
要素より大きいか小さい
あなたが真ん中にいること。

844
00:46:30,120 --> 00:46:36,510
それより大きなです、あなたが下と言う
あなたの探索空間のあなたです

845
00:46:36,510 --> 00:46:41,550
現在の位置、中間、
あなたがプロセスを再起動します。

846
00:46:41,550 --> 00:46:46,150
それが小さいなら、あなたが言うに見える
ええ、最大何the--は？

847
00:46:46,150 --> 00:46:47,400
>> 聴衆：[聞き取れない]？

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN：はい。

850
00:46:54,260 --> 00:46:58,360
で教えられています並べ替えの任意の並べ替え
クラスには、テストのために公正なゲームです。

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [笑い]

853
00:47:04,920 --> 00:47:10,260
>> DAN：そして、あなたは持っていなかったという事実
設定の問題のためにそれを行うためには、公正だ

854
00:47:10,260 --> 00:47:12,420
テストのためのゲーム。

855
00:47:12,420 --> 00:47:15,186
>> 聴衆：私たちはその上に行くことができますどのようにto--

856
00:47:15,186 --> 00:47:17,052
>> DAN：それ以上消えてしまいます。

857
00:47:17,052 --> 00:47:20,496
>> SPEAKER 2：の実際のコード
[聞き取れない] study.cs50.netにあります。

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
だから、練習問題を見れば
のマージソートページで

860
00:47:32,680 --> 00:47:35,880
study.cs50.net、コードがあります
ソートマージ実装する。

861
00:47:35,880 --> 00:47:38,550
だから、実装する必要はありません
それを自分で今夜。

862
00:47:38,550 --> 00:47:42,090
しかし、あなたはむしろそれを理解しておいてください
ただそれを暗記より。

863
00:47:42,090 --> 00:47:45,035
>> 聴衆：[聞き取れない]？

864
00:47:45,035 --> 00:47:49,720
>> SPEAKER 2：上のマージソートページ
study.cs50.net、練習がある

865
00:47:49,720 --> 00:47:53,570
あなたはを通してクリックした場合、問題
問題は、一番最後にあります

866
00:47:53,570 --> 00:47:56,280
マージで解決策、
ソートの実装。

867
00:47:56,280 --> 00:47:58,510
しかし、あなたはそれを理解しておいてください
むしろそれを暗記より

868
00:47:58,510 --> 00:47:59,760
またはそれをコピーする。

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> 聴衆：そして完全に有効
試験の問題は次のようになります

871
00:48:06,340 --> 00:48:07,990
ここのようなものがリストです。

872
00:48:07,990 --> 00:48:12,100
このリストは後にはどのように見えるのか
選択の1つのステップの並べ替えや

873
00:48:12,100 --> 00:48:13,330
挿入ソートまたは何でも。

874
00:48:13,330 --> 00:48:14,940
リストの一つの完全な反復。

875
00:48:14,940 --> 00:48:18,530
だから、あなたが必要としてしまうしない場合でも、
そのためのコードは、あなたがそれを理解する必要があります

876
00:48:18,530 --> 00:48:20,440
それが起こっているのかを知るには十分
この配列を変更することができる。

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN：それは私のためにそれだ。

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [拍手]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS：ねえ、みんな。

883
00:49:07,410 --> 00:49:08,390
私の名前はルーカスです。

884
00:49:08,390 --> 00:49:16,840
私はすべて、再帰について話をするつもりだ
私たちが学んできた種類であり、a

885
00:49:16,840 --> 00:49:18,050
すべてのポインタを少し。

886
00:49:18,050 --> 00:49:18,740
OK？

887
00:49:18,740 --> 00:49:20,340
すべてのだからまず、再帰。

888
00:49:20,340 --> 00:49:22,951
それはそれを言うことは何を意味するのか
関数は再帰的である？

889
00:49:22,951 --> 00:49:24,675
>> 観客は：自分自身を呼び出します。

890
00:49:24,675 --> 00:49:26,500
>> ルーカス：OK、ええ、自身を呼び出す。

891
00:49:26,500 --> 00:49:27,700
したがって、たとえば、この絵が好きです。

892
00:49:27,700 --> 00:49:30,280
それは、内部​​の絵のようなものだ
絵ののように。

893
00:49:30,280 --> 00:49:35,740
だからたとえば、ダンとしてhave--できる
それは、二分探索について話していた。

894
00:49:35,740 --> 00:49:41,840
バイナリ検索が1つの方法
再帰はあなたがしているという事実である

895
00:49:41,840 --> 00:49:43,130
番号を見つけよう。

896
00:49:43,130 --> 00:49:44,250
だから、真ん中に移動します。

897
00:49:44,250 --> 00:49:47,130
そこの数字ならば、あなたは確認する
左中、右中。

898
00:49:47,130 --> 00:49:49,650
>> あなたが見つけた場合、次に番号です
左側にあることを行って、それは同じだ

899
00:49:49,650 --> 00:49:53,340
もう一度検索を行うようなことが、
ただ、リストの左側にある。

900
00:49:53,340 --> 00:49:57,350
だから、それがどのように聞こえるかだ
のような、それは再帰的です。

901
00:49:57,350 --> 00:50:01,870
あなたたちは、再帰的な持っている理由だからです
マージソートのためのソリューション。

902
00:50:01,870 --> 00:50:04,270
>> [OK]を、ので、ここでの例です。

903
00:50:04,270 --> 00:50:07,280
それでは、私が選択したいとしましょう
1からnまでのすべての数字。

904
00:50:07,280 --> 00:50:13,790
Iは、nの和ことを実現することができる
数がn個プラスnはマイナス1までです。

905
00:50:13,790 --> 00:50:17,810
しかし、その後、私はnのマイナス1を見ればプラス
nはマイナス2プラス1、それは同じだ

906
00:50:17,810 --> 00:50:20,680
数字を合計するようなもの
までのnはマイナス1。

907
00:50:20,680 --> 00:50:25,890
だから私は、同じ和の合計を言うことができます
nはマイナス1のnのプラス合計に等しい。

908
00:50:25,890 --> 00:50:28,010
それは理にかなっていますか？

909
00:50:28,010 --> 00:50:32,630
>> そして、私はまた何か他のものを持っているだろう
ということで、基本ケースと呼ばれる

910
00:50:32,630 --> 00:50:37,440
最大数の和
ゼロにゼロになる。

911
00:50:37,440 --> 00:50:42,770
だから、すぐに私は数​​に到達するように
ゼロ、私はカウントを停止します。

912
00:50:42,770 --> 00:50:45,330
それは理にかなっていますか？

913
00:50:45,330 --> 00:50:48,120
>> そこでここでは方法の例です
私はそれを実装することができます。

914
00:50:48,120 --> 00:50:49,860
だから私はいくつかの中で、この機能を持っている。

915
00:50:49,860 --> 00:50:51,700
つまり、整数nを取ります。

916
00:50:51,700 --> 00:50:56,300
nがある場合だからここに私が最初に確認してください
以下はゼロに等しい。

917
00:50:56,300 --> 00:51:00,310
だから、ゼロ以下のだと、私は
私たちの基本ケースである、ゼロを返します。

918
00:51:00,310 --> 00:51:05,690
そうでなければ、私はちょうど戻ることができるnのプラス
数字の合計から

919
00:51:05,690 --> 00:51:07,190
1からnマイナス1。

920
00:51:07,190 --> 00:51:09,360
意味が？

921
00:51:09,360 --> 00:51:10,100
[OK]をクリックします。

922
00:51:10,100 --> 00:51:11,610
>> だからここには次のようになります。

923
00:51:11,610 --> 00:51:15,260
あなたは2等号の合計を持っている
2プラス1の合計。

924
00:51:15,260 --> 00:51:18,930
そして1の一部はプラス1です
0 0の和。

925
00:51:18,930 --> 00:51:20,216
意味が？

926
00:51:20,216 --> 00:51:25,342
だから私たちはあなたのスタックを見れば
このプログラムは、これは次のようになります。

927
00:51:25,342 --> 00:51:26,820
>> まず、主な機能を持っています。

928
00:51:26,820 --> 00:51:30,320
そして、主な機能
合計2と呼ばれる。

929
00:51:30,320 --> 00:51:36,690
そして、合計2ああ、和、言おうとしている
図2は、2プラスワンの合計に等しい。

930
00:51:36,690 --> 00:51:39,460
だから私は、スタックに1の合計を追加します。

931
00:51:39,460 --> 00:51:43,860
そして、1の合計は、の合計を呼び出すために起こっている
また、追加されようとしている0、

932
00:51:43,860 --> 00:51:44,630
スタックを意味します。

933
00:51:44,630 --> 00:51:49,240
あるこれらのもののそれから、それぞれの
互いの上に返却する必要があり

934
00:51:49,240 --> 00:51:52,020
他のものは続けることができます前に。

935
00:51:52,020 --> 00:51:56,240
>> ですから、例えば、ここでは、0の合計は、
まず、0を返すようになるだろう。

936
00:51:56,240 --> 00:51:58,320
そして、1の合計を選択します。

937
00:51:58,320 --> 00:52:00,850
その後、1の合計がしようとしている
2の和に1を返す。

938
00:52:00,850 --> 00:52:03,900
そして最後に、2の和が起こっている
主に3を返します。

939
00:52:03,900 --> 00:52:05,320
それは理にかなっていますか？

940
00:52:05,320 --> 00:52:09,496
>> それはどのように理解することは本当に重要です
スタックは、働いてしようとされている

941
00:52:09,496 --> 00:52:11,980
それは理にかなっているかどうかを確認します。

942
00:52:11,980 --> 00:52:13,260
[OK]を、そのように並べ替え。

943
00:52:13,260 --> 00:52:16,170
では、なぜ重要なのソートされている、
まず？

944
00:52:16,170 --> 00:52:18,260
なぜ気にしなければならない？

945
00:52:18,260 --> 00:52:20,310
誰ですか？

946
00:52:20,310 --> 00:52:20,695
私の例を与えるか？

947
00:52:20,695 --> 00:52:21,040
うん？

948
00:52:21,040 --> 00:52:22,968
>> 聴衆：[聞こえない]。

949
00:52:22,968 --> 00:52:24,700
>> LUCAS：うん、OK。

950
00:52:24,700 --> 00:52:26,090
だから、より効率的に検索することができます。

951
00:52:26,090 --> 00:52:28,580
それは良い方法です。

952
00:52:28,580 --> 00:52:32,462
したがって、たとえば、私たちはたくさんある
物事、実際には、私たちの生活の中でその

953
00:52:32,462 --> 00:52:32,920
並べ替えられています。

954
00:52:32,920 --> 00:52:34,830
たとえば、辞書。

955
00:52:34,830 --> 00:52:39,210
>> それはすべて持っていることは非常に重要です
オーダーのいくつかの種類の単語その私たち

956
00:52:39,210 --> 00:52:41,970
簡単にアクセスすることができます。

957
00:52:41,970 --> 00:52:43,280
だから、彼が言っていたんだ。

958
00:52:43,280 --> 00:52:45,530
あなたは、より効率的に検索することができます。

959
00:52:45,530 --> 00:52:48,740
それは持っているだろうどのようにハードを考える
言葉がでていた辞書

960
00:52:48,740 --> 00:52:49,500
ランダムな順序。

961
00:52:49,500 --> 00:52:53,120
あなたは、ほとんど、見てみなければならないでしょう
一つ一つの単語を見つけるまで、

962
00:52:53,120 --> 00:52:54,720
あなたが探している単語。

963
00:52:54,720 --> 00:52:58,710
>> あなたもフェイスブックを使用している場合は、時
あなたの友人を見ている、あなたがしている

964
00:52:58,710 --> 00:53:03,540
Facebookがあなたを置くことを見に行く
ものの上に近い友人の

965
00:53:03,540 --> 00:53:05,470
あなたは、はるかにそれに話をしないこと。

966
00:53:05,470 --> 00:53:08,080
あなたはの底にすべての道を行けば
あなたの友達リストには、次のように表示するつもりだ

967
00:53:08,080 --> 00:53:11,250
あなたはおそらくさえない人
あなたが友達だことを覚えておいてください。

968
00:53:11,250 --> 00:53:14,590
Facebookがソートされますので、それはだ
方法に基づいて、あなたの友人

969
00:53:14,590 --> 00:53:16,472
あなたが彼らにある閉じます。

970
00:53:16,472 --> 00:53:17,930
>> だから、データを編成する。

971
00:53:17,930 --> 00:53:18,450
また、ポケモン。

972
00:53:18,450 --> 00:53:21,400
だから、すべてのポケモンがわかり
番号があります。

973
00:53:21,400 --> 00:53:27,210
そして、それは簡単なようなものだ
データにアクセスする方法です。

974
00:53:27,210 --> 00:53:29,050
>> 聴衆：ポケモンへのアクセス。

975
00:53:29,050 --> 00:53:29,890
>> LUCAS：うん。

976
00:53:29,890 --> 00:53:32,395
>> 聴衆：[聞こえない]。

977
00:53:32,395 --> 00:53:33,460
>> LUCAS：うん。

978
00:53:33,460 --> 00:53:35,140
そう、選択ソート。

979
00:53:35,140 --> 00:53:41,610
選択ソートを選択しようとしている
リストの最小のソートされていない値の各

980
00:53:41,610 --> 00:53:43,300
各反復の時間。

981
00:53:43,300 --> 00:53:46,800
それは一種のあなたが並べ替えのようなものだ
あなたの頭の中であなたがしようとしているとき

982
00:53:46,800 --> 00:53:48,430
手持ちのリストをソート。

983
00:53:48,430 --> 00:53:51,990
>> 基本的に、あなたが行うすべてがあなたが見ている
最小数のため。

984
00:53:51,990 --> 00:53:54,280
あなたは、ソートされたリストに入れて。

985
00:53:54,280 --> 00:53:56,230
そして、あなたが探して
次の最小数。

986
00:53:56,230 --> 00:54:00,080
そして、あなたがやり続ける
そののように。

987
00:54:00,080 --> 00:54:04,600
>> だから、選択ソートを使用すると、基本的にはある
毎回最小を選択

988
00:54:04,600 --> 00:54:05,750
ソートされていない値。

989
00:54:05,750 --> 00:54:10,840
ソートの最後に入れて
リストの一部。

990
00:54:10,840 --> 00:54:12,370
そして、それをやり続ける。

991
00:54:12,370 --> 00:54:15,890
それでは、すぐに何を見てみましょう
これは次のようになります。

992
00:54:15,890 --> 00:54:19,340
だからここに並べ替えます
そしてソートされていないリスト。

993
00:54:19,340 --> 00:54:23,350
>> だから、リストのソートされたため、
それは最初は空です。

994
00:54:23,350 --> 00:54:26,760
そして私は選択するつもりです
2は、ここで最小数。

995
00:54:26,760 --> 00:54:30,650
だから私は、数2を取得し、私が入れ
リストの先頭にある。

996
00:54:30,650 --> 00:54:34,910
そして私は、次の最小を探す
3である要素。

997
00:54:34,910 --> 00:54:37,050
だから私は最後にそれを置く
ソートされたリストの。

998
00:54:37,050 --> 00:54:38,140
そして私はそれをやり続ける。

999
00:54:38,140 --> 00:54:40,040
私は4を見つけて、最後にそれを置く。

1000
00:54:40,040 --> 00:54:41,360
5を見つけて、最後にそれを置く。

1001
00:54:41,360 --> 00:54:44,830
>> そして、それらの時代のどのすべてのことを見て
私は最後にそれをされて入れて言っている、

1002
00:54:44,830 --> 00:54:46,850
基本的に2つの値を交換する。

1003
00:54:46,850 --> 00:54:48,100
OK？

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
そして最後の、あなただけの
1より多くの要素を持っている。

1006
00:54:52,825 --> 00:54:55,870
だから、それがすでにソートだ。

1007
00:54:55,870 --> 00:54:57,800
>> そう、挿入ソート。

1008
00:54:57,800 --> 00:55:03,180
あなたはまた、必要があるとしている挿入ソート
ソートさを持っていることのようなものと

1009
00:55:03,180 --> 00:55:04,690
ソートされていないリスト。

1010
00:55:04,690 --> 00:55:14,540
唯一のことは、そのたびに、つまり
あなたはソートに要素を追加している

1011
00:55:14,540 --> 00:55:18,170
リスト、あなただけの要素を選ぶこと
ソートされていないリストの前にある。

1012
00:55:18,170 --> 00:55:20,880
そして、あなたは何を見つけるつもりだ
それは、ソートさであるべき位置

1013
00:55:20,880 --> 00:55:22,300
リストの一部。

1014
00:55:22,300 --> 00:55:25,840
>> それではこれがそうであるか見てみましょう
これは、より理にかなっている。

1015
00:55:25,840 --> 00:55:29,360
だから最初は、例えば、私がしようとしている
で3番を挿入する

1016
00:55:29,360 --> 00:55:30,680
リストの一部を選別した。

1017
00:55:30,680 --> 00:55:31,800
だから、リストには何もありません。

1018
00:55:31,800 --> 00:55:34,160
だから、僕は3番を置くことができます。

1019
00:55:34,160 --> 00:55:37,480
>> 今、私は数に5を追加したい
リストのソートされた部分。

1020
00:55:37,480 --> 00:55:38,900
だから私は、数字の5を見てください。

1021
00:55:38,900 --> 00:55:40,450
私はそれが3以上だと気づく。

1022
00:55:40,450 --> 00:55:41,980
だから私は、それは3の後でなければならないことを知っている。

1023
00:55:41,980 --> 00:55:44,100
だから私は3と5を置く。

1024
00:55:44,100 --> 00:55:45,940
>> それから私は、数2を挿入する。

1025
00:55:45,940 --> 00:55:51,630
私は、数2が実際にあることに気付く
その後3と5の両方を持続。

1026
00:55:51,630 --> 00:55:54,580
だから私は実際にそれをすべて配置する必要があります
リストの先頭にある道。

1027
00:55:54,580 --> 00:55:59,030
だから私は、ちょっと、すべてシフトしている
ソートされたリスト内の要素私ができるので、

1028
00:55:59,030 --> 00:56:01,970
数2のためのスペースを作る。

1029
00:56:01,970 --> 00:56:03,160
>> それから私は、数6を参照してください。

1030
00:56:03,160 --> 00:56:05,450
私はそれが5の後でなければならないことがわかります。

1031
00:56:05,450 --> 00:56:06,240
だから私はそこにそれを置く。

1032
00:56:06,240 --> 00:56:07,965
そして最後に、私は数4を見てください。

1033
00:56:07,965 --> 00:56:11,030
そして、私はそれが必要に気づく
3と5の間である。

1034
00:56:11,030 --> 00:56:14,870
そして私はそこにそれを置くとシフト
他のすべての要素。

1035
00:56:14,870 --> 00:56:16,120
意味が？

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> バブルソート。

1038
00:56:19,150 --> 00:56:25,730
だから、バブルソートを使用すると、しているものを基本的に
do--に行く私たちは、バブルと呼んで

1039
00:56:25,730 --> 00:56:30,113
あなたはlist--を通過ソートので
私は示していれば、実際には良いでしょう

1040
00:56:30,113 --> 00:56:32,300
あなたが好きthis--

1041
00:56:32,300 --> 00:56:35,030
あなたが比較するつもりだ
隣接する数字。

1042
00:56:35,030 --> 00:56:38,410
そして、あなたは彼らを交換するつもりだ
ポジション彼らがいないのであれば

1043
00:56:38,410 --> 00:56:39,190
正しい順序で。

1044
00:56:39,190 --> 00:56:42,570
>> したがって、基本的に何が起こっている
ここで起こり、例えば、

1045
00:56:42,570 --> 00:56:44,160
あなたが8と6を持っている。

1046
00:56:44,160 --> 00:56:47,270
あなたは、ソートされた順序がことを知っている
実際に右、6,5であること？

1047
00:56:47,270 --> 00:56:49,540
だから、受注を交換するつもりだ。

1048
00:56:49,540 --> 00:56:51,370
それから私は、ここに8と4を参照してください。

1049
00:56:51,370 --> 00:56:52,250
そして、私は同じことを行う。

1050
00:56:52,250 --> 00:56:53,400
私は再び交換します。

1051
00:56:53,400 --> 00:56:55,070
そして最後に、2および8。

1052
00:56:55,070 --> 00:56:56,670
私はまた、それらを交換。

1053
00:56:56,670 --> 00:57:01,690
>> これは、バブルソートのための後と呼ばれています
これらの反復のそれぞれ、実際に、

1054
00:57:01,690 --> 00:57:05,910
リスト内の最大数は、すべての取得
リストの最後への道。

1055
00:57:05,910 --> 00:57:06,940
それは理にかなっていますか？

1056
00:57:06,940 --> 00:57:11,880
それをスワッピング続け​​るので
、右に移動する。

1057
00:57:11,880 --> 00:57:14,440
>> [OK]を、これは2回目の反復である。

1058
00:57:14,440 --> 00:57:17,200
それは同じことになります。

1059
00:57:17,200 --> 00:57:20,190
私は1つのスワップをやると
最後のもの。

1060
00:57:20,190 --> 00:57:23,290
私は全くスワップは存在しないこと
そしてリストがソートされます。

1061
00:57:23,290 --> 00:57:27,460
だから、バブルソートで、私たちは基本的に維持
リストを通過するとスワッピング

1062
00:57:27,460 --> 00:57:32,310
物事は私がしなかったことに気づくまで、
その繰り返しをやってあらゆるスワップ、どの

1063
00:57:32,310 --> 00:57:34,270
リストがすでにソートされていることを意味している。

1064
00:57:34,270 --> 00:57:35,520
意味が？

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> それでは少し話そう
時間の実行に関する。

1067
00:57:40,870 --> 00:57:45,165
だから、あなたたちはビッグを覚えていますか
O、オメガ、及びシータ？

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
うん？

1070
00:57:50,990 --> 00:57:53,070
[OK]を、まず、ビッグO何ですか？

1071
00:57:53,070 --> 00:57:54,315
>> 聴衆：[聞こえない]。

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS：ええ、それは最悪のケースと呼ばれています
ちょうどそれがだことを意味し、実行時、

1073
00:57:59,070 --> 00:58:03,470
どのくらいのプログラムを期待する
実行するために取る。

1074
00:58:03,470 --> 00:58:04,910
同様に、用語でof--

1075
00:58:04,910 --> 00:58:06,660
このcase-- nの。

1076
00:58:06,660 --> 00:58:09,150
の要素数
最悪の場合にはリスト。

1077
00:58:09,150 --> 00:58:12,520
同様に、最悪の場合には。

1078
00:58:12,520 --> 00:58:17,100
>> バブルソートのためにそのため、例えば、
私たちは、n個の正方形のビッグOを持っている。

1079
00:58:17,100 --> 00:58:20,580
なぜそれを持っていますか？

1080
00:58:20,580 --> 00:58:24,716
なぜバブルソートビッグO nの正方形である？

1081
00:58:24,716 --> 00:58:27,614
>> 聴衆：[聞こえない]。

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS：うん、そう最悪の場合は、になります
という私は、n個の反復を行う必要があるでしょう。

1083
00:58:35,670 --> 00:58:39,260
だから、反復のそれぞれがしようとしている
最後に最大の要素を持って来る

1084
00:58:39,260 --> 00:58:40,290
リストの。

1085
00:58:40,290 --> 00:58:44,230
だから、最悪の場合は、私が持っているということです
その事をn回行う。

1086
00:58:44,230 --> 00:58:48,550
そして、それらの時間のそれぞれについて、私がする必要が
私は比較する必要があるため、n個のスワップを行う

1087
00:58:48,550 --> 00:58:49,870
各二つの要素。

1088
00:58:49,870 --> 00:58:53,730
だから、それがnの二乗の理由です
それはn倍のnだから。

1089
00:58:53,730 --> 00:59:00,120
>> 次に、選択ソートもnの正方形である
ので、各反復のために、私がする必要が

1090
00:59:00,120 --> 00:59:02,650
一つ一つの要素を見て
リスト中。

1091
00:59:02,650 --> 00:59:04,980
そして、最小を見つける
これは私がしなければならないことを意味

1092
00:59:04,980 --> 00:59:06,130
n個の要素に目を通す。

1093
00:59:06,130 --> 00:59:11,750
そして、私はそのn回のためにしなければならない
私はすべてのn個の要素を選択する必要があります。

1094
00:59:11,750 --> 00:59:18,273
>> 挿入ソートもnの正方形である
最悪のシナリオは、意志ため

1095
00:59:18,273 --> 00:59:20,950
、いずれかになり、私は挿入する必要が
n個の数字、右か？

1096
00:59:20,950 --> 00:59:22,765
だから私はすでに、私は行くよことを知っている
n個の反復を持つ。

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
しかし、私は持っていたこれらの数字のそれぞれについて、場合に
中の数字のすべてを見てする

1099
00:59:29,840 --> 00:59:34,380
ソートされたリストと、それをすべての方法を置く
前に、それがn個の正方形になります

1100
00:59:34,380 --> 00:59:36,230
それはn倍のn再びになりますので。

1101
00:59:36,230 --> 00:59:38,280
意味が？

1102
00:59:38,280 --> 00:59:41,512
どのようなオメガはどうですか？

1103
00:59:41,512 --> 00:59:42,886
>> 聴衆：[聞こえない]。

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS：それは最良のシナリオです。

1105
00:59:44,620 --> 00:59:48,810
だから、多くの時間のために、ようなものだ
最良のシナリオであり、ソーティング

1106
00:59:48,810 --> 00:59:50,660
リストがすでにソートされている場合。

1107
00:59:50,660 --> 00:59:52,670
だから、本当に持っていない
何もする。

1108
00:59:52,670 --> 00:59:56,290
バブルソートの最良を持って
n個の場合のシナリオ。

1109
00:59:56,290 --> 00:59:58,820
君たちはどうして知っていますか？

1110
00:59:58,820 --> 01:00:00,620
>> 聴衆：[聞こえない]。

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS：ええ、あなたはを追跡した場合
データ比は、任意のスワップを持っていたかどうか

1112
01:00:05,640 --> 01:00:10,533
あなたが何かを持っている場合ではない、に設定のように
反復があれば、そこにあった場合はtrue

1113
01:00:10,533 --> 01:00:15,140
リストには、すでに、基本的には、ソートされ
何が起こるために起こっていることは、私はするつもりです。

1114
01:00:15,140 --> 01:00:17,890
各2を交換しよう
隣接する要素。

1115
01:00:17,890 --> 01:00:19,920
私はそれを見に行くよ
何スワップはありません。

1116
01:00:19,920 --> 01:00:21,230
そして私はちょうどすぐに戻ります。

1117
01:00:21,230 --> 01:00:24,240
>> だから、私はしなければならなかったことを意味します
リスト1の時間を通過します。

1118
01:00:24,240 --> 01:00:28,990
私が見ているのでだから、Nさん
n個の要素で。

1119
01:00:28,990 --> 01:00:30,930
なぜ選択ソートのn乗？

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> ええ、リストがソートされている場合であっても、用
選択ソートの反復ごとに、私

1122
01:00:45,520 --> 01:00:47,590
最小の要素を選択する必要があります。

1123
01:00:47,590 --> 01:00:49,980
だから、それは私が見てアウト持っていることを意味します
ソートされていないすべての要素で

1124
01:00:49,980 --> 01:00:53,350
一覧表示し、最小値を求める
反復ごと。

1125
01:00:53,350 --> 01:00:54,600
それは理にかなっていますか？

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> 挿入剣はnなぜなら中
私が挿入しようとしている場合

1128
01:01:04,690 --> 01:01:09,320
数字と数字のすべて、ときに私
それらを挿入しようと、私は彼らがいることがわかり

1129
01:01:09,320 --> 01:01:10,510
右の位置にある。

1130
01:01:10,510 --> 01:01:15,120
私は他のすべてをチェックしに行く必要はありません
ソートされていないリスト内の番号。

1131
01:01:15,120 --> 01:01:17,170
それがn個になりますだから、なぜだ。

1132
01:01:17,170 --> 01:01:19,480
意味が？

1133
01:01:19,480 --> 01:01:21,035
そして、シータは何ですか？

1134
01:01:21,035 --> 01:01:23,410
>> 聴衆：[聞こえない]。

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS：何、申し訳ありませんが？

1136
01:01:24,380 --> 01:01:24,960
もう一度言って。

1137
01:01:24,960 --> 01:01:25,666
>> 聴衆：[聞こえない]。

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS：その通り。

1139
01:01:26,490 --> 01:01:31,280
だから、その選択のみを見ることができます
マージに格納されたソートθをしています。

1140
01:01:31,280 --> 01:01:39,920
そして、あなたは唯一のシータを持っているので、それはだ
ビッグOとオメガの両方が同じである場合。

1141
01:01:39,920 --> 01:01:41,520
[OK]をクリックします。

1142
01:01:41,520 --> 01:01:44,210
そして最後に、ログnはソートはマージ。

1143
01:01:44,210 --> 01:01:48,910
>> そして、ダンは、ソートマージ、言っていたように
種類と同じように似ている

1144
01:01:48,910 --> 01:01:50,320
あなたは、バイナリ検索を行う。

1145
01:01:50,320 --> 01:01:53,530
だから、リストを取得。

1146
01:01:53,530 --> 01:01:55,170
そして、あなたは半分にカットするつもりだ。

1147
01:01:55,170 --> 01:02:00,580
そして、あなたはそれらを切る
小さい半分に。

1148
01:02:00,580 --> 01:02:01,730
そして、あなたはそれらをマージ。

1149
01:02:01,730 --> 01:02:02,960
君たちは正しい、ことを覚えて？

1150
01:02:02,960 --> 01:02:04,960
[OK]を、彼は言っていたように。

1151
01:02:04,960 --> 01:02:08,330
>> [OK]を、ポインタ。

1152
01:02:08,330 --> 01:02:11,078
だからポインタとは何でしょうか？

1153
01:02:11,078 --> 01:02:12,050
>> 聴衆：[聞こえない]。

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS：アドレス。

1155
01:02:12,820 --> 01:02:13,720
[OK]をクリックします。

1156
01:02:13,720 --> 01:02:18,530
私はダビデはの束を示していることを知っている
binkyのビデオや物事のポインティング

1157
01:02:18,530 --> 01:02:19,080
お互い。

1158
01:02:19,080 --> 01:02:22,960
しかし、私はポインタと考えたい
単なるアドレスとして。

1159
01:02:22,960 --> 01:02:26,110
だから、起こっている変数だ
アドレスを格納する。

1160
01:02:26,110 --> 01:02:31,940
>> だから、ちょうどこの特別な変数です
それは4バイト長である。

1161
01:02:31,940 --> 01:02:36,550
何かへのポインタであることを、忘れないでください
当社の32ビットのための長い常に4バイト

1162
01:02:36,550 --> 01:02:39,370
マシンの場合とそう
アプライアンス。

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
そして、それはただの場所を持ってい
その中の変数の。

1165
01:02:47,050 --> 01:02:50,240
>> そう、このメモリは、基本的には、あります。

1166
01:02:50,240 --> 01:02:57,420
そのように、メモリの各ブロックは、実際にはA有する
のアドレスであるラベル、

1167
01:02:57,420 --> 01:02:58,890
slottyメモリ。

1168
01:02:58,890 --> 01:03:02,370
だから、私が持っていることを意味し
を指すポインタ

1169
01:03:02,370 --> 01:03:03,380
これらのアドレスのいずれか。

1170
01:03:03,380 --> 01:03:09,930
だから私たちは、ポインタを使用します理由は、
私は場所を覚えておく必要がある場合

1171
01:03:09,930 --> 01:03:12,300
特定の変数がメモリである。

1172
01:03:12,300 --> 01:03:16,560
>> そして、あなたたちは、これらのいずれかを覚えている
私は機能を持っている場合のケースがあった

1173
01:03:16,560 --> 01:03:20,820
私は実際にあなたがしたい場合
実数のためのスワップ、実際に私

1174
01:03:20,820 --> 01:03:22,110
ポインタを送信する必要があります。

1175
01:03:22,110 --> 01:03:23,460
変数ではない。

1176
01:03:23,460 --> 01:03:25,200
あなたたちはそれを覚えていますか？

1177
01:03:25,200 --> 01:03:26,450
違いbetween--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
名前は何ですか？

1180
01:03:34,120 --> 01:03:36,010
値による呼び出しと呼び出し
参照によって、右か？

1181
01:03:36,010 --> 01:03:36,840
>> うん、[OK]をクリックします。

1182
01:03:36,840 --> 01:03:38,330
だから値で呼び出します。

1183
01:03:38,330 --> 01:03:43,570
あなただけの変数を送信すると
あなただけの値を送信している機能。

1184
01:03:43,570 --> 01:03:45,610
だから、実際に送信している
変数のコピー。

1185
01:03:45,610 --> 01:03:49,720
そして、あなたのプログラムは、あまり気にしませんでした
実際に同じ変数であれば約

1186
01:03:49,720 --> 01:03:51,650
コピーが作成されます。

1187
01:03:51,650 --> 01:03:56,330
>> そして、参照があることを意味することによって呼び出す
私は実際のコピーを送信しています

1188
01:03:56,330 --> 01:03:57,550
その変数へのポインタ。

1189
01:03:57,550 --> 01:04:00,970
だから、私が送信していることを意味します
その変数の場所。

1190
01:04:00,970 --> 01:04:04,440
だから私はの場所を持って感じる
私は関数を呼び出す変数、

1191
01:04:04,440 --> 01:04:09,700
ポインタで、私は実際にことができるよ
主にあったデータを変更する。

1192
01:04:09,700 --> 01:04:12,050
意味が？

1193
01:04:12,050 --> 01:04:17,560
>> なお、ポインタは、コピーである
ポインタがまだの実アドレスを持ってい

1194
01:04:17,560 --> 01:04:20,090
私が変更したい変数。

1195
01:04:20,090 --> 01:04:21,920
意味が？

1196
01:04:21,920 --> 01:04:24,290
>> だから、ポインタを作成する。

1197
01:04:24,290 --> 01:04:28,410
覚えておいて、ポインタは常に持っている
それが指してタイプ

1198
01:04:28,410 --> 01:04:29,890
星にしてから。

1199
01:04:29,890 --> 01:04:31,030
そして、あなたが名前を置く。

1200
01:04:31,030 --> 01:04:35,765
だから、あなたが持っているときはいつでもあることを覚えている
どんなスター、それはへのポインタのようなものだ

1201
01:04:35,765 --> 01:04:38,990
そのどんな変数
あなたが持っていたタイプ。

1202
01:04:38,990 --> 01:04:42,850
>> だからここにスターでは、例えば、それはだ
ポインタと整数。

1203
01:04:42,850 --> 01:04:47,680
そして、char型星がポインタである
チャースターなど。

1204
01:04:47,680 --> 01:04:47,960
うん？

1205
01:04:47,960 --> 01:04:52,710
>> 聴衆：私たちが持っている場合
nは体へのポインタは、X星に。

1206
01:04:52,710 --> 01:04:55,255
私はそれをxへのポインタが作成されます知っている。

1207
01:04:55,255 --> 01:04:59,432
それはまた、整数xを宣言していますか？

1208
01:04:59,432 --> 01:05:05,170
>> ルーカス：そう、あなたはn個の星xを言う、
あなたはへのポインタを作成していない

1209
01:05:05,170 --> 01:05:06,000
変数x。

1210
01:05:06,000 --> 01:05:08,170
あなたは、Xという名前のポインタを作成している。

1211
01:05:08,170 --> 01:05:09,396
>> 聴衆：[聞こえない]。

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS：私はn個の星xを言うとき、私は私
ねえ、メモリ内に、私はするつもりだ、と言って

1213
01:05:14,250 --> 01:05:16,390
これらの3つのボックスのいずれかを取得します。

1214
01:05:16,390 --> 01:05:20,750
そして、私はそのことを言うつもりです
である、Xになるだろう

1215
01:05:20,750 --> 01:05:22,000
ポインタになるだろう。

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
ポインタについて興味深い何か
私たちは彼らが持っていると言うことです

1218
01:05:30,640 --> 01:05:32,620
32ビットマシン用の4バイト。

1219
01:05:32,620 --> 01:05:36,320
そしてその理由はからです
4バイトは32ビットです。

1220
01:05:36,320 --> 01:05:40,490
>> そして、実際に64ビットであるマシン
ポインタアドレスを持っている

1221
01:05:40,490 --> 01:05:43,480
64ビット長であることを。

1222
01:05:43,480 --> 01:05:49,820
だから、それだけで意味の大きさ
マシンのアドレスが異なっている。

1223
01:05:49,820 --> 01:05:52,270
>> だから、参照と間接参照。

1224
01:05:52,270 --> 01:05:54,310
その2つの演算子があります
あなたたちは忘れてはならない。

1225
01:05:54,310 --> 01:05:55,450
最初のアンパサンドです。

1226
01:05:55,450 --> 01:05:56,810
二つ目はスターです。

1227
01:05:56,810 --> 01:06:05,060
あの星とこのことで混乱しないでください
主演ために、次のことを覚えている

1228
01:06:05,060 --> 01:06:06,950
このような場合には、n個の星を持っている。

1229
01:06:06,950 --> 01:06:08,700
>> それは一緒にすべてのもののようだ。

1230
01:06:08,700 --> 01:06:10,720
ないn個のスペーススターはありません。

1231
01:06:10,720 --> 01:06:12,070
だから、それがタイプだということを意味します。

1232
01:06:12,070 --> 01:06:14,870
あなたが持っている時にあることを、忘れないでください
変光星、あなたがしている

1233
01:06:14,870 --> 01:06:16,230
タイプの話。

1234
01:06:16,230 --> 01:06:20,540
>> あなただけのスター、次にしたら
変数の名前は、それがあることを意味します

1235
01:06:20,540 --> 01:06:24,100
あなたは、ポインタを逆参照しただ
あなたが見ていることを意味します

1236
01:06:24,100 --> 01:06:28,290
ポインタは、アドレスを見つけることです
、そのアドレスに行く、を指す

1237
01:06:28,290 --> 01:06:30,850
そしていつでも見
あなたがそこに持っている。

1238
01:06:30,850 --> 01:06:34,310
だから私はあなたが持っている時というのが私の生徒たちに伝える
星が、あなたはそれがだと考える必要があります

1239
01:06:34,310 --> 01:06:36,850
の内容の省略形。

1240
01:06:36,850 --> 01:06:39,770
>> あなたは、ポインタを持っているなら、あなた
スターポインタの操作を行い、それがだ

1241
01:06:39,770 --> 01:06:41,720
ポインタの内容。

1242
01:06:41,720 --> 01:06:44,580
だから、それが指して何に行く
そして一定の内容を見てください。

1243
01:06:44,580 --> 01:06:47,730
そして、アンパサンドは同じです
のアドレスとしてのもの。

1244
01:06:47,730 --> 01:06:52,560
>> 私のようなA--変数を持っているのであれば、してみましょう
int型のaが等しい私がやったと言う3--

1245
01:06:52,560 --> 01:06:56,900
私はそれのアドレスを検索する場合
可変メモリ、私はちょうど行うことができます

1246
01:06:56,900 --> 01:06:58,240
アンパサンド。

1247
01:06:58,240 --> 01:07:00,280
だから、のアドレスです。

1248
01:07:00,280 --> 01:07:01,530
意味が？

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> そこでここでは例です。

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
これはint型bおよびint型Cが不足しています。

1253
01:07:11,530 --> 01:07:16,520
3手段に等しいint型だから
私はメモリに行くつもりです。

1254
01:07:16,520 --> 01:07:19,870
そして、私はスロットを見つけるつもりです
ここで数字の3を置く。

1255
01:07:19,870 --> 01:07:22,200
>> そして、整数、bは4に等しい。

1256
01:07:22,200 --> 01:07:23,100
私は同じことをするつもりです。

1257
01:07:23,100 --> 01:07:25,840
メモリに移動し、番号を入れる
ボックスのいずれかの4。

1258
01:07:25,840 --> 01:07:27,100
そして、INTは5に等しい。

1259
01:07:27,100 --> 01:07:29,740
別のボックスを見つけ、5番を置く。

1260
01:07:29,740 --> 01:07:36,160
>> だから、この行は何をしているのですか？
n個の星のPAはアンパサンドaを等しい。

1261
01:07:36,160 --> 01:07:37,800
だから、まず、n個スター年率。

1262
01:07:37,800 --> 01:07:39,050
それは何をしているのですか？

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> 聴衆：[聞こえない]。

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS：うん、そうnはスターのPA、まず、
PAと呼ばれるポインタを宣言します。

1266
01:07:47,890 --> 01:07:53,720
そして、それはの値を代入だ
のアドレスにするために、そのポインタ。

1267
01:07:53,720 --> 01:07:55,790
だから、アンパサンド。

1268
01:07:55,790 --> 01:07:58,510
それから、私がスターPBを行う場合、
スターPBは何ですか？

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> あ、ごめん。

1271
01:08:03,150 --> 01:08:06,330
これはまた、不足しています。 n個の星のPB。

1272
01:08:06,330 --> 01:08:07,905
私はスターのPCを意味する。

1273
01:08:07,905 --> 01:08:11,200
私は、とても残念です。

1274
01:08:11,200 --> 01:08:11,940
それは同じことだ。

1275
01:08:11,940 --> 01:08:16,408
しかし、今、私はポインタを作成するAR良いよ
bにし、Cへのポインタである。

1276
01:08:16,408 --> 01:08:16,886
うん？

1277
01:08:16,886 --> 01:08:18,136
>> 聴衆：[聞き取れない]？

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS：はい。

1280
01:08:26,670 --> 01:08:32,630
だから、メモリに移動し、あなたがに行けば
PAのために指示した箱、

1281
01:08:32,630 --> 01:08:37,149
あなたが実際に行っている
のアドレスを参照してください。

1282
01:08:37,149 --> 01:08:38,399
OK？

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
うん？

1285
01:08:43,300 --> 01:08:45,605
>> 聴衆：[聞き取れない]？

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS：ええ、ポイン​​タがアドレスです。

1287
01:08:49,260 --> 01:08:50,120
それを忘れないでください。

1288
01:08:50,120 --> 01:08:52,800
これは、最も重要なのようなものだ
ポインタについての部分。

1289
01:08:52,800 --> 01:08:56,180
保管およびアドレスあります
いくつかの変数へ。

1290
01:08:56,180 --> 01:08:56,890
何か他には？

1291
01:08:56,890 --> 01:08:58,370
他の質問は？

1292
01:08:58,370 --> 01:08:59,189
[OK]をクリックします。

1293
01:08:59,189 --> 01:09:00,399
>> だからポインタと配列。

1294
01:09:00,399 --> 01:09:08,189
覚えておいて、私はアレイ3をint型行うときに、
基本的に、私がやっていることは、私は親切である

1295
01:09:08,189 --> 01:09:12,779
の、ポインタで宣言。

1296
01:09:12,779 --> 01:09:18,960
だから、配列は種のへのポインタのようなものです
メモリ内の特定の場所のI

1297
01:09:18,960 --> 01:09:21,999
整数の3つのスロットに割り当てられた。

1298
01:09:21,999 --> 01:09:23,430
それは理にかなっていますか？

1299
01:09:23,430 --> 01:09:30,250
>> 私はint配列3を実行したとき、私は何だ
基本的には、3を作成して、やって

1300
01:09:30,250 --> 01:09:31,479
メモリのスロット。

1301
01:09:31,479 --> 01:09:33,899
だから、僕は、メモリ内の3つのスロットを見つける。

1302
01:09:33,899 --> 01:09:38,810
だから私は、その後、スター·アレイ、それを行う場合は、
基本的に、アレイの内容を意味し、

1303
01:09:38,810 --> 01:09:46,180
私はポインタを消去することを意味し、私は行く
それが指してその場所に、

1304
01:09:46,180 --> 01:09:47,939
と私はナンバーワンを置く。

1305
01:09:47,939 --> 01:09:53,729
>> そして、私は星の配列プラス1をすれば、
それは、配列をやって同じことだ

1306
01:09:53,729 --> 01:09:59,690
ちょうど私が行くことを意味カッコ1、
それが指し示す場所だ。

1307
01:09:59,690 --> 01:10:03,000
そして、プラス1になる
私は一つの位置をずらす。

1308
01:10:03,000 --> 01:10:06,510
だから私は、実際には、この位置に移動します
と数2を置く。

1309
01:10:06,510 --> 01:10:10,900
>> そして、最終的には、ときに私が行う
配列プラス2、私はどこへ行く

1310
01:10:10,900 --> 01:10:11,825
での配列のポインティング。

1311
01:10:11,825 --> 01:10:14,690
そして私は、メモリブロックに移動します。

1312
01:10:14,690 --> 01:10:16,240
そして私はここに3番を置く。

1313
01:10:16,240 --> 01:10:16,600
うん？

1314
01:10:16,600 --> 01:10:21,400
>> 聴衆：だからスターアレイが単に
非常に最初のポイントを言って。

1315
01:10:21,400 --> 01:10:25,090
そして、あなたは理由だけで、1を追加することができます
私たちは、本当にしている

1316
01:10:25,090 --> 01:10:27,295
その最初のアドレスを参照している。

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS：うん。

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
なぜ、例えば、配列を言うのですか
0、アレイ1およびアレイ2？

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
私は、なぜあなたは0をしますか、言っている
1、2、3の代わりに1、2、3？

1322
01:10:42,790 --> 01:10:46,550
理由の一つは、一つのコンピュータである
プログラマが開始することを好む

1323
01:10:46,550 --> 01:10:47,750
0からカウント。

1324
01:10:47,750 --> 01:10:52,370
あなたは、アレイ0をするときので、二つはある、
それは、配列をやって同じことだ

1325
01:10:52,370 --> 01:10:56,330
私はに行く意味プラス0、
その位置、と私はしないでください

1326
01:10:56,330 --> 01:10:59,320
任意のメモリ·ブロックをスキップします。

1327
01:10:59,320 --> 01:11:01,750
だから私は、任意のメモリブロックを移動しないでください。

1328
01:11:01,750 --> 01:11:02,015
うん？

1329
01:11:02,015 --> 01:11:03,265
>> 聴衆：[聞き取れない]？

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS：だから彼女は何であるか尋ねるだ
何の違い

1332
01:11:12,670 --> 01:11:14,000
これかのmallocをやって。

1333
01:11:14,000 --> 01:11:17,550
違いの一つは、ということです
int配列3が作成される

1334
01:11:17,550 --> 01:11:19,260
スタック上の配列。

1335
01:11:19,260 --> 01:11:23,080
そして、私は、それをmalloc関数をするとき
ヒープ上に作成します。

1336
01:11:23,080 --> 01:11:25,250
それは理にかなっていますか？

1337
01:11:25,250 --> 01:11:28,870
>> それでは、どのようmalloc関数は、実際に動作しますか？

1338
01:11:28,870 --> 01:11:32,245
では、なぜ私たちも、malloc関数を使用する必要があるのですか？

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
アウトすべての図のあなたのコンパイラの種類
あなたが宣言された変数。

1341
01:11:39,700 --> 01:11:44,040
そして、彼はすべてのためのスペースを作成します。
それらのスタック内。

1342
01:11:44,040 --> 01:11:47,180
だからあなたのすべての変数をしようとしている
どこかにスタックにするために。

1343
01:11:47,180 --> 01:11:49,460
だからここの環境変数です。

1344
01:11:49,460 --> 01:11:53,850
>> これらの変数については、これは基本的に、スペース
メモリ内で割り当てられている

1345
01:11:53,850 --> 01:11:55,080
コンパイル時間を。

1346
01:11:55,080 --> 01:11:58,790
だから、コンピュータに搭載されていることを意味します
これらの変数のすべてを知っている

1347
01:11:58,790 --> 01:11:59,790
事前に。

1348
01:11:59,790 --> 01:12:02,500
それはどのような値を知る必要はありません
あなたはそれらに置くつもりだ。

1349
01:12:02,500 --> 01:12:05,490
しかし、それはどのように知っている必要があります
あなたが必要とするメモリ量。

1350
01:12:05,490 --> 01:12:09,380
>> しかし、今のは、たとえば、以下のことを言わせて、
あなたは、配列を作成したり、取っている

1351
01:12:09,380 --> 01:12:13,430
あなたが取っている文字列
ユーザから。

1352
01:12:13,430 --> 01:12:17,300
あなたはどのように長い文字列がわからない
例えば、あることを行っている。

1353
01:12:17,300 --> 01:12:20,600
だから、正確にどのように多くを知らない
あなたが割り当てるメモリ·ブロック、右？

1354
01:12:20,600 --> 01:12:24,120
>> だから、本当にためには意味がありません
あなたは100文字を入れて言って。

1355
01:12:24,120 --> 01:12:26,420
そして、ユーザが150を書き込む場合はどう？

1356
01:12:26,420 --> 01:12:27,670
あなたがねじ込まれるようになるだろう。

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> そこで、基本的に、あなたはどのように確認することはできません
あなたが割り当てる必要がメモリの量

1359
01:12:34,620 --> 01:12:35,960
あなたがプログラムをコンパイルするとき。

1360
01:12:35,960 --> 01:12:38,240
あなただけの実行時にそれを知っている。

1361
01:12:38,240 --> 01:12:39,950
あなたはヒープを持っている理由だからです。

1362
01:12:39,950 --> 01:12:47,610
だから、ヒープメモリを持っているとしている
あなたが中に割り当てていること

1363
01:12:47,610 --> 01:12:50,810
プログラム実行中の期間。

1364
01:12:50,810 --> 01:12:55,780
>> したがって、基本的に、あなたはmalloc関数を実行したときに、どのような
あなたがメモリを割り当ててやっている

1365
01:12:55,780 --> 01:13:00,160
あなたがしていることを意味し、実行時、
あなたその瞬間に右の決定

1366
01:13:00,160 --> 01:13:02,670
そのメモリを持つ必要があります。

1367
01:13:02,670 --> 01:13:04,210
あなたがそれを割り当てるしているときだからです。

1368
01:13:04,210 --> 01:13:06,430
それは理にかなっていますか？

1369
01:13:06,430 --> 01:13:11,690
>> だからスタックは変数があり、覚えている
それは、コンパイル時に作成されます。

1370
01:13:11,690 --> 01:13:14,560
そして、ヒープは変数がある
あなたが行くように作成される

1371
01:13:14,560 --> 01:13:15,600
mallocで、例えば。

1372
01:13:15,600 --> 01:13:16,850
>> 聴衆：[聞き取れない]？

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS：だからのGetStringです
malloc関数を呼び出すつもり。

1375
01:13:24,340 --> 01:13:26,710
私はmalloc関数についてお話しましょう​​、と
私はのGetStringを説明します。

1376
01:13:26,710 --> 01:13:32,000
だから、malloc関数は同じことです。
メモリ割り当てなど。

1377
01:13:32,000 --> 01:13:34,600
だから、割り当てることが起こっている
ヒープ上のメモリ。

1378
01:13:34,600 --> 01:13:40,010
そして、それはへのポインタを返すために起こっている
ここで、そのメモリがで配分された。

1379
01:13:40,010 --> 01:13:43,090
>> だから、do--とき

1380
01:13:43,090 --> 01:13:44,910
ここexample--用

1381
01:13:44,910 --> 01:13:45,830
n個の星のポインタ。

1382
01:13:45,830 --> 01:13:50,520
そして、ポインタはmalloc関数に等しい
インチの10倍の大きさ。

1383
01:13:50,520 --> 01:13:52,110
私はポインタを作成しています。

1384
01:13:52,110 --> 01:13:59,020
そして私はへのポインタを代入してい
ポインタのmallocの値

1385
01:13:59,020 --> 01:13:59,680
私を与えている。

1386
01:13:59,680 --> 01:14:04,150
>> あなたが割り当てることができるので、私はmalloc関数を求めている
10個の整数のためのスペース。

1387
01:14:04,150 --> 01:14:05,390
つまり、言っているんだ。

1388
01:14:05,390 --> 01:14:09,020
そして、malloc関数は私に戻っています
その場所へのポインタ。

1389
01:14:09,020 --> 01:14:11,460
意味が？

1390
01:14:11,460 --> 01:14:12,270
[OK]をクリックします。

1391
01:14:12,270 --> 01:14:17,940
私とのGetStringは、基本的には、やっている
あなたが割り当てることができるので、malloc関数を呼び出す

1392
01:14:17,940 --> 01:14:21,680
実行時のメモリ。

1393
01:14:21,680 --> 01:14:26,460
>> 常にNULLかどうかを確認することを忘れないでください
malloc関数は、NULLを返すために起こっているので、

1394
01:14:26,460 --> 01:14:28,200
それはメモリを割り当てることができない場合。

1395
01:14:28,200 --> 01:14:31,660
例えば、あなたが、ばかげを求めることとしましょう
メモリの量。

1396
01:14:31,660 --> 01:14:33,950
お使いのコンピュータにはあることを行っていません
それだけ割り当てることができ。

1397
01:14:33,950 --> 01:14:36,410
>> だから、malloc関数はただ起こっている
nullを返します。

1398
01:14:36,410 --> 01:14:42,210
だから、常にかどうかを確認することを忘れないでください
あなたはmalloc関数から得たポインタである

1399
01:14:42,210 --> 01:14:45,640
ヌルかどうかがあれば、あなたがかもしれない、なぜなら
ポインタを逆参照すると、

1400
01:14:45,640 --> 01:14:48,340
サイドの障害を引き起こす。

1401
01:14:48,340 --> 01:14:50,930
そして最後に、忘れてはいけない
あなたの空きメモリ。

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> malloc関数は、ヒープでメモリを作成しています。

1404
01:15:00,560 --> 01:15:03,436
そして、あなたはメモリを解放する必要があります
プログラムが終了する前に。

1405
01:15:03,436 --> 01:15:05,370
[OK]を、それは私のためにすべてです。

1406
01:15:05,370 --> 01:15:07,900
申し訳ありませんが、ロブ。

1407
01:15:07,900 --> 01:15:07,950
ありがとうございます。

1408
01:15:07,950 --> 01:15:09,878
>> [拍手]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS：任意の最後の質問
ロブが来る前に？

1410
01:15:12,679 --> 01:15:13,138
いいえ？

1411
01:15:13,138 --> 01:15:13,597
うん？

1412
01:15:13,597 --> 01:15:15,892
>> 聴衆：私は見ていない
この1オンライン。

1413
01:15:15,892 --> 01:15:17,269
あなたはまだそれをアップロードしたことがありますか？

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS：私はデイブだと思う
すぐにそれをアップロードする。

1415
01:15:19,106 --> 01:15:19,880
>> DAVE：それは掲示されます。

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS：それはオンラインである必要があります。

1417
01:15:20,310 --> 01:15:21,175
>> 聴衆：それは最高です。

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS：それは最高ですか？

1419
01:15:22,090 --> 01:15:23,157
[OK]をクリックします。

1420
01:15:23,157 --> 01:15:23,644
うん？

1421
01:15:23,644 --> 01:15:27,053
>> 聴衆：[聞き取れない]？

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS：はい、あなたはすべて解放する必要があります
ヒープに置かれるメモリ。

1423
01:15:30,285 --> 01:15:31,535
>> 聴衆：[聞き取れない]？

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS：はい。

1426
01:15:36,160 --> 01:15:39,980
あなたは文化のmallocを持っているときはいつでも、
あなたは無料の文化を持っている必要があります

1427
01:15:39,980 --> 01:15:42,640
あなたはその変数の使用を停止した後。

1428
01:15:42,640 --> 01:15:44,800
だから、mallocとfreeである
いつも一緒。

1429
01:15:44,800 --> 01:15:45,410
彼らの親友。

1430
01:15:45,410 --> 01:15:46,720
うん。

1431
01:15:46,720 --> 01:15:47,970
ロブ？

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ROB：私はすぐに行くよ。

1434
01:15:56,850 --> 01:16:00,466
そして、またビデオがお付けします。

1435
01:16:00,466 --> 01:16:01,716
私は上のマイクを持っている。

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> そう、週5のもの。

1438
01:16:26,230 --> 01:16:27,970
私たちが持っているまず最初にスタックです。

1439
01:16:27,970 --> 01:16:33,390
だから、唯一つのスタックがあることを覚えている
アクティブな関数呼び出しごとのフレーム。

1440
01:16:33,390 --> 01:16:34,710
私たちは、第二にそれを表示されます。

1441
01:16:34,710 --> 01:16:37,850
そして、実際に何が起こって覚えている
各スタックフレームであることを行っている

1442
01:16:37,850 --> 01:16:41,880
私たちの関数のローカル変数、
私たちに渡される引数

1443
01:16:41,880 --> 01:16:43,880
カップルと一緒に機能し、
あなたが本当にしない他の事

1444
01:16:43,880 --> 01:16:45,260
心配する必要があります。

1445
01:16:45,260 --> 01:16:50,950
>> そこでここではプログラム例はどこだ、
通知は、メインは、リターンをprintfingさ

1446
01:16:50,950 --> 01:16:52,830
fooの値4。

1447
01:16:52,830 --> 01:16:57,930
fooはただ返すように起こっている
バー4コンマ6の値。

1448
01:16:57,930 --> 01:17:02,380
そして、バーには、いくつかのローカルに設定しようとしている
4〜6倍に等しい変数n。

1449
01:17:02,380 --> 01:17:03,920
そしてnは返す。

1450
01:17:03,920 --> 01:17:09,130
>> それでは、全体のスタックを見てみましょう
このプログラムの実際の繰り返し。

1451
01:17:09,130 --> 01:17:10,500
だから私たちのスタックの底があります。

1452
01:17:10,500 --> 01:17:12,620
スタックが育つことを覚えておいてください。

1453
01:17:12,620 --> 01:17:15,370
私たちは、私たちのスタックの一番下にあるので、
メイン用のスタックフレームを持っている。

1454
01:17:15,370 --> 01:17:17,000
ときにプログラムが起動し、メイン
常にであることを行っている

1455
01:17:17,000 --> 01:17:18,560
私たちのスタックの最下部。

1456
01:17:18,560 --> 01:17:20,880
>> そして、私たちの内側に何か
メイン用のフレームをスタック？

1457
01:17:20,880 --> 01:17:23,810
だからローカル存在しないにもかかわらず、
主に、変数、私が前に言ったように、

1458
01:17:23,810 --> 01:17:29,670
私たちはargcとRGVはスペースを取ってきた
メインスタックフレームの内側。

1459
01:17:29,670 --> 01:17:33,260
今しようとしているので、メイン
関数fooを呼び出す。

1460
01:17:33,260 --> 01:17:35,125
そして、それはfooがしようとしていることを意味
独自のスタックフレームを取得します。

1461
01:17:35,125 --> 01:17:36,970
>> だから今、私たちはの中にいる
関数foo。

1462
01:17:36,970 --> 01:17:38,610
そして、何が中に行く必要がある
、fooのスタックフレーム？

1463
01:17:38,610 --> 01:17:41,100
さて、fooは引数nを持っています。

1464
01:17:41,100 --> 01:17:45,440
それはだから、nは4に等しく、何
メインは、fooの引数として渡している。

1465
01:17:45,440 --> 01:17:48,490
>> だから今fooはバーを呼び出すために起こっている。

1466
01:17:48,490 --> 01:17:52,070
どのようなバーが内部に持っているとしている
その「スタック·フレームの？

1467
01:17:52,070 --> 01:17:55,610
これは、6に等しい4 yに等しいのxを持っています。

1468
01:17:55,610 --> 01:17:58,540
それは私達が必要があるとしていることがすべてではない
バーのためのスタック·フレーム内

1469
01:17:58,540 --> 01:18:00,580
また、ローカル変数nを有する。

1470
01:18:00,580 --> 01:18:03,370
そして、nは、私たちは24に等しくなるように設定しようとしている。

1471
01:18:03,370 --> 01:18:05,750
>> だから今のバーは、nを返すために起こっている。

1472
01:18:05,750 --> 01:18:09,300
だから、バーは24を返している
スタックフレームのfoo。

1473
01:18:09,300 --> 01:18:12,560
そしてバーがあることを、戻っているので、
私たちはスタックフレームをポップしていることを意味

1474
01:18:12,560 --> 01:18:14,250
スタックのオフバーのため。

1475
01:18:14,250 --> 01:18:18,430
バーがあったので、すべてのメモリ
使用すると、スタックからになりました。

1476
01:18:18,430 --> 01:18:21,550
>> さて、fooはまた起こっている
主に24を返します。

1477
01:18:21,550 --> 01:18:25,470
だから今それfooは、メモリを返す
そのfooはその 'で使用していた

1478
01:18:25,470 --> 01:18:27,550
スタックフレームもなくなる。

1479
01:18:27,550 --> 01:18:29,660
そして今、主はprintfのを呼び出すことが起こっている。

1480
01:18:29,660 --> 01:18:31,660
だから、printfのはちょうど別の関数である。

1481
01:18:31,660 --> 01:18:35,320
私たちはprintfのを呼び出すと、それはなるだろう
printfのための別のスタックフレーム

1482
01:18:35,320 --> 01:18:36,470
関数呼び出し。

1483
01:18:36,470 --> 01:18:37,990
>> 私たちは、printfのを渡している？

1484
01:18:37,990 --> 01:18:40,090
それは行くために起こっているものだ
そのスタックフレーム上。

1485
01:18:40,090 --> 01:18:44,970
少なくとも、私たちは渡している
そのパーセントはiがnバックスラッシュと

1486
01:18:44,970 --> 01:18:47,180
引数24。

1487
01:18:47,180 --> 01:18:50,370
それはスタックフレームの中でそれは多くを持っているかもしれません
printfのは、いくつかを使用しているように発生した場合

1488
01:18:50,370 --> 01:18:51,200
ローカル変数。

1489
01:18:51,200 --> 01:18:51,920
私たちは知りません。

1490
01:18:51,920 --> 01:18:53,810
>> しかし、すべてのことは、printfの年代に行く
フレームを積み重ねる。

1491
01:18:53,810 --> 01:18:55,740
これはprintfのを実行するために起こっている。

1492
01:18:55,740 --> 01:18:56,830
その後のprintfを行っています。

1493
01:18:56,830 --> 01:18:57,820
それは戻ります。

1494
01:18:57,820 --> 01:18:58,960
最後に、主に行われる。

1495
01:18:58,960 --> 01:18:59,860
メインに戻ります。

1496
01:18:59,860 --> 01:19:02,020
そして、私たちのプログラムが実行されます。

1497
01:19:02,020 --> 01:19:02,480
うん？

1498
01:19:02,480 --> 01:19:04,505
>> 観客は：あなたが見ている[聞き取れない]

1499
01:19:04,505 --> 01:19:05,900
引数[聞き取れない]

1500
01:19:05,900 --> 01:19:06,830
パラメータ？

1501
01:19:06,830 --> 01:19:09,970
>> ROB：だから微妙な差がある
引数とパラメータの間。

1502
01:19:09,970 --> 01:19:14,400
そして実際に、一般的な用語では、人々は傾向がある
ちょうどすべての時間をそれらを混合する。

1503
01:19:14,400 --> 01:19:17,550
しかし、パラメータが正式です
物事の名前。

1504
01:19:17,550 --> 01:19:20,180
>> だから、argcとargvはある
主へのパラメータ。

1505
01:19:20,180 --> 01:19:23,440
引数は何をあなたが実際に
それらのパラメータとして渡します。

1506
01:19:23,440 --> 01:19:28,340
だから、私は4のfooのを呼び出すと、4
私は渡している引数です。

1507
01:19:28,340 --> 01:19:31,460
および内部パラメータn、
fooは、値をとる4

1508
01:19:31,460 --> 01:19:32,880
4以来の引数だった。

1509
01:19:32,880 --> 01:19:35,826
>> 聴衆：[聞き取れない]？

1510
01:19:35,826 --> 01:19:37,880
>> ROB：nは棒にローカル変数です。

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
nはまだfooへのローカルであるが、
それはfooへのパラメータです。

1513
01:19:44,960 --> 01:19:48,190
これは、ローカル変数ではありません。

1514
01:19:48,190 --> 01:19:48,546
うん？

1515
01:19:48,546 --> 01:19:51,180
>> 聴衆：[聞き取れない]？

1516
01:19:51,180 --> 01:19:55,400
>> ROB：fooはクロスバーを呼び出していると
どんなバーリターンを返す。

1517
01:19:55,400 --> 01:19:56,786
>> 聴衆：[聞き取れない]？

1518
01:19:56,786 --> 01:19:59,591
>> ROB：ええ、ちょうど複数参照するには
スタックフレーム。

1519
01:19:59,591 --> 01:20:00,082
うん？

1520
01:20:00,082 --> 01:20:03,519
>> 聴衆：なぜfooが呼ばれていた
printfの前に？

1521
01:20:03,519 --> 01:20:05,920
>> ROB：なぜfooがprintfの前に呼び出されたのですか？

1522
01:20:05,920 --> 01:20:10,740
だから私は、その代わりに、何かを行っている可能性が
int型のように×4のfooのに等しい

1523
01:20:10,740 --> 01:20:12,980
させ、xをプリント。

1524
01:20:12,980 --> 01:20:17,900
しかし、その代わりに、私は関数を組み合わせた
printfの引数を呼び出す。

1525
01:20:17,900 --> 01:20:23,670
>> しかし、私たちがいない、実際にできることに注意して
私たちまで、printfのための呼び出しを実行する

1526
01:20:23,670 --> 01:20:25,610
4のfooが何であるかを把握。

1527
01:20:25,610 --> 01:20:27,480
そこで、これを評価するつもりだ。

1528
01:20:27,480 --> 01:20:32,504
そして、一度だけそのに行うの予定です
戻ってきて、これを評価した。

1529
01:20:32,504 --> 01:20:32,990
うん？

1530
01:20:32,990 --> 01:20:37,364
>> 聴衆：両方のバー以来[聞き取れない]

1531
01:20:37,364 --> 01:20:41,738
値は、なぜ[聞こえない]持っていないのですか？

1532
01:20:41,738 --> 01:20:44,400
>> ROB：彼らは完全にint型でなければなりません。

1533
01:20:44,400 --> 01:20:46,260
つまり、上の捕捉されなかった
複数のパス。

1534
01:20:46,260 --> 01:20:49,010
だから、int型のバーとint型でなければなりません
これらの両方のため、fooの

1535
01:20:49,010 --> 01:20:50,460
整数を返している。

1536
01:20:50,460 --> 01:20:54,214
ボイドは、彼らがつもりはない場合にのみです。
実際の値を返すようにします。

1537
01:20:54,214 --> 01:20:54,692
うん？

1538
01:20:54,692 --> 01:20:58,038
>> 聴衆：あなたは上記の行を持っていた場合
戻り、[聞こえない]？

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB：戻り上記の行？

1541
01:21:03,730 --> 01:21:04,410
>> 聴衆：うん。

1542
01:21:04,410 --> 01:21:10,780
同様にあなたはprintfや[聞こえない]が行った場合、
それは二度印刷さでしょうか？

1543
01:21:10,780 --> 01:21:12,992
>> ROB：だからfooの内部？

1544
01:21:12,992 --> 01:21:15,945
私たちはここのprintfを持っていた場合？

1545
01:21:15,945 --> 01:21:16,750
>> 聴衆：うん。

1546
01:21:16,750 --> 01:21:19,510
>> ROB：だから私たちはprintfの権利を持っていた場合
ここで、一度印刷しました。

1547
01:21:19,510 --> 01:21:23,400
私たちは一度、右のfooを呼び出しているので
ここでは、私たちはprintfのヒットだろう。

1548
01:21:23,400 --> 01:21:24,620
それから、バーと呼ぶことにします。

1549
01:21:24,620 --> 01:21:25,710
そして、fooが返されます。

1550
01:21:25,710 --> 01:21:26,275
そして、それはそれだ。

1551
01:21:26,275 --> 01:21:30,985
私たちは、今までに遭遇
一回のprintf。

1552
01:21:30,985 --> 01:21:31,482
うん？

1553
01:21:31,482 --> 01:21:32,973
>> 聴衆：[聞き取れない]

1554
01:21:32,973 --> 01:21:37,950
私たちが最初だからのfooを呼び出すのprintf
のprintfを呼び出した後、私たちは渡している

1555
01:21:37,950 --> 01:21:38,580
引数。

1556
01:21:38,580 --> 01:21:40,960
>> ROB：だから理論的には、ありません
printfのはfooを呼ぶ？

1557
01:21:40,960 --> 01:21:42,220
だから無い。

1558
01:21:42,220 --> 01:21:47,360
cがしようとしていることだけでオーダー
私たちができる前に、これらのことを実行している

1559
01:21:47,360 --> 01:21:49,800
、すべての引数を関数を呼び出す
関数にする必要が

1560
01:21:49,800 --> 01:21:51,600
完全に評価される。

1561
01:21:51,600 --> 01:21:53,540
だから、これは完全に評価されている？

1562
01:21:53,540 --> 01:21:54,610
はい、それは単なる文字列です。

1563
01:21:54,610 --> 01:21:55,480
それはちょうど値です。

1564
01:21:55,480 --> 01:21:57,200
>> その後、私たちは完全に持っている
これを評価。

1565
01:21:57,200 --> 01:21:59,720
これが完了すると、今、すべての
その引数を評価する。

1566
01:21:59,720 --> 01:22:01,982
そして今、私たちはすることができます
printfのために呼び出す。

1567
01:22:01,982 --> 01:22:02,478
うん？

1568
01:22:02,478 --> 01:22:03,966
>> 聴衆：一つの疑問。

1569
01:22:03,966 --> 01:22:06,942
あなたはvoid関数を使用している場合は、必要があります
あなたがリターンセミコロンがありますか？

1570
01:22:06,942 --> 01:22:09,910
>> ROB：あなたは、戻りセミコロンない
あなたはvoid関数を持っている場合。

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
[OK]をクリックします。

1573
01:22:14,780 --> 01:22:15,830
だから今、いくつかのヒープのもの。

1574
01:22:15,830 --> 01:22:19,640
だから、ヒープは、私たちが対処しようとしている方法です
動的メモリ管理を備えた。

1575
01:22:19,640 --> 01:22:23,100
そして、これは、直接とは対照的である
私たちは、自動呼び出しますスタック

1576
01:22:23,100 --> 01:22:24,100
メモリ管理。

1577
01:22:24,100 --> 01:22:27,140
>> だからスタックに、あなたが本当に必要はありません
どのようにローカル変数に対処する

1578
01:22:27,140 --> 01:22:30,400
プッシュされ、すべてのポップされています
これらのスタックフレームとすべてのもの。

1579
01:22:30,400 --> 01:22:31,070
あなたはそれを心配する必要はありません。

1580
01:22:31,070 --> 01:22:32,070
それは自動です。

1581
01:22:32,070 --> 01:22:36,990
だから、ヒープは手動です。

1582
01:22:36,990 --> 01:22:38,070
そして、[聞き取れない]

1583
01:22:38,070 --> 01:22:41,260
これらの機能から来る
mallocとfree。

1584
01:22:41,260 --> 01:22:43,550
>> だからここに別のプログラムです。

1585
01:22:43,550 --> 01:22:47,145
私たちがやっているすべてはmallocingです
整数。

1586
01:22:47,145 --> 01:22:49,360
私たちは、スターxにそれを保存している。

1587
01:22:49,360 --> 01:22:52,520
もちろん、チェックする必要が
xがnullかどうかを確認します。

1588
01:22:52,520 --> 01:22:56,400
その後、私たちは何を設定しようとしている
xが50を指している。

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
、を指しているもののxを印刷
印刷のx、その後、無料のx。

1591
01:23:03,260 --> 01:23:08,920
>> それでは、どのこれは実際に見に行くされている
私たちは、スタックとヒープを見れば？

1592
01:23:08,920 --> 01:23:10,950
だから私たちは再び始めます。

1593
01:23:10,950 --> 01:23:12,580
前と同じように私たちのスタックの最下部。

1594
01:23:12,580 --> 01:23:15,930
あなたが直接ヒープことを忘れないでください
スタックに対抗？

1595
01:23:15,930 --> 01:23:18,850
だから私たちは持っているつもり
そこまで私たちのヒープの最上部。

1596
01:23:18,850 --> 01:23:22,590
>> 私たちのスタックの最下部だから、私たちは持っている
主のための私達のスタックフレーム。

1597
01:23:22,590 --> 01:23:28,000
それは、argcは、argvのためのスペースを持っており、私たち
今ローカル変数xを、持っている

1598
01:23:28,000 --> 01:23:30,030
int型の星である。

1599
01:23:30,030 --> 01:23:32,240
だから私たちは反復処理するつもりだ
このプログラムを通して。

1600
01:23:32,240 --> 01:23:34,420
私たちが持っている最初のものです
malloc関数の呼び出し。

1601
01:23:34,420 --> 01:23:36,250
>> だから私たちはmalloc関数への呼び出しを作っている。

1602
01:23:36,250 --> 01:23:37,100
malloc関数は、関数です。

1603
01:23:37,100 --> 01:23:38,770
これは、スタックフレームを取得するつもりだ。

1604
01:23:38,770 --> 01:23:40,180
私たちははmalloc渡している？

1605
01:23:40,180 --> 01:23:41,610
つまり、中に入るために起こっている
スタックフレームの。

1606
01:23:41,610 --> 01:23:45,130
私たちは、4はnのサイズを渡している。

1607
01:23:45,130 --> 01:23:49,700
だからは、malloc関数に渡されます。

1608
01:23:49,700 --> 01:23:50,910
>> malloc関数は何をしますか？

1609
01:23:50,910 --> 01:23:53,820
それは私達にヒープ上にいくつかの領域をつかむ。

1610
01:23:53,820 --> 01:23:55,320
だから私たちは、ヒープに行くつもりです。

1611
01:23:55,320 --> 01:23:57,990
そして、私たちはつかむつもりだ
ヒープから4バイト。

1612
01:23:57,990 --> 01:24:01,500
それでは、まさにそれを与えてみましょう
任意のアドレス。

1613
01:24:01,500 --> 01:24:06,680
0x123ジャストつまりふり
ヒープ上のアドレス。

1614
01:24:06,680 --> 01:24:12,300
>> それでは、その内部に実際にある
アドレスOx123でのメモリ領域？

1615
01:24:12,300 --> 01:24:13,080
ごみ。

1616
01:24:13,080 --> 01:24:15,270
だから私たちはそれには何も保存されていません。

1617
01:24:15,270 --> 01:24:18,830
だから限り私たちは、それを知っているように
何でもかまいません。

1618
01:24:18,830 --> 01:24:20,560
あなたはそれがゼロだと仮定してはいけません。

1619
01:24:20,560 --> 01:24:23,870
それは最も可能性の高いゼロではありません。

1620
01:24:23,870 --> 01:24:26,260
>> だから今のmalloc戻ります。

1621
01:24:26,260 --> 01:24:28,020
そして、私たちはときにmallocが返す何をしますか？

1622
01:24:28,020 --> 01:24:29,800
私たちはそれが何を返すか設定します。

1623
01:24:29,800 --> 01:24:32,290
私たちは何に等しいのxを設定
それが戻っている。

1624
01:24:32,290 --> 01:24:33,690
だから、何を返している？

1625
01:24:33,690 --> 01:24:38,150
それがあるので、それは、0x123を返しています
メモリのブロックのアドレスもその

1626
01:24:38,150 --> 01:24:40,850
ただ、ヒープに確保。

1627
01:24:40,850 --> 01:24:47,160
>> だから、0x123 xは、今設定しようとしている返す
絵でおり、0x123に等しい、

1628
01:24:47,160 --> 01:24:52,940
私たちはしばしば、実際のXとして描く
そのブロックを指す矢印。

1629
01:24:52,940 --> 01:24:55,820
しかし、xはまさにそのアドレスを記憶している。

1630
01:24:55,820 --> 01:24:58,670
だから今、私たちは、xがnullであるかどうかを確認する必要があります。

1631
01:24:58,670 --> 01:24:59,120
それはヌルではありません。

1632
01:24:59,120 --> 01:25:02,170
私たちは、malloc関数が成功したことをふりをする。

1633
01:25:02,170 --> 01:25:04,950
>> だから今スターのxは50に等しい。

1634
01:25:04,950 --> 01:25:08,450
だから星はその意味を覚えて
そのアドレスにアクセスしてください。

1635
01:25:08,450 --> 01:25:12,700
だから、0x123私たちはするつもりだ
そのアドレスにアクセスしてください。

1636
01:25:12,700 --> 01:25:14,660
だから、そこに私たちをもたらします。

1637
01:25:14,660 --> 01:25:16,310
私たちはそのアドレスで何をしているのか？

1638
01:25:16,310 --> 01:25:19,020
私たちは50を保存している。

1639
01:25:19,020 --> 01:25:22,500
>> したがって、この行の後に、それは何ですか
物事が見えるようにしようとしている。

1640
01:25:22,500 --> 01:25:24,640
だから今それはもはやません
そこにごみアップ。

1641
01:25:24,640 --> 01:25:28,910
今、私たちは50点であることを知っている
なぜなら、特定のアドレス

1642
01:25:28,910 --> 01:25:32,410
私たちはそれに設定してください。

1643
01:25:32,410 --> 01:25:32,790
OK？

1644
01:25:32,790 --> 01:25:34,370
だから今、私たちはFを印刷しようとしている。

1645
01:25:34,370 --> 01:25:38,490
>> したがって、最初の私たちはスターxを印刷しようとしている。

1646
01:25:38,490 --> 01:25:39,640
だからスターxは何ですか？

1647
01:25:39,640 --> 01:25:44,300
この場合も、スターのxがに行くことを意味
xはを指していることだ。

1648
01:25:44,300 --> 01:25:47,140
だから、xはそれに0x123囲碁を記憶している。

1649
01:25:47,140 --> 01:25:48,490
私たちは、50を得る。

1650
01:25:48,490 --> 01:25:50,540
だからfを印刷します。

1651
01:25:50,540 --> 01:25:54,900
そして、それは、それが50を印刷するために起こっていることを意味します。

1652
01:25:54,900 --> 01:25:56,850
そして、それが返されます。

1653
01:25:56,850 --> 01:25:58,340
>> そして、私たちは第二のprintfを持っている。

1654
01:25:58,340 --> 01:25:59,370
現在パーセントpをしている。

1655
01:25:59,370 --> 01:26:01,680
あなたはそれを見ていないなら、それはだ
ちょうどあなたは、ポインタを印刷する方法。

1656
01:26:01,680 --> 01:26:04,960
だから私たちは、パーセント％の私を持っている
f及び既にそれらのすべて。

1657
01:26:04,960 --> 01:26:07,160
だからパーセントpは、ポインタを印刷します。

1658
01:26:07,160 --> 01:26:08,920
>> だから、xがポインタである。

1659
01:26:08,920 --> 01:26:13,440
だから私たちはx自身で印刷しようとしている場合には、
私たちは内部実際に何であるかプリントする

1660
01:26:13,440 --> 01:26:19,220
したがって、最初の0x123はx、
印刷fは50を印刷しようとしている。

1661
01:26:19,220 --> 01:26:23,620
第2の印刷fが起こっている
うん0x123を印刷するには？

1662
01:26:23,620 --> 01:26:27,460
>> 聴衆：あなたはパーセントを使用していますか
のxのポインタを印刷するには？

1663
01:26:27,460 --> 01:26:31,200
>> ROB：だから、パーセントを使うのですか
のxのポインタを印刷するには？

1664
01:26:31,200 --> 01:26:38,350
だから、あなたはできますが、パーセントxはちょうどです
一般的に、などのために、いくつかを持っている場合

1665
01:26:38,350 --> 01:26:40,325
整数、あなたが印刷したい
それ進数として。

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
それはあなたがそれを行うだけの方法です。

1668
01:26:44,880 --> 01:26:47,160
>> 一方、割合dはだろ
小数として印刷。

1669
01:26:47,160 --> 01:26:50,310
私たちはパーセントを取得したからだ
D。私はちょうど整数です。

1670
01:26:50,310 --> 01:26:52,690
パーセントpは、具体的である
ポインタ用。

1671
01:26:52,690 --> 01:26:54,060
>> だから、xがポインタである。

1672
01:26:54,060 --> 01:26:56,360
私たちは、パーセントpを使用したい。

1673
01:26:56,360 --> 01:26:57,937
しかしパーセントxは、仕事ができる。

1674
01:26:57,937 --> 01:26:58,414
うん？

1675
01:26:58,414 --> 01:26:59,664
>> 聴衆：[聞き取れない]？

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB：うん。

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
少なくとも、このために私はそうcall--
ここでそれを含んでいませんでした。

1680
01:27:13,440 --> 01:27:19,850
しかし、これらの二つの引数は必ずある
このスタックフレームの内側

1681
01:27:19,850 --> 01:27:23,040
ローカル変数と一緒に
のprintfが使用していることを起こる。

1682
01:27:23,040 --> 01:27:27,020
そして、次の呼び出しは、現在のprintfする
printfのスタック·フレームの内側には、

1683
01:27:27,020 --> 01:27:33,960
パーセントのp、バックスラッシュnと何でも
xの値は、0x123である、である。

1684
01:27:33,960 --> 01:27:34,425
うん？

1685
01:27:34,425 --> 01:27:35,675
>> 聴衆：[聞き取れない]？

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB：それは何かを印刷します
それは次のようになります。

1688
01:27:40,880 --> 01:27:41,846
>> 聴衆：[聞こえない]。

1689
01:27:41,846 --> 01:27:44,510
>> ROB：だからそれはアドレス形式でそれを印刷します。

1690
01:27:44,510 --> 01:27:47,003
これは、アドレスのように見えます。

1691
01:27:47,003 --> 01:27:47,494
うん？

1692
01:27:47,494 --> 01:27:49,458
>> 聴衆：[聞き取れない]？

1693
01:27:49,458 --> 01:27:51,075
>> ROB：なぜ何ですか？

1694
01:27:51,075 --> 01:27:52,920
>> 聴衆：[聞き取れない]？

1695
01:27:52,920 --> 01:27:55,240
>> ROB：なぜ、このポインタは4バイトです？

1696
01:27:55,240 --> 01:27:58,500
だから、全体の束があります
この目の前に0の。

1697
01:27:58,500 --> 01:28:03,740
だから、本当に0x0000000123です。

1698
01:28:03,740 --> 01:28:06,510
64ビットシステムでは、あるだろう
よりゼロの全体の束。

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
うん？

1701
01:28:11,900 --> 01:28:13,150
>> 聴衆：[聞こえない]。

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB：だから最初のprintf
print--しようとしている

1704
01:28:21,130 --> 01:28:21,980
>> 聴衆：[聞こえない]。

1705
01:28:21,980 --> 01:28:24,420
>> ROB：はい、それは印刷するために起こっている
何のxを指している。

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
スターはこれが何であるかと言う
事を指している。

1708
01:28:29,070 --> 01:28:30,300
それをつかむ。

1709
01:28:30,300 --> 01:28:31,455
だから、を指しているでしょうか？

1710
01:28:31,455 --> 01:28:31,850
50。

1711
01:28:31,850 --> 01:28:32,410
それをつかむ。

1712
01:28:32,410 --> 01:28:33,390
つまり、私たちが印刷しようとしているものです。

1713
01:28:33,390 --> 01:28:37,020
次のいずれかのに対して、私たちはしている
ちょうどx自身に印刷。

1714
01:28:37,020 --> 01:28:38,850
のfの内部では何ですか？

1715
01:28:38,850 --> 01:28:43,710
0x123。

1716
01:28:43,710 --> 01:28:44,500
[OK]をクリックします。

1717
01:28:44,500 --> 01:28:46,620
>> そして、最後に、私たちは自由を持っている。

1718
01:28:46,620 --> 01:28:48,040
私たちは、解放するために渡している？

1719
01:28:48,040 --> 01:28:49,470
私たちは、Xを渡している。

1720
01:28:49,470 --> 01:28:52,380
私が実際に表示さその時
そのスタックフレーム中。

1721
01:28:52,380 --> 01:28:56,370
>> だから私たちは値を渡している
解放する0x123。

1722
01:28:56,370 --> 01:28:59,070
だから今知っている自由、すべての権利、
私は、ヒープにまで行かなければならない

1723
01:28:59,070 --> 01:29:00,050
そのメモリを解放する。

1724
01:29:00,050 --> 01:29:03,920
それは、もはや使用していているのか
アドレス0x123にある。

1725
01:29:03,920 --> 01:29:07,010
>> だから自由にリリースする予定です
ヒープからの。

1726
01:29:07,010 --> 01:29:09,490
現在、私たちのヒープは再び空になっています。

1727
01:29:09,490 --> 01:29:11,120
私たちは、メモリリークがありません。

1728
01:29:11,120 --> 01:29:12,940
今すぐ無料で返されます。

1729
01:29:12,940 --> 01:29:16,130
xはまだ​​0x123であることに注意してください。

1730
01:29:16,130 --> 01:29:18,240
しかし、それは今有効なメモリではありません。

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
私たちは、もはやデリファレンスxをすべきである。

1733
01:29:23,986 --> 01:29:24,440
うん？

1734
01:29:24,440 --> 01:29:27,240
>> 観客は：0冗長を返しますか？

1735
01:29:27,240 --> 01:29:28,290
>> ROB：0冗長returenていますか？

1736
01:29:28,290 --> 01:29:31,110
はい。

1737
01:29:31,110 --> 01:29:33,950
私たちは、という理由だけで、そのそこに置く
私たちは、空気のリターン1を持っている。

1738
01:29:33,950 --> 01:29:36,830
だから、ええ、できます、ようなものだ
リターン0が含まれています。

1739
01:29:36,830 --> 01:29:37,310
うん？

1740
01:29:37,310 --> 01:29:38,560
>> 聴衆：[聞き取れない]？

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB：だから無料のxの後に、何があればどうなる
私たちは、ポインタを逆参照しようと？

1743
01:29:45,580 --> 01:29:47,240
それは、何もうまくいかない可能性があります。

1744
01:29:47,240 --> 01:29:49,330
私たちはまだ50を買ってあげることが可能です。

1745
01:29:49,330 --> 01:29:53,590
>> それは、そのメモリがあることを、また、可能性があります
今何か他のもののために使用されている。

1746
01:29:53,590 --> 01:29:57,140
だから、未定義の動作です。

1747
01:29:57,140 --> 01:30:00,772
そして、未定義のは何を意味し、
発生する可能性があります。

1748
01:30:00,772 --> 01:30:01,250
うん？

1749
01:30:01,250 --> 01:30:02,500
>> 聴衆：[聞き取れない]？

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB：いいえ、あなたが割り当てるので、もし
何か他のものへのx。

1752
01:30:10,830 --> 01:30:15,870
ちょうどここのであれば、私たちは、xが等しいと
malloc関数何かelse--

1753
01:30:15,870 --> 01:30:17,100
mallocのサイズevent--

1754
01:30:17,100 --> 01:30:20,180
その元のブロック
メモリが解放されません。

1755
01:30:20,180 --> 01:30:21,490
そして、私たちは正式にそれを失っている。

1756
01:30:21,490 --> 01:30:23,150
つまり、メモリリークです。

1757
01:30:23,150 --> 01:30:25,090
私たちは、すべての参照を失ってしまった
メモリのブロックへ。

1758
01:30:25,090 --> 01:30:26,827
だから、私たちが今までそれを解放することができます方法はありません。

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
そう、その後に行わ0手段を返す。

1761
01:30:36,630 --> 01:30:37,900
>> すべての権利なので、スタックオーバーフロー。

1762
01:30:37,900 --> 01:30:39,320
ここでの考え方は何ですか？

1763
01:30:39,320 --> 01:30:41,210
だから覚えて、ヒープが下がっている。

1764
01:30:41,210 --> 01:30:43,480
スタックが上がっている。

1765
01:30:43,480 --> 01:30:48,000
だから、これは講義の例だった、
私はどこにメインばかりになるだろう、と思う

1766
01:30:48,000 --> 01:30:51,380
起こっているこの関数fooを呼び出す
上で自分自身を再帰的に呼び出すようにし、

1767
01:30:51,380 --> 01:30:52,320
何度も何度も。

1768
01:30:52,320 --> 01:30:55,370
>> だから、しようとしているスタックフレーム
全く同じに動作します。

1769
01:30:55,370 --> 01:30:58,130
だから私たちは主から始めるつもりだ
ボトムスタックフレームとして。

1770
01:30:58,130 --> 01:31:02,000
そしてメインは、fooという呼び出ししようとしている
スタックフレームを取得する予定です。

1771
01:31:02,000 --> 01:31:04,260
>> その後、fooはfooのを呼び出そうとしている
再び、これは取得する予定です

1772
01:31:04,260 --> 01:31:05,500
別のスタックフレーム。

1773
01:31:05,500 --> 01:31:08,270
そして再び、そして再び、そして再び、
そして再びまで、最終的に、私たちは実行

1774
01:31:08,270 --> 01:31:09,190
ヒープへ。

1775
01:31:09,190 --> 01:31:11,990
だから、これは私たちが取得する方法です。
スタックオーバーフロー。

1776
01:31:11,990 --> 01:31:14,910
そして、この時点で、あなたはseg faultを。

1777
01:31:14,910 --> 01:31:17,335
それとも本当にワンセグの前に故障と思います
この点が、うん。

1778
01:31:17,335 --> 01:31:19,660
>> 聴衆：コアダンプされています
ワンセグ断層と同じ？

1779
01:31:19,660 --> 01:31:26,140
>> ROB：だから、セグメンテーションが表示されます
断層コアダンプ。

1780
01:31:26,140 --> 01:31:28,760
あなたは時コアダンプを取得
あなたはseg faultを。

1781
01:31:28,760 --> 01:31:32,580
そしてそれはすべてのダンプのようなものだ
ので、あなたの現在のメモリの内容

1782
01:31:32,580 --> 01:31:36,670
あなたは試してみて、識別することができる
なぜあなたは障害の発生したワンセグ。

1783
01:31:36,670 --> 01:31:37,135
うん？

1784
01:31:37,135 --> 01:31:38,385
>> 聴衆：[聞き取れない]？

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB：だからセグメンテーションフォールト手段
スタックオーバーフローがあります。

1787
01:31:45,460 --> 01:31:47,060
そうとは限らない。

1788
01:31:47,060 --> 01:31:49,880
セグメンテーションフォルトを使用すると、していることを意味します
の方法で接触メモリ

1789
01:31:49,880 --> 01:31:50,880
あなたがすべきではない。

1790
01:31:50,880 --> 01:31:54,750
だから出来事の一つの方法は、時です
あなたは私たちが触れる開始、スタックオーバーフロー

1791
01:31:54,750 --> 01:31:58,736
私たちはすべきではない方法で、メモリ。

1792
01:31:58,736 --> 01:31:59,208
うん？

1793
01:31:59,208 --> 01:32:00,458
>> 聴衆：[聞き取れない]？

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB：だから無限ループの内側。

1796
01:32:05,830 --> 01:32:08,770
同様に、これは再帰的な無限のようです
ループと私たちは別のものを取得する

1797
01:32:08,770 --> 01:32:09,770
スタック毎回フレーム。

1798
01:32:09,770 --> 01:32:13,540
しかし、単に定期的な内部
ひとつ選ぶ一方、無限

1799
01:32:13,540 --> 01:32:16,390
さて、でも印刷しないようにしましょう​​F--

1800
01:32:16,390 --> 01:32:17,040
何かをする。

1801
01:32:17,040 --> 01:32:18,390
何でも。

1802
01:32:18,390 --> 01:32:20,610
>> 当社は、取得するつもりはない
別のスタックフレーム。

1803
01:32:20,610 --> 01:32:22,530
私達はちょうどループを維持するつもりだ
この単一命令オーバー。

1804
01:32:22,530 --> 01:32:23,920
スタックが成長していません。

1805
01:32:23,920 --> 01:32:27,290
各再帰という事実だ
コー​​ルは私たちにスタックフレームを与えている。

1806
01:32:27,290 --> 01:32:31,231
私たちは、スタックオーバーフローを得る理由です。

1807
01:32:31,231 --> 01:32:31,728
うん？

1808
01:32:31,728 --> 01:32:38,189
>> 観客は：ので、もしあなたが得ると言われ
whileループし、[聞こえない]？

1809
01:32:38,189 --> 01:32:42,000
>> ROB：もしそうなら、whileループの内側
printfのがあった、あなたはまだでしょう

1810
01:32:42,000 --> 01:32:42,790
ワンセグではない故障。

1811
01:32:42,790 --> 01:32:46,090
私は物事を混同したくなかった。

1812
01:32:46,090 --> 01:32:46,610
それは、ループだろう。

1813
01:32:46,610 --> 01:32:48,225
あなたは、単一のスタックを取得したい
printfのためのフレーム。

1814
01:32:48,225 --> 01:32:49,580
>> その後のprintfが返されます。

1815
01:32:49,580 --> 01:32:50,280
その後、再びループをしたい。

1816
01:32:50,280 --> 01:32:51,460
あなたは、単一のスタックを取得したい
printfのためのフレーム。

1817
01:32:51,460 --> 01:32:52,850
それは戻ってくる。

1818
01:32:52,850 --> 01:32:54,060
シングルスタックフレーム。

1819
01:32:54,060 --> 01:33:00,215
だから、この無限を取得していない
スタックフレームを積み重ね。

1820
01:33:00,215 --> 01:33:03,185
>> 聴衆：[聞き取れない]？

1821
01:33:03,185 --> 01:33:04,040
>> ROB：はい。

1822
01:33:04,040 --> 01:33:09,360
したがって、このスタックオーバーフローが起こる
これらはいずれも理由

1823
01:33:09,360 --> 01:33:11,600
fooへの呼び出しが戻ってきている。

1824
01:33:11,600 --> 01:33:15,250
私たちが戻るならば、私たちはそのためだろう
スタックフレームを失い始める。

1825
01:33:15,250 --> 01:33:17,870
そして、私たちはスタックオーバーフローではないだろう。

1826
01:33:17,870 --> 01:33:20,070
そして、あなたはベースケースを必要とする理由です
あなたの個人的な機能のために。

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
うん？

1829
01:33:23,479 --> 01:33:27,375
>> 聴衆：電位の大きさと
ヒープで同じにするためにスタック

1830
01:33:27,375 --> 01:33:29,880
すべてのプログラム？

1831
01:33:29,880 --> 01:33:31,910
>> ROB：およそ。

1832
01:33:31,910 --> 01:33:35,090
スタックの潜在的な大きさがあり、
すべてのプログラムのヒープと同じ？

1833
01:33:35,090 --> 01:33:37,180
およそ。

1834
01:33:37,180 --> 01:33:40,080
にはいくつかのランダム化がある
ここでスタックが起動し、

1835
01:33:40,080 --> 01:33:42,400
ここで、ヒープが開始されます。

1836
01:33:42,400 --> 01:33:45,870
あなたは、全体の多くを持っていたりすると
グローバル変数との事、あなたがかもしれない

1837
01:33:45,870 --> 01:33:49,520
いくつかの領域から離れて取る
ヒープ用。

1838
01:33:49,520 --> 01:33:54,060
>> 64ビット·システムでは、あなた事実上
無限のメモリを持っている。

1839
01:33:54,060 --> 01:33:55,820
ただそんなにあります。

1840
01:33:55,820 --> 01:33:59,250
32ビットと64ビットの間で、その
有意な差がある。

1841
01:33:59,250 --> 01:34:02,350
>> あなたはより多くの全体の多くを取得するつもりだ
64ビットでのスタックとヒープ領域

1842
01:34:02,350 --> 01:34:05,810
システムだけでそれだけではありませんので、
彼らが使用できるアドレス。

1843
01:34:05,810 --> 01:34:09,360
しかし、個別のシステム上では、意志
スタックのほぼ同量であること

1844
01:34:09,360 --> 01:34:10,785
とヒープ領域。

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
かしこまりました。

1847
01:34:15,530 --> 01:34:18,220
>> だから、最後に、コンパイルです。

1848
01:34:18,220 --> 01:34:19,810
だから、このプロセスを知っている必要があります。

1849
01:34:19,810 --> 01:34:22,240
4大きなステップがあります。

1850
01:34:22,240 --> 01:34:24,400
だから、最初のものはすべき
覚えやすいこと。

1851
01:34:24,400 --> 01:34:25,085
前処理。

1852
01:34:25,085 --> 01:34:28,390
それはそれで事前接頭辞を持っています。

1853
01:34:28,390 --> 01:34:32,080
だから、他のすべての前に来る。

1854
01:34:32,080 --> 01:34:34,000
>> 覚えておくべき事はハッシュです。

1855
01:34:34,000 --> 01:34:37,250
だからハッシュ定義し、ハッシュが含まれ
これらのすべてにおいて。

1856
01:34:37,250 --> 01:34:39,560
これらは、すべてのプリプロセッサである
ディレクティブ。

1857
01:34:39,560 --> 01:34:42,030
これらは、ものです
プリプロセッサの世話をする。

1858
01:34:42,030 --> 01:34:43,680
>> だから、プリプロセッサは何をするのでしょうか？

1859
01:34:43,680 --> 01:34:44,850
それは本当にばかなことだ。

1860
01:34:44,850 --> 01:34:49,380
すべてのこれらのされているすべての対応だ
コピー、切り取り、貼り付けの操作。

1861
01:34:49,380 --> 01:34:51,790
>> だから、ハッシュは、標準I0ドット時間が含まれています。

1862
01:34:51,790 --> 01:34:52,990
やっていることは何ですか？

1863
01:34:52,990 --> 01:34:56,610
これは、標準I0ドットhをつかんだ
提出し、トップに貼り付ける

1864
01:34:56,610 --> 01:34:58,960
それはハッシュが含まれて言うところ
標準I0ドット時間。

1865
01:34:58,960 --> 01:35:02,480
>> そして、いずれかのハッシュは、私たちがしたことを定義
見て、それは何をしているのですか？

1866
01:35:02,480 --> 01:35:06,730
そのハッシュがその値をコピーする
定義されているが、そのようにして貼り付け定義されている

1867
01:35:06,730 --> 01:35:08,500
どこにあなたが値を使用しています。

1868
01:35:08,500 --> 01:35:13,400
だから、プリプロセッサは本当にない
単純なテキストベースの操作。

1869
01:35:13,400 --> 01:35:15,870
それはスマートな何もしません。

1870
01:35:15,870 --> 01:35:18,920
だから、他のすべてがある
より複雑。

1871
01:35:18,920 --> 01:35:22,970
>> だから、今ではプリプロセッサがある
行って、私たちは実際にコンパイルします。

1872
01:35:22,970 --> 01:35:24,320
だから、コンパイルは何を意味するのでしょうか？

1873
01:35:24,320 --> 01:35:27,310
現在Cコードからつもりだ
アセンブリコードへ。

1874
01:35:27,310 --> 01:35:27,570
うん？

1875
01:35:27,570 --> 01:35:28,820
>> 聴衆：[聞き取れない]？

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB：ええ、私たちはそれをキャッチしました。

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
だからコンパイル。

1880
01:35:38,660 --> 01:35:40,310
私たちは、Cからのアセンブリになるだろう。

1881
01:35:40,310 --> 01:35:42,470
これは、実際の言語の変化である。

1882
01:35:42,470 --> 01:35:45,240
自分自身をコンパイルすると、から行くことを意味
より高いレベルの言語に

1883
01:35:45,240 --> 01:35:47,340
下位レベルの言語。

1884
01:35:47,340 --> 01:35:50,720
>> cは高レベル言語である
アセンブリに比べ。

1885
01:35:50,720 --> 01:35:52,320
アセンブリとは何ですか？

1886
01:35:52,320 --> 01:35:56,440
かなり、であるその指示
ずっと、あなたのCPUのために作ら。

1887
01:35:56,440 --> 01:35:59,130
しかし、あなたのコンピュータはまだない
アセンブリを理解していない。

1888
01:35:59,130 --> 01:36:01,570
それは唯一のものとゼロを理解しています。

1889
01:36:01,570 --> 01:36:06,160
だから、次のステップは、組み立てされている
これらの命令から私たちをもたらすこと

1890
01:36:06,160 --> 01:36:08,760
あなたのCPUが実際に理解し、
に、それらを変換します

1891
01:36:08,760 --> 01:36:10,820
とゼロ。

1892
01:36:10,820 --> 01:36:13,570
>> バイナリへのアセンブリにCだから。

1893
01:36:13,570 --> 01:36:15,870
しかし、私はまだ実行していない。

1894
01:36:15,870 --> 01:36:19,550
だからCS50ライブラリ考える。

1895
01:36:19,550 --> 01:36:23,070
私たちは、バイナリをご提供してきた
のGetStringを持つこのCS50ライブラリ、

1896
01:36:23,070 --> 01:36:24,400
そしてGetIntで、すべてのこと。

1897
01:36:24,400 --> 01:36:25,700
>> しかし、CS50 library--

1898
01:36:25,700 --> 01:36:27,650
内とのitself--は実行可能ではありません。

1899
01:36:27,650 --> 01:36:29,570
これは、主な機能を持っていません。

1900
01:36:29,570 --> 01:36:32,230
それはちょうど、バイナリの束だ
あなたが使用することができます。

1901
01:36:32,230 --> 01:36:41,730
だからリンク私たちはすべて一緒に持って来る方法です
これらの異なるバイナリファイルの

1902
01:36:41,730 --> 01:36:43,110
実際の実行可能ファイルに変換する。

1903
01:36:43,110 --> 01:36:45,900
あなたが入力できますワン
ドットは、ドットをスラッシュ。

1904
01:36:45,900 --> 01:36:51,660
>> だから、これはあなたのファイルのようです。
、書いた - 何でもあなたのプログラムis--

1905
01:36:51,660 --> 01:36:53,620
シーザードットC。

1906
01:36:53,620 --> 01:36:55,100
しかし、今ではコンパイルされています
バイナリへのダウン。

1907
01:36:55,100 --> 01:36:56,480
だからシーザードットoを。

1908
01:36:56,480 --> 01:36:59,620
そして、これは私たちのCS50ライブラリバイナリです。

1909
01:36:59,620 --> 01:37:02,284
そして、彼らは組み合わされています
単一の実行可能に。

1910
01:37:02,284 --> 01:37:02,758
うん？

1911
01:37:02,758 --> 01:37:04,008
>> 聴衆：[聞き取れない]？

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB：だからまず覚えて、含まれる、
ハッシュは実際に含まれる

1914
01:37:12,710 --> 01:37:13,810
プリプロセッサ段階。

1915
01:37:13,810 --> 01:37:14,750
しかし、それは独立したのです。

1916
01:37:14,750 --> 01:37:20,730
あなたはそのいずれかの関数を使用していない場合
その後、あなたの単一ファイルの外にある、

1917
01:37:20,730 --> 01:37:26,100
いいえ、あなたは何をリンクする必要はありません
あなたはすべてを持っているので。

1918
01:37:26,100 --> 01:37:30,310
>> とはいえ、printfのはリンクされている。

1919
01:37:30,310 --> 01:37:32,820
あなたは今までのprintfを使用している場合、それは何か
つまり、リンクされる必要がある

1920
01:37:32,820 --> 01:37:35,740
あなたがそれを書いていないからです。

1921
01:37:35,740 --> 01:37:39,530
そして、実際には、printfのは自動的に
でリンク。

1922
01:37:39,530 --> 01:37:42,760
あなたが知っているどのようにコマンドラインで、または時
あなたはそれを持って参照して、作るタイプ

1923
01:37:42,760 --> 01:37:46,690
リンクがダッシュリットルCS50、
CS50ライブラリ内の？

1924
01:37:46,690 --> 01:37:49,070
printfの、そのようなもの、起こっている
自動的にリンクします。

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
何でも上の任意の他の質問？

1927
01:37:53,930 --> 01:37:56,280
>> 聴衆：[聞き取れない]？

1928
01:37:56,280 --> 01:37:58,300
>> ROB：リンク？

1929
01:37:58,300 --> 01:38:03,450
私たちは、の全体の束を持っている
異なるバイナリファイル。

1930
01:38:03,450 --> 01:38:06,410
これは標準的な例です。
私たちが使用していることは、CS50ライブラリです。

1931
01:38:06,410 --> 01:38:09,960
私達はあなたにコンパイルされ、与えられている
このCS50ライブラリのバイナリ。

1932
01:38:09,960 --> 01:38:12,410
>> あなたはのGetStringを使用したい
プログラム内。

1933
01:38:12,410 --> 01:38:14,750
だから、行くとのGetStringを使用しています。

1934
01:38:14,750 --> 01:38:19,700
しかし、私のバイナリコードなしで
あなたのコードをコンパイルするのGetString、

1935
01:38:19,700 --> 01:38:23,140
ダウン、あなたが実際にあなたを実行することはできません
プログラムのGetString文字列であるため、

1936
01:38:23,140 --> 01:38:25,080
まだ完全に定義されていません。

1937
01:38:25,080 --> 01:38:29,220
>> それはあなたが私のバイナリにリンクする場合にのみです
それは今、すべてのGetStringが含まれています

1938
01:38:29,220 --> 01:38:31,130
右、私は実際にすることができます
のGetStringを実行します。

1939
01:38:31,130 --> 01:38:32,330
私のファイルは完了です。

1940
01:38:32,330 --> 01:38:34,208
そして、私はこれを実行することができます。

1941
01:38:34,208 --> 01:38:34,697
うん？

1942
01:38:34,697 --> 01:38:37,631
>> 聴衆：コンバートを結ぶん
実行可​​能ファイルにバイナリ？

1943
01:38:37,631 --> 01:38:42,032
ですから、他のを持っていない場合でも、
ライブラリーは、それはまだないであろう

1944
01:38:42,032 --> 01:38:44,477
翻訳するために必要な
[聞き取れない]？

1945
01:38:44,477 --> 01:38:48,640
>> ROB：だから、実行可能
バイナリのままです。

1946
01:38:48,640 --> 01:38:51,750
それだけで全体を組み合わせることだ
バイナリの束。

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> 観客は：どうもありがとうございます。

1949
01:38:56,591 --> 01:38:58,560
>> ROB：問題ありません。

1950
01:38:58,560 --> 01:38:59,540
他の質問は？

1951
01:38:59,540 --> 01:39:02,001
そうでなければ、私たちはすべてのセットだ。

1952
01:39:02,001 --> 01:39:02,690
かしこまりました。

1953
01:39:02,690 --> 01:39:02,990
ありがとうございます。

1954
01:39:02,990 --> 01:39:03,590
>> [拍手]

1955
01:39:03,590 --> 01:39:04,490
>> 聴衆：ありがとうございます。

1956
01:39:04,490 --> 01:39:05,740
>> ROB：うん。

1957
01:39:05,740 --> 01:39:06,582