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
任何有效的数据类型可以在struct定义。

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
正如我们将在后面看到，一个结构类型

22
00:01:07,400 --> 00:01:10,700
是在相当于你使用的任何其他类型的方式有很多。

23
00:01:10,700 --> 00:01:13,310
通常情况下，我会比较结构类型，

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
要访问任何特定成员的学生结构，

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
所以在这里，唯一有效的可能性

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
你的结构是匿名的。

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
后字结构。

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
现在，我们可以使用struct学生

68
00:03:33,050 --> 00:03:36,950
在几乎相同的方式，我们将使用int。

69
00:03:36,950 --> 00:03:39,580
因此，我们可以声明一个变量的类型结构学生，

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
他们的大多数你可以做与结构学生类型。

80
00:04:22,460 --> 00:04:26,060
作为函数参数的类型，我们可以使用一个struct学生。

81
00:04:26,060 --> 00:04:28,790
我们可以使用一个新的结构的内部结构学生。

82
00:04:28,790 --> 00:04:31,010
我们可以有一个指针，指向一个结构的学生。

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 X的一些诠释y，

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
Ÿ改变呢？

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
但是请注意，分配一个struct时，

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
也许通过一个块内存malicking其中一个指针以指向

106
00:05:39,780 --> 00:05:42,120
以及将数据复制过来。

107
00:05:42,120 --> 00:05:45,540
这可能是恼人的学生到处写结构。

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结构的学生，

118
00:06:27,670 --> 00:06:31,590
我们可以同时使用的结构学生和学生互换。

119
00:06:31,590 --> 00:06:34,060
他们甚至不必须具有相同的名称。

120
00:06:34,060 --> 00:06:36,710
我们可以鲍勃类型定义结构学生

121
00:06:36,710 --> 00:06:38,950
然后STRUCT学生和Bob

122
00:06:38,950 --> 00:06:41,270
将互换的类型。

123
00:06:41,270 --> 00:06:44,050
不管类型高清

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
类型定义结构节点

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
指针的struct节点。

136
00:07:24,200 --> 00:07:27,740
请注意，我们不得不说结构节点下

137
00:07:27,740 --> 00:07:30,690
内的struct节点的定义，

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
丧失功能

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。

151
00:08:12,850 --> 00:08:15,230
该结构的行为

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，功能和S1。

160
00:08:41,100 --> 00:08:44,760
还有另外一个原因，通过地址在这里。

161
00:08:44,760 --> 00:08:48,030
如果我们的结构中包含100个字段？

162
00:08:48,030 --> 00:08:51,250
每一次我们给函数传递一个学生，

163
00:08:51,250 --> 00:08:55,770
我们的程序需要所有这100场复制到函数的参数s，

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是不是一个结构，或者是一个指向结构的指针，

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，平方，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
学生结构有100个字段？

207
00:11:17,720 --> 00:11:21,240
GPA，课程，发色，性别，等等。

208
00:11:21,240 --> 00:11:25,790
10结构，而是我们需要1,000个独立的变量。

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
如果我们的学生有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
学生和一些变量。

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
指针到一个struct B，

235
00:12:41,910 --> 00:12:47,180
B * X，

236
00:12:47,180 --> 00:12:50,470
现在，我们可以有一个struct乙

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不存在在结构A正在编制。

242
00:13:14,110 --> 00:13:17,600
如果我们交换结构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]