1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] ვისაუბროთ იმაზე მასივები.

2
00:00:09,360 --> 00:00:12,780
ასე რატომ უნდა ოდესმე გვინდა გამოვიყენოთ კოლექტორები?

3
00:00:12,780 --> 00:00:17,210
კარგად ვთქვათ თქვენ გაქვთ პროგრამა, რომელიც სჭირდება შესანახად 5 სტუდენტი პირადობის მოწმობები.

4
00:00:17,210 --> 00:00:21,270
ეს შეიძლება, როგორც ჩანს გონივრული ჰქონდეს 5 ცალკე ცვლადები.

5
00:00:21,270 --> 00:00:24,240
იმის გამო ჩვენ ვხედავთ bit, დავიწყებთ დათვლის საწყისი 0.

6
00:00:24,240 --> 00:00:30,700
ცვლადები გვექნება იქნება int id0, int ID1, და ასე შემდეგ.

7
00:00:30,700 --> 00:00:34,870
ვერანაირ ლოგიკას გვინდა ანსამბლის სტუდენტი ID უნდა იყოს დაკოპირებული და pasted

8
00:00:34,870 --> 00:00:36,870
თითოეული ამ სტუდენტი პირადობის მოწმობები.

9
00:00:36,870 --> 00:00:39,710
თუ გვინდა, რომ შეამოწმოს, რომელიც სტუდენტებს მოხდეს იყოს CS50,

10
00:00:39,710 --> 00:00:43,910
ჩვენ ჯერ უნდა შევამოწმოთ, თუ id0 წარმოადგენს სტუდენტი რა თქმა უნდა.

11
00:00:43,910 --> 00:00:48,070
მაშინ იგივეს მომდევნო სტუდენტი, ჩვენ უნდა დააკოპირეთ და ჩასვით კოდი id0

12
00:00:48,070 --> 00:00:54,430
და შეცვლის ყველა დამთხვევა of id0 ერთად ID1 და ა.შ. ამისთვის id2, 3, და 4.

13
00:00:54,430 --> 00:00:57,560
>> როგორც კი გესმით, რომ ჩვენ უნდა დააკოპირეთ და ჩასვით,

14
00:00:57,560 --> 00:01:00,440
თქვენ უნდა დაიწყოს ფიქრი, რომ არსებობს უკეთესი გამოსავალი.

15
00:01:00,440 --> 00:01:05,360
არის რა, თუ ხვდები, თქვენ არ გჭირდებათ 5 სტუდენტი პირადობის მოწმობები, არამედ 7?

16
00:01:05,360 --> 00:01:09,570
თქვენ უნდა დაბრუნდეს თქვენს კოდის და დაამატე id5, id6,

17
00:01:09,570 --> 00:01:14,260
და დააკოპირეთ და ჩასვით ლოგიკა შესამოწმებლად, თუ პირადობის მოწმობები ეკუთვნის კლასი ამ 2 ახალი პირადობის მოწმობები.

18
00:01:14,260 --> 00:01:19,600
არაფერია დამაკავშირებელი ყველა ამ პირადობის მოწმობების ერთად, და ა.შ. არ არსებობს გზა გეკითხებით

19
00:01:19,600 --> 00:01:22,040
პროგრამის ამის პირადობის მოწმობისათვის 0 მეშვეობით 6.

20
00:01:22,040 --> 00:01:26,120
კარგად არის ხვდები თქვენ გაქვთ 100 სტუდენტი პირადობის მოწმობები.

21
00:01:26,120 --> 00:01:30,770
ის იწყებს ჩანს ნაკლები იდეალური საჭიროა ცალკე განაცხადოს თითოეული პირადობის მოწმობა,

22
00:01:30,770 --> 00:01:33,760
და დააკოპირეთ და ჩასვით ნებისმიერი ლოგიკა იმ ახალი პირადობის მოწმობები.

23
00:01:33,760 --> 00:01:38,380
მაგრამ იქნებ ჩვენ ვაპირებთ, ჩვენ ამას ყველა 100 სტუდენტი.

24
00:01:38,380 --> 00:01:42,240
მაგრამ რა, თუ თქვენ არ იცით, თუ რამდენი სტუდენტი იქ სინამდვილეში?

25
00:01:42,240 --> 00:01:47,320
არსებობს რამოდენიმე N სტუდენტები და თქვენი პროგრამის ვთხოვო მომხმარებლის რა რომ n.

26
00:01:47,320 --> 00:01:50,250
Uh Oh. ეს არ არის იმუშავებს კარგად.

27
00:01:50,250 --> 00:01:53,820
შენი პროგრამა მუშაობს მხოლოდ გარკვეული მუდმივი მოსწავლეთა რაოდენობას.

28
00:01:53,820 --> 00:01:57,520
>> გადაჭრის ყველა ამ პრობლემის სილამაზის მასივი.

29
00:01:57,520 --> 00:01:59,930
რა არის მასივი?

30
00:01:59,930 --> 00:02:04,480
ზოგიერთ პროგრამირების ენების მასივი ტიპის შესაძლოა გავაკეთოთ უფრო მეტი,

31
00:02:04,480 --> 00:02:09,960
მაგრამ აქ ჩვენ ფოკუსირება ძირითად მასივი მონაცემები სტრუქტურა ისევე როგორც დაინახავთ მას C.

32
00:02:09,960 --> 00:02:14,030
Array მხოლოდ დიდი ბლოკი მეხსიერება. ეს არის ის.

33
00:02:14,030 --> 00:02:17,770
როდესაც ჩვენ ვამბობთ, რომ ჩვენ გვაქვს მასივი 10 რიცხვებით, რომ მხოლოდ იმას ნიშნავს, რომ ჩვენ გვაქვს გარკვეული ბლოკი

34
00:02:17,770 --> 00:02:20,740
მეხსიერების რომ არის დიდი საკმარისი გამართავს 10 ცალკე რიცხვებით.

35
00:02:29,930 --> 00:02:33,410
თუ ვივარაუდებთ, რომ მთელი რიცხვი არის 4 ბაიტი, ეს იმას ნიშნავს, რომ მასივი 10 რიცხვებით

36
00:02:33,410 --> 00:02:37,180
არის უწყვეტი ბლოკი 40 ბაიტი მეხსიერებაში.

37
00:02:42,660 --> 00:02:46,280
მაშინაც კი, როდესაც თქვენ იყენებთ მრავალგანზომილებიანი მასივები, რომელიც ჩვენ არ წავიდეს აქ,

38
00:02:46,280 --> 00:02:49,200
ეს ჯერ კიდევ მხოლოდ დიდი ბლოკი მეხსიერება.

39
00:02:49,200 --> 00:02:51,840
მრავალგანზომილებიანი ნოტაცია მხოლოდ მოხერხებულობისთვის.

40
00:02:51,840 --> 00:02:55,640
თუ თქვენ გაქვთ 3 by 3 მრავალგანზომილებიანი მასივი რიცხვებით,

41
00:02:55,640 --> 00:03:00,650
შემდეგ თქვენი პროგრამა მართლაც მხოლოდ ჩათვალოს როგორც დიდი ბლოკი 36 ბაიტი.

42
00:03:00,650 --> 00:03:05,460
საერთო რაოდენობა რიცხვებით არის 3 ჯერ 3, და ყოველი მთელი რიცხვი იკავებს 4 ბაიტს.

43
00:03:05,460 --> 00:03:07,750
>> მოდით შევხედოთ ძირითადი მაგალითი.

44
00:03:07,750 --> 00:03:10,660
ჩვენ აქ 2 სხვადასხვა გზით გამოცხადების მასივები.

45
00:03:15,660 --> 00:03:18,580
ჩვენ უნდა კომენტარის 1 მათგანი გარეთ პროგრამის შედგენა

46
00:03:18,580 --> 00:03:20,900
რადგან ჩვენ ვაცხადებთ x ორჯერ.

47
00:03:20,900 --> 00:03:25,140
ჩვენ შევხედოთ ზოგიერთი განსხვავებები ამ 2 სახის დეკლარაციების bit.

48
00:03:25,140 --> 00:03:28,560
ორივე ეს ხაზები განაცხადოს მასივი ზომა N,

49
00:03:28,560 --> 00:03:30,740
სადაც ჩვენ არ # define N როგორც 10.

50
00:03:30,740 --> 00:03:34,460
ჩვენ შეგვეძლო ასევე ადვილად ვთხოვე მომხმარებლის ამისთვის დადებითი მთელი რიცხვი

51
00:03:34,460 --> 00:03:37,250
და გამოიყენება, რომ მთელი რიცხვი, როგორც რაოდენობის ელემენტები ჩვენს მასივი.

52
00:03:37,250 --> 00:03:41,960
არა ჩვენი სტუდენტი ID მაგალითად ადრე, ეს არის სახის მოსწონს გამოცხადების 10 სრულიად ცალკე

53
00:03:41,960 --> 00:03:49,000
წარმოსახვითი ცვლადები; x0, x1, x2, და ა.შ. მდე xN-1.

54
00:03:57,270 --> 00:04:00,840
იგნორირება ხაზები სადაც ჩვენ ვაცხადებთ მასივი, შეამჩნია კვადრატულ ფრჩხილებში ხელუხლებელი

55
00:04:00,840 --> 00:04:02,090
შიგნით ამისთვის მარყუჟების.

56
00:04:02,090 --> 00:04:09,660
როდესაც ჩვენ წერენ რაღაც x [3], რომელიც მე მხოლოდ იკითხება x bracket 3,

57
00:04:09,660 --> 00:04:13,090
შეგიძლიათ წარმოიდგინოთ, რომ მას მოსწონს ითხოვს წარმოსახვითი x3.

58
00:04:13,090 --> 00:04:17,519
გაითვალისწინეთ, ვიდრე მასივი ზომა N, ეს ნიშნავს, რომ ხმების შიგნით ფრჩხილებში,

59
00:04:17,519 --> 00:04:22,630
რომელიც ჩვენ მოვუწოდებთ ინდექსი, შეიძლება იყოს არაფერს 0 დან N-1,

60
00:04:22,630 --> 00:04:25,660
რომელიც სულ N მაჩვენებლები.

61
00:04:25,660 --> 00:04:28,260
>> ვიფიქროთ იმაზე, თუ როგორ ეს რეალურად მუშაობს

62
00:04:28,260 --> 00:04:31,260
გვახსოვდეს, რომ მასივი არის დიდი ბლოკი მეხსიერება.

63
00:04:31,260 --> 00:04:37,460
თუ ვივარაუდებთ, რომ მთელი რიცხვი არის 4 ბაიტი, მთელი მასივი x არის 40 ბიტიანი ბლოკი მეხსიერება.

64
00:04:37,460 --> 00:04:41,360
ამიტომ x0 ეხება პირველივე 4 bytes of ბლოკი.

65
00:04:45,810 --> 00:04:49,230
X [1] ეხება შემდეგი 4 ბაიტი და ასე შემდეგ.

66
00:04:49,230 --> 00:04:53,760
ეს ნიშნავს, რომ დაწყების x არის ყველა პროგრამა ოდესმე სჭირდება ტრეკზე.

67
00:04:55,660 --> 00:04:59,840
თუ გსურთ გამოიყენოთ x [400], მაშინ პროგრამა იცის, რომ ეს არის ეკვივალენტი

68
00:04:59,840 --> 00:05:03,460
უბრალოდ 1,600 ბაიტი დაწყებიდან x.

69
00:05:03,460 --> 00:05:08,780
Where'd მივიღებთ 1,600 ბაიტი საწყისი? უბრალოდ 400 ჯერ 4 ბაიტი თითო რიცხვი.

70
00:05:08,780 --> 00:05:13,170
>> სანამ მოძრავი, ძალიან მნიშვნელოვანია გვესმოდეს, რომ C

71
00:05:13,170 --> 00:05:17,080
არ არსებობს აღსრულების ინდექსი, რომ ჩვენ გამოიყენონ მასივი.

72
00:05:17,080 --> 00:05:23,180
ჩვენი დიდი ბლოკი მხოლოდ 10 რიცხვებით ხანგრძლივი, მაგრამ არაფერი დაწეროთ ჩვენზე თუ ჩვენ წერენ x [20]

73
00:05:23,180 --> 00:05:26,060
ან თუნდაც x [-5].

74
00:05:26,060 --> 00:05:28,240
ინდექსი კი არ უნდა იყოს რიცხვი.

75
00:05:28,240 --> 00:05:30,630
ეს შეიძლება იყოს ნებისმიერი თვითნებური გამოხატვის.

76
00:05:30,630 --> 00:05:34,800
პროგრამაში ვიყენებთ ცვლადი მე საწყისი ამისთვის loop გვერდზე შევიდა მასივი.

77
00:05:34,800 --> 00:05:40,340
ეს არის ძალიან გავრცელებული ნიმუში, looping საწყისი i = 0 to სიგრძეზე მასივი,

78
00:05:40,340 --> 00:05:43,350
და შემდეგ გამოყენებით მე როგორც მაჩვენებელია მასივი.

79
00:05:43,350 --> 00:05:46,160
ამ გზით თქვენ ეფექტურად loop მთელ მასივი,

80
00:05:46,160 --> 00:05:50,600
და თქვენ შეგიძლიათ მიანიჭოთ თითოეულ ადგილზე მასივში ან ვიყენებთ მას გარკვეული გაანგარიშებით.

81
00:05:50,600 --> 00:05:53,920
>> პირველ for loop, მე იწყება 0,

82
00:05:53,920 --> 00:05:58,680
და ასე იქნება სამუშაოდ მიავლინოს 0 spot in მასივი, ღირებულების 0 ჯერ 2.

83
00:05:58,680 --> 00:06:04,370
მერე increments და უნდა მივუთითოთ პირველ ადგილზე მასივში ღირებულება 1 ჯერ 2.

84
00:06:04,370 --> 00:06:10,170
მერე increments ისევ და ასე შემდეგ წლამდე უნდა მივუთითოთ მისი პოზიციონირება N-1 მასივში

85
00:06:10,170 --> 00:06:13,370
ღირებულება N-1 ჯერ 2.

86
00:06:13,370 --> 00:06:17,810
ამიტომ, ჩვენ შევქმენით მასივში პირველი 10 კი ნომრები.

87
00:06:17,810 --> 00:06:21,970
იქნებ evens იქნებოდა ცოტა უკეთესი სახელი ცვლადი ვიდრე X,

88
00:06:21,970 --> 00:06:24,760
მაგრამ, რომ მისცემდა რამ მოშორებით.

89
00:06:24,760 --> 00:06:30,210
მეორე მარყუჟის მაშინ უბრალოდ ბეჭდავს ღირებულებებს, რომ ჩვენ უკვე ინახება შიგნით მასივი.

90
00:06:30,210 --> 00:06:33,600
>> მოდით ვეცადოთ გაშვებული პროგრამის ორივე ტიპის მასივი დეკლარაციების

91
00:06:33,600 --> 00:06:36,330
და შეხედეთ გამომავალი პროგრამის.

92
00:06:51,450 --> 00:06:57,020
რამდენადაც ვხედავთ, პროგრამა ისე იქცევა ისევე როგორც სახის დეკლარაციები.

93
00:06:57,020 --> 00:07:02,230
მოდით ასევე შეხედეთ რა ხდება თუ შევცვლით პირველი loop to არ შეჩერება N

94
00:07:02,230 --> 00:07:05,040
არამედ ვთქვა 10,000.

95
00:07:05,040 --> 00:07:07,430
გზა მიღმა ბოლოს მასივი.

96
00:07:14,700 --> 00:07:17,210
Oops. იქნებ ვხედავთ ამ ადრე.

97
00:07:17,210 --> 00:07:20,440
სეგმენტაცია ბრალია ნიშნავს, რომ თქვენი პროგრამა შეეჯახა.

98
00:07:20,440 --> 00:07:24,430
თქვენ იწყებთ ვხედავთ ამ როდესაც თქვენ შეეხოთ სფეროებში მეხსიერების თქვენ არ უნდა ეხება.

99
00:07:24,430 --> 00:07:27,870
აქ ჩვენ ეხება 10,000 ადგილების მიღმა დაწყების x,

100
00:07:27,870 --> 00:07:31,920
რაც აშკარად არის ადგილი მეხსიერებაში ჩვენ არ უნდა ეხება.

101
00:07:31,920 --> 00:07:37,690
ასე რომ ყველაზე მეტად ჩვენს ალბათ არ შემთხვევით დააყენა 10,000 ნაცვლად N,

102
00:07:37,690 --> 00:07:42,930
მაგრამ რა, თუ რაიმე უფრო დახვეწილი, როგორიც ვთქვათ, ჩაწერის ნაკლები ან ტოლია N

103
00:07:42,930 --> 00:07:46,830
in for loop მდგომარეობა განსხვავებით ნაკლები ნ

104
00:07:46,830 --> 00:07:50,100
გახსოვდეთ, რომ მასივი მხოლოდ ინდექსების საწყისი 0 დან N-1,

105
00:07:50,100 --> 00:07:54,510
რაც იმას ნიშნავს, რომ ინდექსი N სცილდება ბოლოს მასივი.

106
00:07:54,510 --> 00:07:58,050
პროგრამა შეიძლება არ ჩამოვარდნის ამ შემთხვევაში, მაგრამ მაინც შეცდომა.

107
00:07:58,050 --> 00:08:01,950
ფაქტობრივად, ეს შეცდომა იმდენად გავრცელებული, რომ მას აქვს საკუთარი სახელი,

108
00:08:01,950 --> 00:08:03,970
ეცხოვრათ 1 შეცდომა.

109
00:08:03,970 --> 00:08:05,970
>> სწორედ ეს საფუძვლები.

110
00:08:05,970 --> 00:08:09,960
რა არის ძირითადი განსხვავება 2 ტიპის მასივი დეკლარაციების?

111
00:08:09,960 --> 00:08:13,960
ერთი განსხვავება ის არის, სადაც დიდი ბლოკი მეხსიერება მიდის.

112
00:08:13,960 --> 00:08:17,660
პირველ დეკლარაციაში, რომელიც მე მოვუწოდებ bracket-array ტიპის,

113
00:08:17,660 --> 00:08:20,300
თუმცა ეს არ ნიშნავს პირობითი სახელი,

114
00:08:20,300 --> 00:08:22,480
ეს გაგრძელდება Stack.

115
00:08:22,480 --> 00:08:27,450
ხოლო მეორე, რომელიც მე მოვუწოდებ კურსორი-array ტიპის, ეს გაგრძელდება ბევრი.

116
00:08:27,450 --> 00:08:32,480
ეს იმას ნიშნავს, რომ როდესაც ფუნქცია დააბრუნებს, bracket მასივი ავტომატურად deallocated,

117
00:08:32,480 --> 00:08:36,419
ხოლო, როგორც თქვენ უნდა explicitily მოვუწოდებთ უფასოდ მაჩვენებელი მასივი

118
00:08:36,419 --> 00:08:38,010
ანდა თქვენ გაქვთ მეხსიერების გაჟონვის.

119
00:08:38,010 --> 00:08:42,750
გარდა ამისა, bracket მასივი არ არის რეალურად ცვლადი.

120
00:08:42,750 --> 00:08:45,490
ეს არის მნიშვნელოვანი. უბრალოდ სიმბოლოა.

121
00:08:45,490 --> 00:08:49,160
თქვენ შეგიძლიათ ვფიქრობ, რომ ეს მუდმივი რომ შემდგენელი ირჩევს თქვენთვის.

122
00:08:49,160 --> 00:08:52,970
ეს ნიშნავს, რომ ჩვენ არ შეგვიძლია გავაკეთოთ რაღაც x + + ერთად bracket ტიპის,

123
00:08:52,970 --> 00:08:56,240
თუმცა ეს შესანიშნავად მოქმედებს ერთად კურსორი ტიპის.

124
00:08:56,240 --> 00:08:58,270
>> მაჩვენებელი ტიპის ცვლადი.

125
00:08:58,270 --> 00:09:01,510
იყიდება მაჩვენებელი ტიპის, ჩვენ გვაქვს 2 ცალკე ბლოკები მეხსიერება.

126
00:09:01,510 --> 00:09:06,060
ცვლადი x თავად ინახება დასტის და არის მხოლოდ ერთი მაჩვენებელი,

127
00:09:06,060 --> 00:09:08,620
მაგრამ დიდი ბლოკი მეხსიერება ინახება ბევრი.

128
00:09:08,620 --> 00:09:11,010
ცვლადი x on დასტის მხოლოდ ინახავს მისამართი

129
00:09:11,010 --> 00:09:14,010
დიდი ბლოკი მეხსიერება შესახებ ბევრი.

130
00:09:14,010 --> 00:09:17,370
ერთი გავლენა ამ არის ერთად ზომის ოპერატორს.

131
00:09:17,370 --> 00:09:22,480
თუ თქვენ ეკითხებით ზომა bracket მასივი, ეს მოგცემთ ზომის დიდი ბლოკი მეხსიერება,

132
00:09:22,480 --> 00:09:24,620
რაღაც 40 ბაიტი,

133
00:09:24,620 --> 00:09:26,920
მაგრამ თუ თქვენ ეკითხებით ზომა კურსორის ტიპის მასივი,

134
00:09:26,920 --> 00:09:32,740
ეს მოგცემთ ზომის ცვლადი x თავად, რომელიც ელექტრო სავარაუდოდ მხოლოდ 4 ბაიტი.

135
00:09:32,740 --> 00:09:36,530
გამოყენება კურსორი-array ტიპის, შეუძლებელია პირდაპირ ითხოვენ

136
00:09:36,530 --> 00:09:38,530
ზომა დიდი ბლოკი მეხსიერება.

137
00:09:38,530 --> 00:09:42,530
ეს არ არის ჩვეულებრივ ბევრი შეზღუდვა რადგან ჩვენ ძალიან იშვიათად სურთ ზომა

138
00:09:42,530 --> 00:09:46,980
დიდი ბლოკი მეხსიერება, და ჩვენ შეგვიძლია გამოვთვალოთ ჩვეულებრივ, თუ ჩვენ სჭირდება.

139
00:09:46,980 --> 00:09:51,490
>> საბოლოოდ, bracket მასივი ხდება, მოგვაწოდოს მალსახმობი ამისთვის ინიციალიზაციისას მასივი.

140
00:09:51,490 --> 00:09:56,130
ვნახოთ, თუ როგორ შეეძლო დაეწერა პირველი 10 კი რიცხვებით გამოყენებით კომბინაცია initilization.

141
00:10:11,220 --> 00:10:14,470
ერთად კურსორი მასივი, არ არსებობს გზა ამის კომბინაცია მოსწონს ეს.

142
00:10:14,470 --> 00:10:18,120
ეს არის მხოლოდ შესავალი რა შეგიძლიათ გააკეთოთ ერთად მასივები.

143
00:10:18,120 --> 00:10:20,990
ისინი გამოჩნდება თითქმის ყველა პროგრამა წერთ.

144
00:10:20,990 --> 00:10:24,390
იმედია შეგიძლიათ ნახოთ უკეთესი გზა კეთების სტუდენტი პირადობის მოწმობები მაგალითად

145
00:10:24,390 --> 00:10:26,710
დასაწყისიდან ვიდეო.

146
00:10:26,710 --> 00:10:29,960
>> ჩემი სახელი არის რობ Bowden, და ეს არის CS50.