1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Κριτική] [Κουίζ 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Πανεπιστήμιο του Χάρβαρντ]

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

4
00:00:08,000 --> 00:00:10,000
>> Γεια σου, όλοι.

5
00:00:10,000 --> 00:00:15,000
Καλώς ήρθατε στη συνεδρία για επανεξέταση Quiz 0, η οποία λαμβάνει χώρα αυτή την Τετάρτη.

6
00:00:15,000 --> 00:00:19,000
Τι θα πάμε να κάνουμε απόψε, είμαι με 3 άλλα ΤΡ,

7
00:00:19,000 --> 00:00:24,000
και μαζί θα πάμε να περάσουν από μια ανασκόπηση του τι έχουμε κάνει στην μέχρι τώρα πορεία.

8
00:00:24,000 --> 00:00:27,000
Δεν πρόκειται να είναι 100% ολοκληρωμένη, αλλά θα πρέπει να σας δώσει μια καλύτερη ιδέα

9
00:00:27,000 --> 00:00:31,000
από ό, τι έχετε ήδη κάτω και τι θα πρέπει ακόμα να μελετήσει πριν από την Τετάρτη.

10
00:00:31,000 --> 00:00:34,000
Και μη διστάσετε να σηκώστε το χέρι σας με ερωτήσεις όπως θα πάμε μαζί,

11
00:00:34,000 --> 00:00:38,000
αλλά να έχετε κατά νου ότι θα έχουμε επίσης ένα μικρό κομμάτι του χρόνου στο τέλος-

12
00:00:38,000 --> 00:00:41,000
αν έχουμε περάσει με λίγα λεπτά για να ανταλλακτικά-να κάνουν γενικές ερωτήσεις,

13
00:00:41,000 --> 00:00:47,000
γι 'αυτό κρατήστε αυτό κατά νου, και έτσι θα πάμε να ξεκινήσουμε από την αρχή με την Εβδομάδα 0.

14
00:00:47,000 --> 00:00:50,000
>> [Κουίζ 0 Review!] [Μέρος 0] [Lexi Ross] Αλλά πριν το κάνουμε αυτό ας μιλήσουμε για

15
00:00:50,000 --> 00:00:53,000
τα logistics του κουίζ.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz λαμβάνει χώρα την Τετάρτη 10/10 αντί της διάλεξης]

17
00:00:55,000 --> 00:00:57,000
>> [(Βλέπε http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf για λεπτομέρειες)] Είναι στις Τετάρτη 10 Οκτώβρη.

18
00:00:57,000 --> 00:01:00,000
>> Αυτό είναι την Τετάρτη, και αν πάτε σε αυτή τη διεύθυνση URL εδώ,

19
00:01:00,000 --> 00:01:03,000
το οποίο είναι επίσης προσβάσιμο από CS50.net-υπάρχει μια σύνδεση με αυτό-

20
00:01:03,000 --> 00:01:06,000
μπορείτε να δείτε πληροφορίες σχετικά με το πού να πάνε με βάση

21
00:01:06,000 --> 00:01:10,000
το επώνυμό σας ή την υπαγωγή τους σχολείο, καθώς και

22
00:01:10,000 --> 00:01:14,000
λέει για το τι ακριβώς το κουίζ θα καλύπτει και τα είδη των ερωτήσεων που πρόκειται να πάρει.

23
00:01:14,000 --> 00:01:19,000
Λάβετε υπόψη σας ότι θα έχετε επίσης την ευκαιρία να αναθεωρήσετε για το κουίζ στην ενότητα,

24
00:01:19,000 --> 00:01:21,000
έτσι TFs σας θα πρέπει να πηγαίνει πέρα ​​από κάποια προβλήματα πρακτική,

25
00:01:21,000 --> 00:01:29,000
και αυτό είναι μια άλλη καλή ευκαιρία για να δούμε πού θα πρέπει ακόμα να μελετήσει για το κουίζ.

26
00:01:29,000 --> 00:01:32,000
Ας ξεκινήσουμε από την αρχή με Bytes 'n' Bits.

27
00:01:32,000 --> 00:01:35,000
Θυμηθείτε λίγο απέχει μόλις 0 ή 1,

28
00:01:35,000 --> 00:01:38,000
και ένα byte είναι μια συλλογή από 8 αυτών των bits.

29
00:01:38,000 --> 00:01:42,000
Ας ρίξουμε μια ματιά σε αυτή τη συλλογή των bits δεξιά εδώ.

30
00:01:42,000 --> 00:01:44,000
Θα πρέπει να είναι σε θέση να υπολογίσει πόσα bits υπάρχουν.

31
00:01:44,000 --> 00:01:48,000
Όταν μετράμε υπάρχει μόνο 8 από τους οκτώ 0 ή 1 μονάδες.

32
00:01:48,000 --> 00:01:51,000
Και δεδομένου ότι υπάρχει 8 bits, που είναι 1 byte,

33
00:01:51,000 --> 00:01:53,000
και ας το μετατρέψει σε δεκαεξαδικό.

34
00:01:53,000 --> 00:01:58,000
Δεκαεξαδικό βάση είναι 16, και είναι αρκετά εύκολο να μετατρέψετε

35
00:01:58,000 --> 00:02:01,000
ένας αριθμός σε δυαδική μορφή, το οποίο είναι αυτό που είναι, σε έναν αριθμό σε δεκαεξαδική.

36
00:02:01,000 --> 00:02:04,000
Το μόνο που κάνουμε είναι να κοιτάξουμε τις ομάδες των 4,

37
00:02:04,000 --> 00:02:07,000
και τη μετατροπή τους στο κατάλληλο ψηφίο δεκαεξαδικό.

38
00:02:07,000 --> 00:02:11,000
Ξεκινάμε με την πιο δεξιά-ομάδα 4, οπότε 0011.

39
00:02:11,000 --> 00:02:16,000
Αυτό πρόκειται να είναι ένα 1 και ένα 2, έτσι που κάνει μαζί 3.

40
00:02:16,000 --> 00:02:19,000
Και τότε ας δούμε την άλλη μπλοκ 4.

41
00:02:19,000 --> 00:02:24,000
1101. Αυτό πρόκειται να είναι ένα 1, ένα 4 και ένα 8.

42
00:02:24,000 --> 00:02:28,000
Μαζί που πρόκειται να είναι 13, γεγονός που καθιστά Δ.

43
00:02:28,000 --> 00:02:32,000
Και θα θυμάστε ότι σε δεκαεξαδική δεν πάμε μόνο 0 έως 9.

44
00:02:32,000 --> 00:02:36,000
Πάμε 0 έως F, έτσι ώστε μετά τις 9, 10 αντιστοιχεί στο A,

45
00:02:36,000 --> 00:02:40,000
11 έως Β, κ.λπ. όπου F είναι 15.

46
00:02:40,000 --> 00:02:44,000
Εδώ 13 είναι ένα D,

47
00:02:44,000 --> 00:02:49,000
έτσι ώστε να το μετατρέψει σε δεκαδικό το μόνο που κάνουμε είναι ότι στην πραγματικότητα

48
00:02:49,000 --> 00:02:52,000
αντιμετώπιση κάθε θέση ως δύναμη του 2.

49
00:02:52,000 --> 00:02:58,000
Αυτό είναι ένα 1, ένα 2, μηδέν 4s, μηδέν 8άρια, ένας 16, κ.λπ.,

50
00:02:58,000 --> 00:03:03,000
και είναι λίγο δύσκολο να υπολογιστεί στο κεφάλι σας, αλλά αν πάμε στην επόμενη διαφάνεια

51
00:03:03,000 --> 00:03:05,000
μπορούμε να δούμε την απάντηση σε αυτό.

52
00:03:05,000 --> 00:03:09,000
>> Ουσιαστικά θα πάμε απέναντι από δεξιά προς τα αριστερά πίσω,

53
00:03:09,000 --> 00:03:14,000
και είμαστε πολλαπλασιασμό κάθε ψηφίο με την αντίστοιχη δύναμη του 2.

54
00:03:14,000 --> 00:03:19,000
Και να θυμάστε, για δεκαεξαδικό που χαρακτηρίζει αυτούς τους αριθμούς με 0x στην αρχή

55
00:03:19,000 --> 00:03:23,000
έτσι ώστε να μην συγχέεται με ένα δεκαδικό αριθμό.

56
00:03:23,000 --> 00:03:29,000
Συνεχίζοντας, αυτό είναι ένα ASCII πίνακα,

57
00:03:29,000 --> 00:03:35,000
και αυτό που χρησιμοποιούμε για ASCII είναι να χαρτογραφηθεί από τους χαρακτήρες σε αριθμητικές τιμές.

58
00:03:35,000 --> 00:03:39,000
Θυμηθείτε το PSET κρυπτογραφία που έκαναν εκτεταμένη χρήση του πίνακα ASCII

59
00:03:39,000 --> 00:03:43,000
προκειμένου να χρησιμοποιήσει διάφορες μεθόδους κρυπτογράφησης,

60
00:03:43,000 --> 00:03:47,000
ο Καίσαρας και ο cipher Vigenere, για να μετατρέψετε διαφορετικές επιστολές

61
00:03:47,000 --> 00:03:52,000
σε μια συμβολοσειρά σύμφωνα με την κλείδα δίνονται από τον χρήστη.

62
00:03:52,000 --> 00:03:56,000
Ας δούμε λίγο από ASCII μαθηματικά.

63
00:03:56,000 --> 00:04:02,000
Κοιτάζοντας 'Ρ' + 1, σε μορφή χαρακτήρα που θα μπορούσε να είναι το Q,

64
00:04:02,000 --> 00:04:07,000
και να θυμάστε ότι το '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Και πώς ακριβώς θα γίνεται η μετατροπή μεταξύ αυτών των 2 μορφές;

66
00:04:10,000 --> 00:04:13,000
Δεν είναι πραγματικά πάρα πολύ σκληρά.

67
00:04:13,000 --> 00:04:16,000
Για να πάρετε 5 αφαιρούμε '0 '

68
00:04:16,000 --> 00:04:20,000
επειδή υπάρχουν 5 θέσεις μεταξύ του '0 'και το '5 ».

69
00:04:20,000 --> 00:04:23,000
Για να πάει ο άλλος τρόπος να προσθέσουμε μόνο το 0,

70
00:04:23,000 --> 00:04:25,000
γι 'αυτό είναι το είδος του σαν κανονικό αριθμητική.

71
00:04:25,000 --> 00:04:29,000
Απλώς να θυμάστε ότι όταν κάτι έχει εισαγωγικά γύρω από αυτό είναι ένας χαρακτήρας

72
00:04:29,000 --> 00:04:37,000
και έτσι αντιστοιχεί σε μία τιμή στον πίνακα ASCII.

73
00:04:37,000 --> 00:04:40,000
Προχωρώντας σε πιο γενικά θέματα της επιστήμης των υπολογιστών.

74
00:04:40,000 --> 00:04:43,000
Μάθαμε τι ένας αλγόριθμος είναι και πώς χρησιμοποιούμε τον προγραμματισμό

75
00:04:43,000 --> 00:04:45,000
αλγορίθμους για την εφαρμογή.

76
00:04:45,000 --> 00:04:48,000
Μερικά παραδείγματα των αλγορίθμων είναι κάτι πολύ απλό, όπως

77
00:04:48,000 --> 00:04:51,000
ελέγχει αν ένας αριθμός είναι άρτιος ή περιττός.

78
00:04:51,000 --> 00:04:54,000
Γι 'αυτό να θυμάστε ότι ο αριθμός mod με 2 και ελέγξτε αν το αποτέλεσμα είναι 0.

79
00:04:54,000 --> 00:04:57,000
Αν ναι, είναι ακόμα. Αν όχι, είναι περίεργο.

80
00:04:57,000 --> 00:04:59,000
Και αυτό είναι ένα παράδειγμα μιας πραγματικά βασικό αλγόριθμο.

81
00:04:59,000 --> 00:05:02,000
>> Ένα μικρό κομμάτι από ένα πιο ενεργά το ένα είναι δυαδική αναζήτηση,

82
00:05:02,000 --> 00:05:05,000
που θα πάμε αργότερα πάνω στη σύνοδο κριτική.

83
00:05:05,000 --> 00:05:09,000
Και ο προγραμματισμός είναι ο όρος που χρησιμοποιούμε για τη λήψη έναν αλγόριθμο

84
00:05:09,000 --> 00:05:15,000
και να το μετατρέψει για την κωδικοποίηση του υπολογιστή μπορεί να διαβάσει.

85
00:05:15,000 --> 00:05:20,000
2 παραδείγματα προγραμματισμού Scratch είναι,

86
00:05:20,000 --> 00:05:22,000
η οποία είναι ό, τι κάναμε στην Εβδομάδα 0.

87
00:05:22,000 --> 00:05:25,000
Ακόμα κι αν στην πραγματικότητα δεν πληκτρολογήστε το κωδικό είναι ένας τρόπος για την εφαρμογή της

88
00:05:25,000 --> 00:05:29,000
ο αλγόριθμος αυτός, ο οποίος εκτυπώνει τους αριθμούς 1-10,

89
00:05:29,000 --> 00:05:32,000
και εδώ κάνουμε το ίδιο στη γλώσσα προγραμματισμού C.

90
00:05:32,000 --> 00:05:41,000
Αυτά είναι λειτουργικά ισοδύναμες, απλά γραμμένα σε διαφορετικές γλώσσες ή σύνταξη.

91
00:05:41,000 --> 00:05:44,000
Στη συνέχεια έμαθα για boolean εκφράσεις,

92
00:05:44,000 --> 00:05:48,000
και μια boolean είναι μια τιμή που είναι είτε αληθείς ή ψευδείς,

93
00:05:48,000 --> 00:05:51,000
και εδώ πολλές φορές boolean εκφράσεις

94
00:05:51,000 --> 00:05:55,000
πάει μέσα από τις συνθήκες, έτσι ώστε αν (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
καλά, έχουμε ήδη x = 5, έτσι ώστε η κατάσταση πρόκειται να αξιολογήσει την πραγματική.

96
00:06:00,000 --> 00:06:03,000
Και αν είναι αλήθεια, ό, τι κώδικας είναι κάτω από τον όρο

97
00:06:03,000 --> 00:06:08,000
πρόκειται να αξιολογηθούν από τον υπολογιστή, έτσι ώστε συμβολοσειρά πρόκειται να εκτυπωθεί

98
00:06:08,000 --> 00:06:12,000
στην κανονική έξοδο, και ο όρος κατάσταση

99
00:06:12,000 --> 00:06:16,000
αναφέρεται σε ό, τι είναι μέσα στις παρενθέσεις της if.

100
00:06:16,000 --> 00:06:20,000
Θυμηθείτε όλες τις επιχειρήσεις.

101
00:06:20,000 --> 00:06:26,000
Να θυμάστε ότι && και | | όταν προσπαθούμε να συνδυάσουμε 2 ή περισσότερες συνθήκες,

102
00:06:26,000 --> 00:06:30,000
== = Όχι για να ελέγξετε αν 2 πράγματα είναι ίσες.

103
00:06:30,000 --> 00:06:36,000
Να θυμάστε ότι είναι =, ενώ για την ανάθεση == είναι μια boolean χειριστή.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ και στη συνέχεια το τελικό 2 είναι αυτονόητα.

105
00:06:41,000 --> 00:06:45,000
Μια γενική επισκόπηση της boolean λογική εδώ.

106
00:06:45,000 --> 00:06:48,000
Και boolean εκφράσεις είναι επίσης σημαντικό σε βρόχους,

107
00:06:48,000 --> 00:06:50,000
που θα πάμε πάνω από τώρα.

108
00:06:50,000 --> 00:06:56,000
Μάθαμε περίπου 3 είδη βρόχων μέχρι στιγμής σε CS50, για, ενώ, και ενώ κάνει.

109
00:06:56,000 --> 00:06:59,000
Και είναι σημαντικό να γνωρίζουμε ότι, ενώ για τους περισσότερους σκοπούς

110
00:06:59,000 --> 00:07:02,000
μπορούμε να χρησιμοποιήσουμε πραγματικά οποιοδήποτε είδος του βρόχου γενικά

111
00:07:02,000 --> 00:07:06,000
υπάρχουν ορισμένα είδη σκοπούς ή κοινά πρότυπα

112
00:07:06,000 --> 00:07:09,000
στον προγραμματισμό που ειδικώς απαιτούν μία από αυτές τις θηλιές

113
00:07:09,000 --> 00:07:13,000
που καθιστούν την πιο αποτελεσματική ή κομψό για την κωδικοποίησή του με αυτόν τον τρόπο.

114
00:07:13,000 --> 00:07:18,000
Ας πάει πάνω τι κάθε αυτών των βρόχων τείνει να χρησιμοποιείται για πιο συχνά.

115
00:07:18,000 --> 00:07:21,000
>> Σε ένα για βρόχο που κατά κανόνα ήδη γνωρίζουμε πόσες φορές θέλουμε να επαναλάβει.

116
00:07:21,000 --> 00:07:24,000
Αυτό είναι ό, τι βάζουμε στην κατάσταση.

117
00:07:24,000 --> 00:07:28,000
Για, i = 0, ί <10, για παράδειγμα.

118
00:07:28,000 --> 00:07:31,000
Γνωρίζουμε ήδη ότι θέλουμε να κάνουμε κάτι 10 φορές.

119
00:07:31,000 --> 00:07:34,000
Τώρα, για έναν βρόχο, ενώ, γενικά δεν απαραίτητα

120
00:07:34,000 --> 00:07:36,000
ξέρω πόσες φορές θέλουμε ο βρόχος να τρέξει.

121
00:07:36,000 --> 00:07:39,000
Αλλά γνωρίζουμε κάποια προϋπόθεση ότι θέλουμε να

122
00:07:39,000 --> 00:07:41,000
πάντα να είναι αληθής ή ψευδής πάντα.

123
00:07:41,000 --> 00:07:44,000
Για παράδειγμα, ενώ έχει οριστεί.

124
00:07:44,000 --> 00:07:46,000
Ας πούμε ότι είναι μια μεταβλητή boolean.

125
00:07:46,000 --> 00:07:48,000
Ενώ είναι αλήθεια ότι θέλουμε ο κωδικός για την αξιολόγηση,

126
00:07:48,000 --> 00:07:52,000
έτσι λίγο πιο επεκτάσιμη, λίγο περισσότερο από ό, τι γενικά ένα για βρόχο,

127
00:07:52,000 --> 00:07:55,000
αλλά οποιαδήποτε για βρόχο μπορεί επίσης να μετατραπεί σε ένα βρόχο, ενώ.

128
00:07:55,000 --> 00:08:00,000
Τέλος, κάνει, ενώ βρόχοι, το οποίο μπορεί να είναι το δυσκολότερο να καταλάβει αμέσως,

129
00:08:00,000 --> 00:08:04,000
συχνά χρησιμοποιούνται όταν θέλουμε να αξιολογήσουμε τον κώδικα πρώτου

130
00:08:04,000 --> 00:08:06,000
πριν από την πρώτη φορά που θα ελέγξετε την κατάσταση.

131
00:08:06,000 --> 00:08:09,000
Μια συνηθισμένη περίπτωση χρήσης για ένα do while loop

132
00:08:09,000 --> 00:08:12,000
είναι όταν θέλετε να πάρετε είσοδο του χρήστη, και ξέρετε ότι θέλετε να ζητήσει από το χρήστη

133
00:08:12,000 --> 00:08:15,000
για την είσοδο τουλάχιστον μία φορά, αλλά αν δεν σας δώσει καλή εισόδου αμέσως

134
00:08:15,000 --> 00:08:18,000
θέλετε να κρατήσετε ζητώντας τους μέχρι να σας δώσει το καλό εισόδου.

135
00:08:18,000 --> 00:08:21,000
Αυτή είναι η πιο κοινή χρήση ενός βρόχου ενώ κάνουν,

136
00:08:21,000 --> 00:08:23,000
και ας δούμε την πραγματική δομή αυτών των βρόχων.

137
00:08:23,000 --> 00:08:27,000
Κατά κανόνα, πάντα έχουν την τάση να ακολουθούν αυτά τα πρότυπα.

138
00:08:27,000 --> 00:08:30,000
>> Στο βρόχο για μέσα έχετε 3 στοιχεία:

139
00:08:30,000 --> 00:08:35,000
αρχικοποίηση, συνήθως κάτι σαν int i = 0 όπου i είναι ο μετρητής,

140
00:08:35,000 --> 00:08:40,000
κατάσταση, όπου θέλουμε να πούμε τρέξει αυτό το βρόχο για όσο διάστημα αυτή η κατάσταση εξακολουθεί να κατέχει,

141
00:08:40,000 --> 00:08:44,000
όπως i <10, και στη συνέχεια, τελικά, την ενημέρωση, η οποία είναι το πώς θα αυξήσετε

142
00:08:44,000 --> 00:08:47,000
ο μετρητής μεταβλητής σε κάθε σημείο του βρόχου.

143
00:08:47,000 --> 00:08:50,000
Ένα κοινό πράγμα για να δείτε εκεί είναι ακριβώς i + +,

144
00:08:50,000 --> 00:08:52,000
πράγμα που σημαίνει αυξήσετε i από 1 κάθε φορά.

145
00:08:52,000 --> 00:08:55,000
Θα μπορούσατε επίσης να κάνετε κάτι σαν i + = 2,

146
00:08:55,000 --> 00:08:58,000
πράγμα που σημαίνει προσθέσετε 2 έως θ κάθε φορά που περνάτε από το βρόχο.

147
00:08:58,000 --> 00:09:03,000
Και τότε το κάνετε αυτό ακριβώς αναφέρεται σε κάθε κωδικό που πραγματικά λειτουργεί ως μέρος του βρόχου.

148
00:09:03,000 --> 00:09:09,000
Και για έναν βρόχο, ενώ, αυτή τη φορά έχουμε πραγματικά την εκκίνηση έξω από το βρόχο,

149
00:09:09,000 --> 00:09:12,000
Έτσι, για παράδειγμα, ας υποθέσουμε ότι προσπαθούμε να κάνουμε το ίδιο είδος βρόχου ως που μόλις περιέγραψα.

150
00:09:12,000 --> 00:09:16,000
Θα λέγαμε int i = 0 πριν ο βρόχος αρχίζει.

151
00:09:16,000 --> 00:09:20,000
Στη συνέχεια, θα μπορούσαμε να πούμε, ενώ θ <10 το κάνετε αυτό,

152
00:09:20,000 --> 00:09:22,000
έτσι το ίδιο μπλοκ του κώδικα όπως και πριν,

153
00:09:22,000 --> 00:09:26,000
και αυτή τη φορά το τμήμα ενημέρωσης του κώδικα, για παράδειγμα, ί + +,

154
00:09:26,000 --> 00:09:29,000
πραγματικά πηγαίνει στο εσωτερικό του βρόχου.

155
00:09:29,000 --> 00:09:33,000
Και, τέλος, για ένα κάνει, ενώ, είναι παρόμοιο με το βρόχο while,

156
00:09:33,000 --> 00:09:36,000
αλλά πρέπει να θυμόμαστε ότι ο κώδικας θα αξιολογήσει μια φορά

157
00:09:36,000 --> 00:09:40,000
πριν η κατάσταση ελέγχεται, έτσι ώστε να κάνει μια πολύ πιο λογικό

158
00:09:40,000 --> 00:09:44,000
αν το δει κανείς σε σειρά πάνω προς τα κάτω.

159
00:09:44,000 --> 00:09:49,000
Σε ένα do while loop ο κωδικός αξιολογεί προτού καν εξετάσει την κατάσταση, ενώ,

160
00:09:49,000 --> 00:09:55,000
λαμβάνοντας υπόψη ότι ένα βρόχο, ενώ, ελέγχει πρώτα.

161
00:09:55,000 --> 00:09:59,000
Δηλώσεις και μεταβλητές.

162
00:09:59,000 --> 00:10:04,000
Όταν θέλουμε να δημιουργήσουμε μια νέα μεταβλητή πρώτα θέλουμε να το αρχικοποιήσει.

163
00:10:04,000 --> 00:10:07,000
>> Για παράδειγμα, int γραμμή αρχικοποιεί τη μεταβλητή μπαρ,

164
00:10:07,000 --> 00:10:10,000
αλλά δεν της δώσει μια τιμή, έτσι ποια είναι η αξία μπαρ τώρα;

165
00:10:10,000 --> 00:10:12,000
Δεν ξέρουμε.

166
00:10:12,000 --> 00:10:14,000
Θα μπορούσε να είναι κάποια αξία σκουπίδια που είχε αποθηκευθεί προηγουμένως στη μνήμη εκεί,

167
00:10:14,000 --> 00:10:16,000
και δεν θέλουμε να χρησιμοποιεί το εν λόγω μεταβλητή

168
00:10:16,000 --> 00:10:19,000
έως ότου πραγματικά να δώσει μια τιμή,

169
00:10:19,000 --> 00:10:21,000
έτσι ώστε να το δηλώσει εδώ.

170
00:10:21,000 --> 00:10:24,000
Στη συνέχεια, προετοιμασία για να είναι 42 κατωτέρω.

171
00:10:24,000 --> 00:10:28,000
Τώρα, βέβαια, γνωρίζουμε ότι αυτό μπορεί να γίνει σε μία γραμμή, γραμμή int = 42.

172
00:10:28,000 --> 00:10:30,000
Αλλά ακριβώς για να καθαρίσετε τα πολλά βήματα που βρίσκονται σε εξέλιξη,

173
00:10:30,000 --> 00:10:34,000
Η δήλωση και η αρχικοποίηση συμβαίνουν χωριστά εδώ.

174
00:10:34,000 --> 00:10:38,000
Αυτό συμβαίνει σε ένα βήμα, και η επόμενη, int = baz bar + 1,

175
00:10:38,000 --> 00:10:44,000
αυτή η παρακάτω δήλωση, ότι baz βήματα, ώστε στο τέλος αυτού του μπλοκ κώδικα

176
00:10:44,000 --> 00:10:48,000
αν ήταν να εκτυπώσετε την αξία του baz θα είναι 44

177
00:10:48,000 --> 00:10:52,000
επειδή δηλώνουμε και αρχικοποίηση να είναι 1 bar>,

178
00:10:52,000 --> 00:10:58,000
και τότε θα αυξήσετε για μια ακόμη φορά με το + +.

179
00:10:58,000 --> 00:11:02,000
Πήγαμε σε αυτό το όμορφο εν συντομία, αλλά είναι καλό να έχουμε μια γενική

180
00:11:02,000 --> 00:11:04,000
κατανόηση του τι είναι τα θέματα και γεγονότα.

181
00:11:04,000 --> 00:11:06,000
Το κάναμε αυτό, κυρίως στο Scratch,

182
00:11:06,000 --> 00:11:09,000
έτσι μπορείτε να σκεφτείτε θέματα όπως πολλαπλές ακολουθίες κώδικα

183
00:11:09,000 --> 00:11:11,000
κινούνται με την ίδια φορά.

184
00:11:11,000 --> 00:11:14,000
Στην πραγματικότητα, είναι πιθανόν να μην λειτουργεί με την ίδια στιγμή,

185
00:11:14,000 --> 00:11:17,000
αλλά το είδος της αφηρημένα μπορούμε να σκεφτούμε ότι με αυτόν τον τρόπο.

186
00:11:17,000 --> 00:11:20,000
>> Το Scratch, για παράδειγμα, είχαμε τις πολλαπλές sprites.

187
00:11:20,000 --> 00:11:22,000
Θα μπορούσε να είναι διαφορετικό κώδικα εκτέλεσης ταυτόχρονα.

188
00:11:22,000 --> 00:11:26,000
Κάποιος θα μπορούσε να είναι το περπάτημα, ενώ ο άλλος λέει κάτι

189
00:11:26,000 --> 00:11:29,000
σε ένα διαφορετικό μέρος της οθόνης.

190
00:11:29,000 --> 00:11:34,000
Εκδηλώσεις είναι ένας άλλος τρόπος διαχωρισμού από τη λογική

191
00:11:34,000 --> 00:11:37,000
μεταξύ των διαφόρων στοιχείων του κωδικού σας,

192
00:11:37,000 --> 00:11:40,000
και σε Scratch ήμασταν σε θέση να προσομοιώνουν τα γεγονότα με την Broadcast,

193
00:11:40,000 --> 00:11:43,000
και ότι στην πραγματικότητα όταν λαμβάνω, δεν όταν ακούω,

194
00:11:43,000 --> 00:11:47,000
αλλά ουσιαστικά είναι ένας τρόπος για τη μετάδοση πληροφοριών

195
00:11:47,000 --> 00:11:49,000
από τη μία στην άλλη sprite.

196
00:11:49,000 --> 00:11:52,000
Για παράδειγμα, μπορεί να θέλετε να μεταδώσει το παιχνίδι τελείωσε,

197
00:11:52,000 --> 00:11:56,000
και όταν ένα άλλο ξωτικό παιχνίδι λαμβάνει πάνω,

198
00:11:56,000 --> 00:11:58,000
ανταποκρίνεται με έναν ορισμένο τρόπο.

199
00:11:58,000 --> 00:12:03,000
Είναι ένα σημαντικό μοντέλο για την κατανόηση για τον προγραμματισμό.

200
00:12:03,000 --> 00:12:07,000
Ακριβώς για να πάει πέρα ​​από τη βασική Εβδομάδα 0, αυτό που έχουμε περάσει πάνω μέχρι στιγμής,

201
00:12:07,000 --> 00:12:10,000
ας ρίξουμε μια ματιά σε αυτό το απλό πρόγραμμα C.

202
00:12:10,000 --> 00:12:14,000
Το κείμενο μπορεί να είναι λίγο μικρό από εδώ, αλλά θα πάω πέρα ​​από το πραγματικά γρήγορα.

203
00:12:14,000 --> 00:12:20,000
Είμαστε συμπεριλαμβανομένων 2 αρχεία κεφαλίδας στην κορυφή, cs50.h και stdio.h.

204
00:12:20,000 --> 00:12:23,000
Είμαστε καθορίζει στη συνέχεια μια σταθερή ονομάζεται όριο είναι 100.

205
00:12:23,000 --> 00:12:26,000
Είμαστε εφαρμογή τότε η κύρια λειτουργία μας.

206
00:12:26,000 --> 00:12:29,000
Από τη στιγμή που δεν χρησιμοποιούν τα επιχειρήματα της γραμμής εντολών εδώ πρέπει να βάλουμε κενό

207
00:12:29,000 --> 00:12:32,000
καθώς τα επιχειρήματα για τις κύριες.

208
00:12:32,000 --> 00:12:38,000
Βλέπουμε int πάνω από την κύρια. Αυτός είναι ο τύπος επιστροφής, επιστρέφουν ως εκ τούτου, 0 στο κάτω μέρος.

209
00:12:38,000 --> 00:12:41,000
Και είμαστε χρησιμοποιώντας CS50 λειτουργία της βιβλιοθήκης να πάρει int

210
00:12:41,000 --> 00:12:45,000
να ζητήσει από το χρήστη για την είσοδο, και να το αποθηκεύσετε σε αυτή τη μεταβλητή x,

211
00:12:45,000 --> 00:12:51,000
έτσι δηλώνουμε x παραπάνω, και θα το προετοιμάσει με x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Στη συνέχεια ελέγξτε για να δείτε αν ο χρήστης μας έδωσε καλή εισόδου.

213
00:12:53,000 --> 00:12:59,000
Αν είναι ΟΡΙΟ ≥ θέλουμε να επιστρέψει ένα κωδικό σφάλματος από 1 και να εκτυπώσετε ένα μήνυμα σφάλματος.

214
00:12:59,000 --> 00:13:02,000
Και τέλος, αν ο χρήστης μας έχει δώσει καλή εισόδου

215
00:13:02,000 --> 00:13:08,000
θα πάμε να τετραγωνίσει τον αριθμό και να εκτυπώσετε το αποτέλεσμα.

216
00:13:08,000 --> 00:13:11,000
Ακριβώς για να βεβαιωθείτε ότι όλα αυτά σπίτι χτύπημα

217
00:13:11,000 --> 00:13:17,000
μπορείτε να δείτε τις ετικέτες των διαφόρων τμημάτων του κώδικα εδώ.

218
00:13:17,000 --> 00:13:19,000
Ανέφερα σταθερή, header αρχεία.

219
00:13:19,000 --> 00:13:21,000
Ω, int x. Φροντίστε να θυμάστε ότι είναι μια τοπική μεταβλητή.

220
00:13:21,000 --> 00:13:24,000
Αυτό έρχεται σε αντίθεση από μια καθολική μεταβλητή, η οποία θα μιλήσουμε για

221
00:13:24,000 --> 00:13:27,000
λίγο αργότερα, στη σύνοδο επανεξέτασης,

222
00:13:27,000 --> 00:13:30,000
και καλούμε τη λειτουργία της βιβλιοθήκης printf,

223
00:13:30,000 --> 00:13:34,000
έτσι αν δεν είχε συμπεριληφθεί το stdio.h αρχείο κεφαλίδας

224
00:13:34,000 --> 00:13:37,000
δεν θα είναι σε θέση να καλέσετε printf.

225
00:13:37,000 --> 00:13:42,000
Και πιστεύω ότι το βέλος που πήρε αποκοπεί εδώ είναι στραμμένη προς τα% d,

226
00:13:42,000 --> 00:13:45,000
η οποία είναι μια συμβολοσειρά μορφοποίησης σε printf.

227
00:13:45,000 --> 00:13:52,000
Λέει εκτυπώσετε αυτήν τη μεταβλητή ως ένας αριθμός,% d.

228
00:13:52,000 --> 00:13:58,000
Και αυτό είναι για την Εβδομάδα 0.

229
00:13:58,000 --> 00:14:06,000
Τώρα Lucas πρόκειται να συνεχιστεί.

230
00:14:06,000 --> 00:14:08,000
Γεια σας, παιδιά. Το όνομά μου είναι Lucas.

231
00:14:08,000 --> 00:14:10,000
Είμαι δευτεροετής φοιτητής στο καλύτερο σπίτι στην πανεπιστημιούπολη, Mather,

232
00:14:10,000 --> 00:14:14,000
και θα πάω να μιλήσω λίγο για εβδομάδα 1 και 2,1.

233
00:14:14,000 --> 00:14:16,000
[Εβδομάδα 1 και 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Όπως Lexi έλεγε, όταν άρχισε να μεταφράζει τον κωδικό σας από γρατζουνιές με C

235
00:14:19,000 --> 00:14:23,000
ένα από τα πράγματα που έχουμε παρατηρήσει είναι ότι μπορείτε όχι μόνο

236
00:14:23,000 --> 00:14:26,000
γράψετε τον κωδικό σας και να το εκτελέσετε χρησιμοποιώντας μια πράσινη σημαία πια.

237
00:14:26,000 --> 00:14:30,000
Στην πραγματικότητα, θα πρέπει να χρησιμοποιήσετε κάποια βήματα για να κάνετε το πρόγραμμά σας C

238
00:14:30,000 --> 00:14:33,000
γίνει ένα εκτελέσιμο αρχείο.

239
00:14:33,000 --> 00:14:36,000
Βασικά αυτό που κάνετε όταν γράφετε ένα πρόγραμμα είναι ότι

240
00:14:36,000 --> 00:14:40,000
να μεταφράσετε την ιδέα σας σε μια γλώσσα που ο μεταγλωττιστής μπορεί να καταλάβει,

241
00:14:40,000 --> 00:14:44,000
έτσι όταν γράφετε ένα πρόγραμμα σε C

242
00:14:44,000 --> 00:14:47,000
τι κάνετε γράφει ότι στην πραγματικότητα κάτι μεταγλωττιστή σας πρόκειται να καταλάβει,

243
00:14:47,000 --> 00:14:50,000
και τότε ο compiler πρόκειται να μεταφράσει αυτόν τον κώδικα

244
00:14:50,000 --> 00:14:53,000
σε κάτι που ο υπολογιστής σας θα καταλάβει.

245
00:14:53,000 --> 00:14:55,000
>> Και το πράγμα είναι, ο υπολογιστής σας είναι πραγματικά πολύ χαζή.

246
00:14:55,000 --> 00:14:57,000
Ο υπολογιστής σας μπορεί να καταλάβει μόνο 0s και 1s,

247
00:14:57,000 --> 00:15:01,000
έτσι στην πραγματικότητα το πρώτο υπολογιστές άνθρωποι συνήθως προγραμματιστεί

248
00:15:01,000 --> 00:15:04,000
χρησιμοποιώντας 0s και 1s, αλλά όχι πια, δόξα τω Θεώ.

249
00:15:04,000 --> 00:15:07,000
Εμείς δεν χρειάζεται να απομνημονεύουν τις ακολουθίες για 0s και 1s

250
00:15:07,000 --> 00:15:10,000
για ένα ή για το βρόχο για έναν βρόχο, ενώ και ούτω καθεξής.

251
00:15:10,000 --> 00:15:13,000
Γι 'αυτό έχουμε ένα μεταγλωττιστή.

252
00:15:13,000 --> 00:15:17,000
Τι compiler που κάνει είναι να μετατρέπει ουσιαστικά τον κώδικα C,

253
00:15:17,000 --> 00:15:21,000
στην περίπτωσή μας, σε μια γλώσσα που ο υπολογιστής σας θα καταλάβει,

254
00:15:21,000 --> 00:15:25,000
το οποίο είναι το αντικείμενο κώδικα, και ο compiler που χρησιμοποιείτε

255
00:15:25,000 --> 00:15:30,000
λέγεται κλαγγή, έτσι αυτό είναι πραγματικά το σύμβολο για κλαγγή.

256
00:15:30,000 --> 00:15:33,000
Όταν έχετε το πρόγραμμα σας, θα πρέπει να κάνετε 2 πράγματα.

257
00:15:33,000 --> 00:15:37,000
Κατ 'αρχάς, θα πρέπει να καταρτίσει το πρόγραμμά σας, και στη συνέχεια θα πάμε να τρέξετε το πρόγραμμά σας.

258
00:15:37,000 --> 00:15:41,000
Για την κατάρτιση του προγράμματος σας, έχετε πολλές επιλογές για να το πράξουν.

259
00:15:41,000 --> 00:15:44,000
Το πρώτο είναι να κάνει program.c κλαγγή

260
00:15:44,000 --> 00:15:47,000
σε ποιο πρόγραμμα είναι το όνομα του προγράμματός σας.

261
00:15:47,000 --> 00:15:51,000
Σε αυτή την περίπτωση μπορείτε να δείτε ότι απλά λέγοντας "Γεια σου, συγκεντρώνουν το πρόγραμμά μου."

262
00:15:51,000 --> 00:15:56,000
Δεν λέτε "θέλω αυτό το όνομα για το πρόγραμμά μου» ή οτιδήποτε.

263
00:15:56,000 --> 00:15:58,000
>> Η δεύτερη επιλογή δίνει ένα όνομα για το πρόγραμμά σας.

264
00:15:58,000 --> 00:16:02,000
Μπορείτε να πείτε κλαγγή-o και στη συνέχεια το όνομα που θέλετε

265
00:16:02,000 --> 00:16:06,000
το εκτελέσιμο αρχείο που θα ονομαστεί ως και, στη συνέχεια program.c.

266
00:16:06,000 --> 00:16:11,000
Και μπορείτε επίσης να κάνουν το πρόγραμμα, και να δούμε πώς τις πρώτες 2 περιπτώσεις

267
00:16:11,000 --> 00:16:15,000
Έβαλα. Γ, και το τρίτο που έχω μόνο τα προγράμματα;

268
00:16:15,000 --> 00:16:18,000
Ναι, μπορείτε πραγματικά δεν θα πρέπει να θέσει. Γ. όταν χρησιμοποιείτε το κάνουν.

269
00:16:18,000 --> 00:16:22,000
Διαφορετικά, ο μεταγλωττιστής είναι πραγματικά πρόκειται να φωνάζω σε σας.

270
00:16:22,000 --> 00:16:24,000
Και επίσης, δεν ξέρω αν θυμάστε εσείς,

271
00:16:24,000 --> 00:16:29,000
αλλά πολλές φορές επίσης χρησιμοποιείται lcs50-ή-lm.

272
00:16:29,000 --> 00:16:31,000
Που ονομάζεται σύνδεση.

273
00:16:31,000 --> 00:16:35,000
Λέει απλώς τον compiler ότι θα χρησιμοποιήσετε αυτές τις βιβλιοθήκες εκεί,

274
00:16:35,000 --> 00:16:39,000
οπότε αν θέλετε να χρησιμοποιήσετε cs50.h που πραγματικά πρέπει να πληκτρολογήσετε

275
00:16:39,000 --> 00:16:43,000
κλαγγή program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Αν δεν το κάνουμε αυτό, ο compiler δεν πρόκειται να γνωρίζετε

277
00:16:45,000 --> 00:16:50,000
ότι χρησιμοποιείτε αυτές τις λειτουργίες σε cs50.h.

278
00:16:50,000 --> 00:16:52,000
Και όταν θέλετε να τρέξετε το πρόγραμμά σας έχετε 2 επιλογές.

279
00:16:52,000 --> 00:16:57,000
Αν το κάνατε program.c κλαγγή δεν έχετε δώσει ένα όνομα στο πρόγραμμά σας.

280
00:16:57,000 --> 00:17:01,000
Θα πρέπει να το τρέξει με. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out είναι ένα πρότυπο όνομα που κλαγγή δίνει το πρόγραμμά σας, αν δεν του δώσετε ένα όνομα.

282
00:17:06,000 --> 00:17:11,000
Διαφορετικά, θα πάμε να κάνουμε. / Πρόγραμμα αν έδωσε ένα όνομα για το πρόγραμμά σας,

283
00:17:11,000 --> 00:17:15,000
και, επίσης, αν έκανε το όνομα του προγράμματος ότι το πρόγραμμα πρόκειται να πάρει

284
00:17:15,000 --> 00:17:23,000
έχει ήδη πρόκειται να προγραμματιστεί το ίδιο όνομα με το αρχείο c.

285
00:17:23,000 --> 00:17:26,000
Στη συνέχεια μιλήσαμε για τους τύπους δεδομένων και δεδομένων.

286
00:17:26,000 --> 00:17:31,000
>> Βασικά τύπους δεδομένων είναι το ίδιο πράγμα με μικρά κουτιά που χρησιμοποιούν

287
00:17:31,000 --> 00:17:35,000
για την αποθήκευση τιμών, έτσι ώστε τα δεδομένα τύποι είναι πραγματικά ακριβώς όπως Pokémons.

288
00:17:35,000 --> 00:17:39,000
Έρχονται σε όλα τα μεγέθη και τύπους.

289
00:17:39,000 --> 00:17:43,000
Δεν ξέρω αν αυτή η αναλογία έχει νόημα.

290
00:17:43,000 --> 00:17:46,000
Το μέγεθος εξαρτάται από πραγματικά δεδομένα για την αρχιτεκτονική του μηχανήματος.

291
00:17:46,000 --> 00:17:49,000
Όλα τα μεγέθη δεδομένων που Πάω να δείξει εδώ

292
00:17:49,000 --> 00:17:53,000
είναι στην πραγματικότητα για ένα 32-bit μηχάνημα, το οποίο είναι η περίπτωση της συσκευής μας,

293
00:17:53,000 --> 00:17:56,000
αλλά αν είστε πραγματικά κωδικοποίησης Mac σας ή σε έναν υπολογιστή με Windows, επίσης,

294
00:17:56,000 --> 00:17:59,000
κατά πάσα πιθανότητα θα πάμε να έχουν ένα 64-bit μηχάνημα,

295
00:17:59,000 --> 00:18:03,000
ώστε να θυμάστε ότι τα μεγέθη των δεδομένων που Πάω να δείξει εδώ

296
00:18:03,000 --> 00:18:06,000
είναι για το 32-bit μηχάνημα.

297
00:18:06,000 --> 00:18:08,000
Το πρώτο που είδαμε ήταν ένα int,

298
00:18:08,000 --> 00:18:10,000
η οποία είναι αρκετά απλή.

299
00:18:10,000 --> 00:18:13,000
Μπορείτε να χρησιμοποιήσετε int να αποθηκεύσει έναν ακέραιο.

300
00:18:13,000 --> 00:18:16,000
Είδαμε, επίσης, το χαρακτήρα, το char.

301
00:18:16,000 --> 00:18:20,000
Αν θέλετε να χρησιμοποιήσετε μια επιστολή ή ένα μικρό σύμβολο είστε πιθανώς πρόκειται να χρησιμοποιήσετε μια χαρα.

302
00:18:20,000 --> 00:18:26,000
Μια χαρα έχει 1 byte, που σημαίνει 8 bits, όπως δήλωσε ο Lexi.

303
00:18:26,000 --> 00:18:31,000
Βασικά έχουμε ένα πίνακα ASCII που έχει 256

304
00:18:31,000 --> 00:18:34,000
πιθανών συνδυασμών 0s και 1s,

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

306
00:18:37,000 --> 00:18:44,000
ο χαρακτήρας σας ότι οι εισροές ένας αριθμός που έχετε στον πίνακα ASCII, όπως δήλωσε ο Lexi.

307
00:18:44,000 --> 00:18:48,000
Έχουμε επίσης τον πλωτήρα, το οποίο χρησιμοποιούμε για την αποθήκευση δεκαδικούς αριθμούς.

308
00:18:48,000 --> 00:18:53,000
Αν θέλετε να επιλέξετε 3,14, για παράδειγμα, θα πάμε να χρησιμοποιήσετε ένα απόθεμα

309
00:18:53,000 --> 00:18:55,000
ή ένα διπλό που έχει μεγαλύτερη ακρίβεια.

310
00:18:55,000 --> 00:18:57,000
Ο πλωτήρας έχει 4 byte.

311
00:18:57,000 --> 00:19:01,000
Ένα διπλό έχει 8 bytes, οπότε η μόνη διαφορά είναι η ακρίβεια.

312
00:19:01,000 --> 00:19:04,000
Έχουμε επίσης μια μακρά που χρησιμοποιείται για ακέραιους αριθμούς,

313
00:19:04,000 --> 00:19:09,000
και μπορείτε να δείτε για ένα 32-bit μηχάνημα ένα int και ένα καιρό έχουν το ίδιο μέγεθος,

314
00:19:09,000 --> 00:19:13,000
γι 'αυτό δεν κάνει πραγματικά αίσθηση να χρησιμοποιήσετε ένα χρονικό διάστημα σε ένα 32-bit μηχάνημα.

315
00:19:13,000 --> 00:19:17,000
>> Αλλά αν χρησιμοποιείτε ένα μηχάνημα Mac και 64-bit, στην πραγματικότητα μια μακρά έχει μέγεθος 8,

316
00:19:17,000 --> 00:19:19,000
γι 'αυτό πραγματικά εξαρτάται από την αρχιτεκτονική.

317
00:19:19,000 --> 00:19:22,000
Για την 32-bit μηχάνημα αυτό δεν έχει νόημα να χρησιμοποιήσει μια μακρά πραγματικά.

318
00:19:22,000 --> 00:19:25,000
Και στη συνέχεια μια μακρά μακρά, από την άλλη πλευρά, έχει 8 bytes,

319
00:19:25,000 --> 00:19:30,000
γι 'αυτό είναι πολύ καλό, αν θέλετε να έχετε ένα μεγαλύτερο ακέραιο αριθμό.

320
00:19:30,000 --> 00:19:34,000
Και τέλος, έχουμε σειρά, η οποία είναι στην πραγματικότητα ένα char *,

321
00:19:34,000 --> 00:19:37,000
το οποίο είναι ένας δείκτης σε char.

322
00:19:37,000 --> 00:19:40,000
Είναι πολύ εύκολο να σκεφτεί κανείς ότι το μέγεθος του string θα είναι σαν

323
00:19:40,000 --> 00:19:42,000
ο αριθμός των χαρακτήρων που έχετε εκεί,

324
00:19:42,000 --> 00:19:45,000
αλλά στην πραγματικότητα το ίδιο το char *

325
00:19:45,000 --> 00:19:49,000
Έχει το μέγεθος ενός δείκτη σε char, η οποία είναι 4 bytes.

326
00:19:49,000 --> 00:19:52,000
Το μέγεθος ενός char * είναι 4 bytes.

327
00:19:52,000 --> 00:19:56,000
Δεν έχει σημασία αν έχετε μια μικρή λέξη ή μια επιστολή ή οτιδήποτε.

328
00:19:56,000 --> 00:19:58,000
Είναι πρόκειται να είναι 4 bytes.

329
00:19:58,000 --> 00:20:01,000
Μάθαμε επίσης λίγο για χύτευση,

330
00:20:01,000 --> 00:20:04,000
Έτσι, όπως μπορείτε να δείτε, αν έχετε, για παράδειγμα, ένα πρόγραμμα που λέει

331
00:20:04,000 --> 00:20:08,000
int x = 3 και στη συνέχεια printf ("% d", το χ / 2)

332
00:20:08,000 --> 00:20:12,000
κάνετε εσείς ξέρετε τι πρόκειται να εκτυπώσετε στην οθόνη;

333
00:20:12,000 --> 00:20:14,000
>> Κάποιος; >> [Φοιτητές] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, ναι.

335
00:20:16,000 --> 00:20:20,000
Όταν το κάνετε 3/2 πρόκειται να πάρει 1,5,

336
00:20:20,000 --> 00:20:24,000
αλλά επειδή είμαστε χρησιμοποιώντας έναν ακέραιο πρόκειται να αγνοήσει το δεκαδικό μέρος,

337
00:20:24,000 --> 00:20:26,000
και θα πάμε να έχουν 1.

338
00:20:26,000 --> 00:20:29,000
Αν δεν θέλετε να συμβεί ό, τι μπορείτε να κάνετε, για παράδειγμα,

339
00:20:29,000 --> 00:20:33,000
έχει κηρύξει έναν πλωτήρα y = x.

340
00:20:33,000 --> 00:20:40,000
Τότε x που χρησιμοποιείται για να είναι 3 είναι τώρα πρόκειται να είναι σε 3,000 y.

341
00:20:40,000 --> 00:20:44,000
Και τότε μπορείτε να εκτυπώσετε το y / 2.

342
00:20:44,000 --> 00:20:50,000
Στην πραγματικότητα, θα έπρεπε να έχω ένα 2. εκεί πέρα.

343
00:20:50,000 --> 00:20:55,000
Είναι πρόκειται να κάνει 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
και θα πάμε για να πάρει 1,5.

345
00:20:58,000 --> 00:21:06,000
Και έχουμε αυτό το .2 f είναι να ρωτήσετε απλά για 2 δεκαδικές μονάδες στο δεκαδικό μέρος.

346
00:21:06,000 --> 00:21:12,000
Αν έχετε 0.3 στ πρόκειται να έχουν πραγματικά 1,500.

347
00:21:12,000 --> 00:21:16,000
Αν είναι 2 πρόκειται να είναι 1,50.

348
00:21:16,000 --> 00:21:18,000
Έχουμε, επίσης, την υπόθεση εδώ.

349
00:21:18,000 --> 00:21:22,000
Αν παρουσιάζουν διακυμάνσεις x = 3,14 και τότε printf x

350
00:21:22,000 --> 00:21:24,000
θα πάμε για να πάρει 3,14.

351
00:21:24,000 --> 00:21:29,000
Και αν το κάνετε x = int του x,

352
00:21:29,000 --> 00:21:34,000
πράγμα που σημαίνει θεραπεία x ως int και θα τυπώνει το x τώρα

353
00:21:34,000 --> 00:21:36,000
θα πάμε να έχει 3,00.

354
00:21:36,000 --> 00:21:38,000
Μήπως αυτό έχει νόημα;

355
00:21:38,000 --> 00:21:41,000
Επειδή είστε θεραπεία πρώτη x ως ακέραιος αριθμός, ώστε να είστε αγνοώντας το δεκαδικό μέρος,

356
00:21:41,000 --> 00:21:45,000
και στη συνέχεια να είστε εκτύπωση x.

357
00:21:45,000 --> 00:21:47,000
Και τέλος, μπορείτε επίσης να κάνετε αυτό,

358
00:21:47,000 --> 00:21:52,000
int x = 65, και τότε θα κηρύξει char c = x,

359
00:21:52,000 --> 00:21:56,000
και στη συνέχεια, αν εκτυπώσετε το γ είστε πραγματικά πρόκειται να πάρει

360
00:21:56,000 --> 00:21:59,000
Α, έτσι ουσιαστικά τι κάνετε εδώ

361
00:21:59,000 --> 00:22:02,000
η μετάφραση του σε ακέραιο χαρακτήρα,

362
00:22:02,000 --> 00:22:05,000
ακριβώς όπως ο πίνακας ASCII κάνει.

363
00:22:05,000 --> 00:22:08,000
Μιλήσαμε επίσης για μαθηματικούς τελεστές.

364
00:22:08,000 --> 00:22:14,000
Οι περισσότεροι από αυτούς είναι αρκετά απλή, οπότε +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
και μιλήσαμε για mod, το οποίο είναι το υπόλοιπο της διαίρεσης του 2 αριθμούς.

366
00:22:20,000 --> 00:22:23,000
Εάν έχετε 10% 3, για παράδειγμα,

367
00:22:23,000 --> 00:22:27,000
αυτό σημαίνει ότι χωρίζουν 10 με 3, και ποιο είναι το υπόλοιπο;

368
00:22:27,000 --> 00:22:30,000
Είναι πρόκειται να είναι 1, έτσι είναι πραγματικά πολύ χρήσιμο για πολλά από τα προγράμματα.

369
00:22:30,000 --> 00:22:38,000
Για Vigenere Καίσαρα και είμαι σίγουρος ότι όλοι εσείς που χρησιμοποιούνται mod.

370
00:22:38,000 --> 00:22:43,000
Σχετικά με μαθηματικούς τελεστές, να είναι πολύ προσεκτικοί όταν συνδυάζονται και * /.

371
00:22:43,000 --> 00:22:48,000
>> Για παράδειγμα, αν κάνετε (3/2) * 2 τι πρόκειται να πάρει;

372
00:22:48,000 --> 00:22:50,000
[Φοιτητές] 2.

373
00:22:50,000 --> 00:22:54,000
Ναι, 2, γιατί τρία δεύτερα πρόκειται να είναι 1,5,

374
00:22:54,000 --> 00:22:57,000
αλλά από τη στιγμή που κάνεις πράξεις μεταξύ 2 ακέραιοι

375
00:22:57,000 --> 00:22:59,000
είστε πραγματικά ακριβώς πρόκειται να εξετάσει 1,

376
00:22:59,000 --> 00:23:03,000
και στη συνέχεια, 1 * 2 θα είναι 2, έτσι ώστε να είναι πολύ, πολύ προσεκτικός

377
00:23:03,000 --> 00:23:07,000
όταν κάνουμε αριθμητική με ακέραιους αριθμούς, επειδή

378
00:23:07,000 --> 00:23:12,000
μπορείτε να πάρετε ότι 2 = 3, σε αυτή την περίπτωση.

379
00:23:12,000 --> 00:23:14,000
Και, επίσης, να είναι πολύ προσεκτικοί σχετικά με προβάδισμα.

380
00:23:14,000 --> 00:23:21,000
Θα πρέπει να χρησιμοποιείτε συνήθως παρενθέσεις για να είστε σίγουροι ότι ξέρετε τι κάνετε.

381
00:23:21,000 --> 00:23:27,000
Μερικές χρήσιμες συντομεύσεις, φυσικά, το ένα είναι i + + ή + i = 1

382
00:23:27,000 --> 00:23:30,000
ή χρησιμοποιώντας + =.

383
00:23:30,000 --> 00:23:34,000
Αυτό είναι το ίδιο πράγμα με το να κάνει i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Μπορείτε να το κάνετε, επίσης, i - ή i - = 1,

385
00:23:39,000 --> 00:23:42,000
το οποίο είναι το ίδιο πράγμα με i = i -1,

386
00:23:42,000 --> 00:23:46,000
κάτι που εσείς χρησιμοποιείτε πολλά για βρόχους, τουλάχιστον.

387
00:23:46,000 --> 00:23:52,000
Επίσης, για *, αν χρησιμοποιείτε * = και αν το κάνετε, για παράδειγμα,

388
00:23:52,000 --> 00:23:57,000
* i = 2 είναι το ίδιο πράγμα με το να λέμε i = i * 2,

389
00:23:57,000 --> 00:23:59,000
και το ίδιο πράγμα για τη διαίρεση.

390
00:23:59,000 --> 00:24:08,000
Αν το κάνετε i / = 2 είναι το ίδιο πράγμα με i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Τώρα σχετικά με τις λειτουργίες.

392
00:24:10,000 --> 00:24:13,000
Εσείς μάθει ότι οι λειτουργίες είναι μια πολύ καλή στρατηγική για να αποθηκεύσετε τον κωδικό

393
00:24:13,000 --> 00:24:16,000
ενώ είστε προγραμματισμό, οπότε αν θέλετε να εκτελέσετε την ίδια εργασία

394
00:24:16,000 --> 00:24:20,000
στον κώδικα ξανά και ξανά, ίσως θέλετε να χρησιμοποιήσετε μια συνάρτηση

395
00:24:20,000 --> 00:24:25,000
ακριβώς έτσι δεν χρειάζεται να αντιγράψετε και να επικολλήσετε τον κώδικα ξανά και ξανά.

396
00:24:25,000 --> 00:24:28,000
Στην πραγματικότητα, είναι μια κύρια λειτουργία, και όταν σας δείξει τη μορφή μιας συνάρτησης

397
00:24:28,000 --> 00:24:32,000
θα πάμε να δούμε ότι αυτό είναι αρκετά προφανές.

398
00:24:32,000 --> 00:24:35,000
Μπορούμε επίσης να χρησιμοποιήσετε τις λειτουργίες από ορισμένες βιβλιοθήκες,

399
00:24:35,000 --> 00:24:39,000
για παράδειγμα, printf GetIn, η οποία είναι από τη βιβλιοθήκη CS50,

400
00:24:39,000 --> 00:24:43,000
και άλλες λειτουργίες, όπως toupper.

401
00:24:43,000 --> 00:24:46,000
Όλες αυτές οι λειτουργίες είναι πράγματι εφαρμόζεται σε άλλες βιβλιοθήκες,

402
00:24:46,000 --> 00:24:49,000
και όταν βάζετε αυτά τα αρχεία πρόσδεσης στην αρχή του προγράμματός σας

403
00:24:49,000 --> 00:24:53,000
λέτε να σας παρακαλώ να μου δώσει τον κώδικα για αυτές τις λειτουργίες

404
00:24:53,000 --> 00:24:57,000
γι 'αυτό δεν χρειάζεται να τους εφαρμόσουν με τον εαυτό μου;

405
00:24:57,000 --> 00:25:00,000
Και μπορείτε επίσης να γράψετε τις δικές σας συναρτήσεις, έτσι ώστε όταν αρχίσει ο προγραμματισμός

406
00:25:00,000 --> 00:25:04,000
έχετε συνειδητοποιήσει ότι οι βιβλιοθήκες δεν έχουν όλες τις λειτουργίες που χρειάζεστε.

407
00:25:04,000 --> 00:25:10,000
Για την τελευταία PSET, για παράδειγμα, γράψαμε κλήρωση, αγωνίζομαι, και αναζήτηση,

408
00:25:10,000 --> 00:25:13,000
και είναι πολύ, πολύ σημαντικό να είναι σε θέση να γράψει λειτουργίες

409
00:25:13,000 --> 00:25:17,000
επειδή είναι χρήσιμα, και χρησιμοποιούμε τους όλη την ώρα στον προγραμματισμό,

410
00:25:17,000 --> 00:25:19,000
και εξοικονομεί πολύ κώδικα.

411
00:25:19,000 --> 00:25:21,000
Η μορφή μιας συνάρτησης είναι αυτό.

412
00:25:21,000 --> 00:25:24,000
Έχουμε τύπου επιστροφή στην αρχή. Ποιος είναι ο τύπος επιστροφής;

413
00:25:24,000 --> 00:25:27,000
Είναι μόνο όταν η λειτουργία σας πρόκειται να επιστρέψει.

414
00:25:27,000 --> 00:25:29,000
Αν έχετε μια λειτουργία, για παράδειγμα, παραγοντικό,

415
00:25:29,000 --> 00:25:31,000
δηλαδή πρόκειται για τον υπολογισμό μιας παραγοντικού του ακεραίου,

416
00:25:31,000 --> 00:25:34,000
κατά πάσα πιθανότητα πρόκειται να επιστρέψει έναν ακέραιο επίσης.

417
00:25:34,000 --> 00:25:37,000
Τότε ο τύπος επιστροφής πρόκειται να είναι int.

418
00:25:37,000 --> 00:25:41,000
Printf έχει πραγματικά ένα κενό τύπο επιστροφής

419
00:25:41,000 --> 00:25:43,000
επειδή δεν είστε επιστρέφουν τίποτα.

420
00:25:43,000 --> 00:25:45,000
Είσαι απλά τα πράγματα εκτύπωση στην οθόνη

421
00:25:45,000 --> 00:25:48,000
και το κλείσιμο της λειτουργίας μετά.

422
00:25:48,000 --> 00:25:51,000
Στη συνέχεια, έχετε το όνομα της συνάρτησης που μπορείτε να επιλέξετε.

423
00:25:51,000 --> 00:25:55,000
Θα πρέπει να είναι λίγο λογική, όπως δεν επιλέγουν ένα όνομα όπως xyz

424
00:25:55,000 --> 00:25:58,000
ή όπως x2f.

425
00:25:58,000 --> 00:26:02,000
Προσπαθήστε να κάνετε ένα όνομα που έχει νόημα.

426
00:26:02,000 --> 00:26:04,000
>> Για παράδειγμα, αν είναι παραγοντικό, λένε παραγοντικό.

427
00:26:04,000 --> 00:26:08,000
Αν είναι μια λειτουργία που πρόκειται να συντάξει κάτι, το όνομα ισοπαλία.

428
00:26:08,000 --> 00:26:11,000
Και τότε έχουμε τις παραμέτρους, οι οποίες ονομάζονται επίσης επιχειρήματα,

429
00:26:11,000 --> 00:26:14,000
που είναι σαν τους πόρους που χρειάζεται η λειτουργία σας

430
00:26:14,000 --> 00:26:17,000
από τον κώδικά σας για να εκπληρώσει την αποστολή του.

431
00:26:17,000 --> 00:26:20,000
Αν θέλετε να υπολογίσετε το παραγοντικό ενός αριθμού

432
00:26:20,000 --> 00:26:23,000
μάλλον θα πρέπει να έχετε έναν αριθμό για να υπολογίσει ένα παραγοντικό.

433
00:26:23,000 --> 00:26:27,000
Ένα από τα επιχειρήματα που θα πάμε να είναι ο ίδιος ο αριθμός.

434
00:26:27,000 --> 00:26:31,000
Και στη συνέχεια, πρόκειται να κάνει κάτι και να επιστρέψει την αξία τους στο τέλος

435
00:26:31,000 --> 00:26:35,000
εκτός αν είναι μια άκυρη λειτουργία.

436
00:26:35,000 --> 00:26:37,000
Ας δούμε ένα παράδειγμα.

437
00:26:37,000 --> 00:26:40,000
Αν θέλω να γράψω μια λειτουργία που συνοψίζει όλους τους αριθμούς σε μια σειρά από ακέραιους αριθμούς,

438
00:26:40,000 --> 00:26:43,000
πρώτα από όλα, ο τύπος επιστροφής πρόκειται να είναι int

439
00:26:43,000 --> 00:26:46,000
γιατί έχω μια σειρά από ακέραιους αριθμούς.

440
00:26:46,000 --> 00:26:51,000
Και τότε Πάω να έχει το όνομα της συνάρτησης, όπως sumArray,

441
00:26:51,000 --> 00:26:54,000
και στη συνέχεια πρόκειται να λάβει την ίδια σειρά, σε int Nums,

442
00:26:54,000 --> 00:26:58,000
και στη συνέχεια το μήκος του πίνακα, έτσι ξέρω πόσους αριθμούς που έχω να συνοψίσω.

443
00:26:58,000 --> 00:27:02,000
Τότε θα πρέπει να προετοιμάσει μια μεταβλητή που ονομάζεται ποσό, για παράδειγμα, στο 0,

444
00:27:02,000 --> 00:27:08,000
και κάθε φορά που βλέπω ένα στοιχείο του πίνακα θα πρέπει να το προσθέσετε στο σύνολο, έτσι έκανα ένα για βρόχο.

445
00:27:08,000 --> 00:27:15,000
Ακριβώς όπως είπε ο Lexi, κάνετε int i = 0, i μήκος <και i + +.

446
00:27:15,000 --> 00:27:20,000
Και για κάθε στοιχείο του πίνακα έκανα άθροισμα + = Nums [i],

447
00:27:20,000 --> 00:27:24,000
και στη συνέχεια θα επιστρέψει το ποσό, γι 'αυτό είναι πολύ απλό, και εξοικονομεί πολύ κώδικα

448
00:27:24,000 --> 00:27:28,000
αν χρησιμοποιείτε αυτή τη λειτουργία πολλές φορές.

449
00:27:28,000 --> 00:27:32,000
Στη συνέχεια πήραμε μια ματιά σε όρους.

450
00:27:32,000 --> 00:27:38,000
Έχουμε αν, αλλιώς, αν και αλλιώς.

451
00:27:38,000 --> 00:27:42,000
Ας δούμε ποια είναι η διαφορά μεταξύ αυτών.

452
00:27:42,000 --> 00:27:45,000
Ρίξτε μια ματιά σε αυτές τις 2 κωδικούς. Ποια είναι η διαφορά μεταξύ τους;

453
00:27:45,000 --> 00:27:49,000
Η πρώτη έχει-ουσιαστικά οι κωδικοί θέλετε να πείτε

454
00:27:49,000 --> 00:27:51,000
αν ένας αριθμός είναι +, -, ή 0.

455
00:27:51,000 --> 00:27:55,000
Η πρώτη λέει ότι αν είναι> 0 τότε είναι θετικό.

456
00:27:55,000 --> 00:28:00,000
Αν είναι = 0 τότε να είναι 0, και αν είναι <0 τότε είναι αρνητική.

457
00:28:00,000 --> 00:28:04,000
>> Και ο άλλος κάνει αν, αλλιώς αν, αλλιώς.

458
00:28:04,000 --> 00:28:07,000
Η διαφορά μεταξύ των δύο είναι ότι αυτό είναι στην πραγματικότητα πρόκειται να

459
00:28:07,000 --> 00:28:13,000
ελέγξετε εάν> 0, <0 = 0 ή τρεις φορές,

460
00:28:13,000 --> 00:28:17,000
οπότε αν έχετε τον αριθμό 2, για παράδειγμα, πρόκειται να έρθει εδώ και να πω

461
00:28:17,000 --> 00:28:21,000
if (x> 0), και πρόκειται να πω ναι, έτσι μπορώ να εκτυπώσω θετικά.

462
00:28:21,000 --> 00:28:25,000
Αλλά ακόμα κι αν ξέρω ότι είναι> 0 και δεν πρόκειται να είναι 0 ή <0

463
00:28:25,000 --> 00:28:29,000
Είμαι ακόμα πρόκειται να κάνουμε είναι το 0, είναι <0,

464
00:28:29,000 --> 00:28:33,000
έτσι είμαι πραγματικά συμβαίνει στο εσωτερικό του IFS ότι δεν είχα να

465
00:28:33,000 --> 00:28:38,000
επειδή ξέρω ήδη ότι δεν πρόκειται να ικανοποιήσει κάποια από αυτές τις συνθήκες.

466
00:28:38,000 --> 00:28:41,000
Μπορώ να χρησιμοποιήσω το αν, αλλιώς αν, else.

467
00:28:41,000 --> 00:28:45,000
Λέει βασικά αν x = 0 I εκτυπώσετε το θετικό.

468
00:28:45,000 --> 00:28:48,000
Αν δεν είναι, θα πάω να δοκιμάσει και αυτό.

469
00:28:48,000 --> 00:28:51,000
Αν είναι 2 εγώ δεν πρόκειται να το κάνουμε αυτό.

470
00:28:51,000 --> 00:28:54,000
Βασικά αν είχα x = 2 θα σας πω

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ναι, έτσι εκτυπώσετε αυτό.

472
00:28:57,000 --> 00:29:00,000
Τώρα που ξέρω ότι είναι> 0 και ότι ικανοποιείται εάν η πρώτη

473
00:29:00,000 --> 00:29:02,000
Δεν είμαι καν πρόκειται να εκτελέσετε αυτόν τον κώδικα.

474
00:29:02,000 --> 00:29:09,000
Ο κώδικας τρέχει πιο γρήγορα, στην πραγματικότητα, 3 φορές πιο γρήγορα αν χρησιμοποιείτε αυτό.

475
00:29:09,000 --> 00:29:11,000
Μάθαμε επίσης για και και ή.

476
00:29:11,000 --> 00:29:15,000
Είμαι δεν πρόκειται να περάσει μέσα από αυτό, επειδή Lexi ήδη μιλήσει γι 'αυτούς.

477
00:29:15,000 --> 00:29:17,000
Είναι ακριβώς οι && και | χειριστή |.

478
00:29:17,000 --> 00:29:21,000
>> Το μόνο που θα πω είναι να είστε προσεκτικοί όταν έχετε 3 συνθήκες.

479
00:29:21,000 --> 00:29:24,000
Χρησιμοποιήστε παρενθέσεις γιατί είναι πολύ συγκεχυμένη, όταν έχετε μια κατάσταση

480
00:29:24,000 --> 00:29:27,000
και ένα άλλο ή ένα άλλο.

481
00:29:27,000 --> 00:29:30,000
Χρησιμοποιήστε παρενθέσεις μόνο για να είναι σίγουρος ότι οι συνθήκες σας έχουν νόημα

482
00:29:30,000 --> 00:29:34,000
γιατί σε αυτή την περίπτωση, για παράδειγμα, μπορείτε να φανταστείτε ότι

483
00:29:34,000 --> 00:29:38,000
θα μπορούσε να είναι η πρώτη κατάσταση και η μία ή η άλλη

484
00:29:38,000 --> 00:29:41,000
ή οι 2 συνθήκες συνδυάζονται σε ένα και

485
00:29:41,000 --> 00:29:45,000
ή ο τρίτος, έτσι απλά να είστε προσεκτικοί.

486
00:29:45,000 --> 00:29:48,000
Και τέλος, μιλήσαμε σχετικά με τους διακόπτες.

487
00:29:48,000 --> 00:29:53,000
Ένας διακόπτης είναι πολύ χρήσιμο όταν έχετε μια μεταβλητή.

488
00:29:53,000 --> 00:29:55,000
Ας πούμε ότι έχετε μια μεταβλητή, όπως n

489
00:29:55,000 --> 00:29:59,000
που μπορεί να είναι 0, 1, ή 2, και για κάθε μία από αυτές τις περιπτώσεις

490
00:29:59,000 --> 00:30:01,000
θα πάμε για να εκτελέσει μια εργασία.

491
00:30:01,000 --> 00:30:04,000
Μπορείτε να πείτε αλλάξετε τη μεταβλητή, και αυτό δείχνει ότι

492
00:30:04,000 --> 00:30:08,000
η αξία είναι τότε σαν τιμή1 Πάω να το κάνετε αυτό,

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

494
00:30:12,000 --> 00:30:15,000
ικανοποιημένοι γιατί ήδη ότι η υπόθεση

495
00:30:15,000 --> 00:30:20,000
και στη συνέχεια value2 και ούτω καθεξής, και μπορώ επίσης να έχουν ένα διακόπτη προεπιλογή.

496
00:30:20,000 --> 00:30:24,000
Αυτό σημαίνει ότι αν δεν πληροί καμία από τις περιπτώσεις που είχα

497
00:30:24,000 --> 00:30:29,000
ότι θα πάω να κάνω κάτι άλλο, αλλά αυτό είναι προαιρετικό.

498
00:30:29,000 --> 00:30:36,000
Αυτό είναι όλα για μένα. Τώρα, ας ρίξουμε Tommy.

499
00:30:36,000 --> 00:30:41,000
Εντάξει, αυτό πρόκειται να είναι εβδομάδα 3-ish.

500
00:30:41,000 --> 00:30:45,000
Αυτά είναι μερικά από τα θέματα που θα πρέπει να καλύπτει, crypto, το πεδίο εφαρμογής, πίνακες, κ.λπ..

501
00:30:45,000 --> 00:30:49,000
Απλά μια γρήγορη λέξη για crypto. Εμείς δεν πρόκειται να σφυρί το σπίτι.

502
00:30:49,000 --> 00:30:52,000
>> Το κάναμε αυτό στην PSET 2, αλλά για το κουίζ βεβαιωθείτε ότι γνωρίζετε τη διαφορά

503
00:30:52,000 --> 00:30:54,000
μεταξύ του Καίσαρα κρυπτογράφησης και τον αλγόριθμο Vigenere,

504
00:30:54,000 --> 00:30:57,000
πως και οι δύο από αυτούς τους αλγόριθμους κρυπτογράφησης και το έργο αυτό είναι σαν να κρυπτογραφήσετε

505
00:30:57,000 --> 00:30:59,000
αποκρυπτογραφήσει το κείμενο και τη χρήση αυτών των 2 αλγόριθμους κρυπτογράφησης.

506
00:30:59,000 --> 00:31:03,000
Θυμηθείτε, η Caesar cipher περιστρέφεται απλά κάθε χαρακτήρα κατά το ίδιο ποσό,

507
00:31:03,000 --> 00:31:06,000
φροντίζοντας να mod με τον αριθμό των γραμμάτων του αλφαβήτου.

508
00:31:06,000 --> 00:31:09,000
Και το κρυπτογράφημα Vigenere, από την άλλη πλευρά, περιστρέφει κάθε χαρακτήρα

509
00:31:09,000 --> 00:31:12,000
από ένα διαφορετικό ποσό, έτσι αντί να πει

510
00:31:12,000 --> 00:31:15,000
κάθε χαρακτήρα περιστρέφεται κατά 3 Vigenere θα εναλλάσσονται κάθε χαρακτήρα

511
00:31:15,000 --> 00:31:17,000
από ένα διαφορετικό ποσό, ανάλογα με κάποια λέξη-κλειδί

512
00:31:17,000 --> 00:31:20,000
όπου κάθε γράμμα τη λέξη-κλειδί αντιπροσωπεύει κάποια διαφορετική ποσότητα

513
00:31:20,000 --> 00:31:26,000
για να περιστρέψετε το κείμενο με σαφή.

514
00:31:26,000 --> 00:31:28,000
Ας μιλήσουμε πρώτα για την εμβέλεια των μεταβλητών.

515
00:31:28,000 --> 00:31:30,000
Υπάρχουν 2 διαφορετικοί τύποι των μεταβλητών.

516
00:31:30,000 --> 00:31:33,000
Έχουμε τοπικές μεταβλητές, και αυτές πρόκειται να οριστεί

517
00:31:33,000 --> 00:31:36,000
έξω από τις κύριες ή έξω από οποιαδήποτε λειτουργία ή μπλοκ,

518
00:31:36,000 --> 00:31:39,000
και αυτοί θα είναι προσβάσιμοι σε οποιοδήποτε σημείο του προγράμματός σας.

519
00:31:39,000 --> 00:31:41,000
Αν έχετε μια λειτουργία και στη λειτουργία είναι ένας βρόχος, ενώ

520
00:31:41,000 --> 00:31:44,000
η μεγάλη παγκόσμια μεταβλητή είναι προσβάσιμη παντού.

521
00:31:44,000 --> 00:31:48,000
Μια τοπική μεταβλητή, από την άλλη πλευρά, είναι scoped στον τόπο όπου ορίζεται.

522
00:31:48,000 --> 00:31:53,000
>> Αν έχετε μια λειτουργία εδώ, για παράδειγμα, έχουμε αυτή την συνάρτηση g,

523
00:31:53,000 --> 00:31:56,000
και στο εσωτερικό της g υπάρχει μια μεταβλητή που ονομάζεται εδώ y,

524
00:31:56,000 --> 00:31:58,000
και αυτό σημαίνει ότι αυτή είναι μια τοπική μεταβλητή.

525
00:31:58,000 --> 00:32:00,000
Ακόμη και αν αυτή η μεταβλητή ονομάζεται y

526
00:32:00,000 --> 00:32:03,000
και αυτή η μεταβλητή ονομάζεται y αυτές τις 2 λειτουργίες

527
00:32:03,000 --> 00:32:06,000
δεν έχουν ιδέα τι είναι οι τοπικές μεταβλητές του άλλου.

528
00:32:06,000 --> 00:32:10,000
Από την άλλη πλευρά, εδώ λέμε int x = 5,

529
00:32:10,000 --> 00:32:12,000
και αυτό είναι εκτός του πεδίου της οποιαδήποτε λειτουργία.

530
00:32:12,000 --> 00:32:16,000
Είναι έξω από το πεδίο των βασικών, έτσι αυτό είναι μια καθολική μεταβλητή.

531
00:32:16,000 --> 00:32:20,000
Αυτό σημαίνει ότι μέσα από αυτές τις 2 λειτουργίες, όταν λέω x - ή x + +

532
00:32:20,000 --> 00:32:26,000
Είμαι πρόσβαση στον ίδιο χ όπου αυτή y και η y είναι διαφορετικές μεταβλητές.

533
00:32:26,000 --> 00:32:30,000
Αυτή είναι η διαφορά ανάμεσα σε μια καθολική μεταβλητή και μια τοπική μεταβλητή.

534
00:32:30,000 --> 00:32:33,000
Όσον αφορά το σχεδιασμό ανησυχεί, μερικές φορές είναι πιθανώς μια καλύτερη ιδέα

535
00:32:33,000 --> 00:32:37,000
για να κρατήσει τις τοπικές μεταβλητές κάθε φορά που μπορείτε ενδεχομένως

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

537
00:32:39,000 --> 00:32:42,000
Εάν έχετε μια δέσμη των λειτουργιών τροποποίηση όλοι το ίδιο πράγμα

538
00:32:42,000 --> 00:32:45,000
μπορείτε να ξεχάσετε ό, τι αν αυτή η λειτουργία αλλάζει κατά λάθος αυτό το παγκόσμιο,

539
00:32:45,000 --> 00:32:47,000
και η άλλη λειτουργία δεν ξέρει γι 'αυτό,

540
00:32:47,000 --> 00:32:50,000
και έχει πάρει αρκετά συγκεχυμένη, όπως μπορείτε να πάρετε περισσότερες κωδικό.

541
00:32:50,000 --> 00:32:53,000
Κρατώντας τις τοπικές μεταβλητές κάθε φορά που μπορείτε ενδεχομένως

542
00:32:53,000 --> 00:32:56,000
είναι μόνο καλός σχεδιασμός.

543
00:32:56,000 --> 00:33:00,000
Πίνακες, θυμηθείτε, είναι απλώς καταλόγους στοιχείων του ίδιου τύπου.

544
00:33:00,000 --> 00:33:04,000
Μέσα από CI δεν μπορεί να έχει μια λίστα όπως 1, 2,0, γειά σου.

545
00:33:04,000 --> 00:33:06,000
Εμείς απλά δεν μπορούμε να το κάνουμε αυτό.

546
00:33:06,000 --> 00:33:11,000
>> Όταν δηλώνουμε μια σειρά σε C όλα τα στοιχεία πρέπει να είναι του ίδιου τύπου.

547
00:33:11,000 --> 00:33:14,000
Εδώ έχω μια σειρά από 3 ακέραιους αριθμούς.

548
00:33:14,000 --> 00:33:18,000
Εδώ έχω το μήκος του πίνακα, αλλά αν είμαι δηλώνοντας ακριβώς σε αυτή τη σύνταξη

549
00:33:18,000 --> 00:33:21,000
όπου μπορώ να προσδιορίσω τι όλα τα στοιχεία είναι ότι δεν χρειάζεται αυτή την τεχνική 3.

550
00:33:21,000 --> 00:33:25,000
Ο compiler είναι αρκετά έξυπνος για να καταλάβω πόσο μεγάλη είναι η σειρά πρέπει να είναι.

551
00:33:25,000 --> 00:33:28,000
Τώρα όταν θέλω να πάρω ή να ορίσετε την αξία ενός πίνακα

552
00:33:28,000 --> 00:33:30,000
αυτή είναι η σύνταξη για να το κάνουμε αυτό.

553
00:33:30,000 --> 00:33:33,000
Αυτό θα τροποποιήσει ουσιαστικά το δεύτερο στοιχείο του πίνακα, διότι, θυμηθείτε,

554
00:33:33,000 --> 00:33:36,000
αρίθμηση ξεκινά από το 0, όχι σε 1.

555
00:33:36,000 --> 00:33:42,000
Αν θέλετε να διαβάσετε αυτή την τιμή μπορώ να πω κάτι σαν int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Ή αν θέλετε να ορίσετε αυτή την τιμή, όπως κάνω εδώ,

557
00:33:44,000 --> 00:33:47,000
Μπορώ να πω array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Εκείνη την εποχή πρόσβαση σε στοιχεία από το δείκτη τους

559
00:33:50,000 --> 00:33:52,000
ή τη θέση τους ή όταν είναι στη συστοιχία,

560
00:33:52,000 --> 00:33:57,000
και ότι η επιχείρηση αρχίζει από το 0.

561
00:33:57,000 --> 00:34:00,000
Μπορούμε επίσης να έχουμε συστοιχίες συστοιχιών,

562
00:34:00,000 --> 00:34:03,000
και αυτό ονομάζεται ένα πολυδιάστατο πίνακα.

563
00:34:03,000 --> 00:34:05,000
Όταν έχουμε μια πολυδιάστατη array

564
00:34:05,000 --> 00:34:07,000
αυτό σημαίνει ότι μπορούμε να έχουμε κάτι σαν γραμμές και στήλες,

565
00:34:07,000 --> 00:34:11,000
και αυτό είναι μόνο ένας τρόπος για οπτικοποίηση αυτό ή το σκέφτομαι.

566
00:34:11,000 --> 00:34:14,000
Όταν έχω μια πολυδιάστατη array αυτό σημαίνει ότι είμαι πρόκειται να ξεκινήσει χρειάζεται

567
00:34:14,000 --> 00:34:17,000
περισσότερο από 1 δείκτη, διότι αν έχω ένα πλέγμα

568
00:34:17,000 --> 00:34:19,000
ακριβώς ό, τι λέει σειρά είστε δεν μας δίνει έναν αριθμό.

569
00:34:19,000 --> 00:34:22,000
Αυτός είναι πραγματικά ακριβώς πρόκειται να μας δώσει μια λίστα των αριθμών.

570
00:34:22,000 --> 00:34:25,000
Ας πούμε ότι έχω αυτή την σειρά εδώ.

571
00:34:25,000 --> 00:34:30,000
Έχω μια σειρά που ονομάζεται πλέγμα, και το λέω αυτό είναι 2 γραμμές και 3 στήλες,

572
00:34:30,000 --> 00:34:32,000
και έτσι αυτό είναι ένας τρόπος απεικόνισης της.

573
00:34:32,000 --> 00:34:37,000
Όταν λέω θέλω να πάρω το στοιχείο στο [1] [2]

574
00:34:37,000 --> 00:34:41,000
τούτο σημαίνει ότι επειδή αυτές είναι σειρές πρώτα και έπειτα στήλες

575
00:34:41,000 --> 00:34:44,000
Πάω να πηδήξει με τη σειρά 1, αφού είπα 1.

576
00:34:44,000 --> 00:34:49,000
>> Στη συνέχεια, Πάω να έρθω εδώ στη στήλη 2, και είμαι πρόκειται να πάρει την τιμή 6.

577
00:34:49,000 --> 00:34:51,000
Κάνετε την αίσθηση;

578
00:34:51,000 --> 00:34:55,000
Πολυδιάστατη πίνακες, να θυμάστε, είναι τεχνικά απλώς μια σειρά από πίνακες.

579
00:34:55,000 --> 00:34:57,000
Μπορούμε να έχουμε πίνακες των συστοιχιών των συστοιχιών.

580
00:34:57,000 --> 00:35:00,000
Μπορούμε να συνεχίσουμε, αλλά πραγματικά ένας τρόπος για να σκεφτεί για

581
00:35:00,000 --> 00:35:03,000
πώς γίνεται αυτό που πρέπει και αυτό που συμβαίνει είναι να απεικονίσει

582
00:35:03,000 --> 00:35:09,000
σε ένα πλέγμα σαν αυτό.

583
00:35:09,000 --> 00:35:12,000
Όταν περνάμε πίνακες στις συναρτήσεις, από όπου και αν πρόκειται να συμπεριφέρονται

584
00:35:12,000 --> 00:35:16,000
λίγο διαφορετικά από ό, τι όταν περνάμε τακτικές μεταβλητές σε συναρτήσεις

585
00:35:16,000 --> 00:35:18,000
όπως το πέρασμα ενός int ή float.

586
00:35:18,000 --> 00:35:21,000
Όταν περνάμε σε ένα int ή char ή οποιοδήποτε από αυτούς τους άλλους τύπους δεδομένων

587
00:35:21,000 --> 00:35:24,000
μόλις πήραμε μια ματιά στο αν η λειτουργία αλλάζει

588
00:35:24,000 --> 00:35:28,000
η τιμή αυτής της μεταβλητής ότι η αλλαγή δεν πρόκειται να διαδώσει τις

589
00:35:28,000 --> 00:35:32,000
στην καλούσα λειτουργία.

590
00:35:32,000 --> 00:35:35,000
Με μια διάταξη, από την άλλη πλευρά, αυτό θα συμβεί.

591
00:35:35,000 --> 00:35:39,000
Αν έχω περάσει σε μια σειρά σε κάποια λειτουργία και ότι η λειτουργία αλλάζει ορισμένα από τα στοιχεία,

592
00:35:39,000 --> 00:35:43,000
όταν έρχομαι πίσω μέχρι και τη λειτουργία που θα ονομάζεται

593
00:35:43,000 --> 00:35:47,000
σειρά μου τώρα πρόκειται να είναι διαφορετική, και το λεξιλόγιο για να

594
00:35:47,000 --> 00:35:50,000
Οι πίνακες είναι περάσει από αναφορά, όπως θα δούμε αργότερα.

595
00:35:50,000 --> 00:35:53,000
Αυτό σχετίζεται με το πώς το έργο δείκτες, όπου οι βασικοί τύποι δεδομένων,

596
00:35:53,000 --> 00:35:55,000
Από την άλλη πλευρά, έχουν περάσει ήδη από αξία.

597
00:35:55,000 --> 00:35:59,000
>> Μπορούμε να σκεφτούμε ότι κάνοντας ένα αντίγραφο κάποιας μεταβλητής και στη συνέχεια περνώντας στο αντίγραφο.

598
00:35:59,000 --> 00:36:01,000
Δεν έχει σημασία τι κάνουμε με αυτή τη μεταβλητή.

599
00:36:01,000 --> 00:36:06,000
Η λειτουργία κλήσης δεν θα πρέπει να γνωρίζει ότι ήταν να αλλάξει.

600
00:36:06,000 --> 00:36:10,000
Οι πίνακες είναι απλά ένα λίγο διαφορετικό σε αυτό το θέμα.

601
00:36:10,000 --> 00:36:13,000
Για παράδειγμα, ως είδομεν, κύριος είναι απλά μια συνάρτηση

602
00:36:13,000 --> 00:36:15,000
που μπορεί να πάρει σε 2 επιχειρήματα.

603
00:36:15,000 --> 00:36:20,000
Το πρώτο επιχείρημα για την κύρια λειτουργία τους είναι argc, ή ο αριθμός των επιχειρημάτων,

604
00:36:20,000 --> 00:36:23,000
και το δεύτερο επιχείρημα ονομάζεται argv,

605
00:36:23,000 --> 00:36:27,000
και αυτοί είναι οι πραγματικές τιμές αυτών των επιχειρημάτων.

606
00:36:27,000 --> 00:36:30,000
Ας πούμε ότι έχω ένα πρόγραμμα που ονομάζεται this.c,

607
00:36:30,000 --> 00:36:34,000
και το λέω αυτό κάνω, και θα πάω για να τρέξει αυτό στη γραμμή εντολών.

608
00:36:34,000 --> 00:36:38,000
Τώρα, για να περάσει σε κάποια επιχειρήματα για να μου πρόγραμμα που ονομάζεται αυτό,

609
00:36:38,000 --> 00:36:42,000
Θα μπορούσα να πω κάτι τέτοιο. / Cs αυτό είναι 50.

610
00:36:42,000 --> 00:36:45,000
Αυτό είναι ό, τι φανταζόμαστε τον David να κάνουμε κάθε μέρα στο τερματικό.

611
00:36:45,000 --> 00:36:48,000
Τώρα, όμως, η κύρια λειτουργία του μέσα σε αυτό το πρόγραμμα

612
00:36:48,000 --> 00:36:52,000
έχει αυτές τις τιμές, έτσι argc είναι 4.

613
00:36:52,000 --> 00:36:56,000
Θα μπορούσε να είναι μια μικρή σύγχυση, γιατί πραγματικά είμαστε μόνο περνώντας μέσα είναι cs 50.

614
00:36:56,000 --> 00:36:58,000
Αυτό είναι μόνο 3.

615
00:36:58,000 --> 00:37:02,000
Αλλά να θυμάστε ότι το πρώτο στοιχείο του argv ή το πρώτο επιχείρημα

616
00:37:02,000 --> 00:37:05,000
είναι το όνομα της συνάρτησης.

617
00:37:05,000 --> 00:37:07,190
Έτσι, αυτό σημαίνει ότι έχουμε 4 πράγματα εδώ,

618
00:37:07,190 --> 00:37:10,530
και το πρώτο στοιχείο πρόκειται να είναι. / αυτό.

619
00:37:10,530 --> 00:37:12,970
Και αυτό θα πρέπει να εκπροσωπούνται ως ένα string.

620
00:37:12,970 --> 00:37:18,590
Στη συνέχεια, τα υπόλοιπα στοιχεία είναι αυτό που πληκτρολογήσατε στο μετά το όνομα του προγράμματος.

621
00:37:18,590 --> 00:37:22,720
Έτσι απλά ως ένα μέρος, όπως κατά πάσα πιθανότητα είδε το PSET 2,

622
00:37:22,720 --> 00:37:28,780
να θυμάστε ότι η σειρά 50 είναι το ακέραιο ≠ 50.

623
00:37:28,780 --> 00:37:32,520
Γι 'αυτό και δεν μπορούμε να πούμε κάτι σαν, "int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Αυτό απλά δεν πρόκειται να έχει νόημα, επειδή αυτό είναι ένα string, και αυτό είναι ένας ακέραιος.

625
00:37:36,470 --> 00:37:38,510
Έτσι, εάν θέλετε να μετατρέψετε μεταξύ των 2, θυμηθείτε, θα πάμε να

626
00:37:38,510 --> 00:37:40,810
έχουν αυτή τη μαγική λειτουργία που ονομάζεται atoi.

627
00:37:40,810 --> 00:37:46,270
Αυτό απαιτεί μια σειρά και επιστρέφει το ακέραιο εκπροσωπούνται στο εσωτερικό της εν λόγω σειράς.

628
00:37:46,270 --> 00:37:48,360
Έτσι, αυτό είναι ένα εύκολο λάθος να κάνει με το κουίζ,

629
00:37:48,360 --> 00:37:51,590
ακριβώς να σκεφτεί ότι αυτό θα είναι αυτόματα το σωστό τύπο.

630
00:37:51,590 --> 00:37:53,860
Αλλά ξέρω ότι αυτά θα είναι πάντα χορδές

631
00:37:53,860 --> 00:38:00,920
ακόμη και αν το string περιέχει μόνο έναν ακέραιο αριθμό ή ένα χαρακτήρα ή ένα πλωτήρα.

632
00:38:00,920 --> 00:38:03,380
Έτσι τώρα ας μιλήσουμε για το χρόνο λειτουργίας.

633
00:38:03,380 --> 00:38:06,700
Όταν έχουμε όλα αυτά τα αλγόριθμους που κάνουν όλα αυτά τα τρελά πράγματα,

634
00:38:06,700 --> 00:38:11,580
γίνεται πραγματικά χρήσιμο να θέσουμε το ερώτημα, "Πόσο καιρό θα πάρει;"

635
00:38:11,580 --> 00:38:15,500
Εκπροσωπούμε ότι με κάτι που ονομάζεται ασυμπτωτικό συμβολισμό.

636
00:38:15,500 --> 00:38:18,430
Έτσι, αυτό σημαίνει ότι - καλά, ας πούμε ότι δίνουμε αλγόριθμος μας

637
00:38:18,430 --> 00:38:20,840
μερικά πραγματικά, πραγματικά, πραγματικά μεγάλη είσοδο.

638
00:38:20,840 --> 00:38:23,840
Θέλουμε να θέσουμε το ερώτημα, «πόσο καιρό είναι αυτό πρόκειται να πάρει;

639
00:38:23,840 --> 00:38:26,370
Πόσα μέτρα προτίθεται να λάβει αλγόριθμος μας να τρέξει

640
00:38:26,370 --> 00:38:29,980
ως συνάρτηση του μεγέθους της εισόδου; "

641
00:38:29,980 --> 00:38:33,080
Έτσι, ο πρώτος τρόπος που μπορούμε να περιγράψουμε τρέχει ο χρόνος είναι με το μεγάλο Ο.

642
00:38:33,080 --> 00:38:35,380
Και αυτό είναι η χειρότερη περίπτωση-το χρόνο μας λειτουργία.

643
00:38:35,380 --> 00:38:38,590
Έτσι, αν θέλουμε να ταξινομήσετε μια σειρά, και δίνουμε τον αλγόριθμο μας μια σειρά

644
00:38:38,590 --> 00:38:41,000
αυτό είναι, κατά φθίνουσα σειρά, όταν θα πρέπει να είναι σε αύξουσα σειρά,

645
00:38:41,000 --> 00:38:43,130
αυτό πρόκειται να είναι η χειρότερη περίπτωση.

646
00:38:43,130 --> 00:38:49,800
Αυτό είναι πάνω μας δεσμεύεται στο μέγιστο μήκος του χρόνου αλγόριθμος μας θα λάβει.

647
00:38:49,800 --> 00:38:54,740
Από την άλλη πλευρά, αυτό το Ω πρόκειται να περιγράψει καλύτερη περίπτωση χρόνου λειτουργίας.

648
00:38:54,740 --> 00:38:58,210
Έτσι, αν έχουμε δώσει μια σειρά ήδη ταξινομημένο σε ένα αλγόριθμο ταξινόμησης,

649
00:38:58,210 --> 00:39:00,940
πόσο καιρό θα πάρει για να το τακτοποιήσουμε;

650
00:39:00,940 --> 00:39:06,610
Και αυτό, στη συνέχεια, περιγράφει ένα κάτω όριο για χρόνο λειτουργίας.

651
00:39:06,610 --> 00:39:10,980
Τόσο εδώ είναι μερικά μόνο από τις λέξεις που περιγράφουν μερικές φορές κοινή λειτουργία.

652
00:39:10,980 --> 00:39:13,120
Αυτά είναι σε αύξουσα σειρά.

653
00:39:13,120 --> 00:39:16,060
Ο ταχύτερος χρόνος εκτέλεσης έχουμε ονομάζεται σταθερή.

654
00:39:16,060 --> 00:39:19,800
>> Αυτό σημαίνει ότι δεν έχει σημασία πόσο πολλά στοιχεία που δίνουμε αλγόριθμος μας,

655
00:39:19,800 --> 00:39:22,280
Δεν έχει σημασία πόσο μεγάλο είναι σειρά μας, διαλογή

656
00:39:22,280 --> 00:39:26,510
ή να κάνει ό, τι κάνουμε στη συστοιχία θα είναι πάντα το ίδιο χρονικό διάστημα.

657
00:39:26,510 --> 00:39:30,270
Έτσι μπορούμε να αντιπροσωπεύει ότι μόνο με ένα 1, η οποία είναι μια σταθερά.

658
00:39:30,270 --> 00:39:32,410
Εξετάσαμε επίσης λογαριθμική χρόνο εκτέλεσης.

659
00:39:32,410 --> 00:39:34,800
Έτσι, κάτι σαν δυαδική αναζήτηση είναι λογαριθμική,

660
00:39:34,800 --> 00:39:37,140
όπου θα κοπεί το πρόβλημα στο μισό κάθε φορά

661
00:39:37,140 --> 00:39:40,970
και τότε τα πράγματα απλά να πάρει υψηλότερη από εκεί.

662
00:39:40,970 --> 00:39:43,580
Και αν είστε γραπτώς ποτέ O κάθε παραγοντικό αλγορίθμου,

663
00:39:43,580 --> 00:39:47,850
τότε μάλλον δεν θα πρέπει να θεωρούν αυτό ως εργασία ημέρας σας.

664
00:39:47,850 --> 00:39:53,910
Όταν συγκρίνουμε τους χρόνους εκτέλεσης είναι σημαντικό να έχουμε κατά νου αυτά τα πράγματα.

665
00:39:53,910 --> 00:39:57,760
Έτσι, αν έχω έναν αλγόριθμο που είναι O (n), και κάποιος άλλος

666
00:39:57,760 --> 00:40:03,590
έχει ένας αλγόριθμος του O (2n) αυτά είναι πραγματικά ασυμπτωτικά ισοδύναμη.

667
00:40:03,590 --> 00:40:06,590
Έτσι, αν φανταζόμαστε n να είναι ένα μεγάλο αριθμό, όπως eleventy δισ. ευρώ:

668
00:40:06,590 --> 00:40:13,090
έτσι όταν είμαστε συγκρίνοντας eleventy δισεκατομμύρια κάτι σαν eleventy + 3 δισ.,

669
00:40:13,090 --> 00:40:17,640
3 ξαφνικά ότι δεν κάνει πραγματικά μια μεγάλη διαφορά πια.

670
00:40:17,640 --> 00:40:20,980
Γι 'αυτό θα πάμε να αρχίσουμε να εξετάζουμε αυτά τα πράγματα να είναι ισοδύναμες.

671
00:40:20,980 --> 00:40:24,220
Έτσι τα πράγματα, όπως αυτές τις σταθερές εδώ, υπάρχει 2 χ αυτό, ή την προσθήκη ενός 3,

672
00:40:24,220 --> 00:40:27,180
αυτά είναι μόνο σταθερές, και αυτά που πρόκειται να πέσουν επάνω.

673
00:40:27,180 --> 00:40:32,480
Έτσι ώστε είναι ο λόγος όλων των 3 αυτών των χρόνων λειτουργίας είναι το ίδιο με το να λέμε ότι είναι O (n).

674
00:40:32,480 --> 00:40:37,490
Ομοίως, σε περίπτωση που έχουμε άλλες 2 φορές τρέξιμο, ας πούμε O (n ³ + 2n ²), μπορούμε να προσθέσουμε

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, και στη συνέχεια έχουμε ένα άλλο χρόνο εκτέλεσης που είναι μόνο O (n ³).

676
00:40:42,070 --> 00:40:46,290
πάλι, αυτά είναι το ίδιο πράγμα, επειδή αυτά - αυτές δεν είναι το ίδιο.

677
00:40:46,290 --> 00:40:49,840
Αυτά είναι τα ίδια πράγματα, λυπάμαι. Έτσι, αυτά είναι τα ίδια, διότι

678
00:40:49,840 --> 00:40:53,090
this ³ n πρόκειται να κυριαρχούν σε αυτή την 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Τι δεν είναι το ίδιο πράγμα είναι αν έχουμε τρέξει φορές σαν O (n ³) και Ο (n ²)

680
00:40:59,130 --> 00:41:02,820
επειδή αυτό ³ n είναι πολύ μεγαλύτερο από αυτό ² n.

681
00:41:02,820 --> 00:41:05,470
Έτσι, αν έχουμε εκθέτες, ξαφνικά αυτό αρχίζει να έχει σημασία,

682
00:41:05,470 --> 00:41:08,280
αλλά όταν είμαστε ακριβώς που ασχολούνται με παράγοντες όπως είμαστε εδώ,

683
00:41:08,280 --> 00:41:12,810
τότε δεν πρόκειται να έχει σημασία γιατί ακριβώς πρόκειται να πέσει έξω.

684
00:41:12,810 --> 00:41:16,760
Ας ρίξουμε μια ματιά σε μερικά από τους αλγόριθμους που έχουμε δει μέχρι στιγμής

685
00:41:16,760 --> 00:41:19,260
και να μιλήσουμε για το χρόνο εκτέλεσης τους.

686
00:41:19,260 --> 00:41:23,850
Ο πρώτος τρόπος για να ψάχνει για έναν αριθμό σε μια λίστα, που είδαμε, ήταν γραμμική αναζήτηση.

687
00:41:23,850 --> 00:41:26,950
Και η εφαρμογή της γραμμικής αναζήτησης είναι εξαιρετικά απλή.

688
00:41:26,950 --> 00:41:30,490
Έχουμε μόνο μια λίστα, και θα πάμε να δούμε κάθε στοιχείο στη λίστα

689
00:41:30,490 --> 00:41:34,260
μέχρι να βρούμε τον αριθμό που ψάχνουμε.

690
00:41:34,260 --> 00:41:38,370
Έτσι αυτό σημαίνει ότι στη χειρότερη περίπτωση, αυτό το O (n).

691
00:41:38,370 --> 00:41:40,860
Και η χειρότερη περίπτωση εδώ θα μπορούσε να είναι εάν το στοιχείο είναι

692
00:41:40,860 --> 00:41:45,710
το τελευταίο στοιχείο, στη συνέχεια, χρησιμοποιώντας γραμμική αναζήτηση πρέπει να εξετάσουμε κάθε στοιχείο

693
00:41:45,710 --> 00:41:50,180
μέχρι να φτάσουμε στο τελευταίο, ώστε να γνωρίζουν ότι στην πραγματικότητα ήταν στη λίστα.

694
00:41:50,180 --> 00:41:52,910
Δεν μπορούμε απλά να εγκαταλείψει στα μισά του δρόμου και να πει, "Είναι πιθανόν να μην είναι εκεί."

695
00:41:52,910 --> 00:41:55,980
Με γραμμική αναζήτηση θα πρέπει να εξετάσουμε το όλο θέμα.

696
00:41:55,980 --> 00:41:59,090
Η καλύτερη περίπτωση χρόνου τρέξιμο, από την άλλη πλευρά, είναι σταθερή

697
00:41:59,090 --> 00:42:04,200
γιατί στην καλύτερη περίπτωση το στοιχείο που ψάχνουμε είναι μόνο το πρώτο στη λίστα.

698
00:42:04,200 --> 00:42:08,930
Γι 'αυτό πρόκειται να μας πάρει ακριβώς 1 βήμα, δεν έχει σημασία πόσο μεγάλη είναι η λίστα είναι

699
00:42:08,930 --> 00:42:12,140
αν ψάχνουμε για το πρώτο στοιχείο κάθε φορά.

700
00:42:12,140 --> 00:42:15,390
>> Έτσι, όταν κάνετε αναζήτηση, να θυμάστε, δεν απαιτεί ότι η λίστα μας είναι ταξινομημένο.

701
00:42:15,390 --> 00:42:19,430
Επειδή είμαστε απλώς πρόκειται να κοιτάξουν πέρα ​​από κάθε στοιχείο, και αυτό δεν έχει τόση σημασία

702
00:42:19,430 --> 00:42:23,560
Για ποιο αυτά τα στοιχεία είναι μέσα

703
00:42:23,560 --> 00:42:28,110
Μια πιο ευφυή αλγόριθμο αναζήτησης είναι κάτι σαν δυαδική αναζήτηση.

704
00:42:28,110 --> 00:42:31,500
Θυμηθείτε, η εφαρμογή της δυαδικής αναζήτησης είναι όταν πάμε να

705
00:42:31,500 --> 00:42:34,320
κρατήσει κοιτάζοντας την μέση της λίστας.

706
00:42:34,320 --> 00:42:38,000
Και επειδή ψάχνουμε στο κέντρο, θα απαιτήσει ότι η λίστα είναι ταξινομημένη

707
00:42:38,000 --> 00:42:40,580
ή αλλιώς δεν ξέρουμε όπου η μεσαία είναι, και πρέπει να κοιτάξουν πέρα ​​από

708
00:42:40,580 --> 00:42:44,480
ολόκληρη η λίστα να το βρείτε, και στη συνέχεια, σε αυτό το σημείο είμαστε απλά χάσιμο χρόνου.

709
00:42:44,480 --> 00:42:48,480
Έτσι, αν έχουμε μια ταξινομημένη λίστα και βρίσκουμε τη μέση, θα πάμε να συγκρίνουμε τη μέση

710
00:42:48,480 --> 00:42:51,590
με το στοιχείο που ψάχνουμε.

711
00:42:51,590 --> 00:42:54,640
Εάν είναι πάρα πολύ υψηλή, τότε μπορούμε να ξεχάσουμε το δεξί μισό

712
00:42:54,640 --> 00:42:57,810
γιατί ξέρουμε ότι αν στοιχείο μας είναι ήδη πολύ υψηλή

713
00:42:57,810 --> 00:43:01,080
και πάντα στα δεξιά αυτού του στοιχείου είναι ακόμη υψηλότερο,

714
00:43:01,080 --> 00:43:02,760
τότε δεν χρειάζεται να κοιτάξουμε πια εκεί.

715
00:43:02,760 --> 00:43:05,430
Όταν από την άλλη πλευρά, εάν το στοιχείο μας είναι πολύ χαμηλή,

716
00:43:05,430 --> 00:43:08,700
γνωρίζουμε τα πάντα στα αριστερά του εν λόγω στοιχείου είναι επίσης πολύ χαμηλή,

717
00:43:08,700 --> 00:43:11,390
γι 'αυτό δεν κάνει πραγματικά νόημα να δούμε εκεί, είτε.

718
00:43:11,390 --> 00:43:15,760
Με αυτό τον τρόπο, με κάθε βήμα και κάθε φορά που κοιτάζουμε στο μέσο της λίστας,

719
00:43:15,760 --> 00:43:19,060
θα πάμε να κόψει το πρόβλημά μας κατά το ήμισυ, επειδή ξαφνικά ξέρουμε

720
00:43:19,060 --> 00:43:23,040
ένα σωρό αριθμούς που δεν μπορεί να είναι αυτός που ψάχνουμε.

721
00:43:23,040 --> 00:43:26,950
>> Σε ψευδοκώδικα αυτό θα δούμε κάτι σαν αυτό,

722
00:43:26,950 --> 00:43:30,990
και επειδή είμαστε κοπή της λίστας στο μισό κάθε φορά,

723
00:43:30,990 --> 00:43:34,920
στη χειρότερη περίπτωση άλματα μας χρόνος λειτουργίας από γραμμική σε λογαριθμική.

724
00:43:34,920 --> 00:43:39,260
Έτσι ξαφνικά έχουμε log-in βήματα για να βρει ένα στοιχείο σε μια λίστα.

725
00:43:39,260 --> 00:43:42,460
Η καλύτερη περίπτωση-χρόνο που τρέχει, όμως, εξακολουθεί να είναι σταθερό

726
00:43:42,460 --> 00:43:45,180
γιατί τώρα, ας πούμε ότι το στοιχείο που ψάχνουμε είναι

727
00:43:45,180 --> 00:43:48,380
πάντα την ακριβή μέση της αρχικής λίστας.

728
00:43:48,380 --> 00:43:52,080
Γι 'αυτό και μπορούν να αναπτυχθούν λίστα μας τόσο μεγάλο όσο θέλουμε, αλλά αν το στοιχείο που ψάχνουμε είναι στο κέντρο,

729
00:43:52,080 --> 00:43:54,910
τότε αυτό είναι μόνο πρόκειται να μας πάρει 1 βήμα.

730
00:43:54,910 --> 00:44:00,920
Έτσι, γι 'αυτό είμαστε O (log n) και Ω (1) ή σταθερή.

731
00:44:00,920 --> 00:44:04,510
Ας τρέξει πραγματικά δυαδική αναζήτηση σε αυτή τη λίστα.

732
00:44:04,510 --> 00:44:08,020
Ας πούμε ότι ψάχνουμε για το στοιχείο 164.

733
00:44:08,020 --> 00:44:11,650
Το πρώτο πράγμα που θέλουμε να κάνουμε είναι να βρούμε το μέσο αυτού του καταλόγου.

734
00:44:11,650 --> 00:44:15,060
Συμβαίνει ότι το μέσο πρόκειται να πέσει στο μεταξύ αυτών των 2 αριθμών,

735
00:44:15,060 --> 00:44:18,960
οπότε ας πούμε απλώς αυθαίρετα, κάθε φορά που πέφτει το μέσο σημείο μεταξύ 2 αριθμών,

736
00:44:18,960 --> 00:44:21,150
ας στρογγυλοποιεί προς τα πάνω.

737
00:44:21,150 --> 00:44:24,330
Εμείς απλά πρέπει να βεβαιωθείτε ότι το κάνουμε αυτό σε κάθε βήμα του τρόπου.

738
00:44:24,330 --> 00:44:29,040
Έτσι θα πάμε για να στρογγυλοποιεί προς τα πάνω, και θα πάμε να πούμε ότι 161 είναι η μέση της λίστας μας.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, και κάθε στοιχείο προς τα αριστερά του 161

740
00:44:34,640 --> 00:44:39,120
Είναι επίσης <164, έτσι γνωρίζουμε ότι δεν πρόκειται να μας βοηθήσει καθόλου

741
00:44:39,120 --> 00:44:42,690
να αρχίσει να ψάχνει πάνω από εδώ, επειδή το στοιχείο που ψάχνουμε δεν μπορεί να είναι εκεί.

742
00:44:42,690 --> 00:44:47,060
Έτσι, αυτό που μπορούμε να κάνουμε είναι απλά μπορούμε να ξεχάσουμε το όλο αριστερό μισό του πίνακα,

743
00:44:47,060 --> 00:44:51,700
και τώρα θεωρούν μόνο από το δικαίωμα του 161 και μετά.

744
00:44:51,700 --> 00:44:54,050
>> Έτσι και πάλι, αυτό είναι το μέσο? Ας απλά στρογγυλοποιεί προς τα πάνω.

745
00:44:54,050 --> 00:44:56,260
Τώρα 175 είναι πάρα πολύ μεγάλο.

746
00:44:56,260 --> 00:44:59,180
Γνωρίζουμε, λοιπόν, ότι δεν πρόκειται να μας βοηθήσει να ψάχνει εδώ ή εδώ,

747
00:44:59,180 --> 00:45:06,610
έτσι ώστε να μπορούμε απλά να ρίξει ότι μακριά, και τελικά θα χτυπήσει το 164.

748
00:45:06,610 --> 00:45:10,560
Οποιεσδήποτε ερωτήσεις σχετικά με δυαδική αναζήτηση;

749
00:45:10,560 --> 00:45:14,180
Ας περάσουμε από την αναζήτηση μέσα από ένα ήδη ταξινομημένο λίστα

750
00:45:14,180 --> 00:45:17,660
να λάβει πραγματικά μια λίστα των αριθμών με οποιαδήποτε σειρά

751
00:45:17,660 --> 00:45:20,960
και να καταστεί η λίστα σε αύξουσα σειρά.

752
00:45:20,960 --> 00:45:24,060
Ο πρώτος αλγόριθμος κοιτάξαμε ονομαζόταν bubble sort.

753
00:45:24,060 --> 00:45:27,300
Και αυτό θα ήταν απλούστερο των αλγορίθμων είδαμε.

754
00:45:27,300 --> 00:45:32,970
Bubble sort λέει ότι όταν οι 2 στοιχεία μέσα στον κατάλογο είναι εκτός τόπου,

755
00:45:32,970 --> 00:45:36,500
που σημαίνει ότι υπάρχει ένας μεγαλύτερος αριθμός προς τα αριστερά από ένα μικρότερο αριθμό,

756
00:45:36,500 --> 00:45:40,190
τότε θα πάμε να τα ανταλλάξουν, διότι αυτό σημαίνει ότι ο κατάλογος θα είναι

757
00:45:40,190 --> 00:45:42,860
"Πιο ταξινομημένο" από ό, τι ήταν πριν.

758
00:45:42,860 --> 00:45:45,180
Και είμαστε ακριβώς πρόκειται να συνεχίσει αυτή τη διαδικασία ξανά και ξανά και ξανά

759
00:45:45,180 --> 00:45:52,100
έως ότου τελικά το είδος στοιχεία της φούσκας στην σωστή θέση τους και έχουμε μια ταξινομημένη λίστα.

760
00:45:52,100 --> 00:45:57,230
>> Ο χρόνος λειτουργίας του αυτό πρόκειται να είναι O (n ²). Γιατί να;

761
00:45:57,230 --> 00:46:00,370
Λοιπόν, επειδή στη χειρότερη περίπτωση, θα πάμε να λάβουν κάθε στοιχείο, και

762
00:46:00,370 --> 00:46:04,570
θα πάμε να καταλήξουμε συγκρίνοντάς την με κάθε άλλο στοιχείο από τη λίστα.

763
00:46:04,570 --> 00:46:08,030
Όμως, στην καλύτερη περίπτωση, έχουμε ήδη ταξινομημένη λίστα, φούσκα είδος του

764
00:46:08,030 --> 00:46:12,230
ακριβώς πρόκειται να περάσουν από μια φορά, ας πούμε "Όχι. Δεν είχα κάνει καμία swaps, έτσι είμαι γίνει."

765
00:46:12,230 --> 00:46:17,410
Έτσι έχουμε μια καλύτερη περίπτωση-χρόνος εκτέλεσης του Ω (n).

766
00:46:17,410 --> 00:46:20,680
Ας τρέξει είδος φούσκα σε μια λίστα.

767
00:46:20,680 --> 00:46:23,560
Ή πρώτα, ας δούμε κάποια ψευδοκώδικα πραγματικά γρήγορα.

768
00:46:23,560 --> 00:46:28,160
Θέλουμε να πούμε ότι θέλετε να παρακολουθείτε, σε κάθε επανάληψη του βρόχου,

769
00:46:28,160 --> 00:46:32,190
να παρακολουθείτε από το αν ή δεν αλλάξαμε κάποια στοιχεία.

770
00:46:32,190 --> 00:46:37,610
Έτσι, ο λόγος για αυτό είναι, θα πάμε να σταματήσει όταν δεν έχουμε ανταλλάξει κάποια στοιχεία.

771
00:46:37,610 --> 00:46:41,980
Έτσι, στο ξεκίνημα του βρόχου μας δεν έχουμε ανταλλάξει τίποτα, γι 'αυτό θα πω ότι είναι ψευδείς.

772
00:46:41,980 --> 00:46:47,170
Τώρα, θα πάμε να περάσουν από τη λίστα και συγκρίνετε στοιχείου i στο στοιχείο i + 1

773
00:46:47,170 --> 00:46:50,310
και αν είναι η περίπτωση ότι υπάρχει ένας μεγαλύτερος αριθμός στα αριστερά του μικρότερου αριθμού,

774
00:46:50,310 --> 00:46:52,310
τότε είμαστε ακριβώς πρόκειται να τα ανταλλάξουν.

775
00:46:52,310 --> 00:46:54,490
>> Και μετά θα πάμε να θυμόμαστε ότι αντάλλαξαν ένα στοιχείο.

776
00:46:54,490 --> 00:46:58,900
Αυτό σημαίνει ότι θα πρέπει να περάσουν από τη λίστα τουλάχιστον 1 φορά

777
00:46:58,900 --> 00:47:02,160
επειδή η κατάσταση στην οποία σταματήσαμε είναι όταν ολόκληρη η λίστα είναι ήδη ταξινομημένο,

778
00:47:02,160 --> 00:47:04,890
που σημαίνει ότι δεν έχουν γίνει οποιεσδήποτε συμφωνίες ανταλλαγής.

779
00:47:04,890 --> 00:47:09,960
Οπότε αυτό είναι γιατί κατάστασή μας εδώ κάτω είναι «ενώ ορισμένα στοιχεία έχουν μετατραπεί.

780
00:47:09,960 --> 00:47:13,720
Έτσι τώρα ας εξετάσουμε μόνο αυτό που εκτελείται σε μια λίστα.

781
00:47:13,720 --> 00:47:16,640
Έχω την λίστα 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort πρόκειται να ξεκινήσει σε όλη τη διαδρομή στο αριστερό, και πρόκειται να συγκρίνουν

783
00:47:19,850 --> 00:47:24,700
τα στοιχεία θ, έτσι 0 έως i + 1, η οποία είναι στοιχείο 1.

784
00:47:24,700 --> 00:47:29,020
Είναι πρόκειται να πούμε, και 5> 0, αλλά αυτή τη στιγμή 5 είναι προς τα αριστερά,

785
00:47:29,020 --> 00:47:32,500
γι 'αυτό πρέπει να ανταλλάξουν το 5 και το 0.

786
00:47:32,500 --> 00:47:35,470
Όταν τα ανταλλάξουν, ξαφνικά να βρω αυτό το διαφορετικό κατάλογο.

787
00:47:35,470 --> 00:47:38,260
Τώρα 5> 1, έτσι θα πάμε να τα ανταλλάξουν.

788
00:47:38,260 --> 00:47:42,160
5 δεν είναι> 6, γι 'αυτό δεν χρειάζεται να κάνετε τίποτα εδώ.

789
00:47:42,160 --> 00:47:46,690
Αλλά 6> 4, γι 'αυτό πρέπει να ανταλλάξουν.

790
00:47:46,690 --> 00:47:49,740
Και πάλι, θα πρέπει να διατρέχουν το σύνολο της λίστα για να ανακαλύψουν τελικά

791
00:47:49,740 --> 00:47:52,330
ότι αυτά είναι εκτός λειτουργίας? εμείς τους ανταλλάξουν,

792
00:47:52,330 --> 00:47:57,120
και σε αυτό το σημείο θα πρέπει να τρέχει μέσα από τη λίστα 1 φορά

793
00:47:57,120 --> 00:48:05,390
για να βεβαιωθείτε ότι όλα είναι σε τάξη, και σε αυτό το σημείο είδος φούσκα έχει ολοκληρωθεί.

794
00:48:05,390 --> 00:48:10,720
Ένα διαφορετικό αλγόριθμο για τη λήψη ορισμένων στοιχείων και τη διαλογή τους είναι το είδος επιλογής.

795
00:48:10,720 --> 00:48:15,740
Η ιδέα πίσω από την επιλογή του είδους είναι ότι θα πάμε για να δημιουργήσουν μια ταξινομημένο τμήμα της λίστας

796
00:48:15,740 --> 00:48:18,150
1 στοιχείο τη φορά.

797
00:48:18,150 --> 00:48:23,170
>> Και ο τρόπος που θα πάμε να το κάνουμε αυτό είναι με τη δημιουργία το αριστερό τμήμα της λίστας.

798
00:48:23,170 --> 00:48:27,510
Και βασικά, κάθε - σε κάθε βήμα, θα πάμε να λάβει το μικρότερο στοιχείο που έχουμε μείνει

799
00:48:27,510 --> 00:48:32,310
το οποίο δεν έχει ακόμα ταξινομημένο, και θα πάμε για να το μετακινήσετε σε αυτή ταξινομημένο τμήμα.

800
00:48:32,310 --> 00:48:35,850
Αυτό σημαίνει ότι πρέπει να βρούμε συνεχώς το ελάχιστο στοιχείο αδιαχώριστα

801
00:48:35,850 --> 00:48:40,720
και στη συνέχεια να λάβει αυτό το ελάχιστο στοιχείο και να ανταλλάξει με ό, τι

802
00:48:40,720 --> 00:48:45,090
αριστερά-πλέον στοιχείο που δεν είναι ταξινομημένο.

803
00:48:45,090 --> 00:48:50,890
Ο χρόνος τρέχει από αυτό πρόκειται να είναι O (n ²), γιατί στη χειρότερη περίπτωση

804
00:48:50,890 --> 00:48:55,070
πρέπει να συγκρίνουμε κάθε μεμονωμένο στοιχείο σε κάθε άλλο στοιχείο.

805
00:48:55,070 --> 00:48:59,250
Γιατί λέμε ότι αν αρχίσουμε στο αριστερό μισό του πίνακα, χρειαζόμαστε

806
00:48:59,250 --> 00:49:02,970
να περάσει ολόκληρο το δεξί τμήμα για να βρείτε το μικρότερο στοιχείο.

807
00:49:02,970 --> 00:49:05,430
Και τότε, πάλι, θα πρέπει να πάει πέρα ​​από το ολόκληρο τμήμα δεξιά και

808
00:49:05,430 --> 00:49:08,210
συνεχίστε κατά τη διάρκεια αυτής ξανά και ξανά και ξανά.

809
00:49:08,210 --> 00:49:11,350
Αυτό πρόκειται να είναι n ². Εμείς πάμε να χρειάζονται ένα για βρόχο μέσα από ένα άλλο για βρόχο

810
00:49:11,350 --> 00:49:13,350
γεγονός που υποδηλώνει n ².

811
00:49:13,350 --> 00:49:16,530
Στην καλύτερη περίπτωση σκέψης, ας πούμε ότι δίνουμε ένα ήδη ταξινομημένο λίστα?

812
00:49:16,530 --> 00:49:19,270
στην πραγματικότητα δεν κάνουν καθόλου καλύτερα από ό, τι n ².

813
00:49:19,270 --> 00:49:21,730
Επειδή η επιλογή του είδους δεν έχει καμία δυνατότητα να γνωρίζει ότι

814
00:49:21,730 --> 00:49:25,540
το ελάχιστο στοιχείο είναι ακριβώς το ένα που τυχαίνει να είναι κοιτάζοντας.

815
00:49:25,540 --> 00:49:28,970
Θα πρέπει ακόμα να βεβαιωθείτε ότι αυτό είναι πραγματικά το ελάχιστο.

816
00:49:28,970 --> 00:49:31,670
>> Και ο μόνος τρόπος για να βεβαιωθείτε ότι είναι το ελάχιστο, χρησιμοποιώντας αυτόν τον αλγόριθμο,

817
00:49:31,670 --> 00:49:34,640
είναι να εξετάσουμε κάθε στοιχείο και πάλι.

818
00:49:34,640 --> 00:49:38,420
Έτσι, στην πραγματικότητα, αν το δώσει - αν δώσεις ένα είδος επιλογής ήδη ταξινομημένο κατάλογο,

819
00:49:38,420 --> 00:49:42,720
δεν πρόκειται να κάνει καθόλου καλύτερα από ό, τι του δίνει μια λίστα που δεν είναι ταξινομημένο ακόμα.

820
00:49:42,720 --> 00:49:46,320
Με την ευκαιρία, αν συμβαίνει να είναι η περίπτωση που κάτι είναι O (κάτι)

821
00:49:46,320 --> 00:49:50,640
και το ωμέγα του κάτι, μπορούμε να πούμε πιο λακωνικά ότι είναι κάτι θ του.

822
00:49:50,640 --> 00:49:52,760
Έτσι, αν βλέπετε ότι έρχονται οπουδήποτε, αυτό είναι τι σημαίνει αυτό ακριβώς.

823
00:49:52,760 --> 00:49:57,580
>> Αν κάτι είναι θήτα του ν ², είναι τόσο μεγάλο Ο (n ²) και Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Επομένως, καλή περίπτωση και στη χειρότερη περίπτωση, δεν κάνει τη διαφορά,

825
00:49:59,790 --> 00:50:04,400
ο αλγόριθμος πρόκειται να κάνει το ίδιο πράγμα κάθε φορά.

826
00:50:04,400 --> 00:50:06,610
Έτσι, αυτό είναι ό, τι ψευδοκώδικα για την επιλογή του είδους θα μπορούσε να μοιάζει.

827
00:50:06,610 --> 00:50:10,630
Είμαστε ουσιαστικά πρόκειται να πω ότι θέλω να επαναλάβει πάνω από τη λίστα

828
00:50:10,630 --> 00:50:15,180
από αριστερά προς τα δεξιά, και σε κάθε επανάληψη του βρόχου, Πάω να μετακινήσετε

829
00:50:15,180 --> 00:50:19,780
το ελάχιστο στοιχείο σ 'αυτό το τμήμα με ταξινόμηση του καταλόγου.

830
00:50:19,780 --> 00:50:23,260
Και από τη στιγμή που κινούνται κάτι εκεί, ποτέ δεν πρέπει να δούμε ξανά αυτό το στοιχείο.

831
00:50:23,260 --> 00:50:28,600
Επειδή μόλις έχω ανταλλάξει ένα στοιχείο προς τα αριστερά τμήμα της λίστας, είναι ταξινομημένο

832
00:50:28,600 --> 00:50:32,600
γιατί κάνουμε ό, τι σε αύξουσα σειρά χρησιμοποιώντας ελάχιστα.

833
00:50:32,600 --> 00:50:38,740
Έτσι είπαμε, εντάξει, είμαστε σε θέση i, και εμείς πρέπει να εξετάσουμε όλα τα στοιχεία

834
00:50:38,740 --> 00:50:42,260
στα δεξιά του i για να βρείτε το ελάχιστο.

835
00:50:42,260 --> 00:50:46,150
Έτσι ώστε σημαίνει ότι θέλουμε να δούμε από το i + 1 στο τέλος της λίστας.

836
00:50:46,150 --> 00:50:51,610
Και τώρα, αν το στοιχείο ότι αυτή τη στιγμή εξετάζουμε είναι μικρότερη από την ελάχιστη μας μέχρι σήμερα,

837
00:50:51,610 --> 00:50:54,190
που, θυμηθείτε, ξεκινάμε από το ελάχιστο να είναι μόνο

838
00:50:54,190 --> 00:50:57,020
ανεξάρτητα από το στοιχείο είμαστε αυτή τη στιγμή? Θα υποθέσουμε ότι αυτό είναι το ελάχιστο.

839
00:50:57,020 --> 00:51:00,270
Αν βρω ένα στοιχείο που είναι μικρότερο από αυτό, τότε θα πάω να πω, εντάξει,

840
00:51:00,270 --> 00:51:02,700
καλά, έχω βρει ένα νέο ελάχιστο.

841
00:51:02,700 --> 00:51:06,080
Πάω να θυμηθείτε πού ήταν αυτό το ελάχιστο.

842
00:51:06,080 --> 00:51:09,560
>> Μέχρι τώρα, από τη στιγμή που έχω περάσει αυτό το δικαίωμα αδιαχώριστα τμήμα,

843
00:51:09,560 --> 00:51:16,690
Μπορώ να πω ότι είμαι πρόκειται να ανταλλάξει το ελάχιστο στοιχείο με το στοιχείο που είναι σε θέση i.

844
00:51:16,690 --> 00:51:21,100
Αυτό πρόκειται να δημιουργήσει λίστα μου, ταξινομημένο τμήμα μου στη λίστα από αριστερά προς τα δεξιά,

845
00:51:21,100 --> 00:51:25,190
και δεν πρέπει ποτέ να δούμε ένα στοιχείο για μια ακόμη φορά ότι είναι σε αυτό το τμήμα.

846
00:51:25,190 --> 00:51:27,930
Μόλις έχουμε άλλαζε.

847
00:51:27,930 --> 00:51:30,260
Ας τρέξει είδος επιλογή σε αυτή τη λίστα.

848
00:51:30,260 --> 00:51:38,220
Το μπλε στοιχείο εδώ θα είναι το i, και το κόκκινο στοιχείο θα είναι το ελάχιστο στοιχείο.

849
00:51:38,220 --> 00:51:41,570
Γι 'αυτό και ξεκινά σε όλη τη διαδρομή στο αριστερό μέρος της λίστας, έτσι ώστε σε 5.

850
00:51:41,570 --> 00:51:44,610
Τώρα πρέπει να βρούμε το ελάχιστο στοιχείο αδιαχώριστα.

851
00:51:44,610 --> 00:51:49,480
Γι 'αυτό και λένε 0 <5, οπότε 0 είναι νέα ελάχιστα μου.

852
00:51:49,480 --> 00:51:53,820
>> Αλλά δεν μπορώ να σταματήσει εκεί, διότι ακόμη και αν μπορούμε να αναγνωρίσουμε ότι το 0 είναι το μικρότερο,

853
00:51:53,820 --> 00:51:59,390
πρέπει να τρέξει μέσα από κάθε άλλο στοιχείο της λίστας για να βεβαιωθείτε.

854
00:51:59,390 --> 00:52:01,760
So 1 είναι μεγαλύτερο, 6 είναι μεγαλύτερο, 4 είναι μεγαλύτερο.

855
00:52:01,760 --> 00:52:05,850
Αυτό σημαίνει ότι μετά την εξέταση όλων αυτών των στοιχείων, έχω αποφασισμένος 0 είναι το μικρότερο.

856
00:52:05,850 --> 00:52:09,800
Γι 'αυτό και πρόκειται να ανταλλάξει το 5 και το 0.

857
00:52:09,800 --> 00:52:15,480
Μόλις ανταλλάξουν ότι, Πάω να πάρετε μια νέα λίστα, και ξέρω ότι ποτέ δεν πρέπει να εξετάσουμε και πάλι ότι 0

858
00:52:15,480 --> 00:52:19,380
γιατί από τη στιγμή που έχω άλλαζε, έχω ταξινομημένο και τελειώσαμε.

859
00:52:19,380 --> 00:52:22,730
Τώρα είναι ακριβώς έτσι συμβαίνει ότι το μπλε στοιχείο είναι και πάλι το 5,

860
00:52:22,730 --> 00:52:26,030
και θα πρέπει να εξετάσουμε το 1, το 6 και το 4 για να καθορίσει ότι 1

861
00:52:26,030 --> 00:52:31,520
είναι το μικρότερο στοιχείο ελάχιστο, οπότε θα ανταλλάξουν το 1 και το 5.

862
00:52:31,520 --> 00:52:36,890
Και πάλι, θα πρέπει να εξετάσουμε - συγκρίνετε το 5 στο 6 και το 4,

863
00:52:36,890 --> 00:52:39,830
και θα πάμε για να ανταλλάξει το 4 και το 5, και, τέλος, να συγκρίνουν

864
00:52:39,830 --> 00:52:45,740
οι 2 αριθμοί και ανταλλαγής τους μέχρι να φτάσουμε ταξινομημένη λίστα μας.

865
00:52:45,740 --> 00:52:49,730
Οποιεσδήποτε ερωτήσεις σχετικά με την επιλογή του είδους;

866
00:52:49,730 --> 00:52:56,420
Εντάξει. Ας προχωρήσουμε στο τελευταίο θέμα εδώ, και αυτό είναι αναδρομή.

867
00:52:56,420 --> 00:52:59,810
>> Αναδρομή, θυμηθείτε, είναι πραγματικά αυτό το πράγμα, όπου μετα μια λειτουργία

868
00:52:59,810 --> 00:53:02,740
επανειλημμένα αυτοαποκαλείται.

869
00:53:02,740 --> 00:53:05,620
Έτσι, σε κάποιο σημείο, ενώ fuction μας καλεί η ίδια επανειλημμένα,

870
00:53:05,620 --> 00:53:10,100
πρέπει να υπάρχει κάποιο σημείο στο οποίο θα σταματήσουμε καλώντας τους εαυτούς μας.

871
00:53:10,100 --> 00:53:13,670
Γιατί αν δεν το κάνουμε αυτό, τότε απλά θα συνεχίσουμε να το κάνουμε αυτό για πάντα,

872
00:53:13,670 --> 00:53:16,660
και το πρόγραμμά μας είναι απλώς δεν πρόκειται να λύσει.

873
00:53:16,660 --> 00:53:19,200
Καλούμε αυτή η κατάσταση η βασική περίπτωση.

874
00:53:19,200 --> 00:53:22,570
Και το βασικό σενάριο λέει ότι, αντί να ζητά μια λειτουργία και πάλι,

875
00:53:22,570 --> 00:53:25,330
Είμαι ακριβώς πρόκειται να επιστρέψει κάποια αξία.

876
00:53:25,330 --> 00:53:28,080
Έτσι, όταν έχουμε επιστρέψει μια τιμή, έχουμε σταματήσει να καλεί τον εαυτό μας,

877
00:53:28,080 --> 00:53:32,550
και το υπόλοιπο των προσκλήσεων που έχουμε κάνει μέχρι τώρα μπορεί να επιστρέψει.

878
00:53:32,550 --> 00:53:36,050
Το αντίθετο του το βασικό σενάριο είναι η αναδρομική περίπτωση.

879
00:53:36,050 --> 00:53:39,050
Και αυτό είναι που θέλουμε να κάνουμε άλλη κλήση στη λειτουργία που είμαστε σήμερα μέσα

880
00:53:39,050 --> 00:53:44,690
Και κατά πάσα πιθανότητα, αν και όχι πάντα, θέλουν να χρησιμοποιούν διαφορετικά επιχειρήματα.

881
00:53:44,690 --> 00:53:48,940
>> Έτσι, αν έχουμε μια λειτουργία που ονομάζεται στ, ζ και ονομάζεται απλά πάρτε 1 επιχείρημα,

882
00:53:48,940 --> 00:53:52,010
και εμείς απλά να κρατήσει καλώντας f (1), f (1), f (1), και είναι ακριβώς έτσι συμβαίνει ότι

883
00:53:52,010 --> 00:53:56,510
το επιχείρημα 1 εμπίπτει σε περίπτωση επαναληπτικής, είμαστε ακόμα ποτέ δεν πρόκειται να σταματήσει.

884
00:53:56,510 --> 00:54:01,620
Ακόμα και αν έχουμε μια βασική περίπτωση, θα πρέπει να βεβαιωθείτε ότι τελικά θα πάμε για να χτυπήσει το βασικό σενάριο.

885
00:54:01,620 --> 00:54:04,250
Δεν κρατήσει μόνο διαμονή σε αυτή την περίπτωση επαναληπτικής.

886
00:54:04,250 --> 00:54:09,870
Σε γενικές γραμμές, όταν εμείς οι ίδιοι αποκαλούν, θα πρόκειται πιθανώς να έχουν ένα διαφορετικό επιχείρημα κάθε φορά.

887
00:54:09,870 --> 00:54:12,700
Εδώ είναι ένα πολύ απλό αναδρομική συνάρτηση.

888
00:54:12,700 --> 00:54:15,090
Έτσι, αυτό θα υπολογιστεί το παραγοντικό ενός αριθμού.

889
00:54:15,090 --> 00:54:17,790
Μέχρι κορυφή εδώ έχουμε περίπτωση βάση μας.

890
00:54:17,790 --> 00:54:22,330
Στην περίπτωση που n ≤ 1, δεν πρόκειται να καλέσει ξανά παραγοντικού.

891
00:54:22,330 --> 00:54:26,490
Εμείς πάμε για να σταματήσει? Είμαστε ακριβώς πρόκειται να επιστρέψει κάποια αξία.

892
00:54:26,490 --> 00:54:30,170
Αν αυτό δεν είναι αλήθεια, τότε θα πάμε για να χτυπήσει αναδρομική περίπτωσή μας.

893
00:54:30,170 --> 00:54:33,550
Σημειώστε εδώ ότι δεν είμαστε ένα απλό τηλεφώνημα στο παραγοντικό (n), γιατί αυτό δεν θα ήταν πολύ χρήσιμη.

894
00:54:33,550 --> 00:54:36,810
Εμείς πάμε για να καλέσει παραγοντικό του κάτι άλλο.

895
00:54:36,810 --> 00:54:40,850
>> Και έτσι μπορείτε να δείτε, αν τελικά περνάμε παραγοντικό (5) ή κάτι,

896
00:54:40,850 --> 00:54:45,900
θα πάμε να καλέσει παραγοντικό (4) και ούτω καθεξής, και τελικά θα πάμε για να χτυπήσει αυτό το βασικό σενάριο.

897
00:54:45,900 --> 00:54:51,730
Έτσι, αυτό φαίνεται καλό. Ας δούμε τι συμβαίνει όταν τρέχουμε στην πραγματικότητα αυτό.

898
00:54:51,730 --> 00:54:57,840
Αυτή είναι η στοίβα, και ας πούμε ότι ο κύριος πρόκειται να καλέσετε τη λειτουργία αυτή με το επιχείρημα (4).

899
00:54:57,840 --> 00:55:02,200
Έτσι, όταν βλέπει και παραγοντικό = 4, θα παραγοντικό να ζητήσει η ίδια.

900
00:55:02,200 --> 00:55:05,010
Τώρα, ξαφνικά, έχουμε παραγοντικό (3).

901
00:55:05,010 --> 00:55:10,780
Έτσι αυτές οι λειτουργίες θα συνεχίσει να αυξάνεται έως ότου τελικά χτυπάμε περίπτωση βάση μας.

902
00:55:10,780 --> 00:55:17,830
Σε αυτό το σημείο, η τιμή επιστροφής της είναι η επιστροφή (nx η τιμή επιστροφής αυτής),

903
00:55:17,830 --> 00:55:21,290
η αξία της επιστροφής είναι nx η τιμή επιστροφής αυτής.

904
00:55:21,290 --> 00:55:23,290
Τελικά θα πρέπει να χτυπήσει κάποιον αριθμό.

905
00:55:23,290 --> 00:55:26,560
Στην κορυφή εδώ, λέμε επιστροφή 1.

906
00:55:26,560 --> 00:55:30,650
Αυτό σημαίνει ότι τη στιγμή που θα επιστρέψει τον αριθμό αυτό, μπορούμε να σκάσει αυτό από τη στοίβα.

907
00:55:30,650 --> 00:55:36,570
Έτσι, αυτό το παραγοντικό (1) γίνεται.

908
00:55:36,570 --> 00:55:41,190
Όταν επιστρέφει 1, αυτό το παραγοντικό (1) επιστρέφει, αυτή η επιστροφή στην 1.

909
00:55:41,190 --> 00:55:46,910
Η τιμή επιστροφής αυτής, θυμηθείτε, ήταν nx η τιμή επιστροφής αυτής.

910
00:55:46,910 --> 00:55:50,720
Έτσι, ξαφνικά, αυτός ο τύπος ξέρει ότι θέλω να επιστρέψω 2.

911
00:55:50,720 --> 00:55:55,910
>> Έτσι θυμηθείτε, επιστρέφει τιμή του είναι μόλις nx η τιμή επιστροφής μέχρι εδώ.

912
00:55:55,910 --> 00:56:01,160
Έτσι τώρα μπορούμε να πούμε 3 x 2, και, τέλος, εδώ μπορούμε να πούμε

913
00:56:01,160 --> 00:56:04,010
αυτό ακριβώς πρόκειται να είναι 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Και όταν αυτή η επιστροφή, θα πάρει κάτω σε ένα μόνο ακέραιο μέσα από τα κύρια.

915
00:56:09,570 --> 00:56:15,460
Οποιεσδήποτε ερωτήσεις σχετικά με αναδρομή;

916
00:56:15,460 --> 00:56:17,090
Εντάξει. Έτσι, υπάρχει περισσότερος χρόνος για τις ερωτήσεις στο τέλος,

917
00:56:17,090 --> 00:56:23,360
αλλά τώρα Ιωσήφ θα καλύψει τα υπόλοιπα θέματα.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Εντάξει. Έτσι τώρα που έχουμε μιλήσει για επαναλήψεις,

919
00:56:25,590 --> 00:56:27,840
Ας μιλήσουμε λίγο για το τι είδους είναι συγχώνευση.

920
00:56:27,840 --> 00:56:31,740
Συγχώνευση είδος είναι ουσιαστικά ένας άλλος τρόπος για τη διαλογή μια λίστα αριθμών.

921
00:56:31,740 --> 00:56:36,430
Και πώς λειτουργεί είναι, με τέτοια συγχώνευση έχετε μια λίστα, και αυτό που κάνουμε είναι

922
00:56:36,430 --> 00:56:39,120
λέμε, ας χωριστεί αυτή σε 2 μισά.

923
00:56:39,120 --> 00:56:42,750
Θα πρώτα να εκτελέσετε συγχώνευση είδος και πάλι στο αριστερό μισό,

924
00:56:42,750 --> 00:56:45,040
τότε θα τρέξει συγχώνευση είδος στο δεξιό μισό,

925
00:56:45,040 --> 00:56:50,240
και ότι τώρα μας δίνει 2 μισά που είναι ταξινομημένο, και τώρα θα πάμε να συνδυάσει τα μισά μαζί.

926
00:56:50,240 --> 00:56:55,010
Είναι λίγο δύσκολο να δει χωρίς ένα παράδειγμα, έτσι θα πάμε μέσα από τις κινήσεις και να δούμε τι θα συμβεί.

927
00:56:55,010 --> 00:56:59,590
Έτσι θα ξεκινήσει με αυτόν τον κατάλογο, θα το χωρίσει σε 2 ημίχρονα.

928
00:56:59,590 --> 00:57:02,300
Τρέχουμε συγχώνευση είδος στο αριστερό μισό πρώτα.

929
00:57:02,300 --> 00:57:06,660
Οπότε αυτό είναι το αριστερό μισό, και τώρα μπορούμε να τρέχει μέσα από αυτήν τη λίστα και πάλι

930
00:57:06,660 --> 00:57:09,800
που παίρνει πέρασε σε είδος συγχώνευσης, και στη συνέχεια να δούμε, και πάλι,

931
00:57:09,800 --> 00:57:13,270
στην αριστερή πλευρά του εν λόγω καταλόγου και διατρέχουμε συγχώνευσης είδος σε αυτό.

932
00:57:13,270 --> 00:57:15,880
Τώρα, έχουμε τα κάτω σε μια λίστα από 2 αριθμούς,

933
00:57:15,880 --> 00:57:19,010
και τώρα το αριστερό μισό είναι μόνο 1 στοιχείο καιρό, και δεν μπορούμε να

934
00:57:19,010 --> 00:57:23,380
χωρίσει μια λίστα που είναι μόνο 1 στοιχείο σε μισό, έτσι απλά να πω, από τη στιγμή που έχουμε 50,

935
00:57:23,380 --> 00:57:26,400
το οποίο είναι μόλις 1 στοιχείο, είναι ήδη ταξινομημένο.

936
00:57:26,400 --> 00:57:29,860
>> Μόλις τελειώσουμε με αυτό, μπορούμε να δούμε ότι μπορούμε

937
00:57:29,860 --> 00:57:32,230
προχωρήσουμε στο δεξιό μισό αυτού του καταλόγου,

938
00:57:32,230 --> 00:57:36,480
και 3 είναι επίσης ταξινομημένο, και έτσι τώρα που ταξινομούνται τα δύο μισά αυτού του καταλόγου

939
00:57:36,480 --> 00:57:39,080
μπορούμε να ενώσουμε αυτούς τους αριθμούς πίσω από κοινού.

940
00:57:39,080 --> 00:57:45,320
Γι 'αυτό και δούμε σε 50 και 3? 3 είναι μικρότερο από το 50, έτσι ώστε να πηγαίνει στην πρώτη και στη συνέχεια 50 μπαίνει

941
00:57:45,320 --> 00:57:49,340
Τώρα, αυτό το κάνει? Πάμε πίσω μέχρι εκείνη τη λίστα και το είδος είναι σωστό μισό.

942
00:57:49,340 --> 00:57:52,440
42 είναι το δικό της αριθμό αυτό, γι 'αυτό είναι ήδη ταξινομημένο.

943
00:57:52,440 --> 00:57:57,850
Έτσι τώρα συγκρίνουμε αυτά τα 2 και 3 είναι μικρότερο από 42, έτσι ώστε παίρνει θέσει στην πρώτη,

944
00:57:57,850 --> 00:58:02,340
τώρα 42 παίρνει θέσει σε, και 50 παίρνει θέσει in

945
00:58:02,340 --> 00:58:07,220
Τώρα, που είναι ταξινομημένο, θα πάνε όλα το δρόμο της επιστροφής προς την κορυφή, 1337 και 15.

946
00:58:07,220 --> 00:58:14,560
Λοιπόν, τώρα εξετάσουμε το αριστερό μισό αυτού του καταλόγου? 1337 είναι από μόνη της έτσι ώστε να είναι ταξινομημένο και ίδιο με 15.

947
00:58:14,560 --> 00:58:19,020
Έτσι τώρα να συνδυάσουμε αυτά τα 2 αριθμούς για να ταξινομήσετε ότι η αρχική λίστα, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
έτσι ώστε να πηγαίνει στην πρώτη, στη συνέχεια, πηγαίνει μέσα 1337

949
00:58:23,060 --> 00:58:26,640
Και τώρα ταξινομημένο δύο μισά της αρχικής λίστας επάνω στην κορυφή.

950
00:58:26,640 --> 00:58:30,440
Και το μόνο που έχουμε να κάνουμε είναι να συνδυάσει αυτά.

951
00:58:30,440 --> 00:58:36,890
Εξετάζουμε τις 2 πρώτοι αριθμοί αυτού του καταλόγου, 3 <15, έτσι ώστε να πηγαίνει στο είδος σειρά πρώτα.

952
00:58:36,890 --> 00:58:44,460
15 <42, έτσι ώστε να πηγαίνει μέσα Τώρα, 42 <1337, που πηγαίνει μέσα

953
00:58:44,460 --> 00:58:51,010
50 <1337, έτσι ώστε να πηγαίνει μέσα και παρατηρήσετε ότι πήραμε μόλις 2 αριθμούς μακριά από αυτή τη λίστα.

954
00:58:51,010 --> 00:58:53,640
Γι 'αυτό και δεν είστε απλά εναλλαγή μεταξύ των 2 λιστών.

955
00:58:53,640 --> 00:58:56,050
Είμαστε απλά κοιτάζοντας την αρχή, και παίρνετε το στοιχείο

956
00:58:56,050 --> 00:59:00,270
αυτό είναι μικρότερο και στη συνέχεια, θέτει σε σειρά μας.

957
00:59:00,270 --> 00:59:04,080
Τώρα έχουμε συγχωνευθεί όλα τα μισά και τελειώσαμε.

958
00:59:04,080 --> 00:59:07,780
>> Οποιεσδήποτε ερωτήσεις σχετικά με τη συγχώνευση του είδους; Ναι;

959
00:59:07,780 --> 00:59:14,190
[Φοιτητικό] Αν είναι διαιρεθεί σε πολλές ομάδες, γιατί δεν γίνεται διαχωρισμός μόνο μία φορά

960
00:59:14,190 --> 00:59:19,970
και έχετε 3 και 2 σε μια ομάδα; [Υπόλοιπο ακατάληπτο ερώτημα]

961
00:59:19,970 --> 00:59:24,940
Ο λόγος - έτσι το ερώτημα είναι, γιατί να μην μπορούμε να συγχωνεύσει τους ακριβώς σε αυτό το πρώτο βήμα αφού τους έχουμε;

962
00:59:24,940 --> 00:59:29,530
Ο λόγος που μπορούμε να το κάνουμε αυτό, ξεκινούν από τα αριστερά, τα περισσότερα στοιχεία από τις δύο πλευρές,

963
00:59:29,530 --> 00:59:33,040
και στη συνέχεια να λάβει το μικρότερο και το βάζουμε σε, είναι ότι ξέρουμε ότι αυτά

964
00:59:33,040 --> 00:59:35,290
μεμονωμένες λίστες είναι ταξινομημένο σε παραγγελίες.

965
00:59:35,290 --> 00:59:37,290
Έτσι, αν κοιτάζω αριστερά-τα περισσότερα στοιχεία των δύο ημίχρονα,

966
00:59:37,290 --> 00:59:40,490
Ξέρω ότι πρόκειται να είναι τα μικρότερα στοιχεία αυτών των καταλόγων.

967
00:59:40,490 --> 00:59:43,930
Γι 'αυτό και μπορεί να τα βάλει σε μικρότερες κηλίδες στοιχείο αυτής της μεγάλης λίστας.

968
00:59:43,930 --> 00:59:47,810
Από την άλλη πλευρά, αν δούμε τις 2 λίστες στο δεύτερο επίπεδο εκεί πέρα,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 και 15, αυτά δεν είναι ταξινομημένο.

970
00:59:51,640 --> 00:59:55,770
Έτσι, αν κοιτάζω 50 και 1337, Πάω να βάλει 50 στην λίστα μου πρώτα.

971
00:59:55,770 --> 01:00:00,130
Αλλά αυτό δεν κάνει πραγματικά νόημα, διότι το 3 είναι το μικρότερο στοιχείο από όλα αυτά.

972
01:00:00,130 --> 01:00:04,390
Έτσι, ο μόνος λόγος που μπορούμε να κάνουμε αυτό το βήμα είναι συνδυάζοντας επειδή οι λίστες μας ήδη ταξινομημένο.

973
01:00:04,390 --> 01:00:07,010
Αυτός είναι ο λόγος που έχουμε να πιάσουμε σε όλη τη διαδρομή προς τα κάτω

974
01:00:07,010 --> 01:00:09,800
γιατί όταν έχουμε μόνο έναν αριθμό, ξέρετε ότι ένα μόνο αριθμό

975
01:00:09,800 --> 01:00:14,120
και αυτή η ίδια είναι ήδη ταξινομημένη λίστα.

976
01:00:14,120 --> 01:00:19,360
>> Οποιεσδήποτε ερωτήσεις; Όχι;

977
01:00:19,360 --> 01:00:24,260
Πολυπλοκότητα; Λοιπόν, μπορείτε να δείτε ότι σε κάθε βήμα υπάρχει αριθμοί τέλος,

978
01:00:24,260 --> 01:00:27,590
και μπορούμε να διαιρέσουμε μια λίστα στο ημερολόγιο ενός δεύτερου n φορές,

979
01:00:27,590 --> 01:00:31,700
το οποίο είναι όπου παίρνουμε αυτό n log n x πολυπλοκότητα.

980
01:00:31,700 --> 01:00:34,940
Και θα δείτε την καλύτερη περίπτωση για το είδος συγχώνευσης είναι n log n, και είναι ακριβώς έτσι συμβαίνει

981
01:00:34,940 --> 01:00:39,340
ότι η χειρότερη περίπτωση, ή το Ω εκεί πέρα, είναι επίσης n log n.

982
01:00:39,340 --> 01:00:42,480
Κάτι που πρέπει να θυμάστε.

983
01:00:42,480 --> 01:00:45,750
Προχωρώντας, πάμε για κάποια σούπερ βασικό αρχείο I / O.

984
01:00:45,750 --> 01:00:48,830
Αν κοίταξε Scramble, θα παρατηρήσετε είχαμε κάποιο είδος του συστήματος

985
01:00:48,830 --> 01:00:51,270
όπου θα μπορούσατε να γράψετε σε ένα αρχείο καταγραφής, αν μπορείτε να διαβάσετε μέσω του κώδικα.

986
01:00:51,270 --> 01:00:53,730
Ας δούμε πώς μπορείτε να το κάνετε αυτό.

987
01:00:53,730 --> 01:00:57,450
Λοιπόν, έχουμε fprintf, το οποίο μπορείτε να σκεφτείτε, όπως ακριβώς printf,

988
01:00:57,450 --> 01:01:01,720
αλλά μόνο εκτύπωση σε αρχείο αντί, και ως εκ τούτου η f στην αρχή.

989
01:01:01,720 --> 01:01:07,570
Αυτό το είδος του κώδικα μέχρι εδώ, αυτό που κάνει είναι, όπως ίσως έχετε δει στο Scramble,

990
01:01:07,570 --> 01:01:12,310
περνά από 2-διαστάσεων εκτύπωση από σειρά σας ανά γραμμή τι είναι οι αριθμοί.

991
01:01:12,310 --> 01:01:17,850
Σε αυτή την περίπτωση, printf εκτυπώνει σε τερματικό σας ή αυτό που λέμε η τυπική έξοδο του τμήματος.

992
01:01:17,850 --> 01:01:22,170
>> Και τώρα, σε αυτή την περίπτωση, το μόνο που έχουμε να κάνουμε είναι να αντικαταστήσει printf με fprintf,

993
01:01:22,170 --> 01:01:26,770
πω ότι αυτό το αρχείο που θέλετε να εκτυπώσετε, και στην περίπτωση αυτή εκτυπώνει ακριβώς έξω για αυτό το αρχείο

994
01:01:26,770 --> 01:01:32,230
αντί να την εκτύπωση στο τερματικό σας.

995
01:01:32,230 --> 01:01:36,500
Καλά, τότε ανακύπτει το ερώτημα: Πού θα πάρει αυτό το είδος του αρχείου από το, έτσι δεν είναι;

996
01:01:36,500 --> 01:01:39,840
Περάσαμε συνδεθείτε σε αυτό το fprintf fuction, αλλά δεν είχαμε ιδέα από πού προήλθε.

997
01:01:39,840 --> 01:01:43,980
Λοιπόν, στις αρχές του κώδικα, ό, τι είχαμε ήταν αυτό κομμάτι του κώδικα πάνω από εδώ,

998
01:01:43,980 --> 01:01:48,340
η οποία ουσιαστικά λέει ότι το αρχείο ανοιχτό καλεί log.txt.

999
01:01:48,340 --> 01:01:53,220
Τι κάνουμε μετά από αυτό είναι ότι πρέπει να βεβαιωθείτε ότι το αρχείο είναι στην πραγματικότητα άνοιξε με επιτυχία.

1000
01:01:53,220 --> 01:01:57,070
Γι 'αυτό μπορεί να αποτύχει για πολλούς λόγους? Δεν έχετε αρκετό χώρο στον υπολογιστή σας, για παράδειγμα.

1001
01:01:57,070 --> 01:01:59,790
Γι 'αυτό είναι πάντα σημαντικό, πριν κάνετε οποιαδήποτε εργασία με το αρχείο

1002
01:01:59,790 --> 01:02:03,300
να ελέγξουμε αν αυτό το αρχείο άνοιξε με επιτυχία.

1003
01:02:03,300 --> 01:02:09,330
Έτσι τι ότι, αυτό είναι ένα επιχείρημα για να fopen, καλά, μπορούμε να ανοίξουμε ένα αρχείο με πολλούς τρόπους.

1004
01:02:09,330 --> 01:02:13,510
Τι μπορούμε να κάνουμε είναι, μπορούμε να περάσουμε το w, το οποίο σημαίνει ότι υπερισχύει το αρχείο αν βγαίνει ήδη,

1005
01:02:13,510 --> 01:02:18,070
Μπορούμε να περάσει ένα ένα, τα οποία θα επισυνάπτει στο τέλος του αρχείου αντί του σημαντικού αυτό,

1006
01:02:18,070 --> 01:02:22,730
ή μπορούμε να ορίσουμε r, πράγμα που σημαίνει, ας ανοίξετε το αρχείο ως μόνο για ανάγνωση.

1007
01:02:22,730 --> 01:02:24,890
Έτσι, αν το πρόγραμμα προσπαθεί να κάνει αλλαγές στο αρχείο,

1008
01:02:24,890 --> 01:02:30,140
φωνάζω σε αυτούς και να μην τους αφήσουμε να το κάνουν.

1009
01:02:30,140 --> 01:02:33,320
Τέλος, μόλις τελειώσετε με το αρχείο, κάνει να κάνει εργασίες σε αυτό,

1010
01:02:33,320 --> 01:02:35,860
θα πρέπει να βεβαιωθείτε ότι κλείνουμε το αρχείο.

1011
01:02:35,860 --> 01:02:38,830
Και έτσι στο τέλος του προγράμματός σας, θα έχετε την ευκαιρία να τους περάσει και πάλι

1012
01:02:38,830 --> 01:02:42,120
αυτό το αρχείο που ανοίξατε, και μόλις το κλείσετε.

1013
01:02:42,120 --> 01:02:44,650
Έτσι, αυτό είναι κάτι σημαντικό που θα πρέπει να βεβαιωθείτε ότι έχετε κάνει.

1014
01:02:44,650 --> 01:02:47,180
Έτσι θυμηθείτε, μπορείτε να ανοίξετε ένα αρχείο, τότε μπορείτε να γράψετε στο αρχείο,

1015
01:02:47,180 --> 01:02:51,270
κάνουν εργασίες στο αρχείο, αλλά τότε θα πρέπει να κλείσετε το αρχείο στο τέλος.

1016
01:02:51,270 --> 01:02:53,270
>> Οποιεσδήποτε ερωτήσεις σχετικά με τις βασικές αρχείο I / O; Ναι;

1017
01:02:53,270 --> 01:02:58,050
[Ερώτηση Φοιτητών, ακατάληπτο]

1018
01:02:58,050 --> 01:03:02,480
Δικαίωμα εδώ. Το ερώτημα είναι, όταν το κάνει αυτό αρχείο log.txt εμφανίζονται;

1019
01:03:02,480 --> 01:03:07,890
Λοιπόν, αν έχετε μόλις δώσει log.txt, αυτό δημιουργεί στον ίδιο κατάλογο με το εκτελέσιμο.

1020
01:03:07,890 --> 01:03:10,500
Έτσι, εάν Μπορείτε πλέον - >> [ερώτηση Φοιτητών, ακατάληπτο]

1021
01:03:10,500 --> 01:03:18,830
Ναι. Στον ίδιο φάκελο, ή στον ίδιο κατάλογο, όπως την αποκαλούν.

1022
01:03:18,830 --> 01:03:21,400
Τώρα μνήμη, η καπνοδόχος, και σωρού.

1023
01:03:21,400 --> 01:03:23,400
Λοιπόν, πώς είναι η μνήμη που ορίζονται στον υπολογιστή;

1024
01:03:23,400 --> 01:03:26,270
Λοιπόν, μπορείτε να φανταστείτε μνήμη ως είδος αυτού του μπλοκ εδώ.

1025
01:03:26,270 --> 01:03:30,260
Και στη μνήμη έχουμε αυτό που ονομάζεται το σωρό κολλήσει εκεί πέρα, και τη στοίβα που υπάρχει εκεί κάτω.

1026
01:03:30,260 --> 01:03:34,480
Και ο σωρός μεγαλώνει προς τα κάτω και η στοίβα μεγαλώνει προς τα πάνω.

1027
01:03:34,480 --> 01:03:38,620
Έτσι, όπως ανέφερε ο Tommy - Ω, καλά, και έχουμε αυτά τα άλλα 4 τμήματα που θα πάρω στο δεύτερο -

1028
01:03:38,620 --> 01:03:42,890
Όπως δήλωσε ο Tommy νωρίτερα, ξέρετε πώς τα καθήκοντά του αποκαλούν τους εαυτούς τους και καλούν ο ένας τον άλλο;

1029
01:03:42,890 --> 01:03:44,930
Θα δημιουργήσει αυτό το είδος της στοίβας πλαίσιο.

1030
01:03:44,930 --> 01:03:47,360
Λοιπόν, αν η κύρια κλήσεις foo, foo παίρνει τοποθετούνται στη στοίβα.

1031
01:03:47,360 --> 01:03:52,430
Foo καλεί bar, να βάλουμε στη στοίβα, και που παίρνει τοποθετούνται στη στοίβα μετά.

1032
01:03:52,430 --> 01:03:57,040
Και καθώς επιστρέφουν, ο καθένας να απογειωθεί τη στοίβα.

1033
01:03:57,040 --> 01:04:00,140
Ποια είναι η κάθε μία από αυτές τις θέσεις και κρατήστε τη μνήμη;

1034
01:04:00,140 --> 01:04:03,110
Λοιπόν, η κορυφή, η οποία είναι το τμήμα κειμένου, περιέχει το ίδιο το πρόγραμμα.

1035
01:04:03,110 --> 01:04:06,390
Έτσι, τον κώδικα μηχανής, που υπάρχει, τη στιγμή που θα καταρτίσει το πρόγραμμά σας.

1036
01:04:06,390 --> 01:04:08,520
Στη συνέχεια, οποιαδήποτε καθολικές μεταβλητές αρχικοποιηθούν.

1037
01:04:08,520 --> 01:04:12,660
>> Έτσι έχετε καθολικές μεταβλητές στο πρόγραμμά σας, και όπως λέτε, α = 5,

1038
01:04:12,660 --> 01:04:15,260
που παίρνει θέσει σε αυτό το τμήμα, και ακριβώς κάτω από αυτό,

1039
01:04:15,260 --> 01:04:18,990
έχετε δεν έχει προετοιμαστεί παγκόσμια δεδομένα, τα οποία είναι απλά μια int,

1040
01:04:18,990 --> 01:04:20,990
αλλά δεν λες ότι είναι ίσο με τίποτα.

1041
01:04:20,990 --> 01:04:23,870
Συνειδητοποιήστε αυτές είναι καθολικές μεταβλητές, έτσι ώστε να είμαστε έξω από τα κύρια.

1042
01:04:23,870 --> 01:04:28,560
Έτσι, αυτό σημαίνει ότι όλα τα παγκόσμια μεταβλητές που έχουν δηλωθεί αλλά δεν αρχικοποιείται.

1043
01:04:28,560 --> 01:04:32,310
Έτσι, ό, τι είναι στο σωρό; Η μνήμη που εκχωρείται με malloc, το οποίο θα φτάσουμε στο λίγο.

1044
01:04:32,310 --> 01:04:35,990
Και τέλος, με τη στοίβα έχετε τοπικές μεταβλητές

1045
01:04:35,990 --> 01:04:39,950
και οποιεσδήποτε λειτουργίες μπορείτε να καλέσετε σε οποιαδήποτε από τις παραμέτρους τους.

1046
01:04:39,950 --> 01:04:43,720
Το τελευταίο πράγμα, δεν πρέπει πραγματικά να ξέρετε τι κάνουν οι μεταβλητές περιβάλλοντος,

1047
01:04:43,720 --> 01:04:46,700
αλλά κάθε φορά που τρέχει το πρόγραμμα, δεν υπάρχει κάτι που σχετίζεται, όπως

1048
01:04:46,700 --> 01:04:49,550
αυτό είναι το όνομα του προσώπου που έτρεξε το πρόγραμμα.

1049
01:04:49,550 --> 01:04:51,550
Και αυτό πρόκειται να είναι το είδος του στο κάτω μέρος.

1050
01:04:51,550 --> 01:04:54,540
Όσον αφορά τις διευθύνσεις μνήμης, η οποία είναι δεκαεξαδικές τιμές,

1051
01:04:54,540 --> 01:04:58,170
οι τιμές στην κορυφή ξεκίνημα στο 0, και πάνε σε όλη τη διαδρομή προς τα κάτω.

1052
01:04:58,170 --> 01:05:00,440
Σε αυτή την περίπτωση, αν είστε στο σύστημα 32-bit,

1053
01:05:00,440 --> 01:05:05,390
η διεύθυνση στο κάτω μέρος πρόκειται να είναι 0x, ακολουθούμενη από af, γιατί αυτό είναι 32 bits,

1054
01:05:05,390 --> 01:05:10,890
η οποία είναι 8 bytes, και σε αυτή την περίπτωση 8 bytes αντιστοιχεί σε 8 ψηφία δεκαεξαδική.

1055
01:05:10,890 --> 01:05:20,110
Έτσι, εδώ κάτω θα πάμε να έχουν, όπως, 0xffffff, και εκεί θα πάμε να έχουν 0.

1056
01:05:20,110 --> 01:05:23,660
Έτσι, ποιες είναι οι δείκτες; Μερικοί από εσάς μπορεί να μην καλύπτονται στο τμήμα αυτό πριν.

1057
01:05:23,660 --> 01:05:26,660
αλλά εμείς δεν πάμε πάνω σε διάλεξη, οπότε ένας δείκτης είναι απλά ένας τύπος δεδομένων

1058
01:05:26,660 --> 01:05:34,030
η οποία αποθηκεύει, αντί κάποιου είδους αξίας, όπως 50, αποθηκεύει τη διεύθυνση της κάποια θέση στη μνήμη.

1059
01:05:34,030 --> 01:05:36,020
Όπως αυτή τη μνήμη [ακατάληπτο].

1060
01:05:36,020 --> 01:05:41,120
Έτσι, σε αυτή την περίπτωση, αυτό που έχουμε είναι, έχουμε ένα δείκτη σε ακέραιο ή έναν int *,

1061
01:05:41,120 --> 01:05:46,210
και περιέχει αυτή δεκαεξαδική διεύθυνση του 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Έτσι, αυτό που έχουμε είναι, τώρα, αυτό δείχνει το δείκτη σε κάποια θέση στη μνήμη,

1063
01:05:50,880 --> 01:05:56,020
και αυτό είναι μόνο ένα, η τιμή 50 είναι σε αυτή τη θέση μνήμης.

1064
01:05:56,020 --> 01:06:01,810
Σε μερικά συστήματα 32-bit, σε όλα τα συστήματα 32-bit, δείκτες καταλαμβάνουν 32 bits ή 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Αλλά, για παράδειγμα, σε ένα σύστημα 64-bit, δείκτες είναι 64 μπιτ.

1066
01:06:06,020 --> 01:06:08,040
Έτσι, αυτό είναι κάτι που θα θέλετε να έχετε κατά νου.

1067
01:06:08,040 --> 01:06:12,310
Έτσι, σε ένα σύστημα τέλος-bit, είναι ένας δείκτης bits τέλος μακρύς.

1068
01:06:12,310 --> 01:06:17,320
Οι δείκτες είναι είδος δύσκολο να αφομοιώσουν χωρίς επιπλέον πράγματα,

1069
01:06:17,320 --> 01:06:20,300
οπότε ας πάμε μέσα από ένα παράδειγμα της δυναμικής κατανομής μνήμης.

1070
01:06:20,300 --> 01:06:25,130
Τι δυναμική κατανομή μνήμης κάνει για σας, ή αυτό που λέμε malloc,

1071
01:06:25,130 --> 01:06:29,280
σας επιτρέπει να διαθέσει κάποιο είδος των δεδομένων έξω από το σετ.

1072
01:06:29,280 --> 01:06:31,830
Έτσι αυτά τα δεδομένα είναι είδος μονιμότερη για όλη τη διάρκεια του προγράμματος.

1073
01:06:31,830 --> 01:06:36,430
Διότι, όπως γνωρίζετε, αν δηλώνουν x μέσα από μια συνάρτηση, και ότι επιστρέφει λειτουργία,

1074
01:06:36,430 --> 01:06:40,910
δεν έχετε πλέον πρόσβαση στα δεδομένα που είναι αποθηκευμένα στο x.

1075
01:06:40,910 --> 01:06:44,420
Τι δείκτες ας κάνουμε είναι να αποθηκεύουν ας μνήμη ή κατάστημα αξίες

1076
01:06:44,420 --> 01:06:46,840
σε ένα διαφορετικό τμήμα της μνήμης, δηλαδή το σωρό.

1077
01:06:46,840 --> 01:06:49,340
Τώρα μόλις επιστρέψει από τη λειτουργία, εφ 'όσον έχουμε ένα δείκτη

1078
01:06:49,340 --> 01:06:54,960
σε αυτή τη θέση στη μνήμη, τότε τι μπορούμε να κάνουμε είναι να μπορούμε να εξετάσουμε μόνο τις τιμές που υπάρχουν.

1079
01:06:54,960 --> 01:06:58,020
Ας δούμε ένα παράδειγμα: Αυτή είναι η διάταξη της μνήμης μας και πάλι.

1080
01:06:58,020 --> 01:07:00,050
Και έχουμε αυτή τη λειτουργία, τα κύρια.

1081
01:07:00,050 --> 01:07:06,870
Αυτό που κάνει είναι - εντάξει, έτσι απλά, έτσι; - int x = 5, αυτό είναι απλά μια μεταβλητή στη στοίβα σε κύρια.

1082
01:07:06,870 --> 01:07:12,450
>> Από την άλλη πλευρά, τώρα δηλώνουμε ένα δείκτη ο οποίος καλεί τους giveMeThreeInts λειτουργία.

1083
01:07:12,450 --> 01:07:16,800
Και έτσι τώρα πάμε σε αυτή τη λειτουργία και δημιουργούμε ένα νέο πλαίσιο για το stack.

1084
01:07:16,800 --> 01:07:20,440
Ωστόσο, σε αυτό το πλαίσιο στοίβας, δηλώνουμε int * temp,

1085
01:07:20,440 --> 01:07:23,210
η οποία σε ακέραιους mallocs 3 για εμάς.

1086
01:07:23,210 --> 01:07:25,880
Έτσι, το μέγεθος του int θα μας δώσει πόσα bytes αυτό είναι int,

1087
01:07:25,880 --> 01:07:29,620
malloc και μας δίνει ότι πολλά byte του χώρου στο σωρό.

1088
01:07:29,620 --> 01:07:32,890
Έτσι, σε αυτή την περίπτωση, έχουμε δημιουργήσει αρκετό χώρο για 3 ακέραιους αριθμούς,

1089
01:07:32,890 --> 01:07:36,830
και ο σωρός είναι ο τρόπος εκεί, το οποίο είναι ο λόγος που έχω είναι που ψηλότερα.

1090
01:07:36,830 --> 01:07:42,900
Μόλις τελειώσετε, θα επανέλθουμε εδώ, το μόνο που χρειάζεστε 3 ints επέστρεψε,

1091
01:07:42,900 --> 01:07:47,000
και επιστρέφει την διεύθυνση, στην περίπτωση αυτή πάνω, όταν η μνήμη είναι.

1092
01:07:47,000 --> 01:07:51,250
Και θέτουμε το δείκτη = διακόπτη, και εκεί έχουμε μόνο ένα άλλο δείκτη.

1093
01:07:51,250 --> 01:07:54,550
Αλλά τι επιστρέφει η λειτουργία στοιβάζονται εδώ και εξαφανίζεται.

1094
01:07:54,550 --> 01:07:59,250
Έτσι θερμοκρασία εξαφανίζεται, αλλά εξακολουθούν να διατηρούν τη διεύθυνση όπου

1095
01:07:59,250 --> 01:08:01,850
αυτές οι 3 είναι ακέραιοι μέσα από δίκτυο.

1096
01:08:01,850 --> 01:08:06,180
Έτσι, σε αυτό το σύνολο, οι δείκτες είναι scoped σε τοπικό επίπεδο για την στοιβάζονται πλαίσιο,

1097
01:08:06,180 --> 01:08:09,860
αλλά η μνήμη στο οποίο αναφέρονται είναι στο σωρό.

1098
01:08:09,860 --> 01:08:12,190
>> Μήπως αυτό έχει νόημα;

1099
01:08:12,190 --> 01:08:14,960
[Φοιτητικό] Θα μπορούσατε να επαναλάβετε αυτό; >> [Joseph] Ναι.

1100
01:08:14,960 --> 01:08:20,270
Έτσι, αν πάω πίσω μόνο λίγο, θα δείτε ότι διατίθενται temp

1101
01:08:20,270 --> 01:08:23,500
μέρος της μνήμης στο σωρό μέχρι εκεί.

1102
01:08:23,500 --> 01:08:28,680
Έτσι, όταν αυτή η λειτουργία, giveMeThreeInts επιστρέφει, αυτή η στοίβα εδώ πρόκειται να εξαφανιστούν.

1103
01:08:28,680 --> 01:08:35,819
Και με αυτό οποιαδήποτε από τις μεταβλητές, σε αυτή την περίπτωση, αυτό δείκτη που διατέθηκε στο πλαίσιο στοιβάζονται.

1104
01:08:35,819 --> 01:08:39,649
Δηλαδή πρόκειται να εξαφανιστεί, αλλά από τη στιγμή που επέστρεψε temp

1105
01:08:39,649 --> 01:08:46,330
και θέτουμε δείκτη = temp, ο δείκτης είναι τώρα πρόκειται να επισημάνω την ίδια μνήμη του θέση, όπως η θερμοκρασία ήταν.

1106
01:08:46,330 --> 01:08:50,370
Μέχρι τώρα, ακόμα κι αν χάνουμε temp, ότι οι τοπικές δείκτη,

1107
01:08:50,370 --> 01:08:59,109
που εξακολουθούν να διατηρούν τη διεύθυνση μνήμης του τι έδειχνε προς τα μέσα αυτής της μεταβλητής δείκτη.

1108
01:08:59,109 --> 01:09:03,740
Ερωτήσεις; Αυτό μπορεί να είναι το είδος της μια σύγχυση θέμα, αν δεν έχετε περάσει από πάνω του στο τμήμα.

1109
01:09:03,740 --> 01:09:09,240
Μπορούμε, TF σας σίγουρα θα πάει πέρα ​​από αυτό και φυσικά μπορούμε να απαντήσουμε σε ερωτήσεις

1110
01:09:09,240 --> 01:09:11,500
στο τέλος της συνεδρίας επανεξέτασης για αυτό.

1111
01:09:11,500 --> 01:09:14,220
Αλλά αυτό είναι το είδος της ένα περίπλοκο θέμα, και έχω περισσότερα παραδείγματα που πρόκειται να εμφανιστούν

1112
01:09:14,220 --> 01:09:18,790
που θα βοηθήσει να διευκρινιστεί τι πραγματικά είναι δείκτες.

1113
01:09:18,790 --> 01:09:22,500
>> Σε αυτή την περίπτωση, οι δείκτες είναι ισοδύναμα με συστοιχίες,

1114
01:09:22,500 --> 01:09:25,229
έτσι μπορώ να χρησιμοποιήσω ακριβώς αυτό το δείκτη, όπως το ίδιο πράγμα με έναν int array.

1115
01:09:25,229 --> 01:09:29,840
Έτσι είμαι ευρετηρίαση σε 0, και αλλάζοντας το πρώτο ακέραιο έως 1,

1116
01:09:29,840 --> 01:09:39,689
αλλάζοντας τη δεύτερη ακέραιος έως 2, και η 3η ακέραιος έως 3.

1117
01:09:39,689 --> 01:09:44,210
Έτσι, περισσότερο για δείκτες. Λοιπόν, θυμάμαι Binky.

1118
01:09:44,210 --> 01:09:48,319
Σε αυτή την περίπτωση θα έχουμε ένα δείκτη που διατίθενται, ή θα κηρυχθεί δείκτη,

1119
01:09:48,319 --> 01:09:52,760
αλλά αρχικά, όταν μου δήλωσε απλώς ένα δείκτη, δεν είναι να δείχνει οπουδήποτε στη μνήμη.

1120
01:09:52,760 --> 01:09:54,930
Είναι ακριβώς αξίες σκουπίδια στο εσωτερικό του.

1121
01:09:54,930 --> 01:09:56,470
Έτσι, δεν έχω καμία ιδέα για το πού το δείκτη να δείχνει.

1122
01:09:56,470 --> 01:10:01,630
Έχει μια διεύθυνση που μόλις γεμίσει με το 0 και το 1, όπου είχε αρχικά δηλωθεί.

1123
01:10:01,630 --> 01:10:04,810
Δεν μπορώ να κάνω τίποτα με αυτό μέχρι καλώ malloc για το

1124
01:10:04,810 --> 01:10:08,390
και τότε μου δίνει ένα μικρό χώρο στο σωρό, όπου μπορώ να βάλω τις τιμές στο εσωτερικό.

1125
01:10:08,390 --> 01:10:11,980
Στη συνέχεια, και πάλι, δεν ξέρω τι είναι μέσα από αυτή τη μνήμη.

1126
01:10:11,980 --> 01:10:16,780
Έτσι, το πρώτο πράγμα που πρέπει να κάνετε είναι να ελέγξετε αν το σύστημα είχε αρκετή μνήμη

1127
01:10:16,780 --> 01:10:20,850
να μου δώσει προηγούμενη 1 ακέραιο στην πρώτη θέση, η οποία είναι ο λόγος που κάνω αυτό το ελέγξετε.

1128
01:10:20,850 --> 01:10:25,020
Αν ο δείκτης είναι μηδέν, που σημαίνει ότι δεν έχει αρκετό χώρο ή κάποιο άλλο σφάλμα,

1129
01:10:25,020 --> 01:10:26,320
γι 'αυτό θα πρέπει να βγείτε έξω από το πρόγραμμά μου.

1130
01:10:26,320 --> 01:10:29,400
 Αλλά αν το έκανε επιτυχία, τώρα μπορώ να χρησιμοποιήσω αυτό το δείκτη

1131
01:10:29,400 --> 01:10:35,020
και τι δείκτη * που κάνει είναι να ακολουθεί, όπου η διεύθυνση είναι

1132
01:10:35,020 --> 01:10:38,480
όπου η τιμή αυτή είναι, και θέτει αυτό ισούται με 1.

1133
01:10:38,480 --> 01:10:41,850
Έτσι, πάνω από εδώ, είμαστε έλεγχο εάν η μνήμη υπήρχε.

1134
01:10:41,850 --> 01:10:45,380
>> Μόλις ξέρετε ότι υπάρχει, μπορείτε να βάλετε σε αυτό

1135
01:10:45,380 --> 01:10:50,460
τι τιμή που θέλετε να βάλετε σε αυτό? σε αυτήν την περίπτωση 1.

1136
01:10:50,460 --> 01:10:53,060
Μόλις τελειώσουμε με αυτό, θα πρέπει να ελευθερώσετε ότι ο δείκτης

1137
01:10:53,060 --> 01:10:57,160
γιατί πρέπει να πάρει πίσω το σύστημα ότι η μνήμη που ζήτησε στην πρώτη θέση.

1138
01:10:57,160 --> 01:10:59,690
Επειδή ο υπολογιστής δεν ξέρει πότε θα τελειώσετε με αυτό.

1139
01:10:59,690 --> 01:11:02,510
Σε αυτή την περίπτωση λέμε ρητά, εντάξει, τελειώσαμε με αυτή την μνήμη.

1140
01:11:02,510 --> 01:11:10,780
Εάν κάποια άλλη διαδικασία που χρειάζεται, κάποιο άλλο πρόγραμμα χρειάζεται, μη διστάσετε να προχωρήσει και να το πάρετε.

1141
01:11:10,780 --> 01:11:15,110
Αυτό που μπορούμε να κάνουμε είναι, επίσης, μπορούμε να πάρουμε μόνο τη διεύθυνση των τοπικών μεταβλητών για το σύνολο.

1142
01:11:15,110 --> 01:11:19,080
Έτσι, int x είναι μέσα στο πλαίσιο του στοιβάζονται κύρια.

1143
01:11:19,080 --> 01:11:23,060
Και όταν χρησιμοποιούμε αυτό το εμπορικό, και το φορέα εκμετάλλευσης, αυτό που κάνει είναι

1144
01:11:23,060 --> 01:11:27,310
παίρνει χ, και το χ είναι μόνο μερικά δεδομένα στη μνήμη, αλλά έχει μια διεύθυνση.

1145
01:11:27,310 --> 01:11:33,790
Βρίσκεται κάπου. Έτσι, με την κλήση & x, τι είναι αυτό που κάνει είναι να μας δίνει τη διεύθυνση του x.

1146
01:11:33,790 --> 01:11:38,430
Με τον τρόπο αυτό, κάνουμε το σημείο δείκτη στο σημείο όπου x είναι στη μνήμη.

1147
01:11:38,430 --> 01:11:41,710
Τώρα απλά κάτι σαν x *, θα πάμε για να πάρει 5 πίσω.

1148
01:11:41,710 --> 01:11:43,820
Το αστέρι ονομάζεται εύρεση τιμών του.

1149
01:11:43,820 --> 01:11:46,640
Ακολουθείτε τη διεύθυνση και μπορείτε να πάρετε την αξία του να είναι αποθηκευμένα εκεί.

1150
01:11:51,000 --> 01:11:53,310
>> Οποιεσδήποτε ερωτήσεις; Ναι;

1151
01:11:53,310 --> 01:11:56,500
[Φοιτητικό] Αν δεν κάνει το 3-επισήμανε πράγμα, δεν είναι ακόμα συγκεντρώνουν;

1152
01:11:56,500 --> 01:11:59,490
Ναι. Αν δεν κάνουμε το 3-δείκτη πράγμα, είναι ακόμη σε εξέλιξη για την κατάρτιση,

1153
01:11:59,490 --> 01:12:02,720
αλλά εγώ θα σου δείξω τι θα συμβεί σε ένα δεύτερο, και χωρίς να κάνει ότι,

1154
01:12:02,720 --> 01:12:04,860
ότι είναι αυτό που λέμε μια διαρροή μνήμης. Δεν είστε δίνοντας στο σύστημα

1155
01:12:04,860 --> 01:12:07,850
πίσω τη μνήμη του, έτσι μετά από λίγο το πρόγραμμα πρόκειται να συσσωρεύονται

1156
01:12:07,850 --> 01:12:10,940
μνήμης που δεν είναι με τη χρήση, και τίποτα άλλο δεν μπορεί να το χρησιμοποιήσει.

1157
01:12:10,940 --> 01:12:15,750
Αν έχετε δει ποτέ με τον Firefox 1,5 εκατομμύρια kilobytes στον υπολογιστή σας,

1158
01:12:15,750 --> 01:12:17,840
στο έργο του διαχειριστή, αυτό είναι ό, τι συμβαίνει.

1159
01:12:17,840 --> 01:12:20,760
Έχετε μια διαρροή μνήμης στο πρόγραμμα ότι δεν είστε χειρισμό.

1160
01:12:23,080 --> 01:12:26,240
Και πώς δείκτη εργασίας αριθμητική;

1161
01:12:26,240 --> 01:12:29,480
Λοιπόν, αριθμητική δείκτης είναι περίπου όπως ευρετηρίαση σε μια σειρά.

1162
01:12:29,480 --> 01:12:36,370
Σε αυτή την περίπτωση, έχω ένα δείκτη, και αυτό που κάνω είναι να κάνω το σημείο δείκτη στο πρώτο στοιχείο

1163
01:12:36,370 --> 01:12:42,100
αυτής της σειράς 3 ακέραιους αριθμούς που έχω διατεθεί.

1164
01:12:42,100 --> 01:12:46,670
Και τώρα τι κάνω, αστέρι δείκτης αλλάζει μόνο το πρώτο στοιχείο στη λίστα.

1165
01:12:46,670 --> 01:12:49,140
Κατηγορία δείκτης +1 σημεία εδώ.

1166
01:12:49,140 --> 01:12:53,140
Έτσι, ο δείκτης είναι πάνω από εδώ, ο δείκτης +1 είναι πάνω από εδώ, δείκτης +2 είναι εδώ.

1167
01:12:53,140 --> 01:12:56,610
>> Έτσι, προσθέτοντας μόλις 1 είναι το ίδιο πράγμα όπως κινείται κατά μήκος αυτού του πίνακα.

1168
01:12:56,610 --> 01:12:59,880
Αυτό που κάνουμε είναι, όταν κάνουμε έναν δείκτη μπορείτε να πάρετε τη διεύθυνση πάνω από εδώ,

1169
01:12:59,880 --> 01:13:04,180
και για να πάρει την τιμή εδώ, να βάλετε ένα αστέρι μέσα από το σύνολο της έκφρασης

1170
01:13:04,180 --> 01:13:05,990
για να dereference.

1171
01:13:05,990 --> 01:13:09,940
Έτσι, σε αυτή την περίπτωση, είμαι καθορισμό του πρώτου θέση σε αυτή την σειρά σε 1,

1172
01:13:09,940 --> 01:13:13,970
δεύτερη θέση σε 2, και σε τρίτη θέση 3.

1173
01:13:13,970 --> 01:13:18,180
Στη συνέχεια, αυτό που κάνω εδώ είναι Είμαι εκτύπωση δείκτη μας +1,

1174
01:13:18,180 --> 01:13:19,970
η οποία δίνει μόνο εγώ 2.

1175
01:13:19,970 --> 01:13:23,650
Τώρα είμαι προσαύξηση δείκτη, έτσι ώστε ο δείκτης ισούται με το δείκτη +1,

1176
01:13:23,650 --> 01:13:26,780
η οποία κινείται προς τα εμπρός.

1177
01:13:26,780 --> 01:13:30,810
Και έτσι τώρα αν μπορώ να εκτυπώσω από το δείκτη +1, δείκτης +1 είναι τώρα 3,

1178
01:13:30,810 --> 01:13:33,990
που στην περίπτωση αυτή εκτυπώνει 3.

1179
01:13:33,990 --> 01:13:36,560
Και για να δωρεάν κάτι, ο δείκτης που δίνω

1180
01:13:36,560 --> 01:13:40,540
πρέπει να δείχνει στην αρχή του πίνακα που πήρα πίσω από malloc.

1181
01:13:40,540 --> 01:13:43,430
Έτσι, σε αυτή την περίπτωση, εάν επρόκειτο να καλέσετε 3 δικαίωμα εδώ, αυτό δεν θα ήταν σωστό,

1182
01:13:43,430 --> 01:13:45,070
επειδή είναι στη μέση της διάταξης.

1183
01:13:45,070 --> 01:13:48,820
Θα πρέπει να αφαιρέσετε για να φτάσουμε στην αρχική του θέση

1184
01:13:48,820 --> 01:13:50,420
η αρχική πρώτη θέση πριν μπορώ να το απελευθερώσει.

1185
01:13:56,300 --> 01:13:58,450
Έτσι, εδώ είναι μια πιο περίπλοκη παράδειγμα.

1186
01:13:58,450 --> 01:14:03,360
Σε αυτή την περίπτωση, είμαστε κατανομή 7 χαρακτήρες σε μια σειρά χαρακτήρων.

1187
01:14:03,360 --> 01:14:06,480
>> Και σε αυτή την περίπτωση αυτό που κάνουμε εμείς είναι looping πάνω από την πρώτη 6 από αυτούς,

1188
01:14:06,480 --> 01:14:09,900
και είμαστε ρύθμιση για τους Z.

1189
01:14:09,900 --> 01:14:13,350
Έτσι, για int i = 0, i> 6, ί + +,

1190
01:14:13,350 --> 01:14:16,220
Έτσι, ο δείκτης + i θα μας δώσει ακριβώς, στην περίπτωση αυτή,

1191
01:14:16,220 --> 01:14:20,860
δείκτη, ο δείκτης 1, ο δείκτης 2, δείκτης 3, και ούτω καθεξής και ούτω καθεξής στο βρόχο.

1192
01:14:20,860 --> 01:14:24,040
Τι πρόκειται να κάνουμε είναι να παίρνει αυτή τη διεύθυνση, dereferences να πάρετε την τιμή,

1193
01:14:24,040 --> 01:14:27,440
και ότι οι αλλαγές σε αξία Ζ.

1194
01:14:27,440 --> 01:14:30,350
Στη συνέχεια, στο τέλος θυμηθείτε ότι αυτό είναι ένα string, έτσι δεν είναι;

1195
01:14:30,350 --> 01:14:33,560
Όλες οι χορδές πρέπει να τελειώνει με το null χαρακτήρα τερματισμού.

1196
01:14:33,560 --> 01:14:38,620
Έτσι, αυτό που κάνω είναι στο δείκτη 6 έβαλα το null χαρακτήρα τερματισμού μέσα

1197
01:14:38,620 --> 01:14:43,980
Και τώρα τι είμαι βασικά κάνει εδώ εφαρμόζει printf για μια σειρά, έτσι δεν είναι;

1198
01:14:43,980 --> 01:14:46,190
>> Έτσι, όταν δεν printf τώρα όταν έχει φτάσει στο τέλος της σειράς;

1199
01:14:46,190 --> 01:14:48,230
Όταν χτυπά το null χαρακτήρα τερματισμού.

1200
01:14:48,230 --> 01:14:52,030
Έτσι, σε αυτή την περίπτωση, το αρχικό σημεία δείκτη μου στην αρχή αυτής της συστοιχίας.

1201
01:14:52,030 --> 01:14:56,410
Μπορώ να εκτυπώσω τον πρώτο χαρακτήρα έξω. Εγώ να το μετακινήσετε πάνω από ένα.

1202
01:14:56,410 --> 01:14:58,420
Μπορώ να εκτυπώσω αυτό το χαρακτήρα έξω. Εγώ να το μετακινήσετε πάνω.

1203
01:14:58,420 --> 01:15:02,180
Και συνεχίζω να το κάνετε αυτό μέχρι να φτάσετε στο τέλος.

1204
01:15:02,180 --> 01:15:07,750
Και τώρα ο δείκτης * τέλος θα dereference αυτό και να πάρει το null χαρακτήρα τερματισμού πίσω.

1205
01:15:07,750 --> 01:15:11,780
Και έτσι, ενώ βρόχος μου τρέχει μόνο όταν η τιμή δεν είναι η μηδενική χαρακτήρας τερματισμού.

1206
01:15:11,780 --> 01:15:13,770
Έτσι, τώρα έχω την έξοδο από αυτόν τον βρόχο.

1207
01:15:18,780 --> 01:15:21,180
Και έτσι αν αφαιρέσουμε 6 από αυτό το δείκτη,

1208
01:15:21,180 --> 01:15:22,860
Πάω πίσω σε όλη τη διαδρομή προς την αρχή.

1209
01:15:22,860 --> 01:15:27,880
Θυμηθείτε, το κάνω αυτό, γιατί πρέπει να πάω στην αρχή για να το απελευθερώσει.

1210
01:15:27,880 --> 01:15:30,270
>> Έτσι, ξέρω ότι ήταν μια πολύ. Υπάρχουν ερωτήσεις;

1211
01:15:30,270 --> 01:15:31,870
Παρακαλώ, ναι;

1212
01:15:31,870 --> 01:15:36,610
[Ακατάληπτο ερώτημα Φοιτητών]

1213
01:15:36,610 --> 01:15:38,190
Μπορείτε να πείτε ότι πιο δυνατά; Λυπάμαι.

1214
01:15:38,190 --> 01:15:44,140
[Φοιτητικό] Την τελευταία διαφάνεια δεξιά προτού να απελευθερωθεί το δείκτη,

1215
01:15:44,140 --> 01:15:47,300
όπου ήταν που πραγματικά αλλάζει την τιμή του δείκτη;

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Έτσι, ακριβώς εδώ. >> [Φοιτητικό] Ω, εντάξει.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Έτσι, έχω ένα δείκτη μείον μείον, δεξιά,

1218
01:15:51,890 --> 01:15:54,140
που κινείται το πράγμα πίσω ένα, και στη συνέχεια θα το ελευθερώσει,

1219
01:15:54,140 --> 01:15:57,000
επειδή αυτό δείκτης πρέπει να επισημανθεί στην αρχή του πίνακα.

1220
01:15:57,000 --> 01:16:00,420
[Φοιτητικό] Αλλά αυτό δεν θα είχε χρειαστεί θα σταματήσει μετά από αυτή την γραμμή.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Έτσι, αν είχα σταματήσει μετά από αυτό, αυτό θα μπορούσε να θεωρηθεί μια διαρροή μνήμης,

1222
01:16:03,130 --> 01:16:04,810
επειδή δεν είχα τρέξει το δωρεάν.

1223
01:16:04,810 --> 01:16:11,290
[Φοιτητικό] Ι [ακατάληπτο] μετά από τις πρώτες τρεις γραμμές, όπου είχατε δείκτης +1 [ακατάληπτο].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Έτσι, ποιο είναι το θέμα εκεί;

1225
01:16:13,140 --> 01:16:14,780
Λυπάμαι. Όχι, όχι. Πηγαίνετε, πηγαίνετε, παρακαλώ.

1226
01:16:14,780 --> 01:16:16,870
[Φοιτητικό] Έτσι, δεν είστε αλλάζοντας την τιμή της δείκτες.

1227
01:16:16,870 --> 01:16:19,130
Μπορείτε δεν θα έπρεπε να κάνουμε δείκτη μείον μείον.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ναι, ακριβώς.

1229
01:16:19,730 --> 01:16:21,890
Έτσι, όταν κάνω δείκτης δείκτης +1 και +2,

1230
01:16:21,890 --> 01:16:24,410
Δεν το κάνω δείκτης ισούται με το δείκτη +1.

1231
01:16:24,410 --> 01:16:27,260
Έτσι, ο δείκτης παραμένει ακριβώς δείχνοντας στην αρχή του πίνακα.

1232
01:16:27,260 --> 01:16:31,460
Είναι μόνο όταν κάνω συν συν ότι θέτει την αξία πίσω στο εσωτερικό του δείκτη,

1233
01:16:31,460 --> 01:16:33,550
ότι κινείται στην πραγματικότητα αυτό μαζί.

1234
01:16:36,860 --> 01:16:37,780
Εντάξει.

1235
01:16:40,550 --> 01:16:42,030
Περισσότερες ερωτήσεις;

1236
01:16:44,680 --> 01:16:47,790
>> Και πάλι, αν αυτό είναι το είδος της συντριπτικής, αυτό θα καλυφθεί στη σύνοδο.

1237
01:16:47,790 --> 01:16:50,710
Ρωτήστε τους συναδέλφους σας διδασκαλία γι 'αυτό, και μπορούμε να απαντήσουμε στις ερωτήσεις στο τέλος.

1238
01:16:53,510 --> 01:16:56,600
Και συνήθως δεν ήθελα να κάνω αυτό το πράγμα μείον.

1239
01:16:56,600 --> 01:16:59,760
Αυτό πρέπει να απαιτεί από μένα να παρακολουθείτε πόσα έχω αντισταθμίζεται στον πίνακα.

1240
01:16:59,760 --> 01:17:04,520
Έτσι, σε γενικές γραμμές, αυτό είναι μόνο για να εξηγήσει πώς λειτουργεί η αριθμητική δείκτη.

1241
01:17:04,520 --> 01:17:07,970
Αλλά αυτό που συνήθως αρέσει να κάνουμε είναι να θέλουμε να δημιουργήσουμε ένα αντίγραφο του δείκτη,

1242
01:17:07,970 --> 01:17:11,640
και στη συνέχεια θα χρησιμοποιεί το εν λόγω αντίγραφο, όταν κινούμαστε γύρω στη συμβολοσειρά.

1243
01:17:11,640 --> 01:17:14,660
Έτσι, σε αυτές τις περιπτώσεις θα χρησιμοποιήσετε το αντίγραφο για να εκτυπώσετε το σύνολο εγχόρδων,

1244
01:17:14,660 --> 01:17:19,040
αλλά δεν έχουμε να κάνουμε σαν δείκτη μείον 6 ή να παρακολουθείτε πόσο προχωρήσαμε σε αυτό,

1245
01:17:19,040 --> 01:17:22,700
μόνο και μόνο επειδή γνωρίζουμε ότι το αρχικό σημείο μας εξακολουθεί να επισημάνει την αρχή της λίστας

1246
01:17:22,700 --> 01:17:25,340
και όλα αυτά που αλλάξαμε ήταν αυτό το αντίγραφο.

1247
01:17:25,340 --> 01:17:28,250
Έτσι, σε γενικές γραμμές, να αλλάξει τα αντίγραφα του αρχικού δείκτη σας.

1248
01:17:28,250 --> 01:17:32,350
Μην προσπαθήσετε να ταξινομήσετε όπως του - μην αλλάξει πρωτότυπα.

1249
01:17:32,350 --> 01:17:35,290
Προσπαθώντας να αλλάξει μόνο αντίγραφα της αρχικής σας.

1250
01:17:41,540 --> 01:17:44,870
Έτσι, θα παρατηρήσετε όταν περνάμε το string σε printf

1251
01:17:44,870 --> 01:17:48,990
δεν έχετε να βάλετε ένα αστέρι μπροστά του όπως κάναμε με όλες τις άλλες dereferences, έτσι δεν είναι;

1252
01:17:48,990 --> 01:17:54,180
Έτσι, εάν εκτυπώνετε από το σύνολο εγχόρδων s% αναμένει είναι μια διεύθυνση,

1253
01:17:54,180 --> 01:17:57,610
και στην περίπτωση αυτή ένας δείκτης ή στην περίπτωση αυτή, όπως μια σειρά από χαρακτήρες.

1254
01:17:57,610 --> 01:18:00,330
>> Χαρακτήρες, char * s, και συστοιχίες είναι το ίδιο πράγμα.

1255
01:18:00,330 --> 01:18:03,690
Ο δείκτης είναι χαρακτήρες, και συστοιχίες χαρακτήρας είναι το ίδιο πράγμα.

1256
01:18:03,690 --> 01:18:05,720
Και έτσι, το μόνο που έχουμε να κάνουμε είναι να περάσει στο δείκτη.

1257
01:18:05,720 --> 01:18:08,150
Δεν πρέπει να περάσει με τον ίδιο δείκτη του * ή κάτι τέτοιο.

1258
01:18:13,110 --> 01:18:14,930
Έτσι, πίνακες και δείκτες είναι το ίδιο πράγμα.

1259
01:18:14,930 --> 01:18:19,160
Όταν κάνεις κάτι σαν x [y] εδώ για έναν πίνακα,

1260
01:18:19,160 --> 01:18:21,960
τι κάνει κάτω από την κουκούλα είναι λέει, εντάξει, είναι μια σειρά χαρακτήρων,

1261
01:18:21,960 --> 01:18:23,690
γι 'αυτό είναι ένας δείκτης.

1262
01:18:23,690 --> 01:18:26,510
Και έτσι Χ είναι το ίδιο πράγμα,

1263
01:18:26,510 --> 01:18:28,650
και έτσι αυτό που κάνει είναι να προσθέτει y στο x,

1264
01:18:28,650 --> 01:18:31,820
το οποίο είναι το ίδιο πράγμα όπως κινείται προς τα εμπρός στη μνήμη τόσο πολύ.

1265
01:18:31,820 --> 01:18:34,930
Και τώρα x + y μας δίνει κάποια διεύθυνση,

1266
01:18:34,930 --> 01:18:37,570
και εμείς dereference τη διεύθυνση ή να ακολουθήσετε το βέλος

1267
01:18:37,570 --> 01:18:41,640
όπου η θέση είναι στη μνήμη και παίρνουμε την αξία από αυτή τη θέση στη μνήμη.

1268
01:18:41,640 --> 01:18:43,720
Έτσι, έτσι ώστε αυτά τα δύο είναι ακριβώς το ίδιο πράγμα.

1269
01:18:43,720 --> 01:18:45,840
Είναι απλά μια συντακτική ζάχαρη.

1270
01:18:45,840 --> 01:18:48,090
Κάνουν το ίδιο πράγμα. Είναι απλά διαφορετικές syntactics ένας για τον άλλον.

1271
01:18:51,500 --> 01:18:57,590
>> Έτσι, τι μπορεί να πάει στραβά με δείκτες; Όπως, πολύ. Εντάξει. Έτσι, τα κακά πράγματα.

1272
01:18:57,590 --> 01:19:02,410
Μερικά κακά πράγματα που μπορείτε να κάνετε δεν ελέγχουν αν malloc κλήση σας επιστρέφει null, έτσι δεν είναι;

1273
01:19:02,410 --> 01:19:06,560
Σε αυτή την περίπτωση, ρωτάω το σύστημα να μου δώσει - τι είναι αυτός ο αριθμός;

1274
01:19:06,560 --> 01:19:11,200
Like 2 δισεκατομμύρια φορές 4, επειδή το μέγεθος του ακεραίου είναι 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Είμαι αυτό που ζητούν σαν 8 δις bytes.

1276
01:19:13,810 --> 01:19:17,270
Φυσικά ο υπολογιστής μου δεν πρόκειται να είναι σε θέση να μου δώσει αυτό το πολύ πίσω μνήμης.

1277
01:19:17,270 --> 01:19:20,960
Και εμείς δεν ελέγχει αν αυτή είναι μηδενική, έτσι όταν προσπαθούμε να dereference το πάνω εκεί -

1278
01:19:20,960 --> 01:19:24,270
ακολουθήστε το βέλος στο σημείο όπου πρόκειται να - δεν έχουμε αυτή τη μνήμη.

1279
01:19:24,270 --> 01:19:27,150
Αυτό είναι αυτό που λέμε μια εύρεση τιμών null δείκτη.

1280
01:19:27,150 --> 01:19:29,710
Και αυτό προκαλεί ουσιαστικά να segfault.

1281
01:19:29,710 --> 01:19:31,790
Αυτός είναι ένας από τους τρόπους που μπορείτε να segfault.

1282
01:19:34,090 --> 01:19:38,090
Άλλες κακά πράγματα που μπορείτε να κάνετε - OH καλά.

1283
01:19:38,090 --> 01:19:40,650
Αυτό ήταν ένα εύρεση τιμών null δείκτη. Εντάξει.

1284
01:19:40,650 --> 01:19:45,160
Άλλες κακά πράγματα - και, για να καθορίσει ότι μόλις βάλατε μια επιταγή εκεί

1285
01:19:45,160 --> 01:19:46,980
ότι ελέγχει αν ο δείκτης είναι null

1286
01:19:46,980 --> 01:19:51,000
και την έξοδο από το πρόγραμμα, εφόσον αυτό συμβαίνει ότι malloc επιστρέφει null δείκτη.

1287
01:19:55,110 --> 01:19:59,850
Αυτό είναι το xkcd κόμικ. Οι άνθρωποι το καταλαβαίνουν τώρα. Ταξινόμηση του.

1288
01:20:06,120 --> 01:20:09,350
>> Έτσι, η μνήμη. Και πήγα πάνω από αυτό.

1289
01:20:09,350 --> 01:20:12,000
Καλούμε malloc σε έναν βρόχο, αλλά κάθε φορά που λέμε malloc

1290
01:20:12,000 --> 01:20:14,370
χάνουμε κομμάτι της όπου αυτό δείκτης δείχνει να,

1291
01:20:14,370 --> 01:20:15,750
γιατί είμαστε το πειράζουν.

1292
01:20:15,750 --> 01:20:18,410
Έτσι, η αρχική κλήση μου δίνει malloc μνήμη εδώ.

1293
01:20:18,410 --> 01:20:19,990
Δείκτες δείκτη μου σε αυτό.

1294
01:20:19,990 --> 01:20:23,020
Τώρα, εγώ δεν μπορώ να το ελευθερώσει, έτσι και τώρα καλώ και πάλι malloc.

1295
01:20:23,020 --> 01:20:26,070
Τώρα επισημαίνει εδώ. Τώρα η μνήμη μου είναι στραμμένο προς τα εδώ.

1296
01:20:26,070 --> 01:20:27,640
Υπογραμμίζοντας εδώ. Υπογραμμίζοντας εδώ.

1297
01:20:27,640 --> 01:20:31,820
Αλλά έχω χάσει τα ίχνη από τις διευθύνσεις όλων των μνήμη πάνω από εδώ που διατίθενται.

1298
01:20:31,820 --> 01:20:35,100
Και έτσι τώρα δεν έχω καμία σχέση με αυτούς πια.

1299
01:20:35,100 --> 01:20:37,230
Έτσι, δεν μπορώ να τους απελευθερώσει έξω από αυτόν τον βρόχο.

1300
01:20:37,230 --> 01:20:39,390
Και έτσι για να διορθώσετε κάτι τέτοιο,

1301
01:20:39,390 --> 01:20:42,250
αν ξεχάσετε την ελεύθερη μνήμη και μπορείτε να πάρετε αυτή την διαρροή μνήμης,

1302
01:20:42,250 --> 01:20:45,810
Θα πρέπει να ελευθερώσετε τη μνήμη μέσα από αυτό το βρόχο μόλις τελειώσετε με αυτό.

1303
01:20:45,810 --> 01:20:51,400
Λοιπόν, αυτό είναι ό, τι συμβαίνει. Ξέρω πολλά μισείτε αυτό.

1304
01:20:51,400 --> 01:20:55,270
Αλλά τώρα - yay! Μπορείτε να πάρετε σαν 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Έτσι, μπορείτε να ελευθερώσετε στο τέλος του βρόχου,

1306
01:20:57,110 --> 01:20:59,770
και ότι πρόκειται απλά να ελευθερώσετε τη μνήμη κάθε φορά.

1307
01:20:59,770 --> 01:21:03,620
Ουσιαστικά, το πρόγραμμά σας δεν έχει μια διαρροή μνήμης πια.

1308
01:21:03,620 --> 01:21:08,150
>> Και τώρα κάτι άλλο που μπορείτε να κάνετε είναι να ελευθερώσετε μνήμη που έχετε ζητήσει δύο φορές.

1309
01:21:08,150 --> 01:21:11,060
Σε αυτή την περίπτωση, κάτι malloc, μπορείτε να αλλάξετε την αξία του.

1310
01:21:11,060 --> 01:21:13,140
Μπορείτε να ελευθερώσετε μία φορά, επειδή είπατε ότι έγιναν με αυτό.

1311
01:21:13,140 --> 01:21:14,940
Αλλά τότε θα ελευθερωθεί ξανά.

1312
01:21:14,940 --> 01:21:16,730
Αυτό είναι κάτι που είναι πολύ κακή.

1313
01:21:16,730 --> 01:21:18,820
Δεν πρόκειται να segfault αρχικά,

1314
01:21:18,820 --> 01:21:23,350
αλλά μετά από λίγο τι είναι αυτό που κάνει είναι διπλή απελευθέρωση διαφθείρει τη δομή αυτού του σωρού σας,

1315
01:21:23,350 --> 01:21:27,200
και θα μάθετε λίγο περισσότερα γι 'αυτό, αν επιλέξετε να πάρετε μια τάξη, όπως CS61.

1316
01:21:27,200 --> 01:21:30,000
Αλλά ουσιαστικά μετά από λίγο ο υπολογιστής σας πρόκειται να μπερδευτείτε

1317
01:21:30,000 --> 01:21:33,010
Σχετικά με το τι είναι οι θέσεις μνήμης όπου και όπου είναι αποθηκευμένο -

1318
01:21:33,010 --> 01:21:34,800
όπου τα δεδομένα αποθηκεύονται στη μνήμη.

1319
01:21:34,800 --> 01:21:38,080
Και απελευθερώνοντας έτσι ένα δείκτη δύο φορές είναι ένα κακό πράγμα που δεν θέλετε να το κάνετε.

1320
01:21:38,080 --> 01:21:41,600
>> Άλλα πράγματα που μπορεί να πάει στραβά δεν χρησιμοποιεί sizeof.

1321
01:21:41,600 --> 01:21:44,460
Έτσι, σε αυτή την περίπτωση θα malloc 8 byte,

1322
01:21:44,460 --> 01:21:46,700
και ότι είναι το ίδιο πράγμα με δύο ακέραιους αριθμούς, έτσι δεν είναι;

1323
01:21:46,700 --> 01:21:49,580
Έτσι, αυτό είναι απόλυτα ασφαλές, αλλά είναι αυτό;

1324
01:21:49,580 --> 01:21:52,160
Λοιπόν, ως Lucas μίλησε για διαφορετικές αρχιτεκτονικές,

1325
01:21:52,160 --> 01:21:54,220
ακέραιοι έχουν διαφορετικά μήκη.

1326
01:21:54,220 --> 01:21:57,970
Έτσι, με τη συσκευή που χρησιμοποιείτε, ακέραιοι είναι περίπου 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
αλλά σε κάποιο άλλο σύστημα που θα μπορούσε να είναι 8 bytes ή θα μπορούσαν να είναι 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Έτσι, αν μπορώ να χρησιμοποιήσω μόνο τον αριθμό αυτό πάνω από εδώ,

1329
01:22:05,680 --> 01:22:07,310
το πρόγραμμα αυτό θα μπορούσε να λειτουργήσει στη συσκευή,

1330
01:22:07,310 --> 01:22:10,360
αλλά δεν πρόκειται να διαθέσει αρκετή μνήμη για κάποιο άλλο σύστημα.

1331
01:22:10,360 --> 01:22:14,020
Σε αυτή την περίπτωση, αυτό είναι που ο χειριστής sizeof χρησιμοποιείται για.

1332
01:22:14,020 --> 01:22:16,880
Όταν λέμε sizeof (int), τι είναι αυτό που κάνει είναι να

1333
01:22:16,880 --> 01:22:21,910
 μας δίνει το μέγεθος του ακεραίου στο σύστημα ότι το πρόγραμμα εκτελείται.

1334
01:22:21,910 --> 01:22:25,490
Έτσι, στην περίπτωση αυτή, sizeof (int) θα επιστρέψει 4 για κάτι σαν τη συσκευή,

1335
01:22:25,490 --> 01:22:29,980
και τώρα αυτή η βούληση 4 * 2, η οποία είναι 8,

1336
01:22:29,980 --> 01:22:32,330
το οποίο είναι ακριβώς το ποσό του χώρου που απαιτείται για δύο ακέραιους αριθμούς.

1337
01:22:32,330 --> 01:22:36,710
Σε ένα διαφορετικό σύστημα, αν ένας int είναι σαν 16 byte ή 8 bytes,

1338
01:22:36,710 --> 01:22:39,380
είναι ακριβώς πρόκειται να επιστρέψει αρκετά bytes για την αποθήκευση αυτό το ποσό.

1339
01:22:41,830 --> 01:22:45,310
>> Και τέλος, structs.

1340
01:22:45,310 --> 01:22:48,340
Έτσι, αν θέλετε να αποθηκεύσετε ένα sudoku συμβούλιο στη μνήμη, πώς να το κάνουμε αυτό;

1341
01:22:48,340 --> 01:22:51,570
Μπορείτε να σκεφτείτε σαν μια μεταβλητή για το πρώτο πράγμα που,

1342
01:22:51,570 --> 01:22:53,820
μια μεταβλητή για το δεύτερο πράγμα, μια μεταβλητή για το τρίτο πράγμα,

1343
01:22:53,820 --> 01:22:56,420
μια μεταβλητή για το τέταρτο πράγμα - κακό, έτσι δεν είναι;

1344
01:22:56,420 --> 01:23:00,750
Έτσι, μια βελτίωση που μπορείτε να κάνετε πάνω από αυτό είναι να γίνει ένα 9 x 9 πίνακα.

1345
01:23:00,750 --> 01:23:04,480
Αυτό είναι ωραία, αλλά τι γίνεται αν ήθελε να συνδέσει άλλα πράγματα με το διοικητικό συμβούλιο sudoku

1346
01:23:04,480 --> 01:23:06,490
όπως αυτό που η δυσκολία του πλοίου,

1347
01:23:06,490 --> 01:23:11,740
ή, για παράδειγμα, ποια είναι η βαθμολογία σας, ή πόσο χρόνο έχει πάρει σας για να λύσει αυτό το συμβούλιο;

1348
01:23:11,740 --> 01:23:14,970
Λοιπόν, τι μπορείτε να κάνετε είναι να δημιουργήσετε ένα struct.

1349
01:23:14,970 --> 01:23:18,910
Τι είμαι βασικά λέγοντας ότι είναι Είμαι καθορισμό αυτής της δομής πάνω από εδώ,

1350
01:23:18,910 --> 01:23:23,230
Είμαι και τον καθορισμό ενός sudoku συμβούλιο το οποίο αποτελείται από ένα διοικητικό συμβούλιο που είναι 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Και ό, τι έχει να έχει δείκτες στο όνομα του επιπέδου.

1352
01:23:26,650 --> 01:23:30,730
Έχει, επίσης, x και y, που είναι οι συντεταγμένες του πού είμαι τώρα.

1353
01:23:30,730 --> 01:23:35,980
Έχει επίσης το χρόνο που δαπανάται [ακατάληπτο], και έχει τον συνολικό αριθμό των κινήσεων που έχω εισάγεται μέχρι τώρα.

1354
01:23:35,980 --> 01:23:40,010
Και έτσι σε αυτή την περίπτωση, μπορώ να ομαδοποιήσετε ένα σωρό των δεδομένων σε μία μόνο δομή

1355
01:23:40,010 --> 01:23:42,790
αντί να πετούν γύρω σαν σε διάφορες μεταβλητές, όπως

1356
01:23:42,790 --> 01:23:44,540
ότι δεν μπορώ να κρατήσει πραγματικά κομμάτι της.

1357
01:23:44,540 --> 01:23:49,720
Και αυτό μας επιτρέπει να έχουν μόνο ωραία σύνταξη για το είδος των παραπομπών διαφορετικά πράγματα μέσα από αυτό το struct.

1358
01:23:49,720 --> 01:23:53,430
Δεν μπορώ ακριβώς να κάνω board.board, και παίρνω το sudoku πλακέτα πίσω.

1359
01:23:53,430 --> 01:23:56,320
Board.level, παίρνω πόσο δύσκολο είναι.

1360
01:23:56,320 --> 01:24:00,540
Board.x και board.y να μου δώσει τις συντεταγμένες του, όπου θα μπορούσε να είναι στο διοικητικό συμβούλιο.

1361
01:24:00,540 --> 01:24:04,730
Και έτσι είμαι πρόσβαση σε αυτό που ονομάζουμε πεδία του struct.

1362
01:24:04,730 --> 01:24:08,840
Αυτό ορίζει sudokuBoard, η οποία είναι ένας τύπος που έχω.

1363
01:24:08,840 --> 01:24:14,800
Και τώρα είμαστε εδώ. Έχω μια μεταβλητή που ονομάζεται "συμβούλιο" του sudokuBoard τύπου.

1364
01:24:14,800 --> 01:24:18,820
Και έτσι τώρα μπορώ να έχουν πρόσβαση όλα τα πεδία που συνθέτουν αυτή τη δομή εδώ.

1365
01:24:20,830 --> 01:24:22,450
>> Οποιεσδήποτε ερωτήσεις σχετικά με structs; Ναι;

1366
01:24:22,450 --> 01:24:25,890
[Φοιτητικό] Για int x, y, δηλώσατε και οι δύο σε μια γραμμή; >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Φοιτητικό] Έτσι, θα μπορούσατε να κάνετε ακριβώς αυτό με όλα αυτά;

1368
01:24:27,400 --> 01:24:31,200
Όπως και σε x, y κόμμα φορές ότι η συνολική;

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ναι, θα μπορούσατε να κάνετε σίγουρα ότι, αλλά ο λόγος που έβαλα x και y στην ίδια γραμμή -

1370
01:24:34,460 --> 01:24:36,330
και το ερώτημα είναι γιατί μπορούμε να κάνουμε αυτό ακριβώς στην ίδια γραμμή;

1371
01:24:36,330 --> 01:24:38,600
Γιατί δεν βάζουμε απλώς όλα αυτά στην ίδια γραμμή είναι

1372
01:24:38,600 --> 01:24:42,090
χ και γ συνδέονται μεταξύ τους,

1373
01:24:42,090 --> 01:24:44,780
και αυτό είναι μόνο στυλιστικά πιο σωστό, κατά μία έννοια,

1374
01:24:44,780 --> 01:24:46,600
επειδή είναι ομαδοποίηση δύο πράγματα στην ίδια γραμμή

1375
01:24:46,600 --> 01:24:49,340
ότι σαν είδος σχετίζονται με το ίδιο πράγμα.

1376
01:24:49,340 --> 01:24:51,440
Και εγώ μόλις χωρίσει χώρια αυτά. Είναι απλά ένα θέμα στυλ.

1377
01:24:51,440 --> 01:24:53,720
Δεν κάνει καμία διαφορά λειτουργικά απολύτως.

1378
01:24:58,150 --> 01:24:59,270
Οποιεσδήποτε άλλες ερωτήσεις σχετικά με structs;

1379
01:25:03,030 --> 01:25:06,620
Μπορείτε να ορίσετε ένα Pokédex με ένα struct.

1380
01:25:06,620 --> 01:25:11,720
Ένα Pokémon έχει έναν αριθμό και ένα γράμμα, ένας ιδιοκτήτης, ένας τύπος.

1381
01:25:11,720 --> 01:25:16,990
Και στη συνέχεια, αν έχετε μια σειρά από Pokémon, μπορείτε να κάνετε μια Pokédex, έτσι δεν είναι;

1382
01:25:16,990 --> 01:25:20,810
Εντάξει, δροσερό. Έτσι, ερωτήματα σχετικά με structs. Αυτοί είναι που σχετίζονται με structs.

1383
01:25:20,810 --> 01:25:25,270
>> Τέλος, GDB. Τι σημαίνει GDB σας επιτρέπουν να το κάνετε; Σας επιτρέπει να διορθώσετε το πρόγραμμά σας.

1384
01:25:25,270 --> 01:25:27,650
Και αν δεν έχετε χρησιμοποιήσει GDB, θα ήθελα να συνιστάται βλέποντας το μικρό

1385
01:25:27,650 --> 01:25:31,250
και απλώς πηγαίνει πέρα ​​από ό, τι GDB είναι, πώς μπορείτε να εργαστείτε με αυτό, πώς μπορείτε να το χρησιμοποιήσετε,

1386
01:25:31,250 --> 01:25:32,900
και δοκιμάστε το σε ένα πρόγραμμα.

1387
01:25:32,900 --> 01:25:37,400
Και έτσι αυτό που GDB σας επιτρέπει να κάνετε είναι να αφήνει το παύση [ακατάληπτο] το πρόγραμμά σας

1388
01:25:37,400 --> 01:25:38,920
και ένα πρακτικό γραμμή.

1389
01:25:38,920 --> 01:25:42,600
Για παράδειγμα, θέλω να σε παύση εκτέλεσης, όπως τη γραμμή 3 του προγράμματός μου,

1390
01:25:42,600 --> 01:25:46,010
και ενώ είμαι σε γραμμή 3 μπορώ να εκτυπώσετε όλες τις τιμές που υπάρχουν.

1391
01:25:46,010 --> 01:25:49,710
Και έτσι αυτό που λέμε σαν παύσεις σε μια γραμμή

1392
01:25:49,710 --> 01:25:52,350
είναι αυτό που λέμε βάζοντας ένα breakpoint σε αυτή τη γραμμή

1393
01:25:52,350 --> 01:25:55,920
και στη συνέχεια μπορούμε να τυπώσουμε τις μεταβλητές για την κατάσταση του προγράμματος εκείνη τη στιγμή.

1394
01:25:55,920 --> 01:25:58,990
>> Μπορούμε στη συνέχεια από το βήμα εκεί μέσω του προγράμματος γραμμή-γραμμή.

1395
01:25:58,990 --> 01:26:03,200
Και τότε μπορούμε να εξετάσουμε την κατάσταση της στοίβας κατά τη χρονική στιγμή.

1396
01:26:03,200 --> 01:26:08,600
Και έτσι για να χρησιμοποιήσετε GDB, αυτό που κάνουμε είναι που λέμε κλαγγή στο αρχείο C,

1397
01:26:08,600 --> 01:26:11,290
αλλά πρέπει να περάσουμε αυτό το-ggdb σημαία.

1398
01:26:11,290 --> 01:26:15,850
Και μόλις τελειώσετε με αυτό θα τρέξει μόνο gdb για το τελικό αρχείο εξόδου.

1399
01:26:15,850 --> 01:26:18,810
Και έτσι μπορείτε να πάρετε κάποια σαν μάζα του κειμένου, όπως αυτό,

1400
01:26:18,810 --> 01:26:21,990
αλλά πραγματικά το μόνο που έχετε να κάνετε είναι να πληκτρολογήσετε εντολές στην αρχή.

1401
01:26:21,990 --> 01:26:24,250
Σπάστε κύρια βάζει ένα breakpoint στο κύριο.

1402
01:26:24,250 --> 01:26:28,470
Λίστα 400 παραθέτει τις γραμμές του κώδικα γύρω από τη γραμμή 400.

1403
01:26:28,470 --> 01:26:31,410
Και έτσι σε αυτή την περίπτωση μπορείτε απλά να κοιτάξουμε γύρω μας και να πούμε, OH,

1404
01:26:31,410 --> 01:26:34,360
Θέλω να ορίσετε ένα breakpoint στη γραμμή 397, που είναι η γραμμή,

1405
01:26:34,360 --> 01:26:37,170
και στη συνέχεια, το πρόγραμμα σας τρέχει σε αυτό το βήμα και πρόκειται να σπάσει.

1406
01:26:37,170 --> 01:26:41,120
Είναι πρόκειται να σταματήσει εκεί, και μπορείτε να εκτυπώσετε, για παράδειγμα, η αξία των χαμηλών ή υψηλών.

1407
01:26:41,120 --> 01:26:46,410
Και έτσι υπάρχει μια δέσμη των εντολών που πρέπει να ξέρετε,

1408
01:26:46,410 --> 01:26:48,660
και αυτή η παρουσίαση θα ανεβαίνουν στην ιστοσελίδα της,

1409
01:26:48,660 --> 01:26:54,000
οπότε αν απλά θέλετε να αναφοράς αυτών ή ήθελε να τους εξαπατήσει σχετικά με τα φύλλα σας, μη διστάσετε.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Αυτό ήταν Quiz Αξιολόγηση 0, και θα μείνω, αν έχετε οποιεσδήποτε ερωτήσεις.

1411
01:27:00,650 --> 01:27:03,850
Εντάξει.

1412
01:27:03,850 --> 01:27:09,030
>>  [Χειροκροτήματα]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]