1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [კვირა 4]

2
00:00:03,000 --> 00:00:05,000
[დევიდ ჯ Malan] [ჰარვარდის უნივერსიტეტის]

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

4
00:00:08,000 --> 00:00:12,000
>> ყველა უფლება, ეს არის CS50, და ეს არის დაწყების კვირაში 4,

5
00:00:12,000 --> 00:00:16,000
და ეს არის ერთ ერთი ყველაზე ნელი შესაძლო დახარისხება ალგორითმები.

6
00:00:16,000 --> 00:00:19,000
რომელი იყო ის, რომ ჩვენ უბრალოდ ადევნებდნენ იქ?

7
00:00:19,000 --> 00:00:24,000
ეს იყო ბუშტი დალაგება, რათა დიდი O (N ^ 2) + თანხა,

8
00:00:24,000 --> 00:00:28,000
და მართლაც ჩვენ არ ვართ მხოლოდ ამ მსოფლიოს, როგორც ჩანს, ვიცი

9
00:00:28,000 --> 00:00:30,000
რა ბუშტი დალაგების არის ან მისი ქრონომეტრაჟი.

10
00:00:30,000 --> 00:00:33,000
მართლაც, ეს იყო ინტერვიუში ერიკ შმიდტი Google-

11
00:00:33,000 --> 00:00:45,000
და ყოფილი სენატორი ბარაკ ობამა რამდენიმე წლის წინ.

12
00:00:45,000 --> 00:00:48,000
>> ახლა, სენატორი, თქვენ აქ, Google,

13
00:00:48,000 --> 00:00:54,000
და მე მიყვარს ვფიქრობ თავმჯდომარეობის დროს გასაუბრება.

14
00:00:54,000 --> 00:00:58,000
ახლა, ეს იმისთვის, რომ მიიღოთ სამუშაოს როგორც პრეზიდენტი, და თქვენ აპირებს მეშვეობით rigors არის.

15
00:00:58,000 --> 00:01:00,000
ასევე იმისთვის, რომ მიიღოთ სამსახურიდან, Google.

16
00:01:00,000 --> 00:01:05,000
ჩვენ გვყავს კითხვები და ჩვენ ვთხოვთ ჩვენი კანდიდატების კითხვები,

17
00:01:05,000 --> 00:01:10,000
და ეს ერთი არის Larry შვიმერი.

18
00:01:10,000 --> 00:01:14,000
თქვენ ბიჭები ვფიქრობ მე kidding? ეს უფლება აქ.

19
00:01:14,000 --> 00:01:18,000
რა არის ყველაზე ეფექტური საშუალება დასალაგებლად მილიონი 32-bit რიცხვებით?

20
00:01:18,000 --> 00:01:21,000
[სიცილის]

21
00:01:21,000 --> 00:01:24,000
კარგად

22
00:01:24,000 --> 00:01:26,000
მე უკაცრავად. >> არა, არა, არა, არა.

23
00:01:26,000 --> 00:01:34,000
ვფიქრობ bubble sort იქნება არასწორი გზაა გასავლელი.

24
00:01:34,000 --> 00:01:39,000
>> მოდი შესახებ, რომელმაც განუცხადა, ამ საკითხთან დაკავშირებით?

25
00:01:39,000 --> 00:01:43,000
გასულ კვირას გავიხსენოთ ავიღეთ ჩამოშორდა კოდი, ყოველ შემთხვევაში დღეს,

26
00:01:43,000 --> 00:01:46,000
და დაიწყო ფოკუსირება რამდენიმე უმაღლესი დონის იდეებისა და პრობლემის გადაჭრის უფრო ზოგადად

27
00:01:46,000 --> 00:01:49,000
კონტექსტში ძებნას და დახარისხება,

28
00:01:49,000 --> 00:01:53,000
და ჩვენ გააცნო, რასაც ჩვენ არ Slap ამ სახელით გასულ კვირას,

29
00:01:53,000 --> 00:01:56,000
მაგრამ asymptotic ნოტაცია, დიდი O, დიდი ომეგა,

30
00:01:56,000 --> 00:02:00,000
და ზოგჯერ დიდი Theta ნოტაცია, და ეს იყო უბრალოდ გზები

31
00:02:00,000 --> 00:02:02,000
საქართველოს აღწერს გაშვებული დრო ალგორითმები,

32
00:02:02,000 --> 00:02:05,000
რამდენი დრო სჭირდება ამისთვის ალგორითმი გასაშვებად.

33
00:02:05,000 --> 00:02:08,000
>> თქვენ შეიძლება გავიხსენოთ, რომ თქვენ ისაუბრა ქრონომეტრაჟი თვალსაზრისით ზომა

34
00:02:08,000 --> 00:02:11,000
საქართველოს შეყვანის, რომელიც ჩვენ მოვუწოდებთ ზოგადად N, რასაც პრობლემა არ უნდა იყოს,

35
00:02:11,000 --> 00:02:13,000
სადაც n რაოდენობის ხალხი ოთახი,

36
00:02:13,000 --> 00:02:17,000
გვერდების რაოდენობა სატელეფონო წიგნი, და დავიწყეთ დაწერა ნივთების

37
00:02:17,000 --> 00:02:21,000
მოსწონს O (N ^ 2) ან O (N) ან O (N შესვლა N),

38
00:02:21,000 --> 00:02:24,000
და მაშინაც კი, როცა მათემატიკის არ საკმაოდ შეიმუშაოს ასე შესანიშნავად

39
00:02:24,000 --> 00:02:28,000
და ეს იყო n ² - N / 2 ან რამე მაგდაგვარს

40
00:02:28,000 --> 00:02:31,000
ჩვენ ნაცვლად მხოლოდ გადაყარეთ ზოგიერთი ქვედა წესრიგის თვალსაზრისით,

41
00:02:31,000 --> 00:02:34,000
და მოტივაცია არსებობს, რომ ჩვენ მართლაც გვინდა

42
00:02:34,000 --> 00:02:37,000
სახის ობიექტური გზა შეფასებისას

43
00:02:37,000 --> 00:02:39,000
შესრულების პროგრამების ან შესრულების ალგორითმები

44
00:02:39,000 --> 00:02:42,000
რომ დღის ბოლოს არაფერი აქვს, მაგალითად,

45
00:02:42,000 --> 00:02:45,000
ერთად სიჩქარე თქვენს კომპიუტერში დღეს.

46
00:02:45,000 --> 00:02:47,000
>> მაგალითად, თუ თქვენ განახორციელოს bubble sort,

47
00:02:47,000 --> 00:02:50,000
ან თქვენ განახორციელოს შერწყმა დალაგების ან შერჩევის დალაგების დღევანდელ კომპიუტერი,

48
00:02:50,000 --> 00:02:53,000
2 GHz კომპიუტერი და გაუშვით,

49
00:02:53,000 --> 00:02:56,000
და ეს ხდება გარკვეული რაოდენობის წამში, მომავალ წელს იქ 3 GHz

50
00:02:56,000 --> 00:02:59,000
ან 4 GHz კომპიუტერი, და ალბათ მაშინ ვამბობთ, რომ "Wow, ჩემი ალგორითმი

51
00:02:59,000 --> 00:03:03,000
არის ორჯერ სწრაფად, "როცა რეალურად რომ აშკარად არ შემთხვევაში.

52
00:03:03,000 --> 00:03:06,000
უბრალოდ ტექნიკა არ მიღებული სწრაფად, მაგრამ თქვენს კომპიუტერში

53
00:03:06,000 --> 00:03:10,000
არ, და ამიტომ ჩვენ ნამდვილად გსურთ გადაყარეთ რამ, როგორიცაა

54
00:03:10,000 --> 00:03:13,000
ჯერადი 2 ან ჯერადი 3 როდესაც საქმე აღწერილია

55
00:03:13,000 --> 00:03:17,000
რამდენად სწრაფად ან რამდენად ნელა ალგორითმი არის და რეალურად მხოლოდ ფოკუსირება

56
00:03:17,000 --> 00:03:20,000
on n ან რამდენიმე ფაქტორი მათი

57
00:03:20,000 --> 00:03:24,000
ზოგიერთი ძალა მისი, როგორც იმ შემთხვევაში, თუ სახის გასულ კვირას.

58
00:03:24,000 --> 00:03:27,000
და გავიხსენოთ, რომ დახმარებით შერწყმა დალაგება

59
00:03:27,000 --> 00:03:31,000
ჩვენ შევძელით ამის გაკეთება ბევრად უკეთესია, ვიდრე bubble sort და შერჩევის დალაგება

60
00:03:31,000 --> 00:03:33,000
და კიდევ Insertion ჯიშია.

61
00:03:33,000 --> 00:03:36,000
>> ჩვენ ქვემოთ N შესვლა N, და ისევ,

62
00:03:36,000 --> 00:03:39,000
გავიხსენოთ, რომ შესვლა N ზოგადად ეხება რაღაც რომ იზრდება

63
00:03:39,000 --> 00:03:43,000
უფრო ნელა მაშინ N, ასე n შესვლა N დღემდე იყო კარგი

64
00:03:43,000 --> 00:03:45,000
რადგან ეს იყო ნაკლები n ².

65
00:03:45,000 --> 00:03:47,000
მაგრამ, რათა მივაღწიოთ N შეხვიდეთ N ერთად შერწყმა დალაგება

66
00:03:47,000 --> 00:03:51,000
რა იყო ძირითადი ჩანასახები იდეა, რომ ჩვენ იძულებული გახდა ბერკეტები

67
00:03:51,000 --> 00:03:54,000
რომ ჩვენ ასევე leveraged უკან კვირაში 0?

68
00:03:54,000 --> 00:03:58,000
როგორ ჩვენ დაძლევის დახარისხება პრობლემა cleverly ერთად შერწყმა დალაგება?

69
00:03:58,000 --> 00:04:04,000
რა იყო გასაღები ინსაითი, ალბათ?

70
00:04:04,000 --> 00:04:07,000
არავის საერთოდ.

71
00:04:07,000 --> 00:04:09,000
Okay, მოდით გავიაზროთ მომავალი ნაბიჯები.

72
00:04:09,000 --> 00:04:11,000
აღწერეთ შერწყმა დალაგება თქვენი სიტყვებით.

73
00:04:11,000 --> 00:04:15,000
როგორ მუშაობს იგი?

74
00:04:15,000 --> 00:04:17,000
Okay, ჩვენ ზედიზედ თავში კვირაში 0.

75
00:04:17,000 --> 00:04:19,000
Okay, yeah.

76
00:04:19,000 --> 00:04:22,000
[Inaudible-სტუდენტი]

77
00:04:22,000 --> 00:04:26,000
Okay, კარგი, ამიტომ ჩვენ გაყოფილი მასივი ნომრები შევიდა 2 ცალი.

78
00:04:26,000 --> 00:04:29,000
ჩვენ დახარისხებული თითოეული იმ დარტყმები, და შემდეგ ჩვენ გაერთიანდა მათ,

79
00:04:29,000 --> 00:04:33,000
და ჩვენ ვხედავთ ამ იდეის წინაშე აღების პრობლემა, რომელიც ამ დიდ

80
00:04:33,000 --> 00:04:36,000
და chopping it up შევიდა პრობლემა რომ ამ დიდი თუ ამ დიდი.

81
00:04:36,000 --> 00:04:38,000
>> შეგახსენებთ, სატელეფონო წიგნი მაგალითად.

82
00:04:38,000 --> 00:04:42,000
შეგახსენებთ, თვითმმართველობის დათვლა ალგორითმი საწყისი კვირის წინ

83
00:04:42,000 --> 00:04:45,000
ასე შერწყმა დალაგების იყო შეაჯამა ამ pseudocode აქ.

84
00:04:45,000 --> 00:04:48,000
როდესაც თქვენ მოცემული n ელემენტებს, პირველი ეს იყო საღი აზრის შეამოწმოს.

85
00:04:48,000 --> 00:04:51,000
თუ n <2 მაშინ ნუ არაფერი ყველა

86
00:04:51,000 --> 00:04:55,000
რადგან თუ n <2 მაშინ N აშკარად 0 ან 1,

87
00:04:55,000 --> 00:04:57,000
და ასე თუ ის ან 0 ან 1 არაფერი დასალაგებლად.

88
00:04:57,000 --> 00:04:59,000
თქვენ გაკეთდეს.

89
00:04:59,000 --> 00:05:01,000
თქვენს სიაში უკვე trivially დახარისხებული.

90
00:05:01,000 --> 00:05:04,000
მაგრამ სხვაგვარად, თუ თქვენ მოხვდით 2 ან მეტი ელემენტისაგან წავიდეთ წინ და ყოფს მათ

91
00:05:04,000 --> 00:05:06,000
შევიდა 2 halves, მარცხენა და მარჯვენა.

92
00:05:06,000 --> 00:05:09,000
Sort თითოეული იმ halves, შემდეგ შერწყმა დახარისხებული halves.

93
00:05:09,000 --> 00:05:13,000
მაგრამ პრობლემა აქ ისაა, რომ ერთი შეხედვით ეს იგრძნობა ჩვენ punting.

94
00:05:13,000 --> 00:05:17,000
ეს არის წრიული განმარტება, რომ თუ მე გთხოვეთ დასალაგებლად ამ N ელემენტები

95
00:05:17,000 --> 00:05:22,000
და თქვენ მეუბნებოდა "ყველა უფლება, ჯარიმა, ჩვენ დასალაგებლად იმ N / 2 და იმ N / 2 ელემენტები,"

96
00:05:22,000 --> 00:05:27,000
მაშინ ჩემი შემდეგი კითხვა იქნება "ჯარიმის, როგორ დასალაგებლად N / 2 ელემენტები?"

97
00:05:27,000 --> 00:05:30,000
>> მაგრამ იმის გამო, რომ ამ სტრუქტურის ამ პროგრამის

98
00:05:30,000 --> 00:05:33,000
რადგან ამ ბაზის შემთხვევაში, ასე ვთქვათ,

99
00:05:33,000 --> 00:05:39,000
ამ განსაკუთრებულ შემთხვევაში, რომელიც ამბობს, თუ N არის <ზოგიერთი ფიქსირებული ფასით მოსწონს 2 დაბრუნების დაუყოვნებლივ.

100
00:05:39,000 --> 00:05:42,000
არ უპასუხოს, რომ იგივე წრიული პასუხი.

101
00:05:42,000 --> 00:05:46,000
ეს პროცესი, ამ cyclicity საბოლოოდ დასრულდება.

102
00:05:46,000 --> 00:05:50,000
თუ მე გთხოვთ "დალაგების ამ N ელემენტები," და თქვენ ამბობთ, "ჯარიმის, დასალაგებლად ამ N / 2,"

103
00:05:50,000 --> 00:05:53,000
მაშინ ამბობენ, "ჯარიმის, sort ამ N / 4, n / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
საბოლოოდ თქვენ დაყოფის დიდი საკმარისი რაოდენობის

105
00:05:56,000 --> 00:05:59,000
რომ თქვენ მხოლოდ 1 ელემენტს მარცხენა, სადაც წერტილი შეიძლება ითქვას,

106
00:05:59,000 --> 00:06:02,000
"აქ, აქ არის დახარისხებული ერთჯერადი ელემენტს."

107
00:06:02,000 --> 00:06:06,000
შემდეგ ბრწყინვალების ამ ალგორითმი აქ არის გამომდინარეობს ფაქტი

108
00:06:06,000 --> 00:06:09,000
რომ მას შემდეგ რაც ყველა ეს ინდივიდუალურად დახარისხებული სიები

109
00:06:09,000 --> 00:06:12,000
ყველა რომლებიც ზომა 1, რომელიც, როგორც ჩანს, უსარგებლო,

110
00:06:12,000 --> 00:06:15,000
ერთხელ თქვენ დაიწყება შერწყმის მათ და შერწყმის მათ

111
00:06:15,000 --> 00:06:19,000
თქვენ დაამყარონ საბოლოოდ როგორც რობ გააკეთა ვიდეო საბოლოოდ დახარისხებული სია.

112
00:06:19,000 --> 00:06:22,000
>> მაგრამ ეს იდეა ვრცელდება მიღმა დახარისხება.

113
00:06:22,000 --> 00:06:26,000
არსებობს ამ იდეის ჩართული ამ პროგრამის ცნობილია, როგორც უკან,

114
00:06:26,000 --> 00:06:29,000
იდეა, რომლის დროსაც თქვენ პროგრამა,

115
00:06:29,000 --> 00:06:32,000
და გადაჭრის ზოგიერთი პრობლემა თქვენ დაირქვით,

116
00:06:32,000 --> 00:06:36,000
ან დააყენა კონტექსტში პროგრამირების ენების თქვენ ფუნქცია,

117
00:06:36,000 --> 00:06:39,000
და გადაჭრის მიზნით პრობლემა, თქვენ ფუნქცია დაირქვით

118
00:06:39,000 --> 00:06:42,000
ისევ და ისევ და ისევ, მაგრამ თქვენ ფუნქცია

119
00:06:42,000 --> 00:06:44,000
ვერ ვუწოდებ თავს უსასრულოდ ბევრჯერ.

120
00:06:44,000 --> 00:06:47,000
საბოლოოდ თქვენ უნდა ბოლოში გარეთ, ასე ვთქვათ,

121
00:06:47,000 --> 00:06:49,000
და გარკვეული მყარი კოდირებული ბაზა პირობით, რომ ამბობს

122
00:06:49,000 --> 00:06:53,000
ამ ეტაპზე შეწყვიტოს მოუწოდებენ თავის ისე, რომ მთელი პროცესი

123
00:06:53,000 --> 00:06:56,000
საბოლოოდ ამჯამად ფაქტობრივად შეჩერება.

124
00:06:56,000 --> 00:06:58,000
რას ნიშნავს, რომ recurse?

125
00:06:58,000 --> 00:07:01,000
>> ვნახოთ, თუ შეგვიძლია გავაკეთოთ მარტივი, ტრივიალური მაგალითი, ვთქვათ,

126
00:07:01,000 --> 00:07:03,000
3 ადამიანი ჩემთან ერთად აქ სცენაზე, თუ ვინმე არის კომფორტული.

127
00:07:03,000 --> 00:07:06,000
1, მოდის up, 2 და 3.

128
00:07:06,000 --> 00:07:09,000
თუ თქვენ 3 სურვილი, ჩამოვიდეს აქ.

129
00:07:09,000 --> 00:07:12,000
თუ გსურთ დავდგეთ უფლება ჩემს გვერდით აქ ხაზი, ვივარაუდოთ, რომ პრობლემის მხრივ

130
00:07:12,000 --> 00:07:15,000
ძალიან trivially ითვლიან მათი რაოდენობა, ვინც აქ ვართ.

131
00:07:15,000 --> 00:07:18,000
მაგრამ გულწრფელად, მე დაღლილი ყველა ამ დათვლის მაგალითები.

132
00:07:18,000 --> 00:07:21,000
ეს აპირებს მიიღოს გარკვეული დრო, 1, 2, და dot, dot, dot.

133
00:07:21,000 --> 00:07:23,000
ის აპირებს სამუდამოდ.

134
00:07:23,000 --> 00:07:25,000
მე მირჩევნია უბრალოდ punt ეს პრობლემა საერთოდ დახმარებით-რა გქვია?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, ყველა უფლება.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> კელი და?

137
00:07:29,000 --> 00:07:31,000
>> ვილი. >> ვილი, სარა, კელიმ, და ვილი.

138
00:07:31,000 --> 00:07:34,000
მე ახლავე უკვე კითხვას ვიღაცამ

139
00:07:34,000 --> 00:07:37,000
რამდენი ადამიანი up ამ ეტაპზე, და წარმოდგენა არ მაქვს.

140
00:07:37,000 --> 00:07:40,000
ეს არის მართლაც გრძელი სია და ასე ნაცვლად მე ვაპირებ ამის გაკეთებას შეასრულა.

141
00:07:40,000 --> 00:07:43,000
მე ვაპირებ ვკითხო პირი ჩემს გვერდით არა უმეტეს მუშაობა,

142
00:07:43,000 --> 00:07:46,000
და კიდევ ის კეთდება აკეთებს უმეტესობა სამუშაოს

143
00:07:46,000 --> 00:07:49,000
მე ვაპირებ ამის გაკეთებას მაინც ოდენობით მუშაობა შესაძლებელია და უბრალოდ დაამატოთ 1

144
00:07:49,000 --> 00:07:51,000
to whatever მისი პასუხი, ამიტომ აქ ჩვენ მივდივართ.

145
00:07:51,000 --> 00:07:54,000
მე ვკითხე რამდენი ადამიანი სცენაზე.

146
00:07:54,000 --> 00:07:57,000
რამდენი ადამიანი სცენაზე მარცხნივ თქვენ?

147
00:07:57,000 --> 00:08:00,000
მარცხნივ მე? >> Okay, მაგრამ არ მოატყუო.

148
00:08:00,000 --> 00:08:04,000
ეგ კარგია, რომ ზუსტი, მაგრამ თუ ჩვენ გვინდა, რომ გავაგრძელოთ ამ ლოგიკით

149
00:08:04,000 --> 00:08:08,000
მოდით ვივარაუდოთ, რომ თქვენ ერთნაირად გვინდა punt ეს პრობლემა მარცხნივ შენ,

150
00:08:08,000 --> 00:08:11,000
ამიტომ, ვიდრე პასუხი პირდაპირ წავიდეთ წინ და უბრალოდ გაივლის მამალი.

151
00:08:11,000 --> 00:08:14,000
ოჰ, რამდენი ადამიანი მარცხნივ მე?

152
00:08:14,000 --> 00:08:16,000
რამდენი ადამიანი მარცხნივ?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[სიცილის]

155
00:08:27,000 --> 00:08:30,000
Okay, ასე 0, ასე რომ, ახლა ვილი გააკეთა

156
00:08:30,000 --> 00:08:33,000
არის თქვენ დაბრუნდა თქვენი პასუხი ამ მიმართულებით ამბობდა 0.

157
00:08:33,000 --> 00:08:36,000
ახლა, რა უნდა გავაკეთოთ? >> 1.

158
00:08:36,000 --> 00:08:39,000
Okay, ასე რომ თქვენ 1, ასე რომ თქვენ ამბობენ, "ყველა უფლება, მე ვაპირებ დაამატოთ 1

159
00:08:39,000 --> 00:08:41,000
to whatever Willy ს რაოდენობა იყო ", ასე 1 + 0.

160
00:08:41,000 --> 00:08:43,000
თქვენ ახლა 1 ასე რომ თქვენი პასუხი უფლება არის-

161
00:08:43,000 --> 00:08:45,000
1. >> და ნაღმების იქნებოდა 2.

162
00:08:45,000 --> 00:08:48,000
კარგი, ასე რომ თქვენ აღების წინა პასუხი 1,

163
00:08:48,000 --> 00:08:51,000
დასძინა მინიმალური ოდენობა სამუშაო გსურთ, რომელიც +1.

164
00:08:51,000 --> 00:08:55,000
თქვენ ახლა უკვე 2 და შემდეგ გადასცემს ჩემთვის, რომელიც ღირებულების?

165
00:08:55,000 --> 00:08:57,000
3, ვგულისხმობ, უკაცრავად, 2.

166
00:08:57,000 --> 00:08:59,000
კარგი.

167
00:08:59,000 --> 00:09:02,000
>> ასევე, ჩვენ გვქონდა 0 მარცხნივ.

168
00:09:02,000 --> 00:09:05,000
მაშინ ჩვენ გვქონდა 1 და შემდეგ დავუმატებთ 2,

169
00:09:05,000 --> 00:09:07,000
და ახლა თქვენ გადაცემის ჩემთვის ნომერი 2,

170
00:09:07,000 --> 00:09:10,000
და ა.შ. მე ვამბობ,, okay, +1, 3.

171
00:09:10,000 --> 00:09:13,000
იქ მართლაც 3 ადამიანი იდგა ჩემს გვერდით ამ ეტაპზე,

172
00:09:13,000 --> 00:09:16,000
ამიტომ ჩვენ შეეძლო აშკარად კეთდება ეს ძალიან ხაზოვანი,

173
00:09:16,000 --> 00:09:19,000
ძალიან ბევრი აშკარა მოდის, მაგრამ რა მივიღეთ ნამდვილად?

174
00:09:19,000 --> 00:09:21,000
ჩვენ მივიღეთ პრობლემა ზომა 3 თავდაპირველად.

175
00:09:21,000 --> 00:09:24,000
ჩვენ მაშინ დაარღვია მისი დანგრევა შევიდა პრობლემა ზომა 2,

176
00:09:24,000 --> 00:09:27,000
მაშინ პრობლემა ზომა 1, ხოლო შემდეგ საბოლოოდ ბაზის შემთხვევაში

177
00:09:27,000 --> 00:09:29,000
მართლაც, OH არ არსებობს ერთი,

178
00:09:29,000 --> 00:09:33,000
სადაც წერტილი Willy დაბრუნდა ეფექტურად მყარი კოდირებული პასუხი რამოდენიმე ჯერ,

179
00:09:33,000 --> 00:09:36,000
ხოლო მეორე იყო მაშინ bubbled up, bubbled up, bubbled up,

180
00:09:36,000 --> 00:09:39,000
ხოლო შემდეგ დასძინა ამ ერთ დამატებით 1

181
00:09:39,000 --> 00:09:41,000
ჩვენ განხორციელებული ამ ძირითად იდეას უკან.

182
00:09:41,000 --> 00:09:44,000
>> ახლა კი, ამ შემთხვევაში ეს არ ნამდვილად გადაჭრას პრობლემა

183
00:09:44,000 --> 00:09:46,000
ნებისმიერი უფრო ეფექტურად, მაშინ ჩვენ ვნახეთ დღემდე.

184
00:09:46,000 --> 00:09:48,000
მაგრამ ვიფიქროთ ალგორითმები ჩვენ გავაკეთეთ სცენაზე დღემდე.

185
00:09:48,000 --> 00:09:51,000
ჩვენ გვქონდა 8 ცალი ქაღალდის on chalkboard,

186
00:09:51,000 --> 00:09:55,000
on ვიდეო როცა შონ ეძებდა ნომერი 7, რა უნდოდა მას ნამდვილად?

187
00:09:55,000 --> 00:09:58,000
ისე, მან ეს არ გააკეთა რაიმე სახის გათიშე და დაიპყროთ.

188
00:09:58,000 --> 00:10:01,000
მან ეს არ გააკეთა რაიმე სახის უკან.

189
00:10:01,000 --> 00:10:03,000
პირიქით, მან უბრალოდ ეს ხაზოვანი ალგორითმი.

190
00:10:03,000 --> 00:10:07,000
მაგრამ როდესაც ჩვენ გააცნო იდეა დახარისხებული ნომრები სცენაზე ვცხოვრობთ გასულ კვირას

191
00:10:07,000 --> 00:10:09,000
მაშინ ჩვენ გვქონდა ამ ინსტიქტი აპირებს ახლო,

192
00:10:09,000 --> 00:10:13,000
სადაც წერტილი გვქონდა პატარა ჩამონათვალი ზომა 4 ან სხვა ჩამონათვალი ზომა 4,

193
00:10:13,000 --> 00:10:17,000
და მაშინ ჩვენ გვქონდა ზუსტად იგივე პრობლემა, ამიტომ ჩვენ მეორდება, განმეორებითი, განმეორდეს.

194
00:10:17,000 --> 00:10:19,000
სხვა სიტყვებით, ჩვენ recursed.

195
00:10:19,000 --> 00:10:24,000
დიდი მადლობა ჩვენი 3 მოხალისეები აქ დემონსტრირების უკან ჩვენთან.

196
00:10:24,000 --> 00:10:28,000
>> ვნახოთ, შევძლებთ თუ არა, რომ ეს არის ცოტა უფრო კონკრეტული,

197
00:10:28,000 --> 00:10:30,000
პრობლემის გადაწყვეტის, რომ ერთხელ ჩვენ შეეძლო საკმაოდ ადვილად,

198
00:10:30,000 --> 00:10:34,000
მაგრამ ჩვენ ვიყენებთ მას როგორც სტეპინგზე ქვის შეასრულოს ამ ძირითად იდეას.

199
00:10:34,000 --> 00:10:37,000
თუკი მინდა გამოთვლაც summation საქართველოს bunch of ნომრები,

200
00:10:37,000 --> 00:10:39,000
მაგალითად, თუ თქვენ გაივლის მთელ რიგ 3,

201
00:10:39,000 --> 00:10:42,000
მინდა გადმოგცეთ ღირებულება სიგმა 3,

202
00:10:42,000 --> 00:10:46,000
ასე თანხა 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
მინდა დავუბრუნდეთ პასუხი 6,

204
00:10:48,000 --> 00:10:51,000
ამიტომ ჩვენ შეასრულოს ეს სიგმა ფუნქცია, ამ summation ფუნქცია

205
00:10:51,000 --> 00:10:54,000
რომ, კვლავ იღებს in შეყვანის და შემდეგ დააბრუნებს summation

206
00:10:54,000 --> 00:10:57,000
ამ რაოდენობის ყველა გზა ქვემოთ 0.

207
00:10:57,000 --> 00:10:59,000
ჩვენ შეგვეძლო ამის გაკეთება საკმაოდ უბრალოდ, არა?

208
00:10:59,000 --> 00:11:01,000
ჩვენ შეგვეძლო ამის გაკეთება რამდენიმე სახის looping სტრუქტურა,

209
00:11:01,000 --> 00:11:04,000
ნება მომეცით, წავიდეთ წინ და ამ დაიწყო.

210
00:11:04,000 --> 00:11:07,000
>> ჩართეთ stdio.h.

211
00:11:07,000 --> 00:11:09,000
ნება მომეცით კიდევ თავს შევიდა ძირითადი მუშაობა აქ.

212
00:11:09,000 --> 00:11:12,000
გადავარჩინოთ ეს როგორც sigma.c.

213
00:11:12,000 --> 00:11:14,000
მაშინ მე ვაპირებ წასვლა აქ და მე ვაპირებ განაცხადოს int n,

214
00:11:14,000 --> 00:11:18,000
და მე ვაპირებ გავაკეთოთ შემდეგი ხოლო მომხმარებლის არ ითანამშრომლებს.

215
00:11:18,000 --> 00:11:22,000
მიუხედავად იმისა, რომ მომხმარებლებს არ მომცა დადებითი ხმების

216
00:11:22,000 --> 00:11:26,000
ნება მომეცით წავიდეთ წინ და შეეკითხება მათ n = GetInt,

217
00:11:26,000 --> 00:11:28,000
და ნება მომეცით მივცეთ ზოგიერთ ინსტრუქციას, თუ რა უნდა გავაკეთოთ,

218
00:11:28,000 --> 00:11:33,000
ასე printf ("დადებითი მთელი რიცხვი გთხოვთ").

219
00:11:33,000 --> 00:11:39,000
უბრალოდ რაღაც შედარებით მარტივი მოსწონს ეს ასე, რომ ახლა ჩვენ მოხვდა ხაზი 14

220
00:11:39,000 --> 00:11:42,000
ჩვენ ახლა აქვს დადებითი მთელი რიცხვი სავარაუდოდ n.

221
00:11:42,000 --> 00:11:44,000
>> ახლა მოდით რაღაც არის.

222
00:11:44,000 --> 00:11:50,000
ნება მომეცით წავიდეთ წინ და გამოთვლაც summation, ასე int თანხა = სიგმა (N).

223
00:11:50,000 --> 00:11:54,000
სიგმა მხოლოდ summation, ამიტომ მე უბრალოდ წერა მას fancier გზა.

224
00:11:54,000 --> 00:11:56,000
ჩვენ უბრალოდ ვუწოდებთ მას სიგმა არსებობს.

225
00:11:56,000 --> 00:11:58,000
სწორედ თანხა, და ახლა მე ვაპირებ ამობეჭდოთ შედეგი,

226
00:11:58,000 --> 00:12:08,000
printf ("თანხა არის% d \ n", თანხა).

227
00:12:08,000 --> 00:12:11,000
და მაშინ მე დაბრუნებას 0 კარგი ღონისძიება.

228
00:12:11,000 --> 00:12:15,000
ჩვენ ყველაფერი გავაკეთეთ, რომ ეს პროგრამა საჭიროებს გარდა საინტერესო ნაწილი,

229
00:12:15,000 --> 00:12:18,000
რაც რეალურად განახორციელოს სიგმა ფუნქცია.

230
00:12:18,000 --> 00:12:22,000
>> ნება მომეცით დაცემას აქ ბოლოში, და ნება მომეცით განაცხადოს ფუნქციის სიგმა.

231
00:12:22,000 --> 00:12:26,000
ეს მივიღე მიიღოს ცვლადი რომ ტიპის რიცხვი,

232
00:12:26,000 --> 00:12:30,000
და რა ტიპის მონაცემის არ მინდა დაბრუნებას სავარაუდოდ საწყისი სიგმა?

233
00:12:30,000 --> 00:12:34,000
Int, რადგან მინდა, რომ ის ემთხვევა ჩემი მოლოდინი on line 15.

234
00:12:34,000 --> 00:12:37,000
აქ ნება მომეცით წავიდეთ წინ და განახორციელოს ამ

235
00:12:37,000 --> 00:12:41,000
წელს საკმაოდ პირდაპირი გზა.

236
00:12:41,000 --> 00:12:45,000
>> მოდით წავიდეთ წინ და ვთქვათ int თანხა = 0,

237
00:12:45,000 --> 00:12:47,000
და ახლა მე ვაპირებ წასვლა აქვს პატარა ამისთვის loop აქ

238
00:12:47,000 --> 00:12:50,000
რომ აპირებს ამბობენ რაღაც მსგავსი,

239
00:12:50,000 --> 00:13:01,000
ამისთვის (int i = 0; I <= ნომერი; i + +) თანხა + = i.

240
00:13:01,000 --> 00:13:05,000
და შემდეგ მე ვაპირებ დაბრუნებას თანხა.

241
00:13:05,000 --> 00:13:07,000
მე ვერ განვახორციელეთ ეს ნებისმიერი რაოდენობის გზები.

242
00:13:07,000 --> 00:13:09,000
შემეძლო არ გამოიყენება, ხოლო loop.

243
00:13:09,000 --> 00:13:11,000
შემეძლო არ გამოტოვებენ გამოყენებით თანხა ცვლადი თუ ნამდვილად უნდოდა,

244
00:13:11,000 --> 00:13:15,000
მაგრამ მოკლედ, ჩვენ უბრალოდ უნდა ფუნქცია რომ თუ არ goof აცხადებს თანხა 0.

245
00:13:15,000 --> 00:13:18,000
მაშინ iterates საწყისი 0 on up მეშვეობით ნომერი,

246
00:13:18,000 --> 00:13:23,000
და თითოეულ iteration იგი დასძენს, რომ მიმდინარე ღირებულების თანხა და შემდეგ დააბრუნებს თანხას.

247
00:13:23,000 --> 00:13:25,000
>> ახლა არის უმნიშვნელო ოპტიმიზაცია აქ.

248
00:13:25,000 --> 00:13:29,000
ეს არის ალბათ შეეწირა ნაბიჯი, მაგრამ ასე იქნება ეს. სწორედ ჯარიმა არის.

249
00:13:29,000 --> 00:13:32,000
ჩვენ მინიმუმ მყოფი ამომწურავი და ვაპირებთ 0 ყველა გზა on up.

250
00:13:32,000 --> 00:13:34,000
არ არის ძალიან რთული და საკმაოდ მარტივია,

251
00:13:34,000 --> 00:13:37,000
მაგრამ აღმოჩნდება, რომ სიგმა ფუნქცია გვაქვს იგივე შესაძლებლობა

252
00:13:37,000 --> 00:13:39,000
როგორც ჩვენ აქ სცენაზე.

253
00:13:39,000 --> 00:13:42,000
სცენაზე ჩვენ უბრალოდ დათვლილი რამდენი ადამიანი იყო ჩემს გვერდით,

254
00:13:42,000 --> 00:13:47,000
მაგრამ ნაცვლად თუ გვინდოდა ითვლიან ნომერი 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
on ქვემოთ 0 შეგვეძლო ანალოგიურად punt to ფუნქცია

256
00:13:51,000 --> 00:13:55,000
რომ მე ნაცვლად აღწერს როგორც რეკურსიული.

257
00:13:55,000 --> 00:13:57,000
აქ მოდით სწრაფი საღი აზრის შეამოწმეთ და დარწმუნდით მე არ goof.

258
00:13:57,000 --> 00:14:00,000
>> მე ვიცი, არსებობს მინიმუმ ერთი რამ ამ პროგრამაში, რომ მე გავაკეთებ არასწორია.

259
00:14:00,000 --> 00:14:04,000
როდესაც მე დააჭიროთ მე აპირებს მიიღოს ნებისმიერი სახის yelling at me?

260
00:14:04,000 --> 00:14:06,000
რა ვარ მე უნდა yelled დაახლოებით?

261
00:14:06,000 --> 00:14:11,000
ჰო, დამავიწყდა პროტოტიპი, ამიტომ მე გამოყენებით ფუნქციის მოუწოდა სიგმა on line 15,

262
00:14:11,000 --> 00:14:16,000
მაგრამ ეს არ გამოცხადდა, სანამ ხაზი 22, მე საუკეთესო პროაქტიულად ახვიდეთ აქ

263
00:14:16,000 --> 00:14:22,000
და აცხადებენ, პროტოტიპი, და მე ვთქვა int სიგმა (int ნომერი), და ამით ყველაფერი მთავრდება.

264
00:14:22,000 --> 00:14:24,000
ეს განხორციელდა ბოლოში.

265
00:14:24,000 --> 00:14:27,000
>> ან სხვა გზა მე ვერ გადაჭრის ამ,

266
00:14:27,000 --> 00:14:30,000
შემეძლო გადაადგილება ფუნქცია up there, რაც ცუდი არ არის,

267
00:14:30,000 --> 00:14:32,000
მაგრამ მაინც, როდესაც თქვენი პროგრამების დაიწყოს მიიღოს ხანგრძლივი, გულწრფელად,

268
00:14:32,000 --> 00:14:35,000
ვფიქრობ, რამდენიმე ღირებულების მქონე ყოველთვის მთავარ ზედა

269
00:14:35,000 --> 00:14:38,000
ასე რომ თქვენ მკითხველს შეუძლია გახსნას ფაილი და შემდეგ დაუყოვნებლივ ვხედავ

270
00:14:38,000 --> 00:14:40,000
რა პროგრამა აკეთებს გარეშე ძებნის საშუალება

271
00:14:40,000 --> 00:14:42,000
ეძებს, რომ მთავარი ფუნქცია.

272
00:14:42,000 --> 00:14:49,000
მოდით წავიდეთ ქვემოთ ჩემი ტერმინალის ფანჯარაში აქ, სცადეთ მიღების სიგმა მიიღოს სიგმა,

273
00:14:49,000 --> 00:14:51,000
და მე ბრალია აქაც.

274
00:14:51,000 --> 00:14:55,000
იმპლიციტური დეკლარაციის ფუნქციის GetInt ნიშნავს მე დავიწყებული გავაკეთოთ რა?

275
00:14:55,000 --> 00:14:57,000
[Inaudible-სტუდენტი]

276
00:14:57,000 --> 00:15:00,000
კარგი, ასე აშკარად ჩვეულებრივი შეცდომა, მოდით დააყენა ამ მდე აქ,

277
00:15:00,000 --> 00:15:04,000
cs50.h და ახლა მოდით დავუბრუნდეთ ჩემი ტერმინალის ფანჯარაში.

278
00:15:04,000 --> 00:15:08,000
>> მე გარკვევა ეკრანზე, და მე გამეორება მიიღოს სიგმა.

279
00:15:08,000 --> 00:15:11,000
როგორც ჩანს არ შედგენილი. ნება მიბოძეთ ახლა აწარმოებს სიგმა.

280
00:15:11,000 --> 00:15:15,000
მე აკრიფოთ ნომერი 3, და მე კიდევ 6, ასე არ მკაცრი შემოწმება,

281
00:15:15,000 --> 00:15:18,000
მაგრამ მაინც აშკარად ჩანს, რომ სამუშაო ერთი შეხედვით, მაგრამ ახლა მოდით დააკოპიროთ ის გარდა,

282
00:15:18,000 --> 00:15:21,000
და მოდით რეალურად ბერკეტები იდეა უკან, კიდევ ერთხელ,

283
00:15:21,000 --> 00:15:24,000
ძალიან მარტივია კონტექსტში ისე, რომ რამდენიმე კვირის განმავლობაში დრო

284
00:15:24,000 --> 00:15:27,000
როდესაც ჩვენ ვიწყებთ შეისწავლოს fancier მონაცემები სტრუქტურების ვიდრე კოლექტორები

285
00:15:27,000 --> 00:15:30,000
ჩვენ გვაქვს კიდევ ერთი იარაღია ინსტრუმენტარიუმის, რომლითაც

286
00:15:30,000 --> 00:15:33,000
მანიპულირება ის მონაცემი სტრუქტურების როგორც ვნახავთ.

287
00:15:33,000 --> 00:15:36,000
ეს არის iterative მიდგომა, მარყუჟის დაფუძნებული მიდგომა.

288
00:15:36,000 --> 00:15:39,000
>> ნება მომეცით ნაცვლად ახლა ამის გაკეთება.

289
00:15:39,000 --> 00:15:44,000
ნება მომეცით ნაცვლად ამბობენ, რომ summation საქართველოს ნომერი

290
00:15:44,000 --> 00:15:48,000
on ქვემოთ 0 მართლაც იგივე, როგორც

291
00:15:48,000 --> 00:15:53,000
პუნქტების + სიგმა (ნომერი - 1).

292
00:15:53,000 --> 00:15:57,000
სხვა სიტყვებით, ისევე სცენაზე მე punted თითოეულ ადამიანი ჩემს გვერდით,

293
00:15:57,000 --> 00:16:00,000
და ისინი თავის მხრივ ინახება punting სანამ ჩვენ საბოლოოდ bottomed გამოსვლით ვილი,

294
00:16:00,000 --> 00:16:03,000
ვისაც ჰქონდა დაბრუნების მყარი კოდირებული პასუხი მოსწონს 0.

295
00:16:03,000 --> 00:16:07,000
აქ არის ჩვენ ასეთივე punting to სიგმა

296
00:16:07,000 --> 00:16:10,000
იგივე ფუნქცია, როგორც თავდაპირველად მოუწოდა, მაგრამ გასაღები ინსაითი აქ

297
00:16:10,000 --> 00:16:12,000
ის არის, რომ ჩვენ არ მოუწოდებდა სიგმა იდენტურად.

298
00:16:12,000 --> 00:16:14,000
ჩვენ არ გადადის n.

299
00:16:14,000 --> 00:16:17,000
ჩვენ ნათლად გადადის ნომერი - 1,

300
00:16:17,000 --> 00:16:20,000
ამიტომ ოდნავ პატარა პრობლემა, ოდნავ პატარა პრობლემა.

301
00:16:20,000 --> 00:16:23,000
>> სამწუხაროდ, ეს არ არის საკმაოდ გამოსავალი არ არის, და სანამ ჩვენ დაფიქსირება

302
00:16:23,000 --> 00:16:26,000
რა შეიძლება jumping, როგორც აშკარა რაღაც თქვენგანს

303
00:16:26,000 --> 00:16:28,000
ნება მომეცით წავიდეთ წინ და გამეორება მიიღოს.

304
00:16:28,000 --> 00:16:30,000
როგორც ჩანს შედგენა okay.

305
00:16:30,000 --> 00:16:32,000
ნება მომეცით გამეორება სიგმა ერთად 6.

306
00:16:32,000 --> 00:16:37,000
Whoops, ნება მომეცით გამეორება სიგმა ერთად 6.

307
00:16:37,000 --> 00:16:42,000
ჩვენ ვხედავთ ამ ადრე, თუმცა შემთხვევით ბოლო დროს ისევე.

308
00:16:42,000 --> 00:16:48,000
რატომ მივიღებ ამ cryptic სეგმენტაცია ბრალია? Yeah.

309
00:16:48,000 --> 00:16:50,000
[Inaudible-სტუდენტი]

310
00:16:50,000 --> 00:16:53,000
იქ არ არის ბაზის შემთხვევაში, და უფრო კონკრეტულად, რა ალბათ მოხდა?

311
00:16:53,000 --> 00:16:58,000
ეს არის სიმპტომია რა საქციელი?

312
00:16:58,000 --> 00:17:00,000
ამბობენ, რომ ეს პატარა louder.

313
00:17:00,000 --> 00:17:02,000
[Inaudible-სტუდენტი]

314
00:17:02,000 --> 00:17:05,000
ეს უსასრულო ციკლი ეფექტურად და პრობლემა უსასრულო მარყუჟების

315
00:17:05,000 --> 00:17:08,000
როდესაც მათ ჩართვას უკან ამ შემთხვევაში, ფუნქციის მოუწოდებდა თავად,

316
00:17:08,000 --> 00:17:10,000
რა ხდება ყოველ ჯერზე რეკავთ ფუნქცია?

317
00:17:10,000 --> 00:17:13,000
ისე, ვფიქრობ, თავში თუ როგორ ასახული მეხსიერება კომპიუტერის.

318
00:17:13,000 --> 00:17:16,000
ჩვენ ვთქვით, რომ არსებობს ამ ბლოკი მეხსიერება მოუწოდა დასტის რომ ბოლოში,

319
00:17:16,000 --> 00:17:19,000
და ყოველ ჯერზე რეკავთ ფუნქცია ცოტა მეტი მეხსიერების იღებს დააყენა

320
00:17:19,000 --> 00:17:24,000
ამ ე.წ. დასტის შემცველი რომ ფუნქციის ლოკალური ცვლადების ან პარამეტრების,

321
00:17:24,000 --> 00:17:27,000
ასე რომ, თუ სიგმა მოუწოდებს სიგმა მოუწოდებს სიგმა სიგმა მოუწოდებს

322
00:17:27,000 --> 00:17:29,000
 უწოდებს სიგმა სად ეს ამბავი ბოლომდე?

323
00:17:29,000 --> 00:17:31,000
>> ისე, ეს საბოლოოდ overruns სულ თანხა

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

325
00:17:33,000 --> 00:17:37,000
თქვენ overrun სეგმენტი, რომ თქვენ უნდა დარჩენა ფარგლებში,

326
00:17:37,000 --> 00:17:40,000
და თქვენ ამ სეგმენტაცია ბრალია, core dumped,

327
00:17:40,000 --> 00:17:43,000
და რა ძირითადი dumped ნიშნავს, რომ მე უკვე ფაილი სახელად ძირითადი

328
00:17:43,000 --> 00:17:46,000
რაც ფაილის შემცველი zeros და პირობა

329
00:17:46,000 --> 00:17:49,000
რომ რეალურად მომავალში იქნება diagnostically სასარგებლო.

330
00:17:49,000 --> 00:17:52,000
თუ ეს არ ნათელია, სად თქვენი შეცდომა

331
00:17:52,000 --> 00:17:54,000
შეგიძლიათ მართლაც ცოტა სასამართლო ანალიზი, ასე ვთქვათ,

332
00:17:54,000 --> 00:17:58,000
ამ ძირითადი ნაგავსაყრელი ფაილი, რომელიც, კიდევ ერთხელ, მხოლოდ მთელი bunch of zeros და პირობა

333
00:17:58,000 --> 00:18:02,000
რომ არსებითად წარმოადგენს სახელმწიფო თქვენი პროგრამის მეხსიერებაში

334
00:18:02,000 --> 00:18:05,000
მომენტიდან შეეჯახა ამ გზით.

335
00:18:05,000 --> 00:18:11,000
>> სარემონტო აქ არის ის, რომ ჩვენ არ შეგვიძლია უბრალოდ ბრმად დაბრუნების სიგმა,

336
00:18:11,000 --> 00:18:14,000
პუნქტების + სიგმა of ოდნავ პატარა პრობლემა.

337
00:18:14,000 --> 00:18:16,000
ჩვენ გვჭირდება გარკვეული სახის ბაზის შემთხვევაში აქ,

338
00:18:16,000 --> 00:18:19,000
და რა უნდა ბაზის შემთხვევაში ალბათ?

339
00:18:19,000 --> 00:18:22,000
[Inaudible-სტუდენტი]

340
00:18:22,000 --> 00:18:25,000
Okay, ასე სანამ ხმების დადებითია ჩვენ რეალურად უნდა დაუბრუნდნენ ამ,

341
00:18:25,000 --> 00:18:29,000
ან განათავსოთ სხვა გზა, თუ ნომერი, ვთქვათ, <= 0

342
00:18:29,000 --> 00:18:32,000
იცით, რა, მე წავიდეთ წინ და უკან დაბრუნებას 0,

343
00:18:32,000 --> 00:18:36,000
ჰგავს Willy გააკეთა, და სხვას, მე ვაპირებ წავიდეთ წინ

344
00:18:36,000 --> 00:18:41,000
და დაუბრუნოს ამ, ასე რომ არ არის, რომ ბევრად უფრო მოკლეა

345
00:18:41,000 --> 00:18:44,000
ვიდრე iterative ვერსია, რომ ჩვენ whipped მდე პირველი გამოყენებით ამისთვის მარყუჟის,

346
00:18:44,000 --> 00:18:48,000
მაგრამ შევნიშნოთ, რომ ამ სახის ელეგანტურობა მას.

347
00:18:48,000 --> 00:18:51,000
დაბრუნების ნაცვლად რამდენიმე ნომერი და ასრულებენ ყველა ამ math

348
00:18:51,000 --> 00:18:54,000
და დასძინა რამ ერთად ადგილობრივი ცვლადები

349
00:18:54,000 --> 00:18:57,000
თქვენ ნაცვლად რომ "Okay, თუ ეს სუპერ მარტივი პრობლემა,

350
00:18:57,000 --> 00:19:01,000
მოსწონს რიცხვი <0, ნება მომეცით დაუყოვნებლივ დაბრუნებას 0. "

351
00:19:01,000 --> 00:19:03,000
>> ჩვენ არ ვაპირებთ შეწუხება მხარდამჭერი უარყოფითი რიცხვები,

352
00:19:03,000 --> 00:19:05,000
ამიტომ მე ვაპირებ მძიმე კოდი მნიშვნელობა 0.

353
00:19:05,000 --> 00:19:08,000
მაგრამ სხვაგვარად, შეასრულოს ეს იდეა შემაჯამებელი

354
00:19:08,000 --> 00:19:11,000
ყველა ამ ნომრებზე ერთად შეგიძლიათ ეფექტურად მიიღოს პატარა bite

355
00:19:11,000 --> 00:19:14,000
გარეთ პრობლემა, გაცილებით ისე, როგორც აქ სცენაზე,

356
00:19:14,000 --> 00:19:18,000
მაშინ punt დანარჩენ პრობლემას შემდეგი პირი,

357
00:19:18,000 --> 00:19:20,000
მაგრამ ამ შემთხვევაში შემდეგი პირი თავს.

358
00:19:20,000 --> 00:19:22,000
ეს იდენტურად დაასახელა ფუნქცია.

359
00:19:22,000 --> 00:19:25,000
Just გაიაროს ეს პატარა და პატარა და პატარა პრობლემა ყოველ ჯერზე,

360
00:19:25,000 --> 00:19:28,000
და მიუხედავად იმისა, რომ ჩვენ არ საკმაოდ ფორმალიზებული რამ კოდი აქ

361
00:19:28,000 --> 00:19:33,000
ეს არის ზუსტად ის, რაც ხდებოდა კვირაში 0 ერთად სატელეფონო წიგნში.

362
00:19:33,000 --> 00:19:36,000
ეს არის ზუსტად ის, რაც ხდებოდა წარსულში კვირის ერთად შონ

363
00:19:36,000 --> 00:19:39,000
და ჩვენი დემონსტრაციების ეძებს ნომრები.

364
00:19:39,000 --> 00:19:42,000
ის აღების პრობლემა და გამყოფი ეს ისევ და ისევ.

365
00:19:42,000 --> 00:19:44,000
>> სხვა სიტყვებით, არსებობს გზა არის თარგმნა

366
00:19:44,000 --> 00:19:47,000
ამ რეალურ სამყაროში შენება, ამ უმაღლეს დონეზე შენება

367
00:19:47,000 --> 00:19:51,000
საქართველოს გაყოფა და დაპყრობა და თავისსავე ისევ და ისევ

368
00:19:51,000 --> 00:19:56,000
კოდის, ამიტომ ეს არის ის ვნახავთ ერთხელ დროთა განმავლობაში.

369
00:19:56,000 --> 00:20:00,000
ახლა, როგორც განზე, თუ თქვენ ახალი უკან თქვენ მაინც უნდა გვესმოდეს, ახლა

370
00:20:00,000 --> 00:20:02,000
ამიტომ ეს არის სასაცილო.

371
00:20:02,000 --> 00:20:05,000
მე ვაპირებ წასვლა google.com,

372
00:20:05,000 --> 00:20:17,000
და მე ვაპირებ მოძებნოთ რამდენიმე რჩევა და ხრიკები წლის უკან, შეიყვანოთ.

373
00:20:17,000 --> 00:20:21,000
Tell პირის შემდეგ, თუ ისინი არ იცინის ახლა.

374
00:20:21,000 --> 00:20:23,000
ხომ არ იგულისხმეთ უკან?

375
00:20:23,000 --> 00:20:25,000
ხომ არ იგულისხმეთ-ah, იქ წასვლა.

376
00:20:25,000 --> 00:20:28,000
Okay, ახლა რომ დანარჩენ ყველას.

377
00:20:28,000 --> 00:20:30,000
პატარა აღდგომის კვერცხი ჩანერგილი სადღაც იქ Google.

378
00:20:30,000 --> 00:20:33,000
როგორც განზე, ერთი Links ჩვენ ჩაიცვი რა თქმა ნახვა

379
00:20:33,000 --> 00:20:36,000
დღეს მხოლოდ ამ ქსელის სხვადასხვა დახარისხება ალგორითმები,

380
00:20:36,000 --> 00:20:39,000
რომელთაგან ზოგიერთი ჩვენ შევხედეთ გასულ კვირას, მაგრამ რა ლამაზი ამ ვიზუალიზაცია

381
00:20:39,000 --> 00:20:43,000
როგორც თქვენ ცდილობენ გადაიტანოთ თქვენი აზრით გარშემო სხვადასხვა რამ დაკავშირებული ალგორითმები

382
00:20:43,000 --> 00:20:46,000
ვიცი, რომ თქვენ შეგიძლიათ ძალიან მარტივად არის იწყება სხვადასხვა ტიპის საშუალებებით.

383
00:20:46,000 --> 00:20:50,000
საშუალებებით ყველა შეცვალა, საშუალებებით ძირითადად დახარისხებული, საშუალებებით შემთხვევითი და სხვ.

384
00:20:50,000 --> 00:20:53,000
როგორც თქვენ ცდილობენ, კიდევ ერთხელ, გამოირჩეოდნენ ეს ყველაფერი თქვენს გონება

385
00:20:53,000 --> 00:20:57,000
გააცნობიეროს, რომ ეს მისამართი თქმა ნახვა on ლექციები გვერდზე

386
00:20:57,000 --> 00:21:00,000
შესაძლოა დაგეხმაროთ მიზეზი მეშვეობით ზოგიერთი ასეთი.

387
00:21:00,000 --> 00:21:05,000
>> დღეს ჩვენ საბოლოოდ მივიღებთ ამ პრობლემის მოგვარებას საწყისი ხოლო უკან,

388
00:21:05,000 --> 00:21:08,000
რაც იყო, რომ ეს swap ფუნქციის უბრალოდ არ მუშაობდა,

389
00:21:08,000 --> 00:21:12,000
და რა იყო ფუნდამენტური პრობლემა ამ ფუნქციის swap,

390
00:21:12,000 --> 00:21:15,000
რომლის მთავარი მიზანი, კიდევ ერთხელ, გაცვლა ღირებულება აქ და აქ

391
00:21:15,000 --> 00:21:17,000
ისეთი, რომ ეს მოხდება?

392
00:21:17,000 --> 00:21:20,000
ეს არ რეალურად იმუშაოს. რატომ?

393
00:21:20,000 --> 00:21:22,000
Yeah.

394
00:21:22,000 --> 00:21:28,000
[Inaudible-სტუდენტი]

395
00:21:28,000 --> 00:21:31,000
სწორედ ახსნა ამ bugginess

396
00:21:31,000 --> 00:21:34,000
უბრალოდ იყო, რადგან როცა რეკავთ ფუნქციების C

397
00:21:34,000 --> 00:21:38,000
და ამ ფუნქციების მიიღოს არგუმენტები, როგორიცაა და B აქ,

398
00:21:38,000 --> 00:21:42,000
თქვენ გადადის ასლები რასაც ღირებულება თქვენ უზრუნველყოფს, რომ ფუნქცია.

399
00:21:42,000 --> 00:21:46,000
თქვენ არ უზრუნველყოფს ორიგინალური ღირებულებებს თავს,

400
00:21:46,000 --> 00:21:49,000
ასე ჩვენ ვნახეთ ამ კონტექსტში buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, რომელიც გამოიყურებოდა ცოტა რაღაც მსგავსი.

402
00:21:52,000 --> 00:21:57,000
>> შეგახსენებთ, რომ ჩვენ გვქონდა x და y ინიციალიზაცია რომ 1 და 2, შესაბამისად.

403
00:21:57,000 --> 00:21:59,000
ჩვენ მაშინ ამობეჭდილი რაც იყო.

404
00:21:59,000 --> 00:22:03,000
მე მაშინ აცხადებდა, რომ მე შევცვალე მათ დარეკვით swap of x, y.

405
00:22:03,000 --> 00:22:06,000
მაგრამ პრობლემა ის იყო, რომ შევცვალე მუშაობდა,

406
00:22:06,000 --> 00:22:10,000
თუმცა მხოლოდ ფარგლებს swap ფუნქციონირებას თავად.

407
00:22:10,000 --> 00:22:13,000
როგორც კი მოხვდა ხაზი 40 იმ swapped ღირებულებები

408
00:22:13,000 --> 00:22:16,000
მოხვდნენ მოშორებით, და ასე არაფერი

409
00:22:16,000 --> 00:22:21,000
თავდაპირველ ფუნქციას ძირითად სინამდვილეში შეცვლილა,

410
00:22:21,000 --> 00:22:26,000
ასე რომ, თუ თქვენ ფიქრობთ, მაშინ რაც ამ ჰგავს თვალსაზრისით ჩვენი მეხსიერება

411
00:22:26,000 --> 00:22:29,000
თუ ამ მარცხენა მხარეს გამგეობა წარმოადგენს-

412
00:22:29,000 --> 00:22:33,000
და მე გავაკეთებ ყველასთვის, რომ ეს თუ ამ მარცხენა მხარეს ფორუმში

413
00:22:33,000 --> 00:22:37,000
წარმოადგენს, ვთქვათ, თქვენი RAM და დასტის აპირებს იზრდება up ამ გზით,

414
00:22:37,000 --> 00:22:43,000
და მოვუწოდებთ ფუნქცია, როგორიცაა ძირითადი და უმთავრესი აქვს 2 ადგილობრივი ცვლადები, X და Y,

415
00:22:43,000 --> 00:22:48,000
მოდით აღვწეროთ იმ როგორც x აქ, და მოდით აღვწეროთ ეს როგორც Y აქ,

416
00:22:48,000 --> 00:22:55,000
და მოდით დასვა ღირებულებების 1 და 2, ასე რომ ეს აქ არის მთავარი,

417
00:22:55,000 --> 00:22:58,000
და როდესაც მთავარ მოუწოდებს swap ფუნქციის ოპერაციული სისტემა

418
00:22:58,000 --> 00:23:02,000
აძლევს swap ფუნქციის საკუთარი swath მეხსიერების on დასტის,

419
00:23:02,000 --> 00:23:04,000
საკუთარი ჩარჩო დასტის, ასე ვთქვათ.

420
00:23:04,000 --> 00:23:08,000
იგი ასევე გამოყოფს 32 ბიტი ამ ints.

421
00:23:08,000 --> 00:23:11,000
ეს ხდება მოვუწოდებთ მათ და B, მაგრამ ეს სრულიად უკანონო.

422
00:23:11,000 --> 00:23:13,000
ეს შეეძლო მოუწოდა მათ რაც არ სურს, მაგრამ რა ხდება მაშინ, როდესაც მთავარი

423
00:23:13,000 --> 00:23:19,000
მოუწოდებს swap არის სჭირდება ამ 1, აყენებს ასლი არსებობს, აყენებს ასლი არსებობს.

424
00:23:19,000 --> 00:23:23,000
>> არსებობს 1 სხვა ადგილობრივ ცვლადი in swap, თუმცა, მოუწოდა რა? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
TMP, ნება მომეცით, მისცეს თავს კიდევ 32 ბიტი აქ,

426
00:23:27,000 --> 00:23:29,000
და რა გავაკეთო ამ ფუნქციას?

427
00:23:29,000 --> 00:23:34,000
მე ვუთხარი int tmp იღებს, ასე რომ არის 1, ასე რომ მე ამ როდესაც ჩვენ ბოლო ითამაშა, რომელზეც ეს მაგალითი.

428
00:23:34,000 --> 00:23:39,000
მაშინ იღებს B, ამიტომ B არის 2, ასე რომ ახლა ამ ხდება 2,

429
00:23:39,000 --> 00:23:42,000
და ახლა ბ იღებს temp, ასე Temp არის 1,

430
00:23:42,000 --> 00:23:44,000
ახლა ბ ხდება ამ.

431
00:23:44,000 --> 00:23:46,000
სწორედ დიდი. იგი მუშაობდა.

432
00:23:46,000 --> 00:23:49,000
მაგრამ შემდეგ, როგორც კი ფუნქცია დააბრუნებს

433
00:23:49,000 --> 00:23:52,000
swap ხსოვნას ეფექტურად ქრება ისე, რომ იგი შეიძლება reused

434
00:23:52,000 --> 00:23:58,000
ზოგიერთი სხვა ფუნქცია მომავალში, და ძირითადი აშკარად სრულიად უცვლელი.

435
00:23:58,000 --> 00:24:00,000
ჩვენ გვჭირდება გზა ფუნდამენტურად პრობლემის მოსაგვარებლად,

436
00:24:00,000 --> 00:24:03,000
და დღეს ჩვენ საბოლოოდ აქვს გზა ამით რის

437
00:24:03,000 --> 00:24:06,000
ჩვენ შეგვიძლია წარმოგიდგინოთ რაღაც მოუწოდა მაჩვენებელი.

438
00:24:06,000 --> 00:24:09,000
თურმე ჩვენ შეგვიძლია ამ პრობლემის მოგვარებას

439
00:24:09,000 --> 00:24:12,000
არ გავლით in ასლები x და y

440
00:24:12,000 --> 00:24:18,000
მაგრამ ნაცვლად გავლით რა, ფიქრობთ, რომ swap ფუნქცია?

441
00:24:18,000 --> 00:24:20,000
ჰო, რაც შეეხება მისამართი?

442
00:24:20,000 --> 00:24:22,000
ჩვენ ნამდვილად არ ისაუბრა მისამართები ბევრად დეტალურად

443
00:24:22,000 --> 00:24:25,000
მაგრამ თუ ამ დაფაზე წარმოადგენს ჩემი კომპიუტერის მეხსიერებაში

444
00:24:25,000 --> 00:24:28,000
ჩვენ ნამდვილად დაიწყება ნუმერაციის bytes ჩემი RAM

445
00:24:28,000 --> 00:24:31,000
და ამბობენ, რომ ეს არის byte # 1, ეს არის byte # 2, byte # 3

446
00:24:31,000 --> 00:24:35,000
byte # 4, byte # ... 2 მილიარდი თუ აქვს 2 გიგაბაიტი ოპერატიული მეხსიერება,

447
00:24:35,000 --> 00:24:38,000
ამიტომ ჩვენ ნამდვილად ამუშავება ზოგიერთი თვითნებური ნუმერაციის სქემა

448
00:24:38,000 --> 00:24:41,000
ყველა ინდივიდუალური bytes ჩემი კომპიუტერის მეხსიერებაში.

449
00:24:41,000 --> 00:24:43,000
>> რა მოხდება, თუ ნაცვლად როდესაც მოვუწოდებ swap

450
00:24:43,000 --> 00:24:47,000
ვიდრე კორიდორი ასლები x და y

451
00:24:47,000 --> 00:24:51,000
რატომ არ მე ნაცვლად კორიდორი მისამართი x აქ,

452
00:24:51,000 --> 00:24:55,000
მისამართი Y აქ, არსებითად საფოსტო მისამართი

453
00:24:55,000 --> 00:24:59,000
of x და y რადგან მაშინ სვოპ, თუ იგი ინფორმირებული

454
00:24:59,000 --> 00:25:01,000
მიმართვის ხსოვნისადმი x და y,

455
00:25:01,000 --> 00:25:04,000
მაშინ სვოპ, თუ ჩვენ კარგად გაწვრთნილი მას ცოტა,

456
00:25:04,000 --> 00:25:07,000
მან შესაძლოა გამგზავრება, რომ მისამართი, ასე ვთქვათ,

457
00:25:07,000 --> 00:25:11,000
x, და შეცვალოს ნომერი არსებობს, მაშინ გამგზავრება მისამართი Y,

458
00:25:11,000 --> 00:25:16,000
შეცვლის ნომერი არსებობს, მაშინაც კი, როდესაც რეალურად არ მიღების ასლები იმ ფასეულობებს თავს,

459
00:25:16,000 --> 00:25:19,000
ამიტომ, მიუხედავად იმისა, ჩვენ ვისაუბრეთ ამ როგორც ძირითადი ხსოვნას

460
00:25:19,000 --> 00:25:23,000
და ეს როგორც swap ხსოვნას ძლიერი და სახიფათო ნაწილი C

461
00:25:23,000 --> 00:25:28,000
არის, რომ ნებისმიერი ფუნქცია შეიძლება შეეხოთ მეხსიერების სადმე კომპიუტერში,

462
00:25:28,000 --> 00:25:32,000
და ეს არის მძლავრი, რომ შეგიძლიათ გააკეთოთ ძალიან ლამაზი რამ კომპიუტერული პროგრამების C.

463
00:25:32,000 --> 00:25:36,000
ეს არის საშიში, რადგან შეგიძლიათ ასევე Screw up ძალიან მარტივად.

464
00:25:36,000 --> 00:25:39,000
ფაქტობრივად, ერთი ყველაზე გავრცელებული გზა პროგრამების ამ დღეებში უნდა ექსპლუატაციაში

465
00:25:39,000 --> 00:25:42,000
ჯერ კიდევ არის პროგრამისტი არ გააცნობიეროს

466
00:25:42,000 --> 00:25:45,000
რომ მას მთლიანად ან ნაწილობრივ საშუალებითაც მონაცემები

467
00:25:45,000 --> 00:25:49,000
უნდა ჩაიწეროს საიდან მეხსიერებაში, რომ არ იყო განკუთვნილი.

468
00:25:49,000 --> 00:25:51,000
>> მაგალითად, იგი აცხადებს მასივი ზომა 10

469
00:25:51,000 --> 00:25:56,000
მაგრამ შემდეგ შემთხვევით ცდილობს 11 ბაიტი შევიდა, რომ მასივი მეხსიერება,

470
00:25:56,000 --> 00:25:59,000
და თქვენ დაიწყოს ეხება ნაწილები მეხსიერების, რომლებიც აღარ მოქმედებს.

471
00:25:59,000 --> 00:26:02,000
მხოლოდ შინაარსობრივ ამ ზოგიერთი მოგეხსენებათ, რომ

472
00:26:02,000 --> 00:26:06,000
პროგრამული ხშირად თხოვს თქვენ სერიული ნომრები ან რეგისტრაციის გასაღებები,

473
00:26:06,000 --> 00:26:08,000
Photoshop და Word და პროგრამების მოსწონს ეს.

474
00:26:08,000 --> 00:26:12,000
არსებობს ბზარები, როგორც ზოგიერთი იცით, ონლაინ სადაც შეგიძლიათ აწარმოებს პატარა პროგრამა,

475
00:26:12,000 --> 00:26:14,000
და voila, არა მოთხოვნა სერიული ნომერი.

476
00:26:14,000 --> 00:26:16,000
როგორ ხდება, რომ მუშაობის?

477
00:26:16,000 --> 00:26:21,000
ხშირ შემთხვევაში ეს ყველაფერი უბრალოდ მოძიებას კომპიუტერები

478
00:26:21,000 --> 00:26:24,000
ტექსტი სეგმენტებად კომპიუტერის ფაქტობრივი zeros და პირობა

479
00:26:24,000 --> 00:26:28,000
აქ არის ის, რომ ფუნქცია სადაც სერიული ნომერი ითხოვს,

480
00:26:28,000 --> 00:26:31,000
და თქვენ გადავაწერო, რომ სივრცე, ან მაშინ, როდესაც პროგრამა გაშვებულია

481
00:26:31,000 --> 00:26:33,000
შეგიძლიათ გაერკვნენ, სადაც გასაღები ფაქტობრივად ინახება

482
00:26:33,000 --> 00:26:37,000
გამოყენებით რაღაც მოუწოდა debugger, და თქვენ შეგიძლიათ ბზარი პროგრამული უზრუნველყოფა, რომ გზა.

483
00:26:37,000 --> 00:26:40,000
ეს არ არის იმის თქმა, რომ ეს არის ჩვენი ამოცანა მომდევნო დღეებში,

484
00:26:40,000 --> 00:26:42,000
მაგრამ მას აქვს ძალიან რეალურ სამყაროში ramifications.

485
00:26:42,000 --> 00:26:45,000
რომ ერთი ხდება ჩართვა ქურდობა პროგრამული უზრუნველყოფა,

486
00:26:45,000 --> 00:26:47,000
მაგრამ არსებობს ასევე კომპრომისის მთელი მანქანები.

487
00:26:47,000 --> 00:26:50,000
>> სინამდვილეში, როდესაც საიტებზე ამ დღეებში შედის ექსპლუატაციაში

488
00:26:50,000 --> 00:26:53,000
და კომპრომეტირებული და მონაცემები გაჟონა და პაროლები მოიპარეს

489
00:26:53,000 --> 00:26:58,000
ეს ძალიან ხშირად ეხება ცუდი მართვა ერთი მეხსიერება,

490
00:26:58,000 --> 00:27:01,000
ან, იმ შემთხვევაში, მონაცემთა ბაზა, წარუმატებლობა გავუსწრო

491
00:27:01,000 --> 00:27:03,000
შეჯიბრებითობის შეყვანის, ასე უფრო, რომ კვირის მოსვლა,

492
00:27:03,000 --> 00:27:07,000
მაგრამ ახლა მხოლოდ Sneak ესკიზი სახის ზარალი, რომელიც შეგიძლიათ გააკეთოთ,

493
00:27:07,000 --> 00:27:11,000
არა საკმაოდ გასაგებად როგორ რამ მუშაობა ქვეშ hood.

494
00:27:11,000 --> 00:27:14,000
მოდით წავიდეთ შესახებ გაგება რატომ გატყდა

495
00:27:14,000 --> 00:27:17,000
ერთად ინსტრუმენტი, რომელიც სულ უფრო და უფრო სასარგებლო

496
00:27:17,000 --> 00:27:19,000
როგორც ჩვენი პროგრამების კიდევ უფრო რთული.

497
00:27:19,000 --> 00:27:21,000
ჯერჯერობით, როცა მქონდა bug თქვენს პროგრამაში

498
00:27:21,000 --> 00:27:23,000
როგორ არ ხარ წასული შესახებ გამართვის ეს?

499
00:27:23,000 --> 00:27:25,000
რა თქვენი ტექნიკის ყოფილა ჯერჯერობით თუ არა ასწავლიან თქვენი TF

500
00:27:25,000 --> 00:27:27,000
ან უბრალოდ თვითნასწავლი?

501
00:27:27,000 --> 00:27:29,000
[სტუდენტური] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, ასე printf სავარაუდოდ თქვენი მეგობარი, რომ თუ გინდათ, ნახოთ

503
00:27:31,000 --> 00:27:33,000
რა ხდება შიგნით თქვენი პროგრამა

504
00:27:33,000 --> 00:27:36,000
უბრალოდ დააყენა printf აქ, printf აქ, printf აქ.

505
00:27:36,000 --> 00:27:38,000
მაშინ თქვენ გაუშვით, და თქვენ მიიღებთ მთელი bunch პერსონალის ეკრანზე

506
00:27:38,000 --> 00:27:43,000
რომ თქვენ შეგიძლიათ გამოიყენოთ შემდეგ დავასკვნათ რა არის რეალურად აპირებს არასწორი თქვენს პროგრამას.

507
00:27:43,000 --> 00:27:45,000
>> Printf tends უნდა იყოს ძალიან ძლიერი რამ,

508
00:27:45,000 --> 00:27:47,000
მაგრამ ძალიან მანუალურ პროცესს.

509
00:27:47,000 --> 00:27:49,000
თქვენ უნდა დააყენოს printf აქ, printf აქ,

510
00:27:49,000 --> 00:27:51,000
და თუ ამას შიგნით loop შესაძლოა 100 ხაზები

511
00:27:51,000 --> 00:27:53,000
გამომავალი რომ თქვენ მაშინ უნდა Sift მეშვეობით.

512
00:27:53,000 --> 00:27:58,000
ეს არ არის ძალიან მოსახერხებელი ან ინტერაქტიული მექანიზმს გამართვის პროგრამების,

513
00:27:58,000 --> 00:28:00,000
მაგრამ საბედნიეროდ არსებობს ალტერნატივა.

514
00:28:00,000 --> 00:28:03,000
არსებობს პროგრამა, მაგალითად, სახელად GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
რომელიც ცოტა arcane წელს თუ როგორ გამოიყენოს იგი.

516
00:28:06,000 --> 00:28:08,000
ეს პატარა კომპლექსი, მაგრამ გულწრფელად ვამბობ,

517
00:28:08,000 --> 00:28:11,000
ეს არის ერთ იმ რამ, სადაც თუ თქვენ დააყენა ამ კვირაში და შემდეგი

518
00:28:11,000 --> 00:28:14,000
დამატებითი საათობრივად გვესმოდეს, რაღაც GDB

519
00:28:14,000 --> 00:28:18,000
ეს დაგიზოგავთ თქვენ ალბათ ათობით საათი გრძელვადიან პერსპექტივაში,

520
00:28:18,000 --> 00:28:21,000
ასე რომ, ნება მომეცით მოგცემთ teaser, თუ როგორ ეს რამ მუშაობს.

521
00:28:21,000 --> 00:28:23,000
>> მე ჩემი ტერმინალის ფანჯარაში.

522
00:28:23,000 --> 00:28:26,000
ნება მომეცით წავიდეთ წინ და შეადგინონ ამ პროგრამის buggy3.

523
00:28:26,000 --> 00:28:28,000
ეს უკვე დღემდე.

524
00:28:28,000 --> 00:28:31,000
ნება მომეცით აწარმოებს უბრალოდ ისე, როგორც მაშინ, როდესაც უკან, და მართლაც, ეს გატეხილი.

525
00:28:31,000 --> 00:28:34,000
მაგრამ რატომ არის ეს? იქნებ მე ბრალია swap ფუნქცია.

526
00:28:34,000 --> 00:28:37,000
შეიძლება უფრო და ბ. მე არ საკმაოდ მოძრავი მათ გარშემო სწორად.

527
00:28:37,000 --> 00:28:39,000
ნება მომეცით წავიდეთ წინ და ამის გაკეთება.

528
00:28:39,000 --> 00:28:43,000
იმის ნაცვლად, რომ უბრალოდ აწარმოებს buggy3 ნება მომეცით ნაცვლად აწარმოებს ამ პროგრამის GDB,

529
00:28:43,000 --> 00:28:48,000
და მე ვაპირებ ვამბობ, რომ აწარმოებს buggy3,

530
00:28:48,000 --> 00:28:52,000
და მე ვაპირებ მოიცავს command line არგუმენტი,-TUI,

531
00:28:52,000 --> 00:28:55,000
და ჩვენ დააყენა ამ მომავალში პრობლემების სპეც შევახსენო.

532
00:28:55,000 --> 00:28:57,000
და ახლა ამ შავი და თეთრი ინტერფეისი popped, რომ, ერთხელ,

533
00:28:57,000 --> 00:28:59,000
არის პატარა აბსოლუტური თავდაპირველად რადგან იქ ყველა ამ

534
00:28:59,000 --> 00:29:02,000
გარანტია ინფორმაცია ქვემოთ, მაგრამ მაინც არსებობს რაღაც ნაცნობი.

535
00:29:02,000 --> 00:29:04,000
In ზევით ფანჯარა არის ჩემი ფაქტობრივი კოდი,

536
00:29:04,000 --> 00:29:08,000
და თუ გადახვევა აქ ნება მომეცით გადახვევა რომ ძალიან ზევით ჩემი ფაილი,

537
00:29:08,000 --> 00:29:11,000
და მართლაც, იქ buggy3.c და გაფრთხილების ბოლოში ფანჯრის

538
00:29:11,000 --> 00:29:13,000
მაქვს ამ GDB ზოლზე.

539
00:29:13,000 --> 00:29:16,000
>> ეს არ არის იგივე, რაც ჩემი ნორმალური ჯონ ჰარვარდის ზოლზე.

540
00:29:16,000 --> 00:29:19,000
ეს არის სწრაფი, რომ აპირებს, ნება მიბოძეთ გააკონტროლოს GDB.

541
00:29:19,000 --> 00:29:21,000
GDB არის debugger.

542
00:29:21,000 --> 00:29:24,000
Debugger არის პროგრამა, რომელიც საშუალებას გაძლევთ გავლა

543
00:29:24,000 --> 00:29:27,000
აღსრულების თქვენი პროგრამის ხაზის მიერ ხაზს,

544
00:29:27,000 --> 00:29:30,000
გზაზე აკეთებს არაფერი გსურთ პროგრამა,

545
00:29:30,000 --> 00:29:33,000
კი მოუწოდებდა ფუნქციებს, ან ეძებს, რაც მთავარია,

546
00:29:33,000 --> 00:29:35,000
სხვადასხვა ცვლადი ღირებულებებს.

547
00:29:35,000 --> 00:29:37,000
მოდით წავიდეთ წინ და ამის გაკეთება.

548
00:29:37,000 --> 00:29:40,000
მე ვაპირებ წავიდეთ წინ და აკრიფოთ გარბოდა GDB ს სწრაფი,

549
00:29:40,000 --> 00:29:43,000
ასე შეამჩნია ბოლოში მარცხნივ ეკრანზე მე აკრეფილი აწარმოებს,

550
00:29:43,000 --> 00:29:45,000
და მე 'Enter, რა უნდოდა, რომ გავაკეთო?

551
00:29:45,000 --> 00:29:50,000
ეს სიტყვასიტყვით გაიქცა ჩემი პროგრამით, მაგრამ მე არ რეალურად ბევრი წავიდეთ აქ

552
00:29:50,000 --> 00:29:55,000
იმიტომ, რომ მე არ რეალურად განუცხადა debugger

553
00:29:55,000 --> 00:29:57,000
პაუზის დროს განსაკუთრებული მომენტი დრო.

554
00:29:57,000 --> 00:29:59,000
უბრალოდ აკრეფით პერსპექტივაში ეშვება პროგრამა.

555
00:29:59,000 --> 00:30:01,000
მე არ რეალურად ვხედავ რაიმე. მე ვერ მის მართვას.

556
00:30:01,000 --> 00:30:03,000
>> ამის ნაცვლად ნება მომეცით ამის გაკეთება.

557
00:30:03,000 --> 00:30:08,000
ამ GDB სწრაფი ნება მომეცით ნაცვლად აკრიფოთ შესვენების შევა.

558
00:30:08,000 --> 00:30:10,000
ეს არ არის ის, რაც მე ნიშნავდა ტიპის.

559
00:30:10,000 --> 00:30:13,000
მოდით ნაცვლად აკრიფოთ შესვენების ძირითადი.

560
00:30:13,000 --> 00:30:15,000
სხვა სიტყვებით, მინდა შექმნას რაღაც მოუწოდა breakpoint,

561
00:30:15,000 --> 00:30:18,000
რომელიც aptly დაასახელა, რადგან ეს იქნება შესვენების ან პაუზის

562
00:30:18,000 --> 00:30:21,000
აღსრულების თქვენი პროგრამის იმ კონკრეტულ ადგილას.

563
00:30:21,000 --> 00:30:23,000
მთავარი არის სახელი ჩემი ფუნქცია.

564
00:30:23,000 --> 00:30:25,000
გაითვალისწინეთ, რომ GDB საკმაოდ ჭკვიანი.

565
00:30:25,000 --> 00:30:28,000
ეს figured, რომ მთავარი ხდება დაიწყოს უხეშად დროს ხაზი 18

566
00:30:28,000 --> 00:30:32,000
საქართველოს buggy3.c და შემდეგ შეამჩნევთ აქ ზედა მარცხენა

567
00:30:32,000 --> 00:30:34,000
B + არის სწორი შემდეგ ხაზი 18.

568
00:30:34,000 --> 00:30:38,000
რომ ახსენებს, რომ შევქმენი breakpoint დროს ხაზი 18.

569
00:30:38,000 --> 00:30:42,000
ეს დრო, როდესაც მე აკრიფოთ პერსპექტივაში, მე ვაპირებ აწარმოებს ჩემი პროგრამა

570
00:30:42,000 --> 00:30:45,000
up სანამ გაიტანა რომ breakpoint,

571
00:30:45,000 --> 00:30:48,000
ასე პროგრამა პაუზის ჩემთვის ხაზი 18.

572
00:30:48,000 --> 00:30:50,000
აქ ჩვენ გადასვლა, აწარმოებს.

573
00:30:50,000 --> 00:30:53,000
არაფერი ჩანს, მოხდა, მაგრამ გაფრთხილების ქვედა დაუტოვებიათ

574
00:30:53,000 --> 00:30:58,000
დაწყებული პროგრამის, buggy3, breakpoint 1 მთავარ საათზე buggy3.c ხაზი 18.

575
00:30:58,000 --> 00:31:00,000
როგორ მოვიქცე ახლა?

576
00:31:00,000 --> 00:31:03,000
>> გაითვალისწინეთ შემიძლია დაიწყება აკრეფით რამ, როგორიცაა ბეჭდური,

577
00:31:03,000 --> 00:31:08,000
არ printf, ბეჭდვითი x, და ახლა რომ უცნაურია.

578
00:31:08,000 --> 00:31:11,000
$ 1 მხოლოდ ცნობისმოყვარეობა, როგორც ვნახავთ

579
00:31:11,000 --> 00:31:14,000
ყოველ დროს, თქვენ ბეჭდვა რაღაც თქვენ ახალი $ ღირებულება.

580
00:31:14,000 --> 00:31:18,000
სწორედ ასე რომ თქვენ შეგიძლიათ ეხება თავში წინა ღირებულებების მხოლოდ იმ შემთხვევაში,

581
00:31:18,000 --> 00:31:21,000
მაგრამ ახლა რა არის ბეჭდვის მეუბნებოდა ის არის, რომ ღირებულება x ამ დროისთვის ამბავი

582
00:31:21,000 --> 00:31:26,000
აშკარად 134514032.

583
00:31:26,000 --> 00:31:29,000
რა? სად, რომ თუნდაც მოდის?

584
00:31:29,000 --> 00:31:31,000
[Inaudible-სტუდენტი]

585
00:31:31,000 --> 00:31:34,000
მართლაც, ეს არის ის, რაც ჩვენ მოვუწოდებთ ნაგვის ღირებულება, და ჩვენ არ ისაუბრა ამ გაუკეთებია,

586
00:31:34,000 --> 00:31:37,000
მაგრამ მიზეზი, რომელიც ინიციალიზაცია ცვლადები

587
00:31:37,000 --> 00:31:40,000
აშკარად ისე, რომ მათ აქვთ გარკვეული მნიშვნელობა, რომ გსურთ მათი აქვს.

588
00:31:40,000 --> 00:31:44,000
მაგრამ დაჭერა არის გავიხსენოთ, რომ შეგიძლიათ განაცხადოს ცვლადები

589
00:31:44,000 --> 00:31:46,000
მოსწონს მე მომენტში წინ ჩემი სიგმა მაგალითად

590
00:31:46,000 --> 00:31:48,000
გარეშე რეალურად მათთვის მნიშვნელობა.

591
00:31:48,000 --> 00:31:50,000
გავიხსენოთ, თუ როგორი მე მეტი აქ სიგმა.

592
00:31:50,000 --> 00:31:52,000
მე განაცხადა N, მაგრამ რა ღირებულება არც მე ვაძლევ მას?

593
00:31:52,000 --> 00:31:56,000
არა, რადგან ვიცოდი, რომ უახლოეს ხაზები

594
00:31:56,000 --> 00:31:59,000
GetInt იზრუნებს პრობლემა აყენებს ღირებულება შიგნით n.

595
00:31:59,000 --> 00:32:02,000
>> მაგრამ ამ დროისთვის ამბავი ხაზი 11

596
00:32:02,000 --> 00:32:05,000
და ხაზი 12 და ხაზის 13 და ხაზი 14

597
00:32:05,000 --> 00:32:08,000
მთელ იმ რამდენიმე ხაზები რა არის ღირებულება N?

598
00:32:08,000 --> 00:32:10,000
In C უბრალოდ არ ვიცი.

599
00:32:10,000 --> 00:32:14,000
ეს ზოგადად ზოგიერთი ნაგვის ღირებულება, ზოგიერთი სრულიად შემთხვევითი რიცხვების

600
00:32:14,000 --> 00:32:17,000
რომ დარჩენილი ძირითადად ზოგიერთი წინა ფუნქცია

601
00:32:17,000 --> 00:32:21,000
რომელსაც აწარმოებს, ამიტომ, როგორც თქვენი პროგრამა ეშვება

602
00:32:21,000 --> 00:32:24,000
გავიხსენოთ, რომ ფუნქცია იღებს ფუნქცია, ფუნქციის, ფუნქცია.

603
00:32:24,000 --> 00:32:27,000
ყველა ამ ფარგლებში მისაღებად ჩაიცვი მეხსიერების და შემდეგ ამ ფუნქციების დაბრუნების,

604
00:32:27,000 --> 00:32:31,000
და ისევე, როგორც მე შესთავაზა ერთად Eraser მათი მეხსიერების საბოლოოდ reused.

605
00:32:31,000 --> 00:32:37,000
ისე, ეს მხოლოდ ასე ხდება, რომ ეს ცვლადი x ამ პროგრამაში

606
00:32:37,000 --> 00:32:41,000
როგორც ჩანს, არ შეიცავდა ზოგიერთ ნაგვის ღირებულება მოსწონს 134514032

607
00:32:41,000 --> 00:32:44,000
ზოგიერთი წინა ფუნქცია, არ არის ერთი, რომ დავწერე.

608
00:32:44,000 --> 00:32:47,000
ეს შეიძლება იყოს რაღაც რომ მოდის ეფექტურად ოპერაციული სისტემა,

609
00:32:47,000 --> 00:32:49,000
ზოგიერთი ფუნქციის ქვეშ hood.

610
00:32:49,000 --> 00:32:52,000
>> Okay, რომ ჯარიმა, მაგრამ მოდით ახლა წინასწარ შემდეგი ხაზი.

611
00:32:52,000 --> 00:32:55,000
თუ I ტიპის "შემდეგი" ჩემს GDB სწრაფი და მე 'Enter,

612
00:32:55,000 --> 00:32:58,000
შეამჩნევთ, რომ შეფერადება მოძრაობს ქვემოთ ხაზის 19,

613
00:32:58,000 --> 00:33:01,000
მაგრამ ლოგიკური გავლენა არის, რომ ხაზი 18

614
00:33:01,000 --> 00:33:06,000
ახლა დასრულდა შესრულებაში, ასე რომ, თუ ისევ აკრიფოთ "ბეჭდვის x"

615
00:33:06,000 --> 00:33:10,000
მე ახლა უნდა ნახოთ 1, და მართლაც, მე.

616
00:33:10,000 --> 00:33:14,000
ერთხელ, $ პერსონალი არის გზა GDB ახსენებს თქვენ

617
00:33:14,000 --> 00:33:17,000
რა ისტორიაში ანაბეჭდები ვართ, რომ თქვენ გავაკეთეთ.

618
00:33:17,000 --> 00:33:21,000
ახლა ნება მომეცით წავიდეთ წინ და ამობეჭდოთ Y, და მართლაც, Y არის ზოგიერთი გიჟები ღირებულება, ისევე,

619
00:33:21,000 --> 00:33:24,000
მაგრამ არა დიდი გარიგება, რადგან ხაზი 19 ჩვენ შესახებ დაავალოს ეს

620
00:33:24,000 --> 00:33:27,000
ღირებულება 2, ნება მომეცით, აკრიფოთ "შემდეგი" კიდევ ერთხელ.

621
00:33:27,000 --> 00:33:29,000
და ახლა ჩვენ შესახებ printf ხაზი.

622
00:33:29,000 --> 00:33:31,000
ნება მომეცით გავაკეთოთ ბეჭდვითი x.

623
00:33:31,000 --> 00:33:34,000
ნება მომეცით გავაკეთოთ ბეჭდვითი წ. სიმართლე, მე მიღების ცოტა დაღლილი დაბეჭდვის ამ.

624
00:33:34,000 --> 00:33:38,000
ნება მომეცით ნაცვლად აკრიფოთ "ჩვენების x" და "ჩვენების Y"

625
00:33:38,000 --> 00:33:41,000
და ახლა ყოველ ჯერზე მე აკრიფოთ ბრძანება მომავალში

626
00:33:41,000 --> 00:33:45,000
მე იქნება შეახსენა, რა X და Y, რა X და Y, რა x და y.

627
00:33:45,000 --> 00:33:48,000
>> შემიძლია ასევე, როგორც განზე ტიპის "ინფორმაცია ადგილობრივები."

628
00:33:48,000 --> 00:33:50,000
ინფორმაცია არის სპეციალური ბრძანება.

629
00:33:50,000 --> 00:33:52,000
ადგილობრივები ნიშნავს, რომ იგი გვიჩვენებს ჩემთვის ადგილობრივი ცვლადები.

630
00:33:52,000 --> 00:33:55,000
Just შემთხვევაში მე დაგვავიწყდეს ან ეს გიჟები, რთული ფუნქცია

631
00:33:55,000 --> 00:33:57,000
რომ მე ან ვინმე წერდა ინფორმაცია ადგილობრივები გეტყვით

632
00:33:57,000 --> 00:34:00,000
რისთვის არის ყველა ადგილობრივი ცვლადები შიგნით ამ ადგილობრივი ფუნქცია

633
00:34:00,000 --> 00:34:03,000
რომ თქვენ შეიძლება აინტერესებს, თუ გსურთ poke გარშემო.

634
00:34:03,000 --> 00:34:07,000
ახლა, printf დაახლოებით შეასრულოს, ნება მომეცით, წავიდეთ წინ და მხოლოდ ტიპის "შემდეგი".

635
00:34:07,000 --> 00:34:10,000
იმის გამო, რომ ჩვენ ამ გარემოში ჩვენ რეალურად არ ხედავს იგი

636
00:34:10,000 --> 00:34:14,000
შეასრულოს ქვემოთ აქ, მაგრამ შეამჩნია ის მიღების პატარა mangled აქ.

637
00:34:14,000 --> 00:34:17,000
მაგრამ შენიშნავს უმთავრესი ეკრანზე იქ,

638
00:34:17,000 --> 00:34:21,000
ამიტომ არ სრულყოფილი პროგრამა აქ, მაგრამ ეს okay, რადგან მე ყოველთვის შეგიძლიათ poke გარშემო

639
00:34:21,000 --> 00:34:23,000
გამოყენებით ბეჭდვითი თუ მინდა.

640
00:34:23,000 --> 00:34:26,000
>> ნება მომეცით აკრიფოთ შემდეგი ერთხელ და ახლა აქ საინტერესო ნაწილი.

641
00:34:26,000 --> 00:34:29,000
ამ დროისთვის ამბავი Y არის 2, და x არის 1,

642
00:34:29,000 --> 00:34:32,000
როგორც შესთავაზა აქ, და კიდევ ერთხელ,

643
00:34:32,000 --> 00:34:35,000
მიზეზი ეს ავტომატურად ჩვენებისას ახლა არის იმიტომ, რომ მე გამოიყენება ბრძანება

644
00:34:35,000 --> 00:34:40,000
ჩვენების x და y ჩვენების, ამიტომ მომენტში მე აკრიფოთ შემდეგი

645
00:34:40,000 --> 00:34:43,000
თეორიულად x და y უნდა გახდეს swapped.

646
00:34:43,000 --> 00:34:45,000
ახლა ჩვენ უკვე ვიცით, რომ არ იქნება იმ შემთხვევაში,

647
00:34:45,000 --> 00:34:49,000
მაგრამ ჩვენ ვხედავთ მომენტში როგორ შეგვიძლია ჩაყვინთვის უფრო ღრმა უნდა გაერკვნენ, თუ რატომ, რომ მართალია.

648
00:34:49,000 --> 00:34:54,000
შემდეგი, სამწუხაროდ, Y კვლავ 2 და x კვლავ 1, და შემიძლია დავადასტურო იმდენი.

649
00:34:54,000 --> 00:34:56,000
ბეჭდვის x, ბეჭდვითი წ.

650
00:34:56,000 --> 00:34:59,000
მართლაც, არ შევცვალე უკვე მოხდა სინამდვილეში, ასე რომ დავიწყოთ ამ დასრულდა.

651
00:34:59,000 --> 00:35:01,000
ცხადია swap-ის ბრალია.

652
00:35:01,000 --> 00:35:04,000
მოდით ნაცვლად აკრიფოთ "Run" კიდევ ერთხელ.

653
00:35:04,000 --> 00:35:07,000
ნება მომეცით აღვნიშნო დიახ, მინდა გადატვირთეთ იგი თავიდანვე, შეიყვანოთ.

654
00:35:07,000 --> 00:35:09,000
>> ახლა დავბრუნდი up at ხაზი 18.

655
00:35:09,000 --> 00:35:11,000
ახლა შეამჩნია x და y არიან ნაგვის ღირებულებების ერთხელ.

656
00:35:11,000 --> 00:35:15,000
შემდეგი, შემდეგი, შემდეგი, მომდევნო.

657
00:35:15,000 --> 00:35:17,000
თუ მე მოგწყინდება შემიძლია ასევე უნდა აკრიფოთ N მომავალი.

658
00:35:17,000 --> 00:35:21,000
შეგიძლიათ abbreviate მას უმოკლეს თანმიმდევრობა სიმბოლო.

659
00:35:21,000 --> 00:35:23,000
სვოპი არის გატეხილი.

660
00:35:23,000 --> 00:35:25,000
მოდით Dive in, ასე ნაცვლად აკრეფის შემდეგი,

661
00:35:25,000 --> 00:35:30,000
ახლა მე ვაპირებ აკრიფოთ ნაბიჯი ისე, რომ მე სტეპინგზე შიგნით ამ ფუნქციის

662
00:35:30,000 --> 00:35:33,000
ასე რომ შემიძლია გავლა, ასე რომ მე მოხვდა ნაბიჯი და მხოლოდ შემდეგ შეიყვანოთ.

663
00:35:33,000 --> 00:35:37,000
გაითვალისწინეთ, რომ შეფერადება jumps ქვემოთ ქვედა ჩემი პროგრამის ხაზი 36.

664
00:35:37,000 --> 00:35:39,000
ახლა რა ადგილობრივი ცვლადები?

665
00:35:39,000 --> 00:35:41,000
ინფორმაცია ადგილობრივები.

666
00:35:41,000 --> 00:35:43,000
არაფერი უბრალოდ არავის გაუკეთებია რადგან ჩვენ არ შემოსული, რომ ხაზი,

667
00:35:43,000 --> 00:35:47,000
მოდით წავიდეთ წინ და ვთქვათ "შემდეგი".

668
00:35:47,000 --> 00:35:50,000
ახლა ჩვენ, როგორც ჩანს, აქვს tmp, ბეჭდვითი tmp.

669
00:35:50,000 --> 00:35:52,000
Garbage ღირებულება, არა? ვფიქრობ ასე.

670
00:35:52,000 --> 00:35:55,000
როგორ შესახებ ბეჭდვა, ბეჭდვითი ბ, 1 და 2?

671
00:35:55,000 --> 00:35:58,000
In მომენტში, როგორც კი აკრიფოთ შემდეგი ერთხელ

672
00:35:58,000 --> 00:36:02,000
tmp აპირებს მიიღოს ღირებულება 1, იმედია,

673
00:36:02,000 --> 00:36:05,000
რადგან tmp აპირებს ენიჭება ღირებულების.

674
00:36:05,000 --> 00:36:08,000
>> ახლა მოდით ბეჭდვა, ბეჭდვითი ბ,

675
00:36:08,000 --> 00:36:11,000
მაგრამ ახლა ბეჭდვა tmp, და ეს მართლაც 1.

676
00:36:11,000 --> 00:36:14,000
ნება მომეცით გავაკეთოთ შემდეგი. ნება მომეცით გავაკეთოთ შემდეგი.

677
00:36:14,000 --> 00:36:16,000
მე დავამთავრე swap ფუნქცია.

678
00:36:16,000 --> 00:36:19,000
მე ჯერ კიდევ შიგნით ეს ხაზი 40, ნება მომეცით, ბეჭდვა,

679
00:36:19,000 --> 00:36:22,000
ბეჭდვითი B, და არ მაინტერესებს რა tmp არის.

680
00:36:22,000 --> 00:36:27,000
როგორც ჩანს swap არის სწორი, როდესაც საქმე შევცვალე და ბ.

681
00:36:27,000 --> 00:36:31,000
მაგრამ თუ მე ახლა აკრიფოთ შემდეგი, მე ხტომა თავში ხაზი 25,

682
00:36:31,000 --> 00:36:34,000
და რა თქმა უნდა, თუ ტიპის x და ბეჭდვითი Y

683
00:36:34,000 --> 00:36:38,000
ისინი კვლავ უცვლელია, ამიტომ ჩვენ არ დაფიქსირდა პრობლემა.

684
00:36:38,000 --> 00:36:41,000
მაგრამ diagnostically ახლა ალბათ ამ GDB პროგრამა

685
00:36:41,000 --> 00:36:44,000
ჩვენ მინიმუმ მიღებული ერთი ნაბიჯით მიუახლოვდება გაგება

686
00:36:44,000 --> 00:36:47,000
რა ხდება არასწორი გარეშე litter ჩვენი კოდი გამოსული printf აქ,

687
00:36:47,000 --> 00:36:50,000
printf აქ, printf აქ და შემდეგ გაშვება ვერ ისევ და ისევ

688
00:36:50,000 --> 00:36:52,000
ცდილობს გაერკვნენ რა ხდება არასწორი.

689
00:36:52,000 --> 00:36:55,000
>> მე ვაპირებ წავიდეთ წინ და დატოვა ამ საერთოდ ერთად დატოვა.

690
00:36:55,000 --> 00:36:57,000
იგი აპირებს, მაშინ ამბობენ, "Quit მაინც?" დიახ.

691
00:36:57,000 --> 00:37:00,000
ახლა დავბრუნდი, ჩემი ჩვეულებრივი სწრაფი და მე გაკეთდეს გამოყენებით GDB.

692
00:37:00,000 --> 00:37:03,000
როგორც განზე, თქვენ არ უნდა გამოვიყენოთ ამ-TUI დროშა.

693
00:37:03,000 --> 00:37:07,000
ფაქტობრივად, თუ გამომრჩეს ეს თქვენ არსებითად ქვედა ნახევარში ეკრანზე.

694
00:37:07,000 --> 00:37:11,000
თუ მე აკრიფეთ შესვენების ძირითადი და შემდეგ აწარმოებს

695
00:37:11,000 --> 00:37:15,000
შემიძლია კვლავ აწარმოებს ჩემი პროგრამით, მაგრამ თუ რას გავაკეთებ უფრო textually

696
00:37:15,000 --> 00:37:18,000
უბრალოდ ეჩვენებინა მიმდინარე ხაზს ერთ დროს.

697
00:37:18,000 --> 00:37:21,000
-TUI, ტექსტური ინტერფეისი,

698
00:37:21,000 --> 00:37:25,000
მხოლოდ გიჩვენებთ მეტი პროგრამის ერთდროულად, რომელიც ალბათ ცოტა კონცეპტუალურად ადვილია.

699
00:37:25,000 --> 00:37:27,000
მაგრამ მართლაც, მე შემიძლია უბრალოდ შემდეგი, შემდეგი, მომდევნო,

700
00:37:27,000 --> 00:37:30,000
და მე ვაპირებ ვხედავ ერთ ხაზს იმ დროს, და თუ ნამდვილად გვინდა, რომ რა ხდება

701
00:37:30,000 --> 00:37:35,000
შემიძლია ტიპების სიას და ვნახოთ მთელი bunch of მეზობელ ხაზები.

702
00:37:35,000 --> 00:37:39,000
>> იქ ვიდეო რომ ჩვენ ვთხოვეთ, რომ თქვენ უყუროთ პრობლემის ადგენს 3

703
00:37:39,000 --> 00:37:43,000
რომელშიც Nate მოიცავს ზოგიერთი intricacies of GDB,

704
00:37:43,000 --> 00:37:46,000
და ეს არის ერთ ერთი იმ რამ, პატიოსნად, სადაც რამდენიმე არასამთავრობო ტრივიალური პროცენტული თქვენ

705
00:37:46,000 --> 00:37:49,000
არასდროს შეეხოთ GDB, და რომ იქნება ცუდი რამ

706
00:37:49,000 --> 00:37:53,000
რადგან სიტყვასიტყვით თქვენ დასრულდება მდე ხარჯავს მეტი ხნის შემდეგ ამ სემესტრში

707
00:37:53,000 --> 00:37:56,000
მისდევდნენ ქვემოთ შეცდომები მაშინ იქნებოდა თუ თქვენც არ დაიშურებთ, რომ ნახევარ საათში / საათობრივად

708
00:37:56,000 --> 00:38:00,000
ამ კვირაში და შემდეგი სწავლის მისაღებად კომფორტულად GDB.

709
00:38:00,000 --> 00:38:02,000
Printf იყო თქვენი მეგობარი.

710
00:38:02,000 --> 00:38:05,000
GDB უნდა იყოს თქვენი მეგობარი.

711
00:38:05,000 --> 00:38:08,000
>> ნებისმიერი შეკითხვა GDB?

712
00:38:08,000 --> 00:38:12,000
და აქ სწრაფი სიაში ზოგიერთი ყველაზე ძლიერი და სასარგებლო ბრძანებები.

713
00:38:12,000 --> 00:38:15,000
Yeah. >> შეგიძლიათ ბეჭდვა სტრიქონი?

714
00:38:15,000 --> 00:38:17,000
შეგიძლიათ ბეჭდვა სტრიქონი? აბსოლუტურად.

715
00:38:17,000 --> 00:38:19,000
იგი არ უნდა იყოს მხოლოდ რიცხვებით.

716
00:38:19,000 --> 00:38:22,000
თუ ცვლადი s არის სიმებიანი მხოლოდ ჩაწერეთ ბეჭდვითი s.

717
00:38:22,000 --> 00:38:24,000
იგი გაჩვენებთ რა რომ string ცვლადის.

718
00:38:24,000 --> 00:38:26,000
[Inaudible-სტუდენტი]

719
00:38:26,000 --> 00:38:28,000
ეს მოგცემთ მისამართს და სიმებიანი თავად.

720
00:38:28,000 --> 00:38:32,000
იგი გაჩვენებთ ორივე.

721
00:38:32,000 --> 00:38:34,000
და ერთი რამ ბოლო, მხოლოდ იმიტომ, რომ ეს არის კარგი იცოდეს ძალიან.

722
00:38:34,000 --> 00:38:37,000
Backtrace და ჩარჩო, ნება მომეცით ჩაყვინთვის შევიდა ამ ერთი ბოლო დროს,

723
00:38:37,000 --> 00:38:39,000
იმავე ზუსტი პროგრამა GDB.

724
00:38:39,000 --> 00:38:44,000
ნება მომეცით წავიდეთ წინ და აწარმოებს ტექსტური ინტერფეისი ვერსია,

725
00:38:44,000 --> 00:38:46,000
შესვენება ძირითადი.

726
00:38:46,000 --> 00:38:49,000
ნება მომეცით წავიდეთ წინ და აწარმოებს ერთხელ. აქ ვარ.

727
00:38:49,000 --> 00:38:55,000
ახლა ნება მომეცით წასვლა შემდეგი, შემდეგი, შემდეგი, შემდეგი, მომდევნო, ნაბიჯი, შეიყვანოთ.

728
00:38:55,000 --> 00:39:00,000
>> და ახლა ვარაუდობენ, მე ახლა swap განზრახ, მაგრამ მე როგორც "Damn, რა იყო ღირებულების x?"

729
00:39:00,000 --> 00:39:02,000
მე ვერ გავაკეთებ x უქმნით.

730
00:39:02,000 --> 00:39:05,000
მე ვერ გავაკეთო Y რადგან ისინი არ ფარგლებს.

731
00:39:05,000 --> 00:39:07,000
ისინი არ კონტექსტში, მაგრამ პრობლემა არ არის.

732
00:39:07,000 --> 00:39:09,000
შემიძლია აკრიფოთ backtrace.

733
00:39:09,000 --> 00:39:13,000
რომელიც აჩვენებს ჩემთან ყველა ფუნქცია, რაც არ დასაჯეს მდე ამ მომენტში.

734
00:39:13,000 --> 00:39:16,000
გაითვალისწინეთ, რომ ერთი წლის ბოლოში, მთავარ, ხაზები up ძირითადი

735
00:39:16,000 --> 00:39:18,000
მყოფი ბოლოში ჩვენი სურათს აქ.

736
00:39:18,000 --> 00:39:22,000
ის ფაქტი, რომ swap მაღლა დგას ეს ხაზები ერთად swap მყოფი ზემოთ ის მეხსიერების აქ,

737
00:39:22,000 --> 00:39:26,000
და თუ მინდა დავუბრუნდეთ მთავარ დროებით შემიძლია ვთქვა "ფარგლებში."

738
00:39:26,000 --> 00:39:30,000
რა ნომერი? მთავარი არის ჩარჩო # 1.

739
00:39:30,000 --> 00:39:32,000
მე ვაპირებ წავიდეთ წინ და ვთქვათ "ჩარჩოში 1."

740
00:39:32,000 --> 00:39:36,000
>> ახლა დავბრუნდი მთავარ და შემიძლია ბეჭდვა x, და შემიძლია ბეჭდვა Y,

741
00:39:36,000 --> 00:39:40,000
მაგრამ მე ვერ ბეჭდვა ან ბ.

742
00:39:40,000 --> 00:39:43,000
მაგრამ მე შემიძლია, თუ ვიტყვი, "Okay, დაველოდოთ წუთში. სად იყო swap?"

743
00:39:43,000 --> 00:39:46,000
ნება მომეცით წავიდეთ წინ და ვთქვათ "ჩარჩო 0."

744
00:39:46,000 --> 00:39:48,000
ახლა დავბრუნდი, სადაც მე მინდა იყოს, და როგორც განზე,

745
00:39:48,000 --> 00:39:52,000
არსებობს სხვა ბრძანებები ძალიან, მოსწონს თუ თქვენ ნამდვილად მისაღებად შეწუხებული აკრეფით შემდეგი, შემდეგი, შემდეგი, მომდევნო,

746
00:39:52,000 --> 00:39:56,000
შეგიძლიათ ზოგადად ამბობენ რამ, როგორიცაა "შემდეგი 10," და რომ იქნება დაიხევს მეშვეობით მომდევნო 10 ხაზები.

747
00:39:56,000 --> 00:39:59,000
თქვენ ასევე შეგიძლიათ წერენ "გააგრძელებს", როდესაც თქვენ ნამდვილად მისაღებად გადაღალა სტეპინგზე საშუალება.

748
00:39:59,000 --> 00:40:05,000
გაგრძელება იქნება აწარმოებს თქვენი პროგრამის შეუწყვეტლად სანამ გაიტანა კიდევ ერთი breakpoint,

749
00:40:05,000 --> 00:40:07,000
თუ მარყუჟი ან შეამცირონ ქვემოთ თქვენს პროგრამას.

750
00:40:07,000 --> 00:40:11,000
>> ამ შემთხვევაში ჩვენ გააგრძელა ბოლომდე, და პროგრამის დასრულების ნორმალურად.

751
00:40:11,000 --> 00:40:13,000
ეს არის ლამაზი გზა, inferior პროცესში.

752
00:40:13,000 --> 00:40:16,000
უბრალოდ თქვენი პროგრამის დასრულების ნორმალურად.

753
00:40:16,000 --> 00:40:24,000
უფრო, რომ ვიდეო და გამართვის სხდომები მოვა.

754
00:40:24,000 --> 00:40:26,000
ეს იყო ბევრი.

755
00:40:26,000 --> 00:40:35,000
ავიღოთ ჩვენი 5 წუთიანი შესვენება აქ, და ჩვენ დაბრუნების structs და ფაილები.

756
00:40:35,000 --> 00:40:38,000
>> თუ თქვენ არ dived შევიდა ამ კვირის pset უკვე

757
00:40:38,000 --> 00:40:41,000
თქვენ იცით, რომ ჩვენ გამოიყენონ განაწილების კოდი,

758
00:40:41,000 --> 00:40:45,000
კოდის რომ ჩვენ უზრუნველყოფს თქვენ, როგორც ამოსავალი წერტილი, ახალი ტექნიკით.

759
00:40:45,000 --> 00:40:50,000
კერძოდ, ჩვენ გააცნო ამ ახალი სიტყვით მოუწოდა struct, სტრუქტურული,

760
00:40:50,000 --> 00:40:53,000
ასე, რომ ჩვენ შეგვიძლია შევქმნათ ადრინდელს ცვლადი ჯიშები.

761
00:40:53,000 --> 00:40:57,000
ჩვენ ასევე გააცნო ცნება ფაილის I / O, ფაილის და ჩასათვლელი,

762
00:40:57,000 --> 00:41:00,000
და ეს იმდენად, რომ ჩვენ შეგვიძლია გადარჩენა სახელმწიფო

763
00:41:00,000 --> 00:41:03,000
თქვენი Scramble საბჭოს ფაილი დისკი

764
00:41:03,000 --> 00:41:06,000
ისე, რომ სწავლების პრაქტიკის და მე მესმის

765
00:41:06,000 --> 00:41:09,000
რა ხდება შიგნით თქვენი პროგრამის გარეშე ხელით ითამაშებს

766
00:41:09,000 --> 00:41:11,000
ათობით games of Scramble.

767
00:41:11,000 --> 00:41:13,000
ჩვენ შეგვიძლია ამის გაკეთება უფრო automatedly.

768
00:41:13,000 --> 00:41:18,000
>> ეს იდეა struct წყვეტს საკმაოდ მყარი პრობლემა.

769
00:41:18,000 --> 00:41:21,000
დავუშვათ, რომ ჩვენ გვინდა განვახორციელოთ ზოგიერთი პროგრამა

770
00:41:21,000 --> 00:41:25,000
რომ როგორღაც ინახება ინფორმაციას სტუდენტები,

771
00:41:25,000 --> 00:41:28,000
და სტუდენტები შესაძლოა, მაგალითად, პირადობის მოწმობა, სახელი

772
00:41:28,000 --> 00:41:31,000
და სახლის ადგილი, როგორიცაა ჰარვარდი, ამიტომ ეს 3 ცალი ინფორმაცია

773
00:41:31,000 --> 00:41:34,000
ჩვენ გვინდა შევინარჩუნოთ გარშემო, ნება მომეცით, წავიდეთ წინ და დავიწყოთ წერა პატარა პროგრამა აქ,

774
00:41:34,000 --> 00:41:38,000
მოიცავს stdio.h.

775
00:41:38,000 --> 00:41:42,000
ნება მომეცით გავაკეთოთ მოიცავს cs50.h.

776
00:41:42,000 --> 00:41:44,000
და შემდეგ ჩემი მთავარი ფუნქცია.

777
00:41:44,000 --> 00:41:46,000
მე არ შეწუხება ნებისმიერი ბრძანება ხაზი არგუმენტები,

778
00:41:46,000 --> 00:41:49,000
და აქ მინდა სტუდენტი, ამიტომ მე ვაპირებ ვთქვა

779
00:41:49,000 --> 00:41:54,000
სტუდენტმა სახელი, ამიტომ მე ვაპირებ ვთქვა "სიმებიანი სახელი."

780
00:41:54,000 --> 00:41:59,000
მაშინ მე ვაპირებ ვთქვა სტუდენტი ასევე აქვს პირადობის მოწმობა, ისე int id,

781
00:41:59,000 --> 00:42:03,000
და სტუდენტმა სახლში, ასე რომ მე ასევე აპირებს ამბობენ "სიმებიანი სახლი."

782
00:42:03,000 --> 00:42:06,000
მაშინ მე შეუკვეთოთ ამ ცოტა მეტი cleanly მოსწონს ეს.

783
00:42:06,000 --> 00:42:11,000
Okay, ახლა მაქვს 3 ცვლადები რომელთანაც წარმოადგინოს სტუდენტი, ისე "სტუდენტი."

784
00:42:11,000 --> 00:42:15,000
>> და ახლა მინდა populate ამ ფასეულობების, ნება მომეცით, წავიდეთ წინ და ვთქვათ რაღაც

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
სახელი აპირებს მიიღოს დავით.

787
00:42:21,000 --> 00:42:24,000
ვთქვათ სახლში აპირებს მიიღოს Mather,

788
00:42:24,000 --> 00:42:31,000
და შემდეგ მე ვაპირებ რაღაც თვითნებურად მოსწონს printf ("% s,

789
00:42:31,000 --> 00:42:37,000
რომლის ID არის% d, ცხოვრობს% s.

790
00:42:37,000 --> 00:42:41,000
და ახლა, რას მინდა შეაერთედ აქ, ერთი შემდეგ სხვა?

791
00:42:41,000 --> 00:42:47,000
სახელი, პირადობის მოწმობა, სახლში დაბრუნების 0.

792
00:42:47,000 --> 00:42:50,000
Okay, თუ მე ბრალია სადღაც აქ

793
00:42:50,000 --> 00:42:54,000
მე ვფიქრობ, ჩვენ გვაქვს საკმაოდ კარგი პროგრამა, რომელიც ინახავს ერთი სტუდენტი.

794
00:42:54,000 --> 00:42:57,000
რა თქმა უნდა, ეს არ არის ყველა, რომ საინტერესო. რა მოხდება, თუ მინდა 2 სტუდენტი?

795
00:42:57,000 --> 00:42:59,000
რომ არ დიდი გარიგება. შემიძლია მხარდასაჭერად 2 ადამიანი.

796
00:42:59,000 --> 00:43:03,000
ნება მომეცით წავიდეთ წინ და ითვალისწინებდეს ამ და ქვევით აქ,

797
00:43:03,000 --> 00:43:09,000
და შემიძლია ვთქვა, "id = 456" ვინმეს მოსწონს რობ რომელიც ცხოვრობს KIRKLAND.

798
00:43:09,000 --> 00:43:12,000
>> Okay, დაველოდოთ, მაგრამ მე ვერ ვუწოდებ ამ იგივე,

799
00:43:12,000 --> 00:43:15,000
და როგორც ჩანს მე ვაპირებ აქვს გადააკოპირეთ ეს,

800
00:43:15,000 --> 00:43:19,000
ნება მომეცით ვთქვა, რომ ეს იქნება დავითის ცვლადები,

801
00:43:19,000 --> 00:43:23,000
და ნება მომეცით კიდევ რამდენიმე ეგზემპლარი ამ ამისთვის რობ.

802
00:43:23,000 --> 00:43:27,000
ჩვენ მოვუწოდებთ ამ Rob-ს მაგრამ ეს არ არის იმუშავებს არის

803
00:43:27,000 --> 00:43:33,000
იმიტომ, რომ მე არ-დაველოდოთ, მოდით შეცვლის ჩემთვის ID1, name1 და house1.

804
00:43:33,000 --> 00:43:35,000
რობ იქნება 2, 2.

805
00:43:35,000 --> 00:43:42,000
მაქვს, რომ შეიცვალოს ეს აქ, აქ, აქ, აქ, აქ, აქ.

806
00:43:42,000 --> 00:43:45,000
დაველოდოთ, რა Tommy? მოდით ეს კიდევ ერთხელ გავაკეთოთ.

807
00:43:45,000 --> 00:43:49,000
ცხადია, თუ თქვენ ჯერ კიდევ ფიქრობს, რომ ეს არის კარგი გზა ამით, ეს არ,

808
00:43:49,000 --> 00:43:52,000
ასე კოპირება / პასტა ცუდი.

809
00:43:52,000 --> 00:43:55,000
მაგრამ ჩვენ მოგვარდება ამ ერთი კვირის წინ.

810
00:43:55,000 --> 00:43:59,000
>> რა იყო ჩვენი გამოსავალი, როცა გვინდოდა რამდენიმე ფაქტი იგივე მონაცემები ტიპის?

811
00:43:59,000 --> 00:44:01,000
[სტუდენტთა] მასივი.

812
00:44:01,000 --> 00:44:03,000
Array, ნება მომეცით, ცდილობენ გაწმენდა ამ მდე.

813
00:44:03,000 --> 00:44:07,000
ნება მომეცით გარკვეული ოთახი თვითონ ზედა, და ნება მომეცით ნაცვლად ამის გაკეთება აქ.

814
00:44:07,000 --> 00:44:12,000
ჩვენ მოვუწოდებთ ამ ხალხს, და ნაცვლად მე ვაპირებ ვთქვა "int პირადობის,"

815
00:44:12,000 --> 00:44:14,000
და მე ვაპირებ, რომ მხარი დაუჭირონ 3 ჩვენგანი ახლა.

816
00:44:14,000 --> 00:44:18,000
მე ვაპირებ ვთქვა "სიმებიანი სახელები," და მე მხარს დავუჭერთ 3 ჩვენგანი,

817
00:44:18,000 --> 00:44:22,000
და შემდეგ მე ვაპირებ ვთქვა "სიმებიანი სახლები," და მე ვაპირებ, რომ მხარი დაუჭირონ 3 ჩვენგანისთვის.

818
00:44:22,000 --> 00:44:26,000
ახლა აქ ნაცვლად დავით მიღების საკუთარი ლოკალური ცვლადები

819
00:44:26,000 --> 00:44:28,000
ჩვენ შეგვიძლია თავი დავაღწიოთ იმ.

820
00:44:28,000 --> 00:44:30,000
რომ თავს კარგად გრძნობს, რომ ჩვენ ამ გაწმენდა up.

821
00:44:30,000 --> 00:44:35,000
მე შემიძლია ვთქვა, მაშინ დავით იქნება [0] და names [0]

822
00:44:35,000 --> 00:44:38,000
სახლები [0].

823
00:44:38,000 --> 00:44:41,000
და შემდეგ Rob შეგვიძლია ანალოგიურად გადარჩენა ამ.

824
00:44:41,000 --> 00:44:46,000
მოდით დააყენა ამ ქვევით აქ, ამიტომ იგი აპირებს თვითნებურად იყოს პირადობის მოწმობა [1].

825
00:44:46,000 --> 00:44:50,000
ის იქნება სახელები [1],

826
00:44:50,000 --> 00:44:53,000
და მერე ბოლოს, სახლები [1].

827
00:44:53,000 --> 00:44:57,000
>> ჯერ კიდევ ცოტა რუტინული, და ახლა მე უნდა გაერკვნენ ამ გარეთ,

828
00:44:57,000 --> 00:45:03,000
ასე ვთქვათ "names [0], id [0], სახლები [0],

829
00:45:03,000 --> 00:45:06,000
და მოდით pluralize ამ.

830
00:45:06,000 --> 00:45:09,000
პირადობის, პირადობის, პირადობის მოწმობები.

831
00:45:09,000 --> 00:45:12,000
და ისევ, მე ამის გაკეთება, ამიტომ ისევ, მე უკვე resorting კოპირება / პასტა ერთხელ,

832
00:45:12,000 --> 00:45:14,000
ასე შანსი არსებობს სხვა გამოსავალი აქ.

833
00:45:14,000 --> 00:45:18,000
შემიძლია ალბათ გაწმენდა ამ up შემდგომი ერთად მარყუჟი ან რამე მაგდაგვარს,

834
00:45:18,000 --> 00:45:21,000
ასე მოკლედ, ეს პატარა უკეთესი, მაგრამ მაინც იგრძნობა

835
00:45:21,000 --> 00:45:24,000
მე resorting კოპირება / პასტა, მაგრამ ეს, მე აცხადებენ,

836
00:45:24,000 --> 00:45:27,000
არ არის ფუნდამენტურად უფლება გადაწყვეტა, რადგან

837
00:45:27,000 --> 00:45:29,000
რა, თუ ოდესმე ჩვენ გადაწყვიტოს იცით, რა?

838
00:45:29,000 --> 00:45:32,000
ჩვენ ნამდვილად უნდა შენახვის ელფოსტა დავით და რობ

839
00:45:32,000 --> 00:45:34,000
და ყველას ამ პროგრამაში.

840
00:45:34,000 --> 00:45:36,000
ჩვენ ასევე უნდა შესანახად ტელეფონის ნომრები.

841
00:45:36,000 --> 00:45:39,000
ჩვენ ასევე უნდა შესანახად საგანგებო საკონტაქტო ნომრები.

842
00:45:39,000 --> 00:45:41,000
ჩვენ გვყავს ყველა ამ ცალი მონაცემები, რომ ჩვენ გვინდა შეინახოს,

843
00:45:41,000 --> 00:45:43,000
ასე როგორ დადიხართ შესახებ აკეთებს, რომ?

844
00:45:43,000 --> 00:45:46,000
>> თქვენ გამოაცხადოს მეორე მასივი ზედა, და მერე ხელით დაამატოთ

845
00:45:46,000 --> 00:45:49,000
ელექტრონულ მისამართზე [0], ელექტრონული ფოსტის მისამართი [1]

846
00:45:49,000 --> 00:45:51,000
დავით და რობ და სხვ.

847
00:45:51,000 --> 00:45:56,000
მაგრამ ნამდვილად მხოლოდ ვარაუდი უდევს ამ დიზაინის

848
00:45:56,000 --> 00:45:59,000
რომ მე გამოყენებით პატივი სისტემის ვიცით, რომ

849
00:45:59,000 --> 00:46:03,000
[I] თითოეულ რამდენიმე კოლექტორები

850
00:46:03,000 --> 00:46:06,000
უბრალოდ ასე ხდება მიმართოს იგივე პირი,

851
00:46:06,000 --> 00:46:10,000
ასე [0] წელს პირადობის მოწმობები არის ნომერი 123,

852
00:46:10,000 --> 00:46:13,000
და მე ვაპირებ ვივარაუდოთ, რომ names [0]

853
00:46:13,000 --> 00:46:16,000
არის იგივე პირის სახელი და სახლები [0]

854
00:46:16,000 --> 00:46:21,000
არის იგივე პირი სახლში და ა.შ. ყველა სხვადასხვა მასივები, რომ შევქმნა.

855
00:46:21,000 --> 00:46:24,000
მაგრამ რომ არ არსებობს ფუნდამენტური კავშირი

856
00:46:24,000 --> 00:46:27,000
მათ შორის 3 ცალი ინფორმაციით, პირადობის მოწმობა, სახელის და სახლი,

857
00:46:27,000 --> 00:46:32,000
მიუხედავად იმისა, რომ პირი ვცდილობთ მოდელის ამ პროგრამაში არ არის მასივები.

858
00:46:32,000 --> 00:46:35,000
მასივები მხოლოდ ამ პროგრამული გზას აკეთებენ.

859
00:46:35,000 --> 00:46:38,000
რაც ჩვენ ნამდვილად გსურთ მოდელის ჩვენი პროგრამა არის პირი

860
00:46:38,000 --> 00:46:41,000
მოსწონს დავით, პირი მოსწონს რობ შიგნით, რომლის

861
00:46:41,000 --> 00:46:46,000
ან encapsulating არის სახელი და ID და სახლი.

862
00:46:46,000 --> 00:46:49,000
>> შეგვიძლია რაღაცნაირად გამოხატონ ამ იდეას encapsulation

863
00:46:49,000 --> 00:46:52,000
რომლითაც ადამიანს აქვს პირადობის მოწმობა, სახელის და სახლი

864
00:46:52,000 --> 00:46:55,000
და არ მიმართავს მართლაც ამ hack რომლითაც ჩვენ უბრალოდ

865
00:46:55,000 --> 00:46:58,000
ენდობა, რომ bracket რაღაც

866
00:46:58,000 --> 00:47:02,000
ეხება იგივე ადამიანის პირის თითოეულ ამ განსხვავებული კოლექტორები?

867
00:47:02,000 --> 00:47:04,000
ჩვენ შეგვიძლია რეალურად ამის გაკეთება.

868
00:47:04,000 --> 00:47:08,000
ნება მომეცით წასვლა ზემოთ მთავარ ახლა, და ნება მომეცით შექმნას საკუთარი მონაცემები ტიპის

869
00:47:08,000 --> 00:47:10,000
ამისთვის ნამდვილად პირველად.

870
00:47:10,000 --> 00:47:14,000
ჩვენ გამოიყენება ამ ტექნიკის წელს Scramble,

871
00:47:14,000 --> 00:47:17,000
მაგრამ აქ მე ვაპირებ წავიდეთ წინ და შექმნას მონაცემთა ტიპის,

872
00:47:17,000 --> 00:47:19,000
და იცით, რა, მე ვაპირებ მოვუწოდო მას სტუდენტი ან პირი,

873
00:47:19,000 --> 00:47:23,000
და მე ვაპირებ გამოვიყენო typedef ამისთვის განსაზღვროს ტიპის.

874
00:47:23,000 --> 00:47:25,000
მე ვაპირებ ვთქვა, რომ ეს არის სტრუქტურა,

875
00:47:25,000 --> 00:47:29,000
და მაშინ ეს სტრუქტურა იქნება ტიპის სტუდენტი, ჩვენ ვთქვათ,

876
00:47:29,000 --> 00:47:31,000
მიუხედავად იმისა, რომ ეს პატარა დათარიღებული არის ჩემთვის.

877
00:47:31,000 --> 00:47:33,000
ჩვენ ვთქვათ "int id."

878
00:47:33,000 --> 00:47:35,000
ჩვენ ვიტყვით, "სიმებიანი სახელი."

879
00:47:35,000 --> 00:47:37,000
მაშინ ჩვენ ვიტყვით, "სიმებიანი სახლი"

880
00:47:37,000 --> 00:47:40,000
ახლა ბოლოსთვის ამ რამდენიმე ხაზი კოდი

881
00:47:40,000 --> 00:47:45,000
მე ახლახან ისწავლება clang, რომ არსებობს

882
00:47:45,000 --> 00:47:49,000
მონაცემები ტიპის გარდა ints, გარდა სიმები, გარდა ორადგილიანი, გარდა მოძრავი.

883
00:47:49,000 --> 00:47:54,000
>> როგორც ამ მომენტში დროში ხაზი 11, იქ არის ახალი ტიპის მონაცემის მოუწოდა სტუდენტებს,

884
00:47:54,000 --> 00:47:58,000
და ახლა შემიძლია განვაცხადო სტუდენტი ცვლადი სადმე მინდა,

885
00:47:58,000 --> 00:48:01,000
ნება მომეცით, გადახვევა ქვემოთ აქ ხალხს.

886
00:48:01,000 --> 00:48:05,000
ახლა შემიძლია დავაღწიოთ ამ და შემიძლია დაბრუნდეს ქვემოთ დავით აქ,

887
00:48:05,000 --> 00:48:10,000
და დავით შემიძლია რეალურად აცხადებენ, რომ დავით,

888
00:48:10,000 --> 00:48:13,000
ჩვენ შეგვიძლია სიტყვასიტყვით ასახელებს ცვლადი შემდეგ თავს,

889
00:48:13,000 --> 00:48:16,000
იქნება ტიპის სტუდენტი.

890
00:48:16,000 --> 00:48:18,000
ეს შეიძლება ცოტა უცნაური, მაგრამ ეს არ არის ყველა, რომ სხვადასხვა

891
00:48:18,000 --> 00:48:22,000
საწყისი გამოცხადების რაღაც როგორც int ან string ან float.

892
00:48:22,000 --> 00:48:24,000
უბრალოდ ასე ხდება ე.წ. სტუდენტი ახლა,

893
00:48:24,000 --> 00:48:28,000
და თუ მინდა დააყენა რაღაც შიგნით ამ სტრუქტურის

894
00:48:28,000 --> 00:48:31,000
მე ახლა უნდა გამოვიყენოთ ახალი ნაჭერი სინტაქსი, მაგრამ ეს საკმაოდ მარტივია,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "დავითი" დედაქალაქში D,

896
00:48:39,000 --> 00:48:42,000
და david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
და ახლა შემიძლია დავაღწიოთ ამ პერსონალის აქ.

898
00:48:46,000 --> 00:48:51,000
Notice ჩვენ ახლა დიზაინი ჩვენი პროგრამა მართლაც ბევრად უკეთესი გზა

899
00:48:51,000 --> 00:48:54,000
in, რომ ახლა ჩვენი პროგრამა ასახავს რეალურ სამყაროში.

900
00:48:54,000 --> 00:48:57,000
>> არსებობს რეალურ სამყაროში ცნება პირი ან სტუდენტი.

901
00:48:57,000 --> 00:49:02,000
აქ არის C ვერსია პირის ან უფრო კონკრეტულად სტუდენტი.

902
00:49:02,000 --> 00:49:05,000
შიგნით რომ პირი არის ამ შესაბამის მახასიათებლებს,

903
00:49:05,000 --> 00:49:10,000
ID, სახელი და სახლი, ასე რობ არსებითად ხდება იგივე ქვემოთ აქ,

904
00:49:10,000 --> 00:49:14,000
ასე სტუდენტი ძარცვა, და ახლა rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "რობ".

906
00:49:17,000 --> 00:49:20,000
ის ფაქტი, რომ ცვლადი ეწოდება რობ არის ერთგვარი უაზრო.

907
00:49:20,000 --> 00:49:22,000
ჩვენ შეგვეძლო უწოდა x ან y ან z.

908
00:49:22,000 --> 00:49:25,000
ჩვენ მხოლოდ დასახელებული ეს რობ იყოს semantically თანმიმდევრული,

909
00:49:25,000 --> 00:49:28,000
მაგრამ ნამდვილად სახელია შიგნით ამ სფეროში თავად,

910
00:49:28,000 --> 00:49:30,000
ახლა მე ამ.

911
00:49:30,000 --> 00:49:33,000
ეს ძალიან არ იგრძნონ საუკეთესო დიზაინის, რომ მე მძიმე კოდირებული დავით.

912
00:49:33,000 --> 00:49:35,000
მე მძიმე კოდირებული რობ.

913
00:49:35,000 --> 00:49:39,000
და კიდევ მაქვს მიმართავს ზოგიერთი და ჩასვით ყოველ ჯერზე მინდა ახალი ცვლადები.

914
00:49:39,000 --> 00:49:43,000
უფრო მეტიც, მე უნდა სავარაუდოდ მისცეს თითოეულ ამ ცვლადის სახელი,

915
00:49:43,000 --> 00:49:46,000
მიუხედავად იმისა, რომ მე გაცილებით მეტად აღწერს ამ ცვლადების

916
00:49:46,000 --> 00:49:48,000
 მეტი generically როგორც სტუდენტებს.

917
00:49:48,000 --> 00:49:52,000
>> ახლა ჩვენ შეგვიძლია შერწყმა იდეების რომ არ მუშაობს კარგად ჩვენთვის

918
00:49:52,000 --> 00:49:56,000
და ნაცვლად ამბობენ, "თქვენ იცით, რა, მომეცი ცვლადში სტუდენტები,

919
00:49:56,000 --> 00:50:01,000
და მოდით არ ეს იყოს ზომა 3, "ამიტომაც შემიძლია დახვეწა ამ შემდგომი,

920
00:50:01,000 --> 00:50:04,000
დავაღწიოთ ხელით განაცხადა დავით,

921
00:50:04,000 --> 00:50:08,000
და შემიძლია ვთქვა, ნაცვლად რაღაც სტუდენტებს [0] აქ.

922
00:50:08,000 --> 00:50:11,000
მე შემიძლია ვთქვა, მაშინ სტუდენტები [0] აქ,

923
00:50:11,000 --> 00:50:14,000
სტუდენტებს [0] აქ, და ა.შ., და შემიძლია წასვლა გარშემო

924
00:50:14,000 --> 00:50:16,000
და გაწმენდა რომ up for რობ.

925
00:50:16,000 --> 00:50:19,000
მე შეიძლება წავიდეს შესახებ არის იქნებ დასძინა loop

926
00:50:19,000 --> 00:50:23,000
და გამოყენებით GetString და GetInt რეალურად მიიღოთ ამ ფასეულობათა მომხმარებლის.

927
00:50:23,000 --> 00:50:27,000
შემეძლო წასვლა დაახლოებით დასძინა მუდმივი რადგან ეს ზოგადად ცუდი პრაქტიკა

928
00:50:27,000 --> 00:50:29,000
მძიმე კოდი ზოგიერთი თვითნებური ხმების მოსწონს 3 უფლება აქ

929
00:50:29,000 --> 00:50:33,000
და მაშინ უბრალოდ გვახსოვდეს, რომ თქვენ უნდა დააყენოს არა უმეტეს 3 სტუდენტი იყო.

930
00:50:33,000 --> 00:50:36,000
ეს, ალბათ, უმჯობესია გამოვიყენოთ # განსაზღვრავს ზედა ჩემი ფაილი

931
00:50:36,000 --> 00:50:40,000
და ფაქტორი, რომ, ასე ნამდვილად, მინდა წავიდეთ წინ და განზოგადება ამ.

932
00:50:40,000 --> 00:50:43,000
>> ნება მომეცით გახსენით მაგალითად რომ შორის დღევანდელი

933
00:50:43,000 --> 00:50:46,000
მაგალითები წინასწარ, structs1.

934
00:50:46,000 --> 00:50:49,000
ეს არის უფრო სრულყოფილი პროგრამა, რომელიც იყენებს # განსაზღვროს აქ

935
00:50:49,000 --> 00:50:51,000
და ამბობს, ჩვენ ვაპირებთ აქვს 3 სტუდენტი იყოს.

936
00:50:51,000 --> 00:50:54,000
აქ მე გამოცხადების კლასის ღირებულების სტუდენტები,

937
00:50:54,000 --> 00:50:57,000
ასე საკლასო სტუდენტთა და ახლა მე გამოყენებით loop

938
00:50:57,000 --> 00:51:00,000
უბრალოდ, რათა კოდი უფრო ელეგანტური, populate კლასის

939
00:51:00,000 --> 00:51:05,000
ერთად მომხმარებლის input, ასე iterate საწყისი i = 0 on მდე სტუდენტი, რომელიც 3.

940
00:51:05,000 --> 00:51:07,000
და მერე შეეკითხება მომხმარებელს ამ ვერსია

941
00:51:07,000 --> 00:51:10,000
 რა სტუდენტის პირადობის მოწმობა, და მივიღო იგი GetInt.

942
00:51:10,000 --> 00:51:13,000
რა არის სტუდენტის სახელი და შემდეგ მივიღებ იგი GetString.

943
00:51:13,000 --> 00:51:15,000
რა არის სტუდენტის სახლში? მივიღებ იგი GetString.

944
00:51:15,000 --> 00:51:19,000
და მერე ბოლოში აქ უბრალოდ შეცვლა გადაწყვიტა

945
00:51:19,000 --> 00:51:22,000
როგორ მე დაბეჭდვის ამ გარეთ და რეალურად გამოიყენოს მარყუჟის,

946
00:51:22,000 --> 00:51:24,000
და ვინ ვარ მე დაბეჭდვის?

947
00:51:24,000 --> 00:51:27,000
თანახმად კომენტარი მე დაბეჭდვის არავის Mather,

948
00:51:27,000 --> 00:51:30,000
და ეს ასე რობ და ტომი და სხვ-რეალურად Tommy წელს Mather.

949
00:51:30,000 --> 00:51:34,000
ტომი და დავით იქნება დაბეჭდილი ამ შემთხვევაში, მაგრამ რამდენად არის ეს სამუშაო?

950
00:51:34,000 --> 00:51:40,000
ჩვენ არ გვინახავს ამ ფუნქციის ადრე, მაგრამ მიიღოს ამოიცნობთ, თუ რა ეს იმას.

951
00:51:40,000 --> 00:51:42,000
ადარებს სტრიქონები.

952
00:51:42,000 --> 00:51:45,000
>> ეს პატარა არასამთავრობო აშკარა როგორ ადარებს სიმები რადგან თურმე

953
00:51:45,000 --> 00:51:49,000
თუ ის დააბრუნებს 0, რაც იმას ნიშნავს სტრიქონები ტოლია.

954
00:51:49,000 --> 00:51:53,000
თუ ის დააბრუნებს -1 ეს ნიშნავს, რომ ერთი მოდის ალფავიტის ადრე სხვა,

955
00:51:53,000 --> 00:51:57,000
და თუ ის დააბრუნებს +1 ეს იმას ნიშნავს სხვა სიტყვა მოდის ალფავიტის

956
00:51:57,000 --> 00:52:00,000
ადრე სხვა, და თქვენ შეგიძლიათ გამოიყურებოდეს ონლაინ ან მამაკაცის გვერდზე

957
00:52:00,000 --> 00:52:04,000
რომ ნახოთ ზუსტად რომელიც გზა, რომელიც, მაგრამ ეს ყველაფერი არის ჩანაფიქრია ის ამბობდა

958
00:52:04,000 --> 00:52:09,000
თუ [i]. სახლი უდრის "Mather"

959
00:52:09,000 --> 00:52:13,000
მაშინ წავიდეთ წინ და ამობეჭდოთ ასე და ასე არის Mather.

960
00:52:13,000 --> 00:52:16,000
მაგრამ აქ რაღაც ჩვენ არ მინახავს ადრე, და ჩვენ დავბრუნდებით ამ.

961
00:52:16,000 --> 00:52:21,000
მე არ გავიხსენოთ ოდესმე მქონე ამის გაკეთება ნებისმიერ ჩემი პროგრამები.

962
00:52:21,000 --> 00:52:24,000
უფასო აშკარად გულისხმობდა მეხსიერება, გამონთავისუფლების მეხსიერება,

963
00:52:24,000 --> 00:52:31,000
მაგრამ რა მეხსიერების ვარ აშკარად ათავისუფლებს ამ loop ბოლოში ეს პროგრამა?

964
00:52:31,000 --> 00:52:34,000
როგორც ჩანს მე ათავისუფლებს პირის სახელი

965
00:52:34,000 --> 00:52:37,000
და პირის სახლში, მაგრამ რატომ არის, რომ?

966
00:52:37,000 --> 00:52:41,000
>> თურმე ყველა ამ კვირის რომ თქვენ უკვე გამოყენებით GetString

967
00:52:41,000 --> 00:52:45,000
ჩვენ სახის იქნა შემოღების bug შევიდა ყველა ერთი თქვენი პროგრამები.

968
00:52:45,000 --> 00:52:51,000
GetString მიერ დიზაინი გამოყოფს მეხსიერება ასე რომ შეგიძლიათ დაბრუნდნენ თქვენ ტექსტი,

969
00:52:51,000 --> 00:52:55,000
მოსწონს დავით, ან რობ, და თქვენ შეგიძლიათ მაშინ ნუ რაც გაგიხარდებათ

970
00:52:55,000 --> 00:52:59,000
რომ სიმებიანი თქვენს პროგრამაში, რადგან ჩვენ დაცულია მეხსიერების თქვენთვის.

971
00:52:59,000 --> 00:53:02,000
პრობლემა ის არის, მთელი ამ ხნის ყოველ ჯერზე რეკავთ GetString

972
00:53:02,000 --> 00:53:05,000
ჩვენ, ავტორებს GetString, უკვე სვამს ოპერაციული სისტემა

973
00:53:05,000 --> 00:53:07,000
უნდა მოგვცეს ცოტა RAM ამ სიმებიანი.

974
00:53:07,000 --> 00:53:09,000
მოგვცეს ცოტა RAM ამ შემდეგი სიმებიანი.

975
00:53:09,000 --> 00:53:11,000
გვაწვდიან მეტი RAM ამ შემდეგი სიმებიანი.

976
00:53:11,000 --> 00:53:13,000
რა, პროგრამისტი, არასდროს აკეთებს

977
00:53:13,000 --> 00:53:15,000
გვაძლევს, რომ მეხსიერების უკან,

978
00:53:15,000 --> 00:53:17,000
ისე ამ რამდენიმე კვირის ყველა პროგრამების თქვენ წერილობითი

979
00:53:17,000 --> 00:53:20,000
არ ჰქონდა რასაც მეხსიერების ნახტომი, რომლის დროსაც ისინი გამოყენებით

980
00:53:20,000 --> 00:53:24,000
უფრო და უფრო მეტი მეხსიერების ყოველ ჯერზე რეკავთ GetString, და ეს ჯარიმა.

981
00:53:24,000 --> 00:53:27,000
ჩვენ შეგნებულად გააკეთოს, რომ პირველი კვირის განმავლობაში, რადგან ეს არ არის, რომ საინტერესო

982
00:53:27,000 --> 00:53:29,000
ჰქონდეს ფიქრი სადაც სიმებიანი მოდის.

983
00:53:29,000 --> 00:53:34,000
ყველა გსურთ არის სიტყვის Rob უკან დაბრუნდნენ, როდესაც მომხმარებლის ტიპის ის სისტემაში

984
00:53:34,000 --> 00:53:38,000
>> მაგრამ წინსვლის ჩვენ ახლა უნდა დავიწყოთ სულ უფრო დახვეწილი შესახებ.

985
00:53:38,000 --> 00:53:42,000
ნებისმიერ დროს ჩვენ გამოყოს მეხსიერება ჩვენ უკეთესი საბოლოოდ გადასცემს მას უკან.

986
00:53:42,000 --> 00:53:45,000
წინააღმდეგ შემთხვევაში რეალურ ცხოვრებაში თქვენს Mac ან PC თქვენ ალბათ ზოგჯერ გამოცდილი

987
00:53:45,000 --> 00:53:50,000
სიმპტომები სადაც თქვენი კომპიუტერი grinding შეჩერდა საბოლოოდ

988
00:53:50,000 --> 00:53:54,000
ან სულელური დაწნული Beach ball მხოლოდ საოკუპაციო კომპიუტერის

989
00:53:54,000 --> 00:53:56,000
მთელი ყურადღება და ვერ გავაკეთებ რამ.

990
00:53:56,000 --> 00:54:00,000
რომ აიხსნება ნებისმიერი რაოდენობის შეცდომები, მაგრამ იმ შესაძლო შეცდომები

991
00:54:00,000 --> 00:54:03,000
მათ რამ მოუწოდა მეხსიერების გაჟონვის რომლის ვინც წერს, რომ ნაჭერი პროგრამული უზრუნველყოფა

992
00:54:03,000 --> 00:54:07,000
თქვენ იყენებთ არ ახსოვს თავისუფალი მეხსიერება

993
00:54:07,000 --> 00:54:10,000
რომ მას სთხოვა მოქმედი სისტემა,

994
00:54:10,000 --> 00:54:14,000
არ იყენებს GetString, რადგან ისინი CS50 რამ, მაგრამ მისი გამოყენება ანალოგიური ფუნქციების

995
00:54:14,000 --> 00:54:16,000
რომ ვთხოვო ოპერაციული სისტემის მეხსიერების.

996
00:54:16,000 --> 00:54:19,000
თუ თქვენ ან ისინი Screw მდე და არასოდეს რეალურად დაბრუნებას, რომ მეხსიერების

997
00:54:19,000 --> 00:54:24,000
სიმპტომია, რომ შეიძლება იყოს ის, რომ პროგრამა slows და slows და ანელებს

998
00:54:24,000 --> 00:54:26,000
თუ არ გახსოვთ, რომ მოვუწოდო უფასო.

999
00:54:26,000 --> 00:54:28,000
>> ჩვენ დავბრუნდებით და როდის, რატომ, რომ დარეკოთ თავისუფალი,

1000
00:54:28,000 --> 00:54:32,000
მაგრამ მოდით წავიდეთ წინ მხოლოდ კარგი ღონისძიება და ცდილობენ გაშვებული ამ კონკრეტულ პროგრამას.

1001
00:54:32,000 --> 00:54:35,000
ეს ეწოდა structs1, შეიყვანოთ.

1002
00:54:35,000 --> 00:54:40,000
ნება მომეცით წავიდეთ წინ და აწარმოებს structs1, 123, დავით Mather,

1003
00:54:40,000 --> 00:54:47,000
456, რობ KIRKLAND, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, და ჩვენ ვხედავთ დავითის წელს Mather, Tommy წელს Mather.

1005
00:54:50,000 --> 00:54:53,000
ეს არის მხოლოდ პატარა საღი აზრის გამშვები რომ პროგრამა მუშაობს.

1006
00:54:53,000 --> 00:54:56,000
ახლა, სამწუხაროდ, ამ პროგრამის პატარა იმედგაცრუებაა, რომ

1007
00:54:56,000 --> 00:55:00,000
მე ყველა, რომ მუშაობა, მე აკრეფილი 9 სხვადასხვა სტრინგი, დააჭირეთ,

1008
00:55:00,000 --> 00:55:04,000
მითხრეს რომელიც Mather, მაგრამ აშკარად ვიცოდი, ვინ იყო Mather უკვე იმიტომ, რომ მე აკრეფილი იგი.

1009
00:55:04,000 --> 00:55:07,000
კარგი იქნება, მინიმუმ, თუ ამ პროგრამის უფრო ბაზაში

1010
00:55:07,000 --> 00:55:10,000
და ეს ფაქტიურად ახსოვს რა აკრეფილი

1011
00:55:10,000 --> 00:55:12,000
ასე რომ მე აღარასოდეს უნდა შეყვანის ამ სტუდენტი ჩანაწერი.

1012
00:55:12,000 --> 00:55:15,000
შეიძლება უფრო მოსწონს registrarial სისტემა.

1013
00:55:15,000 --> 00:55:21,000
>> ჩვენ შეგვიძლია ამის გაკეთება გამოყენებისას ტექნიკა ცნობილია როგორც ფაილის I / O, ფაილის და ჩასათვლელი,

1014
00:55:21,000 --> 00:55:24,000
ძალიან generic გზას ვამბობ, ნებისმიერ დროს გსურთ წაიკითხა ფაილების ან ფაილების ჩაწერა

1015
00:55:24,000 --> 00:55:26,000
ამისათვის გარკვეული კომპლექტი ფუნქციები.

1016
00:55:26,000 --> 00:55:29,000
ნება მომეცით წავიდეთ წინ და გახსნა ამ მაგალითში structs2.c,

1017
00:55:29,000 --> 00:55:33,000
რომელიც თითქმის იდენტურია, მაგრამ ვნახოთ, თუ რას აკეთებს ახლა.

1018
00:55:33,000 --> 00:55:36,000
ზედა ფაილის ვაცხადებ კლასი სტუდენტებს.

1019
00:55:36,000 --> 00:55:38,000
მე მაშინ populate კლასის მომხმარებლის input,

1020
00:55:38,000 --> 00:55:41,000
ამიტომ იმ ხაზები კოდი ზუსტად ისევე, როგორც ადრე.

1021
00:55:41,000 --> 00:55:45,000
მაშინ თუ გადახვევა ქვემოთ აქ ბეჭდვა ყველას, ვინც არის Mather თვითნებურად მინდა ადრე,

1022
00:55:45,000 --> 00:55:47,000
მაგრამ ეს არის საინტერესო ახალი ფუნქცია.

1023
00:55:47,000 --> 00:55:51,000
ეს ხაზი კოდი არის ახალი, და მათ გააცნოს რამე,

1024
00:55:51,000 --> 00:55:55,000
ფაილი, ყველა caps, და მას * აქ ასევე.

1025
00:55:55,000 --> 00:55:58,000
ნება მომეცით გადავიდეს ამ მეზობელი, * აქ ასევე.

1026
00:55:58,000 --> 00:56:00,000
>> ეს ფუნქცია ჩვენ არ მინახავს ადრე, fopen,

1027
00:56:00,000 --> 00:56:03,000
მაგრამ ეს ნიშნავს, ფაილის ღია, მოდით skim მეშვეობით ამ,

1028
00:56:03,000 --> 00:56:05,000
და ეს არის რაღაც ჩვენ დაბრუნდება მომავალში psets,

1029
00:56:05,000 --> 00:56:10,000
მაგრამ ეს ხაზი აქ არსებითად ხსნის ფაილი სახელად მონაცემთა ბაზა,

1030
00:56:10,000 --> 00:56:13,000
და ეს სპეციალურად ხსნის მას ისე, რომ მას შეუძლია გააკეთოს ის, რაც მას?

1031
00:56:13,000 --> 00:56:15,000
[Inaudible-სტუდენტი]

1032
00:56:15,000 --> 00:56:19,000
მარჯვენა, ისე "W" მხოლოდ იმას ნიშნავს, რომ ის ეუბნება ოპერაციული სისტემა

1033
00:56:19,000 --> 00:56:21,000
ამ ფაილის გახსნის ისე, რომ მე შეგიძლიათ დაწეროთ იგი.

1034
00:56:21,000 --> 00:56:23,000
მე არ მინდა, რომ მისი წაკითხვა. მე არ მინდა, უბრალოდ შეხედეთ მას.

1035
00:56:23,000 --> 00:56:26,000
მინდა შეცვლის და დაამატოთ პერსონალი პოტენციურად კი

1036
00:56:26,000 --> 00:56:28,000
და ფაილის აპირებს ეწოდოს მონაცემთა ბაზაში.

1037
00:56:28,000 --> 00:56:30,000
ეს შეიძლება ეწოდოს არაფერი.

1038
00:56:30,000 --> 00:56:32,000
ეს შეიძლება იყოს database.txt. ეს შეიძლება იყოს. დეციბელი.

1039
00:56:32,000 --> 00:56:37,000
ეს შეიძლება იყოს: სიტყვა მოსწონს foo, მაგრამ თვითნებურად აირჩია ასახელებს ფაილი მონაცემთა ბაზაში.

1040
00:56:37,000 --> 00:56:42,000
ეს არის პატარა საღი აზრის გამშვები რომ ჩვენ დაბრუნებას დიდი დეტალურად დროთა განმავლობაში,

1041
00:56:42,000 --> 00:56:47,000
თუ FP, ამისთვის ფაილის მაჩვენებელი, არ თანაბარი NULL, რაც იმას ნიშნავს ყველა კარგად არის.

1042
00:56:47,000 --> 00:56:51,000
>> დიდხანს ამბავი მოკლედ, ფუნქციები, როგორიცაა fopen ზოგჯერ ვერ.

1043
00:56:51,000 --> 00:56:53,000
იქნებ ფაილი არ არსებობს. იქნებ თქვენ გარეთ დისკი სივრცეში.

1044
00:56:53,000 --> 00:56:55,000
იქნებ არ გაქვთ, რომ საქაღალდეში,

1045
00:56:55,000 --> 00:56:58,000
ასე რომ, თუ fopen ბრუნდება null რაღაც ცუდი მოხდა.

1046
00:56:58,000 --> 00:57:02,000
პირიქით, თუ fopen არ დააბრუნებს null ყველა კარგად

1047
00:57:02,000 --> 00:57:04,000
და მე შემიძლია წერა ამ ფაილზე.

1048
00:57:04,000 --> 00:57:06,000
აქ ახალი შეასრულა.

1049
00:57:06,000 --> 00:57:08,000
ეს არის განკუთვნილი loop რომ iterating აღემატება თითოეული ჩემი სტუდენტები,

1050
00:57:08,000 --> 00:57:10,000
და ეს გამოიყურება ასე მსგავსია იმისა, რაც ჩვენ გავაკეთეთ ადრე,

1051
00:57:10,000 --> 00:57:15,000
მაგრამ ამ ფუნქციის დეიდაშვილი printf მოუწოდა fprintf ფაილების printf,

1052
00:57:15,000 --> 00:57:18,000
და შენიშნავს, რომ ის განსხვავებულია მხოლოდ 2 გზა.

1053
00:57:18,000 --> 00:57:20,000
ერთი, ეს იწყება F ნაცვლად P,

1054
00:57:20,000 --> 00:57:23,000
მაგრამ მაშინ მისი პირველი არგუმენტი აშკარად რა?

1055
00:57:23,000 --> 00:57:25,000
[სტუდენტთა] ფაილი. >> ეს ფაილი.

1056
00:57:25,000 --> 00:57:30,000
ეს რამ მოუწოდა FP, რომელიც ჩვენ საბოლოოდ აჯავრებენ გარდა რა ფაილის კურსორი არის,

1057
00:57:30,000 --> 00:57:35,000
მაგრამ ახლა FP უბრალოდ წარმოადგენს ფაილი, რომელიც მე არ გახსნა,

1058
00:57:35,000 --> 00:57:41,000
ასე fprintf აქ ამბობს ბეჭდვა ამ მომხმარებლის პირადობის ფაილი, არ ეკრანზე.

1059
00:57:41,000 --> 00:57:44,000
ამობეჭდვა მომხმარებლის სახელზე ფაილი, არ ეკრანზე,

1060
00:57:44,000 --> 00:57:47,000
სახლი ფაილი, არ ეკრანზე, ხოლო შემდეგ ქვემოთ აქ, ცხადია,

1061
00:57:47,000 --> 00:57:50,000
დახურვა ფაილი, ხოლო შემდეგ ქვემოთ აქ თავისუფალი მეხსიერება.

1062
00:57:50,000 --> 00:57:53,000
>> მხოლოდ განსხვავება ამ 2 ვერსია და ვერსია 1

1063
00:57:53,000 --> 00:57:58,000
არის დანერგვა fopen და ამ ფაილის *

1064
00:57:58,000 --> 00:58:01,000
და ეს ცნება fprintf, მოდით ვნახოთ, რა საბოლოო ჯამში.

1065
00:58:01,000 --> 00:58:03,000
ნება მომეცით წასვლას ჩემი ტერმინალის ფანჯარაში.

1066
00:58:03,000 --> 00:58:06,000
ნება მომეცით აწარმოებს structs2, შეიყვანოთ.

1067
00:58:06,000 --> 00:58:09,000
როგორც ჩანს, ყველა კარგად არის. მოდით გამეორება structs2.

1068
00:58:09,000 --> 00:58:15,000
123, დავით Mather, 456, რობ KIRKLAND,

1069
00:58:15,000 --> 00:58:19,000
789, ტომი Mather, შეიყვანოთ.

1070
00:58:19,000 --> 00:58:23,000
როგორც ჩანს, იგი მოიქცა იგივე, მაგრამ თუ ახლა ls

1071
00:58:23,000 --> 00:58:28,000
შეამჩნია რა ფაილი არის აქ შორის ჩემი კოდი, მონაცემთა ბაზა,

1072
00:58:28,000 --> 00:58:32,000
მოდით გავხსნათ, რომ gedit მონაცემთა ბაზის და შევხედოთ, რომ.

1073
00:58:32,000 --> 00:58:34,000
ეს არ არის ყველაზე სექსუალური ფაილის ფორმატებში.

1074
00:58:34,000 --> 00:58:38,000
ეს მართლაც ერთი ნაჭერი მონაცემები ხაზი თითო ხაზზე თითო ხაზზე,

1075
00:58:38,000 --> 00:58:42,000
მაგრამ იმ თქვენ, რომლებიც იყენებენ Excel ან CSV ფაილი მძიმით გამოყოფილი მნიშვნელობები,

1076
00:58:42,000 --> 00:58:47,000
მე ნამდვილად არ გამოიყენება fprintf, რომ ამის სანაცვლოდ ალბათ რაღაც მსგავსი

1077
00:58:47,000 --> 00:58:50,000
ასე რომ მე ვერ რეალურად შექმნა ეკვივალენტს Excel ფაილი

1078
00:58:50,000 --> 00:58:53,000
მიერ ჰყოფს რამ ერთად მძიმეები, არა მხოლოდ ახალი ხაზები.

1079
00:58:53,000 --> 00:58:56,000
>> ამ შემთხვევაში მე რომ ნაცვლად გამოიყენება მძიმეები ნაცვლად ახალი ხაზები

1080
00:58:56,000 --> 00:59:01,000
მე ვერ სიტყვასიტყვით გახსნა ამ მონაცემთა ბაზაში ფაილის Excel თუ ნაცვლად გახადა ასე გამოიყურება.

1081
00:59:01,000 --> 00:59:03,000
მოკლედ, ახლა რომ ჩვენ გვაქვს ძალა ვწერ ფაილები

1082
00:59:03,000 --> 00:59:07,000
ჩვენ შეგვიძლია ახლა დავიწყოთ არსებული მონაცემები, შენახვა ირგვლივ on დისკი

1083
00:59:07,000 --> 00:59:10,000
ასე, რომ ჩვენ შეგვიძლია შევინარჩუნოთ ინფორმაციის ირგვლივ ისევ და ისევ.

1084
00:59:10,000 --> 00:59:14,000
გაითვალისწინეთ რამდენიმე სხვა რამ, რაც ახლა უფრო მეტი ნაცნობი.

1085
00:59:14,000 --> 00:59:16,000
ზედა ამ C ფაილის გვაქვს typedef

1086
00:59:16,000 --> 00:59:21,000
რადგან გვინდოდა შექმნათ მონაცემთა ტიპის, რომელიც წარმოადგენს ერთი სიტყვით,

1087
00:59:21,000 --> 00:59:25,000
ამიტომ ამ ტიპის ეწოდება სიტყვა, და შიგნით ამ სტრუქტურის

1088
00:59:25,000 --> 00:59:27,000
ეს პატარა fancier არის.

1089
00:59:27,000 --> 00:59:30,000
რატომ არის სიტყვა შედგება სავარაუდოდ მასივი?

1090
00:59:30,000 --> 00:59:33,000
რა არის სიტყვა უბრალოდ ინტუიციურად?

1091
00:59:33,000 --> 00:59:35,000
>> ეს მასივი სიმბოლო.

1092
00:59:35,000 --> 00:59:37,000
ეს თანმიმდევრობა გმირები თავში დაბრუნება უკან.

1093
00:59:37,000 --> 00:59:41,000
ასო ყველა caps ხდება იყოს ჩვენ თვითნებურად ამბობენ მაქსიმალური სიგრძე

1094
00:59:41,000 --> 00:59:44,000
ნებისმიერი სიტყვა ლექსიკონი, რომ ჩვენ იყენებს Scramble.

1095
00:59:44,000 --> 00:59:46,000
რატომაა აქვს +1?

1096
00:59:46,000 --> 00:59:48,000
Null ხასიათი.

1097
00:59:48,000 --> 00:59:51,000
შეგახსენებთ, როდესაც ჩვენ გავაკეთეთ Bananagrams მაგალითად გვჭირდებოდა მასივები

1098
00:59:51,000 --> 00:59:55,000
დასასრულს სიტყვა რათა ტრეკზე

1099
00:59:55,000 --> 00:59:59,000
სადაც სიტყვა ფაქტობრივად დასრულდა, და როგორც პრობლემა კომპლექტი სპეციფიკაცია ამბობს

1100
00:59:59,000 --> 01:00:03,000
აქ ჩვენ ასოცირების ერთად მოცემული სიტყვა ლოგიკური ღირებულება,

1101
01:00:03,000 --> 01:00:05,000
დროშა, ასე ვთქვათ, ნამდვილი ან ყალბი.

1102
01:00:05,000 --> 01:00:09,000
არ თქვენ ი ამ სიტყვის უკვე, რადგან ვაცნობიერებთ

1103
01:00:09,000 --> 01:00:13,000
ჩვენ ნამდვილად გვჭირდება გზა დამახსოვრების არა მარტო რა სიტყვა არის Scramble

1104
01:00:13,000 --> 01:00:15,000
მაგრამ თუ არა თქვენ, ადამიანური, იპოვეს ეს

1105
01:00:15,000 --> 01:00:20,000
ასე რომ თუ იპოვოს სიტყვა "" ვერ უნდა აკრიფოთ, მიუთითოთ,, შევა, შეიყვანეთ

1106
01:00:20,000 --> 01:00:23,000
და კიდევ 3 ქულა, 3 ქულა, 3 ქულა, 3 ქულა.

1107
01:00:23,000 --> 01:00:26,000
ჩვენ გვინდა, რომ შეძლებს შავი სია რომ სიტყვა მიიღწევა bool

1108
01:00:26,000 --> 01:00:29,000
ჭეშმარიტი თუ თქვენ უკვე ნაპოვნი, და ასე ამიტომ ჩვენ

1109
01:00:29,000 --> 01:00:31,000
encapsulated იგი ამ სტრუქტურაში.

1110
01:00:31,000 --> 01:00:35,000
>> ახლა ქვევით აქ Scramble არსებობს ამ სხვა struct მოუწოდა ლექსიკონი.

1111
01:00:35,000 --> 01:00:39,000
Absent აქ არის სიტყვა typedef რადგან ამ შემთხვევაში

1112
01:00:39,000 --> 01:00:43,000
ჩვენ საჭირო encapsulate იდეა ლექსიკონი,

1113
01:00:43,000 --> 01:00:46,000
და ლექსიკონი შეიცავს მთელი bunch of სიტყვა,

1114
01:00:46,000 --> 01:00:49,000
როგორც გულისხმობდა ამ მასივი, და რამდენი იმ სიტყვა არსებობს?

1115
01:00:49,000 --> 01:00:51,000
ისე, რასაც ამ ცვლადში ზომა ამბობს.

1116
01:00:51,000 --> 01:00:53,000
მაგრამ ჩვენ უბრალოდ უნდა ერთი ლექსიკონი.

1117
01:00:53,000 --> 01:00:55,000
ჩვენ არ გვჭირდება მონაცემები ტიპის მოუწოდა ლექსიკონი.

1118
01:00:55,000 --> 01:00:58,000
ჩვენ უბრალოდ უნდა ერთი მათგანი, გამოდის, დო

1119
01:00:58,000 --> 01:01:03,000
რომ თუ თქვენ არ ვამბობ typedef, უბრალოდ ამბობენ struct, მაშინ შიგნით Curly braces

1120
01:01:03,000 --> 01:01:05,000
თქვენ განათავსოთ თქვენი ცვლადები, მაშინ დააყენა სახელი.

1121
01:01:05,000 --> 01:01:09,000
ეს არის გამოცხადების ერთ ცვლადში ლექსიკონი

1122
01:01:09,000 --> 01:01:11,000
რომ ასე გამოიყურება.

1123
01:01:11,000 --> 01:01:16,000
პირიქით, ამ ხაზების ვქმნით reusable მონაცემები სტრუქტურა მოუწოდა სიტყვა

1124
01:01:16,000 --> 01:01:19,000
რომ თქვენ შეგიძლიათ შექმნათ სხვადასხვა ასლები, ისევე, როგორც ჩვენ შევქმენით

1125
01:01:19,000 --> 01:01:22,000
მრავალჯერადი ასლები სტუდენტები.

1126
01:01:22,000 --> 01:01:24,000
>> რას საბოლოოდ მოგვცემს გავაკეთოთ?

1127
01:01:24,000 --> 01:01:30,000
ნება მომეცით დაბრუნდეს შევიდა, ასე ვთქვათ, უფრო მარტივი მაგალითი მარტივი ჯერ,

1128
01:01:30,000 --> 01:01:34,000
და ნება მომეცით ქმნის, ვთქვათ, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
პრობლემა აქ ხელთ არის რეალურად კანი უკან

1130
01:01:38,000 --> 01:01:41,000
ფენის სიმებიანი და დაიწყოს მოიხსნას ამ სასწავლო თვლები

1131
01:01:41,000 --> 01:01:44,000
რადგან აღმოჩნდება, რომ სიმებიანი მთელი ამ ხნის

1132
01:01:44,000 --> 01:01:47,000
არის როგორც დაგპირდით წელს კვირაში 1 ნამდვილად მხოლოდ მეტსახელად

1133
01:01:47,000 --> 01:01:51,000
სინონიმი საწყისი CS50 ბიბლიოთეკა რაღაც რომ გამოიყურება ცოტა მეტი cryptic,

1134
01:01:51,000 --> 01:01:53,000
char * და ჩვენ ვხედავთ ამ ვარსკვლავი წინაშე.

1135
01:01:53,000 --> 01:01:55,000
ჩვენ ვნახეთ ის კონტექსტში ფაილი.

1136
01:01:55,000 --> 01:01:59,000
>> მოდით ახლა, თუ რატომ ჩვენ იმალებოდა ამ დეტალურად ზოგიერთი ახლა.

1137
01:01:59,000 --> 01:02:02,000
აქ არის ფაილი სახელად compare1.c,

1138
01:02:02,000 --> 01:02:07,000
და ეს აშკარად სთხოვს მომხმარებლის 2 სიმები, და T,

1139
01:02:07,000 --> 01:02:11,000
და მაშინ იგი ცდილობს შეადაროს იმ სიმები თანასწორობის სტრიქონში 26,

1140
01:02:11,000 --> 01:02:14,000
და თუ ისინი თანაბარი იგი ამბობს: "თქვენ აკრეფილი იგივე"

1141
01:02:14,000 --> 01:02:17,000
და თუ ისინი არ თანაბარი იგი ამბობს: "თქვენ აკრეფილი სხვადასხვა რამ."

1142
01:02:17,000 --> 01:02:19,000
ნება მომეცით წავიდეთ წინ და აწარმოებს ამ პროგრამის.

1143
01:02:19,000 --> 01:02:23,000
ნება მომეცით წასვლას ჩემი წყაროს დირექტორია, მიიღოს compare1. იგი შედგენილია okay.

1144
01:02:23,000 --> 01:02:25,000
ნება მომეცით აწარმოებს compare1.

1145
01:02:25,000 --> 01:02:27,000
მე დიდი ზომით, შეიყვანოთ.

1146
01:02:27,000 --> 01:02:29,000
ამბობენ რაღაც. Hello.

1147
01:02:29,000 --> 01:02:32,000
მე ამბობენ რაიმეს. Hello.

1148
01:02:32,000 --> 01:02:34,000
მე ნამდვილად არ აკრიფოთ სხვადასხვა რამ.

1149
01:02:34,000 --> 01:02:37,000
>> ნება მომეცით ცდილობენ ამ ერთხელ. Bye Bye.

1150
01:02:37,000 --> 01:02:40,000
ნამდვილად არა სხვადასხვა, ისე რა ხდება აქ?

1151
01:02:40,000 --> 01:02:44,000
ისე, რა არის მართლაც მიმდინარეობს შედარებით შეესაბამება 26?

1152
01:02:44,000 --> 01:02:46,000
[Inaudible-სტუდენტი]

1153
01:02:46,000 --> 01:02:49,000
დიახ, ასე გამოდის, რომ ტექსტი, მონაცემები ტიპის, არის ერთგვარი თეთრი სიცრუეა.

1154
01:02:49,000 --> 01:02:53,000
სიმებიანი არის char *, მაგრამ რა არის char *?

1155
01:02:53,000 --> 01:02:56,000
Char *, როგორც ამბობენ, არის მაჩვენებელი,

1156
01:02:56,000 --> 01:03:00,000
და კურსორი არის ეფექტურად მისამართი,

1157
01:03:00,000 --> 01:03:05,000
თანხა საიდან მეხსიერებაში და თუ ემართება არ აკრეფილი სიტყვა მოსწონს Hello,

1158
01:03:05,000 --> 01:03:08,000
გავიხსენოთ წარსულის განხილვა სტრიქონები

1159
01:03:08,000 --> 01:03:16,000
ეს მოსწონს სიტყვა Hello.

1160
01:03:16,000 --> 01:03:19,000
გახსოვდეთ, რომ სიტყვა, როგორიცაა HELLO შეიძლება წარმოდგენილია

1161
01:03:19,000 --> 01:03:22,000
როგორც მასივი გმირები მოსწონს

1162
01:03:22,000 --> 01:03:25,000
შემდეგ კი სპეციალური ხასიათის დასასრულს მოუწოდა null ხასიათი,

1163
01:03:25,000 --> 01:03:27,000
როგორც \ აღნიშნავს.

1164
01:03:27,000 --> 01:03:29,000
რა არის რეალურად სიმებიანი?

1165
01:03:29,000 --> 01:03:32,000
გაითვალისწინეთ, რომ ეს არის მრავალჯერადი მოცულობით მეხსიერება,

1166
01:03:32,000 --> 01:03:36,000
და რეალურად, ბოლოს იგი მხოლოდ ცნობილია ერთხელ გადავხედავთ მთელ string

1167
01:03:36,000 --> 01:03:38,000
ეძებს სპეციალური null ხასიათი.

1168
01:03:38,000 --> 01:03:41,000
მაგრამ თუ ეს არის ბლოკი მეხსიერება ჩემი კომპიუტერის მეხსიერებაში,

1169
01:03:41,000 --> 01:03:44,000
მოდით თვითნებურად ამბობენ, რომ ეს კონტექსტი უბრალოდ მიიღო გაუმართლა,

1170
01:03:44,000 --> 01:03:47,000
და მას განთავსებულია თავიდანვე ჩემი კომპიუტერის RAM.

1171
01:03:47,000 --> 01:03:54,000
ეს არის byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> როდესაც ვამბობ რაღაც GetString და გავაკეთე string s = GetString

1173
01:04:02,000 --> 01:04:04,000
რა ნამდვილად მიმდინარეობს დაბრუნდა?

1174
01:04:04,000 --> 01:04:08,000
ამ ბოლო რამდენიმე კვირის განმავლობაში, თუ რა ნამდვილად მიმდინარეობს ინახება s

1175
01:04:08,000 --> 01:04:13,000
არ არის ეს კონტექსტი თავისთავად, მაგრამ ამ შემთხვევაში რა ხდება ინახება არის

1176
01:04:13,000 --> 01:04:18,000
ნომერი 0, რადგან რა GetString რეალურად აკეთებს

1177
01:04:18,000 --> 01:04:20,000
არის ეს არ ფიზიკურად დაბრუნების სიმებიანი.

1178
01:04:20,000 --> 01:04:22,000
რომ არც კი ნამდვილად მიიღოს კონცეპტუალური გაგებით.

1179
01:04:22,000 --> 01:04:24,000
რა ეს იმას დაბრუნების არის ნომერი.

1180
01:04:24,000 --> 01:04:28,000
რომ ნომერი არის მისამართი HELLO მეხსიერებაში,

1181
01:04:28,000 --> 01:04:32,000
და სიმებიანი s მაშინ, თუ ჩვენ კანი უკან ამ ფენას, string ნამდვილად არ არსებობს.

1182
01:04:32,000 --> 01:04:35,000
ეს მხოლოდ გამარტივების წელს CS50 ბიბლიოთეკაში.

1183
01:04:35,000 --> 01:04:38,000
>> ეს ნამდვილად არის რაღაც მოუწოდა char *.

1184
01:04:38,000 --> 01:04:41,000
ჩარ აზრი რადგან რა სიტყვაა, ისევე როგორც პირველი?

1185
01:04:41,000 --> 01:04:44,000
ისე, ეს სერია სიმბოლო, სერია გმირები.

1186
01:04:44,000 --> 01:04:47,000
ჩარ * ნიშნავს მისამართი ხასიათი,

1187
01:04:47,000 --> 01:04:50,000
ასე რას ნიშნავს დაბრუნებას სიმებიანი?

1188
01:04:50,000 --> 01:04:53,000
ლამაზი, მარტივი გზა დაბრუნების სიმებიანი

1189
01:04:53,000 --> 01:04:57,000
არის ვიდრე ცდილობენ გაერკვნენ, თუ როგორ მე დაბრუნდება 5 ან 6 სხვადასხვა ბაიტი

1190
01:04:57,000 --> 01:05:01,000
დავუბრუნდები მისამართი რომელიც byte?

1191
01:05:01,000 --> 01:05:03,000
პირველი.

1192
01:05:03,000 --> 01:05:06,000
სხვა სიტყვებით, მინდა გადმოგცეთ მისამართი ხასიათი მეხსიერებაში.

1193
01:05:06,000 --> 01:05:10,000
რაც char * წარმოადგენს, მისამართი ერთი ხასიათი მეხსიერებაში.

1194
01:05:10,000 --> 01:05:12,000
ზარის რომ ცვლადი s.

1195
01:05:12,000 --> 01:05:15,000
მაღაზიის წინ, რომ კონკრეტული მისამართი, რომელსაც მე თვითნებურად განაცხადა არის 0,

1196
01:05:15,000 --> 01:05:19,000
უბრალოდ შენარჩუნება რამ მარტივი, მაგრამ სინამდვილეში ეს არის ზოგადად უფრო დიდი რაოდენობის.

1197
01:05:19,000 --> 01:05:21,000
>> დაელოდეთ წუთი.

1198
01:05:21,000 --> 01:05:23,000
თუ თქვენ მხოლოდ მაძლევს მისამართი პირველი ხასიათი, როგორ მე ვიცი, თუ რა მისამართი

1199
01:05:23,000 --> 01:05:25,000
მეორე გმირი, მესამე, მეოთხე და მეხუთე?

1200
01:05:25,000 --> 01:05:27,000
[Inaudible-სტუდენტი]

1201
01:05:27,000 --> 01:05:31,000
თქვენ მხოლოდ ვიცი, სად ბოლომდე სტრიქონს გზით ამ მოსახერხებელი შეასრულა,

1202
01:05:31,000 --> 01:05:35,000
ასე რომ, როდესაც თქვენ იყენებთ რაღაც printf, რა printf სიტყვასიტყვით იღებს როგორც მისი არგუმენტი,

1203
01:05:35,000 --> 01:05:39,000
გავიხსენოთ, რომ ჩვენ ვიყენებთ ამ% s placeholder, და მაშინ კორიდორი

1204
01:05:39,000 --> 01:05:41,000
ცვლადი რომ შენახვის სიმებიანი.

1205
01:05:41,000 --> 01:05:47,000
თქვენ მას ნამდვილად ავლით არის მისამართი პირველი ხასიათი რომ სიმებიანი.

1206
01:05:47,000 --> 01:05:50,000
Printf მაშინ იყენებს ამისთვის მარყუჟი ან ხოლო loop მიღების, რომ მისამართი,

1207
01:05:50,000 --> 01:05:53,000
მაგალითად, 0, ნება მომეცით, ეს ახლა,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" s);

1209
01:06:02,000 --> 01:06:07,000
როდესაც მოვუწოდებ printf ("% s \ n" s); რა მე ნამდვილად უზრუნველყოფს printf ერთად

1210
01:06:07,000 --> 01:06:13,000
არის მისამართი პირველი პერსონაჟი s, რომელიც ამ თვითნებური საქმე H.

1211
01:06:13,000 --> 01:06:16,000
>> როგორ ამჯამად printf ვიცი რა ზუსტად არ არიან ეკრანზე?

1212
01:06:16,000 --> 01:06:19,000
პირი, რომელიც განხორციელდა printf განხორციელებული ხოლო მარყუჟი ან ამისთვის loop

1213
01:06:19,000 --> 01:06:23,000
რომელიც ამბობს, ამჯამად ეს პერსონაჟი გაუტოლდება სპეციალური null ხასიათი?

1214
01:06:23,000 --> 01:06:25,000
თუ არა, დაბეჭდეთ. როგორ ამ ერთი?

1215
01:06:25,000 --> 01:06:28,000
თუ არ დაბეჭდეთ, დაბეჭდეთ, დაბეჭდეთ, დაბეჭდეთ.

1216
01:06:28,000 --> 01:06:32,000
ოჰ, ეს არის სპეციალური. Stop ბეჭდვა და დაბრუნდეს მომხმარებლის.

1217
01:06:32,000 --> 01:06:35,000
და ეს სიტყვასიტყვით ყველა რომ ხდებოდა ქვეშ hood,

1218
01:06:35,000 --> 01:06:38,000
და ეს ბევრი დაიჯესტს პირველ დღეს კლასის,

1219
01:06:38,000 --> 01:06:43,000
მაგრამ ახლა ეს მართლაც შენობა მრავალბინიანი გაგება ყველაფერი

1220
01:06:43,000 --> 01:06:46,000
რომ უკვე მიმდინარეობს შიგნით ჩვენი კომპიუტერის მეხსიერებაში,

1221
01:06:46,000 --> 01:06:49,000
და საბოლოოდ ჩვენ აჯავრებენ ამ გარდა ერთად პატარა დახმარება

1222
01:06:49,000 --> 01:06:51,000
ერთი ჩვენი მეგობარი სტენფორდის.

1223
01:06:51,000 --> 01:06:56,000
>> პროფესორი ნიკ Parlante სტენფორდის გააკეთა ეს მშვენიერი ვიდეო თანმიმდევრობა

1224
01:06:56,000 --> 01:06:58,000
ყველა სახის სხვადასხვა ენებზე, რომ გააცნო

1225
01:06:58,000 --> 01:07:00,000
ამ პატარა Claymation ხასიათი Binky.

1226
01:07:00,000 --> 01:07:03,000
ხმა თქვენ შესახებ მოვისმინოთ რამდენიმე მეორე Sneak გადახედვისას

1227
01:07:03,000 --> 01:07:05,000
ის არის, რომ საქართველოში სტენფორდის პროფესორი, და თქვენ მისაღებად

1228
01:07:05,000 --> 01:07:07,000
მხოლოდ 5 ან 6 წამი ამ წუთას,

1229
01:07:07,000 --> 01:07:09,000
მაგრამ ეს შენიშვნა, რომელიც ჩვენ დავასკვნათ დღეს

1230
01:07:09,000 --> 01:07:11,000
და დაიწყება ოთხშაბათს.

1231
01:07:11,000 --> 01:07:15,000
მე გაძლევთ Pointer გართობა ერთად Binky, ესკიზი.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Music] [პროფესორი Parlante] Hey, Binky.

1233
01:07:18,000 --> 01:07:21,000
ვიღვიძებ. დროა მაჩვენებელი გართობა.

1234
01:07:21,000 --> 01:07:24,000
[Binky] რა არის რომ? ბუნებაში პოინტერები?

1235
01:07:24,000 --> 01:07:26,000
ოჰ, GOODY!

1236
01:07:26,000 --> 01:07:29,000
>> ჩვენ ვხედავთ თქვენ ოთხშაბათს.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]