1
00:00:00,000 --> 00:00:06,030
>> [音楽再生]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD：ポインタ、ここではあります。

3
00:00:08,390 --> 00:00:11,080
これはおそらくに起こっています
最も困難なトピックであること

4
00:00:11,080 --> 00:00:12,840
我々はCS50での話をすることを。

5
00:00:12,840 --> 00:00:15,060
そして、あなたが読んだ場合
ポインタについて何か

6
00:00:15,060 --> 00:00:19,080
あなたが少しあるかもしれない前に、
このビデオに行く威圧的。

7
00:00:19,080 --> 00:00:21,260
これは、ポインタ本当です
あなたの能力を許可しません

8
00:00:21,260 --> 00:00:23,740
おそらく台無しにします
かなりひどくあなたがいるとき

9
00:00:23,740 --> 00:00:27,450
変数、およびデータの操作、
そして、、プログラムがクラッシュする原因となります。

10
00:00:27,450 --> 00:00:30,490
しかし、彼らは実際には本当に便利です
そして彼らは私たちは本当に素晴らしい方法を許可します

11
00:00:30,490 --> 00:00:33,340
バックデータを渡すと、
などの機能との間には、

12
00:00:33,340 --> 00:00:35,490
ことを、私たちは、そうでなければ行うことができません。

13
00:00:35,490 --> 00:00:37,750
>> だから私たちは本当に
ここでやってみたい列車です

14
00:00:37,750 --> 00:00:41,060
あなたの良いポインタの規律を持っているので、
あなたが効果的にポインタを使用することができます

15
00:00:41,060 --> 00:00:43,850
より良いあなたのプログラムを作成します。

16
00:00:43,850 --> 00:00:48,220
私が言ったようにポインタは、私たちに別のを与えます
機能間でデータを渡す方法。

17
00:00:48,220 --> 00:00:50,270
今から思い出した場合
以前のビデオ、時

18
00:00:50,270 --> 00:00:53,720
私たちは話していました
私が述べた変数のスコープ、

19
00:00:53,720 --> 00:01:00,610
その私たちは間を通過するすべてのデータ
C言語の関数は値で渡されます。

20
00:01:00,610 --> 00:01:03,070
そして、私はそれを使用していない可能性があります
私が何を意味するのか用語、

21
00:01:03,070 --> 00:01:07,170
我々は、データのコピーを渡しているということでした。

22
00:01:07,170 --> 00:01:12,252
我々は、関数に変数を渡すと、
私たちは実際に変数を渡していません

23
00:01:12,252 --> 00:01:13,210
関数に、右？

24
00:01:13,210 --> 00:01:17,670
私たちは、のコピーを渡しています
関数へのデータ。

25
00:01:17,670 --> 00:01:20,760
関数がどのようなことがないでしょう
それはいくつかの値を算出し、

26
00:01:20,760 --> 00:01:23,180
そして多分私達は、その値を使用
それをバック与えるとき。

27
00:01:23,180 --> 00:01:26,700
>> 唯一の例外にはありました
値渡しのこのルール、

28
00:01:26,700 --> 00:01:31,210
私たちはどのようなものに戻ってきます
このビデオでは、後にはほとんどです。

29
00:01:31,210 --> 00:01:34,880
我々は、代わりにポインタを使用する場合
変数を使用します、

30
00:01:34,880 --> 00:01:38,180
あるいはその代わりに変数を使用します
自分自身や変数のコピー、

31
00:01:38,180 --> 00:01:43,790
我々は今の周りの変数を渡すことができます
別の方法で機能間。

32
00:01:43,790 --> 00:01:46,550
これは、我々が行った場合ことを意味し
1機能の変化、

33
00:01:46,550 --> 00:01:49,827
その変更は、実際にかかります
異なる機能の効果。

34
00:01:49,827 --> 00:01:52,160
再び、これは、そのものです
我々は、以前に行うことができませんでした

35
00:01:52,160 --> 00:01:56,979
あなたが今までに交換しようとした場合
関数内の2つの変数の値、

36
00:01:56,979 --> 00:01:59,270
あなたはこの問題に気づきました
忍び寄るの一種、右？

37
00:01:59,270 --> 00:02:04,340
>> 我々は、XとYを交換したい場合は、我々
スワップと呼ばれる関数に渡します、

38
00:02:04,340 --> 00:02:08,680
関数の内部で交換します
変数は、為替の値を行います。

39
00:02:08,680 --> 00:02:12,600
一つは2になり、2になります
1、私たちは実際にはありません

40
00:02:12,600 --> 00:02:16,890
元に何かを変更
呼び出し元関数、。

41
00:02:16,890 --> 00:02:19,550
我々は、我々は唯一だことはできませんので、
それらのコピーでの作業。

42
00:02:19,550 --> 00:02:24,760
しかしポインタを、我々はできます
実際に関数にXとYを渡します。

43
00:02:24,760 --> 00:02:26,960
その関数が行うことができます
彼らと何か。

44
00:02:26,960 --> 00:02:29,250
そして、これらの変数値
実際に変更することができます。

45
00:02:29,250 --> 00:02:33,710
だから、中にはかなりの変化です
データを操作する能力。

46
00:02:33,710 --> 00:02:36,100
>> 我々はに飛び込む前に、
ポインタは、私はそれが価値があると思います

47
00:02:36,100 --> 00:02:38,580
数分を取って
ここに戻って基本に行きます。

48
00:02:38,580 --> 00:02:41,000
そして、どのように見ています
コンピュータメモリの動作

49
00:02:41,000 --> 00:02:45,340
これらの2科目を行っているため、
実際にはかなりの相互にすることができます。

50
00:02:45,340 --> 00:02:48,480
あなたはおそらく知っているように、
お使いのコンピュータシステム上の

51
00:02:48,480 --> 00:02:51,310
あなたは、ハードドライブを持っていますか、
おそらく、ソリッドステートドライブ、

52
00:02:51,310 --> 00:02:54,430
ファイルの保存場所のいくつかの並べ替え。

53
00:02:54,430 --> 00:02:57,950
それは、どこかで、通常です
250ギガバイトの近傍

54
00:02:57,950 --> 00:02:59,810
今テラバイトのカップル多分に。

55
00:02:59,810 --> 00:03:02,270
そしてそれはどこにあなたのすべてです
ファイルは、最終的に生き、

56
00:03:02,270 --> 00:03:04,870
お使いのコンピュータをシャットダウンした場合でも
オフ、元に戻すことができます

57
00:03:04,870 --> 00:03:09,190
あなたは、あなたのファイルがある見つけることができます
もう一度、あなたのシステムを再起動したとき。

58
00:03:09,190 --> 00:03:14,820
しかし、ハード・ディスク・ドライブのようなディスク・ドライブ、
HDD、またはソリッド・ステート・ドライブ、SSD、

59
00:03:14,820 --> 00:03:16,050
ちょうど収納スペースです。

60
00:03:16,050 --> 00:03:20,400
>> 私たちは実際に何もできません
ハードディスク内のデータ、

61
00:03:20,400 --> 00:03:22,080
またはソリッド・ステート・ドライブインチ

62
00:03:22,080 --> 00:03:24,950
実際に変更するために、
データまたはそれを動き回ります、

63
00:03:24,950 --> 00:03:28,800
私たちはそれを移動する必要があります
RAM、ランダム・アクセス・メモリ。

64
00:03:28,800 --> 00:03:31,170
今のRAM、あなたはたくさんあり​​ます
お使いのコンピュータ内の以下です。

65
00:03:31,170 --> 00:03:34,185
あなたがどこかを有することができます
512メガバイトの近傍

66
00:03:34,185 --> 00:03:38,850
古いコンピュータを持っている場合、
多分に2つ、4つ、8、16、

67
00:03:38,850 --> 00:03:41,820
おそらく少しでも
それ以上のRAM、ギガバイト。

68
00:03:41,820 --> 00:03:46,390
だから、はるかに小さいのですが、それはです
ここで揮発性データのすべてが存在します。

69
00:03:46,390 --> 00:03:48,270
私たちは物事を変えることができるところです。

70
00:03:48,270 --> 00:03:53,350
しかし、我々はコンピュータの電源を切ると、
RAM内のすべてのデータが破壊されます。

71
00:03:53,350 --> 00:03:57,150
>> 我々はハードディスクを持っている必要がありますだから、なぜです
それのより恒久的な場所のため、

72
00:03:57,150 --> 00:03:59,720
それをだろうexists-ように、
本当に悪いことかのたびに我々

73
00:03:59,720 --> 00:04:03,310
すべての、私たちのコンピュータをオフにし
私たちのシステム内のファイルが消失しました。

74
00:04:03,310 --> 00:04:05,600
だから我々は、RAMの内部で作業。

75
00:04:05,600 --> 00:04:09,210
私たちが話していると毎回
メモリ、かなり、CS50で、

76
00:04:09,210 --> 00:04:15,080
我々は、RAMではなく、ハードディスクの話をしています。

77
00:04:15,080 --> 00:04:18,657
>> だから我々は、メモリに物事を移動すると、
それは、空間の特定の量を占めます。

78
00:04:18,657 --> 00:04:20,740
そのデータ型のすべて
我々はと協力してきました

79
00:04:20,740 --> 00:04:23,480
異なる取ります
RAM内のスペースの量。

80
00:04:23,480 --> 00:04:27,600
だから、毎回あなたが整数を作成
メモリの変数、4バイト

81
00:04:27,600 --> 00:04:30,750
あなたので、RAMに脇に設定されています
その整数を扱うことができます。

82
00:04:30,750 --> 00:04:34,260
あなたは整数を宣言することができ、
それを変更し、それを割り当てます

83
00:04:34,260 --> 00:04:36,700
インクリメントされた値10に
1、というようにというようにすることによって。

84
00:04:36,700 --> 00:04:39,440
で発生する必要があるすべて
RAM、あなたは4バイトを取得

85
00:04:39,440 --> 00:04:42,550
すべてのために動作するように
あなたが作成する整数。

86
00:04:42,550 --> 00:04:45,410
>> すべての文字あなた
作成は、1バイトを取得します。

87
00:04:45,410 --> 00:04:48,160
つまりどれだけのスペースです
文字を格納するのに必要な。

88
00:04:48,160 --> 00:04:51,310
すべてのフロート、本当
番号は、4バイトを取得します

89
00:04:51,310 --> 00:04:53,390
それは二重のない限り
単精度浮動小数点

90
00:04:53,390 --> 00:04:56,510
あなたがすることができます番号、
より正確な桁以上を持っています

91
00:04:56,510 --> 00:04:59,300
小数点以下
精度を失うことなく、

92
00:04:59,300 --> 00:05:01,820
これはメモリの8バイトを取ります。

93
00:05:01,820 --> 00:05:06,730
ロングlong型、本当に大きな整数、
また、メモリの8バイトを取ります。

94
00:05:06,730 --> 00:05:09,000
どのように多くのメモリのバイト数
文字列が取るのですか？

95
00:05:09,000 --> 00:05:12,990
さてそれでは、その質問にピンを入れてみましょう
今のところ、私たちはそれに戻ってくるでしょう。

96
00:05:12,990 --> 00:05:17,350
>> だから、バックメモリのこのアイデアなどに
バイトサイズのセルの大きさの配列。

97
00:05:17,350 --> 00:05:20,871
それは本当にそれがすべてです、それはです
細胞のちょうど巨大な配列、

98
00:05:20,871 --> 00:05:23,370
ただ、他の配列のようなもの
あなたが精通していると参照してください。

99
00:05:23,370 --> 00:05:26,430
すべての要素を除いて1バイト幅です。

100
00:05:26,430 --> 00:05:30,030
そして、ちょうど配列のように、
すべての要素は、アドレスを有します。

101
00:05:30,030 --> 00:05:32,120
配列の各要素
インデックス、私たちを持っています

102
00:05:32,120 --> 00:05:36,302
いわゆる行うには、その索引を使用することができます
アレイ上のランダムアクセス。

103
00:05:36,302 --> 00:05:38,510
私たちはで起動する必要はありません
配列の先頭、

104
00:05:38,510 --> 00:05:40,569
すべての繰り返し処理を実行
その単一の要素、

105
00:05:40,569 --> 00:05:41,860
我々が探しているものを見つけることができます。

106
00:05:41,860 --> 00:05:45,790
私達はちょうど私が取得したい、と言うことができます
第15回要素または100番目の要素。

107
00:05:45,790 --> 00:05:49,930
そして、あなたはちょうどその数に渡すことができます
あなたが探している値を取得します。

108
00:05:49,930 --> 00:05:54,460
>> 同様にすべての場所
メモリ内のアドレスを有しています。

109
00:05:54,460 --> 00:05:57,320
だからあなたのメモリがかもしれません
このような何かを見て。

110
00:05:57,320 --> 00:06:01,420
ここでの非常に小さな塊です
メモリは、これはメモリの20バイトです。

111
00:06:01,420 --> 00:06:04,060
私のために最初の20バイト
そこに一番下のアドレス

112
00:06:04,060 --> 00:06:08,890
0、1、2、3、等です
19までのすべての方法に。

113
00:06:08,890 --> 00:06:13,190
そして、私は、変数を宣言するときに
私は彼らと仕事を開始したとき、

114
00:06:13,190 --> 00:06:15,470
システムは、設定しようとしています
私にとってはさておきいくつかの領域

115
00:06:15,470 --> 00:06:17,595
このメモリで動作するように
私の変数を持ちます。

116
00:06:17,595 --> 00:06:21,610
だから私は、char cが資本に等しい、と言うかもしれません
H.そして、何が起こるだろうか？

117
00:06:21,610 --> 00:06:23,880
さて、システムをしようとしています
私のために脇に1バイトを設定します。

118
00:06:23,880 --> 00:06:27,870
この場合、バイト数を選択しました
4、アドレス4のバイト、

119
00:06:27,870 --> 00:06:31,310
そして、それは保存するために起こっています
私のためにそこに手紙資本H。

120
00:06:31,310 --> 00:06:34,350
私は、int型の速度を言うなら
制限は、それはだ、65に等しいです

121
00:06:34,350 --> 00:06:36,806
別に4を設定しようとして
私のためにメモリのバイト。

122
00:06:36,806 --> 00:06:39,180
そしてそれはそれらを処理するために起こっています
単一のユニットとして4バイト

123
00:06:39,180 --> 00:06:41,305
私たちが取り組んでいるもののため
ここで整数です。

124
00:06:41,305 --> 00:06:44,350
そして、それはそこに65を格納するために起こっています。

125
00:06:44,350 --> 00:06:47,000
>> 今すでに、私は一種のです
あなたの嘘のビットを伝えます、

126
00:06:47,000 --> 00:06:50,150
私たちがいることを知っているので、右
コンピュータがバイナリで働きます。

127
00:06:50,150 --> 00:06:53,100
彼らは理解していません
必ずしも資本Hが何でありますか

128
00:06:53,100 --> 00:06:57,110
または65は、彼らだけで、何です
バイナリ、0と1を理解しています。

129
00:06:57,110 --> 00:06:59,000
だから、実際にどのような
我々はそこに保存しています

130
00:06:59,000 --> 00:07:03,450
文字Hおよび番号65は、ではありません
むしろバイナリ表現

131
00:07:03,450 --> 00:07:06,980
その、これ見て
このような小さなもの。

132
00:07:06,980 --> 00:07:10,360
特に中
整数変数との関連、

133
00:07:10,360 --> 00:07:13,559
それは、ちょうどにそれを吐き出すことはないだろう
それは、1〜4のようにそれを扱うことはないだろう

134
00:07:13,559 --> 00:07:15,350
必ずしもバイトチャンク、
それが実際に起こっています

135
00:07:15,350 --> 00:07:19,570
4 1バイトチャンクとしてそれを治療するために、
これは次のようになります。

136
00:07:19,570 --> 00:07:22,424
とにもこれではありません
完全に真のどちらか、

137
00:07:22,424 --> 00:07:24,840
呼ばれるもののため、
我々はないですエンディアン、

138
00:07:24,840 --> 00:07:26,965
今に取得するつもりはなく、
あなたが興味なら、

139
00:07:26,965 --> 00:07:29,030
あなたは少し上に読むことができます
ビッグエンディアン。

140
00:07:29,030 --> 00:07:31,640
しかし、この議論のために、
このビデオのために、

141
00:07:31,640 --> 00:07:34,860
ちょうどそれがあると仮定しましょう​​、で
実際、どのように数65を希望

142
00:07:34,860 --> 00:07:36,970
で表すこと
すべてのシステム上のメモリ、

143
00:07:36,970 --> 00:07:38,850
それは完全に真実ではないものの。

144
00:07:38,850 --> 00:07:41,700
>> しかし、それでは、実際には取得してみましょう
すべてのバイナリを取り除く完全に、

145
00:07:41,700 --> 00:07:44,460
ちょうどHとして考えます
65、それははるかに簡単です

146
00:07:44,460 --> 00:07:47,900
以下のようにそれについて考えること
人間としてそれ。

147
00:07:47,900 --> 00:07:51,420
すべての権利なので、それも多分そうです
I've-私のシステムその小さなランダム

148
00:07:51,420 --> 00:07:55,130
バイト5、6、7、私に与えていません、
整数を格納する8。

149
00:07:55,130 --> 00:07:58,580
その理由は、あまりにも、あります
我々は今に入るが、十分ではありません

150
00:07:58,580 --> 00:08:00,496
それはその何言って
コンピュータがここにやっています

151
00:08:00,496 --> 00:08:02,810
おそらくその部分に良い動きです。

152
00:08:02,810 --> 00:08:06,020
私のメモリを与えないために、
必ずしも背中合わせに。

153
00:08:06,020 --> 00:08:10,490
それは今それを行うために起こっているが、
私は別の文字列を取得したい場合は、

154
00:08:10,490 --> 00:08:13,080
姓と呼ばれ、私が欲しいです
そこにロイドを配置します。

155
00:08:13,080 --> 00:08:18,360
私は1つに合わせて必要するつもりです
文字、その者の各文字

156
00:08:18,360 --> 00:08:21,330
1を必要とするだろう
文字、1バイトのメモリー。

157
00:08:21,330 --> 00:08:26,230
だから私は私の配列にロイドを置くことができれば
このように私は右、行くにはかなり良いですよ？

158
00:08:26,230 --> 00:08:28,870
何が欠けていますか？

159
00:08:28,870 --> 00:08:31,840
>> すべての文字列我々は働くことを覚えておいてください
C言語で、バックスラッシュゼロで終わると

160
00:08:31,840 --> 00:08:33,339
私たちはどちらか、ここでそれを省略することはできません。

161
00:08:33,339 --> 00:08:36,090
我々はさておき、1バイトを設定する必要があります
私たちのことを保持するためのメモリ

162
00:08:36,090 --> 00:08:39,130
私たちの文字列が終了したときに知っています。

163
00:08:39,130 --> 00:08:41,049
だから、再びこのような構成
物事の

164
00:08:41,049 --> 00:08:42,799
メモリかもしれないに表示されます
少しランダムで、

165
00:08:42,799 --> 00:08:44,870
それが実際にどのように
ほとんどのシステムが設計されています。

166
00:08:44,870 --> 00:08:48,330
倍数でそれらをラインアップするには
再び理由のための4つの

167
00:08:48,330 --> 00:08:50,080
我々はする必要がないこと
今に入ります。

168
00:08:50,080 --> 00:08:53,060
しかし、これは、そうすることを言えば十分
次の3行のコードの後に​​、

169
00:08:53,060 --> 00:08:54,810
これは、メモリがどのように見えるかです。

170
00:08:54,810 --> 00:08:58,930
私は、メモリ位置を必要とする場合
4,8、および12は、自分のデータを保持します

171
00:08:58,930 --> 00:09:01,100
これは、私の記憶がどのようなものであるかです。

172
00:09:01,100 --> 00:09:04,062
>> そして、ちょうど、特にすること
ここで、知識をひけらかします

173
00:09:04,062 --> 00:09:06,020
我々は、メモリの話をしています
アドレス通常我々

174
00:09:06,020 --> 00:09:08,390
進表記を使用して行ってください。

175
00:09:08,390 --> 00:09:12,030
では、なぜ我々はこれらのすべてを変換しません
10進数から16進数へ

176
00:09:12,030 --> 00:09:15,010
それは一般的だという理由だけで
どのように我々は、メモリを参照してください。

177
00:09:15,010 --> 00:09:17,880
だからではなく、0〜という
19、私たちは持っていることはゼロであります

178
00:09:17,880 --> 00:09:20,340
ゼロX1 3を介してXゼロ。

179
00:09:20,340 --> 00:09:23,790
これらは、私たちのメモリの20バイト
持っているか、私たちは、このイメージに見ています

180
00:09:23,790 --> 00:09:25,540
ここ。

181
00:09:25,540 --> 00:09:29,310
>> それは言われているのだから、すべて、レッツ
第二のためにメモリから離れます

182
00:09:29,310 --> 00:09:30,490
バックポインタへ。

183
00:09:30,490 --> 00:09:32,420
ここで最も重要です
覚えておくべき事

184
00:09:32,420 --> 00:09:34,070
我々は、ポインタでの作業を開始します。

185
00:09:34,070 --> 00:09:36,314
ポインタは何もありません
アドレスより。

186
00:09:36,314 --> 00:09:38,230
私はので、再びそれを言いますよ
それは、その重要です

187
00:09:38,230 --> 00:09:42,730
ポインタは何もありません
アドレスより。

188
00:09:42,730 --> 00:09:47,760
ポインタは場所にアドレスです
メモリ内の変数は、住んでいる場所。

189
00:09:47,760 --> 00:09:52,590
それがうまくいけばなることを知って
彼らと一緒に仕事が少し簡単に。

190
00:09:52,590 --> 00:09:54,550
私が好きなもう一つ
行うには、ソートすることです

191
00:09:54,550 --> 00:09:58,510
視覚的に何を表す図の
コー​​ドの様々な線で起こって。

192
00:09:58,510 --> 00:10:00,660
そして、我々は、このカップルやります
ポインタの時刻の、

193
00:10:00,660 --> 00:10:03,354
我々は、動的について話すとき
メモリの割り当てにも。

194
00:10:03,354 --> 00:10:06,020
私はこれらの図と思うので
特に役立ちます。

195
00:10:06,020 --> 00:10:09,540
>> だから私は、たとえば言うならば、int型のK
私のコードでは、何が起こっているのでしょうか？

196
00:10:09,540 --> 00:10:12,524
まあ、基本的に何をされて起こっています
私は、私のために確保されたメモリを取得しています

197
00:10:12,524 --> 00:10:14,690
しかし、私も好きではありません
私は、そのようにそれについて考えます

198
00:10:14,690 --> 00:10:16,300
箱のようにそれについて考えるのが好きです。

199
00:10:16,300 --> 00:10:20,090
私は箱を持って、それはです
色の緑私ので、

200
00:10:20,090 --> 00:10:21,750
緑色のボックスに整数を入れることができます。

201
00:10:21,750 --> 00:10:23,666
それは文字私だった場合
青色のボックスを持っている可能性があります。

202
00:10:23,666 --> 00:10:27,290
私が作成していた場合しかし、私はいつも、言います
整数を保持することができますボックス

203
00:10:27,290 --> 00:10:28,950
そのボックスが緑色に着色されています。

204
00:10:28,950 --> 00:10:33,020
そして、私は永久的なマーカーを取ります
私はそれの側にKを書きます。

205
00:10:33,020 --> 00:10:37,590
だから私は、Kと呼ばれる箱を持っています
その中に私は整数を置くことができます。

206
00:10:37,590 --> 00:10:41,070
私はint型kを言うときに、それはです
何が私の頭の中で起こります。

207
00:10:41,070 --> 00:10:43,140
私は、kは5に等しいと言うなら、私は何をやっていますか？

208
00:10:43,140 --> 00:10:45,110
まあ、私は5を入れています
ボックスで、右。

209
00:10:45,110 --> 00:10:48,670
これがあれば、非常に簡単です
私はint型のkは、Kと呼ばれるボックスを作成言います。

210
00:10:48,670 --> 00:10:52,040
私は、kが5に等しいと言うなら、
ボックスに5を入れます。

211
00:10:52,040 --> 00:10:53,865
うまくいけば、それは飛躍のあまりありません。

212
00:10:53,865 --> 00:10:55,990
物事が行くのはここです
しかし興味深い少し。

213
00:10:55,990 --> 00:11:02,590
私はint型*のPKを言えば、よく私はしていない場合でも
これは必ずしも意味を知って、

214
00:11:02,590 --> 00:11:06,150
それは明らかに何かを持っています
整数とすることができません。

215
00:11:06,150 --> 00:11:08,211
だから私は色に行きますよ
緑っぽいこのボックス、

216
00:11:08,211 --> 00:11:10,210
私はそれが何かを持っている知っています
整数を行うには、

217
00:11:10,210 --> 00:11:13,400
それは整数自体ではありません、
それはint型のスターだから。

218
00:11:13,400 --> 00:11:15,390
何かが少しあります
それについて異なります。

219
00:11:15,390 --> 00:11:17,620
だから、整数の関与、
しかし、それ以外の場合はです

220
00:11:17,620 --> 00:11:19,830
とあまりにも違いはありません
私たちは話していました。

221
00:11:19,830 --> 00:11:24,240
それはボックスだ、そのには、ラベルを持って
それはラベルのPKを着て、

222
00:11:24,240 --> 00:11:27,280
それが保持​​することが可能です
それらがあるどのようなint型星、。

223
00:11:27,280 --> 00:11:29,894
彼らは何かを持っています
整数と、明らかに。

224
00:11:29,894 --> 00:11:31,060
ここで最後の行は、しかしです。

225
00:11:31,060 --> 00:11:37,650
私が言う場合はPK =＆K、おっ、
何がちょうど、起こったのですか？

226
00:11:37,650 --> 00:11:41,820
したがって、この乱数、一見ランダム
数は、そこにボックスの中に投げ込まれます。

227
00:11:41,820 --> 00:11:44,930
つまりすべては、PKであります
kのアドレスを取得します。

228
00:11:44,930 --> 00:11:52,867
kは、メモリ内に住んでだから私はこだわっています、
そのアドレス、そのバイトのアドレス。

229
00:11:52,867 --> 00:11:55,200
私がやっているすべては私が言っています
その値は、私が行くよ何であります

230
00:11:55,200 --> 00:11:59,430
私のボックスと呼ばれるPKの内側に配置します。

231
00:11:59,430 --> 00:12:02,080
そして、これらのものであるため、
ポインタ、見ているため

232
00:12:02,080 --> 00:12:04,955
ゼロXのような文字列で
8ゼロC 7 4 8

233
00:12:04,955 --> 00:12:07,790
2つのゼロと考えられます
非常に意味がありません。

234
00:12:07,790 --> 00:12:12,390
我々は、一般的にポインタを視覚化すると、
私たちは、実際にポインタとしてそう。

235
00:12:12,390 --> 00:12:17,000
Pkが私たちに情報を提供します
我々は、メモリ内のKを見つける必要があります。

236
00:12:17,000 --> 00:12:19,120
したがって、基本的にPKがそれに矢印を持っています。

237
00:12:19,120 --> 00:12:21,670
そして、我々は長さを歩けば
その矢印の、想像

238
00:12:21,670 --> 00:12:25,280
我々かどうかは、あなたが歩くことができる何か
矢印の長さに沿って歩きます、

239
00:12:25,280 --> 00:12:29,490
その矢印の非常に先端に、我々
メモリ内の場所を検索します

240
00:12:29,490 --> 00:12:31,390
ここで、kが住んでいます。

241
00:12:31,390 --> 00:12:34,360
そして、それは本当に重要です
私たちはここで、kの生活を知っていればいるため、

242
00:12:34,360 --> 00:12:37,870
我々は、データを操作するために始めることができます
そのメモリ位置の内部。

243
00:12:37,870 --> 00:12:40,780
私たちは小さなを取得しているものの
今のところ先に自分自身のビット。

244
00:12:40,780 --> 00:12:42,240
>> だからポインタとは何でしょうか？

245
00:12:42,240 --> 00:12:45,590
ポインタは、そのデータ項目です
値がメモリアドレスです。

246
00:12:45,590 --> 00:12:49,740
これは、ゼロのx 8ゼロのものでした
起こって、それはメモリアドレスでした。

247
00:12:49,740 --> 00:12:52,060
つまり、メモリ内の場所でした。

248
00:12:52,060 --> 00:12:55,080
そして、ポインタの型
種類を記述する

249
00:12:55,080 --> 00:12:56,930
データのあなたがで見つけることができます
そのメモリアドレス。

250
00:12:56,930 --> 00:12:58,810
だからint型のスター部分権利があります。

251
00:12:58,810 --> 00:13:03,690
私はその矢印に従った場合、それはです
場所に私をリードして行きます。

252
00:13:03,690 --> 00:13:06,980
そして、その場所、どのような私
私の例でそこでしょう、

253
00:13:06,980 --> 00:13:08,240
緑色のボックスです。

254
00:13:08,240 --> 00:13:12,650
それはそれはどのような私ですが、整数です
私はそのアドレスに行けばわかります。

255
00:13:12,650 --> 00:13:14,830
データ・タイプ
ポインタが何を説明

256
00:13:14,830 --> 00:13:17,936
あなたは、そのメモリアドレスにあります。

257
00:13:17,936 --> 00:13:19,560
だからここにかかわらず、本当にクールなことです。

258
00:13:19,560 --> 00:13:25,090
ポインタは、私たちが通過できるように
関数間の変数。

259
00:13:25,090 --> 00:13:28,520
そして、実際に変数を渡します
およびそれらのコピーを渡さありません。

260
00:13:28,520 --> 00:13:32,879
私たちが知っている場合ので、場所を正確に
メモリ内の変数を見つけるために、

261
00:13:32,879 --> 00:13:35,670
我々は、のコピーを作成する必要はありません
それは、私たちはその場所に行くことができます

262
00:13:35,670 --> 00:13:37,844
その変数で動作します。

263
00:13:37,844 --> 00:13:40,260
だから、本質的にポインタでソート
コンピュータ環境を作ります

264
00:13:40,260 --> 00:13:42,360
より多くの現実の世界のように、右。

265
00:13:42,360 --> 00:13:44,640
>> だからここに類推です。

266
00:13:44,640 --> 00:13:48,080
のは、私はノートパソコンを持っているとしましょう​​、
右、それはノートのフルです。

267
00:13:48,080 --> 00:13:50,230
そして、私はあなたがそれを更新したいと思います。

268
00:13:50,230 --> 00:13:53,960
あなたはその関数であります
アップデートノート、右。

269
00:13:53,960 --> 00:13:56,390
私たちがしてきたように
何、これまでの作業

270
00:13:56,390 --> 00:14:02,370
あなたは私のノートを取るされて起こります、
あなたは、コピー店に行きますよ

271
00:14:02,370 --> 00:14:06,410
あなたは、ゼロックスのコピーを作成します
ノートブックのすべてのページ。

272
00:14:06,410 --> 00:14:09,790
あなたは戻って私のノートを残しておきます
完了したら、私の机の上に、

273
00:14:09,790 --> 00:14:14,600
あなたは私に行くと物事を横断します
日付や間違っから外れているノートブック、

274
00:14:14,600 --> 00:14:19,280
そして、あなたはバックに渡します
私ゼロックスページのスタック

275
00:14:19,280 --> 00:14:22,850
それは私のノートのレプリカであります
あなたがそれに加えた変更。

276
00:14:22,850 --> 00:14:27,040
そして、その時点で、それは、私次第です
呼び出し元の関数は、呼び出し元として、

277
00:14:27,040 --> 00:14:30,582
あなたのノートを取ることを決定し、
戻って私のノートPCに統合します。

278
00:14:30,582 --> 00:14:32,540
Soステップの多くがあります
右、ここに関与。

279
00:14:32,540 --> 00:14:34,850
同様に、それは良いではないでしょう
私はと言えば、ちょっと、することができます

280
00:14:34,850 --> 00:14:38,370
以下のための私のノートブックを更新
私は、あなたに私のノートブックを手

281
00:14:38,370 --> 00:14:40,440
あなたは物事を取り、
文字通りそれらを渡ります

282
00:14:40,440 --> 00:14:42,810
私のノートに私のノートを更新します。

283
00:14:42,810 --> 00:14:45,140
そして私は私のノートブックを返します。

284
00:14:45,140 --> 00:14:47,320
それが何のようなものです
ポインタは、私たちが行うことができ、

285
00:14:47,320 --> 00:14:51,320
彼らはこのような環境の多く作ります
私たちが実際にどのように動作するかのようなより。

286
00:14:51,320 --> 00:14:54,640
>> すべての権利ので、それは何です
ポインタは、の話をしましょう​​さ

287
00:14:54,640 --> 00:14:58,040
ポインタはC言語で作業し、方法について
どのように我々は彼らと仕事を開始することができます。

288
00:14:58,040 --> 00:15:02,550
だから、非常に単純なポインタがあります
C言語でNULLポインタと呼ばれます。

289
00:15:02,550 --> 00:15:04,830
何もNULLポインタを指します。

290
00:15:04,830 --> 00:15:08,310
それはだようにこれはおそらく、そうです
実際には非常に便利なもの、

291
00:15:08,310 --> 00:15:10,500
私たちが見るよう
少し後に、事実

292
00:15:10,500 --> 00:15:15,410
このNULLポインタが存​​在すること
実際には本当に便利になることができます。

293
00:15:15,410 --> 00:15:19,090
そして、あなたはポインタを作成し、いつでも
あなたは、その値を設定していませんimmediately-

294
00:15:19,090 --> 00:15:21,060
設定例
その値直ちに

295
00:15:21,060 --> 00:15:25,401
バックカップルのスライドになります
私はPKに等しい＆K言ったところ、

296
00:15:25,401 --> 00:15:28,740
PKはとして、Kのアドレスを取得します
我々は、それが何を意味するのかがわかります

297
00:15:28,740 --> 00:15:32,990
我々はそれをコーディングする方法を説明しますshortly-
私たちは何かにその値を設定しない場合

298
00:15:32,990 --> 00:15:35,380
すぐに意味のあります、
あなたは常にべき

299
00:15:35,380 --> 00:15:37,480
nullに指すようにポインタを設定します。

300
00:15:37,480 --> 00:15:40,260
あなたはそれが何を指すように設定する必要があります。

301
00:15:40,260 --> 00:15:43,614
>> それは非常に異なるです
そのまま値だけを残します

302
00:15:43,614 --> 00:15:45,530
そして、その後の宣言
ポインタとだけ仮定

303
00:15:45,530 --> 00:15:48,042
それはまれに真のだから、それはNULLです。

304
00:15:48,042 --> 00:15:50,000
だから、常に設定する必要があります
ポインタの値

305
00:15:50,000 --> 00:15:55,690
あなたは、その値を設定しない場合は、NULLに
すぐに意味のあるものに。

306
00:15:55,690 --> 00:15:59,090
あなたは、ポインタの値かどうかを確認することができます
等価演算子を使用して、nullであります

307
00:15:59,090 --> 00:16:05,450
（==）、ちょうどあなたが任意の整数を比較したいです
（==）を使用して、値または文字値

308
00:16:05,450 --> 00:16:06,320
同様に。

309
00:16:06,320 --> 00:16:10,994
これは、一定の特別な一種です
あなたがテストするために使用できる値。

310
00:16:10,994 --> 00:16:13,160
だから、非常に簡単でした
ポインター、NULLポインタ。

311
00:16:13,160 --> 00:16:15,320
作成する別の方法
ポインタは抽出することです

312
00:16:15,320 --> 00:16:18,240
変数のアドレス
すでに作成しました、

313
00:16:18,240 --> 00:16:22,330
あなたは＆を使用してこれを行います
オペレータのアドレス抽出。

314
00:16:22,330 --> 00:16:26,720
どの我々はすでに以前に見てきました
最初の図の例で私は示しました。

315
00:16:26,720 --> 00:16:31,450
このため、xは、私たちがきた変数の場合
すでに整数型で作成され、

316
00:16:31,450 --> 00:16:35,110
その後、＆xは整数へのポインタです。

317
00:16:35,110 --> 00:16:39,810
＆X IS-覚え、＆抽出しようとしています
右側のもののアドレス。

318
00:16:39,810 --> 00:16:45,350
そして、ポインタのみがアドレスであることから、
より＆xは整数へのポインタであります

319
00:16:45,350 --> 00:16:48,560
その値は、ここでメモリのxの生活の中です。

320
00:16:48,560 --> 00:16:50,460
これは、xのアドレスです。

321
00:16:50,460 --> 00:16:53,296
そう＆xは、xのアドレスです。

322
00:16:53,296 --> 00:16:55,670
のは、この一歩を見てみましょう
さらに何かに接続します

323
00:16:55,670 --> 00:16:58,380
私は前にビデオ内に言及しました。

324
00:16:58,380 --> 00:17:06,730
ARRは、doubleの配列である場合、
＆編曲：角括弧私はポインタであります

325
00:17:06,730 --> 00:17:08,109
二重に。

326
00:17:08,109 --> 00:17:08,970
OK。

327
00:17:08,970 --> 00:17:12,160
私、もし角括弧をARR
ARRは、doubleの配列であります

328
00:17:12,160 --> 00:17:19,069
その後、私は角括弧をARR
その配列のi番目の要素、

329
00:17:19,069 --> 00:17:29,270
そして、＆角括弧をARR私がどこであります
メモリARRのi番目の要素が存在します。

330
00:17:29,270 --> 00:17:31,790
>> だからここに意味は何ですか？

331
00:17:31,790 --> 00:17:34,570
アレイ名、含意
この全体のものの、

332
00:17:34,570 --> 00:17:39,290
配列の名前であるということです
実際に自身のポインタ。

333
00:17:39,290 --> 00:17:41,170
あなたが取り組んできました
すべてに沿ってポインタを持ちます

334
00:17:41,170 --> 00:17:45,290
あなたは配列を使用したすべての時間。

335
00:17:45,290 --> 00:17:49,090
例から覚えておいてください
変数のスコープに、

336
00:17:49,090 --> 00:17:53,420
私が提示したビデオの終わり近く
私たちは機能を持っている例

337
00:17:53,420 --> 00:17:56,890
セットのint型とAと呼ばれます
セット配列と呼ばれる関数。

338
00:17:56,890 --> 00:18:00,490
そして、あなたの挑戦は決定します
かどうか、あるいはどのような

339
00:18:00,490 --> 00:18:03,220
我々はプリントアウトした値
関数の最後に、

340
00:18:03,220 --> 00:18:05,960
メインプログラムの終わりに。

341
00:18:05,960 --> 00:18:08,740
>> あなたはその例からリコールした場合
または、あなたがビデオを見てきた場合には、

342
00:18:08,740 --> 00:18:13,080
あなたはへの呼び出しをyou-がときにことを知っています
セットintは効果的に何もしません。

343
00:18:13,080 --> 00:18:16,390
しかし、アレイを設定するための呼び出しが行われます。

344
00:18:16,390 --> 00:18:19,280
そして、私は一種の理由の上に練り
それは当時のケースでした。

345
00:18:19,280 --> 00:18:22,363
私はちょうどよく、それは、それが配列のだ、と述べました
特別な、あなたが知っている、理由があります。

346
00:18:22,363 --> 00:18:25,020
その理由は、配列のことです
名前は、実際には単なるポインタであります

347
00:18:25,020 --> 00:18:28,740
この特別ながあります
角括弧構文こと

348
00:18:28,740 --> 00:18:30,510
で動作するように物事が大きく進歩してください。

349
00:18:30,510 --> 00:18:34,410
そして、彼らはのアイデアを作ります
多くはあまり威圧ポインタ、

350
00:18:34,410 --> 00:18:36,800
そして彼らは、ソートしている理由です
その方法で提示します。

351
00:18:36,800 --> 00:18:38,600
しかし、実際の配列は単なるポインタです。

352
00:18:38,600 --> 00:18:41,580
そして、それは、理由はときに我々を
配列に変更を加え、

353
00:18:41,580 --> 00:18:44,880
我々は、パラメータとして配列を渡したとき
関数または引数として

354
00:18:44,880 --> 00:18:50,110
配列の機能に、内容
実際に呼び出される側の両方で変更

355
00:18:50,110 --> 00:18:51,160
呼び出し元インチ

356
00:18:51,160 --> 00:18:55,846
の他のすべての種類のどの
私たちが見た変数はそうではありませんでした。

357
00:18:55,846 --> 00:18:58,970
だから、ただで保つために何か
あなたはポインタで作業しているときに気にし、

358
00:18:58,970 --> 00:19:01,610
であることの名前
配列実際にポインタ

359
00:19:01,610 --> 00:19:04,750
その配列の最初の要素に。

360
00:19:04,750 --> 00:19:08,930
>> [OK]をので、今、私たちは、これらすべてを持っています
事実、右、続けるのをみましょう。

361
00:19:08,930 --> 00:19:11,370
なぜ我々は気にしません
ここで何かが住んでいます。

362
00:19:11,370 --> 00:19:14,120
私が言ったようにまあ、それはかなりです
何かがどこに住んで知っておくと便利

363
00:19:14,120 --> 00:19:17,240
あなたはそこに行くと、それを変更することができます。

364
00:19:17,240 --> 00:19:19,390
実際にそれと協力し、
あなたの事を持っています

365
00:19:19,390 --> 00:19:23,710
その変数に有効にやってみたいです、
それのいくつかのコピーでは有効になりません。

366
00:19:23,710 --> 00:19:26,150
これを逆参照と呼ばれています。

367
00:19:26,150 --> 00:19:28,690
我々は、参照に移動し、
我々はそこに値を変更します。

368
00:19:28,690 --> 00:19:32,660
だから我々は、ポインタを持っており、それが呼ばれる場合
PC、それが文字を指し、

369
00:19:32,660 --> 00:19:40,610
その後、我々は* PCと* PCがあると言うことができます
私たちが行く場合は、我々は何を見つけるの名前

370
00:19:40,610 --> 00:19:42,910
アドレスPCへ。

371
00:19:42,910 --> 00:19:47,860
私たちはそこに見つけることが文字であり、
* PCは、私たちがその時にデータを参照する方法です

372
00:19:47,860 --> 00:19:48,880
場所。

373
00:19:48,880 --> 00:19:54,150
だから私たちは次のように言うことができます
* PC = Dまたはそのような何か、

374
00:19:54,150 --> 00:19:59,280
それはどのようなことを意味し
メモリアドレスのPCであっ

375
00:19:59,280 --> 00:20:07,040
どんな文字が以前にありました
私たちは* PC = Dを言う場合があり、現在、Dです。

376
00:20:07,040 --> 00:20:10,090
>> そこでここでは、再び行きます
いくつかの奇妙なCのもの、右。

377
00:20:10,090 --> 00:20:14,560
だから我々はあるとして以前に*を見てきました
何らかの方法で、データ型の部分、

378
00:20:14,560 --> 00:20:17,160
今ではで使用されています
わずかに異なるコンテキスト

379
00:20:17,160 --> 00:20:19,605
場所にあるデータにアクセスします。

380
00:20:19,605 --> 00:20:22,480
私はそれが少し混乱知っていると
それは実際には、この全体の一部です

381
00:20:22,480 --> 00:20:25,740
以下のように、なぜポインタがこの神話を持っています
彼らの周りの非常に複雑であるとして、

382
00:20:25,740 --> 00:20:28,250
正直、文法問題の一種です。

383
00:20:28,250 --> 00:20:31,810
しかし*両方のコンテキストで使用され、
両方の型の名前の一部として、

384
00:20:31,810 --> 00:20:34,100
私たちは少し表示されます
あまりにも他の後に、何か。

385
00:20:34,100 --> 00:20:36,490
そして今であります
間接参照演算子。

386
00:20:36,490 --> 00:20:38,760
だから、リファレンスになり、
そのデータにアクセス

387
00:20:38,760 --> 00:20:43,000
ポインタの位置に、及び
あなたは意志でそれを操作することができます。

388
00:20:43,000 --> 00:20:45,900
>> さて、これはと非常によく似ています
あなたの隣人を訪問し、右。

389
00:20:45,900 --> 00:20:48,710
あなたが知っていれば何あなたを
隣人はあなたがしている、住んでいます

390
00:20:48,710 --> 00:20:50,730
あなたの隣人との付き合いはありません。

391
00:20:50,730 --> 00:20:53,510
あなたが知っているに起こります
彼らが住んでいる場所を知っています、

392
00:20:53,510 --> 00:20:56,870
それはによってそれを意味するものではありません
その知識を持っていることの美徳

393
00:20:56,870 --> 00:20:59,170
あなたがそれらと相互作用しています。

394
00:20:59,170 --> 00:21:01,920
あなたがそれらと対話したい場合は、
あなたは、自分の家に行かなければなりません

395
00:21:01,920 --> 00:21:03,760
あなたは彼らが住んでいる場所に移動する必要があります。

396
00:21:03,760 --> 00:21:07,440
そして、あなたはそれを行うと、
あなたが対話することができます

397
00:21:07,440 --> 00:21:09,420
彼らとあなたがしたいと思いたいです。

398
00:21:09,420 --> 00:21:12,730
そして、同様に変数を使用しました、
あなたはそれらのアドレスに移動する必要があります

399
00:21:12,730 --> 00:21:15,320
あなたがそれらを相互に作用したい場合は、
あなただけのアドレスを知ることはできません。

400
00:21:15,320 --> 00:21:21,495
そして、あなたはアドレスに行く方法です
、間接参照演算子*を使用することができます。

401
00:21:21,495 --> 00:21:23,620
あなたが起こるどう思いますか
我々がしようとする間接参照する場合

402
00:21:23,620 --> 00:21:25,260
値がnullのポインタ？

403
00:21:25,260 --> 00:21:28,470
nullのことを思い出してください
ポインタが何を指しています。

404
00:21:28,470 --> 00:21:34,110
だから、試してみて、間接参照場合
何もアドレス何に行きますか、

405
00:21:34,110 --> 00:21:36,800
あなたは何が起こるかだと思いますか？

406
00:21:36,800 --> 00:21:39,630
さてあなたは、セグメンテーションを推測している場合
フォルト、あなたは正しいだろう。

407
00:21:39,630 --> 00:21:41,390
あなたは試してみて、間接参照した場合
NULLポインタ、

408
00:21:41,390 --> 00:21:43,140
あなたがセグメンテーションを受けます
障害が発生しました。しかし、待って

409
00:21:43,140 --> 00:21:45,820
私は、あなたを教えていませんでした
あなたがつもりはない場合

410
00:21:45,820 --> 00:21:49,220
あなたのあなたの値を設定します
意味のあるものへのポインタ、

411
00:21:49,220 --> 00:21:51,000
あなたがnullに設定する必要がありますか？

412
00:21:51,000 --> 00:21:55,290
私はやったし、実際にセグメンテーション
故障が良い行動の一種です。

413
00:21:55,290 --> 00:21:58,680
>> あなたは、変数を宣言し、持っています
すぐにその値が割り当てられていませんか？

414
00:21:58,680 --> 00:22:02,680
だから、あなただけのint型のxを言います。あなたはそうしない
実際には何に割り当て

415
00:22:02,680 --> 00:22:05,340
し、その後にあなたのコード内で、
xの値を印刷

416
00:22:05,340 --> 00:22:07,650
まだ持ちません
何に割り当てられました。

417
00:22:07,650 --> 00:22:10,370
よくあなたが買ってあげます
ゼロが、時にはあなた

418
00:22:10,370 --> 00:22:15,000
いくつかのランダムな番号を取得する可能性があり、
あなたはそれがどこから来た見当がつかない。

419
00:22:15,000 --> 00:22:16,750
同様のことをすることができます
ポインタを発生します。

420
00:22:16,750 --> 00:22:20,110
あなたはポインタを宣言する場合
int型*例えばPK、

421
00:22:20,110 --> 00:22:23,490
あなたは、値に割り当てません
あなたは、メモリの4バイトを取得します。

422
00:22:23,490 --> 00:22:25,950
どんな4バイト
システムメモリは、することができます

423
00:22:25,950 --> 00:22:28,970
いくつかの意味のある値を持っていることがわかります。

424
00:22:28,970 --> 00:22:31,760
そして、そこであったかもしれません
すでにそこにその何か

425
00:22:31,760 --> 00:22:34,190
もはや別で必要とされていません
機能、あなただけの持っているので、

426
00:22:34,190 --> 00:22:35,900
どんなデータがありました。

427
00:22:35,900 --> 00:22:40,570
>> あなたは何を参照解除を行うにしようとした場合
あなたがそこにいたdon't-いくつかのアドレス

428
00:22:40,570 --> 00:22:43,410
すでにのバイト情報
そこに、それはあなたのポインタになりましたです。

429
00:22:43,410 --> 00:22:47,470
あなたがしようとすると、そのポインタを間接参照する場合は、
あなたはいくつかのメモリをいじりされるかもしれません

430
00:22:47,470 --> 00:22:49,390
あなたが意図していなかったこと
それがすべてを台無しに。

431
00:22:49,390 --> 00:22:51,639
そして、実際にあなたが行うことができます
本当に壊滅的な何か、

432
00:22:51,639 --> 00:22:54,880
以下のような別のプログラムを壊します、
または、他の機能を破ります

433
00:22:54,880 --> 00:22:58,289
またはその悪質な何かを
あなたは全くやるつもりはなかったです。

434
00:22:58,289 --> 00:23:00,080
そしてそうそれはそれはだ理由です
実際に良いアイデア

435
00:23:00,080 --> 00:23:04,030
あなたの場合はnullにあなたのポインタを設定します
意味のあるものにそれらを設定しないでください。

436
00:23:04,030 --> 00:23:06,760
それは、おそらく良いでしょう
あなたのプログラムのために一日の終わり

437
00:23:06,760 --> 00:23:09,840
それが何をするために、次にクラッシュします
何かのネジアップ

438
00:23:09,840 --> 00:23:12,400
別のプログラムまたは別の機能。

439
00:23:12,400 --> 00:23:15,207
その行動にもおそらくあります
ちょうどクラッシュ未満理想的。

440
00:23:15,207 --> 00:23:17,040
そしてそうそれはそれはだ理由です
実際に良い習慣

441
00:23:17,040 --> 00:23:20,920
あなたのポインタを設定するに取得します
あなたがそれらを設定しない場合は、NULLに

442
00:23:20,920 --> 00:23:24,540
意味のある値に
あなたが知ってすぐに、値

443
00:23:24,540 --> 00:23:27,260
あなたは間接参照安全にできること。

444
00:23:27,260 --> 00:23:32,240
>> それでは、すぐに戻って来て、見てみましょう
状況の全体的な構文で。

445
00:23:32,240 --> 00:23:37,400
私はint型* pを言うなら;,私は何をしましたか？

446
00:23:37,400 --> 00:23:38,530
私がやったことはこれです。

447
00:23:38,530 --> 00:23:43,290
私は、pの値がアドレスを知っています
すべてのポインタだけであるため、

448
00:23:43,290 --> 00:23:44,660
アドレス。

449
00:23:44,660 --> 00:23:47,750
私は、pを逆参照することができます
*演算子を使用。

450
00:23:47,750 --> 00:23:51,250
ここでこのような状況において、非常に
トップ*は型の一部である思い出します。

451
00:23:51,250 --> 00:23:53,510
INT *データ型です。

452
00:23:53,510 --> 00:23:56,150
しかし、私は逆参照することができます
*演算子を使用してP、

453
00:23:56,150 --> 00:24:01,897
私はそうならば、私はそのアドレスに行けば、
私はそのアドレスで何を見つけるのだろうか？

454
00:24:01,897 --> 00:24:02,855
私は整数があります。

455
00:24:02,855 --> 00:24:05,910
だからint型* pは基本的に
言って、pはアドレスです。

456
00:24:05,910 --> 00:24:09,500
私がすることができますP間接参照とする場合
私は、私は整数を見つけます

457
00:24:09,500 --> 00:24:11,920
そのメモリ位置に。

458
00:24:11,920 --> 00:24:14,260
>> [OK]をので、私は別のがあったと述べ
星と迷惑なもの

459
00:24:14,260 --> 00:24:17,060
ここでどこにいるのです
星と迷惑な事があります。

460
00:24:17,060 --> 00:24:21,640
あなたは今までに宣言しようとしています
同じタイプの複数の変数

461
00:24:21,640 --> 00:24:24,409
コー​​ドの同じ行の？

462
00:24:24,409 --> 00:24:27,700
だから秒間、その行をふり、
私は実際に緑にそこに持っているコード

463
00:24:27,700 --> 00:24:29,366
存在しない、それだけでint型のx、y、zの言う;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
何のことだろうと、実際に作成することです
あなたのための3つの整数変数、

466
00:24:34,550 --> 00:24:36,930
Xと呼ばれるもの、と呼ばれるもの
yおよびzの一方が呼び出されます。

467
00:24:36,930 --> 00:24:41,510
それはせずにそれを行うための方法です
3行に分割すること。

468
00:24:41,510 --> 00:24:43,890
>> 星が得るのはここです
しかし、再び迷惑な、

469
00:24:43,890 --> 00:24:49,200
*が実際に一部であるため、
両方のタイプの名前と一部の

470
00:24:49,200 --> 00:24:50,320
変数名の。

471
00:24:50,320 --> 00:24:56,430
そして私がint * PX、PY、PZを言うならば、どのような私
実際に取得するには、整数へのポインタです

472
00:24:56,430 --> 00:25:01,650
pxと二つの整数、PYおよびPZと呼ばれます。

473
00:25:01,650 --> 00:25:04,950
そして、それはおそらく何ではありません
我々はしたい、それが良いではありません。

474
00:25:04,950 --> 00:25:09,290
>> だから私は、複数のポインタを作成する場合
同じ行に、同じタイプの、

475
00:25:09,290 --> 00:25:12,140
私は実際に必要なものや星、
行うにはint型* PA、PB *、* PCを言うです。

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
今だけのことを言いました
そして今、あなたにこれを伝えます

478
00:25:20,300 --> 00:25:22,170
あなたはおそらくこれを行うことはありません。

479
00:25:22,170 --> 00:25:25,170
そしてそれは、正直なところ、おそらく良いことです
あなたが誤っている場合があるため、

480
00:25:25,170 --> 00:25:26,544
星、そのようなことを省略します。

481
00:25:26,544 --> 00:25:29,290
それは多分宣言するのが最善です
個々の行のポインタ、

482
00:25:29,290 --> 00:25:31,373
それはちょうど別の一つです
それらの迷惑な構文の

483
00:25:31,373 --> 00:25:35,310
作る星との事
で動作するように非常に困難ポインタ。

484
00:25:35,310 --> 00:25:39,480
それだけでこの構文的だからです
あなたを介して仕事をしなければならない混乱。

485
00:25:39,480 --> 00:25:41,600
練習で、それはありません
本当に第二の天性になります。

486
00:25:41,600 --> 00:25:45,410
私はまだ、まだそれで間違いを犯します
10年のためのプログラミングの後、

487
00:25:45,410 --> 00:25:49,630
何かが起こる場合は怒ってはいけません
あなたに、それは正直かなり一般的です。

488
00:25:49,630 --> 00:25:52,850
それは一種の本当にです
構文の欠陥。

489
00:25:52,850 --> 00:25:54,900
>> [OK]をので、私は一種の約束しました
我々は、再検討することを

490
00:25:54,900 --> 00:25:59,370
どれだけ大きいかの概念は文字列です。

491
00:25:59,370 --> 00:26:02,750
さて、私はそれをあなたに言った場合
文字列、我々は一種の本当にしました

492
00:26:02,750 --> 00:26:04,140
あなたに全体の時間を嘘をついています。

493
00:26:04,140 --> 00:26:06,181
呼ばれるにはデータ型がありません
文字列、および実際に私

494
00:26:06,181 --> 00:26:09,730
私たちのいずれかでこれを言及
データ型の最も初期のビデオ、

495
00:26:09,730 --> 00:26:13,820
その文字列は、そのデータ型でした
CS50.h.であなたのために作成されました

496
00:26:13,820 --> 00:26:17,050
あなたは、＃includeする必要があります
それを使用するためにCS50.h。

497
00:26:17,050 --> 00:26:19,250
>> まあ文字列は本当にあります
何かの別名

498
00:26:19,250 --> 00:26:23,600
、のchar *と呼ばれます
文字へのポインタ。

499
00:26:23,600 --> 00:26:26,010
まあポインタ、リコール、
ちょうど対処しています。

500
00:26:26,010 --> 00:26:28,780
だからサイズは何ですか
文字列のバイト単位の？

501
00:26:28,780 --> 00:26:29,796
まあそれは4つまたは8つです。

502
00:26:29,796 --> 00:26:32,170
そして、その理由は、私が言う四、
8は、実際にはそれからです

503
00:26:32,170 --> 00:26:36,730
あなたが使用している場合、システムに依存します
CS50のIDEは、のchar *は、charのサイズです

504
00:26:36,730 --> 00:26:39,340
*それは、64ビット・システムの、8です。

505
00:26:39,340 --> 00:26:43,850
メモリ内のすべてのアドレスは64ビット長です。

506
00:26:43,850 --> 00:26:48,270
あなたはCS50アプライアンスを使用している場合
または任意の32ビットマシンを使用して、

507
00:26:48,270 --> 00:26:51,640
あなたはその用語の32ビットを聞きました
マシン、32ビットマシンは何ですか？

508
00:26:51,640 --> 00:26:56,090
まあ、それだけですべてのことを意味し
メモリ内のアドレスは32ビット長です。

509
00:26:56,090 --> 00:26:59,140
だから32ビットは4バイトです。

510
00:26:59,140 --> 00:27:02,710
だからのchar *は、4または8であります
お使いのシステムに応じてバイト。

511
00:27:02,710 --> 00:27:06,100
実際に任意のデータタイプ、
そして、任意のデータへのポインタ

512
00:27:06,100 --> 00:27:12,030
すべてのポインタがちょうどであるため、入力
アドレスは、4または8バイトです。

513
00:27:12,030 --> 00:27:14,030
それでは、これを再検討しましょう
それでは、結論図としましょう

514
00:27:14,030 --> 00:27:18,130
ここで少しの運動で、このビデオ。

515
00:27:18,130 --> 00:27:21,600
だからここに私たちがオフに左の図です
ビデオの最初に。

516
00:27:21,600 --> 00:27:23,110
私は* PK = 35と言うのであれば、何が今起こりますか？

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
だから、* PK = 35、私が言うとき何を意味するのでしょうか？

519
00:27:30,530 --> 00:27:32,420
秒を取ります。

520
00:27:32,420 --> 00:27:34,990
* PK。

521
00:27:34,990 --> 00:27:39,890
ここで文脈において、*は
間接参照演算子。

522
00:27:39,890 --> 00:27:42,110
だから、ときに間接参照
オペレータは、使用されています

523
00:27:42,110 --> 00:27:48,520
指さ我々はアドレスに移動
PKにより、我々は我々が何を見つける変更します。

524
00:27:48,520 --> 00:27:55,270
だから* PK = 35効果
画像にこれを行います。

525
00:27:55,270 --> 00:27:58,110
だから、基本的には構文的です
= 35と述べたkののと同じ。

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> もう一つ。

528
00:28:01,930 --> 00:28:05,510
私はint型のメートルを言うなら、私が作成します
メートルと呼ばれる新しい変数。

529
00:28:05,510 --> 00:28:08,260
新しいボックスが、それは緑色のボックスのためです
それは整数を保持するために起こっています、

530
00:28:08,260 --> 00:28:09,840
それはMのラベルが付いています。

531
00:28:09,840 --> 00:28:14,960
私は、M = 4と言うなら、私は置きます
そのボックスに整数。

532
00:28:14,960 --> 00:28:20,290
言えば、PK =＆M、どのように
この図の変更？

533
00:28:20,290 --> 00:28:28,760
PK =＆M、あなたは何を思い出すん
＆演算子はないかと呼ばれていますか？

534
00:28:28,760 --> 00:28:34,430
その＆いくつかの変数名を覚えておいてください
変数名のアドレスです。

535
00:28:34,430 --> 00:28:38,740
それでは、私たちが言っていることです
PKは、Mのアドレスを取得します。

536
00:28:38,740 --> 00:28:42,010
だから効果的に何が起こりますか
図は、それはもはや点をPKで

537
00:28:42,010 --> 00:28:46,420
K、しかしメートルを指します。

538
00:28:46,420 --> 00:28:48,470
>> 再びポインタが非常にあります
で作業するのが難しいです

539
00:28:48,470 --> 00:28:50,620
彼らは多くのを取ります
実際、しかし理由

540
00:28:50,620 --> 00:28:54,150
あなたを可能にする能力の
機能間でデータを渡すために

541
00:28:54,150 --> 00:28:56,945
実際にそれらを持っています
変更が有効になり、

542
00:28:56,945 --> 00:28:58,820
周りにあなたの頭を取得
本当に重要です。

543
00:28:58,820 --> 00:29:02,590
これはおそらく、最も複雑です
我々はCS50で議論する話題、

544
00:29:02,590 --> 00:29:05,910
ただし値が
ポインタを使用してから取得します

545
00:29:05,910 --> 00:29:09,200
遠く合併症を上回ります
それは彼らの学習から来ます。

546
00:29:09,200 --> 00:29:12,690
だから私はあなたのベストを望みます
運がポインタについて学びます。

547
00:29:12,690 --> 00:29:15,760
私はダグロイドだけど、これはCS50です。

548
00:29:15,760 --> 00:29:17,447