1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] 構造体について話してみましょう。

2
00:00:09,180 --> 00:00:12,130
構造体は一緒に変数の束をグループ化する方法を提供してくれる

3
00:00:12,130 --> 00:00:14,350
素敵なパッケージに。

4
00:00:14,350 --> 00:00:17,020
それは、すぐに例を参照することが一番簡単です。

5
00:00:17,020 --> 00:00:20,030
ので、我々は、構造体と言う

6
00:00:20,030 --> 00:00:23,340
その後、中括弧を開く

7
00:00:23,340 --> 00:00:26,630
そしてこの構造では、我々は、int型の年齢があるでしょう

8
00:00:28,920 --> 00:00:31,350
char *の名前、

9
00:00:31,350 --> 00:00:34,670
それはそれだ。

10
00:00:37,350 --> 00:00:40,650
それは、中括弧の後にセミコロンと奇妙に思えるかもしれません

11
00:00:40,650 --> 00:00:43,620
それは構造体と、実際に必要なのです。

12
00:00:43,620 --> 00:00:46,270
任意の有効なタイプは、構造体の定義内に行くことができます。

13
00:00:46,270 --> 00:00:49,530
ここでは、int型とchar *を使用してきました

14
00:00:49,530 --> 00:00:52,610
しかし、あなたはまた、言うと、100個の要素を配列を使用することができます

15
00:00:52,610 --> 00:00:54,910
あるいは別の構造体。

16
00:00:54,910 --> 00:00:56,960
あなたはC言語で構造体を使用している場合、

17
00:00:56,960 --> 00:00:58,430
あなたは、新しい型を作成している

18
00:00:58,430 --> 00:01:00,860
他の種類のコレクションのうち。

19
00:01:00,860 --> 00:01:02,620
ここでは、新しい型を作っている

20
00:01:02,620 --> 00:01:05,060
整数とchar *のうち。

21
00:01:05,060 --> 00:01:07,400
後で見るように、struct型

22
00:01:07,400 --> 00:01:10,700
これまで使ってきた他のタイプに相当する多くの方法である。

23
00:01:10,700 --> 00:01:13,310
通常、私はどのようにstruct型を比較す​​ることでしょう

24
00:01:13,310 --> 00:01:15,790
整数型に似ています。

25
00:01:15,790 --> 00:01:18,520
私たちが書いたコードは、有効なCですが、

26
00:01:18,520 --> 00:01:20,320
それは、非常に有用なものではありません

27
00:01:20,320 --> 00:01:22,340
とガチャンという音は私たちに警告を与える。

28
00:01:22,340 --> 00:01:24,970
構造体とそのが類似している方法を覚えていますか？

29
00:01:24,970 --> 00:01:26,710
さて、私たちは基本的には今言った

30
00:01:27,840 --> 00:01:30,060
int型、

31
00:01:30,060 --> 00:01:33,140
これは非常に有用ラインではありません。

32
00:01:33,140 --> 00:01:35,760
だから、実際にその型の変数を宣言してみましょう

33
00:01:35,760 --> 00:01:38,760
セミコロンの前に名称を与えることによって。

34
00:01:42,170 --> 00:01:45,000
我々は変数学生を呼ぶことにします。

35
00:01:48,190 --> 00:01:51,350
今、私たちは、学生と呼ばれる変数を宣言した

36
00:01:51,350 --> 00:01:53,980
構造体で指定された型を持つ。

37
00:01:53,980 --> 00:01:56,730
どのように我々は、構造体の内部変数に取得するのですか？

38
00:01:56,730 --> 00:01:59,040
これらの変数のための技術的には、名

39
00:01:59,040 --> 00:02:01,070
メンバーです。

40
00:02:01,070 --> 00:02:04,000
学生のstruct内の任意の特定のメンバーにアクセスするには、

41
00:02:04,000 --> 00:02:06,440
あなたは、変数名にドットを追加

42
00:02:06,440 --> 00:02:08,860
したいメンバーの名前が続きます。

43
00:02:08,860 --> 00:02:11,690
そこでここでは、2つしか有効な可能性

44
00:02:11,690 --> 00:02:17,760
student.ageアール

45
00:02:17,760 --> 00:02:24,460
とstudent.name。

46
00:02:24,460 --> 00:02:26,820
そして、我々は何かのように行うことができます

47
00:02:26,820 --> 00:02:30,320
student.age = 12

48
00:02:30,320 --> 00:02:39,310
とstudent.name =学生。

49
00:02:39,310 --> 00:02:42,580
今、私たちは第二学生を作りたい場合はどうなりますか？

50
00:02:42,580 --> 00:02:44,760
あなたは、これらの行をコピーして貼り付けると思うかもしれない

51
00:02:44,760 --> 00:02:48,110
と、学生2か何かに学生を変更

52
00:02:48,110 --> 00:02:50,090
それは動作しますが、

53
00:02:50,090 --> 00:02:52,670
しかし技術的には、学生と学生2

54
00:02:52,670 --> 00:02:54,540
同じ型を持っていない。

55
00:02:54,540 --> 00:02:56,940
を参照してください、あなたはお互いにそれらを割り当てることはできません。

56
00:02:56,940 --> 00:02:58,560
これは、これまでのところ、ためである

57
00:02:58,560 --> 00:03:00,950
あなたのstructは匿名となっています。

58
00:03:00,950 --> 00:03:02,290
我々はそれに名前を付ける必要があります。

59
00:03:02,290 --> 00:03:04,420
そのためには、構造体の名前を挿入します

60
00:03:04,420 --> 00:03:06,950
単語のstructの後。

61
00:03:09,440 --> 00:03:11,170
学生、

62
00:03:11,170 --> 00:03:14,680
定義が続きます。

63
00:03:16,500 --> 00:03:18,940
我々はまだ、すぐに型の変数を宣言することができます

64
00:03:18,940 --> 00:03:21,570
我々は前にやったような構造体学生、。

65
00:03:24,320 --> 00:03:28,360
我々は、それがS1と呼ぶことにします

66
00:03:28,590 --> 00:03:30,760
構造体に名前を与えることによって、

67
00:03:30,760 --> 00:03:33,050
我々は今、構造体の学生を使用することができます

68
00:03:33,050 --> 00:03:36,950
ほとんど同じ方法で、我々はintを使うだろう。

69
00:03:36,950 --> 00:03:39,580
だから我々は、struct型の学生の変数を宣言することができます

70
00:03:39,580 --> 00:03:42,360
のような

71
00:03:42,360 --> 00:03:49,500
S2の構造学生。

72
00:03:51,020 --> 00:03:55,130
配列のように、構造体は、ショートカットの初期化構文を提供します

73
00:03:55,130 --> 00:03:58,670
ので、我々は学生がS2構造体、と言うことができます

74
00:03:58,670 --> 00:04:01,420
等しい

75
00:04:01,420 --> 00:04:06,040
左中括弧3、S2。

76
00:04:09,210 --> 00:04:12,600
ここでは、S2.ageは、3になります

77
00:04:12,600 --> 00:04:15,910
とS2.nameはS2を指すようになります。

78
00:04:15,910 --> 00:04:19,149
int型であなたがすることができるすべてのものについて考える

79
00:04:19,149 --> 00:04:22,460
それらのほとんどはあなたは、struct学生型で行うことができます。

80
00:04:22,460 --> 00:04:26,060
我々は関数パラメータの型として構造体の学生を使用することができます。

81
00:04:26,060 --> 00:04:28,790
私たちは、新しい構造体の内部構造体の学生を使用することができます。

82
00:04:28,790 --> 00:04:31,010
我々は、struct学生へのポインタを持つことができます。

83
00:04:31,010 --> 00:04:33,540
我々は、構造体の学生のサイズを行うことができます。

84
00:04:33,540 --> 00:04:35,510
構造体学生がタイプです

85
00:04:35,510 --> 00:04:38,030
ちょうどint型のようなタイプです。

86
00:04:38,030 --> 00:04:40,540
我々はまた、S1とS2を割り当てることができます。

87
00:04:40,540 --> 00:04:43,760
両方が同じタイプであるので、我々は行うことができますので、

88
00:04:44,390 --> 00:04:47,540
S1 = S2。

89
00:04:47,540 --> 00:04:50,430
我々が行う場合はどうなりますか

90
00:04:50,430 --> 00:04:55,300
S1.age = 10？

91
00:04:56,340 --> 00:04:58,880
すべてでS2変わりますか？

92
00:04:58,880 --> 00:05:02,800
繰り返しになりますが、ごく普通の整数のように、構造体だと思います。

93
00:05:02,800 --> 00:05:05,590
我々はいくつかのint型Yにいくつかのint型のXを割り当てた場合、

94
00:05:05,590 --> 00:05:08,970
X = Yのような

95
00:05:08,970 --> 00:05:10,850
その後、Xを変更する

96
00:05:10,850 --> 00:05:14,230
同様にX + +

97
00:05:14,230 --> 00:05:17,020
Yは全く変わるのでしょうか？

98
00:05:17,020 --> 00:05:20,980
Yは、ここで変更なども上記のS2は行いません。

99
00:05:20,980 --> 00:05:24,120
S2.ageはまだ3です。

100
00:05:24,120 --> 00:05:27,350
しかし、別の構造体を割り当てるときにあることに注意

101
00:05:27,350 --> 00:05:30,300
ポインタのすべてはまだ、同じことを指している

102
00:05:30,300 --> 00:05:32,260
以来、彼らは単にコピーされました。

103
00:05:32,260 --> 00:05:34,300
あなたは、ポインタを共有したくない場合は、

104
00:05:34,300 --> 00:05:36,100
あなたは、手動でそれを処理する必要があります

105
00:05:36,100 --> 00:05:39,780
多分指すようにポインタのいずれかのメモリの1つのブロックをmalickingによって

106
00:05:39,780 --> 00:05:42,120
とデータを上書きコピー。

107
00:05:42,120 --> 00:05:45,540
それはどこのstruct学生を書かなければならないのが面倒な場合があります。

108
00:05:45,540 --> 00:05:48,730
タイプのデフを使用して、我々が行うことができます

109
00:05:51,630 --> 00:05:55,850
型デフ

110
00:05:55,850 --> 00:05:58,830
構造体

111
00:05:58,830 --> 00:06:01,270
そして我々はそれ学生と呼ぶことにします。

112
00:06:05,620 --> 00:06:08,360
今、我々はどこにでも生徒を使用することができます

113
00:06:08,360 --> 00:06:11,090
我々は、struct生徒を使用するために使用すること。

114
00:06:11,090 --> 00:06:13,410
このタイプのデフは、匿名構造体の

115
00:06:13,410 --> 00:06:15,750
そして、それは生徒を呼び出します。

116
00:06:15,750 --> 00:06:18,220
しかし、我々はまた、学生の識別子を保持する場合

117
00:06:18,220 --> 00:06:22,380
単語の構造体の隣には、typedef structの学生のように、

118
00:06:27,670 --> 00:06:31,590
私たちは、同じ意味で今のstruct学生と学生の両方を使用することができます。

119
00:06:31,590 --> 00:06:34,060
彼らも、同じ名前を持っている必要はありません。

120
00:06:34,060 --> 00:06:36,710
我々はボブにdef構造体の学生を入力することができます

121
00:06:36,710 --> 00:06:38,950
その後、学生とボブを構造体

122
00:06:38,950 --> 00:06:41,270
交換タイプであろう。

123
00:06:41,270 --> 00:06:44,050
タイプに関係なくDEFの、

124
00:06:44,050 --> 00:06:46,750
我々は、構造体への次の識別子が必要

125
00:06:46,750 --> 00:06:48,250
もし構造体の定義

126
00:06:48,250 --> 00:06:50,450
再帰的です。

127
00:06:50,450 --> 00:06:52,620
たとえば、

128
00:06:52,620 --> 00:06:56,140
DEF型のstructノード

129
00:06:56,140 --> 00:07:01,200
そしてそれは、int valのように定義されます

130
00:07:01,200 --> 00:07:05,420
そして、それは、別の構造体のノードを指すポインタを持つことになります。、

131
00:07:05,420 --> 00:07:09,490
*次の構造体のノードのように。

132
00:07:09,490 --> 00:07:13,670
そして、我々はそれをノードと呼ぶことにします。

133
00:07:15,490 --> 00:07:18,020
この構造体は、再帰的である

134
00:07:18,020 --> 00:07:21,450
構造ノードの定義は、その中に含まれているため、

135
00:07:21,450 --> 00:07:24,200
構造ノードへのポインタ。

136
00:07:24,200 --> 00:07:27,740
我々にはstructノード*次言わなければならないことに注意してください

137
00:07:27,740 --> 00:07:30,690
構造ノードの定義の内側に、

138
00:07:30,690 --> 00:07:33,620
タイプのデフは、私たちは、これを簡略化できるようにするために、まだ完成していないので、

139
00:07:33,620 --> 00:07:36,210
単にノード*の隣にあります。

140
00:07:36,210 --> 00:07:39,260
これに類似した構造体についての詳細を学びます

141
00:07:39,260 --> 00:07:41,750
ときに、リンクリストや木を扱う。

142
00:07:41,750 --> 00:07:44,130
関数内の構造体についてはどうですか？

143
00:07:44,130 --> 00:07:46,800
また、これは完全に有効です。

144
00:07:46,800 --> 00:07:49,430
我々は持っている可能性が

145
00:07:49,430 --> 00:07:53,630
funcを無効

146
00:07:53,630 --> 00:07:55,930
これは、引数として取り

147
00:07:55,930 --> 00:07:59,590
学生の

148
00:07:59,590 --> 00:08:02,790
その生徒で何かを行います。

149
00:08:05,270 --> 00:08:08,450
そして、我々のように、学生の構造体として渡すことができます。

150
00:08:08,450 --> 00:08:12,850
前からS1のFUNC。

151
00:08:12,850 --> 00:08:15,230
structは振る舞う

152
00:08:15,230 --> 00:08:18,460
整数は、関数に渡されただろうというときとまったく同じ。

153
00:08:18,460 --> 00:08:21,510
機能は、S1のコピーを受信

154
00:08:21,510 --> 00:08:23,690
ので、S1変更することはできません。

155
00:08:23,690 --> 00:08:27,110
Sに保存されているそれのではなく、唯一のコピー

156
00:08:27,110 --> 00:08:30,010
あなたは、関数がS1を変更できるようにする場合、

157
00:08:30,010 --> 00:08:33,000
機能は、学生* Sを取る必要があります

158
00:08:33,000 --> 00:08:36,570
そしてあなたは、次のように、アドレスによってS1を通過しなければならないでしょう。

159
00:08:37,549 --> 00:08:41,100
学生* Sは、func＆S1。

160
00:08:41,100 --> 00:08:44,760
ここにアドレス渡しする別の理由があります。

161
00:08:44,760 --> 00:08:48,030
私たちのstructは100フィールドが含まれていた場合はどうなりますか？

162
00:08:48,030 --> 00:08:51,250
我々はfuncに生徒を渡す毎回、

163
00:08:51,250 --> 00:08:55,770
私たちのプログラムは、関数の引数Sに100人のすべてのフィールドをコピーする必要があります

164
00:08:55,770 --> 00:08:59,320
それは、それらの大部分を使用しない場合でも。

165
00:08:59,320 --> 00:09:02,700
機能は、学生を変更することを計画していないので、たとえ

166
00:09:02,700 --> 00:09:05,170
まだアドレス渡しは貴重であることができれば。

167
00:09:05,170 --> 00:09:08,990
さて、我々は構造体へのポインタを作成したい場合はどうなるでしょうか？

168
00:09:08,990 --> 00:09:11,130
我々のような何かができる

169
00:09:11,130 --> 00:09:17,580
学生* S

170
00:09:17,580 --> 00:09:20,980
malloc関数に等しい

171
00:09:20,980 --> 00:09:26,600
学生のサイズ。

172
00:09:30,450 --> 00:09:33,590
静止画のサイズはここで働いていることに注意してください。

173
00:09:33,590 --> 00:09:37,260
それでは、どのように我々は今、時代のメンバーにアクセスするにはどう

174
00:09:37,260 --> 00:09:39,640
ブロックのSが指している？

175
00:09:39,640 --> 00:09:42,300
あなたは最初に何を思うかもしれない

176
00:09:42,300 --> 00:09:47,970
* S.age = 4、

177
00:09:47,970 --> 00:09:50,220
しかし、これは非常に動作しません。

178
00:09:50,220 --> 00:09:52,940
これは実際にあると解釈されますので、

179
00:09:52,940 --> 00:09:57,740
*カッコ内S.age = 4、

180
00:09:57,740 --> 00:10:00,160
これは、コンパイル時にエラーとなります、

181
00:10:00,160 --> 00:10:03,600
Sはstructまたはむしろ構造体へのポインタではないので、

182
00:10:03,600 --> 00:10:06,270
などの点がここでは使用できません。

183
00:10:06,270 --> 00:10:08,860
我々は何ができる

184
00:10:08,860 --> 00:10:13,760
（* S）である。年齢= 4

185
00:10:13,760 --> 00:10:16,790
括弧は迷惑と混乱するかもしれない。

186
00:10:16,790 --> 00:10:19,880
ありがたいことに、我々は特別な矢印演算子を持っている

187
00:10:19,880 --> 00:10:22,350
それは何かのように見える

188
00:10:22,350 --> 00:10:28,860
S  - >年齢= 4。

189
00:10:28,860 --> 00:10:31,600
年齢を参照して、これらの2つの方法

190
00:10:31,600 --> 00:10:33,270
同等である

191
00:10:33,270 --> 00:10:36,870
と私たちは本当に今までに、矢印演算子を必要としない

192
00:10:36,870 --> 00:10:39,300
それは物事が立派に見えるのです。

193
00:10:39,300 --> 00:10:43,050
Sは、構造体が含まれているメモリーの一部のブロックへのポインタであるため、

194
00:10:43,050 --> 00:10:47,820
ポインタの矢印に従っているあなたは、S>年齢を考えることができます

195
00:10:47,820 --> 00:10:50,250
と年齢のメンバーをつかむ。

196
00:10:50,250 --> 00:10:53,750
では、なぜ我々はこれまでに構造体を使うべきでしょうか？

197
00:10:53,750 --> 00:10:57,560
それは、単にプリミティブ整数で逃げることは間違いなく可能だ

198
00:10:57,560 --> 00:10:59,050
文字、ポインタなど

199
00:10:59,050 --> 00:11:01,550
我々は次の目的で使用していること;

200
00:11:01,550 --> 00:11:03,340
代わりにS1とS2の前に、

201
00:11:03,340 --> 00:11:06,290
我々はAGE1、AGE2、NAME1、およびname2あったかもしれない

202
00:11:06,290 --> 00:11:09,120
別々の変数で、すべて。

203
00:11:09,120 --> 00:11:11,390
これは、たった2学生と罰金です

204
00:11:11,390 --> 00:11:13,310
しかし、私たちがそれらの10を持っていた場合はどうなりますか？

205
00:11:13,310 --> 00:11:15,540
そして、どのような場合だけではなく、2つのフィールド、

206
00:11:15,540 --> 00:11:17,720
学生のstructは、100フィールドを持っていた？

207
00:11:17,720 --> 00:11:21,240
GPA、コース、髪の色、性別、などなど。

208
00:11:21,240 --> 00:11:25,790
代わりにわずか10構造体の、我々は千別々の変数を必要としています。

209
00:11:25,790 --> 00:11:28,360
また、関数を考えてみましょう

210
00:11:28,360 --> 00:11:32,270
その唯一の引数との100フィールドで、その構造をとり、その

211
00:11:32,270 --> 00:11:34,350
し、すべてのフィールドを出力します。

212
00:11:34,350 --> 00:11:36,320
我々は、構造体を使用しなかった場合、

213
00:11:36,320 --> 00:11:38,540
我々は、その関数を呼び出す毎回

214
00:11:38,540 --> 00:11:41,460
我々は、すべての100個の変数で渡す必要があります

215
00:11:41,460 --> 00:11:44,430
そして我々は、学生1の100個の変数を持っている場合、

216
00:11:44,430 --> 00:11:47,020
学生のための2および100個の変数、

217
00:11:47,020 --> 00:11:50,540
我々は誤って学生1からいくつかの変数を渡さないことを確認する必要があります

218
00:11:50,540 --> 00:11:52,910
学生2から、いくつかの変数。

219
00:11:52,910 --> 00:11:55,710
それは、構造体でそのミスを犯すことは不可能だ

220
00:11:55,710 --> 00:11:59,010
全100個の変数は、単一のパッケージに含まれているからである。

221
00:11:59,010 --> 00:12:02,050
最後の音符だけのカップル：

222
00:12:02,050 --> 00:12:04,870
あなたは素晴らしい、この点にすべてを理解していれば。

223
00:12:04,870 --> 00:12:07,900
ビデオの残りの部分は、単に完全を期するためのものです。

224
00:12:07,900 --> 00:12:11,010
構造体はポインタの任意の型を保持できるため、

225
00:12:11,010 --> 00:12:14,220
彼らはまた、関数ポインタを保持することができます。

226
00:12:14,220 --> 00:12:17,040
あなたは、オブジェクト指向プログラミングに精通している場合は、

227
00:12:17,040 --> 00:12:21,790
これはオブジェクト指向のスタイルでプログラムを構造体を使用する方法を提供します。

228
00:12:21,790 --> 00:12:24,500
別の時に関数ポインタの詳細。

229
00:12:24,500 --> 00:12:27,760
また、時にはあなたは2点の構造体があるかもしれません

230
00:12:27,760 --> 00:12:30,220
その定義がお互いに依存しています。

231
00:12:30,220 --> 00:12:32,320
たとえば、

232
00:12:32,320 --> 00:12:35,470
我々は、構造体Aを及ぼす可能性があります

233
00:12:35,470 --> 00:12:38,580
として定義されている

234
00:12:38,580 --> 00:12:41,910
構造体Bへのポインタ、

235
00:12:41,910 --> 00:12:47,180
構造体B * X

236
00:12:47,180 --> 00:12:50,470
そして今我々は、struct Bを持つことができます

237
00:12:53,890 --> 00:12:56,280
ポインタとして定義されている

238
00:12:56,280 --> 00:12:59,180
構造体Aに、

239
00:12:59,180 --> 00:13:03,640
構造体A * Y

240
00:13:07,230 --> 00:13:09,060
しかし、これは、コンパイルされません

241
00:13:09,060 --> 00:13:14,110
構造Bは構造体がコンパイルされた時点で存在しないので。

242
00:13:14,110 --> 00:13:17,600
そして我々にはstruct Aと構造Bを交換する場合、

243
00:13:17,600 --> 00:13:20,100
それから私達はちょうど同じ問題が残っているはずだ。

244
00:13:20,100 --> 00:13:22,640
この時間は、使用して既存の構造体ではない。

245
00:13:22,640 --> 00:13:24,720
これを解決するために、我々は書くことができます

246
00:13:24,720 --> 00:13:29,290
構造体B;

247
00:13:29,290 --> 00:13:32,460
構造体Aの定義の前に

248
00:13:32,460 --> 00:13:35,590
これは、前方宣言と呼ばれています。

249
00:13:35,590 --> 00:13:38,590
これは単にコンパイラがそれを知ることができます

250
00:13:38,590 --> 00:13:42,040
構造体Bは完全に以降または他の場所で定義される有効なタイプである。

251
00:13:42,040 --> 00:13:45,980
私の名前はロブ·ボーデンであり、これはCS50です。

252
00:13:45,980 --> 00:13:48,980
[CS50.TV]