1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[音楽再生]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD：OKそう提案
ここで開始する前に。

5
00:00:07,940 --> 00:00:11,660
あなたは上のビデオを見ていない場合
あなたが最初にそうすることができますポインタ。

6
00:00:11,660 --> 00:00:15,860
このビデオであるため、他の
ポインタでの作業の方法。

7
00:00:15,860 --> 00:00:17,574
>> だから、話をするつもりです
いくつかの概念について

8
00:00:17,574 --> 00:00:19,490
我々はにカバーすること
ポインタ映像、私たちはしています

9
00:00:19,490 --> 00:00:21,948
、ここでそれらをごまかすつもり
彼らはすでにしていると仮定

10
00:00:21,948 --> 00:00:23,090
理解の一種。

11
00:00:23,090 --> 00:00:25,440
だから、ちょうどあなたの公正な警告です
あなたはこのビデオを見ている場合に

12
00:00:25,440 --> 00:00:27,814
あなたが見ていません
ポインタ映像、それは一種のかもしれません

13
00:00:27,814 --> 00:00:29,610
あなたの頭の上に少し飛びます。

14
00:00:29,610 --> 00:00:32,080
そしてそれは良いかもしれません
そのためには、それを見て。

15
00:00:32,080 --> 00:00:34,710
>> だから我々はすでに1を見てきました
ポインタで動作するための方法、

16
00:00:34,710 --> 00:00:37,810
これは私たちが宣言されています
変数、し、我々

17
00:00:37,810 --> 00:00:42,160
別の変数、ポインタを宣言
変数は、それはそれを指しています。

18
00:00:42,160 --> 00:00:44,870
だから我々は、作成しました
名前の変数は、我々はしました

19
00:00:44,870 --> 00:00:48,480
名前の第二の変数を作成し、
我々は、第2の変数を指します

20
00:00:48,480 --> 00:00:50,220
その最初は。

21
00:00:50,220 --> 00:00:52,370
この種の持っています
問題しかし、それ理由

22
00:00:52,370 --> 00:00:54,650
正確に知るために私たちを必要とします
どのくらいのメモリ、我々はしています

23
00:00:54,650 --> 00:00:57,600
瞬間が必要になります
私たちのプログラムがコンパイルされます。

24
00:00:57,600 --> 00:00:58,220
>> 何故ですか？

25
00:00:58,220 --> 00:01:03,338
私たちは名前をできるようにする必要があるためか、
可能なすべての変数を識別

26
00:01:03,338 --> 00:01:04,129
我々は発生する可能性があります。

27
00:01:04,129 --> 00:01:07,910
私たちはあるかもしれない配列を持っている可能性があります
多くの情報を保持することができ、

28
00:01:07,910 --> 00:01:10,110
それはまだありません
十分正確に正確な。

29
00:01:10,110 --> 00:01:12,640
私たちは知っていない場合は、
私たちは考えている場合

30
00:01:12,640 --> 00:01:14,370
我々は、コンパイル時にどのくらいが必要になるでしょうか？

31
00:01:14,370 --> 00:01:17,020
あるいは、どのような私たちのプログラムがする場合
本当に長い時間のために実行、

32
00:01:17,020 --> 00:01:19,810
さまざまなユーザーを受け入れます
データ、私たちは本当にすることはできません

33
00:01:19,810 --> 00:01:23,170
私たちがしているかどうかを見積もります
1,000台が必要になりますか？

34
00:01:23,170 --> 00:01:26,060
>> それは、我々はできるようではありません
コマンドラインで言います

35
00:01:26,060 --> 00:01:28,040
どのように多くの項目を入力します。
あなたが必要と思います。

36
00:01:28,040 --> 00:01:31,100
まあその推測は何が間違っている場合は？

37
00:01:31,100 --> 00:01:34,300
動的メモリ割り当て
ソートの私たちに道を可能にします

38
00:01:34,300 --> 00:01:36,867
この特定の問題を回避します。

39
00:01:36,867 --> 00:01:38,700
そして、方法は、それはそれをしません
ポインタを使用することです。

40
00:01:38,700 --> 00:01:42,140
>> 我々は、へのポインタを使用することができます
動的にアクセスします

41
00:01:42,140 --> 00:01:45,710
割り当てられたメモリ、メモリ
あなたのプログラムとして割り当てが実行されています。

42
00:01:45,710 --> 00:01:48,290
これは、コンパイル時に割り当てられていません。

43
00:01:48,290 --> 00:01:51,570
あなたが動的に割り当てると
それはプールから来るメモリ

44
00:01:51,570 --> 00:01:53,795
メモリのヒープとして知られています。

45
00:01:53,795 --> 00:01:56,420
私たちがきたこれまでのすべてのメモリ
コー​​ス内で仕事をして

46
00:01:56,420 --> 00:01:59,920
プールから来てされています
メモリのスタックとして知られています。

47
00:01:59,920 --> 00:02:02,470
一般的に良い方法
mind--と、このルールに保ちます

48
00:02:02,470 --> 00:02:04,720
常に、真の保持していません
しかし、かなりのほとんど

49
00:02:04,720 --> 00:02:09,940
常にtrue--が任意の点である保持
時間は、変数名を与えます

50
00:02:09,940 --> 00:02:12,090
おそらくスタック上に住んでいます。

51
00:02:12,090 --> 00:02:14,650
そうしないと、いつでも
変数に名前を付け、

52
00:02:14,650 --> 00:02:19,160
あなたは、動的なメモリを行うことができます
割り当ては、ヒープ上に住んでいます。

53
00:02:19,160 --> 00:02:22,190
>> 今、私は一種のとしてこれを提示しています
メモリのこれら2つのプールがあるかどうか。

54
00:02:22,190 --> 00:02:24,740
しかし、あなたはこれを見ている可能性があります
一般的に図、

55
00:02:24,740 --> 00:02:27,290
の表現
どのメモリは次のようになります、

56
00:02:27,290 --> 00:02:30,373
我々はについてのすべての世話をするつもりはありません
上部と下部のもの。

57
00:02:30,373 --> 00:02:33,580
私たちが気にすることで、この部分です
ここで、中間、ヒープとスタック。

58
00:02:33,580 --> 00:02:35,570
あなたがすることによって見ることができるように
この図を見て、

59
00:02:35,570 --> 00:02:38,390
これらは、実際には2つのではありません
メモリの別々のプール。

60
00:02:38,390 --> 00:02:42,757
これは、メモリの1共有プールです
どこにこの視覚的に開始します

61
00:02:42,757 --> 00:02:44,590
あなたは底に開始します
そして、いっぱい開始

62
00:02:44,590 --> 00:02:48,040
スタックと下部、およびあなたから
上部に開始し、いっぱい開始

63
00:02:48,040 --> 00:02:50,072
ヒープで上から下。

64
00:02:50,072 --> 00:02:51,780
しかし、それは実際にあります
同じプールには、それだけです

65
00:02:51,780 --> 00:02:56,050
異なるスポットを、異なる場所
メモリに割り当てられていること。

66
00:02:56,050 --> 00:02:59,060
そして、あなたは外に実行することができます
有するかによってメモリ

67
00:02:59,060 --> 00:03:01,240
ヒープはすべての道を行きます
下へ、または持っています

68
00:03:01,240 --> 00:03:05,440
スタックは、一番上にすべての道を行きます
またはヒープとスタックを持ちます

69
00:03:05,440 --> 00:03:06,740
お互いに会います。

70
00:03:06,740 --> 00:03:09,500
それらのすべての条件とすることができます
それはあなたのプログラムを引き起こします

71
00:03:09,500 --> 00:03:11,030
メモリが不足しています。

72
00:03:11,030 --> 00:03:11,952
だから、心の中でそれを維持します。

73
00:03:11,952 --> 00:03:13,660
我々はについて話すとき
ヒープとスタック

74
00:03:13,660 --> 00:03:17,880
私たちは本当に話しています
ただメモリの同じ一般的なチャンク、

75
00:03:17,880 --> 00:03:21,930
そのメモリの異なる部分。

76
00:03:21,930 --> 00:03:24,910
>> どのようにして動的に取得するのですか
最初の場所で割り当てられたメモリを？

77
00:03:24,910 --> 00:03:27,740
どのように私たちのプログラムは、取得しません
それが実行しているように、メモリ？

78
00:03:27,740 --> 00:03:32,660
ウェルCと呼ばれる機能を提供
malloc関数、メモリアロケータ、どの

79
00:03:32,660 --> 00:03:36,810
あなたはへの呼び出しを行い、あなたは渡します
どのように多くのあなたがしたいメモリのバイト。

80
00:03:36,810 --> 00:03:39,940
だからあなたのプログラムが実行されている場合
あなたは整数ランタイムをしたいです、

81
00:03:39,940 --> 00:03:46,040
あなたは、4つのバイトをマロック可能性があります
メモリは、malloc関数は、4つの括弧します。

82
00:03:46,040 --> 00:03:48,540
>> マロックは通過します
ヒープを通して見て、

83
00:03:48,540 --> 00:03:50,750
我々は動的だから
メモリを割り当てます、

84
00:03:50,750 --> 00:03:53,500
そしてそれはあなたに戻ります
そのメモリへのポインタ。

85
00:03:53,500 --> 00:03:56,180
それはあなたにそれを与えるものではありませんmemory--
それはそれに名前を与えるものではありません、

86
00:03:56,180 --> 00:03:57,950
それはあなたにそれへのポインタを提供します。

87
00:03:57,950 --> 00:04:00,780
再び私が言った理由となるようです
それは多分に重要だということ

88
00:04:00,780 --> 00:04:03,770
ポインタのビデオを見ています
我々はこの中に遠く取得する前に。

89
00:04:03,770 --> 00:04:05,940
だから、malloc関数に起こっています
ポインタをあなたにお返し。

90
00:04:05,940 --> 00:04:08,950
>> マロックはあなたに与えることができない場合
メモリあなたが実行したので、

91
00:04:08,950 --> 00:04:10,645
それはNULLポインタをあなたに戻ってあげます。

92
00:04:10,645 --> 00:04:15,282
あなたは私たちとどうなるか覚えていますか
試してみて、NULLポインタ間接参照？

93
00:04:15,282 --> 00:04:17,019
我々は右、ワンセグ障害に苦しみますか？

94
00:04:17,019 --> 00:04:18,060
それはおそらく良いではありません。

95
00:04:18,060 --> 00:04:21,579
>> だから、毎回あなたが電話をかけます
いつも、いつもあなたををmallocします

96
00:04:21,579 --> 00:04:25,270
かどうかを確認する必要があります
それはあなたが戻ってnullで与えたポインタ。

97
00:04:25,270 --> 00:04:28,800
もしそうであれば、あなたのプログラムを終了する必要があります
あなたがしようと間接参照しまうと

98
00:04:28,800 --> 00:04:31,360
あなたが行っているNULLポインタ
セグメンテーションフォールトに苦しみます

99
00:04:31,360 --> 00:04:34,380
あなたのプログラムがあります
とにかくクラッシュするだろう。

100
00:04:34,380 --> 00:04:37,190
それでは、どのよう静的に我々を行います
整数を取得しますか？

101
00:04:37,190 --> 00:04:37,730
>> int型のx。

102
00:04:37,730 --> 00:04:40,010
我々は、おそらくそれをやりました
回の束、右？

103
00:04:40,010 --> 00:04:43,480
これは、という変数を作成します。
スタック上に住んでいるのx。

104
00:04:43,480 --> 00:04:46,190
どのように動的に整数を得るのですか？

105
00:04:46,190 --> 00:04:50,010
int型のスターPXはmalloc関数4に等しいです。

106
00:04:50,010 --> 00:04:53,050
>> あるいは、より適切
我々は、int型のスターPXを言うと思います

107
00:04:53,050 --> 00:04:57,680
int型のmalloc関数のサイズに等しく、
ただ、いくつかの少ないをスローします

108
00:04:57,680 --> 00:04:59,740
私たちのプログラムの周りのマジックナンバー。

109
00:04:59,740 --> 00:05:04,140
これが私たちのために取得しようとしています
ヒープからの4バイトのメモリ、

110
00:05:04,140 --> 00:05:06,720
ポインタは、我々が得ます
それに戻っては、ピクセルと呼ばれています。

111
00:05:06,720 --> 00:05:08,430
そして、我々は同じようにしました
我々は以前に行われ

112
00:05:08,430 --> 00:05:13,966
缶PX逆参照
そのメモリにアクセスします。

113
00:05:13,966 --> 00:05:15,590
どのように我々は、ユーザから整数を得るのですか？

114
00:05:15,590 --> 00:05:17,970
私たちは、int型xはint型を取得するに等しいと言うことができます。

115
00:05:17,970 --> 00:05:19,930
これはかなり簡単です。

116
00:05:19,930 --> 00:05:24,030
私たちは、アレイを作成したい場合はどう
スタック上に住んでいるのx山車の？

117
00:05:24,030 --> 00:05:28,210
フロートはそれが名前ですstack_array--
私たちのarray--角括弧xの。

118
00:05:28,210 --> 00:05:32,419
それが私たちのために配列を作成します
スタック上に住んでいるのx山車の。

119
00:05:32,419 --> 00:05:34,960
私たちは、floatの配列を作成することができます
それも、ヒープ上に住んでいます。

120
00:05:34,960 --> 00:05:37,330
構文は次のとおりになります。
もう少し面倒、

121
00:05:37,330 --> 00:05:41,740
しかし、我々はfloatを言うことができます
スターheap_arrayに等しいです

122
00:05:41,740 --> 00:05:44,360
malloc関数のx倍フロートのサイズ。

123
00:05:44,360 --> 00:05:48,160
私は保持するのに十分なスペースを必要とします
X浮動小数点値。

124
00:05:48,160 --> 00:05:51,560
だから私は100を必要とすると言います
フロート、または千山車。

125
00:05:51,560 --> 00:05:54,810
だから、その場合には、それは次のようになります
100フロート400バイト、

126
00:05:54,810 --> 00:05:59,080
千フロートまたは4,000バイト、
各フロートが占めるため、

127
00:05:59,080 --> 00:06:01,230
スペースの4バイト。

128
00:06:01,230 --> 00:06:05,110
>> これを実行した後、私は使用することができます
heap_arrayの角括弧構文。

129
00:06:05,110 --> 00:06:08,970
ちょうど私がstack_arrayの場合と同じように、私
個別の要素にアクセスすることができます

130
00:06:08,970 --> 00:06:11,590
heap_arrayゼロ、heap_arrayいずれかを使用。

131
00:06:11,590 --> 00:06:15,800
しかし、我々はそれを行うことができた理由を思い出します
であるため、C言語の配列の名前

132
00:06:15,800 --> 00:06:19,990
本当にへのポインタであります
その配列の最初の要素。

133
00:06:19,990 --> 00:06:23,480
私たちは宣言しているという事実そう
ここで、スタック上のfloatの配列

134
00:06:23,480 --> 00:06:24,810
実際に少し誤解を招く恐れがあります。

135
00:06:24,810 --> 00:06:27,600
私たちは本当にしています
そこにコードの2行目

136
00:06:27,600 --> 00:06:32,360
またのチャンクへのポインタを作成します
私たちは、その後にいくつかの作業を行うメモリ。

137
00:06:32,360 --> 00:06:35,620
>> ここでの大きな問題です
動的にかかわらず、メモリが割り当てられ、

138
00:06:35,620 --> 00:06:38,360
これはそれが本当にだ理由です
いくつかの良い習慣を開発することが重要

139
00:06:38,360 --> 00:06:39,800
あなたはそれで作業しているとき。

140
00:06:39,800 --> 00:06:43,060
静的に宣言とは異なり、
メモリ、あなたの記憶

141
00:06:43,060 --> 00:06:46,790
自動的に戻されません
あなたの関数が実行されるシステム。

142
00:06:46,790 --> 00:06:49,280
だから我々は、メインがある場合、および
メインは、関数を呼び出します

143
00:06:49,280 --> 00:06:53,860
それはF仕上げをやっているものは何でもF、
プログラムの制御を戻します

144
00:06:53,860 --> 00:06:58,810
バックメインに、すべてのメモリ
使用されているfはバック与えられています。

145
00:06:58,810 --> 00:07:01,250
再度使用することができます
他のプログラムによって、

146
00:07:01,250 --> 00:07:04,250
またはいくつかの他の機能、その
主に後に呼び出されます。

147
00:07:04,250 --> 00:07:06,970
それは何度も、同じメモリを使用することができます。

148
00:07:06,970 --> 00:07:09,620
>> あなたの場合、動的に
しかしメモリを割り当てます

149
00:07:09,620 --> 00:07:14,380
あなたが明示的に指示する必要があります
あなたはそれで行われているシステム。

150
00:07:14,380 --> 00:07:18,370
それは可能性が、あなたのためにその上に保持します
あなたが不足しての問題につながります

151
00:07:18,370 --> 00:07:19,290
メモリの。

152
00:07:19,290 --> 00:07:22,179
そして、実際には、我々は時々参照してください。
メモリリークとしてこれに。

153
00:07:22,179 --> 00:07:24,970
そして、時には、これらのメモリリーク
実際には本当に壊滅的なことができます

154
00:07:24,970 --> 00:07:27,020
システムパフォーマンスのため。

155
00:07:27,020 --> 00:07:31,120
>> あなたが頻繁にインターネットユーザーの場合
あなたは、特定のWebブラウザを使用する場合があります

156
00:07:31,120 --> 00:07:35,630
そして、私はここで名前を命名しませんが、
一部のWebブラウザは、そこにあります

157
00:07:35,630 --> 00:07:39,150
実際に持つことで有名であること
固定されませんメモリリーク。

158
00:07:39,150 --> 00:07:44,570
そして、あなたは、あなたのブラウザが開いているままにしておくと
時間の非常に長い期間のために、日

159
00:07:44,570 --> 00:07:48,060
数日、または数週間、時には
お使いのシステムことがわかります

160
00:07:48,060 --> 00:07:49,790
本当にゆっくりと、本当に実行されています。

161
00:07:49,790 --> 00:07:54,640
そして、その理由は、ということです
ブラウザは、メモリを割り当てました

162
00:07:54,640 --> 00:07:57,320
しかし、システムを聞いていません
ことそれはそれで行われています。

163
00:07:57,320 --> 00:08:01,000
そして、そのためには、少ないメモリを残し
あなたの他のプログラムのすべてのために利用可能

164
00:08:01,000 --> 00:08:04,480
あなたがしているので、共有する必要がします
そのウェブブラウザleaking--

165
00:08:04,480 --> 00:08:06,755
プログラムがメモリをリークしています。

166
00:08:06,755 --> 00:08:08,880
我々は戻って、メモリを与えるにはどうすればよいです
我々はそれを行っているとき？

167
00:08:08,880 --> 00:08:10,838
まあ幸いです
それを行うには非常に簡単な方法。

168
00:08:10,838 --> 00:08:11,710
我々はそれを解放します。

169
00:08:11,710 --> 00:08:15,020
自由と呼ばれる機能があります、
これは、メモリへのポインタを受け取り、

170
00:08:15,020 --> 00:08:16,010
私たちは行ってもいいです。

171
00:08:16,010 --> 00:08:18,310
>> それでは、私たちがしているとしましょう
私たちのプログラムの途中、

172
00:08:18,310 --> 00:08:21,970
私たちは50文字をmallocしたいです。

173
00:08:21,970 --> 00:08:25,710
我々はできる配列ををmallocしたいです
50文字を保持することができます。

174
00:08:25,710 --> 00:08:29,109
そして、我々は戻っへのポインタを取得するとき
それは、そのポインタの名前は言葉です。

175
00:08:29,109 --> 00:08:30,900
私たちはしているものは何でも
単語をどうするつもり、

176
00:08:30,900 --> 00:08:33,440
し、我々をしているとき
私たちはそれを解放して行わ。

177
00:08:33,440 --> 00:08:37,460
そして今、我々はそれらの50を返しました
バックシステムへのメモリのバイト。

178
00:08:37,460 --> 00:08:40,147
他のいくつかの機能は、それらを使用することができます。

179
00:08:40,147 --> 00:08:43,480
私たちは苦しみを心配する必要はありません
メモリリークは、私たちは言葉を解放しているため。

180
00:08:43,480 --> 00:08:46,639
我々は戻って、メモリを与えてくれました、
私たちはそれで作業完了です。

181
00:08:46,639 --> 00:08:48,430
だから3つがあります
そのすべき黄金のルール

182
00:08:48,430 --> 00:08:51,700
あなたがしている時はいつでも心に留めておきます
動的にメモリを割り当てます

183
00:08:51,700 --> 00:08:52,990
malloc関数と。

184
00:08:52,990 --> 00:08:56,480
そのメモリの各ブロック
あなたのmallocを解放する必要があります

185
00:08:56,480 --> 00:08:58,430
あなたのプログラムの前に実行を終了します。

186
00:08:58,430 --> 00:09:02,029
ここでもう一度、アプライアンス内またはで
IDEは、この種の、とにかくあなたのために起こります

187
00:09:02,029 --> 00:09:04,820
you--とき、これはとにかくどうなります
あなたのプログラムが終了すると、

188
00:09:04,820 --> 00:09:06,880
すべてのメモリが解放されます。

189
00:09:06,880 --> 00:09:10,750
しかし、それは一般的に良いコーディングです
実際、常に、設定が完了したら、

190
00:09:10,750 --> 00:09:13,810
あなたがmallocdたものを解放します。

191
00:09:13,810 --> 00:09:16,690
>> それによると、唯一のものは、
あなたは解放する必要がmallocdました。

192
00:09:16,690 --> 00:09:19,880
あなたは静的に宣言すると
整数、int型のx、セミコロン、

193
00:09:19,880 --> 00:09:23,500
あなたは、スタック上に住んでいます
その後、Xを解放する必要はありません。

194
00:09:23,500 --> 00:09:25,970
あなたがきたので、唯一のもの
mallocdを解放する必要があります。

195
00:09:25,970 --> 00:09:28,960
>> そして最後に、二回無料ではない何かをします。

196
00:09:28,960 --> 00:09:31,170
それがにつながることができます
別の奇妙な状況。

197
00:09:31,170 --> 00:09:33,530
あなたがきたそうすべて
mallocdを解放する必要があります。

198
00:09:33,530 --> 00:09:36,000
あなたがた唯一のもの
malloc関数を解放する必要があります。

199
00:09:36,000 --> 00:09:38,730
そして二度ではない自由な何かをします。

200
00:09:38,730 --> 00:09:43,660
>> それでは、ここでは例を挙げて行ってみよう
いくつかは動的に割り当てられたものの

201
00:09:43,660 --> 00:09:46,122
メモリは、混合のようになります。
いくつかのスタティック・メモリとインチ

202
00:09:46,122 --> 00:09:47,080
ここで何が起こるのでしょうか？

203
00:09:47,080 --> 00:09:48,913
あなたが続くことができるかどうかを確認
沿って、何がだと思います

204
00:09:48,913 --> 00:09:51,720
私たちが行くように起きよう
コー​​ドのすべてのこれらのラインを介して。

205
00:09:51,720 --> 00:09:53,980
>> だから我々は、int型のメートルを言います。

206
00:09:53,980 --> 00:09:54,840
ここで何が起こりますか？

207
00:09:54,840 --> 00:09:56,339
まあ、これは非常に簡単です。

208
00:09:56,339 --> 00:09:59,650
私はメートルと呼ばれる整数型の変数を作成します。

209
00:09:59,650 --> 00:10:01,400
私は、それが緑色
なぜならそれは色です

210
00:10:01,400 --> 00:10:03,730
私が話しているとき、私は使用していること
約整数変数。

211
00:10:03,730 --> 00:10:05,160
それは箱です。

212
00:10:05,160 --> 00:10:08,400
これはMと呼ばれ、次のことができます
その中の整数を格納します。

213
00:10:08,400 --> 00:10:12,400
>> 私は、int型のスターは何と言えば？

214
00:10:12,400 --> 00:10:13,530
まあそれはかなり似ています。

215
00:10:13,530 --> 00:10:15,780
私はと呼ばれるボックスを作成しています。

216
00:10:15,780 --> 00:10:19,100
これは、int型を保持することができるのです
星、整数へのポインタ。

217
00:10:19,100 --> 00:10:21,570
だから私は、同様に緑っぽいそれを着色しています。

218
00:10:21,570 --> 00:10:24,140
>> 私はそれが何かを持っている知っています
整数を行うには、

219
00:10:24,140 --> 00:10:25,852
それは整数そのものではないのです。

220
00:10:25,852 --> 00:10:27,310
しかし、それはほとんど同じ考えです。

221
00:10:27,310 --> 00:10:28,101
私はボックスを作成しました。

222
00:10:28,101 --> 00:10:30,070
これらの権利の両方
今スタック上に住んでいます。

223
00:10:30,070 --> 00:10:32,520
私は彼らに両方の名前を与えてくれました。

224
00:10:32,520 --> 00:10:36,750
>> int型のスターBは、int型のmallocの大きさに等しいです。

225
00:10:36,750 --> 00:10:38,560
この1は少しトリッキーなことがあります。

226
00:10:38,560 --> 00:10:44,110
秒を取り、あなたはどうなんだと思います
この図に起こることを期待します。

227
00:10:44,110 --> 00:10:50,210
int型のスターBは、int型のmallocの大きさに等しいです。

228
00:10:50,210 --> 00:10:51,940
>> まあこれは単に一つの箱を作成しません。

229
00:10:51,940 --> 00:10:53,800
これは実際に2つのボックスを作成します。

230
00:10:53,800 --> 00:10:58,670
そしてそれはまた、確立し、結び付け
関係のポイント。

231
00:10:58,670 --> 00:11:02,240
私たちは一つのブロックを割り当てられました
ヒープ上のメモリ。

232
00:11:02,240 --> 00:11:05,940
右上のボックスことに注意してください
名前がありません。

233
00:11:05,940 --> 00:11:06,760
>> 我々はそれをmallocd。

234
00:11:06,760 --> 00:11:08,050
これは、ヒープ上に存在します。

235
00:11:08,050 --> 00:11:10,090
しかし、bが名前を持っています。

236
00:11:10,090 --> 00:11:11,950
これは、Bと呼ばれるポインタ変数です。

237
00:11:11,950 --> 00:11:13,910
それはスタック上に住んでいます。

238
00:11:13,910 --> 00:11:18,250
>> だから、メモリの一部です
それはまた別の1を指します。

239
00:11:18,250 --> 00:11:21,840
Bは、アドレスが含まれています
メモリのそのブロックの。

240
00:11:21,840 --> 00:11:23,757
それ以外の場合は名前がありません。

241
00:11:23,757 --> 00:11:24,590
しかし、それはそれを指しています。

242
00:11:24,590 --> 00:11:29,760
だから我々は、int型のスターbが等しいと言うとき
int型のmalloc関数の大きさ、その右が、

243
00:11:29,760 --> 00:11:33,490
上のポップアップその矢印
そこに右側、その全部、

244
00:11:33,490 --> 00:11:36,740
私はそれが表示される必要があります
もう一度、何が起こるかです。

245
00:11:36,740 --> 00:11:39,341
そのすべてがで起こります
コー​​ドの一行。

246
00:11:39,341 --> 00:11:41,340
今、私たちは少し多くを得るでしょう
再び簡単な。

247
00:11:41,340 --> 00:11:43,330
アンパサンドメートルに等しいです。

248
00:11:43,330 --> 00:11:46,280
あなたは何を思い出してください
アンパサンドmが等しいですか？

249
00:11:46,280 --> 00:11:48,920
まあそれはメートルのアドレスを取得します。

250
00:11:48,920 --> 00:11:54,150
あるいは、より図式入れます
メートルを指します。

251
00:11:54,150 --> 00:11:56,360
>> Bに等しいです。

252
00:11:56,360 --> 00:11:57,560
[OK]をので、ここでは別のものです。

253
00:11:57,560 --> 00:11:59,230
AがBに等しいです。

254
00:11:59,230 --> 00:12:02,260
何が起こるだろう
この時の図に？

255
00:12:02,260 --> 00:12:04,330
>> まあことを思い出してください
代入演算子の作品

256
00:12:04,330 --> 00:12:08,960
上の値を割り当てることによって、
右、左の値に設定します。

257
00:12:08,960 --> 00:12:14,820
だからではなくメートルを指しての、今
Bポイントが同じ場所を指しています。

258
00:12:14,820 --> 00:12:18,900
、B点はありません
B点を指しています。

259
00:12:18,900 --> 00:12:25,280
>> そのでしょうBに指されました
アンパサンドBに等しいされています。

260
00:12:25,280 --> 00:12:28,150
しかし、その代わりに、単にBに等しいです
それを意味し、bは今あります

261
00:12:28,150 --> 00:12:31,770
、同じアドレスを指しているため、
Bの内側にだけアドレスです。

262
00:12:31,770 --> 00:12:35,004
そして今の内側に同じアドレスです。

263
00:12:35,004 --> 00:12:37,170
mは、おそらく、10に等しいです
最も簡単なもの

264
00:12:37,170 --> 00:12:38,690
我々は少しで行ってきました。

265
00:12:38,690 --> 00:12:40,460
ボックスに10を入れてください。

266
00:12:40,460 --> 00:12:45,640
スターBはMに等しいプラス2からリコール
私たちのポインタビデオどの星bが意味しています。

267
00:12:45,640 --> 00:12:50,230
私たちは、間接参照Bと置くつもりです
そのメモリ位置にあるいくつかの値。

268
00:12:50,230 --> 00:12:51,860
この場合、12で。

269
00:12:51,860 --> 00:12:55,300
>> だから、ときに我々のポイントを間接参照
私達はちょうど矢印を下に移動思い出します。

270
00:12:55,300 --> 00:12:58,205
あるいは、別の言い方をすれば、我々
そのメモリアドレスに移動

271
00:12:58,205 --> 00:12:59,580
そして、我々はいくつかの方法でそれを操作します。

272
00:12:59,580 --> 00:13:00,830
私たちはそこにいくつかの値を入れます。

273
00:13:00,830 --> 00:13:03,960
この場合、スターBに
メートルに等しいプラス2だけです

274
00:13:03,960 --> 00:13:08,230
変数に行くには、Bによって指さ
メモリに行くには、Bによって指さ

275
00:13:08,230 --> 00:13:11,750
そして、、そこに12メートルプラス2を置きます。

276
00:13:11,750 --> 00:13:14,970
>> 今、私はBを解放します。

277
00:13:14,970 --> 00:13:16,490
私はBを解放すると、どうなりますか？

278
00:13:16,490 --> 00:13:18,800
私は自由な手段を言ったことを覚えておいてください。

279
00:13:18,800 --> 00:13:21,920
私はBを解放するとき、私は何を言っていますか？

280
00:13:21,920 --> 00:13:23,410
>> 私はそれで作業終わりですよね？

281
00:13:23,410 --> 00:13:25,702
私は基本的にメモリを放棄します。

282
00:13:25,702 --> 00:13:26,910
私は、それをシステムに返します。

283
00:13:26,910 --> 00:13:33,010
私は、これはもうである必要はありません
私はOK、それらを言っていますか？

284
00:13:33,010 --> 00:13:37,390
>> 今、私はと言えばスターA
11あなたはおそらくすることができます等しいです

285
00:13:37,390 --> 00:13:40,460
既に悪いこと何かを伝えます
右、ここで起こるだろうか？

286
00:13:40,460 --> 00:13:44,160
そして、私はそれ私はおそらくしようとした場合、実際に
セグメンテーションフォールトを被ることになります。

287
00:13:44,160 --> 00:13:47,140
今、あるがため、
メモリの以前にそのチャンク

288
00:13:47,140 --> 00:13:50,220
私が持っていたものでした
この時点でのアクセス、

289
00:13:50,220 --> 00:13:54,590
今私はそのメモリにアクセスしてい
私がアクセスするための法的ではありません。

290
00:13:54,590 --> 00:13:57,330
>> そして、我々は、おそらくれるように
我々はメモリにアクセスリコール、

291
00:13:57,330 --> 00:14:00,000
私たちが触れることになっていないこと、
それは、最も一般的な原因です

292
00:14:00,000 --> 00:14:01,860
セグメンテーションの
障害が発生しました。だから私のプログラム

293
00:14:01,860 --> 00:14:05,170
私はこれを行うにしようとした場合クラッシュしていました。

294
00:14:05,170 --> 00:14:09,910
だから、もう一度、それは良いを取得することをお勧めします
実践と良い習慣が根付い

295
00:14:09,910 --> 00:14:12,920
mallocとfreeで作業する場合、
あなたは、セグメンテーションを受けないように

296
00:14:12,920 --> 00:14:15,310
故障、およびあなたが使用することを
あなたの動的に割り当てられました

297
00:14:15,310 --> 00:14:17,370
メモリ責任。

298
00:14:17,370 --> 00:14:20,300
>> 私は、これはCS50であるダグ・ロイドです。

299
00:14:20,300 --> 00:14:21,947