1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Valgrind]

2
00:00:02,000 --> 00:00:05,000
[Nate Hardison, ჰარვარდის უნივერსიტეტი]

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

4
00:00:07,000 --> 00:00:10,000
ზოგიერთი ყველაზე რთული შეცდომებს C პროგრამების

5
00:00:10,000 --> 00:00:13,000
მოდის არასწორად მართვაში მეხსიერება.

6
00:00:13,000 --> 00:00:15,000
არსებობს დიდი რაოდენობით გზა Screw რამ up,

7
00:00:15,000 --> 00:00:17,000
მათ შორის განაწილების არასწორი ოდენობით მეხსიერება,

8
00:00:17,000 --> 00:00:20,000
ავიწყდება ინიციალიზაცია ცვლადები,

9
00:00:20,000 --> 00:00:23,000
წერის დაწყებამდე ან დასრულების შემდეგ ბუფერული,

10
00:00:23,000 --> 00:00:25,000
და ათავისუფლებს შევინარჩუნოთ ხსოვნა რამდენჯერმე.

11
00:00:25,000 --> 00:00:28,000
სიმპტომები მერყეობს წყვეტილი დამსხვრევაზე

12
00:00:28,000 --> 00:00:30,000
to mysteriously ინსტალერის ღირებულებების,

13
00:00:30,000 --> 00:00:34,000
ხშირად ადგილებზე და ჯერ შორს ამოღებულ ორიგინალური შეცდომა.

14
00:00:34,000 --> 00:00:37,000
ტრასირება გამოვლენილი პრობლემა თავში ფუძემდებლური ძირეული მიზეზი

15
00:00:37,000 --> 00:00:39,000
შეიძლება რთული,

16
00:00:39,000 --> 00:00:42,000
მაგრამ საბედნიეროდ არსებობს გამოსადეგი პროგრამა მოუწოდა Valgrind

17
00:00:42,000 --> 00:00:44,000
რომ ბევრი დასახმარებლად.

18
00:00:44,000 --> 00:00:47,000
>> თქვენ აწარმოებს პროგრამა Valgrind რომელიც საშუალებას მისცემს

19
00:00:47,000 --> 00:00:50,000
ვრცელი შემოწმება ბევრი მეხსიერების გამოყოფის და ხელმისაწვდომი.

20
00:00:50,000 --> 00:00:53,000
როდესაც Valgrind ცნობს პრობლემა, ეს გაძლევთ დაუყოვნებლივ,

21
00:00:53,000 --> 00:00:56,000
პირდაპირი ინფორმაცია, რომელიც საშუალებას გაძლევთ

22
00:00:56,000 --> 00:00:58,000
უფრო ადვილად იპოვოს და დაფიქსირება პრობლემა.

23
00:00:58,000 --> 00:01:01,000
Valgrind ასევე მოხსენებებს ნაკლები სასიკვდილო მეხსიერების საკითხებს,

24
00:01:01,000 --> 00:01:04,000
როგორიცაა მეხსიერების ტბები, გამოყოფის ბევრი მეხსიერება,

25
00:01:04,000 --> 00:01:07,000
და ავიწყდება გასათავისუფლებლად იგი.

26
00:01:07,000 --> 00:01:10,000
არა ჩვენი შემდგენელი, Clang, ჩვენს debugger, GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind არის თავისუფალი პროგრამა, და იგი დამონტაჟებული ელექტრო მოწყობილობების.

28
00:01:14,000 --> 00:01:16,000
Valgrind ეშვება თქვენი ორობითი შესრულებადი,

29
00:01:16,000 --> 00:01:20,000
არ არის თქვენი. გ ან. თ კოდის ფაილი

30
00:01:20,000 --> 00:01:23,000
ასე დარწმუნდით, რომ არ შედგენილი up-to-date ასლი თქვენი პროგრამა

31
00:01:23,000 --> 00:01:25,000
გამოყენებით Clang ან ჩადება.

32
00:01:25,000 --> 00:01:28,000
მაშინ, გაშვებული თქვენი პროგრამა Valgrind შეიძლება იყოს

33
00:01:28,000 --> 00:01:32,000
იმდენად მარტივია, უბრალოდ prefixing სტანდარტული პროგრამა ბრძანება ერთად სიტყვა Valgrind,

34
00:01:32,000 --> 00:01:35,000
რომელიც იწყება up Valgrind და ეშვება პროგრამა შიგნით მას.

35
00:01:35,000 --> 00:01:38,000
როდესაც დაწყებული, Valgrind აკეთებს ზოგიერთი კომპლექსი

36
00:01:38,000 --> 00:01:41,000
jiggering კონფიგურაციის შესრულებადი ამისთვის მეხსიერების ამოწმებს,

37
00:01:41,000 --> 00:01:44,000
ამიტომ მას შეუძლია მიიღოს bit მისაღებად შექმნილია და გამართულად მუშაობს.

38
00:01:44,000 --> 00:01:48,000
პროგრამა შემდეგ შეასრულოს ნორმალურად, იქნება ეს ბევრად უფრო ნელა,

39
00:01:48,000 --> 00:01:52,000
და როდესაც დასრულდება, Valgrind იქნება ბეჭდვა შემაჯამებელი მისი მეხსიერების გამოყენების.

40
00:01:52,000 --> 00:01:58,000
თუ ყველაფერი კარგად, იგი გამოიყურება მსგავსი რამ:

41
00:01:58,000 --> 00:02:01,000
ამ შემთხვევაში. / Clean_program

42
00:02:01,000 --> 00:02:04,000
არის გზა პროგრამის მინდა აწარმოებს.

43
00:02:04,000 --> 00:02:06,000
და სანამ ეს ერთი არ იღებს რაიმე არგუმენტები,

44
00:02:06,000 --> 00:02:09,000
თუ ეს მოხდა მე უბრალოდ Tack მათ ბოლომდე ბრძანება, როგორც ყოველთვის.

45
00:02:09,000 --> 00:02:12,000
სუფთა პროგრამა უბრალოდ სულელური პატარა პროგრამის მე შექმნა

46
00:02:12,000 --> 00:02:15,000
რომ გამოყოფს ფართი ბლოკი ints შესახებ ბევრი,

47
00:02:15,000 --> 00:02:19,000
დააყენა ზოგიერთი ღირებულებების შიგნით მათ, და ათავისუფლებს მთელი ბლოკი.

48
00:02:19,000 --> 00:02:23,000
ეს არის ის, რაც თქვენ სროლა ამისთვის, არ შეცდომები და არ გაჟონვის.

49
00:02:23,000 --> 00:02:27,000
>> კიდევ ერთი მნიშვნელოვანი მეტრულ არის საერთო რაოდენობის ბაიტი გამოყოფილი.

50
00:02:27,000 --> 00:02:32,000
დამოკიდებულია პროგრამის, თუ თქვენი დაფინანსებამ არიან მბ ან უფრო მაღალი,

51
00:02:32,000 --> 00:02:34,000
თქვენ ალბათ აკეთებს რაღაც.

52
00:02:34,000 --> 00:02:37,000
თქვენ ზედმეტად შენახვის დუბლიკატები?

53
00:02:37,000 --> 00:02:40,000
თქვენ გამოყენებით ბევრი შენახვის, როდესაც უკეთესი იქნება გამოიყენოს დასტის?

54
00:02:40,000 --> 00:02:43,000
ასე რომ, მეხსიერების შეცდომები შეიძლება იყოს ჭეშმარიტად ბოროტების.

55
00:02:43,000 --> 00:02:46,000
უფრო აშკარა პირობა გამოიწვიოს სანახაობრივი დამსხვრევაზე,

56
00:02:46,000 --> 00:02:49,000
მაგრამ მაშინ ჯერ კიდევ შეუძლია იყოს ძნელი pinpoint

57
00:02:49,000 --> 00:02:51,000
რა ზუსტად გამოიწვია კრახი.

58
00:02:51,000 --> 00:02:54,000
გაძლიერებული insidiously, პროგრამა მეხსიერების შეცდომა

59
00:02:54,000 --> 00:02:56,000
მაინც შეადგინოს cleanly

60
00:02:56,000 --> 00:02:58,000
და მაინც, როგორც ჩანს, მუშაობს

61
00:02:58,000 --> 00:03:01,000
იმიტომ, რომ თქვენ მოახერხა გაუმართლა ყველაზე მეტად დრო.

62
00:03:01,000 --> 00:03:04,000
შემდეგ რამდენიმე "წარმატებული შედეგების"

63
00:03:04,000 --> 00:03:07,000
თქვენ ალბათ უბრალოდ ფიქრობთ, რომ არის ავარიის Fluke of კომპიუტერი,

64
00:03:07,000 --> 00:03:10,000
მაგრამ კომპიუტერში არასოდეს არ არის არასწორი.

65
00:03:10,000 --> 00:03:13,000
>> Running Valgrind დაგეხმარებათ აკონტროლოთ ქვემოთ მიზეზია ხილული მეხსიერება შეცდომები

66
00:03:13,000 --> 00:03:18,000
ასევე მოვძებნოთ lurking შეცდომები თქვენ კი არ გაუკეთებია შესახებ ვიცით.

67
00:03:18,000 --> 00:03:22,000
ყოველ ჯერზე Valgrind ცნობს პრობლემა, იგი ბეჭდავს ინფორმაციას, თუ რას დაფიქსირდა.

68
00:03:22,000 --> 00:03:24,000
თითოეული პუნქტი საკმაოდ მოკლე -

69
00:03:24,000 --> 00:03:27,000
წყარო ხაზი შეურაცხყოფა დავალებით, რა საკითხი,

70
00:03:27,000 --> 00:03:30,000
და პატარა ინფორმაცია მეხსიერების ჩართული -

71
00:03:30,000 --> 00:03:34,000
მაგრამ ხშირად ეს საკმარისი ინფორმაცია პირდაპირ თქვენს ყურადღებას ადგილას.

72
00:03:34,000 --> 00:03:37,000
აქ არის მაგალითი Valgrind გაშვებული buggy პროგრამა

73
00:03:37,000 --> 00:03:40,000
რომ არ არასწორი წაკითხული of ბევრი მეხსიერებაში.

74
00:03:40,000 --> 00:03:49,000
ჩვენ ვხედავთ შეუცდომლობის ან გაფრთხილებისა წელს კომპილაცია.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, შეცდომა შემაჯამებელი ნათქვამია, რომ არსებობს ორი შეცდომები -

76
00:03:53,000 --> 00:03:56,000
ორი არასწორი ნათქვამია საქართველოს ზომა 4 - ბაიტი, რომ არის.

77
00:03:56,000 --> 00:04:01,000
ორივე ცუდი ნათქვამია მოხდა ძირითადი ფუნქცია invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
პირველი on line 16 და მეორე ხაზი 19.

79
00:04:04,000 --> 00:04:06,000
მოდით შევხედოთ კოდი.

80
00:04:06,000 --> 00:04:11,000
როგორც ჩანს, პირველი ზარი printf ცდილობს წაიკითხა int წარსულში ბოლოს ჩვენი მეხსიერების ბლოკში.

81
00:04:11,000 --> 00:04:13,000
თუ ჩვენ ვიხსენებთ Valgrind ის გამომუშავება,

82
00:04:13,000 --> 00:04:16,000
ჩვენ ვხედავთ, რომ Valgrind გვითხრა ზუსტად რომ.

83
00:04:16,000 --> 00:04:19,000
მისამართი ჩვენ წაკითხვის მცდელობისას იწყება 0 ბაიტი

84
00:04:19,000 --> 00:04:22,000
წარსულში ბოლოს ბლოკი ზომა 16 ბაიტი -

85
00:04:22,000 --> 00:04:25,000
ოთხი 32-bit ints რომ ჩვენ გამოყოფილი.

86
00:04:25,000 --> 00:04:29,000
ანუ, მისამართი ჩვენ წაკითხვის მცდელობისას იწყება უფლება დასასრულს ჩვენი ბლოკის,

87
00:04:29,000 --> 00:04:32,000
ისევე როგორც ჩვენ ვხედავთ ჩვენი ცუდი printf ზარი.

88
00:04:32,000 --> 00:04:36,000
ახლა, არასწორი ნათქვამია შეიძლება არ ჩანს, რომ ეს ასეა დიდი გარიგება,

89
00:04:36,000 --> 00:04:39,000
მაგრამ თუ თქვენ იყენებთ, რომ მონაცემები გაკონტროლება ნაკადის თქვენი პროგრამა -

90
00:04:39,000 --> 00:04:42,000
მაგალითად, როგორც ნაწილი იმ შემთხვევაში, თუ განაცხადი ან loop -

91
00:04:42,000 --> 00:04:45,000
ყველაფერი ჩუმად წასვლა ცუდი.

92
00:04:45,000 --> 00:04:47,000
Watch როგორ შემიძლია აწარმოებს invalid_read პროგრამა

93
00:04:47,000 --> 00:04:50,000
და არაფერი არაორდინალურის ხდება.

94
00:04:50,000 --> 00:04:52,000
საშინელი, არა?

95
00:04:52,000 --> 00:04:56,000
>> ახლა, მოდით შევხედოთ რამდენიმე სახის შეცდომები, რომ თქვენ შეიძლება ექმნებათ თქვენს კოდი,

96
00:04:56,000 --> 00:04:59,000
და ჩვენ დავინახავთ, თუ Valgrind ცნობს მათ.

97
00:04:59,000 --> 00:05:01,000
ჩვენ უბრალოდ დაინახა მაგალითი invalid_read,

98
00:05:01,000 --> 00:05:04,000
ახლა მოდით შეამოწმეთ invalid_write.

99
00:05:04,000 --> 00:05:09,000
ისევ და ისევ, არ შეცდომები ან გაფრთხილებისა წელს კომპილაცია.

100
00:05:09,000 --> 00:05:12,000
Okay, Valgrind ნათქვამია, რომ არსებობს ორი შეცდომები ამ პროგრამაში -

101
00:05:12,000 --> 00:05:15,000
და invalid_write და invalid_read.

102
00:05:15,000 --> 00:05:18,000
მოდით შეამოწმეთ ეს კოდი.

103
00:05:18,000 --> 00:05:21,000
როგორც ჩანს, ჩვენ მივიღეთ ინსტანციის კლასიკური strlen პლუს ერთი bug.

104
00:05:21,000 --> 00:05:24,000
კოდექსი არ malloc ზედმეტი byte სივრცეში

105
00:05:24,000 --> 00:05:26,000
ამისთვის / 0 ხასიათი,

106
00:05:26,000 --> 00:05:30,000
ასე რომ, როდესაც ქ ასლი წავიდა დაწერა მას ssubstrlen "cs50 rocks!"

107
00:05:30,000 --> 00:05:33,000
იგი წერდა 1 byte წარსულში ბოლოს ჩვენი ბლოკი.

108
00:05:33,000 --> 00:05:36,000
Invalid_read მოდის, როდესაც ჩვენ ჩვენი ზარი printf.

109
00:05:36,000 --> 00:05:40,000
Printf მთავრდება კითხულობს არასწორი მეხსიერების როდესაც ნათქვამია მოხსენებაში / 0 ხასიათი

110
00:05:40,000 --> 00:05:43,000
როგორც ეს უყურებს ბოლომდე E სიმებიანი ეს ბეჭდვა.

111
00:05:43,000 --> 00:05:45,000
თუმცა, ეს გაიქცა Valgrind.

112
00:05:45,000 --> 00:05:48,000
ჩვენ ვხედავთ, რომ იგი დაიჭირეს invalid_write ნაწილად ქ ასლი

113
00:05:48,000 --> 00:05:51,000
on line 11 ძირითადი და invalid_read ნაწილია printf.

114
00:05:51,000 --> 00:05:54,000
Rock წლის, Valgrind.

115
00:05:54,000 --> 00:05:57,000
ისევ, ეს არ ჩანს როგორც დიდი გარიგება.

116
00:05:57,000 --> 00:06:00,000
ჩვენ შეგვიძლია მას მოვთხოვოთ ამ პროგრამის მეტი და მეტი გარეთ Valgrind

117
00:06:00,000 --> 00:06:03,000
და ვერ ვხედავთ შეცდომა სიმპტომები.

118
00:06:03,000 --> 00:06:06,000
>> თუმცა, მოდით, შევხედოთ უმნიშვნელო ვარიაცია ამ ვიხილოთ

119
00:06:06,000 --> 00:06:09,000
როგორ შეიძლება კიდევ მართლა ცუდია.

120
00:06:09,000 --> 00:06:14,000
ასე რომ, მიანიჭა, ჩვენ ბოროტად რამ მეტი, ვიდრე უბრალოდ ცოტა ამ კოდექსში.

121
00:06:14,000 --> 00:06:17,000
ჩვენ მხოლოდ გამოყოფის სივრცე ბევრი ორი სიმები

122
00:06:17,000 --> 00:06:19,000
სიგრძეზე cs50 კლდეები,

123
00:06:19,000 --> 00:06:22,000
ამ დროს, დამახსოვრების / 0 ხასიათი.

124
00:06:22,000 --> 00:06:25,000
მაგრამ მაშინ ჩვენ ჩააგდოს წელს სუპერ ხანგრძლივი string შევიდა მეხსიერების ბლოკი

125
00:06:25,000 --> 00:06:27,000
რომ არის მიუთითებს.

126
00:06:27,000 --> 00:06:30,000
რა ეფექტი ექნება, რომ იქონიოს მეხსიერების ბლოკი, რომ T მიუთითებს?

127
00:06:30,000 --> 00:06:34,000
ისე, თუ T რაოდენობა ხსოვნას ეს მხოლოდ მიმდებარე S,

128
00:06:34,000 --> 00:06:37,000
მოვდივარ უბრალოდ მას შემდეგ,

129
00:06:37,000 --> 00:06:39,000
მაშინ ჩვენ, შესაძლოა, წერილობითი მეტი ნაწილი თ

130
00:06:39,000 --> 00:06:41,000
მოდით აწარმოებს ამ კოდი.

131
00:06:41,000 --> 00:06:43,000
შეხედეთ რა მოხდა.

132
00:06:43,000 --> 00:06:47,000
სიმები ჩვენ შენახული ჩვენი ბევრი ბლოკები ორივე აღმოჩნდა არ დაბეჭდილი სწორად.

133
00:06:47,000 --> 00:06:49,000
არაფერი ჩანს არასწორი იყო.

134
00:06:49,000 --> 00:06:52,000
თუმცა, მოდით დავუბრუნდეთ ჩვენს კოდი და

135
00:06:52,000 --> 00:06:55,000
კომენტარის out ხაზის სადაც ჩვენ კოპირება cs50 კლდეები

136
00:06:55,000 --> 00:06:59,000
მეორე მეხსიერების ბლოკი, მიუთითა მიერ ტ.

137
00:06:59,000 --> 00:07:02,000
ახლა, როდესაც ჩვენ აწარმოებს ამ კოდი უნდა

138
00:07:02,000 --> 00:07:06,000
მხოლოდ ვხედავ შინაარსი პირველი მეხსიერების ბლოკი ამობეჭდოთ.

139
00:07:06,000 --> 00:07:09,000
Whoa, მიუხედავად იმისა, რომ ჩვენ არ ქუჩა ასლი

140
00:07:09,000 --> 00:07:12,000
ნებისმიერი გმირები მეორე ბევრი ბლოკი, ერთი მიუთითებს მიერ T,

141
00:07:12,000 --> 00:07:15,000
მივიღებთ ბეჭდვითი out.

142
00:07:15,000 --> 00:07:18,000
მართლაც, string ჩვენ ფუნქციონირებს შევიდა ჩვენი პირველი ბლოკი

143
00:07:18,000 --> 00:07:21,000
დაესხა პირველი ბლოკი და მეორე კორპუსი,

144
00:07:21,000 --> 00:07:23,000
მიღების ყველაფერი ჩანს ნორმალურია.

145
00:07:23,000 --> 00:07:26,000
Valgrind, თუმცა, გვეუბნება ნამდვილი ამბავი.

146
00:07:26,000 --> 00:07:28,000
იქ ჩვენ წავიდეთ.

147
00:07:28,000 --> 00:07:32,000
ყველა იმ არასწორი ნათქვამია და წერს.

148
00:07:32,000 --> 00:07:36,000
>> მოდით შევხედოთ მაგალითს სხვა სახის შეცდომა.

149
00:07:36,000 --> 00:07:39,000
აქ ჩვენ რაღაც საკმაოდ სამწუხაროა.

150
00:07:39,000 --> 00:07:41,000
ჩვენ დაიბრუნოს ფართი int შესახებ ბევრი,

151
00:07:41,000 --> 00:07:45,000
და ჩვენ ინიციალიზაცია int მიმთითებელი - P - აღვნიშნო, რომ სივრცეში.

152
00:07:45,000 --> 00:07:48,000
მიუხედავად იმისა, რომ ჩვენი მაჩვენებელი ინიციალიზდება,

153
00:07:48,000 --> 00:07:52,000
მონაცემები, რომ ის მიუთითებს მხოლოდ უკვე რასაც უსარგებლო არის იმ ნაწილში ბევრი.

154
00:07:52,000 --> 00:07:55,000
ასე რომ, როდესაც ჩვენ ჩატვირთვა, რომ მონაცემების int i,

155
00:07:55,000 --> 00:07:57,000
ჩვენ ტექნიკურად ინიციალიზაცია i,

156
00:07:57,000 --> 00:08:00,000
მაგრამ ჩვენ ამისათვის ერთად უსარგებლო მონაცემები.

157
00:08:00,000 --> 00:08:03,000
ზარი მტკიცებით, რომელიც მოსახერხებელი გამართვის მაკრო

158
00:08:03,000 --> 00:08:06,000
განსაზღვრული aptly დაასახელა ამტკიცებენ ბიბლიოთეკა,

159
00:08:06,000 --> 00:08:09,000
პროცესი შეწყვეტილია პროგრამა თუ მისი ტესტი მდგომარეობა ვერ.

160
00:08:09,000 --> 00:08:11,000
ანუ, თუ არ არის 0.

161
00:08:11,000 --> 00:08:14,000
დამოკიდებულია რა იყო ბევრი სივრცე, მიუთითა მიერ P,

162
00:08:14,000 --> 00:08:18,000
ამ პროგრამის შესაძლოა სამუშაო, ხან და ვერ სხვა ჯერ.

163
00:08:18,000 --> 00:08:20,000
თუ მუშაობს, ჩვენ უბრალოდ ვიღებთ გაუმართლა.

164
00:08:20,000 --> 00:08:24,000
შემდგენელი არ დაიჭიროთ ეს შეცდომა, მაგრამ Valgrind დარწმუნებული ნება.

165
00:08:24,000 --> 00:08:28,000
იქ ჩვენ ვხედავთ შეცდომა გამომდინარე ჩვენი გამოყენება, რომ უსარგებლო მონაცემები.

166
00:08:28,000 --> 00:08:32,000
>> როცა გამოყოფს ბევრი მეხსიერების მაგრამ არ deallocate ის ან თავისუფალი მას,

167
00:08:32,000 --> 00:08:34,000
რომ ჰქვია გაჟონვის.

168
00:08:34,000 --> 00:08:37,000
პატარა, მოკლე ფეხები პროგრამა, რომელიც ეშვება და დაუყოვნებლივ გასასვლელების,

169
00:08:37,000 --> 00:08:39,000
გაჟონვის საკმაოდ უვნებელია,

170
00:08:39,000 --> 00:08:42,000
მაგრამ პროექტი უფრო დიდი ზომა და / ან დღეგრძელობისა,

171
00:08:42,000 --> 00:08:46,000
თუნდაც მცირე გაჟონვის შეიძლება ნაერთის შევიდა რაღაც ძირითადი.

172
00:08:46,000 --> 00:08:49,000
იყიდება CS50, ჩვენ ველით, რომ თქვენ

173
00:08:49,000 --> 00:08:51,000
იზრუნოს ათავისუფლებს ყველა ბევრი მეხსიერება, რომ თქვენ გამოყოფას,

174
00:08:51,000 --> 00:08:54,000
მას შემდეგ, რაც ჩვენ გვინდა თქვენ აშენება უნარი სათანადოდ გაუმკლავდეს მანუალურ პროცესს

175
00:08:54,000 --> 00:08:56,000
მოთხოვნილი C.

176
00:08:56,000 --> 00:08:59,000
ამისათვის თქვენი პროგრამის უნდა ჰქონდეს ზუსტი

177
00:08:59,000 --> 00:09:03,000
ერთი-to-ერთი კორესპონდენცია malloc და თავისუფალი მოუწოდებს.

178
00:09:03,000 --> 00:09:06,000
საბედნიეროდ, Valgrind დაგეხმარებათ მეხსიერების გაჟონვის ძალიან.

179
00:09:06,000 --> 00:09:09,000
აქ არის leaky პროგრამის მოუწოდა leak.c რომ გამოყოფს

180
00:09:09,000 --> 00:09:13,000
სივრცე ბევრი, წერს, მაგრამ არ გათავისუფლებთ იგი.

181
00:09:13,000 --> 00:09:16,000
ჩვენ კომპილირება ერთად ჩადება და გაუშვით ქვეშ Valgrind,

182
00:09:16,000 --> 00:09:18,000
და ჩვენ ვხედავთ, რომ, მაშინ, როდესაც ჩვენ არ გვაქვს მეხსიერების შეცდომები,

183
00:09:18,000 --> 00:09:20,000
ჩვენ გვაქვს ერთი გაჟონვის.

184
00:09:20,000 --> 00:09:23,000
არსებობს 16 ბაიტი ნამდვილად წააგო,

185
00:09:23,000 --> 00:09:27,000
რაც იმას ნიშნავს, რომ მომცეთ, რომ მეხსიერების არ იყო ფარგლებს, როდესაც პროგრამის დასრულების.

186
00:09:27,000 --> 00:09:30,000
ახლა, Valgrind არ მოგვცეს ტონა ინფორმაციას გაჟონვის,

187
00:09:30,000 --> 00:09:35,000
მაგრამ თუ მივყვებით ამ პატარა შენიშვნა, რომ ეს იძლევა ქვემოთ მიმართ ბოლოში თავის ანგარიშს

188
00:09:35,000 --> 00:09:38,000
to გამეორება ერთად - გაჟონვის-შეამოწმოთ = სრული

189
00:09:38,000 --> 00:09:41,000
რომ ნახოთ სრულ დეტალებს გაჟონა მეხსიერება,

190
00:09:41,000 --> 00:09:44,000
ჩვენ კიდევ უფრო მეტი ინფორმაცია.

191
00:09:44,000 --> 00:09:46,000
ახლა კი, ბევრი რეზიუმე,

192
00:09:46,000 --> 00:09:50,000
Valgrind გვეუბნება, სადაც მეხსიერება, რომ დაიკარგა თავდაპირველად გამოყოფილი.

193
00:09:50,000 --> 00:09:52,000
ისე, როგორც ჩვენ ვიცით ეძებს წელს კოდებს,

194
00:09:52,000 --> 00:09:55,000
Valgrind გვამცნობს, რომ ჩვენ გაჟონა მეხსიერება

195
00:09:55,000 --> 00:09:58,000
გამოყოფილი ერთად ზარი malloc on line 8 leak.c

196
00:09:58,000 --> 00:10:00,000
ძირითად ფუნქციას.

197
00:10:00,000 --> 00:10:02,000
Pretty nifty.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind სამი კატეგორია გაჟონვის გამოყენებით ამ თვალსაზრისით:

199
00:10:04,000 --> 00:10:07,000
აუცილებლად დაკარგა - ეს არის ბევრი გამოყოფილი მეხსიერება

200
00:10:07,000 --> 00:10:10,000
რომლის პროგრამა აღარ აქვს მაჩვენებელი.

201
00:10:10,000 --> 00:10:14,000
Valgrind იცის, რომ თქვენ ერთხელ ჰქონდა მაჩვენებელი მაგრამ მას შემდეგ დაკარგა სიმღერა იგი.

202
00:10:14,000 --> 00:10:17,000
ეს მეხსიერების აუცილებლად გაჟონა.

203
00:10:17,000 --> 00:10:20,000
არაპირდაპირ დაკარგა - ეს არის ბევრი გამოყოფილი მეხსიერება

204
00:10:20,000 --> 00:10:24,000
რომლის მხოლოდ მითითებას მას ასევე იკარგება.

205
00:10:24,000 --> 00:10:27,000
მაგალითად, თუ თქვენ დაგავიცყდათ თქვენი მომცეთ პირველი კვანძის of უკავშირდება სია,

206
00:10:27,000 --> 00:10:30,000
მაშინ პირველი კვანძის თავად იქნება აუცილებლად დაკარგა,

207
00:10:30,000 --> 00:10:34,000
ხოლო ნებისმიერი შემდგომი კვანძების იქნება არაპირდაპირ დაკარგა.

208
00:10:34,000 --> 00:10:37,000
შესაძლოა დაკარგა - ეს არის ბევრი გამოყოფილი მეხსიერება

209
00:10:37,000 --> 00:10:41,000
რომლის Valgrind არ შეიძლება იყოს დარწმუნებული არსებობს თუ არა მომცეთ თუ არა.

210
00:10:41,000 --> 00:10:44,000
ჯერ კიდევ მიუწვდომელია არის ბევრი გამოყოფილი მეხსიერება

211
00:10:44,000 --> 00:10:47,000
რომლის პროგრამა ჯერ კიდევ კურსორი ზე გასასვლელი,

212
00:10:47,000 --> 00:10:50,000
რომელიც, როგორც წესი, იმას ნიშნავს, რომ გლობალური ცვლადი რაოდენობა მას.

213
00:10:50,000 --> 00:10:53,000
შევამოწმოთ ეს ტბები, თქვენ ასევე უნდა შეიცავდეს ვარიანტი

214
00:10:53,000 --> 00:10:55,000
- ჯერ კიდევ მიუწვდომელია = დიახ

215
00:10:55,000 --> 00:10:58,000
თქვენს invocation of Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> ამ სხვადასხვა შემთხვევებში შესაძლოა მოითხოვოს, სხვადასხვა სტრატეგიების დასუფთავების მათ,

217
00:11:01,000 --> 00:11:05,000
მაგრამ გაჟონვის უნდა აღმოიფხვრას.

218
00:11:05,000 --> 00:11:08,000
სამწუხაროდ, აფიქსირებს გაჟონვის შეიძლება იყოს ძნელი გასაკეთებელი,

219
00:11:08,000 --> 00:11:11,000
მას შემდეგ, რაც არასწორი მოუწოდებს თავისუფალი შეიძლება აფეთქება თქვენი პროგრამა.

220
00:11:11,000 --> 00:11:14,000
მაგალითად, თუ დავაკვირდებით invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
ჩვენ ვხედავთ მაგალითს ცუდი მეხსიერება deallocation.

222
00:11:18,000 --> 00:11:21,000
რა უნდა იყოს ერთჯერადი ზარის გასათავისუფლებლად მთელი ბლოკი

223
00:11:21,000 --> 00:11:24,000
მეხსიერების მიუთითა მიერ int_block,

224
00:11:24,000 --> 00:11:27,000
სანაცვლოდ გახდეს მცდელობა გასათავისუფლებლად ყოველ GEO-ზომის სექციაში

225
00:11:27,000 --> 00:11:29,000
საქართველოს მეხსიერების ინდივიდუალურად.

226
00:11:29,000 --> 00:11:32,000
ეს ვერ კატასტროფულად.

227
00:11:32,000 --> 00:11:34,000
BooM! რა შეცდომა.

228
00:11:34,000 --> 00:11:36,000
ეს არის ნამდვილად არ არის კარგი.

229
00:11:36,000 --> 00:11:39,000
თუ თქვენ დავრჩებოდით ასეთი შეცდომა, თუმცა, და არ იცით სად უნდა გამოიყურებოდეს,

230
00:11:39,000 --> 00:11:41,000
დაეცემა უკან თქვენი ახალი საუკეთესო მეგობარი.

231
00:11:41,000 --> 00:11:44,000
თქვენ მიხვდა ეს - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, როგორც ყოველთვის, ზუსტად იცის, რა up.

233
00:11:47,000 --> 00:11:50,000
Alloc და თავისუფალი ითვლის არ ემთხვევა up.

234
00:11:50,000 --> 00:11:52,000
გვაქვს 1 alloc და 4 ათავისუფლებს.

235
00:11:52,000 --> 00:11:55,000
და Valgrind ასევე გვეუბნება თუ პირველი ცუდი უფასო ზარის -

236
00:11:55,000 --> 00:11:58,000
ერთი, რომ გამოიწვია blowup - მოდის -

237
00:11:58,000 --> 00:12:00,000
ხაზი 16.

238
00:12:00,000 --> 00:12:03,000
როგორც ხედავთ, ცუდი მოუწოდებს გასათავისუფლებლად მართლაც ცუდია,

239
00:12:03,000 --> 00:12:05,000
ამიტომ ჩვენ გირჩევთ გაქირავების თქვენი პროგრამის გაჟონვის

240
00:12:05,000 --> 00:12:08,000
ხოლო თქვენ მუშაობა მიღების ფუნქციონალური სწორი.

241
00:12:08,000 --> 00:12:12,000
დაწყება ეძებს გაჟონვის მხოლოდ მას შემდეგ თქვენი პროგრამა მუშაობს გამართულად,

242
00:12:12,000 --> 00:12:14,000
ყოველგვარი სხვა შეცდომები.

243
00:12:14,000 --> 00:12:16,000
>> და ეს ყველაფერი გვაქვს for this video.

244
00:12:16,000 --> 00:12:18,000
ახლა რას ელოდება?

245
00:12:18,000 --> 00:12:21,000
გადავიდეთ აწარმოებს Valgrind თქვენს პროგრამებს ახლავე.

246
00:12:21,000 --> 00:12:25,000
ჩემი სახელი არის Nate Hardison. ეს არის CS50. [CS50.TV]