1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] Нека поговорим за structs.

2
00:00:09,180 --> 00:00:12,130
Structs ни предоставяте с начина, по който да се групират заедно куп променливи

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
знак име *

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
но това е в действителност е необходимо, с structs.

12
00:00:43,620 --> 00:00:46,270
Всеки валиден тип могат да отидат в рамките на дефиницията на структурата.

13
00:00:46,270 --> 00:00:49,530
Тук сме използвали вътр и Чар *

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
Когато използвате structs в 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
от цяло число и Чар *.

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
Спомняш ли си как structs и са сходни?

29
00:01:24,970 --> 00:01:26,710
Е, ние просто каза

30
00:01:27,840 --> 00:01:30,060
ПНА,

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
вече могат да използват студент структура

68
00:03:33,050 --> 00:03:36,950
в почти точно по същия начин щяхме да използваме вътр.

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
Подобно на масиви, structs синтаксис комбинация инициализация,

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
Ние можем да използваме студент структура като тип параметър на функция.

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
точно като число е тип.

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
Отново, мисля на structs като редовни числа.

93
00:05:02,800 --> 00:05:05,590
Ако зададете някои INT X до известна Int 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
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
може би от 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
Използването на Def, можем да направим

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
че сме свикнали да използват студент структура.

114
00:06:11,090 --> 00:06:13,410
Този тип Def анонимен структура

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
Бихме могли да въведете 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
тип дефиниция структура възел

129
00:06:56,140 --> 00:07:01,200
и ще бъдат определени като INT Вал

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
Забележете, че ние трябва да кажа, структура възел * следващия

137
00:07:27,740 --> 00:07:30,690
в рамките на определението на структурата на възел,

138
00:07:30,690 --> 00:07:33,620
от вида Def все още не е приключил за да ни позволи да се опрости тази

139
00:07:33,620 --> 00:07:36,210
просто възел *.

140
00:07:36,210 --> 00:07:39,260
Ще научите повече за structs подобни на тази

141
00:07:39,260 --> 00:07:41,750
когато става дума за свързани списъци и дървета.

142
00:07:41,750 --> 00:07:44,130
Ами structs във функция?

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
Func на 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
Func получава копие от 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
се равнява на изчистване

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
Тези два начина на съотнасяне на възраст

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
Така че защо трябва ние някога използват structs?

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
И какво ще стане, ако вместо само два полета,

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 structs, ние се нуждаем 1000 отделни променливи.

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 променливи за студент 1,

216
00:11:44,430 --> 00:11:47,020
и 100 променливи за студент 2,

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
Тъй като structs може да побере всякакъв вид на показалеца,

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
това осигурява начин за използване на structs програма в обектно-ориентиран стил.

228
00:12:21,790 --> 00:12:24,500
На функцията указатели по друго време.

229
00:12:24,500 --> 00:12:27,760
Също така, понякога може да се наложи 2 structs

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
указател към структурата Б,

235
00:12:41,910 --> 00:12:47,180
структура B * X,

236
00:12:47,180 --> 00:12:50,470
и сега можем да имаме Б структура

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
тъй като структура Б не съществува в момента, че структурата се съставя.

242
00:13:14,110 --> 00:13:17,600
И ако ние суап структура А и структура 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
структура Б;

247
00:13:29,290 --> 00:13:32,460
преди определянето на структурата на А.

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]