1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [მიმოხილვა] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [ძაან მაგარი Ross, ტომი MacWilliam, Lucas Freitas, ჯოზეფ Ong] [ჰარვარდის უნივერსიტეტის]

3
00:00:05,000 --> 00:00:08,000
>> [ეს არის CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hey, ყველას.

5
00:00:10,000 --> 00:00:15,000
კეთილი იყოს განხილვის სხდომაზე Quiz 0, რომელსაც ადგილი ამ ოთხშაბათს.

6
00:00:15,000 --> 00:00:19,000
რა ჩვენ ვაპირებთ ამაღამ, მე 3 სხვა TFs,

7
00:00:19,000 --> 00:00:24,000
და ერთად ჩვენ ვაპირებთ გავლა მიმოხილვას, რაც ჩვენ გავაკეთეთ მსვლელობისას ჯერჯერობით.

8
00:00:24,000 --> 00:00:27,000
ეს არ იქნება 100% სრულყოფილი, მაგრამ ეს უნდა გადმოგცეთ უკეთესი იდეა

9
00:00:27,000 --> 00:00:31,000
თუ რა თქვენ უკვე გაქვთ ქვემოთ და რა თქვენ კვლავ უნდა შეისწავლოს ადრე ოთხშაბათი.

10
00:00:31,000 --> 00:00:34,000
და მოგერიდებათ გაზარდოთ თქვენი მხრივ, კითხვები, როგორც ჩვენ ვაპირებთ გასწვრივ,

11
00:00:34,000 --> 00:00:38,000
მაგრამ გახსოვდეთ, რომ ჩვენ ასევე გვაქვს ცოტა დრო დასასრულს-

12
00:00:38,000 --> 00:00:41,000
თუ მივიღებთ მეშვეობით რამდენიმე წუთში სათადარიგო-გავაკეთოთ ზოგადი კითხვები,

13
00:00:41,000 --> 00:00:47,000
გააგრძელეთ, რომ გონება, და ამიტომ ჩვენ ვაპირებთ იწყება იწყება კვირა 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 მიმოხილვა] [Part 0] [ძაან მაგარი Ross] მაგრამ სანამ ჩვენ გავაკეთებთ, რომ ვისაუბროთ იმაზე

15
00:00:50,000 --> 00:00:53,000
ლოგისტიკის ინტელექტუალური.

16
00:00:53,000 --> 00:00:55,000
>> [ლოგისტიკის] [Quiz ხდება ოთხშაბათს 10/10 ნაცვლად ლექცია]

17
00:00:55,000 --> 00:00:57,000
>> [(იხილეთ http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf დეტალებისთვის)] ეს ოთხშაბათს, 10 ოქტომბერს.

18
00:00:57,000 --> 00:01:00,000
>> სწორედ ამ ოთხშაბათს, და თუ ამ URL აქ,

19
00:01:00,000 --> 00:01:03,000
რაც ასევე ხელმისაწვდომი CS50.net-იქ ბმული it-

20
00:01:03,000 --> 00:01:06,000
ხედავთ ინფორმაციას სად ეფუძნება

21
00:01:06,000 --> 00:01:10,000
თქვენი გვარი ან სკოლის კუთვნილების ასევე

22
00:01:10,000 --> 00:01:14,000
იგი მოგვითხრობს, თუ რა ინტელექტუალური დაფარავს და სახის კითხვებით, რომ თქვენ აპირებს მიიღოს.

23
00:01:14,000 --> 00:01:19,000
გაითვალისწინეთ, რომ თქვენ ასევე აქვს შანსი რეცენზია Quiz ნაწილში,

24
00:01:19,000 --> 00:01:21,000
ასე რომ თქვენი TFs უნდა აპირებს მეტი გარკვეული პრაქტიკის პრობლემები,

25
00:01:21,000 --> 00:01:29,000
და ეს კიდევ ერთი კარგი შანსი, რომ ნახოთ სადაც თქვენ მაინც უნდა შეისწავლოს up for ვიქტორინა.

26
00:01:29,000 --> 00:01:32,000
დავიწყოთ დასაწყისში ერთად Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
დამახსოვრება bit მხოლოდ 0 ან 1,

28
00:01:35,000 --> 00:01:38,000
და byte არის კოლექცია 8 იმ ბიტი.

29
00:01:38,000 --> 00:01:42,000
მოდით შევხედოთ ამ კოლექცია ბიტი უფლება აქ.

30
00:01:42,000 --> 00:01:44,000
ჩვენ უნდა შეეძლოს გაერკვნენ რამდენი ბიტი არსებობს.

31
00:01:44,000 --> 00:01:48,000
სადაც ჩვენ ითვლიან არსებობს მხოლოდ 8 მათგანი, რვა 0 ან 1 ერთეული.

32
00:01:48,000 --> 00:01:51,000
და რადგან იქ 8 ბიტი, რომ 1 ნაწილად,

33
00:01:51,000 --> 00:01:53,000
და მოდით კონვერტირება მას თექვსმეტობითი.

34
00:01:53,000 --> 00:01:58,000
თექვსმეტობითი არის ბაზა 16, და ეს საკმაოდ ადვილი დააკონვერტიროთ

35
00:01:58,000 --> 00:02:01,000
ნომერი ორობითი, რაც რომ არის, რომ ნომერი თექვსმეტობითი.

36
00:02:01,000 --> 00:02:04,000
ყველა ვაკეთებთ არის შევხედავთ ჯგუფების 4,

37
00:02:04,000 --> 00:02:07,000
და ჩვენ კონვერტირება მათ შესაბამისი თექვსმეტობითი ციფრი.

38
00:02:07,000 --> 00:02:11,000
ჩვენ დავიწყებთ მარჯვენა საუკეთესო ჯგუფის 4, ამიტომ 0011.

39
00:02:11,000 --> 00:02:16,000
რომ იქნება ერთი 1 და ერთი 2, ასე ერთად რომ აკეთებს 3.

40
00:02:16,000 --> 00:02:19,000
და მაშინ მოდით შევხედოთ სხვა ბლოკი 4.

41
00:02:19,000 --> 00:02:24,000
1101. რომ იქნება ერთი 1, ერთი 4, და ერთი 8.

42
00:02:24,000 --> 00:02:28,000
ერთად რომ იქნება 13, რაც დ

43
00:02:28,000 --> 00:02:32,000
და ჩვენ გვახსოვს, რომ თექვსმეტობითი ჩვენ არ უბრალოდ 0 მეშვეობით 9.

44
00:02:32,000 --> 00:02:36,000
ჩვენ წავიდეთ 0 მეშვეობით F, ასე შემდეგ 9, 10 შეესაბამება,

45
00:02:36,000 --> 00:02:40,000
11 დან B, et cetera, სადაც F არის 15.

46
00:02:40,000 --> 00:02:44,000
აქ არის 13 D,

47
00:02:44,000 --> 00:02:49,000
ასე გარდაქმნას იგი ათობითი ყველა ვაკეთებთ ჩვენ რეალურად

48
00:02:49,000 --> 00:02:52,000
მკურნალობა თითოეული პოზიცია, როგორც ძალა 2.

49
00:02:52,000 --> 00:02:58,000
სწორედ ერთ 1 ერთი 2, ნულოვანი 4S, ნულოვანი 8S, ერთი 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
და ეს პატარა მძიმე გამოთვლაც თქვენს უფროსს, მაგრამ თუ ჩვენ გადასვლა შემდეგ slide

51
00:03:03,000 --> 00:03:05,000
ვხედავთ პასუხი რომ.

52
00:03:05,000 --> 00:03:09,000
>> არსებითად ჩვენ ვაპირებთ მოპირდაპირე უფლება უკან მარცხნივ,

53
00:03:09,000 --> 00:03:14,000
და ჩვენ გამრავლებით თითოეული ციფრი შესაბამისი ძალა 2.

54
00:03:14,000 --> 00:03:19,000
და მახსოვს, ამისთვის თექვსმეტობითი ჩვენ აღინიშნოს ამ ნომრები 0x დასაწყისში

55
00:03:19,000 --> 00:03:23,000
ასე რომ, ჩვენ არ აღრეული შინაარსობრივი თვალსაზრისით, ათობითი რიცხვი.

56
00:03:23,000 --> 00:03:29,000
გაგრძელებით, ეს ASCII მაგიდა,

57
00:03:29,000 --> 00:03:35,000
და რა ჩვენ ვიყენებთ ASCII ამისთვის არის MAP-დან პერსონაჟს რიცხვითი ღირებულებებს.

58
00:03:35,000 --> 00:03:39,000
მახსოვს კრიპტოგრაფიის pset მივიღეთ ფართო გამოყენების ASCII მაგიდა

59
00:03:39,000 --> 00:03:43,000
რათა სხვადასხვა მეთოდების გამოყენება კრიპტოგრაფიის,

60
00:03:43,000 --> 00:03:47,000
Caesar და Vigenère cipher, გადაიყვანოთ სხვადასხვა წერილებს

61
00:03:47,000 --> 00:03:52,000
in string მიხედვით გასაღები მოცემული მომხმარებლის მიერ.

62
00:03:52,000 --> 00:03:56,000
მოდით შევხედოთ ცოტა ASCII მათემატიკის.

63
00:03:56,000 --> 00:04:02,000
ეძებს 'P' + 1, ხასიათს ფორმა იქნებოდა Q,

64
00:04:02,000 --> 00:04:07,000
და გვახსოვდეს, რომ '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
და როგორ ზუსტად რომ ჩვენ დააკონვერტიროთ შორის 2 ფორმები?

66
00:04:10,000 --> 00:04:13,000
ეს არ არის რეალურად ძალიან ძნელი.

67
00:04:13,000 --> 00:04:16,000
იმისათვის, რომ მიიღოთ 5 ჩვენ სხვაობა '0 '

68
00:04:16,000 --> 00:04:20,000
რადგან არსებობს 5 ადგილებში შორის '0 'და '5'.

69
00:04:20,000 --> 00:04:23,000
იმისათვის, რომ წავიდეს სხვა გზა ჩვენ უბრალოდ დაამატოთ 0,

70
00:04:23,000 --> 00:04:25,000
ამიტომ სახის მოსწონს რეგულარული არითმეტიკული.

71
00:04:25,000 --> 00:04:29,000
უბრალოდ გვახსოვდეს, რომ როცა რაიმე აქვს შეთავაზებები გარშემო ის ხასიათი

72
00:04:29,000 --> 00:04:37,000
და ამით შეესაბამება ღირებულების ASCII მაგიდასთან.

73
00:04:37,000 --> 00:04:40,000
მოძრავი შევიდა უფრო ზოგადი კომპიუტერულ მეცნიერებათა თემები.

74
00:04:40,000 --> 00:04:43,000
ჩვენ გავიგეთ რა არის ალგორითმი და როგორ ვიყენებთ პროგრამირების

75
00:04:43,000 --> 00:04:45,000
განახორციელოს ალგორითმები.

76
00:04:45,000 --> 00:04:48,000
მაგალითები ალგორითმები მართლაც რაღაც მარტივი მოსწონს

77
00:04:48,000 --> 00:04:51,000
შემოწმების თუ არა რიცხვი კი ან უცნაური.

78
00:04:51,000 --> 00:04:54,000
ამისათვის ჩვენ გვახსოვს mod ნომერი მიერ 2 და შეამოწმოთ, თუ შედეგი არის 0.

79
00:04:54,000 --> 00:04:57,000
თუ ასეა, ეს კი. თუ არა, ეს უცნაური.

80
00:04:57,000 --> 00:04:59,000
და ეს მაგალითი ნამდვილად ძირითადი ალგორითმი.

81
00:04:59,000 --> 00:05:02,000
>> ცოტა მეტი ჩართული ერთი არის ორობითი ძებნა,

82
00:05:02,000 --> 00:05:05,000
რაც ჩვენ წავიდეთ მეტი მოგვიანებით საანგარიშო სხდომამდე.

83
00:05:05,000 --> 00:05:09,000
და პროგრამირების არის ტერმინი ჩვენ ვიყენებთ აღების ალგორითმი

84
00:05:09,000 --> 00:05:15,000
და კონვერტაცია მას კოდი კომპიუტერი წაიკითხოს.

85
00:05:15,000 --> 00:05:20,000
2 მაგალითები პროგრამირების არის Scratch,

86
00:05:20,000 --> 00:05:22,000
რაც ჩვენ გააკეთა კვირა 0.

87
00:05:22,000 --> 00:05:25,000
მიუხედავად იმისა, რომ ჩვენ არ რეალურად აკრიფოთ გარეთ კოდი ეს გზა განხორციელების

88
00:05:25,000 --> 00:05:29,000
ეს ალგორითმი, რომელიც დაბეჭდვის ნომრები 1-10,

89
00:05:29,000 --> 00:05:32,000
და აქ ჩვენ გავაკეთებთ იგივეს C პროგრამირების ენაზე.

90
00:05:32,000 --> 00:05:41,000
ეს არის ფუნქციურად ექვივალენტური, მხოლოდ წერილობითი სხვადასხვა ენებზე ან სინტაქსი.

91
00:05:41,000 --> 00:05:44,000
ჩვენ მაშინ შეიტყო ლოგიკური გამოთქმები,

92
00:05:44,000 --> 00:05:48,000
და ლოგიკური არის ღირებულება, რომელიც არის ან ნამდვილი ან ყალბი,

93
00:05:48,000 --> 00:05:51,000
და აქ oftentimes ლოგიკური გამონათქვამები

94
00:05:51,000 --> 00:05:55,000
წასვლა შიგნით პირობები ასე რომ, თუ (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
ასევე, ჩვენ უკვე მითითებული x = 5, ასე რომ მდგომარეობა აპირებს შეაფასოს ჭეშმარიტი.

96
00:06:00,000 --> 00:06:03,000
და თუ ეს ასეა, რასაც კოდი არის ქვეშ მდგომარეობა

97
00:06:03,000 --> 00:06:08,000
აპირებს შეფასდება კომპიუტერი, ასე, რომ სიმებიანი აპირებს დაიბეჭდება

98
00:06:08,000 --> 00:06:12,000
სტანდარტულ output, და ტერმინი მდგომარეობა

99
00:06:12,000 --> 00:06:16,000
ეხება რაც შიგნით ფრჩხილებში of თუ განცხადებაში.

100
00:06:16,000 --> 00:06:20,000
დამახსოვრება ყველა ოპერატორები.

101
00:06:20,000 --> 00:06:26,000
დამახსოვრება მისი && და | | როდესაც ჩვენ ვცდილობთ დააკავშიროთ 2 ან მეტი პირობები,

102
00:06:26,000 --> 00:06:30,000
== არ = რათა შეამოწმოს თუ არა 2 რამ თანაბარი.

103
00:06:30,000 --> 00:06:36,000
გახსოვდეთ, რომ = არის დავალება ხოლო == არის ლოგიკური ოპერატორი.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ და შემდეგ საბოლოო 2 are თვითმმართველობის განმარტებითი.

105
00:06:41,000 --> 00:06:45,000
ზოგადი მიმოხილვა ლოგიკური ლოგიკა აქ.

106
00:06:45,000 --> 00:06:48,000
და ლოგიკური გამონათქვამები ასევე მნიშვნელოვანია მარყუჟების,

107
00:06:48,000 --> 00:06:50,000
რაც ჩვენ წავიდეთ მეტი არის.

108
00:06:50,000 --> 00:06:56,000
ჩვენ შეიტყო 3 სახის მარყუჟების ამ დრომდე CS50, ამისთვის, ხოლო, და ნუ ხოლო.

109
00:06:56,000 --> 00:06:59,000
და მნიშვნელოვანია იცოდეს, რომ სანამ ყველაზე მიზნებისათვის

110
00:06:59,000 --> 00:07:02,000
ჩვენ შეგვიძლია რეალურად გამოიყენოს ნებისმიერი ტიპის loop ზოგადად

111
00:07:02,000 --> 00:07:06,000
არსებობს გარკვეული სახის მიზნებისათვის ან საერთო თარგების

112
00:07:06,000 --> 00:07:09,000
პროგრამირებაში რომ კონკრეტულად მოვუწოდებთ ერთი ამ მარყუჟების

113
00:07:09,000 --> 00:07:13,000
რომ ეს ყველაზე ეფექტური ან ელეგანტური, რათა კოდექსის ის, რომ გზა.

114
00:07:13,000 --> 00:07:18,000
მოდით წავიდეთ მეტი რა თითოეულ ამ მარყუჟების tends გამოიყენება ყველაზე ხშირად.

115
00:07:18,000 --> 00:07:21,000
>> In for loop ჩვენ ზოგადად უკვე ვიცით რამდენჯერ გვინდა iterate.

116
00:07:21,000 --> 00:07:24,000
რაც ჩვენ პირობებში.

117
00:07:24,000 --> 00:07:28,000
ამისთვის, i = 0, I <10, მაგალითად.

118
00:07:28,000 --> 00:07:31,000
ჩვენ უკვე კარგად ვიცით, რომ ჩვენ გვინდა რაღაც 10 ჯერ.

119
00:07:31,000 --> 00:07:34,000
ახლა, ცოტა ხნით მარყუჟის, ზოგადად ჩვენ არ ემთხვეოდეს

120
00:07:34,000 --> 00:07:36,000
ვიცი რამდენჯერ გვინდა loop გასაშვებად.

121
00:07:36,000 --> 00:07:39,000
მაგრამ ჩვენ ვიცით, გარკვეული პირობით, რომ ჩვენ გვსურს

122
00:07:39,000 --> 00:07:41,000
ყოველთვის იყოს ჭეშმარიტი ან ყოველთვის იქნება ყალბი.

123
00:07:41,000 --> 00:07:44,000
მაგალითად, მაშინ, როდესაც არ არის მითითებული.

124
00:07:44,000 --> 00:07:46,000
ვთქვათ რომ ლოგიკური ცვლადი.

125
00:07:46,000 --> 00:07:48,000
მიუხედავად იმისა, რომ მართალია ჩვენ გვინდა კოდი შესაფასებლად,

126
00:07:48,000 --> 00:07:52,000
ასე ცოტა მეტი გააფართოვოთ, ცოტა უფრო ზოგადი ვიდრე ამისთვის მარყუჟის,

127
00:07:52,000 --> 00:07:55,000
მაგრამ ნებისმიერი ამისთვის loop ასევე შეიძლება მოაქცია ხოლო loop.

128
00:07:55,000 --> 00:08:00,000
საბოლოოდ, ნუ ხოლო მარყუჟების, რომელიც შეიძლება trickiest აღქმა დაუყოვნებლივ,

129
00:08:00,000 --> 00:08:04,000
ხშირად გამოიყენება, როდესაც ჩვენ გვინდა შევაფასოთ კოდი პირველი

130
00:08:04,000 --> 00:08:06,000
სანამ პირველად ჩვენ შეამოწმოს მდგომარეობა.

131
00:08:06,000 --> 00:08:09,000
საერთო სარგებლობის შემთხვევაში გააკეთოს ხოლო loop

132
00:08:09,000 --> 00:08:12,000
როდესაც გსურთ მიიღოთ მომხმარებლის input, და თქვენ იცით, თქვენ მინდა ვკითხო მომხმარებლის

133
00:08:12,000 --> 00:08:15,000
ამისთვის შეყვანის ერთხელ მაინც, მაგრამ თუ ისინი არ მოგცემთ კარგი შეყვანის დაუყოვნებლივ

134
00:08:15,000 --> 00:08:18,000
დატოვება გსურთ სთხოვს, სანამ ისინი მოგცემთ კარგი შეყვანის.

135
00:08:18,000 --> 00:08:21,000
სწორედ ყველაზე გავრცელებული გამოყენების ნუ ხოლო მარყუჟის,

136
00:08:21,000 --> 00:08:23,000
და მოდით შევხედოთ რეალურ სტრუქტურას ამ მარყუჟების.

137
00:08:23,000 --> 00:08:27,000
ისინი, როგორც წესი, ყოველთვის ტენდენცია მოჰყვება ამ შაბლონებს.

138
00:08:27,000 --> 00:08:30,000
>> On ამისთვის loop შიგნით თქვენ 3 კომპონენტი:

139
00:08:30,000 --> 00:08:35,000
ინიციალიზაციისას, როგორც წესი, მსგავსი რამ int i = 0, სადაც მე არის Counter,

140
00:08:35,000 --> 00:08:40,000
მდგომარეობა, სადაც ჩვენ გვინდა ვთქვათ აწარმოებს ამ loop რადგან ამ მდგომარეობა კვლავ ფლობს,

141
00:08:40,000 --> 00:08:44,000
მოსწონს I <10, ხოლო შემდეგ საბოლოოდ, განახლება, რომელიც არის როგორ ჩვენ ნამატი

142
00:08:44,000 --> 00:08:47,000
Counter ცვლადი ყოველ წერტილი loop.

143
00:08:47,000 --> 00:08:50,000
საერთო რამ დაინახოს არსებობს მხოლოდ მე + +,

144
00:08:50,000 --> 00:08:52,000
რაც იმას ნიშნავს, ნამატი მე მიერ 1 ყოველ ჯერზე.

145
00:08:52,000 --> 00:08:55,000
თქვენ შეიძლება ასევე რაღაც მოსწონს i + = 2,

146
00:08:55,000 --> 00:08:58,000
რაც იმას ნიშნავს, დაამატოთ 2 დან მე ყოველ დროს, თქვენ გავლა loop.

147
00:08:58,000 --> 00:09:03,000
და შემდეგ ამის გაკეთება მხოლოდ ეხება რაიმე კოდი, რომელიც რეალურად მუშაობს როგორც ნაწილი loop.

148
00:09:03,000 --> 00:09:09,000
და ცოტა ხნით მარყუჟის, ამ დროს ჩვენ რეალურად ინიციალიზაციისას გარეთ მარყუჟის,

149
00:09:09,000 --> 00:09:12,000
ასე მაგალითად, ვთქვათ ჩვენ ცდილობს იგივე ტიპის loop როგორც მე უბრალოდ აღწერილი.

150
00:09:12,000 --> 00:09:16,000
ჩვენ ვიტყოდი int i = 0 ადრე loop იწყება.

151
00:09:16,000 --> 00:09:20,000
მაშინ შეიძლება ითქვას, ხოლო I <10 ამის გაკეთება,

152
00:09:20,000 --> 00:09:22,000
ასე იგივე ბლოკი კოდი როგორც ადრე,

153
00:09:22,000 --> 00:09:26,000
და ამ დროს update ნაწილი კოდი, მაგალითად, მე + +,

154
00:09:26,000 --> 00:09:29,000
რეალურად მიდის შიგნით loop.

155
00:09:29,000 --> 00:09:33,000
და ბოლოს, ამისთვის გააკეთებს ხოლო, ის მსგავსია, ხოლო მარყუჟის,

156
00:09:33,000 --> 00:09:36,000
მაგრამ ჩვენ უნდა გვახსოვდეს, რომ კოდი შეაფასებს ერთხელ

157
00:09:36,000 --> 00:09:40,000
სანამ მდგომარეობა შემოწმება, ასე რომ ხდის უფრო გრძნობა

158
00:09:40,000 --> 00:09:44,000
თუ გადავხედავთ ეს გამოიტანს ყველაზე ქვედა.

159
00:09:44,000 --> 00:09:49,000
In გავაკეთოთ ხოლო loop კოდი აფასებს თქვენს წინაშე კი შევხედოთ ხოლო მდგომარეობა,

160
00:09:49,000 --> 00:09:55,000
ხოლო ხოლო მარყუჟის, ის ამოწმებს პირველი.

161
00:09:55,000 --> 00:09:59,000
განცხადებები და ცვლადები.

162
00:09:59,000 --> 00:10:04,000
როდესაც ჩვენ გვინდა შევქმნათ ახალი ცვლადი ჩვენ გვინდა პირველი ინიციალიზაცია იგი.

163
00:10:04,000 --> 00:10:07,000
>> მაგალითად, int ბარი ველში ცვლადი ბარი,

164
00:10:07,000 --> 00:10:10,000
მაგრამ ეს არ აძლევს მას ღირებულება, ასე რომ რა არის ბარი ღირებულების არის?

165
00:10:10,000 --> 00:10:12,000
ჩვენ არ ვიცით.

166
00:10:12,000 --> 00:10:14,000
ეს შეიძლება იყოს რაღაც ნაგავი ღირებულება, რომელიც ადრე შენახული მეხსიერების იქ,

167
00:10:14,000 --> 00:10:16,000
და ჩვენ არ გვინდა, რომ გამოიყენოს ცვალებად

168
00:10:16,000 --> 00:10:19,000
სანამ ჩვენ რეალურად მისცეს მას ღირებულება,

169
00:10:19,000 --> 00:10:21,000
ამიტომ ვაცხადებთ აქ.

170
00:10:21,000 --> 00:10:24,000
მაშინ ჩვენ ინიციალიზაცია, რომ იყოს 42 ქვემოთ.

171
00:10:24,000 --> 00:10:28,000
ახლა, რა თქმა უნდა, ჩვენ ვიცით, ეს შეიძლება გაკეთდეს ერთ ხაზს, int ბარი = 42.

172
00:10:28,000 --> 00:10:30,000
მაგრამ მხოლოდ იმიტომ, რომ განვმარტო მრავალჯერადი ნაბიჯებს, რომლებიც მიმდინარეობს,

173
00:10:30,000 --> 00:10:34,000
დეკლარაციის და ინიციალიზაციისას ხდება ცალკე აქ.

174
00:10:34,000 --> 00:10:38,000
ეს ხდება ერთ ნაბიჯს და შემდეგი ერთი, int baz = ბარი + 1,

175
00:10:38,000 --> 00:10:44,000
ამ განცხადებას ქვემოთ, რომ increments baz, ასე დასასრულს ამ კოდექსის ბლოკი

176
00:10:44,000 --> 00:10:48,000
თუ ჩვენ უნდა ბეჭდვა ღირებულება baz იქნებოდა 44

177
00:10:48,000 --> 00:10:52,000
იმიტომ, რომ ჩვენ ვაცხადებთ და ვრთავ, რომ იყოს 1> ბარი,

178
00:10:52,000 --> 00:10:58,000
და მაშინ ჩვენ ნამატი კიდევ ერთხელ ერთად + +.

179
00:10:58,000 --> 00:11:02,000
წავედით ამ საკმაოდ მოკლედ, მაგრამ კარგია, რომ გვქონდეს ზოგადად

180
00:11:02,000 --> 00:11:04,000
გაგება, თუ რა თემა და მოვლენები.

181
00:11:04,000 --> 00:11:06,000
ჩვენ ძირითადად ეს იმ Scratch,

182
00:11:06,000 --> 00:11:09,000
ასე რომ თქვენ შეგიძლიათ წარმოიდგინოთ, რომ თემა როგორც მრავალჯერადი sequences of კოდი

183
00:11:09,000 --> 00:11:11,000
გაშვებული ამავე დროს.

184
00:11:11,000 --> 00:11:14,000
რეალურად, ეს ალბათ არ არის გაშვებული, ამავე დროს,

185
00:11:14,000 --> 00:11:17,000
მაგრამ სახის აბსტრაქტულად შეგვიძლია ვიფიქროთ, ის, რომ გზა.

186
00:11:17,000 --> 00:11:20,000
>> In Scratch, მაგალითად, ჩვენ გვქონდა მრავალი sprites.

187
00:11:20,000 --> 00:11:22,000
შეიძლება შესრულებაში სხვადასხვა კოდი, ამავე დროს.

188
00:11:22,000 --> 00:11:26,000
ერთი შეიძლება ფეხით ხოლო მეორე ამბობს, რაღაც

189
00:11:26,000 --> 00:11:29,000
სხვადასხვა ნაწილი ეკრანზე.

190
00:11:29,000 --> 00:11:34,000
მოვლენები კიდევ ერთი გზა ჰყოფს გარეთ ლოგიკა

191
00:11:34,000 --> 00:11:37,000
შორის სხვადასხვა ელემენტები თქვენი კოდი,

192
00:11:37,000 --> 00:11:40,000
და Scratch შევძელით სიმულაცია მოვლენების გამოყენებით სამაუწყებლო,

193
00:11:40,000 --> 00:11:43,000
და რომ სინამდვილეში როდესაც მივიღო, არ როდესაც მესმის,

194
00:11:43,000 --> 00:11:47,000
მაგრამ არსებითად ეს გზა გადასცეს ინფორმაცია

195
00:11:47,000 --> 00:11:49,000
ერთი Sprite სხვა.

196
00:11:49,000 --> 00:11:52,000
მაგალითად, შეგიძლიათ გადასცემს თამაშის გამო,

197
00:11:52,000 --> 00:11:56,000
და როდესაც მეორე Sprite იღებს თამაშის გამო,

198
00:11:56,000 --> 00:11:58,000
იგი პასუხობს გარკვეული გზა.

199
00:11:58,000 --> 00:12:03,000
ეს მნიშვნელოვანია მოდელის გვესმოდეს, პროგრამირების.

200
00:12:03,000 --> 00:12:07,000
უბრალოდ წასვლა მეტი ძირითადი კვირა 0, რა ჩვენ წავიდა მეტი ჯერჯერობით

201
00:12:07,000 --> 00:12:10,000
მოდით შევხედოთ ამ მარტივი C პროგრამა.

202
00:12:10,000 --> 00:12:14,000
ტექსტი შეიძლება იყოს ცოტა პატარა აქედან, მაგრამ მე წასვლა მას ნამდვილად სწრაფი.

203
00:12:14,000 --> 00:12:20,000
ჩვენ მათ შორის 2 header ფაილი ზედა, cs50.h და stdio.h.

204
00:12:20,000 --> 00:12:23,000
ჩვენ მაშინ განსაზღვრის მუდმივი მოუწოდა ლიმიტი იყოს 100.

205
00:12:23,000 --> 00:12:26,000
ჩვენ მაშინ ახორციელებს ჩვენი მთავარი ფუნქცია.

206
00:12:26,000 --> 00:12:29,000
მას შემდეგ, რაც ჩვენ არ ვიყენებთ command line არგუმენტები აქ ჩვენ უნდა დააყენოს ბათილად

207
00:12:29,000 --> 00:12:32,000
როგორც არგუმენტები ძირითადი.

208
00:12:32,000 --> 00:12:38,000
ჩვენ ვხედავთ, int ზემოთ ძირითადი. სწორედ დაბრუნების ტიპის, შესაბამისად დაბრუნებას 0 ბოლოში.

209
00:12:38,000 --> 00:12:41,000
და ჩვენ გამოყენებით CS50 ბიბლიოთეკის ფუნქცია კიდევ int

210
00:12:41,000 --> 00:12:45,000
ვთხოვო მომხმარებლის ამისთვის შეყვანის და ჩვენ ჩაწეროთ იგი ამ ცვლადი x,

211
00:12:45,000 --> 00:12:51,000
ამიტომ ვაცხადებთ x ზემოთ და ჩვენ ინიციალიზაცია იგი x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> ჩვენ მაშინ შეამოწმეთ, რომ მომხმარებლის მოგვცა კარგი შეყვანის.

213
00:12:53,000 --> 00:12:59,000
თუ ეს ≥ LIMIT გვინდა დაბრუნების შეცდომის კოდი 1 და ბეჭდვა შეცდომა.

214
00:12:59,000 --> 00:13:02,000
და ბოლოს, თუ მომხმარებლის მოგვცა კარგი შეყვანის

215
00:13:02,000 --> 00:13:08,000
ჩვენ ვაპირებთ მოედანზე ნომერი და ბეჭდვა, რომ შედეგი.

216
00:13:08,000 --> 00:13:11,000
უბრალოდ, დარწმუნდით, რომ ის ყველა Hit მთავარი

217
00:13:11,000 --> 00:13:17,000
ხედავთ ეტიკეტები სხვადასხვა ნაწილების კოდი აქ.

218
00:13:17,000 --> 00:13:19,000
აღვნიშნე მუდმივი, header ფაილი.

219
00:13:19,000 --> 00:13:21,000
ოჰ, int x. დარწმუნდით გვახსოვდეს, რომ ადგილობრივი ცვლადი.

220
00:13:21,000 --> 00:13:24,000
რომ კონტრასტს ის გლობალური ცვლადი, რომელიც ჩვენ ვსაუბრობთ

221
00:13:24,000 --> 00:13:27,000
ცოტა მოგვიანებით საანგარიშო სხდომამდე,

222
00:13:27,000 --> 00:13:30,000
და ჩვენ გთხოვთ ბიბლიოთეკის ფუნქცია printf,

223
00:13:30,000 --> 00:13:34,000
ასე რომ, თუ ჩვენ არ შედის stdio.h header ფაილი

224
00:13:34,000 --> 00:13:37,000
ჩვენ ვერ მოვუწოდებთ printf.

225
00:13:37,000 --> 00:13:42,000
და მე მჯერა, რომ arrow გაბმულ შეწყვიტა აქ მიუთითებს% d,

226
00:13:42,000 --> 00:13:45,000
რაც გაფორმებით string in printf.

227
00:13:45,000 --> 00:13:52,000
განცხადებაში ნათქვამია, ამობეჭდოთ ეს ცვლადი როგორც ნომერი,% d.

228
00:13:52,000 --> 00:13:58,000
და სწორედ ეს კვირა 0.

229
00:13:58,000 --> 00:14:06,000
ახლა ლუკას აპირებს გააგრძელოს.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. ჩემი სახელი არის ლუკასი.

231
00:14:08,000 --> 00:14:10,000
მე მეორე საუკეთესო სახლში კამპუსში, Mather,

232
00:14:10,000 --> 00:14:14,000
და მე ვაპირებ გაიგო ცოტა შესახებ კვირა 1 და 2.1.

233
00:14:14,000 --> 00:14:16,000
[კვირა 1 და 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
როგორც ძაან მაგარი ამბობდა, როდესაც ჩვენ დავიწყეთ თარგმნა თქვენი კოდი ნულიდან to C

235
00:14:19,000 --> 00:14:23,000
ერთი რამ, რომ ჩვენ შენიშნა ისაა, რომ თქვენ არა მხოლოდ

236
00:14:23,000 --> 00:14:26,000
დაწეროთ თქვენი კოდი და გაუშვით გამოყენებით მწვანე დროშა უქმნით.

237
00:14:26,000 --> 00:14:30,000
სინამდვილეში, თქვენ უნდა გამოიყენოთ ზოგიერთ ნაბიჯს, რათა თქვენი C პროგრამის

238
00:14:30,000 --> 00:14:33,000
გახდეს შესრულებად ფაილს.

239
00:14:33,000 --> 00:14:36,000
ძირითადად, თუ რას აკეთებთ თქვენ პროგრამის წერა ის არის, რომ

240
00:14:36,000 --> 00:14:40,000
თქვენ თარგმნოს თქვენი იდეა შევიდა ენა რომ შემდგენელი მესმის,

241
00:14:40,000 --> 00:14:44,000
ასე რომ, როდესაც თქვენ წერილობით პროგრამა C

242
00:14:44,000 --> 00:14:47,000
თუ რას აკეთებს რეალურად წერა რაღაც რომ თქვენი შემდგენელი აპირებს მესმის,

243
00:14:47,000 --> 00:14:50,000
და მაშინ კომპილატორი აპირებს თარგმნოს, რომ კოდი

244
00:14:50,000 --> 00:14:53,000
შევიდა რაღაც, რომ თქვენს კომპიუტერში მიხვდება.

245
00:14:53,000 --> 00:14:55,000
>> და ის კი, კომპიუტერი ძალიან მუნჯები.

246
00:14:55,000 --> 00:14:57,000
თქვენს კომპიუტერში შეიძლება მხოლოდ მესმის 0S და 1s,

247
00:14:57,000 --> 00:15:01,000
ასე რეალურად პირველ კომპიუტერები ხალხი ჩვეულებრივ პროგრამირდება

248
00:15:01,000 --> 00:15:04,000
გამოყენებით 0S და 1s, მაგრამ აღარ, მადლობა ღმერთს.

249
00:15:04,000 --> 00:15:07,000
ჩვენ არ უნდა გვემახსოვრება sequences for 0S და 1s

250
00:15:07,000 --> 00:15:10,000
ამისთვის ამისთვის მარყუჟი ან ხოლო მარყუჟის და ასე შემდეგ.

251
00:15:10,000 --> 00:15:13,000
ამიტომ ჩვენ გვაქვს შემდგენელი.

252
00:15:13,000 --> 00:15:17,000
რა შემდგენელი არ არის ეს ძირითადად ითარგმნება C კოდი,

253
00:15:17,000 --> 00:15:21,000
ჩვენს შემთხვევაში, რომ ენა, რომ თქვენს კომპიუტერში მიხვდება,

254
00:15:21,000 --> 00:15:25,000
რომელიც ობიექტის კოდი და შემდგენელი რომ ჩვენ გამოყენებით

255
00:15:25,000 --> 00:15:30,000
ეწოდება clang, ამიტომ ეს არის რეალურად სიმბოლო clang.

256
00:15:30,000 --> 00:15:33,000
როდესაც თქვენ გაქვთ თქვენი პროგრამა, თქვენ უნდა გააკეთოთ 2 რამ.

257
00:15:33,000 --> 00:15:37,000
პირველი, თქვენ უნდა დააკომპილიროთ თქვენი პროგრამა, და მერე ვაპირებთ აწარმოებს თქვენი პროგრამის.

258
00:15:37,000 --> 00:15:41,000
შედგენა თქვენი პროგრამის გაქვთ უამრავი პარამეტრები ამისათვის.

259
00:15:41,000 --> 00:15:44,000
პირველი ის არის, რომ გააკეთოთ clang program.c

260
00:15:44,000 --> 00:15:47,000
რომელშიც პროგრამის სახელი თქვენი პროგრამა.

261
00:15:47,000 --> 00:15:51,000
ამ შემთხვევაში თქვენ შეგიძლიათ ნახოთ ისინი უბრალოდ რომ "Hey, კომპილაციის ჩემი პროგრამა."

262
00:15:51,000 --> 00:15:56,000
თქვენ არ ვამბობ "მე მინდა ეს სახელი, ჩემი პროგრამა" ან არაფერი.

263
00:15:56,000 --> 00:15:58,000
>> მეორე ვარიანტი იძლევა სახელი თქვენი პროგრამა.

264
00:15:58,000 --> 00:16:02,000
შეიძლება ითქვას clang-o და შემდეგ სახელი რომ გსურთ

265
00:16:02,000 --> 00:16:06,000
შესრულებადი ფაილი უნდა დაასახელა და შემდეგ program.c.

266
00:16:06,000 --> 00:16:11,000
და ასევე შეგიძლიათ გააკეთებს გააკეთოს პროგრამა და ვნახავთ, როგორ პირველ 2 შემთხვევა

267
00:16:11,000 --> 00:16:15,000
მე ზუსტად. გ, ხოლო მესამე მე მხოლოდ პროგრამებს?

268
00:16:15,000 --> 00:16:18,000
ჰო, თქვენ ნამდვილად არ უნდა დააყენოს. გ როდესაც თქვენ გამოიყენოთ მიიღოს.

269
00:16:18,000 --> 00:16:22,000
წინააღმდეგ შემთხვევაში შემდგენელი ფაქტობრივად აპირებს დაწეროთ თქვენ.

270
00:16:22,000 --> 00:16:24,000
და ასევე, არ ვიცი თუ ბიჭები გახსოვთ,

271
00:16:24,000 --> 00:16:29,000
მაგრამ ბევრი ჯერ ჩვენ ასევე გამოიყენება-lcs50 ან-LM.

272
00:16:29,000 --> 00:16:31,000
რომ ჰქვია აკავშირებს.

273
00:16:31,000 --> 00:16:35,000
უბრალოდ ეუბნება შემდგენელი რომ თქვენ გამოიყენოთ იმ ბიბლიოთეკების უფლება არსებობს,

274
00:16:35,000 --> 00:16:39,000
ასე რომ, თუ გსურთ გამოიყენოთ cs50.h თქვენ ნამდვილად უნდა აკრიფოთ

275
00:16:39,000 --> 00:16:43,000
clang program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
თუ არ გავაკეთებთ, შემდგენელი არ აპირებს ვიცი

277
00:16:45,000 --> 00:16:50,000
რომ თქვენ იყენებთ იმ ფუნქციების cs50.h.

278
00:16:50,000 --> 00:16:52,000
ხოლო როდესაც გსურთ აწარმოებს თქვენი პროგრამის გაქვთ 2 ვარიანტი.

279
00:16:52,000 --> 00:16:57,000
თუ თქვენ არ clang program.c თქვენ არ მიუცია სახელი თქვენი პროგრამა.

280
00:16:57,000 --> 00:17:01,000
თქვენ უნდა გაუშვათ გამოყენებით. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out არის სტანდარტული სახელი რომ clang იძლევა თქვენი პროგრამის თუ არ მისცეს მას სახელი.

282
00:17:06,000 --> 00:17:11,000
წინააღმდეგ შემთხვევაში თქვენ აპირებს. / პროგრამა თუ მისცა სახელი თქვენი პროგრამა,

283
00:17:11,000 --> 00:17:15,000
და ასევე თუ რა გააკეთეთ მიიღოს პროგრამის სახელი რომ პროგრამა აპირებს მიიღოს

284
00:17:15,000 --> 00:17:23,000
უკვე აპირებს იყოს დაპროგრამებული ამავე სახელწოდების როგორც გ ფაილი.

285
00:17:23,000 --> 00:17:26,000
მაშინ ჩვენ ვისაუბრეთ მონაცემთა ტიპები და მონაცემთა.

286
00:17:26,000 --> 00:17:31,000
>> ძირითადად მონაცემთა ტიპები არიან იგივე როგორც პატარა ყუთები ისინი იყენებენ

287
00:17:31,000 --> 00:17:35,000
შესანახად ღირებულებებს, ამიტომ მონაცემთა ტიპები რეალურად ისევე Pokémons.

288
00:17:35,000 --> 00:17:39,000
ისინი მოდის ყველა ზომის და ტიპები.

289
00:17:39,000 --> 00:17:43,000
არ ვიცი თუ ეს ანალოგია აზრი.

290
00:17:43,000 --> 00:17:46,000
მონაცემები ზომა რეალურად დამოკიდებულია მანქანის არქიტექტურა.

291
00:17:46,000 --> 00:17:49,000
ყველა მონაცემები ზომის, რომ მე ვაპირებ ნახოთ აქ

292
00:17:49,000 --> 00:17:53,000
რეალურად ამისთვის 32-bit მანქანა, რომელიც არის საქმე ჩვენი ელექტრო მოწყობილობების,

293
00:17:53,000 --> 00:17:56,000
მაგრამ თუ ფაქტობრივად კოდირების თქვენი Mac ან Windows ასევე

294
00:17:56,000 --> 00:17:59,000
ალბათ თქვენ აპირებს აქვს 64-bit მანქანა,

295
00:17:59,000 --> 00:18:03,000
ასე მახსოვს, რომ მონაცემები ზომის, რომ მე ვაპირებ ნახოთ აქ

296
00:18:03,000 --> 00:18:06,000
განკუთვნილია 32-bit მანქანა.

297
00:18:06,000 --> 00:18:08,000
პირველი, რომ ჩვენ ვნახეთ იყო int,

298
00:18:08,000 --> 00:18:10,000
რაც საკმაოდ მარტივია.

299
00:18:10,000 --> 00:18:13,000
თქვენ გამოიყენოთ int შესანახად რიცხვი.

300
00:18:13,000 --> 00:18:16,000
ჩვენ ასევე ვნახეთ ხასიათი, char.

301
00:18:16,000 --> 00:18:20,000
თუ გსურთ გამოიყენოთ ასო ან პატარა სიმბოლო თქვენ ალბათ აპირებს გამოიყენოს char.

302
00:18:20,000 --> 00:18:26,000
Char აქვს 1 byte, რაც იმას ნიშნავს, 8 ბიტი, მოსწონს ძაან მაგარი განაცხადა.

303
00:18:26,000 --> 00:18:31,000
ძირითადად გვაქვს ASCII მაგიდა, რომელსაც აქვს 256

304
00:18:31,000 --> 00:18:34,000
შესაძლო კომბინაციები 0S და 1s,

305
00:18:34,000 --> 00:18:37,000
და მაშინ, როდესაც თქვენ ტიპი char ის აპირებს თარგმნოს

306
00:18:37,000 --> 00:18:44,000
ხასიათი რომ საშუალებებით თქვენ ნომერი რომ გაქვთ ASCII მაგიდა, როგორიც ძაან მაგარი განაცხადა.

307
00:18:44,000 --> 00:18:48,000
ჩვენ ასევე გვაქვს float, რომელიც ჩვენ ვიყენებთ შესანახად ათობითი ნომრები.

308
00:18:48,000 --> 00:18:53,000
თუ გსურთ აირჩიოს 3,14, მაგალითად, თქვენ აპირებს გამოიყენოს float

309
00:18:53,000 --> 00:18:55,000
ან ორმაგი რომ უფრო მეტი სიზუსტით.

310
00:18:55,000 --> 00:18:57,000
Float აქვს 4 ბაიტი.

311
00:18:57,000 --> 00:19:01,000
ორმაგი არის 8 ბაიტი, ამიტომ ერთადერთი განსხვავება არის სიზუსტით.

312
00:19:01,000 --> 00:19:04,000
ჩვენ ასევე გვაქვს ხანგრძლივი, რომელიც გამოიყენება მთელი რიცხვები,

313
00:19:04,000 --> 00:19:09,000
და ხედავთ ამისთვის 32-bit მანქანა int და ხანგრძლივი აქვთ იგივე ზომა,

314
00:19:09,000 --> 00:19:13,000
ასე რომ ნამდვილად არ აქვს აზრი, გამოიყენოს დიდხანს 32-bit მანქანა.

315
00:19:13,000 --> 00:19:17,000
>> მაგრამ თუ თქვენ იყენებთ Mac და 64-bit მანქანა, რეალურად ხანია ზომა 8,

316
00:19:17,000 --> 00:19:19,000
ასე რომ ნამდვილად დამოკიდებულია არქიტექტურა.

317
00:19:19,000 --> 00:19:22,000
For 32-bit მანქანა მას არ აქვს აზრი გამოიყენოს ხანგრძლივი ნამდვილად.

318
00:19:22,000 --> 00:19:25,000
და შემდეგ ხანგრძლივი ხანგრძლივი, მეორეს მხრივ, არის 8 ბაიტი,

319
00:19:25,000 --> 00:19:30,000
ასე რომ ძალიან კარგია, თუ გსურთ აქვს აღარ რიცხვი.

320
00:19:30,000 --> 00:19:34,000
და ბოლოს, ჩვენ გვაქვს ტექსტი, რომელიც რეალურად char *,

321
00:19:34,000 --> 00:19:37,000
რაც მომცეთ char.

322
00:19:37,000 --> 00:19:40,000
ძალიან ადვილია, რომ ვიფიქროთ, რომ ზომის სიმებიანი იქნება მოსწონს

323
00:19:40,000 --> 00:19:42,000
პუნქტების გმირები, რომ თქვენ გაქვთ იქ,

324
00:19:42,000 --> 00:19:45,000
მაგრამ რეალურად char * თავად

325
00:19:45,000 --> 00:19:49,000
აქვს ზომის მომცეთ char, რომელიც 4 ბაიტი.

326
00:19:49,000 --> 00:19:52,000
ზომა char * არის 4 ბაიტი.

327
00:19:52,000 --> 00:19:56,000
არ აქვს მნიშვნელობა, თუ თქვენ გაქვთ პატარა სიტყვა ან ასო ან არაფერი.

328
00:19:56,000 --> 00:19:58,000
ეს იქნება 4 ბაიტი.

329
00:19:58,000 --> 00:20:01,000
ჩვენ ასევე შეიტყო ცოტა შესახებ ჩამოსხმის,

330
00:20:01,000 --> 00:20:04,000
ასე როგორც ხედავთ, თუ გაქვთ, მაგალითად, პროგრამა, რომელიც ამბობს

331
00:20:04,000 --> 00:20:08,000
int x = 3 და შემდეგ printf ("% d", X / 2)

332
00:20:08,000 --> 00:20:12,000
თუ ბიჭები ვიცი რასაც ის აპირებს ბეჭდვა ეკრანზე?

333
00:20:12,000 --> 00:20:14,000
>> ვიღაცამ? >> [სტუდენტთა] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, yeah.

335
00:20:16,000 --> 00:20:20,000
როცა 3/2 ის აპირებს მიიღებთ 1,5,

336
00:20:20,000 --> 00:20:24,000
მაგრამ რადგან ჩვენ გამოყენებით მთელი ის აპირებს იგნორირება ათობითი ნაწილი,

337
00:20:24,000 --> 00:20:26,000
და თქვენ აპირებს აქვს 1.

338
00:20:26,000 --> 00:20:29,000
თუ თქვენ არ გსურთ, რომ მოხდეს რა შეგიძლიათ გააკეთოთ, მაგალითად,

339
00:20:29,000 --> 00:20:33,000
არის განაცხადოს, float y = x.

340
00:20:33,000 --> 00:20:40,000
შემდეგ x, რომ გამოყენებული იყოს 3 არის იქნება 3.000 in წ.

341
00:20:40,000 --> 00:20:44,000
და მაშინ ბეჭდვა Y / 2.

342
00:20:44,000 --> 00:20:50,000
სინამდვილეში, მე უნდა ჰქონდეს 2. იქ.

343
00:20:50,000 --> 00:20:55,000
ის აპირებს 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
და თქვენ აპირებს მიიღოს 1.5.

345
00:20:58,000 --> 00:21:06,000
და ჩვენ გვაქვს ამ .2 f უბრალოდ მოითხოვოს 2 ათობითი ერთეული ათობითი ნაწილი.

346
00:21:06,000 --> 00:21:12,000
თუ თქვენ გაქვთ .3 F ის აპირებს რეალურად 1.500.

347
00:21:12,000 --> 00:21:16,000
თუ ეს 2 ეს იქნება 1.50.

348
00:21:16,000 --> 00:21:18,000
ჩვენ ასევე გვაქვს ამ შემთხვევაში აქ.

349
00:21:18,000 --> 00:21:22,000
თუ float x = 3,14 და მაშინ printf x

350
00:21:22,000 --> 00:21:24,000
თქვენ აპირებს მიიღოს 3,14.

351
00:21:24,000 --> 00:21:29,000
და თუ x = int of x,

352
00:21:29,000 --> 00:21:34,000
რაც იმას ნიშნავს, მკურნალობა x როგორც int და თქვენ ბეჭდვა x ახლა

353
00:21:34,000 --> 00:21:36,000
თქვენ აპირებს აქვს 3,00.

354
00:21:36,000 --> 00:21:38,000
ამჯამად რომ აზრი?

355
00:21:38,000 --> 00:21:41,000
იმიტომ, რომ თქვენ პირველი მკურნალობის x როგორც მთელი რიცხვი, ასე რომ თქვენ იგნორირება ათობითი ნაწილი,

356
00:21:41,000 --> 00:21:45,000
და მაშინ თქვენ დაბეჭდვის x.

357
00:21:45,000 --> 00:21:47,000
და ბოლოს, თქვენ შეგიძლიათ ასევე ამის გაკეთება,

358
00:21:47,000 --> 00:21:52,000
int x = 65, და მერე განაცხადოს char c = x,

359
00:21:52,000 --> 00:21:56,000
და მაშინ, თუ თქვენ ბეჭდვა გ თქვენ რეალურად აპირებს მიიღოს

360
00:21:56,000 --> 00:21:59,000
, ასე რომ ძირითადად თუ რას აკეთებს აქ

361
00:21:59,000 --> 00:22:02,000
არის თარგმნის მთელი შევიდა ხასიათი,

362
00:22:02,000 --> 00:22:05,000
ისევე ASCII მაგიდა აკეთებს.

363
00:22:05,000 --> 00:22:08,000
ჩვენ ასევე ვისაუბრეთ მათემატიკის ოპერატორები.

364
00:22:08,000 --> 00:22:14,000
მათი უმრავლესობა საკმაოდ მარტივია, ასე რომ +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
და ასევე ვისაუბრეთ თავდაცვის სამინისტროს, რომელიც დარჩენილი სამმართველოს 2 ნომრები.

366
00:22:20,000 --> 00:22:23,000
თუ თქვენ გაქვთ 10% 3, მაგალითად,

367
00:22:23,000 --> 00:22:27,000
ეს იმას ნიშნავს, დაყოს 10 მიერ 3, და რა არის დარჩენილი?

368
00:22:27,000 --> 00:22:30,000
ეს იქნება 1, ამიტომ რეალურად ძალიან სასარგებლო ბევრი პროგრამების.

369
00:22:30,000 --> 00:22:38,000
იყიდება Vigenère და ცეზარ მე საკმაოდ დარწმუნებული ვარ, რომ ყველა თქვენგანს ბიჭებს გამოყენებული mod.

370
00:22:38,000 --> 00:22:43,000
შესახებ მათემატიკის ოპერატორები, იყოს ძალიან ფრთხილად, როცა აერთიანებს * და /.

371
00:22:43,000 --> 00:22:48,000
>> მაგალითად, თუ თქვენ (3/2) * 2 რას აპირებს მიიღოს?

372
00:22:48,000 --> 00:22:50,000
[სტუდენტთა] 2.

373
00:22:50,000 --> 00:22:54,000
ჰო, 2, რადგან 3/2 იქნება 1.5,

374
00:22:54,000 --> 00:22:57,000
მაგრამ რადგან თქვენ აკეთებთ ოპერაციების შორის 2 რიცხვებით

375
00:22:57,000 --> 00:22:59,000
თქვენ რეალურად მხოლოდ აპირებს განიხილოს 1,

376
00:22:59,000 --> 00:23:03,000
და შემდეგ 1 * 2 იქნება 2, ასე რომ ძალიან, ძალიან ფრთხილად

377
00:23:03,000 --> 00:23:07,000
როდესაც აკეთებს არითმეტიკული ერთად მთელი რიცხვები, რადგან

378
00:23:07,000 --> 00:23:12,000
შესაძლოა, რომ 2 = 3, ამ შემთხვევაში.

379
00:23:12,000 --> 00:23:14,000
და ასევე ძალიან ფრთხილად პრეცენდენტის.

380
00:23:14,000 --> 00:23:21,000
თქვენ უნდა გამოვიყენოთ ჩვეულებრივ ფრჩხილებში დარწმუნებული უნდა იყოს, რომ თქვენ იცით, თუ რას აკეთებს.

381
00:23:21,000 --> 00:23:27,000
ზოგიერთი სასარგებლო კომბინაციები, რა თქმა უნდა, ერთი არის მე + + ან i + = 1

382
00:23:27,000 --> 00:23:30,000
ან + =.

383
00:23:30,000 --> 00:23:34,000
ეს იგივე რამ, როგორც აკეთებს i = i + 1.

384
00:23:34,000 --> 00:23:39,000
თქვენ ასევე შეგიძლიათ შემიძლია - ან მე - = 1,

385
00:23:39,000 --> 00:23:42,000
რაც იგივე როგორც მე = მე -1,

386
00:23:42,000 --> 00:23:46,000
რაღაც თქვენ ბიჭები გამოიყენოთ ბევრი ამისთვის მარყუჟების, მინიმუმ.

387
00:23:46,000 --> 00:23:52,000
ასევე, *, თუ თქვენ იყენებთ * = და თუ, მაგალითად,

388
00:23:52,000 --> 00:23:57,000
მე * = 2 არის იგივე დაყრდნობით მე = i * 2,

389
00:23:57,000 --> 00:23:59,000
და იგივე შეეხება განაწილებას.

390
00:23:59,000 --> 00:24:08,000
თუ შემიძლია / = 2 ეს იგივე როგორც მე = I / 2.

391
00:24:08,000 --> 00:24:10,000
>> რაც შეეხება ფუნქციებს.

392
00:24:10,000 --> 00:24:13,000
თქვენ ბიჭები შეიტყო, რომ ფუნქციები ძალიან კარგი სტრატეგია გადარჩენა კოდი

393
00:24:13,000 --> 00:24:16,000
ხოლო თქვენ პროგრამირების ასე რომ, თუ გსურთ შეასრულოს იგივე ამოცანა

394
00:24:16,000 --> 00:24:20,000
კოდის ისევ და ისევ, ალბათ გსურთ გამოიყენოთ ფუნქცია

395
00:24:20,000 --> 00:24:25,000
უბრალოდ, ასე რომ თქვენ არ უნდა დააკოპირეთ და ჩასვით კოდი უსასრულოდ.

396
00:24:25,000 --> 00:24:28,000
სინამდვილეში, მთავარი არის ფუნქცია, და როცა მე გაჩვენებთ ფორმატის ფუნქცია

397
00:24:28,000 --> 00:24:32,000
თქვენ აპირებს, რომ რომ საკმაოდ ნათელია.

398
00:24:32,000 --> 00:24:35,000
ჩვენ ასევე ვიყენებთ ფუნქციებს რამდენიმე ბიბლიოთეკა,

399
00:24:35,000 --> 00:24:39,000
მაგალითად, printf, GetIn, რომელიც საწყისი CS50 ბიბლიოთეკა,

400
00:24:39,000 --> 00:24:43,000
და სხვა ფუნქციების მსგავსად toupper.

401
00:24:43,000 --> 00:24:46,000
ყველა იმ ფუნქციებს ფაქტობრივად განხორციელებული სხვა ბიბლიოთეკების,

402
00:24:46,000 --> 00:24:49,000
და როდესაც თქვენ დააყენა იმ tether ფაილი დასაწყისში თქვენი პროგრამა

403
00:24:49,000 --> 00:24:53,000
თქვენ ამბობდა შეგიძლიათ გთხოვთ მომეცი კოდი ამ ფუნქციების

404
00:24:53,000 --> 00:24:57,000
ასე რომ არ უნდა განახორციელონ მათ მიერ თავს?

405
00:24:57,000 --> 00:25:00,000
და ასევე შეგიძლიათ დაწეროთ ფუნქციების, ასე რომ, როდესაც თქვენ დავიწყოთ პროგრამირების

406
00:25:00,000 --> 00:25:04,000
ხვდები, რომ ბიბლიოთეკების არ აქვს ყველა ფუნქცია, რაც თქვენ გჭირდებათ.

407
00:25:04,000 --> 00:25:10,000
უკანასკნელი pset, მაგალითად, ჩვენ წერდა მიაპყროს, scramble, და საძიებელი,

408
00:25:10,000 --> 00:25:13,000
და ეს ძალიან, ძალიან მნიშვნელოვანია შეძლონ წერა ფუნქციები

409
00:25:13,000 --> 00:25:17,000
რადგან ისინი სასარგებლო და ჩვენ მათი გამოყენება ყველა დროის პროგრამირებაში,

410
00:25:17,000 --> 00:25:19,000
და ეს ზოგავს ბევრი კოდი.

411
00:25:19,000 --> 00:25:21,000
ფორმატის ფუნქცია ამ ერთ.

412
00:25:21,000 --> 00:25:24,000
ჩვენ გვყავს დაბრუნების ტიპის დასაწყისია. რა არის დაბრუნების ტიპის?

413
00:25:24,000 --> 00:25:27,000
უბრალოდ, როცა თქვენი ფუნქციის დაბრუნებას აპირებს.

414
00:25:27,000 --> 00:25:29,000
თუ თქვენ გაქვთ ფუნქცია, მაგალითად, factorial,

415
00:25:29,000 --> 00:25:31,000
რომ აპირებს გამოთვლა factorial of რიცხვი,

416
00:25:31,000 --> 00:25:34,000
ალბათ ის დაბრუნებას აპირებს მთელი რიცხვი ასევე.

417
00:25:34,000 --> 00:25:37,000
მაშინ დაბრუნების ტიპის იქნება int.

418
00:25:37,000 --> 00:25:41,000
Printf რეალურად აქვს დაბრუნების ტიპის ბათილად

419
00:25:41,000 --> 00:25:43,000
იმიტომ, რომ თქვენ არ დაბრუნების არაფერი.

420
00:25:43,000 --> 00:25:45,000
თქვენ მხოლოდ დაბეჭდვის რამ ეკრანზე

421
00:25:45,000 --> 00:25:48,000
და წასვლის ფუნქციის შემდეგ.

422
00:25:48,000 --> 00:25:51,000
მაშინ თქვენ გაქვთ სახელით ფუნქცია რომ შეგიძლიათ.

423
00:25:51,000 --> 00:25:55,000
თქვენ უნდა იყოს პატარა გონივრული, როგორიც არ ვირჩევთ სახელი როგორიცაა xyz

424
00:25:55,000 --> 00:25:58,000
ან მოსწონს x2f.

425
00:25:58,000 --> 00:26:02,000
ცდილობს, მოიგონოს სახელი რომ აზრი.

426
00:26:02,000 --> 00:26:04,000
>> მაგალითად, თუ ის factorial, ამბობენ factorial.

427
00:26:04,000 --> 00:26:08,000
თუ ეს ფუნქცია, რომ აპირებს გავამახვილო რაღაც, დაარქვით მიაპყროს.

428
00:26:08,000 --> 00:26:11,000
და მაშინ ჩვენ გვაქვს პარამეტრებს, რომლებიც ასევე მოუწოდა არგუმენტები,

429
00:26:11,000 --> 00:26:14,000
რომლებიც მოსწონს რესურსების, რომ თქვენი ფუნქცია სჭირდება

430
00:26:14,000 --> 00:26:17,000
თქვენი კოდი შეასრულოს თავისი ამოცანა.

431
00:26:17,000 --> 00:26:20,000
თუ გსურთ გამოთვლა factorial რიგი

432
00:26:20,000 --> 00:26:23,000
ალბათ უნდა გქონდეს რაოდენობის გამოთვლა factorial.

433
00:26:23,000 --> 00:26:27,000
ერთი არგუმენტები, რომ თქვენ აპირებს აქვს არის ნომერი თავად.

434
00:26:27,000 --> 00:26:31,000
და მერე ხდება რაღაც და დაბრუნდნენ ღირებულება დასასრულს

435
00:26:31,000 --> 00:26:35,000
თუ იგი არ არის ბათილად ფუნქცია.

436
00:26:35,000 --> 00:26:37,000
ვნახოთ მაგალითი.

437
00:26:37,000 --> 00:26:40,000
თუკი მინდა დაწერა ფუნქციის რომ თანხები ყველა ნომრები მასივი რიცხვებით,

438
00:26:40,000 --> 00:26:43,000
პირველ რიგში, დაბრუნების ტიპის იქნება int

439
00:26:43,000 --> 00:26:46,000
რადგან მაქვს მასივი რიცხვებით.

440
00:26:46,000 --> 00:26:51,000
და შემდეგ მე ვაპირებ აქვს ფუნქცია სახელი როგორიცაა sumArray,

441
00:26:51,000 --> 00:26:54,000
და შემდეგ ის აპირებს მასივი ქვეყნისათვის, int nums,

442
00:26:54,000 --> 00:26:58,000
და მერე სიგრძეზე მასივი ასე ვიცი რამდენი ციფრები უნდა თანხა.

443
00:26:58,000 --> 00:27:02,000
მაშინ მე უნდა ინიციალიზაცია ცვლადში თანხა, მაგალითად, 0,

444
00:27:02,000 --> 00:27:08,000
და ყოველ ჯერზე ვხედავ ელემენტია მასივი მე უნდა დაამატოთ ეს თანხა, ასე რომ მე ამისთვის loop.

445
00:27:08,000 --> 00:27:15,000
ისევე, როგორც ძაან მაგარი განაცხადა, თქვენ int i = 0, I <სიგრძე და მე + +.

446
00:27:15,000 --> 00:27:20,000
და ყველა ელემენტს მასივი მე თანხა + = nums [i],

447
00:27:20,000 --> 00:27:24,000
და შემდეგ დავბრუნდი თანხა, ამიტომ ძალიან მარტივია, და ეს ზოგავს ბევრი კოდი

448
00:27:24,000 --> 00:27:28,000
თუ თქვენ იყენებთ ამ ფუნქციას უამრავი ჯერ.

449
00:27:28,000 --> 00:27:32,000
მაშინ ავიღეთ შევხედოთ პირობებს.

450
00:27:32,000 --> 00:27:38,000
ჩვენ გვყავს თუ სხვაგან, და სხვას თუ.

451
00:27:38,000 --> 00:27:42,000
ვნახოთ რა განსხვავებაა იმ.

452
00:27:42,000 --> 00:27:45,000
შეხედეთ ამ 2 კოდები. რა განსხვავებაა მათ შორის?

453
00:27:45,000 --> 00:27:49,000
პირველი ერთი-ძირითადად კოდები მინდა ვუთხრა

454
00:27:49,000 --> 00:27:51,000
თუ რიცხვი +, -, ან 0.

455
00:27:51,000 --> 00:27:55,000
პირველი ამბობს, თუ ის> 0 მაშინ ეს დადებითი.

456
00:27:55,000 --> 00:28:00,000
თუ ეს = 0 მაშინ ეს 0, და თუ ეს <0, მაშინ ეს უარყოფითი.

457
00:28:00,000 --> 00:28:04,000
>> და მეორე აკეთებს, თუ, სხვას თუ სხვაგან.

458
00:28:04,000 --> 00:28:07,000
განსხვავება ორ არის ის, რომ ამ ერთი რეალურად აპირებს

459
00:28:07,000 --> 00:28:13,000
შეამოწმეთ თუ> 0, <0 ან = 0 სამჯერ,

460
00:28:13,000 --> 00:28:17,000
ასე რომ, თუ თქვენ გაქვთ ნომერი 2, მაგალითად, ის აპირებს ჩამოვიდეს აქ და თქვას

461
00:28:17,000 --> 00:28:21,000
თუ (x> 0) და ეს ხდება იმის თქმა კი, ამიტომ ბეჭდვა დადებითი.

462
00:28:21,000 --> 00:28:25,000
მაგრამ მიუხედავად იმისა, რომ მე ვიცი, რომ ეს> 0 და ეს არ იქნება 0 ან <0

463
00:28:25,000 --> 00:28:29,000
მე ჯერ კიდევ აპირებს თუ არა 0, არის ის <0,

464
00:28:29,000 --> 00:28:33,000
ამიტომ მე რეალურად აპირებს შიგნით IFS, რომ არ უნდა

465
00:28:33,000 --> 00:28:38,000
იმიტომ, რომ მე უკვე ვიცი, რომ ის არ აპირებს დააკმაყოფილოს ნებისმიერი ამ პირობებში.

466
00:28:38,000 --> 00:28:41,000
შემიძლია თუ სხვაგან, თუ სხვაგან განცხადებაში.

467
00:28:41,000 --> 00:28:45,000
იგი ძირითადად ამბობს, თუ x = 0 მე ბეჭდვა დადებითი.

468
00:28:45,000 --> 00:28:48,000
თუ ეს არ, მე ვაპირებ ასევე შეამოწმოთ ამ.

469
00:28:48,000 --> 00:28:51,000
თუ ეს 2 არ მე ვაპირებ ამის გაკეთებას.

470
00:28:51,000 --> 00:28:54,000
ძირითადად მე რომ x = 2 თქვენ ვიტყოდი

471
00:28:54,000 --> 00:28:57,000
თუ (x> 0), დიახ, ასე ბეჭდვა ამ.

472
00:28:57,000 --> 00:29:00,000
ახლა, მე ვიცი, რომ ეს> 0 და რომ იგი კმაყოფილი პირველი თუ

473
00:29:00,000 --> 00:29:02,000
მე კი არ აპირებს ამ კოდექსით.

474
00:29:02,000 --> 00:29:09,000
კოდი ეშვება სწრაფად, ფაქტობრივად, 3 ჯერ უფრო სწრაფად, თუ თქვენ იყენებთ ამ.

475
00:29:09,000 --> 00:29:11,000
ჩვენ ასევე შეიტყო და და ან.

476
00:29:11,000 --> 00:29:15,000
მე არ ვაპირებ გავლა რადგან ძაან მაგარი უკვე ისაუბრა მათ.

477
00:29:15,000 --> 00:29:17,000
უბრალოდ && და | | ოპერატორი.

478
00:29:17,000 --> 00:29:21,000
>> ერთადერთი, რაც მე ვთქვა, ფრთხილად, როდესაც თქვენ 3 პირობები.

479
00:29:21,000 --> 00:29:24,000
გამოიყენეთ ფრჩხილებში იმიტომ რომ ძალიან დამაბნეველი როცა მდგომარეობა

480
00:29:24,000 --> 00:29:27,000
და კიდევ ერთი ან მეორე.

481
00:29:27,000 --> 00:29:30,000
გამოიყენეთ ფრჩხილებში მხოლოდ დარწმუნებული უნდა იყოს, რომ თქვენი პირობები აზრი

482
00:29:30,000 --> 00:29:34,000
რადგან ამ შემთხვევაში, მაგალითად, თქვენ შეგიძლიათ წარმოიდგინოთ, რომ

483
00:29:34,000 --> 00:29:38,000
ეს შეიძლება იყოს პირველი მდგომარეობა და ერთი ან მეორე

484
00:29:38,000 --> 00:29:41,000
ან 2 პირობების შერწყმული და

485
00:29:41,000 --> 00:29:45,000
ან მესამე, ასე რომ მხოლოდ ფრთხილად.

486
00:29:45,000 --> 00:29:48,000
და ბოლოს, ჩვენ ვისაუბრეთ კონცენტრატორები.

487
00:29:48,000 --> 00:29:53,000
შეცვლა არის ძალიან სასარგებლო, როდესაც თქვენ გაქვთ ცვლადი.

488
00:29:53,000 --> 00:29:55,000
ვთქვათ, რომ თქვენ გაქვთ ცვლადი, როგორიცაა N

489
00:29:55,000 --> 00:29:59,000
რომ შეიძლება იყოს 0, 1, ან 2, და თითოეული იმ შემთხვევაში

490
00:29:59,000 --> 00:30:01,000
თქვენ აპირებს შეასრულოს დავალება.

491
00:30:01,000 --> 00:30:04,000
შეიძლება ითქვას გადართოთ ცვლადი, და ეს მიუთითებს იმაზე, რომ

492
00:30:04,000 --> 00:30:08,000
ღირებულება მაშინ ჰგავს value1 მე ვაპირებ ამის გაკეთებას,

493
00:30:08,000 --> 00:30:12,000
და მერე შესვენება, რაც იმას ნიშნავს, მე არ ვაპირებ შეხედოთ ნებისმიერ სხვა შემთხვევებში

494
00:30:12,000 --> 00:30:15,000
იმიტომ, რომ ჩვენ უკვე დარწმუნებულია იმაში, რომ საქმე

495
00:30:15,000 --> 00:30:20,000
და შემდეგ value2 და ასე შემდეგ, და მე ასევე შეგიძლიათ აქვს რა შეცვლა.

496
00:30:20,000 --> 00:30:24,000
ეს იმას ნიშნავს, თუ ის არ აკმაყოფილებს ნებისმიერი შემთხვევები, რომ მქონდა

497
00:30:24,000 --> 00:30:29,000
რომ მე ვაპირებ რაღაც სხვას, მაგრამ ეს აუცილებელი.

498
00:30:29,000 --> 00:30:36,000
ეს იყო ჩემთვის. ახლა მოდით ტომი.

499
00:30:36,000 --> 00:30:41,000
ყველა უფლება, ეს იქნება კვირა 3-ish.

500
00:30:41,000 --> 00:30:45,000
ეს არის ზოგიერთი თემები ჩვენ გააშუქებს, შიფრის, მასშტაბების, მასივები, et cetera.

501
00:30:45,000 --> 00:30:49,000
უბრალოდ სწრაფი სიტყვა Crypto. ჩვენ არ ვაპირებთ, რომ ჩაქუჩი ამ სახლში.

502
00:30:49,000 --> 00:30:52,000
>> ეს გავაკეთეთ წელს pset 2, არამედ ინტელექტუალური დარწმუნდით თქვენ იცით განსხვავება

503
00:30:52,000 --> 00:30:54,000
შორის კეისრის კოდი და Vigenère cipher,

504
00:30:54,000 --> 00:30:57,000
როგორ ორივე ciphers მუშაობა და რა მოსწონს დაშიფვრა

505
00:30:57,000 --> 00:30:59,000
და გაშიფვრა ტექსტი გამოყენებით იმ 2 ciphers.

506
00:30:59,000 --> 00:31:03,000
გახსოვდეთ, კეისრის კოდი უბრალოდ ბრუნავს თითოეული ხასიათი იგივე თანხა,

507
00:31:03,000 --> 00:31:06,000
მიღების დარწმუნებული თქვენ mod მიერ პუნქტების წერილები ანბანი.

508
00:31:06,000 --> 00:31:09,000
და Vigenère cipher, მეორეს მხრივ, ბრუნავს თითოეული ხასიათი

509
00:31:09,000 --> 00:31:12,000
მიერ სხვადასხვა თანხა, ასე რომ, ვიდრე ამბობდა

510
00:31:12,000 --> 00:31:15,000
ყველა ხასიათი გარდამავალია მიერ 3 Vigenère ჩაენაცვლება თითოეული ხასიათი

511
00:31:15,000 --> 00:31:17,000
მიერ სხვადასხვა თანხა დამოკიდებულია რამდენიმე სიტყვით

512
00:31:17,000 --> 00:31:20,000
სადაც თითოეული ასო სიტყვის წარმოადგენს განსხვავებული თანხა

513
00:31:20,000 --> 00:31:26,000
რომ როტაცია წმინდა ტექსტი.

514
00:31:26,000 --> 00:31:28,000
მოდით პირველი საუბარი ცვლადი ფარგლებს.

515
00:31:28,000 --> 00:31:30,000
არის 2 სხვადასხვა ტიპის ცვლადი.

516
00:31:30,000 --> 00:31:33,000
ჩვენ გვყავს ადგილობრივი ცვლადები და ამ ვაპირებთ განისაზღვრება

517
00:31:33,000 --> 00:31:36,000
გარეთ ძირითად ან გარეთ ნებისმიერი ფუნქცია ან ბლოკი,

518
00:31:36,000 --> 00:31:39,000
და ეს იქნება ხელმისაწვდომი ნებისმიერ წერტილში თქვენი პროგრამა.

519
00:31:39,000 --> 00:31:41,000
თუ თქვენ გაქვთ ფუნქცია და ამ ფუნქციის ხოლო loop

520
00:31:41,000 --> 00:31:44,000
დიდი გლობალური ცვლადი არის ხელმისაწვდომი ყველგან.

521
00:31:44,000 --> 00:31:48,000
ადგილობრივი ცვლადი, მეორეს მხრივ, არის scoped იქ, სადაც ის არ არის დადგენილი.

522
00:31:48,000 --> 00:31:53,000
>> თუ თქვენ გაქვთ ფუნქცია აქ, მაგალითად, ჩვენ გვაქვს ამ ფუნქციის გ,

523
00:31:53,000 --> 00:31:56,000
და შიგნით გ არსებობს ცვლადი აქ მოუწოდა Y,

524
00:31:56,000 --> 00:31:58,000
და ეს იმას ნიშნავს, რომ ეს არის ლოკალური ცვლადი.

525
00:31:58,000 --> 00:32:00,000
მიუხედავად იმისა, რომ ამ ცვლადის ეწოდება Y

526
00:32:00,000 --> 00:32:03,000
და ამ ცვლადის ეწოდება Y ამ 2 ფუნქციები

527
00:32:03,000 --> 00:32:06,000
არ ვიცი რა ერთმანეთის ადგილობრივი ცვლადებია.

528
00:32:06,000 --> 00:32:10,000
მეორეს მხრივ, აქ ვამბობთ int x = 5,

529
00:32:10,000 --> 00:32:12,000
და ეს არის სცილდება ნებისმიერი ფუნქცია.

530
00:32:12,000 --> 00:32:16,000
ეს სცილდება მთავარ, ისე ეს გლობალური ცვლადი.

531
00:32:16,000 --> 00:32:20,000
ეს იმას ნიშნავს, რომ შიგნით ამ 2 ფუნქციების როდესაც ვამბობ, რომ X - ან x + +

532
00:32:20,000 --> 00:32:26,000
მე წვდომის იგივე x რომლითაც ამ Y და ამ Y არიან სხვადასხვა ცვლადები.

533
00:32:26,000 --> 00:32:30,000
რომ სხვაობაა გლობალური ცვლადი და ლოკალური ცვლადი.

534
00:32:30,000 --> 00:32:33,000
რამდენადაც დიზაინი ეხება, ზოგჯერ ეს ალბათ უკეთესი იდეა

535
00:32:33,000 --> 00:32:37,000
შენარჩუნება ცვლადები ადგილობრივი როდესაც თქვენ შეგიძლიათ

536
00:32:37,000 --> 00:32:39,000
წლიდან მქონე bunch გლობალური ცვლადები შეუძლიათ მიიღონ მართლაც დამაბნეველი.

537
00:32:39,000 --> 00:32:42,000
თუ თქვენ გაქვთ bunch ფუნქციების ყველა შეცვლის იგივე

538
00:32:42,000 --> 00:32:45,000
თქვენ შეიძლება დაგვავიწყდეს რა, თუ ამ ფუნქციას შემთხვევით modifies ამ გლობალურ,

539
00:32:45,000 --> 00:32:47,000
და ეს სხვა ფუნქცია არ იცის ამის შესახებ,

540
00:32:47,000 --> 00:32:50,000
და ეს სულაც კიდევ საკმაოდ დამაბნეველი, როგორც თქვენ უფრო კოდი.

541
00:32:50,000 --> 00:32:53,000
Keeping ცვლადები ადგილობრივი როდესაც თქვენ შეგიძლიათ

542
00:32:53,000 --> 00:32:56,000
უბრალოდ კარგი დიზაინით.

543
00:32:56,000 --> 00:33:00,000
მასივები, გახსოვდეთ, უბრალოდ სიები ელემენტები იგივე ტიპის.

544
00:33:00,000 --> 00:33:04,000
შიგნით CI არ შეიძლება სიაში მოსწონს 1, 2.0, hello.

545
00:33:04,000 --> 00:33:06,000
ჩვენ უბრალოდ ვერ გავაკეთებთ.

546
00:33:06,000 --> 00:33:11,000
>> როდესაც ვაცხადებთ, array in C ყველა ელემენტები უნდა იყოს იგივე ტიპის.

547
00:33:11,000 --> 00:33:14,000
აქ მაქვს მასივი 3 რიცხვებით.

548
00:33:14,000 --> 00:33:18,000
აქ მაქვს სიგრძეზე მასივი, მაგრამ თუ მე უბრალოდ გამოცხადების იგი ამ სინტაქსის

549
00:33:18,000 --> 00:33:21,000
სადაც მე მიუთითოთ ყველა ელემენტები არიან მე არ ტექნიკურად გვჭირდება ეს 3.

550
00:33:21,000 --> 00:33:25,000
შემდგენელი არის smart საკმარისი გაერკვნენ, თუ როგორ დიდი მასივი უნდა იყოს.

551
00:33:25,000 --> 00:33:28,000
ახლა, როდესაც მე მინდა კიდევ ან ღირებულების მასივი

552
00:33:28,000 --> 00:33:30,000
ეს სინტაქსი გაგვაჩნია.

553
00:33:30,000 --> 00:33:33,000
ეს რეალურად ცვლილებები მეორე ელემენტია მასივი, რადგან, გახსოვდეთ,

554
00:33:33,000 --> 00:33:36,000
ნუმერაციის იწყება 0, არა 1.

555
00:33:36,000 --> 00:33:42,000
თუკი მინდა წაიკითხონ, რომ ღირებულება შემიძლია ვთქვა რაღაც int x = array [1].

556
00:33:42,000 --> 00:33:44,000
ან თუ მინდა, რომ მითითებული ღირებულება, ისევე როგორც მე ვაკეთებ აქ,

557
00:33:44,000 --> 00:33:47,000
შემიძლია ვთქვა, array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
იმ დროს წვდომის ელემენტების მიერ მათი ინდექსი

559
00:33:50,000 --> 00:33:52,000
ან მათი პოზიცია ან სადაც ისინი მასივი,

560
00:33:52,000 --> 00:33:57,000
და რომ ჩამონათვალი იწყება 0.

561
00:33:57,000 --> 00:34:00,000
ჩვენ შეგვიძლია ასევე აქვს კოლექტორები მასივი,

562
00:34:00,000 --> 00:34:03,000
და ეს ჰქვია მრავალ განზომილებიანი მასივი.

563
00:34:03,000 --> 00:34:05,000
როდესაც გვაქვს მრავალ განზომილებიანი მასივი

564
00:34:05,000 --> 00:34:07,000
რაც იმას ნიშნავს, რომ შეგვიძლია რაღაც სტრიქონები და სვეტები,

565
00:34:07,000 --> 00:34:11,000
და ეს არის მხოლოდ ერთი გზა ვიზუალურ ამა თუ ფიქრობს ამის შესახებ.

566
00:34:11,000 --> 00:34:14,000
როდესაც მაქვს მრავალ განზომილებიანი მასივი, რაც იმას ნიშნავს მე ვაპირებ დაიწყება სჭირდება

567
00:34:14,000 --> 00:34:17,000
ზე მეტი 1 ინდექსი რადგან თუ მაქვს ბადე

568
00:34:17,000 --> 00:34:19,000
უბრალოდ ამბობს იმას, რაც ზედიზედ თქვენ არ მოგვცეს ნომერი.

569
00:34:19,000 --> 00:34:22,000
რომ მართლაც მხოლოდ აპირებს მოგვცეს სიაში ნომრები.

570
00:34:22,000 --> 00:34:25,000
ვთქვათ მაქვს ამ მასივი აქ.

571
00:34:25,000 --> 00:34:30,000
მაქვს მასივი მოუწოდა ქსელის, და მე რომ მისი 2 რიგები და 3 მწკრივი,

572
00:34:30,000 --> 00:34:32,000
და ა.შ. ეს არის ერთი გზა ვიზუალურ იგი.

573
00:34:32,000 --> 00:34:37,000
როდესაც ვამბობ მინდა კიდევ ელემენტს ზე [1] [2]

574
00:34:37,000 --> 00:34:41,000
რაც იმას ნიშნავს, რომ რადგან ეს რიგები და შემდეგ სვეტები

575
00:34:41,000 --> 00:34:44,000
მე ვაპირებ გადადით Row 1 წლიდან ვთქვი 1.

576
00:34:44,000 --> 00:34:49,000
>> მაშინ მე ვაპირებ გადმოდიოდნენ აქ სვეტი 2, და მე ვაპირებ კიდევ ღირებულება 6.

577
00:34:49,000 --> 00:34:51,000
აზრი?

578
00:34:51,000 --> 00:34:55,000
Multi-განზომილებიანი მასივები, გახსოვდეთ, ტექნიკურად უბრალოდ მასივი მასივები.

579
00:34:55,000 --> 00:34:57,000
ჩვენ შეგვიძლია აქვს კოლექტორები მასივი მასივი.

580
00:34:57,000 --> 00:35:00,000
ჩვენ შეგვიძლია შევინარჩუნოთ აპირებს, მაგრამ რეალურად ერთი გზა ვიფიქროთ

581
00:35:00,000 --> 00:35:03,000
როგორ მიმდინარეობს ასახული და რა ხდება არის ვიზუალიზაციისთვის ეს

582
00:35:03,000 --> 00:35:09,000
წელს ქსელის მოსწონს ეს.

583
00:35:09,000 --> 00:35:12,000
როდესაც ჩვენ გაიაროს კოლექტორები ფუნქციაში, ისინი აპირებენ მოიქცევა

584
00:35:12,000 --> 00:35:16,000
ცოტა განსხვავებულად, ვიდრე როდესაც ჩვენ გაიაროს რეგულარული ცვლადები ფუნქციები

585
00:35:16,000 --> 00:35:18,000
მოსწონს ავლით int ან float.

586
00:35:18,000 --> 00:35:21,000
როდესაც ჩვენ კორიდორი int ან char ან რომელიმე ამ სხვა მონაცემთა ტიპები

587
00:35:21,000 --> 00:35:24,000
ჩვენ უბრალოდ აიღო შევხედოთ თუ ფუნქცია modifies

588
00:35:24,000 --> 00:35:28,000
ღირებულება რომ ცვლადი, რომ ცვლილება არ აპირებს პროპაგანდაა up

589
00:35:28,000 --> 00:35:32,000
to მოუწოდებდა ფუნქცია.

590
00:35:32,000 --> 00:35:35,000
With მასივი, მეორეს მხრივ, რომ მოხდება.

591
00:35:35,000 --> 00:35:39,000
თუ მე კორიდორი მასივი ზოგიერთი ფუნქცია და რომ ფუნქცია ცვლის ზოგიერთი ელემენტების,

592
00:35:39,000 --> 00:35:43,000
როცა დავბრუნდებით მდე ფუნქცია, რომელიც მას

593
00:35:43,000 --> 00:35:47,000
ჩემი array არის განსხვავებული უნდა იყოს, და ლექსიკა რომ

594
00:35:47,000 --> 00:35:50,000
არის კოლექტორები გავლის მიერ მინიშნება, როგორც ვნახავთ, მოგვიანებით.

595
00:35:50,000 --> 00:35:53,000
ეს უკავშირდება თუ როგორ პოინტერები მუშაობა, სადაც ეს ძირითადი მონაცემთა ტიპები,

596
00:35:53,000 --> 00:35:55,000
მეორეს მხრივ, მათ მიერ მიღებულ ღირებულება.

597
00:35:55,000 --> 00:35:59,000
>> ჩვენ შეგვიძლია ვიფიქროთ, რომ როგორც მიღების ასლი ზოგიერთი ცვლადი და შემდეგ გადადის ასლი.

598
00:35:59,000 --> 00:36:01,000
არ აქვს მნიშვნელობა, თუ რას ვაკეთებთ, რომ ცვლადი.

599
00:36:01,000 --> 00:36:06,000
მოუწოდებდა ფუნქცია არ იქნება იცოდეს, რომ შეიცვალა.

600
00:36:06,000 --> 00:36:10,000
კოლექტორები უბრალოდ ცოტა სხვანაირად, რომ დაკავშირებით.

601
00:36:10,000 --> 00:36:13,000
მაგალითად, როგორც ჩვენ მხოლოდ დაინახეს, მთავარ უბრალოდ ფუნქცია

602
00:36:13,000 --> 00:36:15,000
რომელსაც შეუძლია მიიღოს 2 არგუმენტები.

603
00:36:15,000 --> 00:36:20,000
პირველი არგუმენტი მთავარი ფუნქცია არის argc, ან რაოდენობის არგუმენტები,

604
00:36:20,000 --> 00:36:23,000
და მეორე არგუმენტი ეწოდება argv,

605
00:36:23,000 --> 00:36:27,000
და ეს ის ფაქტობრივი ღირებულებების იმ არგუმენტებს.

606
00:36:27,000 --> 00:36:30,000
ვთქვათ მაქვს პროგრამა მოუწოდა this.c,

607
00:36:30,000 --> 00:36:34,000
და მე ვიტყვი, რომ ეს, და მე ვაპირებ აწარმოებს ამ ბრძანებათა ზოლს.

608
00:36:34,000 --> 00:36:38,000
ახლა უნდა გაიაროს ზოგიერთ არგუმენტები ჩემი პროგრამა უწოდა,

609
00:36:38,000 --> 00:36:42,000
მე შეიძლება ითქვას, მსგავსი რამ. / ეს არის cs 50.

610
00:36:42,000 --> 00:36:45,000
ეს არის ის, რაც ჩვენ წარმოიდგინეთ დავით გავაკეთოთ ყოველდღე ტერმინალში.

611
00:36:45,000 --> 00:36:48,000
მაგრამ ახლა მთავარი ფუნქცია შიგნით რომ პროგრამა

612
00:36:48,000 --> 00:36:52,000
აქვს ამ ფასეულობების, ისე argc არის 4.

613
00:36:52,000 --> 00:36:56,000
ეს შეიძლება იყოს პატარა დამაბნეველი რადგან ნამდვილად ჩვენ მხოლოდ გადადის არის cs 50.

614
00:36:56,000 --> 00:36:58,000
რომ მხოლოდ 3.

615
00:36:58,000 --> 00:37:02,000
მაგრამ გახსოვდეთ, რომ პირველი ელემენტი argv ან პირველი არგუმენტი

616
00:37:02,000 --> 00:37:05,000
არის სახელწოდება ფუნქცია თავად.

617
00:37:05,000 --> 00:37:07,190
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ გვყავს 4 რამ აქ,

618
00:37:07,190 --> 00:37:10,530
და პირველ ელემენტს იქნება. / ამ.

619
00:37:10,530 --> 00:37:12,970
და ეს იქნება წარმოდგენილია როგორც სიმებიანი.

620
00:37:12,970 --> 00:37:18,590
შემდეგ დარჩენილი ელემენტების რაც ჩვენ აკრეფილი შემდეგ პროგრამის დასახელება.

621
00:37:18,590 --> 00:37:22,720
ამიტომ ისევე როგორც განზე, როგორც ჩვენ ალბათ დაინახა pset 2,

622
00:37:22,720 --> 00:37:28,780
გვახსოვდეს, რომ სიმებიანი 50 არის ≠ რიცხვი 50.

623
00:37:28,780 --> 00:37:32,520
ამიტომ, ჩვენ ვერ ვიტყვით, რაღაც, 'int x = argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> ეს მხოლოდ არ აპირებს აზრი, რადგან ეს არის ტექსტი, და ეს არის მთელი რიცხვი.

625
00:37:36,470 --> 00:37:38,510
ასე რომ, თუ თქვენ აკონვერტირებთ შორის 2, გახსოვდეთ, ჩვენ ვაპირებთ

626
00:37:38,510 --> 00:37:40,810
ეს ჯადოსნური ფუნქცია მოუწოდა atoi.

627
00:37:40,810 --> 00:37:46,270
რომ იღებს სიმებიანი და გამოიტანს მთელ რიცხვს წარმოდგენილია შიგნით რომ სიმებიანი.

628
00:37:46,270 --> 00:37:48,360
ასე რომ მარტივი შეცდომა, რათა on ვიქტორინა,

629
00:37:48,360 --> 00:37:51,590
უბრალოდ ფიქრობდა, რომ ამ ავტომატურად იქნება სწორი ტიპის.

630
00:37:51,590 --> 00:37:53,860
მაგრამ ვიცი, რომ ეს ყოველთვის იქნება სტრიქონები

631
00:37:53,860 --> 00:38:00,920
მაშინაც კი, თუ სიმებიანი მხოლოდ შეიცავს მთელ რიცხვს ან სიმბოლოს ან float.

632
00:38:00,920 --> 00:38:03,380
ახლა ვისაუბროთ იმაზე ქრონომეტრაჟი.

633
00:38:03,380 --> 00:38:06,700
როდესაც ჩვენ ყველა ამ ალგორითმები, რომ ყველაფერი ეს გიჟები ნივთებს,

634
00:38:06,700 --> 00:38:11,580
ხდება ნამდვილად სასარგებლო ვთხოვო კითხვა, "როდემდე იღებს თუ არა?"

635
00:38:11,580 --> 00:38:15,500
ჩვენ წარმოვადგენთ, რომ რაღაც მოუწოდა asymptotic ნოტაცია.

636
00:38:15,500 --> 00:38:18,430
ასე რომ, ეს იმას ნიშნავს, რომ - კარგად, ვთქვათ ვაძლევთ ჩვენი ალგორითმი

637
00:38:18,430 --> 00:38:20,840
ზოგიერთი მართლაც, მართლაც, მართლაც დიდი შეყვანის.

638
00:38:20,840 --> 00:38:23,840
ჩვენ გვინდა ვთხოვოთ კითხვაზე, "რამდენ ხანს იგი აპირებს?

639
00:38:23,840 --> 00:38:26,370
რამდენი ნაბიჯები დასჭირდება ჩვენი ალგორითმი გასაშვებად

640
00:38:26,370 --> 00:38:29,980
როგორც ფუნქცია ზომა შეყვანის? "

641
00:38:29,980 --> 00:38:33,080
ამიტომ პირველ გზა ჩვენ შეგვიძლია აღვწეროთ აწარმოებს დრო არის დიდი ო

642
00:38:33,080 --> 00:38:35,380
და ეს ჩვენი უარესი ქრონომეტრაჟი.

643
00:38:35,380 --> 00:38:38,590
ასე რომ, თუ გვინდა, რომ დასალაგებლად მასივი, და ვაძლევთ ჩვენი ალგორითმი მასივი

644
00:38:38,590 --> 00:38:41,000
რომ მიხედვით კლებადობით როდესაც ეს უნდა იყოს აღმავალი შეკვეთა,

645
00:38:41,000 --> 00:38:43,130
რომ იქნება უარეს შემთხვევაში.

646
00:38:43,130 --> 00:38:49,800
ეს არის ჩვენი ზედა შეკრული წელს მაქსიმალური დრო ჩვენი ალგორითმი მიიღებს.

647
00:38:49,800 --> 00:38:54,740
მეორეს მხრივ, ამ Ω აპირებს აღწერს საუკეთესო შემთხვევაში ქრონომეტრაჟი.

648
00:38:54,740 --> 00:38:58,210
ასე რომ, თუ ვაძლევთ უკვე დახარისხებული მასივი დახარისხება ალგორითმი,

649
00:38:58,210 --> 00:39:00,940
რამდენი ხანი დასჭირდება დასალაგებლად ეს?

650
00:39:00,940 --> 00:39:06,610
და ეს, მაშინ, აღწერს ქვედა ბლოკნოტის on გაშვებული დრო.

651
00:39:06,610 --> 00:39:10,980
ასე რომ აქ არის რამოდენიმე სიტყვა, რომ ზოგიერთი საერთო გაშვებული ჯერ.

652
00:39:10,980 --> 00:39:13,120
ეს არის იმ აღმავალი შეკვეთა.

653
00:39:13,120 --> 00:39:16,060
სწრაფი გაშვებული დროს ჩვენ ეწოდება მუდმივი.

654
00:39:16,060 --> 00:39:19,800
>> ეს იმას ნიშნავს, არა აქვს მნიშვნელობა თუ რამდენი ელემენტები ვაძლევთ ჩვენი ალგორითმი,

655
00:39:19,800 --> 00:39:22,280
რაც არ უნდა დიდი ჩვენი მასივი, დახარისხება იგი

656
00:39:22,280 --> 00:39:26,510
ან აკეთებს რასაც ვაკეთებთ მასივს ყოველთვის მიიღოს იმავე დროის.

657
00:39:26,510 --> 00:39:30,270
ასე რომ ჩვენ შეგვიძლია იმას რომ მხოლოდ 1, რაც მუდმივი.

658
00:39:30,270 --> 00:39:32,410
ჩვენ ასევე შევხედე ლოგარითმული პერსპექტივაში დრო.

659
00:39:32,410 --> 00:39:34,800
ასე რომ რაღაც ბინარული ძებნის ლოგარითმული,

660
00:39:34,800 --> 00:39:37,140
სადაც ჩვენ გაჭრა პრობლემა ნახევარი ყოველ ჯერზე

661
00:39:37,140 --> 00:39:40,970
და შემდეგ რამ უბრალოდ უმაღლესი იქიდან.

662
00:39:40,970 --> 00:39:43,580
და თუ თქვენ ოდესმე წერა O ნებისმიერი factorial ალგორითმი,

663
00:39:43,580 --> 00:39:47,850
თქვენ ალბათ არ უნდა განიხილოს ეს თქვენი დღის სამუშაო.

664
00:39:47,850 --> 00:39:53,910
როდესაც შევადარებთ გაშვებული ჯერ მნიშვნელოვანია გვახსოვდეს ეს ყველაფერი.

665
00:39:53,910 --> 00:39:57,760
ასე რომ, თუ მაქვს ალგორითმი რომ O (N), და სხვისი

666
00:39:57,760 --> 00:40:03,590
უკვე ალგორითმი O (2n) ეს არის რეალურად asymptotically ექვივალენტს.

667
00:40:03,590 --> 00:40:06,590
ასე რომ, თუ ჩვენ წარმოიდგინეთ n უნდა იყოს დიდი რაოდენობით მოსწონს eleventy მილიარდი:

668
00:40:06,590 --> 00:40:13,090
ასე რომ, როდესაც ჩვენ შედარებით eleventy მილიარდი რაღაც eleventy მილიარდი + 3,

669
00:40:13,090 --> 00:40:17,640
მოულოდნელად რომ +3 ნამდვილად არ მიიღოს დიდი განსხვავება აღარ არის.

670
00:40:17,640 --> 00:40:20,980
ამიტომ, ჩვენ ვაპირებთ დავიწყოთ გათვალისწინებით ეს ყველაფერი უნდა იყოს ექვივალენტს.

671
00:40:20,980 --> 00:40:24,220
ასე რამ, როგორიცაა ამ მუდმივები აქ, იქ 2 x ამ, ან დაამატონ 3,

672
00:40:24,220 --> 00:40:27,180
ეს უბრალოდ მუდმივები და ამ ვაპირებთ ვარდნა up.

673
00:40:27,180 --> 00:40:32,480
ასე ამიტომ ყველა 3 ამ პერსპექტივაში times are იგივე დაყრდნობით ისინი O (N).

674
00:40:32,480 --> 00:40:37,490
ანალოგიურად, თუ გვაქვს 2 სხვა პერსპექტივაში ჯერ, ვთქვათ O (N ³ + 2n ²), ჩვენ შეგვიძლია დაამატოთ

675
00:40:37,490 --> 00:40:42,070
+ N, + 7 და შემდეგ გვაქვს მეორე ტურის დროს ეს მხოლოდ O (N ³).

676
00:40:42,070 --> 00:40:46,290
ერთხელ, ეს არის იგივე რადგან ეს - ეს არ არის ერთი და იგივე.

677
00:40:46,290 --> 00:40:49,840
ეს არის იგივე რამ, უკაცრავად. ასე რომ ეს არის იგივე იქნება

678
00:40:49,840 --> 00:40:53,090
ამ n ³ აპირებს დომინირება ამ 2n ².

679
00:40:53,090 --> 00:40:59,130
>> რა არ არის იგივე რამ არის, თუ ჩვენ არ აწარმოებს ჯერ მოსწონს O (N ³) და O (N ²)

680
00:40:59,130 --> 00:41:02,820
რადგან ამ N ³ ბევრად აღემატება ამ n ².

681
00:41:02,820 --> 00:41:05,470
ასე რომ, თუ ჩვენ გვაქვს ექსპონატები, მოულოდნელად ამ იწყებს მნიშვნელობა,

682
00:41:05,470 --> 00:41:08,280
მაგრამ როცა ჩვენ უბრალოდ საქმე ფაქტორების როგორც ჩვენ აქ,

683
00:41:08,280 --> 00:41:12,810
მაშინ ის არ აპირებს მნიშვნელობა, რადგან ისინი უბრალოდ აპირებს ვარდნა გარეთ.

684
00:41:12,810 --> 00:41:16,760
მოდით შევხედოთ ზოგიერთი ალგორითმის ჩვენ ვნახეთ ჯერჯერობით

685
00:41:16,760 --> 00:41:19,260
და ვისაუბროთ მათ პერსპექტივაში დრო.

686
00:41:19,260 --> 00:41:23,850
პირველი გზა ეძებს ნომერი სიაში, რომ დავინახეთ, იყო ხაზოვანი ძებნა.

687
00:41:23,850 --> 00:41:26,950
და განხორციელების ხაზოვანი ძებნა არის სუპერ მარტივია.

688
00:41:26,950 --> 00:41:30,490
ჩვენ უბრალოდ უნდა სიაში, და ჩვენ ვაპირებთ შევხედოთ თითოეული ელემენტი სია

689
00:41:30,490 --> 00:41:34,260
სანამ ჩვენ პუნქტების ჩვენ ვეძებთ.

690
00:41:34,260 --> 00:41:38,370
ასე რომ, რაც იმას ნიშნავს, რომ უარეს შემთხვევაში, ამ O (N).

691
00:41:38,370 --> 00:41:40,860
და უარეს შემთხვევაში აქ შეიძლება იყოს თუ ელემენტი არის

692
00:41:40,860 --> 00:41:45,710
ბოლო ელემენტს, მაშინ გამოყენებით ხაზოვანი ძებნა გვაქვს შევხედოთ თითოეული ელემენტს

693
00:41:45,710 --> 00:41:50,180
სანამ არ მივიღებთ, რომ ბოლო ერთი, რათა იცოდეს, რომ ეს იყო რეალურად სიაში.

694
00:41:50,180 --> 00:41:52,910
ჩვენ არ შეგვიძლია უბრალოდ დათმობას შუა ნაწილამდე იყვნენ და ამბობენ, "ეს, ალბათ, არ არსებობს."

695
00:41:52,910 --> 00:41:55,980
With ხაზოვანი ძებნა გვაქვს შევხედოთ მთელი რამ.

696
00:41:55,980 --> 00:41:59,090
საუკეთესო შემთხვევაში ქრონომეტრაჟი, მეორეს მხრივ, არის მუდმივი

697
00:41:59,090 --> 00:42:04,200
რადგან საუკეთესო შემთხვევაში ელემენტს ჩვენ ვეძებთ მხოლოდ პირველი სიაში.

698
00:42:04,200 --> 00:42:08,930
ამიტომ აპირებს us ზუსტად 1 ნაბიჯი, რაც არ უნდა დიდი სია

699
00:42:08,930 --> 00:42:12,140
თუ ჩვენ ვეძებთ პირველ ელემენტს ყოველ ჯერზე.

700
00:42:12,140 --> 00:42:15,390
>> ასე რომ, როდესაც თქვენ მოძებნოთ, გახსოვდეთ, ეს არ მოითხოვს, რომ ჩვენს სიაში იყოს დახარისხებული.

701
00:42:15,390 --> 00:42:19,430
იმის გამო, რომ ჩვენ უბრალოდ აპირებს გამოიყურებოდეს მეტი თითოეული ელემენტის, და ეს ნამდვილად არ აქვს მნიშვნელობა

702
00:42:19,430 --> 00:42:23,560
რა მიზნით იმ ელემენტების სისტემაში

703
00:42:23,560 --> 00:42:28,110
უფრო ინტელექტუალური ძებნა ალგორითმი არის რაღაც ორობითი ძებნა.

704
00:42:28,110 --> 00:42:31,500
გახსოვდეთ, განხორციელების ორობითი ძებნა არის, როდესაც თქვენ აპირებთ

705
00:42:31,500 --> 00:42:34,320
შენარჩუნება ეძებს შუა სიაში.

706
00:42:34,320 --> 00:42:38,000
და რადგან ჩვენ ეძებს ახლო, ჩვენ მოითხოვს, რომ სიაში დალაგებულია

707
00:42:38,000 --> 00:42:40,580
ანდა არ ვიცით, სადაც ახლო არის, და ჩვენ უნდა გამოიყურებოდეს მეტი

708
00:42:40,580 --> 00:42:44,480
მთელი სია მის საპოვნელად, და შემდეგ იმ ეტაპზე ჩვენ უბრალოდ დროის გაყვანაა.

709
00:42:44,480 --> 00:42:48,480
ასე რომ, თუ ჩვენ გვაქვს დახარისხებული სია და ჩვენ ახლო, ჩვენ ვაპირებთ შედარების ახლო

710
00:42:48,480 --> 00:42:51,590
რათა ელემენტს ჩვენ ვეძებთ.

711
00:42:51,590 --> 00:42:54,640
თუ ძალიან მაღალია, მაშინ ჩვენ შეგვიძლია დავივიწყოთ მარჯვენა ნახევარში

712
00:42:54,640 --> 00:42:57,810
რადგან ჩვენ ვიცით, რომ თუ ჩვენი ელემენტს უკვე ძალიან მაღალი

713
00:42:57,810 --> 00:43:01,080
და ყველაფერი უფლებას ამ ელემენტის არის კიდევ უფრო მაღალი,

714
00:43:01,080 --> 00:43:02,760
მაშინ ჩვენ არ გვჭირდება თვალი იქ უქმნით.

715
00:43:02,760 --> 00:43:05,430
სად მეორეს მხრივ, თუ ჩვენი ელემენტს ძალიან დაბალია,

716
00:43:05,430 --> 00:43:08,700
ჩვენ ვიცით ყველაფერი მარცხნივ რომ ელემენტს ასევე ძალიან დაბალია,

717
00:43:08,700 --> 00:43:11,390
ასე რომ ნამდვილად არ აქვს აზრი, თვალი იქ, არც.

718
00:43:11,390 --> 00:43:15,760
ამ გზით, ყველა ნაბიჯი და ყოველ ჯერზე შევხედავთ შუაში სია,

719
00:43:15,760 --> 00:43:19,060
ჩვენ ვაპირებთ გაჭრა ჩვენი პრობლემა ნახევარი რადგან მოულოდნელად ვიცით

720
00:43:19,060 --> 00:43:23,040
მთელი bunch of ციფრები, რომ არ შეიძლება იყოს ერთი ჩვენ ვეძებთ.

721
00:43:23,040 --> 00:43:26,950
>> In pseudocode ამ გამოიყურება მსგავსი რამ,

722
00:43:26,950 --> 00:43:30,990
და რადგან ჩვენ ჭრის სია ნახევარ თითოეული დრო,

723
00:43:30,990 --> 00:43:34,920
ჩვენი უარესი პერსპექტივაში დრო jumps საწყისი ხაზოვანი to ლოგარითმული.

724
00:43:34,920 --> 00:43:39,260
ასე მოულოდნელად გვაქვს შესვლა ნაბიჯები, რათა ელემენტს სიაში.

725
00:43:39,260 --> 00:43:42,460
საუკეთესო შემთხვევაში ქრონომეტრაჟი, თუმცა, ჯერ კიდევ მუდმივი

726
00:43:42,460 --> 00:43:45,180
რადგან ახლა, მოდით უბრალოდ, ვამბობთ, რომ ელემენტს ჩვენ ვეძებთ არის

727
00:43:45,180 --> 00:43:48,380
ყოველთვის ზუსტი შუა ორიგინალური სიაში.

728
00:43:48,380 --> 00:43:52,080
ასე რომ ჩვენ შეგვიძლია იზრდება ჩვენს სიაში, როგორც დიდი, როგორც ჩვენ გვინდა, მაგრამ თუ ელემენტს ჩვენ ვეძებთ არის ახლო,

729
00:43:52,080 --> 00:43:54,910
მაშინ ეს მხოლოდ აპირებს us 1 ნაბიჯი.

730
00:43:54,910 --> 00:44:00,920
ასე რომ სწორედ ამიტომ ჩვენ O (შესვლა N) და Ω (1) ან მუდმივი.

731
00:44:00,920 --> 00:44:04,510
მოდით რეალურად აწარმოებს ორობითი ძებნა ამ სიაში.

732
00:44:04,510 --> 00:44:08,020
მოდით ვთქვათ, რომ ჩვენ ვეძებთ ელემენტს 164.

733
00:44:08,020 --> 00:44:11,650
პირველი, რასაც ჩვენ ვაპირებთ გავაკეთოთ, არის მოვძებნოთ შუაში ამ სიაში.

734
00:44:11,650 --> 00:44:15,060
ეს უბრალოდ ისე ხდება, რომ შუაში აპირებს ჩავარდებიან შორის 2 ნომრები,

735
00:44:15,060 --> 00:44:18,960
მოდით უბრალოდ თვითნებურად ამბობენ, ყოველ ჯერზე შუაში მოდის შორის 2 ნომრები,

736
00:44:18,960 --> 00:44:21,150
მოდით უბრალოდ გარშემო up.

737
00:44:21,150 --> 00:44:24,330
ჩვენ უბრალოდ უნდა დავრწმუნდეთ, ჩვენ ამას ვაკეთებთ, ყოველ ეტაპზე გზა.

738
00:44:24,330 --> 00:44:29,040
ამიტომ, ჩვენ ვაპირებთ გარშემო up, და ჩვენ ვაპირებთ ვთქვა, რომ 161 არის შუა ჩვენს სიაში.

739
00:44:29,040 --> 00:44:34,640
ასე რომ 161 <164, და ყველა ელემენტს მარცხნივ 161

740
00:44:34,640 --> 00:44:39,120
ასევე <164, ასე რომ, ჩვენ ვიცით, რომ ის არ აპირებს დაგვეხმარება ყველა

741
00:44:39,120 --> 00:44:42,690
დაიწყოს ეძებს მეტი აქ იმიტომ ელემენტს ჩვენ ვეძებთ ვერ იქნება იქ.

742
00:44:42,690 --> 00:44:47,060
რა შეგვიძლია გავაკეთოთ არის შეგვიძლია უბრალოდ დაივიწყოს, რომ მთელი მარცხენა ნახევარში სია,

743
00:44:47,060 --> 00:44:51,700
და ახლა მხოლოდ განიხილოს მარჯვენა მხრიდან 161 Onward.

744
00:44:51,700 --> 00:44:54,050
>> ასე რომ კიდევ ერთხელ, ეს არის შუაში, მოდით უბრალოდ გარშემო up.

745
00:44:54,050 --> 00:44:56,260
არის 175 ძალიან დიდია.

746
00:44:56,260 --> 00:44:59,180
ასე რომ, ჩვენ ვიცით, ეს არ დაგვეხმაროს ეძებს აქ ან აქ,

747
00:44:59,180 --> 00:45:06,610
ამიტომ ჩვენ შეგვიძლია მხოლოდ გადაყარეთ, რომ მოშორებით, და საბოლოოდ ჩვენ მოხვდა 164.

748
00:45:06,610 --> 00:45:10,560
ნებისმიერი შეკითხვა ორობითი ძებნა?

749
00:45:10,560 --> 00:45:14,180
მოდით გადაადგილება საწყისი ძებნას მეშვეობით უკვე დახარისხებული სია

750
00:45:14,180 --> 00:45:17,660
რეალურად აღების სიაში ნომრები ნებისმიერი თანმიმდევრობით

751
00:45:17,660 --> 00:45:20,960
და მიღების, რომ სიაში აღმავალი შეკვეთა.

752
00:45:20,960 --> 00:45:24,060
პირველი ალგორითმის ჩვენ შევხედეთ ერქვა bubble sort.

753
00:45:24,060 --> 00:45:27,300
და ეს იქნება მარტივი of ალგორითმები დავინახეთ.

754
00:45:27,300 --> 00:45:32,970
Bubble დალაგების ამბობს, რომ როდესაც რაიმე 2 ელემენტების შიგნით სია გამოსულია ადგილი,

755
00:45:32,970 --> 00:45:36,500
რაც იმას ნიშნავს, არსებობს უმაღლესი ნომრის მარცხენა ქვედა ნომერი,

756
00:45:36,500 --> 00:45:40,190
მაშინ ჩვენ ვაპირებთ სვოპ მათ, რადგან ეს იმას ნიშნავს, რომ სიაში იქნება

757
00:45:40,190 --> 00:45:42,860
"უფრო დალაგებულია", ვიდრე ეს იყო ადრე.

758
00:45:42,860 --> 00:45:45,180
და ჩვენ უბრალოდ გავაგრძელებთ ამ პროცესს ისევ და ისევ და ისევ

759
00:45:45,180 --> 00:45:52,100
სანამ საბოლოოდ ელემენტები სახის ბუშტი მათი სწორი მდებარეობის და ჩვენ გვაქვს დახარისხებული სია.

760
00:45:52,100 --> 00:45:57,230
>> გაუშვათ დროის ამ იქნება O (N ²). რატომ?

761
00:45:57,230 --> 00:46:00,370
ასევე, ვინაიდან უკიდურეს შემთხვევაში, ჩვენ ვაპირებთ მიიღოს ყველა ელემენტს, და

762
00:46:00,370 --> 00:46:04,570
ჩვენ ვაპირებთ დასრულდება მდე შედარებით მას ყველა სხვა ელემენტს სიაში.

763
00:46:04,570 --> 00:46:08,030
მაგრამ საუკეთესო შემთხვევაში, ჩვენ გვაქვს უკვე დახარისხებული სია, bubble sort ს

764
00:46:08,030 --> 00:46:12,230
უბრალოდ აპირებს გავლა ერთხელ, რომ "Nope. მე არ გაუკეთებია გაცვლებს, ამიტომ მე გაკეთდეს."

765
00:46:12,230 --> 00:46:17,410
ასე რომ, ჩვენ გვაქვს საუკეთესო შემთხვევაში გაშვებული დრო Ω (N).

766
00:46:17,410 --> 00:46:20,680
მოდით აწარმოებს bubble sort წლის სიაში.

767
00:46:20,680 --> 00:46:23,560
ან პირველი, მოდით შევჩერდეთ ზოგიერთ pseudocode მართლაც სწრაფად.

768
00:46:23,560 --> 00:46:28,160
ჩვენ გვინდა ვთქვათ, ჩვენ გვინდა ტრეკზე, ყოველ iteration of მარყუჟის,

769
00:46:28,160 --> 00:46:32,190
ტრეკზე თუ არა ჩვენ შეიცვალა რაიმე ელემენტებს.

770
00:46:32,190 --> 00:46:37,610
ასე რომ მიზეზი, რომ არის, ჩვენ შევწყვეტთ, როდესაც ჩვენ არ swapped ნებისმიერი ელემენტები.

771
00:46:37,610 --> 00:46:41,980
ასე სტარტზე ჩვენი loop ჩვენ არ swapped არაფერი, ისე ჩვენ ვთქვათ, რომ არის ყალბი.

772
00:46:41,980 --> 00:46:47,170
ახლა ჩვენ ვაპირებთ გავლა სიაში და შედარების ელემენტს მე რომ ელემენტს მე + 1

773
00:46:47,170 --> 00:46:50,310
და თუ ეს საქმე, რომ არსებობს უფრო დიდი რაოდენობის მარცხნივ პატარა ნომერი,

774
00:46:50,310 --> 00:46:52,310
მაშინ ჩვენ უბრალოდ აპირებს სვოპ მათ.

775
00:46:52,310 --> 00:46:54,490
>> და შემდეგ ჩვენ ვაპირებთ გვახსოვდეს, რომ ჩვენ swapped ელემენტს.

776
00:46:54,490 --> 00:46:58,900
ეს იმას ნიშნავს, რომ ჩვენ უნდა გაიაროს სიაში მინიმუმ 1 მეტი დრო

777
00:46:58,900 --> 00:47:02,160
რადგან მდგომარეობა, რომელშიც ჩვენ შეწყვიტა, როდესაც მთელი სია უკვე დახარისხებული,

778
00:47:02,160 --> 00:47:04,890
რაც იმას ნიშნავს, რომ ჩვენ არ გაუკეთებიათ გაცვლებს.

779
00:47:04,890 --> 00:47:09,960
ასე რომ სწორედ ამიტომ ჩვენი მდგომარეობა ქვევით აქ არის "ხოლო ზოგიერთი ელემენტები უკვე swapped. '

780
00:47:09,960 --> 00:47:13,720
ახლა მოდით შევჩერდეთ ამ გაშვებული სიაში.

781
00:47:13,720 --> 00:47:16,640
მაქვს სია 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble დალაგების იწყებს ყველა გზა at მარცხენა და ეს აპირებს შესადარებლად

783
00:47:19,850 --> 00:47:24,700
მე ელემენტებს, ასე რომ 0 დან I + 1, რომელიც ელემენტს 1.

784
00:47:24,700 --> 00:47:29,020
იგი აპირებს ამბობენ, კარგად 5> 0, მაგრამ ახლავე 5 არის მარცხენა

785
00:47:29,020 --> 00:47:32,500
ამიტომ მე უნდა სვოპ 5 და 0.

786
00:47:32,500 --> 00:47:35,470
როდესაც მე სვოპ მათ, მოულოდნელად მივიღებ ამ სხვადასხვა სიაში.

787
00:47:35,470 --> 00:47:38,260
არის 5> 1, ამიტომ ჩვენ ვაპირებთ სვოპ მათ.

788
00:47:38,260 --> 00:47:42,160
5 არ არის> 6, ამიტომ ჩვენ არ გვჭირდება არაფრის აქ.

789
00:47:42,160 --> 00:47:46,690
მაგრამ 6> 4, ამიტომ ჩვენ უნდა სვოპ.

790
00:47:46,690 --> 00:47:49,740
ისევ და ისევ, ჩვენ გვჭირდება აწარმოებს მთელ სიაში საბოლოოდ აღმოჩენა

791
00:47:49,740 --> 00:47:52,330
რომ ეს მწყობრიდან გამოსულია, ჩვენ სვოპ მათ,

792
00:47:52,330 --> 00:47:57,120
და ამ ეტაპზე ჩვენ გვჭირდება აწარმოებს მეშვეობით სია 1 მეტი დრო

793
00:47:57,120 --> 00:48:05,390
დავრწმუნდეთ, რომ ყველაფერი თავის იმისათვის, და ამ ეტაპზე bubble sort დასრულდა.

794
00:48:05,390 --> 00:48:10,720
სხვადასხვა ალგორითმი აღების ზოგიერთი ელემენტები და დახარისხება მათ შერჩევას ჯიშია.

795
00:48:10,720 --> 00:48:15,740
იდეა უკან შერჩევის დალაგება, რომ ჩვენ ვაპირებთ დაამყარონ დახარისხებული ნაწილი სიაში

796
00:48:15,740 --> 00:48:18,150
1 ელემენტს დროს.

797
00:48:18,150 --> 00:48:23,170
>> და გზა ჩვენ ვაპირებთ, რომ არის მშენებლობაზე მარცხენა სეგმენტი სიაში.

798
00:48:23,170 --> 00:48:27,510
და ძირითადად, ყოველ - ყოველ ნაბიჯს, ჩვენ აპირებს პატარა ელემენტს ჩვენ არ დაუტოვებიათ

799
00:48:27,510 --> 00:48:32,310
რომ არ იქნა დახარისხებული არ არის, და ჩვენ ვაპირებთ მისი გადატანა შევიდა, რომ დალაგებულია სეგმენტი.

800
00:48:32,310 --> 00:48:35,850
ეს იმას ნიშნავს, რომ ჩვენ უნდა მუდმივად იპოვოს მინიმალური არასორტირებული ელემენტს

801
00:48:35,850 --> 00:48:40,720
და შემდეგ მიიღოს, რომ მინიმალური ელემენტს და სვოპ ის რასაც

802
00:48:40,720 --> 00:48:45,090
მარცხენა საუკეთესო ელემენტს, რომელიც არ არის დახარისხებული.

803
00:48:45,090 --> 00:48:50,890
გაუშვათ დროის ამ იქნება O (N ²) რადგან უარეს შემთხვევაში

804
00:48:50,890 --> 00:48:55,070
ჩვენ გვჭირდება შედარების თითოეული ელემენტს ყველა სხვა ელემენტს.

805
00:48:55,070 --> 00:48:59,250
იმის გამო, რომ ჩვენ ვამბობთ, რომ თუ ჩვენ იწყება მარცხენა ნახევარში სია, ჩვენ გვჭირდება

806
00:48:59,250 --> 00:49:02,970
გავლა მთელი უფლება სეგმენტი იპოვონ ყველაზე მცირე ელემენტს.

807
00:49:02,970 --> 00:49:05,430
და შემდეგ, კიდევ ერთხელ, ჩვენ გვჭირდება მთელ უფლება სეგმენტი და

808
00:49:05,430 --> 00:49:08,210
შენარჩუნება აპირებს მეტი რომ დასრულდა და უსასრულოდ.

809
00:49:08,210 --> 00:49:11,350
რომ იქნება n ². ჩვენ ვაპირებთ გვჭირდება ამისთვის loop შიგნით მეორე მარყუჟის

810
00:49:11,350 --> 00:49:13,350
რომელიც გვთავაზობს n ².

811
00:49:13,350 --> 00:49:16,530
საუკეთესო შემთხვევაში აზრის, ვთქვათ ვაძლევთ მას უკვე დახარისხებული სიაში;

812
00:49:16,530 --> 00:49:19,270
ჩვენ რეალურად არ რაიმე უკეთესი, ვიდრე n ².

813
00:49:19,270 --> 00:49:21,730
რადგან შერჩევა sort ვიზიტორების გზა იცის, რომ

814
00:49:21,730 --> 00:49:25,540
მინიმალური ელემენტს მხოლოდ ერთი მე მოხდეს უნდა ეძებს.

815
00:49:25,540 --> 00:49:28,970
იგი ჯერ კიდევ დარწმუნდით რომ ეს რეალურად მინიმალური.

816
00:49:28,970 --> 00:49:31,670
>> და ერთადერთი გზა, დარწმუნდით, რომ ის მინიმალური გამოყენებით ამ ალგორითმი,

817
00:49:31,670 --> 00:49:34,640
არის შევხედოთ თითოეული ელემენტს ერთხელ.

818
00:49:34,640 --> 00:49:38,420
ასე ნამდვილად, თუ თქვენ მისცეს მას - თუ მისცეს შერჩევის დალაგების უკვე დახარისხებული სია,

819
00:49:38,420 --> 00:49:42,720
ეს არ აპირებს რაიმე უკეთესი, ვიდრე ვაძლევთ მას სიაში რომ არ არის დახარისხებული ამჟამად.

820
00:49:42,720 --> 00:49:46,320
სხვათა შორის, თუ ეს მოხდება, რომ იყოს საქმე, რომ რაღაც არის O (რაღაც)

821
00:49:46,320 --> 00:49:50,640
და ომეგა რაღაცის, ჩვენ შეგვიძლია უბრალოდ, ვამბობთ მეტი succinctly რომ θ რაღაცის.

822
00:49:50,640 --> 00:49:52,760
ასე რომ, თუ ხედავთ, რომ ამუშავება არსად არის ის, რაც, რომ უბრალოდ ნიშნავს.

823
00:49:52,760 --> 00:49:57,580
>> თუ რამე არის Theta of n ², ეს როგორც დიდი O (N ²) და Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
ასე რომ საუკეთესო შემთხვევაში და უარეს შემთხვევაში, ეს არ მიიღოს განსხვავება,

825
00:49:59,790 --> 00:50:04,400
ალგორითმი აპირებს იგივე ყოველ ჯერზე.

826
00:50:04,400 --> 00:50:06,610
ასე რომ, ეს არის ის, რაც pseudocode შერჩევის დალაგება შეიძლება გამოიყურებოდეს.

827
00:50:06,610 --> 00:50:10,630
ჩვენ ძირითადად აპირებს ვთქვა, რომ მინდა iterate მეტი სია

828
00:50:10,630 --> 00:50:15,180
მარცხნიდან მარჯვნივ, და ყოველ iteration of მარყუჟის, მე ვაპირებ გადაადგილება

829
00:50:15,180 --> 00:50:19,780
მინიმალური ელემენტს ამ დახარისხებული ნაწილი სიაში.

830
00:50:19,780 --> 00:50:23,260
და კიდევ მე გადაადგილება რაღაც არსებობს, მე არასოდეს უნდა შევხედოთ, რომ ელემენტს ერთხელ.

831
00:50:23,260 --> 00:50:28,600
იმის გამო, რომ როგორც კი სვოპ ელემენტია მარცხნივ სეგმენტი სიაში, ეს დახარისხებული

832
00:50:28,600 --> 00:50:32,600
რადგან ვაკეთებთ ყველაფერს აღმავალი შეკვეთა გამოყენებით მინიმუმების.

833
00:50:32,600 --> 00:50:38,740
ამიტომ, ჩვენ განაცხადა, okay, ჩვენ პოზიციაში მე, და ჩვენ გვჭირდება შევხედოთ ყველა ელემენტები

834
00:50:38,740 --> 00:50:42,260
მარჯვნივ მე, რათა მინიმალური.

835
00:50:42,260 --> 00:50:46,150
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ გვინდა გამოიყურებოდეს საწყისი i + 1 სიის ბოლოში.

836
00:50:46,150 --> 00:50:51,610
და ახლა, თუ ის ელემენტი, რომელიც ჩვენ გაკეთებული ეძებს ნაკლებია, ვიდრე ჩვენი მინიმალური ჯერჯერობით

837
00:50:51,610 --> 00:50:54,190
რომელიც, გახსოვდეთ, რომ ჩვენ დაწყებული მინიმუმ off უბრალოდ იყოს

838
00:50:54,190 --> 00:50:57,020
რასაც ელემენტს ჩვენ ამჟამად, მე ვივარაუდოთ, რომ მინიმუმ.

839
00:50:57,020 --> 00:51:00,270
თუ მე ელემენტს, რომ უფრო მცირე, ვიდრე ის, რომ მაშინ მე ვაპირებ ვთქვა, okay,

840
00:51:00,270 --> 00:51:02,700
ასევე, მე აღმოვაჩინე ახალი მინიმალური.

841
00:51:02,700 --> 00:51:06,080
მე ვაპირებ გახსოვთ სადაც ეს მინიმალური იყო.

842
00:51:06,080 --> 00:51:09,560
>> ახლა, ერთხელ მე გავიარეთ, რომ უფლება არასორტირებული სეგმენტი,

843
00:51:09,560 --> 00:51:16,690
შემიძლია ვთქვა, მე ვაპირებ სვოპ მინიმალური ელემენტს ერთად ელემენტს, რომელიც თანამდებობა მე.

844
00:51:16,690 --> 00:51:21,100
რომ აპირებს შექმნას ჩემი სია, ჩემი დახარისხებული ნაწილი სიაში მარცხნიდან მარჯვნივ,

845
00:51:21,100 --> 00:51:25,190
და ჩვენ არ ოდესმე უნდა შევხედოთ ელემენტს ერთხელ კიდევ ის, რომ ნაწილი.

846
00:51:25,190 --> 00:51:27,930
ერთხელ ჩვენ swapped იგი.

847
00:51:27,930 --> 00:51:30,260
მოდით აწარმოებს შერჩევას დალაგების ამ სიაში.

848
00:51:30,260 --> 00:51:38,220
ლურჯი ელემენტს აქ იქნება მე და წითელი ელემენტს იქნება მინიმალური ელემენტს.

849
00:51:38,220 --> 00:51:41,570
ასე რომ იწყება ყველა გზა at მარცხენა სიის, ისე 5.

850
00:51:41,570 --> 00:51:44,610
ახლა ჩვენ გვჭირდება, მინიმუმ არასორტირებული ელემენტს.

851
00:51:44,610 --> 00:51:49,480
ამიტომ ვამბობთ 0 <5, ასე 0 არის ჩემი ახალი მინიმალური.

852
00:51:49,480 --> 00:51:53,820
>> მაგრამ მე ვერ შეაჩერებს იქ, რადგან მიუხედავად იმისა, რომ ჩვენ შეგვიძლია ვაღიაროთ, რომ 0 არის ყველაზე პატარა,

853
00:51:53,820 --> 00:51:59,390
ჩვენ გვჭირდება აწარმოებს მეშვეობით ყველა სხვა ელემენტის სიაში რომ დავრწმუნდეთ.

854
00:51:59,390 --> 00:52:01,760
ამგვარად 1 მეტია, 6 მეტია, 4 მეტია.

855
00:52:01,760 --> 00:52:05,850
ეს იმას ნიშნავს, რომ მას შემდეგ ეძებს ყველა ამ ელემენტების, მე განსაზღვრული 0 არის ყველაზე პატარა.

856
00:52:05,850 --> 00:52:09,800
ამიტომ მე ვაპირებ სვოპ 5 და 0.

857
00:52:09,800 --> 00:52:15,480
ერთხელ სვოპ რომ, მე ვაპირებ, რომ მიიღოთ ახალი სია, და ვიცი, რომ არასოდეს უნდა შევხედოთ, რომ 0 ერთხელ

858
00:52:15,480 --> 00:52:19,380
რადგან ერთხელ მე swapped იგი, მე დახარისხებული და ჩვენ გავაკეთეთ.

859
00:52:19,380 --> 00:52:22,730
ახლა კი ასე ხდება, რომ ლურჯი ელემენტს კვლავ 5,

860
00:52:22,730 --> 00:52:26,030
და ჩვენ გვჭირდება შევხედოთ 1, 6 და 4 რათა დადგინდეს, რომ 1

861
00:52:26,030 --> 00:52:31,520
არის პატარა მინიმალური ელემენტს, ამიტომ ჩვენ სვოპ 1 და 5.

862
00:52:31,520 --> 00:52:36,890
ერთხელ, ჩვენ უნდა შევხედოთ - შედარების 5 დან 6 და 4,

863
00:52:36,890 --> 00:52:39,830
და ჩვენ ვაპირებთ სვოპ 4 და 5 და ბოლოს, შედარების

864
00:52:39,830 --> 00:52:45,740
იმ 2 ნომრები და სვოპ მათ სანამ არ მივიღებთ ჩვენი დახარისხებული სია.

865
00:52:45,740 --> 00:52:49,730
ნებისმიერი კითხვები შერჩევის დალაგება?

866
00:52:49,730 --> 00:52:56,420
Okay. მოდით გადავა ბოლო თემა აქ, და რომ არის უკან.

867
00:52:56,420 --> 00:52:59,810
>> უკან, გახსოვდეთ, ეს მართლაც მეტა რამ სადაც ფუნქცია

868
00:52:59,810 --> 00:53:02,740
არაერთხელ უწოდებს თავად.

869
00:53:02,740 --> 00:53:05,620
ასე რომ რაღაც მომენტში, მაშინ, როდესაც ჩვენი ფუნქციის გამოსართავად არის არაერთხელ მოუწოდებდა თავად,

870
00:53:05,620 --> 00:53:10,100
იქ უნდა იყოს რაღაც მომენტში, რომლის დროსაც ჩვენ შეწყვიტოს მოუწოდებენ საკუთარ თავს.

871
00:53:10,100 --> 00:53:13,670
რადგან თუ ჩვენ არ გავაკეთებთ, მაშინ ჩვენ უბრალოდ გავაგრძელებთ ამის გაკეთებას სამუდამოდ,

872
00:53:13,670 --> 00:53:16,660
და ჩვენი პროგრამა უბრალოდ არ აპირებს შეწყვიტოს.

873
00:53:16,660 --> 00:53:19,200
ჩვენ მოვუწოდებთ ამ მდგომარეობა ბაზის შემთხვევაში.

874
00:53:19,200 --> 00:53:22,570
და ბაზის შემთხვევაში ამბობს, ვიდრე მოუწოდებდა ფუნქციის ერთხელ,

875
00:53:22,570 --> 00:53:25,330
მე უბრალოდ დაბრუნებას აპირებს გარკვეული მნიშვნელობა.

876
00:53:25,330 --> 00:53:28,080
ასე რომ ერთხელ ჩვენ დაბრუნდა ღირებულება, ჩვენ შეწყვიტა მოუწოდებდა საკუთარ თავს,

877
00:53:28,080 --> 00:53:32,550
და დანარჩენ მოუწოდებს ჩვენ ამ დრომდე ასევე შეუძლია დაბრუნდეს.

878
00:53:32,550 --> 00:53:36,050
საპირისპირო ბაზის საქმე რეკურსიული შემთხვევაში.

879
00:53:36,050 --> 00:53:39,050
და ეს არის, როცა ჩვენ გვსურს კიდევ ერთი ზარი ფუნქცია რომ ჩვენ გაკეთებული სისტემაში

880
00:53:39,050 --> 00:53:44,690
და ჩვენ ალბათ, თუმცა არა ყოველთვის, გინდათ გამოიყენოთ სხვადასხვა არგუმენტები.

881
00:53:44,690 --> 00:53:48,940
>> ასე რომ, თუ ჩვენ გვაქვს ფუნქცია მოუწოდა ვ და ვ უბრალოდ მოუწოდა მიიღოს 1 არგუმენტი,

882
00:53:48,940 --> 00:53:52,010
და ჩვენ უბრალოდ შეინახოს მოუწოდებდა ვ (1), ვ (1), ვ (1), და ეს ასე მოხდება, რომ

883
00:53:52,010 --> 00:53:56,510
არგუმენტი 1 იყოფა რეკურსიული შემთხვევაში, ჩვენ მაინც არასოდეს შევწყვეტთ.

884
00:53:56,510 --> 00:54:01,620
მაშინაც კი, თუ ჩვენ გვაქვს ბაზის შემთხვევაში, ჩვენ უნდა დავრწმუნდეთ, რომ საბოლოოდ ჩვენ ვაპირებთ მოხვდა, რომ ბაზის შემთხვევაში.

885
00:54:01,620 --> 00:54:04,250
ჩვენ არა მარტო შენარჩუნება დარჩენის ამ რეკურსიული შემთხვევაში.

886
00:54:04,250 --> 00:54:09,870
საერთოდ, როცა ჩვენ მოვუწოდებთ თავს, ჩვენ ალბათ გვექნება სხვადასხვა არგუმენტი ყოველ ჯერზე.

887
00:54:09,870 --> 00:54:12,700
აქ არის ნამდვილად მარტივი რეკურსიული ფუნქცია.

888
00:54:12,700 --> 00:54:15,090
ასე რომ, ეს იქნება გამოთვლაც factorial რიგი.

889
00:54:15,090 --> 00:54:17,790
Up ზემოთ აქ ჩვენ გვაქვს ჩვენი ბაზის შემთხვევაში.

890
00:54:17,790 --> 00:54:22,330
იმ შემთხვევაში, რომ n ≤ 1, ჩვენ არ ვაპირებთ, რომ მოვუწოდო factorial ერთხელ.

891
00:54:22,330 --> 00:54:26,490
ჩვენ ვაპირებთ შეჩერება, ჩვენ უბრალოდ დაბრუნებას აპირებს გარკვეული მნიშვნელობა.

892
00:54:26,490 --> 00:54:30,170
თუ ეს ასე არ არის, მაშინ ჩვენ ვაპირებთ მოხვდა ჩვენი რეკურსიული შემთხვევაში.

893
00:54:30,170 --> 00:54:33,550
გაითვალისწინეთ, რომ ჩვენ არა მხოლოდ მოუწოდებდა factorial (N), იმიტომ, რომ არ შეიძლება იყოს ძალიან სასარგებლო.

894
00:54:33,550 --> 00:54:36,810
ჩვენ ვაპირებთ, რომ მოვუწოდო factorial of რაღაც.

895
00:54:36,810 --> 00:54:40,850
>> და ა.შ. ხედავთ, საბოლოოდ, თუ ჩვენ გაიაროს factorial (5) ან რამე,

896
00:54:40,850 --> 00:54:45,900
ჩვენ ვაპირებთ მოვუწოდებთ factorial (4) და ასე შემდეგ, და საბოლოოდ ჩვენ ვაპირებთ მოხვდა ამ ბაზის შემთხვევაში.

897
00:54:45,900 --> 00:54:51,730
ასე რომ, ეს გამოიყურება კარგი. ვნახოთ რა მოხდება, როდესაც ჩვენ რეალურად აწარმოებს ამ.

898
00:54:51,730 --> 00:54:57,840
ეს არის დასტის, და ვთქვათ, რომ ძირითადი აპირებს მოვუწოდებთ ამ ფუნქციის არგუმენტი (4).

899
00:54:57,840 --> 00:55:02,200
ასე რომ ერთხელ factorial ხედავს და = 4, factorial კვლავ თავს.

900
00:55:02,200 --> 00:55:05,010
ახლა, მოულოდნელად, ჩვენ გვაქვს factorial (3).

901
00:55:05,010 --> 00:55:10,780
ასე რომ ამ ფუნქციების ვაპირებთ შენარჩუნება იზრდება, სანამ საბოლოოდ ჩვენ მოხვდა ჩვენი ბაზის შემთხვევაში.

902
00:55:10,780 --> 00:55:17,830
ამ ეტაპზე, დაბრუნების ღირებულება ეს დაბრუნების (NX დაბრუნებული მნიშვნელობა ამ),

903
00:55:17,830 --> 00:55:21,290
დაბრუნების ღირებულება ეს არის NX დაბრუნებული მნიშვნელობა ამ.

904
00:55:21,290 --> 00:55:23,290
საბოლოოდ ჩვენ უნდა მოხვდა რამდენიმე ნომერზე.

905
00:55:23,290 --> 00:55:26,560
ზედა აქ, ვამბობთ დაბრუნების 1.

906
00:55:26,560 --> 00:55:30,650
ეს იმას ნიშნავს, რომ ერთხელ ვბრუნდებით, რომ ნომერი, ჩვენ შეგვიძლია პოპ ამ off Stack.

907
00:55:30,650 --> 00:55:36,570
ასე რომ, ეს factorial (1) კეთდება.

908
00:55:36,570 --> 00:55:41,190
როდესაც 1 ანაზღაურება, ამ factorial (1) ანაზღაურება, ამ დაბრუნების 1.

909
00:55:41,190 --> 00:55:46,910
დაბრუნებული მნიშვნელობა ამ, გახსოვდეთ, იყო NX დაბრუნებული მნიშვნელობა ამ.

910
00:55:46,910 --> 00:55:50,720
ასე მოულოდნელად, ამ ბიჭს იცის, რომ მინდა დაბრუნების 2.

911
00:55:50,720 --> 00:55:55,910
>> ასე მახსოვს, დაბრუნდნენ ღირებულების ეს მხოლოდ NX დაბრუნებული მნიშვნელობა აქ.

912
00:55:55,910 --> 00:56:01,160
ახლა შეგვიძლია ვთქვათ, 3 x 2, და ბოლოს, აქ შეგვიძლია ვთქვათ,

913
00:56:01,160 --> 00:56:04,010
ეს მხოლოდ იქნება 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
და კიდევ ამ ანაზღაურება, მივიღებთ ქვემოთ ერთი მთელი რიცხვი შიგნით ძირითადი.

915
00:56:09,570 --> 00:56:15,460
ნებისმიერი შეკითხვა უკან?

916
00:56:15,460 --> 00:56:17,090
ყველა უფლება. ასე რომ იქ მეტი დრო კითხვები დასასრულს,

917
00:56:17,090 --> 00:56:23,360
მაგრამ ახლა ჯოზეფ დაფარავს დარჩენილი თემები.

918
00:56:23,360 --> 00:56:25,590
>> [ჯოზეფ Ong] ყველა უფლება. ახლა რომ ჩვენ ვისაუბრეთ recursions,

919
00:56:25,590 --> 00:56:27,840
ვისაუბროთ ცოტა იმაზე, თუ რა შერწყმა დალაგების არის.

920
00:56:27,840 --> 00:56:31,740
შერწყმა დალაგების ძირითადად სხვა გზა დახარისხება სიაში ნომრები.

921
00:56:31,740 --> 00:56:36,430
და როგორ მუშაობს არის, ერთად შერწყმა დალაგების გაქვთ სიაში, და რას ვაკეთებთ არის

922
00:56:36,430 --> 00:56:39,120
ჩვენ ვამბობთ, მოდით გაყოფილი ამ შევიდა 2 halves.

923
00:56:39,120 --> 00:56:42,750
ჩვენ პირველი აწარმოებს შერწყმა დალაგების კვლავ მარცხენა ნახევარში,

924
00:56:42,750 --> 00:56:45,040
მაშინ ჩვენ აწარმოებს შერწყმა დალაგების მარჯვენა ნახევარში,

925
00:56:45,040 --> 00:56:50,240
და რომ გვაძლევს არის 2 halves, რომლებიც დალაგებულია, და ახლა ჩვენ ვაპირებთ დააკავშიროთ იმ halves ერთად.

926
00:56:50,240 --> 00:56:55,010
ეს ცოტა რთული ვხედავ გარეშე მაგალითად, ასე ჩვენ გავლა შუამდგომლობა და ვნახოთ, რა მოხდება.

927
00:56:55,010 --> 00:56:59,590
ასე, რომ თქვენ იწყება ამ სიაში, ჩვენ გაყოფილი იგი 2 halves.

928
00:56:59,590 --> 00:57:02,300
ჩვენ აწარმოებს შერწყმა დალაგების მარცხენა ნახევარში პირველი.

929
00:57:02,300 --> 00:57:06,660
ასე რომ მარცხენა ნახევარში, და ახლა ჩვენ აწარმოებს მათ ამ სიაში კვლავ

930
00:57:06,660 --> 00:57:09,800
რომელიც იღებს შევიდა შერწყმა დალაგების, და შემდეგ გადავხედავთ, კიდევ ერთხელ,

931
00:57:09,800 --> 00:57:13,270
at მარცხენა მხარეს ამ სიაში და ჩვენ აწარმოებს შერწყმა დალაგების მასზე.

932
00:57:13,270 --> 00:57:15,880
ახლა ჩვენ კიდევ ქვევით სიაში 2 ნომრები,

933
00:57:15,880 --> 00:57:19,010
და ახლა მარცხენა ნახევარში არის მხოლოდ 1 ელემენტს ხანგრძლივი, და ჩვენ არ შეგვიძლია

934
00:57:19,010 --> 00:57:23,380
გაყოფილი სია რომ მხოლოდ 1 ელემენტს შევიდა ნახევარი, ასე რომ ჩვენ უბრალოდ, ვამბობთ, ერთხელ ჩვენ გვყავს 50,

935
00:57:23,380 --> 00:57:26,400
რომელიც მხოლოდ 1 ელემენტს, უკვე დახარისხებული.

936
00:57:26,400 --> 00:57:29,860
>> ერთხელ ჩვენ გაკეთდეს, რომ, ჩვენ ვხედავთ, რომ შეგვიძლია

937
00:57:29,860 --> 00:57:32,230
გადასვლა მარჯვნივ ნახევარში ამ სიაში,

938
00:57:32,230 --> 00:57:36,480
და 3 ასევე დახარისხებული და ა.შ. არის, რომ ორივე halves ამ სიაში არიან დახარისხებული

939
00:57:36,480 --> 00:57:39,080
ჩვენ შეგიძლიათ შეუერთდება ამ ნომრებზე უკან ერთად.

940
00:57:39,080 --> 00:57:45,320
ამიტომ, ჩვენ შევხედოთ 50 და 3; 3 მცირეა 50, ასე რომ მიდის და შემდეგ 50 მოდის შემოსული

941
00:57:45,320 --> 00:57:49,340
ახლა, რომ კეთდება, ჩვენ დავბრუნდებით მდე რომ სიაში და დალაგების ის მარჯვენა ნახევარში.

942
00:57:49,340 --> 00:57:52,440
42 არის საკუთარი ნომერი, ამიტომ უკვე დახარისხებული.

943
00:57:52,440 --> 00:57:57,850
ახლა შევადარებთ ამ 2 და 3 მცირეა 42, ასე რომ იღებს დასვა პირველი,

944
00:57:57,850 --> 00:58:02,340
ახლა 42 იღებს დასვა და 50 იღებს დააყენა სისტემაში

945
00:58:02,340 --> 00:58:07,220
ახლა, რომ დახარისხებული, ჩვენ წავიდეთ ყველა გზა თავში დაბრუნება, 1337 და 15.

946
00:58:07,220 --> 00:58:14,560
ასევე, ჩვენ ახლა შევხედოთ მარცხენა ნახევარში ამ სიაში; 1337 არის თავისთავად ამიტომ დახარისხებული და იგივე 15.

947
00:58:14,560 --> 00:58:19,020
ახლა ჩვენ დააკავშიროთ ამ 2 ნომრები დასალაგებლად რომ ორიგინალური სიაში, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
ასე რომ მიდის პირველი, მაშინ 1337 ღებულობენ სისტემაში

949
00:58:23,060 --> 00:58:26,640
და ახლა ჩვენ დახარისხებული ორივე halves of ორიგინალური სიაში up დაბრუნება.

950
00:58:26,640 --> 00:58:30,440
და ყველა ჩვენ უნდა გააკეთოთ დააკავშიროთ ამ.

951
00:58:30,440 --> 00:58:36,890
ჩვენ შევხედოთ პირველი 2 ნომრები ამ სიაში, 3 <15, ასე რომ გადადის დალაგების array პირველი.

952
00:58:36,890 --> 00:58:44,460
15 <42, ასე რომ მიდის შემოსული ახლა, 42 <1337, რომ მიდის შემოსული

953
00:58:44,460 --> 00:58:51,010
50 <1337, ასე რომ მიდის შემოსული და შეამჩნია, რომ ჩვენ უბრალოდ აიღო 2 ნომრები off ამ სიაში.

954
00:58:51,010 --> 00:58:53,640
ამიტომ ჩვენ არა მხოლოდ ალტერნატიული შორის 2 სიები.

955
00:58:53,640 --> 00:58:56,050
ჩვენ უბრალოდ ეძებს დასაწყისში, და ჩვენ აღების ელემენტს

956
00:58:56,050 --> 00:59:00,270
რომ უფრო მცირე და შემდეგ აყენებს იგი ჩვენი მასივი.

957
00:59:00,270 --> 00:59:04,080
ახლა ჩვენ გაერთიანდა ყველა halves და ჩვენ გავაკეთეთ.

958
00:59:04,080 --> 00:59:07,780
>> რაიმე კითხვა შერწყმა დალაგება? დიახ?

959
00:59:07,780 --> 00:59:14,190
[სტუდენტური] თუ ეს გაყოფის შევიდა სხვადასხვა ჯგუფების, რატომ არ მხოლოდ გაყოფილი ეს ერთხელ

960
00:59:14,190 --> 00:59:19,970
და თქვენ 3 და 2 ჯგუფი? [დანარჩენი კითხვა გაუგებარია]

961
00:59:19,970 --> 00:59:24,940
მიზეზი - ასე კითხვა არის, რატომ არ შეიძლება ჩვენ მხოლოდ შერწყმა მათ, რომ პირველი ნაბიჯი შემდეგ ჩვენ გვაქვს მათთან?

962
00:59:24,940 --> 00:59:29,530
მიზეზი ჩვენ შეგვიძლია ამის გაკეთება, იწყება მარცხენა საუკეთესო ელემენტები ორივე მხარეს,

963
00:59:29,530 --> 00:59:33,040
და შემდეგ მიიღოს პატარა ერთი და დააყენოს ის, ის არის, რომ ჩვენ ვიცით, რომ ეს

964
00:59:33,040 --> 00:59:35,290
ინდივიდუალური სიები არიან დახარისხებული ბრძანებებს.

965
00:59:35,290 --> 00:59:37,290
ასე რომ, თუ მე ვერ მარცხენა საუკეთესო ელემენტები ორივე halves,

966
00:59:37,290 --> 00:59:40,490
მე ვიცი, ისინი იქნება ყველაზე პატარა შემადგენელი ნაწილი იმ სიებში.

967
00:59:40,490 --> 00:59:43,930
ასე, რომ შეიძლება დააყენა მათი პატარა ელემენტს ლაქების ამ დიდი სია.

968
00:59:43,930 --> 00:59:47,810
მეორეს მხრივ, თუ გავითვალისწინებთ იმ 2 სიები მეორე დონეზე იქ,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 და 15, ეს ის არ დახარისხებული.

970
00:59:51,640 --> 00:59:55,770
ასე რომ, თუ გავითვალისწინებთ 50 და 1337, მე ვაპირებ დააყენა 50 ჩემს სიაში პირველი.

971
00:59:55,770 --> 01:00:00,130
მაგრამ ეს ნამდვილად არ აქვს აზრი, რადგან 3 არის ყველაზე პატარა ელემენტს გარეთ ყველა იმ.

972
01:00:00,130 --> 01:00:04,390
ასე რომ ერთადერთი მიზეზი, ჩვენ შეგვიძლია გავაკეთოთ ეს აერთიანებს ნაბიჯი არის, რადგანაც ჩვენი სიები უკვე დახარისხებული.

973
01:00:04,390 --> 01:00:07,010
სწორედ ამიტომ ჩვენ უნდა Get Down ყველა გზა ბოლოში

974
01:00:07,010 --> 01:00:09,800
რადგან, როდესაც ჩვენ გვაქვს მხოლოდ ერთი ნომერი, თქვენ იცით, რომ ერთი ნომერი

975
01:00:09,800 --> 01:00:14,120
და თავისთავად უკვე დახარისხებული სია.

976
01:00:14,120 --> 01:00:19,360
>> ნებისმიერი კითხვები? არარის?

977
01:00:19,360 --> 01:00:24,260
სირთულის? კარგად, ხედავთ, რომ ყოველი ნაბიჯი არსებობს ბოლომდე ნომრები,

978
01:00:24,260 --> 01:00:27,590
და ჩვენ შეგვიძლია დაყოფის სია ნახევარ შესვლა N ჯერ,

979
01:00:27,590 --> 01:00:31,700
რომელიც სადაც ჩვენ ამ N x შესვლა N სირთულის.

980
01:00:31,700 --> 01:00:34,940
და თქვენ ნახავთ საუკეთესო შემთხვევაში შერწყმა დალაგების არის N შესვლა n, და ეს ასე მოხდება

981
01:00:34,940 --> 01:00:39,340
რომ უარეს შემთხვევაში, ან Ω იქ, ასევე N შეხვიდეთ n.

982
01:00:39,340 --> 01:00:42,480
რაღაც გვახსოვდეს.

983
01:00:42,480 --> 01:00:45,750
მოძრავი, მოდით გაგრძელდება ზოგიერთ სუპერ ძირითადი ფაილის I / O.

984
01:00:45,750 --> 01:00:48,830
თუ შევხედე Scramble თქვენ შეამჩნევთ გვქონდა გარკვეული სისტემა

985
01:00:48,830 --> 01:00:51,270
სადაც თქვენ შეიძლება ჩაწერის შესვლა ფაილს თუ წაიკითხავთ მეშვეობით კოდი.

986
01:00:51,270 --> 01:00:53,730
ვნახოთ თუ როგორ შეიძლება გავაკეთოთ, რომ.

987
01:00:53,730 --> 01:00:57,450
ასევე, ჩვენ არ fprintf, რომელიც შეგიძლიათ წარმოიდგინოთ, რომ როგორც მხოლოდ printf,

988
01:00:57,450 --> 01:01:01,720
მაგრამ დაბეჭდვის to მაგივრად, და შესაბამისად ვ დასაწყისში.

989
01:01:01,720 --> 01:01:07,570
ეს ერთგვარი კოდი აქ, თუ რას აკეთებს არის, როგორც თქვენ ალბათ ჩანს Scramble,

990
01:01:07,570 --> 01:01:12,310
იგი გადის თქვენი 2 განზომილებიანი მასივი დაბეჭდვისას row მიერ მწკრივი, რა რაოდენობით.

991
01:01:12,310 --> 01:01:17,850
ამ შემთხვევაში, printf ბეჭდავს out თქვენს ტერმინალში ან რა ჩვენ მოვუწოდებთ სტანდარტული გამოშვება მონაკვეთზე.

992
01:01:17,850 --> 01:01:22,170
>> და ახლა, ამ შემთხვევაში, ყველა ჩვენ უნდა გავაკეთოთ არის ჩაანაცვლოს printf ერთად fprintf,

993
01:01:22,170 --> 01:01:26,770
გეტყვით იმას, რაც ფაილის გსურთ ბეჭდვა, და ამ შემთხვევაში ეს უბრალოდ ბეჭდავს მას აღმოჩნდება, რომ ფაილი

994
01:01:26,770 --> 01:01:32,230
ნაცვლად ბეჭდვა ეს იმისათვის, რომ თქვენი ტერმინალში.

995
01:01:32,230 --> 01:01:36,500
კარგად, მაშინ ეს სთხოვს კითხვა: სად მივიღებთ ამ სახის ფაილის, არა?

996
01:01:36,500 --> 01:01:39,840
ჩვენ გავიდა შესვლა ამ ფუნქციის გამოსართავად fprintf მაგრამ ჩვენ წარმოდგენაც კი არ ჰქონდათ, სადაც იგი მოვიდა.

997
01:01:39,840 --> 01:01:43,980
ისე, დასაწყისში კოდი, რაც ჩვენ გვქონდა იყო ამ ბლოკი კოდი მეტი აქ,

998
01:01:43,980 --> 01:01:48,340
რომლებიც ძირითადად ნათქვამია, რომ ღია ფაილი მოუწოდებს log.txt.

999
01:01:48,340 --> 01:01:53,220
რას ვაკეთებთ შემდეგ, რაც ჩვენ უნდა დავრწმუნდეთ, რომ ფაილი არის რეალურად გაიხსნა წარმატებით.

1000
01:01:53,220 --> 01:01:57,070
ასე რომ, შესაძლოა, ვერ ამისთვის რამდენიმე მიზეზი, თქვენ არ გაქვთ საკმარისი სივრცე თქვენს კომპიუტერში, მაგალითად.

1001
01:01:57,070 --> 01:01:59,790
ამიტომ ყოველთვის მნიშვნელოვანია, სანამ რაიმე ოპერაციების ფაილი

1002
01:01:59,790 --> 01:02:03,300
რომ ჩვენ შეამოწმოს თუ არა რომ ფაილი გაიხსნა წარმატებით.

1003
01:02:03,300 --> 01:02:09,330
მერე რა რომ, რომ არგუმენტი fopen, ასევე, ჩვენ შეგვიძლია გავხსნათ ფაილი ბევრი თვალსაზრისით.

1004
01:02:09,330 --> 01:02:13,510
რა შეგვიძლია გავაკეთოთ არის, ჩვენ შეგვიძლია მსგავ W, რაც იმას ნიშნავს, override ფაილს თუ ის ითიშება უკვე,

1005
01:02:13,510 --> 01:02:18,070
ჩვენ შეგვიძლია გაივლის, რომელიც მათ დამატება ბოლომდე ფაილის ნაცვლად მნიშვნელოვანი ის,

1006
01:02:18,070 --> 01:02:22,730
ან ჩვენ შეუძლია მიუთითოს r, რაც იმას ნიშნავს, მოდით გავხსნათ ფაილი, როგორც წაუკითხავი.

1007
01:02:22,730 --> 01:02:24,890
ასე რომ, თუ პროგრამა ცდილობს ნებისმიერი ცვლილება ფაილი,

1008
01:02:24,890 --> 01:02:30,140
დაწეროთ მათ და ნუ მათ ამის გაკეთება.

1009
01:02:30,140 --> 01:02:33,320
და ბოლოს, ერთხელ ჩვენ გაკეთდეს ფაილი, შესრულებულია აკეთებს ოპერაციებს მასზე,

1010
01:02:33,320 --> 01:02:35,860
ჩვენ უნდა დავრწმუნდეთ, ჩვენ დახურვა ფაილი.

1011
01:02:35,860 --> 01:02:38,830
და ა.შ. დასასრულს თქვენი პროგრამა, თქვენ არ გეგმავენ მათ ხელახლა

1012
01:02:38,830 --> 01:02:42,120
ამ ფაილის რომ თქვენ გახსნა, და მხოლოდ ვხურავთ მას.

1013
01:02:42,120 --> 01:02:44,650
ასე რომ, ეს არის რაღაც მნიშვნელოვანი, რომ თქვენ უნდა დავრწმუნდეთ, რომ თქვენ ამის გაკეთება.

1014
01:02:44,650 --> 01:02:47,180
ასე გვახსოვს შეგიძლიათ გახსნათ ფაილი, მაშინ ვწერ ფაილი,

1015
01:02:47,180 --> 01:02:51,270
გავაკეთოთ ოპერაციების ფაილი, მაგრამ მაშინ თქვენ უნდა დახუროთ ფაილის დასასრულს.

1016
01:02:51,270 --> 01:02:53,270
>> ნებისმიერი კითხვები ძირითადი ფაილის I / O? დიახ?

1017
01:02:53,270 --> 01:02:58,050
[სტუდენტური კითხვაზე, გაუგებარია]

1018
01:02:58,050 --> 01:03:02,480
მარჯვენა აქ. კითხვაზე, სადაც ამჯამად ამ log.txt ფაილი გამოჩნდება?

1019
01:03:02,480 --> 01:03:07,890
ისე, თუ უბრალოდ მისცეს მას log.txt, ის უქმნის მას იგივე დირექტორიაში, როგორც გაშვება.

1020
01:03:07,890 --> 01:03:10,500
ასე რომ, თუ you're - >> [სტუდენტური კითხვაზე, გაუგებარია]

1021
01:03:10,500 --> 01:03:18,830
დიახ. იმავე საქაღალდეში, ან იგივე დირექტორიაში, როგორც თქვენ ეძახით.

1022
01:03:18,830 --> 01:03:21,400
ახლა მეხსიერება, დასტის, და ბევრი.

1023
01:03:21,400 --> 01:03:23,400
მაშ როგორ არის მეხსიერება ასახული კომპიუტერი?

1024
01:03:23,400 --> 01:03:26,270
კარგად, თქვენ შეგიძლიათ წარმოიდგინოთ მეხსიერების როგორც დალაგების ამ ბლოკის აქ.

1025
01:03:26,270 --> 01:03:30,260
და მეხსიერებაში გვაქვს რასაც ბევრი დავრჩებოდით იქ, და დასტის რომ დახვდა.

1026
01:03:30,260 --> 01:03:34,480
და ბევრი იზრდება დაღმავალ და დასტის იზრდება აღმავალი.

1027
01:03:34,480 --> 01:03:38,620
ასე რომ, როგორც ტომი აღნიშნული - Oh, ისევე, და ჩვენ გვაქვს ამ სხვა 4 სეგმენტების რომელიც მე კიდევ ამ მეორე -

1028
01:03:38,620 --> 01:03:42,890
როგორც Tommy განაცხადა ადრე, თქვენ იცით, თუ რა იქნება მისი ფუნქციები მოვუწოდებთ თავს და მოვუწოდებთ ერთმანეთს?

1029
01:03:42,890 --> 01:03:44,930
მათ დაამყარონ ამ სახის დასტის ჩარჩო.

1030
01:03:44,930 --> 01:03:47,360
ისე, თუ მთავარ მოუწოდებს foo, foo იღებს ჩაიცვი Stack.

1031
01:03:47,360 --> 01:03:52,430
Foo მოუწოდებს ბარი, ბარი მიიღოს მისი დადგმა დასტის, და რომ იღებს ჩაიცვი დასტის შემდეგ.

1032
01:03:52,430 --> 01:03:57,040
და როგორც ისინი დაბრუნდებიან, ისინი ყოველ მისაღებად წაიყვანეს Stack.

1033
01:03:57,040 --> 01:04:00,140
რა თითოეულ ამ ადგილებში და მეხსიერების გამართავს?

1034
01:04:00,140 --> 01:04:03,110
ისე, ყველაზე, რომელიც ტექსტის სეგმენტის შეიცავს პროგრამა თავისთავად.

1035
01:04:03,110 --> 01:04:06,390
ასე რომ მანქანა კოდი, რომ იქ, ერთხელ თქვენ კომპილაციის თქვენი პროგრამა.

1036
01:04:06,390 --> 01:04:08,520
შემდეგი, ნებისმიერი ინიციალიზაცია გლობალური ცვლადები.

1037
01:04:08,520 --> 01:04:12,660
>> ასე რომ თქვენ არ გლობალური ცვლადები თქვენს პროგრამაში, და თქვენ ამბობთ, როგორიცაა, = 5,

1038
01:04:12,660 --> 01:04:15,260
რომ იღებს დასვა, რომ სეგმენტი, და უფლების რომ,

1039
01:04:15,260 --> 01:04:18,990
თქვენ გაქვთ რაიმე uninitialized გლობალური მონაცემები, რომელიც მხოლოდ int,

1040
01:04:18,990 --> 01:04:20,990
მაგრამ თქვენ არ ვამბობ, რომ ეს ტოლია არაფერი.

1041
01:04:20,990 --> 01:04:23,870
გააცნობიეროს ეს გლობალური ცვლადები, ამიტომ ისინი გარეთ მთავარი.

1042
01:04:23,870 --> 01:04:28,560
ასე რომ, ეს ნიშნავს ნებისმიერ გლობალური ცვლადები, რომლებიც გამოცხადდა, მაგრამ არ ინიციალიზდება.

1043
01:04:28,560 --> 01:04:32,310
ასე რომ რა ბევრი? მეხსიერება გამოყოფილი გამოყენებით malloc, რომელიც ჩვენ კიდევ ამ ცოტა.

1044
01:04:32,310 --> 01:04:35,990
და ბოლოს, ერთად დასტის თქვენ გაქვთ რაიმე ადგილობრივი ცვლადები

1045
01:04:35,990 --> 01:04:39,950
და ნებისმიერი ფუნქციები შეიძლება მოვუწოდებთ ნებისმიერი მათი პარამეტრების.

1046
01:04:39,950 --> 01:04:43,720
ბოლო რამ, თქვენ ნამდვილად არ უნდა ვიცოდეთ, თუ რა გარემოში ცვლადები გავაკეთოთ,

1047
01:04:43,720 --> 01:04:46,700
მაგრამ როდესაც თქვენ აწარმოებს პროგრამა, არსებობს რაღაც ასოცირდება, ისევე როგორც

1048
01:04:46,700 --> 01:04:49,550
ეს სახელი იმ პირზე, რომელიც გაიქცა პროგრამა.

1049
01:04:49,550 --> 01:04:51,550
და ეს იქნება ერთგვარი ბოლოში.

1050
01:04:51,550 --> 01:04:54,540
თვალსაზრისით მეხსიერების მისამართები, რომლებიც თექვსმეტობითი ღირებულებებს,

1051
01:04:54,540 --> 01:04:58,170
ღირებულებები ზედა იწყება 0, და ისინი წავიდეთ ყველა გზა ქვემოთ ბოლოში.

1052
01:04:58,170 --> 01:05:00,440
ამ შემთხვევაში, თუ თქვენ წლის 32-bit სისტემა,

1053
01:05:00,440 --> 01:05:05,390
მისამართი ბოლოში იქნება 0x, მოჰყვა AF, რადგან ისინი 32 ბიტი,

1054
01:05:05,390 --> 01:05:10,890
რომელიც 8 ბაიტი, და ამ შემთხვევაში 8 ბაიტი შეესაბამება 8 თექვსმეტობითი ციფრები.

1055
01:05:10,890 --> 01:05:20,110
ასე ქვევით აქ თქვენ აპირებს აქვს, ისევე, 0xffffff, და იქ თქვენ აპირებს აქვს 0.

1056
01:05:20,110 --> 01:05:23,660
რა არის პოინტერები? ზოგიერთ თქვენგანს შეიძლება არ დაფარული ამ ნაწილში ადრე.

1057
01:05:23,660 --> 01:05:26,660
მაგრამ ჩვენ არ წასვლა მას ლექციების, ამიტომ კურსორი არის უბრალოდ მონაცემები ტიპის

1058
01:05:26,660 --> 01:05:34,030
რომელიც მაღაზიებში, ნაცვლად გარკვეული ღირებულება, როგორიცაა 50, იგი ინახავს მისამართი ზოგიერთი საიდან მეხსიერებაში.

1059
01:05:34,030 --> 01:05:36,020
მომწონს, რომ მეხსიერების [გაუგებარია].

1060
01:05:36,020 --> 01:05:41,120
ასე რომ, ამ შემთხვევაში, რაც ჩვენ არ არის, ჩვენ გვაქვს მომცეთ მთელი რიცხვი ან int *,

1061
01:05:41,120 --> 01:05:46,210
და იგი შეიცავს ამ თექვსმეტობითი მისამართი 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> ასე რომ, რაც გვაქვს არის, ახლა, ამ მაჩვენებელმა რაოდენობა რაღაც საიდან მეხსიერებაში,

1063
01:05:50,880 --> 01:05:56,020
და ეს მხოლოდ, ღირებულება 50 არის ამ მეხსიერების საიდან.

1064
01:05:56,020 --> 01:06:01,810
ზოგიერთ 32-bit სისტემები, ყველა 32-bit სისტემები, მითითებები დასჭირდეს 32 ბიტი ან 4 ბაიტი.

1065
01:06:01,810 --> 01:06:06,020
მაგრამ, მაგალითად, 64-bit სისტემა, მითითებები 64 ბიტი.

1066
01:06:06,020 --> 01:06:08,040
ასე რომ რაღაც თქვენ მინდა გვახსოვდეს.

1067
01:06:08,040 --> 01:06:12,310
ასე ბოლომდე ბიტიანი სისტემა, კურსორი არის ბოლომდე ბიტი ხანგრძლივი.

1068
01:06:12,310 --> 01:06:17,320
მითითებები სახის რთული დაიჯესტს გარეშე ზედმეტი ნივთები,

1069
01:06:17,320 --> 01:06:20,300
მოდით გავლა მაგალითი დინამიური მეხსიერების გამოყოფის.

1070
01:06:20,300 --> 01:06:25,130
რა დინამიური მეხსიერების გამოყოფის აკეთებს თქვენთვის, ან ის, რაც ჩვენ მოვუწოდებთ malloc,

1071
01:06:25,130 --> 01:06:29,280
იგი საშუალებას გაძლევთ გამოყოს გარკვეული მონაცემები გარეთ კომპლექტი.

1072
01:06:29,280 --> 01:06:31,830
ასე რომ, ეს მონაცემები არის ერთგვარი უფრო ხანგრძლივვადიანი ამისთვის პროგრამის ხანგრძლივობა.

1073
01:06:31,830 --> 01:06:36,430
რადგან, როგორც იცით, თუ განაცხადოს x შიგნით ფუნქცია, და რომ ფუნქცია დააბრუნებს,

1074
01:06:36,430 --> 01:06:40,910
თქვენ აღარ ხელმისაწვდომობის მონაცემები, რომელიც ინახება x.

1075
01:06:40,910 --> 01:06:44,420
რა პოინტერები მოდით გავაკეთოთ არის ისინი მოდით შესანახად მეხსიერებაში ან მაღაზიის ღირებულებები

1076
01:06:44,420 --> 01:06:46,840
სხვადასხვა სეგმენტი მეხსიერება, კერძოდ ბევრი.

1077
01:06:46,840 --> 01:06:49,340
ახლა კიდევ ერთხელ ვბრუნდებით გარეთ ფუნქცია, რადგან ჩვენ გვაქვს მაჩვენებელი

1078
01:06:49,340 --> 01:06:54,960
იმ ადგილას მეხსიერება, მაშინ რა შეგვიძლია გავაკეთოთ არის შეგვიძლია შევჩერდეთ ღირებულებები არსებობს.

1079
01:06:54,960 --> 01:06:58,020
მოდით შევხედოთ მაგალითს: ეს არის ჩვენი მეხსიერება ერთხელ.

1080
01:06:58,020 --> 01:07:00,050
და ჩვენ გვაქვს ამ ფუნქციის მთავარი.

1081
01:07:00,050 --> 01:07:06,870
რა ეს იმას არის - Okay, ასე მარტივი, არა? - Int x = 5, ეს მხოლოდ ცვლადი on დასტის მთავარ.

1082
01:07:06,870 --> 01:07:12,450
>> მეორეს მხრივ, ახლა ვაცხადებთ მაჩვენებელი რომელიც მოუწოდებს ფუნქცია giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
და ა.შ. ახლა ჩვენ წასვლას ამ ფუნქციას და ჩვენ შევქმნით ახალ დასტის ჩარჩო ამისთვის.

1084
01:07:16,800 --> 01:07:20,440
თუმცა, ამ დასტის ჩარჩო ვაცხადებთ, int * temp,

1085
01:07:20,440 --> 01:07:23,210
რომელიც mallocs 3 რიცხვებით ჩვენთვის.

1086
01:07:23,210 --> 01:07:25,880
ასე ზომა int მოგვცემს რამდენი ბაიტი ამ int არის,

1087
01:07:25,880 --> 01:07:29,620
და malloc გვაძლევს, რომ ბევრი bytes სივრცის შესახებ ბევრი.

1088
01:07:29,620 --> 01:07:32,890
ასე რომ, ამ შემთხვევაში, ჩვენ შევქმენით საკმარისი ფართი 3 მთელი რიცხვები,

1089
01:07:32,890 --> 01:07:36,830
და ბევრი არის გზა up there, რის გამოც მე შედგენილი ეს უმაღლესი up.

1090
01:07:36,830 --> 01:07:42,900
ერთხელ ჩვენ გავაკეთეთ, ჩვენ დავბრუნდებით აქ, თქვენ საჭიროა მხოლოდ 3 ints დაბრუნდა,

1091
01:07:42,900 --> 01:07:47,000
და ის დააბრუნებს მისამართი, ამ შემთხვევაში მეტი აქ რომ მეხსიერება არის.

1092
01:07:47,000 --> 01:07:51,250
და ჩვენ დავსახეთ მაჩვენებელი = შეცვლა, და იქ გვაქვს კიდევ ერთი მაჩვენებელი.

1093
01:07:51,250 --> 01:07:54,550
მაგრამ რა, რომ ფუნქცია დააბრუნებს არის stacked აქ და ქრება.

1094
01:07:54,550 --> 01:07:59,250
ამიტომ temp ქრება, მაგრამ ჩვენ მაინც შევინარჩუნოთ მისამართი სადაც

1095
01:07:59,250 --> 01:08:01,850
იმ 3 რიცხვებით არის შიგნით მაგისტრალური.

1096
01:08:01,850 --> 01:08:06,180
ასე რომ ამ კომპლექტი, მითითებები scoped ადგილობრივად ამისთვის stacked ჩარჩო,

1097
01:08:06,180 --> 01:08:09,860
მაგრამ მეხსიერების რომელიც მათ ეხება არის ბევრი.

1098
01:08:09,860 --> 01:08:12,190
>> ამჯამად რომ აზრი?

1099
01:08:12,190 --> 01:08:14,960
[სტუდენტური] იქნებ გავიმეორო, რომ? >> [ჯოზეფ] დიახ.

1100
01:08:14,960 --> 01:08:20,270
ასე რომ, თუ მე დავუბრუნდეთ უბრალოდ ცოტა, ხედავთ, რომ Temp გამოყოფილი

1101
01:08:20,270 --> 01:08:23,500
ზოგიერთი მეხსიერების შესახებ ბევრი up there.

1102
01:08:23,500 --> 01:08:28,680
ასე რომ, როდესაც ამ ფუნქციას, giveMeThreeInts ანაზღაურება, ამ დასტის აქ აპირებს გაქრება.

1103
01:08:28,680 --> 01:08:35,819
და მასთან ერთად ნებისმიერ ცვლადები, ამ შემთხვევაში, ეს მაჩვენებელი, იყო გამოყოფილი stacked ჩარჩო.

1104
01:08:35,819 --> 01:08:39,649
რომ აპირებს ქრება, მაგრამ რადგან დავბრუნდით temp

1105
01:08:39,649 --> 01:08:46,330
და ჩვენ დავსახეთ მაჩვენებელი = temp, კურსორი ახლა ვაპირებ იგივე ხსოვნას საიდან როგორც temp იყო.

1106
01:08:46,330 --> 01:08:50,370
ახლა, მიუხედავად იმისა, რომ ჩვენ დასაკარგი temp, რომ ადგილობრივი მაჩვენებელი,

1107
01:08:50,370 --> 01:08:59,109
ჩვენ კვლავ ინარჩუნებს მეხსიერების მისამართი, რაც იყო მიუთითებს შიგნით რომ ცვლადი მაჩვენებელი.

1108
01:08:59,109 --> 01:09:03,740
კითხვები? რომელიც შეიძლება სახის დამაბნეველი თემის თუ არ წავიდა მას ნაწილში.

1109
01:09:03,740 --> 01:09:09,240
ჩვენ შეგვიძლია, თქვენი TF აუცილებლად წასვლა მას და რა თქმა უნდა უპასუხოს კითხვებს

1110
01:09:09,240 --> 01:09:11,500
დასასრულს საანგარიშო სხდომამდე ამ.

1111
01:09:11,500 --> 01:09:14,220
მაგრამ ეს არის ერთგვარი კომპლექსი თემის, და მე უფრო მეტი მაგალითები, რომ ვაპირებთ გამოჩნდება

1112
01:09:14,220 --> 01:09:18,790
რაც ხელს შეუწყობს გაერკვია რა პოინტერები რეალურად არიან.

1113
01:09:18,790 --> 01:09:22,500
>> ამ შემთხვევაში, მითითებები ექვივალენტი მასივები,

1114
01:09:22,500 --> 01:09:25,229
ასე, რომ შეიძლება უბრალოდ გამოიყენოს ეს მაჩვენებელი, როგორც იგივე როგორც int მასივი.

1115
01:09:25,229 --> 01:09:29,840
ამიტომ მე ინდექსირებას შევიდა 0, და შეცვლის პირველი რიცხვი 1,

1116
01:09:29,840 --> 01:09:39,689
შეცვლის მეორე რიცხვი 2, და მე -3 რიცხვი დან 3.

1117
01:09:39,689 --> 01:09:44,210
ასე უფრო პოინტერები. ისე, გავიხსენოთ Binky.

1118
01:09:44,210 --> 01:09:48,319
ამ შემთხვევაში ჩვენ გამოყოფილი კურსორი, ან ჩვენ დეკლარირებული მაჩვენებელი,

1119
01:09:48,319 --> 01:09:52,760
მაგრამ თავიდან, როცა მე მხოლოდ დეკლარირებული მაჩვენებელი, ეს არ მიუთითებს სადმე მეხსიერება.

1120
01:09:52,760 --> 01:09:54,930
უბრალოდ ნაგვის ღირებულებების შიგნით მას.

1121
01:09:54,930 --> 01:09:56,470
ასე რომ არ ვიცი, სადაც ეს მაჩვენებელი არის მიუთითებს.

1122
01:09:56,470 --> 01:10:01,630
მას აქვს მისამართზე, რომელიც მხოლოდ ივსება 0 და 1 ს, სადაც მას თავდაპირველად გამოაცხადა.

1123
01:10:01,630 --> 01:10:04,810
მე ვერაფერს ამ სანამ მოვუწოდებ malloc მასზე

1124
01:10:04,810 --> 01:10:08,390
და მაშინ მაძლევს პატარა სივრცე ბევრი სადაც შემიძლია დააყენა ღირებულებების შიგნით.

1125
01:10:08,390 --> 01:10:11,980
მერე ისევ, არ ვიცი რა შიგნით ამ მეხსიერებაში.

1126
01:10:11,980 --> 01:10:16,780
ასე რომ პირველი რაც უნდა გავაკეთოთ, არის თუ არა შეამოწმოთ სისტემა ჰქონდა საკმარისი მეხსიერება

1127
01:10:16,780 --> 01:10:20,850
მისცეს ჩემს უკან 1 რიცხვი პირველ რიგში, რის გამოც მე ამით შეამოწმოს.

1128
01:10:20,850 --> 01:10:25,020
თუ მაჩვენებელი არის null, რაც იმას ნიშნავს, რომ ეს არ გვაქვს საკმარისი სივრცე ან სხვა შეცდომა,

1129
01:10:25,020 --> 01:10:26,320
ასე რომ მე უნდა გამოხვიდეთ გარეთ ჩემი პროგრამა.

1130
01:10:26,320 --> 01:10:29,400
 მაგრამ თუ ეს მოხდა გამოუვათ, ახლა შემიძლია, რომ მომცეთ

1131
01:10:29,400 --> 01:10:35,020
და რა * მაჩვენებელი არ არის ეს შემდეგნაირად სადაც მისამართი

1132
01:10:35,020 --> 01:10:38,480
იქ, სადაც, რომ ღირებულება, და ის ისეთ ის ტოლია 1.

1133
01:10:38,480 --> 01:10:41,850
ასე რომ აქ, ჩვენ შემოწმების თუ მეხსიერების არსებობდა.

1134
01:10:41,850 --> 01:10:45,380
>> ერთხელ თქვენ იცით, რომ იგი არსებობს, შეგიძლიათ იდგა

1135
01:10:45,380 --> 01:10:50,460
რა ღირებულება გსურთ იდგა; ამ შემთხვევაში 1.

1136
01:10:50,460 --> 01:10:53,060
ერთხელ ჩვენ გავაკეთეთ ის, რაც თქვენ გჭირდებათ გასათავისუფლებლად რომ მომცეთ

1137
01:10:53,060 --> 01:10:57,160
რადგან ჩვენ უნდა დავუბრუნდეთ სისტემა, რომელიც მეხსიერების რომ თქვენ სთხოვა პირველ რიგში.

1138
01:10:57,160 --> 01:10:59,690
იმის გამო, რომ კომპიუტერი არ იცის, როდესაც ჩვენ გავაკეთეთ ეს.

1139
01:10:59,690 --> 01:11:02,510
ამ შემთხვევაში ჩვენ მკაფიოდ ვეუბნებოდი მას, okay, ჩვენ გაკეთდეს, რომ მეხსიერებაში.

1140
01:11:02,510 --> 01:11:10,780
თუ რაიმე სხვა პროცესი სჭირდება, ზოგიერთი სხვა პროგრამა სჭირდება, მოგერიდებათ წავიდეთ წინ და მიიღოს იგი.

1141
01:11:10,780 --> 01:11:15,110
რა შეგვიძლია ასევე გააკეთოთ შეგვიძლია უბრალოდ მისამართი ადგილობრივი ცვლადები on კომპლექტი.

1142
01:11:15,110 --> 01:11:19,080
ასე int x არის შიგნით stacked ფარგლებში ძირითადი.

1143
01:11:19,080 --> 01:11:23,060
ხოლო როდესაც ჩვენ ვიყენებთ ამ ampersand, ამ და ოპერატორს, თუ რას აკეთებს არის

1144
01:11:23,060 --> 01:11:27,310
სჭირდება x, და x არის რამოდენიმე მონაცემები მეხსიერებაში, მაგრამ მას აქვს მისამართზე.

1145
01:11:27,310 --> 01:11:33,790
მდებარეობს სადღაც. ასე დარეკვით & x, რა ეს არ არის ის გვაძლევს მისამართი x.

1146
01:11:33,790 --> 01:11:38,430
ამით, ჩვენ მიღების მაჩვენებელი წერტილი, სადაც x არის მეხსიერებაში.

1147
01:11:38,430 --> 01:11:41,710
ახლა ჩვენ უბრალოდ რაღაც * x, ჩვენ ვაპირებთ, რომ მიიღოთ 5 უკან.

1148
01:11:41,710 --> 01:11:43,820
ვარსკვლავი ეწოდება dereferencing იგი.

1149
01:11:43,820 --> 01:11:46,640
თქვენ დაიცვას მისამართი და თქვენ მიიღებთ ღირებულება შენახულ არსებობს.

1150
01:11:51,000 --> 01:11:53,310
>> ნებისმიერი კითხვები? დიახ?

1151
01:11:53,310 --> 01:11:56,500
[სტუდენტური] თუ არ გააკეთებს 3 აღნიშნა რამ, იგი ჯერ კიდევ ადგენენ?

1152
01:11:56,500 --> 01:11:59,490
დიახ. თუ არ გააკეთებს 3-კურსორი რამ, ეს გრძელდება შედგენა,

1153
01:11:59,490 --> 01:12:02,720
მაგრამ მე შენ გაჩვენებ რა ხდება მეორე, და გარეშე აკეთებს, რომ,

1154
01:12:02,720 --> 01:12:04,860
არის ის, რაც ჩვენ მოვუწოდებთ მეხსიერების გაჟონვის. თქვენ არ აძლევდა სისტემა

1155
01:12:04,860 --> 01:12:07,850
უკან მისი მეხსიერება, ასე შემდეგ, ხოლო პროგრამის აპირებს დაგროვება

1156
01:12:07,850 --> 01:12:10,940
მეხსიერება რომ ის გამოყენებით და სხვა არაფერი შეუძლია მისი გამოყენება.

1157
01:12:10,940 --> 01:12:15,750
თუ თქვენ ოდესმე მინახავს Firefox with 1.5 მილიონი kilobytes თქვენს კომპიუტერში,

1158
01:12:15,750 --> 01:12:17,840
in ამოცანა მენეჯერი არის ის, რაც ხდება.

1159
01:12:17,840 --> 01:12:20,760
თქვენ გაქვთ მეხსიერების გაჟონვის პროგრამაში რომ ისინი არ გატარება.

1160
01:12:23,080 --> 01:12:26,240
ასე როგორ მაჩვენებელი არითმეტიკა მუშაობს?

1161
01:12:26,240 --> 01:12:29,480
ისე, კურსორი არითმეტიკული არის ერთგვარი მოსწონს ინდექსირებას შევიდა მასივი.

1162
01:12:29,480 --> 01:12:36,370
ამ შემთხვევაში, მე მაქვს მაჩვენებელი, და რა გავაკეთო არის მე მაჩვენებელი წერტილი პირველ ელემენტს

1163
01:12:36,370 --> 01:12:42,100
ამ მასივი 3 მთელი რიცხვები, რომ მე გამოყოფილი.

1164
01:12:42,100 --> 01:12:46,670
ახლა რა ვქნა, ვარსკვლავი მაჩვენებელი მხოლოდ ცვლის პირველი ელემენტია სიაში.

1165
01:12:46,670 --> 01:12:49,140
Star მაჩვენებელი +1 რაოდენობა მეტი აქ.

1166
01:12:49,140 --> 01:12:53,140
ამიტომ კურსორი დასრულდა აქ, კურსორი +1 დასრულდა აქ, მაჩვენებელი +2 დასრულდა აქ.

1167
01:12:53,140 --> 01:12:56,610
>> ასე რომ მხოლოდ დასძინა 1 არის იგივე როგორც მოძრავი გასწვრივ ამ მასივი.

1168
01:12:56,610 --> 01:12:59,880
რას ვაკეთებთ არის, როდესაც ჩვენ გავაკეთებთ მაჩვენებელი +1 იღებთ მისამართი ზე მეტი აქ,

1169
01:12:59,880 --> 01:13:04,180
და მისაღებად ღირებულების აქ, თქვენ დააყენა ვარსკვლავს მთელი გამოხატვის

1170
01:13:04,180 --> 01:13:05,990
to dereference იგი.

1171
01:13:05,990 --> 01:13:09,940
ასე რომ, ამ შემთხვევაში, მე შექმნის პირველი საიდან ამ მასივი 1,

1172
01:13:09,940 --> 01:13:13,970
მეორე საიდან 2, და მესამე ადგილიდან 3.

1173
01:13:13,970 --> 01:13:18,180
აბა რა მე ვაკეთებ აქ არის მე დაბეჭდვის ჩვენი მაჩვენებელი +1,

1174
01:13:18,180 --> 01:13:19,970
რომელიც მხოლოდ მაძლევს 2.

1175
01:13:19,970 --> 01:13:23,650
ახლა მე დამატება მაჩვენებელი, ამიტომ კურსორი შეადგენს მაჩვენებელი +1,

1176
01:13:23,650 --> 01:13:26,780
რომელიც მოძრაობს ეს ნაბიჯი.

1177
01:13:26,780 --> 01:13:30,810
და ა.შ. ახლა თუ ამობეჭდოთ მაჩვენებელი +1, კურსორი +1 არის 3,

1178
01:13:30,810 --> 01:13:33,990
რომელიც ამ შემთხვევაში ბეჭდავს out 3.

1179
01:13:33,990 --> 01:13:36,560
და იმისთვის, უფასო რაღაც, მაჩვენებელი, მე ვაძლევ მას

1180
01:13:36,560 --> 01:13:40,540
უნდა მიუთითებს დასაწყისში მასივი, რომელიც მე მივიღე უკან malloc.

1181
01:13:40,540 --> 01:13:43,430
ასე რომ, ამ შემთხვევაში, მე რომ მოვუწოდო 3 უფლება აქ, ამ შემთხვევაში არ იქნება სწორი,

1182
01:13:43,430 --> 01:13:45,070
იმიტომ რომ შუა მასივი.

1183
01:13:45,070 --> 01:13:48,820
მე უნდა სხვაობა მისაღებად ორიგინალური საიდან

1184
01:13:48,820 --> 01:13:50,420
საწყის პირველ ადგილზე სანამ შეუძლია მას.

1185
01:13:56,300 --> 01:13:58,450
ასე რომ, აქ უფრო მეტად ჩართულნი მაგალითად.

1186
01:13:58,450 --> 01:14:03,360
ამ შემთხვევაში, ჩვენ გამოყოფის 7 სიმბოლოების ხასიათი მასივი.

1187
01:14:03,360 --> 01:14:06,480
>> და ამ შემთხვევაში იმას თუ რას ვაკეთებთ არის ჩვენ looping ზე პირველი 6 მათგანი,

1188
01:14:06,480 --> 01:14:09,900
და ჩვენ შექმნის მათ ზ

1189
01:14:09,900 --> 01:14:13,350
ასე რომ, ამისთვის int i = 0, i> 6, მე + +,

1190
01:14:13,350 --> 01:14:16,220
ასე რომ, კურსორი + მე მხოლოდ მოგვცეს, ამ შემთხვევაში,

1191
01:14:16,220 --> 01:14:20,860
მაჩვენებელი, რომელიც მაჩვენებელმა +1, +2 მაჩვენებელი, კურსორი +3 და ა.შ. და ა.შ. in loop.

1192
01:14:20,860 --> 01:14:24,040
რასაც ის აპირებს არის იგი იღებს, რომ მისამართი, dereferences რომ მივიღოთ ღირებულება,

1193
01:14:24,040 --> 01:14:27,440
და ცვლილებები, რომ ღირებულებას ზ

1194
01:14:27,440 --> 01:14:30,350
შემდეგ კი ბოლომდე გახსოვთ ეს სიმებიანი, არა?

1195
01:14:30,350 --> 01:14:33,560
ყველა სიმები უნდა დასრულდეს null შეწყვეტის ხასიათი.

1196
01:14:33,560 --> 01:14:38,620
ასე რომ, რა გავაკეთო არის მაჩვენებელი 6 მე ზუსტად null terminator ხასიათი სისტემაში

1197
01:14:38,620 --> 01:14:43,980
ხოლო რაც ახლა ხდება მე ძირითადად აკეთებს აქ ახორციელებს printf ამისთვის სიმებიანი, არა?

1198
01:14:43,980 --> 01:14:46,190
>> ასე რომ, როდესაც ამჯამად printf ახლა, როცა ის მიაღწია ბოლოს სიმებიანი?

1199
01:14:46,190 --> 01:14:48,230
როდესაც ის იგებს null შეწყვეტის ხასიათი.

1200
01:14:48,230 --> 01:14:52,030
ასე რომ, ამ შემთხვევაში, ჩემი ორიგინალური მაჩვენებელი მიუთითებს დასაწყისში მასივი.

1201
01:14:52,030 --> 01:14:56,410
მე ბეჭდვა პირველ სიმბოლოს გარეთ. მე გადატანა მეტი ერთი.

1202
01:14:56,410 --> 01:14:58,420
მე ბეჭდვა რომ ხასიათი გარეთ. მე გადატანა დასრულდა.

1203
01:14:58,420 --> 01:15:02,180
მე აკეთეთ ამ სანამ მიაღწევს ბოლომდე.

1204
01:15:02,180 --> 01:15:07,750
და ახლა ბოლომდე * მაჩვენებელი იქნება dereference ამ და კიდევ null შეწყვეტის ხასიათი უკან.

1205
01:15:07,750 --> 01:15:11,780
და ა.შ. ჩემი ხოლო loop გადის მხოლოდ იმ შემთხვევაში, რომ ღირებულება არ null შეწყვეტის ხასიათი.

1206
01:15:11,780 --> 01:15:13,770
ასე რომ, ახლა მე გაითიშება ამ loop.

1207
01:15:18,780 --> 01:15:21,180
და ასე თუ სხვაობა 6 ამ მაჩვენებელმა,

1208
01:15:21,180 --> 01:15:22,860
მე დაბრუნდეს ყველა გზა დასაწყისია.

1209
01:15:22,860 --> 01:15:27,880
გახსოვდეთ, მე ამით, რადგან მე წასვლა დასაწყისში, რათა გაათავისუფლონ იგი.

1210
01:15:27,880 --> 01:15:30,270
>> ასე რომ, მე ვიცი, რომ იყო ბევრი. არსებობს რაიმე კითხვები?

1211
01:15:30,270 --> 01:15:31,870
გთხოვთ, დიახ?

1212
01:15:31,870 --> 01:15:36,610
[სტუდენტური კითხვა გაუგებარია]

1213
01:15:36,610 --> 01:15:38,190
შეგიძლიათ აცხადებენ, რომ louder? უკაცრავად.

1214
01:15:38,190 --> 01:15:44,140
[სტუდენტური] On ბოლო slide უფლება სანამ გათავისუფლდა მაჩვენებელი,

1215
01:15:44,140 --> 01:15:47,300
სადაც თქვენ რეალურად შეცვლის ღირებულება მაჩვენებელი?

1216
01:15:47,300 --> 01:15:50,370
[ჯოზეფ] ასე რომ, უფლება აქ. >> [სტუდენტური] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[ჯოზეფ] ასე რომ, მე მაჩვენებელი მინუს მინუს, უფლება,

1218
01:15:51,890 --> 01:15:54,140
რომელიც მოძრაობს რამ თავში ერთი, და მერე გასათავისუფლებლად ეს,

1219
01:15:54,140 --> 01:15:57,000
რადგან ეს მაჩვენებელი უნდა აღინიშნოს, რომ დასაწყისში მასივი.

1220
01:15:57,000 --> 01:16:00,420
[სტუდენტური] მაგრამ ეს არ იქნება საჭირო იყო თქვენ შეწყვიტეთ შემდეგ რომ ხაზი.

1221
01:16:00,420 --> 01:16:03,130
[ჯოზეფ] ასე რომ, თუ შეწყდა მას შემდეგ, რაც ამ, ამ შემთხვევაში განიხილება მეხსიერების გაჟონვის,

1222
01:16:03,130 --> 01:16:04,810
იმიტომ, რომ მე არ აწარმოებს უფასო.

1223
01:16:04,810 --> 01:16:11,290
[სტუდენტური] მე [გაუგებარია] შემდეგ პირველი სამი ხაზები სადაც თქვენ ჰქონდა მაჩვენებელი +1 [გაუგებარია].

1224
01:16:11,290 --> 01:16:13,140
[ჯოზეფ] Uh-huh. რა არის კითხვა არსებობს?

1225
01:16:13,140 --> 01:16:14,780
უკაცრავად. არა, არა. წადი, წადით, გთხოვთ.

1226
01:16:14,780 --> 01:16:16,870
[სტუდენტური] ასე რომ, თქვენ არ შეცვლის ღირებულება პოინტერები.

1227
01:16:16,870 --> 01:16:19,130
თქვენ არ უნდა გაეკეთებინათ მაჩვენებელი მინუს მინუს.

1228
01:16:19,130 --> 01:16:19,730
[ჯოზეფ] დიახ, ზუსტად.

1229
01:16:19,730 --> 01:16:21,890
ასე რომ, როდესაც გავაკეთო მაჩვენებელი +1 და +2 მაჩვენებელი,

1230
01:16:21,890 --> 01:16:24,410
მე არ აკეთებს მაჩვენებელი შეადგენს მაჩვენებელი +1.

1231
01:16:24,410 --> 01:16:27,260
ასე რომ, მხოლოდ კურსორი რჩება მიუთითებს დასაწყისში მასივი.

1232
01:16:27,260 --> 01:16:31,460
ეს მხოლოდ მაშინ, როცა გავაკეთო Plus Plus, რომ ის ისეთ ღირებულება უკან შიგნით მაჩვენებელი,

1233
01:16:31,460 --> 01:16:33,550
რომ ის რეალურად მოძრაობს ამ გასწვრივ.

1234
01:16:36,860 --> 01:16:37,780
ყველა უფლება.

1235
01:16:40,550 --> 01:16:42,030
სხვა კითხვები?

1236
01:16:44,680 --> 01:16:47,790
>> ისევ და ისევ, თუ ეს ერთგვარი აბსოლუტური, ეს იქნება დაფარული სხდომაზე.

1237
01:16:47,790 --> 01:16:50,710
დასვით თქვენი სწავლების თანამემამულე ამის შესახებ, და ჩვენ შეგვიძლია უპასუხოს კითხვებს დასასრულს.

1238
01:16:53,510 --> 01:16:56,600
და ჩვეულებრივ ჩვენ არ მოგვწონს ამის მინუს რამ.

1239
01:16:56,600 --> 01:16:59,760
ეს უნდა მოითხოვოს ჩემთვის შენახვა ტრეკზე, თუ რამდენად მე ოფსეტური მასივში.

1240
01:16:59,760 --> 01:17:04,520
ასე რომ, ზოგადად, ეს მხოლოდ ასახსნელად, თუ როგორ მაჩვენებელი არითმეტიკული სამუშაოები.

1241
01:17:04,520 --> 01:17:07,970
მაგრამ ის, რაც ჩვენ, ჩვეულებრივ, მინდა გააკეთოთ ჩვენ გვსურს შევქმნათ ასლი მაჩვენებელი,

1242
01:17:07,970 --> 01:17:11,640
და მაშინ საბოლოოდ დავრწმუნდებით, რომ გამოიყენოთ ასლი, როდესაც ჩვენ გადაადგილდებოდნენ in string.

1243
01:17:11,640 --> 01:17:14,660
ასე რომ, ამ შემთხვევაში თუ თქვენ გამოიყენოთ ასლი ბეჭდვა მთელი ტექსტი,

1244
01:17:14,660 --> 01:17:19,040
მაგრამ ჩვენ არ უნდა გავაკეთოთ, როგორიცაა მაჩვენებელი მინუს 6 ან ტრეკზე რამდენად გადავედით ამ,

1245
01:17:19,040 --> 01:17:22,700
მხოლოდ იმიტომ, რომ ჩვენ ვიცით, რომ ჩვენი ორიგინალური წერტილი კვლავ აღნიშნა, რომ დასაწყისში სიაში

1246
01:17:22,700 --> 01:17:25,340
და ყველა, რომ ჩვენ შეცვლილი იყო ეს ასლი.

1247
01:17:25,340 --> 01:17:28,250
ასე რომ, ზოგადად, შეცვალოს ასლები თქვენი ორიგინალური მაჩვენებელი.

1248
01:17:28,250 --> 01:17:32,350
ნუ ეცდებით სახის მოსწონს - don't შეცვალოს ორიგინალური ასლები.

1249
01:17:32,350 --> 01:17:35,290
ცდილობს შეცვალოს მხოლოდ ასლები თქვენი ორიგინალური.

1250
01:17:41,540 --> 01:17:44,870
ასე რომ, თქვენ შეამჩნევთ, როდესაც ჩვენ გაიაროს სიმებიანი შევიდა printf

1251
01:17:44,870 --> 01:17:48,990
თქვენ არ უნდა დააყენოს ვარსკვლავი წინაშე მას ისე, როგორც ყველა სხვა dereferences, არა?

1252
01:17:48,990 --> 01:17:54,180
ასე რომ, თუ თქვენ ამობეჭდოთ მთელი სიმებიანი% s მოელის არის მისამართი,

1253
01:17:54,180 --> 01:17:57,610
და ამ შემთხვევაში მაჩვენებელი ან ამ შემთხვევაში, როგორიცაა მასივი სიმბოლო.

1254
01:17:57,610 --> 01:18:00,330
>> პერსონაჟები, char * s, და კოლექტორები არის იგივე.

1255
01:18:00,330 --> 01:18:03,690
Pointer არის გმირები, და ხასიათი კოლექტორები არის იგივე.

1256
01:18:03,690 --> 01:18:05,720
ასე რომ, ყველა ჩვენ უნდა გააკეთოთ კორიდორი მაჩვენებელი.

1257
01:18:05,720 --> 01:18:08,150
ჩვენ არ უნდა გაიარონ მსგავსად * კურსორი ან არაფერი რომ.

1258
01:18:13,110 --> 01:18:14,930
ასე რომ, კოლექტორები და მითითებები იგივე.

1259
01:18:14,930 --> 01:18:19,160
როდესაც თქვენ აკეთებთ რაღაც x [y] მეტი აქ მასივი,

1260
01:18:19,160 --> 01:18:21,960
რასაც ის აკეთებს ქვეშ hood არის ის ამბობდა, okay, ეს ხასიათი მასივი,

1261
01:18:21,960 --> 01:18:23,690
ამიტომ კურსორი.

1262
01:18:23,690 --> 01:18:26,510
და ა.შ. x არიან იგივე,

1263
01:18:26,510 --> 01:18:28,650
და ასე თუ რას აკეთებს არის ის დასძენს y to x,

1264
01:18:28,650 --> 01:18:31,820
რაც იგივე როგორც წინსვლის მეხსიერებაში, რომ ბევრი რამ.

1265
01:18:31,820 --> 01:18:34,930
და ახლა x + y გვაძლევს გარკვეული მისამართი,

1266
01:18:34,930 --> 01:18:37,570
და ჩვენ dereference მისამართი ან მიჰყევით arrow

1267
01:18:37,570 --> 01:18:41,640
იქ, სადაც, რომ მდებარეობის მეხსიერება და მივიღებთ მნიშვნელობა საზღვრებს რომ საიდან მეხსიერებაში.

1268
01:18:41,640 --> 01:18:43,720
ასე რომ, ისე ამ ორ ზუსტად იმავეს.

1269
01:18:43,720 --> 01:18:45,840
უბრალოდ სინტაქსური შაქარი.

1270
01:18:45,840 --> 01:18:48,090
ისინი იგივე. ისინი უბრალოდ სხვადასხვა syntactics ერთმანეთის.

1271
01:18:51,500 --> 01:18:57,590
>> ასე რომ, რა შეიძლება ცუდი პოინტერები? მსგავსად, უამრავი. Okay. ასე რომ, ცუდი რამ.

1272
01:18:57,590 --> 01:19:02,410
ზოგიერთი ცუდი რამ რისი გაკეთებაც შეგიძლიათ არ შემოწმების თუ თქვენი malloc ზარის ბრუნდება null, არა?

1273
01:19:02,410 --> 01:19:06,560
ამ შემთხვევაში, მე გეკითხებით სისტემის მომეცი - რა არის ეს რიცხვი?

1274
01:19:06,560 --> 01:19:11,200
მსგავსად 2 მილიარდი ჯერ 4, რადგან ზომის მთელი რიცხვი არის 4 ბაიტი.

1275
01:19:11,200 --> 01:19:13,810
მე გეკითხებით ეს მოსწონს 8 მილიარდ ბაიტს.

1276
01:19:13,810 --> 01:19:17,270
რა თქმა უნდა, ჩემი კომპიუტერი არ აპირებს შეძლებენ მაძლევს, რომ ბევრი რამ მეხსიერებაში უკან.

1277
01:19:17,270 --> 01:19:20,960
და ჩვენ არ შეამოწმოთ თუ ეს null, ამიტომ, როდესაც ვცდილობთ dereference მას იქ -

1278
01:19:20,960 --> 01:19:24,270
დაიცვას ისარი სადაც იგი აპირებს - ჩვენ არ გვაქვს, რომ მეხსიერებაში.

1279
01:19:24,270 --> 01:19:27,150
ეს არის ის, რაც ჩვენ მოვუწოდებთ dereferencing null მაჩვენებელი.

1280
01:19:27,150 --> 01:19:29,710
და ეს არსებითად იწვევს თქვენ segfault.

1281
01:19:29,710 --> 01:19:31,790
ეს არის ერთ გზები შეგიძლიათ segfault.

1282
01:19:34,090 --> 01:19:38,090
სხვა ცუდი რამ რისი გაკეთებაც შეგიძლიათ - Oh კარგად.

1283
01:19:38,090 --> 01:19:40,650
ამის dereferencing null მაჩვენებელი. Okay.

1284
01:19:40,650 --> 01:19:45,160
სხვა ცუდი - კარგად, დაფიქსირება, რომ თქვენ მხოლოდ დააყენა გამშვები იქ

1285
01:19:45,160 --> 01:19:46,980
რომელიც ამოწმებს თუ არა კურსორის არის null

1286
01:19:46,980 --> 01:19:51,000
და გასვლის გარეთ პროგრამა თუ ეს მოხდება, რომ malloc ბრუნდება null მაჩვენებელი.

1287
01:19:55,110 --> 01:19:59,850
სწორედ xkcd კომიკური. ხალხს კარგად ესმის ის არის. სახის.

1288
01:20:06,120 --> 01:20:09,350
>> ასე რომ, მეხსიერება. და მივედი ამ.

1289
01:20:09,350 --> 01:20:12,000
ჩვენ მოუწოდებდა malloc in loop, მაგრამ ყოველ ჯერზე ჩვენ მოვუწოდებთ malloc

1290
01:20:12,000 --> 01:20:14,370
ჩვენ ვკარგავთ კვალს, სადაც ეს მაჩვენებელი არის მიუთითებს,

1291
01:20:14,370 --> 01:20:15,750
რადგან ჩვენ clobbering იგი.

1292
01:20:15,750 --> 01:20:18,410
ასე რომ, საწყის ზარი malloc მაძლევს მეხსიერების მეტი აქ.

1293
01:20:18,410 --> 01:20:19,990
ჩემი კურსორი მითითებას ამ.

1294
01:20:19,990 --> 01:20:23,020
ახლა, მე არ გასათავისუფლებლად, ასე რომ ახლავე მოვუწოდებ malloc ერთხელ.

1295
01:20:23,020 --> 01:20:26,070
ახლა კი მიუთითებს მეტი აქ. არის ჩემი მეხსიერების მიუთითებს მეტი აქ.

1296
01:20:26,070 --> 01:20:27,640
მიმანიშნებელი მეტი აქ. მიმანიშნებელი მეტი აქ.

1297
01:20:27,640 --> 01:20:31,820
მაგრამ მე დავკარგე კვალს მისამართები ყველა მეხსიერების მეტი აქ, რომ მე გამოყოფილი.

1298
01:20:31,820 --> 01:20:35,100
და ახლა მე არ მაქვს რაიმე მინიშნება მათ უქმნით.

1299
01:20:35,100 --> 01:20:37,230
ასე რომ, მე ვერ გასათავისუფლებლად მათ გარეთ ამ loop.

1300
01:20:37,230 --> 01:20:39,390
და რათა მოხდეს დაფიქსირება მსგავსი რამ,

1301
01:20:39,390 --> 01:20:42,250
თუ თქვენ დაგავიწყდებათ თავისუფალი მეხსიერების და თქვენ მიიღებთ ამ მეხსიერების გაჟონვის,

1302
01:20:42,250 --> 01:20:45,810
თქვენ უნდა გასათავისუფლებლად მეხსიერების შიგნით ამ loop ერთხელ თქვენ კეთდება ეს.

1303
01:20:45,810 --> 01:20:51,400
ისე, ეს რა ხდება. მე ვიცი ბევრი თქვენ სიძულვილი ამ.

1304
01:20:51,400 --> 01:20:55,270
მაგრამ ახლა - YAY! თქვენ მიიღებთ მოსწონს 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
ასე რომ, თქვენ გასათავისუფლებლად ეს დასასრულს მარყუჟის,

1306
01:20:57,110 --> 01:20:59,770
და რომ აპირებს მხოლოდ გასათავისუფლებლად მეხსიერების ყოველ ჯერზე.

1307
01:20:59,770 --> 01:21:03,620
არსებითად, თქვენი პროგრამა არ აქვს მეხსიერების გაჟონვის უქმნით.

1308
01:21:03,620 --> 01:21:08,150
>> და ახლა რაღაც შეგიძლიათ გააკეთოთ უფასოა ზოგიერთი მეხსიერების რომ თქვენ სთხოვა ორჯერ.

1309
01:21:08,150 --> 01:21:11,060
ამ შემთხვევაში, თქვენ malloc რაღაც, თქვენ შეცვალოს მისი ღირებულება.

1310
01:21:11,060 --> 01:21:13,140
თქვენ გასათავისუფლებლად ეს ერთხელ რადგან თქვენ თქვით თქვენ კეთდება ეს.

1311
01:21:13,140 --> 01:21:14,940
მაგრამ მაშინ ჩვენ გათავისუფლდა ხელახლა.

1312
01:21:14,940 --> 01:21:16,730
ეს არის ის, რაც საკმაოდ ცუდი.

1313
01:21:16,730 --> 01:21:18,820
ის არ აპირებს თავდაპირველად segfault,

1314
01:21:18,820 --> 01:21:23,350
მაგრამ მას შემდეგ, ხოლო რა ამ ამჯამად არის ორმაგი ათავისუფლებს ამ თვალსაზრისით თქვენი ბევრი სტრუქტურა,

1315
01:21:23,350 --> 01:21:27,200
და თქვენ ვისწავლოთ ცოტა მეტი ამ შემთხვევაში თქვენ მიიღოს კლასის მოსწონს CS61.

1316
01:21:27,200 --> 01:21:30,000
მაგრამ არსებითად შემდეგ, ხოლო თქვენი კომპიუტერი აპირებს მისაღებად დაბნეული

1317
01:21:30,000 --> 01:21:33,010
იმაზე, თუ რა მეხსიერების ადგილებში არიან სად და სადაც ეს ინახება -

1318
01:21:33,010 --> 01:21:34,800
სადაც მონაცემები ინახება მეხსიერებაში.

1319
01:21:34,800 --> 01:21:38,080
და ასე გამონთავისუფლების მაჩვენებელი ორჯერ არის ცუდი რამ რომ თქვენ არ გსურთ.

1320
01:21:38,080 --> 01:21:41,600
>> სხვა რამ, რაც შეიძლება წავიდეთ არასწორი არ არის გამოყენებით sizeof.

1321
01:21:41,600 --> 01:21:44,460
ასე რომ, ამ შემთხვევაში თქვენ malloc 8 ბაიტი,

1322
01:21:44,460 --> 01:21:46,700
და ეს იგივე როგორც ორი მთელი რიცხვები, არა?

1323
01:21:46,700 --> 01:21:49,580
ასე რომ, რომ შესანიშნავად უსაფრთხოა, მაგრამ არის ეს?

1324
01:21:49,580 --> 01:21:52,160
ისე, როგორც ლუკას ისაუბრა სხვადასხვა არქიტექტორები,

1325
01:21:52,160 --> 01:21:54,220
მთელი რიცხვები სხვადასხვა lengths.

1326
01:21:54,220 --> 01:21:57,970
ასე რომ, მე ელექტრო მოწყობილობების, რომ თქვენ იყენებთ, მთელი რიცხვები დაახლოებით 4 ბაიტი,

1327
01:21:57,970 --> 01:22:02,370
მაგრამ ზოგიერთ სხვა სისტემაში, შესაძლოა, მათ 8 ბაიტი ან, შესაძლოა, მათ 16 ბაიტი.

1328
01:22:02,370 --> 01:22:05,680
ასე რომ, თუ უბრალოდ გამოიყენოთ ეს რიცხვი მეტი აქ,

1329
01:22:05,680 --> 01:22:07,310
ამ პროგრამის შეიძლება მუშაობა ელექტრო მოწყობილობების,

1330
01:22:07,310 --> 01:22:10,360
მაგრამ ეს არ გამოყოს საკმარისი მეხსიერების ზოგიერთ სხვა სისტემაში.

1331
01:22:10,360 --> 01:22:14,020
ამ შემთხვევაში, ეს არის ის, რაც sizeof ოპერატორი გამოიყენება.

1332
01:22:14,020 --> 01:22:16,880
როდესაც ჩვენ მოვუწოდებთ sizeof (int), რა ეს არ არის

1333
01:22:16,880 --> 01:22:21,910
 ეს გვაძლევს ზომა რიცხვი on სისტემა, რომელიც პროგრამა გაშვებული.

1334
01:22:21,910 --> 01:22:25,490
ასე რომ, ამ შემთხვევაში, sizeof (int) დაბრუნდება 4 წლის რაღაც ელექტრო მოწყობილობების,

1335
01:22:25,490 --> 01:22:29,980
და ახლა ეს ნება 4 * 2, რომელიც 8,

1336
01:22:29,980 --> 01:22:32,330
რომელიც მხოლოდ თანხის სივრცეში აუცილებელია ორი რიცხვებით.

1337
01:22:32,330 --> 01:22:36,710
წლის სხვადასხვა სისტემა, თუ int ჰგავს 16 ბაიტი ან 8 ბაიტი,

1338
01:22:36,710 --> 01:22:39,380
უბრალოდ დაბრუნებას აპირებს საკმარისი bytes შესანახად, რომ თანხა.

1339
01:22:41,830 --> 01:22:45,310
>> და ბოლოს, structs.

1340
01:22:45,310 --> 01:22:48,340
ასე რომ, თუ თქვენ სურდა შესანახად Sudoku საბჭოს მეხსიერება, როგორ შეიძლება გავაკეთოთ ეს?

1341
01:22:48,340 --> 01:22:51,570
თქვენ ალბათ ფიქრობთ, მსგავსი ცვლადი პირველად რამ,

1342
01:22:51,570 --> 01:22:53,820
ცვლადი მეორე რამ, ცვლადი მესამე რამ,

1343
01:22:53,820 --> 01:22:56,420
ცვლადი უკვე მეოთხედ რამ - ცუდი, არა?

1344
01:22:56,420 --> 01:23:00,750
ასე რომ, ერთი გაუმჯობესება შეგიძლიათ თავზე ეს რათა 9 x 9 მასივი.

1345
01:23:00,750 --> 01:23:04,480
სწორედ ჯარიმა, მაგრამ რა თუ თქვენ სურდა გაერთიანების სხვა რამ ერთად Sudoku ფორუმში

1346
01:23:04,480 --> 01:23:06,490
მსგავსი იმისა, რაც სირთულე გამგეობა,

1347
01:23:06,490 --> 01:23:11,740
ან, მაგალითად, თუ რა თქვენი ანგარიშით, ან რამდენ დროს ის წაიყვანეს თქვენ გადაჭრის ამ ფორუმის?

1348
01:23:11,740 --> 01:23:14,970
ისე, თუ რა შეგიძლიათ გააკეთოთ შეგიძლიათ შექმნათ struct.

1349
01:23:14,970 --> 01:23:18,910
რა მე ძირითადად ამბობდა არის მე განსაზღვრის ამ სტრუქტურის მეტი აქ,

1350
01:23:18,910 --> 01:23:23,230
და მე განსაზღვრის Sudoku საბჭო, რომლის შემადგენლობაში შედის ფორუმში, რომელიც 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> და რა აქვს მას მითითებას სახელით დონეზე.

1352
01:23:26,650 --> 01:23:30,730
მას ასევე X და Y, რომელთა კოორდინატები სადაც მე ვარ ახლა.

1353
01:23:30,730 --> 01:23:35,980
მას ასევე აქვს გატარებული დრო [გაუგებარია], და მას აქვს საერთო რაოდენობის გადადის მე inputted ჯერჯერობით.

1354
01:23:35,980 --> 01:23:40,010
და ა.შ. ამ შემთხვევაში, შემიძლია ჯგუფი A მთელი bunch of მონაცემები შევიდა მხოლოდ ერთი სტრუქტურა

1355
01:23:40,010 --> 01:23:42,790
ნაცვლად, რომელმაც მას მოსწონს საფრენი გარშემო, როგორიცაა ცვლადის სხვადასხვა

1356
01:23:42,790 --> 01:23:44,540
რომ მე ნამდვილად ვერ ტრეკზე.

1357
01:23:44,540 --> 01:23:49,720
და ეს საშუალებას გვაძლევს მხოლოდ ლამაზი სინტაქსი სახის referencing სხვადასხვა რამ შიგნით ამ struct.

1358
01:23:49,720 --> 01:23:53,430
მე შემიძლია უბრალოდ board.board, და მივიღებ Sudoku გამგეობის უკან.

1359
01:23:53,430 --> 01:23:56,320
Board.level, მივიღებ როგორ მკაცრი ეს.

1360
01:23:56,320 --> 01:24:00,540
Board.x და board.y მომეცი კოორდინატები სადაც მე შეიძლება ამ ფორუმში.

1361
01:24:00,540 --> 01:24:04,730
და ა.შ. მე წვდომის, რაც ჩვენ მოვუწოდებთ დარგების struct.

1362
01:24:04,730 --> 01:24:08,840
ეს განსაზღვრავს sudokuBoard, რომელიც ტიპი რომ მაქვს.

1363
01:24:08,840 --> 01:24:14,800
და ახლა ჩვენ აქ. მაქვს ცვლადში "ფორუმში" ტიპის sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
და ა.შ. ახლა მე შეუძლიათ ყველა სფეროებში, რომ შეადგინოს ამ სტრუქტურის მეტი აქ.

1365
01:24:20,830 --> 01:24:22,450
>> რაიმე კითხვა structs? დიახ?

1366
01:24:22,450 --> 01:24:25,890
[სტუდენტური] For int x, y, თქვენ განაცხადა, ორივე ერთ ხაზს? >> [ჯოზეფ] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[სტუდენტური] ასე, იქნებ უბრალოდ, რომ ყველა მათგანი?

1368
01:24:27,400 --> 01:24:31,200
როგორც X, Y მძიმით ჯერ რომ სულ?

1369
01:24:31,200 --> 01:24:34,460
[ჯოზეფ] დიახ, თქვენ შეიძლება აუცილებლად გავაკეთებთ, მაგრამ მიზეზი მე ზუსტად x და y იმავე ხაზის -

1370
01:24:34,460 --> 01:24:36,330
და საკითხია, თუ რატომ შეგვიძლია უბრალოდ ამ იმავე ხაზის?

1371
01:24:36,330 --> 01:24:38,600
რატომ არ გვაქვს მხოლოდ დააყენა ყველა ამ იმავე ხაზზე

1372
01:24:38,600 --> 01:24:42,090
x და y არიან დაკავშირებული ერთმანეთთან,

1373
01:24:42,090 --> 01:24:44,780
და ეს მხოლოდ სტილისტურად უფრო ზუსტი, წელს გრძნობა,

1374
01:24:44,780 --> 01:24:46,600
რადგანაც ეს დაჯგუფება ორი რამ იმავე ხაზის

1375
01:24:46,600 --> 01:24:49,340
რომ მოსწონს სახის ეხება იგივე.

1376
01:24:49,340 --> 01:24:51,440
და მე მხოლოდ გაყოფილი ამ გარდა. უბრალოდ სტილი რამ.

1377
01:24:51,440 --> 01:24:53,720
იგი ფუნქციურად არ აკეთებს განსხვავება განაწილებაზე.

1378
01:24:58,150 --> 01:24:59,270
ნებისმიერი სხვა შეკითხვებს structs?

1379
01:25:03,030 --> 01:25:06,620
თქვენ შეგიძლიათ განსაზღვროს Pokédex ერთად struct.

1380
01:25:06,620 --> 01:25:11,720
Pokemon აქვს ნომერი და მას წერილი, მფლობელი, ტიპის.

1381
01:25:11,720 --> 01:25:16,990
ხოლო შემდეგ, თუ თქვენ გაქვთ მასივი pokemon, შეგიძლიათ შეადგინოს Pokédex, არა?

1382
01:25:16,990 --> 01:25:20,810
Okay, ზემოთ. ასე რომ, შეკითხვა structs. იმ დაკავშირებულია structs.

1383
01:25:20,810 --> 01:25:25,270
>> საბოლოოდ, GDB. რას GDB მოგცემთ გავაკეთოთ? იგი საშუალებას გაძლევთ გამართვის თქვენი პროგრამა.

1384
01:25:25,270 --> 01:25:27,650
და თუ თქვენ არ გამოიყენება GDB, მინდა რეკომენდირებული თვალს მოკლე

1385
01:25:27,650 --> 01:25:31,250
და მხოლოდ აპირებს მეტი რა GDB არის, თუ როგორ ვიმუშაოთ ის, თუ როგორ შეიძლება მისი გამოყენება,

1386
01:25:31,250 --> 01:25:32,900
დააგემოვნოთ ეს პროგრამა.

1387
01:25:32,900 --> 01:25:37,400
და მერე რა GDB გაძლევთ გააკეთოთ ეს საშუალებას პაუზის [გაუგებარია] თქვენი პროგრამა

1388
01:25:37,400 --> 01:25:38,920
და პრაქტიკული ხაზი.

1389
01:25:38,920 --> 01:25:42,600
მაგალითად, მინდა პაუზის შესრულების დროს, როგორიცაა ხაზი 3 ჩემი პროგრამა,

1390
01:25:42,600 --> 01:25:46,010
და სანამ მე დილის ხაზი 3 შემიძლია ამობეჭდოთ ყველა ღირებულებებს, რომ იქ არიან.

1391
01:25:46,010 --> 01:25:49,710
და მერე რა ჩვენ მოვუწოდებთ მოსწონს დაპაუზება in ხაზი

1392
01:25:49,710 --> 01:25:52,350
ჩვენ მოვუწოდებთ ამ აყენებს breakpoint რომ ხაზი

1393
01:25:52,350 --> 01:25:55,920
და მაშინ ჩვენ შეგვიძლია ბეჭდვა გარეთ ცვლადები სახელმწიფო პროგრამის იმ დროს.

1394
01:25:55,920 --> 01:25:58,990
>> ჩვენ შეგვიძლია ამის შემდეგ იქ დაიხევს მეშვეობით პროგრამა ხაზის მიერ ხაზი.

1395
01:25:58,990 --> 01:26:03,200
და მაშინ ჩვენ შეგვიძლია შევხედოთ მდგომარეობას დასტის დროს.

1396
01:26:03,200 --> 01:26:08,600
და ა.შ. რათა GDB, თუ რას ვაკეთებთ ჩვენ მოვუწოდებთ clang on C ფაილი,

1397
01:26:08,600 --> 01:26:11,290
მაგრამ უნდა გაიაროს ეს-ggdb დროშა.

1398
01:26:11,290 --> 01:26:15,850
და კიდევ ჩვენ გაკეთდეს, რომ ჩვენ მხოლოდ აწარმოებს GDB შესახებ მიღებული გამომავალი ფაილი.

1399
01:26:15,850 --> 01:26:18,810
და ასე რომ თქვენ მიიღეთ რაიმე მოსწონს მასობრივი ტექსტის მოსწონს,

1400
01:26:18,810 --> 01:26:21,990
მაგრამ რეალურად ყველა თქვენ უნდა გააკეთოთ აკრიფოთ ბრძანებები დასაწყისში.

1401
01:26:21,990 --> 01:26:24,250
დაარღვიე მთავარ აყენებს breakpoint დროს ძირითადი.

1402
01:26:24,250 --> 01:26:28,470
სია 400 ჩამოთვლილია ხაზების კოდი გარშემო ხაზი 400.

1403
01:26:28,470 --> 01:26:31,410
და ა.შ. ამ შემთხვევაში შეგიძლიათ მხოლოდ მიმოიხედე გარშემო და ამბობენ, ოჰ,

1404
01:26:31,410 --> 01:26:34,360
მინდა მითითებული breakpoint დროს ხაზი 397, რომელიც ამ ხაზს,

1405
01:26:34,360 --> 01:26:37,170
და შემდეგ თქვენი პროგრამა ეშვება შევიდა, რომ ნაბიჯი და ის აპირებს დაარღვიოს.

1406
01:26:37,170 --> 01:26:41,120
იგი აპირებს პაუზის არსებობს, და თქვენ შეგიძლიათ ამობეჭდოთ, მაგალითად, ღირებულება დაბალი ან მაღალი.

1407
01:26:41,120 --> 01:26:46,410
და ასე რომ bunch of ბრძანებები საჭიროა იცოდეთ,

1408
01:26:46,410 --> 01:26:48,660
და ამ Slideshow წავა up on ნახვა,

1409
01:26:48,660 --> 01:26:54,000
ასე რომ, თუ გსურთ მითითებას ამ ან like დააყენა მათ თქვენი მოტყუებას sheets, ვგრძნობ უფასო.

1410
01:26:54,000 --> 01:27:00,650
>> ზემოთ. ეს იყო Quiz მიმოხილვა 0, და ჩვენ გამყარებაში გარშემო თუ თქვენ გაქვთ რაიმე შეკითხვებს.

1411
01:27:00,650 --> 01:27:03,850
ყველა უფლება.

1412
01:27:03,850 --> 01:27:09,030
>>  [ტაში]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]