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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Γεια σου,
Είμαι [? Dan Armadaras;].

3
00:00:02,350 --> 00:00:04,410
Σήμερα, θα πάμε να
να κοιτάζει τον εντοπισμό σφαλμάτων.

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
εντός του IDE CS50 που επιτρέπουν
σας για να διορθώσετε εύκολα ένα πρόγραμμα.

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
εδώ αν είμαστε έξοδο, απλά, 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
>> Στη γραμμή 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
Σε αυτήν την περίπτωση, αυτό είναι
μόνο ένα debug εγχόρδων

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
λέγοντας debug πριν
και τον εντοπισμό σφαλμάτων μετά από τόσες

61
00:03:21,960 --> 00:03:26,540
ότι δεν συγχέεται με τον εαυτό μου
πολλαπλές γραμμές που μοιάζουν πανομοιότυπα.

62
00:03:26,540 --> 00:03:32,290
>> Τώρα, αν αυτό το μεταγλωττίσετε ξανά και να τρέξει
αυτό, εισάγετε έναν αριθμό σαν πέντε και πάλι,

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
Δεν είναι πραγματικά ένα σαφές αποτέλεσμα που
θέλουμε από αυτό το συγκεκριμένο πρόγραμμα.

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
>> Ας μεταγλωττίσετε ξανά αυτό
και να επιβεβαιώσει ότι αυτό

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
δείτε ότι θα μπορούσαμε να έχουμε ένα άλλο
bug εντελώς, η οποία είναι

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
απευθείας μέσα από το βρόχο for

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
να συνειδητοποιήσουμε ότι κάποια πτυχή
από ότι είναι στην πραγματικότητα λάθη.

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
Αλλά καθίσταται επίσης
κουραστικό μετά από λίγο.

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
Υπάρχει ένα πρόγραμμα που υπάρχει
ονομάζεται ένα πρόγραμμα εντοπισμού σφαλμάτων.

114
00:06:16,960 --> 00:06:20,320
Στην περίπτωση αυτή, ο ένας ότι θα
χρήση είναι το πρόγραμμα εντοπισμού σφαλμάτων GNU, ή 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
παρέχει ένα γραφικό περιβάλλον ή σε ένα χρήστη
διεπαφή για 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
Ο τρόπος που μπορώ να έχω πρόσβαση ότι
είναι με τη χρήση του κουμπιού debug

132
00:07:16,930 --> 00:07:20,120
στην κορυφή του IDE CS50.

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
>> Το κουμπί κάνει debug
δύο από αυτά τα βήματα.

136
00:07:29,790 --> 00:07:34,380
Αλλά, επίσης, θα εμφανιστεί η
καρτέλα εντοπισμού σφαλμάτων για την άκρα δεξιά

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
μια νέα καρτέλα στην κονσόλα
παράθυρο στο κάτω μέρος.

141
00:07:48,230 --> 00:07:51,160
>> Και μπορείτε να δείτε ότι αυτή η καρτέλα έχει
ορισμένες πληροφορίες στην κορυφή.

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
θα έπαιρνε αν προσπαθήσαμε να κάνει για
Το πρόγραμμα C στο παράθυρο τερματικού.

146
00:08:03,000 --> 00:08:06,230
>> Εδώ, μπορούμε να δούμε ότι τρέχει κλαγγή,
και έχει μια ποικιλία από σημαίες,

147
00:08:06,230 --> 00:08:12,660
και έχει την κατάρτιση φακέλου count.c μας,
η οποία ήταν η επιλεγμένη καρτέλα στο χρόνο

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
αλλά και απλά έκανε κάποιες χέρι
κουνώντας [δεν ακούγεται], η οποία

155
00:08:32,450 --> 00:08:33,820
Είναι αυτό ακριβώς εδώ.

156
00:08:33,820 --> 00:08:35,790
Σε κλαγγή, λέει -ggdb3.

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

158
00:08:38,570 --> 00:08:41,250
Σε αυτή την περίπτωση, τι είμαστε
λέει κλαγγή, compiler μας,

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
έτσι ώστε ο compiler έχει πράγματι πρόσβαση
σε μια παρτίδα των υποκείμενων πληροφοριών

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
ότι οι μεταβλητές είναι, και μια ποικιλία
άλλα πράγματα που βοηθούν το πρόγραμμα εντοπισμού σφαλμάτων

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
>> Παρατηρήστε ότι έχει πράγματι
ανατραφεί μια νέα καρτέλα σε κονσόλα μας

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
Αλλά αυτή η νέα καρτέλα είναι
στην πραγματικότητα ένα παράθυρο τερματικού.

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
κλαγγή από τον compiler και 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
Αλλά είναι τώρα εμφανίζονται σε αυτό νέα καρτέλα.

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
δείχνοντάς μας εντοπισμού σφαλμάτων μας, την παραγωγή,
η έξοδος που μπορεί να είναι προβληματικό,

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
αν και είχαμε το μενού εντοπισμού σφαλμάτων έρχονται
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
Μόλις γίνει αυτό, μια κόκκινη κουκκίδα
Φαίνεται, γεγονός που δείχνει

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
Εάν επρόκειτο να δημιουργήσετε μια συνάρτηση
εδώ, για example-- άκυρη f--

209
00:11:23,780 --> 00:11:31,230
και απλά να κάνουμε μια γραμμή εκτύπωσης here-- γεια
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
Και τότε, θα είμαι σε θέση να
αλληλεπιδρούν με το πρόγραμμα εντοπισμού σφαλμάτων.

221
00:12:04,100 --> 00:12:08,480
>> Μπορείτε να ορίσετε πολλαπλές γραμμές
σημεία παύσης, αν θέλετε.

222
00:12:08,480 --> 00:12:11,365
Μπορούμε επίσης να δημιουργήσετε ένα line up
εδώ σε αυτό το τμήμα του κώδικα

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
εκτέλεση του προγράμματος εντοπισμού σφαλμάτων.

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
>> Σημειώστε ότι υπάρχει ένα ζευγάρι των άλλων
κουμπιά διατίθενται σε αυτό το debug πίνακα,

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
και βήμα πάνω σε αυτή τη γραμμή για το
επόμενο One, η οποία, στην περίπτωση αυτή,

245
00:13:14,030 --> 00:13:17,060
θα σήμαινε ότι η printf
Δήλωση εκτελείται.

246
00:13:17,060 --> 00:13:22,310
Και τότε θα παύση
εκτέλεση επί της γραμμής 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
Τώρα παρατηρήσετε κάποια άλλα πράγματα που
υπάρχουν στην πραγματικότητα μέσα σε αυτό το debug πίνακα.

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
Και τυχαίνει να είναι σε
γραμμή 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
και, αντ 'αυτού, ορισμένα άλλα τρελός αριθμούς.

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
ότι η Παύση ή μάλλον το βιογραφικό
κουμπί έχει αλλάξει σε αυτό το κουμπί Pause

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
μας περιμένει στην είσοδο κάποιες πληροφορίες
όπως μπορούμε να δούμε από το κείμενο εξόδου μας

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
Αλλά ακριβώς έτσι συμβαίνει ότι σε
συγκεκριμένη περίπτωση μου επί της γραμμής 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
>> Τώρα, η επόμενη φορά που μπαίνω μερικά
input-- γι 'αυτό θα εισάγετε τον αριθμό 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
με το ίδιο αποτέλεσμα που θα
είχε πριν, το πρόγραμμα εντοπισμού σφαλμάτων κλείνει,

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
έτσι ώστε να μπορούμε να προσπαθήσουμε να debug
ακριβώς τι συμβαίνει.

305
00:16:33,820 --> 00:16:37,980
Τώρα που είμαι χρησιμοποιώντας το πρόγραμμα εντοπισμού σφαλμάτων, μου επιτρέπετε
Δεν χρειάζεται να διορθώσετε αυτές τις δηλώσεις 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
θα, και πάλι, πηγαίνετε στην αρχική
σπάσει το σημείο που είχα στη γραμμή 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
Αυτό κόκκινη κουκκίδα θα εξαφανιστούν, αναφέροντας
ότι το σημείο καμπής είναι πλέον φύγει.

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
ότι, πριν, ξέραμε
έτυχε να είναι προβληματικό.

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
Και τώρα που είμαστε
στο εσωτερικό του αυτό για βρόχο

338
00:18:26,810 --> 00:18:29,090
ή τώρα ότι ο βρόχος for
να είναι επιλεγμένο,

339
00:18:29,090 --> 00:18:32,450
βλέπουμε ότι έχουμε μια νέα
μεταβλητή που ονομάζεται i ότι

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
>> Και μπορούμε τώρα να δούμε πώς οι αξίες μας
των i και 3 έχουν αλλάξει με την πάροδο του χρόνου.

356
00:19:22,230 --> 00:19:26,450
Αυτό είναι πολύ χρήσιμο να κάνουμε, στην πραγματικότητα,
είναι να το βήμα πάνω από τις γραμμές επανειλημμένα.

357
00:19:26,450 --> 00:19:30,480
Και μπορείτε να βρείτε αυτό που πραγματικά
συμβαίνει στο εσωτερικό του για το βρόχο σας

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
Επιτρέψτε μου να επανεκκινήσετε αυτό, ακόμη μια φορά, έτσι
ότι μπορώ να επισημάνω και κάτι άλλο έξω,

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
Αλλά αυτή τη φορά, Πάω να εισέλθουν στην
μεγαλύτερος αριθμός έτσι ώστε ο βρόχος for

369
00:20:00,300 --> 00:20:02,540
θα επαναλάβει περισσότερες φορές.

370
00:20:02,540 --> 00:20:06,090
Σε αυτήν την περίπτωση, θα πάω
για να εισάγετε μια τιμή των 11.

371
00:20:06,090 --> 00:20:08,390
>> Τώρα και πάλι γιατί είχα οριστεί
ένα σημείο καμπής στη γραμμή 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
Ενίσχυση πάνω από αυτό, μπορούμε τώρα
δείτε τι συμβαίνει με την αξία μας i

376
00:20:22,460 --> 00:20:25,680
καθώς προχωράμε μέσα από αυτό για το βρόχο.

377
00:20:25,680 --> 00:20:31,960
Παίρνει αυξάνεται κάθε φορά που
φτάσετε στην κορυφή του ότι για βρόχο.

378
00:20:31,960 --> 00:20:35,110
>> Τώρα, ένα από τα πράγματα που θα μπορούσαν να
είναι χρήσιμο να κάνουμε κατά τη διάρκεια της εκτέλεσης

379
00:20:35,110 --> 00:20:40,490
αυτού του προγράμματος είναι για μένα πραγματικά
αλλάξετε το μέσο του ποταμού μεταβλητές για να δείτε

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
Τώρα, στην περίπτωση αυτή, η μεταβλητή
i περιέχει τώρα την τιμή 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

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
ότι μπορείτε να συνεχίσετε
εκτέλεση ενός βρόχου

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
>> Έτσι τώρα που πραγματικά να αλλάξει η
αξία του i ως το πρόγραμμα εκτέλεσης,

397
00:21:36,210 --> 00:21:39,540
προκάλεσε το βρόχο για να σταματήσουν το κάπνισμα
πρόωρα, διότι, ξαφνικά, θ

398
00:21:39,540 --> 00:21:42,770
έτυχε να είναι μεγαλύτερη από την αξία
του υπ 'αριθμ, πράγμα που σημαίνει ότι για βρόχο

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
έχουν εκτελεστεί πριν από το βρόχο
κατάσταση επανεκτιμήθηκε.

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
>> Αλλά ακόμη περισσότερο με το σημείο ήταν
όταν χρησιμοποιείτε το πρόγραμμα εντοπισμού σφαλμάτων,

417
00:22:41,300 --> 00:22:43,920
μπορείτε να βάλετε σε σημεία διακοπής
διαφορετικές γραμμές κώδικα,

418
00:22:43,920 --> 00:22:48,110
το οποίο θα προκαλέσει το πρόγραμμα εντοπισμού σφαλμάτων για
παύση εκτέλεσης σε καθεμία από τις γραμμές

419
00:22:48,110 --> 00:22:52,210
έτσι ώστε να μπορείτε να αξιολογήσετε το
μνήμη ή ακόμα και την αλλαγή του τόπου.

420
00:22:52,210 --> 00:22:55,630
Και πάλι, να θυμάστε ότι μπορείτε να κάνετε
δημιουργήσετε πολλαπλά σημεία διακοπής, έτσι ώστε να

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
>> Υπάρχει στην πραγματικότητα πιο προηγμένη
χαρακτηριστικά του διορθωτή, όπως καλά.

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
Και καλή τύχη εντοπισμού σφαλμάτων.