1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Εβδομάδα 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Πανεπιστήμιο του Χάρβαρντ]

3
00:00:05,000 --> 00:00:08,000
[Αυτό είναι CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Εντάξει, αυτό είναι CS50, και αυτή είναι η αρχή της εβδομάδας 4,

5
00:00:12,000 --> 00:00:16,000
και αυτό είναι μία από τις πιθανές βραδύτερα αλγόριθμοι ταξινόμησης.

6
00:00:16,000 --> 00:00:19,000
Ποιο από τα δύο ήταν το ότι μόλις παρακολουθήσαμε εκεί;

7
00:00:19,000 --> 00:00:24,000
Αυτό ήταν το bubble sort, για μεγάλες O (n ^ 2) + άθροισμα,

8
00:00:24,000 --> 00:00:28,000
και πράγματι δεν είμαστε οι μόνοι σε αυτόν τον κόσμο να φαίνεται να γνωρίζουν

9
00:00:28,000 --> 00:00:30,000
Τι είδους είναι φούσκα ή χρόνο λειτουργίας του.

10
00:00:30,000 --> 00:00:33,000
Πράγματι, αυτό ήταν μια συνέντευξη με τον Eric Schmidt της Google

11
00:00:33,000 --> 00:00:45,000
και πρώην γερουσιαστής Μπαράκ Ομπάμα μόλις πριν από λίγα χρόνια.

12
00:00:45,000 --> 00:00:48,000
>> Τώρα, γερουσιαστής, είστε εδώ στη Google,

13
00:00:48,000 --> 00:00:54,000
και μου αρέσει να σκέφτομαι την προεδρία ως μια συνέντευξη για δουλειά.

14
00:00:54,000 --> 00:00:58,000
Τώρα, είναι δύσκολο να πάρει μια δουλειά ως πρόεδρος, και περνάτε τα ρίγη τώρα.

15
00:00:58,000 --> 00:01:00,000
Είναι επίσης δύσκολο να βρουν μια θέση εργασίας στο Google.

16
00:01:00,000 --> 00:01:05,000
Έχουμε ερωτήσεις, και θα ζητήσει από τους υποψήφιους ερωτήσεις μας,

17
00:01:05,000 --> 00:01:10,000
και αυτό είναι από Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Εσείς νομίζετε ότι αστειεύομαι; Είναι ακριβώς εδώ.

19
00:01:14,000 --> 00:01:18,000
Ποιος είναι ο πιο αποτελεσματικός τρόπος για να ταξινομήσετε ένα εκατομμύριο 32-bit ακέραιοι;

20
00:01:18,000 --> 00:01:21,000
[Γέλια]

21
00:01:21,000 --> 00:01:24,000
Καλά-

22
00:01:24,000 --> 00:01:26,000
Λυπάμαι. >> Όχι, όχι, όχι, όχι.

23
00:01:26,000 --> 00:01:34,000
Νομίζω ότι το είδος φούσκα θα είναι ο λάθος τρόπος για να προχωρήσουμε.

24
00:01:34,000 --> 00:01:39,000
>> Έλα, ο οποίος του είπε αυτό;

25
00:01:39,000 --> 00:01:43,000
Την περασμένη εβδομάδα ανάκληση πήραμε ένα διάλειμμα από τον κώδικα, τουλάχιστον για μια ημέρα,

26
00:01:43,000 --> 00:01:46,000
και ξεκίνησε την εστίαση σε ορισμένες υψηλότερο επίπεδο ιδεών και επίλυση προβλημάτων γενικότερα

27
00:01:46,000 --> 00:01:49,000
στο πλαίσιο της αναζήτηση και την ταξινόμηση,

28
00:01:49,000 --> 00:01:53,000
και παρουσιάσαμε κάτι που δεν ράπισμα αυτό το όνομα για την περασμένη εβδομάδα,

29
00:01:53,000 --> 00:01:56,000
αλλά ασυμπτωτική σημειογραφία, ο Big O, το Big Omega,

30
00:01:56,000 --> 00:02:00,000
και μερικές φορές το μεγάλο συμβολισμό Θήτα, και αυτά ήταν απλά τρόπους

31
00:02:00,000 --> 00:02:02,000
περιγραφής του χρόνου λειτουργίας των αλγορίθμων,

32
00:02:02,000 --> 00:02:05,000
πόσο χρόνο χρειάζεται για έναν αλγόριθμο για να τρέξει.

33
00:02:05,000 --> 00:02:08,000
>> Και ίσως θυμάστε ότι σας μίλησε για το χρόνο λειτουργίας όσον αφορά το μέγεθος

34
00:02:08,000 --> 00:02:11,000
της εισόδου, το οποίο ονομάζουμε γενικά n, ανεξάρτητα από το πρόβλημα μπορεί να είναι,

35
00:02:11,000 --> 00:02:13,000
όπου n είναι ο αριθμός των ατόμων στο δωμάτιο,

36
00:02:13,000 --> 00:02:17,000
ο αριθμός των σελίδων σε ένα τηλεφωνικό κατάλογο, και αρχίσαμε να γράφουμε τα πράγματα

37
00:02:17,000 --> 00:02:21,000
όπως O (n ^ 2) ή O (n) ή O (n log n),

38
00:02:21,000 --> 00:02:24,000
και ακόμη και όταν τα μαθηματικά δεν εργάζονται αρκετά έξω τόσο τέλεια

39
00:02:24,000 --> 00:02:28,000
και ήταν n ² - n / 2 ή κάτι τέτοιο

40
00:02:28,000 --> 00:02:31,000
θα αντί απλώς να ρίξει μακριά μερικά από τα χαμηλότερα όρους ώστε,

41
00:02:31,000 --> 00:02:34,000
και το κίνητρο είναι ότι θέλουμε πραγματικά ένα

42
00:02:34,000 --> 00:02:37,000
είδος αντικειμενικό τρόπο αξιολόγησης

43
00:02:37,000 --> 00:02:39,000
η απόδοση των προγραμμάτων ή η απόδοση των αλγορίθμων

44
00:02:39,000 --> 00:02:42,000
ότι στο τέλος της ημέρας δεν έχει τίποτα να κάνει, για παράδειγμα,

45
00:02:42,000 --> 00:02:45,000
με την ταχύτητα του υπολογιστή σας σήμερα.

46
00:02:45,000 --> 00:02:47,000
>> Για παράδειγμα, εάν έχετε εφαρμόσει bubble sort,

47
00:02:47,000 --> 00:02:50,000
ή να εφαρμόσετε ταξινόμηση με συγχώνευση ή την επιλογή του είδους στον υπολογιστή του σήμερα,

48
00:02:50,000 --> 00:02:53,000
ένα 2 GHz υπολογιστή, και να το τρέξει,

49
00:02:53,000 --> 00:02:56,000
και αυτό παίρνει κάποιο αριθμό δευτερολέπτων, το επόμενο έτος, υπάρχει ένα 3 GHz

50
00:02:56,000 --> 00:02:59,000
ή 4 ​​GHz υπολογιστή, και στη συνέχεια μπορεί να ισχυρίζονται ότι "Πω πω, μου αλγόριθμος

51
00:02:59,000 --> 00:03:03,000
τώρα είναι δύο φορές πιο γρήγορα », όταν στην πραγματικότητα αυτό δεν είναι προφανώς η περίπτωση.

52
00:03:03,000 --> 00:03:06,000
Είναι ακριβώς το υλικό έχει πάρει πιο γρήγορα, αλλά ο υπολογιστής σας

53
00:03:06,000 --> 00:03:10,000
δεν έχει, και έτσι θέλουμε πραγματικά να ρίξει μακριά τα πράγματα όπως

54
00:03:10,000 --> 00:03:13,000
πολλαπλάσια του 2 ή πολλαπλάσια του 3 όταν πρόκειται για την περιγραφή

55
00:03:13,000 --> 00:03:17,000
πόσο γρήγορα ή πόσο αργή είναι ένας αλγόριθμος και πραγματικά επικεντρώνεται μόνο

56
00:03:17,000 --> 00:03:20,000
για ν ή κάποιο παράγοντα αυτού,

57
00:03:20,000 --> 00:03:24,000
κάποια δύναμη αυτού όπως στην περίπτωση των ειδών από την προηγούμενη εβδομάδα.

58
00:03:24,000 --> 00:03:27,000
Και υπενθυμίζουν ότι με τη βοήθεια του είδους συγχώνευση

59
00:03:27,000 --> 00:03:31,000
ήμασταν σε θέση να το κάνουν πολύ καλύτερα από ό, τι είδος φούσκα και το είδος επιλογής

60
00:03:31,000 --> 00:03:33,000
και ακόμη είδος εισαγωγής.

61
00:03:33,000 --> 00:03:36,000
>> Πήραμε κάτω στο n log n, και πάλι,

62
00:03:36,000 --> 00:03:39,000
Υπενθυμίζω ότι log n γενικά αναφέρεται σε κάτι που μεγαλώνει

63
00:03:39,000 --> 00:03:43,000
πιο αργά και στη συνέχεια n, έτσι ώστε n log n μέχρι στιγμής ήταν καλή

64
00:03:43,000 --> 00:03:45,000
επειδή ήταν λιγότερο από ² n.

65
00:03:45,000 --> 00:03:47,000
Αλλά για να επιτευχθεί n log n με το είδος συγχώνευσης

66
00:03:47,000 --> 00:03:51,000
ποια ήταν η βασική φύτρο του μια ιδέα που είχαμε για τη μόχλευση

67
00:03:51,000 --> 00:03:54,000
ότι πρέπει επίσης μόχλευση πίσω στην εβδομάδα 0;

68
00:03:54,000 --> 00:03:58,000
Πώς θα αντιμετωπίσουμε το πρόβλημα ταξινόμησης έξυπνα με το είδος συγχώνευσης;

69
00:03:58,000 --> 00:04:04,000
Ποια ήταν η βασική γνώση, ίσως;

70
00:04:04,000 --> 00:04:07,000
Οποιοσδήποτε καθόλου.

71
00:04:07,000 --> 00:04:09,000
Εντάξει, ας κάνουμε ένα βήμα πίσω.

72
00:04:09,000 --> 00:04:11,000
Περιγράψτε το είδος συγχώνευσης με δικά σας λόγια.

73
00:04:11,000 --> 00:04:15,000
Πώς λειτουργεί;

74
00:04:15,000 --> 00:04:17,000
Εντάξει, θα αρμενίζει πίσω στο 0 εβδομάδα.

75
00:04:17,000 --> 00:04:19,000
Εντάξει, ναι.

76
00:04:19,000 --> 00:04:22,000
[Δεν ακούγεται-φοιτητής]

77
00:04:22,000 --> 00:04:26,000
Εντάξει, καλά, έτσι ώστε να διαιρεθεί η σειρά των αριθμών σε 2 κομμάτια.

78
00:04:26,000 --> 00:04:29,000
Εμείς ταξινομημένο καθένα από αυτά τα κομμάτια, και στη συνέχεια θα τους συγχωνεύονται,

79
00:04:29,000 --> 00:04:33,000
και έχουμε δει αυτή την ιδέα πριν από τη λήψη ένα πρόβλημα που είναι αυτό το μεγάλο

80
00:04:33,000 --> 00:04:36,000
και τον τεμαχισμό επάνω σε ένα πρόβλημα που είναι αυτό το μεγάλο ή το μεγάλο.

81
00:04:36,000 --> 00:04:38,000
>> Θυμηθείτε το παράδειγμα του τηλεφωνικού καταλόγου.

82
00:04:38,000 --> 00:04:42,000
Θυμηθείτε την αυτο-καταμέτρηση αλγόριθμο από εβδομάδες πριν,

83
00:04:42,000 --> 00:04:45,000
έτσι συγχώνευση είδος συνοψίστηκε από αυτό το ψευδοκώδικα εδώ.

84
00:04:45,000 --> 00:04:48,000
Όταν σας δίνεται n στοιχεία, το πρώτο ήταν λογική ελέγχου.

85
00:04:48,000 --> 00:04:51,000
Εάν n <2 τότε δεν κάνουμε τίποτα καθόλου

86
00:04:51,000 --> 00:04:55,000
διότι αν n <2 τότε το η είναι προφανώς 0 ή 1,

87
00:04:55,000 --> 00:04:57,000
και έτσι αν είναι είτε 0 ή 1 δεν υπάρχει τίποτα για να ταξινομήσετε.

88
00:04:57,000 --> 00:04:59,000
Τελειώσατε.

89
00:04:59,000 --> 00:05:01,000
Η λίστα σας είναι ήδη ταξινομημένο επιπόλαια.

90
00:05:01,000 --> 00:05:04,000
Αλλά κατά τα άλλα, αν έχετε 2 ή περισσότερα στοιχεία να προχωρήσει και να τους χωρίζουν

91
00:05:04,000 --> 00:05:06,000
σε 2 ίσα μέρη, αριστερά και δεξιά.

92
00:05:06,000 --> 00:05:09,000
Ταξινόμηση καθένα από αυτά τα μισά, και στη συνέχεια να συγχωνεύσει τα μισά ταξινομημένο.

93
00:05:09,000 --> 00:05:13,000
Αλλά το πρόβλημα εδώ είναι ότι με την πρώτη ματιά αυτό αισθάνεται σαν να είμαστε στοίχημα.

94
00:05:13,000 --> 00:05:17,000
Αυτό είναι ένα κυκλικό ορισμό ότι αν σας έχω ζητήσει να ταξινομήσετε τα n στοιχεία

95
00:05:17,000 --> 00:05:22,000
και μου λες "Εντάξει, εντάξει, θα ταξινομήσετε τα στοιχεία n / 2 και τα n / 2"

96
00:05:22,000 --> 00:05:27,000
τότε η επόμενη ερώτησή μου θα είναι "Καλά, πώς μπορείτε να ταξινομήσετε το n / 2 στοιχεία;"

97
00:05:27,000 --> 00:05:30,000
>> Όμως, λόγω της δομής του εν λόγω προγράμματος,

98
00:05:30,000 --> 00:05:33,000
επειδή υπάρχει αυτή η βασική περίπτωση, να το πω έτσι,

99
00:05:33,000 --> 00:05:39,000
αυτή η ειδική περίπτωση που λέει ότι εάν n είναι <κάποια σταθερή αξία όπως είναι το 2 επιστροφή αμέσως.

100
00:05:39,000 --> 00:05:42,000
Μην απαντάτε με την ίδια εγκύκλιο απάντηση.

101
00:05:42,000 --> 00:05:46,000
Αυτή η διαδικασία, η κυκλικότητα τελικά θα τελειώσει.

102
00:05:46,000 --> 00:05:50,000
Αν σας ζητώ "Ταξινόμηση αυτά τα n στοιχεία," και λέτε, "Καλά, αυτά τα ταξινομήσετε n / 2"

103
00:05:50,000 --> 00:05:53,000
τότε λέτε, "Καλά, αυτοί είδος n / 4, n / 8, n/16,"

104
00:05:53,000 --> 00:05:56,000
τελικά θα χωρίζουν από ένα αρκετά μεγάλο αριθμό

105
00:05:56,000 --> 00:05:59,000
ότι θα έχετε μόλις 1 στοιχείο αριστερά, σε ποιο σημείο μπορείτε να πείτε,

106
00:05:59,000 --> 00:06:02,000
«Εδώ, εδώ είναι ένα ταξινομημένο μόνο στοιχείο."

107
00:06:02,000 --> 00:06:06,000
Στη συνέχεια, η λάμψη αυτού του αλγορίθμου μέχρι εδώ είναι να προέρχεται από το γεγονός

108
00:06:06,000 --> 00:06:09,000
ότι από τη στιγμή που έχετε όλα αυτά τα ξεχωριστά ταξινομημένο καταλόγους,

109
00:06:09,000 --> 00:06:12,000
όλα από τα οποία έχουν μέγεθος 1, η οποία φαίνεται να είναι άχρηστη,

110
00:06:12,000 --> 00:06:15,000
τη στιγμή που θα ξεκινήσει τη συγχώνευσή τους και τη συγχώνευσή τους

111
00:06:15,000 --> 00:06:19,000
θα δημιουργηθεί τελικά ως Rob έκανε στο βίντεο ένα τέλος ταξινομημένη λίστα.

112
00:06:19,000 --> 00:06:22,000
>> Αλλά αυτή η ιδέα επεκτείνεται πολύ πέρα ​​από τη διαλογή.

113
00:06:22,000 --> 00:06:26,000
Υπάρχει αυτή η ιδέα ενσωματωμένα σε αυτό το πρόγραμμα που είναι γνωστό ως αναδρομή,

114
00:06:26,000 --> 00:06:29,000
η ιδέα σύμφωνα με την οποία είστε ένα πρόγραμμα,

115
00:06:29,000 --> 00:06:32,000
και να λύσει κάποιο πρόβλημα αποκαλείς τον εαυτό σου,

116
00:06:32,000 --> 00:06:36,000
ή έχουν τεθεί στο πλαίσιο των γλωσσών προγραμματισμού που είναι μια λειτουργία,

117
00:06:36,000 --> 00:06:39,000
και για να λύσει ένα πρόβλημα, που η λειτουργία αποκαλείς τον εαυτό σου

118
00:06:39,000 --> 00:06:42,000
ξανά και ξανά και ξανά, αλλά η λειτουργία

119
00:06:42,000 --> 00:06:44,000
δεν μπορεί να θέσει τον εαυτό σας απείρως πολλές φορές.

120
00:06:44,000 --> 00:06:47,000
Τελικά θα πρέπει να ανακάμπτουν, να το πω έτσι,

121
00:06:47,000 --> 00:06:49,000
και να έχουν κάποια hard-coded κατάσταση βάσης που λέει

122
00:06:49,000 --> 00:06:53,000
σε αυτό το σημείο να σταματήσει καλώντας τον εαυτό σας, έτσι ώστε η όλη διαδικασία

123
00:06:53,000 --> 00:06:56,000
Τέλος, στην πραγματικότητα δεν σταματά.

124
00:06:56,000 --> 00:06:58,000
Τι σημαίνει αυτό πραγματικά σημαίνει, να recurse;

125
00:06:58,000 --> 00:07:01,000
>> Ας δούμε, αν μπορούμε να κάνουμε ένα απλό, ασήμαντο παράδειγμα, ας πούμε,

126
00:07:01,000 --> 00:07:03,000
3 άτομα μαζί μου εδώ στη σκηνή, αν κάποιος είναι άνετα.

127
00:07:03,000 --> 00:07:06,000
1, έλα επάνω, 2 και 3.

128
00:07:06,000 --> 00:07:09,000
Αν σας 3 θέλουν να έρθουν εδώ.

129
00:07:09,000 --> 00:07:12,000
Αν θέλετε να σταθεί δίπλα μου εδώ σε μια γραμμή, ας υποθέσουμε ότι το πρόβλημα στο χέρι

130
00:07:12,000 --> 00:07:15,000
είναι πολύ επιπόλαια να μετρήσει τον αριθμό των ανθρώπων που είναι εδώ.

131
00:07:15,000 --> 00:07:18,000
Αλλά ειλικρινά, είμαι κουρασμένος από όλα αυτά τα παραδείγματα καταμέτρηση.

132
00:07:18,000 --> 00:07:21,000
Αυτό πρόκειται να πάρει κάποιο χρόνο, 1, 2, και τελεία, τελεία, τελεία.

133
00:07:21,000 --> 00:07:23,000
Είναι πρόκειται να πάρει για πάντα.

134
00:07:23,000 --> 00:07:25,000
Θα προτιμούσα μόνο κλωτσιά αυτό το πρόβλημα εντελώς με τη βοήθεια του-ό, τι είναι το όνομά σας;

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, εντάξει.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly και;

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly, και Willy.

138
00:07:31,000 --> 00:07:34,000
Αυτή τη στιγμή έχω την ερώτηση από κάποιον

139
00:07:34,000 --> 00:07:37,000
πόσοι άνθρωποι βρίσκονται επάνω σε αυτό το στάδιο, και δεν έχω καμία ιδέα.

140
00:07:37,000 --> 00:07:40,000
Αυτό είναι ένα πραγματικά μακρύ κατάλογο, και έτσι αντί να πάω να κάνω αυτό το τέχνασμα.

141
00:07:40,000 --> 00:07:43,000
Πάω να ζητήσει από το πρόσωπο δίπλα μου για να κάνω το μεγαλύτερο μέρος του έργου,

142
00:07:43,000 --> 00:07:46,000
και μόλις αυτή γίνεται κάνει μεγαλύτερο μέρος του έργου

143
00:07:46,000 --> 00:07:49,000
Πάω να κάνω το ελάχιστο ποσό της εργασίας είναι δυνατόν και απλά προσθέστε 1

144
00:07:49,000 --> 00:07:51,000
απάντηση σε ό, τι της είναι, τόσο εδώ πηγαίνουμε.

145
00:07:51,000 --> 00:07:54,000
Έχω κληθεί πόσοι άνθρωποι είναι πάνω στη σκηνή.

146
00:07:54,000 --> 00:07:57,000
Πόσοι άνθρωποι είναι πάνω στη σκηνή στα αριστερά σας;

147
00:07:57,000 --> 00:08:00,000
Το αριστερό μου; >> Εντάξει, αλλά δεν εξαπατά.

148
00:08:00,000 --> 00:08:04,000
Αυτό είναι καλό, αυτό είναι σωστό, αλλά αν θέλουμε να συνεχίσουμε αυτή τη λογική

149
00:08:04,000 --> 00:08:08,000
Ας υποθέσουμε ότι έχετε ομοίως θέλετε να punt αυτό το πρόβλημα στα αριστερά σας,

150
00:08:08,000 --> 00:08:11,000
Έτσι, αντί να απαντήσει άμεσα να προχωρήσει και μόλις περάσει το buck.

151
00:08:11,000 --> 00:08:14,000
Ω, πόσοι άνθρωποι είναι στα αριστερά μου;

152
00:08:14,000 --> 00:08:16,000
Πόσοι άνθρωποι είναι προς τα αριστερά;

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

154
00:08:18,000 --> 00:08:27,000
[Γέλια]

155
00:08:27,000 --> 00:08:30,000
Εντάξει, έτσι 0, έτσι και τώρα τι έχει κάνει Willy

156
00:08:30,000 --> 00:08:33,000
το έχετε επιστρέψει απάντησή σας αυτή την κατεύθυνση λέγοντας 0.

157
00:08:33,000 --> 00:08:36,000
Τώρα, τι πρέπει να κάνετε; >> 1.

158
00:08:36,000 --> 00:08:39,000
Εντάξει, έτσι είστε το 1, έτσι ώστε να λένε, "Εντάξει, Πάω να προσθέσετε 1

159
00:08:39,000 --> 00:08:41,000
όποια και αν είναι να μετράνε Willy ήταν, «έτσι ώστε 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Τώρα είστε 1, έτσι η απάντησή σας προς τα δεξιά είναι τώρα-

161
00:08:43,000 --> 00:08:45,000
1. >> Και η δική μου θα είναι 2.

162
00:08:45,000 --> 00:08:48,000
Καλό, έτσι ώστε να παίρνετε την προηγούμενη απάντηση του 1,

163
00:08:48,000 --> 00:08:51,000
προσθέτοντας το ελάχιστο ποσό της εργασίας που θέλετε να κάνετε, η οποία είναι +1.

164
00:08:51,000 --> 00:08:55,000
Τώρα έχετε 2, και το χέρι σας στη συνέχεια, με την οποία αξία;

165
00:08:55,000 --> 00:08:57,000
3, θέλω να πω,, συγνώμη 2.

166
00:08:57,000 --> 00:08:59,000
Καλή.

167
00:08:59,000 --> 00:09:02,000
>> Λοιπόν, είχαμε 0 προς τα αριστερά.

168
00:09:02,000 --> 00:09:05,000
Στη συνέχεια, είχαμε 1, και στη συνέχεια προσθέτουμε 2,

169
00:09:05,000 --> 00:09:07,000
και τώρα είστε παράδοση με τον αριθμό 2,

170
00:09:07,000 --> 00:09:10,000
και γι 'αυτό λέω, εντάξει, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Υπάρχει πράγματι 3 άτομα στέκεται δίπλα μου σε αυτό το στάδιο,

172
00:09:13,000 --> 00:09:16,000
έτσι θα μπορούσαμε να είχαμε κάνει προφανώς αυτό είναι πολύ γραμμικά,

173
00:09:16,000 --> 00:09:19,000
πάρα πολύ στην προφανή τρόπο, αλλά αυτό που κάναμε πραγματικά κάνει;

174
00:09:19,000 --> 00:09:21,000
Πήραμε ένα πρόβλημα του μεγέθους 3 αρχικά.

175
00:09:21,000 --> 00:09:24,000
Εμείς έσπασε έπειτα κάτω σε ένα πρόβλημα του μεγέθους 2,

176
00:09:24,000 --> 00:09:27,000
τότε ένα πρόβλημα του μεγέθους 1, και έπειτα τελικά η περίπτωση βάσεως

177
00:09:27,000 --> 00:09:29,000
Ήταν πραγματικά, OH, δεν υπάρχει κανείς εκεί,

178
00:09:29,000 --> 00:09:33,000
σε ποιο σημείο Willy επέστρεψε αποτελεσματικά μια μόνιμη απάντηση μια-δυο φορές,

179
00:09:33,000 --> 00:09:36,000
και η δεύτερη Στη συνέχεια διαβιβάσθηκε επάνω, διοχετεύεται επάνω, διοχετεύεται επάνω,

180
00:09:36,000 --> 00:09:39,000
και στη συνέχεια με προσθήκη σε αυτό ένα επιπλέον 1

181
00:09:39,000 --> 00:09:41,000
έχουμε εφαρμόσει αυτή τη βασική ιδέα της αναδρομής.

182
00:09:41,000 --> 00:09:44,000
>> Τώρα, σε αυτή την περίπτωση δεν λύσει πραγματικά το πρόβλημα

183
00:09:44,000 --> 00:09:46,000
οποιαδήποτε πιο αποτελεσματικά τότε έχουμε δει μέχρι στιγμής.

184
00:09:46,000 --> 00:09:48,000
Αλλά σκεφτείτε για τους αλγόριθμους που έχουμε κάνει στη σκηνή μέχρι στιγμής.

185
00:09:48,000 --> 00:09:51,000
Είχαμε 8 κομμάτια χαρτιού στο μαυροπίνακα,

186
00:09:51,000 --> 00:09:55,000
στο βίντεο, όταν ο Sean έψαχνε για τον αριθμό 7, και τι έκανε πραγματικά κάνει;

187
00:09:55,000 --> 00:09:58,000
Καλά, αυτός δεν κάνει οποιοδήποτε είδος του διαίρει και βασίλευε.

188
00:09:58,000 --> 00:10:01,000
Δεν κάνει οποιοδήποτε είδος αναδρομής.

189
00:10:01,000 --> 00:10:03,000
Μάλλον το έκανε ακριβώς αυτό το γραμμικό αλγόριθμο.

190
00:10:03,000 --> 00:10:07,000
Αλλά όταν εισήγαγε την ιδέα των αριθμών ταξινομημένο ζουν στη σκηνή την περασμένη εβδομάδα

191
00:10:07,000 --> 00:10:09,000
τότε είχαμε αυτό το ένστικτο να πάει στη μέση,

192
00:10:09,000 --> 00:10:13,000
σε ποιο σημείο είχαμε μια μικρότερη λίστα μέγεθος 4 ή άλλη λίστα μεγέθους 4,

193
00:10:13,000 --> 00:10:17,000
και στη συνέχεια, είχαμε ακριβώς το ίδιο πρόβλημα, γι 'αυτό επαναλαμβάνεται, επαναλαμβάνεται, επαναλαμβάνεται.

194
00:10:17,000 --> 00:10:19,000
Με άλλα λόγια, έχουμε recursed.

195
00:10:19,000 --> 00:10:24,000
Σας ευχαριστώ πολύ για 3 εθελοντές μας εδώ για την επίδειξη αναδρομή μαζί μας.

196
00:10:24,000 --> 00:10:28,000
>> Ας δούμε αν δεν μπορούμε να κάνουμε αυτό τώρα λίγο πιο συγκεκριμένα,

197
00:10:28,000 --> 00:10:30,000
επίλυση ενός προβλήματος που και πάλι θα μπορούσαμε να κάνουμε πολύ εύκολα,

198
00:10:30,000 --> 00:10:34,000
αλλά θα το χρησιμοποιήσουν ως εφαλτήριο για την υλοποίηση αυτής της βασικής ιδέας.

199
00:10:34,000 --> 00:10:37,000
Αν θέλω να υπολογίσει το άθροισμα του ένα μάτσο αριθμούς,

200
00:10:37,000 --> 00:10:39,000
Για παράδειγμα, αν έχετε περάσει στον αριθμό 3,

201
00:10:39,000 --> 00:10:42,000
Θέλω να σας δώσουμε την αξία του σίγμα 3,

202
00:10:42,000 --> 00:10:46,000
οπότε το άθροισμα των 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Θέλω να πάρω πίσω την απάντηση 6,

204
00:10:48,000 --> 00:10:51,000
έτσι θα εφαρμόσει αυτό το σίγμα λειτουργία, αυτή η λειτουργία άθροισης

205
00:10:51,000 --> 00:10:54,000
ότι, και πάλι, παίρνει στην είσοδο, και στη συνέχεια επιστρέφει το άθροισμα

206
00:10:54,000 --> 00:10:57,000
από τον αριθμό αυτό σε όλη τη διαδρομή μέχρι το 0.

207
00:10:57,000 --> 00:10:59,000
Θα μπορούσαμε να το κάνουμε αυτό πολύ απλά, έτσι δεν είναι;

208
00:10:59,000 --> 00:11:01,000
Θα μπορούσαμε να το κάνουμε αυτό με κάποιο είδος του looping δομή,

209
00:11:01,000 --> 00:11:04,000
οπότε επιτρέψτε μου να προχωρήσει και να πάρει αυτό που ξεκίνησε.

210
00:11:04,000 --> 00:11:07,000
>> Συμπεριλάβετε stdio.h.

211
00:11:07,000 --> 00:11:09,000
Επιτρέψτε μου να μπει στο κυρίως να συνεργαστεί με εδώ.

212
00:11:09,000 --> 00:11:12,000
Ας σώσει αυτό ως sigma.c.

213
00:11:12,000 --> 00:11:14,000
Στη συνέχεια, Πάω να πάει εδώ, και θα πάω να κηρύξει int n,

214
00:11:14,000 --> 00:11:18,000
και Πάω να κάνετε τα εξής, ενώ ο χρήστης δεν συνεργάζεται.

215
00:11:18,000 --> 00:11:22,000
Αν ο χρήστης δεν έχει δώσει εμένα ένα θετικό αριθμό

216
00:11:22,000 --> 00:11:26,000
επιτρέψτε μου να πάμε μπροστά και να προτρέψει τους για GetInt n =,

217
00:11:26,000 --> 00:11:28,000
και επιτρέψτε μου να τους δώσουμε κάποιες οδηγίες για το τι να κάνουν,

218
00:11:28,000 --> 00:11:33,000
έτσι printf ("θετικός ακέραιος παρακαλώ").

219
00:11:33,000 --> 00:11:39,000
Απλά κάτι σχετικά απλό σαν αυτό, έτσι ώστε από τη στιγμή που χτύπησε γραμμή 14

220
00:11:39,000 --> 00:11:42,000
έχουμε τώρα ένα θετικό ακέραιο πιθανώς σε n.

221
00:11:42,000 --> 00:11:44,000
>> Τώρα, ας κάνει κάτι με αυτό.

222
00:11:44,000 --> 00:11:50,000
Επιτρέψτε μου να προχωρήσει και να υπολογίζουν το άθροισμα, έτσι int sum = σίγμα (n).

223
00:11:50,000 --> 00:11:54,000
Sigma είναι απλώς άθροισμα, έτσι γράφω αυτό ακριβώς τον εκτροφέα τρόπο.

224
00:11:54,000 --> 00:11:56,000
Θα αποκαλούν απλώς σίγμα εκεί.

225
00:11:56,000 --> 00:11:58,000
Αυτό είναι το ποσό, και τώρα θα πάω να εκτυπώσετε το αποτέλεσμα,

226
00:11:58,000 --> 00:12:08,000
printf ("Το άθροισμα είναι% d \ n", άθροισμα).

227
00:12:08,000 --> 00:12:11,000
Και τότε θα επιστρέψει 0 για το καλό μέτρο.

228
00:12:11,000 --> 00:12:15,000
Έχουμε κάνει τα πάντα ότι το πρόγραμμα αυτό απαιτεί εκτός από το ενδιαφέρον μέρος,

229
00:12:15,000 --> 00:12:18,000
που είναι να εφαρμόσουν στην πράξη τη λειτουργία σίγμα.

230
00:12:18,000 --> 00:12:22,000
>> Επιτρέψτε μου να πάω εδώ κάτω προς τα κάτω, και επιτρέψτε μου να δηλώσω λειτουργία σίγμα.

231
00:12:22,000 --> 00:12:26,000
Είναι πήρε να λάβει μια μεταβλητή που είναι του τύπου integer,

232
00:12:26,000 --> 00:12:30,000
και τι είδους δεδομένα δεν θέλω να επιστρέψει κατά πάσα πιθανότητα από το σίγμα;

233
00:12:30,000 --> 00:12:34,000
Int, γιατί θέλω να ταιριάζει με τις προσδοκίες μου στη γραμμή 15.

234
00:12:34,000 --> 00:12:37,000
Εδώ επιτρέψτε μου να προχωρήσει και να εφαρμόσει αυτό

235
00:12:37,000 --> 00:12:41,000
σε ένα αρκετά απλό τρόπο.

236
00:12:41,000 --> 00:12:45,000
>> Ας πάμε μπροστά και να πω int sum = 0,

237
00:12:45,000 --> 00:12:47,000
και τώρα είμαι πρόκειται να πάει έχουν λίγο για βρόχο εδώ

238
00:12:47,000 --> 00:12:50,000
που πρόκειται να πω κάτι τέτοιο,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0? I <= αριθμός? i + +) άθροισμα + = i.

240
00:13:01,000 --> 00:13:05,000
Και τότε Πάω να επιστρέψει ποσό.

241
00:13:05,000 --> 00:13:07,000
Ι θα μπορούσε να έχει υλοποιηθεί αυτό σε οποιοδήποτε αριθμό τρόπων.

242
00:13:07,000 --> 00:13:09,000
Θα μπορούσα να έχω χρησιμοποιήσει ένα βρόχο while.

243
00:13:09,000 --> 00:13:11,000
Θα μπορούσα να παραληφθεί με τη χρήση της μεταβλητής ποσό αν ήθελα πραγματικά να,

244
00:13:11,000 --> 00:13:15,000
αλλά εν ολίγοις, έχουμε μόνο μια λειτουργία που αν δεν το έκανα βλάκας δηλώνει άθροισμα είναι 0.

245
00:13:15,000 --> 00:13:18,000
Τότε επαναλαμβάνεται από 0 για επάνω διαμέσου του αριθμού,

246
00:13:18,000 --> 00:13:23,000
και σε κάθε επανάληψη προσθέτει ότι η τρέχουσα αξία σε ποσό και στη συνέχεια επιστρέφει ποσό.

247
00:13:23,000 --> 00:13:25,000
>> Τώρα, υπάρχει μια μικρή βελτιστοποίηση εδώ.

248
00:13:25,000 --> 00:13:29,000
Αυτό είναι πιθανώς μια χαμένη βήμα, αλλά ας είναι. Αυτό είναι μια χαρά για τώρα.

249
00:13:29,000 --> 00:13:32,000
Είμαστε τουλάχιστον να είναι διεξοδική και πηγαίνοντας 0 σε όλη τη διαδρομή προς τα πάνω.

250
00:13:32,000 --> 00:13:34,000
Δεν είναι πολύ δύσκολο και αρκετά απλή,

251
00:13:34,000 --> 00:13:37,000
αλλά αποδεικνύεται ότι με τη λειτουργία σίγμα έχουμε την ίδια ευκαιρία

252
00:13:37,000 --> 00:13:39,000
όπως κάναμε εδώ πάνω στη σκηνή.

253
00:13:39,000 --> 00:13:42,000
Στη σκηνή που μόλις υπολογίζονται πόσοι άνθρωποι ήταν δίπλα μου,

254
00:13:42,000 --> 00:13:47,000
αλλά αν θέλουμε να μετρήσει τον αριθμό 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
στο κάτω στο 0 θα μπορούσαμε ομοίως punt σε λειτουργία

256
00:13:51,000 --> 00:13:55,000
ότι θα είμαι αντί περιγράφουν ως αναδρομική.

257
00:13:55,000 --> 00:13:57,000
Εδώ ας κάνουμε μια γρήγορη λογική ελέγξετε και να βεβαιωθείτε ότι δεν το έκανα βλάκας.

258
00:13:57,000 --> 00:14:00,000
>> Ξέρω ότι υπάρχει τουλάχιστον ένα πράγμα σε αυτό το πρόγραμμα που είχα κάνει λάθος.

259
00:14:00,000 --> 00:14:04,000
Όταν πατήσω το enter θα πάω να πάρετε οποιοδήποτε είδος του φωνάζεις;

260
00:14:04,000 --> 00:14:06,000
Τι είμαι πρόκειται να φώναξε σε περίπου;

261
00:14:06,000 --> 00:14:11,000
Ναι, ξέχασα το πρωτότυπο, έτσι είμαι χρησιμοποιώντας μια λειτουργία που ονομάζεται σίγμα στη γραμμή 15,

262
00:14:11,000 --> 00:14:16,000
αλλά είναι που δεν έχουν δηλωθεί μέχρι τη γραμμή 22, γι 'αυτό καλύτερα προληπτικά ανεβαίνουν εδώ

263
00:14:16,000 --> 00:14:22,000
και να κηρύξει ένα πρωτότυπο, και θα πω int σίγμα (int number), και αυτό είναι αυτό.

264
00:14:22,000 --> 00:14:24,000
Είναι εφαρμοστεί στο κάτω μέρος.

265
00:14:24,000 --> 00:14:27,000
>> Ή ένας άλλος τρόπος που θα μπορούσε να λύσει αυτό,

266
00:14:27,000 --> 00:14:30,000
Θα μπορούσα να μετακινήσετε τη λειτουργία εκεί, η οποία δεν είναι κακή,

267
00:14:30,000 --> 00:14:32,000
αλλά τουλάχιστον όταν τα προγράμματα αρχίζουν να σας πάρει μακριά, ειλικρινά,

268
00:14:32,000 --> 00:14:35,000
Νομίζω ότι υπάρχει κάποια αξία σε βασικές έχοντας πάντα στην κορυφή

269
00:14:35,000 --> 00:14:38,000
έτσι ώστε να του αναγνώστη μπορεί να ανοίξει το αρχείο και στη συνέχεια να δούμε αμέσως

270
00:14:38,000 --> 00:14:40,000
τι κάνει το πρόγραμμα χωρίς να χρειάζεται να ψάξετε μέσα από αυτό

271
00:14:40,000 --> 00:14:42,000
ψάχνει για το εν λόγω κύρια λειτουργία.

272
00:14:42,000 --> 00:14:49,000
Ας πάμε κάτω στο παράθυρο του τερματικού μου εδώ, δοκιμάστε να κάνετε σίγμα σίγμα κάνουν,

273
00:14:49,000 --> 00:14:51,000
και εγώ μαντάρα εδώ.

274
00:14:51,000 --> 00:14:55,000
Σιωπηρή δήλωση του GetInt λειτουργία σημαίνει έχω ξεχάσει να κάνει ό, τι άλλο;

275
00:14:55,000 --> 00:14:57,000
[Δεν ακούγεται-φοιτητής]

276
00:14:57,000 --> 00:15:00,000
Καλό, οπότε προφανώς ένα κοινό λάθος, οπότε ας βάλουμε αυτό εδώ,

277
00:15:00,000 --> 00:15:04,000
cs50.h, και τώρα ας πάμε πίσω στο παράθυρο του τερματικού μου.

278
00:15:04,000 --> 00:15:08,000
>> Θα καθαρίσετε την οθόνη, και εγώ θα κάνω επανάληψη σίγμα.

279
00:15:08,000 --> 00:15:11,000
Φαίνεται να έχουν συνταχθεί. Επιτρέψτε μου να τρέχουν τώρα σίγμα.

280
00:15:11,000 --> 00:15:15,000
Θα πληκτρολογήσετε τον αριθμό 3, και είχα πάρει 6, έτσι δεν είναι ένα αυστηρό έλεγχο,

281
00:15:15,000 --> 00:15:18,000
αλλά τουλάχιστον φαίνεται να λειτουργεί με την πρώτη ματιά, αλλά τώρα ας το διαρρήξουν,

282
00:15:18,000 --> 00:15:21,000
και ας αξιοποιούν πραγματικά την ιδέα της αναδρομής, και πάλι,

283
00:15:21,000 --> 00:15:24,000
σε ένα πολύ απλό πλαίσιο, έτσι ώστε σε λίγες εβδομάδες »

284
00:15:24,000 --> 00:15:27,000
όταν θα αρχίσετε την εξερεύνηση fancier δομές δεδομένων από πίνακες

285
00:15:27,000 --> 00:15:30,000
έχουμε ένα άλλο εργαλείο για την εργαλειοθήκη με την οποία να

286
00:15:30,000 --> 00:15:33,000
χειρίζονται αυτές τις δομές δεδομένων, όπως θα δούμε.

287
00:15:33,000 --> 00:15:36,000
Αυτή είναι η επαναληπτική προσέγγιση, ο βρόχος προσέγγιση.

288
00:15:36,000 --> 00:15:39,000
>> Επιτρέψτε μου τώρα, αντί να το κάνετε αυτό.

289
00:15:39,000 --> 00:15:44,000
Επιτρέψτε μου να πω ότι αντί για το άθροισμα του αριθμού

290
00:15:44,000 --> 00:15:48,000
κάτω στο 0 είναι πραγματικά το ίδιο πράγμα

291
00:15:48,000 --> 00:15:53,000
Αριθμός + σίγμα (αριθμός - 1).

292
00:15:53,000 --> 00:15:57,000
Με άλλα λόγια, όπως ακριβώς και για το στάδιο Ι κλότσησε σε κάθε ένα από τους ανθρώπους δίπλα μου,

293
00:15:57,000 --> 00:16:00,000
και αυτοί με τη σειρά στοίχημα διατηρούνται μέχρι τελικά έφθασε στο απόγειό της στο Willy,

294
00:16:00,000 --> 00:16:03,000
που έπρεπε να επιστρέψει ένα σκληρό κωδικοποιημένο απάντηση όπως 0.

295
00:16:03,000 --> 00:16:07,000
Εδώ τώρα είμαστε στο ίδιο στοίχημα σίγμα

296
00:16:07,000 --> 00:16:10,000
την ίδια λειτουργία όπως αρχικά λεγόταν, αλλά η βασική εικόνα εδώ

297
00:16:10,000 --> 00:16:12,000
είναι ότι δεν είμαστε καλώντας σίγμα τον ίδιο τρόπο.

298
00:16:12,000 --> 00:16:14,000
Δεν είμαστε περνώντας n.

299
00:16:14,000 --> 00:16:17,000
Είμαστε σαφώς περνά σε αριθμό - 1,

300
00:16:17,000 --> 00:16:20,000
έτσι, ένα ελαφρώς μικρότερο πρόβλημα, λίγο μικρότερο πρόβλημα.

301
00:16:20,000 --> 00:16:23,000
>> Δυστυχώς, αυτό δεν είναι αρκετά μια λύση ακόμη και πριν καθορίσει

302
00:16:23,000 --> 00:16:26,000
τι θα μπορούσε να είναι το άλμα από το προφανές σε κάποιους από εσάς

303
00:16:26,000 --> 00:16:28,000
επιτρέψτε μου να προχωρήσει και να κάνει επανάληψη.

304
00:16:28,000 --> 00:16:30,000
Φαίνεται ότι για την κατάρτιση εντάξει.

305
00:16:30,000 --> 00:16:32,000
Επιτρέψτε μου να επαναπροσδιορίζονται με σίγμα 6.

306
00:16:32,000 --> 00:16:37,000
Ωχ, επιτρέψτε μου να επαναπροσδιορίζονται με 6 σίγμα.

307
00:16:37,000 --> 00:16:42,000
Έχουμε ξαναδεί αυτό, έστω και κατά λάθος την τελευταία φορά, καθώς και.

308
00:16:42,000 --> 00:16:48,000
Γιατί να πάρω αυτό το αινιγματικό σφάλμα κατάτμησης; Ναι.

309
00:16:48,000 --> 00:16:50,000
[Δεν ακούγεται-φοιτητής]

310
00:16:50,000 --> 00:16:53,000
Δεν υπάρχει καμία περίπτωση βάση, και πιο συγκεκριμένα, τι πιθανώς συνέβη;

311
00:16:53,000 --> 00:16:58,000
Αυτό είναι ένα σύμπτωμα του τι συμπεριφορά;

312
00:16:58,000 --> 00:17:00,000
Πείτε λίγο πιο δυνατά.

313
00:17:00,000 --> 00:17:02,000
[Δεν ακούγεται-φοιτητής]

314
00:17:02,000 --> 00:17:05,000
Είναι ένας άπειρος βρόχος αποτελεσματικά, και το πρόβλημα με άπειρη βρόχους

315
00:17:05,000 --> 00:17:08,000
όταν σε αυτές συμμετέχουν αναδρομή σε αυτή την περίπτωση, η ίδια η λειτουργία κλήσης,

316
00:17:08,000 --> 00:17:10,000
τι συμβαίνει κάθε φορά που θα καλέσετε μια συνάρτηση;

317
00:17:10,000 --> 00:17:13,000
Λοιπόν, νομίζω πίσω για το πώς θα το που τη μνήμη σε έναν υπολογιστή.

318
00:17:13,000 --> 00:17:16,000
Είπαμε ότι υπάρχει αυτό το κομμάτι της μνήμης που ονομάζεται στοίβα που είναι στο κάτω μέρος,

319
00:17:16,000 --> 00:17:19,000
και κάθε φορά που θα καλέσει μια λειτουργία λίγο περισσότερη μνήμη παίρνει θέσει

320
00:17:19,000 --> 00:17:24,000
σε αυτό το λεγόμενο στοίβα που περιέχει τις τοπικές μεταβλητές ή παραμέτρους που η λειτουργία του,

321
00:17:24,000 --> 00:17:27,000
οπότε αν σίγμα σίγμα κλήσεις κλήσεις σίγμα σίγμα κλήσεις

322
00:17:27,000 --> 00:17:29,000
 καλεί σίγμα όπου κάνει αυτό τελειώνει η ιστορία;

323
00:17:29,000 --> 00:17:31,000
>> Λοιπόν, τελικά υπερβάσεις το συνολικό ποσό

324
00:17:31,000 --> 00:17:33,000
της μνήμης που έχετε διαθέσιμα στον υπολογιστή σας.

325
00:17:33,000 --> 00:17:37,000
Μπορείτε υπέρβαση του τμήματος ότι είστε υποτίθεται για να μείνετε μέσα,

326
00:17:37,000 --> 00:17:40,000
και μπορείτε να πάρετε αυτό το σφάλμα κατάτμησης, πυρήνα που αποτελούν αντικείμενο ντάμπινγκ,

327
00:17:40,000 --> 00:17:43,000
και τι σημαίνει πυρήνα που αποτελούν αντικείμενο ντάμπινγκ είναι ότι έχω τώρα ένα αρχείο με το όνομα του πυρήνα

328
00:17:43,000 --> 00:17:46,000
το οποίο είναι ένα αρχείο που περιέχει μηδενικά και μονάδες

329
00:17:46,000 --> 00:17:49,000
ότι στην πραγματικότητα στο μέλλον θα είναι χρήσιμα διαγνωστικά.

330
00:17:49,000 --> 00:17:52,000
Αν δεν είναι προφανές για να σας όπου σας είναι bug

331
00:17:52,000 --> 00:17:54,000
μπορείτε να το κάνετε πραγματικά ένα κομμάτι της εγκληματολογική ανάλυση, να το πω έτσι,

332
00:17:54,000 --> 00:17:58,000
σε αυτό το αρχείο ένδειξης σφαλμάτων πυρήνα, η οποία, και πάλι, είναι απλώς ένα σωρό μηδενικά και μονάδες

333
00:17:58,000 --> 00:18:02,000
που αποτελεί ουσιαστικά την κατάσταση του προγράμματος στη μνήμη σας

334
00:18:02,000 --> 00:18:05,000
η στιγμή που συνέτριψε με αυτόν τον τρόπο.

335
00:18:05,000 --> 00:18:11,000
>> Η λύση εδώ είναι ότι δεν μπορούμε απλώς να επιστρέψουν στα τυφλά σίγμα,

336
00:18:11,000 --> 00:18:14,000
+ ο αριθμός σίγμα από ένα ελαφρώς μικρότερο πρόβλημα.

337
00:18:14,000 --> 00:18:16,000
Πρέπει να έχουν κάποιο είδος της υπόθεσης βάση εδώ,

338
00:18:16,000 --> 00:18:19,000
και τι θα πρέπει η βασική περίπτωση πιθανώς να είναι;

339
00:18:19,000 --> 00:18:22,000
[Δεν ακούγεται-φοιτητής]

340
00:18:22,000 --> 00:18:25,000
Εντάξει, εφ 'όσον ο αριθμός είναι θετικός πρέπει να επιστρέψουμε στην πραγματικότητα αυτό,

341
00:18:25,000 --> 00:18:29,000
ή με άλλα λόγια, αν ο αριθμός είναι, ας πούμε, <= στο 0

342
00:18:29,000 --> 00:18:32,000
ξέρετε τι, θα πάω μπροστά και να επιστρέψει 0,

343
00:18:32,000 --> 00:18:36,000
σαν Willy έκανε και αλλιώς, είμαι πρόκειται να πάει μπροστά

344
00:18:36,000 --> 00:18:41,000
και να επιστρέψει αυτό, έτσι δεν είναι ότι πολύ μικρότερη

345
00:18:41,000 --> 00:18:44,000
από την επαναληπτική εκδοχή ότι χτυπημένη μέχρι την πρώτη χρήση ενός βρόχου for,

346
00:18:44,000 --> 00:18:48,000
αλλά παρατηρώ ότι υπάρχει αυτό το είδος της κομψότητας σε αυτό.

347
00:18:48,000 --> 00:18:51,000
Αντί να επιστρέψει κάποια αριθμός και εκτελεί όλα αυτά τα μαθηματικά

348
00:18:51,000 --> 00:18:54,000
και προσθέτοντας τα πράγματα με τις τοπικές μεταβλητές

349
00:18:54,000 --> 00:18:57,000
είστε αντί να λέει "Εντάξει, αν αυτό είναι ένα εξαιρετικά εύκολο πρόβλημα,

350
00:18:57,000 --> 00:19:01,000
όπως ο αριθμός είναι <0, επιτρέψτε μου να επιστρέψει αμέσως 0. "

351
00:19:01,000 --> 00:19:03,000
>> Εμείς δεν πρόκειται να ενοχλεί την υποστήριξη των αρνητικών αριθμών,

352
00:19:03,000 --> 00:19:05,000
έτσι θα πάω στο σκληρό κώδικα την τιμή 0.

353
00:19:05,000 --> 00:19:08,000
Αλλά κατά τα άλλα, για την υλοποίηση αυτής της ιδέας του αθροίζοντας

354
00:19:08,000 --> 00:19:11,000
όλοι από αυτούς τους αριθμούς μαζί μπορείτε να πάρετε πραγματικά μια μικρή μπουκιά

355
00:19:11,000 --> 00:19:14,000
έξω από το πρόβλημα, όπως ακριβώς κάναμε εδώ στη σκηνή,

356
00:19:14,000 --> 00:19:18,000
punt τότε το υπόλοιπο του προβλήματος για το επόμενο πρόσωπο,

357
00:19:18,000 --> 00:19:20,000
αλλά σε αυτή την περίπτωση το επόμενο πρόσωπο είναι τον εαυτό σας.

358
00:19:20,000 --> 00:19:22,000
Είναι μια λειτουργία το ίδιο όνομα.

359
00:19:22,000 --> 00:19:25,000
Μόλις περάσει το ένα όλο και μικρότερα και μικρότερα πρόβλημα κάθε φορά,

360
00:19:25,000 --> 00:19:28,000
και ακόμα κι αν δεν έχουμε αρκετά πράγματα επισημοποιηθεί στον κώδικα εδώ

361
00:19:28,000 --> 00:19:33,000
αυτό είναι ακριβώς ό, τι συνέβαινε στην εβδομάδα 0 με τον τηλεφωνικό κατάλογο.

362
00:19:33,000 --> 00:19:36,000
Αυτό είναι ακριβώς ό, τι συνέβαινε σε προηγούμενες εβδομάδες με τον Sean

363
00:19:36,000 --> 00:19:39,000
και με διαδηλώσεις μας από την αναζήτηση για τους αριθμούς.

364
00:19:39,000 --> 00:19:42,000
Είναι ένα πρόβλημα, λαμβάνοντας και τη διαίρεση ξανά και ξανά.

365
00:19:42,000 --> 00:19:44,000
>> Με άλλα λόγια, υπάρχει τώρα ένας τρόπος της μετάφρασης

366
00:19:44,000 --> 00:19:47,000
αυτό το πραγματικό κόσμο κατασκεύασμα, αυτό το υψηλότερο επίπεδο κατασκεύασμα

367
00:19:47,000 --> 00:19:51,000
του διαίρει και βασίλευε και να κάνει κάτι ξανά και ξανά

368
00:19:51,000 --> 00:19:56,000
στον κώδικα, έτσι αυτό είναι κάτι που θα δούμε και πάλι την πάροδο του χρόνου.

369
00:19:56,000 --> 00:20:00,000
Τώρα, ως ένα μέρος, αν είστε νέοι στην αναδρομή θα πρέπει τουλάχιστον να καταλάβουν τώρα

370
00:20:00,000 --> 00:20:02,000
γιατί αυτό είναι αστείο.

371
00:20:02,000 --> 00:20:05,000
Πάω να πάει στο google.com,

372
00:20:05,000 --> 00:20:17,000
και Πάω να ψάξει για μερικές συμβουλές και κόλπα για αναδρομή, εισάγετε.

373
00:20:17,000 --> 00:20:21,000
Πείτε το πρόσωπο δίπλα σε σας αν δεν γελούσαν μόλις τώρα.

374
00:20:21,000 --> 00:20:23,000
Μήπως εννοείτε αναδρομή;

375
00:20:23,000 --> 00:20:25,000
Μήπως εννοείτε-αχ, εκεί πάμε.

376
00:20:25,000 --> 00:20:28,000
Εντάξει, τώρα που είναι το υπόλοιπο του καθενός.

377
00:20:28,000 --> 00:20:30,000
Ένα μικρό αυγό του Πάσχα ενσωματωμένο κάπου εκεί στο Google.

378
00:20:30,000 --> 00:20:33,000
Ως μέρος, έναν από τους συνδέσμους που βάζουμε στην ιστοσελίδα του μαθήματος

379
00:20:33,000 --> 00:20:36,000
για σήμερα είναι ακριβώς αυτό το πλέγμα των διαφόρων αλγορίθμων ταξινόμησης,

380
00:20:36,000 --> 00:20:39,000
μερικές από τις οποίες εξετάσαμε την περασμένη εβδομάδα, αλλά τι είναι ωραίο για αυτό το οπτικοποίηση

381
00:20:39,000 --> 00:20:43,000
όπως την προσπάθειά σας να τυλίξουν το μυαλό σας γύρω από διάφορα πράγματα που σχετίζονται με αλγόριθμους

382
00:20:43,000 --> 00:20:46,000
ξέρετε ότι μπορείτε πολύ εύκολα να αρχίσει τώρα με διαφορετικούς τύπους των εισροών.

383
00:20:46,000 --> 00:20:50,000
Οι είσοδοι όλοι αντιστραφεί, οι είσοδοι κυρίως ταξινόμηση, οι είσοδοι τυχαία και ούτω καθεξής.

384
00:20:50,000 --> 00:20:53,000
Όπως μπορείτε να προσπαθήσετε, πάλι, διακρίνει αυτά τα πράγματα στο μυαλό σας

385
00:20:53,000 --> 00:20:57,000
συνειδητοποιούν ότι αυτή η διεύθυνση URL στην ιστοσελίδα του μαθήματος στη σελίδα Διαλέξεις

386
00:20:57,000 --> 00:21:00,000
μπορεί να σας βοηθήσει λόγο σε μερικά από αυτά.

387
00:21:00,000 --> 00:21:05,000
>> Σήμερα επιτέλους να λυθεί αυτό το πρόβλημα, ενώ από πίσω,

388
00:21:05,000 --> 00:21:08,000
το οποίο ήταν ότι αυτή η λειτουργία ανταλλαγής απλά δεν λειτουργεί,

389
00:21:08,000 --> 00:21:12,000
και ποιο ήταν το θεμελιώδες πρόβλημα με αυτή τη λειτουργία ανταλλαγής,

390
00:21:12,000 --> 00:21:15,000
ο στόχος της οποίας ήταν, και πάλι, να ανταλλάξουν μια τιμή εδώ και εδώ

391
00:21:15,000 --> 00:21:17,000
έτσι ώστε αυτό που συμβαίνει;

392
00:21:17,000 --> 00:21:20,000
Αυτό στην πραγματικότητα δεν λειτουργεί. Γιατί;

393
00:21:20,000 --> 00:21:22,000
Ναι.

394
00:21:22,000 --> 00:21:28,000
[Δεν ακούγεται-φοιτητής]

395
00:21:28,000 --> 00:21:31,000
Ακριβώς, η εξήγηση για αυτό το bugginess

396
00:21:31,000 --> 00:21:34,000
απλά επειδή ήταν όταν καλέσετε συναρτήσεις σε C

397
00:21:34,000 --> 00:21:38,000
και οι λειτουργίες λαμβάνουν επιχειρήματα, σαν και β εδώ,

398
00:21:38,000 --> 00:21:42,000
περνάτε σε ό, τι αντίγραφα αξία που παρέχετε στη λειτουργία που εξασφαλίζει.

399
00:21:42,000 --> 00:21:46,000
Μπορείτε δεν παρέχουν οι ίδιοι τις αρχικές τιμές,

400
00:21:46,000 --> 00:21:49,000
έτσι είδαμε αυτό στο πλαίσιο της buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, που φαινόταν λίγο κάτι σαν αυτό.

402
00:21:52,000 --> 00:21:57,000
>> Υπενθυμίζουμε ότι είχαμε x και y αρχικοποιείται στο 1 και 2, αντιστοίχως.

403
00:21:57,000 --> 00:21:59,000
Στη συνέχεια εκτυπώνεται από ό, τι ήταν.

404
00:21:59,000 --> 00:22:03,000
Στη συνέχεια ισχυρίστηκε ότι ήμουν εναλλαγή τους καλώντας ανταλλαγής των x, y.

405
00:22:03,000 --> 00:22:06,000
Αλλά το πρόβλημα ήταν ότι η εναλλαγή εργασίας,

406
00:22:06,000 --> 00:22:10,000
αλλά μόνον στο πεδίο της ίδιας της συμφωνίας ανταλλαγής λειτουργούν.

407
00:22:10,000 --> 00:22:13,000
Από τη στιγμή που θα χτυπήσει γραμμή 40 Τα αντάλλαξαν αξίες

408
00:22:13,000 --> 00:22:16,000
πετάχτηκαν μακριά, και έτσι τίποτα

409
00:22:16,000 --> 00:22:21,000
στην αρχική κύρια λειτουργία ήταν στην πραγματικότητα άλλαξε καθόλου,

410
00:22:21,000 --> 00:22:26,000
έτσι αν νομίζετε τότε ως προς τι αυτό μοιάζει με την άποψη της μνήμης μας

411
00:22:26,000 --> 00:22:29,000
εάν αυτή η αριστερή πλευρά της πλακέτας παριστά-

412
00:22:29,000 --> 00:22:33,000
και εγώ θα κάνω το καλύτερό μου για να το δουν όλοι αυτό-αν αυτό αριστερή πλευρά του πλοίου

413
00:22:33,000 --> 00:22:37,000
αντιπροσωπεύει, ας πούμε, μνήμη RAM σας, και η στοίβα πρόκειται να αυξηθεί σε πάνω αυτόν τον τρόπο,

414
00:22:37,000 --> 00:22:43,000
και καλούμε μια συνάρτηση σαν κύριος, και έχει 2 κύριες τοπικές μεταβλητές, x και y,

415
00:22:43,000 --> 00:22:48,000
ας περιγράψει αυτούς ως x εδώ, και ας περιγράψει αυτά ως y εδώ,

416
00:22:48,000 --> 00:22:55,000
και ας βάλουμε τις τιμές 1 και 2, έτσι αυτό είναι εδώ κυρίως,

417
00:22:55,000 --> 00:22:58,000
και όταν η κύρια καλεί η λειτουργία ανταλλαγής το λειτουργικό σύστημα

418
00:22:58,000 --> 00:23:02,000
Η λειτουργία δίνει τη δική ανταλλαγής λωρίδα της μνήμης στη στοίβα,

419
00:23:02,000 --> 00:23:04,000
δικό του πλαίσιο για τη στοίβα, να το πω έτσι.

420
00:23:04,000 --> 00:23:08,000
Διαθέτει επίσης 32 bits για αυτά τα χαρακτηριστικά της.

421
00:23:08,000 --> 00:23:11,000
Συμβαίνει να καλέσετε τους a και b, αλλά αυτό είναι εντελώς αυθαίρετη.

422
00:23:11,000 --> 00:23:13,000
Θα μπορούσε να τους κάλεσε ό, τι θέλει, αλλά τι συμβαίνει όταν η κύρια

423
00:23:13,000 --> 00:23:19,000
κλήσεις swap είναι ότι παίρνει αυτό το 1, δίνει ένα αντίγραφο, δίνει ένα αντίγραφο.

424
00:23:19,000 --> 00:23:23,000
>> Υπάρχει 1 άλλες τοπικές μεταβλητές σε swap, όμως, που ονομάζεται τι; Tmp >>.

425
00:23:23,000 --> 00:23:27,000
Tmp, οπότε επιτρέψτε μου να δώσω στον εαυτό μου ένα άλλο 32 bit εδώ,

426
00:23:27,000 --> 00:23:29,000
και ό, τι έκανα σε αυτή τη λειτουργία;

427
00:23:29,000 --> 00:23:34,000
Είπα int tmp παίρνει, έτσι, ένα έχει 1, έτσι το έκανα αυτό, όταν την τελευταία μας έπαιξε με αυτό το παράδειγμα.

428
00:23:34,000 --> 00:23:39,000
Τότε ένας παίρνει b, οπότε το b είναι 2, έτσι τώρα αυτό γίνεται 2,

429
00:23:39,000 --> 00:23:42,000
και τώρα παίρνει β θερμοκρασία, έτσι temp είναι 1,

430
00:23:42,000 --> 00:23:44,000
έτσι και τώρα γίνεται αυτό b.

431
00:23:44,000 --> 00:23:46,000
Αυτό είναι μεγάλη. Δούλεψε.

432
00:23:46,000 --> 00:23:49,000
Στη συνέχεια, όμως, το συντομότερο τις αποδόσεις λειτουργία

433
00:23:49,000 --> 00:23:52,000
μνήμη της ανταλλαγής εξαφανίζεται αποτελεσματικά, έτσι ώστε να μπορούν να επαναχρησιμοποιηθούν

434
00:23:52,000 --> 00:23:58,000
από κάποια άλλη λειτουργία στο μέλλον, και κυρίως είναι προφανώς εντελώς αμετάβλητη.

435
00:23:58,000 --> 00:24:00,000
Χρειαζόμαστε έναν τρόπο ριζικά την επίλυση αυτού του προβλήματος,

436
00:24:00,000 --> 00:24:03,000
και σήμερα θα έχουμε τελικά έναν τρόπο για να γίνει αυτό σύμφωνα με την οποία

437
00:24:03,000 --> 00:24:06,000
μπορούμε να εισάγουμε κάτι που ονομάζεται ένα δείκτη.

438
00:24:06,000 --> 00:24:09,000
Αποδεικνύεται ότι μπορούμε να λύσουμε αυτό το πρόβλημα

439
00:24:09,000 --> 00:24:12,000
όχι με πέρασμα στα αντίγραφα των χ και γ

440
00:24:12,000 --> 00:24:18,000
αλλά με το πέρασμα σε ό, τι, νομίζετε ότι, με τη λειτουργία ανταλλαγής;

441
00:24:18,000 --> 00:24:20,000
Ναι, τι γίνεται με τη διεύθυνση;

442
00:24:20,000 --> 00:24:22,000
Δεν έχουμε πραγματικά μίλησε για τις διευθύνσεις σε πολλές λεπτομέρειες,

443
00:24:22,000 --> 00:24:25,000
αλλά αν αυτό το μαυροπίνακα αντιπροσωπεύει τη μνήμη του υπολογιστή μου

444
00:24:25,000 --> 00:24:28,000
θα μπορούσαμε βεβαίως να ξεκινήσετε την αρίθμηση των bytes στη μνήμη RAM μου

445
00:24:28,000 --> 00:24:31,000
και λένε ότι αυτό είναι # 1 byte, αυτό είναι byte # 2, # 3 byte,

446
00:24:31,000 --> 00:24:35,000
# 4 byte, byte ... # 2 δισεκατομμύρια αν έχω 2 gigabytes μνήμης RAM,

447
00:24:35,000 --> 00:24:38,000
έτσι θα μπορούσαμε σίγουρα να καταλήξει σε κάποιο αυθαίρετο σύστημα αρίθμησης

448
00:24:38,000 --> 00:24:41,000
για όλα τα επιμέρους bytes στη μνήμη του υπολογιστή μου.

449
00:24:41,000 --> 00:24:43,000
>> Τι θα συμβεί αν αντί όταν καλώ ανταλλαγής

450
00:24:43,000 --> 00:24:47,000
αντί πέρασμα σε αντίτυπα των x και y

451
00:24:47,000 --> 00:24:51,000
γιατί δεν μπορώ να κάνω αντί να περάσει στην διεύθυνση του x εδώ,

452
00:24:51,000 --> 00:24:55,000
η διεύθυνση του y εδώ, κατ 'ουσίαν, η ταχυδρομική διεύθυνση

453
00:24:55,000 --> 00:24:59,000
των x και y, διότι τότε ανταλλάξουν, αν έχει ενημερωθεί

454
00:24:59,000 --> 00:25:01,000
της διεύθυνσης στη μνήμη της χ και γ,

455
00:25:01,000 --> 00:25:04,000
ανταλλάξουν στη συνέχεια, αν έχουμε εκπαιδευτεί να τον λίγο,

456
00:25:04,000 --> 00:25:07,000
θα μπορούσε ενδεχομένως να οδηγήσει σε αυτή τη διεύθυνση, να το πω έτσι,

457
00:25:07,000 --> 00:25:11,000
x, και να αλλάξετε τον αριθμό εκεί, στη συνέχεια, οδηγεί στη διεύθυνση του y,

458
00:25:11,000 --> 00:25:16,000
αλλάξετε τον αριθμό εκεί, ακόμα και αν δεν πάρει πραγματικά αντίγραφα αυτών των αξιών ίδιος,

459
00:25:16,000 --> 00:25:19,000
έτσι ακόμα κι αν μιλούσαμε γι 'αυτό ως κύρια μνήμη του

460
00:25:19,000 --> 00:25:23,000
και τη μνήμη αυτού ως ανταλλαγή για το ισχυρό και το επικίνδυνο τμήμα του C

461
00:25:23,000 --> 00:25:28,000
είναι ότι κάθε λειτουργία μπορεί να αγγίξει τη μνήμη οπουδήποτε στον υπολογιστή,

462
00:25:28,000 --> 00:25:32,000
και αυτό είναι ισχυρό σε αυτό που μπορείτε να κάνετε πολύ φανταχτερά πράγματα με τα προγράμματα ηλεκτρονικών υπολογιστών σε C.

463
00:25:32,000 --> 00:25:36,000
Αυτό είναι επικίνδυνο γιατί μπορεί επίσης να βίδα μέχρι και πολύ εύκολα.

464
00:25:36,000 --> 00:25:39,000
Στην πραγματικότητα, ένας από τους πιο κοινούς τρόπους για προγράμματα αυτές τις μέρες να αξιοποιηθούν

465
00:25:39,000 --> 00:25:42,000
εξακολουθεί να είναι ένας προγραμματιστής για να μην συνειδητοποιούν

466
00:25:42,000 --> 00:25:45,000
ότι αυτός ή αυτή έχει μια επιτρέποντας δεδομένων

467
00:25:45,000 --> 00:25:49,000
για να γραφτεί σε μια θέση στη μνήμη, που δεν προορίζεται.

468
00:25:49,000 --> 00:25:51,000
>> Για παράδειγμα, αυτός ή αυτή δηλώνει μία συστοιχία μεγέθους 10

469
00:25:51,000 --> 00:25:56,000
αλλά στη συνέχεια τυχαία προσπαθεί να βάλει 11 bytes σε εκείνο συστοιχία μνήμης,

470
00:25:56,000 --> 00:25:59,000
και να αρχίσετε αγγίζει τα μέρη της μνήμης που δεν είναι πλέον σε ισχύ.

471
00:25:59,000 --> 00:26:02,000
Ακριβώς για αυτό συμφραζόμενα, κάποιοι από εσάς μπορεί να γνωρίζουν ότι

472
00:26:02,000 --> 00:26:06,000
λογισμικό σας ζητά συχνά για σειριακούς αριθμούς ή τα κλειδιά εγγραφής,

473
00:26:06,000 --> 00:26:08,000
Photoshop και το Word και προγράμματα όπως αυτό.

474
00:26:08,000 --> 00:26:12,000
Υπάρχουν ρωγμές, όπως κάποιοι από εσάς γνωρίζετε, σε απευθείας σύνδεση, όπου μπορείτε να εκτελέσετε ένα μικρό πρόγραμμα,

475
00:26:12,000 --> 00:26:14,000
και ιδού, πλέον αίτηση για τον ίδιο αύξοντα αριθμό.

476
00:26:14,000 --> 00:26:16,000
Πώς είναι ότι λειτουργεί;

477
00:26:16,000 --> 00:26:21,000
Σε πολλές περιπτώσεις, αυτά τα πράγματα είναι απλά διαπίστωση στους υπολογιστές

478
00:26:21,000 --> 00:26:24,000
τμήματα κειμένου σε πραγματικό μηδενικά και μονάδες του υπολογιστή

479
00:26:24,000 --> 00:26:28,000
όπου είναι η λειτουργία, όπου ο αριθμός σειράς έχει ζητηθεί,

480
00:26:28,000 --> 00:26:31,000
και μπορείτε να αντικαταστήσετε αυτό το χώρο, ή κατά την εκτέλεση του προγράμματος

481
00:26:31,000 --> 00:26:33,000
μπορείτε να υπολογίσετε όπου το κλειδί είναι πραγματικά αποθηκεύονται

482
00:26:33,000 --> 00:26:37,000
με κάτι που ονομάζεται ένα πρόγραμμα εντοπισμού σφαλμάτων, και μπορείτε να σπάσει το λογισμικό με αυτόν τον τρόπο.

483
00:26:37,000 --> 00:26:40,000
Αυτό δεν πρόκειται να πει ότι αυτός είναι ο στόχος μας για το επόμενο ζεύγος των ημερών,

484
00:26:40,000 --> 00:26:42,000
αλλά έχει πολύ πραγματικό κόσμο διακλαδώσεις.

485
00:26:42,000 --> 00:26:45,000
Αυτό συμβαίνει να αφορούν κλοπή του λογισμικού,

486
00:26:45,000 --> 00:26:47,000
αλλά υπάρχει επίσης συμβιβασμός ολόκληρων μηχανημάτων.

487
00:26:47,000 --> 00:26:50,000
>> Στην πραγματικότητα, όταν οι ιστοσελίδες αξιοποιηθούν αυτές τις μέρες

488
00:26:50,000 --> 00:26:53,000
και σε κίνδυνο και τα δεδομένα που διέρρευσαν και οι κωδικοί πρόσβασης κλαπεί

489
00:26:53,000 --> 00:26:58,000
αυτό πολύ συχνά σχετίζεται με κακή διαχείριση της μνήμης του,

490
00:26:58,000 --> 00:27:01,000
ή, στην περίπτωση των βάσεων δεδομένων, αδυναμία να προβλέψει

491
00:27:01,000 --> 00:27:03,000
αντιδικία εισόδου, έτσι ώστε περισσότερα για τις επόμενες εβδομάδες,

492
00:27:03,000 --> 00:27:07,000
αλλά προς το παρόν μόνο μια προεπισκόπηση του το είδος της βλάβης που μπορείτε να κάνετε

493
00:27:07,000 --> 00:27:11,000
δεν είναι αρκετά από την κατανόηση πώς λειτουργούν τα πράγματα κάτω από το καπό.

494
00:27:11,000 --> 00:27:14,000
Πάμε για την κατανόηση γιατί αυτό είναι σπασμένο

495
00:27:14,000 --> 00:27:17,000
με ένα εργαλείο που θα γίνεται όλο και πιο χρήσιμος

496
00:27:17,000 --> 00:27:19,000
τα προγράμματα μας πάρει πιο περίπλοκη.

497
00:27:19,000 --> 00:27:21,000
Μέχρι στιγμής, όταν είχατε ένα bug στο πρόγραμμα σας

498
00:27:21,000 --> 00:27:23,000
πώς έχετε πάει για debugging αυτό;

499
00:27:23,000 --> 00:27:25,000
Τι έχουν τις τεχνικές σας ήταν μέχρι τώρα, αν διδάσκεται από TF σας

500
00:27:25,000 --> 00:27:27,000
ή απλά αυτοδίδακτος;

501
00:27:27,000 --> 00:27:29,000
[Φοιτητικό] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, έτσι printf έχει πιθανώς φίλο σας ότι αν θέλετε να δείτε

503
00:27:31,000 --> 00:27:33,000
τι συμβαίνει στο εσωτερικό του προγράμματός σας

504
00:27:33,000 --> 00:27:36,000
μόλις τεθεί printf εδώ, εδώ printf, printf εδώ.

505
00:27:36,000 --> 00:27:38,000
Στη συνέχεια, μπορείτε να τρέξει, και θα έχετε ένα σωρό πράγματα στην οθόνη

506
00:27:38,000 --> 00:27:43,000
που μπορείτε να χρησιμοποιήσετε στη συνέχεια για να συμπεράνουμε τι πραγματικά συμβαίνει λάθος στο πρόγραμμά σας.

507
00:27:43,000 --> 00:27:45,000
>> Printf τείνει να είναι ένα πολύ ισχυρό πράγμα,

508
00:27:45,000 --> 00:27:47,000
αλλά είναι μια πολύ χειροκίνητη διαδικασία.

509
00:27:47,000 --> 00:27:49,000
Θα πρέπει να βάλετε ένα printf εδώ, μια printf εδώ,

510
00:27:49,000 --> 00:27:51,000
και αν το βάλετε μέσα από ένα βρόχο μπορείτε να πάρετε 100 γραμμές

511
00:27:51,000 --> 00:27:53,000
της παραγωγής που θα πρέπει στη συνέχεια να κοσκινίσει μέσω.

512
00:27:53,000 --> 00:27:58,000
Δεν είναι ένα πολύ φιλικό προς το χρήστη και διαδραστικό μηχανισμός για τον εντοπισμό σφαλμάτων προγραμμάτων,

513
00:27:58,000 --> 00:28:00,000
αλλά ευτυχώς υπάρχει εναλλακτικές λύσεις.

514
00:28:00,000 --> 00:28:03,000
Υπάρχει ένα πρόγραμμα, για παράδειγμα, που ονομάζεται GDB, η GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
το οποίο είναι ένα μικρό απόκρυφες το πώς μπορείτε να το χρησιμοποιήσετε.

516
00:28:06,000 --> 00:28:08,000
Είναι λίγο περίπλοκο, αλλά ειλικρινά,

517
00:28:08,000 --> 00:28:11,000
αυτό είναι ένα από εκείνα τα πράγματα που αν βάλεις σε αυτή την εβδομάδα και την επόμενη

518
00:28:11,000 --> 00:28:14,000
η επιπλέον ώρα για να καταλάβουμε κάτι σαν GDB

519
00:28:14,000 --> 00:28:18,000
θα σας εξοικονομήσει κατά πάσα πιθανότητα δεκάδες ώρες σε μακροπρόθεσμη βάση,

520
00:28:18,000 --> 00:28:21,000
έτσι με αυτό, επιτρέψτε μου να σας δώσω ένα teaser για το πώς λειτουργεί αυτό το πράγμα.

521
00:28:21,000 --> 00:28:23,000
>> Είμαι στο παράθυρο του τερματικού μου.

522
00:28:23,000 --> 00:28:26,000
Επιτρέψτε μου να προχωρήσει και να καταρτίζουν το πρόγραμμα αυτό, buggy3.

523
00:28:26,000 --> 00:28:28,000
Είναι ήδη μέχρι σήμερα.

524
00:28:28,000 --> 00:28:31,000
Επιτρέψτε μου να τρέξει, ακριβώς όπως κάναμε μια πίσω, ενώ, και πράγματι, έχει σπάσει.

525
00:28:31,000 --> 00:28:34,000
Αλλά γιατί συμβαίνει αυτό; Ίσως μαντάρα τη λειτουργία ανταλλαγής.

526
00:28:34,000 --> 00:28:37,000
Ίσως είναι a και b. Δεν είμαι κινείται γύρω τους αρκετά σωστά.

527
00:28:37,000 --> 00:28:39,000
Επιτρέψτε μου να προχωρήσει και να το κάνουμε αυτό.

528
00:28:39,000 --> 00:28:43,000
Αντί απλά να τρέξει buggy3 επιτρέψτε μου να τρέξει αντί αυτού GDB πρόγραμμα,

529
00:28:43,000 --> 00:28:48,000
και θα πάω να το πω για να τρέξει buggy3,

530
00:28:48,000 --> 00:28:52,000
και Πάω να περιλαμβάνουν επιχείρημα γραμμή εντολών,-TUI,

531
00:28:52,000 --> 00:28:55,000
και θα βάλουμε αυτό στο μέλλον προβλήματα στο spec να υπενθυμίσει.

532
00:28:55,000 --> 00:28:57,000
Και τώρα αυτό το μαύρο και άσπρο διεπαφή έσκασε επάνω ότι, και πάλι,

533
00:28:57,000 --> 00:28:59,000
είναι λίγο συντριπτική κατά την πρώτη, γιατί υπάρχει όλη αυτή η

534
00:28:59,000 --> 00:29:02,000
πληροφορίες εγγύησης εδώ κάτω, αλλά τουλάχιστον υπάρχει κάτι γνωστό.

535
00:29:02,000 --> 00:29:04,000
Στην κορυφή του παραθύρου είναι πραγματικό κώδικα μου,

536
00:29:04,000 --> 00:29:08,000
και αν μετακινηθείτε προς τα επάνω εδώ επιτρέψτε μου να μετακινηθείτε στην κορυφή του αρχείου μου,

537
00:29:08,000 --> 00:29:11,000
και πράγματι, δεν υπάρχει buggy3.c και ειδοποίηση στο κάτω μέρος αυτού του παραθύρου

538
00:29:11,000 --> 00:29:13,000
Έχω αυτό το GDB εντολών.

539
00:29:13,000 --> 00:29:16,000
>> Αυτό δεν είναι το ίδιο με το κανονικό John Harvard μου προτροπή.

540
00:29:16,000 --> 00:29:19,000
Αυτή είναι μια ερώτηση που πρόκειται να μου επιτρέψετε να ελέγχει GDB.

541
00:29:19,000 --> 00:29:21,000
GDB είναι ένα πρόγραμμα εντοπισμού σφαλμάτων.

542
00:29:21,000 --> 00:29:24,000
Ένα πρόγραμμα εντοπισμού σφαλμάτων είναι ένα πρόγραμμα που σας επιτρέπει να περπατήσετε

543
00:29:24,000 --> 00:29:27,000
εκτέλεση της γραμμής με το πρόγραμμά σας ανά γραμμή,

544
00:29:27,000 --> 00:29:30,000
κατά τον τρόπο να κάνει ό, τι θέλετε με το πρόγραμμα,

545
00:29:30,000 --> 00:29:33,000
ακόμη και καλώντας λειτουργίες, ή ψάχνει, το πιο σημαντικό,

546
00:29:33,000 --> 00:29:35,000
σε τιμές διαφόρων μεταβλητών.

547
00:29:35,000 --> 00:29:37,000
Ας πάμε μπροστά και να το κάνουμε αυτό.

548
00:29:37,000 --> 00:29:40,000
Πάω να πάει μπροστά και να πληκτρολογήσετε το τρέξιμο σε άμεση GDB, η

549
00:29:40,000 --> 00:29:43,000
έτσι παρατηρήσετε στο κάτω αριστερό μέρος της οθόνης που έχω πληκτρολογήσει τρέξει,

550
00:29:43,000 --> 00:29:45,000
και έχω πατήστε enter, και τι έκανε ότι κάνει;

551
00:29:45,000 --> 00:29:50,000
Είναι κυριολεκτικά έτρεξε το πρόγραμμά μου, αλλά δεν είχα πραγματικά να δείτε πολύ συνεχιστεί εδώ

552
00:29:50,000 --> 00:29:55,000
επειδή δεν έχω πει στην πραγματικότητα το πρόγραμμα εντοπισμού σφαλμάτων

553
00:29:55,000 --> 00:29:57,000
για παύση σε μια συγκεκριμένη χρονική στιγμή.

554
00:29:57,000 --> 00:29:59,000
Απλά πληκτρολογώντας τρέχει τρέχει το πρόγραμμα.

555
00:29:59,000 --> 00:30:01,000
Δεν βλέπω τίποτα στην πραγματικότητα. Δεν μπορώ να το χειραγωγήσουν.

556
00:30:01,000 --> 00:30:03,000
>> Αντ 'αυτού επιτρέψτε μου να το κάνετε αυτό.

557
00:30:03,000 --> 00:30:08,000
Σε αυτό το GDB άμεση επιτρέψτε μου να πληκτρολογήσετε αντί διάλειμμα, εισάγετε.

558
00:30:08,000 --> 00:30:10,000
Αυτό δεν είναι αυτό που ήθελα να πληκτρολογήσετε.

559
00:30:10,000 --> 00:30:13,000
Ας αντί να πληκτρολογήσετε κύρια διάλειμμα.

560
00:30:13,000 --> 00:30:15,000
Με άλλα λόγια, θέλω να ρυθμίσετε κάτι που ονομάζεται ένα σημείο διακοπής,

561
00:30:15,000 --> 00:30:18,000
η οποία εύστοχα ονομάστηκε, επειδή θα σπάσει ή παύση

562
00:30:18,000 --> 00:30:21,000
εκτέλεση του προγράμματός σας σε αυτή τη συγκεκριμένη θέση.

563
00:30:21,000 --> 00:30:23,000
Κύρια είναι το όνομα της συνάρτησης μου.

564
00:30:23,000 --> 00:30:25,000
Σημειώστε ότι GDB είναι αρκετά έξυπνος.

565
00:30:25,000 --> 00:30:28,000
Το κατάλαβα ότι ο κύριος συμβαίνει να ξεκινήσει περίπου σε γραμμή 18

566
00:30:28,000 --> 00:30:32,000
buggy3.c του, και στη συνέχεια να παρατηρήσετε εδώ στο πάνω αριστερά

567
00:30:32,000 --> 00:30:34,000
β + είναι ακριβώς δίπλα στην γραμμή 18.

568
00:30:34,000 --> 00:30:38,000
Αυτό είναι μου θυμίζει ότι έχω θέσει ένα breakpoint στη γραμμή 18.

569
00:30:38,000 --> 00:30:42,000
Αυτή τη φορά όταν πληκτρολογώ τρέξιμο, Πάω να τρέχει το πρόγραμμα μου

570
00:30:42,000 --> 00:30:45,000
μέχρι να χτυπήσει αυτό το σημείο διακοπής,

571
00:30:45,000 --> 00:30:48,000
έτσι ώστε το πρόγραμμα θα σταματήσει για μένα στη γραμμή 18.

572
00:30:48,000 --> 00:30:50,000
Πάμε λοιπόν, να τρέξει.

573
00:30:50,000 --> 00:30:53,000
Τίποτα δεν φαίνεται να έχει συμβεί, αλλά ειδοποίηση στο κάτω αριστερά

574
00:30:53,000 --> 00:30:58,000
έναρξη του προγράμματος, buggy3, breakpoint 1 στην κύρια γραμμή στο buggy3.c 18.

575
00:30:58,000 --> 00:31:00,000
Τι μπορώ να κάνω τώρα;

576
00:31:00,000 --> 00:31:03,000
>> Παρατηρήστε μπορώ να αρχίσετε να πληκτρολογείτε τα πράγματα όπως εκτύπωση,

577
00:31:03,000 --> 00:31:08,000
δεν printf, εκτύπωση x, και τώρα αυτό είναι παράξενο.

578
00:31:08,000 --> 00:31:11,000
Η $ 1 είναι απλά μια περιέργεια, όπως θα δούμε

579
00:31:11,000 --> 00:31:14,000
κάθε φορά που εκτυπώνετε κάτι μπορείτε να πάρετε μια νέα τιμή $.

580
00:31:14,000 --> 00:31:18,000
Αυτό είναι έτσι ώστε να μπορείτε να ανατρέχετε σε προηγούμενες τιμές μόνο σε περίπτωση,

581
00:31:18,000 --> 00:31:21,000
αλλά για τώρα τι εκτύπωσης μου λέει είναι ότι η τιμή του x σε αυτό το σημείο στην ιστορία

582
00:31:21,000 --> 00:31:26,000
είναι προφανώς 134514032.

583
00:31:26,000 --> 00:31:29,000
Τι; Πού πήγαν ακόμη ότι προέρχονται από;

584
00:31:29,000 --> 00:31:31,000
[Δεν ακούγεται-φοιτητής]

585
00:31:31,000 --> 00:31:34,000
Πράγματι, αυτό είναι αυτό που θα αποκαλούμε αξία σκουπίδια, και εμείς δεν έχουμε μιλήσει ακόμα γι 'αυτό,

586
00:31:34,000 --> 00:31:37,000
αλλά ο λόγος που αρχικοποιήσετε μεταβλητές

587
00:31:37,000 --> 00:31:40,000
είναι προφανώς έτσι ώστε να έχουν κάποια αξία που θέλετε να έχουν.

588
00:31:40,000 --> 00:31:44,000
Όμως, τα αλιεύματα υπενθυμίσει ότι μπορείτε να δηλώσετε τις μεταβλητές

589
00:31:44,000 --> 00:31:46,000
όπως έκανα πριν από λίγο σε σίγμα παράδειγμα μου

590
00:31:46,000 --> 00:31:48,000
χωρίς στην πραγματικότητα δίνοντάς τους αξία.

591
00:31:48,000 --> 00:31:50,000
Θυμηθείτε τι έκανα εδώ στο σίγμα.

592
00:31:50,000 --> 00:31:52,000
Δήλωσα n, αλλά τι αξία δεν μπορώ να δώσω;

593
00:31:52,000 --> 00:31:56,000
Καμία, γιατί ήξερα ότι μέσα στις επόμενες λίγες γραμμές

594
00:31:56,000 --> 00:31:59,000
GetInt θα αναλάβει τη φροντίδα του προβλήματος της αξιοποίησης μέσα από n.

595
00:31:59,000 --> 00:32:02,000
>> Αλλά σε αυτό το σημείο στην ιστορία της γραμμής 11

596
00:32:02,000 --> 00:32:05,000
και 12 της γραμμής και της γραμμής 13 και της γραμμής 14

597
00:32:05,000 --> 00:32:08,000
όλη αυτών αρκετές σειρές ποια είναι η τιμή του η;

598
00:32:08,000 --> 00:32:10,000
Στο C απλά δεν ξέρω.

599
00:32:10,000 --> 00:32:14,000
Είναι γενικά κάποια αξία σκουπίδια, μερικές εντελώς τυχαίο αριθμό

600
00:32:14,000 --> 00:32:17,000
που έχει απομείνει ουσιαστικά από κάποια προηγούμενη λειτουργία

601
00:32:17,000 --> 00:32:21,000
έχει τρέξει, έτσι ώστε το πρόγραμμα σας τρέχει

602
00:32:21,000 --> 00:32:24,000
Υπενθυμίζω ότι η λειτουργία παίρνει τη λειτουργία, τη λειτουργία, τη λειτουργία.

603
00:32:24,000 --> 00:32:27,000
Όλα αυτά τα πλαίσια να πάρει θέσει στη μνήμη, και στη συνέχεια αυτές τις λειτουργίες απόδοσης,

604
00:32:27,000 --> 00:32:31,000
και ακριβώς όπως πρότεινα με τη γόμα μνήμη τους είναι τελικά επαναχρησιμοποιείται.

605
00:32:31,000 --> 00:32:37,000
Λοιπόν, αυτό ακριβώς συμβαίνει, έτσι ώστε αυτή τη μεταβλητή x σε αυτό το πρόγραμμα

606
00:32:37,000 --> 00:32:41,000
φαίνεται να έχει κάποια αξία που περιέχονται σκουπίδια σαν 134514032

607
00:32:41,000 --> 00:32:44,000
από κάποια προηγούμενη λειτουργία, δεν είναι αυτό που έγραψα.

608
00:32:44,000 --> 00:32:47,000
Θα μπορούσε να είναι κάτι που έρχεται αποτελεσματικά με το λειτουργικό σύστημα,

609
00:32:47,000 --> 00:32:49,000
κάποια λειτουργία κάτω από την κουκούλα.

610
00:32:49,000 --> 00:32:52,000
>> Εντάξει, αυτό είναι εντάξει, αλλά ας τώρα να προχωρήσετε στην επόμενη γραμμή.

611
00:32:52,000 --> 00:32:55,000
Αν πληκτρολογήσετε «επόμενο» στην GDB προτροπή μου και πατήσω το enter,

612
00:32:55,000 --> 00:32:58,000
παρατηρήσετε ότι η ανάδειξη κινείται προς τα κάτω στη γραμμή 19,

613
00:32:58,000 --> 00:33:01,000
αλλά η λογική συνέπεια είναι ότι η γραμμή 18

614
00:33:01,000 --> 00:33:06,000
έχει πλέον τελειώσει την εκτέλεση, οπότε αν εγώ πάλι πληκτρολογήσετε "print x"

615
00:33:06,000 --> 00:33:10,000
Θα πρέπει τώρα να δείτε 1, και μάλιστα, να κάνω.

616
00:33:10,000 --> 00:33:14,000
Και πάλι, η $ ουσία είναι ένας τρόπος GDB σας υπενθυμίζουμε

617
00:33:14,000 --> 00:33:17,000
ποια είναι η ιστορία των εκτυπώσεων είναι ότι έχετε κάνει.

618
00:33:17,000 --> 00:33:21,000
Τώρα, επιτρέψτε μου να προχωρήσει και να εκτυπώσετε y, και πράγματι, y είναι κάποια τρελή αξία, καθώς,

619
00:33:21,000 --> 00:33:24,000
αλλά δεν είναι μεγάλη υπόθεση, γιατί στην γραμμή 19 είμαστε έτοιμοι να αναθέσει

620
00:33:24,000 --> 00:33:27,000
η τιμή 2, οπότε επιτρέψτε μου να πληκτρολογήσετε "επόμενο" και πάλι.

621
00:33:27,000 --> 00:33:29,000
Και τώρα είμαστε στη γραμμή printf.

622
00:33:29,000 --> 00:33:31,000
Επιτρέψτε μου να κάνω x εκτύπωσης.

623
00:33:31,000 --> 00:33:34,000
Επιτρέψτε μου να κάνω y εκτύπωσης. Ειλικρινά, παίρνω λίγο κουρασμένος από την εκτύπωση αυτή.

624
00:33:34,000 --> 00:33:38,000
Επιτρέψτε μου να πληκτρολογήσετε αντί "οθόνη x" και "y οθόνη,"

625
00:33:38,000 --> 00:33:41,000
και τώρα κάθε φορά που πληκτρολογείτε μια εντολή στο μέλλον

626
00:33:41,000 --> 00:33:45,000
Θα γίνει υπενθύμιση του τι είναι x και y, τι είναι x και y, τι είναι x και y.

627
00:33:45,000 --> 00:33:48,000
>> Δεν μπορώ επίσης, ως ένα μέρος, πληκτρολογήστε "ντόπιους πληροφορίες."

628
00:33:48,000 --> 00:33:50,000
Info είναι μια ειδική εντολή.

629
00:33:50,000 --> 00:33:52,000
Οι ντόπιοι σημαίνει ότι μου δείχνει τις τοπικές μεταβλητές.

630
00:33:52,000 --> 00:33:55,000
Ακριβώς σε περίπτωση που ξεχάσω ή αυτό είναι ένα τρελό, πολύπλοκη λειτουργία

631
00:33:55,000 --> 00:33:57,000
ότι εγώ ή κάποιος άλλος έγραψε ντόπιους πληροφορίες θα σας πω

632
00:33:57,000 --> 00:34:00,000
ποιες είναι όλες οι τοπικές μεταβλητές μέσα σε αυτό το τοπικό λειτουργία

633
00:34:00,000 --> 00:34:03,000
που μπορεί να ενδιαφέρονται για το αν θέλετε να σακί γύρω.

634
00:34:03,000 --> 00:34:07,000
Τώρα, printf είναι έτοιμος να εκτελέσει, οπότε επιτρέψτε μου να προχωρήσει και απλά πληκτρολογήστε "επόμενο".

635
00:34:07,000 --> 00:34:10,000
Επειδή είμαστε σε αυτό το περιβάλλον δεν είμαστε βλέπουμε την πραγματικότητα

636
00:34:10,000 --> 00:34:14,000
εκτελέσει εδώ κάτω, αλλά παρατηρήσετε είναι να πάρει λίγο παραμορφωμένα εδώ.

637
00:34:14,000 --> 00:34:17,000
Αλλά παρατηρήσετε ότι είναι επιτακτικό την οθόνη υπάρχει,

638
00:34:17,000 --> 00:34:21,000
έτσι δεν είναι ένα τέλειο πρόγραμμα εδώ, αλλά αυτό είναι εντάξει, γιατί μπορεί πάντα να σακί γύρω από

639
00:34:21,000 --> 00:34:23,000
χρησιμοποιώντας εκτύπωση αν θέλω.

640
00:34:23,000 --> 00:34:26,000
>> Επιτρέψτε μου να πληκτρολογήσετε στη συνέχεια και πάλι, και τώρα εδώ είναι το ενδιαφέρον κομμάτι.

641
00:34:26,000 --> 00:34:29,000
Σε αυτό το σημείο στην ιστορία γ είναι 2, και το χ είναι 1,

642
00:34:29,000 --> 00:34:32,000
όπως προτείνεται εδώ, και πάλι,

643
00:34:32,000 --> 00:34:35,000
ο λόγος για αυτό είναι αυτόματα εμφανίζει τώρα είναι επειδή χρησιμοποίησα την εντολή

644
00:34:35,000 --> 00:34:40,000
οθόνη x και y οθόνη, έτσι ώστε η στιγμή που πληκτρολογείτε επόμενη

645
00:34:40,000 --> 00:34:43,000
στη θεωρία Χ και Υ πρέπει να ανταλλάσσονται.

646
00:34:43,000 --> 00:34:45,000
Τώρα, γνωρίζουμε ήδη ότι δεν πρόκειται να είναι η περίπτωση,

647
00:34:45,000 --> 00:34:49,000
αλλά θα δούμε σε μια στιγμή πώς μπορούμε να περάσουμε να καταλάβω γιατί αυτό είναι αλήθεια.

648
00:34:49,000 --> 00:34:54,000
Στη συνέχεια, και δυστυχώς, εξακολουθεί να είναι y 2 και x εξακολουθεί να είναι 1, και μπορώ να επιβεβαιώσω τόσο πολύ.

649
00:34:54,000 --> 00:34:56,000
Εκτύπωση x, y εκτύπωσης.

650
00:34:56,000 --> 00:34:59,000
Πράγματι, δεν υπάρχει εναλλαγή έχει πράγματι συμβεί, γι 'αυτό ας ξεκινήσουμε αυτό πάνω.

651
00:34:59,000 --> 00:35:01,000
Είναι σαφές ότι το swap σπάσει.

652
00:35:01,000 --> 00:35:04,000
Ας πληκτρολογήστε αντί "τρέχει" και πάλι.

653
00:35:04,000 --> 00:35:07,000
Επιτρέψτε μου να πω ναι, θέλω να τεθεί πάλι σε λειτουργία από την αρχή, αρχίζει.

654
00:35:07,000 --> 00:35:09,000
>> Τώρα είμαι πίσω επάνω στη γραμμή 18.

655
00:35:09,000 --> 00:35:11,000
Τώρα παρατηρήσετε x και y είναι οι τιμές και πάλι σκουπίδια.

656
00:35:11,000 --> 00:35:15,000
Στη συνέχεια, δίπλα, δίπλα, δίπλα.

657
00:35:15,000 --> 00:35:17,000
Αν έχω βαρεθεί μπορώ επίσης να πληκτρολογήσετε μόνο ν για την επόμενη.

658
00:35:17,000 --> 00:35:21,000
Μπορείτε να συντομεύσει τη συντομότερη δυνατή ακολουθία χαρακτήρων.

659
00:35:21,000 --> 00:35:23,000
Swap είναι πλέον σπάσει.

660
00:35:23,000 --> 00:35:25,000
Ας βουτιά στην, έτσι αντί να πληκτρολογήσετε επόμενο,

661
00:35:25,000 --> 00:35:30,000
τώρα πάω να πληκτρολογήσετε το βήμα, έτσι ώστε Είμαι αναβάθμιση μέσα από αυτή τη λειτουργία

662
00:35:30,000 --> 00:35:33,000
έτσι ώστε να μπορώ να περπατήσω μέσα από αυτό, έτσι χτύπησα βήμα και στη συνέχεια εισάγετε.

663
00:35:33,000 --> 00:35:37,000
Παρατηρήστε ότι οι τονίζοντας άλματα κάτω κάτω στο πρόγραμμα μου με τη γραμμή 36.

664
00:35:37,000 --> 00:35:39,000
Τώρα ποιες είναι οι τοπικές μεταβλητές;

665
00:35:39,000 --> 00:35:41,000
Πληροφορίες για τους ντόπιους.

666
00:35:41,000 --> 00:35:43,000
Τίποτα ακριβώς ακόμα, γιατί εμείς δεν έχουμε φτάσει σε αυτή τη γραμμή,

667
00:35:43,000 --> 00:35:47,000
οπότε ας προχωρήσουμε και να πούμε "επόμενο".

668
00:35:47,000 --> 00:35:50,000
Τώρα φαίνεται να έχουμε tmp, tmp εκτύπωσης.

669
00:35:50,000 --> 00:35:52,000
Σκουπίδια αξία, έτσι δεν είναι; Νομίζω πως ναι.

670
00:35:52,000 --> 00:35:55,000
Πώς εκτυπώσετε για ένα, εκτύπωσης β, 1 και 2;

671
00:35:55,000 --> 00:35:58,000
Σε μια στιγμή, το συντομότερο τύπου Ι επόμενη φορά

672
00:35:58,000 --> 00:36:02,000
tmp πρόκειται να αναλάβει την τιμή 1, ελπίζουμε,

673
00:36:02,000 --> 00:36:05,000
tmp, επειδή πρόκειται να λαμβάνει την τιμή του a.

674
00:36:05,000 --> 00:36:08,000
>> Τώρα, ας μην εκτυπωθεί, β εκτύπωσης,

675
00:36:08,000 --> 00:36:11,000
εκτύπωση αλλά τώρα tmp, και είναι πράγματι 1.

676
00:36:11,000 --> 00:36:14,000
Επιτρέψτε μου να κάνω στη συνέχεια. Επιτρέψτε μου να κάνω στη συνέχεια.

677
00:36:14,000 --> 00:36:16,000
Έχω τελειώσει τη λειτουργία ανταλλαγής.

678
00:36:16,000 --> 00:36:19,000
Είμαι ακόμα μέσα από αυτό στην γραμμή 40, οπότε επιτρέψτε μου να εκτυπώσετε ένα,

679
00:36:19,000 --> 00:36:22,000
β εκτύπωσης, και δεν με νοιάζει τι είναι tmp.

680
00:36:22,000 --> 00:36:27,000
Μοιάζει swap είναι σωστό, όταν πρόκειται για εναλλαγή a και b.

681
00:36:27,000 --> 00:36:31,000
Αλλά αν εγώ τώρα πληκτρολογήστε επόμενη, εγώ άλμα πίσω στη γραμμή 25,

682
00:36:31,000 --> 00:36:34,000
και φυσικά, αν εγώ πληκτρολογήστε x και y εκτύπωση

683
00:36:34,000 --> 00:36:38,000
είναι ακόμα αμετάβλητη, γι 'αυτό δεν έχουν καθορίσει το πρόβλημα.

684
00:36:38,000 --> 00:36:41,000
Αλλά διαγνωστικά τώρα ίσως με αυτό το πρόγραμμα GDB

685
00:36:41,000 --> 00:36:44,000
έχουμε πάρει τουλάχιστον ένα βήμα πιο κοντά στην κατανόηση

686
00:36:44,000 --> 00:36:47,000
τι πηγαίνει στραβά, χωρίς να χρειάζεται να σκουπίδια μας κώδικα με την τοποθέτηση ενός printf εδώ,

687
00:36:47,000 --> 00:36:50,000
printf εδώ, εδώ printf και στη συνέχεια να τρέχει ξανά και ξανά

688
00:36:50,000 --> 00:36:52,000
προσπαθώ να καταλάβω τι συμβαίνει λάθος.

689
00:36:52,000 --> 00:36:55,000
>> Πάω να πάει μπροστά και να βγείτε από αυτό το εντελώς με σταματήσουν.

690
00:36:55,000 --> 00:36:57,000
Είναι πρόκειται να πει τότε, "Κλείστε ούτως ή άλλως;" Ναι.

691
00:36:57,000 --> 00:37:00,000
Τώρα είμαι πίσω σε κανονική προτροπή μου, και είμαι γίνει με GDB.

692
00:37:00,000 --> 00:37:03,000
Ως μέρος, δεν χρειάζεται να χρησιμοποιήσετε αυτό-tui σημαία.

693
00:37:03,000 --> 00:37:07,000
Στην πραγματικότητα, εάν μπορείτε να παραλείψετε να πάρετε ουσιαστικά το κάτω μισό της οθόνης.

694
00:37:07,000 --> 00:37:11,000
Αν στη συνέχεια πληκτρολογήστε διάλειμμα κύρια και στη συνέχεια να εκτελέσετε

695
00:37:11,000 --> 00:37:15,000
Μπορώ να τρέξω ακόμη το πρόγραμμά μου, αλλά τι θα κάνει είναι περισσότερο κειμενικά

696
00:37:15,000 --> 00:37:18,000
Απλά δείξτε μου την τρέχουσα μία γραμμή κάθε φορά.

697
00:37:18,000 --> 00:37:21,000
Η TUI-, κειμένου διεπαφή χρήστη,

698
00:37:21,000 --> 00:37:25,000
απλά σας δείχνει περισσότερο από το πρόγραμμα με τη μία, η οποία είναι ίσως λίγο πιο εύκολο εννοιολογικά.

699
00:37:25,000 --> 00:37:27,000
Αλλά πράγματι, μπορώ να το κάνω ακριβώς δίπλα, δίπλα, δίπλα,

700
00:37:27,000 --> 00:37:30,000
και πάω να δω μια γραμμή κάθε φορά, και αν πραγματικά θέλετε να δείτε τι συμβαίνει

701
00:37:30,000 --> 00:37:35,000
Μπορώ να πληκτρολογήσετε λίστα και δείτε ένα σωρό από γειτονικές γραμμές.

702
00:37:35,000 --> 00:37:39,000
>> Υπάρχει ένα βίντεο που έχουμε ζητήσει να παρακολουθήσετε πρόβλημα για σύνολα 3

703
00:37:39,000 --> 00:37:43,000
στην οποία Nate καλύπτει μερικά από τα περιπλοκές της GDB,

704
00:37:43,000 --> 00:37:46,000
και αυτό είναι ένα από εκείνα τα πράγματα, ειλικρινά, όπου κάποιες μη-τετριμμένη ποσοστό από εσάς

705
00:37:46,000 --> 00:37:49,000
Ποτέ δεν θα αγγίξει GDB, και ότι θα είναι ένα κακό πράγμα

706
00:37:49,000 --> 00:37:53,000
γιατί κυριολεκτικά θα καταλήξετε ξοδεύουν περισσότερο χρόνο αργότερα αυτό το εξάμηνο

707
00:37:53,000 --> 00:37:56,000
κυνηγώντας τα έντομα τότε θα αν βάλετε στη μισή ώρα / ώρα

708
00:37:56,000 --> 00:38:00,000
αυτή την εβδομάδα και την επόμενη μάθησης για να πάρει άνετα με το GDB.

709
00:38:00,000 --> 00:38:02,000
Printf ήταν ο φίλος σας.

710
00:38:02,000 --> 00:38:05,000
GDB θα πρέπει τώρα να είναι ο φίλος σας.

711
00:38:05,000 --> 00:38:08,000
>> Οποιεσδήποτε ερωτήσεις σχετικά με GDB;

712
00:38:08,000 --> 00:38:12,000
Και εδώ είναι μια γρήγορη λίστα με μερικές από τις πιο ισχυρές και χρήσιμες εντολές.

713
00:38:12,000 --> 00:38:15,000
Ναι. >> Μπορείτε να εκτυπώσετε μια σειρά;

714
00:38:15,000 --> 00:38:17,000
Μπορείτε να εκτυπώσετε ένα string; Απολύτως.

715
00:38:17,000 --> 00:38:19,000
Δεν πρέπει να είναι μόνο ακέραιοι.

716
00:38:19,000 --> 00:38:22,000
Αν μια μεταβλητή s είναι μια συμβολοσειρά απλά πληκτρολογήστε s εκτύπωσης.

717
00:38:22,000 --> 00:38:24,000
Θα σας δείξει τι είναι μεταβλητή συμβολοσειράς.

718
00:38:24,000 --> 00:38:26,000
[Δεν ακούγεται-φοιτητής]

719
00:38:26,000 --> 00:38:28,000
Αυτό θα σας δώσει τη διεύθυνση και την ίδια σειρά.

720
00:38:28,000 --> 00:38:32,000
Θα σας δείξω και τα δύο.

721
00:38:32,000 --> 00:38:34,000
Και κάτι τελευταίο, μόνο και μόνο επειδή αυτά είναι καλό να γνωρίζουμε πάρα πολύ.

722
00:38:34,000 --> 00:38:37,000
Backtrace και το πλαίσιο, επιτρέψτε μου να βουτήξει σε αυτό το τελευταίο ένα χρόνο,

723
00:38:37,000 --> 00:38:39,000
ίδιο ακριβώς πρόγραμμα με το GDB.

724
00:38:39,000 --> 00:38:44,000
Επιτρέψτε μου να πάμε μπροστά και να τρέξει την κειμενική έκδοση διεπαφή χρήστη,

725
00:38:44,000 --> 00:38:46,000
σπάσει κύρια.

726
00:38:46,000 --> 00:38:49,000
Επιτρέψτε μου να πάμε μπροστά και να τρέξει ξανά. Εδώ είμαι.

727
00:38:49,000 --> 00:38:55,000
Τώρα, επιτρέψτε μου να πάει δίπλα, δίπλα, δίπλα, δίπλα, δίπλα, το βήμα, εισάγετε.

728
00:38:55,000 --> 00:39:00,000
>> Και τώρα ας υποθέσουμε ότι είμαι τώρα σε ανταλλαγή σκόπιμα, αλλά είμαι σαν "Damn, ποια ήταν η αξία του Χ;"

729
00:39:00,000 --> 00:39:02,000
Δεν μπορώ να κάνω πια x.

730
00:39:02,000 --> 00:39:05,000
Δεν μπορώ να κάνω y επειδή δεν είστε σε πεδίο.

731
00:39:05,000 --> 00:39:07,000
Δεν είναι στο πλαίσιο, αλλά δεν υπάρχει πρόβλημα.

732
00:39:07,000 --> 00:39:09,000
Μπορώ να πληκτρολογήσετε backtrace.

733
00:39:09,000 --> 00:39:13,000
Αυτό μου δείχνει όλες τις λειτουργίες που έχουν εκτελεστεί μέχρι αυτό το χρονικό σημείο.

734
00:39:13,000 --> 00:39:16,000
Παρατηρήστε ότι η μία στο κάτω μέρος, κυρίως, των γραμμών με κύρια

735
00:39:16,000 --> 00:39:18,000
είναι στο κάτω μέρος της εικόνας μας εδώ.

736
00:39:18,000 --> 00:39:22,000
Το γεγονός ότι το swap είναι παραπάνω γραμμές με ανταλλαγή να είναι πάνω στη μνήμη εδώ,

737
00:39:22,000 --> 00:39:26,000
και αν θέλω να γυρίσω στην κύρια προσωρινά μπορώ να πω "κορνίζα".

738
00:39:26,000 --> 00:39:30,000
Τι νούμερο; Κύρια πλαίσιο είναι # 1.

739
00:39:30,000 --> 00:39:32,000
Πάω να πάει μπροστά και να πει "πλαισίου 1."

740
00:39:32,000 --> 00:39:36,000
>> Τώρα είμαι πίσω στην κύρια, και μπορώ να τυπώνει το x, και μπορώ να εκτυπώσετε y,

741
00:39:36,000 --> 00:39:40,000
αλλά δεν μπορώ να εκτυπώσετε ένα ή b.

742
00:39:40,000 --> 00:39:43,000
Αλλά δεν μπορώ να πω αν, "Εντάξει, περιμένετε ένα λεπτό. Πού ήταν η ανταλλαγή;"

743
00:39:43,000 --> 00:39:46,000
Επιτρέψτε μου να πάμε μπροστά και να πει "0 πλαισίου."

744
00:39:46,000 --> 00:39:48,000
Τώρα είμαι πίσω όπου θέλω να είμαι, και ως ένα μέρος,

745
00:39:48,000 --> 00:39:52,000
υπάρχει άλλη εντολές πάρα πολύ, όπως και αν είστε πραγματικά βαρεθεί να πάρει επόμενη πληκτρολόγηση, δίπλα, δίπλα, δίπλα,

746
00:39:52,000 --> 00:39:56,000
μπορείτε να πείτε γενικά πράγματα όπως «επόμενα 10», και ότι θα ενισχύσει μέσα από τις επόμενες 10 γραμμές.

747
00:39:56,000 --> 00:39:59,000
Μπορείτε επίσης να γράψετε "Συνέχεια" όταν πραγματικά να βαρεθεί με την ενίσχυση μέσα από αυτό.

748
00:39:59,000 --> 00:40:05,000
Συνεχίστε να τρέξετε το πρόγραμμά σας χωρίς διακοπή μέχρι να χτυπήσει ένα άλλο σημείο διακοπής,

749
00:40:05,000 --> 00:40:07,000
είτε σε έναν βρόχο ή να μειώσετε τα κάτω στο πρόγραμμά σας.

750
00:40:07,000 --> 00:40:11,000
>> Σε αυτή την περίπτωση έχουμε συνέχισε μέχρι το τέλος, και το πρόγραμμα διεγείρεται κανονικά.

751
00:40:11,000 --> 00:40:13,000
Αυτό είναι ένα φανταχτερό τρόπο, κάτω διαδικασία.

752
00:40:13,000 --> 00:40:16,000
Μόλις βγήκε από το πρόγραμμά σας κανονικά.

753
00:40:16,000 --> 00:40:24,000
Περισσότερα για αυτό το βίντεο και τον εντοπισμό σφαλμάτων σε συνεδρίες για να έρθει.

754
00:40:24,000 --> 00:40:26,000
Αυτό ήταν ένα πολύ.

755
00:40:26,000 --> 00:40:35,000
Ας ρίξουμε 5-λεπτά διάλειμμα μας εδώ, και θα επιστρέψουμε με structs και αρχεία.

756
00:40:35,000 --> 00:40:38,000
>> Αν έχετε βουτήξει σε PSET αυτής της εβδομάδας ήδη

757
00:40:38,000 --> 00:40:41,000
θα ξέρετε ότι χρησιμοποιούμε στον κώδικα της διανομής,

758
00:40:41,000 --> 00:40:45,000
το πηγαίο κώδικα που παρέχουμε σε σας ως σημείο εκκίνησης, κάποιες νέες τεχνικές.

759
00:40:45,000 --> 00:40:50,000
Συγκεκριμένα, εισήγαγε αυτή τη νέα λέξη-κλειδί που ονομάζεται struct, για τη δομή,

760
00:40:50,000 --> 00:40:53,000
ώστε να μπορέσουμε να δημιουργήσετε προσαρμοσμένες μεταβλητές του είδους.

761
00:40:53,000 --> 00:40:57,000
Επίσης, εισαγάγαμε την έννοια του αρχείου I / O, το αρχείο εισόδου και εξόδου,

762
00:40:57,000 --> 00:41:00,000
και αυτό είναι έτσι ώστε να μπορεί να σώσει την κατάσταση

763
00:41:00,000 --> 00:41:03,000
του διοικητικού συμβουλίου Scramble σας σε ένα αρχείο στο δίσκο

764
00:41:03,000 --> 00:41:06,000
έτσι ώστε οι υπότροφοι διδασκαλίας και μπορώ να καταλάβω

765
00:41:06,000 --> 00:41:09,000
τι συμβαίνει στο εσωτερικό του προγράμματός σας, χωρίς να χρειάζεται να παίξει το χέρι

766
00:41:09,000 --> 00:41:11,000
δεκάδες παιχνίδια αγωνίζομαι.

767
00:41:11,000 --> 00:41:13,000
Μπορούμε να το κάνουμε αυτό πιο automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Αυτή η ιδέα ενός struct λύνει ένα αρκετά συναρπαστικό πρόβλημα.

769
00:41:18,000 --> 00:41:21,000
Ας υποθέσουμε ότι θέλουμε να εφαρμόσουμε κάποιο πρόγραμμα

770
00:41:21,000 --> 00:41:25,000
που κρατά κατά κάποιο τρόπο κομμάτι των πληροφοριών σχετικά με τους φοιτητές,

771
00:41:25,000 --> 00:41:28,000
και οι μαθητές θα μπορούσαν να έχουν, για παράδειγμα, ένα αναγνωριστικό, ένα όνομα

772
00:41:28,000 --> 00:41:31,000
και ένα σπίτι σε ένα μέρος όπως το Harvard, ώστε αυτοί να είναι 3 κομμάτια των πληροφοριών

773
00:41:31,000 --> 00:41:34,000
θέλουμε να κρατήσουμε περίπου, οπότε επιτρέψτε μου να προχωρήσει και να αρχίσετε να γράφετε ένα μικρό πρόγραμμα εδώ,

774
00:41:34,000 --> 00:41:38,000
περιλαμβάνουν stdio.h.

775
00:41:38,000 --> 00:41:42,000
Επιτρέψτε μου να κάνω περιλαμβάνουν cs50.h.

776
00:41:42,000 --> 00:41:44,000
Και στη συνέχεια, ξεκινήστε κύρια λειτουργία μου.

777
00:41:44,000 --> 00:41:46,000
Δεν θα ασχοληθείτε με οποιαδήποτε επιχειρήματα της γραμμής εντολών,

778
00:41:46,000 --> 00:41:49,000
και εδώ θέλω να έχω έναν μαθητή, έτσι Πάω να πω

779
00:41:49,000 --> 00:41:54,000
ένας μαθητής έχει ένα όνομα, έτσι Πάω να πω "όνομα χορδών."

780
00:41:54,000 --> 00:41:59,000
Στη συνέχεια, θα πάω να πω ένα φοιτητής έχει επίσης ένα αναγνωριστικό, έτσι int id,

781
00:41:59,000 --> 00:42:03,000
και ένας μαθητής έχει ένα σπίτι, έτσι είμαι επίσης πρόκειται να πει "σπίτι σειρά."

782
00:42:03,000 --> 00:42:06,000
Τότε θα παραγγείλετε αυτά τα λίγο πιο καθαρά σαν αυτό.

783
00:42:06,000 --> 00:42:11,000
Εντάξει, τώρα έχω 3 μεταβλητές με τις οποίες να αντιπροσωπεύουν ένα μαθητή, έτσι "ένα φοιτητή."

784
00:42:11,000 --> 00:42:15,000
>> Και τώρα θέλω να συμπληρώσετε αυτές τις τιμές, οπότε επιτρέψτε μου να προχωρήσει και να πω κάτι σαν

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

786
00:42:18,000 --> 00:42:21,000
Όνομα πρόκειται να πάρει ο David.

787
00:42:21,000 --> 00:42:24,000
Ας πούμε ότι το σπίτι πρόκειται να πάρει Mather,

788
00:42:24,000 --> 00:42:31,000
και στη συνέχεια να πάω να κάνω κάτι αυθαίρετα σαν printf ("% s,

789
00:42:31,000 --> 00:42:37,000
των οποίων η ταυτότητα είναι% d, ζει σε% s.

790
00:42:37,000 --> 00:42:41,000
Και τώρα τι θέλω να συνδέσετε εδώ, το ένα μετά το άλλο;

791
00:42:41,000 --> 00:42:47,000
Όνομα, id, σπίτι? Return 0.

792
00:42:47,000 --> 00:42:50,000
Εντάξει, αν έκανα θάλασσα κάπου εδώ

793
00:42:50,000 --> 00:42:54,000
Νομίζω ότι έχουμε ένα πολύ καλό πρόγραμμα που αποθηκεύει ένας μαθητής.

794
00:42:54,000 --> 00:42:57,000
Φυσικά, αυτό δεν είναι όλα αυτά ενδιαφέρον. Τι γίνεται αν θέλω να έχω 2 μαθητές;

795
00:42:57,000 --> 00:42:59,000
Αυτό δεν είναι μεγάλη υπόθεση. Μπορώ να υποστηρίξει 2 άτομα.

796
00:42:59,000 --> 00:43:03,000
Επιτρέψτε μου να πάμε μπροστά και να αναδείξει αυτό και κατεβαίνουν εδώ,

797
00:43:03,000 --> 00:43:09,000
και μπορώ να πω "id = 456" για κάποιον σαν τον Rob που ζει σε Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Εντάξει, περιμένετε, αλλά δεν μπορώ να τα λέμε το ίδιο πράγμα,

799
00:43:12,000 --> 00:43:15,000
και φαίνεται σαν να είμαι πρόκειται να πρέπει να αντιγράψετε αυτό,

800
00:43:15,000 --> 00:43:19,000
οπότε επιτρέψτε μου να πω ότι αυτές θα είναι οι μεταβλητές του Δαβίδ,

801
00:43:19,000 --> 00:43:23,000
και επιτρέψτε μου να πάρετε κάποια από αυτά τα αντίγραφα για τον Rob.

802
00:43:23,000 --> 00:43:27,000
Θα καλέσετε αυτά τα Rob, αλλά αυτό δεν πρόκειται να λειτουργήσει τώρα

803
00:43:27,000 --> 00:43:33,000
επειδή έχω-περιμένετε, ας μου αλλάξει σε id1, NAME1 και House1.

804
00:43:33,000 --> 00:43:35,000
Rob θα είναι 2, 2.

805
00:43:35,000 --> 00:43:42,000
Έχω να το αλλάξετε αυτό εδώ, εδώ, εδώ, εδώ, εδώ, εδώ.

806
00:43:42,000 --> 00:43:45,000
Περιμένετε, τι γίνεται με τον Tommy; Ας κάνουμε αυτό και πάλι.

807
00:43:45,000 --> 00:43:49,000
Προφανώς, αν εξακολουθούν να πιστεύουν αυτό είναι ένας καλός τρόπος για να γίνει αυτό, δεν είναι,

808
00:43:49,000 --> 00:43:52,000
έτσι αντιγραφή / επικόλληση κακό.

809
00:43:52,000 --> 00:43:55,000
Αλλά έχουμε λύσει αυτό πριν από μία εβδομάδα.

810
00:43:55,000 --> 00:43:59,000
>> Ποια ήταν η λύση μας όταν θέλαμε να έχουμε πολλαπλές εμφανίσεις του ίδιου τύπου δεδομένων;

811
00:43:59,000 --> 00:44:01,000
[Φοιτητές] Μια σειρά.

812
00:44:01,000 --> 00:44:03,000
Μια σειρά, οπότε επιτρέψτε μου να προσπαθήσω να καθαρίσει αυτό επάνω.

813
00:44:03,000 --> 00:44:07,000
Επιτρέψτε μου να κάνω λίγο χώρο για τον εαυτό μου στην κορυφή, και επιτρέψτε μου να κάνω αυτό αντί για εδώ.

814
00:44:07,000 --> 00:44:12,000
Θα καλέσετε αυτούς τους ανθρώπους, και αντί να πάω να πω "int ταυτότητες,"

815
00:44:12,000 --> 00:44:14,000
και Πάω να υποστηρίξει 3 μας για τώρα.

816
00:44:14,000 --> 00:44:18,000
Πάω να πω "ονόματα εγχόρδων,« και εγώ θα υποστηρίξει 3 από εμάς,

817
00:44:18,000 --> 00:44:22,000
και στη συνέχεια, θα πάω να πω "σπίτια εγχόρδων," και είμαι πρόκειται να υποστηρίξει 3 από εμάς.

818
00:44:22,000 --> 00:44:26,000
Τώρα, εδώ, αντί του David να πάρει τις δικές του τοπικές μεταβλητές

819
00:44:26,000 --> 00:44:28,000
μπορούμε να απαλλαγούμε από αυτά.

820
00:44:28,000 --> 00:44:30,000
Αυτό αισθάνεται καλά ότι είμαστε καθαρισμό αυτό επάνω.

821
00:44:30,000 --> 00:44:35,000
Μπορώ να πω στη συνέχεια, ο David θα είναι [0] και τα ονόματα [0]

822
00:44:35,000 --> 00:44:38,000
και τα σπίτια [0].

823
00:44:38,000 --> 00:44:41,000
Και στη συνέχεια, Rob μπορούμε ομοίως να αποθηκεύσετε σε αυτό.

824
00:44:41,000 --> 00:44:46,000
Ας το θέσουμε εδώ κάτω, έτσι πρόκειται να είναι αυθαίρετα ids [1].

825
00:44:46,000 --> 00:44:50,000
Είναι πρόκειται να είναι τα ονόματα [1],

826
00:44:50,000 --> 00:44:53,000
και, στη συνέχεια, τέλος, σπίτια [1].

827
00:44:53,000 --> 00:44:57,000
>> Ακόμα λίγο κουραστική, και τώρα πρέπει να το καταλάβουν αυτό,

828
00:44:57,000 --> 00:45:03,000
έτσι ας πούμε "τα ονόματα [0], id [0], σπίτια [0],

829
00:45:03,000 --> 00:45:06,000
και ας πληθυντικό και αυτό.

830
00:45:06,000 --> 00:45:09,000
Ταυτότητες, ταυτότητες, ταυτότητες.

831
00:45:09,000 --> 00:45:12,000
Και πάλι, το κάνω, οπότε και πάλι, είμαι ήδη καταφεύγουν σε αντιγραφή / επικόλληση και πάλι,

832
00:45:12,000 --> 00:45:14,000
έτσι οι πιθανότητες είναι ότι υπάρχει άλλη λύση εδώ.

833
00:45:14,000 --> 00:45:18,000
Μπορώ να καθαρίσει πιθανότατα αυτό περαιτέρω με έναν βρόχο ή κάτι τέτοιο,

834
00:45:18,000 --> 00:45:21,000
έτσι με λίγα λόγια, είναι λίγο καλύτερα, αλλά εξακολουθεί να αισθάνεται σαν

835
00:45:21,000 --> 00:45:24,000
Είμαι καταφεύγουν σε αντιγραφή / επικόλληση, αλλά ακόμη και αυτό, ισχυρίζονται,

836
00:45:24,000 --> 00:45:27,000
δεν είναι πραγματικά ουσιαστικά η σωστή λύση, διότι

837
00:45:27,000 --> 00:45:29,000
τι θα γίνει αν κάποια στιγμή αποφασίσουμε ξέρετε τι;

838
00:45:29,000 --> 00:45:32,000
Θα πρέπει πραγματικά να έχουν την αποθήκευση των διευθύνσεων ηλεκτρονικού ταχυδρομείου για τον David και Rob

839
00:45:32,000 --> 00:45:34,000
και όλοι οι άλλοι σε αυτό το πρόγραμμα.

840
00:45:34,000 --> 00:45:36,000
Θα πρέπει επίσης να αποθηκεύσει αριθμούς τηλεφώνου.

841
00:45:36,000 --> 00:45:39,000
Θα πρέπει επίσης να αποθηκεύσει αριθμούς επικοινωνίας έκτακτης ανάγκης.

842
00:45:39,000 --> 00:45:41,000
Έχουμε όλα αυτά τα κομμάτια των δεδομένων που θέλετε να αποθηκεύσετε,

843
00:45:41,000 --> 00:45:43,000
έτσι πώς μπορείτε να κάνετε για αυτό;

844
00:45:43,000 --> 00:45:46,000
>> Μπορείτε να δηλώσετε μια άλλη σειρά στην κορυφή, και στη συνέχεια μπορείτε να προσθέσετε οι ίδιοι

845
00:45:46,000 --> 00:45:49,000
μια διεύθυνση ηλεκτρονικού ταχυδρομείου [0], τη διεύθυνση ηλεκτρονικού ταχυδρομείου [1]

846
00:45:49,000 --> 00:45:51,000
για τον David και Rob και ούτω καθεξής.

847
00:45:51,000 --> 00:45:56,000
Αλλά υπάρχει πραγματικά μόνο μια υπόθεση στην οποία βασίζεται αυτό το σχέδιο

848
00:45:56,000 --> 00:45:59,000
ότι είμαι χρησιμοποιώντας το σύστημα τιμή να σας γνωρίζουμε ότι

849
00:45:59,000 --> 00:46:03,000
[I] σε κάθε μία από τις αρκετές συστοιχίες

850
00:46:03,000 --> 00:46:06,000
ακριβώς έτσι συμβαίνει να αναφέρονται στο ίδιο πρόσωπο,

851
00:46:06,000 --> 00:46:10,000
έτσι [0] σε ταυτότητες είναι ο αριθμός 123,

852
00:46:10,000 --> 00:46:13,000
και Πάω να υποθέσουμε ότι τα ονόματα [0]

853
00:46:13,000 --> 00:46:16,000
είναι το όνομα του ίδιου του ατόμου και τα σπίτια [0]

854
00:46:16,000 --> 00:46:21,000
είναι το σπίτι του ίδιου του ατόμου και ούτω καθ 'εξής για όλες τις διάφορες σειρές που έχω δημιουργήσει.

855
00:46:21,000 --> 00:46:24,000
Αλλά παρατηρώ ότι δεν υπάρχει θεμελιώδης σύνδεση

856
00:46:24,000 --> 00:46:27,000
μεταξύ των 3 κομμάτια των πληροφοριών, id, όνομα και σπίτι,

857
00:46:27,000 --> 00:46:32,000
ακόμη και αν η οικονομική οντότητα προσπαθούμε να μοντέλο σε αυτό το πρόγραμμα δεν είναι συστοιχίες.

858
00:46:32,000 --> 00:46:35,000
Οι πίνακες είναι ακριβώς αυτή η προγραμματική τρόπος για να γίνει αυτό.

859
00:46:35,000 --> 00:46:38,000
Αυτό που πραγματικά θέλουμε να μοντελοποιήσουμε στο πρόγραμμά μας είναι ένα πρόσωπο

860
00:46:38,000 --> 00:46:41,000
όπως ο David, ένα πρόσωπο όπως ο Rob μέσα από τα οποία

861
00:46:41,000 --> 00:46:46,000
ή εγκλεισμού είναι ένα όνομα και ταυτότητα και ένα σπίτι.

862
00:46:46,000 --> 00:46:49,000
>> Μπορούμε να εκφράσουμε με κάποιο τρόπο αυτή την ιδέα του εγκλεισμού

863
00:46:49,000 --> 00:46:52,000
σύμφωνα με την οποία ένα άτομο έχει μια ταυτότητα, ένα όνομα και ένα σπίτι

864
00:46:52,000 --> 00:46:55,000
και να μην καταφεύγουν σε πραγματικά αυτό το hack το οποίο απλά

865
00:46:55,000 --> 00:46:58,000
εμπιστοσύνη ότι κάτι βραχίονα

866
00:46:58,000 --> 00:47:02,000
αναφέρεται στην ίδια ανθρώπινη οντότητα σε κάθε μία από αυτές τις ανόμοιες συστοιχίες;

867
00:47:02,000 --> 00:47:04,000
Μπορούμε να το κάνουμε αυτό πραγματικότητα.

868
00:47:04,000 --> 00:47:08,000
Επιτρέψτε μου να πάω πάνω από την κύρια για τώρα, και επιτρέψτε μου να δημιουργήσετε τα δικά μου δεδομένα τύπου

869
00:47:08,000 --> 00:47:10,000
πραγματικά για πρώτη φορά.

870
00:47:10,000 --> 00:47:14,000
Χρησιμοποιήσαμε αυτή την τεχνική σε Scramble,

871
00:47:14,000 --> 00:47:17,000
αλλά εδώ είμαι πρόκειται να πάει μπροστά και να δημιουργήσετε έναν τύπο δεδομένων,

872
00:47:17,000 --> 00:47:19,000
και ξέρετε τι, θα πάω να το ονομάσουμε φοιτητής ή πρόσωπο,

873
00:47:19,000 --> 00:47:23,000
και είμαι πρόκειται να χρησιμοποιήσετε typedef για τον καθορισμό έναν τύπο.

874
00:47:23,000 --> 00:47:25,000
Πάω να πω ότι αυτό είναι μια δομή,

875
00:47:25,000 --> 00:47:29,000
και στη συνέχεια, αυτή η δομή θα είναι φοιτητής του τύπου, εμείς θα πούμε,

876
00:47:29,000 --> 00:47:31,000
ακόμα κι αν είναι λίγο ημερομηνία τώρα για μένα.

877
00:47:31,000 --> 00:47:33,000
Θα πούμε "int id".

878
00:47:33,000 --> 00:47:35,000
Θα πω "όνομα χορδών."

879
00:47:35,000 --> 00:47:37,000
Στη συνέχεια, εμείς θα πούμε "σπίτι σειρά,"

880
00:47:37,000 --> 00:47:40,000
έτσι τώρα μέχρι το τέλος του αυτές τις λίγες γραμμές κώδικα

881
00:47:40,000 --> 00:47:45,000
Έχω διδάξει μόλις κλαγγή ότι υπάρχει

882
00:47:45,000 --> 00:47:49,000
ένας τύπος δεδομένων εκτός ints, εκτός από χορδές, εκτός διπλασιάζεται, εκτός από πλωτήρες.

883
00:47:49,000 --> 00:47:54,000
>> Από αυτή τη στιγμή σε χρονική γραμμή 11, υπάρχει τώρα ένας νέος τύπος δεδομένων που ονομάζεται φοιτητές,

884
00:47:54,000 --> 00:47:58,000
και τώρα μπορώ να δηλώσετε μια μεταβλητή φοιτητής οπουδήποτε θέλω,

885
00:47:58,000 --> 00:48:01,000
οπότε επιτρέψτε μου να μετακινηθείτε προς τα κάτω εδώ στους ανθρώπους.

886
00:48:01,000 --> 00:48:05,000
Τώρα μπορώ να απαλλαγούμε από αυτό, και μπορώ να πάω πίσω στον David εδώ,

887
00:48:05,000 --> 00:48:10,000
και για τον David μπορώ πραγματικά να πω ότι ο David,

888
00:48:10,000 --> 00:48:13,000
μπορούμε να ονομάσουμε τη μεταβλητή κυριολεκτικά τον εαυτό μου,

889
00:48:13,000 --> 00:48:16,000
πρόκειται να είναι του τύπου των φοιτητών.

890
00:48:16,000 --> 00:48:18,000
Αυτό μπορεί να φαίνεται λίγο παράξενο, αλλά αυτό δεν είναι όλα αυτά διαφορετικά

891
00:48:18,000 --> 00:48:22,000
από τη δήλωση κάτι σαν int ή ένα string ή ένα πλωτήρα.

892
00:48:22,000 --> 00:48:24,000
Είναι ακριβώς έτσι συμβαίνει να λέγεται φοιτητής τώρα,

893
00:48:24,000 --> 00:48:28,000
και αν θέλω να βάλω κάτι μέσα από αυτή τη δομή

894
00:48:28,000 --> 00:48:31,000
Τώρα πρέπει να χρησιμοποιήσετε ένα νέο κομμάτι της σύνταξης, αλλά είναι αρκετά απλή,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" στο κεφάλαιο Δ,

896
00:48:39,000 --> 00:48:42,000
και david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
και τώρα μπορώ να απαλλαγούμε από αυτά τα πράγματα εδώ.

898
00:48:46,000 --> 00:48:51,000
Ανακοίνωση έχουμε επανασχεδιασμένο τώρα το πρόγραμμά μας σε πραγματικά ένα πολύ καλύτερο τρόπο

899
00:48:51,000 --> 00:48:54,000
στο ότι τώρα το πρόγραμμά μας αντικατοπτρίζει τον πραγματικό κόσμο.

900
00:48:54,000 --> 00:48:57,000
>> Υπάρχει ένα πραγματικό κόσμο αντίληψη ενός ατόμου ή ενός φοιτητή.

901
00:48:57,000 --> 00:49:02,000
Εδώ έχουμε τώρα μια έκδοση C από ένα άτομο ή πιο συγκεκριμένα ένα φοιτητή.

902
00:49:02,000 --> 00:49:05,000
Μέσα από αυτό το άτομο είναι αυτοί οι σχετικές χαρακτηριστικά,

903
00:49:05,000 --> 00:49:10,000
ID, το όνομα και το σπίτι, έτσι Rob γίνεται ουσιαστικά το ίδιο πράγμα εδώ κάτω,

904
00:49:10,000 --> 00:49:14,000
έτσι φοιτητής ληστεύουν, και τώρα rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob".

906
00:49:17,000 --> 00:49:20,000
Το γεγονός ότι η μεταβλητή ονομάζεται Rob είναι το είδος της νόημα.

907
00:49:20,000 --> 00:49:22,000
Θα μπορούσε να ονομάζεται το x ή το y ή z.

908
00:49:22,000 --> 00:49:25,000
Εμείς απλά ονόμασε Rob να είναι συνεπής σημασιολογικά,

909
00:49:25,000 --> 00:49:28,000
αλλά πραγματικά το όνομα είναι μέσα από αυτό το ίδιο το πεδίο,

910
00:49:28,000 --> 00:49:30,000
έτσι τώρα έχω αυτό.

911
00:49:30,000 --> 00:49:33,000
Αυτό σημαίνει επίσης δεν αισθάνονται τον καλύτερο σχεδιασμό σε ότι έχω σκληρά κωδικοποιούνται David.

912
00:49:33,000 --> 00:49:35,000
Έχω σκληρό κωδικοποιούνται Rob.

913
00:49:35,000 --> 00:49:39,000
Και έχω ακόμα να καταφύγουν σε κάποιο αντιγραφή και επικόλληση κάθε φορά που θέλω νέες μεταβλητές.

914
00:49:39,000 --> 00:49:43,000
Επιπλέον, θα πρέπει να δώσει προφανώς κάθε μία από αυτές τις μεταβλητές ένα όνομα,

915
00:49:43,000 --> 00:49:46,000
παρόλο που θα ήθελα πολύ μάλλον περιγράψει αυτές τις μεταβλητές

916
00:49:46,000 --> 00:49:48,000
 πιο γενικά ως φοιτητές.

917
00:49:48,000 --> 00:49:52,000
>> Τώρα μπορούμε να συγχωνεύσει τις ιδέες που έχουν εργαστεί καλά για εμάς

918
00:49:52,000 --> 00:49:56,000
και αντί να λένε, "Ξέρεις κάτι, να μου δώσει μια μεταβλητή που ονομάζεται φοιτητές,

919
00:49:56,000 --> 00:50:01,000
και ας έχουν το μέγεθος του είναι 3, "έτσι τώρα μπορώ να βελτιώσετε αυτό περαιτέρω,

920
00:50:01,000 --> 00:50:04,000
να απαλλαγούμε από το χέρι δήλωσε ο David,

921
00:50:04,000 --> 00:50:08,000
και μπορώ να πω κάτι, αντί σαν φοιτητές [0] εδώ.

922
00:50:08,000 --> 00:50:11,000
Μπορώ να πω τότε οι μαθητές [0] εδώ,

923
00:50:11,000 --> 00:50:14,000
φοιτητές [0] εδώ, και ούτω καθεξής, και μπορώ να πάω γύρω

924
00:50:14,000 --> 00:50:16,000
και καθαρίστε ότι για τον Rob.

925
00:50:16,000 --> 00:50:19,000
Θα μπορούσα επίσης να πάτε τώρα για προσθέτοντας ίσως ένα βρόχο

926
00:50:19,000 --> 00:50:23,000
και χρησιμοποιώντας GetString και GetInt για να πάρει πραγματικά αυτές τις τιμές από το χρήστη.

927
00:50:23,000 --> 00:50:27,000
Θα μπορούσα να συνεχίσω για προσθέτοντας μια σταθερά, διότι αυτό είναι γενικά κακή πρακτική

928
00:50:27,000 --> 00:50:29,000
στο σκληρό κωδικός κάποιο αυθαίρετο αριθμό σαν 3 εδώ

929
00:50:29,000 --> 00:50:33,000
και στη συνέχεια απλά να θυμάστε ότι θα πρέπει να τεθεί όχι περισσότερο από 3 φοιτητές σε αυτό.

930
00:50:33,000 --> 00:50:36,000
Θα ήταν μάλλον καλύτερο να χρησιμοποιήσετε # define στην κορυφή του αρχείου μου

931
00:50:36,000 --> 00:50:40,000
και παράγοντας που έξω, έτσι πράγματι, επιτρέψτε μου να προχωρήσει και να γενικεύσει αυτό.

932
00:50:40,000 --> 00:50:43,000
>> Επιτρέψτε μου να ανοίξει ένα παράδειγμα που είναι μεταξύ του σήμερα

933
00:50:43,000 --> 00:50:46,000
παραδείγματα εκ των προτέρων, structs1.

934
00:50:46,000 --> 00:50:49,000
Αυτό είναι ένα πιο ολοκληρωμένο πρόγραμμα που χρησιμοποιεί το # define εδώ

935
00:50:49,000 --> 00:50:51,000
και λέει ότι θα πάμε να έχουν 3 μαθητές από προεπιλογή.

936
00:50:51,000 --> 00:50:54,000
Εδώ είμαι κήρυξη αξίζει κατηγορία των φοιτητών,

937
00:50:54,000 --> 00:50:57,000
έτσι μια τάξη από τους μαθητές, και τώρα είμαι χρησιμοποιώντας ένα βρόχο

938
00:50:57,000 --> 00:51:00,000
απλά για να γίνει ο κώδικας είναι λίγο πιο κομψά, συμπληρώσετε την κατηγορία

939
00:51:00,000 --> 00:51:05,000
με την είσοδο του χρήστη, έτσι επαναλάβει από i = 0 έως φοιτητές, που είναι 3.

940
00:51:05,000 --> 00:51:07,000
Και τότε θα ζητήσει από το χρήστη σε αυτή την έκδοση

941
00:51:07,000 --> 00:51:10,000
 τι ταυτότητας του μαθητή, και θα το πάρει με GetInt.

942
00:51:10,000 --> 00:51:13,000
Ποιο είναι το όνομα του μαθητή, και στη συνέχεια να πάρω με GetString.

943
00:51:13,000 --> 00:51:15,000
Τι είναι το σπίτι του μαθητή; Κατάλαβα με GetString.

944
00:51:15,000 --> 00:51:19,000
Και στη συνέχεια, στο κάτω μέρος εδώ απλά αποφάσισε να αλλάξει

945
00:51:19,000 --> 00:51:22,000
πώς είμαι εκτύπωση από αυτά και να χρησιμοποιήσετε πραγματικά ένα βρόχο,

946
00:51:22,000 --> 00:51:24,000
και ποιος είμαι εγώ εκτύπωση;

947
00:51:24,000 --> 00:51:27,000
Σύμφωνα με το σχόλιο Είμαι εκτύπωση σε οποιονδήποτε Mather,

948
00:51:27,000 --> 00:51:30,000
και ότι είναι τόσο Rob και ο Tommy και ούτω καθεξής-στην πραγματικότητα του Tommy σε Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy και ο David θα εκτυπωθεί σε αυτή την περίπτωση, αλλά πώς αυτό λειτουργεί;

950
00:51:34,000 --> 00:51:40,000
Δεν έχουμε δει αυτή τη λειτουργία πριν, αλλά να λάβει μια εικασία για το τι κάνει αυτό.

951
00:51:40,000 --> 00:51:42,000
Συγκρίνει χορδές.

952
00:51:42,000 --> 00:51:45,000
>> Είναι ένα μικρό μη-προφανές πώς συγκρίνει συμβολοσειρές, διότι αποδεικνύεται

953
00:51:45,000 --> 00:51:49,000
αν επιστρέφει 0 αυτό σημαίνει ότι οι χορδές είναι ίσες.

954
00:51:49,000 --> 00:51:53,000
Αν επιστρέφει -1 αυτό σημαίνει ότι το ένα έρχεται αλφαβητικά πριν από την άλλη,

955
00:51:53,000 --> 00:51:57,000
και αν επιστρέφει +1 που σημαίνει ότι την άλλη λέξη προέρχεται αλφαβητικά

956
00:51:57,000 --> 00:52:00,000
πριν από την άλλη, και μπορείτε να δείτε σε απευθείας σύνδεση ή στη σελίδα man

957
00:52:00,000 --> 00:52:04,000
για να δείτε ποια ακριβώς τρόπο που είναι, αλλά όλα αυτά τώρα κάνει είναι να λέει

958
00:52:04,000 --> 00:52:09,000
αν η [i]. το σπίτι είναι ίσο με "Mather"

959
00:52:09,000 --> 00:52:13,000
στη συνέχεια, να προχωρήσει και να εκτυπώσετε έτσι και έτσι είναι σε Mather.

960
00:52:13,000 --> 00:52:16,000
Αλλά εδώ είναι κάτι που δεν έχουμε ξαναδεί, και θα επανέλθουμε σε αυτό.

961
00:52:16,000 --> 00:52:21,000
Δεν θυμάμαι ποτέ να χρειάζεται να το κάνετε αυτό σε οποιοδήποτε από τα προγράμματα μου.

962
00:52:21,000 --> 00:52:24,000
Δωρεάν προφανώς αναφέρεται στην μνήμη, ελευθερώνοντας μνήμη,

963
00:52:24,000 --> 00:52:31,000
αλλά τι μνήμη είμαι προφανώς απελευθέρωση σε αυτό το βρόχο στο κάτω μέρος αυτού του προγράμματος;

964
00:52:31,000 --> 00:52:34,000
Φαίνεται σαν να είμαι ελευθερώνοντας το όνομα ενός ατόμου

965
00:52:34,000 --> 00:52:37,000
και το σπίτι ενός ατόμου, αλλά γιατί συμβαίνει αυτό;

966
00:52:37,000 --> 00:52:41,000
>> Βγάζει όλα αυτές τις εβδομάδες που έχετε χρησιμοποιήσει GetString

967
00:52:41,000 --> 00:52:45,000
έχουμε το είδος της εισαγωγής έχει ένα bug σε κάθε ένα από τα προγράμματα σας.

968
00:52:45,000 --> 00:52:51,000
GetString από το σχεδιασμό διαθέτει μνήμη ώστε να μπορεί να επιστρέψει σε εσάς μια σειρά,

969
00:52:51,000 --> 00:52:55,000
όπως ο David, ή Rob, και στη συνέχεια μπορείτε να κάνετε ό, τι θέλετε

970
00:52:55,000 --> 00:52:59,000
με την σειρά στο πρόγραμμά σας, γιατί έχουμε διατηρούνται για τη μνήμη σας.

971
00:52:59,000 --> 00:53:02,000
Το πρόβλημα είναι όλο αυτό το διάστημα κάθε φορά που καλείτε GetString

972
00:53:02,000 --> 00:53:05,000
εμείς, οι συγγραφείς του GetString, έχουν ζητήσει το λειτουργικό σύστημα

973
00:53:05,000 --> 00:53:07,000
για να μας δώσει ένα κομμάτι της μνήμης RAM για αυτό το string.

974
00:53:07,000 --> 00:53:09,000
Δώστε μας ένα κομμάτι της μνήμης RAM για αυτήν την επόμενη σειρά.

975
00:53:09,000 --> 00:53:11,000
Δώστε μας κάποια περισσότερη μνήμη RAM για αυτήν την επόμενη σειρά.

976
00:53:11,000 --> 00:53:13,000
Τι, ο προγραμματιστής, ποτέ δεν έχουν κάνει

977
00:53:13,000 --> 00:53:15,000
μας δίνει ότι η μνήμη πίσω,

978
00:53:15,000 --> 00:53:17,000
έτσι για αυτές τις αρκετές εβδομάδες όλα τα προγράμματα που έχετε γράψει

979
00:53:17,000 --> 00:53:20,000
είχε αυτό που ονομάζεται ένα άλμα μνήμη σύμφωνα με την οποία θα συνεχίσετε να χρησιμοποιείτε

980
00:53:20,000 --> 00:53:24,000
όλο και περισσότερη μνήμη κάθε φορά που καλείτε GetString, και ότι είναι μια χαρά.

981
00:53:24,000 --> 00:53:27,000
Εμείς κάνουμε σκόπιμα ότι τις πρώτες εβδομάδες, επειδή δεν είναι τόσο ενδιαφέρουσα

982
00:53:27,000 --> 00:53:29,000
να χρειάζεται να ανησυχείτε για το πού η σειρά έρχεται από.

983
00:53:29,000 --> 00:53:34,000
Το μόνο που θέλουμε είναι η λέξη Rob να επανέλθει όταν ο χρήστης πληκτρολογεί μέσα

984
00:53:34,000 --> 00:53:38,000
>> Αλλά κινείται προς τα εμπρός πρέπει τώρα να αρχίσουν να πάρει πιο εξελιγμένα γι 'αυτό.

985
00:53:38,000 --> 00:53:42,000
Κάθε φορά που διαθέτουν μνήμη μας καλύτερο χέρι τελικά πίσω.

986
00:53:42,000 --> 00:53:45,000
Διαφορετικά, στον πραγματικό κόσμο στο Mac ή το PC σας μπορεί να έχετε περιστασιακά έμπειρους

987
00:53:45,000 --> 00:53:50,000
συμπτώματα όταν ο υπολογιστής σας είναι τελμάτωση τελικά

988
00:53:50,000 --> 00:53:54,000
ή η ηλίθια κλώση μπάλα καταλαμβάνει μόλις τον υπολογιστή του

989
00:53:54,000 --> 00:53:56,000
όλη την προσοχή και δεν μπορείτε να κάνετε πράγματα.

990
00:53:56,000 --> 00:54:00,000
Που μπορεί να εξηγηθεί από οποιοδήποτε αριθμό των σφαλμάτων, αλλά μεταξύ των πιθανών σφαλμάτων

991
00:54:00,000 --> 00:54:03,000
Τα πράγματα που ονομάζεται διαρροές μνήμης σύμφωνα με την οποία κάποιος ο οποίος έγραψε εκείνο το κομμάτι του λογισμικού

992
00:54:03,000 --> 00:54:07,000
που χρησιμοποιείτε δεν θυμάται την ελεύθερη μνήμη

993
00:54:07,000 --> 00:54:10,000
ότι αυτός ή αυτή ζήτησε από το λειτουργικό σύστημα για,

994
00:54:10,000 --> 00:54:14,000
δεν χρησιμοποιούν GetString, γιατί αυτό είναι ένα πράγμα CS50, αλλά χρησιμοποιώντας παρόμοιες λειτουργίες

995
00:54:14,000 --> 00:54:16,000
που ζητούν το λειτουργικό σύστημα για τη μνήμη.

996
00:54:16,000 --> 00:54:19,000
Αν εσείς ή να βίδα μέχρι και να μην επιστρέψει ποτέ στην πραγματικότητα ότι η μνήμη

997
00:54:19,000 --> 00:54:24,000
ένα σύμπτωμα που μπορεί να είναι ότι ένα πρόγραμμα επιβραδύνει και επιβραδύνει και επιβραδύνει

998
00:54:24,000 --> 00:54:26,000
εκτός αν θυμηθείτε να καλέσετε δωρεάν.

999
00:54:26,000 --> 00:54:28,000
>> Θα επανέλθουμε στο πότε και γιατί θα καλέσετε δωρεάν,

1000
00:54:28,000 --> 00:54:32,000
αλλά ας προχωρήσουμε μόνο για το καλό μέτρο και προσπαθήστε να εκτελέσετε το συγκεκριμένο πρόγραμμα.

1001
00:54:32,000 --> 00:54:35,000
Αυτό ονομάζεται structs1, εισάγετε.

1002
00:54:35,000 --> 00:54:40,000
Επιτρέψτε μου να πάμε μπροστά και να τρέξει structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, και βλέπουμε το Δαβίδ σε Mather, του Tommy σε Mather.

1005
00:54:50,000 --> 00:54:53,000
Αυτό είναι μόνο ένα μικρό έλεγχο λογική ότι το πρόγραμμα λειτουργεί.

1006
00:54:53,000 --> 00:54:56,000
Τώρα, δυστυχώς, αυτό το πρόγραμμα είναι λίγο απογοητευτικό το γεγονός ότι

1007
00:54:56,000 --> 00:55:00,000
Έκανα όλη αυτή η εργασία, θα πληκτρολογήσει σε 9 διαφορετικές σειρές, πατήστε enter,

1008
00:55:00,000 --> 00:55:04,000
είπαν οι οποίοι ήταν σε Mather, αλλά προφανώς ήξερα ποιος ήταν ήδη σε Mather γιατί το πληκτρολογήσατε.

1009
00:55:04,000 --> 00:55:07,000
Θα ήταν τουλάχιστον ωραίο αν αυτό το πρόγραμμα είναι περισσότερο σαν μια βάση δεδομένων

1010
00:55:07,000 --> 00:55:10,000
και να θυμάται ό, τι πραγματικά έχω πληκτρολογήσει στο

1011
00:55:10,000 --> 00:55:12,000
έτσι ποτέ δεν έχω και πάλι πρέπει να εισάγετε τα αρχεία των φοιτητών.

1012
00:55:12,000 --> 00:55:15,000
Ίσως είναι σαν ένα registrarial σύστημα.

1013
00:55:15,000 --> 00:55:21,000
>> Μπορούμε να το κάνουμε αυτό χρησιμοποιώντας την τεχνική αυτή είναι γνωστή ως αρχείο I / O, το αρχείο εισόδου και εξόδου,

1014
00:55:21,000 --> 00:55:24,000
ένα πολύ γενικό τρόπο του λέγοντας κάθε φορά που θέλετε να διαβάσετε τα αρχεία ή εγγραφή αρχείων

1015
00:55:24,000 --> 00:55:26,000
μπορείτε να το κάνετε αυτό με ένα συγκεκριμένο σύνολο λειτουργιών.

1016
00:55:26,000 --> 00:55:29,000
Επιτρέψτε μου να πάμε μπροστά και να ανοίξετε αυτό το structs2.c παράδειγμα,

1017
00:55:29,000 --> 00:55:33,000
η οποία είναι σχεδόν όμοια, αλλά ας δούμε τι κάνει τώρα.

1018
00:55:33,000 --> 00:55:36,000
Στην κορυφή του αρχείου δηλώνω μια τάξη μαθητών.

1019
00:55:36,000 --> 00:55:38,000
I συμπληρώσετε στη συνέχεια την τάξη με την είσοδο του χρήστη,

1020
00:55:38,000 --> 00:55:41,000
έτσι ώστε αυτές οι γραμμές κώδικα ακριβώς όπως πριν.

1021
00:55:41,000 --> 00:55:45,000
Στη συνέχεια, αν μετακινηθείτε προς τα κάτω εδώ μπορώ να εκτυπώσω όλοι όσοι είναι σε Mather αυθαίρετα όπως πριν,

1022
00:55:45,000 --> 00:55:47,000
αλλά αυτό είναι ένα ενδιαφέρον νέο χαρακτηριστικό.

1023
00:55:47,000 --> 00:55:51,000
Αυτές οι γραμμές του κώδικα είναι νέα, και εισάγουν κάτι εδώ,

1024
00:55:51,000 --> 00:55:55,000
ΑΡΧΕΙΟ, όλα τα καλύμματα, και έχει * το ως εδώ καλά.

1025
00:55:55,000 --> 00:55:58,000
Επιτρέψτε μου να περάσω αυτό εδώ, μια * εδώ επίσης.

1026
00:55:58,000 --> 00:56:00,000
>> Αυτή η λειτουργία δεν έχουμε ξαναδεί, fopen,

1027
00:56:00,000 --> 00:56:03,000
αλλά αυτό σημαίνει ότι το αρχείο ανοιχτό, οπότε ας ξαφρίσει μέσω αυτών,

1028
00:56:03,000 --> 00:56:05,000
και αυτό είναι κάτι που θα έρθει πίσω στο μέλλον psets,

1029
00:56:05,000 --> 00:56:10,000
αλλά αυτή η γραμμή εδώ ανοίγει ουσιαστικά ένα αρχείο με το όνομα της βάσης δεδομένων,

1030
00:56:10,000 --> 00:56:13,000
και ανοίγει ειδικά, σε τέτοιο τρόπο ώστε να μπορεί να κάνει ό, τι σε αυτό;

1031
00:56:13,000 --> 00:56:15,000
[Δεν ακούγεται-φοιτητής]

1032
00:56:15,000 --> 00:56:19,000
Σωστά, έτσι "w" μόνο σημαίνει ότι είναι λέει το λειτουργικό σύστημα

1033
00:56:19,000 --> 00:56:21,000
ανοίξετε το αρχείο με τέτοιο τρόπο ώστε να μπορώ να γράψω για αυτό.

1034
00:56:21,000 --> 00:56:23,000
Δεν θέλω να το διαβάσετε. Δεν θέλω απλά να το δει κανείς.

1035
00:56:23,000 --> 00:56:26,000
Θέλω να το αλλάξετε και να προσθέσετε τα πράγματα ενδεχομένως να είναι,

1036
00:56:26,000 --> 00:56:28,000
και το αρχείο θα πρέπει να ονομάζεται βάση δεδομένων.

1037
00:56:28,000 --> 00:56:30,000
Αυτό θα μπορούσε να ονομαστεί τίποτα.

1038
00:56:30,000 --> 00:56:32,000
Αυτό θα μπορούσε να είναι database.txt. Αυτό θα μπορούσε να είναι. Db.

1039
00:56:32,000 --> 00:56:37,000
Αυτό θα μπορούσε να είναι μια λέξη όπως foo, αλλά αυθαίρετα επέλεξε να ονομάσει το αρχείο βάσης δεδομένων.

1040
00:56:37,000 --> 00:56:42,000
Αυτό είναι ένα μικρό έλεγχο λογική ότι θα έρθει πίσω σε με μεγάλη λεπτομέρεια την πάροδο του χρόνου,

1041
00:56:42,000 --> 00:56:47,000
αν fp, για το δείκτη αρχείο, δεν ισούται NULL αυτό σημαίνει ότι όλα είναι καλά.

1042
00:56:47,000 --> 00:56:51,000
>> Μεγάλη ιστορία σύντομη, λειτουργίες όπως η fopen μερικές φορές αποτυγχάνουν.

1043
00:56:51,000 --> 00:56:53,000
Ίσως το αρχείο δεν υπάρχει. Ίσως είστε έξω από χώρο στο σκληρό δίσκο.

1044
00:56:53,000 --> 00:56:55,000
Ίσως δεν έχετε άδεια σε αυτόν το φάκελο,

1045
00:56:55,000 --> 00:56:58,000
οπότε αν fopen επιστρέφει null κάτι κακό συνέβη.

1046
00:56:58,000 --> 00:57:02,000
Αντίθετα, αν δεν fopen επιστρέφει null όλα είναι καλά

1047
00:57:02,000 --> 00:57:04,000
και μπορώ να αρχίσετε να γράφετε σε αυτό το αρχείο.

1048
00:57:04,000 --> 00:57:06,000
Εδώ είναι ένα νέο τέχνασμα.

1049
00:57:06,000 --> 00:57:08,000
Αυτό είναι ένα βρόχο for που είναι πάνω από κάθε επανάληψη των μαθητών μου,

1050
00:57:08,000 --> 00:57:10,000
και αυτό φαίνεται τόσο παρόμοιο με ό, τι έχουμε κάνει στο παρελθόν,

1051
00:57:10,000 --> 00:57:15,000
αλλά αυτή η λειτουργία είναι ξάδελφος της printf ονομάζεται fprintf για αυτό το αρχείο printf,

1052
00:57:15,000 --> 00:57:18,000
και παρατηρήσετε ότι είναι διαφορετικό σε μόνο 2 τρόπους.

1053
00:57:18,000 --> 00:57:20,000
Ένα, ξεκινά με f αντί του p,

1054
00:57:20,000 --> 00:57:23,000
αλλά στη συνέχεια, το πρώτο επιχείρημα του είναι προφανώς τι;

1055
00:57:23,000 --> 00:57:25,000
[Φοιτητές] αρχείου. >> Είναι ένα αρχείο.

1056
00:57:25,000 --> 00:57:30,000
Αυτό το πράγμα που ονομάζεται fp, η οποία τελικά θα δώσουμε έμφαση, εκτός ό, τι ένας δείκτης αρχείου,

1057
00:57:30,000 --> 00:57:35,000
αλλά για τώρα fp αντιπροσωπεύει απλά το αρχείο που έχω ανοίξει,

1058
00:57:35,000 --> 00:57:41,000
έτσι fprintf εδώ λέει εκτύπωση ταυτότητα του χρήστη στο αρχείο, όχι στην οθόνη.

1059
00:57:41,000 --> 00:57:44,000
Εκτυπώστε το όνομα του χρήστη στο αρχείο, όχι στην οθόνη,

1060
00:57:44,000 --> 00:57:47,000
το σπίτι στο αρχείο, όχι στην οθόνη, και στη συνέχεια, εδώ κάτω, προφανώς,

1061
00:57:47,000 --> 00:57:50,000
κλείστε το αρχείο και, στη συνέχεια κάτω εδώ δωρεάν η μνήμη.

1062
00:57:50,000 --> 00:57:53,000
>> Η μόνη διαφορά μεταξύ αυτής της έκδοσης 2 και έκδοση 1

1063
00:57:53,000 --> 00:57:58,000
είναι η εισαγωγή της fopen και αυτό το αρχείο με *

1064
00:57:58,000 --> 00:58:01,000
και αυτή η έννοια της fprintf, οπότε ας δούμε τι είναι το τελικό αποτέλεσμα.

1065
00:58:01,000 --> 00:58:03,000
Επιτρέψτε μου να πάω σε παράθυρο τερματικού μου.

1066
00:58:03,000 --> 00:58:06,000
Επιτρέψτε μου να τρέξει structs2, εισάγετε.

1067
00:58:06,000 --> 00:58:09,000
Μοιάζει όλα είναι καλά. Ας επανάληψη structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, εισάγετε.

1070
00:58:19,000 --> 00:58:23,000
Μοιάζει σαν να συμπεριφερθεί το ίδιο, αλλά αν το κάνω τώρα ls

1071
00:58:23,000 --> 00:58:28,000
παρατηρήσετε τι αρχείο είναι εδώ μεταξύ όλων κωδικό μου, βάση δεδομένων,

1072
00:58:28,000 --> 00:58:32,000
οπότε ας ανοίξουν ότι, gedit της βάσης δεδομένων, και το βλέμμα σε αυτό.

1073
00:58:32,000 --> 00:58:34,000
Δεν είναι η πιο σέξι μορφές αρχείων.

1074
00:58:34,000 --> 00:58:38,000
Είναι πραγματικά ένα κομμάτι της γραμμής δεδομένων ανά γραμμή ανά γραμμή,

1075
00:58:38,000 --> 00:58:42,000
αλλά όσοι από εσάς χρησιμοποιείτε το Excel ή αρχεία CSV, τιμές διαχωρισμένες με κόμμα,

1076
00:58:42,000 --> 00:58:47,000
Θα μπορούσα βεβαίως να χρησιμοποιηθεί αντί για fprintf ίσως κάνουμε κάτι σαν αυτό

1077
00:58:47,000 --> 00:58:50,000
έτσι ώστε θα μπορούσε να δημιουργήσει πραγματικά το ισοδύναμο ενός αρχείου Excel

1078
00:58:50,000 --> 00:58:53,000
διαχωρίζοντας τα πράγματα με κόμματα, όχι μόνο νέες γραμμές.

1079
00:58:53,000 --> 00:58:56,000
>> Σε αυτή την περίπτωση, αν είχα χρησιμοποιήσει αντί κόμματα αντί των νέων γραμμών

1080
00:58:56,000 --> 00:59:01,000
Θα μπορούσα να ανοίξει κυριολεκτικά αυτό το αρχείο βάσης δεδομένων στο Excel αν αντί έκανε να μοιάζει με αυτό.

1081
00:59:01,000 --> 00:59:03,000
Με λίγα λόγια, τώρα που έχουμε τη δύναμη να γράψει σε αρχεία

1082
00:59:03,000 --> 00:59:07,000
μπορούμε να αρχίσουμε τώρα δεδομένα εξακολουθούν να υφίστανται, κρατώντας το δίσκο γύρω από την

1083
00:59:07,000 --> 00:59:10,000
έτσι ώστε να μπορεί να κρατήσει τις πληροφορίες γύρω ξανά και ξανά.

1084
00:59:10,000 --> 00:59:14,000
Προσέξτε μερικά άλλα πράγματα που είναι τώρα λίγο πιο εξοικειωμένοι.

1085
00:59:14,000 --> 00:59:16,000
Στην κορυφή αυτού του αρχείου C έχουμε μια typedef

1086
00:59:16,000 --> 00:59:21,000
γιατί θέλαμε να δημιουργήσουμε έναν τύπο δεδομένων που αντιπροσωπεύει μια λέξη,

1087
00:59:21,000 --> 00:59:25,000
έτσι ώστε αυτός ο τύπος ονομάζεται λέξη, και στο εσωτερικό της δομής αυτής

1088
00:59:25,000 --> 00:59:27,000
είναι λίγο πιό φανταχτερό τώρα.

1089
00:59:27,000 --> 00:59:30,000
Γιατί είναι μια λέξη που αποτελείται από μια σειρά φαινομενικά;

1090
00:59:30,000 --> 00:59:33,000
Τι είναι μια λέξη μόνο διαισθητικά;

1091
00:59:33,000 --> 00:59:35,000
>> Είναι μια σειρά από χαρακτήρες.

1092
00:59:35,000 --> 00:59:37,000
Είναι μια σειρά από χαρακτήρες πλάτη με πλάτη με πλάτη.

1093
00:59:37,000 --> 00:59:41,000
ΕΠΙΣΤΟΛΕΣ σε όλα τα καλύμματα συμβαίνει να είναι αυθαίρετα λένε ότι το μέγιστο μήκος

1094
00:59:41,000 --> 00:59:44,000
από κάθε λέξη στο λεξικό που χρησιμοποιείτε για Scramble.

1095
00:59:44,000 --> 00:59:46,000
Γιατί έχω μια +1;

1096
00:59:46,000 --> 00:59:48,000
Ο χαρακτήρας null.

1097
00:59:48,000 --> 00:59:51,000
Θυμηθείτε όταν κάναμε το παράδειγμα Bananagrams χρειαζόμασταν μια ειδική τιμή

1098
00:59:51,000 --> 00:59:55,000
στο τέλος της λέξης, προκειμένου να παρακολουθεί

1099
00:59:55,000 --> 00:59:59,000
από όπου οι λέξεις πραγματικά τελείωσε, καθώς και τις προδιαγραφές του προβλήματος, λέει ο

1100
00:59:59,000 --> 01:00:03,000
εδώ είμαστε συνδέει με μια συγκεκριμένη λέξη μια boolean τιμή,

1101
01:00:03,000 --> 01:00:05,000
μια σημαία, να το πω έτσι, αληθής ή ψευδής.

1102
01:00:05,000 --> 01:00:09,000
Έχετε βρει και εσείς αυτή τη λέξη ήδη, επειδή συνειδητοποιούμε

1103
01:00:09,000 --> 01:00:13,000
χρειαζόμαστε πραγματικά έναν τρόπο να θυμόμαστε όχι μόνο ό, τι είναι μια λέξη στο Scramble

1104
01:00:13,000 --> 01:00:15,000
αλλά αν έχετε ή όχι, ο άνθρωπος, έχουν βρεθεί

1105
01:00:15,000 --> 01:00:20,000
έτσι ώστε αν το κάνετε βρείτε τη λέξη "το" δεν μπορείτε να πληκτρολογήσετε μόνο το, εισάγετε, το, πληκτρολογήστε το, πληκτρολογήστε

1106
01:00:20,000 --> 01:00:23,000
και να πάρει 3 πόντους, 3 βαθμούς, 3 βαθμούς, 3 βαθμούς.

1107
01:00:23,000 --> 01:00:26,000
Θέλουμε να είμαστε σε θέση να αποκλείσετε αυτή τη λέξη με τον καθορισμό ενός bool

1108
01:00:26,000 --> 01:00:29,000
να ισχύει εάν έχετε βρεί ήδη, και έτσι γι 'αυτό

1109
01:00:29,000 --> 01:00:31,000
ενθυλακωμένο το σε αυτή τη δομή.

1110
01:00:31,000 --> 01:00:35,000
>> Τώρα, εδώ κάτω στην Scramble υπάρχει αυτή η άλλη struct που ονομάζεται λεξικό.

1111
01:00:35,000 --> 01:00:39,000
Απουσιάζει εδώ είναι η λέξη typedef, διότι σε αυτή την περίπτωση

1112
01:00:39,000 --> 01:00:43,000
έπρεπε να ενσωματώσει την ιδέα ενός λεξικού,

1113
01:00:43,000 --> 01:00:46,000
και ένα λεξικό περιέχει ένα σωρό λέξεις,

1114
01:00:46,000 --> 01:00:49,000
όπως υπονοείται από την παρούσα διάταξη, και πόσες από αυτές τις λέξεις είναι εκεί;

1115
01:00:49,000 --> 01:00:51,000
Λοιπόν, ό, τι αυτή η μεταβλητή ονομάζεται μέγεθος λέει.

1116
01:00:51,000 --> 01:00:53,000
Αλλά χρειαζόμαστε μόνο ένα λεξικό.

1117
01:00:53,000 --> 01:00:55,000
Δεν χρειαζόμαστε έναν τύπο δεδομένων που ονομάζεται λεξικό.

1118
01:00:55,000 --> 01:00:58,000
Πρέπει μόνο ένα από αυτά, έτσι ώστε να βγάζει σε C

1119
01:00:58,000 --> 01:01:03,000
ότι αν δεν πούμε typedef, λέτε ακριβώς struct, στη συνέχεια, μέσα στα άγκιστρα

1120
01:01:03,000 --> 01:01:05,000
βάζετε μεταβλητές σας, τότε βάζετε το όνομα.

1121
01:01:05,000 --> 01:01:09,000
Αυτό δηλώνει μια μεταβλητή που ονομάζεται λεξικό

1122
01:01:09,000 --> 01:01:11,000
που μοιάζει με αυτό.

1123
01:01:11,000 --> 01:01:16,000
Αντίθετα, οι γραμμές αυτές δημιουργούν ένα επαναχρησιμοποιήσιμο δομή δεδομένων που ονομάζεται λέξη

1124
01:01:16,000 --> 01:01:19,000
ότι μπορείτε να δημιουργήσετε πολλαπλά αντίγραφα του, όπως ακριβώς δημιουργήσαμε

1125
01:01:19,000 --> 01:01:22,000
πολλαπλά αντίγραφα των φοιτητών.

1126
01:01:22,000 --> 01:01:24,000
>> Τι σημαίνει αυτό τελικά θα μας επιτρέψει να κάνουμε;

1127
01:01:24,000 --> 01:01:30,000
Επιτρέψτε μου να πάω πίσω στο, ας πούμε, ένα απλό παράδειγμα από απλούστερες εποχές,

1128
01:01:30,000 --> 01:01:34,000
και επιτρέψτε μου να ανοίξει, ας πούμε, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Το πρόβλημα εδώ είναι στο χέρι πραγματικά φλούδα πίσω

1130
01:01:38,000 --> 01:01:41,000
το στρώμα της σειράς και αρχίσετε να παίρνετε από αυτές τις ρόδες

1131
01:01:41,000 --> 01:01:44,000
γιατί αποδεικνύεται ότι μια σειρά όλο αυτό το διάστημα

1132
01:01:44,000 --> 01:01:47,000
είναι όπως υποσχεθήκαμε στο εβδομάδα 1 πραγματικά ακριβώς ένα ψευδώνυμο,

1133
01:01:47,000 --> 01:01:51,000
συνώνυμο από τη βιβλιοθήκη CS50 για κάτι που μοιάζει λίγο πιο αινιγματικά,

1134
01:01:51,000 --> 01:01:53,000
char *, και έχουμε δει αυτό το αστέρι πριν.

1135
01:01:53,000 --> 01:01:55,000
Το είδαμε στο πλαίσιο των αρχείων.

1136
01:01:55,000 --> 01:01:59,000
>> Ας δούμε τώρα γιατί έχουμε κρύβει την πληροφορία αυτή για αρκετό καιρό τώρα.

1137
01:01:59,000 --> 01:02:02,000
Εδώ είναι ένα αρχείο που ονομάζεται compare1.c,

1138
01:02:02,000 --> 01:02:07,000
και ζητά προφανώς το χρήστη για 2 χορδές, s και t,

1139
01:02:07,000 --> 01:02:11,000
και στη συνέχεια να προσπαθεί να συγκρίνει αυτές τις χορδές για την ισότητα στη γραμμή 26,

1140
01:02:11,000 --> 01:02:14,000
και αν είναι ίση λέει, "Πληκτρολογήσατε το ίδιο πράγμα,"

1141
01:02:14,000 --> 01:02:17,000
και αν δεν είναι ίσες λέει, "Πληκτρολογήσατε διαφορετικά πράγματα."

1142
01:02:17,000 --> 01:02:19,000
Επιτρέψτε μου να πάμε μπροστά και να τρέξει αυτό το πρόγραμμα.

1143
01:02:19,000 --> 01:02:23,000
Επιτρέψτε μου να μπω σε κατάλογο πηγή μου, κάνει μια compare1. Θα καταρτίζονται εντάξει.

1144
01:02:23,000 --> 01:02:25,000
Επιτρέψτε μου να τρέξει compare1.

1145
01:02:25,000 --> 01:02:27,000
Θα μεγέθυνση, εισάγετε.

1146
01:02:27,000 --> 01:02:29,000
Πείτε κάτι. ΓΕΙΑ ΣΟΥ.

1147
01:02:29,000 --> 01:02:32,000
Θα πω κάτι και πάλι. ΓΕΙΑ ΣΟΥ.

1148
01:02:32,000 --> 01:02:34,000
Εγώ σίγουρα δεν πληκτρολογήσετε διαφορετικά πράγματα.

1149
01:02:34,000 --> 01:02:37,000
>> Επιτρέψτε μου να προσπαθήσω ξανά αυτό το μήνυμα. Bye Bye.

1150
01:02:37,000 --> 01:02:40,000
Σίγουρα δεν είναι διαφορετική, έτσι ώστε ό, τι συμβαίνει εδώ;

1151
01:02:40,000 --> 01:02:44,000
Λοιπόν, αυτό που πραγματικά σε σύγκριση με τη γραμμή 26;

1152
01:02:44,000 --> 01:02:46,000
[Δεν ακούγεται-φοιτητής]

1153
01:02:46,000 --> 01:02:49,000
Ναι, έτσι ώστε να αποδεικνύεται ότι ένα string, τον τύπο δεδομένων, είναι το είδος του ένα λευκό ψέμα.

1154
01:02:49,000 --> 01:02:53,000
Μια συμβολοσειρά είναι μια char *, αλλά αυτό είναι ένα char *;

1155
01:02:53,000 --> 01:02:56,000
Μια char *, όπως λένε, είναι ένας δείκτης,

1156
01:02:56,000 --> 01:03:00,000
και ένας δείκτης είναι ουσιαστικά μια διεύθυνση,

1157
01:03:00,000 --> 01:03:05,000
μια θέση στη μνήμη άθροισμα, και αν τύχει να έχετε πληκτρολογήσει σε μια λέξη όπως το HELLO,

1158
01:03:05,000 --> 01:03:08,000
θυμάμαι από το παρελθόν συζητήσεις του χορδές

1159
01:03:08,000 --> 01:03:16,000
αυτό είναι σαν τη λέξη HELLO.

1160
01:03:16,000 --> 01:03:19,000
Να θυμάστε ότι μια λέξη όπως ΓΕΙΑ μπορεί να αναπαρασταθεί

1161
01:03:19,000 --> 01:03:22,000
ως μια σειρά από χαρακτήρες, όπως αυτό

1162
01:03:22,000 --> 01:03:25,000
και στη συνέχεια με ένα ειδικό χαρακτήρα στο τέλος ονομάζεται μηδενική χαρακτήρα,

1163
01:03:25,000 --> 01:03:27,000
όπως το \ σημαίνει.

1164
01:03:27,000 --> 01:03:29,000
Τι είναι στην πραγματικότητα μια σειρά;

1165
01:03:29,000 --> 01:03:32,000
Σημειώστε ότι αυτό είναι πολλαπλά κομμάτια της μνήμης,

1166
01:03:32,000 --> 01:03:36,000
και στην πραγματικότητα, το τέλος της είναι γνωστό μόνο όταν κοιτάζετε μέσα από το σύνολο εγχόρδων

1167
01:03:36,000 --> 01:03:38,000
ψάχνει για το ιδιαίτερο χαρακτήρα null.

1168
01:03:38,000 --> 01:03:41,000
Αλλά αν αυτό είναι ένα κομμάτι της μνήμης από τη μνήμη του υπολογιστή μου,

1169
01:03:41,000 --> 01:03:44,000
ας αυθαίρετα λένε ότι αυτή η συμβολοσειρά μόλις πήρε τυχερός,

1170
01:03:44,000 --> 01:03:47,000
και πήρε θέση στην αρχή της μνήμης RAM του υπολογιστή μου.

1171
01:03:47,000 --> 01:03:54,000
Αυτό είναι byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Όταν λέω κάτι σαν GetString και να κάνω string s = GetString

1173
01:04:02,000 --> 01:04:04,000
τι πραγματικά να επιστρέψει;

1174
01:04:04,000 --> 01:04:08,000
Για αυτές τις τελευταίες εβδομάδες, αυτό που πραγματικά που αποθηκεύονται σε s

1175
01:04:08,000 --> 01:04:13,000
δεν είναι αυτή η σειρά per se, αλλά σε αυτή την περίπτωση τι είναι να αποθηκεύονται

1176
01:04:13,000 --> 01:04:18,000
το ψηφίο 0, επειδή ό, τι κάνει στην πραγματικότητα GetString

1177
01:04:18,000 --> 01:04:20,000
είναι ότι δεν επιστρέφει φυσικά ένα string.

1178
01:04:20,000 --> 01:04:22,000
Αυτό δεν έχει ακόμη κάνει πραγματικά εννοιολογική έννοια του όρου.

1179
01:04:22,000 --> 01:04:24,000
Αυτό που κάνει την επιστροφή είναι ένας αριθμός.

1180
01:04:24,000 --> 01:04:28,000
Ο αριθμός αυτός είναι η διεύθυνση του ΓΕΙΑ στη μνήμη,

1181
01:04:28,000 --> 01:04:32,000
string s και στη συνέχεια, αν φλούδα πίσω αυτό το στρώμα, string δεν υπάρχει στην πραγματικότητα.

1182
01:04:32,000 --> 01:04:35,000
Είναι μόνο μια απλοποίηση στη βιβλιοθήκη CS50.

1183
01:04:35,000 --> 01:04:38,000
>> Αυτό είναι πραγματικά κάτι που ονομάζεται char *.

1184
01:04:38,000 --> 01:04:41,000
Char έχει νόημα γιατί αυτό είναι μια λέξη, όπως ΓΕΙΑ ΣΟΥ;

1185
01:04:41,000 --> 01:04:44,000
Λοιπόν, είναι μια σειρά από χαρακτήρες, μια σειρά από χαρακτήρες.

1186
01:04:44,000 --> 01:04:47,000
Char * σημαίνει τη διεύθυνση ενός χαρακτήρα,

1187
01:04:47,000 --> 01:04:50,000
έτσι τι σημαίνει να επιστρέψει ένα string;

1188
01:04:50,000 --> 01:04:53,000
Ένα όμορφο, απλό τρόπο να επιστρέψει ένα string

1189
01:04:53,000 --> 01:04:57,000
είναι αντί να προσπαθήσουμε να καταλάβουμε πώς θα επιστρέψει σε 5 ή 6 διαφορετικά bytes

1190
01:04:57,000 --> 01:05:01,000
επιτρέψτε μου να επανέλθω στη διεύθυνση των οποίων byte;

1191
01:05:01,000 --> 01:05:03,000
Το πρώτο.

1192
01:05:03,000 --> 01:05:06,000
Με άλλα λόγια, επιτρέψτε μου να σας δώσω τη διεύθυνση ενός χαρακτήρα στη μνήμη.

1193
01:05:06,000 --> 01:05:10,000
Αυτό είναι ό, τι char * αντιπροσωπεύει, η διεύθυνση ενός ενιαίου χαρακτήρα στη μνήμη.

1194
01:05:10,000 --> 01:05:12,000
Καλέστε ότι η μεταβλητή s.

1195
01:05:12,000 --> 01:05:15,000
Κατάστημα σε s ότι η συγκεκριμένη διεύθυνση, την οποία αυθαίρετα είπε είναι 0,

1196
01:05:15,000 --> 01:05:19,000
μόνο για να κρατήσει τα πράγματα απλά, αλλά στην πραγματικότητα είναι γενικά ένα μεγαλύτερο αριθμό.

1197
01:05:19,000 --> 01:05:21,000
>> Περιμένετε ένα λεπτό.

1198
01:05:21,000 --> 01:05:23,000
Αν είστε μόνο που μου δίνετε τη διεύθυνση του πρώτου χαρακτήρα, πώς μπορώ να ξέρω ποια είναι η διεύθυνση είναι

1199
01:05:23,000 --> 01:05:25,000
του δεύτερου χαρακτήρα, η τρίτη, η τέταρτη και η πέμπτη;

1200
01:05:25,000 --> 01:05:27,000
[Δεν ακούγεται-φοιτητής]

1201
01:05:27,000 --> 01:05:31,000
Το μόνο που ξέρουν πού το τέλος του string είναι με τον τρόπο του αυτό το πρακτικό τέχνασμα,

1202
01:05:31,000 --> 01:05:35,000
έτσι όταν χρησιμοποιείτε κάτι σαν printf, τι printf παίρνει κυριολεκτικά ως επιχείρημα,

1203
01:05:35,000 --> 01:05:39,000
Υπενθυμίζω ότι χρησιμοποιούμε κράτησης θέσης αυτής% s, και στη συνέχεια να περάσει στο

1204
01:05:39,000 --> 01:05:41,000
η μεταβλητή που είναι μια σειρά αποθήκευση.

1205
01:05:41,000 --> 01:05:47,000
Τι είστε πραγματικά περνώντας είναι η διεύθυνση του πρώτου χαρακτήρα της στοιχειοσειράς.

1206
01:05:47,000 --> 01:05:50,000
Printf χρησιμοποιεί στη συνέχεια ένα βρόχο for ή ένα βρόχο, ενώ κατά την παραλαβή του διεύθυνση,

1207
01:05:50,000 --> 01:05:53,000
για παράδειγμα, 0, οπότε επιτρέψτε μου να κάνω αυτό τώρα,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s)?

1209
01:06:02,000 --> 01:06:07,000
Όταν καλώ printf ("% s \ n", s)? Τι είμαι πραγματικά με την παροχή printf

1210
01:06:07,000 --> 01:06:13,000
είναι η διεύθυνση του πρώτου χαρακτήρα σε s, το οποίο σε αυτή την περίπτωση είναι αυθαίρετη Η.

1211
01:06:13,000 --> 01:06:16,000
>> Πώς printf ξέρω τι ακριβώς να εμφανιστεί στην οθόνη;

1212
01:06:16,000 --> 01:06:19,000
Το πρόσωπο που εφαρμόζονται εφαρμογή printf ένα βρόχο while ή ένα βρόχο για

1213
01:06:19,000 --> 01:06:23,000
που λέει ότι αυτός ο χαρακτήρας ισούται με τον ειδικό χαρακτήρα null;

1214
01:06:23,000 --> 01:06:25,000
Αν όχι, να το εκτυπώσετε. Τι λέτε για αυτό;

1215
01:06:25,000 --> 01:06:28,000
Αν δεν το τυπώσετε, να το εκτυπώσετε, να το τυπώσετε, να το τυπώσετε.

1216
01:06:28,000 --> 01:06:32,000
Ω, αυτό είναι ιδιαίτερο. Σταματήστε την εκτύπωση και επιστρέφει στο χρήστη.

1217
01:06:32,000 --> 01:06:35,000
Και αυτό είναι κυριολεκτικά όλα αυτά που συμβαίνουν κάτω από την κουκούλα,

1218
01:06:35,000 --> 01:06:38,000
και αυτό είναι ένα πολύ να χωνέψει την πρώτη ημέρα μιας τάξης,

1219
01:06:38,000 --> 01:06:43,000
αλλά για τώρα είναι πραγματικά το δομικό στοιχείο των πάντων κατανόηση

1220
01:06:43,000 --> 01:06:46,000
που είναι ήδη σε εξέλιξη στο εσωτερικό της μνήμης του υπολογιστή μας,

1221
01:06:46,000 --> 01:06:49,000
και τελικά θα πειράζω αυτό πέρα ​​με λίγη βοήθεια

1222
01:06:49,000 --> 01:06:51,000
από έναν από τους φίλους μας στο Πανεπιστήμιο του Στάνφορντ.

1223
01:06:51,000 --> 01:06:56,000
>> Ο καθηγητής Νικ Parlante στο Πανεπιστήμιο του Στάνφορντ έχει κάνει αυτή την υπέροχη σειρά βίντεο

1224
01:06:56,000 --> 01:06:58,000
από όλα τα είδη των διαφορετικών γλωσσών που εισήγαγε

1225
01:06:58,000 --> 01:07:00,000
αυτό το μικρό Binky Claymation χαρακτήρα.

1226
01:07:00,000 --> 01:07:03,000
Η φωνή που είστε έτοιμος να ακούσει μέσα σε λίγα δευτερόλεπτα προεπισκόπηση ματιά

1227
01:07:03,000 --> 01:07:05,000
είναι ότι από ένα καθηγητής του Στάνφορντ, και παίρνετε

1228
01:07:05,000 --> 01:07:07,000
μόνο 5 ή 6 δευτερόλεπτα το δικαίωμα αυτό τώρα,

1229
01:07:07,000 --> 01:07:09,000
αλλά αυτό είναι το σημείωμα στο οποίο θα ολοκληρώσει σήμερα

1230
01:07:09,000 --> 01:07:11,000
και να αρχίσει την Τετάρτη.

1231
01:07:11,000 --> 01:07:15,000
Σας δίνω Fun Pointer με Binky, η προεπισκόπηση.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Μουσική] [Καθηγητής Parlante] Γεια σου, Binky.

1233
01:07:18,000 --> 01:07:21,000
Ξυπνήστε. Ήρθε η ώρα για διασκέδαση δείκτη.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Τι είναι αυτό; Μάθετε σχετικά με δείκτες;

1235
01:07:24,000 --> 01:07:26,000
Ω, γλύκισμα!

1236
01:07:26,000 --> 01:07:29,000
>> Θα σας δούμε την Τετάρτη.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]