1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> დინამიკები 1: Hi ყველას.

3
00:00:05,680 --> 00:00:07,530
ჩვენ ვაპირებთ დავიწყოთ.

4
00:00:07,530 --> 00:00:09,330
მე ვფიქრობ, ხალხს ჯერ კიდევ გრძელდება
უნდა იყოს ფილტრაცია in.

5
00:00:09,330 --> 00:00:12,840
მაგრამ ინტერესი, ამიტომ ჩვენ შეგიძლიათ
მისაღებად თქვენ ბიჭები აქედან დროს,

6
00:00:12,840 --> 00:00:14,110
ჩვენ ვაპირებთ დავიწყოთ.

7
00:00:14,110 --> 00:00:18,780
ასე რომ, კეთილი იყოს CS50 Quiz 0 მიმოხილვა.

8
00:00:18,780 --> 00:00:23,020
იმ თქვენ, რომლებიც არ მიხვდა,
ჯერჯერობით, თქვენ გაქვთ კითხვა, ოთხშაბათს.

9
00:00:23,020 --> 00:00:25,700
Woo-hoo.

10
00:00:25,700 --> 00:00:29,780
>> თუ თქვენ არ დაიწყო სწავლა ჯერ ან
არ მიხვდა, რომ ეს არსებობს ჯერ კიდევ,

11
00:00:29,780 --> 00:00:34,070
წარსულში ტესტებში და ყველა ინფორმაცია
თქვენი Quiz არიან cs50.net/quizzes.

12
00:00:34,070 --> 00:00:38,090
არსებობს რამდენიმე საკმაოდ კარგი პერსონალი იქ,
წარსულში ტესტებში ბოლო 10

13
00:00:38,090 --> 00:00:43,760
წლის განმავლობაში, ასევე ინფორმაცია
ამ ვიქტორინაში და თემა

14
00:00:43,760 --> 00:00:46,250
დაიფარება.

15
00:00:46,250 --> 00:00:48,980
ასე რომ, მოდით დავიწყოთ.

16
00:00:48,980 --> 00:00:54,240
>> ასე რომ თქვენ ბიჭები შეიძლება გახსოვთ, პირველი
დღეს კლასის დავითი იმ ნათურები.

17
00:00:54,240 --> 00:00:59,650
ასე რომ, არსებითად, ყველაფერი, რაც მიდის
ქვეშ hood of კომპიუტერი

18
00:00:59,650 --> 00:01:00,860
გაკეთდეს ორობითი.

19
00:01:00,860 --> 00:01:04,080
ორობითი რას ნიშნავს ეს ჟღერს,
როგორიცაა, 0 და 1 ს.

20
00:01:04,080 --> 00:01:09,290
მას აქვს ორი ღირებულებები, რომელიც
შეიძლება წარმოდგენილი.

21
00:01:09,290 --> 00:01:14,675
>> ამიტომ ისევე როგორც პირველ დღეს განყოფილებიანი
როდესაც დავით აღმოჩნდა სინათლის

22
00:01:14,675 --> 00:01:21,990
ნათურა წარმოადგენს, ან 1, ჩვენი კომპიუტერი
ესმის ორობითი როგორც 0 და

23
00:01:21,990 --> 00:01:24,110
1 ს, ან გამოსართავად.

24
00:01:24,110 --> 00:01:25,360
საფუძვლები ორობითი.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
ყველა ადგილი არის წარმოდგენილი
ბაზის ორი.

27
00:01:32,470 --> 00:01:36,260
ასე რომ თქვენ დაამატოთ 2 დან 0 დან
1 2 ყველა გზა მდე.

28
00:01:36,260 --> 00:01:41,970
>> გამოვთვალოთ რა ორობითი არის
ათობითი, უბრალოდ მიყევით ამ განტოლების

29
00:01:41,970 --> 00:01:42,840
ტიპი რამ.

30
00:01:42,840 --> 00:01:49,510
თუ თქვენ გაქვთ 1 და იმ ადგილებში,
თქვენ გავამრავლოთ იგი ნებისმიერი

31
00:01:49,510 --> 00:01:53,820
ბაზის ის წელს, დაამატოთ it up, და
თქვენ მიიღებთ ათობითი.

32
00:01:53,820 --> 00:01:57,930
ასე რომ, ეს არის, თუ როგორ ითვლიან
დან 5 ორობითი.

33
00:01:57,930 --> 00:02:01,400
ისევე, როგორც ის, რასაც ჩვენ ვაკეთებთ
ბოლო slide, ეს არის, თუ როგორ

34
00:02:01,400 --> 00:02:02,650
წარმოადგენს 1 მეშვეობით 5.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> ანალოგიურად, ისევე, როგორც თქვენ შეგიძლიათ დაამატოთ და
სხვაობა ათობითი ან ბაზის 10, ან

37
00:02:09,660 --> 00:02:13,040
მართლაც რაიმე ბაზა, შეგიძლიათ დაამატოთ
და სხვაობა ორობითი.

38
00:02:13,040 --> 00:02:18,400
ზუსტად ის, რაც თქვენ მოელოდა, როდესაც თქვენ
დაამატეთ ორი, თუ იგი შეადგენს დიდი

39
00:02:18,400 --> 00:02:24,220
ვიდრე 1, თქვენ განახორციელოს 1, იგი 0,
და ამის გარდა, რომ გზა, მხოლოდ

40
00:02:24,220 --> 00:02:29,910
როგორც თქვენ მოელოდა რეგულარული
ათობითი ან სხვა ბაზის.

41
00:02:29,910 --> 00:02:30,970
ზემოთ.

42
00:02:30,970 --> 00:02:35,140
>> ასე რომ, როგორც ვთქვი, ყველაფერი, რაც
მიდის ქვეშ hood ჩვენი კომპიუტერი

43
00:02:35,140 --> 00:02:37,560
კეთდება 0 და 1 ს, ან ორობითი.

44
00:02:37,560 --> 00:02:43,470
ასე როგორ უნდა გამოხატოს, მაგალითად,
წერილები, ან ნომრები, ან სიმბოლოების?

45
00:02:43,470 --> 00:02:45,560
და პასუხი რომ ASCII.

46
00:02:45,560 --> 00:02:49,380
>> ASCII არის რუკების შორის გმირები
რომ ჩვენ ჩვეულებრივ ვხედავთ

47
00:02:49,380 --> 00:02:53,360
ინგლისური ენის მსგავსად ის, B-ს,
C-ს უსვამს, dashes და

48
00:02:53,360 --> 00:02:54,910
არაფერი რომ.

49
00:02:54,910 --> 00:02:57,260
და ეს რუკები, რომ ASCII ღირებულება.

50
00:02:57,260 --> 00:03:03,080
ASCII არც მხოლოდ ნომერი, რომელიც
გასაგებია თქვენი კომპიუტერის.

51
00:03:03,080 --> 00:03:07,430
და ისევე, როგორც თქვენ შეგიძლიათ ამის გარდა და
გამოკლებაში ნომრები, შეგიძლიათ გააკეთოთ

52
00:03:07,430 --> 00:03:10,890
მათ ASCII ღირებულებებს.

53
00:03:10,890 --> 00:03:14,050
>> ასე რომ, ამ მაგალითად, რა
იქნება ეს ამობეჭდოთ?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
ჰო, ისე, უბრალოდ სივრცეში B სივრცე C ფართი
დ სად ჩემს მაუსის წასვლა?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
ყურადღება მიაქციეთ, შეგიძლიათ განსაზღვროს int 65.

58
00:03:43,380 --> 00:03:47,080
და როდესაც თქვენ ბეჭდვა გამოყენებით
პროცენტი C, ის ყველაფერს ინტერპრეტაცია, რომ როგორც

59
00:03:47,080 --> 00:03:49,330
ხასიათი და ამობეჭდოთ ა

60
00:03:49,330 --> 00:03:52,800
>> ასევე, თქვენ შეიძლება ითქვას,
როგორც char.

61
00:03:52,800 --> 00:03:56,860
და როდესაც თქვენ ამობეჭდოთ გამოყენებით პროცენტს
C, ის ყველაფერს ინტერპრეტაცია, რომ როგორც

62
00:03:56,860 --> 00:04:05,240
პროცენტი D. და ისევე, როგორც თქვენ შეგიძლიათ დაამატოთ
ნომერი, შეგიძლიათ დაამატოთ სიმბოლოები

63
00:04:05,240 --> 00:04:06,878
ASCII ღირებულებებს, ამ შემთხვევაში.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> ასე რომ, პატარა მაჩვენებელი ყველასთვის.

66
00:04:16,130 --> 00:04:19,610
5, როგორც სიმებიანი, არ
რეალურად ტოლი 5.

67
00:04:19,610 --> 00:04:26,610
ასე როგორ შეიძლება ჩვენ დააკონვერტიროთ
string 5 რიცხვი 5?

68
00:04:26,610 --> 00:04:28,930
ნებისმიერი იდეები?

69
00:04:28,930 --> 00:04:31,630
Yeah.

70
00:04:31,630 --> 00:04:36,720
>> ასე რომ, თუ ჩვენ გვაქვს 5, როგორც ტექსტი,
ჩვენ შეგვიძლია გამოვაკლოთ 0.

71
00:04:36,720 --> 00:04:37,820
და რომ მივცემ us 5.

72
00:04:37,820 --> 00:04:41,670
და ანალოგიურად, თუ ჩვენ გვაქვს 5,
რიცხვი, დავამატებთ, რომ სიმებიანი 0.

73
00:04:41,670 --> 00:04:43,112
და რომ გვაძლევს სიმებიანი 5.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
ზემოთ.

76
00:04:48,350 --> 00:04:52,940
>> ახლა, გავიხსენოთ თავში ლექცია, სადაც
ჩვენ ვისაუბრეთ ალგორითმები.

77
00:04:52,940 --> 00:04:57,260
ასე რომ, ჩვენ რეალურად გვინდა კომპიუტერი
გავაკეთოთ საინტერესო რამ?

78
00:04:57,260 --> 00:05:00,460
თქვენ იცით, უბრალოდ დასძინა და subtracting
ნომრები და ბეჭდვა რამ, არ არის

79
00:05:00,460 --> 00:05:01,730
საინტერესოა.

80
00:05:01,730 --> 00:05:04,620
როგორც წესი, ჩვენ გვინდა ჩვენი კომპიუტერიდან
შეასრულოს გარკვეული ალგორითმის.

81
00:05:04,620 --> 00:05:07,820
რაღაც ცოტა უფრო რთული
ვიდრე უბრალოდ არითმეტიკული.

82
00:05:07,820 --> 00:05:11,930
>> ალგორითმი არის მხოლოდ ეტაპობრივად კომპლექტი
ინსტრუქციები, თუ როგორ ასრულებს

83
00:05:11,930 --> 00:05:14,640
გარკვეული task--

84
00:05:14,640 --> 00:05:15,660
ისევე როგორც რეცეპტი.

85
00:05:15,660 --> 00:05:19,990
გახსოვთ, ალბათ, პირველ დღეს
კლასი, სადაც დავითმა ითვლიან ოთახი

86
00:05:19,990 --> 00:05:22,550
ადამიანი და რამდენი ადამიანი
ოთახში.

87
00:05:22,550 --> 00:05:24,480
თქვენ შეიძლება გამოყენებულ იქნას დათვლა
ერთი.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
იმ შემთხვევაში, წრფივი ალგორითმი.

90
00:05:28,010 --> 00:05:31,710
>> მაგრამ დავით გააცნო ალგორითმი
თქვენ ითვლიან ადამიანი ოთახში

91
00:05:31,710 --> 00:05:37,340
სადაც ყველას დგას up, თქვენ ამბობთ, თქვენი
ნომერი სხვა პირს, დავამატებთ, რომ

92
00:05:37,340 --> 00:05:39,200
ნომერი, და ერთი ადამიანი ზის ქვემოთ.

93
00:05:39,200 --> 00:05:40,410
და ვიმეორებ, რომ.

94
00:05:40,410 --> 00:05:42,910
ეს არის ერთ ერთი ტიპის ალგორითმი.

95
00:05:42,910 --> 00:05:47,520
ჩვენ შეგვიძლია ანალიზი, თუ რამდენად ეფექტური
ალგორითმი ეფუძნება ის აწარმოებს დროს.

96
00:05:47,520 --> 00:05:49,680
მაგრამ ჩვენ ამაზე ცოტა
ამის შესახებ მოგვიანებით.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> ასე რომ ყველა ალგორითმები ასევე შეგიძლიათ
უნდა ჩაიწეროს pseudocode.

99
00:05:57,090 --> 00:06:01,120
Pseudocode მხოლოდ ინგლისური, როგორიცაა
სინტაქსი გამოიყენება წარმოადგენს

100
00:06:01,120 --> 00:06:02,420
პროგრამირების ენა.

101
00:06:02,420 --> 00:06:06,070
მაგალითად, თუ ჩვენ მინდოდა ვთხოვო შესახებ
მისახვედრია, ჩემი საყვარელი ნომერი, ჩვენ

102
00:06:06,070 --> 00:06:08,390
შესაძლოა, pseudocode, როგორც ასეთი.

103
00:06:08,390 --> 00:06:09,850
>> მიიღეთ მომხმარებლები ვხვდები.

104
00:06:09,850 --> 00:06:13,570
თუ ვხვდები სწორია, ვუთხრა
ისინი სწორი, სხვას ვუთხრა,

105
00:06:13,570 --> 00:06:15,560
ისინი არ არის სწორი.

106
00:06:15,560 --> 00:06:22,530
და pseudocode არის გზა ადვილად
წარმოადგენს იდეა ან ალგორითმი.

107
00:06:22,530 --> 00:06:26,910
ასე რომ, ახლა ჩვენ დაგვჭირდება რეალურად წერენ
ამ ენაზე, კომპიუტერული

108
00:06:26,910 --> 00:06:27,980
შეიძლება გაგება.

109
00:06:27,980 --> 00:06:35,660
ასე რომ ჩვენ შეგვიძლია დავწეროთ ჩვენი pseudocode და
ინტერპრეტაცია, რომ შევიდა კოდის.

110
00:06:35,660 --> 00:06:41,320
>> ჯერჯერობით, კოდის უნდა დაიცვას
გარკვეული syntax of

111
00:06:41,320 --> 00:06:42,490
პროგრამირების ენა.

112
00:06:42,490 --> 00:06:45,430
და ჯერჯერობით, წელს CS50, ჩვენ
გამოყენებით ძირითადად გ.

113
00:06:45,430 --> 00:06:48,320
ასე რომ, ეს შეიძლება იყოს კოდის გ.

114
00:06:48,320 --> 00:06:51,440
მოგვიანებით, რა თქმა უნდა, ღამით მოდის
კონტაქტი სხვა პროგრამირების

115
00:06:51,440 --> 00:06:52,480
ენებს, როგორიცაა PHP.

116
00:06:52,480 --> 00:06:57,540
ან თუ კი მიიღოს სხვა კლასების, თქვენ
შეიძლება ამის გაკეთება Java, Python, ან თუნდაც OCML.

117
00:06:57,540 --> 00:07:01,570
მაგრამ ჩვენს c პროგრამა ენაზე, ეს არის
როგორ შეიძლება დაწერა კოდის

118
00:07:01,570 --> 00:07:04,760
pseudocode ალგორითმი, რომელიც
უბრალოდ აღწერილია ადრე.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> ასე როგორ თქვენი კომპიუტერი რეალურად
მესმის, რომ?

121
00:07:11,430 --> 00:07:14,490
როგორც მანამდე ვთქვი, ეს მხოლოდ მართლაც
ესმის zeros და პირობა.

122
00:07:14,490 --> 00:07:17,880
ასე როგორ მიიღონ წყარო
კოდი, რაც შეიძლება იყოს

123
00:07:17,880 --> 00:07:18,960
ამის გაგება?

124
00:07:18,960 --> 00:07:22,920
ასევე, ჩვენ გვაქვს რაღაც
ე.წ. შემდგენელი.

125
00:07:22,920 --> 00:07:28,450
>> თუ გავიხსენებთ თავში უმეტეს თქვენი
psets, თქვენ უნდა გარკვეული სახის პროგრამა

126
00:07:28,450 --> 00:07:30,370
დაწერილი dot გ ფაილი.

127
00:07:30,370 --> 00:07:32,550
და მაშინ აკრიფოთ მიიღოს.

128
00:07:32,550 --> 00:07:35,970
ასე რომ, რა უნდა გააკეთოს აკეთებს?

129
00:07:35,970 --> 00:07:39,970
>> შეგიძლიათ აკრიფოთ მიიღოს კომპილაციის თქვენი
პროგრამა, რადგან someone--

130
00:07:39,970 --> 00:07:42,730
ვინც დაწერა თქვენი P კომპლექტი;
ალბათ David--

131
00:07:42,730 --> 00:07:44,190
განთავსებულია მიიღოს ფაილი.

132
00:07:44,190 --> 00:07:51,320
და რომ ეუბნება, რათა იცოდეთ, რომ აწარმოებს თქვენს
შემდგენელი, ეწოდება clang, რომ იქნება

133
00:07:51,320 --> 00:07:55,560
შემდეგ ადგენენ თქვენი კოდის გააპროტესტებენ
კოდი, რომელიც zeros და პირობა

134
00:07:55,560 --> 00:07:57,720
რომ თქვენი კომპიუტერი ესმის.

135
00:07:57,720 --> 00:08:01,610
მაგრამ ცოტა მოგვიანებით, წავალთ
მეტი სიღრმისეული შესახებ compilers.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> ასე რომ გავიხსენოთ, pset 0, where-- დიახ,
თქვენ გაქვთ შეკითხვა?

138
00:08:10,800 --> 00:08:11,620
>> აუდიტორია: [INAUDIBLE]?

139
00:08:11,620 --> 00:08:12,490
>> დინამიკები 1: დიახ.

140
00:08:12,490 --> 00:08:14,960
მე ვფიქრობ, რომ ისინი, ფაქტობრივად,
უნდა იყოს ონლაინ რეჟიმში.

141
00:08:14,960 --> 00:08:15,120
Yeah.

142
00:08:15,120 --> 00:08:16,572
>> აუდიტორია: რა არის ეს, როგორიცაა [INAUDIBLE]?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> დინამიკები 1: ეს არ არის.

145
00:08:20,830 --> 00:08:25,810
არიან cs50.net/quizzes.

146
00:08:25,810 --> 00:08:32,900
>> აუდიტორია: Slash ტესტები, ხაზი 2013,
slash 0, და დაწკაპეთ მეშვეობით

147
00:08:32,900 --> 00:08:35,956
ტესტები 2013 და ვიქტორინაში 0,
მიმოხილვა მონაკვეთზე სლაიდები.

148
00:08:35,956 --> 00:08:40,380
>> დინამიკები 1: ჰო, ასე რომ, თუ თქვენ ბიჭები მინდა
გაიყვანოს ეს და შევხედოთ მას თქვენი

149
00:08:40,380 --> 00:08:42,740
კომპიუტერი, რომ ძალიან ჯარიმა.

150
00:08:42,740 --> 00:08:43,130
ამბობენ, რომ ერთხელ.

151
00:08:43,130 --> 00:08:44,546
>> აუდიტორია: [INAUDIBLE].

152
00:08:44,546 --> 00:08:48,780
>> დინამიკები 1: Yeah, [INAUDIBLE]
არის რაღაც განსხვავებულია.

153
00:08:48,780 --> 00:08:49,644
Oh, დიახ?

154
00:08:49,644 --> 00:08:51,372
>> აუდიტორია: [INAUDIBLE]?

155
00:08:51,372 --> 00:08:54,300
>> დინამიკები 1: არა, გაფიცვების
არ არის გამოცდა.

156
00:08:54,300 --> 00:08:55,950
უკაცრავად, მის კითხვაზე, იყო
იერიშის გამოცდა.

157
00:08:55,950 --> 00:08:59,530
და ეს არ არის.

158
00:08:59,530 --> 00:09:05,780
ასე რომ pset 0, თქვენ ბიჭები უნდა ჰქონდეს ყველა
განხორციელებული რაღაც გამოყენებით ნულიდან.

159
00:09:05,780 --> 00:09:13,100
და გავიგეთ, რომ ზოგიერთი ძირითადი პროგრამირების
სამშენებლო ბლოკების გამოყენებით ნულიდან.

160
00:09:13,100 --> 00:09:15,590
>> მოდით შევხედოთ ზოგიერთი
ამ სამშენებლო ბლოკები

161
00:09:15,590 --> 00:09:18,170
რომ შეადგინოს პროგრამა.

162
00:09:18,170 --> 00:09:20,570
პირველი არის ის ლოგიკური გამოხატულებაა.

163
00:09:20,570 --> 00:09:24,540
ლოგიკური გამონათქვამები პირობა და
0 ან რამე რომ აქვს

164
00:09:24,540 --> 00:09:25,700
ორი შესაძლო მნიშვნელობებია.

165
00:09:25,700 --> 00:09:30,320
ამ შემთხვევაში, ჭეშმარიტი ან მცდარი,
ან გამოსართავად, და არა.

166
00:09:30,320 --> 00:09:35,390
უბრალო მაგალითი, ძალიან მარტივია,
პროგრამა, რომელიც იყენებს ლოგიკური

167
00:09:35,390 --> 00:09:39,140
გამოხატვის აქ.

168
00:09:39,140 --> 00:09:43,220
>> ამიტომ იმისათვის, ლოგიკური გამონათქვამები
სასარგებლო იქნება, ჩვენ გვაქვს ლოგიკური ოპერატორები.

169
00:09:43,220 --> 00:09:48,920
ეს არის ოპერატორები, რომ შეიძლება გამოყენებულ იქნას
შედარების გარკვეული ღირებულებები.

170
00:09:48,920 --> 00:09:52,820
ასე რომ, ჩვენ გვაქვს და ან არ არის ტოლი, ნაკლებად
მეტი ან ტოლია მეტია ან

171
00:09:52,820 --> 00:09:55,130
ტოლია და ნაკლები
ან მეტი.

172
00:09:55,130 --> 00:09:59,060
მაგრამ ეს ოპერატორი არ არის ძალიან სასარგებლო
თუ არ შეგვიძლია დააკავშიროთ მათ

173
00:09:59,060 --> 00:10:00,320
პირობები.

174
00:10:00,320 --> 00:10:04,370
>> ასე რომ თქვენ ბიჭები შეიძლება გახსოვთ ნულიდან
და თქვენი p ადგენს, რომ ჩვენ

175
00:10:04,370 --> 00:10:05,400
მქონდა პირობები.

176
00:10:05,400 --> 00:10:09,710
ისინი, ძირითადად, როგორიცაა ჩანგლები
ლოგიკა თქვენი პროგრამა, რომელიც

177
00:10:09,710 --> 00:10:12,670
ახორციელებს დამოკიდებულია თუ არა
მდგომარეობა შეხვდა.

178
00:10:12,670 --> 00:10:18,150
ასე რომ, ერთი პირობა, რომ ჩვენ გვქონდა
გამოიყენება ბევრჯერ ეს კურსი არის

179
00:10:18,150 --> 00:10:21,470
თუ სხვაგან, თუ, და სხვა პირობები.

180
00:10:21,470 --> 00:10:24,060
>> აი მაგალითი, თუ როგორ
თქვენ შეიძლება გამოვიყენოთ რომ.

181
00:10:24,060 --> 00:10:28,430
ვინმეს ვიცი განსხვავება
მხოლოდ გამოყენებით თუ განცხადებებს ყველა

182
00:10:28,430 --> 00:10:32,530
გზა ქვემოთ ლექსები თუ სხვაგან,
თუ, და სხვა კომბინირებული?

183
00:10:32,530 --> 00:10:33,013
დიახ?

184
00:10:33,013 --> 00:10:34,263
>> აუდიტორია: [INAUDIBLE].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> დინამიკები 1: ზუსტად.

187
00:10:42,160 --> 00:10:50,210
ასე რომ, თუ მე მქონდა თუ ყველა გზა ქვემოთ ამ
მაშინაც კი, თუ ეს მდგომარეობა ბრუნდება

188
00:10:50,210 --> 00:10:52,800
მართალია, ეს კვლავაც გაგრძელდება
ტესტირების მომდევნო ორი.

189
00:10:52,800 --> 00:11:00,120
ვინაიდან, სხვაგან თუ, სხვას
განცხადება, თუ ერთი დააბრუნებს ასეა,

190
00:11:00,120 --> 00:11:02,640
სხვები არ ტესტირება.

191
00:11:02,640 --> 00:11:05,955
რაიმე შეკითხვები, რომ?

192
00:11:05,955 --> 00:11:06,890
ზემოთ.

193
00:11:06,890 --> 00:11:12,240
>> ასე, რომ თქვენ იყენებთ თუ სხვას- სხვას
განცხადება, თუ თქვენ იცით, რომ ეს მხოლოდ

194
00:11:12,240 --> 00:11:14,470
ერთი ამ შემთხვევაში.

195
00:11:14,470 --> 00:11:21,550
ასე რომ, ჩვენ ვიცით, თუ x ნაკლებია, ვიდრე 0, ეს
ნამდვილად არ იქნება

196
00:11:21,550 --> 00:11:22,890
უფრო მეტი, ვიდრე 0.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> შემდეგი, კიდევ ერთი შენობა ბლოკი
შევიტყვეთ, მარყუჟების.

199
00:11:31,480 --> 00:11:33,310
ჩვენ გვაქვს სამი ტიპის მარყუჟების.

200
00:11:33,310 --> 00:11:35,830
ამისთვის მარყუჟების, ხოლო მარყუჟების,
და ნუ ხოლო მარყუჟების.

201
00:11:35,830 --> 00:11:38,730
და საერთოდ, როდესაც დასხდნენ
რაღაც დავწერო, თქვენ უნდა გადაწყვიტოს,

202
00:11:38,730 --> 00:11:40,060
რომელიც სამი გსურთ გამოიყენოთ.

203
00:11:40,060 --> 00:11:41,900
ასე როგორ უნდა გადაწყვიტოს, რომელი ერთი?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> ჩვენ ზოგადად გამოიყენოს ამისთვის loop თუ ჩვენ ვიცით,
რამდენი ჯერ ჩვენ გვინდა iterate

206
00:11:48,790 --> 00:11:53,650
მეშვეობით რაღაც ან რამდენჯერ
ჩვენ გვინდა, რომ შეასრულოს დავალება.

207
00:11:53,650 --> 00:11:58,830
ჩვენ ვიყენებთ ხოლო მარყუჟების თუ ჩვენ გვჭირდება
მდგომარეობა უნდა იყოს ნამდვილი შენარჩუნება გაშვებული.

208
00:11:58,830 --> 00:12:03,730
ჩვენ ვიყენებთ გააკეთოს, ხოლო ძალიან ჰგავს
ხოლო, მაგრამ ჩვენ გვინდა, რომ ჩვენი კოდი გარბოდა

209
00:12:03,730 --> 00:12:04,880
მინიმუმ ერთ დროს.

210
00:12:04,880 --> 00:12:09,410
>> ასე რომ, ნუ ხოლო, რაც წელს გავაკეთებთ
ყოველთვის აწარმოებს მინიმუმ ერთი დრო.

211
00:12:09,410 --> 00:12:13,120
ვინაიდან, ხოლო, ის
შეიძლება არ აწარმოებს ყველა, თუ

212
00:12:13,120 --> 00:12:15,490
მდგომარეობა არ დაკმაყოფილდა.

213
00:12:15,490 --> 00:12:16,740
ნებისმიერი კითხვები რომ?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> ასე სტრუქტურა ამისთვის loop.

216
00:12:22,860 --> 00:12:23,620
თქვენ ბიჭები არ მინახავს ყველა ეს.

217
00:12:23,620 --> 00:12:25,320
თქვენ ინიციალიზაცია იგი.

218
00:12:25,320 --> 00:12:26,600
თქვენ უნდა გარკვეული სახის მდგომარეობა.

219
00:12:26,600 --> 00:12:32,340
ასე, მაგალითად, ჩვენ შეიძლება ინიციალიზაცია
როგორც მე შეადგენს 0.

220
00:12:32,340 --> 00:12:34,040
i ნაკლებია, ვიდრე 10.

221
00:12:34,040 --> 00:12:35,442
და მე ++.

222
00:12:35,442 --> 00:12:39,010
ძალიან მარტივია, რომ ჩვენ გავაკეთეთ.

223
00:12:39,010 --> 00:12:42,210
>> ხოლო მარყუჟის, ანალოგიურად, თქვენ უნდა
აქვს რაიმე სახის ინიციალიზაციისას,

224
00:12:42,210 --> 00:12:44,980
გარკვეული სახის მდგომარეობა და
გარკვეული სახის განახლება.

225
00:12:44,980 --> 00:12:51,990
ასე რომ, ჩვენ შეგვიძლია განვახორციელოთ ჩვენი ამისთვის loop ასევე
ხოლო მარყუჟის გამოყენებისას.

226
00:12:51,990 --> 00:12:56,000
და მსგავსად do ხოლო მარყუჟის,
ჩვენ შეიძლება გვაქვს ინიციალიზაციისას,

227
00:12:56,000 --> 00:12:58,640
შეასრულოს რაიმე, განახლება, და
შემდეგ შეამოწმოს მდგომარეობა.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> ასე რომ, ახლა ფუნქციები.

230
00:13:05,140 --> 00:13:06,460
ჩვენ ყველაფერს ერთად.

231
00:13:06,460 --> 00:13:10,140
ჩვენ დაგვჭირდება წერა რამდენიმე
სახის ფუნქცია.

232
00:13:10,140 --> 00:13:12,790
საერთო ფუნქცია, რომ თქვენ შეიძლება
ვნახეთ უკვე არის მთავარი.

233
00:13:12,790 --> 00:13:13,770
მთავარი არის ფუნქცია.

234
00:13:13,770 --> 00:13:16,160
მას დაბრუნების ტიპის, int.

235
00:13:16,160 --> 00:13:18,470
მას აქვს ფუნქცია სახელი, მთავარი.

236
00:13:18,470 --> 00:13:20,810
და მას აქვს არგუმენტები, argc და argv.

237
00:13:20,810 --> 00:13:24,040
ასე რომ მთავარი მხოლოდ ფუნქცია.

238
00:13:24,040 --> 00:13:27,230
>> სხვა ფუნქციები შეიძლება არ გამოიყენება,
printf-- printf არის ფუნქცია

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
მაგრამ ეს მოხდება, რომ არ ყოფილიყო
განხორციელებული ჩვენს მიერ

241
00:13:32,010 --> 00:13:33,270
გარკვეული სახის ბიბლიოთეკა.

242
00:13:33,270 --> 00:13:37,400
თუ ბიჭები გახსოვთ, მათ შორის
ამ CS50.h ბიბლიოთეკის ან

243
00:13:37,400 --> 00:13:38,510
სტანდარტული I / O ბიბლიოთეკაში.

244
00:13:38,510 --> 00:13:39,200
დიახ, კითხვის ნიშნის ქვეშ?

245
00:13:39,200 --> 00:13:41,610
>> აუდიტორია: რა არის მთავარი მხოლოდ თანდაყოლილი გ?

246
00:13:41,610 --> 00:13:44,740
იმას, რომ ეს მხოლოდ სახის [INAUDIBLE]?

247
00:13:44,740 --> 00:13:47,370
>> დინამიკები 1: ეს საკითხი არ არის
თუ ძირითადი თან ახლავს გ.

248
00:13:47,370 --> 00:13:51,460
და დიახ, ყველა ფუნქცია
მთავარი ფუნქცია.

249
00:13:51,460 --> 00:13:55,290
ეს არის სახის საჭირო კომპიუტერული
ვიცი, სად უნდა დაიწყოს

250
00:13:55,290 --> 00:13:55,993
გაშვებული კოდი.

251
00:13:55,993 --> 00:13:58,108
>> აუდიტორია: ასე რომ თქვენ არ [INAUDIBLE]?

252
00:13:58,108 --> 00:13:59,480
>> დინამიკები 1: არა

253
00:13:59,480 --> 00:14:00,760
ნებისმიერი სხვა კითხვები?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
ზემოთ.

256
00:14:04,770 --> 00:14:08,050
ასე რომ, ისევე, როგორც თქვენ შეგიძლიათ გამოიყენოთ ფუნქცია
რომ წერია, თქვენ ასევე შეგიძლიათ

257
00:14:08,050 --> 00:14:10,380
დაწეროთ ფუნქცია.

258
00:14:10,380 --> 00:14:17,050
ეს არის ფუნქცია, რომ ვინმე
არ წერია, რომ მოცულობის გამოთვლა

259
00:14:17,050 --> 00:14:18,395
საქართველოს q, მაგალითად.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
იქ დაბრუნების ტიპის, აქ, ამ შემთხვევაში,
int, ჩვენი ფუნქციის სახელი q და ჩვენი

262
00:14:29,500 --> 00:14:31,360
სია პარამეტრები.

263
00:14:31,360 --> 00:14:34,550
>> და აღნიშნავენ, რომ თქვენ უნდა დაწეროთ მონაცემები
ტიპის პარამეტრი გსურთ

264
00:14:34,550 --> 00:14:38,660
გამოყენება ან სხვა ფუნქცია არ
ვიცით, თუ როგორი

265
00:14:38,660 --> 00:14:41,650
პარამეტრების უნდა მე მიღება.

266
00:14:41,650 --> 00:14:48,110
ასე რომ, ამ შემთხვევაში, ჩვენ გვინდა
რიცხვი, როგორც ჩვენი დასტური.

267
00:14:48,110 --> 00:14:50,390
ასე რომ, რატომ გვინდა, რომ ფუნქციები?

268
00:14:50,390 --> 00:14:52,800
>> პირველ რიგში, დიდი ორგანიზაცია.

269
00:14:52,800 --> 00:14:56,350
მათ დაეხმარება გაწყვეტის თქვენი კოდი შევიდა
უფრო ორგანიზებული მოცულობით და

270
00:14:56,350 --> 00:14:57,960
ეს უფრო ადვილი წასაკითხი.

271
00:14:57,960 --> 00:14:59,760
გამარტივებას.

272
00:14:59,760 --> 00:15:01,740
ეს არის კარგი დიზაინი.

273
00:15:01,740 --> 00:15:04,570
როდესაც თქვენ კითხულობთ ნაჭერი კოდი
და მისი მთავარი ფუნქცია მართლაც,

274
00:15:04,570 --> 00:15:07,750
მართლაც დიდი, ეს შეიძლება იყოს უფრო რთული,
მიზეზი, თუ რა ხდება.

275
00:15:07,750 --> 00:15:11,710
ასე რომ, თუ თქვენ შესვენება მას down შევიდა ფუნქციები,
ეს შეიძლება იყოს უფრო ადვილი წასაკითხი.

276
00:15:11,710 --> 00:15:12,750
და reuse უნარი.

277
00:15:12,750 --> 00:15:16,940
თუ თქვენ გაქვთ ბლოკი კოდი, რომელიც მიმდინარეობს
მოუწოდა ან აწარმოებს რამდენჯერმე,

278
00:15:16,940 --> 00:15:20,690
ნაცვლად გადაწერა რომ კოდი 10 ჯერ
თქვენს მთავარ ფუნქციას, თქვენ შეიძლება

279
00:15:20,690 --> 00:15:21,440
მინდა, რომ reuse ეს.

280
00:15:21,440 --> 00:15:25,740
და შემდეგ ყოველ დროს, თქვენ უნდა გამოვიყენოთ, რომ
ნაჭერი კოდი, მოვუწოდებთ ფუნქცია.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> ახლა, თუ ჩვენ გვახსოვს უკან ნულიდან,
ჩვენ ასევე ვისაუბრეთ რამდენიმე კონცეფციები,

283
00:15:35,380 --> 00:15:37,680
რომელთაგან ერთი ნაკადებზე.

284
00:15:37,680 --> 00:15:41,120
თემა კონცეფციის სხვადასხვა
sequences of კოდი

285
00:15:41,120 --> 00:15:43,040
შესრულებაში, ამავე დროს,.

286
00:15:43,040 --> 00:15:47,490
ასე რომ, ვფიქრობ, უკან ერთი დღე, სადაც დავითი
თქვენ ბიჭები ითვლიან off ნომერი

287
00:15:47,490 --> 00:15:48,440
ადამიანი ოთახში.

288
00:15:48,440 --> 00:15:50,550
>> არსებითად, რა ხდებოდა
არის ყველა თქვენ ბიჭები იყვნენ

289
00:15:50,550 --> 00:15:52,370
გაშვებული ცალკე თემა.

290
00:15:52,370 --> 00:15:55,540
და იმ თემა იყო მომავალი ერთად
მიიღოს გარკვეული პასუხი.

291
00:15:55,540 --> 00:15:58,890
ანალოგიურად, Scratch, როდესაც თქვენ გაქვთ
რამდენიმე sprites, თქვენ შეიძლება

292
00:15:58,890 --> 00:16:01,070
კატა და ძაღლი.

293
00:16:01,070 --> 00:16:08,770
და ისინი ერთდროულად
გაშვებული საკუთარი სკრიპტები.

294
00:16:08,770 --> 00:16:10,020
რომ არის მაგალითი threading.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> და სხვა კონცეფცია, რომელიც იყო
დაინერგა ნულიდან იყო მოვლენები.

297
00:16:18,000 --> 00:16:22,550
და მოვლენები, როდესაც მრავალჯერადი ნაწილები
თქვენი კოდი დაუკავშირდეს ერთმანეთს.

298
00:16:22,550 --> 00:16:26,840
Scratch, ეს იყო, როდესაც გამოყენებულია
სამაუწყებლო კონტროლი და როცა

299
00:16:26,840 --> 00:16:29,500
მიიღეთ ბლოკები.

300
00:16:29,500 --> 00:16:35,170
>> და ასევე, რომ პრობლემა Set 4, დავინახეთ
ცოტა მოვლენების, ასევე.

301
00:16:35,170 --> 00:16:38,250
თქვენ ბიჭები შესაძლოა გამოყენებული
Gevent ბიბლიოთეკა.

302
00:16:38,250 --> 00:16:42,450
და იყო ფუნქციის waitForClick
რომელშიც თქვენ ელოდნენ

303
00:16:42,450 --> 00:16:44,300
მომხმარებელს დაჭერით.

304
00:16:44,300 --> 00:16:47,870
და თქვენი click, ამ შემთხვევაში იქნება
ღონისძიება და დაველოდოთ click თქვენი

305
00:16:47,870 --> 00:16:49,120
ღონისძიება დამმუშავებლის.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> და ასევე, მთელი გაშვებული თქვენი psets
და მუშაობს თქვენს psets, თქვენ

308
00:16:58,630 --> 00:17:01,920
შეიძლება არ მოვიდეს კონტაქტში
ზოგიერთი ეს ბრძანებები.

309
00:17:01,920 --> 00:17:05,579
ეს არის ის, რაც თქვენ აკრეფილი თქვენს
ტერმინალის ფანჯარაში ან რასაც window

310
00:17:05,579 --> 00:17:12,119
ჩანს, რომ თქვენი g რედაქტირება,
არსებითად, ნავიგაცია თქვენს კომპიუტერში.

311
00:17:12,119 --> 00:17:19,440
>> ასე მაგალითად, LS ჩამოთვლილია
შინაარსი დირექტორია.

312
00:17:19,440 --> 00:17:22,510
მიიღოს დირექტორია ქმნის ახალ საქაღალდეში.

313
00:17:22,510 --> 00:17:24,819
CD, შეცვალოს დირექტორია.

314
00:17:24,819 --> 00:17:28,400
RM, წაშლა, წაშლის ფაილების
ან რაიმე დირექტორია.

315
00:17:28,400 --> 00:17:31,050
და შემდეგ ამოიღონ კატალოგი
ხსნის დირექტორია.

316
00:17:31,050 --> 00:17:32,300
>> აუდიტორია: [INAUDIBLE]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> დინამიკები 1: ჰო, რა თქმა უნდა.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
ბოდიში, კითხვაზე იყო თუ
მინდა ვარაუდობენ აყენებს

321
00:17:46,040 --> 00:17:48,840
on cheat ფურცელი.

322
00:17:48,840 --> 00:17:49,440
ეს შეიძლება დაეხმაროს.

323
00:17:49,440 --> 00:17:51,490
თუ თქვენ გაქვთ ოთახში, თქვენ შეგიძლიათ განათავსოთ.

324
00:17:51,490 --> 00:17:56,170
ეს არის ასევე მხოლოდ ზოგადად არის საკმარისი
უნდა გვახსოვდეს, რომ როდესაც თქვენ გამოიყენოს იგი

325
00:17:56,170 --> 00:17:59,060
დაგვჭირდება მხოლოდ
აქვს ეს.

326
00:17:59,060 --> 00:18:02,750
რომ გავაკეთებ თქვენი ცხოვრება ბევრი ადვილია.

327
00:18:02,750 --> 00:18:04,000
არც მე უპასუხოს თქვენს კითხვაზე?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> ახლა, ჩვენ ვისაუბრეთ ცოტა
მოკლედ ბიბლიოთეკები.

330
00:18:14,290 --> 00:18:18,570
მაგრამ ორი ძირითადი პირობა, რომ ჩვენ
გამოყენებით ამ დრომდე რა თქმა უნდა,

331
00:18:18,570 --> 00:18:20,860
სტანდარტული I / O და cs50.

332
00:18:20,860 --> 00:18:25,410
რა სახის რამ შედის
სტანდარტული I / O ბიბლიოთეკაში?

333
00:18:25,410 --> 00:18:28,410
>> ჰო, ჯერჯერობით ჩვენ გამოიყენება printf.

334
00:18:28,410 --> 00:18:31,150
CS50, ჩვენ გამოიყენება GetInt
და GetString.

335
00:18:31,150 --> 00:18:37,200
და მონაცემების ტიპის სიმებიანი ასევე მოხდება
უნდა გამოცხადდეს ამ CS50 ბიბლიოთეკაში.

336
00:18:37,200 --> 00:18:40,250
ჩვენ გაიგო უფრო სიღრმისეული შესახებ
როგორ ბიბლიოთეკების მუშაობა და როგორ

337
00:18:40,250 --> 00:18:41,870
ურთიერთქმედება დანარჩენი თქვენი კოდი.

338
00:18:41,870 --> 00:18:46,220
მაგრამ ეს ის ორი ძირითადი პირობა, რომ ჩვენ
არ შეხება ამ დრომდე

339
00:18:46,220 --> 00:18:48,430
რა თქმა უნდა.

340
00:18:48,430 --> 00:18:50,050
>> სახის.

341
00:18:50,050 --> 00:18:58,120
ეს არის კარგი გვახსოვს რამდენად
თითოეული სახის წარმოდგენილია ან როგორ

342
00:18:58,120 --> 00:19:02,840
ბევრი bytes თითოეული ტიპის requires--

343
00:19:02,840 --> 00:19:04,990
int, 4 ბაიტი; char, 1 ბაიტი.

344
00:19:04,990 --> 00:19:06,550
Float არის 4 ბაიტი.

345
00:19:06,550 --> 00:19:07,782
რა არის ორმაგი?

346
00:19:07,782 --> 00:19:09,032
>> აუდიტორია: [INAUDIBLE].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> დინამიკები 1: ჰო, ასე რომ float
მაგრამ ორჯერ უფრო დიდია.

349
00:19:16,240 --> 00:19:17,150
რაც შეეხება ხანგრძლივი?

350
00:19:17,150 --> 00:19:18,400
>> აუდიტორია: [INAUDIBLE].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> დინამიკები 1: OK.

353
00:19:24,680 --> 00:19:25,410
რა არის გრძელი?

354
00:19:25,410 --> 00:19:26,660
>> აუდიტორია: [INAUDIBLE].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> დინამიკები 1: Yeah, ორმაგი int.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
დიახ.

359
00:19:34,705 --> 00:19:36,100
>> აუდიტორია: [INAUDIBLE].

360
00:19:36,100 --> 00:19:38,030
>> დინამიკები 1: Long [INAUDIBLE].

361
00:19:38,030 --> 00:19:41,860
და შემდეგ ხანგრძლივი ხანგრძლივი ორჯერ.

362
00:19:41,860 --> 00:19:42,814
>> აუდიტორია: არა, არა.

363
00:19:42,814 --> 00:19:47,107
ხანგრძლივი მხოლოდ int.

364
00:19:47,107 --> 00:19:50,910
ეს დამოკიდებულია არქიტექტურა
ადრე [INAUDIBLE]

365
00:19:50,910 --> 00:19:52,922
და int აქვს იგივე ზომის.

366
00:19:52,922 --> 00:19:54,172
[INAUDIBLE].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> დინამიკები 1: ასე ხანგრძლივი და
int არის იგივე.

369
00:20:00,920 --> 00:20:02,943
და შემდეგ ხანგრძლივი ხანგრძლივი
ორმაგი int.

370
00:20:02,943 --> 00:20:03,910
ზემოთ.

371
00:20:03,910 --> 00:20:05,550
და მაშინ, რა არის ბოლო ტიპის?

372
00:20:05,550 --> 00:20:06,510
>> აუდიტორია: Pointer.

373
00:20:06,510 --> 00:20:10,350
>> დინამიკები 1: ჰო, ჩვენ ვისწავლეთ
ცოტა შესახებ მითითებას.

374
00:20:10,350 --> 00:20:14,015
და მიუხედავად იმისა, რა კურსორი არის
მიუთითებს, რომელთა მიზანია: ეს შეიძლება იყოს char ვარსკვლავი

375
00:20:14,015 --> 00:20:15,880
ან int star--

376
00:20:15,880 --> 00:20:20,530
ის ყოველთვის 4 ბაიტი მაჩვენებელი.

377
00:20:20,530 --> 00:20:21,633
კითხვა რომ?

378
00:20:21,633 --> 00:20:22,116
დიახ?

379
00:20:22,116 --> 00:20:24,531
>> აუდიტორია: [INAUDIBLE]?

380
00:20:24,531 --> 00:20:29,530
>> დინამიკები 1: ასე ხანგრძლივი და int არის
იგივე ამ CS50 ელექტრო მოწყობილობების.

381
00:20:29,530 --> 00:20:32,302
>> აუდიტორია: ელექტრო სრულიად
ურთიერთშემცვლელნი.

382
00:20:32,302 --> 00:20:33,510
>> დინამიკები 1: Yeah.

383
00:20:33,510 --> 00:20:36,610
ასე რომ, შემდეგ ხანგრძლივი ხანგრძლივი ორმაგი int.

384
00:20:36,610 --> 00:20:39,250
>> აუდიტორია: ეს არის 32 ბიტიანი?

385
00:20:39,250 --> 00:20:40,620
>> დინამიკები 1: 32 bit, yeah.

386
00:20:40,620 --> 00:20:43,572
>> აუდიტორია: ასე რომ [INAUDIBLE]?

387
00:20:43,572 --> 00:20:46,790
>> დინამიკები 1: დიახ, თუ იგი არ
მკაფიოდ ვთქვა,

388
00:20:46,790 --> 00:20:47,870
უნდა ვივარაუდოთ, რომ 32 ბიტიანი.

389
00:20:47,870 --> 00:20:50,040
>> აუდიტორია: ეს ვიტყოდი რაღაც
როგორიცაა ვთქვათ,

390
00:20:50,040 --> 00:20:51,498
არქიტექტურა, როგორიცაა ელექტრო.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 bit, ერთადერთი რამ,
ცვლილება longs და მითითებები.

393
00:21:01,710 --> 00:21:05,614
ორივემ [INAUDIBLE].

394
00:21:05,614 --> 00:21:06,590
>> დინამიკები 1: დიახ?

395
00:21:06,590 --> 00:21:07,566
>> აუდიტორია: კითხვა.

396
00:21:07,566 --> 00:21:10,982
ასე რომ, ერთი პრაქტიკა ტესტები,
ის სთხოვს ხელმოუწერელი int.

397
00:21:10,982 --> 00:21:15,374
ისე როგორ იქნებოდა, რომ უნდა განისაზღვროს,
საწყისი int [INAUDIBLE]?

398
00:21:15,374 --> 00:21:18,140
>> დინამიკები 1: ხელმოუწერელი
წელს არის ასევე 4 ბაიტი.

399
00:21:18,140 --> 00:21:21,172
მაგრამ რა არის განსხვავებული გაფორმდა
int და ხელმოუწერელი int?

400
00:21:21,172 --> 00:21:22,422
>> აუდიტორია: [INAUDIBLE].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> დინამიკები 1: Right.

403
00:21:25,630 --> 00:21:27,570
ერთი შეუძლია წარმოადგენს უარყოფითი ღირებულებებს.

404
00:21:27,570 --> 00:21:28,580
მაგრამ როგორ გავაკეთოთ ეს?

405
00:21:28,580 --> 00:21:30,536
>> აუდიტორია: [INAUDIBLE].

406
00:21:30,536 --> 00:21:36,370
>> დინამიკები 1: ჰო, ეს ზოგავს 1
ცოტა წარმოადგენს ნიშანი.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
ხელმოწერილი აქვს ერთი ცოტა რომ
წარმოადგენს ნიშანი.

409
00:21:45,040 --> 00:21:48,886
და ხელმოუწერელი უბრალოდ ყველა დადებითი.

410
00:21:48,886 --> 00:21:50,365
>> აუდიტორია: OK.

411
00:21:50,365 --> 00:21:54,230
ასე, რომ თქვენ აცხადებენ, რომ ორმაგი
ორჯერ ზომა float?

412
00:21:54,230 --> 00:21:58,202
>> დინამიკები 1: Double ორჯერ
ზომა float, დიახ.

413
00:21:58,202 --> 00:22:01,639
>> აუდიტორია: როგორ მაჩვენებელი
ხანგრძლივი ხანგრძლივი [INAUDIBLE]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> დინამიკები 1: ასე რომ, კითხვა, თუ როგორ აკეთებს
მომცეთ ხანგრძლივი ხანგრძლივი

416
00:22:10,870 --> 00:22:13,800
როგორ არის, რომ მხოლოდ ოთხი ბაიტი, როდესაც
ხანგრძლივი ხანგრძლივი მისი 8 ბაიტი.

417
00:22:13,800 --> 00:22:17,310
ასე მახსოვს რა არის მაჩვენებელი,
არსებითად, სწორედ ბაზა ღირებულება.

418
00:22:17,310 --> 00:22:19,046
>> აუდიტორია: [INAUDIBLE].

419
00:22:19,046 --> 00:22:22,670
>> დინამიკები 1: ჰო, ასე რომ მომცეთ
მხოლოდ მეხსიერებაში.

420
00:22:22,670 --> 00:22:28,040
ასე რომ არ აქვს მნიშვნელობა, თუ რამდენად სივრცეში
ეს მაჩვენებელი მიუთითებს.

421
00:22:28,040 --> 00:22:32,060
ეს მხოლოდ სჭირდება 4 bytes შენარჩუნება სიმღერა
რომ მეხსიერებაში.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
ნებისმიერი სხვა კითხვები?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
ზემოთ.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> ასე რომ, ბოლო რაც მაქვს,
არის სტანდარტული გამომავალი.

428
00:22:47,460 --> 00:22:51,020
თქვენ უნდა გამოიყენოთ ისინი ხშირად
საკმარისი, რომ თქვენ მახსოვს.

429
00:22:51,020 --> 00:22:54,800
მაგრამ ეს არის, როდესაც ჩვენ ვიყენებთ
printf, მაგალითად.

430
00:22:54,800 --> 00:22:59,260
და ჩვენ გვაქვს ამ მფლობელები, რომ
დაიბარეს ფორმატის კოდები.

431
00:22:59,260 --> 00:23:03,910
>> ამიტომ პროცენტს c char, პროცენტი i for int,
და ჩვენ შეგვიძლია ასევე გამოვიყენოთ პროცენტი დ.

432
00:23:03,910 --> 00:23:05,130
ეს იგივე.

433
00:23:05,130 --> 00:23:08,200
მაგრამ, ზოგადად, CS50 ჩვენ
ცდილობენ გამოიყენონ პროცენტი i.

434
00:23:08,200 --> 00:23:09,860
პროცენტი f for float.

435
00:23:09,860 --> 00:23:15,620
პროცენტი ld ხანგრძლივი ხანგრძლივი და
პროცენტი s სიმებიანი.

436
00:23:15,620 --> 00:23:18,550
>> ანალოგიურად, ჩვენ უკვე გამოყენებით რამდენიმე
ამ გაქცევის sequences.

437
00:23:18,550 --> 00:23:22,431
მაგალითად, წარმატებული n ახალი ხაზი.

438
00:23:22,431 --> 00:23:26,910
ეს არის მხოლოდ მაშინ, როდესაც თქვენ გაფორმებით
თქვენი კოდი ბეჭდვითი ვ.

439
00:23:26,910 --> 00:23:27,260
დიახ?

440
00:23:27,260 --> 00:23:28,906
>> აუდიტორია: რა არის პროცენტს დ?

441
00:23:28,906 --> 00:23:31,850
>> დინამიკები 1: ასე რომ, კითხვა
, რა არის პროცენტი დ?

442
00:23:31,850 --> 00:23:33,270
პროცენტი d არის ints.

443
00:23:33,270 --> 00:23:37,392
პროცენტი d და პროცენტი i იგივეა.

444
00:23:37,392 --> 00:23:41,130
>> აუდიტორია: რა სხვაობაა
წარმატებული ო და წარმატებული r?

445
00:23:41,130 --> 00:23:45,300
>> დინამიკები 1: ასე რომ, კითხვა, თუ რა არის
განსხვავება საწინააღმდეგოდ n და

446
00:23:45,300 --> 00:23:48,615
საწინააღმდეგოდ r?

447
00:23:48,615 --> 00:23:50,906
ვფიქრობ, წარმატებული r is--

448
00:23:50,906 --> 00:23:54,340
>> აუდიტორია: ასე რომ წარმატებული r მხოლოდ გულისხმობს
ბრუნდება ხაზის დასაწყისში

449
00:23:54,340 --> 00:23:56,670
გარეშე რეალურად მიმდინარეობს ახალი ხაზი.

450
00:23:56,670 --> 00:24:01,000
ასე რომ, თუ თქვენ ბეჭდვა წარმატებული r და თქვენ
დაბრუნდეს დასაწყისში ხაზი

451
00:24:01,000 --> 00:24:04,005
მაშინ ბეჭდვა მეტი პერსონალი, თქვენ გადავაწერო
პერსონალი, რომ უკვე

452
00:24:04,005 --> 00:24:04,390
[INAUDIBLE].

453
00:24:04,390 --> 00:24:06,725
მაშინ, როდესაც n რეალურად მიდის ახალ
ონლაინ და მიდის [INAUDIBLE].

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> დინამიკები 1: ისე, ნებისმიერი სხვა კითხვები?

456
00:24:13,915 --> 00:24:15,430
ყველა უფლება.

457
00:24:15,430 --> 00:24:18,617
მე ვაპირებ ხელის ეს off to
Dan, რომელიც გაგრძელდება.

458
00:24:18,617 --> 00:24:25,078
>> [ტაში]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN: ყველა კეთილი.

461
00:25:09,720 --> 00:25:18,590
ასე რომ, მე უნდა ლაპარაკი კიდევ ფართო
სპექტრი იდეები კლასს, რომლებიც

462
00:25:18,590 --> 00:25:23,220
დაახლოებით წარმომადგენელი კვირაში ორი და
დაწყების კვირაში სამი დაწყებული off

463
00:25:23,220 --> 00:25:28,690
ჩამოსხმის, რომელიც მხოლოდ გზას
მკურნალობის ღირებულება გარკვეული ტიპის, როგორც

464
00:25:28,690 --> 00:25:30,830
ღირებულება სხვადასხვა ტიპის.

465
00:25:30,830 --> 00:25:34,110
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ ამ სიმბოლო
ints, მოძრავი to ints და

466
00:25:34,110 --> 00:25:35,360
ხანგრძლივი longs გაორმაგდება.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> ეს ყველაფერი შეიძლება გამოყენებულ იქნას, როგორც გზა
მკურნალობის ზოგიერთი რიცხვითი მნიშვნელობა

469
00:25:44,500 --> 00:25:48,370
მინუს char, როგორც ზოგიერთი სხვა
რიცხვითი მნიშვნელობა.

470
00:25:48,370 --> 00:25:54,480
ასე რომ, არსებობს გარკვეული საკითხები ამ,
რა თქმა უნდა, რომელიც მოდის მაშინ, როდესაც მსახიობი

471
00:25:54,480 --> 00:25:57,860
რამ, როგორიცაა float to ints.

472
00:25:57,860 --> 00:26:00,500
ასე რომ, ეს ცოტა უცნაურია.

473
00:26:00,500 --> 00:26:03,170
ჩვენ გვაქვს float, რომ არის 1.31.

474
00:26:03,170 --> 00:26:05,220
ჩვენ გავამრავლოთ ის მიერ 10,000.

475
00:26:05,220 --> 00:26:08,380
და მაშინ ჩვენ ბეჭდვა, როგორც int.

476
00:26:08,380 --> 00:26:09,630
რას ნიშნავს ეს გამომავალი?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 ჯერ 1.31.

479
00:26:14,020 --> 00:26:18,761
ასე რომ, 13,000, არის ის, რომ ვხვდები?

480
00:26:18,761 --> 00:26:20,685
>> აუდიტორია: მე ვფიქრობ, რომ ეს 10,000.

481
00:26:20,685 --> 00:26:24,234
>> DAN: ასე რომ, მე გამრავლებით ეს 10,000
ადრე მე აძლევენ მას.

482
00:26:24,234 --> 00:26:25,202
>> აუდიტორია: Oh.

483
00:26:25,202 --> 00:26:27,622
რომ არ იყოს, ერთი 9
და ზოგიერთი 0 ნომრები?

484
00:26:27,622 --> 00:26:29,270
>> DAN: ალბათ რაღაც უცნაური ციფრები.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
ასე რომ უფლება, ის 1.3-ჯერ 10,000.

487
00:26:37,670 --> 00:26:40,040
ასე რომ, ეს 13,000.

488
00:26:40,040 --> 00:26:41,313
და ეს ზედმეტი weird--

489
00:26:41,313 --> 00:26:42,160
>> აუდიტორია: 13.100.

490
00:26:42,160 --> 00:26:42,650
>> DAN: 13.100.

491
00:26:42,650 --> 00:26:44,910
გმადლობთ, Rob.

492
00:26:44,910 --> 00:26:46,610
და ეს ზედმეტი weirdness--

493
00:26:46,610 --> 00:26:48,060
ამ 9,9--

494
00:26:48,060 --> 00:26:53,860
უბრალოდ იმიტომ, რომ ეს casting
დასრულდა დამრგვალება ქვემოთ, სადაც

495
00:26:53,860 --> 00:26:55,394
ეს არ უნდა.

496
00:26:55,394 --> 00:26:55,871
Yeah.

497
00:26:55,871 --> 00:26:58,256
>> აუდიტორია: casting ხდება
შემდეგ არაფერი?

498
00:26:58,256 --> 00:27:03,865
>> DAN: ასე იმიტომ, რომ მე ეს ბეჭდვითი,
ჯერ ეს გამრავლება, სანამ ის

499
00:27:03,865 --> 00:27:05,230
ჯერ ეს გააპროტესტეს.

500
00:27:05,230 --> 00:27:06,140
>> აუდიტორია: [INAUDIBLE].

501
00:27:06,140 --> 00:27:11,350
>> DAN: ვფიქრობ, ეს იქნებოდა მიცემული პირველი,
yeah, რომელიც იქნება 10,000.

502
00:27:11,350 --> 00:27:12,610
არაფერი?

503
00:27:12,610 --> 00:27:13,330
ზემოთ.

504
00:27:13,330 --> 00:27:16,344
ასე რომ, ეს არის 13.099.

505
00:27:16,344 --> 00:27:17,840
რატომ ხდება ეს?

506
00:27:17,840 --> 00:27:18,900
ორაზროვნება.

507
00:27:18,900 --> 00:27:21,020
>> მოძრავი არ არის სრულყოფილი.

508
00:27:21,020 --> 00:27:27,550
მათ შეუძლიათ მხოლოდ წარმოადგენს ნომრები
გარკვეული რაოდენობის მნიშვნელოვანი მოღვაწეები.

509
00:27:27,550 --> 00:27:35,120
ასე რომ, თუ ჩვენ ამობეჭდოთ 8 sig ლეღვის on
ამ float, მივიღებთ სახის

510
00:27:35,120 --> 00:27:36,800
მახინჯი ეძებს ნომერი.

511
00:27:36,800 --> 00:27:45,580
და ეს იმიტომ, 1.31 არ შეუძლია ზუსტად
შეიძლება წარმოდგენილი იყოს მარტივი

512
00:27:45,580 --> 00:27:49,000
უფლებამოსილების ორი მანქანა.

513
00:27:49,000 --> 00:27:53,530
ასე რომ მთავრდება აღების უახლოესი
ვხვდები, რომელიც მთავრდება

514
00:27:53,530 --> 00:27:55,710
რომ ცოტა დაბალია.

515
00:27:55,710 --> 00:27:57,730
აზრი?

516
00:27:57,730 --> 00:27:59,110
OK.

517
00:27:59,110 --> 00:28:05,840
>> ახლა, გადავიდა სხვადასხვა გზა
აკეთებს პირობითი, სადაც ყველა

518
00:28:05,840 --> 00:28:09,900
ჩვენ აღელვებს ის არის ერთი ცვლადის.

519
00:28:09,900 --> 00:28:16,570
ასე რომ, ამ კონკრეტულ მაგალითს, ჩვენ
მიღების რიცხვი შესახებ.

520
00:28:16,570 --> 00:28:21,070
და შემდეგ ჩვენ შევხედავთ
რა, რომ მთელი რიცხვი.

521
00:28:21,070 --> 00:28:23,500
სავარაუდოდ, ეს ნომერი
ერთი და ოთხი.

522
00:28:23,500 --> 00:28:24,800
რომ ის, რაც ჩვენ ითხოვს.

523
00:28:24,800 --> 00:28:28,450
>> ასე რომ თქვენ გადართვის of
ცვლადის სახელი.

524
00:28:28,450 --> 00:28:34,290
მაშინ შეიქმნა ფაქტებზე
აფასებს ეს შეიძლება იყოს.

525
00:28:34,290 --> 00:28:37,730
ასე რომ, საქმე ერთი, ამბობენ, რომ ეს დაბალი.

526
00:28:37,730 --> 00:28:41,080
და მაშინ შესვენება გავიდნენ
შეცვლა მდგომარეობა, ამიტომ

527
00:28:41,080 --> 00:28:43,270
თქვენ არ გაქვთ აპირებს.

528
00:28:43,270 --> 00:28:44,830
>> მომდევნო case--

529
00:28:44,830 --> 00:28:46,940
ასე შემთხვევაში ორი და საქმის three--

530
00:28:46,940 --> 00:28:51,920
თუ ეს საქმე ორ უბრალოდ წვეთები ქვემოთ
პირველი ხაზი კოდი, რომ ხედავს ერთად

531
00:28:51,920 --> 00:28:55,400
შემთხვევაში სამი, სანამ ის ხედავს შესვენების.

532
00:28:55,400 --> 00:29:00,430
ასე რომ, იმ მიზეზით, თქვენ მიიღებთ შემთხვევაში ერთი
მხოლოდ ბეჭდვა დაბალი იმიტომ, რომ მე

533
00:29:00,430 --> 00:29:01,890
აქვს ამ შესვენების აქ.

534
00:29:01,890 --> 00:29:05,360
თუ მე, ვთქვათ, იგნორირებული ამ break--
თუ გადააგდეს ეს breakaway--

535
00:29:05,360 --> 00:29:09,740
ეს იქნებოდა ბეჭდვა დაბალია, და მაშინ
ბეჭდვა შუა და შემდეგ ეს იქნებოდა შესვენება.

536
00:29:09,740 --> 00:29:12,200
>> ასე რომ, შეღავათები მნიშვნელოვანი ნაწილი
შეცვლა პირობები და

537
00:29:12,200 --> 00:29:14,340
მათ უნდა იქ.

538
00:29:14,340 --> 00:29:20,070
ნებისმიერი შემთხვევები, რომ არ უთქვამს მკაფიოდ,
სიფრთხილით მიერ ნაგულისხმები

539
00:29:20,070 --> 00:29:26,645
შემთხვევაა შეცვლა და უნდა მისცეს.

540
00:29:26,645 --> 00:29:31,363
>> აუდიტორია: ასე რომ 1, 2, 3,
4 იქნება n?

541
00:29:31,363 --> 00:29:33,310
>> DAN: ფასეულობები, რომელიც n შეიძლება იყოს.

542
00:29:33,310 --> 00:29:34,654
დიახ.

543
00:29:34,654 --> 00:29:35,146
ჰო?

544
00:29:35,146 --> 00:29:37,606
>> აუდიტორია: ასე რომ, როდესაც თქვენ გაქვთ
რომ [INAUDIBLE]?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN თქვენ ბეჭდვა დაბალია, და მაშინ
ეს იქნებოდა ბეჭდვა შუა და

547
00:29:46,830 --> 00:29:47,400
მაშინ ეს იქნებოდა შესვენება.

548
00:29:47,400 --> 00:29:50,244
>> აუდიტორია: რატომ უნდა ბეჭდვა
შუა [INAUDIBLE]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN: So ყველაფერი შემთხვევაში
ადრე შესვენების ქვეშ ექცევა.

551
00:30:00,550 --> 00:30:09,390
ასე რომ, საქმე ბეჭდვითი ქვევმოთ შემთხვევაში
ერთი, როგორც ეს შემდეგ ბეჭდვა.

552
00:30:09,390 --> 00:30:09,890
ჰო?

553
00:30:09,890 --> 00:30:11,140
>> აუდიტორია: [INAUDIBLE]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN: ასე რომ, ეს არის მხოლოდ კონკრეტული
ღირებულება, რომელიც ამ ცვლადი

556
00:30:22,170 --> 00:30:23,420
შეუძლია, არა?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
ამჯამად რომ აზრი?

559
00:30:28,490 --> 00:30:28,990
Yeah.

560
00:30:28,990 --> 00:30:31,490
>> აუდიტორია: [INAUDIBLE]?

561
00:30:31,490 --> 00:30:34,130
>> DAN: დიახ, საქმე ორი ბეჭდვა
შუა და შემდეგ შესვენება.

562
00:30:34,130 --> 00:30:35,380
>> აუდიტორია: [INAUDIBLE]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN: ვფიქრობ, არა?

565
00:30:40,050 --> 00:30:43,855
რა სხვა მონაცემთა ტიპები
შეგიძლიათ გადართოთ მეტი?

566
00:30:43,855 --> 00:30:46,320
>> აუდიტორია: თქვენ შეგიძლიათ გადახვიდეთ
მეტი ნებისმიერი ტიპის მონაცემები.

567
00:30:46,320 --> 00:30:50,905
მაგრამ ეს მხოლოდ იმას ნიშნავს, არაფერი მეტი სიმბოლო
და ints და პერსონალის იგრძნობა, რადგან

568
00:30:50,905 --> 00:30:55,600
თუ თქვენ გადართვის მეტი მაჩვენებელი
ეს ნამდვილად არ აქვს აზრი,

569
00:30:55,600 --> 00:30:59,555
გადართვის მეტი ტვირთის გადატანა, თუ ის კიდევ მოდით
თქვენ, რომ, იმის გამო, რომ მცურავი წერტილი

570
00:30:59,555 --> 00:31:02,840
სიზუსტით, თქვენ ნამდვილად არ
მინდა, რომ მაინც.

571
00:31:02,840 --> 00:31:07,320
ასე რომ, საკმაოდ ბევრი, უბრალოდ ints და
სიმბოლო და პერსონალის მსგავსი.

572
00:31:07,320 --> 00:31:12,360
>> DAN: ჰო, როდესაც თქვენ გაქვთ გამოკვეთილ
ღირებულებები, რომ თქვენ იცით, ვფიქრობ, შეიძლება იყოს

573
00:31:12,360 --> 00:31:14,250
რომ შეცვლა ფაქტობრივად სასარგებლო.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
კარგი?

576
00:31:18,990 --> 00:31:21,370
OK.

577
00:31:21,370 --> 00:31:26,180
>> Scope არის სპექტრი, დეკლარირებული
ცვლადი ვრცელდება.

578
00:31:26,180 --> 00:31:32,190
ასე რომ, ამ პატარა ბლოკი კოდი მაქვს,
ეს იქნება სრული შეცდომები.

579
00:31:32,190 --> 00:31:41,450
და მიზეზი ის არის, რომ მე განაცხადა int
i ფარგლებში ამ for loop.

580
00:31:41,450 --> 00:31:46,390
და მაშინ ვცდილობ მითითებას, რომ
i გარეთ რომ მარყუჟი ფარგლებს.

581
00:31:46,390 --> 00:31:50,330
>> ასე რომ, ძირითადად, შეგიძლიათ ვიფიქროთ ფარგლებში
როგორც ყველაფერი, რაც თქვენ გამოაცხადოს

582
00:31:50,330 --> 00:31:59,750
შიგნით კომპლექტი curly braces მხოლოდ
არსებობს ფარგლებში იმ Curly braces.

583
00:31:59,750 --> 00:32:04,990
და თუ თქვენ ცდილობენ და გამოიყენოს ცვალებად
გარეთ იმ Curly braces, თქვენ

584
00:32:04,990 --> 00:32:08,356
მიიღოს შეცდომა შემდგენელი.

585
00:32:08,356 --> 00:32:08,812
ჰო?

586
00:32:08,812 --> 00:32:09,724
>> აუდიტორია: ასე რომ, ეს ერთი არ მუშაობს?

587
00:32:09,724 --> 00:32:11,790
>> DAN: ეს არ მუშაობს, დიახ.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
სიმები.

590
00:32:18,660 --> 00:32:19,780
სიმებიანი char *.

591
00:32:19,780 --> 00:32:22,250
ისინი ზუსტად იგივე.

592
00:32:22,250 --> 00:32:25,540
ისინი მხოლოდ მითითებას გმირები.

593
00:32:25,540 --> 00:32:33,000
და ნებისმიერი strings, რომ თქვენ უნდა უნდა დასრულდეს
ერთად წარმატებული ნულოვანი, რაც არის

594
00:32:33,000 --> 00:32:34,410
c კონვენციას.

595
00:32:34,410 --> 00:32:36,680
>> მას უწოდებენ null terminator.

596
00:32:36,680 --> 00:32:39,050
და NULL--

597
00:32:39,050 --> 00:32:41,670
კაპიტალის N კაპიტალური, U, დედაქალაქის
L, დედაქალაქში L--

598
00:32:41,670 --> 00:32:44,290
არ არის იგივე, რაც
Null terminator.

599
00:32:44,290 --> 00:32:46,640
ეს არის მაჩვენებელი.

600
00:32:46,640 --> 00:32:48,280
ეს არის გმირი.

601
00:32:48,280 --> 00:32:49,530
ისინი ძალიან მკაფიო.

602
00:32:49,530 --> 00:32:50,200
მახსოვს.

603
00:32:50,200 --> 00:32:52,320
ეს იქნება ინტელექტუალური, ალბათ.

604
00:32:52,320 --> 00:32:54,040
მე არ მინახავს ვიქტორინა.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
ჰო?

607
00:32:58,840 --> 00:33:01,232
>> აუდიტორია: ასე რომ NULL არის, ვთქვათ, მაჩვენებელი?

608
00:33:01,232 --> 00:33:01,995
>> DAN: დიახ.

609
00:33:01,995 --> 00:33:05,170
>> აუდიტორია: რა [INAUDIBLE]?

610
00:33:05,170 --> 00:33:10,050
>> DAN: თუ, ვთქვათ, malloc ეწოდება, როდესაც თქვენ
არ არის საკმარისი მეხსიერება მისაღებად

611
00:33:10,050 --> 00:33:14,400
რაც ზომა თქვენ ითხოვს,
malloc დაბრუნდება NULL.

612
00:33:14,400 --> 00:33:19,550
ეს, ძირითადად, როდესაც ფუნქცია
უნდა დაბრუნდეს კურსორი, თქვენ

613
00:33:19,550 --> 00:33:22,600
უნდა შეამოწმოთ წინააღმდეგ NULL რადგან
NULL არის საკმაოდ good--

614
00:33:22,600 --> 00:33:25,260
ეს, ერთგვარი, ნაგვის ღირებულება.

615
00:33:25,260 --> 00:33:27,050
ის ნულოვანი რამდენადაც მითითებას წასვლა.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> ყოველთვის, როცა რეკავთ ფუნქცია,
რომ ბრუნდება მაჩვენებელი.

618
00:33:32,250 --> 00:33:35,960
თქვენ აპირებს გვინდა შევამოწმოთ იყოს
დარწმუნებული ვარ, რომ ეს მაჩვენებელი არ არის NULL

619
00:33:35,960 --> 00:33:37,760
იმიტომ, რომ NULL არის ძალიან საერთო.

620
00:33:37,760 --> 00:33:40,160
ეს ერთგვარი ნაგვის დაბრუნებას.

621
00:33:40,160 --> 00:33:44,902
ასე რომ, თუ რამე არ წასვლა უფლება,
დააბრუნებს NULL ნაცვლად.

622
00:33:44,902 --> 00:33:45,898
>> აუდიტორია: [INAUDIBLE]?

623
00:33:45,898 --> 00:33:48,922
>> DAN: დიახ, და რომ ეს.

624
00:33:48,922 --> 00:33:51,750
>> აუდიტორია: [INAUDIBLE]?

625
00:33:51,750 --> 00:33:52,800
>> DAN: Spell, როგორც ეს.

626
00:33:52,800 --> 00:33:54,150
ის NULL terminator.

627
00:33:54,150 --> 00:33:56,560
ის ამას N-U-L-L თუ
თქვენ მართლწერის მას.

628
00:33:56,560 --> 00:33:59,860
>> აუდიტორია: მე უბრალოდ წავიდა
უკან და ტესტირება.

629
00:33:59,860 --> 00:34:03,010
და თუ თქვენ ცდილობენ დააყენა მცურავი წერტილი
ღირებულება შევიდა შეცვლა, რომ თქვენ დაწეროთ თქვენ

630
00:34:03,010 --> 00:34:05,916
განაცხადა, რომ განცხადებაში მოითხოვს გამოხატვის
რიცხვი ტიპის.

631
00:34:05,916 --> 00:34:07,166
>> DAN: წავიდეთ.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
მაგრამ ჰო, რა იყო კითხვა ისევ?

634
00:34:12,246 --> 00:34:13,496
>> აუდიტორია: [INAUDIBLE]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN: So კაპიტალის N კაპიტალური, U, დედაქალაქის
L, დედაქალაქში L ფაქტობრივი c რამ.

637
00:34:23,679 --> 00:34:29,719
ეს არის NULL მაჩვენებელი და იქნება
მხოლოდ განიხილება, როგორც ასეთი.

638
00:34:29,719 --> 00:34:33,530
თქვენ არ ოდესმე ცდილობენ და სიტყვიერად
NULL ხასიათი და ვხედავ

639
00:34:33,530 --> 00:34:35,630
სხვა გზა, ვიდრე ეს.

640
00:34:35,630 --> 00:34:36,610
ჰო?

641
00:34:36,610 --> 00:34:42,490
>> აუდიტორია: ასე რომ დაბრუნების char max ან
რაღაც აღნიშნავს, რომ მას

642
00:34:42,490 --> 00:34:43,960
განასახიერებს იგივე ფუნქცია
როგორც [INAUDIBLE]?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> აუდიტორია: ასე რომ თქვენ გულისხმობდა
დაბრუნების char max საწყისი getchar, ან

645
00:34:54,949 --> 00:34:55,444
რაც არ არის?

646
00:34:55,444 --> 00:34:55,940
>> აუდიტორია: Yeah.

647
00:34:55,940 --> 00:34:58,620
>> აუდიტორია: ჰო, ისე, ზოგადად,
ტერმინი ყველა იმ რამ

648
00:34:58,620 --> 00:34:59,920
არის Sentinel ღირებულებების.

649
00:34:59,920 --> 00:35:03,640
ასე რომ, როგორც დაბრუნების int max საწყისი GetInt
და char max საწყისი getchar, ეს

650
00:35:03,640 --> 00:35:06,010
უნდა იყოს, ყველა უფლება, თუ
ეს ყველაფერი უბრუნდება us,

651
00:35:06,010 --> 00:35:07,210
რაღაც წავიდა არასწორი.

652
00:35:07,210 --> 00:35:09,950
>> ამისთვის პოინტერები, ჩვენ უბრალოდ არ უნდა ჰქონდეს
ამ Sentinel ღირებულება, რომ ყველას

653
00:35:09,950 --> 00:35:10,750
შეათანხმებს.

654
00:35:10,750 --> 00:35:13,210
და ეს არის ის, რაც თქვენ დაბრუნდება
როდესაც რამ წავიდეთ არასწორი.

655
00:35:13,210 --> 00:35:15,910
ასე რომ char max არის ის, რაც ჩვენ გამოყენებით
, წარმოადგენს რაღაც

656
00:35:15,910 --> 00:35:18,100
ისევე როგორც NULL ან getchar.

657
00:35:18,100 --> 00:35:23,420
>> აუდიტორია: ასე რომ, თუ თქვენ ტესტირების getchar,
შეიძლება უბრალოდ დააყენა NULL?

658
00:35:23,420 --> 00:35:23,910
რომ რომ განსხვავება?

659
00:35:23,910 --> 00:35:25,400
>> DAN თქვენ ვერ მხოლოდ შესამოწმებლად NULL.

660
00:35:25,400 --> 00:35:30,130
ნეტავ უნდა შეამოწმოს char max რადგან
დაბრუნების ღირებულება ფუნქცია

661
00:35:30,130 --> 00:35:35,416
ხასიათი არ მომცეთ.

662
00:35:35,416 --> 00:35:35,888
ჰო?

663
00:35:35,888 --> 00:35:38,248
>> აუდიტორია: ეს კითხვა სთხოვს
სიმებიანი სიგრძე.

664
00:35:38,248 --> 00:35:40,136
იმას, რომ მოიცავს NULL ხასიათი?

665
00:35:40,136 --> 00:35:41,000
>> DAN: არა

666
00:35:41,000 --> 00:35:45,930
და ეს რეალურად როგორ სიმებიანი სიგრძე
იცის, რომ შეწყვიტოს, რადგან ეს გადის

667
00:35:45,930 --> 00:35:49,070
თქვენი მასივი გმირები სანამ
ის ხედავს NULL ხასიათი.

668
00:35:49,070 --> 00:35:51,030
და შემდეგ ეს იგივეა, ყველა
მარჯვენა, მე გაკეთდეს.

669
00:35:51,030 --> 00:35:52,130
>> აუდიტორია: [INAUDIBLE] ხუთ?

670
00:35:52,130 --> 00:35:53,990
>> DAN: Hello იქნება ხუთ.

671
00:35:53,990 --> 00:35:55,240
Yep.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
ასე რომ კოლექტორები არის უწყვეტი
ბლოკები მეხსიერება.

674
00:36:02,880 --> 00:36:08,480
ისინი მყისიერი ხელმისაწვდომობის და განაცხადა,
მომხმარებლის სახელი მასივი და შემდეგ, curly

675
00:36:08,480 --> 00:36:16,720
braces, რასაც ინდექსი გსურთ წავიდეთ
რომ, ისინი ინდექსირებული ნულიდან მეშვეობით

676
00:36:16,720 --> 00:36:20,100
სიგრძეზე მასივი მინუს 1.

677
00:36:20,100 --> 00:36:23,070
>> და ისინი განაცხადა ტიპის
რამ, რომ თქვენ შენახვის

678
00:36:23,070 --> 00:36:29,750
მასივი, სახელი მასივი, და შემდეგ
მიუხედავად ზომა არის, რომ მასივი.

679
00:36:29,750 --> 00:36:36,660
ასე რომ, ეს არის char array სიგრძე
ექვსი, რომელსაც აქვს ამ ღირებულებებს.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
ჰო?

682
00:36:42,700 --> 00:36:43,950
>> აუდიტორია: [INAUDIBLE]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN: ჰო.

685
00:36:48,460 --> 00:36:51,340
>> აუდიტორია: [INAUDIBLE]?

686
00:36:51,340 --> 00:36:56,700
>> DAN: თუ თქვენ გაქვთ, რა ხდება
მასივი უკვე გააკეთა.

687
00:36:56,700 --> 00:37:02,260
ასე რომ თქვენ ვერ აკონკრეტებს, ეს ნაცვლად, როგორც,
ვთქვათ, char, რასაც სახელი თქვენი

688
00:37:02,260 --> 00:37:12,200
array არის, ცარიელი ფრჩხილები ტოლია curly
გაუწიოს H მძიმე E მძიმე L მძიმე L მძიმით

689
00:37:12,200 --> 00:37:16,290
O მძიმე NULL ხასიათი
და curly გაუწიოს.

690
00:37:16,290 --> 00:37:18,180
რომ ასევე მუშაობა როგორც დეკლარაცია.

691
00:37:18,180 --> 00:37:20,886
>> აუდიტორია: [INAUDIBLE]?

692
00:37:20,886 --> 00:37:23,110
>> DAN: მაშინ თქვენ უნდა
ზომა უკვე გააკეთა.

693
00:37:23,110 --> 00:37:23,896
>> აუდიტორია: [INAUDIBLE]?

694
00:37:23,896 --> 00:37:25,146
>> DAN: დიახ.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
ყველა კეთილი.

697
00:37:32,420 --> 00:37:36,430
ბრძანების ხაზი არგუმენტები არის გზა
მიღების შეიტანენ შესახებ,

698
00:37:36,430 --> 00:37:39,380
არგუმენტები ძირითადი.

699
00:37:39,380 --> 00:37:40,600
მთავარი იღებს ორ არგუმენტს.

700
00:37:40,600 --> 00:37:47,680
რიგი არგუმენტები, რაც მიმდინარეობს
გადაიარეს ბრძანების და

701
00:37:47,680 --> 00:37:55,340
string ვექტორი ან სიმებიანი მასივი
ყველა არგუმენტები.

702
00:37:55,340 --> 00:38:07,840
>> ასე რომ, თუ, ვთქვათ, მოუწოდა ფუნქცია, როგორიცაა
dot out 1 ფართი, 2 ფართი, სამი,

703
00:38:07,840 --> 00:38:10,110
argc იქნება 4.

704
00:38:10,110 --> 00:38:17,370
და argv 0 იქნებოდა dot out.

705
00:38:17,370 --> 00:38:19,130
Argv1 იქნება 1.

706
00:38:19,130 --> 00:38:23,030
argv2 იქნება 2 argv3 იქნება
3, ამ კონკრეტულ შემთხვევაში.

707
00:38:23,030 --> 00:38:23,310
ჰო?

708
00:38:23,310 --> 00:38:25,400
>> აუდიტორია: [INAUDIBLE]?

709
00:38:25,400 --> 00:38:34,010
>> DAN: ბოლო ელემენტს მასივი
იმის გამო, რომ მასივი სიგრძე argc plus

710
00:38:34,010 --> 00:38:41,050
ერთი argb, ბოლო ელემენტს
null მაჩვენებელი.

711
00:38:41,050 --> 00:38:42,580
ეს არის argc პლუს 1.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
ასე რომ იმ შემთხვევაში, რომ მე განაცხადა, რომ ეს
იქნება argv 0 dot out.

714
00:38:52,150 --> 00:38:56,330
argv 1 არის 1 argv2 არის 2 argv 3 3.

715
00:38:56,330 --> 00:39:03,490
argv 4, რომელიც არის ერთ ერთი დიდი
ვიდრე argc იქნება NULL.

716
00:39:03,490 --> 00:39:04,870
>> და ეს არის NULL მაჩვენებელი.

717
00:39:04,870 --> 00:39:06,590
დიახ.

718
00:39:06,590 --> 00:39:11,250
და ეს იმიტომ, რომ სიმებიანი
char ვარსკვლავი მაჩვენებელმა.

719
00:39:11,250 --> 00:39:14,102
ასე რომ, ეს უნდა იყოს იგივე ტიპის.

720
00:39:14,102 --> 00:39:14,595
ჰო?

721
00:39:14,595 --> 00:39:16,074
>> აუდიტორია: ორი კითხვა.

722
00:39:16,074 --> 00:39:21,004
ასე რომ, ერთი რა სხვაობაა
ამ და GetString, გარდა ერთი ტიპის

723
00:39:21,004 --> 00:39:22,483
ამ მომხმარებლის სისტემაში?

724
00:39:22,483 --> 00:39:25,934
და ორი, იგი ინახება
თქვენი ბოლო მეხსიერება?

725
00:39:25,934 --> 00:39:28,399
ამიტომ მინდა, GetString რომ
იქნება [INAUDIBLE]?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN: სად ინახება?

728
00:39:33,650 --> 00:39:34,905
მე არ ვიცი, სადაც იგი ინახება.

729
00:39:34,905 --> 00:39:40,000
>> აუდიტორია: ასე რომ, ფაქტობრივად, იცით, რამდენი
ფუნქცია რეკავთ ეს არგუმენტები

730
00:39:40,000 --> 00:39:42,170
ინახება დასტის?

731
00:39:42,170 --> 00:39:46,610
ისე argc და argv არგუმენტები to main
და ისინი დასტის, ან მართლაც

732
00:39:46,610 --> 00:39:49,131
მაღლა რას ფიქრობთ თქვენ, როგორც
დაწყების Stack.

733
00:39:49,131 --> 00:39:53,490
რა იყო მეორე ნაწილი
კითხვა?

734
00:39:53,490 --> 00:39:56,821
>> აუდიტორია: ასე რომ რა [INAUDIBLE]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: ჰო, უბრალოდ, სხვაგვარად,
მიღების შეტანის შესახებ.

736
00:40:00,990 --> 00:40:06,030
ამ ერთი ოდნავ უფრო ეფექტური და
ეს handier სკრიპტები, რადგან თქვენ

737
00:40:06,030 --> 00:40:10,070
შეგიძლიათ უბრალოდ გაივლის არგუმენტებით მთავარი
ფუნქცია, ვიდრე მქონე დაველოდოთ

738
00:40:10,070 --> 00:40:13,400
მომხმარებლებს, თუ არ გაქვთ რაიმე მომხმარებლებს.

739
00:40:13,400 --> 00:40:16,280
>> აუდიტორია: და ჰო, კიდევ strings
იქნება [INAUDIBLE].

740
00:40:16,280 --> 00:40:17,922
ის შესანახად პერსონალის გჭირდებათ.

741
00:40:17,922 --> 00:40:18,834
>> DAN: ჰო?

742
00:40:18,834 --> 00:40:21,114
>> აუდიტორია: [INAUDIBLE]?

743
00:40:21,114 --> 00:40:27,545
>> DAN: დიახ, argv 0 ყოველთვის მოიცავს
dot slash ფუნქცია ზარი.

744
00:40:27,545 --> 00:40:28,042
ჰო?

745
00:40:28,042 --> 00:40:29,292
>> აუდიტორია: [INAUDIBLE]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN: დიახ, თითოეულ არგუმენტებია
დასრულდა NULL ხასიათი, რადგან ისინი

748
00:40:37,310 --> 00:40:38,310
სიმები.

749
00:40:38,310 --> 00:40:40,892
>> აუდიტორია: [INAUDIBLE]?

750
00:40:40,892 --> 00:40:44,116
>> DAN: დიახ, argv argc არის NULL მაჩვენებელი.

751
00:40:44,116 --> 00:40:45,112
>> აუდიტორია: [INAUDIBLE]?

752
00:40:45,112 --> 00:40:47,104
>> DAN: Oh yeah.

753
00:40:47,104 --> 00:40:48,100
ჰო, ბოდიში.

754
00:40:48,100 --> 00:40:49,594
>> აუდიტორია: ასე რომ [INAUDIBLE]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN: ასე რომ, კითხვა, თუ თქვენ გქონდათ
ბრძანების ხაზი dot slash dot out 1, 2,

757
00:41:16,340 --> 00:41:20,410
რომ რაოდენობის command line
არგუმენტები იყოს ორი ან უნდა იყოს, სამი?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> აუდიტორია: ვფიქრობ, რომ ეს არ
ნამდვილად აქვს.

760
00:41:28,240 --> 00:41:31,370
მე, როგორც წესი, უი, თქვენ არ უნდა გაიაროს
ნებისმიერი ბრძანების ხაზი არგუმენტები, როდესაც

761
00:41:31,370 --> 00:41:32,730
ცხადია, რომ თქვენ მოუწოდა ფუნქცია.

762
00:41:32,730 --> 00:41:37,950
ასე რომ, ხშირად ხმამაღლა გამორიცხავს
ფუნქცია იმ ბრძანების

763
00:41:37,950 --> 00:41:40,350
არგუმენტები მიუხედავად იმისა, რომ
შედის argv.

764
00:41:40,350 --> 00:41:42,600
>> DAN: მაგრამ თუ ეს იყო Test--

765
00:41:42,600 --> 00:41:46,550
yeah-- და ასევე თუ ამბობენ, რომ რაღაც
როგორიცაა argc უდრის 3

766
00:41:46,550 --> 00:41:48,512
თქვენ უსაფრთხო იდგა.

767
00:41:48,512 --> 00:41:49,416
ჰო?

768
00:41:49,416 --> 00:41:50,666
>> აუდიტორია: [INAUDIBLE]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN: მე ვფიქრობ, თუ ნაცვლად მოუწოდებდა ამ
in argc და სიმებიანი argv ფრჩხილებში

771
00:42:09,510 --> 00:42:14,350
მაგრამ ინახება იმავე ტიპის და უბრალოდ მოუწოდა
მათ რაღაც განსხვავებული

772
00:42:14,350 --> 00:42:16,640
და ბ, რომ ეს ჯერ კიდევ მუშაობს?

773
00:42:16,640 --> 00:42:18,790
და ეს მაინც იმუშავებს,
თქვენ უნდა just--

774
00:42:18,790 --> 00:42:21,520
ნაცვლად გამოყენებით argc--
მინდა გამოიყენოს და ბ.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
ჰო?

777
00:42:25,408 --> 00:42:26,658
>> აუდიტორია: [INAUDIBLE]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN: ასე რომ, კითხვა GetString არის
აპირებს შესანახად მეხსიერება ბევრი

780
00:42:38,850 --> 00:42:42,280
რადგან GetString არის char *.

781
00:42:42,280 --> 00:42:47,530
იგი ინახავს მეხსიერება ბევრი იმიტომ, რომ ეს
მოუწოდებს ახლა malloc ფარგლებში ფაქტობრივი

782
00:42:47,530 --> 00:42:49,258
განხორციელების GetString.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
OK, მოძრავი.

785
00:42:55,090 --> 00:42:55,950
>> უსაფრთხოება.

786
00:42:55,950 --> 00:43:01,090
ასე რომ, ნამდვილად უსაფრთხო, იმედი არ
ერთი და მისცეს არავის მიუწვდება ნებისმიერ

787
00:43:01,090 --> 00:43:04,540
თქვენი ინფორმაცია, რის გამოც
ყველას აშენებს საკუთარი მანქანები,

788
00:43:04,540 --> 00:43:09,580
საკუთარი ოპერაციული სისტემა, მთელი თავისი
პროგრამები ნულიდან, და, ცხადია,

789
00:43:09,580 --> 00:43:13,410
არ დაკავშირება ნებისმიერ სხვა მანქანები
ინტერნეტით.

790
00:43:13,410 --> 00:43:17,350
ისე კომპიუტერები დაუცველად.

791
00:43:17,350 --> 00:43:19,200
ისინი მართლაც არიან.

792
00:43:19,200 --> 00:43:20,940
ჩვენ უნდა ენდობა სხვა ადამიანები.

793
00:43:20,940 --> 00:43:26,500
>> და იდეა, რომ უსაფრთხოების, რომ თქვენ
ცდილობს შეზღუდოს ოდენობით

794
00:43:26,500 --> 00:43:27,540
ნდობა, რომელიც თქვენ გჭირდებათ.

795
00:43:27,540 --> 00:43:32,080
და ერთი საშუალება გავაკეთოთ, რომ
მეშვეობით კრიპტოგრაფიის.

796
00:43:32,080 --> 00:43:34,950
კრიპტოგრაფიის არის, არსებითად,
ჩვენ საიდუმლოებას.

797
00:43:34,950 --> 00:43:38,880
>> ზოგჯერ ჩვენ უნდა გაიაროს ჩვენი საიდუმლოების
ერთად მეშვეობით, ვთქვათ, ინტერნეტით ან

798
00:43:38,880 --> 00:43:39,980
სხვა რამ.

799
00:43:39,980 --> 00:43:43,180
და ჩვენ არ გვინდა, რომ ადამიანები
ვიცი ამ საიდუმლოებას.

800
00:43:43,180 --> 00:43:50,100
ასე რომ, ჩვენ დაშიფვრა ჩვენი საიდუმლოების შევიდა გზა
ჩვენ იმედი გვაქვს, რომ ვერავინ ვერ გაერკვნენ.

801
00:43:50,100 --> 00:43:51,600
>> ასე რომ, ჩვენ used--

802
00:43:51,600 --> 00:43:54,340
მეშვეობით რა თქმა უნდა ამ class--

803
00:43:54,340 --> 00:44:00,750
რამ, როგორიცაა კეისრის და
[INAUDIBLE], რომლებიც ორივე ძალიან, ძალიან

804
00:44:00,750 --> 00:44:03,200
არასაიმედო გზა encrypting რამ.

805
00:44:03,200 --> 00:44:07,930
ისინი ადვილად გაერკვნენ, რასაც ისინი
და რა თქვენი საიდუმლოებას არიან.

806
00:44:07,930 --> 00:44:12,130
რეალურ სამყაროში იყენებს ბევრად უფრო
რთული კოდირების სქემები.

807
00:44:12,130 --> 00:44:13,880
და ჩვენ არ მოხვდება
უფრო მეტი, ვიდრე, რომ.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> გამართვის.

810
00:44:19,430 --> 00:44:20,785
GDB არის საუკეთესო.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
მე ვაპირებ აღვნიშნო ეს კიდევ ერთხელ.

813
00:44:25,810 --> 00:44:30,920
გამოყენება GDB ყველა დროის ყველა
ამჯერად თქვენ გაქვთ პრობლემა.

814
00:44:30,920 --> 00:44:36,030
ბრძანებები, რომლებიც სასარგებლო GDB არის
შესვენება, რომელიც თქვენ გაივლის ან ხაზი

815
00:44:36,030 --> 00:44:41,330
ნომერი, ფუნქციის სახელი, არსებითად
სადაც თქვენი კოდი გსურთ შეჩერება,

816
00:44:41,330 --> 00:44:45,600
და შეძლებს აღებას.

817
00:44:45,600 --> 00:44:54,140
>> Print იღებს ცვლადი და ბეჭდავს
რაც არ უნდა იყოს ცვლადი, რომ

818
00:44:54,140 --> 00:44:55,990
წერტილი თქვენს აღსრულება.

819
00:44:55,990 --> 00:45:00,130
შემდეგი მოძრაობს თქვენს აღსრულება
ერთად ერთი ნაბიჯია.

820
00:45:00,130 --> 00:45:05,050
და ნაბიჯ ნაბიჯები შიგნით ფუნქცია
თქვენს აღსრულება.

821
00:45:05,050 --> 00:45:10,480
>> სხვა რამ პერსპექტივაში, რომელიც, როგორ
თქვენ რეალურად აწარმოებს თქვენი კოდი.

822
00:45:10,480 --> 00:45:16,630
გაგრძელება იღებს ყველა საჭირო ნაბიჯი,
მიიღოს შემდეგი შესვენების წერტილი.

823
00:45:16,630 --> 00:45:18,300
და ბევრი, ბევრი სხვა.

824
00:45:18,300 --> 00:45:19,040
შეხედეთ მათ.

825
00:45:19,040 --> 00:45:19,901
ისინი დიდი.

826
00:45:19,901 --> 00:45:20,863
ჰო?

827
00:45:20,863 --> 00:45:22,113
>> აუდიტორია: [INAUDIBLE]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN: დიახ, რაც debugger.

830
00:45:28,200 --> 00:45:34,230
ასე რომ, debugger არის პროგრამა, რომელიც
გაძლევთ გამართვის თქვენი პროგრამა.

831
00:45:34,230 --> 00:45:39,931
ეს არ არის პროგრამა, რომელიც დაადგენს შეცდომები
თქვენ, მიუხედავად იმისა, რომ ძალიან კარგი იქნება.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> და ბოლოს ჩემთვის არის ძებნა.

834
00:45:46,040 --> 00:45:51,470
ასე რომ სახის ძიების, რომ ჩვენ ვისაუბრეთ
დაახლოებით ამ კლასში ხაზოვანი ძებნა,

835
00:45:51,470 --> 00:45:55,960
რაც არის, რომ თქვენ გაეცნონ თითოეული
ელემენტის ძებნის სივრცეში, ერთი

836
00:45:55,960 --> 00:46:00,410
ელემენტს დროს, სანამ თქვენთვის რა
ვეძებთ და სანამ მიაღწევს

837
00:46:00,410 --> 00:46:03,350
ბოლოს თქვენი ძებნა სივრცეში, სადაც
აღვნიშნო ამბობენ, რომ თქვენ ვერ იპოვა

838
00:46:03,350 --> 00:46:06,360
ელემენტს, რომ თქვენ ეძებს.

839
00:46:06,360 --> 00:46:13,450
და ეს მაშინ, საუკეთესო მუდმივ დრო,
რაც 0 1 და უარეს ხაზოვანი

840
00:46:13,450 --> 00:46:16,070
დრო, რომელიც 0 ო.

841
00:46:16,070 --> 00:46:19,250
>> ორობითი ძებნა, რაც საჭიროებს
ბინძური ელემენტებს.

842
00:46:19,250 --> 00:46:24,230
თქვენ წასვლა შუა თქვენი ელემენტები,
თუ ელემენტი თქვენ ეძებთ

843
00:46:24,230 --> 00:46:30,120
არის უფრო დიდი ან მცირე, ვიდრე ელემენტი
რომ თქვენ ცენტრიდან.

844
00:46:30,120 --> 00:46:36,510
ეს ის დიდი, თქვენ ამბობთ, რომ ბოლოში
თქვენი ძებნა სივრცე თქვენი

845
00:46:36,510 --> 00:46:41,550
ადგილსამყოფელი, შუა,
და გადატვირთვის პროცესი.

846
00:46:41,550 --> 00:46:46,150
თუ ეს არის პატარა, გადავხედავთ ამბობენ
რომ the-- yeah, რა ხდება?

847
00:46:46,150 --> 00:46:47,400
>> აუდიტორია: [INAUDIBLE]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN: დიახ.

850
00:46:54,260 --> 00:46:58,360
ნებისმიერ სახის რომ ასწავლიან
კლასი არის სამართლიანი თამაში ტესტი.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [სიცილი]

853
00:47:04,920 --> 00:47:10,260
>> DAN: ის ფაქტი, რომ თქვენ არ ჰქონდა
ამის პრობლემა კომპლექტი,, სამართლიანი

854
00:47:10,260 --> 00:47:12,420
თამაშის ტესტი.

855
00:47:12,420 --> 00:47:15,186
>> აუდიტორია: ჩვენ მივდივართ ის, თუ როგორ უნდა

856
00:47:15,186 --> 00:47:17,052
>> DAN: ეს იქნება წავიდა.

857
00:47:17,052 --> 00:47:20,496
>> დინამიკები 2: ფაქტობრივი კოდი
[INAUDIBLE] არის study.cs50.net.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
ასე რომ, თუ გადავხედავთ პრაქტიკას პრობლემა
იმ შერწყმა დალაგების გვერდი

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, არის კოდი
განხორციელების შერწყმა ჯიშია.

861
00:47:35,880 --> 00:47:38,550
ასე რომ თქვენ არ უნდა განახორციელოს
ის თავს დღეს.

862
00:47:38,550 --> 00:47:42,090
მაგრამ დარწმუნდით გესმით, რომ საკმაოდ
მეტი, ვიდრე უბრალოდ იმახსოვრებდა მას.

863
00:47:42,090 --> 00:47:45,035
>> აუდიტორია: [INAUDIBLE]?

864
00:47:45,035 --> 00:47:49,720
>> დინამიკები 2: The შერწყმა დალაგების გვერდი,
study.cs50.net, არსებობს პრაქტიკა

865
00:47:49,720 --> 00:47:53,570
პრობლემა, რომ, თუ თქვენ დააჭირეთ მეშვეობით
პრობლემა, ბოლომდე არ არის

866
00:47:53,570 --> 00:47:56,280
გამოსავალი, რომელიც შერწყმა
სახის განხორციელება.

867
00:47:56,280 --> 00:47:58,510
მაგრამ დარწმუნდით, რომ გესმით
ვიდრე უბრალოდ იმახსოვრებდა მას

868
00:47:58,510 --> 00:47:59,760
ან კოპირება მას.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> აუდიტორია: და კარგად მოქმედებს
პრობლემა გამოცდა იქნება

871
00:48:06,340 --> 00:48:07,990
რაღაც აქ არის სია.

872
00:48:07,990 --> 00:48:12,100
რას ნიშნავს ეს სია ასე შემდეგ
ერთი ნაბიჯია არჩევანი დალაგების ან

873
00:48:12,100 --> 00:48:13,330
Insertion დალაგების ან რასაც.

874
00:48:13,330 --> 00:48:14,940
ერთი სრული iteration სიაში.

875
00:48:14,940 --> 00:48:18,530
ასე რომ, მაშინაც კი, თუ თქვენ არ დასრულდება up სჭირდება
კოდი ის, თქვენ უნდა გვესმოდეს, რომ ეს

876
00:48:18,530 --> 00:48:20,440
საკმარისი ვიცი, როგორ აპირებს
რომ შეცვლის ამ მასივი.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: ეს არის ის ჩემთვის.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [ტაში]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: Hey ყველას.

883
00:49:07,410 --> 00:49:08,390
ჩემი სახელი არის ლუკასი.

884
00:49:08,390 --> 00:49:16,840
მე ვაპირებ ვისაუბრო უკან, ყველა
სახის, რომ ჩვენ ვისწავლეთ, და

885
00:49:16,840 --> 00:49:18,050
ცოტა ყველა მითითებას.

886
00:49:18,050 --> 00:49:18,740
OK?

887
00:49:18,740 --> 00:49:20,340
ასე რომ, პირველ რიგში, უკან.

888
00:49:20,340 --> 00:49:22,951
რას ნიშნავს ეს ვთქვა, რომ
ფუნქცია რეკურსიული?

889
00:49:22,951 --> 00:49:24,675
>> აუდიტორია: მოუწოდებს თავად.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: OK, მოუწოდებს თავად, yeah.

891
00:49:26,500 --> 00:49:27,700
ისე, როგორც ეს სურათზე, მაგალითად.

892
00:49:27,700 --> 00:49:30,280
ეს იგივეა, რომ სურათზე შიგნით
სურათის და ასე შემდეგ.

893
00:49:30,280 --> 00:49:35,740
ასე მაგალითად, შეგიძლიათ აქვს დენ
რომ ვსაუბრობთ ორობითი ძებნა.

894
00:49:35,740 --> 00:49:41,840
ერთი გზა, რომელიც ბინარული ძებნის
რეკურსიული არის ის ფაქტი, რომ თქვენ

895
00:49:41,840 --> 00:49:43,130
ცდილობს იპოვოს ნომერი.

896
00:49:43,130 --> 00:49:44,250
ასე, რომ თქვენ წასვლა შუა.

897
00:49:44,250 --> 00:49:47,130
და შემდეგ თქვენ შეამოწმეთ თუ ნომრები არ
მარცხენა და მარჯვენა.

898
00:49:47,130 --> 00:49:49,650
>> და შემდეგ თუ თქვენ გაირკვეს, ნომერი
იქნება მარცხენა, ის იგივე

899
00:49:49,650 --> 00:49:53,340
რამ, როგორც აკეთებს ძებნის ერთხელ, მაგრამ
მხოლოდ მარცხენა სიაში.

900
00:49:53,340 --> 00:49:57,350
ასე რომ, როგორ ჟღერს
როგორც ეს რეკურსიული.

901
00:49:57,350 --> 00:50:01,870
ასე რომ, ამიტომ ბიჭებს რეკურსიული
გადაწყვეტილება შერწყმა ჯიშია.

902
00:50:01,870 --> 00:50:04,270
>> OK, ასე რომ აქ არის მაგალითი.

903
00:50:04,270 --> 00:50:07,280
ასე ვთქვათ, მინდა აირჩიონ
ყველა ციფრები 1 დან n.

904
00:50:07,280 --> 00:50:13,790
მე გააცნობიეროს, რომ თანხა n
რიცხვი n plus N მინუს 1 მდე 1.

905
00:50:13,790 --> 00:50:17,810
მაგრამ შემდეგ, თუ გავითვალისწინებთ N მინუს 1 plus
n-2 plus 1, რომელიც იგივეა,

906
00:50:17,810 --> 00:50:20,680
რამ, როგორც შემაჯამებელი ნომრები
მდე N მინუს 1.

907
00:50:20,680 --> 00:50:25,890
ასე რომ, შემიძლია ვთქვა, რომ ეს თანხა თანაბრად თანხა
უდრის n პლუს თანხა n მინუს 1.

908
00:50:25,890 --> 00:50:28,010
ამჯამად რომ აზრი?

909
00:50:28,010 --> 00:50:32,630
>> და ასევე, მინდა რაღაც
ე.წ. ბაზის საქმე, რომელიც არის ის, რომ

910
00:50:32,630 --> 00:50:37,440
თანხა ნომრები მდე
ნულოვანი იქნება ნულოვანი.

911
00:50:37,440 --> 00:50:42,770
ამიტომ, როგორც კი მივიღებ ნომერი
ნულოვანი, მე შეწყვიტოს დათვლის.

912
00:50:42,770 --> 00:50:45,330
ამჯამად რომ აზრი?

913
00:50:45,330 --> 00:50:48,120
>> ასე რომ, აქ არის მაგალითი იმისა, თუ როგორ
შეიძლება განახორციელოს, რომ.

914
00:50:48,120 --> 00:50:49,860
ასე რომ, მე ამ ფუნქციის ზოგიერთი.

915
00:50:49,860 --> 00:50:51,700
რომელიც იღებს მთელ რიცხვს n.

916
00:50:51,700 --> 00:50:56,300
ასე რომ აქ მე შევამოწმოთ, თუ N არის
ნაკლები ან ნულის ტოლია.

917
00:50:56,300 --> 00:51:00,310
ასე რომ, თუ ის ნაკლებად ან ნულის ტოლია, I
დაბრუნების ნულოვანი, რომელიც არის ჩვენი ბაზის შემთხვევაში.

918
00:51:00,310 --> 00:51:05,690
წინააღმდეგ შემთხვევაში, მე უბრალოდ დააბრუნოს n plus
თანხა ნომრები

919
00:51:05,690 --> 00:51:07,190
ერთი n მინუს ერთი.

920
00:51:07,190 --> 00:51:09,360
აზრი?

921
00:51:09,360 --> 00:51:10,100
OK.

922
00:51:10,100 --> 00:51:11,610
>> ასე რომ, აქ არის ის, რაც გამოიყურება.

923
00:51:11,610 --> 00:51:15,260
თქვენ გაქვთ თანხა 2 ტოლობის
2 plus თანხა 1.

924
00:51:15,260 --> 00:51:18,930
და ზოგიერთი 1 1 Plus
თანხა 0, რომელიც არის 0.

925
00:51:18,930 --> 00:51:20,216
აზრი?

926
00:51:20,216 --> 00:51:25,342
ასე რომ, თუ ჩვენ შევხედავთ იმ დასტის თქვენი
პროგრამა, ეს არის, თუ რას ჰგავს.

927
00:51:25,342 --> 00:51:26,820
>> პირველ რიგში, ჩვენ ძირითად ფუნქციას.

928
00:51:26,820 --> 00:51:30,320
და შემდეგ, მთავარი ფუნქცია
ე.წ. თანხა 2.

929
00:51:30,320 --> 00:51:36,690
და შემდეგ ეს თანხა 2 თქმას, oh, თანხა
2 უდრის 2 პლუს თანხა ერთი.

930
00:51:36,690 --> 00:51:39,460
ასე რომ დავამატო თანხა 1 Stack.

931
00:51:39,460 --> 00:51:43,860
და თანხა 1 ვაპირებ მოვუწოდო თანხა
0, რომელიც ასევე იქნება დამატებული

932
00:51:43,860 --> 00:51:44,630
Stack.

933
00:51:44,630 --> 00:51:49,240
და მაშინ თითოეული ამ პირობა, რომ
თავზე კიდევ ერთი უნდა დაბრუნდეს

934
00:51:49,240 --> 00:51:52,020
ადრე სხვა პირობა შეიძლება შენარჩუნებას აპირებს.

935
00:51:52,020 --> 00:51:56,240
>> ასე მაგალითად, აქ, თანხა 0,
პირველი, აპირებს დაბრუნებას 0.

936
00:51:56,240 --> 00:51:58,320
და შემდეგ აირჩიოს თანხა 1.

937
00:51:58,320 --> 00:52:00,850
მაშინ თანხა 1 აპირებს
დაბრუნდეს 1 თანხა 2.

938
00:52:00,850 --> 00:52:03,900
და ბოლოს, თანხა 2 აპირებს
დაბრუნების 3 ძირითადი.

939
00:52:03,900 --> 00:52:05,320
ამჯამად რომ აზრი?

940
00:52:05,320 --> 00:52:09,496
>> ეს მართლაც მნიშვნელოვანია, გვესმოდეს, თუ როგორ
დასტის მუშაობს და ცდილობენ

941
00:52:09,496 --> 00:52:11,980
ვნახოთ, თუ ეს აზრი.

942
00:52:11,980 --> 00:52:13,260
OK, ასე დახარისხება.

943
00:52:13,260 --> 00:52:16,170
რატომ არის დახარისხება მნიშვნელოვანია,
პირველ რიგში?

944
00:52:16,170 --> 00:52:18,260
რატომ უნდა იზრუნოს?

945
00:52:18,260 --> 00:52:20,310
ვინმეს?

946
00:52:20,310 --> 00:52:20,695
მომეცი მაგალითი?

947
00:52:20,695 --> 00:52:21,040
ჰო?

948
00:52:21,040 --> 00:52:22,968
>> აუდიტორია: [INAUDIBLE].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: Yeah, OK.

950
00:52:24,700 --> 00:52:26,090
ასე რომ თქვენ შეგიძლიათ მოძებნოთ უფრო ეფექტურად.

951
00:52:26,090 --> 00:52:28,580
ეს არის კარგი გზა.

952
00:52:28,580 --> 00:52:32,462
ასე, მაგალითად, ჩვენ გვაქვს ძალიან ბევრი
რამ, ფაქტობრივად, ჩვენი ცხოვრება, რომ

953
00:52:32,462 --> 00:52:32,920
დახარისხებული.

954
00:52:32,920 --> 00:52:34,830
მაგალითად, ლექსიკონები.

955
00:52:34,830 --> 00:52:39,210
>> ეს ძალიან მნიშვნელოვანია, რომ ყველა
სიტყვა რაღაც იმისათვის, რომ ჩვენ

956
00:52:39,210 --> 00:52:41,970
შეუძლიათ ადვილად.

957
00:52:41,970 --> 00:52:43,280
ასე რომ, რასაც ამბობდა.

958
00:52:43,280 --> 00:52:45,530
თქვენ შეგიძლიათ მოძებნოთ უფრო ეფექტურად.

959
00:52:45,530 --> 00:52:48,740
ვფიქრობ, რა მძიმე იქნებოდა, რომ აქვს
ლექსიკონი, რომელშიც სიტყვები

960
00:52:48,740 --> 00:52:49,500
შემთხვევითი მიზნით.

961
00:52:49,500 --> 00:52:53,120
თქვენ უნდა შევხედოთ, საკმაოდ ბევრი,
თითოეული სიტყვა, სანამ თქვენთვის

962
00:52:53,120 --> 00:52:54,720
სიტყვა, რომ თქვენ ეძებთ.

963
00:52:54,720 --> 00:52:58,710
>> თუ თქვენ იყენებთ Facebook ასევე, როცა
თქვენ ეძებთ თქვენი მეგობრები, თქვენ

964
00:52:58,710 --> 00:53:03,540
ვაპირებთ, რომ Facebook განათავსოთ თქვენი
დაახლოება მეგობარს თავზე პირობა

965
00:53:03,540 --> 00:53:05,470
რომ თქვენ არ გაიგო, რომ ბევრი რამ.

966
00:53:05,470 --> 00:53:08,080
თუ თქვენ წავიდეთ ყველა გზა ბოლოში
მეგობრების სია, თქვენ აპირებს,

967
00:53:08,080 --> 00:53:11,250
ხალხს, რომ თქვენ ალბათ არც კი
გახსოვდეთ, რომ თქვენ მეგობრებს.

968
00:53:11,250 --> 00:53:14,590
და ეს იმიტომ, რომ Facebook სახის
თქვენს მეგობრებს საფუძველზე, თუ როგორ

969
00:53:14,590 --> 00:53:16,472
მჭიდრო თქვენ მათ.

970
00:53:16,472 --> 00:53:17,930
>> ასე აწყობს მონაცემები.

971
00:53:17,930 --> 00:53:18,450
ასევე Pokemon.

972
00:53:18,450 --> 00:53:21,400
ასე რომ, ხედავთ, რომ ყველა Pokemons
აქვს ნომრები.

973
00:53:21,400 --> 00:53:27,210
და ასეთი მარტივი
გზა წვდომის მონაცემები.

974
00:53:27,210 --> 00:53:29,050
>> აუდიტორია: წვდომის Pokemon.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: ჰო.

976
00:53:29,890 --> 00:53:32,395
>> აუდიტორია: [INAUDIBLE].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: Yep.

978
00:53:33,460 --> 00:53:35,140
OK, ასე რომ შერჩევის ჯიშია.

979
00:53:35,140 --> 00:53:41,610
შერჩევის დალაგების აპირებს შერჩევა
პატარა ქალაქის დაუხარისხებელი ღირებულება სიაში ყოველ

980
00:53:41,610 --> 00:53:43,300
დრო თითოეულ iteration.

981
00:53:43,300 --> 00:53:46,800
ეს არის სახის, როგორიცაა სახის, რომ თქვენ ამის გაკეთება
თქვენი უფროსი, როდესაც თქვენ ცდილობთ

982
00:53:46,800 --> 00:53:48,430
დასალაგებლად სიაში მხრივ.

983
00:53:48,430 --> 00:53:51,990
>> ძირითადად, თქვენ არ არის გადავხედავთ
პატარა ნომერი.

984
00:53:51,990 --> 00:53:54,280
თქვენ ამას დახარისხებული სია.

985
00:53:54,280 --> 00:53:56,230
და მაშინ გადახედეთ
შემდეგი ყველაზე პატარა ნომერი.

986
00:53:56,230 --> 00:54:00,080
და შემდეგ თქვენ აკეთეთ
რომ და ასე შემდეგ.

987
00:54:00,080 --> 00:54:04,600
>> ასე შერჩევა დალაგების ძირითადად თქვენ
შეარჩიეთ ყველა დროის ყველაზე პატარა

988
00:54:04,600 --> 00:54:05,750
დაუხარისხებელი ღირებულება.

989
00:54:05,750 --> 00:54:10,840
დააყენა დასასრულს დახარისხებული
ნაწილი სიაში.

990
00:54:10,840 --> 00:54:12,370
და აკეთეთ, რომ.

991
00:54:12,370 --> 00:54:15,890
ასე რომ, მოდით სწრაფად ნახოთ თუ რა
ამ ჰგავს.

992
00:54:15,890 --> 00:54:19,340
ასე რომ აქ დალაგებულია
და დაუხარისხებელი სიაში.

993
00:54:19,340 --> 00:54:23,350
>> ასე რომ, დახარისხებული სია,
ის თავდაპირველად ცარიელი.

994
00:54:23,350 --> 00:54:26,760
და შემდეგ მე ვაპირებ აირჩიოთ
ყველაზე პატარა ნომერი აქ, 2.

995
00:54:26,760 --> 00:54:30,650
ასე რომ მე რიცხვი 2 და მე დააყენა
წინა სიაში.

996
00:54:30,650 --> 00:54:34,910
და მერე ვეძებოთ მომავალი პატარა
ელემენტს, რომელიც 3.

997
00:54:34,910 --> 00:54:37,050
ასე რომ, თქვა ბოლოს
დახარისხებული სია.

998
00:54:37,050 --> 00:54:38,140
და მერე აკეთეთ, რომ.

999
00:54:38,140 --> 00:54:40,040
მე 4 და დააყენოს ის ბოლოს.

1000
00:54:40,040 --> 00:54:41,360
ს 5 და დააყენოს ის ბოლოს.

1001
00:54:41,360 --> 00:54:44,830
>> და შევხედოთ, თუ როგორ ყველა ამ დროს, რომ
მე ვამბობ, რომ ეს დასასრულს,

1002
00:54:44,830 --> 00:54:46,850
ძირითადად, შევცვალე ორი ღირებულებებს.

1003
00:54:46,850 --> 00:54:48,100
OK?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
და შემდეგ ბოლო ერთი, თქვენ უბრალოდ
კიდევ ერთი ელემენტს.

1006
00:54:52,825 --> 00:54:55,870
ასე რომ, ეს უკვე დახარისხებული.

1007
00:54:55,870 --> 00:54:57,800
>> OK, ასე რომ Insertion ჯიშია.

1008
00:54:57,800 --> 00:55:03,180
Insertion დალაგების თქვენ ვაპირებთ აქვს ასევე
რომ რამ, რაც დახარისხებული და

1009
00:55:03,180 --> 00:55:04,690
არასორტირებული სიაში.

1010
00:55:04,690 --> 00:55:14,540
მხოლოდ ის არის, რომ ყოველ ჯერზე, რომ
თქვენ დასძინა ელემენტს დახარისხებული

1011
00:55:14,540 --> 00:55:18,170
სია, თქვენ უბრალოდ აირჩიოთ ელემენტი, რომელიც
არის თვალწინ არასორტირებული სიაში.

1012
00:55:18,170 --> 00:55:20,880
და მაშინ თქვენ აპირებს იპოვოს ის, რაც
პოზიცია უნდა იყოს დახარისხებული

1013
00:55:20,880 --> 00:55:22,300
ნაწილი სიაში.

1014
00:55:22,300 --> 00:55:25,840
>> ვნახოთ, თუ რა არის ეს ასე
ეს ხდის უფრო გრძნობა.

1015
00:55:25,840 --> 00:55:29,360
ასე რომ თავდაპირველად, მაგალითად, ვცდილობ
ჩადეთ ნომერი სამი

1016
00:55:29,360 --> 00:55:30,680
დახარისხებული ნაწილი სიაში.

1017
00:55:30,680 --> 00:55:31,800
ასე რომ სია არ აქვს არაფერს.

1018
00:55:31,800 --> 00:55:34,160
ასე რომ, მე მხოლოდ დააყენა ნომერი 3.

1019
00:55:34,160 --> 00:55:37,480
>> ახლა, მე მინდა რომ დაამატოთ ნომერი 5
დახარისხებული ნაწილი სიაში.

1020
00:55:37,480 --> 00:55:38,900
ასე რომ შევხედოთ ნომერი 5.

1021
00:55:38,900 --> 00:55:40,450
ვამჩნევ, რომ უფრო მეტი, ვიდრე 3.

1022
00:55:40,450 --> 00:55:41,980
მე ვიცი, რომ ეს უნდა იყოს შემდეგ 3.

1023
00:55:41,980 --> 00:55:44,100
ასე რომ მე ზუსტად 3 და 5.

1024
00:55:44,100 --> 00:55:45,940
>> მაშინ მინდა ჩადეთ ნომერი 2.

1025
00:55:45,940 --> 00:55:51,630
ვამჩნევ, რომ ნომერი 2, ფაქტობრივად,
გაგრძელდება შემდეგ ორივე 3 და 5.

1026
00:55:51,630 --> 00:55:54,580
ასე რომ რეალურად უნდა დააყენოს ყველა
გზა დასაწყისში სიაში.

1027
00:55:54,580 --> 00:55:59,030
ამიტომ უნდა, სახის, გადაეტანა ყველა
ელემენტების დახარისხებული სია ასე, რომ შეიძლება

1028
00:55:59,030 --> 00:56:01,970
ოთახში ნომერი 2.

1029
00:56:01,970 --> 00:56:03,160
>> მაშინ მე ვერ ვხედავ ნომერი 6.

1030
00:56:03,160 --> 00:56:05,450
მე ვხედავ, რომ ეს უნდა იყოს შემდეგ 5.

1031
00:56:05,450 --> 00:56:06,240
ასე რომ, მე ამას იქ.

1032
00:56:06,240 --> 00:56:07,965
და ბოლოს, მე შევხედოთ ნომერი 4.

1033
00:56:07,965 --> 00:56:11,030
და მე ეს უნდა
იყოს 3 და 5.

1034
00:56:11,030 --> 00:56:14,870
და მერე ვთქვათ არსებობს და ცვლა
ყველა სხვა ელემენტს.

1035
00:56:14,870 --> 00:56:16,120
აზრი?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> Bubble დალაგება.

1038
00:56:19,150 --> 00:56:25,730
ამიტომ ბუშტი დალაგების ძირითადად ის, რაც თქვენ
აპირებს გააკეთოს, რომ ჩვენ მას bubble

1039
00:56:25,730 --> 00:56:30,113
სახის რადგან თქვენ გაიაროს list--
ეს რეალურად, თუ მე მხოლოდ აჩვენებს

1040
00:56:30,113 --> 00:56:32,300
გნებავთ ამას

1041
00:56:32,300 --> 00:56:35,030
და თქვენ ვაპირებთ შედარების
ნომერზე.

1042
00:56:35,030 --> 00:56:38,410
და თქვენ აპირებს სვოპ მათი
პოზიციებზე, თუ ისინი არ

1043
00:56:38,410 --> 00:56:39,190
სწორი მიზნით.

1044
00:56:39,190 --> 00:56:42,570
>> ასე რომ, ძირითადად, რა ხდება
მოხდება ის, აქ, მაგალითად,

1045
00:56:42,570 --> 00:56:44,160
თქვენ გაქვთ 8 და 6.

1046
00:56:44,160 --> 00:56:47,270
თქვენ იცით, რომ დახარისხებული მიზნით იქნება
რეალურად იყოს 6 და 5, არა?

1047
00:56:47,270 --> 00:56:49,540
ასე რომ თქვენ აპირებს სვოპ ბრძანებებს.

1048
00:56:49,540 --> 00:56:51,370
მაშინ მე ვერ ვხედავ 8 და 4 აქ.

1049
00:56:51,370 --> 00:56:52,250
და მე იგივე.

1050
00:56:52,250 --> 00:56:53,400
სვოპ ერთხელ.

1051
00:56:53,400 --> 00:56:55,070
და ბოლოს, 2 და 8.

1052
00:56:55,070 --> 00:56:56,670
მე ასევე სვოპ მათ.

1053
00:56:56,670 --> 00:57:01,690
>> ეს მოუწოდა Bubble Sort რადგან მას შემდეგ,
თითოეული ამ გამეორების, ფაქტობრივად,

1054
00:57:01,690 --> 00:57:05,910
უდიდესი ნომერი სიაში იღებს
გზა დასასრულს სიაში.

1055
00:57:05,910 --> 00:57:06,940
ამჯამად რომ აზრი?

1056
00:57:06,940 --> 00:57:11,880
რადგან იგი ინახავს შევცვალე ეს
და მოძრავი უფლება.

1057
00:57:11,880 --> 00:57:14,440
>> OK, ასე რომ ეს არის მეორე iteration.

1058
00:57:14,440 --> 00:57:17,200
ეს იქნება იგივე.

1059
00:57:17,200 --> 00:57:20,190
მე გავაკეთებ ერთი swap და
შემდეგ ბოლო ერთი.

1060
00:57:20,190 --> 00:57:23,290
მე რომ არ არსებობს სვოპების
და სია დალაგებულია.

1061
00:57:23,290 --> 00:57:27,460
ასე რომ, Bubble დალაგების, ჩვენ ძირითადად შენარჩუნება
გადის სიაში და შევცვალე

1062
00:57:27,460 --> 00:57:32,310
რამ, სანამ, მე რომ მე არ გავაკეთებ
ნებისმიერი სვოპების აკეთებს, რომ გამეორების, რომელიც

1063
00:57:32,310 --> 00:57:34,270
იმას ნიშნავს, რომ სიაში უკვე დახარისხებული.

1064
00:57:34,270 --> 00:57:35,520
აზრი?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> მოდით ვისაუბროთ ცოტა
იმაზე ქრონომეტრაჟი.

1067
00:57:40,870 --> 00:57:45,165
ასე რომ ბიჭები გახსოვთ დიდი
O, Omega, და Theta?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
ჰო?

1070
00:57:50,990 --> 00:57:53,070
მაშ, რა არის დიდი O, პირველ რიგში?

1071
00:57:53,070 --> 00:57:54,315
>> აუდიტორია: [INAUDIBLE].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: ჰო, ეს ე.წ. უარეს შემთხვევაში
runtime, რომელიც მხოლოდ იმას ნიშნავს, რომ ის

1073
00:57:59,070 --> 00:58:03,470
რამდენად თქვენ ველით პროგრამა
მიიღოს აწარმოებს.

1074
00:58:03,470 --> 00:58:04,910
Like თვალსაზრისით of--

1075
00:58:04,910 --> 00:58:06,660
ამ შემთხვევაში n.

1076
00:58:06,660 --> 00:58:09,150
რაოდენობის ელემენტების
სია ყველაზე ცუდ შემთხვევაში.

1077
00:58:09,150 --> 00:58:12,520
მსგავსად, ყველაზე უარესი შემთხვევაში.

1078
00:58:12,520 --> 00:58:17,100
>> ასე Bubble Sort, მაგალითად,
ჩვენ გვაქვს დიდი O of n კვადრატში.

1079
00:58:17,100 --> 00:58:20,580
რატომ გვაქვს, რომ?

1080
00:58:20,580 --> 00:58:24,716
რატომ არის Bubble Sort დიდი O n მოედანზე?

1081
00:58:24,716 --> 00:58:27,614
>> აუდიტორია: [INAUDIBLE].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: ჰო, უარეს შემთხვევაში იქნება
რომ მე უნდა გავაკეთოთ n iterations.

1083
00:58:35,670 --> 00:58:39,260
ასე რომ, თითოეული გამეორების აპირებს
მოუტანს უდიდესი ელემენტი ბოლომდე

1084
00:58:39,260 --> 00:58:40,290
სიაში.

1085
00:58:40,290 --> 00:58:44,230
ასე რომ, ყველაზე ცუდი ის არის, რომ მე არ მაქვს
გავაკეთოთ, რომ, რაც n-ჯერ.

1086
00:58:44,230 --> 00:58:48,550
და თითოეული იმ დროს, მე უნდა
ამის გაკეთება n გაცვლებს იმიტომ, რომ მე უნდა შეადაროთ

1087
00:58:48,550 --> 00:58:49,870
ყოველი ორი ელემენტები.

1088
00:58:49,870 --> 00:58:53,730
ამიტომაც ის n კვადრატში
იმიტომ, რომ ეს n-ჯერ n.

1089
00:58:53,730 --> 00:59:00,120
>> მაშინ, შერჩევის დალაგების ასევე n მოედანზე
იმიტომ, რომ თითოეული iteration, მე უნდა

1090
00:59:00,120 --> 00:59:02,650
შევხედოთ თითოეული ელემენტი
სიაში.

1091
00:59:02,650 --> 00:59:04,980
და შემდეგ მოვძებნოთ პატარა,
რაც იმას ნიშნავს, რომ მე უნდა

1092
00:59:04,980 --> 00:59:06,130
გაეცნონ n ელემენტებს.

1093
00:59:06,130 --> 00:59:11,750
და მე უნდა გავაკეთოთ, რომ n-ჯერ, რადგან
მე უნდა აირჩიოთ ყველა n ელემენტებს.

1094
00:59:11,750 --> 00:59:18,273
>> Insertion დალაგების, ასევე n მოედანზე
იმიტომ, რომ ყველაზე ცუდი სცენარი იქნება

1095
00:59:18,273 --> 00:59:20,950
შეიძლება, ერთი, მე უნდა ჩაწეროთ
n ციფრები, უფლება?

1096
00:59:20,950 --> 00:59:22,765
ასე რომ, მე უკვე ვიცი, რომ მე ვაპირებ
აქვს n iterations.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
არამედ თითოეული იმ ნომრებს, თუ მქონდა
შევხედოთ ყველა ნომრები

1099
00:59:29,840 --> 00:59:34,380
დახარისხებული სია და ამით მას ყველა გზა
წინ, რომ იქნება n მოედანზე

1100
00:59:34,380 --> 00:59:36,230
რადგან ეს იქნება N ჯერ N ერთხელ.

1101
00:59:36,230 --> 00:59:38,280
აზრი?

1102
00:59:38,280 --> 00:59:41,512
რაც შეეხება omega?

1103
00:59:41,512 --> 00:59:42,886
>> აუდიტორია: [INAUDIBLE].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: საუკეთესო შემთხვევაში სცენარი.

1105
00:59:44,620 --> 00:59:48,810
ასე რომ, ეს იგივეა, ბევრი ჯერ
დახარისხება, საუკეთესო სცენარი

1106
00:59:48,810 --> 00:59:50,660
როდესაც სიაში უკვე დახარისხებული.

1107
00:59:50,660 --> 00:59:52,670
ასე, რომ თქვენ ნამდვილად არ აქვს
არაფერი.

1108
00:59:52,670 --> 00:59:56,290
Bubble Sort აქვს საუკეთესო
სცენარით n.

1109
00:59:56,290 --> 00:59:58,820
თუ ბიჭები ვიცი, რატომ?

1110
00:59:58,820 --> 01:00:00,620
>> აუდიტორია: [INAUDIBLE].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: ჰო, თუ თქვენ შენარჩუნება სიმღერა
არა მონაცემები რაციონი ჰქონდა გაცვლებს ან

1112
01:00:05,640 --> 01:00:10,533
არა, თუ თქვენ გაქვთ რაღაც მითითებული
ნამდვილი იყო თუ iteration, თუ

1113
01:00:10,533 --> 01:00:15,140
სიაში უკვე დახარისხებული, ძირითადად,
რა მოხდება, რომ მე ვაპირებ

1114
01:00:15,140 --> 01:00:17,890
ცდილობენ, რომ სვოპ ყოველი ორი
მიმდებარე ელემენტები.

1115
01:00:17,890 --> 01:00:19,920
მე ვაპირებ, რომ
არსებობს სვოპების.

1116
01:00:19,920 --> 01:00:21,230
და მე უბრალოდ დააბრუნოს დაუყოვნებლივ.

1117
01:00:21,230 --> 01:00:24,240
>> ასე რომ, ეს იმას ნიშნავს, რომ მე მქონდა
გავლა სიაში ერთ დროს.

1118
01:00:24,240 --> 01:00:28,990
ასე რომ, ეს n იმიტომ, რომ მე მოუთმენლად
at n ელემენტებს.

1119
01:00:28,990 --> 01:00:30,930
რატომ შერჩევის დალაგების n კვადრატში?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> ჰო, მაშინაც კი, თუ სია დალაგებულია, for
ყოველ iteration შერჩევის დალაგების, I

1122
01:00:45,520 --> 01:00:47,590
უნდა აირჩიოთ მინიმალური ელემენტს.

1123
01:00:47,590 --> 01:00:49,980
ეს კი იმას ნიშნავს, რომ მე მაქვს, რათა გამოიყურებოდეს
ყველა ელემენტების დაუხარისხებელი

1124
01:00:49,980 --> 01:00:53,350
სიაში და მინიმალური
თითოეული iteration.

1125
01:00:53,350 --> 01:00:54,600
ამჯამად რომ აზრი?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> და ჩასმა ხმალი არის n რადგან
საქმე, რომ მე ვცდილობ ჩასმა

1128
01:01:04,690 --> 01:01:09,320
ნომრები და ყველა რიცხვი, როდესაც მე
ცდილობენ ჩადეთ მათ, მე ვხედავ, რომ მათ

1129
01:01:09,320 --> 01:01:10,510
არის სწორი პოზიცია.

1130
01:01:10,510 --> 01:01:15,120
მე არ მაქვს წასვლა შეამოწმეთ ყველა სხვა
ნომრები არასორტირებული სიაში.

1131
01:01:15,120 --> 01:01:17,170
ასე რომ, ამიტომ ეს იქნება n.

1132
01:01:17,170 --> 01:01:19,480
აზრი?

1133
01:01:19,480 --> 01:01:21,035
და რა არის Theta?

1134
01:01:21,035 --> 01:01:23,410
>> აუდიტორია: [INAUDIBLE].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: რა ბოდიში?

1136
01:01:24,380 --> 01:01:24,960
ამას კიდევ ერთხელ.

1137
01:01:24,960 --> 01:01:25,666
>> აუდიტორია: [INAUDIBLE].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: ზუსტად.

1139
01:01:26,490 --> 01:01:31,280
ასე რომ თქვენ ხედავთ, რომ მხოლოდ შერჩევა
შენახული შერწყმა დალაგების აქვს thetas.

1140
01:01:31,280 --> 01:01:39,920
და ეს იმიტომ, რომ თქვენ მხოლოდ თეტა
თუ ორივე დიდი O და ომეგა იგივეა.

1141
01:01:39,920 --> 01:01:41,520
OK.

1142
01:01:41,520 --> 01:01:44,210
და ბოლოს, შერწყმა დალაგების არის ჟურნალის n.

1143
01:01:44,210 --> 01:01:48,910
>> შემდეგ კი, როგორც Dan ამბობდა, შერწყმა დალაგების
არის სახის მოსწონს იგივე გზა, რომელიც

1144
01:01:48,910 --> 01:01:50,320
თქვენ აკეთებთ ორობითი ძებნა.

1145
01:01:50,320 --> 01:01:53,530
ასე რომ თქვენ მიიღოთ სიაში.

1146
01:01:53,530 --> 01:01:55,170
და თქვენ აპირებს განახევრდა.

1147
01:01:55,170 --> 01:02:00,580
და შემდეგ მოჭრილი მათ
ამ პატარა halves.

1148
01:02:00,580 --> 01:02:01,730
და მაშინ შერწყმა მათ.

1149
01:02:01,730 --> 01:02:02,960
ბიჭები გახსოვთ, არა?

1150
01:02:02,960 --> 01:02:04,960
OK, როგორც ამბობდა.

1151
01:02:04,960 --> 01:02:08,330
>> OK, პოინტერები.

1152
01:02:08,330 --> 01:02:11,078
რა არის მაჩვენებელი?

1153
01:02:11,078 --> 01:02:12,050
>> აუდიტორია: [INAUDIBLE].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: მისამართზე.

1155
01:02:12,820 --> 01:02:13,720
OK.

1156
01:02:13,720 --> 01:02:18,530
მე ვიცი, რომ დავით გვიჩვენებს რამოდენიმე
ვიდეო binky და რამ მიუთითებს

1157
01:02:18,530 --> 01:02:19,080
ერთმანეთს.

1158
01:02:19,080 --> 01:02:22,960
მაგრამ მე მიყვარს ფიქრი პოინტერები
როგორც უბრალოდ მისამართზე.

1159
01:02:22,960 --> 01:02:26,110
ასე რომ, ეს ცვლადი, რომ აპირებს
შესანახად მისამართზე.

1160
01:02:26,110 --> 01:02:31,940
>> ასე რომ, ეს მხოლოდ ამ სპეციალური ცვლადი
რომ არის ოთხი ბაიტი ხანგრძლივი.

1161
01:02:31,940 --> 01:02:36,550
გახსოვდეთ, რომ მომცეთ რამე
ყოველთვის ოთხი ბაიტი ხანგრძლივი ჩვენი 32-bit

1162
01:02:36,550 --> 01:02:39,370
მანქანა ისე, რომ საქმე
ელექტრო.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
და ეს უბრალოდ განთავსების
ცვლადი შიგნით მას.

1165
01:02:47,050 --> 01:02:50,240
>> OK, ასე რომ ეს მეხსიერება, ძირითადად.

1166
01:02:50,240 --> 01:02:57,420
ასე რომ, თითოეული ბლოკი მეხსიერება რეალურად აქვს
ეტიკეტების, რომელიც მისამართი

1167
01:02:57,420 --> 01:02:58,890
slotty მეხსიერება.

1168
01:02:58,890 --> 01:03:02,370
ეს კი იმას ნიშნავს, რომ შემიძლია აქვს
მაჩვენებელი მიუთითებს

1169
01:03:02,370 --> 01:03:03,380
რომელიმე ამ მისამართებზე.

1170
01:03:03,380 --> 01:03:09,930
ასე რომ, მიზეზი, რის გამოც ჩვენ ვიყენებთ მითითებები არის
თუ მე უნდა გვახსოვდეს მდებარეობა

1171
01:03:09,930 --> 01:03:12,300
რომ კონკრეტული ცვლადი მეხსიერებაში.

1172
01:03:12,300 --> 01:03:16,560
>> და ბიჭები გახსოვთ, რომ ერთი იმ
შემთხვევა იყო, თუ მაქვს ფუნქცია

1173
01:03:16,560 --> 01:03:20,820
თუ მაქვს რეალურად მინდა
swap for reals, მე რეალურად

1174
01:03:20,820 --> 01:03:22,110
უნდა გააგზავნოთ მაჩვენებელი.

1175
01:03:22,110 --> 01:03:23,460
არ ცვლადი.

1176
01:03:23,460 --> 01:03:25,200
ბიჭებს გვახსოვდეს, რომ?

1177
01:03:25,200 --> 01:03:26,450
განსხვავება between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
რა არის სახელი?

1180
01:03:34,120 --> 01:03:36,010
დარეკვის ღირებულება და მოუწოდებს
მინიშნება, არა?

1181
01:03:36,010 --> 01:03:36,840
>> OK, yeah.

1182
01:03:36,840 --> 01:03:38,330
ამიტომ მოვუწოდებთ ღირებულება.

1183
01:03:38,330 --> 01:03:43,570
როდესაც თქვენ უბრალოდ გამოგვიგზავნეთ ცვლადი
ფუნქცია თქვენ უბრალოდ გაგზავნის ღირებულება.

1184
01:03:43,570 --> 01:03:45,610
ასე, რომ თქვენ რეალურად გაგზავნის
ასლი ცვლადი.

1185
01:03:45,610 --> 01:03:49,720
და თქვენი პროგრამა ვერ ზრუნვა ნაკლებად
შესახებ, თუ იგივე ცვლადი რეალურად

1186
01:03:49,720 --> 01:03:51,650
იღებს ასლი.

1187
01:03:51,650 --> 01:03:56,330
>> და მოუწოდებს მინიშნება იმას ნიშნავს, რომ
მე რეალურად გაგზავნის ასლი

1188
01:03:56,330 --> 01:03:57,550
მომცეთ, რომ ცვლადი.

1189
01:03:57,550 --> 01:04:00,970
ასე რომ, ეს იმას ნიშნავს, რომ მე ვაგზავნი
მდებარეობა რომ ცვლადი.

1190
01:04:00,970 --> 01:04:04,440
ასე რომ იგრძნოს მაქვს მდებარეობა
ცვლადი, როცა რეკავთ ფუნქცია

1191
01:04:04,440 --> 01:04:09,700
პოინტერები, მე შეუძლია რეალურად
შეცვალოს მონაცემები, რომელიც იყო მთავარი.

1192
01:04:09,700 --> 01:04:12,050
აზრი?

1193
01:04:12,050 --> 01:04:17,560
>> თუმცა, მაჩვენებელი არის ასლი,
მაჩვენებელი ჯერ კიდევ აქვს რეალური მისამართი

1194
01:04:17,560 --> 01:04:20,090
ცვლადი, რომ მინდა, რომ შეიცვალოს.

1195
01:04:20,090 --> 01:04:21,920
აზრი?

1196
01:04:21,920 --> 01:04:24,290
>> ასე შექმნა მითითებას.

1197
01:04:24,290 --> 01:04:28,410
გახსოვდეთ, მაჩვენებელი ყოველთვის უნდა
ტიპის, რომ ეს მიუთითებს

1198
01:04:28,410 --> 01:04:29,890
და შემდეგ ვარსკვლავი.

1199
01:04:29,890 --> 01:04:31,030
და მაშინ დააყენა სახელი.

1200
01:04:31,030 --> 01:04:35,765
ასე რომ გვახსოვდეს, რომ როდესაც თქვენ გაქვთ
რასაც star, ეს როგორც მომცეთ

1201
01:04:35,765 --> 01:04:38,990
რომ რაც არ უნდა ცვლადი
ტიპი რომ ჰქონდა.

1202
01:04:38,990 --> 01:04:42,850
>> ასე რომ აქ ვარსკვლავი, მაგალითად, ეს
მაჩვენებელი და რიცხვი.

1203
01:04:42,850 --> 01:04:47,680
და შემდეგ char ვარსკვლავი მაჩვენებელი
char ვარსკვლავი და სხვ.

1204
01:04:47,680 --> 01:04:47,960
ჰო?

1205
01:04:47,960 --> 01:04:52,710
>> აუდიტორია: რა მოხდება, თუ ჩვენ გვაქვს
მომცეთ n to ვარსკვლავი x.

1206
01:04:52,710 --> 01:04:55,255
მე ვიცი, რომ ქმნის მაჩვენებელი x.

1207
01:04:55,255 --> 01:04:59,432
ნიშნავს თუ არა ეს, ასევე, ვაცხადებთ x რიცხვი?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: OK, ასე რომ, როდესაც თქვენ ამბობთ n star x,
თქვენ არ შექმნის მომცეთ

1209
01:05:05,170 --> 01:05:06,000
ცვლადი x.

1210
01:05:06,000 --> 01:05:08,170
თქვენ შექმნით მაჩვენებელი დაასახელა x.

1211
01:05:08,170 --> 01:05:09,396
>> აუდიტორია: [INAUDIBLE].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: ამიტომ როდესაც ვამბობ n star x, მე
ამბობს, hey, მეხსიერება, მე ვაპირებ

1213
01:05:14,250 --> 01:05:16,390
კიდევ ერთი ამ სამი ყუთები.

1214
01:05:16,390 --> 01:05:20,750
და მე ვაპირებ ვთქვა, რომ
იქნება x, რომელიც

1215
01:05:20,750 --> 01:05:22,000
იქნება მაჩვენებელი.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
და რაღაც საინტერესო პოინტერები
არის, რომ ჩვენ ვამბობთ, რომ მათ აქვთ

1218
01:05:30,640 --> 01:05:32,620
4 bytes for 32-bit მანქანა.

1219
01:05:32,620 --> 01:05:36,320
და მიზეზი ის არის, რომ
4 ბაიტი არის 32 ბიტი.

1220
01:05:36,320 --> 01:05:40,490
>> და მანქანები, რომელიც 64 ბიტი რეალურად
პოინტერები მისამართები

1221
01:05:40,490 --> 01:05:43,480
რომ 64 ბიტი ხანგრძლივი.

1222
01:05:43,480 --> 01:05:49,820
ასე რომ, ეს მხოლოდ იმას ნიშნავს, რომ ზომა
მისამართები მანქანა არის სხვადასხვა.

1223
01:05:49,820 --> 01:05:52,270
>> ასე რომ, მითითება და dereferencing.

1224
01:05:52,270 --> 01:05:54,310
არსებობს ორი ოპერატორები,
თქვენ ბიჭები უნდა გვახსოვდეს.

1225
01:05:54,310 --> 01:05:55,450
პირველი არის ampersand.

1226
01:05:55,450 --> 01:05:56,810
მეორე არის ვარსკვლავი.

1227
01:05:56,810 --> 01:06:05,060
ნუ დაბნეული, რომ ვარსკვლავი და ამ
ვარსკვლავი, რადგან გვახსოვდეს, რომ,

1228
01:06:05,060 --> 01:06:06,950
ამ შემთხვევაში, თქვენ უნდა n star.

1229
01:06:06,950 --> 01:06:08,700
>> ეს იგივეა მთელი რამ ერთად.

1230
01:06:08,700 --> 01:06:10,720
არ არსებობს n სივრცეში ვარსკვლავი.

1231
01:06:10,720 --> 01:06:12,070
ეს იმას ნიშნავს, რომ ის ტიპის.

1232
01:06:12,070 --> 01:06:14,870
გახსოვდეთ, რომ როდესაც თქვენ გაქვთ
ცვლადი ვარსკვლავი, თქვენ

1233
01:06:14,870 --> 01:06:16,230
ვსაუბრობთ ტიპის.

1234
01:06:16,230 --> 01:06:20,540
>> როდესაც თქვენ მხოლოდ ვარსკვლავი და შემდეგ
ცვლადის სახელი, ეს ნიშნავს, რომ

1235
01:06:20,540 --> 01:06:24,100
თქვენ dereferencing მაჩვენებელი, რომელიც
ნიშნავს, რომ თქვენ ეძებს

1236
01:06:24,100 --> 01:06:28,290
მაჩვენებელი, მოძიებაში მისამართზე ეს
მიუთითებს, აპირებს, რომ მისამართი,

1237
01:06:28,290 --> 01:06:30,850
და ეძებს, როდესაც
თქვენ უნდა იქ.

1238
01:06:30,850 --> 01:06:34,310
მე გეტყვით ჩემს სტუდენტებს, რომ როდესაც თქვენ
ვარსკვლავი, თქვენ უნდა ვიფიქროთ, რომ ეს

1239
01:06:34,310 --> 01:06:36,850
აბრევიატურა შინაარსი.

1240
01:06:36,850 --> 01:06:39,770
>> ასე რომ, თუ თქვენ გაქვთ მომცეთ და
ამის გაკეთება ვარსკვლავი მაჩვენებელი, ის

1241
01:06:39,770 --> 01:06:41,720
content მაჩვენებელი.

1242
01:06:41,720 --> 01:06:44,580
ასე, რომ თქვენ წასვლა რასაც ის მიუთითებს
და შევხედოთ მუდმივი შინაარსი.

1243
01:06:44,580 --> 01:06:47,730
და ampersand არის იგივე
რამ, როგორც მისამართი.

1244
01:06:47,730 --> 01:06:52,560
>> ასე რომ, თუ გვაქვს ცვლადი a--, როგორიცაა, მოდით
ამბობენ, რომ მე int ტოლია 3--

1245
01:06:52,560 --> 01:06:56,900
თუ მინდა, რომ იპოვოთ მისამართი, რომელიც
ცვლადი მეხსიერება, მე შემიძლია უბრალოდ

1246
01:06:56,900 --> 01:06:58,240
ampersand.

1247
01:06:58,240 --> 01:07:00,280
ასე რომ, ეს მისამართი.

1248
01:07:00,280 --> 01:07:01,530
აზრი?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> ასე რომ, აქ არის მაგალითი.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
ეს არის დაკარგული int b და int გ.

1253
01:07:11,530 --> 01:07:16,520
ასე int შეადგენს 3 იმას ნიშნავს, რომ
მე ვაპირებ წასვლა მეხსიერება.

1254
01:07:16,520 --> 01:07:19,870
და მე ვაპირებ, რათა იპოვოს slot
და ბოლო ნომერი 3 აქ.

1255
01:07:19,870 --> 01:07:22,200
>> და მაშინ int b შეადგენს 4.

1256
01:07:22,200 --> 01:07:23,100
მე ვაპირებ, რომ იგივე რამ.

1257
01:07:23,100 --> 01:07:25,840
გადადით მეხსიერების და დააყენოს ნომერი
4 ერთი ყუთები.

1258
01:07:25,840 --> 01:07:27,100
და int შეადგენს 5.

1259
01:07:27,100 --> 01:07:29,740
ს სხვა ყუთი და დააყენოს ნომერი 5.

1260
01:07:29,740 --> 01:07:36,160
>> რა არის ეს ხაზი აკეთებს out?
n star pa ტოლია ampersand.

1261
01:07:36,160 --> 01:07:37,800
ასე რომ, პირველ რიგში, n star pa.

1262
01:07:37,800 --> 01:07:39,050
რა არის ეს აკეთებს?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> აუდიტორია: [INAUDIBLE].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: ჰო, ისე n star pa, პირველ რიგში,
აცხადებს მაჩვენებელი მოუწოდა pa.

1266
01:07:47,890 --> 01:07:53,720
და მაშინ ის მინიჭების ღირებულება
რომ მომცეთ მისამართი.

1267
01:07:53,720 --> 01:07:55,790
ასე ampersand.

1268
01:07:55,790 --> 01:07:58,510
მაშინ, თუ ამის გაკეთება ვარსკვლავი pb,
რა არის ვარსკვლავი pb?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> ოჰ, უკაცრავად.

1271
01:08:03,150 --> 01:08:06,330
ეს ასევე არის დაკარგული. n star pb.

1272
01:08:06,330 --> 01:08:07,905
ვგულისხმობ ვარსკვლავი pc.

1273
01:08:07,905 --> 01:08:11,200
მე ასე ვარ.

1274
01:08:11,200 --> 01:08:11,940
ეს იგივე.

1275
01:08:11,940 --> 01:08:16,408
მაგრამ ახლა მე ვარ კარგი ar შექმნის მაჩვენებელი
ბ და შემდეგ მაჩვენებელი გ.

1276
01:08:16,408 --> 01:08:16,886
ჰო?

1277
01:08:16,886 --> 01:08:18,136
>> აუდიტორია: [INAUDIBLE]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: დიახ.

1280
01:08:26,670 --> 01:08:32,630
ასე რომ, თუ მეხსიერების და თქვენ გადასვლა
ყუთი რომ არის აღმნიშვნელის for pa,

1281
01:08:32,630 --> 01:08:37,149
თქვენ რეალურად აპირებს
ვხედავ მისამართი.

1282
01:08:37,149 --> 01:08:38,399
OK?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
ჰო?

1285
01:08:43,300 --> 01:08:45,605
>> აუდიტორია: [INAUDIBLE]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: Yeah, მაჩვენებელი მისამართზე.

1287
01:08:49,260 --> 01:08:50,120
არასოდეს დაივიწყებს.

1288
01:08:50,120 --> 01:08:52,800
ეს იგივეა, რომ ყველაზე მნიშვნელოვანი
ნაწილი მითითებას.

1289
01:08:52,800 --> 01:08:56,180
არსებობს შენახვისა და მისამართი
ზოგიერთი ცვლადი.

1290
01:08:56,180 --> 01:08:56,890
არაფერი?

1291
01:08:56,890 --> 01:08:58,370
ნებისმიერი სხვა კითხვები?

1292
01:08:58,370 --> 01:08:59,189
OK.

1293
01:08:59,189 --> 01:09:00,399
>> ასე პოინტერები და მასივები.

1294
01:09:00,399 --> 01:09:08,189
გახსოვდეთ, რომ, როდესაც მე int array 3,
ძირითადად, რასაც მე ვაკეთებ არის მე, სახის

1295
01:09:08,189 --> 01:09:12,779
საქართველოს, განაცხადა, მაჩვენებელი.

1296
01:09:12,779 --> 01:09:18,960
ამიტომ მასივი სახის როგორც მომცეთ
კონკრეტული ადგილი მეხსიერებაში, რომელიც მე

1297
01:09:18,960 --> 01:09:21,999
გამოყოფილი სამი სლოტი რიცხვებით.

1298
01:09:21,999 --> 01:09:23,430
ამჯამად რომ აზრი?

1299
01:09:23,430 --> 01:09:30,250
>> ასე რომ, როდესაც მე int array 3, რაც მე
ამით, პრაქტიკულად, ვქმნით სამი

1300
01:09:30,250 --> 01:09:31,479
slots მეხსიერებაში.

1301
01:09:31,479 --> 01:09:33,899
ამიტომ მე მხოლოდ სამი slots მეხსიერებაში.

1302
01:09:33,899 --> 01:09:38,810
ასე რომ, თუ, მაშინ, ვარსკვლავი მასივი, ის
ძირითადად, ეს ნიშნავს, რომ შინაარსი მასივი,

1303
01:09:38,810 --> 01:09:46,180
რაც იმას ნიშნავს, წაშალოს მაჩვენებელმა, მე
იმ ადგილას, რომ ეს მიუთითებს,

1304
01:09:46,180 --> 01:09:47,939
მე და ნომერ პირველი.

1305
01:09:47,939 --> 01:09:53,729
>> და შემდეგ, თუ ამის გაკეთება ვარსკვლავი მასივი პლუს 1,
რომ არის იგივე როგორც აკეთებს მასივი

1306
01:09:53,729 --> 01:09:59,690
ფრჩხილებში ერთი, რომელიც მხოლოდ იმას ნიშნავს, მე წასვლა
იმ ადგილას, რომ ის მიუთითებს.

1307
01:09:59,690 --> 01:10:03,000
და შემდეგ პლუს 1 მარკა
me გადაიტანოს ერთი პოზიცია.

1308
01:10:03,000 --> 01:10:06,510
ასე რომ მე ამ თანამდებობაზე, ფაქტობრივად,
და ამით ნომერი ორი.

1309
01:10:06,510 --> 01:10:10,900
>> და მაშინ, საბოლოოდ, როცა ამის
array plus 2, მე წასვლა, სადაც

1310
01:10:10,900 --> 01:10:11,825
array მიუთითებს.

1311
01:10:11,825 --> 01:10:14,690
და მერე გადავა მეხსიერების ბლოკები.

1312
01:10:14,690 --> 01:10:16,240
და მერე დააყენოს ნომერი სამი აქ.

1313
01:10:16,240 --> 01:10:16,600
ჰო?

1314
01:10:16,600 --> 01:10:21,400
>> აუდიტორია: ასე რომ ვარსკვლავი array უბრალოდ
განაცხადა, რომ პირველი პუნქტი.

1315
01:10:21,400 --> 01:10:25,090
და თქვენ შეგიძლიათ დაამატოთ 1, მხოლოდ იმიტომ,
ჩვენ მხოლოდ ნამდვილად

1316
01:10:25,090 --> 01:10:27,295
მითითება, რომ პირველ მისამართზე.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: ჰო.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
რატომ ჩვენ, მაგალითად, ამბობენ, მასივი
0 მასივი 1, და array 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
მე ვამბობ, რატომ აკეთებთ ამას: 0,
1, 2, 3, ნაცვლად 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
ერთი მიზეზი ის არის, რომ, ერთი, კომპიუტერული
პროგრამისტები ურჩევნია დაიწყოს

1323
01:10:46,550 --> 01:10:47,750
დათვლის საწყისი 0.

1324
01:10:47,750 --> 01:10:52,370
ორი იმიტომ, რომ როდესაც თქვენ აკეთებთ მასივი 0,
ეს არის იგივე როგორც აკეთებს მასივი

1325
01:10:52,370 --> 01:10:56,330
+0, რაც იმას ნიშნავს, მე წასვლა
ამ თანამდებობაზე, და მე არ

1326
01:10:56,330 --> 01:10:59,320
გამოტოვოთ ნებისმიერი მეხსიერების ბლოკები.

1327
01:10:59,320 --> 01:11:01,750
ასე რომ არ გადავიდეს ნებისმიერი მეხსიერების ბლოკები.

1328
01:11:01,750 --> 01:11:02,015
ჰო?

1329
01:11:02,015 --> 01:11:03,265
>> აუდიტორია: [INAUDIBLE]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: ასე რომ, ის ეკითხება, თუ რა არის
შორის სხვაობა აკეთებს

1332
01:11:12,670 --> 01:11:14,000
ამ დროს ან აკეთებს malloc.

1333
01:11:14,000 --> 01:11:17,550
ერთი განსხვავებები არის, რომ
int array 3 შექმნა

1334
01:11:17,550 --> 01:11:19,260
array Stack.

1335
01:11:19,260 --> 01:11:23,080
და როდესაც მე malloc, იგი
ქმნის ბევრი.

1336
01:11:23,080 --> 01:11:25,250
ამჯამად რომ აზრი?

1337
01:11:25,250 --> 01:11:28,870
>> ასე რომ, როგორ ამჯამად malloc რეალურად მუშაობს?

1338
01:11:28,870 --> 01:11:32,245
რატომ ჩვენ კი უნდა გამოვიყენოთ malloc?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
თქვენი შემდგენელი სახის ფიგურები ყველა
ცვლადები, რომ თქვენ განაცხადა.

1341
01:11:39,700 --> 01:11:44,040
და ის ქმნის სივრცეს ყველა
მათგანი Stack.

1342
01:11:44,040 --> 01:11:47,180
ასე რომ, ყველა თქვენი ცვლადები ვაპირებთ
სადღაც უნდა იყოს Stack.

1343
01:11:47,180 --> 01:11:49,460
ასე რომ აქ არის გარემოს ცვლადი.

1344
01:11:49,460 --> 01:11:53,850
>> ასე რომ, ძირითადად, ფართი ცვლადები
მეხსიერების გამოყო,

1345
01:11:53,850 --> 01:11:55,080
კომპილირების დროს.

1346
01:11:55,080 --> 01:11:58,790
ასე რომ, ეს იმას ნიშნავს, რომ თქვენი კომპიუტერი
ვიცი, ყველა იმ ცვლადების

1347
01:11:58,790 --> 01:11:59,790
წინასწარ.

1348
01:11:59,790 --> 01:12:02,500
ეს არ უნდა იცოდეს, თუ რა ღირებულების
თქვენ აპირებს დააყენოს მათ.

1349
01:12:02,500 --> 01:12:05,490
მაგრამ ეს უნდა იცოდეს, თუ როგორ
რამდენად მეხსიერების თქვენ გჭირდებათ.

1350
01:12:05,490 --> 01:12:09,380
>> მაგრამ ახლა ვთქვათ, რომ, მაგალითად,
თქვენ შექმნით მასივი ან მიღების

1351
01:12:09,380 --> 01:12:13,430
სიმებიანი რომ თქვენ იღებენ
შესახებ.

1352
01:12:13,430 --> 01:12:17,300
თუ თქვენ არ იცით, თუ როგორ ხანგრძლივი string
იქნება, მაგალითად.

1353
01:12:17,300 --> 01:12:20,600
ასე რომ თქვენ არ იცით ზუსტად რამდენი
მეხსიერების ბლოკები, რომ თქვენ გამოყოფს, არა?

1354
01:12:20,600 --> 01:12:24,120
>> ასე რომ, ეს ნამდვილად არ აქვს აზრი
თქვენ ვთქვა მა 100 სიმბოლო.

1355
01:12:24,120 --> 01:12:26,420
და მერე რა, თუ მომხმარებელს წერს 150?

1356
01:12:26,420 --> 01:12:27,670
თქვენ აპირებს უნდა ბრალია.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> ასე რომ, ძირითადად, თქვენ შეგიძლიათ დარწმუნებული უნდა იყოს, თუ როგორ
რამდენად მეხსიერების თქვენ უნდა გამოყოს

1359
01:12:34,620 --> 01:12:35,960
როდესაც თქვენ შედგენის პროგრამა.

1360
01:12:35,960 --> 01:12:38,240
თქვენ იცით, რომ პერსპექტივაში დრო.

1361
01:12:38,240 --> 01:12:39,950
ასე რომ, ამიტომ თქვენ გაქვთ ბევრი.

1362
01:12:39,950 --> 01:12:47,610
ასე რომ, ბევრი აპირებს მეხსიერება
რომ თქვენ გამოყოფის დროს

1363
01:12:47,610 --> 01:12:50,810
პროგრამის ხანგრძლივობა გაშვებული.

1364
01:12:50,810 --> 01:12:55,780
>> ასე რომ, ძირითადად, როდესაც თქვენ malloc, რა
რას აკეთებს გამოყოფის მეხსიერება

1365
01:12:55,780 --> 01:13:00,160
runtime, რაც იმას ნიშნავს, რომ თქვენ
გადამწყვეტი იმ მომენტში, რომ თქვენ

1366
01:13:00,160 --> 01:13:02,670
უნდა ჰქონდეს, რომ მეხსიერებაში.

1367
01:13:02,670 --> 01:13:04,210
ასე რომ, როდესაც თქვენ გამოყოფის იგი.

1368
01:13:04,210 --> 01:13:06,430
ამჯამად რომ აზრი?

1369
01:13:06,430 --> 01:13:11,690
>> ასე მახსოვს, დასტის აქვს ცვლადები
რომ იქმნება კომპილირების დროს.

1370
01:13:11,690 --> 01:13:14,560
და მაშინ ბევრი აქვს ცვლადები
რომელიც იქმნება, როგორც თქვენ გადასვლა

1371
01:13:14,560 --> 01:13:15,600
ერთად malloc, მაგალითად.

1372
01:13:15,600 --> 01:13:16,850
>> აუდიტორია: [INAUDIBLE]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: ამიტომ GetString
ვაპირებ მოვუწოდო malloc.

1375
01:13:24,340 --> 01:13:26,710
მიადევნე თვალი საუბრობენ malloc, და
მე ახსნას GetString.

1376
01:13:26,710 --> 01:13:32,000
ასე malloc არის იგივე, რაც
მეხსიერების გამოყოფის.

1377
01:13:32,000 --> 01:13:34,600
ასე რომ, ეს აპირებს გამოყოს
მეხსიერების შესახებ ბევრი.

1378
01:13:34,600 --> 01:13:40,010
და ის აპირებს დააბრუნოს მომცეთ
რომ მეხსიერება დაეთმო.

1379
01:13:40,010 --> 01:13:43,090
>> ასე რომ, როდესაც თქვენ გააკეთოს

1380
01:13:43,090 --> 01:13:44,910
აქ example--

1381
01:13:44,910 --> 01:13:45,830
n star მაჩვენებელი.

1382
01:13:45,830 --> 01:13:50,520
და შემდეგ მაჩვენებელი შეადგენს malloc
ზომა inch ჯერ 10.

1383
01:13:50,520 --> 01:13:52,110
მე შექმნის მაჩვენებელი.

1384
01:13:52,110 --> 01:13:59,020
და შემდეგ მე მინიჭება რომ მომცეთ
ღირებულება მაჩვენებელი, რომ malloc

1385
01:13:59,020 --> 01:13:59,680
მაძლევს.

1386
01:13:59,680 --> 01:14:04,150
>> ასე რომ, მე გეკითხებით malloc შეგიძლიათ გამოყოფს
ფართი 10 რიცხვებით.

1387
01:14:04,150 --> 01:14:05,390
ეს არის ის, რასაც ის ამბობდა.

1388
01:14:05,390 --> 01:14:09,020
და malloc მაძლევს უკან
მაჩვენებელი იმ ადგილას.

1389
01:14:09,020 --> 01:14:11,460
აზრი?

1390
01:14:11,460 --> 01:14:12,270
OK.

1391
01:14:12,270 --> 01:14:17,940
I და GetString არის, ძირითადად, აკეთებს
მოვუწოდებთ malloc, ასე რომ თქვენ შეგიძლიათ გამოყოფს

1392
01:14:17,940 --> 01:14:21,680
მეხსიერების დროს Runtime.

1393
01:14:21,680 --> 01:14:26,460
>> ყოველთვის გვახსოვდეს, შევამოწმოთ null
რადგან malloc დაბრუნებას აპირებს null

1394
01:14:26,460 --> 01:14:28,200
თუ მას არ შეუძლია გამოყოს მეხსიერება.

1395
01:14:28,200 --> 01:14:31,660
მოდით ვთქვათ, რომ ითხოვენ სასაცილოა
თანხის მეხსიერება.

1396
01:14:31,660 --> 01:14:33,950
თქვენს კომპიუტერში არ იქნება
შეუძლია გამოყოს რომ ბევრი რამ.

1397
01:14:33,950 --> 01:14:36,410
>> ასე malloc მხოლოდ აპირებს
დაბრუნების null.

1398
01:14:36,410 --> 01:14:42,210
ასე რომ, ყოველთვის გვახსოვდეს, რომ შეამოწმოთ, თუ
მაჩვენებელი, რომ თქვენ მიიღო malloc არის

1399
01:14:42,210 --> 01:14:45,640
null ან არა იმიტომ, რომ ამ შემთხვევაში, თქვენ შეიძლება
შეიძლება dereferencing მაჩვენებელი და

1400
01:14:45,640 --> 01:14:48,340
რამაც მხარეს ხარვეზი.

1401
01:14:48,340 --> 01:14:50,930
და ბოლოს, არ უნდა დაგვავიწყდეს
თქვენი თავისუფალი მეხსიერება.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc ქმნის მეხსიერება ბევრი.

1404
01:15:00,560 --> 01:15:03,436
და თქვენ უნდა გასათავისუფლებლად მეხსიერების
ადრე პროგრამა მთავრდება.

1405
01:15:03,436 --> 01:15:05,370
OK, ეს ყველაფერი ჩემთვის.

1406
01:15:05,370 --> 01:15:07,900
უკაცრავად, Rob.

1407
01:15:07,900 --> 01:15:07,950
მადლობა.

1408
01:15:07,950 --> 01:15:09,878
>> [ტაში]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: ნებისმიერი ბოლო შეკითხვები
ადრე Rob მოდის?

1410
01:15:12,679 --> 01:15:13,138
არა?

1411
01:15:13,138 --> 01:15:13,597
ჰო?

1412
01:15:13,597 --> 01:15:15,892
>> აუდიტორია: მე ვერ ვხედავ
ეს ერთი ონლაინ რეჟიმში.

1413
01:15:15,892 --> 01:15:17,269
არ თქვენ აიტვირთა ამაზე?

1414
01:15:17,269 --> 01:15:19,106
>> ლუკასი: ვფიქრობ, Dave არის
ატვირთვა მალე.

1415
01:15:19,106 --> 01:15:19,880
>> DAVE: ეს უნდა გამოქვეყნდა.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: ეს იქნება ონლაინ რეჟიმში.

1417
01:15:20,310 --> 01:15:21,175
>> აუდიტორია: ეს up.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: up?

1419
01:15:22,090 --> 01:15:23,157
OK.

1420
01:15:23,157 --> 01:15:23,644
ჰო?

1421
01:15:23,644 --> 01:15:27,053
>> აუდიტორია: [INAUDIBLE]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: დიახ, თქვენ უნდა გავათავისუფლოთ ყველა
მეხსიერება, რომელიც დააყენა ბევრი.

1423
01:15:30,285 --> 01:15:31,535
>> აუდიტორია: [INAUDIBLE]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: დიახ.

1426
01:15:36,160 --> 01:15:39,980
ნებისმიერ დროს, რომ თქვენ გაქვთ კულტურის malloc,
თქვენ უნდა ჰქონდეს კულტურის free

1427
01:15:39,980 --> 01:15:42,640
მას შემდეგ, რაც თქვენ შეწყვიტოს გამოყენებით, რომ ცვლადი.

1428
01:15:42,640 --> 01:15:44,800
ასე malloc და თავისუფალი არიან
ყოველთვის ერთად.

1429
01:15:44,800 --> 01:15:45,410
მათი საუკეთესო მეგობარი.

1430
01:15:45,410 --> 01:15:46,720
Yeah.

1431
01:15:46,720 --> 01:15:47,970
Rob?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ROB: მე წავიდეთ სწრაფად.

1434
01:15:56,850 --> 01:16:00,466
და ასევე ვიდეო გატანილი იქნება.

1435
01:16:00,466 --> 01:16:01,716
მე მაქვს მიკროფონი on.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> OK, ასე კვირაში ხუთი პერსონალი.

1438
01:16:26,230 --> 01:16:27,970
პირველი, რაც უნდა დასტის.

1439
01:16:27,970 --> 01:16:33,390
ასე რომ გვახსოვდეს, რომ არსებობს მხოლოდ ერთი დასტის
კადრი აქტიური ფუნქცია ზარი.

1440
01:16:33,390 --> 01:16:34,710
ჩვენ დავინახავთ, რომ მეორე.

1441
01:16:34,710 --> 01:16:37,850
და გვახსოვდეს, რა რეალურად მიდის
თითოეული დასტის ჩარჩო ვაპირებთ იყოს

1442
01:16:37,850 --> 01:16:41,880
ადგილობრივი ცვლადები ჩვენი ფუნქციები,
არგუმენტები, რომლებიც შევიდა ჩვენი

1443
01:16:41,880 --> 01:16:43,880
ფუნქციები, ისევე, როგორც რამდენიმე
სხვა რამ, რაც ნამდვილად არ

1444
01:16:43,880 --> 01:16:45,260
უნდა ფიქრი.

1445
01:16:45,260 --> 01:16:50,950
>> ასე რომ, აქ არის მაგალითი პროგრამა, სადაც,
ცნობა, მთავარი printfing დაბრუნება

1446
01:16:50,950 --> 01:16:52,830
ღირებულება foo 4.

1447
01:16:52,830 --> 01:16:57,930
foo მხოლოდ დაბრუნებას აპირებს
ღირებულება ბარი 4 მძიმით 6.

1448
01:16:57,930 --> 01:17:02,380
და ბარი შექმნას აპირებს ზოგიერთი ადგილობრივი
ცვლადი n = 4 ჯერ 6.

1449
01:17:02,380 --> 01:17:03,920
ხოლო შემდეგ დაბრუნდნენ n.

1450
01:17:03,920 --> 01:17:09,130
>> ასე რომ, მოდით შევხედოთ დასტის მასშტაბით
ფაქტობრივი iteration ამ პროგრამის.

1451
01:17:09,130 --> 01:17:10,500
ასე რომ იქ ბოლოში ჩვენი Stack.

1452
01:17:10,500 --> 01:17:12,620
გახსოვდეთ, რომ დასტის იზრდება.

1453
01:17:12,620 --> 01:17:15,370
ასე რომ ბოლოში ჩვენი დასტის,
აქვს დასტის ჩარჩო მთავარი.

1454
01:17:15,370 --> 01:17:17,000
როდესაც პროგრამა იწყება, მთავარი
ყოველთვის იქნება ზე

1455
01:17:17,000 --> 01:17:18,560
ბოლოში ჩვენი Stack.

1456
01:17:18,560 --> 01:17:20,880
>> და რა არის შიგნით ჩვენი
დასტის ჩარჩო მთავარი?

1457
01:17:20,880 --> 01:17:23,810
ასე რომ, მიუხედავად იმისა, რომ არ არსებობს ადგილობრივი
ცვლადების მთავარი, როგორც უკვე ვთქვი,

1458
01:17:23,810 --> 01:17:29,670
ჩვენ argc და rgv აღების up სივრცეში
შიგნით ძირითადი დასტის ჩარჩო.

1459
01:17:29,670 --> 01:17:33,260
ასე რომ მთავარი არის აპირებს
მოვუწოდებთ ფუნქცია foo.

1460
01:17:33,260 --> 01:17:35,125
ეს ნიშნავს, რომ foo აპირებს
საკუთარი დასტის ჩარჩო.

1461
01:17:35,125 --> 01:17:36,970
>> ასე რომ, ახლა ჩვენ შიგნით
ფუნქცია foo.

1462
01:17:36,970 --> 01:17:38,610
და რა უნდა წავიდეს
foo-ს დასტის ჩარჩო?

1463
01:17:38,610 --> 01:17:41,100
ასევე, foo აქვს არგუმენტი, n.

1464
01:17:41,100 --> 01:17:45,440
და n = 4 რადგან ეს არის ის, რაც
მთავარი გავლით, როგორც foo არგუმენტი.

1465
01:17:45,440 --> 01:17:48,490
>> ასე რომ, ახლა foo ვაპირებ მოვუწოდო ბარი.

1466
01:17:48,490 --> 01:17:52,070
რა არის ბარი აპირებს შიგნით
მისი "დასტის ჩარჩო?

1467
01:17:52,070 --> 01:17:55,610
მას აქვს x უდრის 4 y უდრის ექვსი.

1468
01:17:55,610 --> 01:17:58,540
ეს არ არის ყველა, რომ ჩვენ ვაპირებთ აქვს
დასტის ჩარჩო, რადგან ბარი

1469
01:17:58,540 --> 01:18:00,580
ასევე აქვს ადგილობრივი ცვლადი n.

1470
01:18:00,580 --> 01:18:03,370
და n, ჩვენ ვაპირებთ, რომ თანაბარი 24.

1471
01:18:03,370 --> 01:18:05,750
>> ასე რომ, ახლა ბარი დაბრუნებას აპირებს n.

1472
01:18:05,750 --> 01:18:09,300
ასე ბარი ბრუნდება 24
დასტის ჩარჩო foo.

1473
01:18:09,300 --> 01:18:12,560
და რადგან ბარი არის დაბრუნების, რომელიც
ნიშნავს, რომ ჩვენ popping დასტის ჩარჩო

1474
01:18:12,560 --> 01:18:14,250
ბარი off დასტის.

1475
01:18:14,250 --> 01:18:18,430
ასე რომ, ყველა, მეხსიერება, ბარი იყო
გამოყენებით არის off დასტის.

1476
01:18:18,430 --> 01:18:21,550
>> ახლა, foo ასევე აპირებს
დაბრუნების 24 ძირითადი.

1477
01:18:21,550 --> 01:18:25,470
ახლა რომ foo ბრუნდება, მეხსიერების
რომ foo გამოყენებით თავის "

1478
01:18:25,470 --> 01:18:27,550
დასტის ჩარჩო ასევე წავიდა.

1479
01:18:27,550 --> 01:18:29,660
და ახლა, მთავარი აპირებს მოვუწოდებთ printf.

1480
01:18:29,660 --> 01:18:31,660
ამიტომ printf უბრალოდ კიდევ ერთი ფუნქცია.

1481
01:18:31,660 --> 01:18:35,320
როცა ჩვენ მოვუწოდებთ printf, ეს იქნება
ერთი დასტის ჩარჩო printf

1482
01:18:35,320 --> 01:18:36,470
ფუნქცია ზარი.

1483
01:18:36,470 --> 01:18:37,990
>> რა ჩვენ გავლის printf?

1484
01:18:37,990 --> 01:18:40,090
რომ ის, რაც ხდება წასვლა
მისი დასტის ჩარჩო.

1485
01:18:40,090 --> 01:18:44,970
სულ ცოტა, ჩვენ გავლის
რომ პროცენტი i წარმატებული ო და

1486
01:18:44,970 --> 01:18:47,180
არგუმენტი 24.

1487
01:18:47,180 --> 01:18:50,370
ალბათ, ეს უფრო ის დასტის ჩარჩო
თუ printf ხდება იყენებთ

1488
01:18:50,370 --> 01:18:51,200
ადგილობრივი ცვლადები.

1489
01:18:51,200 --> 01:18:51,920
ჩვენ არ ვიცით.

1490
01:18:51,920 --> 01:18:53,810
>> მაგრამ ყველა რომ მიდის printf ს
დასტის ჩარჩო.

1491
01:18:53,810 --> 01:18:55,740
ის აპირებს შეასრულოს printf.

1492
01:18:55,740 --> 01:18:56,830
მაშინ printf კეთდება.

1493
01:18:56,830 --> 01:18:57,820
ის დაბრუნდება.

1494
01:18:57,820 --> 01:18:58,960
და ბოლოს, მთავარი კეთდება.

1495
01:18:58,960 --> 01:18:59,860
მთავარი დაბრუნდება.

1496
01:18:59,860 --> 01:19:02,020
და მაშინ ჩვენი პროგრამა კეთდება.

1497
01:19:02,020 --> 01:19:02,480
ჰო?

1498
01:19:02,480 --> 01:19:04,505
>> აუდიტორია: თქვენ ხედავს [INAUDIBLE]

1499
01:19:04,505 --> 01:19:05,900
არგუმენტები [INAUDIBLE]

1500
01:19:05,900 --> 01:19:06,830
პარამეტრები?

1501
01:19:06,830 --> 01:19:09,970
>> ROB: ასე რომ, არსებობს დახვეწილი განსხვავება
შორის არგუმენტები და პარამეტრებს.

1502
01:19:09,970 --> 01:19:14,400
და მართლაც, საერთო საუბარი, ხალხი ტენდენცია
უბრალოდ აურიეთ მათ ყველა დროის.

1503
01:19:14,400 --> 01:19:17,550
მაგრამ პარამეტრების ფორმალური
ასახელებს რამ.

1504
01:19:17,550 --> 01:19:20,180
>> ისე argc და argv არის
პარამეტრების მთავარ.

1505
01:19:20,180 --> 01:19:23,440
არგუმენტები, რაც თქვენ რეალურად
გაივლის, როგორც იმ პარამეტრებს.

1506
01:19:23,440 --> 01:19:28,340
ასე რომ, როდესაც მე მოვუწოდებ foo 4, 4
არის არგუმენტი მე გადადის.

1507
01:19:28,340 --> 01:19:31,460
და პარამეტრი n შიგნით,
foo, იღებს ღირებულების 4

1508
01:19:31,460 --> 01:19:32,880
მას შემდეგ, რაც 4 იყო არგუმენტი.

1509
01:19:32,880 --> 01:19:35,826
>> აუდიტორია: [INAUDIBLE]?

1510
01:19:35,826 --> 01:19:37,880
>> ROB: n არის ლოკალური ცვლადი ბარი.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n კვლავ ადგილობრივი foo, მაგრამ
ეს პარამეტრი foo.

1513
01:19:44,960 --> 01:19:48,190
ეს არ არის ადგილობრივი ცვლადი.

1514
01:19:48,190 --> 01:19:48,546
ჰო?

1515
01:19:48,546 --> 01:19:51,180
>> აუდიტორია: [INAUDIBLE]?

1516
01:19:51,180 --> 01:19:55,400
>> ROB: foo არის მხოლოდ მოუწოდებდა ბარი და
დაბრუნების რასაც ბარი ბრუნდება.

1517
01:19:55,400 --> 01:19:56,786
>> აუდიტორია: [INAUDIBLE]?

1518
01:19:56,786 --> 01:19:59,591
>> ROB: ჰო, უბრალოდ უნდა ნახოთ მრავალი
დასტის ფარგლებში.

1519
01:19:59,591 --> 01:20:00,082
ჰო?

1520
01:20:00,082 --> 01:20:03,519
>> აუდიტორია: რატომ იყო foo მოუწოდა
ადრე printf?

1521
01:20:03,519 --> 01:20:05,920
>> ROB: რატომ იყო foo წარსდგება printf?

1522
01:20:05,920 --> 01:20:10,740
ამიტომ შეეძლო, ნაცვლად, ისეთი რამ გააკეთა,
როგორიცაა int x უდრის foo 4

1523
01:20:10,740 --> 01:20:12,980
და მერე დაბეჭდილი x.

1524
01:20:12,980 --> 01:20:17,900
მაგრამ ამის ნაცვლად, მე კომბინირებული ფუნქცია
შემოუერთდნენ printf არგუმენტი.

1525
01:20:17,900 --> 01:20:23,670
>> მაგრამ გაითვალისწინეთ, რომ ჩვენ არ შეგვიძლია რეალურად
შეასრულოს ზარი printf სანამ ჩვენ

1526
01:20:23,670 --> 01:20:25,610
გაერკვნენ, რა foo 4 არის.

1527
01:20:25,610 --> 01:20:27,480
ამიტომ, ჩვენ ვაპირებთ, რათა შეფასდეს ეს.

1528
01:20:27,480 --> 01:20:32,504
და მხოლოდ ერთხელ რომ კეთდება ვაპირებთ
დავბრუნდებით და შევაფასოთ ეს.

1529
01:20:32,504 --> 01:20:32,990
ჰო?

1530
01:20:32,990 --> 01:20:37,364
>> აუდიტორია: მას შემდეგ, რაც ორივე ბარი [INAUDIBLE]

1531
01:20:37,364 --> 01:20:41,738
ღირებულება, თუ რატომ არ აქვს [INAUDIBLE]?

1532
01:20:41,738 --> 01:20:44,400
>> ROB: ისინი სრულიად უნდა იყოს int.

1533
01:20:44,400 --> 01:20:46,260
რომ არ იყო დაჭერილი მეტი
მრავალჯერადი შეჭრა.

1534
01:20:46,260 --> 01:20:49,010
ასე რომ უნდა იყოს int ბარი და int
foo რადგან ორივე

1535
01:20:49,010 --> 01:20:50,460
ბრუნდებიან რიცხვებით.

1536
01:20:50,460 --> 01:20:54,214
ბათილად, თუ ისინი არ ვაპირებთ
დაბრუნების რეალურ ღირებულებებს.

1537
01:20:54,214 --> 01:20:54,692
ჰო?

1538
01:20:54,692 --> 01:20:58,038
>> აუდიტორია: თუ ჰქონდა ხაზის ზემოთ
სანაცვლოდ, [INAUDIBLE]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB: A ხაზის ზემოთ სანაცვლოდ?

1541
01:21:03,730 --> 01:21:04,410
>> აუდიტორია: Yeah.

1542
01:21:04,410 --> 01:21:10,780
Like თუ თქვენ არ printf და [INAUDIBLE],
რომ ის ბეჭდვა ორჯერ?

1543
01:21:10,780 --> 01:21:12,992
>> ROB: ასე რომ შიგნით foo?

1544
01:21:12,992 --> 01:21:15,945
თუ ჩვენ გვქონდა printf აქ?

1545
01:21:15,945 --> 01:21:16,750
>> აუდიტორია: Yeah.

1546
01:21:16,750 --> 01:21:19,510
>> ROB: ასე რომ, თუ ჩვენ გვქონდა printf უფლება
აქ, ეს იქნებოდა ბეჭდვა ერთხელ.

1547
01:21:19,510 --> 01:21:23,400
მას შემდეგ, რაც ჩვენ მოვუწოდებთ foo ერთხელ უფლება
აქ, მაშინ ჩვენ მოხვდა printf.

1548
01:21:23,400 --> 01:21:24,620
მაშინ ჩვენ მოვუწოდებთ ბარი.

1549
01:21:24,620 --> 01:21:25,710
და შემდეგ foo დაბრუნდება.

1550
01:21:25,710 --> 01:21:26,275
და ეს არის ის.

1551
01:21:26,275 --> 01:21:30,985
ჩვენ მხოლოდ ოდესმე ექმნებათ
printf ერთხელ.

1552
01:21:30,985 --> 01:21:31,482
ჰო?

1553
01:21:31,482 --> 01:21:32,973
>> აუდიტორია: [INAUDIBLE]

1554
01:21:32,973 --> 01:21:37,950
printf მოუწოდებს foo, რადგან ჩვენ პირველი
მოუწოდებდა printf და შემდეგ ჩვენ გავლის

1555
01:21:37,950 --> 01:21:38,580
არგუმენტები.

1556
01:21:38,580 --> 01:21:40,960
>> ROB: ასე რომ, თეორიულად, არ არის
printf მოუწოდებს foo?

1557
01:21:40,960 --> 01:21:42,220
ასე არ არის.

1558
01:21:42,220 --> 01:21:47,360
მხოლოდ იმისათვის, რომ c აპირებს
შეასრულოს ეს ყველაფერი არის, სანამ ჩვენ შეგვიძლია

1559
01:21:47,360 --> 01:21:49,800
მოვუწოდებთ ფუნქცია, ყველა არგუმენტები
ფუნქცია უნდა

1560
01:21:49,800 --> 01:21:51,600
მთლიანად უნდა შეფასდეს.

1561
01:21:51,600 --> 01:21:53,540
ასე რომ ეს სრულიად შეაფასეს?

1562
01:21:53,540 --> 01:21:54,610
დიახ, ეს მხოლოდ სიმებიანი.

1563
01:21:54,610 --> 01:21:55,480
უბრალოდ ღირებულება.

1564
01:21:55,480 --> 01:21:57,200
>> მაშინ ჩვენ უნდა მთლიანად
შევაფასოთ ეს.

1565
01:21:57,200 --> 01:21:59,720
მას შემდეგ, რაც ამ საქმეს, ახლა ყველა
მისი არგუმენტები არსებობს.

1566
01:21:59,720 --> 01:22:01,982
და ახლა ჩვენ შეგვიძლია
მოვუწოდებთ printf.

1567
01:22:01,982 --> 01:22:02,478
ჰო?

1568
01:22:02,478 --> 01:22:03,966
>> აუდიტორია: ერთი შეკითხვა.

1569
01:22:03,966 --> 01:22:06,942
თუ თქვენ გაქვთ ბათილად ფუნქცია, უნდა
თქვენ უნდა დაბრუნება მძიმით?

1570
01:22:06,942 --> 01:22:09,910
>> ROB: თქვენ არ დაბრუნების მძიმით
თუ თქვენ გაქვთ ბათილად ფუნქცია.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
OK.

1573
01:22:14,780 --> 01:22:15,830
ასე რომ, ახლა ზოგიერთი ბევრი პერსონალი.

1574
01:22:15,830 --> 01:22:19,640
ასე რომ, ბევრი არის, თუ როგორ ვაპირებთ გაუმკლავდეთ
დინამიური მეხსიერების მართვა.

1575
01:22:19,640 --> 01:22:23,100
და ეს პირდაპირ წინააღმდეგობაში მოდის
დასტის, რომელიც ჩვენ მოვუწოდებთ ავტომატიკა

1576
01:22:23,100 --> 01:22:24,100
მეხსიერების მართვა.

1577
01:22:24,100 --> 01:22:27,140
>> ასე რომ, დასტის, თქვენ არასდროს ნამდვილად აქვს
გამკლავება, თუ როგორ ადგილობრივი ცვლადები

1578
01:22:27,140 --> 01:22:30,400
მიმდინარეობს მივიღებთ და popped off ყველა
ამ დასტის ფარგლებში და ყველა რომ პერსონალი.

1579
01:22:30,400 --> 01:22:31,070
თქვენ არ უნდა ფიქრი, რომ.

1580
01:22:31,070 --> 01:22:32,070
ეს არის ავტომატური.

1581
01:22:32,070 --> 01:22:36,990
ასე რომ, ბევრი არის სახელმძღვანელო.

1582
01:22:36,990 --> 01:22:38,070
და [INAUDIBLE]

1583
01:22:38,070 --> 01:22:41,260
მოდის ეს ფუნქციები
malloc და თავისუფალი.

1584
01:22:41,260 --> 01:22:43,550
>> ასე რომ, აქ არის კიდევ ერთი პროგრამა.

1585
01:22:43,550 --> 01:22:47,145
ყველა ვაკეთებთ არის mallocing
მთელი რიცხვი.

1586
01:22:47,145 --> 01:22:49,360
ჩვენ თქვენ შენახვა ეს ვარსკვლავი x.

1587
01:22:49,360 --> 01:22:52,520
რა თქმა უნდა, ჩვენ უნდა შეამოწმოთ
ვნახოთ, თუ x არის null.

1588
01:22:52,520 --> 01:22:56,400
მაშინ ჩვენ ვაპირებთ მითითებული, თუ რა
x მიუთითებს 50.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
ბეჭდვა რა x მიუთითებს,
ბეჭდვითი x, და შემდეგ უფასოდ x.

1591
01:23:03,260 --> 01:23:08,920
>> მაშ როგორ არის ეს რეალურად აპირებს გამოიყურებოდეს
თუ დავაკვირდებით ჩვენი დასტის და ბევრი?

1592
01:23:08,920 --> 01:23:10,950
ასე რომ დავიწყოთ თავიდან.

1593
01:23:10,950 --> 01:23:12,580
ბოლოში ჩვენი დასტის, როგორც ადრე.

1594
01:23:12,580 --> 01:23:15,930
გახსოვდეთ, რომ შენ heap პირდაპირ
ეწინააღმდეგება დასტის?

1595
01:23:15,930 --> 01:23:18,850
ამიტომ, ჩვენ ვაპირებთ აქვს
ზედა ჩვენი ბევრი up there.

1596
01:23:18,850 --> 01:23:22,590
>> ისე ბოლოში ჩვენი დასტის, ჩვენ გვაქვს
ჩვენი დასტის ჩარჩო მთავარი.

1597
01:23:22,590 --> 01:23:28,000
მას აქვს ფართი argc, argv, და ჩვენ
ახლა უკვე ადგილობრივი ცვლადი x, რომელიც

1598
01:23:28,000 --> 01:23:30,030
არის int ვარსკვლავი.

1599
01:23:30,030 --> 01:23:32,240
ასე რომ, ჩვენ ვაპირებთ iterate
ამ პროგრამის.

1600
01:23:32,240 --> 01:23:34,420
პირველი, რაც ჩვენ გვაქვს არის
ზარი malloc.

1601
01:23:34,420 --> 01:23:36,250
>> ასე რომ, ჩვენ დარეკვით malloc.

1602
01:23:36,250 --> 01:23:37,100
Malloc არის ფუნქცია.

1603
01:23:37,100 --> 01:23:38,770
ის აპირებს დასტის ჩარჩო.

1604
01:23:38,770 --> 01:23:40,180
რა ჩვენ გავლის malloc?

1605
01:23:40,180 --> 01:23:41,610
რომ აპირებს წავიდეთ შიგნით
დასტის ჩარჩო.

1606
01:23:41,610 --> 01:23:45,130
ჩვენ გავლის ზომის n, რომელიც 4.

1607
01:23:45,130 --> 01:23:49,700
ასე რომ გავიდა malloc.

1608
01:23:49,700 --> 01:23:50,910
>> რას malloc გავაკეთოთ?

1609
01:23:50,910 --> 01:23:53,820
ის grabs გარკვეული სივრცე ბევრი.

1610
01:23:53,820 --> 01:23:55,320
ამიტომ, ჩვენ ვაპირებთ წასვლა ბევრი.

1611
01:23:55,320 --> 01:23:57,990
და ჩვენ ვაპირებთ დაიბრუნოს
4 bytes from ბევრი.

1612
01:23:57,990 --> 01:24:01,500
მოდით მივცეთ, რომ
თვითნებური მისამართზე.

1613
01:24:01,500 --> 01:24:06,680
0x123 უბრალოდ ვიტყვი, რომ ეს არის
მისამართი, რომელიც ბევრი.

1614
01:24:06,680 --> 01:24:12,300
>> რა არის რეალურად შიგნით რომ
რეგიონში მეხსიერების მისამართი Ox123?

1615
01:24:12,300 --> 01:24:13,080
ნაგავი.

1616
01:24:13,080 --> 01:24:15,270
ასე რომ, ჩვენ არ ინახება არაფერი ეს.

1617
01:24:15,270 --> 01:24:18,830
ასე რომ როგორც ვიცით,
შეიძლება იყოს რამე.

1618
01:24:18,830 --> 01:24:20,560
თქვენ არ უნდა ვივარაუდოთ, რომ ეს ნულოვანი.

1619
01:24:20,560 --> 01:24:23,870
ეს, სავარაუდოდ, არ არის ნულოვანი.

1620
01:24:23,870 --> 01:24:26,260
>> ასე რომ, ახლა malloc ბრუნდება.

1621
01:24:26,260 --> 01:24:28,020
და რა ვქნათ, როდესაც malloc ბრუნდება?

1622
01:24:28,020 --> 01:24:29,800
ჩვენ მითითებული, თუ რა ის დააბრუნებს.

1623
01:24:29,800 --> 01:24:32,290
ჩვენ დავსახეთ x ტოლია, რაც
იგი ბრუნდება.

1624
01:24:32,290 --> 01:24:33,690
რა არის ეს დაბრუნების?

1625
01:24:33,690 --> 01:24:38,150
ის დაბრუნების 0x123 რადგან ეს არის
მისამართი ბლოკი მეხსიერება, რომ ეს

1626
01:24:38,150 --> 01:24:40,850
უბრალოდ გამოყოფილი ბევრი.

1627
01:24:40,850 --> 01:24:47,160
>> ასე იქნება 0x123 x არის იქნება მითითებული,
ტოლი 0x123, რომელიც, pictorially,

1628
01:24:47,160 --> 01:24:52,940
ჩვენ ხშირად ხატავდა x მქონე ფაქტობრივი
arrow მიუთითებს, რომ ბლოკი.

1629
01:24:52,940 --> 01:24:55,820
მაგრამ x მხოლოდ შენახვის, რომ მისამართზე.

1630
01:24:55,820 --> 01:24:58,670
ახლა ჩვენ უნდა შეამოწმოთ, თუ x არის null.

1631
01:24:58,670 --> 01:24:59,120
ეს არ არის null.

1632
01:24:59,120 --> 01:25:02,170
ჩვენ პრეტენზია, რომ malloc შეძლო.

1633
01:25:02,170 --> 01:25:04,950
>> ასე რომ, ახლა ვარსკვლავი x უდრის 50.

1634
01:25:04,950 --> 01:25:08,450
ასე ვარსკვლავი ახსოვს ეს იმას ნიშნავს,
რომ მისამართი.

1635
01:25:08,450 --> 01:25:12,700
ასე რომ, 0x123 ჩვენ ვაპირებთ
რომ მისამართი.

1636
01:25:12,700 --> 01:25:14,660
ასე რომ მოაქვს აქ.

1637
01:25:14,660 --> 01:25:16,310
რას ვაკეთებთ, რომ მისამართი?

1638
01:25:16,310 --> 01:25:19,020
ჩვენ შენახვის 50.

1639
01:25:19,020 --> 01:25:22,500
>> ასე რომ, ამის შემდეგ ხაზი, რომ ის, რაც
ვაპირებთ ჰგავს.

1640
01:25:22,500 --> 01:25:24,640
ასე რომ, ახლა აღარ
ნაგვის იქ.

1641
01:25:24,640 --> 01:25:28,910
ახლა ჩვენ ვიცით, რომ 50 არის, რომ
კონკრეტულ მისამართზე, რადგან

1642
01:25:28,910 --> 01:25:32,410
ჩვენ ვაყენებთ მას, რომ.

1643
01:25:32,410 --> 01:25:32,790
OK?

1644
01:25:32,790 --> 01:25:34,370
ახლა ჩვენ ვაპირებთ ბეჭდვა ვ.

1645
01:25:34,370 --> 01:25:38,490
>> ასე რომ, პირველ რიგში, ჩვენ ვაპირებთ ბეჭდვა ვარსკვლავი x.

1646
01:25:38,490 --> 01:25:39,640
რა არის ვარსკვლავი x?

1647
01:25:39,640 --> 01:25:44,300
ერთხელ, ვარსკვლავი x ნიშნავს წასვლა
, რაც x მიუთითებს.

1648
01:25:44,300 --> 01:25:47,140
ასე რომ, x შენახვის 0x123 Go რომ.

1649
01:25:47,140 --> 01:25:48,490
მივიღებთ 50.

1650
01:25:48,490 --> 01:25:50,540
ასე ბეჭდვა f რომ.

1651
01:25:50,540 --> 01:25:54,900
ეს ნიშნავს, რომ ის აპირებს ბეჭდვა 50.

1652
01:25:54,900 --> 01:25:56,850
და შემდეგ, რომ დააბრუნებს.

1653
01:25:56,850 --> 01:25:58,340
>> და შემდეგ ჩვენ გვაქვს მეორე printf.

1654
01:25:58,340 --> 01:25:59,370
ჩვენ ახლა პროცენტი გვ.

1655
01:25:59,370 --> 01:26:01,680
თუ თქვენ არ მინახავს ის, რომ
უბრალოდ, თუ როგორ ბეჭდვა მაჩვენებელი.

1656
01:26:01,680 --> 01:26:04,960
ამიტომ ჩვენ გვაქვს პროცენტი i, პროცენტი
f, და ყველა იმ უკვე.

1657
01:26:04,960 --> 01:26:07,160
ამიტომ პროცენტს p, ბეჭდვა მაჩვენებელი.

1658
01:26:07,160 --> 01:26:08,920
>> ასე რომ X არის მაჩვენებელი.

1659
01:26:08,920 --> 01:26:13,440
ასე რომ, თუ ჩვენ ვაპირებთ ბეჭდვა x თავად,
ჩვენ ბეჭდვის რა არის შიგნით

1660
01:26:13,440 --> 01:26:19,220
x, რომელიც 0x123 ასე რომ, პირველი
ბეჭდვითი ვ აპირებს ბეჭდვა 50.

1661
01:26:19,220 --> 01:26:23,620
მეორე ბეჭდვითი ვ აპირებს
ბეჭდვა 0x123 ჰო?

1662
01:26:23,620 --> 01:26:27,460
>> აუდიტორია: ნუ გამოიყენებთ პროცენტი
x ბეჭდვა მაჩვენებელი?

1663
01:26:27,460 --> 01:26:31,200
>> ROB: ასე რომ თქვენ გამოიყენოთ პროცენტი
x ბეჭდვა მაჩვენებელი?

1664
01:26:31,200 --> 01:26:38,350
ასე, რომ თქვენ შეგიძლიათ, მაგრამ პროცენტი x სამართლიანია,
ზოგადად, როგორიცაა, თუ გაქვთ

1665
01:26:38,350 --> 01:26:40,325
რიცხვი და გსურთ ბეჭდვა
მას, როგორც თექვსმეტობითი.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
ის, თუ რამდენად თქვენ, რომ.

1668
01:26:44,880 --> 01:26:47,160
>> ხოლო, პროცენტი d გვინდა
ბეჭდვა ათობითი.

1669
01:26:47,160 --> 01:26:50,310
რომ ის იყო მივიღებთ პროცენტი
დ. მე უბრალოდ რიცხვი.

1670
01:26:50,310 --> 01:26:52,690
პროცენტი p კონკრეტულად
ამისთვის პოინტერები.

1671
01:26:52,690 --> 01:26:54,060
>> ასე რომ X არის მაჩვენებელი.

1672
01:26:54,060 --> 01:26:56,360
ჩვენ გვინდა გამოვიყენოთ პროცენტი გვ.

1673
01:26:56,360 --> 01:26:57,937
მაგრამ პროცენტი x ვერ იმუშავებს.

1674
01:26:57,937 --> 01:26:58,414
ჰო?

1675
01:26:58,414 --> 01:26:59,664
>> აუდიტორია: [INAUDIBLE]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB: Yeah.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
ყოველ შემთხვევაში ამ მოვუწოდებთ, ასე რომ მე
არ მოიცავს მას აქ.

1680
01:27:13,440 --> 01:27:19,850
მაგრამ ეს ორი არგუმენტი აუცილებლად
შიგნით ამ დასტის ჩარჩო

1681
01:27:19,850 --> 01:27:23,040
ერთად რაიმე ადგილობრივი ცვლადები
printf ხდება გამოყენებით.

1682
01:27:23,040 --> 01:27:27,020
ხოლო შემდეგ მომდევნო ზარი printf ახლა
შიგნით printf დასტის ჩარჩო არის

1683
01:27:27,020 --> 01:27:33,960
პროცენტი p წარმატებული ო და რაც
ღირებულება x არის, რაც 0x123.

1684
01:27:33,960 --> 01:27:34,425
ჰო?

1685
01:27:34,425 --> 01:27:35,675
>> აუდიტორია: [INAUDIBLE]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB: ეს კიდე ბეჭდვა რაღაც
რომელიც ასე გამოიყურება.

1688
01:27:40,880 --> 01:27:41,846
>> აუდიტორია: [INAUDIBLE].

1689
01:27:41,846 --> 01:27:44,510
>> ROB: ასე რომ ბეჭდავს ეს მისამართი ფორმა.

1690
01:27:44,510 --> 01:27:47,003
ეს ჰგავს მისამართზე.

1691
01:27:47,003 --> 01:27:47,494
ჰო?

1692
01:27:47,494 --> 01:27:49,458
>> აუდიტორია: [INAUDIBLE]?

1693
01:27:49,458 --> 01:27:51,075
>> ROB: რატომ, რა ხდება?

1694
01:27:51,075 --> 01:27:52,920
>> აუდიტორია: [INAUDIBLE]?

1695
01:27:52,920 --> 01:27:55,240
>> ROB: რატომ არის ეს მაჩვენებელი 4 ბაიტი?

1696
01:27:55,240 --> 01:27:58,500
ასე რომ, არსებობს მთელი bunch
0 ს წინაშე ამ.

1697
01:27:58,500 --> 01:28:03,740
ასე რომ, ეს ნამდვილად 0x0000000123.

1698
01:28:03,740 --> 01:28:06,510
64 ბიტიანი სისტემა, არ იქნება
მთელი bunch მეტი zeros.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
ჰო?

1701
01:28:11,900 --> 01:28:13,150
>> აუდიტორია: [INAUDIBLE].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB: ასე რომ, პირველი printf
აპირებს print--

1704
01:28:21,130 --> 01:28:21,980
>> აუდიტორია: [INAUDIBLE].

1705
01:28:21,980 --> 01:28:24,420
>> ROB: დიახ, ის აპირებს ბეჭდვა
რა x მიუთითებს.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
ვარსკვლავი ამბობს, რა არის ეს
რაც მიუთითებს.

1708
01:28:29,070 --> 01:28:30,300
დაიბრუნოს ის.

1709
01:28:30,300 --> 01:28:31,455
ასე რომ, რა არის ეს მიუთითებს?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
დაიბრუნოს ის.

1712
01:28:32,410 --> 01:28:33,390
ის, რასაც ჩვენ ვაპირებთ ბეჭდვა.

1713
01:28:33,390 --> 01:28:37,020
ხოლო, შემდეგ, ჩვენ
უბრალოდ ბეჭდვის x თავად.

1714
01:28:37,020 --> 01:28:38,850
რა არის შიგნით ვ?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
OK.

1717
01:28:44,500 --> 01:28:46,620
>> და მაშინ, საბოლოოდ, ჩვენ გვაქვს უფასო.

1718
01:28:46,620 --> 01:28:48,040
რა ჩვენ გავლის გასათავისუფლებლად?

1719
01:28:48,040 --> 01:28:49,470
ჩვენ გავლის x.

1720
01:28:49,470 --> 01:28:52,380
იმ დროს მე რეალურად ნაჩვენები
ის დასტის ჩარჩო.

1721
01:28:52,380 --> 01:28:56,370
>> ასე რომ, ჩვენ გავლის ღირებულება
0x123 გასათავისუფლებლად.

1722
01:28:56,370 --> 01:28:59,070
ასე რომ, ახლა free იცის, ყველა უფლება,
მე უნდა წავიდეს ბევრი

1723
01:28:59,070 --> 01:29:00,050
და თავისუფალი, რომ მეხსიერებაში.

1724
01:29:00,050 --> 01:29:03,920
ეს უკვე აღარ იყენებენ რა
არის მისამართი 0x123.

1725
01:29:03,920 --> 01:29:07,010
>> ასე რომ თავისუფალი აპირებს გამოაქვეყნოს
რომ ბევრი.

1726
01:29:07,010 --> 01:29:09,490
ახლა ჩვენი ბევრი არის ისევ ცარიელი.

1727
01:29:09,490 --> 01:29:11,120
ჩვენ არ გვაქვს მეხსიერების გაჟონვის.

1728
01:29:11,120 --> 01:29:12,940
ახლა თავისუფალი დაბრუნდება.

1729
01:29:12,940 --> 01:29:16,130
გაითვალისწინეთ, რომ x არის კიდევ 0x123.

1730
01:29:16,130 --> 01:29:18,240
მაგრამ ეს არ არის ახლა მოქმედებს მეხსიერების.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
ჩვენ აღარ უნდა dereference x.

1733
01:29:23,986 --> 01:29:24,440
ჰო?

1734
01:29:24,440 --> 01:29:27,240
>> აუდიტორია: არის დაბრუნებას 0 ზედმეტი?

1735
01:29:27,240 --> 01:29:28,290
>> ROB: returen 0 ზედმეტი?

1736
01:29:28,290 --> 01:29:31,110
დიახ.

1737
01:29:31,110 --> 01:29:33,950
ჩვენ უბრალოდ, რომ არსებობს, რადგან
ჩვენ გვაქვს დაბრუნების ერთი ცის ქვეშ.

1738
01:29:33,950 --> 01:29:36,830
ასე რომ მოსწონს, yeah, საშუალებას
მოიცავს დაბრუნების 0.

1739
01:29:36,830 --> 01:29:37,310
ჰო?

1740
01:29:37,310 --> 01:29:38,560
>> აუდიტორია: [INAUDIBLE]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB: ასე რომ, მას შემდეგ, რაც free x, რა მოხდება, თუ
ვცდილობთ dereference მაჩვენებელი?

1743
01:29:45,580 --> 01:29:47,240
შესაძლებელია, რომ არაფერი მიდის არასწორი.

1744
01:29:47,240 --> 01:29:49,330
შესაძლებელია, რომ ჩვენ მაინც 50.

1745
01:29:49,330 --> 01:29:53,590
>> შესაძლებელია, ასევე, რომ რომ მეხსიერება არის
ახლა გამოიყენება რაღაც.

1746
01:29:53,590 --> 01:29:57,140
ასე რომ, ეს გაურკვეველი ქცევა.

1747
01:29:57,140 --> 01:30:00,772
და გაურკვეველი არაფერს ნიშნავს
შეიძლება მოხდეს.

1748
01:30:00,772 --> 01:30:01,250
ჰო?

1749
01:30:01,250 --> 01:30:02,500
>> აუდიტორია: [INAUDIBLE]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB: არა, ასე რომ, თუ თქვენ მივანიჭოთ
x რაღაც.

1752
01:30:10,830 --> 01:30:15,870
ასე რომ, თუ სწორი აქ ჩვენ ვთქვით x უდრის
malloc რაღაც else--

1753
01:30:15,870 --> 01:30:17,100
malloc ზომა ღონისძიება

1754
01:30:17,100 --> 01:30:20,180
მაშინ, რომ ორიგინალური ბლოკი
მეხსიერება არ გაათავისუფლა.

1755
01:30:20,180 --> 01:30:21,490
და ჩვენ ოფიციალურად დაკარგა.

1756
01:30:21,490 --> 01:30:23,150
რომ არის მეხსიერების გაჟონვის.

1757
01:30:23,150 --> 01:30:25,090
ჩვენ დავკარგეთ ყველა ცნობას
რომ ბლოკი მეხსიერება.

1758
01:30:25,090 --> 01:30:26,827
ასე რომ არ არსებობს გზა, ჩვენ ოდესმე მას.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
OK, ასე რომ შემდეგ დაბრუნდნენ 0 საშუალებით კეთდება.

1761
01:30:36,630 --> 01:30:37,900
>> ყველა უფლება, ასე დასტის overflow.

1762
01:30:37,900 --> 01:30:39,320
რა არის იდეა აქ?

1763
01:30:39,320 --> 01:30:41,210
ასე მახსოვს, ბევრი მიდის ქვემოთ.

1764
01:30:41,210 --> 01:30:43,480
დასტის იზრდებოდა.

1765
01:30:43,480 --> 01:30:48,000
ასე რომ, ეს იყო მაგალითი ლექცია,
ჩემის აზრით, სადაც მთავარი მხოლოდ აპირებს

1766
01:30:48,000 --> 01:30:51,380
მოვუწოდებთ ამ ფუნქციის foo, რომელიც აპირებს
დარეკვა თავად რეკურსიული მეტი და

1767
01:30:51,380 --> 01:30:52,320
თავიდან.

1768
01:30:52,320 --> 01:30:55,370
>> ასე დასტის ფარგლებში ვაპირებთ
მუშაობა ზუსტად იგივე.

1769
01:30:55,370 --> 01:30:58,130
ამიტომ, ჩვენ ვაპირებთ, რომ დაიწყოს მთავარი
როგორც ბოლოში დასტის ჩარჩო.

1770
01:30:58,130 --> 01:31:02,000
შემდეგ მთავარ აპირებს მოვუწოდებთ foo, რომელიც
აპირებს დასტის ჩარჩო.

1771
01:31:02,000 --> 01:31:04,260
>> შემდეგ foo აპირებს მოვუწოდებთ foo
ერთხელ, რომელიც აპირებს

1772
01:31:04,260 --> 01:31:05,500
ერთი დასტის ჩარჩო.

1773
01:31:05,500 --> 01:31:08,270
და მერე ისევ, და ისევ და ისევ,
და ისევ, სანამ, საბოლოოდ, ჩვენ აწარმოებს

1774
01:31:08,270 --> 01:31:09,190
შევიდა ბევრი.

1775
01:31:09,190 --> 01:31:11,990
ასე რომ, ეს არის, თუ როგორ მივიღებთ
დასტის overflow.

1776
01:31:11,990 --> 01:31:14,910
და ამ ეტაპზე, თქვენ seg ბრალია.

1777
01:31:14,910 --> 01:31:17,335
ან ნეტავ მართლა seg ბრალია, სანამ
ამ ეტაპზე, მაგრამ yeah.

1778
01:31:17,335 --> 01:31:19,660
>> აუდიტორია: არის ძირითადი ნაგავსაყრელი
იგივე, რაც seg ბრალია?

1779
01:31:19,660 --> 01:31:26,140
>> ROB: ასე რომ დაინახავთ სეგმენტაცია
ბრალი core მოხვდა.

1780
01:31:26,140 --> 01:31:28,760
თქვენ core ნაგავსაყრელი როდესაც
თქვენ seg ბრალია.

1781
01:31:28,760 --> 01:31:32,580
და ეს როგორც ნაგავსაყრელი ყველა
შინაარსი თქვენი არსებული მეხსიერების ასე

1782
01:31:32,580 --> 01:31:36,670
რომ თქვენ შეგიძლიათ ცდილობენ და იდენტიფიცირება
ამიტომ თქვენ seg გააკრიტიკა.

1783
01:31:36,670 --> 01:31:37,135
ჰო?

1784
01:31:37,135 --> 01:31:38,385
>> აუდიტორია: [INAUDIBLE]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB: So სეგმენტაცია ბრალია საშუალებით
არსებობს დასტის overflow.

1787
01:31:45,460 --> 01:31:47,060
ასე რომ, არ არის აუცილებელი.

1788
01:31:47,060 --> 01:31:49,880
სეგმენტაცია ბრალია ნიშნავს, რომ თქვენ
ეხება მეხსიერების ისე,

1789
01:31:49,880 --> 01:31:50,880
თქვენ არ უნდა იყოს.

1790
01:31:50,880 --> 01:31:54,750
ასე რომ ერთი გზა, რომ ხდება, როდესაც
თქვენ დასტის overflow, ჩვენ ვიწყებთ ეხება

1791
01:31:54,750 --> 01:31:58,736
მეხსიერების ისე, რომ ჩვენ არ უნდა ვიყოთ.

1792
01:31:58,736 --> 01:31:59,208
ჰო?

1793
01:31:59,208 --> 01:32:00,458
>> აუდიტორია: [INAUDIBLE]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB: ასე რომ შიგნით უსასრულო ციკლი.

1796
01:32:05,830 --> 01:32:08,770
ისევე, როგორც ეს არის, როგორიც რეკურსიული უსასრულო
loop ამიტომ ჩვენ კიდევ სხვა

1797
01:32:08,770 --> 01:32:09,770
დასტის ჩარჩო ყოველ ჯერზე.

1798
01:32:09,770 --> 01:32:13,540
მაგრამ მხოლოდ შიგნით რეგულარული
უსასრულო ხოლო one--

1799
01:32:13,540 --> 01:32:16,390
კარგად, მოდით კი არ ბეჭდვა ვ

1800
01:32:16,390 --> 01:32:17,040
რაღაც.

1801
01:32:17,040 --> 01:32:18,390
როგორიც არ უნდა იყოს.

1802
01:32:18,390 --> 01:32:20,610
>> ჩვენ არ ვაპირებთ, მიღების
ერთი დასტის ჩარჩო.

1803
01:32:20,610 --> 01:32:22,530
ჩვენ უბრალოდ აპირებს შეინარჩუნოს looping
მეტი ამ ერთ დავალებით.

1804
01:32:22,530 --> 01:32:23,920
დასტის არ იზრდება.

1805
01:32:23,920 --> 01:32:27,290
ის ფაქტი, რომ თითოეული რეკურსიული
დარეკეთ გვაძლევს დასტის ჩარჩო.

1806
01:32:27,290 --> 01:32:31,231
სწორედ ამიტომ, ჩვენ დასტის overflow.

1807
01:32:31,231 --> 01:32:31,728
ჰო?

1808
01:32:31,728 --> 01:32:38,189
>> აუდიტორია: ასე რომ, თუ თქვენ თქვით, რომ მიიღოს
ხოლო მარყუჟის და შემდეგ [INAUDIBLE]?

1809
01:32:38,189 --> 01:32:42,000
>> ROB: ასე რომ, თუ შიგნით, ხოლო მარყუჟის
იყო printf, თქვენ კვლავ

1810
01:32:42,000 --> 01:32:42,790
არ seg ბრალია.

1811
01:32:42,790 --> 01:32:46,090
მე უბრალოდ არ მინდა, რომ აღრეული რამ.

1812
01:32:46,090 --> 01:32:46,610
ეს იქნებოდა loop.

1813
01:32:46,610 --> 01:32:48,225
ნეტავ კიდევ ერთი დასტის
ვიზრუნოთ, რომ printf.

1814
01:32:48,225 --> 01:32:49,580
>> მაშინ printf დაბრუნდნენ.

1815
01:32:49,580 --> 01:32:50,280
მაშინ ნეტავ loop ერთხელ.

1816
01:32:50,280 --> 01:32:51,460
ნეტავ კიდევ ერთი დასტის
ვიზრუნოთ, რომ printf.

1817
01:32:51,460 --> 01:32:52,850
რომ დაბრუნდნენ.

1818
01:32:52,850 --> 01:32:54,060
ერთი დასტის ჩარჩო.

1819
01:32:54,060 --> 01:33:00,215
ასე რომ თქვენ არ მიღების ამ უსასრულო
პილინგი up დასტის ფარგლებში.

1820
01:33:00,215 --> 01:33:03,185
>> აუდიტორია: [INAUDIBLE]?

1821
01:33:03,185 --> 01:33:04,040
>> ROB: დიახ.

1822
01:33:04,040 --> 01:33:09,360
ასე რომ, ამ დასტის overflow ხდება
იმიტომ, რომ არც ერთი ამ

1823
01:33:09,360 --> 01:33:11,600
ზარები foo ბრუნდებიან.

1824
01:33:11,600 --> 01:33:15,250
ასე რომ, თუ დავუბრუნდებით, მაშინ ჩვენ
დაიწყოს დაკარგვის დასტის ფარგლებში.

1825
01:33:15,250 --> 01:33:17,870
და მაშინ ჩვენ არ დასტის overflow.

1826
01:33:17,870 --> 01:33:20,070
და სწორედ ამიტომ თქვენ გჭირდებათ ბაზის შემთხვევაში
თქვენი პირადი ფუნქციები.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
ჰო?

1829
01:33:23,479 --> 01:33:27,375
>> აუდიტორია: არის პოტენციალი და ზომის
დასტის ბევრი იგივე

1830
01:33:27,375 --> 01:33:29,880
ყველა პროგრამა?

1831
01:33:29,880 --> 01:33:31,910
>> ROB: დაახლოებით.

1832
01:33:31,910 --> 01:33:35,090
პოტენციური ზომა დასტის და
ბევრი ერთი და იგივე ყველა, პროგრამები?

1833
01:33:35,090 --> 01:33:37,180
უხეშად.

1834
01:33:37,180 --> 01:33:40,080
არსებობს რამდენიმე randomization to
სადაც დასტის იწყება და

1835
01:33:40,080 --> 01:33:42,400
სადაც ბევრი იწყება.

1836
01:33:42,400 --> 01:33:45,870
თუ მოხდება მთელი ბევრი
გლობალური ცვლადები და ნივთები, თქვენ შეიძლება

1837
01:33:45,870 --> 01:33:49,520
წართმევას გარკვეული სივრცე
თქვენი ბევრი.

1838
01:33:49,520 --> 01:33:54,060
>> 64 ბიტიანი სისტემა, პრაქტიკულად
უსასრულო მეხსიერება.

1839
01:33:54,060 --> 01:33:55,820
არსებობს მხოლოდ იმდენად.

1840
01:33:55,820 --> 01:33:59,250
შორის 32 ბიტი და 64 ბიტი, რომ
მნიშვნელოვანი განსხვავება.

1841
01:33:59,250 --> 01:34:02,350
>> თქვენ აპირებს მიიღოს მთელი ბევრი უფრო
დასტის და ბევრი სივრცე 64-bit

1842
01:34:02,350 --> 01:34:05,810
სისტემაში, რადგან არსებობს მხოლოდ მეტი
მიმართავს, რომ მათ შეუძლიათ გამოიყენონ.

1843
01:34:05,810 --> 01:34:09,360
მაგრამ ინდივიდუალური სისტემით, იგი
იქნება დაახლოებით იგივე თანხა დასტის

1844
01:34:09,360 --> 01:34:10,785
და ბევრი სივრცეში.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
ყველა უფლება.

1847
01:34:15,530 --> 01:34:18,220
>> ასე რომ, ბოლო რამ არის კოლექცია.

1848
01:34:18,220 --> 01:34:19,810
ასე, რომ თქვენ უნდა იცოდეს, რომ ეს პროცესი.

1849
01:34:19,810 --> 01:34:22,240
არსებობს ოთხი დიდი ნაბიჯები.

1850
01:34:22,240 --> 01:34:24,400
ასე რომ, პირველი უნდა
იყოს ადვილად დასამახსოვრებელი.

1851
01:34:24,400 --> 01:34:25,085
წინასწარი დამუშავება.

1852
01:34:25,085 --> 01:34:28,390
მას აქვს პრეფიქსი წინასწარი მას.

1853
01:34:28,390 --> 01:34:32,080
ასე საქმე ადრე ყველაფერი.

1854
01:34:32,080 --> 01:34:34,000
>> რამ უნდა გვახსოვდეს არის hash.

1855
01:34:34,000 --> 01:34:37,250
ასე რომ hash განსაზღვრავს და hash შედის
ყველა იმ.

1856
01:34:37,250 --> 01:34:39,560
ეს ყველაფერი წინასწარ პროცესორი
დავალებები მისცა.

1857
01:34:39,560 --> 01:34:42,030
ეს ყველაფერი, რომ
წინასწარ პროცესორი ზრუნავს.

1858
01:34:42,030 --> 01:34:43,680
>> ასე რომ, რა წინასწარ პროცესორი გავაკეთოთ?

1859
01:34:43,680 --> 01:34:44,850
ეს მართლაც dumb რამ.

1860
01:34:44,850 --> 01:34:49,380
ყველა ის, რომელსაც შეუძლია ყველა ამ
ასლი და მოჭრილი და პასტა ოპერაციებში.

1861
01:34:49,380 --> 01:34:51,790
>> ასე რომ hash შედის სტანდარტული i0 dot h.

1862
01:34:51,790 --> 01:34:52,990
რა არის ეს აკეთებს?

1863
01:34:52,990 --> 01:34:56,610
ის grabbing სტანდარტული i0 dot h
ფაილი და pasting ის ზედა

1864
01:34:56,610 --> 01:34:58,960
იქ, სადაც ის ამბობს, რომ hash შედის
სტანდარტული i0 dot h.

1865
01:34:58,960 --> 01:35:02,480
>> და ნებისმიერი hash განსაზღვრავს, რომ ჩვენ
ჩანს, თუ რა რომ აკეთებს?

1866
01:35:02,480 --> 01:35:06,730
მისი გადაწერა ღირებულება, რომ hash
განსაზღვრული განისაზღვრება, როგორც და pasting, რომ

1867
01:35:06,730 --> 01:35:08,500
სადაც თქვენ იყენებთ ღირებულება.

1868
01:35:08,500 --> 01:35:13,400
ამიტომ preprocessor უბრალოდ რეალურად
მარტივი ტექსტი დაფუძნებული ოპერაციებში.

1869
01:35:13,400 --> 01:35:15,870
იგი არაფერს აკეთებს ჭკვიანი.

1870
01:35:15,870 --> 01:35:18,920
ასე რომ ყველაფერი არის
უფრო რთული.

1871
01:35:18,920 --> 01:35:22,970
>> ახლა რომ preprocessor არის
კეთდება, რეალურად ადგენენ.

1872
01:35:22,970 --> 01:35:24,320
ასე რომ, რას შედგენა ნიშნავს?

1873
01:35:24,320 --> 01:35:27,310
ჩვენ ახლა ვაპირებთ საწყისი C კოდი
შეკრების კოდი.

1874
01:35:27,310 --> 01:35:27,570
ჰო?

1875
01:35:27,570 --> 01:35:28,820
>> აუდიტორია: [INAUDIBLE]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB: Yeah, ჩვენ დაჭერილი, რომ.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
ამიტომ შედგენას.

1880
01:35:38,660 --> 01:35:40,310
ჩვენ ვაპირებთ C შეკრებისა.

1881
01:35:40,310 --> 01:35:42,470
ასე რომ, ეს არის ფაქტობრივი ენის შეცვლა.

1882
01:35:42,470 --> 01:35:45,240
შედგენის თავისთავად ნიშნავს აპირებს საწყისი
მაღალ დონეზე ენის to

1883
01:35:45,240 --> 01:35:47,340
ქვედა დონის ენა.

1884
01:35:47,340 --> 01:35:50,720
>> და c არის მაღალი დონის ენა
შედარებით ასამბლეის.

1885
01:35:50,720 --> 01:35:52,320
რა არის შეკრების?

1886
01:35:52,320 --> 01:35:56,440
მის მითითებებს, რომლებიც, საკმაოდ
ბევრი, გააკეთა თქვენი CPU.

1887
01:35:56,440 --> 01:35:59,130
მაგრამ თქვენს კომპიუტერში ჯერ კიდევ
არ მესმის ასამბლეის.

1888
01:35:59,130 --> 01:36:01,570
ეს მარტო ესმის, პირობა და zeros.

1889
01:36:01,570 --> 01:36:06,160
ასე რომ შემდეგი ნაბიჯი იკრიბებიან, რომელიც
მოაქვს ამ ინსტრუქციას, რომ

1890
01:36:06,160 --> 01:36:08,760
თქვენი CPU ესმის და რეალურად
თარგმნის მათ,

1891
01:36:08,760 --> 01:36:10,820
პირობა და zeros.

1892
01:36:10,820 --> 01:36:13,570
>> ასე რომ, C შეკრებისა ორობითი.

1893
01:36:13,570 --> 01:36:15,870
მაგრამ მე არ მაქვს შესრულებადი ამჟამად.

1894
01:36:15,870 --> 01:36:19,550
ასე რომ, ვფიქრობ CS50 ბიბლიოთეკაში.

1895
01:36:19,550 --> 01:36:23,070
ჩვენ გათვალისწინებული თქვენ ორობითი
ეს არის CS50 ბიბლიოთეკა, რომელსაც აქვს GetString

1896
01:36:23,070 --> 01:36:24,400
და GetInt და ყველა რომ.

1897
01:36:24,400 --> 01:36:25,700
>> მაგრამ cs50 ბიბლიოთეკა

1898
01:36:25,700 --> 01:36:27,650
in და თავად არ არის შესრულებადი.

1899
01:36:27,650 --> 01:36:29,570
მას არ გააჩნია ძირითადი ფუნქცია.

1900
01:36:29,570 --> 01:36:32,230
ეს მხოლოდ რამოდენიმე ორობითი
რომ თქვენ შეგიძლიათ გამოიყენოთ.

1901
01:36:32,230 --> 01:36:41,730
ასე რომ აკავშირებს, თუ როგორ შევუწყოთ ყველა
ამ სხვადასხვა ორობითი ფაილი

1902
01:36:41,730 --> 01:36:43,110
შევიდა ფაქტობრივი შემსრულებელი.

1903
01:36:43,110 --> 01:36:45,900
ერთი, რომ თქვენ შეგიძლიათ აკრიფოთ
dot slash dot out.

1904
01:36:45,900 --> 01:36:51,660
>> ასე რომ, ეს, როგორიცაა ფაილი, რომელიც თქვენ
წერდა, - რაც თქვენი პროგრამა is--

1905
01:36:51,660 --> 01:36:53,620
Ceaser dot გ.

1906
01:36:53,620 --> 01:36:55,100
მაგრამ ახლა ეს უკვე შედგენილი
ქვემოთ ორობითი.

1907
01:36:55,100 --> 01:36:56,480
ასე Ceaser dot o.

1908
01:36:56,480 --> 01:36:59,620
და ეს არის ჩვენი CS50 ბიბლიოთეკები ორობითი.

1909
01:36:59,620 --> 01:37:02,284
და ისინი შეეხამება
ერთ შემსრულებელი.

1910
01:37:02,284 --> 01:37:02,758
ჰო?

1911
01:37:02,758 --> 01:37:04,008
>> აუდიტორია: [INAUDIBLE]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB: ასე რომ, პირველი მოიცავს, გახსოვდეთ,
hash მოიცავს ფაქტიურად

1914
01:37:12,710 --> 01:37:13,810
წინასწარ პროცესორი ნაბიჯი.

1915
01:37:13,810 --> 01:37:14,750
მაგრამ ეს ცალკე.

1916
01:37:14,750 --> 01:37:20,730
თუ თქვენ არ იყენებთ ნებისმიერი ფუნქციები,
გარეთ თქვენი ერთი ფაილი შემდეგ,

1917
01:37:20,730 --> 01:37:26,100
არა, თქვენ არ უნდა უკავშირებენ არაფერს
მას შემდეგ, რაც თქვენ გაქვთ ყველაფერი.

1918
01:37:26,100 --> 01:37:30,310
>> რომ განაცხადა, printf მიმდინარეობს უკავშირდება.

1919
01:37:30,310 --> 01:37:32,820
თუ თქვენ ოდესმე გამოიყენოს printf, რომ რაღაც
, რომელიც უნდა უკავშირდება

1920
01:37:32,820 --> 01:37:35,740
იმიტომ, რომ თქვენ არ დაწერა.

1921
01:37:35,740 --> 01:37:39,530
და, ფაქტობრივად, printf ავტომატურად
უკავშირდება.

1922
01:37:39,530 --> 01:37:42,760
თქვენ იცით, როგორ ბრძანების ან, როდესაც
აკრიფოთ მიიღოს, თქვენ ხედავთ მას აქვს

1923
01:37:42,760 --> 01:37:46,690
dash ლ cs50, რომელსაც აქვს ლინკი
CS50 ბიბლიოთეკა?

1924
01:37:46,690 --> 01:37:49,070
Printf და პერსონალის მოსწონს, რომ აპირებს
უკავშირდება ავტომატურად.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
ნებისმიერი სხვა კითხვები არაფერი?

1927
01:37:53,930 --> 01:37:56,280
>> აუდიტორია: [INAUDIBLE]?

1928
01:37:56,280 --> 01:37:58,300
>> ROB: აკავშირებს?

1929
01:37:58,300 --> 01:38:03,450
ჩვენ გვაქვს მთელი თაიგული
სხვადასხვა ორობითი ფაილი.

1930
01:38:03,450 --> 01:38:06,410
ეს არის კანონიკური მაგალითად
რომ ჩვენ ვიყენებთ არის CS50 ბიბლიოთეკაში.

1931
01:38:06,410 --> 01:38:09,960
ჩვენ შევიკრიბეთ და იმის გათვალისწინებით, რომ თქვენ
ორობითი ამ CS50 ბიბლიოთეკაში.

1932
01:38:09,960 --> 01:38:12,410
>> გსურთ გამოიყენოთ GetString
თქვენი პროგრამა.

1933
01:38:12,410 --> 01:38:14,750
ასე, რომ თქვენ და გამოიყენოს GetString.

1934
01:38:14,750 --> 01:38:19,700
მაგრამ გარეშე ჩემი ორობითი კოდი
GetString, როდესაც თქვენ კომპილაციის თქვენი კოდი

1935
01:38:19,700 --> 01:38:23,140
ქვემოთ, თქვენ შეგიძლიათ რეალურად არ აწარმოებს თქვენი
პროგრამა, რადგან GetString სიმებიანი არის

1936
01:38:23,140 --> 01:38:25,080
ჯერ კიდევ არ არის ბოლომდე ნათელი.

1937
01:38:25,080 --> 01:38:29,220
>> ეს მხოლოდ მაშინ, როდესაც ბმული ჩემი ორობითი
რომელიც შეიცავს GetString, რომ ახლა, ყველა

1938
01:38:29,220 --> 01:38:31,130
უფლება, მე შეიძლება რეალურად
შეასრულოს GetString.

1939
01:38:31,130 --> 01:38:32,330
ჩემი ფაილი არის სრული.

1940
01:38:32,330 --> 01:38:34,208
და შემიძლია აწარმოებს ამ.

1941
01:38:34,208 --> 01:38:34,697
ჰო?

1942
01:38:34,697 --> 01:38:37,631
>> აუდიტორია: არა აკავშირებს გადაიყვანო
ორობითი შესრულებადი?

1943
01:38:37,631 --> 01:38:42,032
ასე რომ, მაშინაც კი, თუ თქვენ არ გაქვთ სხვა
ბიბლიოთეკების, არ მაინც იყოს

1944
01:38:42,032 --> 01:38:44,477
აუცილებელია თარგმნა
[INAUDIBLE]?

1945
01:38:44,477 --> 01:38:48,640
>> ROB: ასე შემსრულებელი
კვლავ ორობითი.

1946
01:38:48,640 --> 01:38:51,750
უბრალოდ აერთიანებს მთელი
bunch of binaries.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> აუდიტორია: დიდი მადლობა, რომ.

1949
01:38:56,591 --> 01:38:58,560
>> ROB: პრობლემა არ არის.

1950
01:38:58,560 --> 01:38:59,540
ნებისმიერი სხვა კითხვები?

1951
01:38:59,540 --> 01:39:02,001
წინააღმდეგ შემთხვევაში, ჩვენ ყველა მითითებული.

1952
01:39:02,001 --> 01:39:02,690
ყველა უფლება.

1953
01:39:02,690 --> 01:39:02,990
მადლობა.

1954
01:39:02,990 --> 01:39:03,590
>> [ტაში]

1955
01:39:03,590 --> 01:39:04,490
>> აუდიტორია: დიდი მადლობა.

1956
01:39:04,490 --> 01:39:05,740
>> ROB: Yeah.

1957
01:39:05,740 --> 01:39:06,582