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
>> DOUG LLOYD: OK.

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
ჩვენ ამოწურა საკმაოდ ბევრი ყველა
[INAUDIBLE] ტიპები,

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
მაგრამ ეს არის ერთგვარი წვერი
off შემდგენელი, რომ ეს

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
შიგნით curly აფრთხილებს
ყველა ე.წ. სფეროებში,

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
odometer, რომ ჩვეულებრივ აქვს
გარკვეული რაოდენობის მილი მასზე,

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
მაგალითად, თქვენ უბრალოდ უნდა
ღია Curly გაუწიოს, მჭიდრო Curly გაუწიოს.

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
>> OK.

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
მაგალითად, თქვენ შესაძლოა ამით მათ
ცალკე dot თ ფაილი, რომელიც თქვენ შემდეგ

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
იმ sub-ცვლადები, იმ ცვლადის
რომ არსებობს შიგნით სტრუქტურა?

78
00:03:43,530 --> 00:03:46,810
ისე, ჩვენ გვაქვს რაღაც მოუწოდა
dot ოპერატორი, რომელიც საშუალებას გვაძლევს

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
ზედა ჩემი პროგრამა, ან შესაძლოა,
dot თ ფაილი რომ მე ფუნტი შედის.

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
x, ან სიმებიანი სახელი მძიმით.

85
00:04:11,580 --> 00:04:18,100
>> მონაცემთა ტიპის აქ არის struct მანქანა,
სახელი ცვლადი არის ჩემი მანქანა,

86
00:04:18,100 --> 00:04:23,770
და მერე შეგიძლიათ გამოიყენოთ dot ოპერატორი
წვდომის სხვადასხვა სფეროებში ჩემი მანქანა.

87
00:04:23,770 --> 00:04:27,494
ასე რომ, შემიძლია ვთქვა, ჩემი მანქანა
dot წელს უდრის 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
dot წელს შეადგენს და შემდეგ მივანიჭოთ
ეს რაღაც მთელი ღირებულება, 2011 წელს.

93
00:04:44,030 --> 00:04:47,290
ჩემი მანქანა dot დისკო შეადგენს CS50.

94
00:04:47,290 --> 00:04:51,180
ჩემი ანკეტა dot odometer
უდრის 50505 მძიმით.

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
სტრუქტურებში, თუმცა, არ უნდა
შეიქმნება Stack.

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
ჩვენ ვერ ვიტყვით მაჩვენებელი dot სფეროში
ასახელებს და რა ჩვენ ვეძებთ.

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
შეადგენს malloc ზომა struct მანქანა.

114
00:05:51,250 --> 00:05:54,950
ზომა ჩვენ გაერკვნენ, თუ რამდენი
ბაიტი თქვენი ახალი მონაცემები ტიპის იკავებს.

115
00:05:54,950 --> 00:05:58,570
თქვენ არ აუცილებლად მხოლოდ უნდა გამოვიყენოთ
ზომა, სიგანე, int, ან char, ან

116
00:05:58,570 --> 00:05:59,715
ჩაშენებული მონაცემთა ტიპები.

117
00:05:59,715 --> 00:06:02,090
შემდგენელი არის smart საკმარისი
გაერკვნენ, თუ რამდენი ბაიტი

118
00:06:02,090 --> 00:06:04,170
მიერ მოთხოვნილი თქვენი ახალი სტრუქტურა.

119
00:06:04,170 --> 00:06:09,610
ასე რომ, მე malloc თავს ერთეული მეხსიერება
დიდი საკმარისი გამართავს 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
მერე შეგიძლიათ გამოიყენოთ dot ოპერატორი
წვდომის სხვადასხვა სფეროებში ჩემი მანქანა.

126
00:06:32,200 --> 00:06:35,490
Star ჩემი მანქანა dot წელს უდრის 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
და ჩვენ გვაქვს dot ოპერატორი.

133
00:06:48,910 --> 00:06:51,660
და როგორც მოსალოდნელი იყო, იმიტომ, რომ
C პროგრამისტები მიყვარს მოკლე გზა

134
00:06:51,660 --> 00:06:53,740
გავაკეთოთ ყველაფერი, არ არის
მოკლე გზა ამის გაკეთება.

135
00:06:53,740 --> 00:06:57,790
არსებობს კიდევ ერთი ოპერატორი მოუწოდა arrow,
რაც ამ პროცესში ბევრი ადვილია.

136
00:06:57,790 --> 00:07:00,750
გზა arrow მუშაობს
ეს პირველი 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
ასე რომ, ადრე ჩვენ გვქონდა ასეთი
ვარსკვლავი ჩემი მანქანა dot ყველა ამ პერსონალის,

141
00:07:14,170 --> 00:07:15,880
როგორიც იყო ბევრი ხდება.

142
00:07:15,880 --> 00:07:22,040
მაგრამ რა შეგვიძლია ნაცვლად გააკეთოს არის ამ
ჩემი მანქანა arrow წელს უდრის 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
შემდეგ შედიხართ სფეროებში
წელს, დისკო, და odometer

148
00:07:35,130 --> 00:07:40,020
ისევე, როგორც შემეძლო, სანამ, რომელსაც პირველი
მეორადი ვარსკვლავი dereference ჩემი მანქანა,

149
00:07:40,020 --> 00:07:42,020
და dot წვდომის სფეროში.

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
Dot ან arrow, დამოკიდებულია
როგორ ცვლადი გამოცხადდა.

154
00:07:57,640 --> 00:08:00,510
მე Doug Lloyd, ეს არის CS50.

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