1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] 配列について説明しましょう​​。

2
00:00:09,360 --> 00:00:12,780
では、なぜ我々はこれまでに配列を使用したいのでしょうか？

3
00:00:12,780 --> 00:00:17,210
さてさて、あなたは5の学生IDを格納するために必要なプログラムを持っていると言う。

4
00:00:17,210 --> 00:00:21,270
それは、5つの個別の変数を持っている合理的なように思えるかもしれません。

5
00:00:21,270 --> 00:00:24,240
我々は少しでわかるの理由から、我々は0から数え始めます。

6
00:00:24,240 --> 00:00:30,700
我々はあるでしょう変数のデータ型はint ID0、ID1 int型などになります。

7
00:00:30,700 --> 00:00:34,870
我々は、学生IDに実行したい任意のロジックは、コピーと貼り付けする必要があります

8
00:00:34,870 --> 00:00:36,870
これらの学生IDのそれぞれについて。

9
00:00:36,870 --> 00:00:39,710
私たちは、学生はCS50にたまたまあるかをチェックしたい場合

10
00:00:39,710 --> 00:00:43,910
我々は最初のID0がコースの学生を表しているかどうかをチェックする必要があります。

11
00:00:43,910 --> 00:00:48,070
その後、次の生徒のために同じことをすること、我々は、ID0のコードをコピーして貼り付ける必要があります

12
00:00:48,070 --> 00:00:54,430
とID2、3、および4のようにID1のID0のすべてのオカレンスを置換します。

13
00:00:54,430 --> 00:00:57,560
>> できるだけ早くあなたが我々がコピーして貼り付ける必要があることを聞くと、

14
00:00:57,560 --> 00:01:00,440
あなたはより良い解決策があることを考え始めるべきである。

15
00:01:00,440 --> 00:01:05,360
今度は何あなたが5学生証ではなく7を必要としません実現したら？

16
00:01:05,360 --> 00:01:09,570
あなたは、あなたのソースコードに戻って、ID5に追加するID6が必要

17
00:01:09,570 --> 00:01:14,260
IDはこれらの2つの新しいIDのクラスに属している場合にチェックするためのロジックをコピーして貼り付ける。

18
00:01:14,260 --> 00:01:19,600
一緒にすべてのこれらのIDを接続するものは何もありませんし、そう問う方法はありません

19
00:01:19,600 --> 00:01:22,040
6を介してIDが0のためにこれを行うためのプログラム。

20
00:01:22,040 --> 00:01:26,120
さて、あなたは100学生証を持って実現する。

21
00:01:26,120 --> 00:01:30,770
それは、別々にこれらのIDのそれぞれを宣言する必要があると理想よりも少ないように見えるし始めている

22
00:01:30,770 --> 00:01:33,760
そして、それらの新しいIDの任意のロジックをコピーして貼り付ける。

23
00:01:33,760 --> 00:01:38,380
しかし、多分私たちが決定され、我々はすべての100人の学生のためにそれを行うている。

24
00:01:38,380 --> 00:01:42,240
しかし、あなたが実際に存在するどのように多くの学生が知らない場合はどうなるでしょうか？

25
00:01:42,240 --> 00:01:47,320
そこにいくつかのN学生はわずかであり、あなたのプログラムはnであることをユーザーに問い合わせる必要があります。

26
00:01:47,320 --> 00:01:50,250
ああええと。これは非常にうまく機能するつもりはない。

27
00:01:50,250 --> 00:01:53,820
あなたのプログラムは、学生だけのある一定数のために動作します。

28
00:01:53,820 --> 00:01:57,520
>> これらの問題のすべてを解決することは、配列の美しさです。

29
00:01:57,520 --> 00:01:59,930
だから配列は何ですか？

30
00:01:59,930 --> 00:02:04,480
いくつかのプログラミング言語では配列型は、もう少しやることができるかもしれない

31
00:02:04,480 --> 00:02:09,960
しかしここで私たちは、あなたがCでそれが表示されます同じような基本的な配列データ構造に焦点を当てていきます

32
00:02:09,960 --> 00:02:14,030
配列はメモリの大きいだけのブロックです。それはそれだ。

33
00:02:14,030 --> 00:02:17,770
我々は10個の整数の配列を持っていると言うとき、それはちょうど私たちはいくつかのブロックを持っていることを意味

34
00:02:17,770 --> 00:02:20,740
10独立した整数値を保持するのに十分な大きさのメモリのその。

35
00:02:29,930 --> 00:02:33,410
整数は4バイトであると仮定すると、これはつまり、10個の整数の配列

36
00:02:33,410 --> 00:02:37,180
メモリ内の40バイトの連続した​​ブロックです。

37
00:02:42,660 --> 00:02:46,280
あなたは私たちがここに行くことはありません多次元配列を使用する場合でも、

38
00:02:46,280 --> 00:02:49,200
それだけで、まだメモリの大きなブロックだ。

39
00:02:49,200 --> 00:02:51,840
多次元表記は単に利便性です。

40
00:02:51,840 --> 00:02:55,640
あなたは整数の3多次元配列によって3を持っている場合は、

41
00:02:55,640 --> 00:03:00,650
その後、あなたのプログラムは本当にわずか36バイトの大きなブロックとして扱います。

42
00:03:00,650 --> 00:03:05,460
整数の総数は3回3であり、それぞれの整数は4バイトを占有します。

43
00:03:05,460 --> 00:03:07,750
>> のが基本的な例を見てみましょう。

44
00:03:07,750 --> 00:03:10,660
我々はここで宣言する配列の2つの異なる方法を見ることができます。

45
00:03:15,660 --> 00:03:18,580
我々は、コンパイルするプログラムのためにそれらの1をコメントアウトする必要があります

46
00:03:18,580 --> 00:03:20,900
私たちは二回xを宣言して以来。

47
00:03:20,900 --> 00:03:25,140
我々は少しの宣言のこれらの2つのタイプの違いのいくつかを見てみましょう。

48
00:03:25,140 --> 00:03:28,560
これらの行の両方は、サイズnの配列を宣言し、

49
00:03:28,560 --> 00:03:30,740
ここで我々は＃10としてNを定義しています。

50
00:03:30,740 --> 00:03:34,460
我々は同じように簡単に正の整数をユーザーに尋ねたかもしれない

51
00:03:34,460 --> 00:03:37,250
我々の配列の要素数と、その整数を使用していました。

52
00:03:37,250 --> 00:03:41,960
前に私達の学生証の例のように、これは完全に独立した10を宣言するような種類のものである

53
00:03:41,960 --> 00:03:49,000
虚数変数; XN-1までにX0、X1、X2、など。

54
00:03:57,270 --> 00:04:00,840
我々は配列を宣言する行を無視して、角括弧はそのまま気付く

55
00:04:00,840 --> 00:04:02,090
forループの内側。

56
00:04:02,090 --> 00:04:09,660
我々は、私はちょうどXブラケット3のように読んであげるX [3]のようにして、記述するときは、

57
00:04:09,660 --> 00:04:13,090
あなたは虚X3を求めたいと考えることができます。

58
00:04:13,090 --> 00:04:17,519
そのカッコの中に数字、サイズN、この手段の配列よりも注意してください

59
00:04:17,519 --> 00:04:22,630
我々はインデックスと呼びます、、0からN-1まで何もすることができます

60
00:04:22,630 --> 00:04:25,660
これは、N個の指標の合計です。

61
00:04:25,660 --> 00:04:28,260
>> これが実際にどのように動作するかを考えること

62
00:04:28,260 --> 00:04:31,260
配列はメモリの大きなブロックであることを忘れないでください。

63
00:04:31,260 --> 00:04:37,460
整数は4バイトであると仮定すると、全体の配列xはメモリの40バイトのブロックです。

64
00:04:37,460 --> 00:04:41,360
だから、x0は、ブロックの非常に最初の4バイトを指します。

65
00:04:45,810 --> 00:04:49,230
X [1]次の4バイトなどを指します。

66
00:04:49,230 --> 00:04:53,760
これは、xの開始が今までが追跡するために必要なすべてのプログラムであることを意味します。

67
00:04:55,660 --> 00:04:59,840
は、x [400]を使用する場合は、プログラムは、これが同等であることを知っている

68
00:04:59,840 --> 00:05:03,460
xの開始後わずか1600バイトまで。

69
00:05:03,460 --> 00:05:08,780
我々から1600バイトを取得where didの縮約形？これは、整数あたりわずか400回4バイトです。

70
00:05:08,780 --> 00:05:13,170
>> 上に移動する前に、それが実現することは非常に重要だとCで

71
00:05:13,170 --> 00:05:17,080
我々は配列で使用するインデックスのない執行はありません。

72
00:05:17,080 --> 00:05:23,180
私たちの大きなブロックは、10個の整数長いですが、我々はx [20]と書いた場合、何も私たちを怒鳴りつけるません

73
00:05:23,180 --> 00:05:26,060
あるいはX [-5]。

74
00:05:26,060 --> 00:05:28,240
インデックスが偶数である必要はありません。

75
00:05:28,240 --> 00:05:30,630
それは、任意の式を指定できます。

76
00:05:30,630 --> 00:05:34,800
プログラムでは、配列のインデックスにforループからの変数iを使用しています。

77
00:05:34,800 --> 00:05:40,340
これは、i = 0のから配列の長さにループして、非常に一般的なパターンです

78
00:05:40,340 --> 00:05:43,350
その後配列のインデックスとしてiを使用して。

79
00:05:43,350 --> 00:05:46,160
アレイ全体にわたってあなたが効果的にループこのように、

80
00:05:46,160 --> 00:05:50,600
そしてあなたは、配列内の各スポットに割り当てるか、またはいくつかの計算のためにそれを使用することができます。

81
00:05:50,600 --> 00:05:53,920
>> 最初のforループでは、iは、0から始まります

82
00:05:53,920 --> 00:05:58,680
ので、それは配列の0点は、値を0回2に割り当てられます。

83
00:05:58,680 --> 00:06:04,370
次にiをインクリメントしており、値が1回2配列の最初のスポットを割り当てます。

84
00:06:04,370 --> 00:06:10,170
その後、我々は、配列内のN-1個の位置まで上に再びので、私は増分割り当てられるまで

85
00:06:10,170 --> 00:06:13,370
値N-1回2。

86
00:06:13,370 --> 00:06:17,810
だから我々は、最初の10個の偶数を使用して配列を作成しました。

87
00:06:17,810 --> 00:06:21,970
多分、xよりも変数のビットより良い名前だっただろう追いついた

88
00:06:21,970 --> 00:06:24,760
それは離れて物事を与えているだろう。

89
00:06:24,760 --> 00:06:30,210
2番目のforループは、ちょうど我々がすでに配列の内部に格納した値を出力します。

90
00:06:30,210 --> 00:06:33,600
>> 配列宣言の両方のタイプを使用してプログラムを実行してみましょう

91
00:06:33,600 --> 00:06:36,330
そしてプログラムの出力を見てみましょう。

92
00:06:51,450 --> 00:06:57,020
限り我々が見ることができるように、プログラムは、宣言の両方のタイプの同じように動作します。

93
00:06:57,020 --> 00:07:02,230
我々は、Nで停止しないように、最初のループを変更した場合にも、何が起こるかを見てみましょう

94
00:07:02,230 --> 00:07:05,040
むしろ万を言う。

95
00:07:05,040 --> 00:07:07,430
配列の終端を越えて道。

96
00:07:14,700 --> 00:07:17,210
おっと。たぶん、あなたは前にこれを見てきました。

97
00:07:17,210 --> 00:07:20,440
セグメンテーションフォールトは、プログラムがクラッシュしたことを意味します。

98
00:07:20,440 --> 00:07:24,430
あなたが触れるべきではないメモリの領域に触れるときは、これらを見始める。

99
00:07:24,430 --> 00:07:27,870
ここでは、xの最初を超え万箇所に触れている

100
00:07:27,870 --> 00:07:31,920
これは明らかに我々が触れてはいけません、メモリ内の場所です。

101
00:07:31,920 --> 00:07:37,690
だから、私たちのほとんどは、おそらく誤って、Nの代わりに10,000を我慢できないだろう

102
00:07:37,690 --> 00:07:42,930
我々が言うように、より微妙な何かをしたら、何よりも小さいまたはNに等しい書き込み

103
00:07:42,930 --> 00:07:46,830
N未満とは対照的にするためのループ条件で

104
00:07:46,830 --> 00:07:50,100
配列だけ0からN-1までのインデックスを持っていることを忘れないでください、

105
00:07:50,100 --> 00:07:54,510
これは、インデックスNが配列の終わりを超えていることを意味します。

106
00:07:54,510 --> 00:07:58,050
プログラムは、このケースではクラッシュしないかもしれませんが、それはまだエラーだ。

107
00:07:58,050 --> 00:08:01,950
実際には、このエラーは、それはそれ自身の名前を持っていることが非常に一般的な

108
00:08:01,950 --> 00:08:03,970
1エラーでオフ。

109
00:08:03,970 --> 00:08:05,970
>> それは基本的なことはそれだ。

110
00:08:05,970 --> 00:08:09,960
だから、配列宣言の2つのタイプの主な違いは何ですか？

111
00:08:09,960 --> 00:08:13,960
メモリの大きなブロックがどこに行く一つの差である。

112
00:08:13,960 --> 00:08:17,660
私はブラケット配列型と呼ぶことにします最初の宣言、内

113
00:08:17,660 --> 00:08:20,300
これは、従来の名前をしたものではまったくないにもかかわらず、

114
00:08:20,300 --> 00:08:22,480
それはスタックに積まれます。

115
00:08:22,480 --> 00:08:27,450
私はポインタ配列型と呼ぶことにします第二に、一方で、それは、ヒープ上に行きます。

116
00:08:27,450 --> 00:08:32,480
これは、関数から戻るとき、ブラケットの配列が自動的に解放されることを意味します

117
00:08:32,480 --> 00:08:36,419
あなたはexplicitilyポインタ配列の空き呼び出す必要がありますように、一方

118
00:08:36,419 --> 00:08:38,010
さもないとすると、メモリリークが発生している。

119
00:08:38,010 --> 00:08:42,750
また、ブラケットの配列は、実際に変数ではありません。

120
00:08:42,750 --> 00:08:45,490
これは重要です。それはただのシンボルだ。

121
00:08:45,490 --> 00:08:49,160
あなたは、コンパイラはあなたが選択する定数と考えることができます。

122
00:08:49,160 --> 00:08:52,970
これは、我々はx + +はブラケットタイプを持つような何かを行うことができないことを意味

123
00:08:52,970 --> 00:08:56,240
これは、ポインタ型と完全に有効ですが。

124
00:08:56,240 --> 00:08:58,270
>> ポインタ型は可変です。

125
00:08:58,270 --> 00:09:01,510
ポインタ型のために、我々はメモリの2つの独立したブロックがあります。

126
00:09:01,510 --> 00:09:06,060
変数x自身は、スタックに格納されており、ちょうど単一のポインタである

127
00:09:06,060 --> 00:09:08,620
しかし、メモリの大きなブロックは、ヒープに格納されています。

128
00:09:08,620 --> 00:09:11,010
スタック上の変数xは単にアドレスを格納

129
00:09:11,010 --> 00:09:14,010
ヒープ上のメモリブロックの大きい。

130
00:09:14,010 --> 00:09:17,370
これの一つの含意は、演算子のサイズである。

131
00:09:17,370 --> 00:09:22,480
あなたがブラケット配列のサイズを求めるなら、それはあなたのメモリの大きなブロックの大きさを与えるが、

132
00:09:22,480 --> 00:09:24,620
40バイトのようなもの、

133
00:09:24,620 --> 00:09:26,920
しかし、配列のポインタ型のサイズを求めるなら、

134
00:09:26,920 --> 00:09:32,740
それはあなたのアプライアンスでは、4バイトだけ可能性がある変数x自体の大きさを与える。

135
00:09:32,740 --> 00:09:36,530
ポインタ配列型を使用して、それを直接求めることは不可能である

136
00:09:36,530 --> 00:09:38,530
メモリの大きなブロックのサイズ。

137
00:09:38,530 --> 00:09:42,530
我々は非常にまれにサイズがほしいと思っていませんので、これは通常、制限のあまりないです

138
00:09:42,530 --> 00:09:46,980
の大きなメモリのブロック、そして我々がそれを必要とする場合、我々は通常、それを計算することができます。

139
00:09:46,980 --> 00:09:51,490
>> 最後に、ブラケットの配列は、配列を初期化するためのショートカットを提供してくれることを起こる。

140
00:09:51,490 --> 00:09:56,130
我々は、ショートカットinitilizationを使用して、最初の10個の偶数の整数を書くことができるか見てみましょう。

141
00:10:11,220 --> 00:10:14,470
ポインタ配列を使用すると、このようなショートカットを実行する方法はありません。

142
00:10:14,470 --> 00:10:18,120
これは、ちょうどあなたが、配列を使って何ができるかを紹介します。

143
00:10:18,120 --> 00:10:20,990
彼らは、あなたが、ほとんどすべてのプログラムに表示される。

144
00:10:20,990 --> 00:10:24,390
うまくいけば、あなたは現在、学生IDの例を行う良い方法を見ることができます

145
00:10:24,390 --> 00:10:26,710
動画の先頭から。

146
00:10:26,710 --> 00:10:29,960
>> 私の名前はロブ·ボーデンであり、これはCS50です。