1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [第4週、続く]

2
00:00:02,310 --> 00:00:04,240
[デビッド·J·マラン - ハーバード大学]

3
00:00:04,240 --> 00:00:07,290
[これはCS50です。 -  CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> これはCS50であり、これは第4週の終わりです。

5
00:00:11,290 --> 00:00:14,030
いくつかの良いニュースと悪いニュースがそう。

6
00:00:14,030 --> 00:00:26,240
月曜日には何の講義、問題は来週設定されません。 [生徒が応援]

7
00:00:26,240 --> 00:00:28,680
あなたは、これがどこに行っているかなどするつもりはない。

8
00:00:28,680 --> 00:00:31,590
しかし、我々は次水曜日代わりにこれを持っていますが、

9
00:00:31,590 --> 00:00:37,740
そして次金曜日は、我々はトラックにとどまることができるようにシラバス1金曜日の講義ごとにもある。

10
00:00:37,740 --> 00:00:40,580
しかし、すべてはいつものように撮影されますので、心配しないように。

11
00:00:40,580 --> 00:00:44,100
>> とに関しては、我々は今週の終わりに向かって何をしようとして0をクイズに

12
00:00:44,100 --> 00:00:47,140
コー​​スのホームページcs50.net説明に投稿されている

13
00:00:47,140 --> 00:00:50,160
それは最初のクイズに来るときあなたが持っているはずの期待がどんなものなのかの。

14
00:00:50,160 --> 00:00:55,100
一般的には、多肢選択、正誤、短文ショートコーディングな問題となるだろう。

15
00:00:55,100 --> 00:00:57,360
あなたは、同等のものを実装することを期待するつもりはない

16
00:00:57,360 --> 00:01:00,030
あなたはコンピュータを持っているのpset、見たい問題の

17
00:01:00,030 --> 00:01:03,240
とデバッガ等が挙げられるが、小さなコーディングの問題があるでしょう。

18
00:01:03,240 --> 00:01:06,900
>> そして実際、CS50クイズ何の感覚を得るための最良のガイドでは、のようなもの

19
00:01:06,900 --> 00:01:09,180
cs50.netに行くされ、クイズのリンクを参照してください

20
00:01:09,180 --> 00:01:11,920
そしてあなたは、過​​去数年間クイズの価値を確認することができます。

21
00:01:11,920 --> 00:01:16,600
ただカリキュラムは常に長年にわたって同じではなかったことを実現します。

22
00:01:16,600 --> 00:01:18,510
時には我々は、時には加算、減算、

23
00:01:18,510 --> 00:01:20,670
あなたはそれらの古いクイズの1にいくつかのトピックを参照してくださいので、もし

24
00:01:20,670 --> 00:01:25,380
あなたはそれが何について話しているのか見当がつかないこと、それは我々がそれをカバーしたことのどちらかだ

25
00:01:25,380 --> 00:01:27,210
あるいは、我々がそれをカバーしていない。

26
00:01:27,210 --> 00:01:31,110
しかし、レビューの形で、この日曜日、月曜日、火曜日

27
00:01:31,110 --> 00:01:34,770
同様に日曜日の夜にコース全体のレビューセッションとして - 

28
00:01:34,770 --> 00:01:37,500
コー​​スのホームページ上で発表される時間と場所 - 

29
00:01:37,500 --> 00:01:40,120
あなたはすべてのコースのティーチング仲間と検討する機会を持つ

30
00:01:40,120 --> 00:01:44,830
セクションと完全クラスとして両方今年の材料、

31
00:01:44,830 --> 00:01:48,400
そしてそれらは同様にいつものように撮影されます。

32
00:01:48,400 --> 00:01:53,380
>> かしこまりました。だから、さらに騒ぎがなければ、パス上の1つのコメントには/失敗し、アド/ドロップ。

33
00:01:53,380 --> 00:01:57,980
昨夜は私のノートを見ている可能性があり、これは本当にちょうどいくつかの追加安心です

34
00:01:57,980 --> 00:02:01,250
あなたはそれらの間で特にあまり快適またはどこかの間にあるときは、同

35
00:02:01,250 --> 00:02:04,870
そしてあなたは、あなたの頭の上に少しだけ感じている

36
00:02:04,870 --> 00:02:08,430
確かに非常に正常であることを認識し、所定の位置に十分な支持構造があり、

37
00:02:08,430 --> 00:02:13,530
営業時間は、最後の夜私のメールごとにすべてのそれ以上の上達に専念していたそのうちの1

38
00:02:13,530 --> 00:02:16,520
とパスのようなオプションが/このようなクラスで失敗することにも気付く

39
00:02:16,520 --> 00:02:21,540
本当にこのようなコースの端を脱ぐためのメカニズムとして意図され、

40
00:02:21,540 --> 00:02:24,200
ので、あなたはそれらの10、15、20時間を費やしている場合は、再度

41
00:02:24,200 --> 00:02:28,160
ちょうど仕事にいくつかのpsetを取得しようと、あなたがそこに道の90〜95％している知っている

42
00:02:28,160 --> 00:02:32,100
しかし、あなたは大丈夫のようなものだ合格/不合格のモデルでは、いくつかの気のバグを見つけることができません。

43
00:02:32,100 --> 00:02:36,230
>> アイデアは、そのメカニズムとは、あなたの他のpsetにフォーカスを行くことができるということです

44
00:02:36,230 --> 00:02:39,530
スリープモードまたは何でもそれはあなたがに集中したいということです。

45
00:02:39,530 --> 00:02:43,390
ですから、今度の火曜日まで持っていることを実感 - 技術的には第五月曜日、

46
00:02:43,390 --> 00:02:50,840
それは休日なので、今度の火曜日 - パスから切り替える/傾斜、またはその逆に失敗する。

47
00:02:50,840 --> 00:02:54,450
そして、あなたは絶壁に本当にしていると完全に落下を考えているのなら、

48
00:02:54,450 --> 00:02:56,440
講義の後に私を捕まえるか、私にメールを送ってください。

49
00:02:56,440 --> 00:02:59,990
我々は、あなたが別れを告げる前に、少なくともおしゃべりが大好きです。

50
00:02:59,990 --> 00:03:03,470
かしこまりました。だから我々は前回から補助輪を撮り始めた。

51
00:03:03,470 --> 00:03:06,030
特に、我々は、文字列に焦点を当てた。

52
00:03:06,030 --> 00:03:09,740
文字列は、CS50ライブラリ内で宣言されているものです

53
00:03:09,740 --> 00:03:14,340
特に我々は今週と次のを見てから始めましょうcs50.hと呼ばれるファイルに記録します。

54
00:03:14,340 --> 00:03:17,250
しかし、文字列は本当に何かのほんの簡略化したものである

55
00:03:17,250 --> 00:03:20,980
それはもう少しarcanely char *として説明します。

56
00:03:20,980 --> 00:03:24,090
我々が精通しているCHAR。それはちょうど単一文字です。

57
00:03:24,090 --> 00:03:28,010
しかし、月曜日の時点で*は何を表す？ >> [生徒]のポインタ。

58
00:03:28,010 --> 00:03:31,290
ポインター。ポインタとは何ですか？ >> [生徒]アドレス。

59
00:03:31,290 --> 00:03:33,420
>> それは、アドレス、メモリ内の位置のようなものだ。

60
00:03:33,420 --> 00:03:35,910
住所や場所やメモリとは何ですか？

61
00:03:35,910 --> 00:03:40,290
繰り返しますが、私たちのすべては、これらの日の最も可能性の高いギグまたは2 GBのRAMを搭載したノートパソコンを持っている

62
00:03:40,290 --> 00:03:44,160
とすると、メモリの価値億か2億バイトを持っていることを意味します。

63
00:03:44,160 --> 00:03:46,240
そしてそれは本当に、それが物理的にどのように見えるかは問題ではありません

64
00:03:46,240 --> 00:03:51,220
しかし、あなたは自分のノートパソコンが持っている個々のバイト数全できるという信仰を取る - 

65
00:03:51,220 --> 00:03:54,580
これは0バイトですが、これは1バイトですが、これは20億バイトです - 

66
00:03:54,580 --> 00:03:56,100
それはコンピュータが何をするかがまさにそれだ。

67
00:03:56,100 --> 00:04:00,030
あなたは、単一の文字にスペースを割り当てるときに、例えば、

68
00:04:00,030 --> 00:04:02,480
それは明らかに、コンピュータのメモリ内のどこかに住んでいる必要があります

69
00:04:02,480 --> 00:04:05,860
そして多分それは、12345バイト数でだ

70
00:04:05,860 --> 00:04:08,470
そしてそれはあなたのコンピュータのメモリにここにどこか次第です。

71
00:04:08,470 --> 00:04:12,630
そしてその文字の後、アドレスは12345です。

72
00:04:12,630 --> 00:04:16,140
>> さて、今を通じてこれまで0週目に、私たちは本当に気にしていない

73
00:04:16,140 --> 00:04:19,170
我々は通常、記号を使用していますので、メモリ物事に格納されている、

74
00:04:19,170 --> 00:04:22,540
変数は、実際に我々のデータを取得するために、配列。

75
00:04:22,540 --> 00:04:24,950
しかし、月曜日となおさら今日の時点で、あなたが今持っているつもりです

76
00:04:24,950 --> 00:04:27,710
書き込みプログラムとすべてのそれ以上の表現力

77
00:04:27,710 --> 00:04:31,330
あなたが合うしかし実際には、コンピュータのメモリを操作し、

78
00:04:31,330 --> 00:04:33,720
良い目的と悪の両方に対して、

79
00:04:33,720 --> 00:04:39,620
このようなものを学ぶことに、この時点では非常に一般的な結果であるバグを修正しました。

80
00:04:39,620 --> 00:04:42,460
しかし、それは実際にはchar *であることが何を意味するのか？

81
00:04:42,460 --> 00:04:46,140
そして今日は約束通り、我々はBINKYに戻ってくるだろう - のはに戻って先に進みましょう。

82
00:04:46,140 --> 00:04:48,670
のがここで簡単な例に行こう。

83
00:04:48,670 --> 00:04:53,060
私はcompare.cとしてこのファイルを保存して、私はちょうどここにいくつかのテンプレートのコードを得ることができましょう

84
00:04:53,060 --> 00:05:00,490
ので、stdio.hをインクルード、私はまた自分自身を含んで与えることができcs50.h.私はそこにズームします。

85
00:05:00,490 --> 00:05:05,850
私はメインのint、メイン（void）を、書き始めるとすぐに私はこのような何かをしたいとしましょう​​：

86
00:05:05,850 --> 00:05:13,520
のprintf（ "私に文字列を教えてください："）してから、私は、文字列sがgetString取得に使用する

87
00:05:13,520 --> 00:05:16,750
ユーザから文字列を取得するには、その後、私は別のもののためにユーザに依頼するつもりです。

88
00:05:16,750 --> 00:05:21,870
そして私はそれを取得するGetStringメソッドを介してそれらを依頼するつもりです：（ "私に別の文字列を与える"）。

89
00:05:21,870 --> 00:05:27,020
それはかなり標準的なものであればsとsが文字列のためのすてきな名前です後にtが来るので、私はそれトンと呼ぶことにします。

90
00:05:27,020 --> 00:05:30,030
だからGetStringを、今私はちょうど健全性チェックをやってみたいと私は言うつもりです

91
00:05:30,030 --> 00:05:39,770
その後、私はちょうど（ "！あなたは同じことを入力します\ n"）printfのユーザーに伝えるつもりです（秒== t）の場合;

92
00:05:39,770 --> 00:05:45,520
他の私のような何かを（ "あなた型付け何か違う！\ n"）をプリントアウトするつもりです

93
00:05:45,520 --> 00:05:48,460
または任意の文は次のようになります。だから、そのような何か。

94
00:05:48,460 --> 00:05:52,200
その後、いつものように、私はちょうど何も悪いことが起こっていませんシニフィエ0を返します

95
00:05:52,200 --> 00:05:54,400
と私は先に行くと、このプログラムをコンパイルして実行するつもりです。

96
00:05:54,400 --> 00:05:56,540
>> しかし、月曜日に私たちは、このプログラムを実行した

97
00:05:56,540 --> 00:06:00,420
そして実際に、HELLOがHELLOではなく、さよならさよならではないと言われた。

98
00:06:00,420 --> 00:06:03,140
我々が見た行動は、このようにもう少しだった。

99
00:06:03,140 --> 00:06:11,450
私は、私のソースディレクトリに移動し、ここで、ズーム、および比較作るかしてみましょうましょう。

100
00:06:11,450 --> 00:06:14,570
大丈夫コンパイル。比較する私が実行してみましょう。私に文字列を与える：こんにちは。

101
00:06:14,570 --> 00:06:16,300
私に別の文字列を与える：こんにちは。

102
00:06:16,300 --> 00:06:18,000
あなたが別の何かを入力した！

103
00:06:18,000 --> 00:06:22,650
さて、私は50、50のようなシンプルなものを試してみましょう。あなたが別の何かを入力した！

104
00:06:22,650 --> 00:06:25,740
やあ、こんにちは。だから明らかに、何かがここで起こっている。

105
00:06:25,740 --> 00:06:28,440
しかし、理由の説明何でしたか？

106
00:06:28,440 --> 00:06:33,850
どうやら、12行目は完全に機能不全に陥っている。

107
00:06:34,300 --> 00:06:39,430
ここに根本的な問題は何ですか？うん。 >> [生徒]それはアドレスを比較している。

108
00:06:39,430 --> 00:06:41,850
ええ、その通りです。これは、実際のアドレスを比較している

109
00:06:41,850 --> 00:06:44,580
たハローとHELLO格納されています。

110
00:06:44,580 --> 00:06:48,290
それは、何度も何度も、HELLO文字を比較していない

111
00:06:48,290 --> 00:06:52,370
本当に何が起こっているのか、私達がGetStringメソッドを使用してきたすべての時間 - 

112
00:06:52,370 --> 00:06:56,130
この黒板は、再び我々のコンピュータのメモリです

113
00:06:56,130 --> 00:07:00,100
としてみましょう私は、変数sを宣言した後GetStringを呼び出すと言う。

114
00:07:00,100 --> 00:07:01,930
私の記憶がどのように見えますか？

115
00:07:01,930 --> 00:07:07,070
Let 'sは、任意にsがこのようになっていることを言う。それは正方形です。

116
00:07:07,070 --> 00:07:09,040
とかなりいつでも私は、画面上のメモリの一部を描いた

117
00:07:09,040 --> 00:07:12,860
それが32ビットの場合、私は、アプライアンスであるため、実際にこのような正方形を描画してきた

118
00:07:12,860 --> 00:07:17,380
ポインタは、アドレスは、32ビットです。それはintと同じです。

119
00:07:17,380 --> 00:07:19,420
コンピュータ·システムに基づいて変化する可能性があること。

120
00:07:19,420 --> 00:07:24,630
お使いのMacまたはPCが64ビットであるという事実と漠然と理解しているあなたの人々、

121
00:07:24,630 --> 00:07:28,120
実際にお使いのコンピュータが64ビット·ポインタを使用していることを示している、

122
00:07:28,120 --> 00:07:33,730
64ビットのアドレス、五分五分の間では、コンピュータである

123
00:07:33,730 --> 00:07:35,560
往年よりもはるかに多くのRAMを持つことができます。

124
00:07:35,560 --> 00:07:39,240
長い話を短く、昔にコンピュータが32ビットだけを使用したとき

125
00:07:39,240 --> 00:07:42,740
アドレスを表すために、バイトの最大数あなたは表すことができました

126
00:07:42,740 --> 00:07:46,280
その場合には、32ビットを持っていたらどうだった？

127
00:07:46,280 --> 00:07:49,590
32から2が4億円ですので、右のように4億ドルであった。

128
00:07:49,590 --> 00:07:51,370
この数はもちろんで再発されています。

129
00:07:51,370 --> 00:07:55,240
>> あなたは32ビットだけを持っているなら、あなたが数えることができる最大数は、約4億ドルである。

130
00:07:55,240 --> 00:07:58,750
しかし、それは数年前まで、コンピュータの基本的な制限があった

131
00:07:58,750 --> 00:08:01,180
あなただけ40億ほど高く数えることができる場合があるため、

132
00:08:01,180 --> 00:08:05,270
RAMの8ギガバイト以上のRAMさえ5ギガバイトを買えば、それは問題ではありません。

133
00:08:05,270 --> 00:08:07,780
あなたはそれが高い数えることができないので、それは無駄だった。

134
00:08:07,780 --> 00:08:11,430
あなたは、あなたのコンピュータのメモリの最初の3または4ギガバイトにアクセスすることができました。

135
00:08:11,430 --> 00:08:14,410
それが今ではそれほど問題だし、のMacBook Proとデルを購入することができます

136
00:08:14,410 --> 00:08:17,680
8ギガバイトのRAMあるいはそれ以上のこれらの日である。

137
00:08:17,680 --> 00:08:24,100
しかし、私はこのプログラムに非常に単純にポインタsと呼ばれるポインタを割り当てる場合

138
00:08:24,100 --> 00:08:28,370
確かに我々は、この層背面剥離する必要があるため、それが画面に次のようになります。

139
00:08:28,370 --> 00:08:33,520
、私は、文字列を言い続けるが、月曜日のように、文字列は本当にchar *である

140
00:08:33,520 --> 00:08:35,590
いくつかの文字のアドレス。

141
00:08:35,590 --> 00:08:39,280
だから我々は今のGetStringメソッドを使用し続けるつもりもかかわらずの、その補助輪を外してみ​​ましょう。

142
00:08:39,280 --> 00:08:42,600
だから私は、sを宣言したが、これはメモリの塊、32ビットです。

143
00:08:42,600 --> 00:08:47,370
デフォルトでは、メモリ内にここに何があるか。 >> [聞こえない学生の応答]

144
00:08:47,370 --> 00:08:50,040
それは何？ >> [生徒]ごみ。 >>ガベージ。その通りです。

145
00:08:50,040 --> 00:08:54,610
あなたはプログラマが変数に値を入れない場合、誰がそれが何であるか知っている？

146
00:08:54,610 --> 00:08:57,990
時々、あなたは幸運を得ると、それは素敵な、きれいなデフォルト値の一種である0、、だ

147
00:08:57,990 --> 00:09:00,310
我々が見たように月曜日しかし、時にはそれが、完全にナンセンスだ

148
00:09:00,310 --> 00:09:04,130
どこから来たいくつかの非常に大きな正または負の数？

149
00:09:05,350 --> 00:09:07,010
うん。関数の前に>> [生徒]。 >>うん。

150
00:09:07,010 --> 00:09:10,170
>> しばしば思い出すので、前に呼ばれました機能、

151
00:09:10,170 --> 00:09:13,920
あなたは、メモリ内の関数を呼び出すように、彼らは下から上に、より多くのスペースを取る、

152
00:09:13,920 --> 00:09:17,040
とすぐに関数が戻ったとして、そのメモリは再利用されます

153
00:09:17,040 --> 00:09:20,890
呼び出された隣の男で、誰があなたのメモリの同じスライスを使用しています。

154
00:09:20,890 --> 00:09:23,450
そして、あなたは、そこに以前の値をゴミを残してきた場合

155
00:09:23,450 --> 00:09:28,190
私たちは本当に我々がそこには何も入れていないときに、いくつかの値を持つものとしてsを間違える可能性があります。

156
00:09:28,190 --> 00:09:30,960
だから、この時点で私達のRAMは、このように見えます。

157
00:09:30,960 --> 00:09:36,030
今では7行目の右側に、我々は、GetStringメソッドを呼んでいる

158
00:09:36,030 --> 00:09:40,150
我々は数週間のために今行ってきたが、何が本当にやってgetStringをされている？

159
00:09:40,150 --> 00:09:43,350
CS50スタッフによって書かGetStringメソッドは少し理性的である

160
00:09:43,350 --> 00:09:46,500
その中でユーザーが入力するキーとヒットは、入力し始めるとすぐに、

161
00:09:46,500 --> 00:09:50,010
数字をgetStringをどのように多くのキーストロークは、ユーザーがヒットしました、

162
00:09:50,010 --> 00:09:53,360
どのように多くの文字私は、RAMを割り当てる必要がない。

163
00:09:53,360 --> 00:09:55,660
そして、ここで、そのRAMは、から来ている人は知っていますか？

164
00:09:55,660 --> 00:09:58,930
それはあなたのコンピュータの2ギガバイト以上のメモリその他もろもろのどこかだ。

165
00:09:58,930 --> 00:10:05,200
しかし、ここではコンピュータは右ここにハローワードのためのスペースを見つけたとしましょう​​。

166
00:10:05,200 --> 00:10:08,710
私が入力した単語は、H-E-L-L-Oだった。

167
00:10:08,710 --> 00:10:13,510
そして、我々は文字のシーケンスとしてこれを描くならば、我々はこのようにそれを描くかもしれません。

168
00:10:13,510 --> 00:10:17,860
しかし、私は1余分なことを行う必要があります。何がC言語で任意の文字列の末尾に属する？

169
00:10:17,860 --> 00:10:20,710
我々は\ 0として書き込み、ヌル文字。

170
00:10:20,710 --> 00:10:23,980
それは技術的には数字の0ですが、バックスラッシュは、すべて明確になります

171
00:10:23,980 --> 00:10:28,150
これは、文字通り数0、整数0であること;

172
00:10:28,150 --> 00:10:32,440
それはあなたがキーボードでタイプかもしれない、例えば、俗に言う0ではありません。

173
00:10:32,440 --> 00:10:33,940
だから、これはHELLOです。

174
00:10:33,940 --> 00:10:36,350
>> そして、我々はGetStringメソッドのような関数と月曜日に何を言った

175
00:10:36,350 --> 00:10:39,580
実際に、これらのすべての週を返している？

176
00:10:39,580 --> 00:10:43,960
それは本当に意味を持っていませんので、それはそれ自体が文字列を返していない

177
00:10:43,960 --> 00:10:47,710
文字列が存在しないため。彼らは、CS50、ライブラリ内の製造の一種だ。

178
00:10:47,710 --> 00:10:51,300
より技術的に、本当に文字列とは何ですか？ >> [生徒]それは最初の文字です。

179
00:10:51,300 --> 00:10:55,950
その通りです。それは、ユーザーがログイン入力した非常に単純に最初の文字のアドレスだ

180
00:10:55,950 --> 00:11:02,810
もしそうであればバイト数123で、その後バイト数124で、それを終わるこんにちは私の言葉、

181
00:11:02,810 --> 00:11:08,320
125、126など、最大で0〜私はちょうど私の数バイトであれば、

182
00:11:08,320 --> 00:11:12,650
本当にGetStringメソッドは、戻されると、文字通り数123です。

183
00:11:12,650 --> 00:11:19,270
だから何秒に入れれるとハロー番号123ではなく、文字Hではなく、言葉であり、

184
00:11:19,270 --> 00:11:23,130
非常に単純に私はHELLOの最初の文字を見つけることができているアドレス。

185
00:11:23,130 --> 00:11:26,500
しかし、それは十分なように見えるしていません。私は、文字列ではなく、文字の入力を求めました。

186
00:11:26,500 --> 00:11:32,970
それではまたはコンピュータがELLO種類のはHと一緒に来ていることを知っていますか？

187
00:11:35,760 --> 00:11:37,460
我々が持っている契約書のソートは何ですか？うん。

188
00:11:37,460 --> 00:11:40,100
[学生]それはいくつかのより多くの文字を見つけるために自分自身を語って保持します。まさに>>。

189
00:11:40,100 --> 00:11:44,570
>> あなたが文字列を扱っていることにより、この人間とコンピュータの規則は、あり

190
00:11:44,570 --> 00:11:49,410
そうでなければ今のchar星として知られている、あなたは、単に把握する必要があります

191
00:11:49,410 --> 00:11:54,350
生活の中ですべての文字列の最後は本当にただ、forループでそれを反復することである

192
00:11:54,350 --> 00:11:57,820
あなたが文字列の終わりを見つけるように何でも、whileループ、

193
00:11:57,820 --> 00:12:02,160
今、あなたはそこから推測することができる、ああ、単語全体はHELLOだった。

194
00:12:02,160 --> 00:12:04,820
プログラミング経験を持つあなたの人々は、Javaで知っているかもしれません

195
00:12:04,820 --> 00:12:09,880
あなただけ。長さを呼び出すことができますし、他の言語では、長さまたは類似を呼び出すことができます。

196
00:12:09,880 --> 00:12:14,060
多くの言語で、特に物事はオブジェクト指向言語と呼ばれるのはそういうわけです。

197
00:12:14,060 --> 00:12:18,580
何かの長さは、データ自体の一部のカプセル内部の一種である

198
00:12:18,580 --> 00:12:24,000
ずっと月曜日に学生の中にカプセル化された我々IDと名前と家が好きです。

199
00:12:24,000 --> 00:12:28,700
しかし、Cは、はるかに低いレベルである。あなたが前にそれらの用語を聞いたことがある場合にはオブジェクトやクラスは、ありません。

200
00:12:28,700 --> 00:12:31,490
あなたが持っているすべては、実際にはメモリアドレスです。

201
00:12:31,490 --> 00:12:35,540
だから、これは興味深いデータ構造を表現する昔ながらの方法の一種です。

202
00:12:35,540 --> 00:12:38,760
あなたは、最初の文字のアドレスのような開始値が設定されてい

203
00:12:38,760 --> 00:12:42,340
その後、誰もが従うことに同意するだけでいくつかの任意の慣例。

204
00:12:42,340 --> 00:12:46,420
だから、文字列の長さがどのように実装されるか、我々は提案しましたか？

205
00:12:46,420 --> 00:12:51,360
あなた方の何人かがここ数回使用しているstrlenは、strlenは、。これは、右、非常に簡単です？

206
00:12:51,360 --> 00:12:53,060
これは、2行のコードのようなものだ。

207
00:12:53,060 --> 00:12:56,140
それは多分、追加のローカル変数と、かなりいくつかの並べ替えのためのループです。

208
00:12:56,140 --> 00:13:00,540
しかし、strlenはただのポインタを取り、次に\ 0を探して起動する必要があります。

209
00:13:00,540 --> 00:13:05,190
>> とすぐにそれを見つけると、それは、その文字列で取ってきてステップの合計数を返すことができます。

210
00:13:05,190 --> 00:13:07,150
だから、我々は次で何が起こっているのかこのことから推測することができます。

211
00:13:07,150 --> 00:13:11,850
私は10行目で行ったように、私はトンを宣言した後と仮定します。

212
00:13:11,850 --> 00:13:14,280
これは、いくつかのゴミ値です。誰が最初​​に知っていますか？

213
00:13:14,280 --> 00:13:18,490
しかし、10の行の右側に、私は再びGetStringメソッドを呼んでいる。

214
00:13:18,490 --> 00:13:20,050
これが終わるどこに誰が知っているか？

215
00:13:20,050 --> 00:13:23,830
任意のオペレーティング·システムは、ここの上に方法のための部屋を見つけたとしましょう​​。

216
00:13:23,830 --> 00:13:28,610
私は、偶然に再びH-E-L-L-Oを入力するように起こる

217
00:13:28,610 --> 00:13:31,260
それで我々は絵の同じ種類を描くことができます。

218
00:13:31,260 --> 00:13:34,290
しかし、私はこの絵を描画したという事実は意図的なものである

219
00:13:34,290 --> 00:13:37,720
それがあるため、これよりも、HELLO異なる。

220
00:13:37,720 --> 00:13:43,920
だからここでは、この場所456、これは457である、などであるかもしれません。

221
00:13:43,920 --> 00:13:47,170
疑問符がかつてあった場所だから何入れてされますか？

222
00:13:47,170 --> 00:13:50,190
この場合、456で。

223
00:13:50,190 --> 00:13:53,540
我々は今日の後なぜなら本当に任意にこれらの数字を拾っている

224
00:13:53,540 --> 00:13:57,110
我々は何のアドレスが何であるかについてはあまり気にするつもりはない。

225
00:13:57,110 --> 00:14:02,690
我々が気にすべては、我々はハローのようないくつかのデータのアドレスを把握することができるということです。

226
00:14:02,690 --> 00:14:07,100
>> だから、実際にはメモリアドレスの話をするとき、ほとんどの人はコンピュータ科学に何をすべきか

227
00:14:07,100 --> 00:14:10,210
そして、具体的にポインタの話

228
00:14:10,210 --> 00:14:14,220
このようなものが実際にある気に、 -  123を考え出す気にするのではなく

229
00:14:14,220 --> 00:14:17,440
我々はちょうどそれがいくつかの数値アドレスであることを知っている - 

230
00:14:17,440 --> 00:14:22,180
我々は世界を単純化し、ちょうどsはその文字を指していることを言う

231
00:14:22,180 --> 00:14:25,080
とtはその文字を指している。

232
00:14:25,080 --> 00:14:27,430
そして、それは矢だという事実は、かなり意図的なものです

233
00:14:27,430 --> 00:14:31,610
文字通り今sはHとTを指しているので、他のHに向いている

234
00:14:31,610 --> 00:14:34,720
、一日の終わりに、それはアドレスが何であるかは関係ありませんので、

235
00:14:34,720 --> 00:14:40,240
しかしそれは我々がコードのいくつかの作品で、そのアドレスを表現する能力を持っていることに関係しません。

236
00:14:40,240 --> 00:14:42,730
私たちは本当に、まだ、これらのアドレスを操作していない

237
00:14:42,730 --> 00:14:47,770
ので、我々は、我々は差し挟むとポインタで物事を行うに並べ替えることができますどこに表示されます

238
00:14:47,770 --> 00:14:52,030
しかし今では、12行目で、文字通り我々が比較しているものの値について

239
00:14:52,030 --> 00:14:55,500
12行目でこの話によると？

240
00:14:56,570 --> 00:15:01,290
我々は456から123に等しい等しいと言っている？そして、それは確かにそうではない。

241
00:15:01,290 --> 00:15:05,320
さらには概念的に、このポインタは間違いなく、これと同じではありません

242
00:15:05,320 --> 00:15:09,500
は、2回GetStringメソッドと呼ばれ、GetStringメソッドは、巧妙なスーパーになろうとしないので、

243
00:15:09,500 --> 00:15:12,470
それが実現しようとはしません、ああ、あなたは5分前Hello型付け;

244
00:15:12,470 --> 00:15:15,090
私が前にあなたを与えたとして、私はあなたに同じポインタを与えることができ、

245
00:15:15,090 --> 00:15:18,450
それはちょうどあなたがそれを呼び出すたびにメモリの新しいチャンクを割り当てます。

246
00:15:18,450 --> 00:15:20,350
>> だから我々はこの問題をどのように修正すればよいですか？

247
00:15:20,350 --> 00:15:24,270
私はハローとHELLOの文字列を比較したい場合は、より高いレベル - 

248
00:15:24,270 --> 00:15:28,680
私はポインタを気にしないでください - 私は、質問に答えるにはどうすればいい、

249
00:15:28,680 --> 00:15:31,980
ユーザーが同じことを入力したのですか？ここには何が必要ですか？うん。

250
00:15:31,980 --> 00:15:35,200
[学生]は関数を使用します。 >>私は箱の機能を使用することができます。

251
00:15:35,200 --> 00:15:38,170
私は、S-T-R-C-M-Pは、strcmpという関数を使用することができます

252
00:15:38,170 --> 00:15:41,190
ストリング比較というのは単に簡略版。

253
00:15:41,190 --> 00:15:45,070
そして、我々が入る場合には、例えば、2を比較して、今日の資料の中である、

254
00:15:45,070 --> 00:15:46,690
私はまさにそれを行います。

255
00:15:46,690 --> 00:15:51,750
私は、26かそこらまでに他のすべての1行目にも同じものを保持

256
00:15:51,750 --> 00:15:54,360
そして今、この部分が少しだけ変更されています注意してください。

257
00:15:54,360 --> 00:15:57,690
瞬間のため28行を無視して、この1にだけ焦点を当ててみましょう。

258
00:15:57,690 --> 00:16:00,410
我々は、str比較がないことを月曜日何を言いましたか？

259
00:16:00,410 --> 00:16:05,200
それが、この場合は2ポインタ、s、tを取るのプロセスを処理

260
00:16:05,200 --> 00:16:08,480
実質的にはこれらの2文字に、その指を入れての並べ替え、

261
00:16:08,480 --> 00:16:11,530
をどのように処理をしなければならないことは、forループ、whileループ、またはのようなものです

262
00:16:11,530 --> 00:16:16,050
それはこれらが同じであると言う？そうだとすれば、それは、指または前方ポインタを移動します。

263
00:16:16,050 --> 00:16:17,970
これらは同じですが、これらと同じ、これらと同じ、

264
00:16:17,970 --> 00:16:22,710
これらと同じ、これらと同じ？とのooh、私はsとtの両方で、文字列の末尾に来ている。

265
00:16:22,710 --> 00:16:26,780
私はすべての矛盾を発見していない。はい、これらの文字列は同じです。

266
00:16:26,780 --> 00:16:31,940
2つの文字列が同じである場合、何が明らかにstrを、リターンを比較するのですか？ゼロ。

267
00:16:31,940 --> 00:16:35,900
だから、0は、この場合には良いのだから、これは-1または1を返す場合

268
00:16:35,900 --> 00:16:40,560
それはsがちょうどトンアルファベットの前または後に来るトンを起こることを意味します。

269
00:16:40,560 --> 00:16:43,760
そして、なぜその文字列が前に来るかを示し機能があると便利だろう

270
00:16:43,760 --> 00:16:46,720
またはディクショナリ内の後？

271
00:16:46,720 --> 00:16:48,740
[学生]検索。 >>検索と並べ替え。

272
00:16:48,740 --> 00:16:51,730
>> だから、二分探索やバブルソートのようなものを行うか、またはソートをマージすることができます

273
00:16:51,730 --> 00:16:53,230
あなたは物事を比較する必要がある。

274
00:16:53,230 --> 00:16:56,420
これまで我々は、種のいくつかのコーナーをカットしたとだけソートの話

275
00:16:56,420 --> 00:16:59,430
数値の文脈でそれは話をいいと簡単なので、

276
00:16:59,430 --> 00:17:02,430
しかし、あなたは確かに、文字列、リンゴとバナナを比較することができます

277
00:17:02,430 --> 00:17:05,349
リンゴも同様に、バナナの前に来ることが知られている場合があるため、

278
00:17:05,349 --> 00:17:09,319
あなたは、ビデオでマージソートでやっただけロブのようなメモリ内の周りの文字列を移動することができます

279
00:17:09,319 --> 00:17:15,880
そして我々は選択ソート、挿入ソート、バブルソートと一緒にステージにここで行った。

280
00:17:15,880 --> 00:17:18,710
だから他にどこ私たちはこれを取ることができますか？これを試してみましょう。

281
00:17:18,710 --> 00:17:23,980
ソートの瞬間のためにその教訓を忘れて、今試してみて、次の操作を実行する1.Cコピーしましょう​​。

282
00:17:23,980 --> 00:17:26,800
21行目では、私は、印刷に何かを言っている

283
00:17:26,800 --> 00:17:28,520
それから私は、ユーザから文字列を取得しています

284
00:17:28,520 --> 00:17:30,690
その後、私はこれをチェックしている。

285
00:17:30,690 --> 00:17:33,620
私たちは本当にまだこの習慣に得たが、今これをしてみましょうされていません。

286
00:17:33,620 --> 00:17:40,990
バックこの層はがし実際にしてみましょう。これは本当にchar *である。この男は本当にchar *である。

287
00:17:40,990 --> 00:17:45,690
だからそれは、s == NULLかどうかをチェックすることが何を意味するのか？

288
00:17:45,690 --> 00:17:48,380
それはあなたがGetStringメソッドのような関数を呼び出すときにことが判明

289
00:17:48,380 --> 00:17:51,540
以上、一般的に、単に、あなたにいくつかのメモリを与えるために、コンピュータを頼む

290
00:17:51,540 --> 00:17:53,030
何かが間違って行くことができます。

291
00:17:53,030 --> 00:17:56,630
あなたが夢中になるとメモリのテラバイトのためにコンピュータを頼むことができる

292
00:17:56,630 --> 00:18:01,780
ちょうどコンピュータに存在しないメモリのバイト数兆を求めることによって、

293
00:18:01,780 --> 00:18:05,130
しかしGetStringメソッドと他の機能はあなたに叫んでのいくつかの方法が必要

294
00:18:05,130 --> 00:18:06,820
あなたはあまりにも多くを求めてきた場合。

295
00:18:06,820 --> 00:18:10,450
あなたがより多くのメモリを要求した場合とGetStringがこれを行う方法です

296
00:18:10,450 --> 00:18:14,250
それは、超、超低確率であっても、コンピュータで利用できるより

297
00:18:14,250 --> 00:18:17,730
私たちの誰にEnterを叩いて次に兆文字を入力しようとされていないため、

298
00:18:17,730 --> 00:18:21,980
それはあるかもしれませんが、低確率は、私はまだ、念のためにそれをチェックしたい

299
00:18:21,980 --> 00:18:26,120
そして特別な値GetStringメソッドは、答え、およびその他の機能返す

300
00:18:26,120 --> 00:18:30,630
何かが間違っている場合はすべて大文字でNULLです。

301
00:18:30,630 --> 00:18:36,520
>> とNULLは何ですか？ NULLは、ポインタを表すために起こります。これは、メモリアドレス0です。

302
00:18:36,520 --> 00:18:40,800
これは私のコンピュータのメモリであれば、世界は、その任意に決めた - あなたは何を知っているか - 

303
00:18:40,800 --> 00:18:46,260
我々は、すべてのコンピュータのメモリの1バイトだけを盗もうとしているが、これは位置0になります。

304
00:18:46,260 --> 00:18:49,560
我々はそれをNULLのニックネームを与えようとしている、と我々は約束しようとしている

305
00:18:49,560 --> 00:18:52,660
私たちは実際にそこに実際のデータを入れないことを

306
00:18:52,660 --> 00:18:56,770
私達はちょうど任意に特別な値、0、別名NULLを、必要とするので

307
00:18:56,770 --> 00:19:00,230
何かがうまくいかない場合、我々はユーザーが怒鳴ることができるように。

308
00:19:00,230 --> 00:19:03,590
そうでなければ、ここに何かを置く0を意味するのか知らないかもしれない

309
00:19:03,590 --> 00:19:05,490
またはそれは何かが間違っていた意味があるのですか？

310
00:19:05,490 --> 00:19:09,190
我々は、すべてがNULLの場合は何も返されませんでした同意する必要があります

311
00:19:09,190 --> 00:19:11,700
実際のアドレスが返されませんでした。

312
00:19:11,700 --> 00:19:15,210
さて、ここで私はちょうど私の私の人間の慣習を採用していると、メインから1を返す

313
00:19:15,210 --> 00:19:17,040
何かがうまくいかない場合。

314
00:19:17,040 --> 00:19:20,650
メインの戻り規約が良い場合には0を返すことであるのはそういうわけです。

315
00:19:20,650 --> 00:19:22,990
1または他のいくつかの値が悪い場合。

316
00:19:22,990 --> 00:19:28,200
しかし、GetStringメソッドと、何かが悪くなった場合、そのメモリを返すのお得情報がNULL任意の関数。

317
00:19:28,200 --> 00:19:33,480
>> オーケー。だから残念ながら、27行目、それはですが、超簡単に、完全に文字列のコピーに失敗した。

318
00:19:33,480 --> 00:19:35,740
なぜですか？我々は、これは次のように見ることができます。

319
00:19:35,740 --> 00:19:40,120
私はsのコピーを作り、それがトン呼び出しする27行目で主張している。

320
00:19:40,120 --> 00:19:45,790
だから私は2つの文字列今回の入力をユーザーに求めていないよ、私はちょうどsの値を言っている

321
00:19:45,790 --> 00:19:47,870
同様にトンに置かなければいけません。

322
00:19:47,870 --> 00:19:52,890
だから今ちょうど私がやっている29行目以降では、これがどのように壊れた実証するには？

323
00:19:52,890 --> 00:19:56,980
tの長さが0より大きい場合は最初に私がチェックしている。

324
00:19:56,980 --> 00:19:59,330
そこにいくつかの文字列があります。ユーザーが何かを打鍵した

325
00:19:59,330 --> 00:20:03,410
32行目は、明らかに、何をやっている？

326
00:20:03,410 --> 00:20:08,910
[聞き取れない生徒の応答] >>権。に、どのような種類の私はそれをやって言ったことから、それを推測することができます。

327
00:20:08,910 --> 00:20:13,200
しかし、技術的には、これは何をやっている？ T [0]何を表す？

328
00:20:13,200 --> 00:20:15,140
[学生]ゼロ番目の文字。 >> [マラン]ゼロ番目の文字。

329
00:20:15,140 --> 00:20:19,620
または、より人間に近い、Hはこのケースでは、多分ある何トン、の最初の文字。

330
00:20:19,620 --> 00:20:24,990
とtoupperはそれが言うことありません。これは、tのゼロ番目の文字を大文字にし、それを変更します。

331
00:20:24,990 --> 00:20:28,430
だから、これが意味するのは、tのゼロ番目の文字を取り、それを大文字にし、

332
00:20:28,430 --> 00:20:30,320
その同じ位置に戻す。

333
00:20:30,320 --> 00:20:35,540
私は小文字でhelloと入力した場合そのためには、これは資本Hに小文字のhを変更する必要があります

334
00:20:35,540 --> 00:20:41,400
しかし、問題は、行35と36で私は何をしようとしているんということであることは私達のsとtのためにプリントアウトしています。

335
00:20:41,400 --> 00:20:43,120
そして、あなたの勘は何ですか？

336
00:20:43,120 --> 00:20:47,250
私は実際に私はすべて小文字でhelloで入力かどうかを確認するために何をするつもり？

337
00:20:47,250 --> 00:20:52,280
何が印刷されたために起こっているのか？ >> [聞こえない学生の応答] >>それは何ですか？

338
00:20:52,280 --> 00:20:58,360
[学生]ビッグHと残り小。 >>ビッグHとなるための小さな残り、SまたはT？

339
00:20:58,360 --> 00:21:03,170
[学生]の両方。 >>両方。その通りです。だからここで何が起こっているのか見てみましょう。

340
00:21:03,170 --> 00:21:08,380
>> 私が先に行くと、これをコンパイルしましょう​​。これはCOPY1ので、COPY1を作る。かしこまりました。

341
00:21:08,380 --> 00:21:14,840
小文字でこんにちは：私が先に行くとCOPY1を実行すると、入力し、何かを言わせてズームイン。

342
00:21:14,840 --> 00:21:19,570
、それはコピーを大文字にしますが、それは明らかにだけでなく、元の大文字

343
00:21:19,570 --> 00:21:22,070
今、この物語の中で何が起こるか理由？

344
00:21:22,070 --> 00:21:27,030
27行目では、私は実際には、文字列をコピーしていないようです

345
00:21:27,030 --> 00:21:30,450
しかし、あなたは、直感的にそうであることを望んでいたかもしれませんが、

346
00:21:30,450 --> 00:21:33,680
あなたがこの絵を考えると、何が本当に私がやっていますか？

347
00:21:33,680 --> 00:21:35,410
絵の半分は同じです。

348
00:21:35,410 --> 00:21:39,390
tはまだ物語の中で存在していないので、それでは時間にロールバックすることができます。

349
00:21:39,390 --> 00:21:43,160
Sは、物語の中で存在することができますが、レッツはhello今回の小文字。

350
00:21:43,160 --> 00:21:46,710
だから私は、実際に打鍵したものを私が修正しましょう

351
00:21:46,710 --> 00:21:51,280
ここではこの場合、私たちはH-E-L-L-oを持っています。

352
00:21:51,280 --> 00:21:58,050
我々は、文字のシーケンスとしてそれを描くよ、ここに私の区切り線を入れて、私の\ 0。

353
00:21:58,050 --> 00:22:05,980
だから、これは我々が24っぽいを通じてできるだけ早く、1行目のようにされている場所です、与えるか、または取る、実行されました。

354
00:22:05,980 --> 00:22:07,800
これは私の記憶の絵です。

355
00:22:07,800 --> 00:22:10,800
私は27行目に到達したとき、何が起こりますか？

356
00:22:10,800 --> 00:22:14,730
前と同じように、私はこの正方形として描画しますポインタを取得します。

357
00:22:14,730 --> 00:22:19,740
それは、tと呼ばれています。と、デフォルトで、その値は何ですか？誰が知っているか？いくつかのゴミ値。

358
00:22:19,740 --> 00:22:22,060
>> だから私は、その先に疑問符などの抽象的なよ。

359
00:22:22,060 --> 00:22:27,670
とすぐに27行目の右側の実行時に、私は何トンの内側に入れています？

360
00:22:27,670 --> 00:22:30,770
sでの同じ事。

361
00:22:30,770 --> 00:22:34,120
であれば、その瞬間のために矢印のこの抽象化を削除して、我々は言う、

362
00:22:34,120 --> 00:22:40,330
ああ、これはあなたがtはs、セミコロンを取得すると言うときに、メモリの読み込みアドレス123であり、

363
00:22:40,330 --> 00:22:42,700
あなたは文字通りここに123を入れている。

364
00:22:42,700 --> 00:22:45,200
今、私たちは、一種の映像が付いて再び私たちの世界を単純化した場合、

365
00:22:45,200 --> 00:22:48,750
あなたが本当にやっただけで、あなたの世界に別の矢印が追加されます

366
00:22:48,750 --> 00:22:52,910
それはtからまったく同じ文字列を指している。

367
00:22:52,910 --> 00:22:59,730
だから、31行目と32に私が実際にT [0]を変更しようとするなら、

368
00:22:59,730 --> 00:23:05,580
今でT [0]どうやら代名詞は何ですか？ S [0]

369
00:23:05,580 --> 00:23:07,030
だからそれは起こっているすべてです。

370
00:23:07,030 --> 00:23:09,900
そして、この種のは少し低レベルと難解に感じていても

371
00:23:09,900 --> 00:23:12,760
そして、この種のは、おそらく直感的に、これは単に働いているはずのように感じている - 

372
00:23:12,760 --> 00:23:15,410
私は前のもののコピーを作った、それだけで働いていた - 

373
00:23:15,410 --> 00:23:18,590
あなたが実際に文字列が本当に何なのか考えてみれば、それはchar *です。

374
00:23:18,590 --> 00:23:21,700
まあ、それは何ですか？これは、いくつかの文字のアドレスです。

375
00:23:21,700 --> 00:23:24,930
その後、おそらくそれはあなたが何かをしようとする方が理にかなっている

376
00:23:24,930 --> 00:23:29,220
このようなスーパーは一見単純な、あなたがやっているすべてのメモリアドレスをコピーしています。

377
00:23:29,220 --> 00:23:32,530
あなたが実際に文字列そのものを使って何をやっていない。

378
00:23:32,530 --> 00:23:37,500
あなたは、コード内でこの問題を解決するだろうか見当がつかないので、たとえ、

379
00:23:37,500 --> 00:23:45,080
高レベルは、概念的には、我々は明らかに、sの真のコピーtaのようにするために何をすべきか必要なのでしょうか？

380
00:23:46,670 --> 00:23:48,820
うん。 >> [生徒]それに新しい場所を与えるか？まさに>>。

381
00:23:48,820 --> 00:23:50,800
>> 我々は、tのブランドの新しい場所を指定する必要があります。

382
00:23:50,800 --> 00:23:55,230
我々は、何らかの形で我々はメモリの新しいチャンクを取得している世界を作成する必要があります

383
00:23:55,230 --> 00:24:00,090
ただ明瞭さのために私は右のこの1下描きますが、それはそこである必要はありません。

384
00:24:00,090 --> 00:24:04,880
しかし、それは同じサイズである必要があるので、私は同じ場所で、これらの垂直線を描画します。

385
00:24:04,880 --> 00:24:09,720
これは、最初にすべてのゴミであれば、それは大丈夫です。誰が何だったか知っていますか？

386
00:24:09,720 --> 00:24:13,850
しかし、ステップ1は、私は必要なだけのメモリとして私に与えなければならないとしている

387
00:24:13,850 --> 00:24:18,630
ハローのコピーに合わせて、ここでのe、ここにhをコピーする方法を見つけ出す、

388
00:24:18,630 --> 00:24:20,390
ここなどリットル。

389
00:24:20,390 --> 00:24:24,880
しかし、これは既に詳細のいくつかは、まだ抽象的であっても、少し明らかに感じるはずです。

390
00:24:24,880 --> 00:24:28,690
この中には、この文字列をコピーするには、それがループまたはwhileループのためだけだ

391
00:24:28,690 --> 00:24:31,580
またはすべてのより身近になってきたいると何か。

392
00:24:31,580 --> 00:24:35,970
それでは、これを試してみましょう。私はcopy2.cに行こう。

393
00:24:35,970 --> 00:24:43,270
copy2.cでは、27行目を除いてほぼ同じプログラムを持っています。

394
00:24:43,270 --> 00:24:47,260
、それは少し複雑に見えますが、私たちは、ピース単位でそれを打破した場合

395
00:24:47,260 --> 00:24:48,950
左側は同じです。

396
00:24:48,950 --> 00:24:52,790
char *のtは疑問符とはいえ、メモリ内にこの事を作成

397
00:24:52,790 --> 00:24:54,680
私たちは、デフォルトで何があるか見当がつかないので。

398
00:24:54,680 --> 00:24:57,920
右側に我々は今、新しい関数、malloc関数を導入している

399
00:24:57,920 --> 00:25:00,640
メモリーてくれメモリを与える、割り当てる、

400
00:25:00,640 --> 00:25:06,900
そしてそれは明らかにどのように多くの引数が、どのように多くのものは括弧内がかかるのですが？

401
00:25:09,660 --> 00:25:12,130
私は1と2のつぶやきを聞いたが、それだけで1です。

402
00:25:12,130 --> 00:25:15,320
括弧の内側のちょうど1の事があることを意味しな​​いカンマは、ありません。

403
00:25:15,320 --> 00:25:17,720
他の括弧があるにもかかわらず、私が強調表示させ

404
00:25:17,720 --> 00:25:21,460
最も外側の括弧の中に何だし、それは、この式は次のとおりです

405
00:25:21,460 --> 00:25:25,880
（strlenは（S）+ 1）*はsizeof（char）は。

406
00:25:25,880 --> 00:25:29,190
我々は実際にこれを介して思えばそれで、これは私にsの長さを与えると言っている。

407
00:25:29,190 --> 00:25:34,440
なぜ私は長さに1を加算する、しかし、午前？ >> [聞こえない学生の応答]

408
00:25:34,440 --> 00:25:40,200
その通りです。我々は、最後尾には英語の意味もありません6番目の文字をこの男のためのスペースが必要

409
00:25:40,200 --> 00:25:42,250
しかし、特別なプログラム的な意味を持っていません。

410
00:25:42,250 --> 00:25:46,800
>> だから我々はそのために+ 1を必要とするため、strlenの戻り長さの人間の期待、

411
00:25:46,800 --> 00:25:50,890
helloまたは5、それはあなたに追加のNULL文字を与えるものではありません。

412
00:25:50,890 --> 00:25:52,980
だから私は、手動で+1でこれを追加します。

413
00:25:52,980 --> 00:25:56,060
そして、この、*サイズ（char）は、我々は前にこれを見ていない。

414
00:25:56,060 --> 00:25:57,480
これは技術的には関数ではありません。

415
00:25:57,480 --> 00:26:04,150
それはちょうどサイズがコンピュータ上でいくつかのデータ型であるかを表示します、特別なキーワードだ

416
00:26:04,150 --> 00:26:06,980
現実には、私たちの一部は32ビットコンピュータを持っているからです。

417
00:26:06,980 --> 00:26:10,900
私は自宅でかなり古いコンピュータを持っている、それだけでポインタを表すために32ビットを使用します。

418
00:26:10,900 --> 00:26:13,900
私はデータ型の大きさをしたそうだとすれば、それは32ビットであるかもしれません。

419
00:26:13,900 --> 00:26:18,300
しかし、私は私の新しい派手なコンピュータを使用している場合、私は64ビットの値を取り戻すかもしれません

420
00:26:18,300 --> 00:26:20,510
アドレスのような何かのために。

421
00:26:20,510 --> 00:26:25,400
したがって、この場合は、単にスーパーセーフであるとは、私たちのようなハードコード何かするつもりはない - 

422
00:26:25,400 --> 00:26:28,740
まあ、我々はこれまでに言ったことによるとcharのサイズは何ですか？

423
00:26:28,740 --> 00:26:34,450
我々はかなりそれが1バイトだし、それは軒並みかなり本当だと口頭で言ってきました。

424
00:26:34,450 --> 00:26:37,000
しかし、再び、仮定が悪くなる傾向があります。

425
00:26:37,000 --> 00:26:40,850
人々はあなたが意図していなかった方法で、お使いのソフトウェアを使用している場合、彼らはバグだらけのソフトウェアにつながる。

426
00:26:40,850 --> 00:26:44,750
そうしてみましょうこの抽象離れて、ちょうどより一般的に言う

427
00:26:44,750 --> 00:26:46,830
私は、メモリのこの多くのチャンクが必要

428
00:26:46,830 --> 00:26:50,210
とメモリの各チャンクは、文字の大きさと同等である必要があります

429
00:26:50,210 --> 00:26:54,870
これは、このケースでは、実際には1に等しいですが、それは、それを作成するための、より一般的な方法です。

430
00:26:54,870 --> 00:27:00,460
言葉は、helloがないような場合は、どのように多くのバイトmallocが明らかにハローに割り当てるのでしょうか？

431
00:27:00,460 --> 00:27:04,980
[学生] 6。 >>シックス。我々は画面上に疑問符を持っているとおりに正確に多くの。

432
00:27:04,980 --> 00:27:07,800
そして、今、GetStringメソッドの理解に基づいた推測取る

433
00:27:07,800 --> 00:27:12,790
malloc関数は、おそらく何を返すのでしょうか？ >> [生徒]アドレス。

434
00:27:12,790 --> 00:27:17,020
何のアドレス？最初のメモリチャンクの。

435
00:27:17,020 --> 00:27:20,670
>> 我々は、いくつかの他の機能ので、何があるか見当がつかない

436
00:27:20,670 --> 00:27:23,010
以前にこのメモリを使用している可能性があります。

437
00:27:23,010 --> 00:27:28,380
しかし、mallocは、GetStringメソッドのように、メモリの最初のバイトのアドレスを返します

438
00:27:28,380 --> 00:27:30,540
それはあなたのために取っておかれていること。

439
00:27:30,540 --> 00:27:38,380
しかし、どのようなことが行わないと、バックスラッシュヌル文字で、この空白を埋めている

440
00:27:38,380 --> 00:27:43,030
整数、文字列、配列、：何かを割り当てるためにmallocを使用することができますアウトそれは回りため

441
00:27:43,030 --> 00:27:45,700
山車、学生構造。

442
00:27:45,700 --> 00:27:47,750
あなたは完全に一般的にmallocを使用することができます。

443
00:27:47,750 --> 00:27:51,470
それは気にしたりするためのメモリを割り当てているものを知っている必要はありません。

444
00:27:51,470 --> 00:27:55,810
だから、\ 0を置くためにmallocのおこがましいだろう

445
00:27:55,810 --> 00:27:58,340
メモリの各チャンクの終わりに、それはあなたを与えている

446
00:27:58,340 --> 00:28:02,620
この\ 0のものは、単なる文字列のための規則ですので。

447
00:28:02,620 --> 00:28:06,310
それはint型に使用されていないのは、それが浮動小数では使われない、それは学生のためには使用されません。

448
00:28:06,310 --> 00:28:11,730
それでmallocで落とし穴が負担はあなたに完全にプログラマであるということです

449
00:28:11,730 --> 00:28:16,790
あなたが割り当てられ、何バイトを覚えて、これまで、forループを使用しないように

450
00:28:16,790 --> 00:28:21,570
またはwhileループとあなたが与えられたメモリの塊の境界を越えて行く。

451
00:28:21,570 --> 00:28:23,540
できるだけ早くあなたがメモリを割り当てるように、別の言い方をすれば、

452
00:28:23,540 --> 00:28:28,510
は、オペレーティング·システムを求めることはできない、ああ、ところで、これがどのようにメモリのチャンクのビッグでしたか？

453
00:28:28,510 --> 00:28:32,080
あなたは、その値が必要な場合は覚えて完全にあなた次第それだけです。

454
00:28:32,080 --> 00:28:34,330
>> だから私はこのメモリを使用するように進んで方法を見てみましょう。

455
00:28:34,330 --> 00:28:38,430
28行目と29では、なぜ私はこれをやっている？

456
00:28:39,850 --> 00:28:42,260
ちょうど合計サニティチェック。

457
00:28:42,260 --> 00:28:45,110
念のために何かが間違っていた、私はメモリのいくつかのクレイジーな量を求める

458
00:28:45,110 --> 00:28:48,690
または私がそう多くの事は、ちょうど十分なメモリがないことをコンピュータ上で実行されている

459
00:28:48,690 --> 00:28:51,780
そのような何かは、私は、少なくともnullをチェックしたいと思います。

460
00:28:51,780 --> 00:28:55,260
現実には、ほとんどのコンピュータはあなたにすべてのプログラムのような錯覚を与えるだろう

461
00:28:55,260 --> 00:28:57,080
あなたのRAMの全体を使用することができ、

462
00:28:57,080 --> 00:29:00,740
しかし、たとえそうであっても、おそらくいくつかのクレイジーな長い文字列で、ユーザがタイプした場合は、彼らは悪いやつだから

463
00:29:00,740 --> 00:29:03,440
そして、彼らは実際に、そこにあなたのプログラムやハックをクラッシュしようとしている

464
00:29:03,440 --> 00:29:07,300
あなたは少なくともmallocの戻り値をチェックしたい、それはヌルと等しいかどうかを指定します。

465
00:29:07,300 --> 00:29:11,630
それがないなら、私はそのような場合に何をするかわからないので、ちょうど今やめておきましょう。

466
00:29:11,630 --> 00:29:13,950
どのように私は、文字列をコピーするのですか？これにはいくつかの方法があります。

467
00:29:13,950 --> 00:29:18,850
そこにstrのC言語の関数をコピーしていますが、私たちは、この昔ながらの方法で行うためには、それは簡単なスーパーです。

468
00:29:18,850 --> 00:29:23,110
>> 最初に私はsの長さが何であるかを把握しましょう​​。

469
00:29:23,110 --> 00:29:26,930
私は、ループ内でこれを入れたかもしれないが、その代わりに、私はちょうどここではわかりやすくするために消した。

470
00:29:26,930 --> 00:29:30,610
だから、nが今明らかに、5元の文字列の長さが格納されます。

471
00:29:30,610 --> 00:29:35,290
次にループのための私に私がアップした場合は0からnまで反復するんだけど、

472
00:29:35,290 --> 00:29:40,940
し、反復のたびに私が入れているs [i]はtの内部[i]とする。

473
00:29:40,940 --> 00:29:45,060
だから、それは私が前に文字列を指して私の2本の指で暗示なのです。

474
00:29:45,060 --> 00:29:49,260
このforループは次のように反復したように、私はここにhをコピーするつもりだ、

475
00:29:49,260 --> 00:29:52,890
ここで、Lはここにに電子本がsであるので、これはtです。

476
00:29:52,890 --> 00:29:58,770
そして、最後に、35行目では、なぜ私はこれをやっている？

477
00:29:58,770 --> 00:30:03,770
私は、文字列tを終了していることを確認する必要があります。

478
00:30:03,770 --> 00:30:06,170
そして、私は明示的なスーパーであることが、このようにそれをやった。

479
00:30:06,170 --> 00:30:09,510
しかし、あなたができれば、これを行うための別の方法を誰かを提案する。

480
00:30:09,510 --> 00:30:13,930
私は本当に35行は必要ありません。これを行うには別の方法があります。

481
00:30:13,930 --> 00:30:18,880
うん。 >> [聞こえない学生の応答] >>それは大声で言ってやる。

482
00:30:18,880 --> 00:30:20,960
[学生]より小さいか等しい。まさに>>。

483
00:30:20,960 --> 00:30:24,450
私達はちょうどより小さいか、一般的には悪くなっているnに等しいと言えるでしょう

484
00:30:24,450 --> 00:30:28,190
なぜなら、ほとんどの場合、私たちが頼りにしている事に等しいに上がるとき

485
00:30:28,190 --> 00:30:30,000
我々はあまりにも遠くに1ステップ移動します。

486
00:30:30,000 --> 00:30:32,170
しかし、覚えて、我々はどのように多くのバイトを割り当てたのですか？

487
00:30:32,170 --> 00:30:37,210
我々は6の合計なので、5 + 1 sのstrlenを割り当てられた。

488
00:30:37,210 --> 00:30:39,980
したがって、この場合、我々はこのような何かができる

489
00:30:39,980 --> 00:30:46,450
我々は非常に端にだけ挨拶も\ 0ではありませんコピーしているようにします。

490
00:30:46,450 --> 00:30:49,860
別の方法として、我々は、strcpyのは、strのコピーと呼ばれる機能を使用することができます

491
00:30:49,860 --> 00:30:51,700
それはほぼ同じくらい楽しいことはないだろう。

492
00:30:51,700 --> 00:30:54,000
しかし、それがすべてで、それがフードの下に行います。

493
00:30:54,000 --> 00:30:56,050
それから最後に、私たちは前と同じことを行う。

494
00:30:56,050 --> 00:31:01,620
私はtを大文字にしてから、私はこのようなオリジナルのルックスとコピーがそのようになっていることを主張している。

495
00:31:01,620 --> 00:31:08,570
それでは、今、これを試してみましょう。私はここに行ってみよう。 COPY2を作る。我々はズームインしてCOPY2を実行することになるでしょう。

496
00:31:08,570 --> 00:31:13,840
私は小文字にhelloを入力するつもりですし、実際に私は、元のようにこんにちは小文字取得

497
00:31:13,840 --> 00:31:16,930
コピーのための資本こんにちはけど。

498
00:31:16,930 --> 00:31:20,300
しかし、私はちょうどまだいないよ。私はここ1最後の事を行う必要があります。

499
00:31:20,300 --> 00:31:28,000
46と47は明らかにメモリを解放しているが、それは実際に何を意味するのか？

500
00:31:28,000 --> 00:31:33,250
私は何をやっていると、46行目と47行を呼び出すことによって、思いますか？

501
00:31:33,250 --> 00:31:38,900
これはどういう効果があるのでしょうか？うん。

502
00:31:38,900 --> 00:31:43,140
[聞き取れない生徒の応答] >>その通りです。

503
00:31:43,140 --> 00:31:46,380
>> あなたはただ、ちょっと、このメモリのおかげで、オペレーティング·システムに指示しています。

504
00:31:46,380 --> 00:31:48,320
これで、他の誰かのためにそれを使用することができます。

505
00:31:48,320 --> 00:31:50,790
そしてここでは、ゴミの値の完璧な例です。

506
00:31:50,790 --> 00:31:55,430
私はちょうど、2ヶ所にhelloという言葉を書き留めて、このメモリを使用している

507
00:31:55,430 --> 00:31:57,490
ここ、ここ、ここ、ここに。

508
00:31:57,490 --> 00:32:00,910
だから、これはH-E-L-L-O-\ 0です。

509
00:32:00,910 --> 00:32:06,960
しかし、私は46行目と47行を呼び出すと、あなたは、絵の面でそこに何が起こるか知っていますか？

510
00:32:06,960 --> 00:32:10,010
実際には、待って、この絵は古いものです。

511
00:32:10,010 --> 00:32:12,550
我々はコピーを作成したら、この男は、実際には、ここを指している

512
00:32:12,550 --> 00:32:16,110
ので、もう一度番号を削除して、単なる抽象的な離れて私たちの矢印のようにしてみましょう。

513
00:32:16,110 --> 00:32:19,370
私は自由を呼び出すときに何がこの写真ではどうなりますか？

514
00:32:19,370 --> 00:32:22,750
[聞き取れない生徒の応答] >>さえない。

515
00:32:22,750 --> 00:32:29,510
私はsとtの空き呼び出す場合 - トリックの質問の種類 - この絵はまったく変更されません

516
00:32:29,510 --> 00:32:33,880
sを呼び出すと、呼び出しているため、tはちょうど、オペレーティングシステムに指示

517
00:32:33,880 --> 00:32:39,010
ねえ、あなたは再びこのメモリを使用することができますが、これがnullに変更されることはありません

518
00:32:39,010 --> 00:32:41,840
またはいくつかの特殊文字は、それは、これを変更しない

519
00:32:41,840 --> 00:32:47,350
それは、Hまたはeまたは何か他のもののいずれかの場所でLまたはlまたはoを変更することはありません。

520
00:32:47,350 --> 00:32:51,610
絵の面では、できるだけ早くあなたが自由に、何も変化を呼ぶ。

521
00:32:51,610 --> 00:32:56,570
なぜならもし私がその後、このプログラムで、そこにゴミの値の起点に位置してい

522
00:32:56,570 --> 00:33:01,010
そのようなGetStringまたはmallocまたは何かでより多くのメモリ用のオペレーティングシステムを尋ねる

523
00:33:01,010 --> 00:33:04,900
およびオペレーティング·システムは、確かに、私はちょうど解放された12バイトのメモリを持っている、と言う

524
00:33:04,900 --> 00:33:08,080
これらを使用して、あなたは何を手渡しするつもりですか？

525
00:33:08,080 --> 00:33:10,830
あなたは、私たちが一般的に描くだろうとメモリの塊を手渡しすることになるだろう

526
00:33:10,830 --> 00:33:13,700
疑問符を含むが、これらの疑問符は何ですか？

527
00:33:13,700 --> 00:33:17,000
彼らは、H-E-L-L-O、H-E-L-L-Oであることが起こる。

528
00:33:17,000 --> 00:33:20,940
これらはできるだけ早くあなたがそのメモリを解放としての新しいガベージ値です。

529
00:33:20,940 --> 00:33:22,750
>> 現実世界の含意がここにもあります。

530
00:33:22,750 --> 00:33:24,720
これは、RAMで行うことになりますが、コンピュータ

531
00:33:24,720 --> 00:33:26,720
実際にはディスクと同じことを行う。

532
00:33:26,720 --> 00:33:30,620
我々は、科学捜査に焦点を当て、将来の問題セットで、特にこのことについて話します。

533
00:33:30,620 --> 00:33:36,170
しかし、あなたがあなたのデスクトップにいくつかの重要な財務ファイルがある場合は実際に何が起こるのか

534
00:33:36,170 --> 00:33:39,600
またはいくつかの不完全なJPEGとあなたのゴミ箱にドラッグし、

535
00:33:39,600 --> 00:33:44,390
あなたがゴミ箱やごみ箱にドラッグしたときに何が起こるか？

536
00:33:44,390 --> 00:33:47,240
あなたは、私が何を話しているかを知っていた。 [笑い]

537
00:33:47,240 --> 00:33:52,370
あなたのごみ箱またはゴミ箱にその証拠をドラッグしたときに何が起こりますか？

538
00:33:52,370 --> 00:33:55,920
[聞き取れない生徒の応答]

539
00:33:55,920 --> 00:33:58,000
まあので注意。あなたがそれを行うとどうなりますか？

540
00:33:58,000 --> 00:34:01,030
短い答えは右、何もありません？

541
00:34:01,030 --> 00:34:04,790
スケッチや機密ファイルはまだちょうどあなたのハードドライブのどこかにそこに座っています。

542
00:34:04,790 --> 00:34:07,940
私たちのほとんどは、少なくともあなたのゴミ箱を空にする必要があり、ハードな方法を学んできました

543
00:34:07,940 --> 00:34:10,429
またはあなたのごみ箱は、実際にファイルを削除します。

544
00:34:10,429 --> 00:34:13,440
そして実際には、右クリックするか、ゴミ箱をクリックしてコントロールすることができたとき

545
00:34:13,440 --> 00:34:15,580
またはファイル、ゴミ箱を空または何を選ぶ

546
00:34:15,580 --> 00:34:21,420
そして実際にゴミ箱や実際にこの絵に次に何が起こるかごみ箱、空？

547
00:34:22,810 --> 00:34:25,969
もっと何もありません。だから、何も実際にディスク上に起こりません。

548
00:34:25,969 --> 00:34:30,880
>> 我々だけで一時的に脱線して書き込む場合と -  I'llはちょうどこれの裏を使用しています。

549
00:34:30,880 --> 00:34:34,639
だから今の話は、プログラムが存在するところであるRAMから変化している

550
00:34:34,639 --> 00:34:39,250
あなたは彼らが長期的に保存されている場所である、ディスクには、それらを実行している間

551
00:34:39,250 --> 00:34:42,920
電力は今のところ、外に出るときでも - と我々は将来的にはこれに戻ってくる - 

552
00:34:42,920 --> 00:34:46,380
ただこれは、コンピュータのハードドライブの内部を表しているふりをしてみましょう

553
00:34:46,380 --> 00:34:50,110
ので、戻って一日で、彼らははるかにフロッピーディスクのように、円形のディスクであることを用いた。

554
00:34:50,110 --> 00:34:55,130
あなたには、いくつかの敏感なExcelファイルを持っているそうだとすれば、それはメモリの塊を取るかもしれない

555
00:34:55,130 --> 00:34:59,770
お使いのコンピュータのディスクに、と私はちょうど同じ任意の1と0を描いてる。

556
00:34:59,770 --> 00:35:03,970
あなたのゴミ箱にそのようなファイルをドラッグするか、ビンをリサイクルすることができ、

557
00:35:03,970 --> 00:35:07,750
AppleとMicrosoftは決めたから、文字通り何も起こりません

558
00:35:07,750 --> 00:35:10,450
ごみ箱とごみ箱は実際には単なる一時的なプレースホルダです。

559
00:35:10,450 --> 00:35:14,710
たぶん、最終的にOSがあなたのためにそれを空にしますが、一般的に、それは何もしません、

560
00:35:14,710 --> 00:35:17,090
あなたが宇宙には本当に残り少ない少なくともまで。

561
00:35:17,090 --> 00:35:20,870
>> ただし、空のゴミ箱やごみ箱を空に行くとき、

562
00:35:20,870 --> 00:35:23,460
同様に、何もこの絵に起こりません。

563
00:35:23,460 --> 00:35:28,590
お使いのコンピュータ上の他の場所に起こるすべてのことですが、テーブルのいくつかの種類があります。

564
00:35:28,590 --> 00:35:35,400
それは、、としましょう​​、と言って少しカンニングペーパーのようにソートのresume.docだ

565
00:35:35,400 --> 00:35:40,920
ので、あなたのハードディスク上の場所123に住んでいたMicrosoft Wordファイルであなたの履歴書、

566
00:35:40,920 --> 00:35:43,710
メモリではなくではなくRAMにしかし、あなたのハードディスク上、

567
00:35:43,710 --> 00:35:49,050
と456であなたの大ざっぱなJPEGの生活、あなたのExcelファイルが789で、またはどこに住んでいます。

568
00:35:49,050 --> 00:35:53,640
あなたが実際にゴミ箱やごみ箱を空にしてファイルを削除すると、

569
00:35:53,640 --> 00:35:59,530
この絵は変わりません。ハードドライブ上の0と1はどこにもありません。

570
00:35:59,530 --> 00:36:03,930
しかし、この表には、ある種のこの小さなデータベースは、変更を行います。

571
00:36:03,930 --> 00:36:08,750
ファイルはいくつかの意味で削除されているかのようにあなたの履歴書を削除すると、それは、ある

572
00:36:08,750 --> 00:36:12,790
その事は、ハードドライブ上のどこに住んでますが、すべてのコンピュータが忘れされません。

573
00:36:12,790 --> 00:36:17,870
あなたの履歴書またはこれらの他のファイルのいずれかを構成する0と1はまだそのままです。

574
00:36:17,870 --> 00:36:21,960
>> あなたが誤ってこれをしたのであれば、非ゼロの確率はまだある

575
00:36:21,960 --> 00:36:25,800
あなたは、Norton Utilitiesまたはいくつかの商用ソフトウェアを使用してデータを回復できること

576
00:36:25,800 --> 00:36:29,810
その目的は生活の中で一種の孤立されたことを、0と1を見つけることで、

577
00:36:29,810 --> 00:36:33,300
ここで忘れてしまっていますが、データを取り戻すことができるように、ここを去った。

578
00:36:33,300 --> 00:36:38,410
または警察やFBIの法医学調査官は、実際にはハードドライブを取るだろう

579
00:36:38,410 --> 00:36:42,550
そして実際には、Excelファイルのように見えますが、JPEGのような0と1その表情のパターンを探して

580
00:36:42,550 --> 00:36:46,400
とコンピュータがそれらを忘れてしまった場合でも、それらをそのように回復します。

581
00:36:46,400 --> 00:36:49,820
だから我々は、将来的に説明しますと、データを削除するには、本当に唯一の方法は、

582
00:36:49,820 --> 00:36:54,190
することで、ファイルやハードディスクをスクラブまたは拭くことです - 

583
00:36:54,190 --> 00:36:56,540
あなたは本当に、0と1を取り除くことができない

584
00:36:56,540 --> 00:36:59,440
そうしないと、ギガバイトのハードドライブで開始したいので、

585
00:36:59,440 --> 00:37:02,380
あなたは常に削除された場合、あなたは、メガバイトのハードディスクドライブで終わるだろう

586
00:37:02,380 --> 00:37:04,380
文字通り、0と1。

587
00:37:04,380 --> 00:37:06,310
あなたが本当にあなたの曲をカバーしたいならそれで、あなたは何をしますか

588
00:37:06,310 --> 00:37:10,510
そして根本的な問題はまだディスク上に0と1があるということです？

589
00:37:10,510 --> 00:37:14,930
私はあなたがデバイスを物理的に壊してしまうことをジェスチャーを誰かを参照してください。それが動作します。

590
00:37:14,930 --> 00:37:19,600
[笑い]しかし、それはより合理的であるもの高価な解決策のようなものだかな？

591
00:37:19,600 --> 00:37:23,270
うん。 >> [生徒]、それらを上書きします。 >>何でそれらを上書きしますか？ >> [生徒]その他のデータ。

592
00:37:23,270 --> 00:37:29,070
その他のデータ。あなただけの0または1またはすべて0、すべて1を使用してディスクを上書きすることができます。

593
00:37:29,070 --> 00:37:31,230
>> そして、それはいくつかのソフトウェアが何をするのか本当にです。

594
00:37:31,230 --> 00:37:33,570
あなたは、ソフトウェアを購入したり、無料のソフトウェアを取得することができます

595
00:37:33,570 --> 00:37:36,610
さらに、Windowsで少ないので、これらの日のMac OSに組み込まれ、

596
00:37:36,610 --> 00:37:38,660
安全に消去する機能です。

597
00:37:38,660 --> 00:37:41,960
実際に、あなたがMacを持っていて、これを行う場合は、今日すべてのホームランをしてみたいのなら、

598
00:37:41,960 --> 00:37:45,740
あなたが持っている場合は、ゴミ箱の中にいくつかのものは、あなたは、確実にゴミ箱を空にするを行うことができます

599
00:37:45,740 --> 00:37:47,610
これは、まさにその作業を行います。

600
00:37:47,610 --> 00:37:53,350
ちょうどここにファイルを消去するのではなく、それは、ここで0と1を消去しません

601
00:37:53,350 --> 00:38:01,240
むしろ、それだけで0とドット、ドット、ドットには、例えば、それらをすべて変更します。

602
00:38:01,240 --> 00:38:05,330
だから、あなたの将来のpsetの一つは、実際には意図的にデータを回復するであろう - 

603
00:38:05,330 --> 00:38:08,430
我々は人々、場所、キャンパス上のものの撮影した写真

604
00:38:08,430 --> 00:38:12,810
私たちは、デジタルカメラのメモリーカードのフォレンジックイメージを作ってあげる

605
00:38:12,810 --> 00:38:17,120
そのまったく同じ考えです - あなたは、実際に見つけるために挑戦しなければならないでしょう

606
00:38:17,120 --> 00:38:20,160
ハードドライブ上のJPEGファイルを表すパターン

607
00:38:20,160 --> 00:38:23,610
ずっとそのメールその元学生のように私は数週間前に読みました

608
00:38:23,610 --> 00:38:25,860
妹の写真を回復する。

609
00:38:25,860 --> 00:38:30,300
なぜ我々はここで5分間の休憩を取ることはありません、我々はメモリの詳細に再編成します。

610
00:38:33,030 --> 00:38:38,610
そこでここでは、物事は少しハラハラドキドキ取得する場所ですが、これは非常に強力なステップです

611
00:38:38,610 --> 00:38:40,480
このすべての詳細を理解するため。

612
00:38:40,480 --> 00:38:42,900
ここpointers.cと呼ばれるプログラムです。

613
00:38:42,900 --> 00:38:45,430
それは今日のサンプルコードの一つです。

614
00:38:45,430 --> 00:38:51,280
最初の数行は、22〜19で、私たちがやっていることすべてがGetStringメソッドのようなものであることに注意してください

615
00:38:51,280 --> 00:38:54,460
とsに格納し、アドレスを返す。

616
00:38:54,460 --> 00:38:58,380
今後のpsetさえ3用したい場合はしかし、PSET 4と上

617
00:38:58,380 --> 00:39:01,030
あなたは自分自身をオフこれらの補助輪を取るために始めることができる場所、

618
00:39:01,030 --> 00:39:04,030
文字列がもう存在しているふりをする理由はありません。

619
00:39:04,030 --> 00:39:07,030
それは確かにただのchar *を言って起動しても大丈夫です。

620
00:39:07,030 --> 00:39:12,610
>> 余談ですが、オンラインの参考文献に、書籍では、多くの場合、変数の横に星が表示される場合があります。

621
00:39:12,610 --> 00:39:15,600
あなたも、それの両側の前後にスペースが表示される場合があります。

622
00:39:15,600 --> 00:39:17,680
それらのすべてが機能的に正しいです。

623
00:39:17,680 --> 00:39:21,180
ただし今のところ、我々はスーパーを明確にするために、このアプローチを標準化します

624
00:39:21,180 --> 00:39:24,000
そのchar *は文字ポインタを言っているようなものです。

625
00:39:24,000 --> 00:39:25,680
これはデータタイプです。

626
00:39:25,680 --> 00:39:28,730
そして、変数の名前は、このケースではsです。

627
00:39:28,730 --> 00:39:31,180
だから我々は文字列を得ていると我々はそれだと呼んでいます。

628
00:39:31,180 --> 00:39:35,180
その後ダウンして、ここで私は実際に策略を少しやっていることに気づく。

629
00:39:35,180 --> 00:39:39,080
これは超簡単なの一種でポインタ演算を、と呼ばれています。

630
00:39:39,080 --> 00:39:41,790
それだけでポインタに数字を加算および減算を意味します。

631
00:39:41,790 --> 00:39:43,660
しかし、これは実際に動作します。

632
00:39:43,660 --> 00:39:49,170
このプログラムは明らかにそのような最終的な結果は、その行あたりの文字列の1文字を出力します - 

633
00:39:49,170 --> 00:39:54,920
ちょうどので、私たちは、これがどこに行っているか台無しにポインタを作り、ポインタを実行し、私がズームインさせることができます

634
00:39:54,920 --> 00:39:58,940
今私は、ハローのようなものでタイプAとタイプ入力してみましょう

635
00:39:58,940 --> 00:40:01,080
そしてそれは1行につき1文字を出力します。

636
00:40:01,080 --> 00:40:04,730
最大秒前まで、我々は、角括弧表記でこれをやっていただろう。

637
00:40:04,730 --> 00:40:09,760
我々はループのために持っているだろうと我々は、sのprintf行うと思います[i]は、我々は再び、何度も何度もそれを行うと思います

638
00:40:09,760 --> 00:40:11,950
各行の末尾にバックスラッシュnです。

639
00:40:11,950 --> 00:40:16,800
しかし、このプログラムは異なります。このプログラムは、文字通り、算術を使用しています。

640
00:40:16,800 --> 00:40:18,860
だからここで何が起こっているのですか？

641
00:40:18,860 --> 00:40:24,720
まず第一に、このループがあっても実行する前に、ちょうど明確にするために、実際の何ですか？

642
00:40:24,720 --> 00:40:27,270
Sはありますか？ >> [生徒]アドレス。 >>アドレス。

643
00:40:27,270 --> 00:40:32,980
>> そしてそれは、ハローの場合には、hでその単語、の最初の文字のアドレスです。

644
00:40:32,980 --> 00:40:37,370
だからsは、この特定の例では、hのアドレスです。

645
00:40:37,370 --> 00:40:41,850
だから何それがS + Iを行う意味があるのですか？

646
00:40:41,850 --> 00:40:46,280
まあ、私は、このforループでは0から始まります。我々は、何回もやった。

647
00:40:46,280 --> 00:40:49,760
私は明らかに、文字列の長さまで行くつもりです。

648
00:40:49,760 --> 00:40:53,950
だから、このループの最初の繰り返しで、私は明らかに0である。

649
00:40:53,950 --> 00:41:01,740
したがって、この式は、S + Iを言っている - むしろ、S +0、つまりちょうど明らかにSさん。

650
00:41:01,740 --> 00:41:04,320
だからここに* sは何ですか？

651
00:41:04,320 --> 00:41:08,530
今、私たちは少し異なる方法でスターを使っている。

652
00:41:08,530 --> 00:41:13,080
我々はtとsのコピーの話をやっているので私が先に行くと、トンを取り除くましょう。

653
00:41:13,080 --> 00:41:15,540
今、私たちは単にsを含むストーリーをお伝えしたいと思います。

654
00:41:15,540 --> 00:41:20,090
ので、この瞬間に、string型をした後、私たちの世界は、それが以前と全く同じように見えます

655
00:41:20,090 --> 00:41:26,630
ちょうどSがHのアドレスを格納し、より一般的にハローの文字列を指している。

656
00:41:26,630 --> 00:41:33,170
私は今、*（S + I）のような行を行う場合は、これを試してみましょう。

657
00:41:33,170 --> 00:41:40,140
だから*（S + I）。これが0であるので、私はこれを簡素化しましょう​​、これは*（S 0）です。

658
00:41:40,140 --> 00:41:43,790
まあ、ちょっと待って。さらに簡素化されます。これは*（s）である。

659
00:41:43,790 --> 00:41:47,020
さて、今括弧は愚かなの一種であるので、今ちょうど* sは行いましょう。

660
00:41:47,020 --> 00:41:50,540
だから、このループの最初の繰り返し、ハイライト表示さ​​れ、その行は26で、

661
00:41:50,540 --> 00:41:53,650
これを印刷にほとんど同等である。

662
00:41:53,650 --> 00:41:56,040
* sのデータ型は何ですか？

663
00:41:56,040 --> 00:42:00,770
この文脈では、星がS自体の隣にあることを起こるので

664
00:42:00,770 --> 00:42:04,930
しかし、より具体的には、私たちはもはや、sを宣言されていないため、

665
00:42:04,930 --> 00:42:09,730
我々はもはや変数を作成していない、26行目のchar *の言及は、ありません

666
00:42:09,730 --> 00:42:14,280
キーワード文字列の言及がありません、我々だけでは、sという変数を使用している

667
00:42:14,280 --> 00:42:19,650
それが今では星が意味を混乱させて、確かに、少し異なるがあり、判明した。

668
00:42:19,650 --> 00:42:26,590
ここで* sは存在するものは何でもsおよび印刷のアドレスに送られることを意味します。

669
00:42:26,590 --> 00:42:33,750
だからsがここにある、* sが - のような滑り台とはしごのようなものには、矢印をたどる - ここ。

670
00:42:33,750 --> 00:42:35,850
だから、これは* sです。

671
00:42:35,850 --> 00:42:39,060
>> だから、26行目でそのループの最初の繰り返しで何が印刷される？

672
00:42:39,060 --> 00:42:42,170
私は文字のプレースホルダです％cを、プリントアウトする

673
00:42:42,170 --> 00:42:48,520
その後、新しい行の\ n。 *（S + I）iは0がちょうどこれですです。

674
00:42:48,520 --> 00:42:53,670
だから私は％cにに何charを置けばよいでしょうか。 H.

675
00:42:53,670 --> 00:42:56,900
これがどこに行っているか、あなたはおそらく見ることができます -   - ループの次の反復で

676
00:42:56,900 --> 00:43:01,350
次の繰り返し私は明らかに1であるので、この手段の1、

677
00:43:01,350 --> 00:43:05,580
その後すぐに私は今、星は言う必要があるため、括弧が必要なのでしょうか

678
00:43:05,580 --> 00:43:08,620
メモリアドレスの1に行く。

679
00:43:08,620 --> 00:43:14,170
sは何ですか？のが時間内にロールバックし、この矢印が今、実際に私達に好意をやっていないとしましょう​​。

680
00:43:14,170 --> 00:43:18,450
これはナンバー123を保存していると言うより具体的にしてみましょう

681
00:43:18,450 --> 00:43:25,110
この文字列の先頭がhello、これはアドレス123であるので、これは等124である、と。

682
00:43:25,110 --> 00:43:30,550
だから私は、S 1を言って2回目の繰り返しで、それは、123 1を言ってようなものだ

683
00:43:30,550 --> 00:43:35,340
そうでなければ124として知られているので、何charは2回目の反復に印字されますか？

684
00:43:35,340 --> 00:43:37,850
メモリアドレス124でE。

685
00:43:37,850 --> 00:43:44,440
次に+を再度、125、126、127、と私たちはここに来る前に、このループは、ありがたいことに停止します

686
00:43:44,440 --> 00:43:49,040
私は私が高すぎカウントされないことを確認するためにstrlenを使用していますので。

687
00:43:49,040 --> 00:43:50,810
だから、あまりにもそれである。

688
00:43:50,810 --> 00:43:55,000
繰り返しますが、これは、我々は一週間前に行われたかのようになります。

689
00:43:55,000 --> 00:43:59,200
我々は両方を行うにはしたくないにもかかわらず、私はその下の行に書いてみましょう。

690
00:43:59,200 --> 00:44:02,500
これはここと同じです。

691
00:44:02,500 --> 00:44:08,310
>> だから我々は数週間のためにそれを求めてきたようにsは、文字列であっても、sは本当にchar *である。

692
00:44:08,310 --> 00:44:13,270
私たちはスーパー肛門になりたいのであれば、それは、特定の文字を書くことが本当に適切だ

693
00:44:13,270 --> 00:44:17,490
これらの数値アドレスとこの星の演算子を使用してi番目の位置で、

694
00:44:17,490 --> 00:44:20,470
しかし率直に言って、これはちょうどそんなにクリーナーです。だから、これは悪いことではありません。

695
00:44:20,470 --> 00:44:26,720
いいえここに27行をやって停止する理由はありませんが、26は機能的には同じですが、

696
00:44:26,720 --> 00:44:31,570
そしてそれは我々がこれまで扱ってきたまさに理由のために、機能的に同じです。

697
00:44:31,570 --> 00:44:33,650
そして最後に、29がちょうど良い習慣です。

698
00:44:33,650 --> 00:44:38,420
sのフリーコールすると、今あなたがGetStringメソッドはあなたを与えていたメモリをバック与えていることを意味します

699
00:44:38,420 --> 00:44:41,630
再び、私は週にgetString、月曜日に述べたようので、

700
00:44:41,630 --> 00:44:44,180
あなたのコードにバグを導入してきました。

701
00:44:44,180 --> 00:44:46,490
週間のあなたのコードは、メモリリークがありました

702
00:44:46,490 --> 00:44:49,970
それによってあなたは、メモリにGetStringを求めてきたが​​、あなたが戻ってそれを与えるされていなかった。

703
00:44:49,970 --> 00:44:53,410
そして、それは意図的に教育的に当社が選ばれました

704
00:44:53,410 --> 00:44:55,880
それが早い段階で考えるようにあまりにも多くのだから。

705
00:44:55,880 --> 00:44:57,710
しかし、今、私たちはより多くの対称性を必要としています。

706
00:44:57,710 --> 00:45:00,830
あなたがメモリをコンピュータに言わせれば、として、GetStringメソッドの場合である

707
00:45:00,830 --> 00:45:02,820
などの場合は、malloc関数らしいが

708
00:45:02,820 --> 00:45:07,970
あなたも無料のpset 4以降、このようなメモリのために今しなければならない。

709
00:45:07,970 --> 00:45:11,650
これは、int nを言って異なっていることに注意してください。

710
00:45:11,650 --> 00:45:15,040
あなたがGetStringメソッドを呼び出していませんでしたので、これを解放する必要がありません

711
00:45:15,040 --> 00:45:16,890
そしてあなたは、mallocを呼び出していませんでした。

712
00:45:16,890 --> 00:45:20,610
>> そして、我々は最終的にわかるようにあなたはgetIntを呼ばれた場合でも、

713
00:45:20,610 --> 00:45:25,520
あなたが実際に整数の周りを通過できるので、getIntはあなたのためのメモリを割り当てません

714
00:45:25,520 --> 00:45:29,430
我々は数週間のために行ってきただけの方法山車と文字。

715
00:45:29,430 --> 00:45:33,960
本当に彼らは複数の文字を連結しているので、文字列は、しかし、特別なものです。

716
00:45:33,960 --> 00:45:37,450
そこで、彼らは文字や山車やintからわずかに異なっているなどが挙げられる。

717
00:45:37,450 --> 00:45:39,980
しかし、我々はそのずっと前に戻るでしょう。

718
00:45:39,980 --> 00:45:44,920
次に、ポインタのこの初めに何か質問はありますか？うん。

719
00:45:44,920 --> 00:45:49,690
[聞こえない学生の質問]

720
00:45:49,690 --> 00:45:51,440
ああ、非常に良い質問です。

721
00:45:51,440 --> 00:45:55,790
便利であるCは、実際にあなたのためにいくつかの選択肢の中からひとつ、

722
00:45:55,790 --> 00:46:00,110
それはサイズがデータ型である何あなたのための割り出しれ

723
00:46:00,110 --> 00:46:03,060
そして次にあなたのための乗算のようなものを行います。

724
00:46:03,060 --> 00:46:06,610
ほとんどの場合charは1バイトですので、これは文字の場合には関係ありません

725
00:46:06,610 --> 00:46:08,150
ので、これだけで動作します。

726
00:46:08,150 --> 00:46:11,220
しかし、議論のために、あなたが実際に整数を印刷していた場合

727
00:46:11,220 --> 00:46:15,500
そしてあなたは、整数を指していたいくつかの値sをプリントアウトしようとしていた

728
00:46:15,500 --> 00:46:20,720
あなたは、同様に、intは4バイトであるという理由だけで+4 * iを実行する必要はありません。

729
00:46:20,720 --> 00:46:25,780
ポインタ演算は、Cコンパイラがあなたのためのすべてのその計算を行うことを意味します。

730
00:46:25,780 --> 00:46:29,190
あなたが気にしなければならないすべては、人間の感覚のようなもので計算したものです。うん。

731
00:46:29,190 --> 00:46:35,200
[学生]は、forループの中の文字列を宣言する場合は、後でそれを解放しなければなりませんか？

732
00:46:35,200 --> 00:46:36,760
良い質問です。

733
00:46:36,760 --> 00:46:41,390
>> forループの文字列を内部に宣言された場合は、後でそれを解放する必要がありますか？

734
00:46:41,390 --> 00:46:47,520
あなただけがgetStringでまたはmallocと割り当てることメモリを解放する必要があります。

735
00:46:47,520 --> 00:46:53,110
あなただけの何かが好きと言うのであれば - すべてのコードが関係しているので、私は今、中括弧を置くことができます。

736
00:46:53,110 --> 00:46:58,580
あなたはこのようなbuggilyいえ何かを、やっているならば、char * T = S、

737
00:46:58,580 --> 00:47:03,450
トンは、mallocまたはGetStringの一切の言及を伴わないので、あなたは自由をtにする必要はありません。

738
00:47:03,450 --> 00:47:08,960
あなたがこれをしなかった場合はこれとは対照的に、GetStringメソッドは、[はい、あなたは自由トンに作る必要があるでしょう。

739
00:47:08,960 --> 00:47:14,350
そして、実際には、何にあなたの唯一のチャンスは、同じ有効範囲の問題のため、このループの内側になりました

740
00:47:14,350 --> 00:47:16,060
我々は過去に議論してきたこと。

741
00:47:16,060 --> 00:47:18,830
そうしないと、メモリを割り当てるメモリを割り当て、メモリを割り当てることがしたい、

742
00:47:18,830 --> 00:47:21,230
と、プログラムの終了時には、そのループの外にいるので、

743
00:47:21,230 --> 00:47:24,240
tが存在していませんが、オペレーティング·システムを言わなかった

744
00:47:24,240 --> 00:47:26,750
あなたはもう、そのメモリを必要としなかったこと。

745
00:47:26,750 --> 00:47:30,430
やがて、psetの4または5のために我々は、Valgrindのと呼ばれるプログラムを身につけるよ

746
00:47:30,430 --> 00:47:34,160
それは、それは難解なインターフェイスから多少持っているという点で、精神でGDBに似ています

747
00:47:34,160 --> 00:47:35,750
しかし、生活の中で、その目的は、あなたを助けることである。

748
00:47:35,750 --> 00:47:39,380
とValgrindは将来的にあなたのプログラムを検索するプログラムです

749
00:47:39,380 --> 00:47:42,550
メモリリークを探し、GetStringまたはmallocからかどうか、

750
00:47:42,550 --> 00:47:47,800
その我々はできるだけ多くCS50ライブラリを使用して停止すると、すべての詳細を使用して起動します。

751
00:47:47,800 --> 00:47:53,030
我々は最終的に今の語彙と理論的にはメンタルモデルの並べ替えのようなものを持って

752
00:47:53,030 --> 00:47:55,170
この壊れたプログラムを解決するためにどのと。

753
00:47:55,170 --> 00:47:59,410
>> だから、この壊れたプログラムでは、スワップは、スワップの内部で動作

754
00:47:59,410 --> 00:48:05,280
メインではxとyのリコール、渡されたので、それは実際にメインで働いていたことはありません

755
00:48:05,280 --> 00:48:07,260
そしてそれらはいわば、値によって渡された。

756
00:48:07,260 --> 00:48:09,330
それらのコピーは交換するために与えられた。

757
00:48:09,330 --> 00:48:12,520
スワップの終わりまでには、aとbは実際に交換されていたが、

758
00:48:12,520 --> 00:48:16,120
もちろん我々は月曜日に述べたように、xとyは、されていなかった。

759
00:48:16,120 --> 00:48:19,940
だから私は、これはここで実際に解決することをここに緑色で提案する。

760
00:48:19,940 --> 00:48:22,640
そして実際に、私はちょうど一致しているように私の星を動かしてみましょう

761
00:48:22,640 --> 00:48:24,440
にもかかわらず、再び、機能的にこれは問題ではありません。

762
00:48:24,440 --> 00:48:28,730
ときに、なぜそれが問題か将来週間後に我々は説明します。

763
00:48:28,730 --> 00:48:30,600
だから緑色になりましたソリューションです。

764
00:48:30,600 --> 00:48:33,700
私はこれらすべての星を持っているので、率直に言って、それは全体の多くの乱雑に見えます。

765
00:48:33,700 --> 00:48:35,380
私は一つのことを指摘してみましょう。

766
00:48:35,380 --> 00:48:40,040
それがint * aとint型* bを言うここで一番上の行

767
00:48:40,040 --> 00:48:42,820
それが常に持っているので基本的には同じことをやっている。

768
00:48:42,820 --> 00:48:47,070
これは、交換する2つの引数またはパラメータを宣言している

769
00:48:47,070 --> 00:48:49,940
と呼ばれるintポインタであるのは、最初に

770
00:48:49,940 --> 00:48:53,100
第二は、bと呼ばれるint型のポインタです。

771
00:48:53,100 --> 00:48:55,770
この時点で新しいだ唯一のことは、星がそこにあるという事実である。

772
00:48:55,770 --> 00:48:59,340
>> どういう意味ですか？ int型ではありませんが、bがint型ではありません。

773
00:48:59,340 --> 00:49:04,100
intのアドレスであり、bは異なるintのアドレスです。

774
00:49:04,100 --> 00:49:06,980
私はCが混乱取得認めるところダウンここで、これはです。

775
00:49:06,980 --> 00:49:09,790
今、私たちは星を使っているが、それはこの文脈で異なる意味を持ちます。

776
00:49:09,790 --> 00:49:13,150
我々がここでアップしているように、我々はポインタを宣言していないので、

777
00:49:13,150 --> 00:49:15,500
ここで我々は物事を逆参照しています。

778
00:49:15,500 --> 00:49:21,520
したがって、厳密には、スワップの内側に第一、第二、第三行のこの文脈でのスター

779
00:49:21,520 --> 00:49:24,560
ちょうどそこに行くことを意味し、間接参照演算子である。

780
00:49:24,560 --> 00:49:27,400
私の指は、hに矢印を追ったので、同じように

781
00:49:27,400 --> 00:49:31,100
*そのアドレスに移動して、私にはありint型を見つけることを意味します。

782
00:49:31,100 --> 00:49:34,250
* bはアドレスに行くと何があるか私を渡すことを意味します。

783
00:49:34,250 --> 00:49:40,730
だから、今のフレームのスタックを使用してのは、月曜日から画像を再描画してみましょう

784
00:49:40,730 --> 00:49:43,130
の底1は、メインになるだろう

785
00:49:43,130 --> 00:49:47,600
の上位1は、スワップになるだろう

786
00:49:47,600 --> 00:49:50,880
私たちの世界はこのように、ちょうど月曜日のように、見えるように。

787
00:49:50,880 --> 00:49:53,620
ここでの主な使用しようとしているメモリのチャンクです。

788
00:49:53,620 --> 00:49:56,520
>> プログラムはちょうど2つの変数を持っていたことを思い出して、月曜日から、

789
00:49:56,520 --> 00:50:01,930
1は、xとyと呼ばれる1と呼ばれ、私はそこに1番と2番を入れていた。

790
00:50:01,930 --> 00:50:06,580
今私は、私は月曜日に行ったように、スワップを呼び出したとき

791
00:50:06,580 --> 00:50:11,000
以前に私はこのようになり、このプログラムの赤バージョンを、使用した場合

792
00:50:11,000 --> 00:50:17,470
私は2つのパラメータaとbを持って、我々はこことここに何を書いたのか？

793
00:50:17,470 --> 00:50:21,160
文字通り1と2は、xとyのコピー。

794
00:50:21,160 --> 00:50:23,070
今日、我々はそれを変更します。

795
00:50:23,070 --> 00:50:28,510
代わりに整数aとbを渡すの今日は2アドレスを渡すつもりです。

796
00:50:28,510 --> 00:50:34,290
これらのアドレスは、intを指すように起こるが、それらのアドレスは、自分自身をINTSされていません。

797
00:50:34,290 --> 00:50:37,330
彼らはアドレスです。それは代わりに郵便住所のようなものだ。

798
00:50:37,330 --> 00:50:40,580
だから今我々は、単に画面上でもう少し詳細に自分自身を与える必要があります。

799
00:50:40,580 --> 00:50:43,250
それはすべての一日だったので、これは私のコンピュータのメモリです。

800
00:50:43,250 --> 00:50:45,120
今我々はいくつかの任意の番号付け方式を必要としています。

801
00:50:45,120 --> 00:50:50,580
だから、これはメモリアドレス123、124であることを、ただ偶然、言うてみましょう。

802
00:50:50,580 --> 00:50:55,660
ただ、これは125であると言いましょう、これは126であるなど、それは全くの自由です。

803
00:50:55,660 --> 00:50:58,590
私達はちょうど私の記憶のいくつかのナンバリングスキームを必要としています。

804
00:50:58,590 --> 00:51:04,030
だから今、私は実際に、xとy方向に通過したとき、私は、xとyを渡すつもりはない。

805
00:51:04,030 --> 00:51:08,400
私はXの、yの、いわば、住所を渡すつもりです

806
00:51:08,400 --> 00:51:11,870
何こことここに格納されることではない1と2になるように

807
00:51:11,870 --> 00:51:16,030
しかし、あなたはこことここで渡されるもの、私の小さなテキストを見ることができるかどうか？

808
00:51:16,030 --> 00:51:23,340
[聞き取れない生徒の応答] >>その通りです。 123はここに入れて取得し、124はここに置かれます。

809
00:51:23,340 --> 00:51:28,910
>> 今、私は一番上にあるここでは、この非常に最初の行のようにスターを使用したので、

810
00:51:28,910 --> 00:51:34,340
私のプログラムはちょうど彼らが明らかに整数でいるにもかかわらず、その123と124を知っている

811
00:51:34,340 --> 00:51:40,160
どんな人間が気づくことができること、それらがアドレス、数値アドレスとして解釈されるべきである。

812
00:51:40,160 --> 00:51:43,250
彼らは、彼らがしているアドレスは、intで、それ自体がありません

813
00:51:43,250 --> 00:51:46,120
私は明示的にそこに星を入れているので、それはです。

814
00:51:46,120 --> 00:51:51,360
だから今ここで何が起こるかを実際のコードの私の第一、第二、第三行目の？

815
00:51:51,360 --> 00:51:53,380
のは、画像の残りの部分を描きましょう。

816
00:51:53,380 --> 00:51:56,980
tmpはちょうどそれが月曜日にあったようなものです。 tmpに何も特別なことはありません。

817
00:51:56,980 --> 00:52:03,060
それはちょうどローカル32ビットの変数であり、その内部に、私は明らかに*の値を格納しています。

818
00:52:03,060 --> 00:52:08,580
さて、私が今言っている場合TMP = A、私はここに何を入れるでしょう？ >> [学生] 123。

819
00:52:08,580 --> 00:52:10,370
123。しかし、それは私がやっているものではありません。

820
00:52:10,370 --> 00:52:13,670
私はtmpを言っている= * A。スターはそこに行くことを意味します。

821
00:52:13,670 --> 00:52:19,370
そこでここでは、123です。どうやってそこに行くのですか？矢印があるようなふりをする。

822
00:52:19,370 --> 00:52:24,460
まあ、それは、1がある。どうやら、tmpに何が格納される？わずか1。

823
00:52:24,460 --> 00:52:29,620
だから、他の言葉で、tmpは、現在のアドレスに行く* A、*手段であり、

824
00:52:29,620 --> 00:52:31,320
これは明らかに123です。

825
00:52:31,320 --> 00:52:33,910
>> さて、ここで我々は123の場所にあり、私は、番号1を参照

826
00:52:33,910 --> 00:52:35,670
ので、私はそこに数字の1を入れてするつもりです。

827
00:52:35,670 --> 00:52:39,020
今私は2行目に何をすればよいでしょうか、* A * B =？

828
00:52:39,020 --> 00:52:44,570
この1つは、今何があるため、もう少し複雑ですか？それは123だ。

829
00:52:44,570 --> 00:52:50,220
だから*どこにあるのでしょうか？右ここで私が前にあった。だからそこに行く。オーケー。

830
00:52:50,220 --> 00:52:53,420
さて、最後に、そして最後に、これは、うまくいけば、意味を理解するために開始されます

831
00:52:53,420 --> 00:53:00,280
* bは、bに何を意味する？ 124。だから私は2である、そこに行く必要があります。

832
00:53:00,280 --> 00:53:03,430
だから私は、どこに何を入れますか？

833
00:53:03,430 --> 00:53:10,100
* bは*に行くので、2がここに入ります。だから私はそれをするつもりだ。

834
00:53:10,100 --> 00:53:13,120
そして、あなたはすでに私たちはそんなに近づいているのだから、多分、見ることができます

835
00:53:13,120 --> 00:53:17,710
初めて正しくこの愚かな、単純な問題を解決するための

836
00:53:17,710 --> 00:53:20,920
今、我々はまだ、xが何であったかの記憶を持っているので、

837
00:53:20,920 --> 00:53:23,230
我々は、Yの、確かに、2つのコピーを持っている

838
00:53:23,230 --> 00:53:25,850
しかし、3行目は* bは言う。

839
00:53:25,850 --> 00:53:31,080
だからここにBはAの。 * bはそこに行くことを意味します。だから場所124はどこにあるのでしょうか？

840
00:53:31,080 --> 00:53:35,560
ここは明らかにだ。だから私はここに何を入れますか？明らかに、tmpです。

841
00:53:35,560 --> 00:53:39,600
だから今、私はこれを行う。だから私はここに1と2をここに持っている。

842
00:53:39,600 --> 00:53:43,560
そして今何がこのすべて、123、124、約1？

843
00:53:43,560 --> 00:53:47,910
もうすぐスワップ戻ると、このメモリは失われているようにように良いです

844
00:53:47,910 --> 00:53:51,070
とすぐにスワップリターン、オペレーティングシステムなどのため

845
00:53:51,070 --> 00:53:54,190
将来再びそのメモリを自由に使用できます。

846
00:53:54,190 --> 00:53:58,870
このいわゆるスタックの一番下にある唯一のメインのメモリが周りにこだわっています。

847
00:53:58,870 --> 00:54:01,470
>> それで我々は最終的に今取り組んでバージョンを持っています。

848
00:54:01,470 --> 00:54:06,310
私はswap.cに入り、次のことがわかりましょう。

849
00:54:06,310 --> 00:54:11,280
プログラムの先頭に、私はあることが私のプロトタイプを変更したint型* aとint型* bです。

850
00:54:11,280 --> 00:54:15,000
私が悪かった赤、緑から良いです、に行くように変更だけだそう、

851
00:54:15,000 --> 00:54:17,350
私が今日、これらの星を追加されます。

852
00:54:17,350 --> 00:54:21,520
しかし、その後、ダウンここで自分自身を交換する私はコピーしなければならなかった、ただのスライドにあったものに貼り付けます。

853
00:54:21,520 --> 00:54:24,140
私は、ここにここに星を星を持っている - プロトタイプと一致する - 

854
00:54:24,140 --> 00:54:27,930
その後これらの事のすべてでtmpを除く星を持っている

855
00:54:27,930 --> 00:54:30,680
一時的な変数を使用するので、新しいものは何もありません。

856
00:54:30,680 --> 00:54:33,040
私はちょうどint型のための一時的なストレージが必要です。

857
00:54:33,040 --> 00:54:34,820
だから我々はそこにスターを必要としません。

858
00:54:34,820 --> 00:54:39,310
我々は任意の境界のこの種を越えることができるように、私達はちょうどスターが必要

859
00:54:39,310 --> 00:54:42,900
私のコンピュータのメモリ内のこれらの2つのフレーム間。

860
00:54:42,900 --> 00:54:45,630
しかし、一つの最後の事は変わらなければならない、あなたはすでにそれをちらっと見たかもしれません。

861
00:54:45,630 --> 00:54:48,810
他のラインは明らかに異なるとは何ですか？ >> [生徒]＆xになります。

862
00:54:48,810 --> 00:54:53,270
>> ええ、そう25、私はこれが機能するために、変更する必要のあるコードの最後の行です。

863
00:54:53,270 --> 00:54:58,360
一週間前にしても月曜日には25行目では、このように見えた、xとyを入れ替える

864
00:54:58,360 --> 00:55:02,020
あなたが言う場合ので、これがちょうど壊れていたスワップ（x、y）は

865
00:55:02,020 --> 00:55:05,660
あなたは、それは、そのことをやって、交換するxとyのコピーを与えている

866
00:55:05,660 --> 00:55:09,080
しかし、実際にはxとy自体を変えたことがないている。

867
00:55:09,080 --> 00:55:12,880
だからあなたは、コード内のアンパサンド前にこの文字を見たことがない場合であっても、

868
00:55:12,880 --> 00:55:15,860
単なる推測を取る。アンパサンドは、明らかに、何をしますか？

869
00:55:15,860 --> 00:55:17,890
[学生]アドレスを取ります。 >>は、アドレスを取ります。

870
00:55:17,890 --> 00:55:21,160
だから、アンパサンドは私にxのアドレスを与えると言っている。

871
00:55:21,160 --> 00:55:25,590
それがどこにあるか誰が知っているか？それが123であることを起こる。私は気にしないでください。ちょうど私にxのアドレスを与える。

872
00:55:25,590 --> 00:55:28,340
＆Yは私にyのアドレスを与えることを意味します。

873
00:55:28,340 --> 00:55:34,450
その時点で話は、我々は少し前に描いた絵と完全に一致している。

874
00:55:34,450 --> 00:55:38,310
>> 私が最初にこれを習い始めたときにだから私は、私のために確かに、ポインタを認めるよ

875
00:55:38,310 --> 00:55:40,570
間違いなく私の心の周りをラップするために、最も難しいものの一つであった。

876
00:55:40,570 --> 00:55:43,760
しかし、我々は物事のこれらの種類と再生し続ける、特にとして、実現

877
00:55:43,760 --> 00:55:48,030
あなたはこれらの超簡単なソートにそれを打破する場合知的に問題が面白くない

878
00:55:48,030 --> 00:55:52,270
ただ、周りのポインタを持つ多くの混乱への答えを数値を動かす

879
00:55:52,270 --> 00:55:56,590
実際にこれらの非常に基本的な力学から導出することができる。

880
00:55:56,590 --> 00:55:59,070
こちらのアドレスです。星とそこに行く。

881
00:55:59,070 --> 00:56:03,830
あるいは逆に、ここでは、アンパサンドだ。アドレスが実際に何であるかを見つけ出す。

882
00:56:03,830 --> 00:56:06,270
かしこまりました。

883
00:56:06,270 --> 00:56:09,000
だからここで、このメモリのすべてがから来ている？

884
00:56:09,000 --> 00:56:12,360
我々は数回この絵を描かれた、と私は、我々は、それに戻ってくると約束守る

885
00:56:12,360 --> 00:56:14,920
しかしここで、あなたのコンピュータのメモリを表現したものです

886
00:56:14,920 --> 00:56:17,420
ここでもう少し私たちの黒板よりもラベルが付いていることだ。

887
00:56:17,420 --> 00:56:21,590
上部のテキスト·セグメントは、プログラムに関して何を表して？

888
00:56:21,590 --> 00:56:26,090
[聞き取れない生徒の応答] >>申し訳ありませんが？もう一度言う。

889
00:56:26,090 --> 00:56:28,660
[学生]実際のプログラム。 >>実際のプログラム。

890
00:56:28,660 --> 00:56:32,430
>> だから、0と1は、Cのコードを書いた後コンパイルした後、Clangの実行

891
00:56:32,430 --> 00:56:35,910
と、0と1を生成するまでメモリにそこに隠れされてしまう

892
00:56:35,910 --> 00:56:38,570
あなたは二重使いのMacまたはPC上のアイコンをクリックすると、なぜなら

893
00:56:38,570 --> 00:56:43,010
またはディスクからあなたのプロンプトで、0と1でマリオのよう​​なコマンドを実行します。

894
00:56:43,010 --> 00:56:45,700
コンピュータがそれらを操作できるようにメモリにロードされ

895
00:56:45,700 --> 00:56:47,540
より迅速にそれらを実行する。

896
00:56:47,540 --> 00:56:50,880
だから、初期化されたデータと初期化されていないデータは、我々は、それらについて多くを話すことはありません

897
00:56:50,880 --> 00:56:52,420
しかし、それらは単なるグローバル変数です。

898
00:56:52,420 --> 00:56:54,710
初期化では、値を与えたグローバル変数を意味する;

899
00:56:54,710 --> 00:56:59,300
初期化されていないあなたはまだに値を与えていないことをグローバル変数を意味します。

900
00:56:59,300 --> 00:57:01,900
その後、私は完全に私の手を振るよ、これらの環境変数はあり

901
00:57:01,900 --> 00:57:04,860
しかし、彼らはそこにあり、そのユーザー名のような店の事

902
00:57:04,860 --> 00:57:08,090
低レベル詳細や他の種類。

903
00:57:08,090 --> 00:57:12,880
しかし、あなたのメモリのレイアウトのジューシーな部分は、スタックとヒープと呼ばれるこの事である。

904
00:57:12,880 --> 00:57:17,470
スタックは、再び、明確にするために、関数が呼び出されるたびに使われているメモリであり、

905
00:57:17,470 --> 00:57:19,710
ローカル変数があるときは必ず

906
00:57:19,710 --> 00:57:22,120
とするたびに周りに渡されるパラメータがあります。

907
00:57:22,120 --> 00:57:24,490
スタック内で起こるすべてのこと。

908
00:57:24,490 --> 00:57:29,570
ヒープは、私たちは話をしますが、ヒープを使用し推測を取るていない。

909
00:57:31,120 --> 00:57:32,690
メモリのちょうど別のチャンク。

910
00:57:32,690 --> 00:57:36,620
それが一番上にここで描かれるようなことが起こるが、それは任意の絵大会だ。

911
00:57:36,620 --> 00:57:41,670
誰がどうやら週間のヒープからメモリを使っている？

912
00:57:41,670 --> 00:57:44,830
それは間接的に、技術的にだが。 >> [生徒] GetStringメソッド。

913
00:57:44,830 --> 00:57:47,950
GetStringメソッドとmalloc関数。だからここに根本的な違いです。

914
00:57:47,950 --> 00:57:51,300
>> あなたがメモリを必要とするならば、単に変数を宣言することを過去数週間のために知っている。

915
00:57:51,300 --> 00:57:54,560
あなたは多くのメモリを必要とする場合は、右の内側関数の配列を宣言します。

916
00:57:54,560 --> 00:57:59,620
あなたが関数のローカル内で変数を宣言した場合しかし、我々が直面して守ってきた問題があり、

917
00:57:59,620 --> 00:58:05,340
とすぐに関数が戻ったとして、何がメモリと、それらの変数はどうなるのでしょうか？

918
00:58:05,340 --> 00:58:09,620
ちょうど、もはやマーケットが来ないの並べ替え？それは単に概念的のようなものを表示されなくなります。

919
00:58:09,620 --> 00:58:13,950
それは明らかに、物理的にそこにまだあるが、それは、もはや使用する権利はない。

920
00:58:13,950 --> 00:58:17,160
あなたは生活の中で関数を記述したい場合、これは明らかに問題がある

921
00:58:17,160 --> 00:58:20,440
実際にメモリを割り当てて、それをすぐにお返しをしないこと。

922
00:58:20,440 --> 00:58:24,180
ポイントのケース：生活の中でGetStringメソッドの目的は、事前に見当がつかないことである

923
00:58:24,180 --> 00:58:26,390
どのように私はキーボードでタイプするつもりの文字列の大きな、

924
00:58:26,390 --> 00:58:30,390
それはデヴィッドまたはhelloを保持するためのメモリを割り当てることができるように持っている

925
00:58:30,390 --> 00:58:32,860
ユーザがログイン入力した可能性があることや全体エッセイ

926
00:58:32,860 --> 00:58:35,280
だからGetStringメソッドは、mallocを使用してきました。

927
00:58:35,280 --> 00:58:38,910
mallocは高くないスタックを使用する必要があります。

928
00:58:38,910 --> 00:58:40,770
代わりに、それはヒープと呼ばれるこの事を使っている。

929
00:58:40,770 --> 00:58:44,430
メモリについてのさまざまなことは何もありません。それは速くなったり遅くなったり、またはそのような何もありません。

930
00:58:44,430 --> 00:58:46,570
それは別の場所に物理的にだけだ。

931
00:58:46,570 --> 00:58:50,120
>> しかし、ルールはそのヒープに割り当てられているメモリ

932
00:58:50,120 --> 00:58:56,180
呼び出すまであなたから取り去られることはありません - 推測を取る - 無料。

933
00:58:56,180 --> 00:59:00,510
これとは対照的に、任意のメモリがあなただけの配列を宣言することによってスタック上を求める

934
00:59:00,510 --> 00:59:03,320
あるいは、我々は数週間のために行ってきたように変数を宣言する、

935
00:59:03,320 --> 00:59:05,640
つまり、デフォルトではスタックに終わる。

936
00:59:05,640 --> 00:59:09,550
そして、それは時間の偉大な90％に動作しますが、それらのまれな場面で

937
00:59:09,550 --> 00:59:12,470
あなたは、メモリを割り当てて、それを周りに残しておきたい場所

938
00:59:12,470 --> 00:59:14,730
次にあなたは、mallocのような関数を使用する必要があります。

939
00:59:14,730 --> 00:59:19,370
あるいは、我々は、順番に、mallocを使用してGetStringを、次のような関数を使用してきました。

940
00:59:19,370 --> 00:59:23,300
これは分解してからBINKYでかいま見を取る可能性のある場所を見てみましょう。

941
00:59:23,300 --> 00:59:25,820
将来的にはそれに戻ってくる。

942
00:59:25,820 --> 00:59:29,270
ここでは、最初の2行で何をしている超簡単なプログラムは何ですか？

943
00:59:29,270 --> 00:59:33,460
英語では、コードのこれらの最初の2行は、メインの内側に何をすればいいですか？

944
00:59:33,460 --> 00:59:35,600
[聞き取れない生徒の応答]

945
00:59:35,600 --> 00:59:37,880
注意してください。それは私にxまたはyのアドレスを与えるものではありません。

946
00:59:37,880 --> 00:59:41,840
[学生] int型へのポインタを与えます。グッド。>>整数に私に2ポインタを与える。

947
00:59:41,840 --> 00:59:45,130
言い換えれば、私が今日図面を保存しておくことをメモリの2チャンクを与える

948
00:59:45,130 --> 00:59:46,950
にもかかわらず、私は正方形として、今、それを消した。

949
00:59:46,950 --> 00:59:50,000
 - 私のメモリを2チャンク、xという1、yと呼ばれるものを与える

950
00:59:50,000 --> 00:59:54,320
以前の私はそれらのsとtと呼ばれる - とメモリのチャンクの種類は何ですか？

951
00:59:54,320 --> 00:59:57,160
これは、アドレスを格納するために起こっている。

952
00:59:57,160 --> 00:59:59,110
これは、int *型の一つだ。

953
00:59:59,110 --> 01:00:01,630
>> だからintのアドレスは、最終的には、xに住むようになる

954
01:00:01,630 --> 01:00:03,860
intのアドレスは、最終的には、yに住むようになる

955
01:00:03,860 --> 01:00:08,460
しかし当初は、xとyの内側は何ですか？誰が知っているか？ゴミの値。

956
01:00:08,460 --> 01:00:10,180
これは、ポインタとは何の関係もない。

957
01:00:10,180 --> 01:00:12,720
我々はそこに実際にあるものを知っているそこに何かを入れていない場合はどうなりますか？

958
01:00:12,720 --> 01:00:18,950
今は、x。ここで何が起こりますか？ xがポインタであるので、これは今では合法です。それはint *です。

959
01:00:18,950 --> 01:00:21,870
だから私は、xにメモリの一部チャンクのアドレスを置くことができることを意味します。

960
01:00:21,870 --> 01:00:25,120
malloc関数は何を返すのでしょうか？パーフェクト、それは、アドレスを返す

961
01:00:25,120 --> 01:00:28,510
メモリの全体のチャンク内の最初のバイトのアドレス。

962
01:00:28,510 --> 01:00:31,140
これは明らかにアプライアンスでは、例えば、どのように多くのバイトを割り当てていますか？

963
01:00:31,140 --> 01:00:33,510
intのサイズは何ですか？ 4。

964
01:00:33,510 --> 01:00:36,600
あなたが週1に戻って考えるなら、それは、常にそれを覚えておくことが重要スーパーではありません

965
01:00:36,600 --> 01:00:38,870
しかしこのケースでは、4バイトを知っておくと便利です。

966
01:00:38,870 --> 01:00:41,770
だから、これはヒープの4バイトに割り当てている

967
01:00:41,770 --> 01:00:46,110
そして、それは任意に、私には最初のもののアドレスを返している。

968
01:00:46,110 --> 01:00:47,700
さて、xが何をやっている？

969
01:00:47,700 --> 01:00:52,200
* X = 42は何をやっている？

970
01:00:52,200 --> 01:00:57,150
我々はいくつかのゴミ値で次のようになります。xを、持っている物語で、この時点で場合

971
01:00:57,150 --> 01:01:04,120
これは現在、3行目で、私は4バイトを割り当てられましたが、今ではいくつかのゴミ値とyです。

972
01:01:04,120 --> 01:01:06,950
この絵は、本質的にこ​​のように見えます。

973
01:01:06,950 --> 01:01:12,010
これは任意のアドレス123である場合、またはより具体的には、これは私たちの話は今のように見えるものです。

974
01:01:12,010 --> 01:01:23,940
* X = 42は今何を意味する？それはアドレス123に移動して、そこ番号42を置いたことを意味します。

975
01:01:23,940 --> 01:01:26,220
我々は文字列をやっていないので、私はこれらの線を描画する必要はありません。

976
01:01:26,220 --> 01:01:29,480
>> 私はちょうどこのような、ただのデモのためにそれを書かれているはずですが、

977
01:01:29,480 --> 01:01:33,240
int型の種類として42は、4バイトを多くのスペースを占有します。

978
01:01:33,240 --> 01:01:35,960
だから、それはそこに起こったことが、問題は今そこだ。

979
01:01:35,960 --> 01:01:40,580
* Y = 13。ここで何が起こるだろう？

980
01:01:40,580 --> 01:01:46,470
問題は、私たちの世界では簡略化* yはちょうどyのアドレスに行くことを意味しています。

981
01:01:46,470 --> 01:01:48,590
yには何ですか？それはいくつかのゴミ値だ。

982
01:01:48,590 --> 01:01:53,150
だからゴミの値が、そのような狂気何か5551212であると仮定してみましょう。

983
01:01:53,150 --> 01:01:56,750
* yは5551212に対処するために行くことを意味します。

984
01:01:56,750 --> 01:02:00,450
それはこっちのようなものだ。その中には、たとえば、存在しません。

985
01:02:00,450 --> 01:02:05,310
だから* yは私がここで13を描画しようとしている13の手段を取得します。それは存在しません。

986
01:02:05,310 --> 01:02:08,790
私は黒板のセグメントを超えました。私は何を手に入れたのか？

987
01:02:08,790 --> 01:02:14,930
私はメモリに入れしようとしているので、その謎めいたメッセージセグメンテーションフォールト

988
01:02:14,930 --> 01:02:19,470
存在しない場所で、13のような値です。

989
01:02:19,470 --> 01:02:23,900
そうでない、その時点までのプログラムの残りの部分は大丈夫ですが、アップに働くかもしれない。

990
01:02:23,900 --> 01:02:25,350
それでは、この話をしてみましょう。

991
01:02:25,350 --> 01:02:27,830
我々は六角の話したら、我々はそれに戻ってくる。

992
01:02:27,830 --> 01:02:30,290
、のはこれに戻ってBINKYと呼ばれるこの事で締めくくりましょう

993
01:02:30,290 --> 01:02:33,710
そのリコールは、クレイと一緒に遊んで自宅で座ってスタンフォード大学の教授である

994
01:02:33,710 --> 01:02:36,380
まさにその同じプログラムの話をします。

995
01:02:36,380 --> 01:02:40,580
それはちょうど約3分の長さです。ここでは、BINKY持っています。

996
01:02:40,580 --> 01:02:45,030
[ビデオの男性話]ちょっとBINKY、目を覚ます。これは、ポインタの楽しみのための時間です。

997
01:02:45,030 --> 01:02:50,080
[BINKY]それは何ですか？ポインタについて学ぶのか？ああ、すごーい！

998
01:02:50,080 --> 01:02:53,700
[男性話]さて、始めるために、私たちはカップルのポインタが必要になるだろうと思います。

999
01:02:53,700 --> 01:02:57,890
>> [BINKY]オーケー。このコードは、整数を指すことができます2ポインタを割り当てます。

1000
01:02:57,890 --> 01:03:02,220
[男性話]さて。まあ、私は2ポインタを参照してください、しかし、彼らは何を指していないように見えます。

1001
01:03:02,220 --> 01:03:05,550
[BINKY]そうですね。最初は、ポインタが何を指していない。

1002
01:03:05,550 --> 01:03:09,270
それらが指すものは指示先と呼ばれ、それらの設定は別個のステップですされています。

1003
01:03:09,270 --> 01:03:12,330
[男性話]ああ、右、右。私はそれを知っていた。指示先が別になります。

1004
01:03:12,330 --> 01:03:15,630
erが、それでは、どのように指示先を割り当てるには？

1005
01:03:15,630 --> 01:03:21,510
[BINKY]オーケー。このコードは、新しい整数指示先を割り当て、この部分は、xがそれを指すように設定します。

1006
01:03:21,510 --> 01:03:23,500
[男性話]ねえ、それが良く見えます。

1007
01:03:23,500 --> 01:03:26,030
だから、何かを作る。 >> [BINKY]オーケー。

1008
01:03:26,030 --> 01:03:30,300
私は間接参照ポインタxがその指示に番号42を格納するよ。

1009
01:03:30,300 --> 01:03:34,410
このトリックのために私はデリファレンスの私の魔法の杖が必要になるでしょう。

1010
01:03:34,410 --> 01:03:38,610
[男性話]間接参照のあなたの魔法の杖？それは素晴らしいことだ。

1011
01:03:38,610 --> 01:03:44,230
[BINKY]これは、コードがどのようなものです。私はただの数字を設定してよ... [ポッピング音]

1012
01:03:44,230 --> 01:03:46,100
見て[男性話]ちょっと、そこに行く。

1013
01:03:46,100 --> 01:03:50,990
だからx上の間接参照を行うと、矢印がその指示にアクセスするために、次の

1014
01:03:50,990 --> 01:03:53,230
この場合には、そこに42を格納する。

1015
01:03:53,230 --> 01:03:57,630
ねえ、他のポインタ、yを通じて番号13を格納するためにそれを使用してみてください。

1016
01:03:57,630 --> 01:04:03,250
[BINKY]オーケー。私はちょうどyにこっちに行くと13番が設定され得るでしょう

1017
01:04:03,250 --> 01:04:08,360
その後ちょうど逆参照との杖を取る... [賑やかな音]おっと！

1018
01:04:08,360 --> 01:04:10,980
[男性話]やあああ、うまくいきませんでした。

1019
01:04:10,980 --> 01:04:14,870
>> BINKY、言う、私はyを間接参照するのは良いアイデアだとは思わない

1020
01:04:14,870 --> 01:04:17,880
指示先を設定することは別個のステップですので、

1021
01:04:17,880 --> 01:04:19,850
と私は、私たちが今までそれをやったとは思わない。

1022
01:04:19,850 --> 01:04:21,770
[BINKY]うーん、良い点。

1023
01:04:21,770 --> 01:04:26,640
[男性話]うん。我々は、ポインタyを割り当てられているが、我々は指示先を指すように設定することはありません。

1024
01:04:26,640 --> 01:04:28,780
[BINKY]うーん、非常に注意深い。

1025
01:04:28,780 --> 01:04:30,690
[男性話]ねえ、あなたは、そこにBINKYの良い探している。

1026
01:04:30,690 --> 01:04:34,160
あなたは、xと同じ指示先にyが点になるようにそれを解決することができますか？ >> [BINKY]確かに。

1027
01:04:34,160 --> 01:04:37,100
私はポインタ代入の私の魔法の杖を使用します。

1028
01:04:37,100 --> 01:04:39,070
[男性話]前のような問題になることですか？

1029
01:04:39,070 --> 01:04:40,840
[BINKY]いいえ、これは指示先に触れていない。

1030
01:04:40,840 --> 01:04:44,780
それはちょうど別のと同じものを指すように、一つのポインタを変更します。 [ポッピング音]

1031
01:04:44,780 --> 01:04:48,570
[男性話]ああ、なるほど。 xと同じ場所になりましたy点。

1032
01:04:48,570 --> 01:04:51,140
だから、待ってください。今すぐYは固定されています。それは指示先を持っています。

1033
01:04:51,140 --> 01:04:54,520
だからあなたは13歳以上を送信するために再び逆参照の杖を試してみることができます。

1034
01:04:54,520 --> 01:04:58,130
[BINKY]ええと、大丈夫。ここに行く。 [ポッピング音]

1035
01:04:58,130 --> 01:05:01,250
[男性話]ねえ、それを見てみましょう。今すぐyの作品を間接参照。

1036
01:05:01,250 --> 01:05:05,200
ポインタはその1指示先を共有しているため、彼らは両方とも13を参照してください。

1037
01:05:05,200 --> 01:05:06,910
[BINKY]うん、共有。ものは何でも。

1038
01:05:06,910 --> 01:05:08,880
>> だから我々は今の場所を切り替えるつもりですか？

1039
01:05:08,880 --> 01:05:11,420
[男性話]ルックああ、私たちは時間がなくなってしまい。 >> [BINKY]しかし - 

1040
01:05:11,420 --> 01:05:13,880
[男性話] 3ポインタのルールをただ覚えている。

1041
01:05:13,880 --> 01:05:18,630
番号1は、基本的な構造は、ポインタを持っていることであり、それは指示先にポイント以上。

1042
01:05:18,630 --> 01:05:23,120
しかし、ポインタと指示先は独立しており、一般的なエラーは、ポインタを設定することです

1043
01:05:23,120 --> 01:05:25,680
しかし、それを指示先を与えることを忘れている。

1044
01:05:25,680 --> 01:05:29,580
番号2は、ポインタの間接参照は、ポインタから始まり、上で矢印を次

1045
01:05:29,580 --> 01:05:31,060
その指示にアクセスすることができます。

1046
01:05:31,060 --> 01:05:34,340
我々はすべて知っているように、ポインタの指示がある場合にのみ動作しますが、

1047
01:05:34,340 --> 01:05:36,460
どの種類の番号1を支配するために戻って取得します。

1048
01:05:36,460 --> 01:05:39,870
番号3は、ポインタ代入は1ポインタを受け取り、それを変更します

1049
01:05:39,870 --> 01:05:42,390
別のポインタと同じ指示先を指すように設定します。

1050
01:05:42,390 --> 01:05:45,890
だから代入した後、2のポインタが同じ指示先を指すようになります。

1051
01:05:45,890 --> 01:05:47,800
時にはそれは、共有と呼ばれています。

1052
01:05:47,800 --> 01:05:50,910
>> そして、それは本当にこれだけです。今バイバイ。

1053
01:05:50,910 --> 01:05:55,840
これはBINKYです。これはCS50です。我々は、来週お会いしましょう​​。 [拍手]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]