1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[Παίζει μουσική]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: Εντάξει έτσι μια πρόταση
πριν από την έναρξη εδώ.

5
00:00:07,940 --> 00:00:11,660
Αν δεν έχετε παρακολουθήσει το βίντεο
Δείκτες ίσως να θέλετε να το κάνετε αυτό πρώτα.

6
00:00:11,660 --> 00:00:15,860
Επειδή αυτό το βίντεο είναι ένα άλλο
τρόπο εργασίας με δείκτες.

7
00:00:15,860 --> 00:00:17,574
>> Έτσι, πρόκειται να μιλήσω
σχετικά με ορισμένες έννοιες

8
00:00:17,574 --> 00:00:19,490
ότι έχουμε καλύψει το
Δείκτες βίντεο, και είμαστε

9
00:00:19,490 --> 00:00:21,948
πρόκειται να αποσιωπήσει τους τώρα,
υποθέτοντας ότι είναι ήδη

10
00:00:21,948 --> 00:00:23,090
είδος κατανοητό.

11
00:00:23,090 --> 00:00:25,440
Έτσι, αυτό είναι μόνο δίκαιη προειδοποίηση σας
ότι, αν βλέπετε αυτό το βίντεο

12
00:00:25,440 --> 00:00:27,814
και δεν έχετε δει το
Δείκτες βίντεο, θα μπορούσε το είδος του

13
00:00:27,814 --> 00:00:29,610
πετούν πάνω από το κεφάλι σας λίγο.

14
00:00:29,610 --> 00:00:32,080
Και έτσι θα μπορούσε να είναι καλύτερο
για να το δείτε σε αυτή τη σειρά.

15
00:00:32,080 --> 00:00:34,710
>> Έτσι, έχουμε ήδη δει ένα
τρόπος για να συνεργαστεί με τους δείκτες,

16
00:00:34,710 --> 00:00:37,810
η οποία είναι μια δηλώνουμε
μεταβλητή, και στη συνέχεια

17
00:00:37,810 --> 00:00:42,160
δηλώνουν μια άλλη μεταβλητή, ένα δείκτη
μεταβλητή, που δείχνει σ 'αυτό.

18
00:00:42,160 --> 00:00:44,870
Έτσι έχουμε δημιουργήσει μια
μεταβλητή με όνομα, έχουμε

19
00:00:44,870 --> 00:00:48,480
δημιούργησε μια δεύτερη μεταβλητή με όνομα,
και επισημαίνουμε ότι η δεύτερη μεταβλητή

20
00:00:48,480 --> 00:00:50,220
σε αυτό το πρώτο.

21
00:00:50,220 --> 00:00:52,370
Αυτό το είδος της έχει
πρόβλημα όμως, επειδή

22
00:00:52,370 --> 00:00:54,650
απαιτεί από εμάς να γνωρίζουμε ακριβώς
πόση μνήμη είμαστε

23
00:00:54,650 --> 00:00:57,600
θα χρειαστούν τη στιγμή
το πρόγραμμά μας έχει μεταγλωττιστεί.

24
00:00:57,600 --> 00:00:58,220
>> Γιατί αυτό?

25
00:00:58,220 --> 00:01:03,338
Επειδή πρέπει να είμαστε σε θέση να αναφέρουμε ή
τον εντοπισμό όλων των πιθανών μεταβλητών

26
00:01:03,338 --> 00:01:04,129
ενδέχεται να συναντήσουν.

27
00:01:04,129 --> 00:01:07,910
Μπορεί να έχουμε έναν πίνακα που θα μπορούσε να
μπορεί να συγκρατήσει πολλές πληροφορίες,

28
00:01:07,910 --> 00:01:10,110
αλλά δεν είναι ακόμα
ακριβώς αρκετά ακριβείς.

29
00:01:10,110 --> 00:01:12,640
Τι θα συμβεί αν δεν γνωρίζουμε,
Τι κι αν δεν έχουμε ιδέα

30
00:01:12,640 --> 00:01:14,370
πόσο θα χρειαστεί κατά τη μεταγλώττιση;

31
00:01:14,370 --> 00:01:17,020
Ή τι θα γινόταν αν το πρόγραμμά μας θα
τρέξει για ένα πραγματικά μεγάλο χρονικό διάστημα,

32
00:01:17,020 --> 00:01:19,810
αποδεχόμενοι τις διάφορες χρήστης
δεδομένων, και δεν μπορούμε πραγματικά

33
00:01:19,810 --> 00:01:23,170
να εκτιμήσουν κατά πόσον είμαστε
Θα χρειαστεί 1.000 μονάδες;

34
00:01:23,170 --> 00:01:26,060
>> Δεν είναι όπως μπορούμε
δηλαδή στη γραμμή εντολών

35
00:01:26,060 --> 00:01:28,040
εισάγετε πόσα στοιχεία
νομίζετε ότι θα χρειαστείτε.

36
00:01:28,040 --> 00:01:31,100
Λοιπόν τι θα γινόταν αν η εικασία είναι λάθος;

37
00:01:31,100 --> 00:01:34,300
Δυναμική κατανομή μνήμης
είδος μας επιτρέπει το δρόμο

38
00:01:34,300 --> 00:01:36,867
για να πάρει γύρω από αυτό το συγκεκριμένο πρόβλημα.

39
00:01:36,867 --> 00:01:38,700
Και ο τρόπος που το κάνει
είναι με τη χρήση δεικτών.

40
00:01:38,700 --> 00:01:42,140
>> Μπορούμε να χρησιμοποιήσουμε δείκτες για να
αποκτήστε πρόσβαση σε δυναμικά

41
00:01:42,140 --> 00:01:45,710
κατανεμημένη μνήμη, μνήμη που είναι
κατανέμονται ως πρόγραμμα τρέχει.

42
00:01:45,710 --> 00:01:48,290
Δεν είναι κατανέμονται κατά τη διάρκεια της μεταγλώττισης.

43
00:01:48,290 --> 00:01:51,570
Όταν δυναμικά διαθέσει
μνήμη προέρχεται από μια πισίνα

44
00:01:51,570 --> 00:01:53,795
της μνήμης είναι γνωστή ως του σωρού.

45
00:01:53,795 --> 00:01:56,420
Προηγουμένως όλη η μνήμη έχουμε
εργάζονται με κατά τη διάρκεια

46
00:01:56,420 --> 00:01:59,920
έχει προέρχεται από μια πισίνα
της μνήμης είναι γνωστή ως στοίβα.

47
00:01:59,920 --> 00:02:02,470
Ένας καλός τρόπος για να γένει
κρατήσει σε mind-- και αυτόν τον κανόνα

48
00:02:02,470 --> 00:02:04,720
δεν είναι πάντα θα ισχύει,
αλλά λίγο πολύ σχεδόν

49
00:02:04,720 --> 00:02:09,940
πάντα κρατά true-- είναι ότι κάθε
φορά που θα δώσει ένα όνομα μεταβλητής που

50
00:02:09,940 --> 00:02:12,090
πιθανώς ζει στη στοίβα.

51
00:02:12,090 --> 00:02:14,650
Και κάθε φορά που δεν
δώσει μια μεταβλητή ένα όνομα,

52
00:02:14,650 --> 00:02:19,160
που μπορείτε να κάνετε με δυναμική μνήμη
κατανομή, ζει στο σωρό.

53
00:02:19,160 --> 00:02:22,190
>> Τώρα είμαι το είδος της παρουσίασης, όπως αυτό
Αν υπάρχουν αυτά τα δύο πισίνες της μνήμης.

54
00:02:22,190 --> 00:02:24,740
Αλλά μπορεί να έχετε δει αυτό
διάγραμμα, το οποίο είναι γενικά

55
00:02:24,740 --> 00:02:27,290
μια αναπαράσταση της
ποια μνήμη μοιάζει,

56
00:02:27,290 --> 00:02:30,373
και εμείς δεν πρόκειται να νοιάζονται για όλα
τα πράγματα στην κορυφή και στο κάτω μέρος.

57
00:02:30,373 --> 00:02:33,580
Τι μας νοιάζει είναι αυτό το μέρος σε
η μέση εδώ, σωρού και στοίβα.

58
00:02:33,580 --> 00:02:35,570
Όπως μπορείτε να δείτε από
κοιτάζοντας αυτό το διάγραμμα,

59
00:02:35,570 --> 00:02:38,390
αυτά στην πραγματικότητα δεν είναι δύο
χωριστές πισίνες της μνήμης.

60
00:02:38,390 --> 00:02:42,757
Είναι ένα κοινό απόθεμα μνήμης
όπου μπορείτε να ξεκινήσετε, σε αυτή την οπτική

61
00:02:42,757 --> 00:02:44,590
που ξεκινούν από τη βάση
και να αρχίσει να γεμίζει

62
00:02:44,590 --> 00:02:48,040
από το κάτω μέρος με τη στοίβα, και
ξεκινούν από την κορυφή και να αρχίσει να γεμίζει

63
00:02:48,040 --> 00:02:50,072
από πάνω προς τα κάτω με το σωρό.

64
00:02:50,072 --> 00:02:51,780
Αλλά πραγματικά είναι η
ίδια πισίνα, είναι ακριβώς

65
00:02:51,780 --> 00:02:56,050
διαφορετικά σημεία, διαφορετικές θέσεις
στη μνήμη που έχει εκχωρηθεί.

66
00:02:56,050 --> 00:02:59,060
Και μπορείτε να ξεμείνει από
μνήμη είτε με

67
00:02:59,060 --> 00:03:01,240
ο σωρός να πάει όλος ο τρόπος
προς τα κάτω, ή να έχουν

68
00:03:01,240 --> 00:03:05,440
η στοίβα πάνε όλα το δρόμο προς την κορυφή,
ή με το σωρό και τη στοίβα

69
00:03:05,440 --> 00:03:06,740
συναντήσει ένας εναντίον του άλλου.

70
00:03:06,740 --> 00:03:09,500
Όλα αυτά μπορεί να είναι προϋποθέσεις
που προκαλούν το πρόγραμμά σας

71
00:03:09,500 --> 00:03:11,030
να ξεμείνει από μνήμη.

72
00:03:11,030 --> 00:03:11,952
Έτσι κρατήστε αυτό κατά νου.

73
00:03:11,952 --> 00:03:13,660
Όταν μιλάμε για
ο σωρός και η στοίβα

74
00:03:13,660 --> 00:03:17,880
είμαστε πραγματικά μιλάμε για το
ίδια γενική κομμάτι της μνήμης, απλά

75
00:03:17,880 --> 00:03:21,930
διαφορετικά τμήματα της εν λόγω μνήμης.

76
00:03:21,930 --> 00:03:24,910
>> Επομένως, πώς θα πάρει δυναμικά
μνήμης που έχει εκχωρηθεί στην πρώτη θέση;

77
00:03:24,910 --> 00:03:27,740
Πώς να πάρετε το πρόγραμμά μας
μνήμη καθώς τρέχει;

78
00:03:27,740 --> 00:03:32,660
Καλά C παρέχει μια λειτουργία που ονομάζεται
malloc, εκχώρησης μνήμης, η οποία

79
00:03:32,660 --> 00:03:36,810
μπορείτε να πραγματοποιήσετε μια κλήση, ενώ μπορείτε και να περάσει σε
πόσα bytes της μνήμης που θέλετε.

80
00:03:36,810 --> 00:03:39,940
Έτσι, αν το πρόγραμμά σας τρέχει
και θέλετε ένα runtime ακέραιο,

81
00:03:39,940 --> 00:03:46,040
ίσως Mallock τέσσερα byte
μνήμη, malloc τέσσερις παρενθέσεις.

82
00:03:46,040 --> 00:03:48,540
>> Mallock θα περάσει
κοιτάζοντας μέσα από το σωρό,

83
00:03:48,540 --> 00:03:50,750
επειδή είμαστε δυναμικά
την κατανομή της μνήμης,

84
00:03:50,750 --> 00:03:53,500
και θα επιστρέψει σε σας
ένας δείκτης σε αυτή την μνήμη.

85
00:03:53,500 --> 00:03:56,180
Δεν σας δώσει ότι memory--
δεν δώσει ένα όνομα,

86
00:03:56,180 --> 00:03:57,950
σας δίνει ένα δείκτη σε αυτό.

87
00:03:57,950 --> 00:04:00,780
Και έτσι γι 'αυτό είπα και πάλι
ότι είναι σημαντικό να ίσως

88
00:04:00,780 --> 00:04:03,770
έχουν παρακολουθήσει το βίντεο δείκτες
πριν φτάσουμε πολύ μακριά σε αυτό.

89
00:04:03,770 --> 00:04:05,940
Έτσι malloc πρόκειται να
να σας δώσει πίσω ένα δείκτη.

90
00:04:05,940 --> 00:04:08,950
>> Αν Mallock δεν μπορεί να σας δώσει οποιαδήποτε
μνήμης, επειδή έχετε τρέξει έξω,

91
00:04:08,950 --> 00:04:10,645
αυτό θα σας δώσει πίσω ένα κενό δείκτη.

92
00:04:10,645 --> 00:04:15,282
Θυμάστε τι θα συμβεί αν
δοκιμάστε και dereference ένα κενό δείκτη;

93
00:04:15,282 --> 00:04:17,019
Έχουμε υποστεί βλάβη SEG, σωστά;

94
00:04:17,019 --> 00:04:18,060
Αυτό ίσως δεν είναι καλό.

95
00:04:18,060 --> 00:04:21,579
>> Έτσι, κάθε φορά που κάνετε μια κλήση
να σας malloc πάντα, πάντα

96
00:04:21,579 --> 00:04:25,270
πρέπει να ελέγξει κατά πόσον ή όχι η
pointer που σας έδωσε πίσω είναι άκυρη.

97
00:04:25,270 --> 00:04:28,800
Αν είναι, θα πρέπει να τερματίσετε το πρόγραμμα σας
γιατί αν προσπαθήσετε και dereference

98
00:04:28,800 --> 00:04:31,360
η μηδενική δείκτης θα πάμε
να υποστούν ένα σφάλμα κατάτμησης

99
00:04:31,360 --> 00:04:34,380
και το πρόγραμμα σας είναι
έτοιμο να εκραγεί έτσι κι αλλιώς.

100
00:04:34,380 --> 00:04:37,190
Πώς, λοιπόν, εμείς στατικά
αποκτήσει έναν ακέραιο;

101
00:04:37,190 --> 00:04:37,730
>> int x.

102
00:04:37,730 --> 00:04:40,010
Πιθανώς Έχουμε κάνει ότι
ένα μάτσο φορές, σωστά;

103
00:04:40,010 --> 00:04:43,480
Αυτό δημιουργεί μια μεταβλητή που ονομάζεται
x που ζει στη στοίβα.

104
00:04:43,480 --> 00:04:46,190
Πώς παίρνουμε δυναμικά έναν ακέραιο;

105
00:04:46,190 --> 00:04:50,010
Int px αστέρων ισούται με malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Ή πιο σωστά
θα λέγαμε px int αστέρων

107
00:04:53,050 --> 00:04:57,680
ισούται με malloc μέγεθος του int,
απλά για να ρίξει κάποια λιγότερα

108
00:04:57,680 --> 00:04:59,740
μαγικοί αριθμοί γύρω από το πρόγραμμά μας.

109
00:04:59,740 --> 00:05:04,140
Αυτό πρόκειται να λάβουν για εμάς
τέσσερα bytes της μνήμης από το σωρό,

110
00:05:04,140 --> 00:05:06,720
και ο δείκτης παίρνουμε
Επιστροφή στην λέγεται px.

111
00:05:06,720 --> 00:05:08,430
Και τότε ακριβώς όπως έχουμε
έχουμε κάνει στο παρελθόν

112
00:05:08,430 --> 00:05:13,966
μπορεί να dereference px
πρόσβαση σε αυτή την μνήμη.

113
00:05:13,966 --> 00:05:15,590
Πώς θα πάρετε έναν ακέραιο από το χρήστη;

114
00:05:15,590 --> 00:05:17,970
Μπορούμε να πούμε int x ισούται με πάρει int.

115
00:05:17,970 --> 00:05:19,930
Αυτό είναι αρκετά απλή.

116
00:05:19,930 --> 00:05:24,030
Τι γίνεται αν θέλουμε να δημιουργήσουμε μια σειρά
Χ άρματα που ζουν στη στοίβα;

117
00:05:24,030 --> 00:05:28,210
επιπλέουν stack_array-- αυτό είναι το όνομα
της array-- αγκύλες μας χ.

118
00:05:28,210 --> 00:05:32,419
Αυτό θα δημιουργήσει για μας μια σειρά
Χ άρματα που ζουν στη στοίβα.

119
00:05:32,419 --> 00:05:34,960
Μπορούμε να δημιουργήσουμε μια σειρά από άρματα
ότι ζει στο σωρό, πάρα πολύ.

120
00:05:34,960 --> 00:05:37,330
Η σύνταξη μπορεί να μοιάζει μια
λίγο πιο περίπλοκη,

121
00:05:37,330 --> 00:05:41,740
αλλά μπορούμε να πούμε με πλωτήρα
heap_array αστέρι ισούται

122
00:05:41,740 --> 00:05:44,360
malloc x φορές το μέγεθος του πλωτήρα.

123
00:05:44,360 --> 00:05:48,160
Χρειάζομαι αρκετό χώρο για να κρατήσει
x τιμές κινητής υποδιαστολής.

124
00:05:48,160 --> 00:05:51,560
Έτσι λένε ότι χρειάζονται 100
πλωτήρες, ή 1.000 άρματα.

125
00:05:51,560 --> 00:05:54,810
Έτσι, σε αυτή την περίπτωση, θα ήταν
400 bytes για 100 άρματα,

126
00:05:54,810 --> 00:05:59,080
ή 4.000 bytes για 1.000 άρματα,
γιατί κάθε πλωτήρα καταλαμβάνει

127
00:05:59,080 --> 00:06:01,230
τέσσερα byte του χώρου.

128
00:06:01,230 --> 00:06:05,110
>> Μετά από αυτό μπορώ να χρησιμοποιήσω το
πλατεία σύνταξη βραχίονα heap_array.

129
00:06:05,110 --> 00:06:08,970
Ακριβώς όπως θα ήθελα για stack_array, Ι
μπορούν να έχουν πρόσβαση τα στοιχεία του ξεχωριστά

130
00:06:08,970 --> 00:06:11,590
χρησιμοποιώντας heap_array μηδέν, heap_array μία.

131
00:06:11,590 --> 00:06:15,800
Αλλά υπενθυμίζουν το λόγο μπορούμε να το κάνουμε αυτό
είναι επειδή το όνομα ενός πίνακα σε C

132
00:06:15,800 --> 00:06:19,990
Είναι πραγματικά ένας δείκτης για
το πρώτο στοιχείο που συστοιχίας.

133
00:06:19,990 --> 00:06:23,480
Έτσι, το γεγονός ότι είμαστε ένας δηλώνοντας
σειρά αρμάτων στη στοίβα εδώ

134
00:06:23,480 --> 00:06:24,810
είναι στην πραγματικότητα λίγο παραπλανητικό.

135
00:06:24,810 --> 00:06:27,600
Είμαστε πραγματικά στην
δεύτερη γραμμή του κώδικα εκεί

136
00:06:27,600 --> 00:06:32,360
δημιουργώντας επίσης ένα δείκτη σε ένα μεγάλο κομμάτι
μνήμης που τότε κάνουμε κάποια εργασία με.

137
00:06:32,360 --> 00:06:35,620
>> Εδώ είναι το μεγάλο πρόβλημα με το
κατανέμονται δυναμικά μνήμη όμως,

138
00:06:35,620 --> 00:06:38,360
και αυτός είναι ο λόγος για τον οποίο είναι πραγματικά
σημαντικό να αναπτυχθούν κάποιες καλές συνήθειες

139
00:06:38,360 --> 00:06:39,800
όταν εργάζεστε με αυτό.

140
00:06:39,800 --> 00:06:43,060
Σε αντίθεση με στατικά δηλωθεί
μνήμη, η μνήμη σας

141
00:06:43,060 --> 00:06:46,790
Δεν επιστρέφει αυτόματα στην
όταν η λειτουργία του συστήματος σας γίνεται.

142
00:06:46,790 --> 00:06:49,280
Έτσι, αν έχουμε κύρια, και
κύρια καλεί μια συνάρτηση

143
00:06:49,280 --> 00:06:53,860
f, όπου το f τελειώνει ό, τι κάνει
και επιστρέφει τον έλεγχο του προγράμματος

144
00:06:53,860 --> 00:06:58,810
πίσω στην κύρια, το σύνολο της μνήμης
ότι η f χρησιμοποιείται δίνεται πίσω.

145
00:06:58,810 --> 00:07:01,250
Μπορεί να χρησιμοποιηθεί ξανά
από κάποιο άλλο πρόγραμμα,

146
00:07:01,250 --> 00:07:04,250
ή κάποια άλλη λειτουργία που
φώναξαν αργότερα στην κύρια.

147
00:07:04,250 --> 00:07:06,970
Μπορεί να χρησιμοποιήσει την ίδια τη μνήμη ξανά.

148
00:07:06,970 --> 00:07:09,620
>> Αν δυναμικά
εκχώρηση μνήμης αν

149
00:07:09,620 --> 00:07:14,380
έχετε να πείτε ρητά η
σύστημα που θα τελειώσετε με αυτό.

150
00:07:14,380 --> 00:07:18,370
Θα κρατήσουν για σας, η οποία θα μπορούσε
να οδηγήσει σε ένα πρόβλημα που εξαντλείται

151
00:07:18,370 --> 00:07:19,290
της μνήμης.

152
00:07:19,290 --> 00:07:22,179
Και στην πραγματικότητα, μερικές φορές αναφερόμαστε
σε αυτό ως μια διαρροή μνήμης.

153
00:07:22,179 --> 00:07:24,970
Και ενίοτε αυτές οι διαρροές μνήμης
μπορεί πραγματικά να είναι πραγματικά καταστροφικό

154
00:07:24,970 --> 00:07:27,020
για την απόδοση του συστήματος.

155
00:07:27,020 --> 00:07:31,120
>> Αν είστε συχνός χρήστης του Διαδικτύου
μπορείτε να χρησιμοποιήσετε ορισμένα προγράμματα περιήγησης στο Web,

156
00:07:31,120 --> 00:07:35,630
και εγώ δεν θα αναφέρω ονόματα εδώ, αλλά
υπάρχουν μερικά web browser εκεί έξω

157
00:07:35,630 --> 00:07:39,150
που είναι διαβόητη για την πραγματικότητα που έχει
διαρροές μνήμης που δεν διορθώνονται.

158
00:07:39,150 --> 00:07:44,570
Και εάν αφήσετε το πρόγραμμα περιήγησης ανοικτό
για ένα πολύ μεγάλο χρονικό διάστημα, ημέρα

159
00:07:44,570 --> 00:07:48,060
και ημέρες, εβδομάδες ή, μερικές φορές
μπορεί να παρατηρήσετε ότι το σύστημά σας

160
00:07:48,060 --> 00:07:49,790
τρέχει πραγματικά, πραγματικά αργά.

161
00:07:49,790 --> 00:07:54,640
Και ο λόγος για αυτό είναι ότι
το πρόγραμμα περιήγησης έχει διαθέσει μνήμης,

162
00:07:54,640 --> 00:07:57,320
αλλά στη συνέχεια δεν είπε το σύστημα
ότι έχει κάνει με αυτό.

163
00:07:57,320 --> 00:08:01,000
Και έτσι ώστε να αφήνει λιγότερη μνήμη
διαθέσιμες για όλα τα άλλα προγράμματα σας

164
00:08:01,000 --> 00:08:04,480
να πρέπει να μοιραστεί, επειδή είστε
leaking-- που ο web browser

165
00:08:04,480 --> 00:08:06,755
το πρόγραμμα έχει διαρροή μνήμης.

166
00:08:06,755 --> 00:08:08,880
Πώς μπορούμε να δώσουμε πίσω τη μνήμη
όταν τελειώσουμε με αυτό;

167
00:08:08,880 --> 00:08:10,838
Καλά ευτυχώς είναι μια
πολύ εύκολος τρόπος για να το κάνουμε.

168
00:08:10,838 --> 00:08:11,710
Εμείς απλά το απελευθερώσει.

169
00:08:11,710 --> 00:08:15,020
Υπάρχει μια λειτουργία που ονομάζεται δωρεάν,
δέχεται ένα δείκτη στη μνήμη,

170
00:08:15,020 --> 00:08:16,010
και είμαστε καλοί να πάτε.

171
00:08:16,010 --> 00:08:18,310
>> Ας πούμε ότι είμαστε στη
μέση του προγράμματός μας,

172
00:08:18,310 --> 00:08:21,970
θέλουμε να malloc 50 χαρακτήρων.

173
00:08:21,970 --> 00:08:25,710
Θέλουμε να malloc έναν πίνακα που μπορεί να
μπορεί να χωρέσει 50 χαρακτήρων.

174
00:08:25,710 --> 00:08:29,109
Και όταν παίρνουμε ένα δείκτη πίσω στο
ότι, όνομα αυτού του δείκτη είναι η λέξη.

175
00:08:29,109 --> 00:08:30,900
Εμείς κάνουμε ό, τι είμαστε
πρόκειται να κάνει με το λόγο,

176
00:08:30,900 --> 00:08:33,440
και στη συνέχεια, όταν είμαστε
κάνει απλά το απελευθερώσει.

177
00:08:33,440 --> 00:08:37,460
Και τώρα έχουμε επιστρέψει τα εν λόγω 50
bytes της μνήμης πίσω στο σύστημα.

178
00:08:37,460 --> 00:08:40,147
Κάποια άλλη λειτουργία μπορούν να τα χρησιμοποιήσουν.

179
00:08:40,147 --> 00:08:43,480
Δεν χρειάζεται να ανησυχείτε για την ταλαιπωρία ένα
διαρροή μνήμης, επειδή έχουμε απελευθερωθεί λέξη.

180
00:08:43,480 --> 00:08:46,639
Έχουμε δεδομένη τη μνήμη πίσω,
έτσι ώστε να τελειώσετε την εργασία με αυτό.

181
00:08:46,639 --> 00:08:48,430
Έτσι, υπάρχουν τρεις
χρυσούς κανόνες που θα πρέπει

182
00:08:48,430 --> 00:08:51,700
να έχουμε κατά νου όταν είστε
δυναμική εκχώρηση μνήμης

183
00:08:51,700 --> 00:08:52,990
με malloc.

184
00:08:52,990 --> 00:08:56,480
Κάθε μπλοκ μνήμης που
Σας malloc πρέπει να απελευθερωθεί

185
00:08:56,480 --> 00:08:58,430
πριν από το πρόγραμμά σας ολοκληρωθεί η εκτέλεση.

186
00:08:58,430 --> 00:09:02,029
Τώρα πάλι, στη συσκευή ή στο
IDE αυτό το είδος της συμβαίνει για σας ούτως ή άλλως

187
00:09:02,029 --> 00:09:04,820
όταν you-- αυτό θα συμβεί ούτως ή άλλως
όταν το πρόγραμμα σας τερματίζεται,

188
00:09:04,820 --> 00:09:06,880
όλη η μνήμη θα κυκλοφορήσει.

189
00:09:06,880 --> 00:09:10,750
Αλλά είναι γενικά καλή κωδικοποίηση
πρακτικής για πάντα, όταν τελειώσετε,

190
00:09:10,750 --> 00:09:13,810
ελευθερώσει τι έχετε mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Τούτου λεχθέντος, μόνα πράγματα που
έχετε mallocd πρέπει να απελευθερωθούν.

192
00:09:16,690 --> 00:09:19,880
Αν στατικά δηλώνουν μια
ακέραιος, int x άνω τελεία,

193
00:09:19,880 --> 00:09:23,500
ότι ζει στη στοίβα, μπορείτε
τότε δεν θέλετε να ελευθερώσετε x.

194
00:09:23,500 --> 00:09:25,970
Έτσι, μόνο τα πράγματα που έχετε
mallocd θα πρέπει να απελευθερωθεί.

195
00:09:25,970 --> 00:09:28,960
>> Και τέλος, δεν κάνουμε κάτι δωρεάν δύο φορές.

196
00:09:28,960 --> 00:09:31,170
Αυτό μπορεί να οδηγήσει σε
ένα άλλο παράξενο κατάσταση.

197
00:09:31,170 --> 00:09:33,530
Έτσι, όλα αυτά που έχετε
mallocd πρέπει να ελευθερωθεί.

198
00:09:33,530 --> 00:09:36,000
Μόνο πράγματα που έχετε
malloc θα πρέπει να απελευθερωθεί.

199
00:09:36,000 --> 00:09:38,730
Και δεν κάνουμε κάτι δωρεάν δύο φορές.

200
00:09:38,730 --> 00:09:43,660
>> Ας πάμε μέσα από ένα παράδειγμα εδώ
από ό, τι ορισμένοι κατανέμονται δυναμικά

201
00:09:43,660 --> 00:09:46,122
μνήμης μπορεί να μοιάζει με μικτό
με κάποια στατική μνήμη.

202
00:09:46,122 --> 00:09:47,080
Τι θα μπορούσε να συμβεί εδώ;

203
00:09:47,080 --> 00:09:48,913
Δείτε αν μπορείτε να ακολουθήσετε
μήκος και μαντέψτε τι είναι

204
00:09:48,913 --> 00:09:51,720
πρόκειται να συμβεί καθώς προχωράμε
σε όλες αυτές τις γραμμές κώδικα.

205
00:09:51,720 --> 00:09:53,980
>> Έτσι λέμε int m.

206
00:09:53,980 --> 00:09:54,840
Τι συμβαίνει εδώ;

207
00:09:54,840 --> 00:09:56,339
Λοιπόν αυτό είναι αρκετά απλή.

208
00:09:56,339 --> 00:09:59,650
Έχω δημιουργήσει μια μεταβλητή που ονομάζεται ακέραιο m.

209
00:09:59,650 --> 00:10:01,400
Έχω χρώμα πράσινο,
γιατί αυτό είναι το χρώμα

210
00:10:01,400 --> 00:10:03,730
ότι χρησιμοποιώ όταν μιλώ
σχετικά με ακέραιες μεταβλητές.

211
00:10:03,730 --> 00:10:05,160
Είναι ένα κουτί.

212
00:10:05,160 --> 00:10:08,400
Αυτό λέγεται m, και μπορείτε να
κατάστημα ακέραιοι στο εσωτερικό του.

213
00:10:08,400 --> 00:10:12,400
>> Τι θα συμβεί εάν στη συνέχεια να πω ένα αστέρι int;

214
00:10:12,400 --> 00:10:13,530
Λοιπόν αυτό είναι αρκετά παρόμοια.

215
00:10:13,530 --> 00:10:15,780
Είμαι δημιουργώντας ένα κουτί που ονομάζεται.

216
00:10:15,780 --> 00:10:19,100
Είναι σε θέση να συγκρατήσει int
αστέρια, δείκτες σε ακέραιους αριθμούς.

217
00:10:19,100 --> 00:10:21,570
Έτσι είμαι χρωματισμό πράσινο-ish, όπως καλά.

218
00:10:21,570 --> 00:10:24,140
>> Ξέρω ότι έχει κάτι
να κάνει με ένα ακέραιο,

219
00:10:24,140 --> 00:10:25,852
αλλά η ίδια δεν είναι ένας ακέραιος αριθμός.

220
00:10:25,852 --> 00:10:27,310
Αλλά είναι λίγο πολύ η ίδια ιδέα.

221
00:10:27,310 --> 00:10:28,101
Έχω δημιουργήσει ένα κουτί.

222
00:10:28,101 --> 00:10:30,070
Και οι δύο αυτές δικαιώματος
τώρα ζουν στη στοίβα.

223
00:10:30,070 --> 00:10:32,520
Έχω δώσει και τα δύο ονόματα.

224
00:10:32,520 --> 00:10:36,750
>> int αστέρι β ισούται με malloc μέγεθος του int.

225
00:10:36,750 --> 00:10:38,560
Αυτό θα μπορούσε κανείς να είναι λίγο δύσκολο.

226
00:10:38,560 --> 00:10:44,110
Πάρτε μια δεύτερη και σκεφτείτε τι
θα περίμενε κανείς να συμβεί σε αυτό το διάγραμμα.

227
00:10:44,110 --> 00:10:50,210
int αστέρι β ισούται με malloc μέγεθος του int.

228
00:10:50,210 --> 00:10:51,940
>> Καλά αυτό δεν είναι μόνο να δημιουργήσει ένα πλαίσιο.

229
00:10:51,940 --> 00:10:53,800
Αυτή η πραγματικότητα δημιουργεί δύο κουτιά.

230
00:10:53,800 --> 00:10:58,670
Και δένει, θεσπίζει επίσης
ένα σημείο σε μια σχέση.

231
00:10:58,670 --> 00:11:02,240
Έχουμε διατεθεί ένα τετράγωνο
της μνήμης στο σωρό.

232
00:11:02,240 --> 00:11:05,940
Παρατηρήστε ότι το πάνω δεξιά παράθυρο
εκεί δεν έχει όνομα.

233
00:11:05,940 --> 00:11:06,760
>> Εμείς mallocd.

234
00:11:06,760 --> 00:11:08,050
Υπάρχει στο σωρό.

235
00:11:08,050 --> 00:11:10,090
Αλλά η Β έχει ένα όνομα.

236
00:11:10,090 --> 00:11:11,950
Είναι μια μεταβλητή δείκτη που ονομάζεται β.

237
00:11:11,950 --> 00:11:13,910
Που ζει στη στοίβα.

238
00:11:13,910 --> 00:11:18,250
>> Γι 'αυτό είναι ένα κομμάτι της μνήμης
επισημαίνει ότι σε μια άλλη.

239
00:11:18,250 --> 00:11:21,840
β περιέχει τη διεύθυνση
του εν λόγω μπλοκ της μνήμης.

240
00:11:21,840 --> 00:11:23,757
Δεν έχει άλλο ένα όνομα.

241
00:11:23,757 --> 00:11:24,590
Αλλά επισημαίνει σε αυτό.

242
00:11:24,590 --> 00:11:29,760
Έτσι, όταν λέμε int αστέρι β ισούται με
το μέγεθος της malloc int, ότι ακριβώς εκεί,

243
00:11:29,760 --> 00:11:33,490
ότι το βέλος που έσκασε επάνω του
δεξιά εκεί, όλο αυτό το πράγμα,

244
00:11:33,490 --> 00:11:36,740
Θα πρέπει να εμφανιστεί
και πάλι, είναι ό, τι συμβαίνει.

245
00:11:36,740 --> 00:11:39,341
Όλα αυτά συμβαίνουν σε
ότι ούτε μία γραμμή κώδικα.

246
00:11:39,341 --> 00:11:41,340
Τώρα θα πάρει λίγο περισσότερο
απλή και πάλι.

247
00:11:41,340 --> 00:11:43,330
ισούται με ένα ampersand m.

248
00:11:43,330 --> 00:11:46,280
Θυμάστε τι μια
ισούται με εμπορικό και το m είναι;

249
00:11:46,280 --> 00:11:48,920
Καλά αυτός είναι ένας παίρνει τη διεύθυνση του χρήστη m.

250
00:11:48,920 --> 00:11:54,150
Ή να τεθούν πιο διαγραμματικά,
ένα σημεία στο m.

251
00:11:54,150 --> 00:11:56,360
>> α ισούται με b.

252
00:11:56,360 --> 00:11:57,560
Εντάξει έτσι εδώ είναι ένα άλλο.

253
00:11:57,560 --> 00:11:59,230
Α ισούται με b.

254
00:11:59,230 --> 00:12:02,260
Τι πρόκειται να συμβεί
στο διάγραμμα αυτή τη φορά;

255
00:12:02,260 --> 00:12:04,330
>> Καλά υπενθυμίζουν ότι η
έργα τελεστή εκχώρησης

256
00:12:04,330 --> 00:12:08,960
αναθέτοντας την τιμή για το
δικαίωμα στην τιμή στα αριστερά.

257
00:12:08,960 --> 00:12:14,820
Έτσι, αντί ενός που δείχνουν στο m, ένα τώρα
επισημαίνει στην ίδια θέση που β πόντους.

258
00:12:14,820 --> 00:12:18,900
α δεν φαίνεται να υποδηλώνουν b, a
σημεία όπου β πόντους.

259
00:12:18,900 --> 00:12:25,280
>> Αν ένα μυτερό στο B, το οποίο θα
Έχουν μια ισούται εμπορικό και β.

260
00:12:25,280 --> 00:12:28,150
Αλλά αντ 'αυτού ένα ισούται με b μόνο
σημαίνει ότι και b είναι τώρα

261
00:12:28,150 --> 00:12:31,770
που δείχνουν προς την ίδια διεύθυνση, επειδή
στο εσωτερικό του b είναι απλώς μια διεύθυνση.

262
00:12:31,770 --> 00:12:35,004
Και τώρα στο εσωτερικό του ένα είναι η ίδια διεύθυνση.

263
00:12:35,004 --> 00:12:37,170
m ισούται με 10, πιθανώς το
πιο απλό πράγμα

264
00:12:37,170 --> 00:12:38,690
έχουμε κάνει σε λίγο.

265
00:12:38,690 --> 00:12:40,460
Βάλτε το 10 στο κουτί.

266
00:12:40,460 --> 00:12:45,640
Αστέρι β ισούται με m συν 2, ανάκληση από τους
μας δείκτες βίντεο τι σημαίνει β αστέρων.

267
00:12:45,640 --> 00:12:50,230
Εμείς πάμε για να dereference β και πώλησης
κάποια αξία σε αυτή τη θέση μνήμης.

268
00:12:50,230 --> 00:12:51,860
Σε αυτή την περίπτωση 12.

269
00:12:51,860 --> 00:12:55,300
>> Έτσι όταν dereference ένα σημείο
Υπενθυμίζουμε απλά ταξιδεύουν κάτω από το βέλος.

270
00:12:55,300 --> 00:12:58,205
Ή με άλλα λόγια, εμείς
μεταβεί στη συγκεκριμένη διεύθυνση μνήμης

271
00:12:58,205 --> 00:12:59,580
και θα το χειριστείτε με κάποιο τρόπο.

272
00:12:59,580 --> 00:13:00,830
Βάλαμε κάποια αξία εκεί.

273
00:13:00,830 --> 00:13:03,960
Σε αυτή την περίπτωση β αστέρων
ισούται με m συν 2 είναι ακριβώς

274
00:13:03,960 --> 00:13:08,230
πηγαίνετε στην μεταβλητή που υποδεικνύεται από β,
πηγαίνετε στη μνήμη που υποδεικνύεται από β,

275
00:13:08,230 --> 00:13:11,750
και να θέσει m συν 2 εκεί, 12.

276
00:13:11,750 --> 00:13:14,970
>> Τώρα μπορώ να ελευθερώσετε β.

277
00:13:14,970 --> 00:13:16,490
Τι συμβαίνει όταν η ελεύθερη β;

278
00:13:16,490 --> 00:13:18,800
Θυμηθείτε τι είπα δωρεάν μέσα.

279
00:13:18,800 --> 00:13:21,920
Τι λέω όταν θα απελευθερώσει β;

280
00:13:21,920 --> 00:13:23,410
>> Έχω ολοκληρώσει την εργασία με αυτό, έτσι δεν είναι;

281
00:13:23,410 --> 00:13:25,702
Έχω κατ 'ουσίαν, να εγκαταλείψει τη μνήμη.

282
00:13:25,702 --> 00:13:26,910
Δίνω πίσω στο σύστημα.

283
00:13:26,910 --> 00:13:33,010
Δεν χρειάζομαι αυτό πια είναι
αυτό που τους λέω, εντάξει;

284
00:13:33,010 --> 00:13:37,390
>> Τώρα, αν πω ένα αστέρι
ισούται με 11 μπορείτε πιθανώς

285
00:13:37,390 --> 00:13:40,460
ήδη πει ότι κάτι κακό
πρόκειται να συμβεί εδώ, σωστά;

286
00:13:40,460 --> 00:13:44,160
Και πράγματι, αν προσπάθησα ότι πιθανώς
θα υποστούν ένα σφάλμα κατάτμησης.

287
00:13:44,160 --> 00:13:47,140
Γιατί τώρα, αν και
προηγουμένως ότι κομμάτι της μνήμης

288
00:13:47,140 --> 00:13:50,220
ήταν κάτι που είχα
πρόσβαση σε, στο σημείο αυτό

289
00:13:50,220 --> 00:13:54,590
τώρα είμαι πρόσβαση μνήμης που
Δεν είναι νόμιμο για μένα να έχουν πρόσβαση.

290
00:13:54,590 --> 00:13:57,330
>> Και όπως πιθανότατα θα
Υπενθυμίζουμε, όταν έχουμε πρόσβαση στη μνήμη

291
00:13:57,330 --> 00:14:00,000
ότι δεν είμαστε υποτιθέμενοι για να αγγίξει,
αυτή είναι η πιο κοινή αιτία

292
00:14:00,000 --> 00:14:01,860
της τμηματοποίησης
κατηγορήσω. Και έτσι το πρόγραμμά μου

293
00:14:01,860 --> 00:14:05,170
θα συντριβή αν προσπάθησα να το κάνετε αυτό.

294
00:14:05,170 --> 00:14:09,910
Έτσι και πάλι είναι μια καλή ιδέα για να πάρει καλό
πρακτικές και συνήθειες βαθιά ριζωμένες καλό

295
00:14:09,910 --> 00:14:12,920
όταν εργάζεστε με malloc και δωρεάν,
έτσι ώστε να μην υποφέρουν τμηματοποίηση

296
00:14:12,920 --> 00:14:15,310
σφάλματα, και ότι μπορείτε να χρησιμοποιήσετε
σας δυναμικά διατίθενται

297
00:14:15,310 --> 00:14:17,370
μνήμη υπεύθυνα.

298
00:14:17,370 --> 00:14:20,300
>> Είμαι Doug Lloyd αυτό είναι CS50.

299
00:14:20,300 --> 00:14:21,947