1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Ενότητα 6] [Περισσότερα Άνετα]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Πανεπιστήμιο του Χάρβαρντ]

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

4
00:00:09,000 --> 00:00:11,000
>> Μπορούμε να κατευθυνθείτε προς το τμήμα μας ερωτήσεις.

5
00:00:11,000 --> 00:00:17,000
Έστειλα το URL για το διάστημα πριν.

6
00:00:17,000 --> 00:00:22,000
Η αρχή της ενότητας των ερωτήσεων πω-

7
00:00:22,000 --> 00:00:26,000
προφανώς δεν είμαι απόλυτα unsick-είναι μια πολύ εύκολη ερώτηση

8
00:00:26,000 --> 00:00:28,000
του τι ακριβώς είναι Valgrind;

9
00:00:28,000 --> 00:00:30,000
Τι σημαίνει valgrind κάνουμε;

10
00:00:30,000 --> 00:00:34,000
Όποιος θέλει να πει ό, τι valgrind κάνει;

11
00:00:34,000 --> 00:00:36,000
[Φοιτητικό] Έλεγχοι διαρροών μνήμης.

12
00:00:36,000 --> 00:00:41,000
Ναι, valgrind είναι ένας γενικός ελεγκτής μνήμης.

13
00:00:41,000 --> 00:00:44,000
Είναι, σε τελική ανάλυση, σας λέει αν έχετε τυχόν διαρροές μνήμης,

14
00:00:44,000 --> 00:00:49,000
η οποία είναι ως επί το πλείστον αυτό που το χρησιμοποιείτε για, γιατί, αν θέλετε να

15
00:00:49,000 --> 00:00:54,000
κάνουν καλά στο σύνολο πρόβλημα ή αν θέλετε να

16
00:00:54,000 --> 00:00:59,000
να πάρει την μεγάλη του σκάφους, θα πρέπει να έχετε κανένα απολύτως διαρροές μνήμης,

17
00:00:59,000 --> 00:01:01,000
και σε περίπτωση που έχετε μια διαρροή μνήμης που δεν μπορείτε να βρείτε,

18
00:01:01,000 --> 00:01:04,000
Επίσης, να έχετε κατά νου ότι κάθε φορά που ανοίγετε ένα αρχείο

19
00:01:04,000 --> 00:01:07,000
και αν δεν το κλείσει, αυτό είναι μια διαρροή μνήμης.

20
00:01:07,000 --> 00:01:10,000
>> Πολλοί άνθρωποι ψάχνουν για κάποιο κόμβο ότι δεν είστε απελευθερώνοντας

21
00:01:10,000 --> 00:01:15,000
όταν πραγματικά, δεν κλείσει το λεξικό στο πρώτο βήμα.

22
00:01:15,000 --> 00:01:19,000
Επίσης, σας ενημερώνει αν έχετε οποιαδήποτε άκυρη διαβάζει ή γράφει,

23
00:01:19,000 --> 00:01:22,000
το οποίο σημαίνει ότι αν προσπαθήσετε και να ορίσετε μια τιμή

24
00:01:22,000 --> 00:01:26,000
αυτό είναι πέρα ​​από το τέλος του σωρού και αυτό δεν συμβαίνει σε seg σφάλμα

25
00:01:26,000 --> 00:01:30,000
αλλά valgrind πιάνει, δεδομένου ότι δεν θα πρέπει πραγματικά να γράφει εκεί,

26
00:01:30,000 --> 00:01:33,000
και έτσι σίγουρα δεν πρέπει να έχουν κανένα από αυτά είτε.

27
00:01:33,000 --> 00:01:38,000
Πώς μπορείτε να χρησιμοποιήσετε Valgrind;

28
00:01:38,000 --> 00:01:42,000
Πώς μπορείτε να χρησιμοποιήσετε Valgrind;

29
00:01:42,000 --> 00:01:45,000
>> Είναι ένα γενικό ζήτημα της

30
00:01:45,000 --> 00:01:49,000
είδος του να τρέξει και να δούμε την έξοδο.

31
00:01:49,000 --> 00:01:51,000
Η έξοδος υπερισχύει πολλές φορές.

32
00:01:51,000 --> 00:01:54,000
Υπάρχει επίσης διασκέδαση όπου τα λάθη, αν έχετε κάποια τρομερά λάθος πράγμα

33
00:01:54,000 --> 00:01:59,000
συμβαίνει σε έναν βρόχο, τότε τελικά θα πει, "Way πάρα πολλά λάθη.

34
00:01:59,000 --> 00:02:03,000
Πάω να σταματήσει την καταμέτρηση τώρα. "

35
00:02:03,000 --> 00:02:08,000
Είναι βασικά κειμένου εξόδου που θα πρέπει να αναλύσει.

36
00:02:08,000 --> 00:02:13,000
Στο τέλος, θα σας πω τυχόν διαρροές μνήμης που έχετε,

37
00:02:13,000 --> 00:02:16,000
πόσες ομάδες, η οποία μπορεί να είναι χρήσιμα διότι

38
00:02:16,000 --> 00:02:20,000
αν είναι ένα unfreed μπλοκ, τότε είναι συνήθως πιο εύκολο να βρείτε

39
00:02:20,000 --> 00:02:23,000
από 1.000 μπλοκ unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 τεμάχια unfreed σημαίνει ότι κατά πάσα πιθανότητα δεν είστε απελευθερώνοντας

41
00:02:26,000 --> 00:02:30,000
συνδεδεμένες λίστες σας σωστά ή κάτι τέτοιο.

42
00:02:30,000 --> 00:02:32,000
Που είναι Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Τώρα έχουμε το τμήμα μας ερωτήσεις,

44
00:02:35,000 --> 00:02:38,000
το οποίο δεν χρειάζεται να κατεβάσετε.

45
00:02:38,000 --> 00:02:41,000
Μπορείτε να κάνετε κλικ στο όνομά μου και τραβήξτε τους στο χώρο.

46
00:02:41,000 --> 00:02:44,000
Τώρα κάντε κλικ πάνω μου.

47
00:02:44,000 --> 00:02:46,000
Αναθεώρηση 1 θα είναι στοίβα, που κάνουμε πρώτα.

48
00:02:46,000 --> 00:02:55,000
Αναθεώρηση 2 θα είναι ουρά, και Αναθεώρηση 3 θα είναι η κατά μόνας συνδεδεμένη λίστα.

49
00:02:55,000 --> 00:02:58,000
Ξεκινώντας με το stack μας.

50
00:02:58,000 --> 00:03:02,000
Όπως λέει εδώ, μια στοίβα είναι ένα από τα πιο βασικά,

51
00:03:02,000 --> 00:03:07,000
θεμελιώδεις δομές δεδομένων της επιστήμης των υπολογιστών.

52
00:03:07,000 --> 00:03:11,000
Η πολύ πρωτότυπο παράδειγμα είναι

53
00:03:11,000 --> 00:03:13,000
η στοίβα των δίσκων στην τραπεζαρία.

54
00:03:13,000 --> 00:03:16,000
Είναι βασικά κάθε φορά που εισάγονται σε μια στοίβα,

55
00:03:16,000 --> 00:03:20,000
κάποιος πρόκειται να πει, "Ω, σαν μια στοίβα των δίσκων."

56
00:03:20,000 --> 00:03:22,000
Μπορείτε στοίβα τους δίσκους επάνω.

57
00:03:22,000 --> 00:03:24,000
Στη συνέχεια, όταν θα πάτε για να τραβήξει ένα δίσκο,

58
00:03:24,000 --> 00:03:31,000
ο πρώτος δίσκος που είναι να πάρει τράβηξε είναι ο τελευταίος που τέθηκε στη στοίβα.

59
00:03:31,000 --> 00:03:34,000
Η στοίβα επίσης-όπως λέει-εδώ

60
00:03:34,000 --> 00:03:37,000
έχουμε το τμήμα της μνήμης που ονομάζεται η στοίβα.

61
00:03:37,000 --> 00:03:40,000
Και γιατί είναι αυτό που ονομάζεται η στοίβα;

62
00:03:40,000 --> 00:03:42,000
>> Επειδή σαν μια δομή δεδομένων στοίβα,

63
00:03:42,000 --> 00:03:46,000
ωθεί και σκάει πλαίσια στοίβα στη στοίβα,

64
00:03:46,000 --> 00:03:53,000
όπου στοίβα καρέ είναι σαν μια ειδική πρόσκληση μιας συνάρτησης.

65
00:03:53,000 --> 00:03:57,000
Και όπως μια στοίβα, θα πρέπει πάντα να επιστρέψετε

66
00:03:57,000 --> 00:04:03,000
από μια κλήση συνάρτησης για να μπορέσετε να κατεβείτε σε χαμηλότερα πλαίσια στοίβα πάλι.

67
00:04:03,000 --> 00:04:08,000
Δεν μπορείτε να έχουν την κύρια γραμμή κλήσης foo κλήση και να επιστρέψετε στην κύρια γραμμή άμεσα.

68
00:04:08,000 --> 00:04:14,000
Είναι πάντα έχεις να ακολουθήσετε τη σωστή στοίβα πιέζει και σκάει.

69
00:04:14,000 --> 00:04:18,000
Οι δύο πράξεις, όπως είπα, είναι push και pop.

70
00:04:18,000 --> 00:04:20,000
Αυτά είναι καθολική άποψη.

71
00:04:20,000 --> 00:04:26,000
Θα πρέπει να γνωρίζετε ώθηση και ποπ άποψη των στοίβες δεν το θέμα αυτό.

72
00:04:26,000 --> 00:04:28,000
Θα δούμε ουρές είναι το είδος των διαφορετικών.

73
00:04:28,000 --> 00:04:32,000
Δεν έχει πραγματικά μια καθολική θητεία, αλλά ώθηση και pop είναι καθολική για στοίβες.

74
00:04:32,000 --> 00:04:34,000
Push είναι μόλις τεθεί στη στοίβα.

75
00:04:34,000 --> 00:04:37,000
Pop είναι απογειωθεί τη στοίβα.

76
00:04:37,000 --> 00:04:43,000
Και βλέπουμε εδώ έχουμε typedef struct στοίβα μας,

77
00:04:43,000 --> 00:04:46,000
έτσι έχουμε char ** χορδές.

78
00:04:46,000 --> 00:04:51,000
Μην φοβάστε να πάρετε από οποιαδήποτε **.

79
00:04:51,000 --> 00:04:54,000
Αυτό πρόκειται να καταλήξει να είναι μια σειρά από χορδές

80
00:04:54,000 --> 00:04:58,000
ή μια σειρά από δείκτες σε χαρακτήρες, όπου

81
00:04:58,000 --> 00:05:00,000
δείκτες σε χαρακτήρες τείνουν να είναι χορδές.

82
00:05:00,000 --> 00:05:05,000
Δεν πρέπει να είναι χορδές, αλλά εδώ, από όπου και αν πρόκειται να είναι χορδές.

83
00:05:05,000 --> 00:05:08,000
>> Έχουμε μια σειρά από χορδές.

84
00:05:08,000 --> 00:05:14,000
Έχουμε ένα μέγεθος, το οποίο αντιπροσωπεύει πόσα στοιχεία είναι σήμερα στην στοίβα,

85
00:05:14,000 --> 00:05:19,000
και τότε έχουμε την ικανότητα, η οποία είναι πόσα στοιχεία μπορεί να είναι στη στοίβα.

86
00:05:19,000 --> 00:05:22,000
Η χωρητικότητα θα πρέπει να ξεκινήσει ως κάτι μεγαλύτερο από 1,

87
00:05:22,000 --> 00:05:27,000
αλλά το μέγεθος πρόκειται να ξεκινήσει ως 0.

88
00:05:27,000 --> 00:05:36,000
Τώρα, υπάρχουν βασικά τρεις διαφορετικοί τρόποι που μπορείτε να σκεφτείτε μια στοίβα.

89
00:05:36,000 --> 00:05:39,000
Λοιπόν, υπάρχουν πιθανώς περισσότερο, αλλά οι δύο βασικοί τρόποι είναι

90
00:05:39,000 --> 00:05:43,000
μπορείτε να το εφαρμόσουν χρησιμοποιώντας μια σειρά, ή μπορείτε να το εφαρμόσουν χρησιμοποιώντας μια συνδεδεμένη λίστα.

91
00:05:43,000 --> 00:05:48,000
Συνδέεται λίστες είναι το είδος των ασήμαντο για να κάνουν στοίβες από.

92
00:05:48,000 --> 00:05:51,000
Είναι πολύ εύκολο να κάνει μια στοίβα χρησιμοποιώντας συνδεδεμένες λίστες,

93
00:05:51,000 --> 00:05:55,000
έτσι και εδώ, θα πάμε για να κάνει μια στοίβα με συστοιχίες,

94
00:05:55,000 --> 00:05:59,000
και στη συνέχεια, χρησιμοποιώντας πίνακες, υπάρχει επίσης δύο τρόποι που μπορείτε να το σκεφτώ.

95
00:05:59,000 --> 00:06:01,000
Πριν, όταν είπα έχουμε μια ικανότητα για τη στοίβα,

96
00:06:01,000 --> 00:06:04,000
έτσι ώστε να μπορούν να χωρέσουν ένα στοιχείο στη στοίβα.

97
00:06:04,000 --> 00:06:09,000
>> Ο ένας τρόπος θα μπορούσε να συμβεί είναι το συντομότερο να χτυπήσει 10 στοιχεία, τότε είστε έτοιμοι.

98
00:06:09,000 --> 00:06:13,000
Ίσως γνωρίζετε ότι υπάρχει ένα άνω φράγμα των 10 πράγματα στον κόσμο

99
00:06:13,000 --> 00:06:16,000
ότι δεν θα χρειαστεί περισσότερο από 10 πράγματα για το stack σας,

100
00:06:16,000 --> 00:06:20,000
περίπτωση κατά την οποία μπορείτε να έχετε ένα ανώτατο όριο για το μέγεθος του stack σας.

101
00:06:20,000 --> 00:06:23,000
Ή θα μπορούσατε να έχετε το stack σας είναι απεριόριστη,

102
00:06:23,000 --> 00:06:27,000
αλλά αν κάνετε μια σειρά, αυτό σημαίνει ότι κάθε φορά που θα χτυπήσει 10 στοιχεία,

103
00:06:27,000 --> 00:06:29,000
τότε θα πάμε να πρέπει να αυξηθεί σε 20 στοιχεία, και όταν χτύπησε 20 στοιχεία,

104
00:06:29,000 --> 00:06:33,000
εσείς πρόκειται να πρέπει να αυξηθεί σειρά σας στοιχεία σε 30 ή 40 στοιχεία.

105
00:06:33,000 --> 00:06:37,000
Θα πάμε να πρέπει να αυξηθεί η ικανότητα, η οποία είναι αυτό που πάμε να κάνουμε εδώ.

106
00:06:37,000 --> 00:06:40,000
Κάθε φορά που φθάνουν το μέγιστο μέγεθος του stack μας,

107
00:06:40,000 --> 00:06:46,000
όταν πιέζουμε για κάτι άλλο, θα πάμε να χρειαστεί να αυξηθεί η χωρητικότητα.

108
00:06:46,000 --> 00:06:50,000
Εδώ, έχουμε δηλωθεί ως ώθηση ώθηση bool (char str *).

109
00:06:50,000 --> 00:06:54,000
Char str * είναι η συμβολοσειρά που πιέζουμε πάνω στη στοίβα,

110
00:06:54,000 --> 00:06:58,000
bool και λέει μόνο αν θα επιτύχει ή αποτύχει.

111
00:06:58,000 --> 00:07:00,000
>> Πώς μπορούμε να αποτύχει;

112
00:07:00,000 --> 00:07:04,000
Ποια είναι η μόνη περίσταση που μπορείτε να σκεφτείτε

113
00:07:04,000 --> 00:07:07,000
όπου θα πρέπει να επιστρέψει false;

114
00:07:07,000 --> 00:07:09,000
Ναι.

115
00:07:09,000 --> 00:07:12,000
[Φοιτητικό] Αν είναι πλήρης και είμαστε χρησιμοποιώντας μια εφαρμογή που οριοθετείται.

116
00:07:12,000 --> 00:07:17,000
Ναι, ναι, πώς ορίζουμε-απάντησε

117
00:07:17,000 --> 00:07:23,000
αν είναι πλήρης και είμαστε χρησιμοποιώντας ένα φραγμένο εφαρμογή.

118
00:07:23,000 --> 00:07:26,000
Στη συνέχεια, θα επιστρέψει σίγουρα ψευδής.

119
00:07:26,000 --> 00:07:31,000
Από τη στιγμή που θα χτυπήσει 10 πράγματα στον πίνακα, δεν μπορεί να χωρέσει 11, έτσι ώστε να επιστρέψει false.

120
00:07:31,000 --> 00:07:32,000
Τι και αν είναι απεριόριστο; Ναι.

121
00:07:32,000 --> 00:07:38,000
Εάν δεν μπορείτε να επεκτείνετε τον πίνακα για κάποιο λόγο.

122
00:07:38,000 --> 00:07:43,000
Ναι, έτσι η μνήμη είναι ένας περιορισμένος πόρος,

123
00:07:43,000 --> 00:07:51,000
και τελικά, αν θα συνεχίσουμε να πιέζουμε τα πράγματα στη στοίβα ξανά και ξανά,

124
00:07:51,000 --> 00:07:54,000
θα πάμε για να προσπαθήσουμε και να διαθέσει ένα μεγαλύτερο φάσμα για να χωρέσει

125
00:07:54,000 --> 00:07:59,000
η μεγαλύτερη χωρητικότητα, και malloc ή οτιδήποτε άλλο που χρησιμοποιούμε πρόκειται να επιστρέψει ψευδείς.

126
00:07:59,000 --> 00:08:02,000
Λοιπόν, malloc θα επιστρέψει null.

127
00:08:02,000 --> 00:08:05,000
>> Θυμηθείτε, κάθε φορά που θα καλέσει ποτέ malloc, θα πρέπει να ελέγξει για να δείτε αν

128
00:08:05,000 --> 00:08:12,000
επιστρέφει null ή αλλιώς αυτό είναι μια αφαίρεση ορθότητα.

129
00:08:12,000 --> 00:08:17,000
Επειδή θέλουμε να έχουμε ένα απέραντο στοίβα,

130
00:08:17,000 --> 00:08:21,000
η μόνη περίπτωση θα πάμε να επιστρέψει ψευδείς είναι αν προσπαθήσουμε να

131
00:08:21,000 --> 00:08:26,000
αύξηση της ικανότητας και malloc ή ό, τι επιστρέφει false.

132
00:08:26,000 --> 00:08:30,000
Στη συνέχεια, pop δεν παίρνει ορίσματα,

133
00:08:30,000 --> 00:08:37,000
και επιστρέφει τη συμβολοσειρά που βρίσκεται στην κορυφή της στοίβας.

134
00:08:37,000 --> 00:08:41,000
Ό, τι πιο πρόσφατα έσπρωξε στη στοίβα είναι ό, τι ποπ επιστρέφει,

135
00:08:41,000 --> 00:08:44,000
και αφαιρεί επίσης από την στοίβα.

136
00:08:44,000 --> 00:08:50,000
Και παρατηρήσετε ότι επιστρέφει null αν δεν υπάρχει τίποτα στη στοίβα.

137
00:08:50,000 --> 00:08:53,000
Είναι πάντοτε δυνατό ότι η στοίβα είναι άδειο.

138
00:08:53,000 --> 00:08:55,000
Στην Java, αν έχετε συνηθίσει σε αυτό, ή σε άλλες γλώσσες,

139
00:08:55,000 --> 00:09:01,000
προσπαθεί να σκάσει από ένα άδειο στοίβα θα μπορούσε να προκαλέσει μια εξαίρεση ή κάτι τέτοιο.

140
00:09:01,000 --> 00:09:09,000
>> Αλλά σε C, null είναι ένα είδος πολλές από τις περιπτώσεις πώς θα χειριστεί αυτά τα προβλήματα.

141
00:09:09,000 --> 00:09:13,000
Επιστρέφοντας null είναι το πώς θα πάμε για να δηλώσει ότι η στοίβα ήταν άδειο.

142
00:09:13,000 --> 00:09:16,000
Έχουμε παρέχονται κωδικό που θα δοκιμάσουν τη λειτουργικότητα stack σας,

143
00:09:16,000 --> 00:09:19,000
εφαρμογή πιέστε και ποπ.

144
00:09:19,000 --> 00:09:23,000
Αυτό δεν θα είναι ένα πολύ κώδικα.

145
00:09:23,000 --> 00:09:40,000
Θα το κάνω, στην πραγματικότητα, πριν το κάνουμε αυτό, υπαινιγμός, υπαινιγμός-

146
00:09:40,000 --> 00:09:44,000
αν δεν το έχετε δει, malloc δεν είναι η μόνη λειτουργία

147
00:09:44,000 --> 00:09:47,000
που διαθέτει μνήμη στο σωρό για σας.

148
00:09:47,000 --> 00:09:51,000
Υπάρχουν μια οικογένεια των λειτουργιών alloc.

149
00:09:51,000 --> 00:09:53,000
Το πρώτο είναι η malloc, που έχετε συνηθίσει.

150
00:09:53,000 --> 00:09:56,000
Στη συνέχεια υπάρχει calloc, η οποία κάνει το ίδιο πράγμα με malloc,

151
00:09:56,000 --> 00:09:59,000
αλλά θα το μηδέν τα πάντα για σένα.

152
00:09:59,000 --> 00:10:04,000
Αν έχετε ποτέ ήθελε να θέσει τα πάντα σε κενή μετά mallocing κάτι

153
00:10:04,000 --> 00:10:06,000
θα πρέπει να έχουν χρησιμοποιηθεί μόνο calloc στην πρώτη θέση, αντί της γραφής

154
00:10:06,000 --> 00:10:09,000
α για το βρόχο στο μηδέν από το σύνολο του μπλοκ μνήμης.

155
00:10:09,000 --> 00:10:15,000
>> Realloc είναι σαν malloc και έχει πολλές ειδικές περιπτώσεις,

156
00:10:15,000 --> 00:10:19,000
αλλά βασικά αυτό που κάνει είναι realloc

157
00:10:19,000 --> 00:10:24,000
παίρνει ένα δείκτη που είχαν ήδη διατεθεί.

158
00:10:24,000 --> 00:10:27,000
Realloc είναι η λειτουργία που θέλετε να είναι η προσοχή στο σημείο αυτό.

159
00:10:27,000 --> 00:10:31,000
Παίρνει ένα δείκτη που είχε ήδη επιστραφεί από malloc.

160
00:10:31,000 --> 00:10:35,000
Ας πούμε ότι έχετε ζητήσει από malloc ένα δείκτη των 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Στη συνέχεια, αργότερα θα διαπιστώσετε ότι ήθελε 20 bytes,

162
00:10:38,000 --> 00:10:42,000
έτσι ώστε να καλέσετε realloc σε αυτό το δείκτη με 20 bytes,

163
00:10:42,000 --> 00:10:47,000
realloc και αυτόματα θα αντιγράψει τα πάντα για εσάς.

164
00:10:47,000 --> 00:10:51,000
Αν ονομάζεται απλά malloc και πάλι, όπως έχω ένα μπλοκ των 10 bytes.

165
00:10:51,000 --> 00:10:53,000
Τώρα χρειάζομαι ένα μπλοκ των 20 bytes,

166
00:10:53,000 --> 00:10:58,000
οπότε αν malloc 20 bytes, τότε θα πρέπει να αντιγράψετε το χέρι πάνω από τα 10 bytes από το πρώτο πράγμα που

167
00:10:58,000 --> 00:11:01,000
στο δεύτερο πράγμα και στη συνέχεια δωρεάν το πρώτο πράγμα.

168
00:11:01,000 --> 00:11:04,000
Realloc θα χειριστεί αυτό για σας.

169
00:11:04,000 --> 00:11:11,000
>> Παρατηρήστε ότι η υπογραφή θα είναι άκυρη *,

170
00:11:11,000 --> 00:11:15,000
το οποίο επιστρέφει μόνο ένα δείκτη προς το μπλοκ της μνήμης,

171
00:11:15,000 --> 00:11:17,000
τότε άκυρη * ptr.

172
00:11:17,000 --> 00:11:22,000
Μπορείτε να φανταστείτε * άκυρη ως γενικό δείκτη.

173
00:11:22,000 --> 00:11:27,000
Σε γενικές γραμμές, ποτέ δεν ασχολούνται με * άκυρη,

174
00:11:27,000 --> 00:11:30,000
αλλά malloc επιστρέφει ένα κενό *, και στη συνέχεια, είναι ακριβώς χρησιμοποιείται σαν

175
00:11:30,000 --> 00:11:34,000
αυτό είναι πραγματικά πρόκειται να είναι ένα char *.

176
00:11:34,000 --> 00:11:37,000
Η προηγούμενη * κενό που είχε επιστρέψει από malloc

177
00:11:37,000 --> 00:11:41,000
τώρα θα πρέπει να περάσει για να realloc, και στη συνέχεια, το μέγεθος

178
00:11:41,000 --> 00:11:49,000
είναι ο νέος αριθμός των bytes που θέλετε να διαθέσει, έτσι νέας παραγωγικής ικανότητας σας.

179
00:11:49,000 --> 00:11:57,000
Θα σας δώσω μερικά λεπτά, και να το κάνουμε στο χώρο μας.

180
00:11:57,000 --> 00:12:02,000
Ξεκινήστε με την Αναθεώρηση 1.

181
00:12:16,000 --> 00:12:21,000
Θα σταματήσετε μετά ελπίζουμε για αρκετό χρόνο για να εφαρμόσει ώθηση,

182
00:12:21,000 --> 00:12:24,000
και στη συνέχεια, θα σας δώσω ένα άλλο διάλειμμα για να κάνει ποπ.

183
00:12:24,000 --> 00:12:27,000
Αλλά δεν είναι πραγματικά τόσο πολύ κώδικα σε όλα.

184
00:12:27,000 --> 00:12:35,000
Το πιο κώδικας είναι ίσως η επέκταση πράγματα, να αυξάνεται η ικανότητα.

185
00:12:35,000 --> 00:12:39,000
Εντάξει, δεν υπάρχει πίεση για να γίνει εντελώς,

186
00:12:39,000 --> 00:12:47,000
αλλά εφ 'όσον αισθάνεστε σαν να είστε στο σωστό δρόμο, αυτό είναι καλό.

187
00:12:47,000 --> 00:12:53,000
>> Υπάρχει κάποιος που να έχει οποιοδήποτε κώδικα αισθάνονται άνετα μαζί μου τραβώντας προς τα επάνω;

188
00:12:53,000 --> 00:12:59,000
Ναι, θα το κάνω, αλλά δεν έχει καμία κάποιος κωδικός που μπορώ να σηκώσει;

189
00:12:59,000 --> 00:13:05,000
Εντάξει, μπορεί να ξεκινήσετε, να το αποθηκεύσετε, ό, τι είναι;

190
00:13:05,000 --> 00:13:09,000
Ξεχάσω πάντα αυτό το βήμα.

191
00:13:09,000 --> 00:13:15,000
Εντάξει, κοιτάζοντας ώθηση,

192
00:13:15,000 --> 00:13:18,000
θέλεις να εξηγήσει τον κωδικό σας;

193
00:13:18,000 --> 00:13:24,000
[Φοιτητικό] Πρώτα απ 'όλα, θα αυξηθεί το μέγεθος.

194
00:13:24,000 --> 00:13:28,000
Υποθέτω ότι ίσως θα έπρεπε να είχα-ότι ούτως ή άλλως, θα αυξηθεί το μέγεθος,

195
00:13:28,000 --> 00:13:31,000
και να δω αν είναι μικρότερη από τη χωρητικότητα.

196
00:13:31,000 --> 00:13:36,000
Και αν είναι μικρότερη από τη χωρητικότητα, μπορώ να προσθέσω στην παράταξη που ήδη έχουμε.

197
00:13:36,000 --> 00:13:42,000
Και αν δεν είναι, θα πολλαπλασιάσει τη χωρητικότητα κατά 2,

198
00:13:42,000 --> 00:13:50,000
και εγώ την ανακατανομή σειρά χορδές σε κάτι με ένα μεγαλύτερο μέγεθος χωρητικότητας τώρα.

199
00:13:50,000 --> 00:13:55,000
Και στη συνέχεια, αν αυτό αποτύχει, λέω το χρήστη και να επιστρέψει ψευδείς,

200
00:13:55,000 --> 00:14:04,000
και αν είναι εντάξει, τότε έβαλα το string στο νέο σημείο.

201
00:14:04,000 --> 00:14:07,000
>> [Rob Β.] Επίσης, παρατηρούμε ότι χρησιμοποιήσαμε ένα ωραίο χειριστή bitwise εδώ

202
00:14:07,000 --> 00:14:09,000
να πολλαπλασιάζονται επί 2.

203
00:14:09,000 --> 00:14:11,000
Θυμηθείτε, αριστερή στροφή είναι πάντα θα πρέπει να πολλαπλασιάζεται επί 2.

204
00:14:11,000 --> 00:14:15,000
Δεξιά στροφή διαιρείται με το 2, αρκεί να θυμάστε ότι αυτό σημαίνει

205
00:14:15,000 --> 00:14:18,000
διαιρούμε με το 2 όπως σε έναν ακέραιο διαιρείται δια 2.

206
00:14:18,000 --> 00:14:20,000
Θα μπορούσε να περικόψει το 1 εδώ ή εκεί.

207
00:14:20,000 --> 00:14:26,000
Αλλά στροφή αριστερά κατά 1 είναι πάντα πρόκειται να πολλαπλασιαστεί επί 2,

208
00:14:26,000 --> 00:14:32,000
εκτός και αν τα όρια υπερχείλισης του ακεραίου, και τότε δεν θα είναι.

209
00:14:32,000 --> 00:14:34,000
Ένα σχόλιο πλευρά.

210
00:14:34,000 --> 00:14:39,000
Μου αρέσει να κάνω, αυτό δεν πρόκειται να αλλάξει την κωδικοποίηση με οποιονδήποτε τρόπο,

211
00:14:39,000 --> 00:14:48,000
αλλά μου αρέσει να κάνω κάτι τέτοιο.

212
00:14:48,000 --> 00:14:51,000
Είναι πραγματικά πρόκειται να γίνει λίγο περισσότερο.

213
00:15:04,000 --> 00:15:08,000
Ίσως αυτό δεν είναι η ιδανική περίπτωση για να δείξει αυτό,

214
00:15:08,000 --> 00:15:14,000
αλλά μου αρέσει να σε τμήμα αυτών των μπλοκ-

215
00:15:14,000 --> 00:15:17,000
εντάξει, αν αυτό, αν συμβεί αυτό, τότε θα πάω να κάνω κάτι,

216
00:15:17,000 --> 00:15:19,000
και στη συνέχεια η λειτουργία γίνεται.

217
00:15:19,000 --> 00:15:22,000
Δεν χρειάζεται να μετακινηθείτε προς τα μάτια μου σε όλη τη διαδρομή κάτω από τη λειτουργία

218
00:15:22,000 --> 00:15:25,000
για να δούμε τι θα συμβεί μετά το άλλο.

219
00:15:25,000 --> 00:15:27,000
Είναι αν αυτό εάν συμβεί κάτι τέτοιο, τότε θα επιστρέψει ακριβώς.

220
00:15:27,000 --> 00:15:30,000
Έχει επίσης το ωραίο πρόσθετο όφελος των πάντων πέρα ​​από αυτό

221
00:15:30,000 --> 00:15:33,000
τώρα μετατίθενται αριστερά μία φορά.

222
00:15:33,000 --> 00:15:40,000
Εγώ δεν χρειάζεται πλέον να-αν ποτέ κοντά γελοία παραγάδια,

223
00:15:40,000 --> 00:15:45,000
τότε τα 4 byte μπορεί να βοηθήσει, και, επίσης, η πιο αριστερά είναι κάτι,

224
00:15:45,000 --> 00:15:48,000
το λιγότερο αισθάνεστε συγκλονισμένοι αν θέλετε-εντάξει, έχω να θυμάμαι

225
00:15:48,000 --> 00:15:53,000
Είμαι σήμερα σε ένα βρόχο, ενώ στο εσωτερικό του άλλου μέσα από ένα βρόχο for.

226
00:15:53,000 --> 00:15:58,000
Οπουδήποτε μπορείτε να κάνετε αυτήν την επιστροφή αμέσως, κάτι σαν.

227
00:15:58,000 --> 00:16:05,000
Είναι εντελώς προαιρετική και δεν αναμένεται σε καμία περίπτωση.

228
00:16:05,000 --> 00:16:12,000
>> [Φοιτητικό] Πρέπει να υπάρχει ένα μέγεθος - σε κατάσταση αποτυχίας;

229
00:16:12,000 --> 00:16:19,000
Η κατάσταση εδώ είναι αποτυχία που δεν realloc, οπότε ναι.

230
00:16:19,000 --> 00:16:22,000
Παρατηρήστε πως στην κατάσταση βλάβης, κατά πάσα πιθανότητα,

231
00:16:22,000 --> 00:16:26,000
εκτός και αν εμείς δωρεάν πράγματα αργότερα, είμαστε πάντα θα αποτύχει

232
00:16:26,000 --> 00:16:29,000
Δεν έχει σημασία πόσες φορές προσπαθούμε να προωθήσουμε κάτι.

233
00:16:29,000 --> 00:16:32,000
Αν συνεχίσουμε να πιέζουμε, κρατάμε προσαύξηση μέγεθος,

234
00:16:32,000 --> 00:16:36,000
ακόμα κι αν δεν είμαστε τίποτα βάζοντας πάνω στη στοίβα.

235
00:16:36,000 --> 00:16:39,000
Συνήθως δεν αυξήσετε το μέγεθος μέχρι

236
00:16:39,000 --> 00:16:43,000
αφού έχουμε θέσει με επιτυχία στη στοίβα.

237
00:16:43,000 --> 00:16:50,000
Εμείς θα το κάνουμε, ας πούμε, είτε εδώ και εδώ.

238
00:16:50,000 --> 00:16:56,000
Και στη συνέχεια, αντί να λέει s.size ≤ ικανότητα, είναι λιγότερο από ό, τι ικανότητα,

239
00:16:56,000 --> 00:17:01,000
μόνο και μόνο επειδή περάσαμε, όπου τα πάντα ήταν.

240
00:17:01,000 --> 00:17:07,000
>> Και, θυμηθείτε το μόνο μέρος που θα μπορούσε ενδεχομένως να επιστρέψει false

241
00:17:07,000 --> 00:17:14,000
Είναι εδώ, όπου realloc επέστρεψε null,

242
00:17:14,000 --> 00:17:19,000
και αν τύχει να θυμάστε τυπικό σφάλμα,

243
00:17:19,000 --> 00:17:22,000
ίσως θα μπορούσε να εξετάσει αυτό μια περίπτωση κατά την οποία θέλετε να εκτυπώσετε ένα τυπικό σφάλμα,

244
00:17:22,000 --> 00:17:26,000
έτσι fprintf stderr αντί απλά να τυπώνουν απευθείας από πρότυπο.

245
00:17:26,000 --> 00:17:31,000
Και πάλι, αυτό δεν είναι η προσδοκία, αλλά αν είναι λάθος,

246
00:17:31,000 --> 00:17:41,000
πληκτρολογήστε printf, τότε ίσως να θέλετε να το εκτυπώσετε σε τυπικό σφάλμα, αντί του στάνταρ έξω.

247
00:17:41,000 --> 00:17:44,000
>> Όποιος έχει κάτι άλλο να σημειώσουμε; Ναι.

248
00:17:44,000 --> 00:17:47,000
[Φοιτητικό] Μπορείς να πάει πάνω από το [δεν ακούγεται];

249
00:17:47,000 --> 00:17:55,000
[Rob Β.] Ναι, η πραγματική binariness του ή απλά τι είναι;

250
00:17:55,000 --> 00:17:57,000
[Φοιτητικό] Έτσι, μπορείτε να το πολλαπλασιάσετε με το 2;

251
00:17:57,000 --> 00:17:59,000
[Rob Β.] Ναι, βασικά.

252
00:17:59,000 --> 00:18:11,000
Στο δυαδικό γη, έχουμε πάντα μας σύνολο των ψηφίων.

253
00:18:11,000 --> 00:18:22,000
Η μετατόπιση αυτή την αριστερά κατά 1 βασικά αυτό εισάγει εδώ στη δεξιά πλευρά.

254
00:18:22,000 --> 00:18:25,000
Πίσω από αυτό, απλά να θυμόμαστε ότι τα πάντα σε δυαδική

255
00:18:25,000 --> 00:18:28,000
είναι μία δύναμη του 2, οπότε αυτό αντιπροσωπεύει 2 στο 0,

256
00:18:28,000 --> 00:18:30,000
αυτό το 2 στο 1, αυτό το 2 στο 2.

257
00:18:30,000 --> 00:18:33,000
Με την εισαγωγή ενός 0 έως τη δεξιά πλευρά τώρα, έχουμε αλλάξει τα πάντα πάνω.

258
00:18:33,000 --> 00:18:38,000
Αυτό που κάποτε ήταν 2 προς το μηδέν είναι πλέον 2 στο 1, 2 στο 2.

259
00:18:38,000 --> 00:18:41,000
Η δεξιά πλευρά που εισάγεται

260
00:18:41,000 --> 00:18:44,000
πρόκειται απαραιτήτως να είναι 0,

261
00:18:44,000 --> 00:18:46,000
που έχει νόημα.

262
00:18:46,000 --> 00:18:49,000
Αν πολλαπλασιάσει ποτέ έναν αριθμό με το 2, δεν πρόκειται να καταλήξουμε περίεργο,

263
00:18:49,000 --> 00:18:54,000
έτσι ώστε το 2 προς τον τόπο 0 πρέπει να είναι 0,

264
00:18:54,000 --> 00:18:59,000
και αυτό είναι αυτό που προειδοποίησε για ένα δεύτερο είναι, αν πριν το κάνετε να συμβεί για να μετατοπίσει

265
00:18:59,000 --> 00:19:01,000
πέρα από τον αριθμό των bits σε έναν ακέραιο

266
00:19:01,000 --> 00:19:04,000
τότε αυτό το 1 πρόκειται να καταλήξουν μακριά.

267
00:19:04,000 --> 00:19:10,000
Αυτό είναι το μόνο ανησυχία, αν τυχαίνει να ασχολείται με πραγματικά μεγάλες δυνατότητες.

268
00:19:10,000 --> 00:19:15,000
Αλλά σε αυτό το σημείο, τότε έχουμε να κάνουμε με μια σειρά από δισεκατομμύρια των πραγμάτων,

269
00:19:15,000 --> 00:19:25,000
το οποίο δεν θα μπορούσε να χωρέσει σε μνήμη ούτως ή άλλως.

270
00:19:25,000 --> 00:19:31,000
>> Τώρα μπορούμε να προχωρήσουμε σε ποπ, η οποία είναι ακόμη πιο εύκολο.

271
00:19:31,000 --> 00:19:36,000
Θα μπορούσατε να μου αρέσει αν τύχει να σκάσει ένα σωρό,

272
00:19:36,000 --> 00:19:38,000
και τώρα είστε στο μισό ικανότητα και πάλι.

273
00:19:38,000 --> 00:19:42,000
Θα μπορούσατε να realloc να συρρικνωθεί το μέγεθος της μνήμης που έχετε,

274
00:19:42,000 --> 00:19:47,000
αλλά δεν έχετε να ανησυχείτε για αυτό, έτσι η μόνη περίπτωση realloc πρόκειται να είναι

275
00:19:47,000 --> 00:19:50,000
αυξανόμενη μνήμη, ποτέ συρρίκνωση της μνήμης,

276
00:19:50,000 --> 00:19:59,000
το οποίο πρόκειται να κάνει ποπ εξαιρετικά εύκολο.

277
00:19:59,000 --> 00:20:02,000
Τώρα ουρές, οι οποίες πρόκειται να είναι όπως στοίβες,

278
00:20:02,000 --> 00:20:06,000
αλλά η εντολή που θα πάρουμε τα πράγματα από αντιστρέφεται.

279
00:20:06,000 --> 00:20:10,000
Ο πρωτότυπος παράδειγμα μια ουρά είναι μια γραμμή,

280
00:20:10,000 --> 00:20:12,000
οπότε υποθέτω αν ήταν αγγλικά, θα έλεγα

281
00:20:12,000 --> 00:20:17,000
ένα πρωτότυπο παράδειγμα μιας ουράς είναι μια ουρά.

282
00:20:17,000 --> 00:20:22,000
Έτσι, σαν μια γραμμή, εάν είστε το πρώτο πρόσωπο στη γραμμή,

283
00:20:22,000 --> 00:20:24,000
περιμένετε να είναι το πρώτο πρόσωπο από τη γραμμή.

284
00:20:24,000 --> 00:20:31,000
Εάν είστε το τελευταίο άτομο στη γραμμή, θα έχετε την ευκαιρία να είναι το τελευταίο πρόσωπο εξυπηρετούνται.

285
00:20:31,000 --> 00:20:35,000
Καλούμε αυτό το μοτίβο FIFO, ενώ ήταν στοίβα LIFO μοτίβο.

286
00:20:35,000 --> 00:20:40,000
Αυτά τα λόγια είναι αρκετά καθολική.

287
00:20:40,000 --> 00:20:46,000
>> Όπως και σε αντίθεση με στοίβες συστοιχίες, ουρές τυπικώς δεν επιτρέπουν την πρόσβαση σε στοιχεία στην μέση.

288
00:20:46,000 --> 00:20:50,000
Εδώ, μια στοίβα, έχουμε ώθηση και ποπ.

289
00:20:50,000 --> 00:20:54,000
Εδώ, τυχαίνει να έχουν καλέσει τους enqueue και dequeue.

290
00:20:54,000 --> 00:20:58,000
Έχω επίσης ακούσει να λέγεται μετατόπιση και unshift.

291
00:20:58,000 --> 00:21:02,000
Έχω ακούσει ανθρώπους να λένε ποπ ώθηση και να ισχύουν και για τις ουρές.

292
00:21:02,000 --> 00:21:05,000
Έχω ακούσει τοποθετείτε, αφαιρείτε,

293
00:21:05,000 --> 00:21:11,000
έτσι ώθηση και ποπ, αν μιλάμε για στοίβες, σας πιέζουν και σκάει.

294
00:21:11,000 --> 00:21:16,000
Αν μιλάμε για ουρές, θα μπορούσατε να πάρετε τις λέξεις που θέλετε να χρησιμοποιήσετε

295
00:21:16,000 --> 00:21:23,000
για την εισαγωγή και την αφαίρεση, και δεν υπάρχει συναίνεση σχετικά με το τι θα έπρεπε να λέγεται.

296
00:21:23,000 --> 00:21:27,000
Αλλά εδώ, έχουμε enqueue και dequeue.

297
00:21:27,000 --> 00:21:37,000
Τώρα, η struct μοιάζει σχεδόν ίδιο με το struct στοίβας.

298
00:21:37,000 --> 00:21:40,000
Αλλά θα πρέπει να παρακολουθείτε το κεφάλι.

299
00:21:40,000 --> 00:21:44,000
Υποθέτω ότι λέει εδώ κάτω, αλλά γιατί χρειαζόμαστε το κεφάλι;

300
00:21:53,000 --> 00:21:57,000
Τα πρωτότυπα είναι βασικά ίδια με ωθήσει και ποπ.

301
00:21:57,000 --> 00:21:59,000
Μπορείτε να σκεφτείτε από το ως ώθηση και ποπ.

302
00:21:59,000 --> 00:22:08,000
Η μόνη διαφορά είναι ποπ επιστρέφει, αντί του τελευταίου, αυτό είναι το πρώτο επιστροφή.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, ή κάτι τέτοιο.

304
00:22:12,000 --> 00:22:14,000
Και εδώ είναι η αρχή.

305
00:22:14,000 --> 00:22:17,000
Ουρά μας είναι τελείως γεμάτο, οπότε υπάρχουν τέσσερα στοιχεία σε αυτό.

306
00:22:17,000 --> 00:22:21,000
Το τέλος της ουράς μας είναι επί του παρόντος 2,

307
00:22:21,000 --> 00:22:24,000
και τώρα πάμε να εισάγετε κάτι άλλο.

308
00:22:24,000 --> 00:22:29,000
>> Όταν θέλετε να εισαγάγετε αυτό το κάτι άλλο, ό, τι κάναμε για την έκδοση στοίβα

309
00:22:29,000 --> 00:22:36,000
είναι να επεκταθεί μπλοκ της μνήμης μας.

310
00:22:36,000 --> 00:22:40,000
Ποιο είναι το πρόβλημα με αυτό;

311
00:22:40,000 --> 00:22:45,000
[Φοιτητικό] Μπορείτε να μετακινήσετε το 2.

312
00:22:45,000 --> 00:22:51,000
Αυτό που είπα πριν για το τέλος της ουράς,

313
00:22:51,000 --> 00:22:57,000
αυτό δεν έχει νόημα να αρχίσουμε σε 1,

314
00:22:57,000 --> 00:23:01,000
τότε θέλουμε να dequeue 1, τότε dequeue 3, τότε dequeue 4,

315
00:23:01,000 --> 00:23:05,000
τότε dequeue 2, dequeue τότε αυτό το ένα.

316
00:23:05,000 --> 00:23:08,000
Εμείς δεν μπορούμε να χρησιμοποιήσουμε realloc τώρα,

317
00:23:08,000 --> 00:23:11,000
ή τουλάχιστον, θα πρέπει να χρησιμοποιήσετε realloc με διαφορετικό τρόπο.

318
00:23:11,000 --> 00:23:15,000
Αλλά ίσως δεν θα πρέπει να χρησιμοποιούν μόνο realloc.

319
00:23:15,000 --> 00:23:18,000
Θα έχετε την ευκαιρία να χρειαστεί να αντιγράψετε το χέρι μνήμη σας.

320
00:23:18,000 --> 00:23:21,000
>> Υπάρχουν δύο λειτουργίες για να αντιγράψετε τη μνήμη.

321
00:23:21,000 --> 00:23:25,000
Υπάρχει memcopy και memmove.

322
00:23:25,000 --> 00:23:29,000
Διαβάζω σήμερα τις σελίδες man για να δείτε ποιο θα πάμε να θέλετε να χρησιμοποιήσετε.

323
00:23:29,000 --> 00:23:35,000
Εντάξει, memcopy, η διαφορά είναι

324
00:23:35,000 --> 00:23:38,000
ότι memcopy και memmove, ένας χειρίζεται την υπόθεση σωστά

325
00:23:38,000 --> 00:23:41,000
Όπου και αν αντιγράψετε σε μια περιοχή που συμβαίνει να συμπίπτουν με την περιοχή

326
00:23:41,000 --> 00:23:46,000
πραγματοποιείτε αντιγραφή.

327
00:23:46,000 --> 00:23:50,000
Memcopy δεν το χειριστεί. Memmove κάνει.

328
00:23:50,000 --> 00:23:59,000
Μπορείτε να σκεφτείτε το πρόβλημα που-

329
00:23:59,000 --> 00:24:09,000
Ας πούμε ότι θέλετε να αντιγράψετε αυτόν τον τύπο,

330
00:24:09,000 --> 00:24:13,000
αυτά τα τέσσερα για αυτόν τον τύπο πάνω.

331
00:24:13,000 --> 00:24:16,000
Στο τέλος, ποια είναι η σειρά πρέπει να μοιάσει

332
00:24:16,000 --> 00:24:26,000
μετά το αντίγραφο είναι 2, 1, 2, 1, 3, 4, και στη συνέχεια κάποια πράγματα στο τέλος.

333
00:24:26,000 --> 00:24:29,000
Αλλά αυτό εξαρτάται από την σειρά με την οποία έχουμε πραγματικά αντιγραφή,

334
00:24:29,000 --> 00:24:32,000
δεδομένου ότι, αν δεν ληφθεί υπόψη το γεγονός ότι η περιοχή είμαστε σε αντιγραφή

335
00:24:32,000 --> 00:24:35,000
επικαλύπτει το ένα είμαστε αντιγραφή από,

336
00:24:35,000 --> 00:24:46,000
τότε θα μπορούσαμε να κάνουμε σαν αρχή εδώ, αντιγράψτε το 2 στο μέρος που θέλετε να πάτε,

337
00:24:46,000 --> 00:24:52,000
στη συνέχεια να προχωρήσουμε προς τα εμπρός δείκτες μας.

338
00:24:52,000 --> 00:24:56,000
>> Τώρα θα πάμε να είναι εδώ και εδώ, και τώρα θέλετε να αντιγράψετε

339
00:24:56,000 --> 00:25:04,000
αυτός ο τύπος για αυτόν τον τύπο και να προχωρήσουμε προς τα εμπρός δείκτες μας.

340
00:25:04,000 --> 00:25:07,000
Τι θα πάμε να καταλήξετε είναι 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
αντί της κατάλληλης 2, 1, 2, 1, 3, 4, επειδή

342
00:25:10,000 --> 00:25:15,000
2, 1 αγνόησε την αρχική 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove ότι χειρίζεται σωστά.

344
00:25:19,000 --> 00:25:23,000
Στην περίπτωση αυτή, βασικά ακριβώς να χρησιμοποιείτε πάντα memmove

345
00:25:23,000 --> 00:25:26,000
επειδή χειρίζεται σωστά.

346
00:25:26,000 --> 00:25:29,000
Γενικά, δεν εκτελέσει οποιαδήποτε χειρότερα.

347
00:25:29,000 --> 00:25:32,000
Η ιδέα είναι αντί της ξεκινώντας από την αρχή και με αυτόν τον τρόπο η αντιγραφή

348
00:25:32,000 --> 00:25:35,000
όπως εμείς μόλις έκανε εδώ, αρχίζει από το τέλος και αντιγράφει σε,

349
00:25:35,000 --> 00:25:38,000
και σε αυτή την περίπτωση, δεν μπορείτε ποτέ να έχετε ένα πρόβλημα.

350
00:25:38,000 --> 00:25:40,000
Δεν υπάρχει καμία απόδοση χαθεί.

351
00:25:40,000 --> 00:25:47,000
Πάντα να χρησιμοποιείτε memmove. Ποτέ μην ανησυχείτε για memcopy.

352
00:25:47,000 --> 00:25:51,000
Και αυτό είναι που θα πάμε να πρέπει να χωριστά memmove

353
00:25:51,000 --> 00:26:01,000
το τυλιγμένο γύρω-τμήμα της ουράς σας.

354
00:26:01,000 --> 00:26:04,000
Μην ανησυχείτε αν δεν γίνει εντελώς.

355
00:26:04,000 --> 00:26:10,000
Αυτό είναι πιο δύσκολο από ό, τι στοίβα, ώθηση, και ποπ.

356
00:26:10,000 --> 00:26:15,000
>> Όποιος έχει οποιοδήποτε κώδικα θα μπορούσε να συνεργαστεί με;

357
00:26:15,000 --> 00:26:21,000
Ακόμα και αν εντελώς ελλιπής;

358
00:26:21,000 --> 00:26:23,000
[Φοιτητικό] Ναι, είναι τελείως ελλιπείς, εν τούτοις.

359
00:26:23,000 --> 00:26:27,000
Εντελώς ελλιπής είναι μια χαρά όσο εμείς-μπορεί να σας σώσει την αναθεώρηση;

360
00:26:27,000 --> 00:26:32,000
Ξεχάσω ότι κάθε φορά.

361
00:26:32,000 --> 00:26:39,000
Εντάξει, αγνοώντας τι συμβαίνει όταν πρέπει να αλλάξετε το μέγεθος πράγματα.

362
00:26:39,000 --> 00:26:42,000
Εντελώς αγνοούν resize.

363
00:26:42,000 --> 00:26:49,000
Εξηγήστε αυτόν τον κώδικα.

364
00:26:49,000 --> 00:26:54,000
Φεύγω πρώτα από όλα, εάν το μέγεθος είναι μικρότερο από το αντίγραφο καταρχάς

365
00:26:54,000 --> 00:27:01,000
και στη συνέχεια, μετά από αυτό, βάζω-παίρνω το κεφάλι + μέγεθος,

366
00:27:01,000 --> 00:27:05,000
και εγώ να βεβαιωθείτε ότι αναδιπλώνεται γύρω από την χωρητικότητα της συστοιχίας,

367
00:27:05,000 --> 00:27:08,000
και βάζω τη νέα σειρά σε αυτή τη θέση.

368
00:27:08,000 --> 00:27:12,000
Τότε θα αυξήσει το μέγεθος και την επιστροφή αλήθεια.

369
00:27:12,000 --> 00:27:22,000
>> [Rob Β.] Αυτό είναι σίγουρα μία από εκείνες τις περιπτώσεις όπου θα πάμε να θέλουν να χρησιμοποιούν mod.

370
00:27:22,000 --> 00:27:25,000
Κάθε είδους περίπτωση που έχετε περιτύλιγμα γύρω, αν νομίζετε ότι περιτύλιγμα γύρω,

371
00:27:25,000 --> 00:27:29,000
η άμεση σκέψη θα πρέπει να είναι mod.

372
00:27:29,000 --> 00:27:36,000
Ως μια γρήγορη βελτιστοποίηση / κωδικό σας κάνουν μια γραμμή μικρότερη,

373
00:27:36,000 --> 00:27:42,000
θα παρατηρήσετε ότι η γραμμή αμέσως μετά αυτό το ένα

374
00:27:42,000 --> 00:27:53,000
είναι ακριβώς το μέγεθος + +, έτσι ώστε να συγχωνευθούν ότι σε αυτή τη γραμμή, το μέγεθος + +.

375
00:27:53,000 --> 00:27:58,000
Τώρα εδώ κάτω, έχουμε την περίπτωση

376
00:27:58,000 --> 00:28:01,000
όπου δεν έχουμε αρκετή μνήμη,

377
00:28:01,000 --> 00:28:05,000
έτσι αυξάνουμε την ικανότητά μας με το 2.

378
00:28:05,000 --> 00:28:09,000
Υποθέτω ότι θα μπορούσατε να έχετε το ίδιο πρόβλημα εδώ, αλλά μπορούμε να το αγνοήσουμε τώρα,

379
00:28:09,000 --> 00:28:13,000
όπου κι αν αποτύχει να αυξήσει την ικανότητά σας,

380
00:28:13,000 --> 00:28:18,000
τότε θα πάμε να θέλουν να μειωθεί η ικανότητά σας κατά 2 ξανά.

381
00:28:18,000 --> 00:28:24,000
Άλλο ένα σύντομο σημείωμα είναι ακριβώς όπως μπορείτε να κάνετε + =,

382
00:28:24,000 --> 00:28:30,000
μπορείτε επίσης να κάνετε << =.

383
00:28:30,000 --> 00:28:43,000
Σχεδόν οτιδήποτε μπορεί να πάει πριν ισούται, + =, | =, & = << =.

384
00:28:43,000 --> 00:28:52,000
Char * νέα είναι νέο μπλοκ της μνήμης μας.

385
00:28:52,000 --> 00:28:55,000
Ω, εδώ.

386
00:28:55,000 --> 00:29:02,000
>> Τι κάνουν οι άνθρωποι σκέφτονται για τον τύπο του νέου μπλοκ της μνήμης μας;

387
00:29:02,000 --> 00:29:06,000
[Φοιτητικό] Θα πρέπει να είναι char **.

388
00:29:06,000 --> 00:29:12,000
Ανακαλώντας στη μνήμη struct μας εδώ,

389
00:29:12,000 --> 00:29:14,000
χορδές είναι αυτό που ανακατανομή.

390
00:29:14,000 --> 00:29:21,000
Κάνουμε μια ολόκληρη νέα δυναμική αποθήκευση των στοιχείων στην ουρά.

391
00:29:21,000 --> 00:29:25,000
Τι θα πάμε να υπαγωγή στις χορδές σας είναι ό, τι είμαστε τώρα mallocing,

392
00:29:25,000 --> 00:29:30,000
και έτσι οι νέες πρόκειται να είναι ένα char **.

393
00:29:30,000 --> 00:29:34,000
Είναι πρόκειται να είναι μια σειρά από χορδές.

394
00:29:34,000 --> 00:29:38,000
Τότε ποια είναι η περίπτωση σύμφωνα με την οποία θα πάμε να επιστρέψει false;

395
00:29:38,000 --> 00:29:41,000
[Φοιτητικό] Θα πρέπει να κάνουμε το char *;

396
00:29:41,000 --> 00:29:44,000
[Rob Β.] Ναι, καλή κλήση.

397
00:29:44,000 --> 00:29:46,000
[Φοιτητικό] Τι ήταν αυτό;

398
00:29:46,000 --> 00:29:49,000
[Rob Β.] Θέλαμε να κάνουμε το μέγεθος του char * επειδή δεν είμαστε πλέον-

399
00:29:49,000 --> 00:29:53,000
αυτό θα ήταν πράγματι ένα πολύ μεγάλο πρόβλημα, διότι sizeof (char) θα είναι 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * πρόκειται να είναι 4,

401
00:29:55,000 --> 00:29:58,000
έτσι πολλές φορές, όταν έχουμε να κάνουμε με ints,

402
00:29:58,000 --> 00:30:01,000
έχετε την τάση να πάρετε μακριά με αυτό, επειδή το μέγεθος του int και το μέγεθος του int *

403
00:30:01,000 --> 00:30:04,000
σε 32-bit σύστημα πρόκειται να είναι το ίδιο πράγμα.

404
00:30:04,000 --> 00:30:09,000
Αλλά εδώ, sizeof (char) και sizeof (char *) είναι τώρα πρόκειται να είναι το ίδιο πράγμα.

405
00:30:09,000 --> 00:30:15,000
>> Ποια είναι η περίσταση όπου θα επιστρέψει false;

406
00:30:15,000 --> 00:30:17,000
[Φοιτητικό] Νέα είναι μηδενική.

407
00:30:17,000 --> 00:30:23,000
Ναι, αν είναι νέα null, θα επιστρέψει false,

408
00:30:23,000 --> 00:30:34,000
και Πάω να ρίξει εδώ κάτω-

409
00:30:34,000 --> 00:30:37,000
[Φοιτητών] [δεν ακούγεται]

410
00:30:37,000 --> 00:30:39,000
[Rob Β.] Ναι, αυτό είναι καλό.

411
00:30:39,000 --> 00:30:46,000
Θα μπορούσατε να το κάνετε είτε 2 φορές ικανότητα ή αλλαγή χωρητικότητας 1 και στη συνέχεια το μόνο που εδώ κάτω ή οτιδήποτε άλλο.

412
00:30:46,000 --> 00:30:52,000
Θα το κάνουμε εμείς ως είχε.

413
00:30:52,000 --> 00:30:56,000
Χωρητικότητα >> = 1.

414
00:30:56,000 --> 00:31:08,000
Και δεν πρόκειται ποτέ να χρειάζεται να ανησυχείτε για να χάσει τη θέση του για 1

415
00:31:08,000 --> 00:31:12,000
γιατί έφυγες μετατοπιστεί κατά 1, έτσι η θέση του 1 είναι κατ 'ανάγκη ένα 0,

416
00:31:12,000 --> 00:31:16,000
τόσο δεξιά στροφή από 1, είστε ακόμα πρόκειται να είναι μια χαρά.

417
00:31:16,000 --> 00:31:19,000
[Φοιτητικό] Μήπως πρέπει να το κάνουμε αυτό πριν από την επιστροφή;

418
00:31:19,000 --> 00:31:29,000
[Rob Β.] Ναι, αυτό έχει απολύτως κανένα νόημα.

419
00:31:29,000 --> 00:31:36,000
>> Ας υποθέσουμε τώρα ότι θα πάμε να καταλήξετε επιστρέφουν αλήθεια για το τέλος.

420
00:31:36,000 --> 00:31:39,000
Ο τρόπος που θα πάμε να κάνουμε αυτές τις memmoves,

421
00:31:39,000 --> 00:31:45,000
πρέπει να είμαστε προσεκτικοί με το πώς μπορούμε να κάνουμε.

422
00:31:45,000 --> 00:31:50,000
Υπάρχει κάποιος που έχει κάποιες προτάσεις για το πώς μπορούμε να κάνουμε;

423
00:32:17,000 --> 00:32:21,000
Εδώ είναι αρχή μας.

424
00:32:21,000 --> 00:32:28,000
Αναπόφευκτα, θέλουμε να ξεκινήσουμε από την αρχή και πάλι

425
00:32:28,000 --> 00:32:35,000
και δραστηριότητες αντίγραφο σε από εκεί, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Πώς μπορείτε να το κάνετε αυτό;

427
00:32:41,000 --> 00:32:52,000
Κατ 'αρχάς, πρέπει να δούμε την σελίδα man για memmove πάλι.

428
00:32:52,000 --> 00:32:57,000
Memmove, σειρά επιχειρημάτων είναι πάντα σημαντικό.

429
00:32:57,000 --> 00:33:01,000
Θέλουμε προορισμός μας πρώτη, δεύτερη πηγή, το τρίτο μέγεθος.

430
00:33:01,000 --> 00:33:06,000
Υπάρχουν πολλές λειτουργίες που αντιστρέφουν προέλευσης και προορισμού.

431
00:33:06,000 --> 00:33:11,000
Προορισμός, πηγή τείνει να είναι κάπως συνεπής.

432
00:33:17,000 --> 00:33:21,000
Μετακίνηση, τι είναι αυτό που επιστρέφει;

433
00:33:21,000 --> 00:33:27,000
Επιστρέφει ένα δείκτη προς τον προορισμό, για οποιοδήποτε λόγο, μπορεί να θέλετε να.

434
00:33:27,000 --> 00:33:32,000
Μπορώ να το διαβάσετε εικόνα, αλλά θέλουμε να προχωρήσουμε σε προορισμό μας.

435
00:33:32,000 --> 00:33:35,000
>> Τι είναι ο προορισμός μας θα πρέπει να;

436
00:33:35,000 --> 00:33:37,000
[Φοιτητικό] Νέα.

437
00:33:37,000 --> 00:33:39,000
[Rob Β.] Ναι, και όπου είμαστε από αντιγραφή;

438
00:33:39,000 --> 00:33:43,000
Το πρώτο πράγμα που αντιγράφετε είναι αυτό το 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Ποιο είναι το αυτό-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Ποια είναι η διεύθυνση αυτού του 1;

441
00:33:55,000 --> 00:33:58,000
Ποια είναι η διεύθυνση του εν λόγω 1;

442
00:33:58,000 --> 00:34:01,000
[Φοιτητών] [δεν ακούγεται]

443
00:34:01,000 --> 00:34:03,000
[Rob Β.] Επικεφαλής + η διεύθυνση του πρώτου στοιχείου.

444
00:34:03,000 --> 00:34:05,000
Πώς να πάρει το πρώτο στοιχείο του πίνακα;

445
00:34:05,000 --> 00:34:10,000
[Φοιτητικό] Ουρά.

446
00:34:10,000 --> 00:34:15,000
[Rob Β.] Ναι, q.strings.

447
00:34:15,000 --> 00:34:20,000
Να θυμάστε, εδώ, το κεφάλι μας είναι 1.

448
00:34:20,000 --> 00:34:24,000
Καταριέται αυτό. Απλά πιστεύω ότι είναι μαγικά-

449
00:34:24,000 --> 00:34:29,000
Εδώ, το κεφάλι μας είναι 1. Πάω να αλλάξετε το χρώμα μου πάρα πολύ.

450
00:34:29,000 --> 00:34:36,000
Και εδώ είναι χορδές.

451
00:34:36,000 --> 00:34:41,000
Αυτό μπορούμε να το γράψετε είτε όπως κάναμε εδώ

452
00:34:41,000 --> 00:34:43,000
με το κεφάλι + q.strings.

453
00:34:43,000 --> 00:34:51,000
Πολλοί άνθρωποι, επίσης, να το γράψετε και q.strings [κεφάλι].

454
00:34:51,000 --> 00:34:55,000
Αυτό δεν είναι πραγματικά είναι λιγότερο αποτελεσματική.

455
00:34:55,000 --> 00:34:58,000
Μπορείτε να σκεφτείτε από το όπως εσείς την εύρεση τιμών και στη συνέχεια να πάρει τη διεύθυνση του,

456
00:34:58,000 --> 00:35:04,000
αλλά ο compiler δεν πρόκειται να το μεταφράσει σε ό, τι είχαμε πριν από ούτως ή άλλως, q.strings + κεφάλι.

457
00:35:04,000 --> 00:35:06,000
Είτε έτσι είτε αλλιώς θέλετε να το σκέφτομαι αυτό.

458
00:35:06,000 --> 00:35:11,000
>> Και πόσα bytes θέλουμε να αντιγράψετε;

459
00:35:11,000 --> 00:35:15,000
[Φοιτητικό] Χωρητικότητα - το κεφάλι.

460
00:35:15,000 --> 00:35:18,000
Χωρητικότητα - το κεφάλι.

461
00:35:18,000 --> 00:35:21,000
Και τότε θα μπορούσε πάντα να γράψουν ένα παράδειγμα

462
00:35:21,000 --> 00:35:23,000
να καταλάβω αν αυτό είναι σωστό.

463
00:35:23,000 --> 00:35:26,000
[Φοιτητικό] Πρέπει να διαιρείται με το 2 τότε.

464
00:35:26,000 --> 00:35:30,000
Ναι, έτσι υποθέτω ότι θα μπορούσε να χρησιμοποιήσει το μέγεθος.

465
00:35:30,000 --> 00:35:35,000
Έχουμε ακόμα το μέγεθος είναι-

466
00:35:35,000 --> 00:35:39,000
χρησιμοποιώντας το μέγεθος, έχουμε το μέγεθος ίσο προς 4.

467
00:35:39,000 --> 00:35:42,000
Μέγεθος μας είναι 4. Το κεφάλι μας είναι 1.

468
00:35:42,000 --> 00:35:46,000
Θέλουμε να αντιγράψετε αυτά τα 3 στοιχεία.

469
00:35:46,000 --> 00:35:54,000
Αυτή είναι η λογική ελέγχει ότι το μέγεθος - το κεφάλι είναι σωστά 3.

470
00:35:54,000 --> 00:35:58,000
Και επιστρέφοντας εδώ, όπως είπαμε πριν,

471
00:35:58,000 --> 00:36:00,000
αν χρησιμοποιείται ικανότητα, τότε θα είχαμε να διαιρούμε με το 2

472
00:36:00,000 --> 00:36:04,000
επειδή έχουμε μεγαλώσει ήδη την ικανότητά μας, έτσι αντ 'αυτού, θα πάμε να χρησιμοποιήσετε το μέγεθος.

473
00:36:11,000 --> 00:36:13,000
Που αντιγράφει το τμήμα.

474
00:36:13,000 --> 00:36:18,000
Τώρα, θα πρέπει να αντιγράψετε το άλλο τμήμα, το τμήμα που έχει απομείνει από την αρχή.

475
00:36:18,000 --> 00:36:28,000
>> Αυτό πρόκειται να memmove σε ποια θέση;

476
00:36:28,000 --> 00:36:32,000
[Φοιτητικό] Μέγεθος Plus - κεφάλι.

477
00:36:32,000 --> 00:36:38,000
Ναι, γι 'αυτό έχουν ήδη αντιγραφεί σε μέγεθος - bytes κεφάλι,

478
00:36:38,000 --> 00:36:43,000
και έτσι όπου θέλετε να αντιγράψετε τα υπόλοιπα bytes είναι νέα

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

480
00:36:48,000 --> 00:36:52,000
Και στη συνέχεια, όταν εμείς από την αντιγραφή;

481
00:36:52,000 --> 00:36:54,000
[Φοιτητικό] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob Β.] Ναι, q.strings.

483
00:36:56,000 --> 00:37:02,000
Θα μπορούσαμε να κάνουμε και είτε q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Αυτό είναι σημαντικά λιγότερο κοινή από αυτό.

485
00:37:05,000 --> 00:37:14,000
Αν είναι ακριβώς πρόκειται να είναι 0, τότε θα έχουν την τάση να δείτε q.strings.

486
00:37:14,000 --> 00:37:16,000
Αυτό είναι όπου είμαστε από αντιγραφή.

487
00:37:16,000 --> 00:37:18,000
Πόσα bytes δεν έχουμε αφήσει να αντιγράψετε; >> [Φοιτητικό] 10.

488
00:37:18,000 --> 00:37:20,000
Δεξιά.

489
00:37:20,000 --> 00:37:25,000
[Φοιτητικό] Μήπως πρέπει να πολλαπλασιαστούν 5 έως 10 φορές το μέγεθος των bytes ή κάτι άλλο;

490
00:37:25,000 --> 00:37:30,000
Ναι, έτσι αυτό είναι όπου-τι ακριβώς είμαστε αντιγραφή;

491
00:37:30,000 --> 00:37:32,000
[Φοιτητών] [δεν ακούγεται]

492
00:37:32,000 --> 00:37:34,000
Ποιο είναι το είδος του πράγματος είμαστε αντιγραφή;

493
00:37:34,000 --> 00:37:36,000
[Φοιτητών] [δεν ακούγεται]

494
00:37:36,000 --> 00:37:41,000
Ναι, έτσι το char * s που είμαστε αντιγραφή, δεν γνωρίζουμε εάν αυτά προέρχονται από.

495
00:37:41,000 --> 00:37:47,000
Λοιπόν, εκεί που δείχνει να, σαν τις χορδές, καταλήγουμε σπρώχνοντάς το επάνω στην ουρά

496
00:37:47,000 --> 00:37:49,000
ή enqueuing επάνω στην ουρά.

497
00:37:49,000 --> 00:37:51,000
Όταν αυτά προέρχονται από, δεν έχουμε ιδέα.

498
00:37:51,000 --> 00:37:56,000
Πρέπει απλώς να παρακολουθείτε την char * s οι ίδιοι.

499
00:37:56,000 --> 00:38:00,000
Δεν θέλουμε να αντιγράψετε το μέγεθος - bytes κεφάλι.

500
00:38:00,000 --> 00:38:03,000
Θέλουμε να αντιγράψετε το μέγεθος - το κεφάλι char * s,

501
00:38:03,000 --> 00:38:11,000
έτσι θα πάμε να πολλαπλασιάσει αυτό με sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Ίδιο εδώ κάτω, το κεφάλι * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Φοιτητικό] Τι γίνεται με [δεν ακούγεται];

504
00:38:24,000 --> 00:38:26,000
Το δικαίωμα αυτό εδώ;

505
00:38:26,000 --> 00:38:28,000
[Φοιτητικό] Όχι, κάτω από αυτό, το μέγεθος - το κεφάλι.

506
00:38:28,000 --> 00:38:30,000
[Rob Β.] Το δικαίωμα αυτό εδώ;

507
00:38:30,000 --> 00:38:32,000
Αριθμητική δείκτη.

508
00:38:32,000 --> 00:38:35,000
Πώς αριθμητική δείκτη πρόκειται να λειτουργήσει είναι

509
00:38:35,000 --> 00:38:40,000
πολλαπλασιάζει αυτόματα από το μέγεθος του τύπου ότι έχουμε να κάνουμε με.

510
00:38:40,000 --> 00:38:46,000
Ακριβώς όπως και εδώ, νέα + (μέγεθος - κεφάλι)

511
00:38:46,000 --> 00:38:56,000
είναι ακριβώς ισοδύναμη με νέο & [μέγεθος - το κεφάλι]

512
00:38:56,000 --> 00:39:00,000
μέχρι να αναμένουμε ότι για να λειτουργήσει σωστά,

513
00:39:00,000 --> 00:39:04,000
από το αν έχουμε να κάνουμε με έναν int πίνακα, τότε δεν με δείκτη int-

514
00:39:04,000 --> 00:39:07,000
ή αν είναι το μέγεθος των 5 και θέλετε το 4ο στοιχείο, τότε ο δείκτης σε

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
Μπορείτε μην τα-[4] * μέγεθος του int.

517
00:39:14,000 --> 00:39:21,000
Αυτό είναι χειρίζεται αυτόματα, και αυτή η υπόθεση

518
00:39:21,000 --> 00:39:29,000
Είναι κυριολεκτικά ισοδύναμο, έτσι ώστε η σύνταξη βραχίονα

519
00:39:29,000 --> 00:39:34,000
είναι ακριβώς πρόκειται να μετατραπεί σε αυτό το συντομότερο κάνετε compile.

520
00:39:34,000 --> 00:39:38,000
Αυτό είναι κάτι που πρέπει να είστε προσεκτικοί από αυτό

521
00:39:38,000 --> 00:39:42,000
όταν προσθέτετε το μέγεθος - το κεφάλι

522
00:39:42,000 --> 00:39:45,000
προσθέτετε όχι ένα byte.

523
00:39:45,000 --> 00:39:53,000
Είσαι προσθήκη ενός char *, το οποίο μπορεί να είναι ένα byte ή οτιδήποτε άλλο.

524
00:39:53,000 --> 00:39:56,000
>> Άλλες ερωτήσεις;

525
00:39:56,000 --> 00:40:04,000
Εντάξει, dequeue πρόκειται να είναι εύκολο.

526
00:40:04,000 --> 00:40:11,000
Θα σας δώσω ένα λεπτό για να εφαρμόσουν.

527
00:40:11,000 --> 00:40:18,000
Ω, και υποθέτω ότι αυτή είναι η ίδια κατάσταση όπου

528
00:40:18,000 --> 00:40:21,000
τι η enqueue περίπτωση, εάν είμαστε enqueuing null,

529
00:40:21,000 --> 00:40:24,000
ίσως θέλουμε να το χειριστεί, ίσως δεν το κάνουμε.

530
00:40:24,000 --> 00:40:27,000
Εμείς δεν θα το κάνουμε και πάλι εδώ, αλλά ίδια με την περίπτωση stack μας.

531
00:40:27,000 --> 00:40:34,000
Αν enqueue null, θα μπορούσαμε να θέλουμε να το αγνοήσει.

532
00:40:34,000 --> 00:40:40,000
Όποιος έχει κάποιο κώδικα μπορώ να σηκώσει;

533
00:40:40,000 --> 00:40:45,000
[Φοιτητικό] Έχω μόλις dequeue.

534
00:40:45,000 --> 00:40:56,000
Έκδοση 2 είναι ότι, εντάξει.

535
00:40:56,000 --> 00:40:59,000
Θέλετε να εξηγήσει;

536
00:40:59,000 --> 00:41:01,000
[Φοιτητικό] Κατ 'αρχάς, μπορείτε να βεβαιωθείτε ότι δεν υπάρχει κάτι στην ουρά

537
00:41:01,000 --> 00:41:07,000
και ότι το μέγεθος θα είναι κάτω από το 1.

538
00:41:07,000 --> 00:41:11,000
Θα πρέπει να το κάνουμε αυτό, και στη συνέχεια μπορείτε να επιστρέψετε το κεφάλι

539
00:41:11,000 --> 00:41:13,000
και στη συνέχεια μετακινήστε το κεφάλι μέχρι 1.

540
00:41:13,000 --> 00:41:19,000
Εντάξει, έτσι υπάρχει μια περίπτωση γωνία πρέπει να εξετάσουμε. Ναι.

541
00:41:19,000 --> 00:41:24,000
[Φοιτητικό] Αν το κεφάλι σας είναι το τελευταίο στοιχείο,

542
00:41:24,000 --> 00:41:26,000
τότε δεν θέλετε να το κεφάλι έξω από το σημείο του πίνακα.

543
00:41:26,000 --> 00:41:29,000
>> Ναι, έτσι ώστε μόλις το κεφάλι χτυπά το τέλος της σειρά μας,

544
00:41:29,000 --> 00:41:35,000
όταν εμείς dequeue, το κεφάλι μας θα πρέπει να modded πίσω στο 0.

545
00:41:35,000 --> 00:41:40,000
Δυστυχώς, δεν μπορούμε να το κάνουμε αυτό σε ένα βήμα.

546
00:41:40,000 --> 00:41:44,000
Υποθέτω ότι με τον τρόπο που θα καθορίσει κατά πάσα πιθανότητα θα είναι

547
00:41:44,000 --> 00:41:52,000
αυτό πρόκειται να είναι ένα char *, τι είμαστε επιστροφή,

548
00:41:52,000 --> 00:41:55,000
ό, τι όνομα της μεταβλητής σας θέλει να είναι.

549
00:41:55,000 --> 00:42:02,000
Στη συνέχεια, θέλουμε να mod το κεφάλι από την ικανότητά μας

550
00:42:02,000 --> 00:42:10,000
και στη συνέχεια επιστρέφουν ret.

551
00:42:10,000 --> 00:42:14,000
Πολλοί άνθρωποι εδώ θα μπορούσαν να κάνουν-

552
00:42:14,000 --> 00:42:19,000
αυτή είναι η περίπτωση της-θα δούμε αν οι άνθρωποι κάνουν το κεφάλι

553
00:42:19,000 --> 00:42:29,000
είναι μεγαλύτερη από την ικανότητα, κάντε το κεφάλι - ικανότητα.

554
00:42:29,000 --> 00:42:36,000
Και αυτό είναι ακριβώς που εργάζονται γύρω από το τι είναι mod.

555
00:42:36,000 --> 00:42:41,000
Επικεφαλής mod = ικανότητα είναι πολύ πιο καθαρά

556
00:42:41,000 --> 00:42:51,000
του περιτύλιγμα γύρω από ό, τι αν το κεφάλι μεγαλύτερη από το κεφάλι ικανότητα - ικανότητα.

557
00:42:51,000 --> 00:42:56,000
>> Ερωτήσεις;

558
00:42:56,000 --> 00:43:02,000
Εντάξει, το τελευταίο πράγμα που μας έχει απομείνει είναι συνδεδεμένη λίστα μας.

559
00:43:02,000 --> 00:43:07,000
Μπορεί να χρησιμοποιηθεί για μερικές από τις συμπεριφορές που συνδέονται με λίστα, αν κάνατε

560
00:43:07,000 --> 00:43:11,000
συνδεδεμένες λίστες σε πίνακες κατακερματισμού σας, αν κάνατε ένα πίνακα κατακερματισμού.

561
00:43:11,000 --> 00:43:15,000
Συνιστώ ανεπιφύλακτα να κάνει ένα πίνακα κατακερματισμού.

562
00:43:15,000 --> 00:43:17,000
Μπορεί να έχουν κάνει ήδη μια trie,

563
00:43:17,000 --> 00:43:23,000
αλλά προσπαθεί είναι πιο δύσκολο.

564
00:43:23,000 --> 00:43:27,000
Στη θεωρία, είναι ασυμπτωτικά καλύτερα.

565
00:43:27,000 --> 00:43:30,000
Αλλά μόλις δούμε τη μεγάλη του σκάφους,

566
00:43:30,000 --> 00:43:35,000
και προσπαθεί ποτέ να κάνουμε κάτι καλύτερο, και καταλαμβάνουν περισσότερο χώρο στη μνήμη.

567
00:43:35,000 --> 00:43:43,000
Τα πάντα προσπαθεί για καταλήγει να είναι χειρότερο για περισσότερη δουλειά.

568
00:43:43,000 --> 00:43:49,000
Είναι αυτό που ο David Malan λύση είναι πάντα

569
00:43:49,000 --> 00:43:56,000
είναι αυτός δημοσιεύσεις πάντα trie λύση του, και ας δούμε πού είναι σήμερα.

570
00:43:56,000 --> 00:44:00,000
Τι ήταν αυτός κάτω, David J;

571
00:44:00,000 --> 00:44:06,000
Είναι # 18, οπότε αυτό δεν είναι τρομερά κακό,

572
00:44:06,000 --> 00:44:09,000
και αυτό πρόκειται να είναι ένα από τα καλύτερα προσπαθεί μπορείτε να σκεφτείτε

573
00:44:09,000 --> 00:44:17,000
ή ένα από τα καλύτερα προσπαθεί ενός δραστήριoτητα.

574
00:44:17,000 --> 00:44:23,000
Δεν είναι καν πρωτότυπη λύση του;

575
00:44:23,000 --> 00:44:29,000
Νιώθω σαν trie λύσεις τείνουν να είναι περισσότερο σε αυτό το εύρος της χρήσης μνήμης RAM.

576
00:44:29,000 --> 00:44:33,000
>> Πηγαίνετε μέχρι την κορυφή, και μνήμη RAM χρήση είναι σε μονοψήφια.

577
00:44:33,000 --> 00:44:36,000
Κατεβείτε προς τα κάτω, και τότε θα αρχίσετε να βλέπετε προσπαθεί

578
00:44:36,000 --> 00:44:41,000
όπου μπορείτε να πάρετε απολύτως μαζική χρήση RAM,

579
00:44:41,000 --> 00:44:45,000
και προσπαθεί είναι πιο δύσκολη.

580
00:44:45,000 --> 00:44:53,000
Δεν είναι εντελώς αξίζει τον κόπο, αλλά μια εκπαιδευτική εμπειρία, αν κάνατε ένα.

581
00:44:53,000 --> 00:44:56,000
Το τελευταίο πράγμα που είναι συνδεδεμένη λίστα μας,

582
00:44:56,000 --> 00:45:04,000
και αυτά τα τρία πράγματα, στοίβες, ουρές, και συνδεδεμένες λίστες,

583
00:45:04,000 --> 00:45:09,000
οποιαδήποτε μελλοντική πράγμα που κάνετε πάντα στην επιστήμη των υπολογιστών

584
00:45:09,000 --> 00:45:12,000
Θα υποθέσουμε ότι έχετε εξοικείωση με αυτά τα πράγματα.

585
00:45:12,000 --> 00:45:19,000
Είναι ακριβώς τόσο θεμελιώδες για τα πάντα.

586
00:45:19,000 --> 00:45:25,000
>> Συνδέεται λίστες, και εδώ έχουμε μια μεμονωμένα συνδεδεμένη λίστα πρόκειται να είναι εφαρμογή μας.

587
00:45:25,000 --> 00:45:34,000
Τι σημαίνει μεμονωμένα συνδέονται σε αντίθεση με διπλά συνδέονται; Ναι.

588
00:45:34,000 --> 00:45:37,000
[Φοιτητικό] Επισημαίνει μόνο στο επόμενο δείκτη αντί για τους δείκτες,

589
00:45:37,000 --> 00:45:39,000
όπως εκείνη που προηγείται και το ένα μετά από αυτό.

590
00:45:39,000 --> 00:45:44,000
Ναι, έτσι σε μορφή εικόνας, τι έκανα ακριβώς κάνουν;

591
00:45:44,000 --> 00:45:48,000
Έχω δύο πράγματα. Έχω εικόνα και εικόνα.

592
00:45:48,000 --> 00:45:51,000
Σε μορφή εικόνας, μεμονωμένα συνδεδεμένες λίστες μας,

593
00:45:51,000 --> 00:45:57,000
αναπόφευκτα, θα έχουν κάποιο είδος του δείκτη στο κεφάλι του καταλόγου μας,

594
00:45:57,000 --> 00:46:02,000
και στη συνέχεια μέσα στη λίστα μας, έχουμε μόλις δείκτες,

595
00:46:02,000 --> 00:46:05,000
και ίσως αυτό δείχνει σε null.

596
00:46:05,000 --> 00:46:08,000
Είναι πρόκειται να είναι τυπικό το σχέδιό σας από μια λίστα που συνδέονται με μεμονωμένα.

597
00:46:08,000 --> 00:46:14,000
Μια διπλά συνδεδεμένη λίστα, μπορείτε να πάτε πίσω.

598
00:46:14,000 --> 00:46:19,000
Αν μπορώ να σας δώσω καμία κόμβος στη λίστα, τότε μπορείτε να πάρετε οπωσδήποτε να

599
00:46:19,000 --> 00:46:23,000
οποιοδήποτε άλλο κόμβο στον κατάλογο εάν είναι μια διπλά συνδεδεμένη λίστα.

600
00:46:23,000 --> 00:46:27,000
Αλλά αν σου φέρω το τρίτο κόμβο στη λίστα και είναι μια μεμονωμένα συνδεδεμένη λίστα,

601
00:46:27,000 --> 00:46:30,000
κανένας τρόπος εσείς πρόκειται ποτέ να φτάσουμε στην πρώτη και δεύτερη κόμβους.

602
00:46:30,000 --> 00:46:34,000
Και υπάρχουν οφέλη και μειονεκτήματα, και μία προφανής

603
00:46:34,000 --> 00:46:42,000
είναι να πάρετε περισσότερο το μέγεθος, και θα πρέπει να παρακολουθείτε πού αυτά τα πράγματα δείχνουν τώρα.

604
00:46:42,000 --> 00:46:49,000
Αλλά μόνο νοιάζονται για μεμονωμένα συνδέονται.

605
00:46:49,000 --> 00:46:53,000
>> Λίγα πράγματα θα πάμε να πρέπει να εφαρμόσουν.

606
00:46:53,000 --> 00:47:00,000
Typedef struct κόμβος σας, int i: struct node * επόμενος? Κόμβο.

607
00:47:00,000 --> 00:47:09,000
Αυτό typedef πρέπει να καεί στο μυαλό σας.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 θα πρέπει να δώσει μια παρόμοια typedef ενός συνδεδεμένου κόμβου λίστα,

609
00:47:14,000 --> 00:47:18,000
και θα πρέπει να είναι σε θέση να κακογράφω ότι αμέσως κάτω

610
00:47:18,000 --> 00:47:22,000
χωρίς καν να το σκεφτούμε.

611
00:47:22,000 --> 00:47:27,000
Υποθέτω ότι ένα ζευγάρι ερωτήσεις, γιατί χρειαζόμαστε struct εδώ;

612
00:47:27,000 --> 00:47:32,000
Γιατί δεν μπορούμε να πούμε κόμβο *;

613
00:47:32,000 --> 00:47:35,000
[Φοιτητών] [δεν ακούγεται]

614
00:47:35,000 --> 00:47:38,000
Ναι.

615
00:47:38,000 --> 00:47:44,000
Το μόνο πράγμα που καθορίζει ένα κόμβο ως ένα πράγμα

616
00:47:44,000 --> 00:47:47,000
είναι το ίδιο το typedef.

617
00:47:47,000 --> 00:47:55,000
Αλλά από αυτό το σημείο, όταν είμαστε το είδος της ανάλυσης μέσω του κόμβου αυτού του ορισμού struct,

618
00:47:55,000 --> 00:48:01,000
δεν έχουμε τελειώσει ακόμα typedef μας, έτσι ώστε από το typedef δεν έχει τελειώσει,

619
00:48:01,000 --> 00:48:05,000
κόμβος δεν υπάρχει.

620
00:48:05,000 --> 00:48:12,000
Αλλά struct κόμβος κάνει, και αυτός ο κόμβος εδώ,

621
00:48:12,000 --> 00:48:14,000
αυτό θα μπορούσε επίσης να ονομάζεται οτιδήποτε άλλο.

622
00:48:14,000 --> 00:48:16,000
Αυτό θα μπορούσε να ονομαστεί n.

623
00:48:16,000 --> 00:48:19,000
Θα μπορούσε να ονομαστεί συνδεδεμένη κόμβο λίστας.

624
00:48:19,000 --> 00:48:21,000
Θα μπορούσε να λέγεται τίποτα.

625
00:48:21,000 --> 00:48:26,000
Αλλά αυτός ο κόμβος struct πρέπει να λέγεται το ίδιο πράγμα με αυτό τον κόμβο struct.

626
00:48:26,000 --> 00:48:29,000
Αυτό εσείς το λέτε αυτό, θα πρέπει επίσης να είναι εδώ,

627
00:48:29,000 --> 00:48:32,000
και έτσι ώστε να απαντά, επίσης, το δεύτερο σημείο της ερώτησης

628
00:48:32,000 --> 00:48:37,000
η οποία είναι ο λόγος, πολλές φορές όταν βλέπεις structs και typedefs της structs,

629
00:48:37,000 --> 00:48:42,000
θα δείτε ανώνυμο structs όπου θα δείτε ακριβώς typedef struct,

630
00:48:42,000 --> 00:48:47,000
εφαρμογή του struct, λεξικό, ή οτιδήποτε άλλο.

631
00:48:47,000 --> 00:48:51,000
>> Γιατί εδώ δεν χρειάζεται να πούμε κόμβο;

632
00:48:51,000 --> 00:48:54,000
Γιατί δεν μπορεί να είναι μια ανώνυμη struct;

633
00:48:54,000 --> 00:48:56,000
Είναι σχεδόν η ίδια απάντηση.

634
00:48:56,000 --> 00:48:58,000
[Φοιτητικό] Θα πρέπει να αναφερθεί ότι στο πλαίσιο του struct.

635
00:48:58,000 --> 00:49:04,000
Ναι, στο πλαίσιο του struct, θα πρέπει να αναφερθώ στην ίδια struct.

636
00:49:04,000 --> 00:49:10,000
Εάν δεν δώσει το struct ένα όνομα, αν είναι μια ανώνυμη struct, δεν μπορείτε να ανατρέχετε σε αυτό.

637
00:49:10,000 --> 00:49:17,000
Και τελευταίο αλλά όχι λιγότερο σημαντικό, αυτά θα πρέπει όλα να είναι κάπως απλό,

638
00:49:17,000 --> 00:49:20,000
και θα πρέπει να σας βοηθήσει να συνειδητοποιήσετε αν είστε γραπτώς αυτό κάτω

639
00:49:20,000 --> 00:49:24,000
ότι κάνεις κάτι λάθος, αν αυτά τα είδη των πραγμάτων δεν έχουν νόημα.

640
00:49:24,000 --> 00:49:28,000
Τελευταίο, αλλά όχι λιγότερο σημαντικό, γιατί αυτό πρέπει να είναι struct node *;

641
00:49:28,000 --> 00:49:34,000
Γιατί δεν μπορεί απλά να struct node το επόμενο βήμα;

642
00:49:34,000 --> 00:49:37,000
[Φοιτητικό] Δείκτης στο επόμενο struct.

643
00:49:37,000 --> 00:49:39,000
Αυτό είναι αναπόφευκτα ό, τι θέλουμε.

644
00:49:39,000 --> 00:49:42,000
Γιατί ποτέ δεν θα μπορούσε να είναι κόμβος struct το επόμενο βήμα;

645
00:49:42,000 --> 00:49:50,000
Γιατί πρέπει να είναι struct node * το επόμενο βήμα; Ναι.

646
00:49:50,000 --> 00:49:53,000
[Φοιτητικό] Είναι σαν ένα άπειρο βρόχο.

647
00:49:53,000 --> 00:49:55,000
Ναι.

648
00:49:55,000 --> 00:49:57,000
[Φοιτητικό] Θα είναι όλα σε ένα.

649
00:49:57,000 --> 00:50:02,000
Ναι, απλά σκεφτείτε πώς θα κάνουμε το μέγεθος του ή κάτι τέτοιο.

650
00:50:02,000 --> 00:50:08,000
Μέγεθος της struct είναι βασικά + ή - μερικές μοτίβο εδώ ή εκεί.

651
00:50:08,000 --> 00:50:15,000
Είναι ουσιαστικά θα είναι το άθροισμα των μεγεθών των πραγμάτων στο struct.

652
00:50:15,000 --> 00:50:18,000
Το δικαίωμα αυτό εδώ, χωρίς να αλλάξει τίποτα, το μέγεθος πρόκειται να είναι εύκολο.

653
00:50:18,000 --> 00:50:24,000
Μέγεθος struct του κόμβου θα είναι το μέγεθος του i + μέγεθος του επόμενου.

654
00:50:24,000 --> 00:50:27,000
Μέγεθος του i πρόκειται να είναι 4. Μέγεθος της επόμενης πρόκειται να είναι 4.

655
00:50:27,000 --> 00:50:30,000
Μέγεθος struct του κόμβου θα είναι 8.

656
00:50:30,000 --> 00:50:34,000
Αν δεν έχουμε την *, σκέφτεται sizeof,

657
00:50:34,000 --> 00:50:37,000
τότε sizeof (i) θα είναι 4.

658
00:50:37,000 --> 00:50:43,000
Μέγεθος struct του κόμβου είναι επόμενο θα είναι το μέγεθος του i + μέγεθος του κόμβου struct επόμενη

659
00:50:43,000 --> 00:50:46,000
+ Μέγεθος του μεγέθους i + struct του κόμβου επόμενο.

660
00:50:46,000 --> 00:50:55,000
Θα ήταν μια άπειρη αναδρομή των κόμβων.

661
00:50:55,000 --> 00:51:00,000
Γι 'αυτό είναι πως τα πράγματα πρέπει να είναι.

662
00:51:00,000 --> 00:51:03,000
>> Και πάλι, σίγουρα απομνημονεύσει ότι,

663
00:51:03,000 --> 00:51:06,000
ή τουλάχιστον αυτό καταλαβαίνω αρκετά ώστε να μπορείτε να είναι σε θέση να

664
00:51:06,000 --> 00:51:12,000
λόγο μέσα από ό, τι πρέπει να μοιάσει.

665
00:51:12,000 --> 00:51:14,000
Τα πράγματα θα πάμε να θέλουν να εφαρμόσουν.

666
00:51:14,000 --> 00:51:18,000
Εάν το μήκος του καταλόγου-

667
00:51:18,000 --> 00:51:21,000
θα μπορούσε να εξαπατήσει και να κρατήσει γύρω από ένα

668
00:51:21,000 --> 00:51:24,000
παγκόσμια μήκος ή κάτι, αλλά εμείς δεν πρόκειται να το κάνουμε αυτό.

669
00:51:24,000 --> 00:51:28,000
Εμείς πάμε για να μετρήσετε το μήκος της λίστας.

670
00:51:28,000 --> 00:51:34,000
Έχουμε περιέχει, έτσι ώστε να είναι ουσιαστικά σαν μια αναζήτηση,

671
00:51:34,000 --> 00:51:41,000
έτσι έχουμε μια συνδεδεμένη λίστα ακεραίων για να δούμε αν αυτό είναι ακέραιος στην συνδεδεμένη λίστα.

672
00:51:41,000 --> 00:51:44,000
Βάλε πρόκειται να προστεθεί στην αρχή της λίστας.

673
00:51:44,000 --> 00:51:46,000
Προσάρτηση πρόκειται να προστεθεί στο τέλος.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted πρόκειται να εισαγάγει την ταξινόμηση θέση στη λίστα.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted είδους υποθέτει ότι ποτέ δεν χρησιμοποιείται ή βάλε το προσθέσετε σε κακή τρόπους.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted όταν εφαρμογή insert_sorted-

677
00:52:09,000 --> 00:52:13,000
Ας πούμε ότι έχουμε συνδεδεμένη λίστα μας.

678
00:52:13,000 --> 00:52:18,000
Αυτό είναι ό, τι φαίνεται σήμερα, όπως, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Θέλω να εισαγάγετε 3, έτσι ώστε όσο η ίδια η λίστα είναι ήδη ταξινόμηση,

680
00:52:24,000 --> 00:52:27,000
Είναι εύκολο να βρείτε όπου 3 ανήκει.

681
00:52:27,000 --> 00:52:29,000
Αρχίζω στο 2.

682
00:52:29,000 --> 00:52:32,000
Εντάξει, 3 είναι μεγαλύτερο του 2, έτσι θέλω να συνεχίσω.

683
00:52:32,000 --> 00:52:35,000
Ω, 4 είναι πάρα πολύ μεγάλη, γι 'αυτό γνωρίζω 3 πρόκειται να πάει στο μεταξύ 2 και 4,

684
00:52:35,000 --> 00:52:39,000
και έχω να καθορίσει δείκτες και όλα αυτά τα πράγματα.

685
00:52:39,000 --> 00:52:43,000
Αλλά αν δεν είναι απολύτως χρησιμοποιούν insert_sorted,

686
00:52:43,000 --> 00:52:50,000
όπως ας πούμε ότι βάζουμε μπροστά 6,

687
00:52:50,000 --> 00:52:55,000
τότε συνδεδεμένη λίστα μου πρόκειται να γίνει αυτό.

688
00:52:55,000 --> 00:53:01,000
Δεν έχει πλέον κανένα νόημα, έτσι για insert_sorted, μπορείτε απλά να υποθέσουμε

689
00:53:01,000 --> 00:53:04,000
ότι η λίστα είναι ταξινομημένη, ακόμη και αν οι λειτουργίες υπάρχουν

690
00:53:04,000 --> 00:53:09,000
η οποία μπορεί να προκαλέσει το να μην ταξινόμηση, και αυτό είναι αυτό.

691
00:53:09,000 --> 00:53:20,000
Βρείτε ένα χρήσιμο ένθετο έτσι αυτά είναι τα κύρια πράγματα που πρόκειται να πρέπει να εφαρμόσουν.

692
00:53:20,000 --> 00:53:24,000
>> Προς το παρόν, πάρτε ένα λεπτό για να κάνει το μήκος και περιέχει,

693
00:53:24,000 --> 00:53:30,000
και εκείνοι θα πρέπει να είναι σχετικά γρήγορη.

694
00:53:41,000 --> 00:53:48,000
Πλησιάζει η ώρα κλεισίματος, έτσι ώστε ο καθένας έχει κάτι για το μήκος ή περιέχει;

695
00:53:48,000 --> 00:53:50,000
Θα πάμε να είναι σχεδόν ταυτόσημες.

696
00:53:50,000 --> 00:53:57,000
[Φοιτητικό] Μήκος.

697
00:53:57,000 --> 00:54:01,000
Ας δούμε, αναθεώρηση.

698
00:54:01,000 --> 00:54:04,000
Εντάξει.

699
00:54:12,000 --> 00:54:15,000
Θέλετε να εξηγήσει;

700
00:54:15,000 --> 00:54:21,000
[Φοιτητικό] θα δημιουργήσει μόνο έναν κόμβο δείκτη και η προετοιμασία για το πρώτο, το οποίο είναι καθολική μεταβλητή μας,

701
00:54:21,000 --> 00:54:27,000
και στη συνέχεια να ελέγξω αν είναι μηδενική, έτσι δεν παίρνω ένα σφάλμα SEG και να επιστρέψει 0 αν αυτή είναι η περίπτωση.

702
00:54:27,000 --> 00:54:34,000
Διαφορετικά, θα βρόχο μέσω, παρακολουθώντας μέσα ακέραιο

703
00:54:34,000 --> 00:54:38,000
πόσες φορές έχω πρόσβαση το επόμενο στοιχείο της λίστας

704
00:54:38,000 --> 00:54:43,000
και στην ίδια λειτουργία προσαύξησης πρόσβαση επίσης ότι η πραγματική στοιχείο,

705
00:54:43,000 --> 00:54:47,000
και στη συνέχεια θα κάνει συνεχώς ο έλεγχος για να δούμε αν είναι μηδενική,

706
00:54:47,000 --> 00:54:56,000
και αν είναι μηδενική, τότε από τη ματαίωση και απλά επιστρέφει τον αριθμό των στοιχείων που έχω πρόσβαση.

707
00:54:56,000 --> 00:55:01,000
>> [Rob Β.] Υπάρχει κάποιος που έχει κάποιες παρατηρήσεις σε τίποτα;

708
00:55:01,000 --> 00:55:06,000
Αυτό φαίνεται μια χαρά ορθότητα σοφός.

709
00:55:06,000 --> 00:55:10,000
[Φοιτητικό] Δεν νομίζω ότι θα πρέπει να έχετε τον κόμβο == null.

710
00:55:10,000 --> 00:55:13,000
Ναι, έτσι εάν ο κόμβος == null 0 επιστροφής.

711
00:55:13,000 --> 00:55:18,000
Αλλά αν ο κόμβος == null, τότε αυτό-OH, υπάρχει ένα ζήτημα ορθότητας.

712
00:55:18,000 --> 00:55:23,000
Ήταν απλά είστε i επιστρέφουν, αλλά δεν είναι στο πεδίο εφαρμογής αυτή τη στιγμή.

713
00:55:23,000 --> 00:55:30,000
Απλά πρέπει int i, έτσι ώστε i = 0.

714
00:55:30,000 --> 00:55:34,000
Αλλά αν ο κόμβος είναι μηδενική, τότε εγώ ακόμα θα είναι 0,

715
00:55:34,000 --> 00:55:39,000
και θα πάμε να επιστρέψει 0, οπότε αυτή η περίπτωση είναι όμοια.

716
00:55:39,000 --> 00:55:48,000
Ένα άλλο κοινό πράγμα είναι να κρατήσει τη δήλωση

717
00:55:48,000 --> 00:55:51,000
μέσα από τον κόμβο του για βρόχο.

718
00:55:51,000 --> 00:55:54,000
Θα μπορούσαμε να πούμε-ω, όχι.

719
00:55:54,000 --> 00:55:56,000
Ας κρατήσουμε ως αυτό.

720
00:55:56,000 --> 00:55:59,000
I θα μπορούσε πιθανότατα να τεθεί int i = 0 εδώ,

721
00:55:59,000 --> 00:56:05,000
τότε ο κόμβος * κόμβος = πρώτη εδώ.

722
00:56:05,000 --> 00:56:11,000
Και αυτό είναι πιθανώς το πώς-να απαλλαγούμε από αυτό τώρα.

723
00:56:11,000 --> 00:56:14,000
Αυτό είναι πιθανώς το πώς θα είχα γράψει.

724
00:56:14,000 --> 00:56:21,000
Θα μπορούσατε επίσης το μέλλον σε αυτό σαν αυτό.

725
00:56:21,000 --> 00:56:25,000
Αυτό για τη δομή βρόχου εδώ

726
00:56:25,000 --> 00:56:30,000
θα πρέπει να είναι σχεδόν τόσο φυσικό για εσάς και για int i = 0

727
00:56:30,000 --> 00:56:33,000
i είναι μικρότερο από το μήκος της συστοιχίας i + +.

728
00:56:33,000 --> 00:56:38,000
Αν αυτό είναι το πώς θα επαναλάβει σε μια σειρά, αυτό είναι το πώς θα επαναλάβει σε μια συνδεδεμένη λίστα.

729
00:56:38,000 --> 00:56:45,000
>> Αυτό θα πρέπει να είναι δεύτερη φύση σε κάποιο σημείο.

730
00:56:45,000 --> 00:56:50,000
Με αυτό κατά νου, αυτό πρόκειται να είναι σχεδόν το ίδιο πράγμα.

731
00:56:50,000 --> 00:56:57,000
Θα πάμε να θέλουν να επαναλάβει πάνω από μια συνδεδεμένη λίστα.

732
00:56:57,000 --> 00:57:02,000
Αν ο κόμβος-δεν έχω ιδέα ποια είναι η αξία ονομάζεται.

733
00:57:02,000 --> 00:57:04,000
Κόμβου i.

734
00:57:04,000 --> 00:57:15,000
Εάν η τιμή στο συγκεκριμένο κόμβο i = επιστρέψει αλήθεια, και αυτό είναι αυτό.

735
00:57:15,000 --> 00:57:18,000
Παρατηρήστε ότι ο μόνος τρόπος για να επιστρέψει ποτέ ψευδή

736
00:57:18,000 --> 00:57:23,000
είναι αν θα επαναλάβει κατά τη διάρκεια της συνδέεται με ολόκληρη τη λίστα και να μην επιστρέψει ποτέ αλήθεια,

737
00:57:23,000 --> 00:57:29,000
έτσι αυτό είναι που κάνει αυτό.

738
00:57:29,000 --> 00:57:36,000
Ως μια πλευρά σημείωση, που κατά πάσα πιθανότητα δεν θα πάρετε για να προσθέσετε ή να βάζουμε μπροστά.

739
00:57:36,000 --> 00:57:39,000
>> Γρήγορη τελευταία σημείωση.

740
00:57:39,000 --> 00:57:52,000
Αν δείτε το στατικό λέξη-κλειδί, οπότε ας πούμε στατική μέτρηση int = 0,

741
00:57:52,000 --> 00:57:56,000
τότε μετράνε + +, μπορείτε να βασικά σκεφτείτε από το ως μια καθολική μεταβλητή,

742
00:57:56,000 --> 00:58:00,000
παρόλο που μόλις είπα αυτό δεν είναι το πώς θα πάμε να εφαρμόσει το μήκος.

743
00:58:00,000 --> 00:58:06,000
Το κάνω αυτό εδώ, και στη συνέχεια υπολογίζει + +.

744
00:58:06,000 --> 00:58:11,000
Κάθε τρόπος με τον οποίο μπορούν να εισέλθουν σε έναν κόμβο συνδεδεμένη λίστα μας, είμαστε προσαύξηση μας μετράνε.

745
00:58:11,000 --> 00:58:15,000
Το σημείο αυτό είναι ό, τι το στατικό λέξη-κλειδί μέσα.

746
00:58:15,000 --> 00:58:20,000
Αν είχα μόνο int count = 0 η οποία θα είναι μια τακτική παλιά παγκόσμια μεταβλητή.

747
00:58:20,000 --> 00:58:25,000
Τι σημαίνει στατική int count είναι ότι είναι μια καθολική μεταβλητή για αυτό το αρχείο.

748
00:58:25,000 --> 00:58:28,000
Είναι αδύνατο για κάποιο άλλο αρχείο,

749
00:58:28,000 --> 00:58:34,000
όπως σκέφτομαι PSET 5, αν έχετε ξεκινήσει.

750
00:58:34,000 --> 00:58:39,000
Έχετε τόσο speller.c, και έχετε dictionary.c,

751
00:58:39,000 --> 00:58:42,000
και αν δηλώνουν μόνο ένα πράγμα παγκόσμιο, τότε τίποτα σε speller.c

752
00:58:42,000 --> 00:58:45,000
Μπορείτε να έχετε πρόσβαση σε dictionary.c και αντίστροφα.

753
00:58:45,000 --> 00:58:48,000
Οι καθολικές μεταβλητές είναι προσβάσιμα από οποιοδήποτε αρχείο. C,

754
00:58:48,000 --> 00:58:54,000
αλλά στατικές μεταβλητές είναι προσβάσιμη μόνο μέσα από το ίδιο το αρχείο,

755
00:58:54,000 --> 00:59:01,000
τόσο στο εσωτερικό της ορθογραφικό έλεγχο ή στο εσωτερικό του dictionary.c,

756
00:59:01,000 --> 00:59:06,000
αυτό είναι το είδος του πώς θα κηρύξει μεταβλητή μου για το μέγεθος του πίνακα μου

757
00:59:06,000 --> 00:59:10,000
ή το μέγεθος του αριθμού μου των λέξεων στο λεξικό.

758
00:59:10,000 --> 00:59:15,000
Επειδή δεν θέλω να κηρύξει μια παγκόσμια μεταβλητή που ο καθένας έχει πρόσβαση,

759
00:59:15,000 --> 00:59:18,000
Πραγματικά μόνο ενδιαφέρονται για αυτό για τους δικούς τους σκοπούς μου.

760
00:59:18,000 --> 00:59:21,000
>> Το καλό πράγμα για αυτό είναι, επίσης, η όλη ουσία σύγκρουση όνομα.

761
00:59:21,000 --> 00:59:27,000
Αν κάποιο άλλο αρχείο προσπαθεί να χρησιμοποιήσει μια καθολική μεταβλητή που ονομάζεται μέτρηση, τα πράγματα πάνε πολύ, πολύ λάθος,

762
00:59:27,000 --> 00:59:33,000
έτσι αυτό κρατά ωραία πράγματα ασφαλή, και μόνο μπορείτε να έχετε πρόσβαση,

763
00:59:33,000 --> 00:59:38,000
και κανένας άλλος δεν μπορεί, και αν κάποιος άλλος δηλώνει μια μεταβλητή που ονομάζεται παγκόσμια καταμέτρηση,

764
00:59:38,000 --> 00:59:43,000
τότε δεν θα παρεμβαίνει με στατική μεταβλητή σας ονομάζεται μετράνε.

765
00:59:43,000 --> 00:59:47,000
Αυτό είναι ό, τι είναι στατική. Πρόκειται για ένα αρχείο global μεταβλητή.

766
00:59:47,000 --> 00:59:52,000
>> Ερωτήσεις για τίποτα;

767
00:59:52,000 --> 00:59:59,000
Όλα έτοιμα. Αντίο.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]