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

2
00:00:11,320 --> 00:00:13,260
>> DAVIDマラン：こんにちは、と
CS50に戻る歓迎。

3
00:00:13,260 --> 00:00:14,860
だから、これは、週4の終わりです。

4
00:00:14,860 --> 00:00:16,680
まずひとつ発表。

5
00:00:16,680 --> 00:00:19,600
だから、いわゆる第五月曜日です
この来る月曜日来る。

6
00:00:19,600 --> 00:00:22,800
これはから変更する機会です
手紙グレードへ/ UNSATのSAT、またはから

7
00:00:22,800 --> 00:00:24,130
手紙グレード/ UNSATを土

8
00:00:24,130 --> 00:00:27,130
うるさく、そのプロセスが必要とし
署名は、入力する必要があるため

9
00:00:27,130 --> 00:00:28,770
それらのピンクのアド/ドロップのいずれかの形式外。

10
00:00:28,770 --> 00:00:31,680
>> なぜなら技術的に、SAT / UNSAT
バージョンと手紙グレードバージョン

11
00:00:31,680 --> 00:00:33,320
個別のカタログ番号を持っている。

12
00:00:33,320 --> 00:00:34,240
しかし、大したことない。

13
00:00:34,240 --> 00:00:36,620
ただ、私のところに来るか、ロブに
または任意の時点でローレンへ。

14
00:00:36,620 --> 00:00:39,550
あなたが種を持っていない場合、または私達に電子メールを送り
書類のあなたは、今日必要とする、と私たち

15
00:00:39,550 --> 00:00:43,410
あなたが取る手助けして確実である
月曜日の前にそれの世話。

16
00:00:43,410 --> 00:00:45,780
>> すべての権利なので、今日は - 

17
00:00:45,780 --> 00:00:47,630
実際に、エコーのビットがあります。

18
00:00:47,630 --> 00:00:51,070
私たちは、私に少しトーンダウンすることはできますか？

19
00:00:51,070 --> 00:00:51,730
OK。

20
00:00:51,730 --> 00:00:54,850
だから、今日、我々は、トピックを紹介
ポインタとして知られている。

21
00:00:54,850 --> 00:00:57,770
そして、私は、これはの一つであることは認めるよ
私たちがする傾向があることを、より複雑なトピック

22
00:00:57,770 --> 00:01:00,960
このクラスでカバーするか、実際に任意の
C.を使用しています入門コース

23
00:01:00,960 --> 00:01:05,510
>> しかし、特に、それは私の言葉を取る
あなたの心はもう少し曲がっ感じるなら

24
00:01:05,510 --> 00:01:07,100
今日と週間で来る。

25
00:01:07,100 --> 00:01:10,340
それはあなたが得ることの代表ではありません
これでどんな悪くそれだけであることを意味

26
00:01:10,340 --> 00:01:13,360
それは特に高度なトピックだ
私が約束したので、数週間

27
00:01:13,360 --> 00:01:17,610
それ故に、あまりにも驚くほどだと思われる
振り返ってみると分かりやすい。

28
00:01:17,610 --> 00:01:18,720
>> 私はまだこの日に覚えています。

29
00:01:18,720 --> 00:01:22,190
私はエリオットのダイニングホールに座っていた、
私のTFニシャットメータの隣に座って、

30
00:01:22,190 --> 00:01:24,070
エリオット家の居住者が誰であった。

31
00:01:24,070 --> 00:01:26,340
そして、いくつかの理由のために、この
トピックでは、ただクリック。

32
00:01:26,340 --> 00:01:29,430
私も苦労していると言うことであるかどれ
一定の時間のためにそれが、私と

33
00:01:29,430 --> 00:01:33,610
そのようなを避けるのを助けるために最善を尽くします
その最終的な話題と闘争

34
00:01:33,610 --> 00:01:34,580
かなり強力です。

35
00:01:34,580 --> 00:01:37,350
>> 実際には、我々は説明しますのいずれかのトピック
週間で来ていることです

36
00:01:37,350 --> 00:01:41,130
のセキュリティ、およびどのようにあなたが実際にすることができます
の方法でマシンを活用

37
00:01:41,130 --> 00:01:42,320
それは、意図されていなかった。

38
00:01:42,320 --> 00:01:45,850
そして、それらの悪用は通常です
バグ、その我々のミスの結果

39
00:01:45,850 --> 00:01:49,740
人々は、いくつかを理解しないで作る
基礎となる実装の

40
00:01:49,740 --> 00:01:52,250
詳細はそれを介してプログラムが作られています。

41
00:01:52,250 --> 00:01:55,410
>> さて、これはすべてのより多くのユーザーに見えるようにする
優しい、私は10をプレイしようと思いました

42
00:01:55,410 --> 00:01:59,680
少しクレイメーションの第二プレビュー
に持って来られたBinkyの名前の数字

43
00:01:59,680 --> 00:02:03,020
スタンフォード大学の我々の友人によって生命、
教授ニックParlante。

44
00:02:03,020 --> 00:02:06,753
だから私はあなたにこれを与えることができ
ここBinkyののティーザー。

45
00:02:06,753 --> 00:02:09,520
>> [ビデオの再生]

46
00:02:09,520 --> 00:02:10,380
>>  - ねえ、Binkyの。

47
00:02:10,380 --> 00:02:11,050
起きて。

48
00:02:11,050 --> 00:02:13,610
これは、ポインタの楽しみのための時間です。

49
00:02:13,610 --> 00:02:14,741
>>  - どのようなそれはだ？

50
00:02:14,741 --> 00:02:16,440
ポインタについて学ぶ？

51
00:02:16,440 --> 00:02:17,928
ああ、グッディ。

52
00:02:17,928 --> 00:02:18,920
>> [ENDビデオ再生]

53
00:02:18,920 --> 00:02:20,670
>> DAVIDマラン：スタンフォードです
コンピュータサイエンス。

54
00:02:20,670 --> 00:02:23,194
だからもっとそれに来ています。

55
00:02:23,194 --> 00:02:24,930
>> [拍手]

56
00:02:24,930 --> 00:02:26,660
>> DAVIDマラン：申し訳ありませんが、ニック。

57
00:02:26,660 --> 00:02:30,680
>> だから我々に終了し、最後の時間を思い出す
これは本当にエキサイティングな接戦

58
00:02:30,680 --> 00:02:32,960
それによって、この関数
単に動作しませんでした。

59
00:02:32,960 --> 00:02:34,960
少なくとも直感的に、それはフェルト
のようにそれが動作するはずです。

60
00:02:34,960 --> 00:02:37,600
単に値をスワッピング
二つの整数の。

61
00:02:37,600 --> 00:02:40,915
しかし、我々はプリントアウトしたときにことを思い出してください
メイン、もう1つは元の値

62
00:02:40,915 --> 00:02:44,210
二人は、彼らはまだ1つだったと
2としない2と1。

63
00:02:44,210 --> 00:02:46,070
>> だから私は、実際に切り替えてみましょう
アプライアンスにオーバー。

64
00:02:46,070 --> 00:02:50,180
そして、私は内骨格コードのビットを書いた
私はXと主張するところ、ここで進める

65
00:02:50,180 --> 00:02:52,500
1になり、yは2になります。

66
00:02:52,500 --> 00:02:54,810
私はその後、彼らの両方をプリントアウト
プリントfの値。

67
00:02:54,810 --> 00:02:57,540
>> 私はその後、ここでダウンして主張している
我々はそれらを交換するつもりだ。

68
00:02:57,540 --> 00:03:00,800
私は、私たちにはここを空白のスポットを残し
ほんの一瞬で、今日に記入。

69
00:03:00,800 --> 00:03:03,380
その後、私はそれを主張するつもりだ
2つの変数が入れ替わっている。

70
00:03:03,380 --> 00:03:04,770
それから私は印刷するつもりです
再びそれら。

71
00:03:04,770 --> 00:03:07,090
そしてうまくいけば、私は1、2を参照する必要があります。

72
00:03:07,090 --> 00:03:07,380
2、1。

73
00:03:07,380 --> 00:03:09,830
それは超簡単です
今目標。

74
00:03:09,830 --> 00:03:12,430
>> だから私たちはスワッピングについてどのように行くのですか
二つの変数？

75
00:03:12,430 --> 00:03:17,220
さて、私はこれらのカップことをここで提案している場合
コンピュータのメモリを表す場合があります。

76
00:03:17,220 --> 00:03:19,070
これは、いくつか刺されている
別のいくつか刺されています。

77
00:03:19,070 --> 00:03:23,260
我々は、最大でボランティアに来たかもしれないと
おなじみの場合、私たちにいくつかの飲み物を混ぜて？

78
00:03:23,260 --> 00:03:23,920
までさあ。

79
00:03:23,920 --> 00:03:24,815
あなたの名前は？

80
00:03:24,815 --> 00:03:25,260
>> JESS：ジェス。

81
00:03:25,260 --> 00:03:25,690
>> DAVIDマラン：ジェス？

82
00:03:25,690 --> 00:03:26,540
、アップジェスをさあ。

83
00:03:26,540 --> 00:03:29,180
あなたが気にしないならば、我々は配置する必要があります
あなたにGoogleのグラスたちができるので

84
00:03:29,180 --> 00:03:30,430
これを不死化。

85
00:03:30,430 --> 00:03:32,800

86
00:03:32,800 --> 00:03:34,670
OK、ガラス。

87
00:03:34,670 --> 00:03:37,250
映像を記録します。

88
00:03:37,250 --> 00:03:43,103
し、[OK]を、私たちは、にぴったり
ここジェスと行く。

89
00:03:43,103 --> 00:03:43,810
わかりました。

90
00:03:43,810 --> 00:03:45,120
よろしくね。

91
00:03:45,120 --> 00:03:47,720
>> それでは、私はあなたがここで何したいのです - 
非常に迅速に、あなたができれば - 

92
00:03:47,720 --> 00:03:51,040
ちょうど私達にオレンジの半分ガラスを注ぐ
ジュース、牛乳の半分ガラス、

93
00:03:51,040 --> 00:03:55,710
効果的に数字1を表す
他のカップに1カップと2インチ

94
00:03:55,710 --> 00:04:01,380

95
00:04:01,380 --> 00:04:02,630
>> これは良い映像になるだろう。

96
00:04:02,630 --> 00:04:04,910

97
00:04:04,910 --> 00:04:05,860
>> JESS：申し訳ありません。

98
00:04:05,860 --> 00:04:06,330
>> DAVIDマラン：いや、いや。

99
00:04:06,330 --> 00:04:08,703
それはOKです。

100
00:04:08,703 --> 00:04:10,120
ニース。

101
00:04:10,120 --> 00:04:12,950
そうすべての権利、私たちは4バイトを持って
オレンジジュースの価値がある。

102
00:04:12,950 --> 00:04:14,460
我々は、それは値1と呼ばれるでしょう。

103
00:04:14,460 --> 00:04:16,579
今、牛乳の価値が他の4バイト。

104
00:04:16,579 --> 00:04:18,519
それは値2を呼び出します。

105
00:04:18,519 --> 00:04:20,440
それぞれ、xおよびyはそう。

106
00:04:20,440 --> 00:04:23,450
>> すべての権利、今手元の作業であれば - 
すべての前のあなたのために、ジェス、

107
00:04:23,450 --> 00:04:24,270
クラスメートの - 

108
00:04:24,270 --> 00:04:28,510
xとyなどの値を交換することです
我々は中にオレンジジュースを望んでいる

109
00:04:28,510 --> 00:04:32,070
他のカップと、このカップに牛乳、方法
あなたかもしれない - あなたが実際に行う前に、

110
00:04:32,070 --> 00:04:34,020
それは - これをやって行く？

111
00:04:34,020 --> 00:04:35,220
>> OK、決定を賢明。

112
00:04:35,220 --> 00:04:36,340
だから、少しより多くのメモリを必要とする。

113
00:04:36,340 --> 00:04:38,190
だから、一時的に割り当ててみましょう
カップ、可能ならば。

114
00:04:38,190 --> 00:04:40,540
そして今、xとyを入れ替えるに進みます。

115
00:04:40,540 --> 00:04:52,950

116
00:04:52,950 --> 00:04:53,530
>> 優秀。

117
00:04:53,530 --> 00:04:54,420
だから、非常によくやった。

118
00:04:54,420 --> 00:04:55,670
、そんなにジェスをありがとうございます。

119
00:04:55,670 --> 00:04:59,520

120
00:04:59,520 --> 00:05:00,020
はい、どうぞ。

121
00:05:00,020 --> 00:05:01,950
少しお土産。

122
00:05:01,950 --> 00:05:04,350
>> [OK]を、ので、明らかに、超シンプルなアイデア。

123
00:05:04,350 --> 00:05:07,500
我々はビットが必要であることを完全に直感的な
より多くの記憶領域 - この形で、

124
00:05:07,500 --> 00:05:09,750
カップ - 私たちが実際にしたい場合
これら2つの変数を入れ替える。

125
00:05:09,750 --> 00:05:11,110
それでは、正確に行うことができます。

126
00:05:11,110 --> 00:05:14,330
ここまでで、私は私が主張するところの間に
いくつかのスワップを行うことになるだろう、私はよ

127
00:05:14,330 --> 00:05:15,720
先に行くと、温度を宣言します。

128
00:05:15,720 --> 00:05:17,980
そして、私は、言うに等しいxはそれを設定します。

129
00:05:17,980 --> 00:05:21,110
>> それから私は、の値を変更するつもりです
ただジェスのようなxがと一緒にここにいた

130
00:05:21,110 --> 00:05:23,200
牛乳とオレンジジュース
yに等しくなるように。

131
00:05:23,200 --> 00:05:27,460
そして、私は等しくなるように、yを変更するつもりです
今、我々は次のようになりませんようにためのx、

132
00:05:27,460 --> 00:05:29,530
サークルで立ち往生、むしろ温度。

133
00:05:29,530 --> 00:05:33,170
どこで一時的に - 場所やジェス
一時的にオレンジジュースを入れて

134
00:05:33,170 --> 00:05:35,460
それをつかう前に
ミルクカップ。

135
00:05:35,460 --> 00:05:37,250
>> だから私は今、先に行くと、これを作ってみましょう。

136
00:05:37,250 --> 00:05:39,210
それはnoswap.cと呼ばれています。

137
00:05:39,210 --> 00:05:41,190
そして今、私は全くスワップを実行していないことができます。

138
00:05:41,190 --> 00:05:43,910
私が展開すると、実際に、私は、以下を参照してください
窓少し、その

139
00:05:43,910 --> 00:05:45,160
xは1であり、yは2である。

140
00:05:45,160 --> 00:05:47,230
そして、xが2であり、yは1である。

141
00:05:47,230 --> 00:05:51,910
>> しかし、月曜日に我々は物事をしたことを思い出してください
少し違ったそれによってI

142
00:05:51,910 --> 00:05:56,760
代わりに、ヘルパー関数を実装
あなたがする場合は、それが実際に無効であった。

143
00:05:56,760 --> 00:05:58,010
私はそれがスワップと呼ばれる。

144
00:05:58,010 --> 00:06:01,600
私はそれを二つのパラメータを与え、私が呼ばれる
それらは、と私は彼らがBと呼ばれる。

145
00:06:01,600 --> 00:06:04,380
>> 率直に言って、私は彼らに、xとy呼び出すことができます。

146
00:06:04,380 --> 00:06:06,040
停止は何もありません
ことをやってから私。

147
00:06:06,040 --> 00:06:08,140
しかし、私はそれがだと主張するだろう
少し曖昧。

148
00:06:08,140 --> 00:06:11,910
なぜなら月曜日リコール私たち
これらのパラメータがあったことを主張した

149
00:06:11,910 --> 00:06:13,650
値のコピーが渡された

150
00:06:13,650 --> 00:06:15,640
あなたととてもそれだけで台無し
心、私が思うに、あなたが使用している場合

151
00:06:15,640 --> 00:06:17,370
まったく同じ変数。

152
00:06:17,370 --> 00:06:20,150
>> だから私は、代わりに呼ぶことにします
aおよびbは、単に明確にするために。

153
00:06:20,150 --> 00:06:21,840
しかし、我々はそれらのほとんどを呼び出すことができ
私たちが望む何でも。

154
00:06:21,840 --> 00:06:26,280
そして、私はコピーして貼り付けるつもり
そこにから効果的にこのコード

155
00:06:26,280 --> 00:06:27,170
ここにダウン。

156
00:06:27,170 --> 00:06:29,110
私はそれが動作することを見たので。

157
00:06:29,110 --> 00:06:30,790
だからかなり良い形でだ。

158
00:06:30,790 --> 00:06:37,390
そして私は、私のXに自分Xを変更します
に、私のY BとBに私のyに。

159
00:06:37,390 --> 00:06:39,130
>> だから、他の言葉で、まったく同じロジック。

160
00:06:39,130 --> 00:06:40,850
ジェスがしたことはまったく同じこと。

161
00:06:40,850 --> 00:06:44,350
そして、私がしなければならない一つのこと
ここでは、もちろん、今ではこれを呼び出すことである

162
00:06:44,350 --> 00:06:45,990
関数、またはこの関数を呼び出します。

163
00:06:45,990 --> 00:06:50,430
だから私は2で、この関数を呼び出します
入力、xとy、および保存を押してください。

164
00:06:50,430 --> 00:06:52,300
>> すべての権利なので、根本的に
同じこと。

165
00:06:52,300 --> 00:06:55,570
実際に、私はおそらくプログラムを作りました
によって不必要に複雑な

166
00:06:55,570 --> 00:07:00,820
ただ取っている関数を書く
コー​​ドの一部6行に対し、I

167
00:07:00,820 --> 00:07:02,970
以前に実装されていた
わずか3でこれ。

168
00:07:02,970 --> 00:07:06,230
>> だから私は今、先に行くと、リメイクさせ
これは、スワップをしない。

169
00:07:06,230 --> 00:07:07,920
すべての権利、私はここで台無し。

170
00:07:07,920 --> 00:07:11,290
これは、可能性があるエラーでなければなりません
あなたのように、ますます一般的に見

171
00:07:11,290 --> 00:07:12,380
プログラムが複雑になる。

172
00:07:12,380 --> 00:07:13,470
しかし、簡単な修正はあり。

173
00:07:13,470 --> 00:07:15,650
私はここに戻って上にスクロールしましょう​​。

174
00:07:15,650 --> 00:07:18,190
>> そして、私は見ている最初のエラーは何ですか？

175
00:07:18,190 --> 00:07:19,520
暗黙の宣言。

176
00:07:19,520 --> 00:07:21,466
それは一般的に何を示すのでしょうか？

177
00:07:21,466 --> 00:07:22,830
ああ、私は試作品を忘れてしまった。

178
00:07:22,830 --> 00:07:26,900
私はそのスワップコンパイラを教えるのを忘れて
存在するために起こっているにもかかわらず、彼

179
00:07:26,900 --> 00:07:28,920
冒頭には存在しません
プログラムの。

180
00:07:28,920 --> 00:07:35,780
だから、僕は、無効、スワップを言うつもりです
int型、int型、B、セミコロン。

181
00:07:35,780 --> 00:07:37,280
>> だから私はそれを再実装するつもりはない。

182
00:07:37,280 --> 00:07:39,140
しかし、今、それはここでダウンしていたものと一致。

183
00:07:39,140 --> 00:07:42,530
、予告、セミコロンの欠如
ここで、これは必要ではないとき

184
00:07:42,530 --> 00:07:43,200
実装。

185
00:07:43,200 --> 00:07:46,010
>> だから私はこれをリメイクさせて、スワップをしない。

186
00:07:46,010 --> 00:07:46,910
はるかに良い形。

187
00:07:46,910 --> 00:07:48,130
全くスワップを実行しません。

188
00:07:48,130 --> 00:07:48,740
と畜生。

189
00:07:48,740 --> 00:07:51,650
我々は月曜日にいたところ今度は私達は戻って、
どこの事は交換しませんでした。

190
00:07:51,650 --> 00:07:55,410
>> と直感的な説明は何ですか
これがそうである理由のために？

191
00:07:55,410 --> 00:07:56,380
うん？

192
00:07:56,380 --> 00:07:57,630
>> 学生：[聞こえない]。

193
00:07:57,630 --> 00:08:04,140

194
00:08:04,140 --> 00:08:05,230
>> DAVIDマラン：その通り。

195
00:08:05,230 --> 00:08:07,330
そうbはxとyのコピーである。

196
00:08:07,330 --> 00:08:10,680
あなたがしてきたし、実際には、いつでも
これまでその機能を呼び出す

197
00:08:10,680 --> 00:08:12,540
int型のように変数を渡し - 

198
00:08:12,540 --> 00:08:14,470
スワップはここで期待しているのと同様に - 

199
00:08:14,470 --> 00:08:16,270
君たちにはコピーを渡してきた。

200
00:08:16,270 --> 00:08:19,150
>> 今では少しかかることを意味する
のための時間の、一瞬、

201
00:08:19,150 --> 00:08:23,270
1からビットをコピーするコンピュータ
別のビットに可変。

202
00:08:23,270 --> 00:08:24,610
しかし、それはそのような大したことではありません。

203
00:08:24,610 --> 00:08:25,920
しかし、彼らはそれにもかかわらず、コピーしている。

204
00:08:25,920 --> 00:08:30,020
>> そして今では、スワップの文脈において、
私は正常、実際に午前

205
00:08:30,020 --> 00:08:31,180
aとbを変更。

206
00:08:31,180 --> 00:08:33,000
実際には、迅速に行うみましょう
正気をチェック。

207
00:08:33,000 --> 00:08:36,830
私は、新しい行％であるFを印刷します。

208
00:08:36,830 --> 00:08:38,770
とにしましょう​​プラグ。

209
00:08:38,770 --> 00:08:41,830
今、Bと同じことをしてみましょう。

210
00:08:41,830 --> 00:08:43,640
そして、ここで同じことをしてみましょう。

211
00:08:43,640 --> 00:08:47,260
>> そして今、私はそれらの同じ行をコピーしてみましょう
再び機能の下部にある

212
00:08:47,260 --> 00:08:51,250
興味深いの私の三行の後
実行され、ている可能性が

213
00:08:51,250 --> 00:08:53,270
再びまだaとbを印刷します。

214
00:08:53,270 --> 00:08:56,030
だから今のこれをしてみましょう、スワップをしない。

215
00:08:56,030 --> 00:08:58,430
私はターミナルウィンドウを作ってみよう
少し背が高く、我々が見ることができるように

216
00:08:58,430 --> 00:08:59,520
一度にそれ以上の。

217
00:08:59,520 --> 00:09:00,860
>> と全くスワップを実行しません。

218
00:09:00,860 --> 00:09:04,000
xは1であり、yは2である。 1であり、bが2である。

219
00:09:04,000 --> 00:09:06,070
次いで、2であり、bは1である。

220
00:09:06,070 --> 00:09:09,390
だからそれだけでジェスのように、取り組んでいる
ここで内部スワップのでした。

221
00:09:09,390 --> 00:09:13,090
もちろん、それは何も影響を及ぼさないだ
メインの変数に。

222
00:09:13,090 --> 00:09:15,360
>> だから我々は、それによって我々のトリックを見た
右に、この問題を解決するだろうか？

223
00:09:15,360 --> 00:09:19,560
あなたは、このスコープに直面しているとき
問題は、あなただけパントとXを作ることができる

224
00:09:19,560 --> 00:09:22,400
とyどんな代わりの変数？

225
00:09:22,400 --> 00:09:23,390
>> あなたは彼らがグローバル作ることができます。

226
00:09:23,390 --> 00:09:27,560
ファイルの最上部に置く
私たちも、15のゲームで、行ったように。

227
00:09:27,560 --> 00:09:28,890
私たちは、グローバル変数を使用しています。

228
00:09:28,890 --> 00:09:32,420
しかし、ゲーム15の文脈において、
それはグローバルを有するのが妥当だ

229
00:09:32,420 --> 00:09:37,170
、ボードを表す変数理由
15.cの全体が全てです

230
00:09:37,170 --> 00:09:38,650
そのゲームの実装について。

231
00:09:38,650 --> 00:09:41,470
それはファイルが何を存在するものだ。

232
00:09:41,470 --> 00:09:44,170
>> しかし、ここで、この場合、私はよ
関数スワップを呼び出す。

233
00:09:44,170 --> 00:09:45,380
私は2つの変数を交換したい。

234
00:09:45,380 --> 00:09:48,950
そして、それだけでずさんな感じ始めるべき
もし我々のすべての解決策

235
00:09:48,950 --> 00:09:51,300
我々はスコープに実行する問題
問題は、それがグローバルにすることです。

236
00:09:51,300 --> 00:09:54,730
非常に迅速に私たちのプログラムであるため
かなり混乱になろう。

237
00:09:54,730 --> 00:09:57,760
そして我々はその非常に控えめにしました
15.c.で結果として

238
00:09:57,760 --> 00:10:00,470
>> そこうちしかし、それは変わり
完全に良い方法。

239
00:10:00,470 --> 00:10:05,600
私は実際に戻って削除してみましょう
ただ、このコードを簡素化するために、Fのを印刷してください。

240
00:10:05,600 --> 00:10:09,160
そして、私はそれを提案してみましょう
これは、確かに、悪いです。

241
00:10:09,160 --> 00:10:15,990
しかし、私はその代わりに、いくつかのアスタリスクに追加する場合
そして星は、私の代わりにこれを回すことができる

242
00:10:15,990 --> 00:10:18,670
の一つに機能
実際に運用。

243
00:10:18,670 --> 00:10:25,020
>> だから私はここに戻って行くと言って認めてみましょう
アスタリスクは、常に困難である

244
00:10:25,020 --> 00:10:26,170
ので、私は星を言うよ。

245
00:10:26,170 --> 00:10:27,660
私はちょうどそのいずれかに白状します。

246
00:10:27,660 --> 00:10:28,190
わかりました。

247
00:10:28,190 --> 00:10:30,190
そして今、何を私がつもり
代わりにするか？

248
00:10:30,190 --> 00:10:34,130
>> すべてのだから最初、私が指定するつもりです
その代わりにint型を渡す

249
00:10:34,130 --> 00:10:37,980
スワップ機能は、私の代わりによ
int型星を言おうとした。

250
00:10:37,980 --> 00:10:39,170
さて、スターは何を示すのでしょうか？

251
00:10:39,170 --> 00:10:41,970
これは、ポインタの概念であること
Binkyの、クレイメーションの文字があった

252
00:10:41,970 --> 00:10:43,465
前の瞬間に言及。

253
00:10:43,465 --> 00:10:47,610
>> だから我々はint型星、の意味を言えば
これは今であることを行っていないということです

254
00:10:47,610 --> 00:10:49,110
その値によって渡された。

255
00:10:49,110 --> 00:10:50,350
それはインチコピーするつもりはない

256
00:10:50,350 --> 00:10:54,700
むしろ、のアドレスである
渡されようとして

257
00:10:54,700 --> 00:10:57,840
>> だからあなたのコンピュータのその内部を思い出す
そうしないと、メモリの全体の束である

258
00:10:57,840 --> 00:10:58,760
RAMとして知られている。

259
00:10:58,760 --> 00:11:00,520
とRAMだけであることを
バイトの全体の束。

260
00:11:00,520 --> 00:11:03,320
お使いのMacまたはPCには、持っているのであれば
2ギガバイト、あなたは2を持っている

261
00:11:03,320 --> 00:11:05,760
メモリの億バイト。

262
00:11:05,760 --> 00:11:08,440
>> 今ちょうどそれだけを仮定してみましょう
我々は、物事が良いと整然と保つ

263
00:11:08,440 --> 00:11:09,450
アドレスを割り当てる - 

264
00:11:09,450 --> 00:11:10,170
数 - 

265
00:11:10,170 --> 00:11:12,270
お使いのコンピュータ内のRAMのすべてのバイトに。

266
00:11:12,270 --> 00:11:15,410
それらの2の非常に最初のバイト
億は数字のゼロである。

267
00:11:15,410 --> 00:11:18,572
次は、数バイトのナンバーワンである
までの2つの、すべての方法、ドットドット

268
00:11:18,572 --> 00:11:20,530
およそ20億にドット。

269
00:11:20,530 --> 00:11:23,640
>> だから、バイト数缶
お使いのコンピュータのメモリ。

270
00:11:23,640 --> 00:11:26,460
だから何だと仮定してみましょう
我々は、アドレスの意味。

271
00:11:26,460 --> 00:11:31,360
だから私は何が起こっているint型星、見るとき
今スワップに渡される

272
00:11:31,360 --> 00:11:32,830
のアドレス。

273
00:11:32,830 --> 00:11:37,150
はなく、その値が、どのようなその郵便
アドレスは、いわば、です - 

274
00:11:37,150 --> 00:11:38,810
RAM内の位置。

275
00:11:38,810 --> 00:11:41,250
>> 同様にBのために、私は行くよ
同じことを言うこと。

276
00:11:41,250 --> 00:11:42,720
int型、星、B。

277
00:11:42,720 --> 00:11:46,350
余談ですが、技術的にはスターとして
他の場所に行くことができます。

278
00:11:46,350 --> 00:11:50,140
しかし、我々はされて星に標準化します
データ型のすぐ隣。

279
00:11:50,140 --> 00:11:54,080
>> だから署名が今意味スワップ、私を与える
int型のアドレス、およびコール

280
00:11:54,080 --> 00:11:55,400
そのアドレス。

281
00:11:55,400 --> 00:11:58,690
と私の別のアドレスを与える
そのアドレスbをint型と呼ぶ。

282
00:11:58,690 --> 00:12:01,120
>> しかし、今ここに私のコードは変更する必要があります。

283
00:12:01,120 --> 00:12:03,470
なぜなら私はint型温度を宣言した場合 - 

284
00:12:03,470 --> 00:12:05,580
これは、int型はまだです - 

285
00:12:05,580 --> 00:12:08,700
しかし、私は、それに格納
値の種類？

286
00:12:08,700 --> 00:12:12,870
明確にするために、私はと入れています
今書かれたようなコード？

287
00:12:12,870 --> 00:12:14,360
>> 私は場所を入れている。

288
00:12:14,360 --> 00:12:16,500
しかし、私は気にしない
今場所は、右？

289
00:12:16,500 --> 00:12:21,940
温度は、ちょうどジェス '三杯を存在
存在し、どのような目的のために？

290
00:12:21,940 --> 00:12:23,090
値を格納する。

291
00:12:23,090 --> 00:12:24,830
牛乳やオレンジジュース。

292
00:12:24,830 --> 00:12:28,520
実際のアドレスを記憶しない
感じているそれらのもの、のいずれか

293
00:12:28,520 --> 00:12:31,200
この現実の中で少し無意味
とにかく世界コンテキスト。

294
00:12:31,200 --> 00:12:34,990
>> だから本当に、私は一時に入れたいもの
のアドレスではなく、ある

295
00:12:34,990 --> 00:12:36,180
の内容。

296
00:12:36,180 --> 00:12:41,930
123のような数であるのであれば、これは
ちょうどそのメモリの第123バイト

297
00:12:41,930 --> 00:12:45,090
、占領であることを起こる、その値
に占めることを起こる。

298
00:12:45,090 --> 00:12:49,040
>> 、私は、そのアドレスに行きたい場合は、
私は星と言う必要があります。

299
00:12:49,040 --> 00:12:52,610
同様に、私は何に変更していた
アドレスに、私が変更

300
00:12:52,610 --> 00:12:53,570
これが起動します。

301
00:12:53,570 --> 00:12:58,185
私がで何で保存したい場合
場所で何と場所

302
00:12:58,185 --> 00:13:02,180
Bの、星B星。

303
00:13:02,180 --> 00:13:05,340
>> これは非常にではないので、要するに、たとえ
まだでシンク - と私は期待していない

304
00:13:05,340 --> 00:13:06,560
それはとても速いだろうと - 

305
00:13:06,560 --> 00:13:11,100
私がやっているすべての前置されていることを実感
これらの星私の変数へ、

306
00:13:11,100 --> 00:13:13,350
と言って、値を取得しないでください。

307
00:13:13,350 --> 00:13:14,520
値は変更しないでください。

308
00:13:14,520 --> 00:13:17,600
むしろ、それらのアドレスに行く
と値を取得します。

309
00:13:17,600 --> 00:13:21,430
そのアドレスと変更に行く
そこに値。

310
00:13:21,430 --> 00:13:25,500
>> だから今、私が先頭に戻ってスクロールアップしてみましょう
だけに、ここでは、この行を修正する

311
00:13:25,500 --> 00:13:27,690
一致するプロトタイプを変更してください。

312
00:13:27,690 --> 00:13:30,280
しかし、私は今ではもう一つのことを行う必要があります。

313
00:13:30,280 --> 00:13:35,500
直感的に、私は種類を変更した場合
スワップは、期待されていることを引数の

314
00:13:35,500 --> 00:13:37,245
私は他に何をする必要がありますか
私のコードに変更しますか？

315
00:13:37,245 --> 00:13:39,750

316
00:13:39,750 --> 00:13:40,840
>> 私はスワップを呼び出すとき。

317
00:13:40,840 --> 00:13:43,340
今、何が入っているので
私はまだ交換に渡す？

318
00:13:43,340 --> 00:13:47,450
値xとyの値、または
牛乳とオレンジジュース。

319
00:13:47,450 --> 00:13:48,510
しかし、私はそれを行うにはしたくない。

320
00:13:48,510 --> 00:13:51,060
私の代わりに何を渡したいですか？

321
00:13:51,060 --> 00:13:53,050
、xの位置および
yの場所。

322
00:13:53,050 --> 00:13:55,300
彼らの郵便のアドレスは、どのようなものがあります
いわば。

323
00:13:55,300 --> 00:13:57,600
>> だから、それを行うには、アンパサンドはあり。

324
00:13:57,600 --> 00:13:59,260
アドレスのような音のアンパサンド一種。

325
00:13:59,260 --> 00:14:03,240
そうN、アンパサンド、アドレス
のx、およびyのアドレス。

326
00:14:03,240 --> 00:14:06,790
だから、我々が使用することを意図的だ
アンパサンド関数を呼び出し、

327
00:14:06,790 --> 00:14:10,230
と星宣言しとき
機能を実現する。

328
00:14:10,230 --> 00:14:14,220
>> としてそして、ちょうどアンパサンド考える
演算子のアドレス、などの星

329
00:14:14,220 --> 00:14:15,490
オペレータはそこに行く - 

330
00:14:15,490 --> 00:14:18,640
または、より適切に、
間接参照演算子。

331
00:14:18,640 --> 00:14:23,480
だから、それはただの言葉の全体の多くは、だ
今、うまくいけば、スワップが起こっていると言う

332
00:14:23,480 --> 00:14:24,440
正しいように。

333
00:14:24,440 --> 00:14:26,550
>> 私が先に行くと作ってみよう - 

334
00:14:26,550 --> 00:14:30,940
実際にはないように、ファイルの名前を変更てみましょう
このプログラムはまだないスワップと呼ばれません。

335
00:14:30,940 --> 00:14:33,240
私たちは、今ではswap.c呼ぶだろうことを主張している。

336
00:14:33,240 --> 00:14:35,670
だからスワップ、作る。

337
00:14:35,670 --> 00:14:37,520
ドット、スラッシュ、スワップ。

338
00:14:37,520 --> 00:14:40,210
>> そして今実際に、xは1であり、yは2である。

339
00:14:40,210 --> 00:14:44,040
そして、xは2であり、yは1である。

340
00:14:44,040 --> 00:14:46,500
まあ我々はこれを行うことができないかどうかを確認してみましょう
何のように異なって少し

341
00:14:46,500 --> 00:14:47,180
ここで起こって。

342
00:14:47,180 --> 00:14:51,250
まず、私は我々の上にズームインさせ
ここで画面を描画。

343
00:14:51,250 --> 00:14:54,160
と私は一瞬提案してみましょう - と
私はここに描く時にミラーリングされます

344
00:14:54,160 --> 00:14:58,660
今そこに - 私はそれを提案してみましょう
ここでは、メモリの全体の束です、または

345
00:14:58,660 --> 00:15:00,540
RAM、私のコンピュータの内部。

346
00:15:00,540 --> 00:15:04,140
>> そして、これは、一口数になります
の言う、1を聞かせて。

347
00:15:04,140 --> 00:15:05,720
これは、バイト数2になります。

348
00:15:05,720 --> 00:15:08,220
そして、私はより多くの全体の束を行い、よ
その後にドットドットドットの束

349
00:15:08,220 --> 00:15:10,880
20億があることを示している
これらの事。

350
00:15:10,880 --> 00:15:13,520
4,5、等が挙げられる。

351
00:15:13,520 --> 00:15:17,055
>> だから、最初の5バイトがあります
私のコンピュータのメモリ。

352
00:15:17,055 --> 00:15:17,560
大丈夫？

353
00:15:17,560 --> 00:15:19,060
20億のうち、ごく少数。

354
00:15:19,060 --> 00:15:21,120
しかし、今私が提案するつもりです
次。

355
00:15:21,120 --> 00:15:27,490
私はxがしようとしていることを提案するつもりだ
番号1を格納し、yが起こっている

356
00:15:27,490 --> 00:15:29,690
番号2を格納する。

357
00:15:29,690 --> 00:15:35,000
と私は今、先に行くと表してみましょう
これらの値は以下の通りである。

358
00:15:35,000 --> 00:15:41,510
>> 次のようにこれを実行しましょう​​。

359
00:15:41,510 --> 00:15:42,870
私だけ一秒を与えます。

360
00:15:42,870 --> 00:15:44,150
一秒。

361
00:15:44,150 --> 00:15:45,680
OK。

362
00:15:45,680 --> 00:15:47,560
私はこの小さなを作りたい - 

363
00:15:47,560 --> 00:15:50,440
再びこれを行うてみましょう。

364
00:15:50,440 --> 00:15:53,250
そうでなければ私はに行って使用しています
同じ数字、思わず、

365
00:15:53,250 --> 00:15:54,230
複数回。

366
00:15:54,230 --> 00:15:57,320
>> だから私たちは異なる番号を持っている
について話をする、のはこのバイトを呼び出してみましょう

367
00:15:57,320 --> 00:16:03,391
番号123、124、125、126、
ドットドットドット。

368
00:16:03,391 --> 00:16:08,400
そして、私は私がするつもりだ今主張してみましょう
ここで値1、値2を入れて

369
00:16:08,400 --> 00:16:11,990
ここで、そうでなければ、xとyとして知られています。

370
00:16:11,990 --> 00:16:15,300
だから、それはちょうどようになりますか
これは、xが、これはyです。

371
00:16:15,300 --> 00:16:18,180
>> そして、ちょうどいくつかの偶然によって、
コンピュータ、オペレーティングシステム、

372
00:16:18,180 --> 00:16:21,890
場所にXを入れて起こった
数123。

373
00:16:21,890 --> 00:16:25,590
とyは位置124で終わった - 

374
00:16:25,590 --> 00:16:26,330
畜生。

375
00:16:26,330 --> 00:16:28,700
私はこれを修正しているはずです。

376
00:16:28,700 --> 00:16:34,040
男はああ、私は本当にこれをやりたいのですか？

377
00:16:34,040 --> 00:16:37,340
はい、私はこれとを固定したい
今日はこれについて適正なB。

378
00:16:37,340 --> 00:16:39,950
申し訳ありませんが、これに新しい。

379
00:16:39,950 --> 00:16:45,020
>> 127、131、、私はこのようにしたくなかった
複雑な、しかし、なぜ私が変更したの

380
00:16:45,020 --> 00:16:46,340
そこに数字？

381
00:16:46,340 --> 00:16:48,360
私はint型にしたいので、
実際には4バイトである。

382
00:16:48,360 --> 00:16:49,810
それでは、これについてスーパー肛門とする。

383
00:16:49,810 --> 00:16:53,800
だから1が対処しなければ発生した場合という
123、2は、アドレスであることを行っている

384
00:16:53,800 --> 00:16:55,730
127それだけで4不戦勝距離だから。

385
00:16:55,730 --> 00:16:56,210
それがすべてです。

386
00:16:56,210 --> 00:16:58,640
そして我々はすべてのことを忘れるだろう
世界の他のアドレス。

387
00:16:58,640 --> 00:17:03,320
>> だからxが、位置123にある
yは位置127にあります。

388
00:17:03,320 --> 00:17:05,770
そして今、私は実際に何をすべきか
やってみたい？

389
00:17:05,770 --> 00:17:10,099
私は今、スワップを呼び出すと、何です
実際に起こっている？

390
00:17:10,099 --> 00:17:14,920
まあ、私はスワップを呼び出すときに、私が渡しています
xとyのアドレスのアドレス。

391
00:17:14,920 --> 00:17:18,540
だから例えば、もしこれら二つ
紙から今2を表す

392
00:17:18,540 --> 00:17:23,510
引数と私は何を、交換するB
、これらの最初に書くつもり

393
00:17:23,510 --> 00:17:27,720
私はを参照して呼び出すつもりれる？

394
00:17:27,720 --> 00:17:30,610
>> 正確には、123。

395
00:17:30,610 --> 00:17:31,905
だから私は主張するこれは。

396
00:17:31,905 --> 00:17:32,955
これはパラメータです。

397
00:17:32,955 --> 00:17:35,856
私はそこのxのアドレスを入れている。

398
00:17:35,856 --> 00:17:38,152
>> 何それ？

399
00:17:38,152 --> 00:17:40,890
>> 何それ？

400
00:17:40,890 --> 00:17:41,190
>> いや、いや。

401
00:17:41,190 --> 00:17:41,720
それでOKです。

402
00:17:41,720 --> 00:17:42,570
まだ良い、まだ良い。

403
00:17:42,570 --> 00:17:43,530
だから、これはです。

404
00:17:43,530 --> 00:17:46,240
そして今、紙の2枚目に、
これは、Bになるだろう、と私は何です

405
00:17:46,240 --> 00:17:49,010
に書くことになるだろう
この紙？

406
00:17:49,010 --> 00:17:50,080
127。

407
00:17:50,080 --> 00:17:53,720
>> だから以降に変わっただけだ
この物語の我々の以前語っている、

408
00:17:53,720 --> 00:17:58,590
むしろ文字通り1と2よりも、私は私
123と127に渡すつもり。

409
00:17:58,590 --> 00:18:02,130
そして私は今、これらの内部を置くつもりです
このボックスの、大丈夫？

410
00:18:02,130 --> 00:18:04,640
だからブラックボックスは現在を表し
スワップ機能。

411
00:18:04,640 --> 00:18:07,230
>> 一方、今、誰かを持ってみましょう
スワップ機能を実装しています。

412
00:18:07,230 --> 00:18:09,090
ここで誰かがアップするでしょう
ボランティアしたい？

413
00:18:09,090 --> 00:18:09,560
までさあ。

414
00:18:09,560 --> 00:18:11,080
あなたの名前は？

415
00:18:11,080 --> 00:18:11,460
チャーリー。

416
00:18:11,460 --> 00:18:12,080
すべての権利、チャーリー。

417
00:18:12,080 --> 00:18:14,810
までさあ。

418
00:18:14,810 --> 00:18:17,310
>> だからチャーリーは遊ぶために起こっている
我々のブラックボックスの役割。

419
00:18:17,310 --> 00:18:21,460
私はあなたがやりたいのかとチャーリー、
今、このような方法でスワップを実装され

420
00:18:21,460 --> 00:18:25,320
、それらの2つのアドレスを与え、その
あなたが実際に行っていた

421
00:18:25,320 --> 00:18:26,330
値を変更します。

422
00:18:26,330 --> 00:18:28,290
そして、私はあなたの耳にささやくよ
ここでは、テレビを実行する方法について説明します。

423
00:18:28,290 --> 00:18:29,930
>> だから先に行く、あなたはブラックボックスだ。

424
00:18:29,930 --> 00:18:30,920
そこにリーチ。

425
00:18:30,920 --> 00:18:34,054
あなたは何の値をを参照しない
あなたは、Bのためにどのような値を見ていますか？

426
00:18:34,054 --> 00:18:36,740
>> CHARLIE：123であり、bは127です。

427
00:18:36,740 --> 00:18:37,530
>> DAVIDマラン：OK、まさに。

428
00:18:37,530 --> 00:18:38,940
今、ちょっとそこに一時停止します。

429
00:18:38,940 --> 00:18:41,680
あなたが今やろうとしている最初のもの、
コー​​ドに従って - どの

430
00:18:41,680 --> 00:18:43,220
私は今、画面上にプルアップします - 

431
00:18:43,220 --> 00:18:46,750
少しを割り当てることになるだろう
メモリのビットは、温度と呼ばれる。

432
00:18:46,750 --> 00:18:48,850
だから私は先に行くつもりだと
あなたにそのメモリを与える。

433
00:18:48,850 --> 00:18:52,210
>> だから、これは3番目の変数になるだろう
あなたは、にアクセスできる持っていること

434
00:18:52,210 --> 00:18:54,080
あなたは、温度と呼ばれる。

435
00:18:54,080 --> 00:18:57,120
そして、何を書こうとしている
紙の一時作品で？

436
00:18:57,120 --> 00:19:02,524

437
00:19:02,524 --> 00:19:03,470
>> CHARLIE：ポインタ、右？

438
00:19:03,470 --> 00:19:04,790
>> DAVIDマラン：OK、よくありません
ポインタを必ずしも。

439
00:19:04,790 --> 00:19:07,230
だから、私がしたことをコードの行
右側に強調表示され、

440
00:19:07,230 --> 00:19:07,900
そこから始めましょう。

441
00:19:07,900 --> 00:19:08,890
それは、星氏は述べています。

442
00:19:08,890 --> 00:19:11,670
だから、現在保存している
数123。

443
00:19:11,670 --> 00:19:16,660
そして、ちょうど直感的に、どのような
星123もしかして？

444
00:19:16,660 --> 00:19:21,630
>> しかし、具体的には、ある場合
123、星の何を意味する？

445
00:19:21,630 --> 00:19:22,560
の値。

446
00:19:22,560 --> 00:19:24,580
以上何気なく、そこに行く。

447
00:19:24,580 --> 00:19:28,620
だから私はに保持することを提案させて
あなたの手は、先に行くとそれを扱う

448
00:19:28,620 --> 00:19:29,430
あたかもそれはマップです。

449
00:19:29,430 --> 00:19:32,940
とコンピュータのに自分自身をオーバー歩く
メモリ、何か私たちを見つける

450
00:19:32,940 --> 00:19:36,520
場所123で。

451
00:19:36,520 --> 00:19:37,720
まさに。

452
00:19:37,720 --> 00:19:41,100
>> だから我々は、場所123で見
明らかに、何ですか？

453
00:19:41,100 --> 00:19:44,240
[OK]を、ので、今、あなたはどのような値である
一時に置くつもり？

454
00:19:44,240 --> 00:19:44,750
まさに。

455
00:19:44,750 --> 00:19:45,600
だから先に行くとそれを行う。

456
00:19:45,600 --> 00:19:51,280
との部分に番号1を書き込む
現在温度というタイトルの論文。

457
00:19:51,280 --> 00:19:53,540
>> そして今、次のステップでその
あなたが実装するつもり

458
00:19:53,540 --> 00:19:54,310
何になるだろう。

459
00:19:54,310 --> 00:19:57,820
まあ、の右側に
コー​​ドの次の行では、星のBです。 A、Bの

460
00:19:57,820 --> 00:19:59,260
コー​​スは、アドレスを格納します。

461
00:19:59,260 --> 00:20:02,270
それは127に対応しています。

462
00:20:02,270 --> 00:20:06,620
星bが何気なく話し何を意味？

463
00:20:06,620 --> 00:20:08,700
>> その場所に移動します。

464
00:20:08,700 --> 00:20:14,988
だから先に行くと何私たちを見つける
場所127で。

465
00:20:14,988 --> 00:20:15,480
OK。

466
00:20:15,480 --> 00:20:19,170
もちろん、位置127において、
まだ値2です。

467
00:20:19,170 --> 00:20:24,060
だから、で今何を保存しようとしている
内の場所でどのようなのですか？

468
00:20:24,060 --> 00:20:26,860
だから星は場所に行くことを意味します。

469
00:20:26,860 --> 00:20:29,770
場所は何ですか？

470
00:20:29,770 --> 00:20:30,430
>> まさに。

471
00:20:30,430 --> 00:20:34,190
だから今、あなたが変更したい場合
その場所で何が - 

472
00:20:34,190 --> 00:20:36,470
私が先に行くと実行することになるでしょう
消しゴムはここにある。

473
00:20:36,470 --> 00:20:37,760
そして今、ブラシの上に戻す。

474
00:20:37,760 --> 00:20:42,190
何番のように書くつもりです
その空白のボックスになりました？

475
00:20:42,190 --> 00:20:42,850
>> まさに。

476
00:20:42,850 --> 00:20:46,470
だから、このコード行は、明確にするために - せ
チャーリーはやっているのか、私を一時停止

477
00:20:46,470 --> 00:20:51,730
ここで指摘し、どのような彼はまさに行われていることである
場所123でその箱に書き込む

478
00:20:51,730 --> 00:20:55,150
Bの前にあった値。

479
00:20:55,150 --> 00:20:59,140
そして我々は今、確かに実装しました
コー​​ドのこの二行。

480
00:20:59,140 --> 00:21:01,920
>> さて、残念ながら、そこ
残りまだ一行。

481
00:21:01,920 --> 00:21:04,900
文字通り、一時に今は何ですか？

482
00:21:04,900 --> 00:21:06,200
それは明らかにナンバーワンだ。

483
00:21:06,200 --> 00:21:07,020
それはアドレスではありません。

484
00:21:07,020 --> 00:21:09,380
それは一種の、ほんの数だ
週1から変数。

485
00:21:09,380 --> 00:21:13,520
>> そして今、あなたは、星bが、その意味すると言うとき
あるアドレスBに行く

486
00:21:13,520 --> 00:21:15,090
ここのコース。

487
00:21:15,090 --> 00:21:16,020
だから、一度そこに着く - 

488
00:21:16,020 --> 00:21:18,320
私が先に行くと、実際に何を消去します
そこに - あなたは、何である

489
00:21:18,320 --> 00:21:20,820
位置127で今書くつもり？

490
00:21:20,820 --> 00:21:22,010
>> CHARLIE：温度、一つです。

491
00:21:22,010 --> 00:21:23,430
>> DAVIDマラン：温度、一つです。

492
00:21:23,430 --> 00:21:25,670
そして最後には一時に何が起こる？

493
00:21:25,670 --> 00:21:26,600
さて、私たちは本当にわからない。

494
00:21:26,600 --> 00:21:27,420
私たちは本当に気にしない。

495
00:21:27,420 --> 00:21:31,090
我々は機能を実装しましたいつでも
これまで、すべてのローカル変数は、あなたが持っている

496
00:21:31,090 --> 00:21:31,890
確かにローカルです。

497
00:21:31,890 --> 00:21:33,060
そして、彼らはただ消えてしまう。

498
00:21:33,060 --> 00:21:35,040
彼らは、オペレーティングによって回収している
最終的にシステム。

499
00:21:35,040 --> 00:21:39,800
>> だから温度がまだ持っているという事実
値1は、基本的に一種である

500
00:21:39,800 --> 00:21:41,150
私たちに面白くない。

501
00:21:41,150 --> 00:21:43,100
すべての権利なので、拍手
我々はチャーリーできれば。

502
00:21:43,100 --> 00:21:46,400
非常によくやった。

503
00:21:46,400 --> 00:21:51,520
>> すべての権利は​​、なおさらどういう
これは我々が行うことができます意味ですか？

504
00:21:51,520 --> 00:21:54,400
だから、私たちがしてきたことが判明
いくつかの白い嘘をつく

505
00:21:54,400 --> 00:21:55,540
かなりの時間のために。

506
00:21:55,540 --> 00:21:59,990
確かに、それは、その文字列が判明
この時間のすべてが、本当にない

507
00:21:59,990 --> 00:22:02,190
自体の文字のシーケンス。

508
00:22:02,190 --> 00:22:03,980
の種類は、直感的にそれです。

509
00:22:03,980 --> 00:22:08,270
>> しかし、技術的に言えば、文字列は
我々は内部で宣言したデータ型

510
00:22:08,270 --> 00:22:12,170
世界を簡素化するためにCS50ライブラリ
クラスの最初の数週間のために。

511
00:22:12,170 --> 00:22:20,130
どんな文字列が本当にあることはアドレスです
どこかでRAM内の文字の。

512
00:22:20,130 --> 00:22:25,530
文字列には、123のように、本当に数です
区別するために起こるまたは127、

513
00:22:25,530 --> 00:22:28,420
文字列がで始まる場所
コンピュータのメモリ。

514
00:22:28,420 --> 00:22:31,870
>> しかし、それは表していません
文字列、それ自体、それ自体。

515
00:22:31,870 --> 00:22:33,460
そして我々は、これは次のように見ることができます。

516
00:22:33,460 --> 00:22:35,980
私が先に行くと開放しましょう
間のいくつかのコード

517
00:22:35,980 --> 00:22:38,340
今日のソースコードの例。

518
00:22:38,340 --> 00:22:42,225
そして、私は先に行くと開くつもりです
まで、比較-0.c、のは言わせて。

519
00:22:42,225 --> 00:22:44,830

520
00:22:44,830 --> 00:22:48,790
これが起こっているバグのプログラムです
次のように実装される。

521
00:22:48,790 --> 00:22:49,040
>> 最初。

522
00:22:49,040 --> 00:22:50,420
私が何かを言うつもりです。

523
00:22:50,420 --> 00:22:52,660
それから私は先に行くつもりだと
ユーザーからの文字列を取得

524
00:22:52,660 --> 00:22:53,750
その次の行である。

525
00:22:53,750 --> 00:22:55,370
その後、私は再びそれを言うつもりです。

526
00:22:55,370 --> 00:22:57,540
それから私は別のを取得するつもりだ
ユーザから文字列。

527
00:22:57,540 --> 00:23:00,390
>> と通知は、私は次のいずれかを示しています
Sと呼ばれる変数内の文字列、および

528
00:23:00,390 --> 00:23:03,040
これらの文字列の別の
Tと呼ばれる変数である。

529
00:23:03,040 --> 00:23:07,480
そして今、私は非常に、請求するつもりです
sが等しい場合に合理的に、それは、Tに等しい

530
00:23:07,480 --> 00:23:08,940
文字列は同じです。

531
00:23:08,940 --> 00:23:09,970
あなたが同じことを入力します。

532
00:23:09,970 --> 00:23:11,830
そうでなければ、文字列は
しないと同じこと。

533
00:23:11,830 --> 00:23:15,440
>> 結局のところ、我々は、入力2つのint、2を場合
文字、2フロート、2つのdoubleのいずれか

534
00:23:15,440 --> 00:23:18,400
我々はについて話したデータ型
これまで、それらを比較する - 

535
00:23:18,400 --> 00:23:22,070
我々はしばらく前に非常に明確にしたリコール
これを実行しないこと、なぜなら

536
00:23:22,070 --> 00:23:25,840
単一の等号はもちろんですが
代入演算子。

537
00:23:25,840 --> 00:23:26,820
だから、それはバグでしょう。

538
00:23:26,820 --> 00:23:29,260
>> 我々は平等​​な等号を使用し、
確かに比較する

539
00:23:29,260 --> 00:23:31,050
真の平等のためのもの。

540
00:23:31,050 --> 00:23:32,275
しかし、私は、これはバグであると主張。

541
00:23:32,275 --> 00:23:37,400
私が先に行くとゼロを比較する場合、
その後ドットスラッシュゼロを比較しないでください。

542
00:23:37,400 --> 00:23:39,700
と私は、こんにちは、のは言わせて、入力します。

543
00:23:39,700 --> 00:23:41,590
その後の、再び挨拶しましょう​​。

544
00:23:41,590 --> 00:23:46,040
文字通り同じこと、コンピュータ
私は別のものを入力したと主張している。

545
00:23:46,040 --> 00:23:47,640
>> 今、多分私はちょうど何かをミスタイプ。

546
00:23:47,640 --> 00:23:49,910
私は私の名前、この時間を入力します。

547
00:23:49,910 --> 00:23:52,580
私は意味、こんにちは。

548
00:23:52,580 --> 00:23:54,770
こんにちは。

549
00:23:54,770 --> 00:23:57,360
それは毎回違う。

550
00:23:57,360 --> 00:23:58,430
>> まあ、理由です？

551
00:23:58,430 --> 00:24:00,140
何が本当に起こっているの
ボンネットの下に？

552
00:24:00,140 --> 00:24:03,270
さて、何が本当に下に起こっている
フードは、文字列である

553
00:24:03,270 --> 00:24:07,410
私は、例えば、最初の時間で入力
ワードはもちろん、ハローある。

554
00:24:07,410 --> 00:24:11,660
しかし、我々の下に、これを表している場合
ボンネット、そのリコール

555
00:24:11,660 --> 00:24:13,470
文字列が配列になっています。

556
00:24:13,470 --> 00:24:15,040
そして、私たちは、過去に同じくらいと言ってきました。

557
00:24:15,040 --> 00:24:20,200
>> 私はこのように、その配列を描くのであれば、私はよ
非常に何かを表現しようとし

558
00:24:20,200 --> 00:24:23,030
我々は一瞬前にやったことと似ています。

559
00:24:23,030 --> 00:24:25,390
そして、何かが実際にあり
あまりにも、ここに特別な。

560
00:24:25,390 --> 00:24:28,090
にいた我々は何を決定するた
すべての文字列の末尾に？

561
00:24:28,090 --> 00:24:30,760
ですええ、このバックスラッシュゼロ、
表現だけの方法、

562
00:24:30,760 --> 00:24:33,610
文字通り、00000000。

563
00:24:33,610 --> 00:24:35,680
行の八0ビット。

564
00:24:35,680 --> 00:24:37,610
>> 私は、率直に言って、わかりません
この後何。

565
00:24:37,610 --> 00:24:40,090
それはちょうど束より多くのRAMだ
私のコンピュータの内部。

566
00:24:40,090 --> 00:24:40,970
しかし、これは配列です。

567
00:24:40,970 --> 00:24:42,260
我々は前に配列の話。

568
00:24:42,260 --> 00:24:45,010
そして、私たちは一般的に配列の話
場所はゼロであるとして、

569
00:24:45,010 --> 00:24:46,580
次いでその後一つ、二つ。

570
00:24:46,580 --> 00:24:47,950
しかし、それは利便性のためだけだ。

571
00:24:47,950 --> 00:24:49,380
そして、それは完全に相対的です。

572
00:24:49,380 --> 00:24:53,010
>> あなたが実際にからメモリを取得しているとき
、それはもちろん、任意のコンピュータの

573
00:24:53,010 --> 00:24:55,450
20億いくつかの奇妙なバイト、潜在的に。

574
00:24:55,450 --> 00:24:59,100
だから本当にボンネットの下に、
すべてのこの時間、はい。

575
00:24:59,100 --> 00:25:01,670
これは非常によく、ブラケットゼロであるかもしれません。

576
00:25:01,670 --> 00:25:04,780
しかし、あなたは下にさらに深く掘る場合
本当にだフード、

577
00:25:04,780 --> 00:25:07,000
番号123に対応する。

578
00:25:07,000 --> 00:25:09,150
これは、アドレス124である。

579
00:25:09,150 --> 00:25:11,040
これは、アドレス125です。

580
00:25:11,040 --> 00:25:12,540
>> そして、私はこの時間を台無しにしませんでした。

581
00:25:12,540 --> 00:25:15,840
これらは現在、1バイト
別に何の理由で？

582
00:25:15,840 --> 00:25:17,930
char型の大きさは？

583
00:25:17,930 --> 00:25:19,170
char型は、ちょうど1バイトです。

584
00:25:19,170 --> 00:25:20,570
int型は通常4バイトです。

585
00:25:20,570 --> 00:25:24,850
私は123それを作った理由ようです、
127、131等が挙げられる。

586
00:25:24,850 --> 00:25:27,560
今、私は数学が簡単に保つことができ
とだけプラス1を行う。

587
00:25:27,560 --> 00:25:30,510
そして、これは今、本当に何が起こっているのです
ボンネットの下に。

588
00:25:30,510 --> 00:25:37,760
>> ですから、このような何かを宣言するときに、
文字列sは、これは実際にある - 

589
00:25:37,760 --> 00:25:39,170
それが判明 - 

590
00:25:39,170 --> 00:25:41,190
charのスター。

591
00:25:41,190 --> 00:25:44,640
スターもちろん、手段
アドレス、別名ポインタ。

592
00:25:44,640 --> 00:25:46,200
だから、何かのアドレスです。

593
00:25:46,200 --> 00:25:47,510
それのアドレスは何ですか？

594
00:25:47,510 --> 00:25:47,760
>> まあ - 

595
00:25:47,760 --> 00:25:51,680
私は非常に見ることができる唯一の​​人です
重要な点は私が作り、または思うよ

596
00:25:51,680 --> 00:25:52,560
私が作ってるんだ。

597
00:25:52,560 --> 00:25:55,270
だから文字列 - 

598
00:25:55,270 --> 00:25:57,180
悲しいことは、私はモニターを持っている
右がどこ

599
00:25:57,180 --> 00:25:58,100
ことを見たかもしれない。

600
00:25:58,100 --> 00:26:00,990
>> すべての権利なので、文字列sとは何か
私は以前に宣言した。

601
00:26:00,990 --> 00:26:04,600
しかし、それは、少しのおかげで判明
CS50ライブラリ内の魔法、すべてこの

602
00:26:04,600 --> 00:26:08,780
時刻文字列は、文字通り持つ
charの星でし。

603
00:26:08,780 --> 00:26:11,310
星は再び意味
ポインタまたはアドレス。

604
00:26:11,310 --> 00:26:14,180
それが隣接であるという事実
言葉のcharは、それがあることを意味

605
00:26:14,180 --> 00:26:15,970
文字のアドレス。

606
00:26:15,970 --> 00:26:23,100
>> だから文字列が呼び出され得る、と私は入力した場合
H-E-L-L-Oには、取得したものになりまし提案

607
00:26:23,100 --> 00:26:27,330
文字列は文字通りのすべてを返してき
我々はむしろしたにも関わらず、今回は、

608
00:26:27,330 --> 00:26:29,980
世界を単純化しすぎ？

609
00:26:29,980 --> 00:26:33,310
実際に文字列を何を得るん
その戻り値として返すこと？

610
00:26:33,310 --> 00:26:35,830

611
00:26:35,830 --> 00:26:38,720
>> 例えば、この場合は123、。

612
00:26:38,720 --> 00:26:42,630
我々は以前の文字列を得ることを言ってきた
単に文字列のシーケンスを返します

613
00:26:42,630 --> 00:26:43,300
文字。

614
00:26:43,300 --> 00:26:44,790
しかし、それは嘘のビットです。

615
00:26:44,790 --> 00:26:48,010
方法は、文字列が実際に動作を取得
ボンネットの下にそれを取得で

616
00:26:48,010 --> 00:26:48,930
ユーザから文字列。

617
00:26:48,930 --> 00:26:51,530
それは、その文字をplops
彼または彼女は、メモリ内のタイプ。

618
00:26:51,530 --> 00:26:54,680
それは最後にバックスラッシュゼロを置く
文字のそれらの配列の。

619
00:26:54,680 --> 00:26:57,310
>> しかし、その後の文字列を何を得るん
文字通り戻る？

620
00:26:57,310 --> 00:27:02,710
それは文字通りのアドレスを返します
RAM内の非常に最初のバイトその

621
00:27:02,710 --> 00:27:04,130
その強さに使用されます。

622
00:27:04,130 --> 00:27:07,500
そしてそれはただで返すことが判明
単一のアドレス

623
00:27:07,500 --> 00:27:12,120
文字列の最初の文字であり、
全体を見つけるために十分

624
00:27:12,120 --> 00:27:12,630
文字列。

625
00:27:12,630 --> 00:27:16,930
>> 言い換えれば、文字列はありません得る
123と124と125を返します。

626
00:27:16,930 --> 00:27:19,950
それは私に長い間を与えることはありません
そのバイトのすべてのリスト

627
00:27:19,950 --> 00:27:20,740
私の文字列は使用しています。

628
00:27:20,740 --> 00:27:22,670
1ので、バックアップするすべてのバックです。

629
00:27:22,670 --> 00:27:28,160
最初のアドレスに基づいており、2、I
文字列が終わるところを見つけ出すことができます。

630
00:27:28,160 --> 00:27:29,910
どうやって？

631
00:27:29,910 --> 00:27:33,490
>> 特別なNULL文字、
末尾にゼロをスラッシュ。

632
00:27:33,490 --> 00:27:35,430
そう言い換えれば、もし
あなたの周りに渡す - 

633
00:27:35,430 --> 00:27:36,530
変数の内側 - 

634
00:27:36,530 --> 00:27:41,300
char型のアドレスを、あなたが前提としてい
任意の文字列の末尾に、任意のその

635
00:27:41,300 --> 00:27:45,040
私たち人間のように一連の文字
あなたがそれを想定した場合、文字列を考える

636
00:27:45,040 --> 00:27:48,600
そのような文字列の末尾にあり
スラッシュゼロは、あなたは黄金だ。

637
00:27:48,600 --> 00:27:52,430
いつでも見つけることができますので、
文字列の終わり。

638
00:27:52,430 --> 00:27:54,870
>> 今、本当に次に何が起こっているか
このプログラム内で？

639
00:27:54,870 --> 00:27:59,990
なぜ、このプログラムは、です
比較-0.c、バギー？

640
00:27:59,990 --> 00:28:01,690
実際に何が比較されている？

641
00:28:01,690 --> 00:28:02,420
うん？

642
00:28:02,420 --> 00:28:05,000
>> 学生：[聞こえない]。

643
00:28:05,000 --> 00:28:05,730
>> DAVIDマラン：その通り。

644
00:28:05,730 --> 00:28:08,350
それは場所を比較している
文字列の。

645
00:28:08,350 --> 00:28:12,420
ユーザーはこんにちは一度に入力しているのであれば、
私が行ったように、メモリが終わるかもしれない

646
00:28:12,420 --> 00:28:13,430
このように見える。

647
00:28:13,430 --> 00:28:18,210
再びこんにちはでユーザがタイプした場合、
しかし、再び文字列を取得する呼び出すことによって、cがある

648
00:28:18,210 --> 00:28:21,800
あなたが教えない限り、特に賢くない
コー​​ドを記述して巧妙であるためにそれ。

649
00:28:21,800 --> 00:28:22,430
>> C  - 

650
00:28:22,430 --> 00:28:23,860
より一般的とコンピュータ - 

651
00:28:23,860 --> 00:28:27,370
あなたは、こんにちは再びワードに入力した場合
あなたが得ようとしているのかを知っています。

652
00:28:27,370 --> 00:28:31,480
あなただけの二番目の配列を取得するつもりだ
メモリが、はい、ことが起こること

653
00:28:31,480 --> 00:28:35,510
H-E-L-L-O記憶等が挙げられる。

654
00:28:35,510 --> 00:28:38,240
>> それは、同じに見えるだろう
私たち人間が、このアドレス

655
00:28:38,240 --> 00:28:39,460
123ではないかもしれません。

656
00:28:39,460 --> 00:28:42,470
それはちょうどように起こるかもしれない
オペレーティング·システムは、いくつかの利用可能を有する

657
00:28:42,470 --> 00:28:45,430
場所でインスタンスのためのスペース - 

658
00:28:45,430 --> 00:28:49,820
任意の何かを言ってみましょう、
このような場所200です。

659
00:28:49,820 --> 00:28:51,620
そして、これは場所201です。

660
00:28:51,620 --> 00:28:53,060
そして、これは場所202です。

661
00:28:53,060 --> 00:28:55,730
私たちは、それはだ見当がつかない
メモリにするつもり。

662
00:28:55,730 --> 00:28:59,110
>> しかし、これが意味することは何かであるということです
s単位で最終的に保存することになるだろう？

663
00:28:59,110 --> 00:29:00,750
数123。

664
00:29:00,750 --> 00:29:04,860
、Tに格納されて何が起こっているのか
この任意の例では？

665
00:29:04,860 --> 00:29:06,300
番号200。

666
00:29:06,300 --> 00:29:11,410
そして、つまり、すべてが明らかにされ
123は200と等しくない。

667
00:29:11,410 --> 00:29:14,940
ので、この条件であれば決して
trueと評価されます。

668
00:29:14,940 --> 00:29:18,430
GET文字列が別の使用しているため
メモリのチャンク毎回。

669
00:29:18,430 --> 00:29:20,360
>> 今、我々は再びこれを見ることができます
別の例である。

670
00:29:20,360 --> 00:29:23,764
私が先に行くと、コピー0.cを開いてみましょう。

671
00:29:23,764 --> 00:29:28,770
私は、この例では、しようとしていることを主張する
試す - しかし失敗 -  2つの文字列をコピーする

672
00:29:28,770 --> 00:29:29,910
以下のとおりです。

673
00:29:29,910 --> 00:29:31,730
>> 私が何かを言うつもりです
ユーザーに。

674
00:29:31,730 --> 00:29:34,490
私はその後、取得するつもりだ
文字列とそれの呼び出し。

675
00:29:34,490 --> 00:29:36,400
そして今、私はここで、このチェックをやっている。

676
00:29:36,400 --> 00:29:37,990
私たちは、しばらく前にこのことを言及した。

677
00:29:37,990 --> 00:29:42,490
しかし、文字列の戻りはnullを取得する可能性がある場合、
別の特殊文字、または特殊

678
00:29:42,490 --> 00:29:45,050
シンボルましょうと言う。

679
00:29:45,050 --> 00:29:45,900
それはメモリ不足ましょう。

680
00:29:45,900 --> 00:29:48,970
>> 例えば、ユーザが実際にある場合
凶悪難しいと型であること

681
00:29:48,970 --> 00:29:51,220
で文字数
キーボードとヒットが入力します。

682
00:29:51,220 --> 00:29:54,580
文字のその数がちょうどできない場合
クレイジー何用のRAMに収まる

683
00:29:54,580 --> 00:29:57,820
理由は、よく文字列はともかく取得
非常によく、nullを返します。

684
00:29:57,820 --> 00:30:01,080
>> またはあなたのプログラム自体は多くのことを行っている場合
他のものとだけあり

685
00:30:01,080 --> 00:30:03,790
文字列を取得するための十分なメモリがありません
成功するために、それは終わるかもしれない

686
00:30:03,790 --> 00:30:05,240
ヌルを返すまで。

687
00:30:05,240 --> 00:30:07,160
しかしみましょうより正確に
これが何であるかにように。

688
00:30:07,160 --> 00:30:10,280
Sのデータ型が実際には何ですか？

689
00:30:10,280 --> 00:30:11,610
シャアスター。

690
00:30:11,610 --> 00:30:14,560
>> だから、今、私たちが剥がれることができ判明
ヌルの層をバックアップします。

691
00:30:14,560 --> 00:30:17,500
結局、ヌルは - はい、明らかに
特殊記号。

692
00:30:17,500 --> 00:30:19,190
しかし、それは本当に何ですか？

693
00:30:19,190 --> 00:30:25,220
本当に、ヌルは単なる記号であることを我々
人間は同様にゼロを表現するために使用します。

694
00:30:25,220 --> 00:30:29,010
>> Cの著者、およびコンピュータだから
より一般的には、数年前に決定した

695
00:30:29,010 --> 00:30:30,010
つまり、あなたは何を知っています。

696
00:30:30,010 --> 00:30:34,850
なぜ我々は無いことを保証するものではありません
データは、これまで、これまでに、これまでです

697
00:30:34,850 --> 00:30:36,730
さようならゼロで保管？

698
00:30:36,730 --> 00:30:39,610
実際にも、私の任意の例では、
前に、私はナンバリング起動しませんでした

699
00:30:39,610 --> 00:30:40,390
ゼロでバイト。

700
00:30:40,390 --> 00:30:41,540
私は1から開始しました。

701
00:30:41,540 --> 00:30:44,950
私は世界の人々を知っていたので
ゼロを予約することにしました

702
00:30:44,950 --> 00:30:47,970
誰のRAMなどのバイト
何か特別なもの。

703
00:30:47,970 --> 00:30:52,020
>> その理由は、いつでもあなたがしたい
何かがうまくいかなかったことを通知

704
00:30:52,020 --> 00:30:55,960
アドレスに関して、返さ
ヌル - そうでなければゼロとして知られて - 

705
00:30:55,960 --> 00:30:59,410
そして、あなたは何があることを知っていないので、
明らかに、アドレスがゼロでデータを合法

706
00:30:59,410 --> 00:31:00,400
それはエラーを意味します。

707
00:31:00,400 --> 00:31:04,080
そして、それは、我々は、慣例により、チェック理由です
ヌルとリターン何かのため

708
00:31:04,080 --> 00:31:06,260
これらのケースの1つのような。

709
00:31:06,260 --> 00:31:09,300
>> 我々は今、下にスクロールしそうだとすれば、これはただです
その後いくつかのエラーチェック、念の

710
00:31:09,300 --> 00:31:10,610
何かが[と間違っていた？保釈？]

711
00:31:10,610 --> 00:31:13,470
完全にとプログラムを終了
早期に返すことによって。

712
00:31:13,470 --> 00:31:19,030
この行は、現在書き直すことができ
このように、これは何を意味する？

713
00:31:19,030 --> 00:31:23,155
左側に、私に別のものを与える
文字へのポインタ、それT呼ぶ。

714
00:31:23,155 --> 00:31:26,935
私はベース、Tの内側に何を格納しています
この1行のコードで？

715
00:31:26,935 --> 00:31:30,950

716
00:31:30,950 --> 00:31:32,170
>> 私は場所を格納しています。

717
00:31:32,170 --> 00:31:34,742
具体的場所
そのsであった。

718
00:31:34,742 --> 00:31:39,000
だからユーザーはこんにちはで入力している場合、および
最初の挨拶が終わるために起こること

719
00:31:39,000 --> 00:31:42,567
ここでは、その後数123です
取得から戻って来ることを行って

720
00:31:42,567 --> 00:31:43,810
文字列と保存される - 

721
00:31:43,810 --> 00:31:44,780
先ほど言ったように - 

722
00:31:44,780 --> 00:31:45,440
のである。

723
00:31:45,440 --> 00:31:50,560
>> 私は今まで別のポインタを宣言する場合
charおよびそれを呼び出すtは、数字は何ですか

724
00:31:50,560 --> 00:31:53,940
文字通りで終わるつもり
話によるとT？

725
00:31:53,940 --> 00:31:55,420
123だから。

726
00:31:55,420 --> 00:32:00,310
>> だから技術的には今のと両方
tは正確に指している

727
00:32:00,310 --> 00:32:02,410
メモリの同じチャンク。

728
00:32:02,410 --> 00:32:06,140
だから私はここでやろうとしているものに気づく
このプログラムにバグがあることを証明する。

729
00:32:06,140 --> 00:32:08,820
>> と最初に私は、請求するつもりです
印刷fは、活かし

730
00:32:08,820 --> 00:32:10,080
文字列のコピー。

731
00:32:10,080 --> 00:32:11,660
それから私は少しを行うつもりだ
エラーチェック。

732
00:32:11,660 --> 00:32:12,160
私は確認するつもりです。

733
00:32:12,160 --> 00:32:16,710
Let 'sは、文字列tがであることを確認してください
少なくとも長さがゼロよりも大きい、

734
00:32:16,710 --> 00:32:19,190
ので、いくつかの文字がそこにあり
実際に活用する。

735
00:32:19,190 --> 00:32:22,840
>> そして、あなたはこれを思い出すかもしれません
前の例から。

736
00:32:22,840 --> 00:32:25,630
上位2  - にある
ctype.hファイル。

737
00:32:25,630 --> 00:32:30,800
Tブラケットゼロの私にゼロを与えます
文字列tの文字。

738
00:32:30,800 --> 00:32:34,360
と同じ値の上限と2、
もちろん、それは大文字に変換します。

739
00:32:34,360 --> 00:32:38,230
>> だから直感的に、これはラインを強調した
コー​​ドの最初を大文字にされる

740
00:32:38,230 --> 00:32:40,250
Tの文字。

741
00:32:40,250 --> 00:32:44,485
しかし、それは、直感的に、活用していない
s内の最初の文字。

742
00:32:44,485 --> 00:32:48,130
しかし、あなたは私が何を、先に考えている場合
私はこのプログラムを実行するときに表示する約

743
00:32:48,130 --> 00:32:54,220
そして、オリジナルの両方をプリントアウト
sであり、所謂コピーのT？

744
00:32:54,220 --> 00:32:55,350
>> 彼らは、実際には同じことになるだろう。

745
00:32:55,350 --> 00:32:56,600
そして、なぜ、彼らは同じことを行っている？

746
00:32:56,600 --> 00:32:58,970

747
00:32:58,970 --> 00:33:01,020
彼らは両方を指している
まったく同じこと。

748
00:33:01,020 --> 00:33:01,610
だから、これを行うてみましょう。

749
00:33:01,610 --> 00:33:03,160
>> コピーはゼロにします。

750
00:33:03,160 --> 00:33:04,070
これは、[OK]をコンパイルします。

751
00:33:04,070 --> 00:33:06,500
私はコピーゼロを実行してみましょう。

752
00:33:06,500 --> 00:33:10,110
私のタイプのハローのようなものにしましょう
すべて小文字で入力し、Enterを押してください。

753
00:33:10,110 --> 00:33:16,520
そしてそれは主張して、元の両方
およびコピーは確かに同じです。

754
00:33:16,520 --> 00:33:17,920
>> だから何が本当にここで起こった？

755
00:33:17,920 --> 00:33:20,100
私はちょうどこの絵を描画しましょう
で話をする

756
00:33:20,100 --> 00:33:21,340
わずかに異なる方法。

757
00:33:21,340 --> 00:33:26,060
何が本当にの下で起こっている
私のような何かを宣言するフード

758
00:33:26,060 --> 00:33:30,410
charの開始秒、または文字列s、
私はポインタを取得しています - 

759
00:33:30,410 --> 00:33:33,090
これは4バイトであることを起こる
CS50アプライアンスで

760
00:33:33,090 --> 00:33:34,410
とコンピュータの多くである。

761
00:33:34,410 --> 00:33:36,008
そして、私はこのSを呼ぶつもりです。

762
00:33:36,008 --> 00:33:39,810
そして、これは、現在持って
いくつかの未知の値。

763
00:33:39,810 --> 00:33:43,900
>> あなたがいない限り、変数を宣言するとき
自分では、そこに誰が価値を置く

764
00:33:43,900 --> 00:33:44,570
そこに何を知っています。

765
00:33:44,570 --> 00:33:48,110
これは、いくつかのランダムシーケンスのかもしれません
前回の実行からのビット。

766
00:33:48,110 --> 00:33:52,490
だから私は、コードの私のラインで取得を行うとき
その後、文字列、およびリターンを保存

767
00:33:52,490 --> 00:33:54,800
s内の値は、何とか文字列を取得する - 

768
00:33:54,800 --> 00:33:58,520
そして我々は最終的に取得する方法裏よ
文字作品は、何とか割り当て

769
00:33:58,520 --> 00:34:00,480
おそらく見え配列
このようなビット。

770
00:34:00,480 --> 00:34:05,390
H-E-L-L-O、バックスラッシュゼロ。

771
00:34:05,390 --> 00:34:09,510
>> これがアドレスであると仮定してみましょう
123ただ最初の一貫性。

772
00:34:09,510 --> 00:34:13,000
そこらで、文字列のリターンを得る
そこのラインを強調し、それを返します

773
00:34:13,000 --> 00:34:15,000
我々が言った数字、123。

774
00:34:15,000 --> 00:34:17,420
だから、何が本当にここに秒の内部に入る？

775
00:34:17,420 --> 00:34:26,590
>> まあ、実際に何を行く
内部のSのは123です。

776
00:34:26,590 --> 00:34:29,250
しかし、率直に言って、私は少しを得て
、これらのアドレスのすべてで混乱

777
00:34:29,250 --> 00:34:30,320
これらの任意の数字がすべて。

778
00:34:30,320 --> 00:34:32,290
123、124、127。

779
00:34:32,290 --> 00:34:34,570
それでは、実際に簡素化させて
世界が少し。

780
00:34:34,570 --> 00:34:38,800
>> 我々は率直に言って、ポインタについて話すときに
一体気に私たち人間が、

781
00:34:38,800 --> 00:34:39,870
物事はメモリ内にある？

782
00:34:39,870 --> 00:34:41,080
それは完全に任意です。

783
00:34:41,080 --> 00:34:43,370
それはどのように依存するように起こっている
多くのユーザーが持っているRAM。

784
00:34:43,370 --> 00:34:46,590
それはその日にに依存するだろう
あなたは、おそらく、プログラムを実行し、

785
00:34:46,590 --> 00:34:48,250
何を入力ユーザーがあなたを与える。

786
00:34:48,250 --> 00:34:50,060
私たちは、重要でない細部に住居している。

787
00:34:50,060 --> 00:34:54,230
>> だから、抽象的なの離れて聞かせていると言う
あなたはこのようなコードの行を実行すると、

788
00:34:54,230 --> 00:34:57,320
charの星sがリターンを得る
GET文字列の値。

789
00:34:57,320 --> 00:35:02,720
なぜ我々だけではなく、私たち描画しない
それはあたかも、ポインタを呼び出し続ける

790
00:35:02,720 --> 00:35:04,140
何を指して？

791
00:35:04,140 --> 00:35:07,000
だから私は、その、今までの主張
ポインタがあります - 

792
00:35:07,000 --> 00:35:08,480
ボンネットの下に、それはアドレスです。

793
00:35:08,480 --> 00:35:11,330
しかし、それだけを指している
内の最初のバイト

794
00:35:11,330 --> 00:35:12,780
文字列が返されていること。

795
00:35:12,780 --> 00:35:16,710
>> 私は今ここにコードに戻ると、
何がこのラインで起こっているのでしょうか？

796
00:35:16,710 --> 00:35:20,020
さて、今、この強調表示された行で、
私は明らかに別の宣言だ

797
00:35:20,020 --> 00:35:21,070
Tと呼ばれる変数。

798
00:35:21,070 --> 00:35:25,700
しかし、それはまた、ポインタだので、私は行くよ
正確な、理論的には、としてそれを描画する

799
00:35:25,700 --> 00:35:26,710
同じサイズのボックス。

800
00:35:26,710 --> 00:35:28,160
そして、私はそれがt呼ぶつもりです。

801
00:35:28,160 --> 00:35:33,500
>> そして今、我々は再びコードに戻った場合、
とき、tのI店舗sの内部、

802
00:35:33,500 --> 00:35:36,920
私は技術的には何です
Tの内側に入れて？

803
00:35:36,920 --> 00:35:39,350
まあ技術的には、この
数123だった。

804
00:35:39,350 --> 00:35:42,270
だから、本当に私が執筆されるべきである
そこに数123。

805
00:35:42,270 --> 00:35:43,900
しかし、のは、それより高いレベルを取ることができます。

806
00:35:43,900 --> 00:35:48,090
T、それだけでポインタである場合、
直感的に、そういうことだ。

807
00:35:48,090 --> 00:35:49,800
それがされているすべてのことです
そこに格納されている。

808
00:35:49,800 --> 00:35:54,970
>> だから今最後の興味深いラインにおける
私は実際に取り掛かるコードの

809
00:35:54,970 --> 00:36:00,680
ゼロの文字を大文字に
Tで、何が起こっている？

810
00:36:00,680 --> 00:36:06,310
まあ、Tブラケットゼロが今指している
にどのような文字、おそらく？

811
00:36:06,310 --> 00:36:07,460
>> それは時間を指しています。

812
00:36:07,460 --> 00:36:08,870
なぜならTブラケットゼロ - 

813
00:36:08,870 --> 00:36:12,490
リコールは、これは、古い構文です。 Tブラケット
tは、tの文字列である場合は、ゼロはただ意味

814
00:36:12,490 --> 00:36:15,590
ブラケットゼロがゼロになって意味
その強さの文字。

815
00:36:15,590 --> 00:36:18,650
本当に意味だから何
この配列に行くされて - 

816
00:36:18,650 --> 00:36:21,520
とはい、これは、123かもしれない
これは124かもしれません。

817
00:36:21,520 --> 00:36:22,790
しかし、それはすべての相対だ、覚えておいてください。

818
00:36:22,790 --> 00:36:25,640
配列の話をするたびに、我々は持っている
について話しての利点

819
00:36:25,640 --> 00:36:27,000
相対的な指標。

820
00:36:27,000 --> 00:36:31,120
>> そして今、我々は単に仮定することができます
そのTブラケットゼロがhである。

821
00:36:31,120 --> 00:36:35,090
だから私は、その上に2がアッパー呼び出す場合、それが何
実際に活用されてやって

822
00:36:35,090 --> 00:36:38,290
大文字Hに小文字のhの
しかし、もちろん、sは何ですか？

823
00:36:38,290 --> 00:36:41,010
これは、同じくそ文字列を指しています。

824
00:36:41,010 --> 00:36:44,200
>> だから、これは何が起こっているなら、すべての
このコードで、これまで。

825
00:36:44,200 --> 00:36:45,960
だから含意は次に何ですか？

826
00:36:45,960 --> 00:36:48,300
我々は、これらの2つの問題をどのように修正すればよい？

827
00:36:48,300 --> 00:36:50,870
どのように我々は実際の文字列と比較するのですか？

828
00:36:50,870 --> 00:36:53,720
>> まあ直感的に、どのようにだろう
次の2つを比較して取り掛かる

829
00:36:53,720 --> 00:36:55,090
真の平等のための文字列？

830
00:36:55,090 --> 00:36:58,920

831
00:36:58,920 --> 00:37:00,750
>> 2場合、それはどういう意味ですか
文字列は等しい？

832
00:37:00,750 --> 00:37:04,330
はっきりしない自分のアドレスがあることを
それが低いだから、メモリに等しく

833
00:37:04,330 --> 00:37:06,590
レベルの実装の詳細。

834
00:37:06,590 --> 00:37:08,360
すべての文字は同じです。

835
00:37:08,360 --> 00:37:12,810
だから私は提案してみましょう、と私が紹介させて
compare.cのバージョン1で

836
00:37:12,810 --> 00:37:14,970
ここで、いわゆる1.Cを比較します。

837
00:37:14,970 --> 00:37:19,590
>> 私は、我々はまだ得ることを提案しましょう
Sと呼ばれるポインタ、それに保管

838
00:37:19,590 --> 00:37:20,610
取得する文字列の値を返す。

839
00:37:20,610 --> 00:37:21,750
Tと同じことをしてみましょう。

840
00:37:21,750 --> 00:37:23,230
だからコードのどれも違いはありません。

841
00:37:23,230 --> 00:37:25,420
私は少しを追加するつもりだ
今すぐチェックを複数のエラー。

842
00:37:25,420 --> 00:37:29,390
だから今我々は戻って剥離の一種だということ
どんな文字列のCS50でこの層

843
00:37:29,390 --> 00:37:33,520
実際には、我々はより多くの肛門にする必要があり
我々は乱用しないことを確認することについて

844
00:37:33,520 --> 00:37:35,330
nullのような無効な値。

845
00:37:35,330 --> 00:37:36,440
>> だから、僕は確認するつもりです。

846
00:37:36,440 --> 00:37:41,490
sが等しく、nullをせず、tがない場合は
等しいnullの場合は、それは我々がOKしていることを意味します。

847
00:37:41,490 --> 00:37:44,460
文字列が取得台無しなかっゲット
これらの文字列のいずれか。

848
00:37:44,460 --> 00:37:51,270
そして、あなたは多分、今推測することができるもの
STR CMPはおそらくのでしょうか？

849
00:37:51,270 --> 00:37:52,000
文字列を比較。

850
00:37:52,000 --> 00:37:55,470
>> あなたは前にJavaでプログラムをしましたのであれば、
これは内のequalsメソッドと同様です。

851
00:37:55,470 --> 00:37:56,490
文字列クラス。

852
00:37:56,490 --> 00:37:57,890
しかし、いない人のために
前にプログラム、

853
00:37:57,890 --> 00:37:59,320
これはただのCの関数である。

854
00:37:59,320 --> 00:38:02,180
それはに来て起こる
string.hで呼ばれるファイル。

855
00:38:02,180 --> 00:38:03,830
それが宣言されたところです。

856
00:38:03,830 --> 00:38:05,110
>> と文字列を比較 - 

857
00:38:05,110 --> 00:38:07,530
私は、その使用を実際に忘れて、
しかし、それを気にすることはありません。

858
00:38:07,530 --> 00:38:10,470
私たちにできることを思い出してください
男は、比較をかき混ぜる。

859
00:38:10,470 --> 00:38:12,590
そして、これは起動しようとしている
Linuxのプログラマーマニュアル。

860
00:38:12,590 --> 00:38:14,060
そしてそれは、率直に言って、少し不可解だ。

861
00:38:14,060 --> 00:38:15,270
しかし、私はうん、ことをここで見ることができます。

862
00:38:15,270 --> 00:38:17,570
私はstring.hでを含める必要があります。

863
00:38:17,570 --> 00:38:20,590
>> そしてそれは、 "説明の下ここで言う
文字列比較関数を比較

864
00:38:20,590 --> 00:38:24,560
S1とS2の二つの文字列。 "とS1
とS2は明らかに2アール

865
00:38:24,560 --> 00:38:26,120
引数が渡された

866
00:38:26,120 --> 00:38:28,650
私は本当に覚えていないのか
constのですが、今では気付く - 

867
00:38:28,650 --> 00:38:31,480
いつ、あなたはすでにこれを見たことがあるかもしれませ
あなたがあれば、manページを使用してきた

868
00:38:31,480 --> 00:38:32,390
それをすべて持っている - 

869
00:38:32,390 --> 00:38:36,220
charの星はただ同義であることを
文字列を持つ。

870
00:38:36,220 --> 00:38:40,440
>> だから、二つの文字列、S1とを比較し、
S2、そしてそれは以下の整数を返し

871
00:38:40,440 --> 00:38:44,930
小さいか等しいかゼロより大きい
S1があることが、それぞれ、検出された場合

872
00:38:44,930 --> 00:38:47,450
未満、あるいは一致、または
S2よりも大きくなる。

873
00:38:47,450 --> 00:38:51,220
それはちょうど言って、非常に複雑な方法です
その文字列はリターンを比較する

874
00:38:51,220 --> 00:38:55,760
ゼロ二つの文字列が直感的である場合
で同一で、文字

875
00:38:55,760 --> 00:38:57,120
文字の文字。

876
00:38:57,120 --> 00:38:59,970
>> 場合は負の数を返します。
S、アルファベット順には、想定される

877
00:38:59,970 --> 00:39:01,010
T前に来ています。

878
00:39:01,010 --> 00:39:05,300
または正の数は、次の場合に返されます
sがtの後に来ることになっている

879
00:39:05,300 --> 00:39:06,170
アルファベット順に。

880
00:39:06,170 --> 00:39:08,360
だから、この単純な機能を持つ、可能性
あなたは、例えば、ソート

881
00:39:08,360 --> 00:39:09,770
言葉の全体の束？

882
00:39:09,770 --> 00:39:13,984
>> したがって、この新しいバージョンでは、私は行くよ
先に行くとコンペア1を作る。

883
00:39:13,984 --> 00:39:15,750
ドットスラッシュが1を比較します。

884
00:39:15,750 --> 00:39:18,030
私はすべて小文字でこんにちはを入力します。

885
00:39:18,030 --> 00:39:20,300
私はこんにちはを入力するつもりです
すべて小文字で再び。

886
00:39:20,300 --> 00:39:23,340
そして、ありがたいことに今では実現
私は同じことを入力しました。

887
00:39:23,340 --> 00:39:27,520
>> その間、私は下にこんにちはに入力した場合
ケースと大文字でハローと

888
00:39:27,520 --> 00:39:29,710
私が入力し、それらを比較
異なるもの。

889
00:39:29,710 --> 00:39:32,530
だけでなく、アドレスがあるので
異なるが、我々は比較している

890
00:39:32,530 --> 00:39:35,350
何度も何度も別の文字。

891
00:39:35,350 --> 00:39:37,320
>> まあのは、1つを行って修正してみましょう
現在、他の問題。

892
00:39:37,320 --> 00:39:41,590
私はバージョンの1つを開いてみましょう
今アドレスコピー、

893
00:39:41,590 --> 00:39:42,900
この問題は次の通り。

894
00:39:42,900 --> 00:39:45,650
、この1つは見ることになるだろう
少し複雑。

895
00:39:45,650 --> 00:39:49,320
しかし、あなたはどのような問題を考える場合、私たち
解決する必要があり、うまくいけばこれは次のようになります

896
00:39:49,320 --> 00:39:51,870
今ちょうど瞬間にオフにします。

897
00:39:51,870 --> 00:39:57,280
>> したがって、この最初の行、charをスタートT、で
普通の言葉では、誰かが提案することができ

898
00:39:57,280 --> 00:39:59,450
この行がここで何を意味？

899
00:39:59,450 --> 00:40:01,050
シャア星tは、やっていることは何ですか？

900
00:40:01,050 --> 00:40:06,660

901
00:40:06,660 --> 00:40:07,210
>> グッド。

902
00:40:07,210 --> 00:40:09,500
一部へのポインタを作成
メモリのスポット。

903
00:40:09,500 --> 00:40:10,930
そして、私はそれを少し改良しましょう​​。

904
00:40:10,930 --> 00:40:17,180
格納する変数を宣言
単にメモリ内のいくつかのcharのアドレス、

905
00:40:17,180 --> 00:40:18,480
もう少し適切になるように。

906
00:40:18,480 --> 00:40:21,210
>> [OK]を、ので、今右側に、私がしました
これらの関数のいずれかを見たことがない

907
00:40:21,210 --> 00:40:22,660
前に、malloc関数。

908
00:40:22,660 --> 00:40:26,980
しかし、それは何を意味するのでしょうか？

909
00:40:26,980 --> 00:40:28,050
メモリの割り当て。

910
00:40:28,050 --> 00:40:29,410
メモリの割り当て。

911
00:40:29,410 --> 00:40:33,050
>> だから、我々は、これまで、判明
本当に強力な方法がありませんでした

912
00:40:33,050 --> 00:40:36,210
オペレーティング·システムに求め、
私にいくつかのメモリを与える。

913
00:40:36,210 --> 00:40:39,980
むしろ、我々は今呼ばれる機能を持って
まさにそれを行いますmalloc関数。

914
00:40:39,980 --> 00:40:42,960
これはのビットであるにもかかわらず
気晴らし今、気付くのその

915
00:40:42,960 --> 00:40:46,200
2括弧の間にある
ただ数字になるだろう。

916
00:40:46,200 --> 00:40:48,510
私は質問に入力した場所
マークは、番号を指定できます。

917
00:40:48,510 --> 00:40:51,020
>> そして、その数は、意味
私に10バイトを与える。

918
00:40:51,020 --> 00:40:52,320
私に20バイトを与える。

919
00:40:52,320 --> 00:40:53,820
私に100バイトを与える。

920
00:40:53,820 --> 00:40:56,500
とmallocがために最善を尽くします
オペレーティングシステムに依頼 - 

921
00:40:56,500 --> 00:40:57,630
この場合はLinuxを、 - 

922
00:40:57,630 --> 00:40:59,630
ねえ、彼らの100バイト
利用可能なRAMの？

923
00:40:59,630 --> 00:41:04,320
もしそうなら、が私にそれらのバイトを返す
うちのアドレスを返す

924
00:41:04,320 --> 00:41:06,610
おそらくそれらのバイト、？

925
00:41:06,610 --> 00:41:07,610
非常に最初のもの。

926
00:41:07,610 --> 00:41:10,460
>> だからここにあまりにも - これは支配的である
C、あなたがしている任意の時間内に

927
00:41:10,460 --> 00:41:11,680
アドレスを扱う？

928
00:41:11,680 --> 00:41:15,830
あなたは、ほとんどの場合を扱っている
最初にそのようなアドレス、どんなに大きな

929
00:41:15,830 --> 00:41:19,490
あなたがされているメモリのチャンク
いわば、戻って手渡した。

930
00:41:19,490 --> 00:41:20,880
>> だからここでのダイビングみましょう。

931
00:41:20,880 --> 00:41:23,940
私はどのように割り当てしようとしています
正確に何バイト、？

932
00:41:23,940 --> 00:41:24,080
まあ。

933
00:41:24,080 --> 00:41:26,090
Sの文字列の長さ - レッツ
具体的な例を行う。

934
00:41:26,090 --> 00:41:30,700
sが何、こんにちは、H-E-L-L-Oである場合
Sの文字列の長さ、明らかに？

935
00:41:30,700 --> 00:41:32,010
だから、5です。

936
00:41:32,010 --> 00:41:34,590
しかし、私はそれにプラス1をやって、なぜですか？

937
00:41:34,590 --> 00:41:37,700
なぜ私は6バイトをしたいですか
代わりに5の？

938
00:41:37,700 --> 00:41:38,790
ヌル文字。

939
00:41:38,790 --> 00:41:41,210
>> 私はこれをオフのままにしたくない
特殊ヌル文字。

940
00:41:41,210 --> 00:41:45,160
ので、私はハローのコピーを作成した場合
ただ、H-E-L-L-Oを行うが、私は入れてはいけません

941
00:41:45,160 --> 00:41:50,160
その特殊文字は、コンピュータ
偶然、バックスラッシュが、持っていない可能性があり

942
00:41:50,160 --> 00:41:51,730
私のためにそこにゼロ。

943
00:41:51,730 --> 00:41:55,570
そして、私が把握しようとしている場合
コピーの長さは、私は、と思うかもしれません

944
00:41:55,570 --> 00:41:59,360
それは、20文字、または億だ
私は決して起こらない場合、文字の長さ

945
00:41:59,360 --> 00:42:01,050
スラッシュゼロをヒットする。

946
00:42:01,050 --> 00:42:05,780
>> だから我々は、6バイトを格納する必要があります
H-E-L-L-O、バックスラッシュゼロ。

947
00:42:05,780 --> 00:42:07,870
そして、これはただです
スーパーアナルすること。

948
00:42:07,870 --> 00:42:10,700
私は何を忘れているとし
文字の大きさである。

949
00:42:10,700 --> 00:42:12,020
我々は、それが1バイトだと言っておいてください。

950
00:42:12,020 --> 00:42:12,860
そして、それは通常。

951
00:42:12,860 --> 00:42:15,425
理論的には、何かかもしれ
別のMacや上に、異なる

952
00:42:15,425 --> 00:42:16,250
別のPC。

953
00:42:16,250 --> 00:42:19,650
>> この演算子があるうちだからそれは回り
sizeof演算子と呼ばれることは、それを渡すと

954
00:42:19,650 --> 00:42:22,680
データ型の名前 - 様
char型、またはint型、またはフロート - 

955
00:42:22,680 --> 00:42:26,930
それはどのように多くの、動的に、あなたを教えてくれる
charがこれに占めるバイト

956
00:42:26,930 --> 00:42:28,090
特定のコンピュータ。

957
00:42:28,090 --> 00:42:31,360
>> だから、これは事実だけです。
回1を言ってような

958
00:42:31,360 --> 00:42:32,440
全然時間は何もありません。

959
00:42:32,440 --> 00:42:36,340
しかし、私はちょうどスーパー肛門であるためにそれをやって、
念のためにcharが異なること

960
00:42:36,340 --> 00:42:40,610
コンピュータ対地雷、この方法で
数学はいつもチェックアウトするために起こっている。

961
00:42:40,610 --> 00:42:43,720
>> 最後に、ダウンしてここで私は、nullをチェック
それは常に良い習慣です - 再び、

962
00:42:43,720 --> 00:42:44,920
我々はポインタを扱っているいつでも。

963
00:42:44,920 --> 00:42:47,520
malloc関数は、与えることができなかった場合
私6不戦勝 - です

964
00:42:47,520 --> 00:42:49,210
ありそうもないが、念のため - 

965
00:42:49,210 --> 00:42:50,730
すぐにいずれかを返す。

966
00:42:50,730 --> 00:42:53,290
そして今、先に行くと、コピー
文字列は次のとおり。

967
00:42:53,290 --> 00:42:57,240
そして、これは、おなじみの構文です
異なる役割にもかかわらず。

968
00:42:57,240 --> 00:43:01,210
>> 私が先に行くと、文字列を取得するつもりだ
sの長さとnに格納します。

969
00:43:01,210 --> 00:43:06,620
私はその後、私は等しいから反復するつもりです
、までゼロとnを含む

970
00:43:06,620 --> 00:43:08,410
より大きいか等しい。

971
00:43:08,410 --> 00:43:13,540
各反復で、私が置かれるように
i番目の中のSのi番目の文字

972
00:43:13,540 --> 00:43:15,380
Tの文字。

973
00:43:15,380 --> 00:43:18,190
>> だから、本当に下に何が起こっているのか
ここにフード？

974
00:43:18,190 --> 00:43:22,140
さて、この場合、例えば、sです - 

975
00:43:22,140 --> 00:43:26,400
と私は言葉H-E-L-L-Oで入力した
とバックスラッシュゼロはそこだ。

976
00:43:26,400 --> 00:43:29,020
そして再び、これはsがここで指している。

977
00:43:29,020 --> 00:43:30,830
そして今ここtである。

978
00:43:30,830 --> 00:43:34,860
>> そして、これはここで指している
メモリのコピー、右？

979
00:43:34,860 --> 00:43:37,340
malloc関数は私の全体を与えている
メモリのチャンク。

980
00:43:37,340 --> 00:43:41,440
私は何最初は知らない
これらの場所のいずれかである。

981
00:43:41,440 --> 00:43:44,340
だから私は、これらのように考えるつもりです
疑問符の全体の束。

982
00:43:44,340 --> 00:43:50,190
>> しかし、すぐに私は、ゼロから始めるとループ
S、Tの長を通じて、最大で

983
00:43:50,190 --> 00:43:52,790
ブラケットゼロとtブラケット1  - 

984
00:43:52,790 --> 00:43:55,080
そして私は今、これを置くよ
オーバーヘッドで - 

985
00:43:55,080 --> 00:44:04,190
Tブラケットゼロとsブラケットゼロ意味
私は、コピーするつもりだ

986
00:44:04,190 --> 00:44:09,875
ここで反復して、H、E-L-L-O。
プラス、私はプラスでしたので、

987
00:44:09,875 --> 00:44:12,370
1、バックスラッシュゼロ。

988
00:44:12,370 --> 00:44:19,060
>> だから今、コンペア1.Cの場合には、
最後に、私はプリントアウトする場合

989
00:44:19,060 --> 00:44:24,760
Tの大文字、我々はすべき
sが変更されていないことがわかります。

990
00:44:24,760 --> 00:44:26,090
私は今、先に行くと、これをやってみましょう。

991
00:44:26,090 --> 00:44:28,630
だからCOPY1を行います。

992
00:44:28,630 --> 00:44:30,860
ドットスラッシュCOPY1。

993
00:44:30,860 --> 00:44:33,670
私はこんにちは、Enterキーを入力するつもりです。

994
00:44:33,670 --> 00:44:37,430
そして今、コピーだけに気付く
資産計上されています。

995
00:44:37,430 --> 00:44:40,890
私は本当に持っているので、2
メモリのチャンク。

996
00:44:40,890 --> 00:44:44,390
>> 残念なことに、いくつかのかなりを行うことができます
ここで悪いとかなり危険なもの。

997
00:44:44,390 --> 00:44:49,290
私は今ここに例をプルアップしましょう​​、
それは私たちにいくつかの例を示し

998
00:44:49,290 --> 00:44:51,540
異なる行。

999
00:44:51,540 --> 00:44:56,040
だから直感的にここで、最初の行
コー​​ド、int型星xが、宣言している

1000
00:44:56,040 --> 00:44:57,340
Xと呼ばれる変数。

1001
00:44:57,340 --> 00:44:58,810
とデータ型は何ですか
その変数の？

1002
00:44:58,810 --> 00:45:01,820

1003
00:45:01,820 --> 00:45:04,290
その変数のデータ型は何ですか？

1004
00:45:04,290 --> 00:45:06,980
それは接戦ではなかった。

1005
00:45:06,980 --> 00:45:08,350
>> データ型はint型星である。

1006
00:45:08,350 --> 00:45:12,600
だからそれが何を意味するのでしょうか？ X意志
int型のアドレスを格納します。

1007
00:45:12,600 --> 00:45:13,520
分かりきったことだ。

1008
00:45:13,520 --> 00:45:16,220
Yは、保存するために起こっている
int型のアドレス。

1009
00:45:16,220 --> 00:45:18,390
三行目は何ですか
コー​​ドそこやって？

1010
00:45:18,390 --> 00:45:21,850
それはどのように多くを割り当てている
バイト、最も可能性が高い？

1011
00:45:21,850 --> 00:45:22,350
四つ。

1012
00:45:22,350 --> 00:45:25,460
なぜならint型の大きさである
一般的には4の4、malloc関数は、与え

1013
00:45:25,460 --> 00:45:29,950
私に背中のチャンクのアドレス
メモリ、そのバイトでの最初の

1014
00:45:29,950 --> 00:45:32,110
Xに今保存。

1015
00:45:32,110 --> 00:45:34,410
>> 今、私たちは、すぐに少し移動している。

1016
00:45:34,410 --> 00:45:35,760
すた×は何を意味する？

1017
00:45:35,760 --> 00:45:38,480

1018
00:45:38,480 --> 00:45:42,590
これは、そのアドレスに行くことを意味し
とどのような数があり置く？

1019
00:45:42,590 --> 00:45:43,870
そこに番号42を置く。

1020
00:45:43,870 --> 00:45:47,590
スターyはYで何に行くことを意味し
そしてそこに13番を置く。

1021
00:45:47,590 --> 00:45:48,600
>> しかし、ちょっと待って。

1022
00:45:48,600 --> 00:45:51,640
一瞬でyは何ですか？

1023
00:45:51,640 --> 00:45:54,950
どのアドレスがyの保存している？

1024
00:45:54,950 --> 00:45:55,770
我々は右、分からないのですか？

1025
00:45:55,770 --> 00:45:59,230
我々は、一度割り当てを使用したことがない
Yが関与する演算子。

1026
00:45:59,230 --> 00:46:03,370
だからyはとしての2行目に宣言された
コー​​ドは、単にいくつかのゴミ値、大きい

1027
00:46:03,370 --> 00:46:04,760
疑問符は、いわば。

1028
00:46:04,760 --> 00:46:07,230
これは、ランダムに指すことができます
メモリ内の何に、どの

1029
00:46:07,230 --> 00:46:08,340
一般的には悪いです。

1030
00:46:08,340 --> 00:46:13,540
>> だからできるだけ早く我々はそこにその行を打つように、
星yを13に等しく、何か悪いこと、

1031
00:46:13,540 --> 00:46:17,220
非常に悪い何かについてです
Binkyのに起こるように。

1032
00:46:17,220 --> 00:46:25,810
だから、最後まで何が起こっているのか見てみましょう
この分でここBINKYに起こっ

1033
00:46:25,810 --> 00:46:26,200
またはそう見える。

1034
00:46:26,200 --> 00:46:26,490
>> [ビデオの再生]

1035
00:46:26,490 --> 00:46:26,745
>>  - ねえ、Binkyの。

1036
00:46:26,745 --> 00:46:27,000
起きて。

1037
00:46:27,000 --> 00:46:29,296
これは、ポインタの楽しみのための時間です。

1038
00:46:29,296 --> 00:46:30,680
>>  - どのようなそれはだ？

1039
00:46:30,680 --> 00:46:31,980
ポインタについて学ぶ？

1040
00:46:31,980 --> 00:46:34,010
ああ、グッディ。

1041
00:46:34,010 --> 00:46:37,220
>> まあ、開始するために、私たちはしていると思います
カップルのポインタが必要になる。

1042
00:46:37,220 --> 00:46:37,930
>> -OK。

1043
00:46:37,930 --> 00:46:41,650
このコードには、2つのポインタを割り当てる
これは、整数に指すことができます。

1044
00:46:41,650 --> 00:46:43,760
>> -OK、まあ、私には、2つのポインタを参照してください。

1045
00:46:43,760 --> 00:46:45,850
しかし、彼らはされていないようです
何を指している。

1046
00:46:45,850 --> 00:46:46,490
>>  - そうです。

1047
00:46:46,490 --> 00:46:48,630
最初は、ポインタはない
何を指している。

1048
00:46:48,630 --> 00:46:51,700
それらが指し示すものは呼ばれています
指示先、最大それらを設定することです

1049
00:46:51,700 --> 00:46:52,850
別のステップ。

1050
00:46:52,850 --> 00:46:53,740
>>  - ああ、右、右。

1051
00:46:53,740 --> 00:46:54,500
私はそれを知っていた。

1052
00:46:54,500 --> 00:46:56,270
指示先は別のものです。

1053
00:46:56,270 --> 00:46:58,553
それでは、どのように指示先を割り当てるには？

1054
00:46:58,553 --> 00:46:59,480
>> -OK。

1055
00:46:59,480 --> 00:47:03,707
さて、このコードは、新しい整数を割り当て
指示先、そしてこの部分は、xを設定

1056
00:47:03,707 --> 00:47:05,520
それを指すように。

1057
00:47:05,520 --> 00:47:06,760
>>  - ねえ、それが良く見えます。

1058
00:47:06,760 --> 00:47:08,520
だから、何かを作る。

1059
00:47:08,520 --> 00:47:09,530
>> -OK。

1060
00:47:09,530 --> 00:47:14,110
私は、逆参照ポインタxを格納するよ
その指示に数42。

1061
00:47:14,110 --> 00:47:17,660
このトリックのために、私は私の魔法が必要になるでしょう
間接参照の杖。

1062
00:47:17,660 --> 00:47:20,695
>> 間接参照の - あなたの魔法の杖？

1063
00:47:20,695 --> 00:47:22,632
ええと、それは素晴らしいことだ。

1064
00:47:22,632 --> 00:47:24,620
>>  - これは、コードがどのように見えるかです。

1065
00:47:24,620 --> 00:47:27,526
私はちょうど数を設定し、よ - 

1066
00:47:27,526 --> 00:47:28,250
>>  - ねえ、見て。

1067
00:47:28,250 --> 00:47:29,680
そこにそれは行く。

1068
00:47:29,680 --> 00:47:34,520
だから、xは次の上の逆参照を行う
その指示にアクセスするための矢印。

1069
00:47:34,520 --> 00:47:36,690
この場合には、そこに42を格納する。

1070
00:47:36,690 --> 00:47:40,890
ねえ、番号を格納するためにそれを使用してみてください
他のポインタを通じて13、Y。

1071
00:47:40,890 --> 00:47:42,125
>> -OK。

1072
00:47:42,125 --> 00:47:46,810
私はちょうどyにこっちに行くよと
番号13は、設定を取得。

1073
00:47:46,810 --> 00:47:50,890
その後の杖を取る
ただ間接参照と - 

1074
00:47:50,890 --> 00:47:52,430
ちょっと待って！

1075
00:47:52,430 --> 00:47:53,030
>>  - ああ、ちょっと。

1076
00:47:53,030 --> 00:47:54,610
それは動作しませんでした。

1077
00:47:54,610 --> 00:47:58,200
Binkyの、言う、私はないと思う
Yを逆参照すると、良いアイデアです

1078
00:47:58,200 --> 00:48:01,370
指示先を設定するため
別個のステップです。

1079
00:48:01,370 --> 00:48:03,460
と私は、私たちが今までそれをやったとは思わない。

1080
00:48:03,460 --> 00:48:03,810
>>  - うーん。

1081
00:48:03,810 --> 00:48:05,160
グッドポイント。

1082
00:48:05,160 --> 00:48:07,410
>>  - ええ、私たちは、ポインタyを割り当てられた。

1083
00:48:07,410 --> 00:48:10,045
しかし、我々はそれを設定することはありません
指示先を指す。

1084
00:48:10,045 --> 00:48:10,490
>>  - うーん。

1085
00:48:10,490 --> 00:48:12,170
非常に注意深い。

1086
00:48:12,170 --> 00:48:13,790
>>  - ねえ、あなたが探している
Binkyの、そこに良い。

1087
00:48:13,790 --> 00:48:16,920
yのポイントようにあなたはそれを修正することができます
xと同じ指示先へ？

1088
00:48:16,920 --> 00:48:17,810
>>  - 確かに。

1089
00:48:17,810 --> 00:48:20,300
私は私の魔法の杖を使用します
ポインタ代入。

1090
00:48:20,300 --> 00:48:22,240
>>  - であることがあることを行って
前のような問題？

1091
00:48:22,240 --> 00:48:22,665
>>  - いいえ。

1092
00:48:22,665 --> 00:48:24,300
これは、指示先に触れていない。

1093
00:48:24,300 --> 00:48:27,880
それだけを指すように一つのポインタを変更
別のと同じものに。

1094
00:48:27,880 --> 00:48:28,970
>>  - ああ、私は参照してください。

1095
00:48:28,970 --> 00:48:31,730
xと同じ場所に今、yがポイント。

1096
00:48:31,730 --> 00:48:32,450
だから、待ってください。

1097
00:48:32,450 --> 00:48:33,490
今、yが固定されています。

1098
00:48:33,490 --> 00:48:34,630
それは指示先を持っています。

1099
00:48:34,630 --> 00:48:36,520
だから、杖を試すことができます
再び参照解除の

1100
00:48:36,520 --> 00:48:39,200
上の13を送信する。

1101
00:48:39,200 --> 00:48:39,840
>> -OK。

1102
00:48:39,840 --> 00:48:41,570
ここに行く。

1103
00:48:41,570 --> 00:48:42,870
>>  - ねえ、それを見てください。

1104
00:48:42,870 --> 00:48:44,320
今、Y上の作品を間接参照。

1105
00:48:44,320 --> 00:48:47,020
とポインタは共有しているため、
その1指示先、それら

1106
00:48:47,020 --> 00:48:48,585
両方とも13を参照してください。

1107
00:48:48,585 --> 00:48:49,040
>>  - うん。

1108
00:48:49,040 --> 00:48:49,670
共有。

1109
00:48:49,670 --> 00:48:50,380
ものは何でも。

1110
00:48:50,380 --> 00:48:52,290
だから我々は現在のスイッチの場所に行くのですか？

1111
00:48:52,290 --> 00:48:52,970
>>  - ああ、見える。

1112
00:48:52,970 --> 00:48:54,150
我々は時間の外出。

1113
00:48:54,150 --> 00:48:55,200
>>  - しかし - 

1114
00:48:55,200 --> 00:48:57,060
>>  - わずか3を覚えている
ポインタルール。

1115
00:48:57,060 --> 00:49:00,100
ナンバーワン、基本構造
ポインタを有することである。

1116
00:49:00,100 --> 00:49:02,170
そしてそれは、指示先にポイント以上。

1117
00:49:02,170 --> 00:49:04,160
しかし、ポインタと指示先
別のものです。

1118
00:49:04,160 --> 00:49:06,460
と一般的なエラーは、することです
ポインタを設定し、これに

1119
00:49:06,460 --> 00:49:08,540
指示先を与えられたことを忘れない。

1120
00:49:08,540 --> 00:49:12,460
>> ナンバー2、ポインタデリファレンスが開始
ポインタで、以下その

1121
00:49:12,460 --> 00:49:14,570
矢印の上にその指示にアクセスする。

1122
00:49:14,570 --> 00:49:18,640
我々はすべて知っているように、これはのみ動作している場合があり
に戻って取得ポインティング先であり、

1123
00:49:18,640 --> 00:49:19,790
ルール番号1。

1124
00:49:19,790 --> 00:49:23,670
>> 3番、譲渡にかかるポインタ
1ポインタと変化、それが指すように

1125
00:49:23,670 --> 00:49:25,850
別のポインタと同じポインティング先。

1126
00:49:25,850 --> 00:49:27,840
だから代入後、
二つのポインタ意志

1127
00:49:27,840 --> 00:49:29,430
同じ指示先を指す。

1128
00:49:29,430 --> 00:49:31,600
時には、それは共有と呼ばれています。

1129
00:49:31,600 --> 00:49:33,430
そして、それは本当に、これだけです。

1130
00:49:33,430 --> 00:49:33,840
今バイバイ。

1131
00:49:33,840 --> 00:49:34,300
>> [ENDビデオ再生]

1132
00:49:34,300 --> 00:49:36,940
>> DAVIDマラン：だから複数のポインタで、
Binkyの来週の詳細。

1133
00:49:36,940 --> 00:49:38,190
私たちは、月曜日にお会いしましょう​​。

1134
00:49:38,190 --> 00:49:42,187