1
00:00:00,000 --> 00:00:02,395
>> [Музички]

2
00:00:02,395 --> 00:00:05,750

3
00:00:05,750 --> 00:00:06,506
>> Даг LLOYD: Во ред.

4
00:00:06,506 --> 00:00:08,880
Ние работевме со цели броеви,
ние сме работеле со ликовите,

5
00:00:08,880 --> 00:00:11,930
ние сме работеле лебди,
двојки, стрингови, и bools.

6
00:00:11,930 --> 00:00:14,870
Ние сме исцрпени доста ги сите
на [Беззвучен] видови кои

7
00:00:14,870 --> 00:00:17,100
да се достапни за сите нас, заедно.

8
00:00:17,100 --> 00:00:19,430
Но сега ние сакаме да се направи нешто повеќе.

9
00:00:19,430 --> 00:00:20,210
Како го правиме тоа?

10
00:00:20,210 --> 00:00:22,560
Како да се креираат различни типови на податоци?

11
00:00:22,560 --> 00:00:26,130
Ние може да го стори тоа со помош на структури.

12
00:00:26,130 --> 00:00:30,180
Структури, така ни овозможи да се обедини
променливи на различни видови

13
00:00:30,180 --> 00:00:34,810
во една, нова променлива тип,
кои можеме да му ја додели свое име тип.

14
00:00:34,810 --> 00:00:37,570
Ова е навистина силна
нешто што треба да биде во можност да се направи,

15
00:00:37,570 --> 00:00:40,900
бидејќи ние сега да се група
елементи на различни типови на податоци

16
00:00:40,900 --> 00:00:43,910
заедно, кои имаат логична врска.

17
00:00:43,910 --> 00:00:46,440
Ние сме биле во можност да го стори тоа
со низи вид на, нели?

18
00:00:46,440 --> 00:00:49,540
Ние можеме да се променливи група
од ист вид на податоци

19
00:00:49,540 --> 00:00:53,410
заедно во голем единица
меморија, низа.

20
00:00:53,410 --> 00:00:56,660
>> Но, ние не сме биле во можност да се меша
до различни типови на податоци заедно.

21
00:00:56,660 --> 00:01:02,610
Не можеме да се, да речеме, спарите цел број,
и еден лик, и двојно сите

22
00:01:02,610 --> 00:01:05,330
во истото и
јавам дека една единица.

23
00:01:05,330 --> 00:01:08,830
Но, со структури, или
често се нарекува structs,

24
00:01:08,830 --> 00:01:09,585
ние всушност може.

25
00:01:09,585 --> 00:01:12,370
Така, една структура е вид
на како супер променлива.

26
00:01:12,370 --> 00:01:16,530
Тоа е променлива, која содржи
други променливи во него.

27
00:01:16,530 --> 00:01:19,650
Па еве еден пример на
многу едноставна структура.

28
00:01:19,650 --> 00:01:23,380
Тоа е она што ќе изгледа синтаксата
сакал да се создаде структура за автомобил.

29
00:01:23,380 --> 00:01:25,250
Сега, ајде да се оди преку синтакса тука.

30
00:01:25,250 --> 00:01:27,400
Struct, тоа е
клучен збор кој означува

31
00:01:27,400 --> 00:01:30,270
дека јас сум создавање на нов тип на податоци тука.

32
00:01:30,270 --> 00:01:33,860
Особено, на име на типот на податоци е
ќе биде struct автомобилот, како што ќе видиме.

33
00:01:33,860 --> 00:01:36,640
Но, ова е еден вид на врв
исклучување на компајлерот дека овој

34
00:01:36,640 --> 00:01:42,440
како група на променливи кои се случува
што треба да се смета за дел од ист вид

35
00:01:42,440 --> 00:01:44,010
во една минута.

36
00:01:44,010 --> 00:01:46,340
>> Автомобили, само името на структурата.

37
00:01:46,340 --> 00:01:50,590
Повторно, типот податоци тука се случува
да биде struct автомобил, а не само автомобил.

38
00:01:50,590 --> 00:01:53,060
Но, ако имате different--
Ако креирате повеќе structs

39
00:01:53,060 --> 00:01:56,950
во истата програма, ќе треба да
разлика помеѓу struct и struct.

40
00:01:56,950 --> 00:02:00,140
Па struct автомобил, јас, исто така, би можеле да имаат
struct студент, на пример,

41
00:02:00,140 --> 00:02:01,790
во истата програма.

42
00:02:01,790 --> 00:02:05,980
Внатрешноста на големите загради се
сите на т.н. полиња,

43
00:02:05,980 --> 00:02:07,954
или членови на структурата.

44
00:02:07,954 --> 00:02:10,370
Значи она што се некои од работите
кои се својствени во автомобил?

45
00:02:10,370 --> 00:02:15,270
Па, тоа обично има една година,
име на модел, и регистарска табличка,

46
00:02:15,270 --> 00:02:18,000
со километража која обично има
некои бројот на милји на неа,

47
00:02:18,000 --> 00:02:19,225
а можеби и големината на моторот.

48
00:02:19,225 --> 00:02:23,570
И како што можете да видите, јас сум мешање
цели броеви и карактери и двојки.

49
00:02:23,570 --> 00:02:26,420
Сите тие се случува да се биде
дел на овој нов тип на податок.

50
00:02:26,420 --> 00:02:29,750
>> И на крај, конечната нешто што треба да направите,
бидете сигурни дека оваа мала запирка

51
00:02:29,750 --> 00:02:30,290
на крај.

52
00:02:30,290 --> 00:02:34,380
Откако ќе завршиме со дефинирање на структурата,
ние треба да се стави запирка на крајот.

53
00:02:34,380 --> 00:02:37,325
Тоа е многу честа синтаксички
грешка, бидејќи со функција,

54
00:02:37,325 --> 00:02:40,200
На пример, можете само ќе треба
отворен кадрава голема заграда, во близина кадрава голема заграда.

55
00:02:40,200 --> 00:02:42,950
Не се стави запирка во
крајот на дефиницијата функција.

56
00:02:42,950 --> 00:02:46,430
Ова личи на функцијата
дефиниција, но тоа не е,

57
00:02:46,430 --> 00:02:49,653
и така запирка таму
е само потсетување дека

58
00:02:49,653 --> 00:02:52,440
треба да го стави таму, бидејќи
компајлер во спротивно не ќе

59
00:02:52,440 --> 00:02:53,510
знае што да прави со него.

60
00:02:53,510 --> 00:02:56,160
Тоа е многу честа грешка
случајно да

61
00:02:56,160 --> 00:02:58,570
кога си прв на дефинирање структури.

62
00:02:58,570 --> 00:02:59,500
>> ВО РЕД.

63
00:02:59,500 --> 00:03:02,824
Па ние обично се дефинираат нашите структури
во самиот врв на нашите програми

64
00:03:02,824 --> 00:03:05,490
затоа што тие се веројатно нема
што треба да се користи од страна на повеќе функции.

65
00:03:05,490 --> 00:03:08,850
Ние не сакаме да се дефинира
struct внатрешноста на некоја функција,

66
00:03:08,850 --> 00:03:12,110
бидејќи тогаш можеме да only-- на
обемот на структурата навистина

67
00:03:12,110 --> 00:03:13,790
постои само во внатрешноста на таа функција.

68
00:03:13,790 --> 00:03:17,450
Веројатно ние би сакале да се дефинира структурата
за да можеме да го користат во повеќе функции,

69
00:03:17,450 --> 00:03:20,670
или можеби во повеќе
датотеки, кои се врзани заедно

70
00:03:20,670 --> 00:03:22,920
да се создаде нашата единствена програма.

71
00:03:22,920 --> 00:03:24,920
Понекогаш, исто така, наместо
за дефинирање на структурата

72
00:03:24,920 --> 00:03:27,961
во самиот врв, каде што ќе ги ставаш
фунтата вклучува и вашиот фунта дефинира,

73
00:03:27,961 --> 00:03:32,080
на пример, може да ги стави во
посебна точка ж датотеки, кои потоа

74
00:03:32,080 --> 00:03:35,020
фунтата вклучуваат себе.

75
00:03:35,020 --> 00:03:37,620
>> Па ние имаме структури, но сега
ние треба да се добие во внатрешноста на нив.

76
00:03:37,620 --> 00:03:39,800
Како да се добие во внатрешноста на
структура за пристап

77
00:03:39,800 --> 00:03:43,530
оние кои се под-променливи, овие променливи
кои постојат во внатрешноста на структура?

78
00:03:43,530 --> 00:03:46,810
Па, ние имаме нешто што се нарекува
операторот точка, која ни овозможува

79
00:03:46,810 --> 00:03:50,990
пристап до областа на структурата.

80
00:03:50,990 --> 00:03:55,490
Така на пример, да речеме дека сум го прогласи
моите податоци структура тип некаде

81
00:03:55,490 --> 00:03:59,020
на врвот од мојата програма, или можеби во
точка ж датотека што сум фунта вклучени.

82
00:03:59,020 --> 00:04:03,360
Ако јас потоа ќе сакате да се создаде нова
променливата на тој тип на податоци, можам да кажам,

83
00:04:03,360 --> 00:04:06,260
struct автомобил, мојот автомобил, точка-запирка.

84
00:04:06,260 --> 00:04:11,580
Исто како што можев да кажам int
х, или името на стрингот запирка.

85
00:04:11,580 --> 00:04:18,100
>> Типот податоци тука е struct автомобил,
името на променливата е мојот автомобил,

86
00:04:18,100 --> 00:04:23,770
и тогаш ќе можат да го користат операторот точка да
пристап до различни области на мојот автомобил.

87
00:04:23,770 --> 00:04:27,494
Па можам да кажам мојот автомобил
дот година изнесува 2011.

88
00:04:27,494 --> 00:04:28,410
Тоа е совршено добро.

89
00:04:28,410 --> 00:04:34,210
Година, ако се сеќавате, е дефинирана како
цел број поле во внатрешноста на оваа struct автомобил

90
00:04:34,210 --> 00:04:35,200
тип на податок.

91
00:04:35,200 --> 00:04:39,966
Па секоја променлива на податоци на struct автомобил
тип, како што мојот автомобил, можам да кажам дека мојот автомобил

92
00:04:39,966 --> 00:04:44,030
дот година изнесува, а потоа му ја додели
тоа некои целобројна вредност, 2011.

93
00:04:44,030 --> 00:04:47,290
Мојот автомобил точка плоча еднаква CS50.

94
00:04:47,290 --> 00:04:51,180
Мојата картичка точка километража
еднакво на 50.505 запирка.

95
00:04:51,180 --> 00:04:53,270
Сите оние кои се
совршено добро и тоа е

96
00:04:53,270 --> 00:04:57,802
како ние пристап на
полиња на структурата.

97
00:04:57,802 --> 00:05:00,260
Структури, сепак, не треба да
да бидат создадени на магацинот.

98
00:05:00,260 --> 00:05:02,950
Исто како и сите други променливи, ние
динамички да ги распредели.

99
00:05:02,950 --> 00:05:06,309
Ако имаме програма која би
се генерира многу структури,

100
00:05:06,309 --> 00:05:08,100
не знаеме колку
ние се случува да треба,

101
00:05:08,100 --> 00:05:10,800
тогаш ние треба да се динамички
распредели тие структури

102
00:05:10,800 --> 00:05:12,960
како нашата програма се извршува.

103
00:05:12,960 --> 00:05:16,600
И така, ако ние се случува да пристапите до
полиња на една структура во тој контекст,

104
00:05:16,600 --> 00:05:20,660
потсетиме дека ние прво треба да се dereference
покажувачот на структурата,

105
00:05:20,660 --> 00:05:24,810
а потоа, откако ние dereference на
покажувач, тогаш можеме да пристапите на полиња.

106
00:05:24,810 --> 00:05:26,830
Ако имаме само
покажувач на структура,

107
00:05:26,830 --> 00:05:32,120
ние не може само да се каже поле покажувачот точка
именува и да добијат она што го барате.

108
00:05:32,120 --> 00:05:34,259
Тука е дополнителен чекор на dereferencing.

109
00:05:34,259 --> 00:05:36,050
Значи, да се каже дека
наместо previous--

110
00:05:36,050 --> 00:05:38,770
исто како и во претходниот пример,
наместо да го прогласи

111
00:05:38,770 --> 00:05:43,680
на магацинот, struct автомобил, мојот
автомобил, запирка, велам struct автомобил,

112
00:05:43,680 --> 00:05:48,020
ѕвезда, покажувач кон
struct автомобил наречен мојот автомобил,

113
00:05:48,020 --> 00:05:51,250
Примерок еднаква на големината на struct автомобил.

114
00:05:51,250 --> 00:05:54,950
Големината ќе дознаам колку
бајти вашиот нов тип на податоци зазема.

115
00:05:54,950 --> 00:05:58,570
Вие не секогаш треба да се користи само
големината, ширина, цел број, или да се усвити, или било кој

116
00:05:58,570 --> 00:05:59,715
на вграден типови на податоци.

117
00:05:59,715 --> 00:06:02,090
Компајлерот е доволно паметни
за да дознаам колку бајти

118
00:06:02,090 --> 00:06:04,170
се бара од страна на вашиот нов структура.

119
00:06:04,170 --> 00:06:09,610
Значи јас Примерок единица на меморијата
доволно голема за да се одржи struct автомобил,

120
00:06:09,610 --> 00:06:12,410
и можам да добијам назад покажувачот
за тој блок од меморија,

121
00:06:12,410 --> 00:06:16,090
и дека покажувачот е доделен на мојот автомобил.

122
00:06:16,090 --> 00:06:18,050
>> Сега, ако сакам да пристап
областа на мојот автомобил,

123
00:06:18,050 --> 00:06:22,615
Јас прв пат dereference мојот автомобил користење
на dereference оператор, ѕвезда

124
00:06:22,615 --> 00:06:26,620
дека ние сме виделе од покажувачи
видео клипови, а потоа, откако јас dereference,

125
00:06:26,620 --> 00:06:32,200
тогаш може да се користи операторот точка да
пристап до различни области на мојот автомобил.

126
00:06:32,200 --> 00:06:35,490
Ѕвезда мојот автомобил точка година изнесува 2011.

127
00:06:35,490 --> 00:06:38,480
Кои ќе имаат ефект
ние сакаме во овој случај,

128
00:06:38,480 --> 00:06:41,960
бидејќи ние сме динамички
распределени мојот автомобил.

129
00:06:41,960 --> 00:06:43,610
>> Тоа е вид на досадни, иако, нели?

130
00:06:43,610 --> 00:06:44,818
Има процесот на 2-чекор сега.

131
00:06:44,818 --> 00:06:47,460
Сега ние треба да dereference--
имаме оператор ѕвезда,

132
00:06:47,460 --> 00:06:48,910
и ние имаме оператор точка.

133
00:06:48,910 --> 00:06:51,660
И како што може да се очекува, бидејќи
С програмери сакаат пократки патишта

134
00:06:51,660 --> 00:06:53,740
да се прават работите, постои
пократок начин да го направите тоа.

135
00:06:53,740 --> 00:06:57,790
Постои уште еден оператор се нарекува со стрелки,
што го прави овој процес многу полесно.

136
00:06:57,790 --> 00:07:00,750
Начинот на кој функционира е на тастатурата
таа прво dereferences

137
00:07:00,750 --> 00:07:03,560
покажувачот на левата
страна на операторот,

138
00:07:03,560 --> 00:07:06,620
а потоа, откако dereferenced
покажувачот на левата страна,

139
00:07:06,620 --> 00:07:09,620
ја пристапува од областа на правото.

140
00:07:09,620 --> 00:07:14,170
И така претходно имавме овој вид
на Star мојот автомобил dot сите овие работи,

141
00:07:14,170 --> 00:07:15,880
како што имаше многу се случува таму.

142
00:07:15,880 --> 00:07:22,040
Но, она што, наместо да можеме да направиме е this--
мојот автомобил стрелката година изнесува 2011.

143
00:07:22,040 --> 00:07:23,580
>> Повторно, она што се случува овде?

144
00:07:23,580 --> 00:07:25,720
Прво, јас dereferencing мојот автомобил.

145
00:07:25,720 --> 00:07:27,810
Која, повторно, е покажувачот тука.

146
00:07:27,810 --> 00:07:31,270
Потоа, откако ќе го
dereferenced мојот автомобил, јас

147
00:07:31,270 --> 00:07:35,130
тогаш може да пристапите на полиња
година, чинија, и километражата

148
00:07:35,130 --> 00:07:40,020
јас како што може да пред тоа има прв
користени ѕвезда да dereference мојот автомобил,

149
00:07:40,020 --> 00:07:42,020
и точка за пристап на оваа област.

150
00:07:42,020 --> 00:07:45,290
Па можете да имате структури, ќе
може да има покажувачи за структури,

151
00:07:45,290 --> 00:07:48,360
и имаш начини за пристап
областа на овие структури,

152
00:07:48,360 --> 00:07:52,600
дали имате покажувачи
нив или на самите променливи.

153
00:07:52,600 --> 00:07:57,640
Дот или стрелките, во зависност од
колку променливата беше прогласена.

154
00:07:57,640 --> 00:08:00,510
Јас сум Даг Лојд, ова е CS50.

155
00:08:00,510 --> 00:08:01,975