1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hi,
მე ვარ [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
დღეს, ჩვენ ვაპირებთ
ეძებს debugging.

4
00:00:04,410 --> 00:00:06,697
არა მხოლოდ ჩვენ ვაპირებთ
ვისაუბროთ ზოგიერთ ტექნიკას,

5
00:00:06,697 --> 00:00:09,280
არამედ ჩვენ ვაპირებთ შევხედოთ
ზოგიერთი თავისებურება შეიცავს

6
00:00:09,280 --> 00:00:14,170
ფარგლებში CS50 IDE, რომელიც საშუალებას
თქვენ ადვილად გამართვის პროგრამა.

7
00:00:14,170 --> 00:00:16,272
>> მხოლოდ ერთი მაგალითი
ის, რაც შეიძლება წავიდეთ არასწორი

8
00:00:16,272 --> 00:00:18,730
და ეს არის რეალურად რაღაც
რომ ჩვენ უკვე მინახავს ადრე.

9
00:00:18,730 --> 00:00:23,200
ამ შემთხვევაში, ეს არის C პროგრამა
რომელიც ადასტურებს რიცხვი შესახებ,

10
00:00:23,200 --> 00:00:27,580
ყოფს მას ორი და უზრუნველყოფს
გამომავალი უკან შესახებ.

11
00:00:27,580 --> 00:00:30,610
ახლა, რაც ჩვენ ვნახეთ
ადრე ლექციები,

12
00:00:30,610 --> 00:00:34,370
ჩვენ ვიცით, რომ ეს რეალურად გამოიწვიოს
კონკრეტული სახის სამმართველოს პრობლემები

13
00:00:34,370 --> 00:00:35,860
როდესაც ჩვენ გვაქვს კენტი ნომრები.

14
00:00:35,860 --> 00:00:40,330
>> კერძოდ, ჩვენ მხოლოდ გადაყარეთ
არაფერი შემდეგ ათობითი წერტილი.

15
00:00:40,330 --> 00:00:43,170
ახლა ჩვენ ვიცით, რომ ეს
ხდება, რომ იყოს საქმე.

16
00:00:43,170 --> 00:00:47,430
და თუ ჩვენ აწარმოებს, ჩვენ შეგვიძლია ადასტურებენ
ჩვენი ეჭვები, პირველ რიგში, შედგენა.

17
00:00:47,430 --> 00:00:50,460
და მაშინ, მიერ გაშვებული და
შესვლის კენტი.

18
00:00:50,460 --> 00:00:51,720
>> ეს არის ახალი არაფერია.

19
00:00:51,720 --> 00:00:54,490
მაგრამ ეს არის რეალურად
მაგალითად შეცდომა, რომ

20
00:00:54,490 --> 00:00:58,810
შეიძლება არსებობდეს ფარგლებში უფრო დიდი პროგრამა
რომ ხდება უფრო რთული მწკრივზე ქვემოთ.

21
00:00:58,810 --> 00:01:02,640
მიუხედავად იმისა, რომ ჩვენ ვიცით, რა საკითხი
არის, ჭეშმარიტი არსი საკითხზე

22
00:01:02,640 --> 00:01:06,250
შეიძლება ცდილობს იდენტიფიცირება
კონკრეტულად სადაც შეცდომა ხდება,

23
00:01:06,250 --> 00:01:09,750
საიდენტიფიკაციო რა, რომ პრობლემა
და შემდეგ აფიქსირებს მას.

24
00:01:09,750 --> 00:01:14,400
ასე რომ გთავაზობთ, როგორც მაგალითად
რა შეიძლება იყოს რაღაც

25
00:01:14,400 --> 00:01:19,030
ჩვენ უკვე ვიცით, მაგრამ შეიძლება დაკრძალეს
ფარგლებში სხვა ელემენტების კოდი.

26
00:01:19,030 --> 00:01:23,090
>> ასე იხსნება სხვა წყარო
კოდი ფაილი, როგორც მაგალითად,

27
00:01:23,090 --> 00:01:27,165
ეს გაყოფა არის
ნაწილი უფრო დიდი პროგრამა.

28
00:01:27,165 --> 00:01:29,040
ჯერ კიდევ შეიძლება იყოს პატარა
ცოტა ჩაიფიქრეს და ჩვენ

29
00:01:29,040 --> 00:01:31,076
შეიძლება შეძლებთ ადვილად
იდენტიფიცირება, მით უმეტეს,

30
00:01:31,076 --> 00:01:32,450
მას შემდეგ, რაც ჩვენ უბრალოდ განხილული.

31
00:01:32,450 --> 00:01:38,250
მაგრამ ჩვენ შეგვიძლია გაერკვნენ, რომ ეს
პრობლემა შეიძლება არსებობდეს უფრო ფართო მასშტაბით.

32
00:01:38,250 --> 00:01:45,450
>> თუ მე კომპილაციის და ახლა
აწარმოებს, შეიყვანოთ უცნაური ნომერი,

33
00:01:45,450 --> 00:01:49,816
ჩვენ ვხედავთ, რომ ჩვენ არ მიიღოს ზუსტად
გამომავალი, რომ ჩვენ შეიძლება არ ელოდა.

34
00:01:49,816 --> 00:01:51,690
ამ კონკრეტულ შემთხვევაში,
შეიძლება ითქვას, რომ ჩვენ

35
00:01:51,690 --> 00:01:56,060
გსურთ ითვლიან ყველა ნომრები
ერთი მდე ზოგიერთი კონკრეტული რაოდენობა.

36
00:01:56,060 --> 00:01:58,130
ჩვენ ვხედავთ, რომ ჩვენ
აქვს სხვადასხვა საკითხებზე

37
00:01:58,130 --> 00:02:03,880
აქ თუ ჩვენ outputting, უბრალოდ, 0
და 1 როდესაც ჩვენ გთავაზობთ შეყვანის 5.

38
00:02:03,880 --> 00:02:07,380
>> ასე რომ, ჩვენ უკვე ვიცით, რომ
არსებობს პრობლემა აქ.

39
00:02:07,380 --> 00:02:11,662
მაგრამ ჩვენ შეიძლება არ ვიცი ზუსტად
სადაც ეს საკითხი რეალურად არსებობს.

40
00:02:11,662 --> 00:02:13,620
ახლა ერთ-ერთი გზა, რომ
ჩვენ შეგვიძლია ცდილობენ დაფიქსირება ამ

41
00:02:13,620 --> 00:02:15,745
არის ის, რომ ჩვენ
უკვე გააცნო.

42
00:02:15,745 --> 00:02:18,880
ჩვენ შეგვიძლია მხოლოდ გამოიყენოს იგი უფრო ფართო მასშტაბით.

43
00:02:18,880 --> 00:02:21,680
>> On line 14, ჩვენ გვაქვს
ამ printf ფუნქცია,

44
00:02:21,680 --> 00:02:25,620
რაც საშუალებას გვაძლევს ამობეჭდოთ სახელმწიფო
სხვადასხვა ცალი ინფორმაციას.

45
00:02:25,620 --> 00:02:28,880
და ეს არის ის, რომ თქვენ
უნდა ბერკეტები თქვენი პროგრამა

46
00:02:28,880 --> 00:02:33,100
ცდილობენ გაერკვნენ, თუ რა არის
ხდება სხვადასხვა ხაზების კოდი.

47
00:02:33,100 --> 00:02:36,350
ასე რომ, მაშინაც კი, თუ ეს ასე არ არის
საბოლოო გამომავალი, რომ ჩვენ რეალურად

48
00:02:36,350 --> 00:02:39,830
გსურთ პროდუქციის გარეთ
ამ პროგრამის, ჩვენ ჯერ კიდევ

49
00:02:39,830 --> 00:02:42,300
ალბათ ზოგიერთი გამართვის
განცხადებები, სადაც ჩვენ

50
00:02:42,300 --> 00:02:46,970
შეგიძლიათ ცდილობენ გაერკვნენ, თუ რა
ხდება შიგნით ჩვენი კოდი.

51
00:02:46,970 --> 00:02:51,210
>> ასე რომ, ამ შემთხვევაში, მე
printf ერთად გამართვის აქვს.

52
00:02:51,210 --> 00:02:53,540
ამ შემთხვევაში, ეს არის
უბრალოდ გამართვის string

53
00:02:53,540 --> 00:02:56,840
რომ მე ვარ up აყენებს ასე რომ ხდება
ძალიან ნათელი გამომავალი ჩემი კოდი

54
00:02:56,840 --> 00:02:59,200
რა არის, რომ მე მინდა გაჩვენოთ.

55
00:02:59,200 --> 00:03:04,410
და გამომავალი აქ რაოდენობის
რომ ჩვენ გამოითვლება.

56
00:03:04,410 --> 00:03:06,800
>> ამ შემთხვევაში, მე შეიძლება
გვინდა ვიცოდეთ, ზუსტად

57
00:03:06,800 --> 00:03:11,380
რა ხდება და მის
მას შემდეგ, რაც კონკრეტული გამოთვლები.

58
00:03:11,380 --> 00:03:16,224
ასე რომ, მე შეიძლება გამოიყენოთ printf ადრე
და ამის შემდეგ ხაზი კოდი.

59
00:03:16,224 --> 00:03:18,640
ამ შემთხვევაში, მე ვერ კი
რათა ის ცოტა უფრო ნათელი

60
00:03:18,640 --> 00:03:21,960
განაცხადა, გამართვის ადრე
და გამართვის შემდეგ,

61
00:03:21,960 --> 00:03:26,540
რომ მე არ აღრეული თავს
სხვადასხვა ხაზები, რომ გამოიყურება იდენტურია.

62
00:03:26,540 --> 00:03:32,290
>> ახლა თუ ჩვენ recompile ამ და პერსპექტივაში
ის, შეიტანეთ ნომერი, როგორიცაა ხუთ ერთხელ,

63
00:03:32,290 --> 00:03:35,090
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს
ახლა გამომავალი და მის შემდეგ

64
00:03:35,090 --> 00:03:40,670
და ნახავთ, რომ ჩვენ არ კეთდება წმინდა
გაყოფა და ნათელი, რომელსაც მთელი რიგი

65
00:03:40,670 --> 00:03:43,680
რომ ჩვენ რეალურად გვინდა გავაკეთოთ.

66
00:03:43,680 --> 00:03:48,660
ახლა ამ შემთხვევაში, ეს არის
არ არის ნათელი გამომავალი.

67
00:03:48,660 --> 00:03:52,440
ეს ნამდვილად არ არის ნათელი შედეგს, რომ
ჩვენ გვინდა out ამ კონკრეტული პროგრამა.

68
00:03:52,440 --> 00:03:54,427
>> და ეს არის, კიდევ ერთხელ,
ცოტა ჩაიფიქრეს.

69
00:03:54,427 --> 00:03:57,510
მაგრამ, ალბათ, ერთ-ერთი რამ, რომ
ჩვენ შეგვიძლია ამის გაკეთება, თუ დაზუსტება განაცხადა

70
00:03:57,510 --> 00:04:01,900
ჩვენ გვინდა, რომ გაყოფა ამ მიერ
2 და დაამატოთ 1-- ასე რომ, სხვა სიტყვებით რომ ვთქვათ,

71
00:04:01,900 --> 00:04:04,550
ჩვენ გვინდა, რომ მრგვალ up-- შემდეგ
ჩვენ შეიძლება ვიცით, რომ ჩვენ შეგვიძლია

72
00:04:04,550 --> 00:04:08,060
გავაკეთოთ, რომ კონკრეტული რამ, ამ შემთხვევაში.

73
00:04:08,060 --> 00:04:14,010
ახლა აქ ჩვენ ვიცით, რომ ჩვენ ვიქნებით
შეუძლია დაამატოთ 1 ჩვენი განახევრდა ნომერი.

74
00:04:14,010 --> 00:04:16,490
>> მოდით recompile ამ
და დაადასტუროს, რომ ეს

75
00:04:16,490 --> 00:04:18,860
იქცევა ისე, რომ ჩვენ გვინდა.

76
00:04:18,860 --> 00:04:21,980
ჩვენ ვხედავთ, რომ ახლა, სანამ
რომელსაც, ჩვენ გვაქვს 5 ნომერი.

77
00:04:21,980 --> 00:04:26,620
მას შემდეგ, რაც, ჩვენ გვაქვს 3,
რომლის თანახმად, ჩვენი დაზუსტება,

78
00:04:26,620 --> 00:04:29,292
არის ის, რაც გვინდოდა ამის გაკეთება.

79
00:04:29,292 --> 00:04:31,000
მაგრამ თუ გადავხედავთ
გამომავალი აქ, ჩვენ შეგვიძლია

80
00:04:31,000 --> 00:04:33,760
ვხედავ, რომ ჩვენ შეიძლება ჰქონდეს სხვა
შეცდომის საერთოდ, რომელიც

81
00:04:33,760 --> 00:04:36,940
რომ ჩვენ ვიწყებთ ჩვენი რაოდენობა 0-დან.

82
00:04:36,940 --> 00:04:39,390
>> ახლა, ეს არის ის,
რომ ჩვენ ვნახეთ წარსულში

83
00:04:39,390 --> 00:04:42,500
და ჩვენ შეგვიძლია დაფიქსირება საკმაოდ ადვილად.

84
00:04:42,500 --> 00:04:44,790
მაგრამ ამ შემთხვევაში, ჩვენ
ასევე მქონდა სასარგებლოდ

85
00:04:44,790 --> 00:04:48,940
გამოყენებით printf განცხადება
პირდაპირ შიგნით ამისთვის loop

86
00:04:48,940 --> 00:04:52,930
ვიცოდეთ, ზუსტად იქ, სადაც
რომ შეცდომა იყო ხდება.

87
00:04:52,930 --> 00:04:55,150
ასე რომ, printf განცხადებები,
ძალიან სასარგებლო ეხმარება

88
00:04:55,150 --> 00:04:57,940
თქვენ განსაზღვრავს, სადაც,
ზუსტად თქვენი კოდის,

89
00:04:57,940 --> 00:05:00,620
სპეციფიური შეცდომა ხდება.

90
00:05:00,620 --> 00:05:03,650
>> და ეს ასევე მნიშვნელოვანია გვესმოდეს
რომ, როგორც ჩვენ წერილობით კოდი,

91
00:05:03,650 --> 00:05:06,052
ჩვენ შეიძლება ვარაუდები
ამის შესახებ სახელმწიფო პროგრამა.

92
00:05:06,052 --> 00:05:08,510
ან ჩვენ შეიძლება ვარაუდები
იმაზე, თუ რა ნაწილი პროგრამა

93
00:05:08,510 --> 00:05:13,020
რეალურად სწორი ან არასწორი, როდესაც
მოგვიანებით, როგორც ჩვენ ავაშენოთ, რომ პროგრამა

94
00:05:13,020 --> 00:05:15,950
და რათა ის ნაწილი
რთული და დიდი პროგრამა

95
00:05:15,950 --> 00:05:19,700
რომ ჩვენ გვესმის, რომ ზოგიერთი ასპექტი
რომ არის რეალურად buggy.

96
00:05:19,700 --> 00:05:22,680
>> გამოყენება printf ნამდვილად დაეხმარება
ვიწრო ქვემოთ და იდენტიფიცირება

97
00:05:22,680 --> 00:05:26,430
რეგიონებში პროგრამა, რომელიც არ შეიძლება
იქცევიან ზუსტად ისე, რომ ჩვენ

98
00:05:26,430 --> 00:05:29,500
ველით, ჩვენი ვარაუდები.

99
00:05:29,500 --> 00:05:31,460
მაგრამ არსებობს სხვა ინსტრუმენტები
შესაძლებელია, აგრეთვე,

100
00:05:31,460 --> 00:05:34,860
რომელიც საშუალებას გვაძლევს, რომ ცდილობენ გაერკვნენ
გარეთ, სადაც შეცდომა ხდება

101
00:05:34,860 --> 00:05:39,930
და ასევე, კონკრეტულად, რა რამ
ხდება შიგნით პროგრამა.

102
00:05:39,930 --> 00:05:41,990
>> ასე გამოყენებით printf ძალიან
სასარგებლო როდესაც ჩვენ გვინდა

103
00:05:41,990 --> 00:05:45,900
იდენტიფიცირება კონკრეტულ სფეროებში
პროგრამა, რომელიც აქვს გარკვეული შეცდომა.

104
00:05:45,900 --> 00:05:47,730
მაგრამ ეს ასევე ხდება
tedious შემდეგ, ხოლო.

105
00:05:47,730 --> 00:05:50,500
ამ შემთხვევაში, ეს არის
შედარებით მარტივი პროგრამა

106
00:05:50,500 --> 00:05:52,750
მხოლოდ ერთი ან ორი ცვლადი.

107
00:05:52,750 --> 00:05:57,260
და ეს ხდება ძალიან ადვილია,
ამობეჭდოთ ღირებულება იმ ცვლადების

108
00:05:57,260 --> 00:05:59,670
ამ კონტექსტში დიდი პროგრამა.

109
00:05:59,670 --> 00:06:02,670
>> მაგრამ ჩვენ შეიძლება ჰქონდეს სხვადასხვა
პროგრამა, რომელიც მრავალი ცვლადი.

110
00:06:02,670 --> 00:06:06,530
და ეს არ შეიძლება იყოს საკმაოდ
ასე მარტივი printf

111
00:06:06,530 --> 00:06:10,120
ცდილობენ შეაფასონ, თუ რა ხდება
ყოველი მათგანი იმ ცვლადების

112
00:06:10,120 --> 00:06:13,590
როგორც პროგრამის შესრულებაში.

113
00:06:13,590 --> 00:06:16,960
არსებობს პროგრამა, რომელიც არსებობს
მოუწოდა debugger პროგრამა.

114
00:06:16,960 --> 00:06:20,320
ამ შემთხვევაში, ერთი, რომ ჩვენ
გამოყენება GNU debugger, ან GDB,

115
00:06:20,320 --> 00:06:24,260
რომელიც საშუალებას გვაძლევს, რათა შეამოწმოს შიდა
დამუშავებული პროგრამა ბევრად უფრო

116
00:06:24,260 --> 00:06:25,700
დეტალურად.

117
00:06:25,700 --> 00:06:28,810
>> ჩვენ შეგვიძლია რეალურად შეასრულოს
GDB იმ ბრძანების

118
00:06:28,810 --> 00:06:35,370
აქ უბრალოდ აკრეფის GDB და
ბრძანება, რომ ჩვენ გვინდა გამართვის.

119
00:06:35,370 --> 00:06:37,550
ამ შემთხვევაში, ითვლიან.

120
00:06:37,550 --> 00:06:41,650
ახლა, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ ეს
მოაქვს სწრაფი, რომელიც ამბობს, GDB.

121
00:06:41,650 --> 00:06:44,020
და ჩვენ შეგვიძლია რეალურად
შეასრულოს ბრძანებები GDB

122
00:06:44,020 --> 00:06:48,260
რეალურად იწყება აღსრულება
პროგრამა, შეჩერება გარკვეული რაოდენობა,

123
00:06:48,260 --> 00:06:51,060
შეაფასოს ცვლადები და
შეამოწმოს ცვლადები, რომ

124
00:06:51,060 --> 00:06:54,152
არსებობს პროგრამა სახელმწიფო
იმ მომენტში,

125
00:06:54,152 --> 00:06:55,110
და ასე შემდეგ და ასე შემდეგ.

126
00:06:55,110 --> 00:06:57,240
ის უზრუნველყოფს ბევრი ძალა ჩვენთვის.

127
00:06:57,240 --> 00:06:59,960
>> მაგრამ ეს ასე მოხდება,
რომ CS50 IDE ასევე

128
00:06:59,960 --> 00:07:05,870
უზრუნველყოფს GUI ან მომხმარებლის
ინტერფეისი GDB, რომ

129
00:07:05,870 --> 00:07:11,120
საშუალებას გვაძლევს, რომ ამის გაკეთება არ არის საჭირო
ბრძანების ხაზი ინტერფეისი განაწილებაზე

130
00:07:11,120 --> 00:07:13,560
ან საერთოდ კი.

131
00:07:13,560 --> 00:07:16,930
ისე, რომ მე შეუძლიათ, რომ
არის გამოყენებით გამართვის ღილაკს

132
00:07:16,930 --> 00:07:20,120
ძალიან ზევით CS50 IDE.

133
00:07:20,120 --> 00:07:24,280
ახლა წარსულში, რაც გვაქვს
ჩანს, რომ ჩვენ გამოვიყენოთ ბრძანება

134
00:07:24,280 --> 00:07:27,660
ხაზი შედგენა და შემდეგ გაუშვით პროგრამა.

135
00:07:27,660 --> 00:07:29,790
>> გამართვის ღილაკს აკეთებს
ორივე ნაბიჯები.

136
00:07:29,790 --> 00:07:34,380
მაგრამ ეს ასევე გამოიტანს
debugger tab on შორს უფლება

137
00:07:34,380 --> 00:07:38,280
რომელიც საშუალებას გვაძლევს, რათა შეამოწმოს სხვადასხვა
თვისებები პროგრამა

138
00:07:38,280 --> 00:07:40,500
რადგან ის შესრულებაში.

139
00:07:40,500 --> 00:07:44,280
თუ მე დააჭირეთ გამართვის, ამ
შემთხვევაში, ეს გამოიტანს

140
00:07:44,280 --> 00:07:48,230
ახალი tab კონსოლში
ფანჯრის დროს ძალიან ბოლოში.

141
00:07:48,230 --> 00:07:51,160
>> და თქვენ შეგიძლიათ ნახოთ, რომ ეს tab აქვს
გარკვეული ინფორმაცია ძალიან დაბრუნება.

142
00:07:51,160 --> 00:07:52,670
და ჩვენ შეგვიძლია მეტწილად ეს.

143
00:07:52,670 --> 00:07:54,800
მაგრამ ერთი რამ
ჩვენ გვინდა, რომ შეამჩნია

144
00:07:54,800 --> 00:07:57,170
ის არის, რომ ეს შედეგები
იგივე, რომ ჩვენ

145
00:07:57,170 --> 00:08:03,000
დაიჭერს თუ ჩვენ შევეცადეთ აწარმოებს მიიღოს on
რომ C პროგრამის ტერმინალის ფანჯარაში.

146
00:08:03,000 --> 00:08:06,230
>> აქ, ჩვენ ვხედავთ, რომ ის გაშვებული clang,
და მას აქვს სხვადასხვა დროშები,

147
00:08:06,230 --> 00:08:12,660
და ის შედგენის ჩვენი count.c ფაილი,
რომელიც შერჩეულ tab დროს

148
00:08:12,660 --> 00:08:15,100
რომ მე მოხვდა გამართვის.

149
00:08:15,100 --> 00:08:18,010
ასე რომ, ეს არის ძალიან სასარგებლო, რადგან
ახლა გამოყენებით ამ გამართვის ღილაკს,

150
00:08:18,010 --> 00:08:23,280
ჩვენ შეგვიძლია ერთდროულად შედგენა და შემდეგ
შეასრულოს პროგრამა, რომელიც ჩვენ, ფაქტობრივად,

151
00:08:23,280 --> 00:08:24,460
გსურთ აწარმოებს.

152
00:08:24,460 --> 00:08:27,880
>> ერთ-ერთი დროშებით, რომ არის
მნიშვნელოვანია, რომ ამ შემთხვევაში,

153
00:08:27,880 --> 00:08:30,190
ჩვენ, ფაქტობრივად, გამოყენებით
ყველაზე გრძელი დრო

154
00:08:30,190 --> 00:08:32,450
არამედ უბრალოდ გააკეთა რაღაც მხრივ
ფრიალი [INAUDIBLE], რომელიც

155
00:08:32,450 --> 00:08:33,820
ეს არის ერთ-ერთი უფლება აქ.

156
00:08:33,820 --> 00:08:35,790
In clang, იგი აცხადებს, რომ -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
ამ შემთხვევაში, რაც ჩვენ ვართ
ვეუბნებოდი clang, ჩვენი შემდგენელი,

159
00:08:41,250 --> 00:08:43,820
ის არის, რომ ჩვენ გვინდა კომპილაციის ჩვენი პროგრამა.

160
00:08:43,820 --> 00:08:46,810
მაგრამ ასევე რა არის
ეწოდება სიმბოლო ინფორმაცია

161
00:08:46,810 --> 00:08:50,940
ისე, რომ შემდგენელი რეალურად აქვს დაშვება
ბევრი ძირითადი ინფორმაცია

162
00:08:50,940 --> 00:08:52,610
შეიცავს პროგრამის ფარგლებში.

163
00:08:52,610 --> 00:08:55,260
>> უფრო კონკრეტულად, ნომერი
ფუნქციები, რომელიც მე მაქვს,

164
00:08:55,260 --> 00:08:58,000
სახელები იმ ფუნქციებს,
ცვლადები, სახის

165
00:08:58,000 --> 00:09:01,730
რომ იმ ცვლადების, და სხვადასხვა
სხვა რამ, რომ დაეხმაროს debugger

166
00:09:01,730 --> 00:09:04,350
შეასრულოს თავისი ოპერაცია.

167
00:09:04,350 --> 00:09:06,600
ახლა არის რაღაც
რომ მნიშვნელოვანია, რომ აღარაფერი ვთქვათ

168
00:09:06,600 --> 00:09:10,280
როდესაც ჩვენ მსჯელობენ გაშვებული
პროგრამის ამ გზით.

169
00:09:10,280 --> 00:09:13,660
>> გაითვალისწინეთ, რომ ეს ფაქტიურად
აღიზარდოს ახალი tab ჩვენს კონსოლი

170
00:09:13,660 --> 00:09:14,780
გასწვრივ ბოლოში.

171
00:09:14,780 --> 00:09:18,600
ჩვენ უკვე აღარ გვაქვს ურთიერთობა
პირდაპირ ტერმინალის ფანჯარაში.

172
00:09:18,600 --> 00:09:21,420
მაგრამ ეს ახალი tab არის
რეალურად ტერმინალის ფანჯარაში.

173
00:09:21,420 --> 00:09:26,710
ეს უბრალოდ არის სპეციფიკური გაშვებული
პროგრამა, რომელიც ჩვენ შევქმენით.

174
00:09:26,710 --> 00:09:29,270
>> გაითვალისწინეთ, რომ ბოლოში,
ერთად ზოგიერთ გამომავალი

175
00:09:29,270 --> 00:09:33,500
მიერ clang შემდგენელი და GDB,
რომელიც ჩვენ შეგვიძლია მეტწილად,

176
00:09:33,500 --> 00:09:37,570
ეს რეალურად გვიჩვენებს გამოშვება
ჩვენი პროგრამა ძალიან ბოლოში.

177
00:09:37,570 --> 00:09:41,240
ახლა ეს მნიშვნელოვანია გვესმოდეს
რომ ეს ერთი ფანჯრის რეალურად

178
00:09:41,240 --> 00:09:43,360
გაჩვენებთ
გამომავალი თქვენი პროგრამის

179
00:09:43,360 --> 00:09:47,190
მაგრამ ასევე შეუძლია მიიღოს შეყვანის
რომ პროგრამა, ისევე.

180
00:09:47,190 --> 00:09:49,260
>> ასე რომ, ცნობა, რომელიც ამბობს,
გთხოვთ შეიყვანოთ ნომერი,

181
00:09:49,260 --> 00:09:53,050
რომელიც არის იგივე გამომავალი, რომ ჩვენ გვქონდა
ჰქონდა ტერმინალის ფანჯარაში ადრე.

182
00:09:53,050 --> 00:09:55,510
მაგრამ ეს ნაჩვენები ამ ახალ tab.

183
00:09:55,510 --> 00:09:56,550
შემიძლია შეყვანის ნომერი.

184
00:09:56,550 --> 00:10:00,900
და ის, ფაქტობრივად,
ფუნქცია, როგორც ჩვენ ველით,

185
00:10:00,900 --> 00:10:05,890
გვიჩვენებს, ჩვენი გამართვის, გამომავალი,
გამომავალი, რომელიც შეიძლება იყოს buggy,

186
00:10:05,890 --> 00:10:07,010
როგორც ჩვენ ვნახეთ ადრე.

187
00:10:07,010 --> 00:10:10,460
და ძალიან ბოლოში, ის
რეალურად აქვს რამდენიმე დამატებითი გამომავალი

188
00:10:10,460 --> 00:10:14,550
საწყისი მშპ-ს უბრალოდ ვამბობ, რომ
ეს პროგრამა დაასრულა.

189
00:10:14,550 --> 00:10:16,655
>> ახლა, როგორც თქვენ ნახეთ ამ
კერძოდ პერსპექტივაში მეშვეობით,

190
00:10:16,655 --> 00:10:19,370
ეს არ იყო განსაკუთრებით
სასარგებლოა, რადგან მაშინაც კი,

191
00:10:19,370 --> 00:10:23,740
მიუხედავად იმისა, რომ ჩვენ გვქონდა debugger მენიუ მოდის
up, ეს იყო ჯერ კიდევ გაშვებული პროგრამა.

192
00:10:23,740 --> 00:10:26,790
ამის აზრი არ გააკეთა ეს, ფაქტობრივად,
პაუზის აღსრულების ჩვენთვის

193
00:10:26,790 --> 00:10:30,767
შეძლებს შეამოწმოს ყველა
ცვლადები შეიცავს.

194
00:10:30,767 --> 00:10:32,850
არსებობს რაღაც
რომ ჩვენ უნდა გავაკეთოთ იმისათვის,

195
00:10:32,850 --> 00:10:36,910
მისაღებად GDB იმის აღიარება, რომ ჩვენ გვინდა
პაუზის აღსრულების პროგრამა

196
00:10:36,910 --> 00:10:42,820
და არა მხოლოდ დაუშვებს, რომ გაგრძელება
ჩვეულებრივ, როგორც ჩვენ გვინდა სხვა შემთხვევაში.

197
00:10:42,820 --> 00:10:45,530
>> იმისათვის, რომ პაუზის შესრულების,
რაღაც კონკრეტული ხაზი,

198
00:10:45,530 --> 00:10:47,830
ჩვენ უნდა შევქმნათ რა არის
მოუწოდა შესვენების წერტილი.

199
00:10:47,830 --> 00:10:52,670
და შესვენების ძალიან ადვილად შექმნა
ამ CS50 IDE აღების თქვენი მაუსის

200
00:10:52,670 --> 00:10:57,090
და დაჭერით პირდაპირ მარცხენა
კონკრეტული ხაზის ნომერი.

201
00:10:57,090 --> 00:10:59,920
მას შემდეგ, რაც მე ამის გაკეთება, წითელი dot
როგორც ჩანს, რაც მიუთითებს,

202
00:10:59,920 --> 00:11:02,300
, რომ ხაზი არის შესვენების წერტილი.

203
00:11:02,300 --> 00:11:07,540
>> და მომავალი დრო, რომ აწარმოებს GDB, ის
შეწყდება შესრულების დროს, რომ შესვენების წერტილი

204
00:11:07,540 --> 00:11:10,280
როდესაც იგი აღწევს, რომ ხაზი კოდი.

205
00:11:10,280 --> 00:11:12,230
ახლა ეს არის მნიშვნელოვანი
რამ უნდა გააცნობიეროს

206
00:11:12,230 --> 00:11:16,140
ის, რომ არ არის აუცილებელი,
იმ შემთხვევაში, რომ ყველა ხაზი კოდი

207
00:11:16,140 --> 00:11:17,880
რეალურად ხელმისაწვდომი.

208
00:11:17,880 --> 00:11:23,780
მე რომ შევქმნათ ფუნქცია
აქ, მაგალითად ბათილად f--

209
00:11:23,780 --> 00:11:31,230
და მხოლოდ ამის ბეჭდვითი ხაზის აქ მიესალმები
world-- თუ მე არასოდეს მოვუწოდებთ ამ ფუნქციის

210
00:11:31,230 --> 00:11:34,770
ეს იქნება საქმე, რომ,
თუ მე მითითებული შესვენების აქ,

211
00:11:34,770 --> 00:11:36,220
ფუნქცია არასოდეს არ იქნება მოუწოდა.

212
00:11:36,220 --> 00:11:38,310
შესაბამისად, ეს
კერძოდ შესვენების წერტილი

213
00:11:38,310 --> 00:11:43,040
არასოდეს რეალურად პაუზის
პროგრამის შესრულება.

214
00:11:43,040 --> 00:11:48,020
>> მოდით ვთქვათ, რომ მე სწორად შექმნა
შესვენების ზოგიერთი ხაზი კოდი

215
00:11:48,020 --> 00:11:50,340
რომელიც რეალურად შესრულდება.

216
00:11:50,340 --> 00:11:53,470
ახლა ამ შემთხვევაში, ეს არის
პირველი ხაზი ძირითად ფუნქციას.

217
00:11:53,470 --> 00:11:56,630
ასე რომ, ეს, რა თქმა უნდა იმ შემთხვევაში,
რომ, როგორც კი დაიწყება აღსრულება,

218
00:11:56,630 --> 00:11:58,580
პირველივე ხაზი იქნება მიღწეული.

219
00:11:58,580 --> 00:12:00,230
GDB პაუზის აღსრულება.

220
00:12:00,230 --> 00:12:04,100
და მაშინ, მე შეძლებს
ურთიერთქმედება debugger.

221
00:12:04,100 --> 00:12:08,480
>> შეგიძლიათ დააყენოთ მრავალი ხაზს
Breakpoints, თუ გსურთ.

222
00:12:08,480 --> 00:12:11,365
ჩვენ ასევე შეგიძლიათ შექმნათ გამოდიან
აქ ამ სეგმენტის კოდი

223
00:12:11,365 --> 00:12:12,490
რომ არასოდეს არ იქნება მიღწეული.

224
00:12:12,490 --> 00:12:14,744
ჩვენ ასევე შეუძლია შექმნას კიდევ ერთი ქვემოთ.

225
00:12:14,744 --> 00:12:16,660
მიზეზის გამო, რომ ჩვენ გვინდა
გსურთ ამის გაკეთება ჩვენ გამოგიგზავნით

226
00:12:16,660 --> 00:12:19,119
წასვლას ცოტა მეტი
დეტალური რაღაც მომენტში.

227
00:12:19,119 --> 00:12:21,660
ასე რომ, ახლა, ნება მომეცით უბრალოდ გამორთოთ
ეს დამატებითი შესვენება რაოდენობა

228
00:12:21,660 --> 00:12:24,940
ასე რომ ჩვენ შეგვიძლია შევხედოთ რა ხდება
როდესაც მე მაქვს ერთი შესვენების

229
00:12:24,940 --> 00:12:27,650
წერტილი ჩემი პროგრამა.

230
00:12:27,650 --> 00:12:29,410
მე მივიღე რამდენიმე
ცვლილებები ამ პროგრამაში.

231
00:12:29,410 --> 00:12:30,750
ასე რომ, მე უნდა შეინახოთ.

232
00:12:30,750 --> 00:12:34,490
მე დააწკაპუნეთ გამართვის ისე, რომ მე არ შემიძლია
დაიწყოს კოლექცია და შემდეგ

233
00:12:34,490 --> 00:12:36,880
აღსრულების debugger.

234
00:12:36,880 --> 00:12:40,632
>> ჩვენ ვხედავთ, რომ მას შემდეგ, რაც მომენტები,
ხაზი, რომ ჩვენ შერჩეული როგორც შესვენების

235
00:12:40,632 --> 00:12:43,360
წერტილი მონიშნულია ყვითელი.

236
00:12:43,360 --> 00:12:47,440
ჩვენ შეგვიძლია ასევე შეამჩნევთ, რომ
ზედა მარჯვენა გამართვის პანელი

237
00:12:47,440 --> 00:12:50,940
რომ პაუზის ხატი იქცა
შევიდა პატარა პიესა ხატი.

238
00:12:50,940 --> 00:12:54,710
ეს იმას ნიშნავს, რომ ჩვენ გვაქვს პაუზის
შესრულების, ამ კონკრეტულ შემთხვევაში.

239
00:12:54,710 --> 00:12:57,840
და დარტყმის Play ღილაკს რომ
საშუალებას გვაძლევს განაახლონ შესრულების

240
00:12:57,840 --> 00:13:00,000
იმ კონკრეტული წერტილი.

241
00:13:00,000 --> 00:13:03,240
>> გავითვალისწინოთ, რომ არსებობს რამდენიმე სხვა
ღილაკები შესაძლებელი ამ გამართვის პანელი,

242
00:13:03,240 --> 00:13:04,220
როგორც.

243
00:13:04,220 --> 00:13:09,470
ჩამოდი, რომელიც საშუალებას იძლევა ჩემთვის
შეასრულოს, რომ ერთი ხაზი კოდი

244
00:13:09,470 --> 00:13:14,030
და ნაბიჯ მეტი რომ ხაზი
შემდეგ, რაც, ამ შემთხვევაში,

245
00:13:14,030 --> 00:13:17,060
იმას ნიშნავს, რომ printf
განაცხადი ხორციელდება.

246
00:13:17,060 --> 00:13:22,310
და ეს მაშინ პაუზის
აღსრულების on line 13, ასე.

247
00:13:22,310 --> 00:13:25,090
>> და არსებობს ასევე ნაბიჯი
შევიდა ფუნქცია, რომელიც

248
00:13:25,090 --> 00:13:28,950
სასარგებლოა თუ მე შევქმენი სხვა
ფუნქციები სხვაგან კოდის.

249
00:13:28,950 --> 00:13:31,420
და მე მინდა დახევას შევიდა
იმ ფუნქციებს, ვიდრე

250
00:13:31,420 --> 00:13:33,050
შეასრულოს, რომ ფუნქცია, როგორც მთელი.

251
00:13:33,050 --> 00:13:37,279
მაგრამ ჩვენ უფრო იმ ნაბიჯი
შევიდა ფუნქცია რაღაც მომენტში.

252
00:13:37,279 --> 00:13:40,320
ახლა შეამჩნია, ზოგიერთი სხვა რამ, რომ
რეალურად არსებობს ამ გამართვის პანელი.

253
00:13:40,320 --> 00:13:44,110
>> ჩვენ გვაქვს პანელი მოუწოდა
მოვუწოდებთ დასტის, რომელიც გვიჩვენებს,

254
00:13:44,110 --> 00:13:45,300
სადაც ზუსტად ვართ.

255
00:13:45,300 --> 00:13:48,550
ამ შემთხვევაში, ჩვენ შიგნით
მთავარი ფუნქცია.

256
00:13:48,550 --> 00:13:50,880
ჩვენი Script მოუწოდა count.c.

257
00:13:50,880 --> 00:13:53,820
და ჩვენ არ უნდა იყოს
line 13, სვეტი ერთი, რომელიც

258
00:13:53,820 --> 00:13:58,950
არის ზუსტად ის, რაც ხაზგასმით რეგიონში
კოდის მიუთითებს, ისევე.

259
00:13:58,950 --> 00:14:02,435
>> ახლა შეამჩნია, რომ ეს ასევე ადასტურებს,
ქვეშ ადგილობრივი ცვლადი განყოფილებაში

260
00:14:02,435 --> 00:14:06,710
ყველა ცვლადები, რომ
არსებობს ამ ფუნქცია.

261
00:14:06,710 --> 00:14:08,930
ეს მნიშვნელოვანია აღინიშნოს,
რომ ყველა ცვლადები

262
00:14:08,930 --> 00:14:12,580
გამოჩნდება ეს ადგილობრივი ცვლადი
მონაკვეთის ფარგლებში ფუნქცია,

263
00:14:12,580 --> 00:14:14,380
კი, სანამ ისინი განისაზღვრება.

264
00:14:14,380 --> 00:14:19,160
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ცვლადი
მოუწოდა num, აქვს, რა მნიშვნელობა 0,

265
00:14:19,160 --> 00:14:21,280
და ეს არის ტიპის int.

266
00:14:21,280 --> 00:14:24,110
>> ახლა, სანამ ჩვენ რეალურად ინიციალიზაცია
ყველა ამ ცვლადების,

267
00:14:24,110 --> 00:14:26,685
ჩვენ არ ემთხვეოდეს
გარანტირებული ვხედავ მნიშვნელობა 0.

268
00:14:26,685 --> 00:14:29,200
და დამოკიდებულია სხვა სიკვდილით დასჯის
რომ თქვენ არ შესრულდა

269
00:14:29,200 --> 00:14:32,020
და სახელმწიფო თქვენი მეხსიერების, როდესაც
თქვენ რეალურად აწარმოებს ამ პროგრამის,

270
00:14:32,020 --> 00:14:34,605
თქვენ ნახავთ, რომ თქვენ
ვერ ვხედავ ღირებულებები 0

271
00:14:34,605 --> 00:14:36,550
და ნაცვლად ამისა, ზოგიერთი სხვა Crazy ნომრები.

272
00:14:36,550 --> 00:14:38,390
>> მაგრამ არ ინერვიულოთ შესახებ.

273
00:14:38,390 --> 00:14:44,610
ეს არ იქნება შესაბამისი, ვიდრე
თქვენ ნამდვილად ინიციალიზაცია ღირებულება.

274
00:14:44,610 --> 00:14:49,630
ახლა, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ
მე არ შესრულდა გარკვეული შედეგები.

275
00:14:49,630 --> 00:14:52,131
და მე, ახლა, შეჩერებულია აღსრულება.

276
00:14:52,131 --> 00:14:53,880
მაგრამ ამ შემთხვევაში, რა
მე ნამდვილად გსურთ ამის გაკეთება

277
00:14:53,880 --> 00:14:58,060
არის ახლა დაიხევს ამ ონლაინ
კოდი ისე, რომ მე შემიძლია რეალურად

278
00:14:58,060 --> 00:15:04,390
შეკითხვის შესახებ, რომ int, რომ
ჩვენ გვინდა გამოვიყენოთ ჩვენი პროგრამა.

279
00:15:04,390 --> 00:15:07,060
>> ახლა ამ შემთხვევაში, როდესაც
მე მოხვდა ნაბიჯი დასრულდა, ცნობა

280
00:15:07,060 --> 00:15:11,940
რომ პაუზა ან საკმაოდ რეზიუმე
ღილაკს შეიცვალა ამ პაუზა ღილაკს

281
00:15:11,940 --> 00:15:14,022
იმიტომ, რომ ეს კოდი რეალურად შესრულებაში.

282
00:15:14,022 --> 00:15:15,730
რა ხდება
ახლა ის არის, რომ

283
00:15:15,730 --> 00:15:21,630
ელოდება us შემავალი ზოგიერთი ინფორმაცია
როგორც ვხედავთ, ჩვენი გამომავალი ტექსტი

284
00:15:21,630 --> 00:15:23,600
ძალიან ბოლოში.

285
00:15:23,600 --> 00:15:25,787
>> ასე რომ, ახლა, ეს არის
რეალურად არ დააყოვნა,

286
00:15:25,787 --> 00:15:28,620
მიუხედავად იმისა, რომ, ერთგვარი, როგორც ჩანს,
იმის გამო, რომ არაფერი არ ხდება.

287
00:15:28,620 --> 00:15:32,360
მაგრამ ეს ასე ხდება, რომ
ჩემი კონკრეტულ შემთხვევაში on line 13

288
00:15:32,360 --> 00:15:34,210
ველოდები მომხმარებლის შეყვანის.

289
00:15:34,210 --> 00:15:39,130
ასე რომ, GDB არ შეუძლია შეამოწმოს
პროგრამა, როგორც ეს არის გაშვებული.

290
00:15:39,130 --> 00:15:43,370
>> ახლა მომავალი დრო, რომ მე შეიყვანოთ
შეყვანის ასე რომ მე შევა, რომ ნომერი 5,

291
00:15:43,370 --> 00:15:46,140
როგორც ჩვენ ვნახეთ
past-- მოხვდა დაბრუნება, და ჩვენ

292
00:15:46,140 --> 00:15:51,430
შეამჩნია, რომ დაუყოვნებლივ, GDB პაუზებით
და კიდევ ერთხელ, ხაზს უსვამს, რომ მომდევნო ხაზი.

293
00:15:51,430 --> 00:15:55,320
მაგრამ შეამჩნია, რომ ახლა, როგორც
შედეგი ჩვენი შესაყვანი მნიშვნელობა,

294
00:15:55,320 --> 00:15:58,930
ჩვენ ახლდება, რომ ღირებულება შიგნით
ჩვენი ადგილობრივი ცვლადები, რომელიც

295
00:15:58,930 --> 00:16:05,560
ძალიან სასარგებლოა ვიცი ზუსტად
რა რიცხვი იყო მეხსიერებაში.

296
00:16:05,560 --> 00:16:10,650
>> ახლა შემიძლია საშუალებას ეს პროგრამა გაგრძელდება
სათამაშო ბოლომდე მისი შესრულების

297
00:16:10,650 --> 00:16:12,570
დარტყმის რეზიუმე.

298
00:16:12,570 --> 00:16:16,410
ჩვენ ვხედავთ, რომ ძალიან სწრაფად
რა პროგრამა ფერი შესრულებაში

299
00:16:16,410 --> 00:16:19,790
იგივე გამომავალი, რომ ჩვენ
ჰქონდა ადრე, debugger იხურება,

300
00:16:19,790 --> 00:16:23,170
და ახლა ამ პროგრამის
მთლიანად შეწყვეტილია.

301
00:16:23,170 --> 00:16:25,320
>> მე აჩვენებს, რომ მხოლოდ
მიზნებისათვის ხედავს, თუ რა

302
00:16:25,320 --> 00:16:27,280
ხდება, როდესაც ჩვენ რეალურად მოხვდა რეზიუმე.

303
00:16:27,280 --> 00:16:30,640
მაგრამ ჩვენ რეალურად ვაპირებთ
მინდა, რომ დაბრუნდეს ამ პროგრამის

304
00:16:30,640 --> 00:16:33,820
ასე რომ ჩვენ შეგვიძლია ცდილობენ გამართვის
ზუსტად რა ხდება.

305
00:16:33,820 --> 00:16:37,980
ახლა, მე გამოყენებით debugger, მე შეიძლება
არ გვჭირდება ამ გამართვის printf განცხადებები.

306
00:16:37,980 --> 00:16:43,860
>> ასე რომ მე ვერ ამოიღონ მათ, როგორც მე ყველაფერს გავაკეთებ
ახლა უბრალოდ უნდა დავუბრუნდეთ მარტივი კოდი

307
00:16:43,860 --> 00:16:45,950
რომ ჩვენ გვქონდა მომენტში წინ.

308
00:16:45,950 --> 00:16:48,790
ახლა, როდესაც მე გადარჩენა
პროგრამა და შეასრულოს ის,

309
00:16:48,790 --> 00:16:53,700
ეს იქნება, ერთხელ, რომ საწყის
შესვენება წერტილი, რომელიც მე მქონდა on line 11.

310
00:16:53,700 --> 00:16:57,700
და მე გექნებათ შეამოწმოს
ჩემი ცვლადები როგორც მე მინდა ამის გაკეთება.

311
00:16:57,700 --> 00:17:00,695
>> ეს უბრალოდ ისე ხდება, რომ ეს
ნაწილი არის ძალიან საინტერესო,

312
00:17:00,695 --> 00:17:04,364
და მე ვიცი, რომ მე ვაპირებ
ბეჭდვა ეს განცხადება.

313
00:17:04,364 --> 00:17:05,280
გთხოვთ შეიყვანოთ ნომერი.

314
00:17:05,280 --> 00:17:08,099
და მაშინ, მე ვიცი, რომ მე ვაპირებ
ვთხოვო შესახებ, რომ რიცხვი.

315
00:17:08,099 --> 00:17:13,329
ასე რომ, ალბათ, მე რეალურად მინდა გადავიდეს ჩემი
შესვენების წერტილი ცოტა უფრო ქვემოთ.

316
00:17:13,329 --> 00:17:16,710
>> შეგიძლიათ ამოიღონ შესვენების რაოდენობა
დაჭერით, კიდევ ერთხელ, პირდაპირ

317
00:17:16,710 --> 00:17:18,460
მარცხნივ, რომ ხაზის ნომერი.

318
00:17:18,460 --> 00:17:22,200
ეს წითელი dot გაქრება, რაც მიუთითებს,
, რომ შესვენების წერტილი არის წასული.

319
00:17:22,200 --> 00:17:24,780
ახლა, ამ შემთხვევაში,
აღსრულების შეჩერებულია.

320
00:17:24,780 --> 00:17:27,770
ასე რომ, ეს რეალურად არ აპირებს
განახლდეს, რომ კონკრეტულ შემთხვევაში.

321
00:17:27,770 --> 00:17:30,210
მაგრამ მე შემიძლია მითითებული შესვენების
მეტიც, ცოტა მოგვიანებით.

322
00:17:30,210 --> 00:17:33,880
>> და როდესაც მე ახლა განაახლებს ჩემი
კოდი, იგი აღდგება და ვუთხრა

323
00:17:33,880 --> 00:17:36,190
თვალსაზრისით, რომ შესვენების წერტილი.

324
00:17:36,190 --> 00:17:37,374
ისევ და ისევ, მე მოხვდა რეზიუმე.

325
00:17:37,374 --> 00:17:39,040
არ ჩანს როგორც არაფერი ხდება.

326
00:17:39,040 --> 00:17:41,450
მაგრამ ეს იმიტომ, რომ ჩემი
კოდი ელოდება შეყვანის.

327
00:17:41,450 --> 00:17:47,900
მე შევა ნომერი 5, Enter, და
ახლა შემდეგი შესვენების წერტილი იქნება მოხვდა.

328
00:17:47,900 --> 00:17:50,570
>> ახლა, ამ შემთხვევაში, ეს
არის ხაზი კოდი

329
00:17:50,570 --> 00:17:53,820
რომ, სანამ ჩვენ ვიცოდით,
მოხდა, რომ buggy.

330
00:17:53,820 --> 00:17:57,590
მოდით შევაფასოთ, რა ხდება,
ამ კონკრეტულ მომენტში.

331
00:17:57,590 --> 00:18:02,620
როდესაც ხაზი გაუსვა ხაზი, რომ ეს
ხაზი ჯერ კიდევ არ არის შესრულებული.

332
00:18:02,620 --> 00:18:06,490
ასე რომ, ამ შემთხვევაში, ჩვენ ვხედავთ,
რომ მე მაქვს ნომერი, რომელიც

333
00:18:06,490 --> 00:18:11,610
მე მაქვს მთელი მოუწოდა
num რომ აქვს მნიშვნელობა 5.

334
00:18:11,610 --> 00:18:15,090
და მე ვაპირებ ასრულებენ
ზოგიერთი მათემატიკის, რომ ნომერი.

335
00:18:15,090 --> 00:18:20,130
>> თუ მე ნაბიჯი მეტი რომ, ჩვენ შეგვიძლია
შეამჩნია, რომ მნიშვნელობა num

336
00:18:20,130 --> 00:18:23,780
შეიცვალა შესაბამისად
არითმეტიკული რომ ჩვენ რეალურად გაკეთდეს.

337
00:18:23,780 --> 00:18:26,810
და ახლა, რომ ჩვენ ვართ
შიგნით ამ loop

338
00:18:26,810 --> 00:18:29,090
ან ახლა, რომ ამისთვის loop
თავად არის ასახული,

339
00:18:29,090 --> 00:18:32,450
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ახალი
ცვლადში მე რომ

340
00:18:32,450 --> 00:18:35,370
იქნება გამოყენებული, რომ მარყუჟი.

341
00:18:35,370 --> 00:18:38,230
>> ახლა მახსოვს ადრე, რომ მე
აღინიშნა, რომ ზოგჯერ თქვენ

342
00:18:38,230 --> 00:18:43,470
აპირებს, რომ ზოგიერთი სახის გიჟები
ნომრები, როგორც ნაგულისხმები ადრე, რომ ნომერი

343
00:18:43,470 --> 00:18:45,530
ან, რომ ცვლადი
რეალურად ინიციალიზაცია.

344
00:18:45,530 --> 00:18:49,040
ჩვენ ვხედავთ, რომ ზუსტად
აქ ამ ცვლადის

345
00:18:49,040 --> 00:18:51,345
მოუწოდა i, რომელსაც არა
ჯერ ინიციალიზაცია

346
00:18:51,345 --> 00:18:53,560
დროს ხაზს უსვამს.

347
00:18:53,560 --> 00:18:57,070
მაგრამ ჩვენ ვხედავთ, რომ მას აქვს გარკვეული რაოდენობის
, რომ ჩვენ რეალურად არ ელის.

348
00:18:57,070 --> 00:18:57,620
>> არაუშავს.

349
00:18:57,620 --> 00:18:59,661
არ ინერვიულოთ შესახებ
იმიტომ, რომ ჩვენ არ რეალურად

350
00:18:59,661 --> 00:19:04,970
ინიციალიზაცია, რომ ნომერი, სანამ მე
გადადგას ამ ონლაინ და ღირებულება

351
00:19:04,970 --> 00:19:08,560
i უკვე ინიციალიზაცია ღირებულება 1.

352
00:19:08,560 --> 00:19:11,400
ასე, რომ ნახოთ, რომ სინამდვილეში
იმ შემთხვევაში, მოდით გადადგას მეტი.

353
00:19:11,400 --> 00:19:14,420
ჩვენ ახლა ვხედავთ, რომ
ხაზი უკვე შესრულებული.

354
00:19:14,420 --> 00:19:17,000
და ჩვენ ახლა ხაზს უსვამს
ამ printf ხაზი.

355
00:19:17,000 --> 00:19:22,230
>> ჩვენ ახლა ვხედავთ, თუ ჩვენი ღირებულებები
მე და 3 შეიცვალა დროთა განმავლობაში.

356
00:19:22,230 --> 00:19:26,450
ეს არის ძალიან სასარგებლო, ფაქტობრივად,
არის გადადგას მეტი ხაზები არაერთხელ.

357
00:19:26,450 --> 00:19:30,480
და ნახავთ, თუ რეალურად რა
ხდება შიგნით თქვენი ამისთვის loop

358
00:19:30,480 --> 00:19:33,660
და რა მოხდება,
ცვლადის შიგნით რომ მარყუჟი

359
00:19:33,660 --> 00:19:39,200
იმის გამო, რომ პროგრამის შესრულების
ხდება ერთი ნაბიჯი იმ დროს.

360
00:19:39,200 --> 00:19:41,110
>> ახლა ამ ეტაპზე, მე
გადააბიჯეს მხოლოდ საკმარისი

361
00:19:41,110 --> 00:19:44,210
რომ მე ახლა ვარ ბოლოს ჩემი პროგრამა.

362
00:19:44,210 --> 00:19:46,980
თუ მე ნაბიჯი მეტი რომ, ეს იქნება
კი აღარ შესრულების

363
00:19:46,980 --> 00:19:48,860
როგორც ვნახეთ წარსულში.

364
00:19:48,860 --> 00:19:52,110
მიადევნე თვალი გადატვირთეთ ეს, კიდევ ერთხელ, ასე რომ,
რომ მე შემიძლია აღვნიშნო რაღაც out,

365
00:19:52,110 --> 00:19:53,320
როგორც.

366
00:19:53,320 --> 00:19:55,350
>> ამ შემთხვევაში, ეს არის
ახლა მთხოვდნენ, კიდევ ერთხელ,

367
00:19:55,350 --> 00:19:57,100
რიგი, რომელიც
მე, კიდევ ერთხელ, შევა.

368
00:19:57,100 --> 00:20:00,300
მაგრამ ამ დროს, მე ვაპირებ შევა
დიდი რაოდენობის ისე, რომ ამისთვის loop

369
00:20:00,300 --> 00:20:02,540
იქნება iterate ჯერ.

370
00:20:02,540 --> 00:20:06,090
ამ შემთხვევაში, მე ვაპირებ
შესვლის ღირებულება 11.

371
00:20:06,090 --> 00:20:08,390
>> ახლა ისევ იმიტომ, რომ მე მინდა მითითებული
შესვენების წერტილი line 15,

372
00:20:08,390 --> 00:20:10,490
ის აპირებს, რომ ხაზი გავუსვა, რომ ხაზი.

373
00:20:10,490 --> 00:20:12,980
ჩვენ ვხედავთ, რომ ჩვენი
ნომერი 11 არის სწორად

374
00:20:12,980 --> 00:20:15,560
წარმოდგენილია ჩვენი ადგილობრივი ცვლადები.

375
00:20:15,560 --> 00:20:22,460
Stepping გამო, რომ, ჩვენ შეგვიძლია ახლა
უყურეთ რა მოსდის ჩვენს ღირებულება i

376
00:20:22,460 --> 00:20:25,680
როგორც ვაგრძელებთ შიგნით ამ loop.

377
00:20:25,680 --> 00:20:31,960
იგი იღებს incremented ყოველ ჯერზე ჩვენ
მიღწევა ზევით რომ მარყუჟი.

378
00:20:31,960 --> 00:20:35,110
>> ახლა ერთი რამ, რომ შეიძლება
სასარგებლო იყოს უნდა გავაკეთოთ დროს აღსრულების

379
00:20:35,110 --> 00:20:40,490
ამ პროგრამის ჩემთვის რეალურად
შეცვალოთ ცვლადის midstream ვხედავ

380
00:20:40,490 --> 00:20:42,450
რა მოხდება, რომ ჩემი პროგრამა.

381
00:20:42,450 --> 00:20:46,540
ამ შემთხვევაში, მე შემიძლია რეალურად
ორჯერ დააწკაპუნეთ მნიშვნელობა.

382
00:20:46,540 --> 00:20:48,040
გაითვალისწინეთ, რომ ეს ხდება ველში.

383
00:20:48,040 --> 00:20:50,280
>> ახლა შემიძლია შემოსვლა სხვადასხვა
ვაფასებთ საერთოდ

384
00:20:50,280 --> 00:20:55,700
როგორ ჩემი პროგრამა ისე იქცევა
როდესაც მე შეიცვალა, რომ ცვლადი.

385
00:20:55,700 --> 00:20:59,560
ახლა ამ შემთხვევაში, ცვლადი
ახლა მე შეიცავს ღირებულების 10.

386
00:20:59,560 --> 00:21:02,810
მაგრამ პროგრამა ჯერ კიდევ
ათვისება აღსრულება.

387
00:21:02,810 --> 00:21:07,610
როდესაც მე ნაბიჯ მეტი, მე ვხედავ, რომ
მნიშვნელობა i, რომელიც მე შევიდა, როგორც 10,

388
00:21:07,610 --> 00:21:12,170
არ არის უფრო დიდი, ვიდრე ღირებულება num,
რომელიც მაშინვე იწვევს for loop

389
00:21:12,170 --> 00:21:14,240
შეჩერება შესრულებაში.

390
00:21:14,240 --> 00:21:16,210
>> ახლა, რომ ეს არ არის მხოლოდ
მიზეზი, თუ რატომ გვინდა

391
00:21:16,210 --> 00:21:19,450
შესაცვლელი ცვლადი ადგილზე.

392
00:21:19,450 --> 00:21:22,210
თქვენ შესაძლოა, რეალურად სურს
ცდილობენ ცვლილებები მას ასე

393
00:21:22,210 --> 00:21:24,590
რომ შეგიძლიათ გაგრძელდება
აღსრულების loop

394
00:21:24,590 --> 00:21:27,370
ან ისე, რომ თქვენ შეგიძლიათ შეცვალოთ
გარკვეული მნიშვნელობა, სანამ ეს

395
00:21:27,370 --> 00:21:32,630
აღწევს ზოგიერთი კონკრეტული ნაკრები არითმეტიკული
, რომ თქვენ უნდა შეასრულოს.

396
00:21:32,630 --> 00:21:36,210
>> ახლა, რომ ჩვენ რეალურად შეცვლის
ღირებულება მე როგორც პროგრამა შესრულებაში,

397
00:21:36,210 --> 00:21:39,540
ეს გამოწვეულია იმ მარყუჟის დატოვა
ნაადრევად იმიტომ, რომ უეცრად, i

398
00:21:39,540 --> 00:21:42,770
მოხდა, რომ უფრო მეტი, ვიდრე ღირებულება
საქართველოს num, რაც იმას ნიშნავს, რომ რომ მარყუჟი

399
00:21:42,770 --> 00:21:45,410
აღარ არის საჭირო შესრულდება.

400
00:21:45,410 --> 00:21:48,780
გარდა ამისა, მოხდა ისე, რომ
საქმე, რომელიც ჩვენ შევცვალეთ ღირებულება i

401
00:21:48,780 --> 00:21:53,270
მაშინ, როცა ხაზი 17 ხაზგასმით აღინიშნა,
რომელიც იყო მომენტში

402
00:21:53,270 --> 00:21:56,280
რომ ამისთვის loop შესრულების
იყო რეალურად მიმდინარეობს შეაფასა.

403
00:21:56,280 --> 00:22:00,210
>> თუ მე შეიცვალა ღირებულება
i სხვადასხვა ხაზი, ვთქვათ, 19,

404
00:22:00,210 --> 00:22:03,360
ჩვენ ვნახეთ სხვადასხვა
ქცევა, რადგან ხაზი 19

405
00:22:03,360 --> 00:22:08,310
შესრულებული ადრე ციკლი
მდგომარეობა reevaluated.

406
00:22:08,310 --> 00:22:11,900
ახლა ამ ეტაპზე, მე, კიდევ ერთხელ,
ბოლოს ეს პროგრამა.

407
00:22:11,900 --> 00:22:15,707
და შემიძლია დაუშვებს, რომ გაგრძელება
საშუალებას ჩემი პროგრამა დატოვა ბუნებრივია.

408
00:22:15,707 --> 00:22:18,290
მაგრამ არსებობს რამდენიმე რამ,
რომელიც მნიშვნელოვანია წართმევას

409
00:22:18,290 --> 00:22:19,960
ამ კონკრეტულ დისკუსია.

410
00:22:19,960 --> 00:22:22,490
თქვენ უნდა შეაფასოს
საკუთარი ვარაუდები

411
00:22:22,490 --> 00:22:24,710
იმაზე, თუ როგორ კოდი უნდა იქცევა.

412
00:22:24,710 --> 00:22:28,220
თუ თქვენ ფიქრობთ, რომ ზოგიერთი ცალი
კოდი თქვენ იცით ხდება მუშაობა,

413
00:22:28,220 --> 00:22:30,940
რომ შეიძლება იყოს წითელი დროშა წასვლა
უკან და შეაფასოს, და რა თქმა უნდა

414
00:22:30,940 --> 00:22:33,470
რომ თქვენი ვარაუდი
როგორ, რომ კოდი ფუნქციონირებს

415
00:22:33,470 --> 00:22:38,290
სინამდვილეში, თუ როგორ არის
გამოიხატება თქვენი კოდის.

416
00:22:38,290 --> 00:22:41,300
>> მაგრამ კიდევ უფრო წერტილი იყო,
როდესაც ჩვენ გამოყენებით debugger,

417
00:22:41,300 --> 00:22:43,920
თქვენ შეგიძლიათ განათავსოთ breakpoints ზე
სხვადასხვა ხაზების კოდი,

418
00:22:43,920 --> 00:22:48,110
რაც გამოიწვევს debugger რომ
პაუზის შესრულების დროს თითოეული იმ ხაზები

419
00:22:48,110 --> 00:22:52,210
ასე რომ თქვენ შეგიძლიათ შეაფასოთ
მეხსიერების ან თუნდაც შეცვალოს ეს ადგილი.

420
00:22:52,210 --> 00:22:55,630
ისევ და ისევ, გახსოვდეთ, რომ თქვენ შეუძლია
შექმნათ მრავალი breakpoints ისე, რომ თქვენ

421
00:22:55,630 --> 00:23:00,390
ასევე შეგიძლიათ განაახლონ აღსრულება, გაფართოებული
მეტი დიდი ნაწილი კოდი,

422
00:23:00,390 --> 00:23:04,790
და ეს თქვენ ავტომატურად პაუზის
მომდევნო შესვენების წერტილი.

423
00:23:04,790 --> 00:23:07,760
>> არსებობს ფაქტიურად უფრო მოწინავე
თვისებები debugger, ისევე.

424
00:23:07,760 --> 00:23:10,170
მაგრამ ჩვენ უნდა მიმართოს თქვენ
ზოგიერთი მომდევნო ვიდეოები

425
00:23:10,170 --> 00:23:14,090
იმისათვის, რომ რეალურად აჯავრებენ გარდა, თუ როგორ
გამოიყენოს იმ კონკრეტული ფუნქციები.

426
00:23:14,090 --> 00:23:15,990
ახლა, მადლობა
ძალიან ბევრი უყურებს.

427
00:23:15,990 --> 00:23:18,080
და წარმატებას debugging.