1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID MALAN: Εντάξει, να καλωσορίσω πίσω.

3
00:00:12,580 --> 00:00:13,290
Αυτό είναι CS50.

4
00:00:13,290 --> 00:00:15,130
Αυτή είναι η αρχή της εβδομάδας επτά.

5
00:00:15,130 --> 00:00:18,890
Γι 'αυτό είναι μια στιγμή, έτσι σκέφτηκα ότι θα
λάβει μια ανεμοστρόβιλος περιοδεία του όπου

6
00:00:18,890 --> 00:00:20,760
σταμάτησε και πού είμαστε τώρα σε εξέλιξη.

7
00:00:20,760 --> 00:00:23,310
>> Έτσι, αυτό το πράγμα εδώ θα μπορούσε να έχει
προκάλεσε κάποια αγωνία την πρώτη.

8
00:00:23,310 --> 00:00:27,680
Αλλά ελπίζουμε, είστε αρχίζουν να
εγκλιματιστεί με ό, τι αυτό σημαίνει εδώ -

9
00:00:27,680 --> 00:00:32,670
αστέρι αντιπροσωπεύει ένα δείκτη, η οποία είναι
ακριβώς αυτό, όσον αφορά την πιο απλή γλώσσα;

10
00:00:32,670 --> 00:00:33,400
Έτσι είναι μια διεύθυνση.

11
00:00:33,400 --> 00:00:35,490
>> Έτσι είναι η διεύθυνση της
κάτι στη μνήμη.

12
00:00:35,490 --> 00:00:38,260
Και αρχίσαμε να φλούδα πίσω τα στρώματα
μια-δυο εβδομάδες πριν, τα πράγματα όπως

13
00:00:38,260 --> 00:00:41,800
GetString και άλλων τέτοιων λειτουργιών
όλο αυτό το διάστημα έχουν επιστρέψει

14
00:00:41,800 --> 00:00:46,010
διευθύνσεις των πραγμάτων στη μνήμη, όπως η
διεύθυνση του πρώτου χαρακτήρα

15
00:00:46,010 --> 00:00:46,990
κάποια αλληλουχία.

16
00:00:46,990 --> 00:00:50,360
>> Γι 'αυτό και εισήγαγε επίσης valgrind, η οποία
θα αρχίσετε να χρησιμοποιείτε για αυτό το πρόβλημα

17
00:00:50,360 --> 00:00:53,380
που, ιδίως για την επόμενη
πρόβλημα που, όπως καλά.

18
00:00:53,380 --> 00:00:54,980
Και valgrind κάνει ό, τι για μας;

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
Ελέγχει για διαρροές μνήμης, και
Επίσης, ελέγχει για κατάχρηση της μνήμης.

21
00:01:01,020 --> 00:01:05,890
>> Μπορεί, με κάποια πιθανότητα, ανιχνεύει αν
κωδικό σας πρόκειται να αγγίξει τη μνήμη

22
00:01:05,890 --> 00:01:07,100
ότι απλώς δεν θα έπρεπε.

23
00:01:07,100 --> 00:01:10,410
Έτσι, δεν είναι απαραίτητα μια διαρροή, αλλά αν
υπερβαίνουν τα όρια ορισμένων

24
00:01:10,410 --> 00:01:14,730
array, και μπορείτε πραγματικά να τρέξει Valgrind
και προκαλούν αυτή τη συμπεριφορά, ενώ

25
00:01:14,730 --> 00:01:17,870
valgrind τρέχει στο πρόγραμμά σας είναι
τρέχει μέσα από αυτό, θα πάρετε

26
00:01:17,870 --> 00:01:21,460
μηνύματα όπως αυτό - «άκυρο γράφουν
μέγεθος 4 ", το οποίο, υπενθυμίζουν ένα ζευγάρι των

27
00:01:21,460 --> 00:01:25,880
εβδομάδες πριν σήμαινε ότι είχα λάθος
όπως σε ένα int πολύ

28
00:01:25,880 --> 00:01:27,250
πέρα από τα όρια του πίνακα.

29
00:01:27,250 --> 00:01:30,790
Και έτσι το μέγεθος 4 σημαίνει εδώ το μέγεθος
του συγκεκριμένου Int.

30
00:01:30,790 --> 00:01:35,260
>> Πάρτε λοιπόν διαβεβαίωση για το γεγονός ότι
εξόδου valgrind, η μορφή του,

31
00:01:35,260 --> 00:01:36,170
είναι απλά άθλιες.

32
00:01:36,170 --> 00:01:40,180
Είναι πραγματικά δύσκολο να δει μέσα από το χάος
για τον ενδιαφέρουσες πληροφορίες.

33
00:01:40,180 --> 00:01:42,910
Έτσι, αυτό που έχουμε κάνει εδώ είναι μόνο απόσπασμα
μερικά από το ζευγάρι των περισσότερων

34
00:01:42,910 --> 00:01:43,850
ενδιαφέρουσες γραμμές.

35
00:01:43,850 --> 00:01:46,760
Αλλά συνειδητοποιούν ότι το 80% των εξαγωγών του valgrind
εξόδου πρόκειται να είναι ένα κομμάτι ενός

36
00:01:46,760 --> 00:01:47,650
απόσπαση της προσοχής.

37
00:01:47,650 --> 00:01:52,820
>> Απλά κοιτάξτε για τα πρότυπα, όπως αυτά -
άκυρο το δικαίωμα, άκυρο διαβάσετε, 40 bytes

38
00:01:52,820 --> 00:01:56,690
και κάποια αριθμός των μπλοκ είναι σίγουρα
χαθεί, λέξεις-κλειδιά όπως αυτό.

39
00:01:56,690 --> 00:02:01,920
Και τι θα ελπίζουμε δείτε είναι μερικά
είδος ίχνος ποια λειτουργία το

40
00:02:01,920 --> 00:02:03,340
λάθος είναι στην πραγματικότητα μέσα

41
00:02:03,340 --> 00:02:07,195
Στην περίπτωση αυτή, εδώ, σε ποια γραμμή
κωδικό μου ήταν το λάθος προφανώς;

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 26 σε ένα αρχείο που ονομάζεται memory.c, η οποία ήταν
το παράδειγμα παίζαμε με

44
00:02:14,130 --> 00:02:14,890
κατά τη χρονική στιγμή.

45
00:02:14,890 --> 00:02:16,460
Έτσι, είναι πιθανόν να μην το malloc.

46
00:02:16,460 --> 00:02:18,630
Ήταν ίσως το κωδικό μου αντ 'αυτού.

47
00:02:18,630 --> 00:02:20,910
Έτσι, θα δούμε πάλι αυτό
και πάλι πριν από καιρό.

48
00:02:20,910 --> 00:02:24,080
>> Έτσι, scanf, αυτό ήρθε σε ένα
ζευγάρι των εντύπων μέχρι στιγμής.

49
00:02:24,080 --> 00:02:26,410
Είδαμε sscanf σύντομα.

50
00:02:26,410 --> 00:02:28,330
Ήταν κάτι ένας αριθμός
που βουτούσαν σε σας

51
00:02:28,330 --> 00:02:29,535
προετοιμασίες για το κουίζ.

52
00:02:29,535 --> 00:02:33,130
Και scanf είναι στην πραγματικότητα αυτό το CS50
βιβλιοθήκης χρησιμοποιεί κάτω από την

53
00:02:33,130 --> 00:02:36,560
κουκούλα για αρκετό καιρό, ώστε
για να πάρετε είσοδο από το χρήστη.

54
00:02:36,560 --> 00:02:40,420
>> Για παράδειγμα, αν μπορώ να μεταπηδήσουν στην CS50
συσκευή εδώ, επιτρέψτε μου να ανοίξει ένα

55
00:02:40,420 --> 00:02:45,315
παράδειγμα που σήμερα λέγεται scanf-0.c
Και είναι εξαιρετικά απλό.

56
00:02:45,315 --> 00:02:46,590
Είναι μόνο λίγες γραμμές κώδικα.

57
00:02:46,590 --> 00:02:50,880
Αλλά αυτό δείχνει πραγματικά πόσο getInt
έχει εργαστεί όλη αυτήν την περίοδο.

58
00:02:50,880 --> 00:02:54,710
>> Σε αυτό το πρόγραμμα εδώ, στη γραμμή 16
, Ανακοινώνει ότι δηλώνω ένα int.

59
00:02:54,710 --> 00:02:57,270
Έτσι, δεν υπάρχουν δείκτες, κάτι μαγικό
, υπάρχει μόνο ένας int.

60
00:02:57,270 --> 00:03:00,330
Στη συνέχεια, γραμμή 17, θα ζητήσει η
χρήστη για έναν αριθμό, παρακαλώ.

61
00:03:00,330 --> 00:03:02,930
Στη συνέχεια, στα τέλη του 18, μπορώ να χρησιμοποιήσω scanf εδώ.

62
00:03:02,930 --> 00:03:06,910
Και έχω καθορίσει, κάτι σαν printf,
ότι Περιμένω παράθεση

63
00:03:06,910 --> 00:03:08,110
unquote i τοις εκατό.

64
00:03:08,110 --> 00:03:10,920
>> Έτσι τοις εκατό Ι, φυσικά,
υποδηλώνει μια int.

65
00:03:10,920 --> 00:03:14,580
Αλλά παρατηρήστε τι το δεύτερο
επιχείρημα για να scanf είναι.

66
00:03:14,580 --> 00:03:17,350
Πώς θα περιγράφατε τη δεύτερη
επιχείρημα μετά το κόμμα;

67
00:03:17,350 --> 00:03:19,450
Τι είναι αυτό;

68
00:03:19,450 --> 00:03:20,670
>> Είναι η διεύθυνση του x.

69
00:03:20,670 --> 00:03:25,490
Έτσι, αυτό είναι χρήσιμο, επειδή με την παροχή
scanf με τη διεύθυνση του x, τι κάνει

70
00:03:25,490 --> 00:03:29,560
που ενισχύουν τη λειτουργία αυτή για να κάνει;

71
00:03:29,560 --> 00:03:33,010
Όχι μόνο εκεί, αλλά και να κάνει τι;

72
00:03:33,010 --> 00:03:34,060
>> Κάντε μια αλλαγή σε αυτό.

73
00:03:34,060 --> 00:03:38,080
Επειδή μπορείτε να πάτε εκεί, αυτό είναι το είδος της
σαν ένα χάρτη σε μια θέση στη μνήμη.

74
00:03:38,080 --> 00:03:41,900
Και εφ 'όσον παρέχουν scanf, ή
οποιαδήποτε λειτουργία με ένα τέτοιο χάρτη, αυτό

75
00:03:41,900 --> 00:03:45,840
λειτουργία μπορεί να πάει εκεί, και όχι μόνο
δούμε την αξία, αλλά μπορεί επίσης να

76
00:03:45,840 --> 00:03:49,670
αλλάξετε αυτή την τιμή, η οποία είναι χρήσιμη αν
ο σκοπός της ζωής του είναι να scanf

77
00:03:49,670 --> 00:03:53,060
ανιχνεύσει είσοδο από το χρήστη, ειδικά
από το πληκτρολόγιο.

78
00:03:53,060 --> 00:03:57,830
Και το f υποδηλώνει σχηματοποιημένη, όπως ακριβώς
printf, το f υποδηλώνει ένα μορφοποιημένο

79
00:03:57,830 --> 00:03:58,930
κορδόνι που θέλετε να εκτυπώσετε.

80
00:03:58,930 --> 00:04:04,430
>> Έτσι, με λίγα λόγια, αυτή η γραμμή 18 λέει απλά,
προσπαθώ να διαβάσω έναν int από το χρήστη

81
00:04:04,430 --> 00:04:10,420
πληκτρολόγιο και να το αποθηκεύσετε στο εσωτερικό του x, σε
ανεξάρτητα από τη διεύθυνση x τυχαίνει να ζουν στο.

82
00:04:10,420 --> 00:04:14,860
Και στη συνέχεια, τέλος, γραμμή 19 λέει ακριβώς,
ευχαριστίες για το int, σε αυτή την περίπτωση.

83
00:04:14,860 --> 00:04:15,940
>> Έτσι, επιτρέψτε μου να πάει μπροστά και να κάνουν αυτό.

84
00:04:15,940 --> 00:04:18,570
Έτσι κάνουν scanf 0.

85
00:04:18,570 --> 00:04:20,130
Επιτρέψτε μου να πάω μπροστά και να μεγεθύνετε

86
00:04:20,130 --> 00:04:22,960
Θα πάω και να τρέξει αυτό με
τελείες κάθετο scanf 0.

87
00:04:22,960 --> 00:04:24,020
Αριθμός, παρακαλώ;

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
Ευχαριστώ για την 50.

90
00:04:25,730 --> 00:04:27,270
Έτσι, είναι πολύ απλό.

91
00:04:27,270 --> 00:04:28,160
>> Τώρα τι είναι αυτό που δεν κάνει;

92
00:04:28,160 --> 00:04:29,940
Δεν κάνει ένα σωρό
τον έλεγχο σφαλμάτων.

93
00:04:29,940 --> 00:04:33,000
Για παράδειγμα, αν δεν συνεργαστούν,
και δεν πληκτρολογήσετε έναν αριθμό, αλλά

94
00:04:33,000 --> 00:04:37,860
αντί να γράφω κάτι σαν "γεια"
Αυτό είναι ακριβώς το είδος της παράξενο.

95
00:04:37,860 --> 00:04:41,130
Και έτσι ένα από τα πράγματα που το CS50
βιβλιοθήκη έχει κάνει για εμάς για κάποιους

96
00:04:41,130 --> 00:04:43,440
τη στιγμή είναι ότι reprompting
και reprompting.

97
00:04:43,440 --> 00:04:49,320
>> Η ξαναδοκιμάσετε ανάκληση φράση ήταν σε cs50.c,
και αυτός είναι ο λόγος που getInt σε

98
00:04:49,320 --> 00:04:51,670
η βιβλιοθήκη CS50 είναι στην πραγματικότητα ένα σύνολο
μάτσο γραμμές καιρό, γιατί είμαστε

99
00:04:51,670 --> 00:04:53,190
έλεγχο για ηλίθια πράγματα όπως αυτό.

100
00:04:53,190 --> 00:04:55,730
Μήπως δεν είναι ο χρήστης να
μας, στην πραγματικότητα, ένας int;

101
00:04:55,730 --> 00:04:57,910
Μήπως αυτός ή αυτή να μας δώσει κάτι
σαν ένα αλφαβητικό γράμμα;

102
00:04:57,910 --> 00:05:01,410
Αν ναι, θέλουμε να ανιχνεύσει
ότι και να φωνάζουν σε αυτούς.

103
00:05:01,410 --> 00:05:03,915
>> Όμως, τα πράγματα γίνονται πιο ενδιαφέροντα
σε αυτό το επόμενο παράδειγμα.

104
00:05:03,915 --> 00:05:09,840
Αν πάω στην scanf-1.γ, τι είναι το ένα
πράγμα που έχει αλλάξει ριζικά σε

105
00:05:09,840 --> 00:05:11,135
αυτό το επόμενο παράδειγμα;

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
Είμαι χρησιμοποιώντας char *, φυσικά,
αντί για int.

108
00:05:16,010 --> 00:05:19,210
>> Έτσι, αυτό είναι ενδιαφέρον, γιατί char *,
θυμάστε, είναι πραγματικά μόνο η

109
00:05:19,210 --> 00:05:20,190
ίδιο πράγμα όπως string.

110
00:05:20,190 --> 00:05:23,840
Γι 'αυτό αισθάνεται όπως ίσως αυτό είναι ένα σούπερ
απλή εφαρμογή των GetString.

111
00:05:23,840 --> 00:05:26,010
Αλλά έχω τραβηχτεί προς τα πίσω το στρώμα
της βιβλιοθήκης CS50, έτσι είμαι

112
00:05:26,010 --> 00:05:27,550
καλώντας αυτό το char * τώρα.

113
00:05:27,550 --> 00:05:30,070
Έτσι, ας δούμε πού, εάν οπουδήποτε,
θα πάει στραβά.

114
00:05:30,070 --> 00:05:30,840
>> Γραμμή 17 -

115
00:05:30,840 --> 00:05:33,950
Θα ήθελα και πάλι να πω, παρακαλώ να μου δώσει κάτι,
σε αυτή την περίπτωση, ένα string.

116
00:05:33,950 --> 00:05:37,940
Και στη συνέχεια, στην επόμενη γραμμή, καλώ scanf,
και πάλι, δίνοντας έναν κωδικό μορφή,

117
00:05:37,940 --> 00:05:39,310
αλλά αυτή τη φορά s τοις εκατό.

118
00:05:39,310 --> 00:05:41,900
Και τότε αυτή τη φορά, είμαι
δίνοντας buffer.

119
00:05:41,900 --> 00:05:43,550
>> Τώρα, προσέξτε, δεν είμαι χρησιμοποιώντας
Το εμπορικό.

120
00:05:43,550 --> 00:05:47,120
Αλλά γιατί είναι ότι μάλλον ΟΚ εδώ;

121
00:05:47,120 --> 00:05:49,760
Γιατί ό, τι είναι ήδη buffer;

122
00:05:49,760 --> 00:05:50,770
Είναι ήδη ένας δείκτης.

123
00:05:50,770 --> 00:05:51,650
Είναι ήδη μια διεύθυνση.

124
00:05:51,650 --> 00:05:54,510
>> Και ας είναι αυτή η λέξη "σύγχυση", επιτρέψτε μου να
αποκαλούν απλώς s, για παράδειγμα, για

125
00:05:54,510 --> 00:05:55,050
απλότητα.

126
00:05:55,050 --> 00:05:58,250
Αλλά έχω την αποκάλεσε buffer διότι σε
Γενικά, στον προγραμματισμό, αν έχετε ένα

127
00:05:58,250 --> 00:06:02,130
κομμάτι της μνήμης, η οποία είναι πραγματικά μια σειρά
ακριβώς είναι, θα μπορούσαμε να πούμε ότι ένα ρυθμιστικό.

128
00:06:02,130 --> 00:06:04,460
Είναι ένα μέρος για να αποθηκεύουν πληροφορίες.

129
00:06:04,460 --> 00:06:07,400
>> Παρόμοια με τα πράγματα όπως το YouTube, όταν
από όπου και αν buffering, να το πω έτσι, ότι

130
00:06:07,400 --> 00:06:10,270
απλά σημαίνει ότι είναι το κατέβασμα κομμάτια από
το διαδίκτυο και την αποθήκευση τους σε ένα

131
00:06:10,270 --> 00:06:14,160
τοπική ποικιλία, ένα τοπικό κομμάτι της μνήμης, ώστε
ότι μπορείτε να το παρακολουθήσετε αργότερα χωρίς

132
00:06:14,160 --> 00:06:16,830
να παρακάμπτοντας ή να κρέμεται
σας κατά την αναπαραγωγή.

133
00:06:16,830 --> 00:06:20,930
>> Έτσι, υπάρχει ένα πρόβλημα εδώ όμως,
γιατί λέω scanf, αναμένουμε μια

134
00:06:20,930 --> 00:06:22,320
συμβολοσειρά από το χρήστη.

135
00:06:22,320 --> 00:06:24,410
Εδώ είναι η διεύθυνση του
ένα μεγάλο κομμάτι της μνήμης.

136
00:06:24,410 --> 00:06:26,180
Βάλτε αυτό το αλφαριθμητικό εκεί.

137
00:06:26,180 --> 00:06:31,230
Γιατί είναι ότι δεσμεύεται να
μας πρόβλημα, όμως;

138
00:06:31,230 --> 00:06:33,490
>> Τι είναι αυτό;

139
00:06:33,490 --> 00:06:35,510
Μου επιτρέπεται να έχουν πρόσβαση
ότι ένα μέρος της μνήμης;

140
00:06:35,510 --> 00:06:36,250
Ξέρεις, δεν ξέρω.

141
00:06:36,250 --> 00:06:39,210
Επειδή έχει ρυθμιστικό γίνει προετοιμασία
σε τίποτα;

142
00:06:39,210 --> 00:06:39,820
Όχι πραγματικά.

143
00:06:39,820 --> 00:06:43,090
Και γι 'αυτό είναι ό, τι έχουμε καλώντας
μια τιμή σκουπίδια, ο οποίος

144
00:06:43,090 --> 00:06:44,040
δεν είναι μια τυπική λέξη.

145
00:06:44,040 --> 00:06:49,200
Σημαίνει απλώς δεν έχουμε ιδέα ποια κομμάτια
είναι μέσα από τα τέσσερα bytes που

146
00:06:49,200 --> 00:06:51,240
Έχω κατανέμονται ως buffer.

147
00:06:51,240 --> 00:06:52,450
>> Δεν έχω ονομάζεται malloc.

148
00:06:52,450 --> 00:06:53,940
Έχω σίγουρα δεν λέγεται GetString.

149
00:06:53,940 --> 00:06:56,380
Έτσι, ποιος ξέρει τι είναι πραγματικότητα
εσωτερικό του buffer;

150
00:06:56,380 --> 00:07:00,550
Και όμως λέει scanf τυφλά, εκεί
και να θέσει ό, τι ο χρήστης πληκτρολογήσει.

151
00:07:00,550 --> 00:07:04,460
>> Έτσι, αυτό που είναι πιθανό να προκαλέσει
στον κώδικά μας, αν θα το τρέξει;

152
00:07:04,460 --> 00:07:05,700
Πιθανώς segfault.

153
00:07:05,700 --> 00:07:07,970
Ίσως όχι, αλλά μάλλον segfault.

154
00:07:07,970 --> 00:07:10,620
Και λέω ίσως όχι επειδή μερικές φορές
κάνετε, μερικές φορές

155
00:07:10,620 --> 00:07:11,380
δεν έχετε μια segfault.

156
00:07:11,380 --> 00:07:14,280
Μερικές φορές, μπορείτε απλά να πάρετε τυχεροί, αλλά
είναι, ωστόσο, πρόκειται να είναι

157
00:07:14,280 --> 00:07:15,340
ένα bug στο πρόγραμμά μας.

158
00:07:15,340 --> 00:07:17,060
>> Επιτρέψτε μου λοιπόν να προχωρήσει και η συγκέντρωση αυτών.

159
00:07:17,060 --> 00:07:18,280
Πάω να κάνω τον παλιό τρόπο σχολείο.

160
00:07:18,280 --> 00:07:23,825
Έτσι παύλα κλαγγή 0, scanf-1,
scanf-1.γ, Enter.

161
00:07:23,825 --> 00:07:24,720
Ωχ, πολύ παλιό σχολείο.

162
00:07:24,720 --> 00:07:26,550
Ας δούμε.

163
00:07:26,550 --> 00:07:28,440
Πού να πάω;

164
00:07:28,440 --> 00:07:29,700
Ω, char buffer *.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
Αχ, σας ευχαριστώ -

167
00:07:35,130 --> 00:07:36,930
Αποθήκευση, OK -

168
00:07:36,930 --> 00:07:37,690
πολύ παλιό σχολείο.

169
00:07:37,690 --> 00:07:38,900
Εντάξει, αυτό είναι λίγο.

170
00:07:38,900 --> 00:07:41,720
>> Έτσι έχω σωθεί μόνο το αρχείο μετά
για την εν λόγω προσωρινή

171
00:07:41,720 --> 00:07:42,700
αλλάξει πριν από λίγο.

172
00:07:42,700 --> 00:07:46,090
Και τώρα έχω καταρτίζονται
με το χέρι με Clang.

173
00:07:46,090 --> 00:07:49,500
Και τώρα είμαι πρόκειται να πάει μπροστά
και να τρέξει scanf-1, Enter.

174
00:07:49,500 --> 00:07:50,290
String παρακαλώ.

175
00:07:50,290 --> 00:07:51,600
Θα πληκτρολογήσετε "γεια".

176
00:07:51,600 --> 00:07:54,070
>> Και τώρα, εδώ είναι όπου, ειλικρινά, printf
μπορεί να είναι λίγο ενοχλητικό.

177
00:07:54,070 --> 00:07:56,020
Δεν είναι πραγματικά πρόκειται να
segfault σε αυτή την περίπτωση.

178
00:07:56,020 --> 00:07:59,860
Printf είναι λίγο ιδιαίτερη, διότι
είναι τόσο σούπερ που χρησιμοποιούνται συνήθως ότι

179
00:07:59,860 --> 00:08:03,570
ουσιαστικά printf κάνει
μας κάνει τη χάρη και την υλοποίηση,

180
00:08:03,570 --> 00:08:04,830
αυτό δεν είναι ένα έγκυρο δείκτη.

181
00:08:04,830 --> 00:08:09,080
Επιτρέψτε μου να το πάρετε επάνω στον εαυτό μου να εκτυπώσετε μόνο
έξω σε παρένθεση null, ακόμη

182
00:08:09,080 --> 00:08:13,340
αν και δεν είναι απαραίτητα αυτό που
εμείς οι ίδιοι περιμέναμε.

183
00:08:13,340 --> 00:08:16,940
>> Έτσι, δεν μπορούμε πολύ εύκολα να προκαλέσει μια
segfault με αυτό, αλλά προφανώς αυτό

184
00:08:16,940 --> 00:08:18,600
δεν είναι η συμπεριφορά που ήθελα.

185
00:08:18,600 --> 00:08:19,800
Έτσι, ποια είναι η απλή λύση;

186
00:08:19,800 --> 00:08:25,650
Λοιπόν, στην scanf-2, επιτρέψτε μου να προτείνω
αντί πραγματικά κατανομής μόνο ένα

187
00:08:25,650 --> 00:08:30,100
char *, επιτρέψτε μου να είμαι λίγο πιο έξυπνοι σχετικά με
αυτό, και επιτρέψτε μου να διαθέσει buffer

188
00:08:30,100 --> 00:08:32,940
ως μια ακολουθία από 16 χαρακτήρες.

189
00:08:32,940 --> 00:08:34,200
>> Έτσι μπορώ να το κάνετε αυτό σε μια-δυο τρόπους.

190
00:08:34,200 --> 00:08:35,610
Θα μπορούσα να χρησιμοποιήσω απολύτως malloc.

191
00:08:35,610 --> 00:08:38,980
Αλλά μπορώ να πάω πίσω στην εβδομάδα, όταν δύο
Χρειαζόμουν ένα σωρό

192
00:08:38,980 --> 00:08:39,620
χαρακτήρων.

193
00:08:39,620 --> 00:08:40,860
Αυτό είναι απλά μια σειρά.

194
00:08:40,860 --> 00:08:44,870
Επιτρέψτε μου λοιπόν να επαναπροσδιορίσουμε αντί ρυθμιστικού
να είναι μια συστοιχία 16 χαρακτήρων.

195
00:08:44,870 --> 00:08:47,340
>> Και τώρα, όταν περάσει ρυθμιστικού -

196
00:08:47,340 --> 00:08:49,940
και αυτό είναι κάτι που δεν
μιλάμε για την εβδομάδα δύο -

197
00:08:49,940 --> 00:08:53,730
αλλά μπορείτε να τη θεραπεία μιας σειράς, όπως
αν και είναι μια διεύθυνση.

198
00:08:53,730 --> 00:08:56,390
Τεχνικά, όπως έχουμε δει, είναι
λίγο διαφορετικό.

199
00:08:56,390 --> 00:09:01,290
Αλλά scanf δεν θα πείραζε αν το περάσετε
το όνομα ενός πίνακα, γιατί αυτό

200
00:09:01,290 --> 00:09:05,030
Clang θα κάνει για μας είναι κατ 'ουσίαν
αντιμετωπίζουν το όνομα του εν λόγω πίνακα, όπως η

201
00:09:05,030 --> 00:09:08,280
διεύθυνση του κομμάτι των 16 bytes.

202
00:09:08,280 --> 00:09:09,550
>> Έτσι, αυτό είναι η καλύτερη.

203
00:09:09,550 --> 00:09:12,110
Αυτό σημαίνει ότι τώρα μπορώ να ελπίζουμε
κάντε τα εξής.

204
00:09:12,110 --> 00:09:16,800
Επιτρέψτε μου σμίκρυνση για μια στιγμή και
κάνουν scanf-2, καταρτίζονται OK.

205
00:09:16,800 --> 00:09:19,390
Τώρα, επιτρέψτε μου να κάνω πήρε slash scanf-2.

206
00:09:19,390 --> 00:09:22,430
String παρακαλώ. "Hello". Και
φάνηκε να λειτουργεί αυτή τη φορά.

207
00:09:22,430 --> 00:09:26,020
>> Αλλά μπορεί κάποιος να προτείνει ένα σενάριο
στην οποία μπορεί να μην εξακολουθούν να εργάζονται;

208
00:09:26,020 --> 00:09:28,550
Ναι;

209
00:09:28,550 --> 00:09:30,640
Κάτι περισσότερο από 16 χαρακτήρες.

210
00:09:30,640 --> 00:09:32,020
Και στην πραγματικότητα, μπορούμε να
λίγο πιο ακριβή.

211
00:09:32,020 --> 00:09:36,540
Κάτι περισσότερο από τους 15 χαρακτήρες,
γιατί πραγματικά πρέπει να έχουμε κατά νου

212
00:09:36,540 --> 00:09:39,920
ότι χρειαζόμαστε αυτό το backslash μηδέν
σιωπηρά στο τέλος του string,

213
00:09:39,920 --> 00:09:42,950
η οποία αποτελεί μέρος scanf θα είναι τυπικά
να φροντίσει για μας.

214
00:09:42,950 --> 00:09:46,210
>> Έτσι, επιτρέψτε μου να κάνω κάτι σαν -

215
00:09:46,210 --> 00:09:48,040
Μερικές φορές μπορούμε απλά
αφήσουμε έτσι.

216
00:09:48,040 --> 00:09:50,630
Εντάξει, έτσι έχουμε τώρα προκαλείται
σφάλμα κατάτμησης μας.

217
00:09:50,630 --> 00:09:51,000
Γιατί;

218
00:09:51,000 --> 00:09:54,940
Επειδή έχω πληκτρολογήσει σε περισσότερες από 15
χαρακτήρες, και έτσι έχουμε στην πραγματικότητα

219
00:09:54,940 --> 00:09:58,280
άγγιξε μνήμη που έχω πραγματικά
Δεν θα πρέπει να έχουν.

220
00:09:58,280 --> 00:10:00,180
>> Έτσι, αυτό που είναι πραγματικά η λύση εδώ;

221
00:10:00,180 --> 00:10:02,210
Λοιπόν, τι θα γίνει αν χρειαζόμαστε μια μεγαλύτερη σειρά;

222
00:10:02,210 --> 00:10:03,960
Λοιπόν, ίσως να είναι 32 bytes.

223
00:10:03,960 --> 00:10:05,160
Λοιπόν, τι θα γίνει αν αυτό δεν είναι αρκετό;

224
00:10:05,160 --> 00:10:06,040
Πόσο περίπου 64 bytes;

225
00:10:06,040 --> 00:10:07,080
Τι θα συμβεί αν αυτό δεν είναι αρκετό;

226
00:10:07,080 --> 00:10:09,640
Τι θα λέγατε για 128 ή 200 bytes;

227
00:10:09,640 --> 00:10:12,660
Ποια είναι πραγματικά η λύση εδώ στο
γενική περίπτωση, αν δεν γνωρίζουμε σε

228
00:10:12,660 --> 00:10:14,460
εκ των προτέρων αυτό που ο χρήστης πρόκειται να πληκτρολογήσετε;

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> Είναι ακριβώς το είδος της μια μεγάλη πόνος στο γάιδαρο,
για να είμαι ειλικρινής, η οποία είναι ο λόγος για τον

231
00:10:23,050 --> 00:10:29,050
CS50 βιβλιοθήκη έχει μερικές ντουζίνες γραμμές
κώδικα που συλλογικά την εφαρμογή

232
00:10:29,050 --> 00:10:32,390
GetString σειρά με έναν τρόπο που δεν το κάνουμε
πρέπει να γνωρίζουμε εκ των προτέρων ποια είναι η

233
00:10:32,390 --> 00:10:33,430
χρήστης πρόκειται να πληκτρολογήσετε.

234
00:10:33,430 --> 00:10:37,370
Ειδικότερα, αν κοιτάξουμε πίσω στο
cs50.c από πριν από δύο εβδομάδες, θα δείτε

235
00:10:37,370 --> 00:10:40,480
ότι GetString κάνει στην πραγματικότητα
δεν χρησιμοποιεί scanf με αυτόν τον τρόπο.

236
00:10:40,480 --> 00:10:43,720
Αντίθετα, διαβάζει ένα χαρακτήρα
σε μια στιγμή.

237
00:10:43,720 --> 00:10:46,010
>> Επειδή το ένα ωραίο πράγμα για
Διάβαζα ένα χαρακτήρα είναι ότι μπορούμε να

238
00:10:46,010 --> 00:10:48,490
εγγυώνται τον εαυτό μας να είναι πάντα
έχουν τουλάχιστον ένα char.

239
00:10:48,490 --> 00:10:51,740
Μπορώ να δηλώσω μόνο μια χαρα, και στη συνέχεια να λάβει
αυτές οι πραγματικά το μωρό βήματα σε μόλις

240
00:10:51,740 --> 00:10:54,380
διαβάστε ένα χαρακτήρα μέσα σε ένα
φορά από το πληκτρολόγιο.

241
00:10:54,380 --> 00:10:58,240
Και τότε, τι θα δείτε GetString
δεν είναι κάθε φορά που τρέχει από,

242
00:10:58,240 --> 00:11:02,280
ας πούμε, 16 bytes της μνήμης, χρησιμοποιεί
malloc, ή μια ξαδέλφη τους, για να

243
00:11:02,280 --> 00:11:06,810
διαθέσει περισσότερη μνήμη, αντιγράφοντας το παλιό
μνήμης στο νέο, και στη συνέχεια να σέρνεται

244
00:11:06,810 --> 00:11:09,900
μαζί, να πάρει ένα χαρακτήρα κάθε φορά,
και όταν τρέχει έξω από αυτό

245
00:11:09,900 --> 00:11:13,370
κομμάτι της μνήμης, πετάει μακριά, αρπαγές
ένα μεγαλύτερο κομμάτι της μνήμης, αντιγράφει παλιά

246
00:11:13,370 --> 00:11:14,750
σε νέες και επαναλήψεις.

247
00:11:14,750 --> 00:11:18,480
Και είναι πραγματικά ένας πόνος πραγματικά
εφαρμόσουν κάτι τόσο απλό όσο

248
00:11:18,480 --> 00:11:19,710
να πάρει είσοδο από το χρήστη.

249
00:11:19,710 --> 00:11:21,090
>> Έτσι, μπορείτε να χρησιμοποιήσετε το scanf.

250
00:11:21,090 --> 00:11:22,430
Μπορείτε να χρησιμοποιήσετε και άλλες παρόμοιες λειτουργίες.

251
00:11:22,430 --> 00:11:25,420
Και πολλά βιβλία και σε απευθείας σύνδεση
παραδείγματα αυτά, αλλά είναι όλα

252
00:11:25,420 --> 00:11:27,210
ευάλωτο σε προβλήματα όπως αυτό.

253
00:11:27,210 --> 00:11:29,550
Και, τελικά, να πάρει ένα segfault
είναι ενοχλητικό είδος της.

254
00:11:29,550 --> 00:11:30,680
Δεν είναι καλό για τον χρήστη.

255
00:11:30,680 --> 00:11:33,560
>> Όμως, στη χειρότερη περίπτωση, αυτό που κάνει
να θέσει ουσιαστικά σας

256
00:11:33,560 --> 00:11:37,160
κώδικα σε κίνδυνο;

257
00:11:37,160 --> 00:11:39,250
Κάποιο είδος της επίθεσης, ενδεχομένως.

258
00:11:39,250 --> 00:11:41,680
Μιλήσαμε για μια τέτοια επίθεση -
υπερχείλιση της στοίβας.

259
00:11:41,680 --> 00:11:44,660
Αλλά σε γενικές γραμμές, αν σας επιτρέπεται να
υπερχείλιση ένα ρυθμιστικό, όπως κάναμε

260
00:11:44,660 --> 00:11:48,070
πριν από μερικές εβδομάδες, με μόνο γραπτώς
περισσότερο από το "γεια" στη στοίβα, θα

261
00:11:48,070 --> 00:11:52,330
μπορεί πράγματι να αναλάβει, ενδεχομένως, ένα
υπολογιστή, ή τουλάχιστον να πάρει στα δεδομένα που

262
00:11:52,330 --> 00:11:53,510
δεν ανήκουν σε σας.

263
00:11:53,510 --> 00:11:55,970
>> Έτσι, με λίγα λόγια, αυτός είναι ο λόγος που έχουμε
οι βοηθητικές ρόδες.

264
00:11:55,970 --> 00:11:59,090
Αλλά τώρα, αρχίζουμε να τα πάρει μακριά,
τα προγράμματα μας, δεν χρειάζεται πλέον,

265
00:11:59,090 --> 00:12:00,610
κατ 'ανάγκην, είσοδο από το χρήστη.

266
00:12:00,610 --> 00:12:03,960
Αλλά στην περίπτωση του προβλήματος που έχει έξι,
συμβολή σας θα προέλθει από μια τεράστια

267
00:12:03,960 --> 00:12:07,520
αρχείο λεξικού με 150 μερικές
περίεργο χίλιες λέξεις.

268
00:12:07,520 --> 00:12:10,330
>> Έτσι δεν θα έχετε να ανησυχείτε για
αυθαίρετη είσοδο του χρήστη.

269
00:12:10,330 --> 00:12:13,720
Εμείς θα σας δώσει κάποιες παραδοχές
σχετικά με αυτό το αρχείο.

270
00:12:13,720 --> 00:12:20,340
Οποιεσδήποτε ερωτήσεις σχετικά με δείκτες ή scanf
ή την είσοδο του χρήστη σε γενικές γραμμές;

271
00:12:20,340 --> 00:12:24,450
>> Εντάξει, έτσι μια γρήγορη ματιά στη συνέχεια σε ένα
πίσω από το θέμα πριν από δύο εβδομάδες.

272
00:12:24,450 --> 00:12:28,590
Και αυτό ήταν η έννοια του struct.

273
00:12:28,590 --> 00:12:34,180
Όχι ότι - αυτή η έννοια μιας
struct, το οποίο ήταν αυτό;

274
00:12:34,180 --> 00:12:35,430
Τι έκανε struct κάνει για μας;

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> Ορισμός -

277
00:12:39,860 --> 00:12:41,710
Ορίστε;

278
00:12:41,710 --> 00:12:42,820
Ορίστε μια μεταβλητή τύπου.

279
00:12:42,820 --> 00:12:44,410
Έτσι ταξινομήσετε του.

280
00:12:44,410 --> 00:12:46,180
Είμαστε συνδυάζουν στην πραγματικότητα δύο θέματα.

281
00:12:46,180 --> 00:12:49,510
Έτσι, με typedef, υπενθυμίζουν ότι μπορούμε
κηρύξει ένα είδος δική μας, σαν

282
00:12:49,510 --> 00:12:51,500
συνώνυμο, όπως και κορδόνι για το char *.

283
00:12:51,500 --> 00:12:56,200
Αλλά χρησιμοποιώντας typedef struct και, μπορούμε να
δημιουργούν πραγματικά τις δικές μας δομές δεδομένων.

284
00:12:56,200 --> 00:12:59,600
>> Για παράδειγμα, εάν πάω πίσω στο gedit
εδώ μόνο για μια στιγμή, και να πάω μπροστά

285
00:12:59,600 --> 00:13:08,230
και να κάνουμε κάτι σαν, επιτρέψτε μου να αποθηκεύσετε
Αυτό, όπως, ας πούμε, structs.c

286
00:13:08,230 --> 00:13:10,840
προσωρινά, είμαι απλώς πρόκειται
να προχωρήσει και να συμπεριλάβει

287
00:13:10,840 --> 00:13:14,360
standardio.h, int main κενό.

288
00:13:14,360 --> 00:13:18,960
Και στη συνέχεια, εδώ, ας υποθέσουμε ότι θέλω
να γράψει ένα πρόγραμμα που αποθηκεύει

289
00:13:18,960 --> 00:13:21,840
πολλαπλές μαθητές από πολλαπλές
σπίτια, για παράδειγμα.

290
00:13:21,840 --> 00:13:24,430
Έτσι είναι σαν ένα registrarial
βάση δεδομένων κάποιου είδους.

291
00:13:24,430 --> 00:13:29,550
>> Έτσι, αν χρειάζομαι το όνομα ενός φοιτητή,
μπορεί να κάνει κάτι σαν char * name,

292
00:13:29,550 --> 00:13:31,570
και θα κάνω κάτι σαν -

293
00:13:31,570 --> 00:13:34,410
στην πραγματικότητα, ας χρησιμοποιήσουμε την CS50 βιβλιοθήκη
για μια στιγμή για να κάνουν αυτό ένα

294
00:13:34,410 --> 00:13:38,380
λίγο πιο απλό, ώστε να μπορούμε να δανειστούν
οι δεκάδες γραμμές κώδικα.

295
00:13:38,380 --> 00:13:39,340
Και ας κρατήσει μόνο το απλό.

296
00:13:39,340 --> 00:13:42,610
Θα συνεχίσουμε να το string,
και τώρα GetString.

297
00:13:42,610 --> 00:13:47,420
>> Γι 'αυτό και ισχυρίζονται τώρα που έχω αποθηκεύσει το όνομα
κάποιου μαθητή, και το σπίτι του

298
00:13:47,420 --> 00:13:50,240
κάποια φοιτητής, απλά με τη χρήση μεταβλητών
όπως κάναμε και στην εβδομάδα.

299
00:13:50,240 --> 00:13:52,370
Αλλά υποθέτω ότι τώρα θέλουμε να υποστηρίξουμε
πολλαπλές φοιτητές.

300
00:13:52,370 --> 00:13:58,460
Εντάξει, έτσι ώστε το ένστικτό μου είναι να κάνω
κορδόνι όνομα2, παίρνει GetString, string

301
00:13:58,460 --> 00:14:01,370
house2 παίρνει GetString.

302
00:14:01,370 --> 00:14:05,850
Και τότε τριτοετής φοιτητής μας,
ας κάνουμε NAME3 GetString.

303
00:14:05,850 --> 00:14:09,170
>> Εντάξει, έτσι αυτό είναι αισίως εντυπωσιακό
σας ως ηλίθια,

304
00:14:09,170 --> 00:14:11,580
επειδή αυτή η διαδικασία είναι πραγματικά ποτέ
πρόκειται να τελειώσει, και είναι ακριβώς πρόκειται να

305
00:14:11,580 --> 00:14:13,130
κάνουν τον κωδικό μου φαίνονται χειρότερα
και χειρότερα και χειρότερα.

306
00:14:13,130 --> 00:14:14,810
Αλλά θα λυθεί κι αυτό σε δύο την εβδομάδα.

307
00:14:14,810 --> 00:14:19,450
Τι ήταν σχετικά καθαρό λύση μας
όταν είχαμε πολλαπλές μεταβλητές του

308
00:14:19,450 --> 00:14:23,580
ίδιο τύπο δεδομένων που είναι όλα συνδέονται μεταξύ τους, αλλά
εμείς δεν θέλουμε αυτό το φρικτό χάος

309
00:14:23,580 --> 00:14:26,870
από παρόμοιο όνομα μεταβλητές;

310
00:14:26,870 --> 00:14:30,060
Τι να κάνουμε αντ 'αυτού;

311
00:14:30,060 --> 00:14:31,260
>> Θεωρώ, λοιπόν, άκουσα μερικές θέσεις.

312
00:14:31,260 --> 00:14:32,590
Είχαμε μια σειρά.

313
00:14:32,590 --> 00:14:37,110
Αν θέλετε πολλαπλές παρουσίες του
κάτι, γιατί δεν έχουμε καθαρίσει αυτό όλα

314
00:14:37,110 --> 00:14:39,540
και απλώς να πω, να μου δώσει
array ονομάζεται ονόματα;

315
00:14:39,540 --> 00:14:41,640
>> Και για τώρα, ας σκληρό 3 κώδικα.

316
00:14:41,640 --> 00:14:44,450
Και τότε να μου δώσει μια άλλη σειρά
ονομάζονται σπίτια, και επιτρέψτε μου για

317
00:14:44,450 --> 00:14:45,800
πλέον δύσκολο κωδικό 3.

318
00:14:45,800 --> 00:14:49,220
Και έχω μαζικά καθαριστεί η
χάος που μόλις δημιουργήσατε.

319
00:14:49,220 --> 00:14:52,400
Τώρα, έχω ακόμα κωδικοποιημένα σκληρό 3, αλλά ακόμη και
το 3 θα μπορούσε δυναμικά να προέρχονται από την

320
00:14:52,400 --> 00:14:54,350
χρήστη ή argv, ή τα παρόμοια.

321
00:14:54,350 --> 00:14:55,720
Έτσι, αυτό είναι ήδη καθαρότερα.

322
00:14:55,720 --> 00:15:00,100
>> Αλλά αυτό που είναι ενοχλητικό για αυτό είναι ότι
τώρα, ακόμα κι αν το όνομα είναι κάπως

323
00:15:00,100 --> 00:15:02,280
ουσιαστικά συνδέεται με
σπίτι ενός μαθητή -

324
00:15:02,280 --> 00:15:04,720
Είναι ένας φοιτητής που πραγματικά
θέλουν να εκπροσωπεί -

325
00:15:04,720 --> 00:15:08,080
Τώρα έχω δύο πίνακες που είναι παράλληλες
υπό την έννοια ότι είναι η

326
00:15:08,080 --> 00:15:13,930
ίδιο μέγεθος, και τα ονόματα βραχίονα 0
προφανώς χάρτες σε σπίτια βραχίονα 0,

327
00:15:13,930 --> 00:15:16,600
και τα ονόματα βραχίονα 1 χάρτες
στα σπίτια βραχίονα 1.

328
00:15:16,600 --> 00:15:19,280
Με άλλα λόγια, ο φοιτητής ζει στο
ότι το σπίτι, και ότι άλλο μαθητή

329
00:15:19,280 --> 00:15:20,530
ζει σε άλλο σπίτι.

330
00:15:20,530 --> 00:15:23,720
Αλλά σίγουρα αυτό θα μπορούσε να
γίνεται ακόμα πιο καθαρό τρόπο.

331
00:15:23,720 --> 00:15:24,990
>> Λοιπόν, μπορεί, στην πραγματικότητα.

332
00:15:24,990 --> 00:15:28,730
Και επιτρέψτε μου να προχωρήσει και να ανοίξει
μέχρι structs.h, και θα

333
00:15:28,730 --> 00:15:31,130
δείτε αυτήν την ιδέα εδώ.

334
00:15:31,130 --> 00:15:34,905
Παρατηρήστε ότι έχω χρησιμοποιήσει typedef, όπως
αναφέρθηκε σε μια στιγμή πριν να δηλώσει μας

335
00:15:34,905 --> 00:15:35,570
δικό τύπο δεδομένων.

336
00:15:35,570 --> 00:15:39,660
Αλλά είμαι με τη χρήση κι άλλη λέξη-κλειδί
ονομάζεται struct που μου δίνει μια νέα

337
00:15:39,660 --> 00:15:40,790
δομή δεδομένων.

338
00:15:40,790 --> 00:15:43,980
>> Και αυτή η δομή δεδομένων που ισχυρίζονται πρόκειται
να έχουν δύο πράγματα στο εσωτερικό του

339
00:15:43,980 --> 00:15:47,060
αυτό - μια σειρά που ονομάζεται το όνομα, και
μια σειρά που ονομάζεται σπίτι.

340
00:15:47,060 --> 00:15:49,820
Και το όνομα Πάω να δώσει
Αυτή η δομή δεδομένων πρόκειται

341
00:15:49,820 --> 00:15:51,005
να ονομάζεται μαθητή.

342
00:15:51,005 --> 00:15:54,030
Θα μπορούσα να το ονομάσουμε ό, τι θέλω,
αλλά αυτό σημασιολογικά κάνει

343
00:15:54,030 --> 00:15:55,810
νόημα για μένα στο μυαλό μου.

344
00:15:55,810 --> 00:15:59,160
>> Έτσι τώρα, αν ανοίξει μια καλύτερη έκδοση
του προγράμματος άρχισα να γράφω

345
00:15:59,160 --> 00:16:00,390
εκεί, επιτρέψτε μου να μετακινηθείτε προς τα πάνω.

346
00:16:00,390 --> 00:16:03,190
Και υπάρχει κάποια περισσότερες γραμμές κώδικα
εδώ, αλλά επιτρέψτε μου να επικεντρωθεί για

347
00:16:03,190 --> 00:16:04,160
τη στιγμή σε ένα.

348
00:16:04,160 --> 00:16:07,790
Έχω δηλώσει μια σταθερά που ονομάζεται φοιτητές
και κωδικοποιούνται σκληρά 3 για τώρα.

349
00:16:07,790 --> 00:16:11,110
Αλλά τώρα, παρατηρήστε πόσο καθαρό
τον κωδικό μου αρχίζει να παίρνει.

350
00:16:11,110 --> 00:16:15,030
>> Στη γραμμή 22, δηλώνω
σειρά των φοιτητών.

351
00:16:15,030 --> 00:16:18,760
Και παρατηρήσετε ότι μαθητής είναι προφανώς
τώρα ένας τύπος δεδομένων.

352
00:16:18,760 --> 00:16:23,360
Επειδή στην κορυφή αυτού του αρχείου, παρατηρήστε
Έχω συμπεριληφθεί το αρχείο header

353
00:16:23,360 --> 00:16:24,820
ότι τράβηξα μέχρι πριν από λίγο.

354
00:16:24,820 --> 00:16:28,820
Και αυτό το αρχείο header πολύ απλά είχε
Αυτός ο ορισμός ενός φοιτητή.

355
00:16:28,820 --> 00:16:32,470
>> Μέχρι τώρα, έχω δημιουργήσει τη δική σας προσαρμοσμένη στα δεδομένα μου
τύπου ότι οι συγγραφείς της C ετών

356
00:16:32,470 --> 00:16:33,890
Πριν δεν σκέφτομαι εκ των προτέρων.

357
00:16:33,890 --> 00:16:34,570
Αλλά δεν υπάρχει πρόβλημα.

358
00:16:34,570 --> 00:16:35,870
Μπορώ να κάνω μόνος μου.

359
00:16:35,870 --> 00:16:39,050
Έτσι, αυτό είναι ένας πίνακας που ονομάζεται φοιτητές,
καθένα από τα μέλη των οποίων

360
00:16:39,050 --> 00:16:41,100
είναι μια δομή σπουδαστών.

361
00:16:41,100 --> 00:16:44,270
Και θέλω τρεις από αυτούς
στη συστοιχία.

362
00:16:44,270 --> 00:16:46,030
>> Και τώρα, τι κάνει το υπόλοιπο
αυτού του προγράμματος να κάνω;

363
00:16:46,030 --> 00:16:47,550
Χρειαζόμουν κάτι λίγο αυθαίρετο.

364
00:16:47,550 --> 00:16:51,450
Έτσι, από το online 24 και μετά,
Ι επαναλέγω από 0 έως 3.

365
00:16:51,450 --> 00:16:54,000
Έχω ζητήσει από το χρήστη για την
το όνομα του μαθητή.

366
00:16:54,000 --> 00:16:56,110
Και τότε μπορώ να χρησιμοποιήσω GetString όπως πριν.

367
00:16:56,110 --> 00:16:59,410
Στη συνέχεια, ζητώ για το σπίτι του μαθητή,
και μπορώ να χρησιμοποιήσω GetString όπως πριν.

368
00:16:59,410 --> 00:17:01,780
>> Αλλά προσέξτε - ελαφρώς νέα
κομμάτι της σύνταξης -

369
00:17:01,780 --> 00:17:07,010
Μπορώ ακόμα δείκτη για το μαθητή i-ου,
αλλά πώς μπορώ να πάρω στα συγκεκριμένα δεδομένα

370
00:17:07,010 --> 00:17:08,354
στο εσωτερικό πεδίο του struct;

371
00:17:08,354 --> 00:17:11,770
Λοιπόν, αυτό είναι προφανώς το
νέο κομμάτι της σύνταξης;

372
00:17:11,770 --> 00:17:13,339
Είναι απλά ο χειριστής dot.

373
00:17:13,339 --> 00:17:14,510
>> Εμείς δεν έχουμε πραγματικά δει αυτό πριν.

374
00:17:14,510 --> 00:17:17,819
Έχετε δει στο PSET πέντε, αν έχετε
βούτηξε ήδη με αρχεία bitmap.

375
00:17:17,819 --> 00:17:22,372
Αλλά η τελεία σημαίνει ακριβώς μέσα από αυτό
struct ή πολλαπλά πεδία, δίνουν dot

376
00:17:22,372 --> 00:17:24,510
το όνομα, ή να μου δώσει dot σπίτι.

377
00:17:24,510 --> 00:17:28,690
Αυτό σημαίνει ότι πάει μέσα του struct
και να πάρει εκείνους τους συγκεκριμένους τομείς.

378
00:17:28,690 --> 00:17:30,200
>> Τι σημαίνει το υπόλοιπο αυτού του προγράμματος να κάνω;

379
00:17:30,200 --> 00:17:31,190
Δεν είναι όλα ότι η σέξι.

380
00:17:31,190 --> 00:17:34,640
Παρατηρήστε ότι έχω επαναλάβει 0-3 και πάλι,
και εγώ απλά να δημιουργήσετε ένα αγγλικό

381
00:17:34,640 --> 00:17:40,500
φράση όπως έτσι και έτσι είναι σε τέτοια και
ένα τέτοιο σπίτι, περνώντας dot όνομα

382
00:17:40,500 --> 00:17:43,320
το i-οστό των φοιτητών και τους
σπίτι, καθώς και.

383
00:17:43,320 --> 00:17:47,560
>> Και στη συνέχεια, τέλος, τώρα θα αρχίσουν να παίρνουν
πρωκτικό γι 'αυτό, τώρα που είμαστε

384
00:17:47,560 --> 00:17:49,580
εξοικειωμένοι με το τι malloc και
άλλες λειτουργίες έχουν

385
00:17:49,580 --> 00:17:50,570
κάνει όλο αυτό το διάστημα.

386
00:17:50,570 --> 00:17:54,220
Γιατί έχω να απελευθερώσει τόσο το όνομα
και το σπίτι, ακόμα κι αν

387
00:17:54,220 --> 00:17:56,960
δεν θέτει malloc;

388
00:17:56,960 --> 00:17:58,020
>> GetString έκανε.

389
00:17:58,020 --> 00:18:00,930
Και αυτό ήταν το βρώμικο μικρό μυστικό για
αρκετές εβδομάδες, αλλά έχει GetString

390
00:18:00,930 --> 00:18:03,530
έχει διαρροή μνήμης σε όλη τη
τοποθετήστε όλες τις εξάμηνο μέχρι στιγμής.

391
00:18:03,530 --> 00:18:05,990
Και Valgrand τελικά θα
αποκαλύψει αυτό για εμάς.

392
00:18:05,990 --> 00:18:10,730
>> Αλλά δεν είναι μια μεγάλη υπόθεση, γιατί ξέρω
ότι μπορώ να απελευθερώσει απλά το όνομα

393
00:18:10,730 --> 00:18:15,750
και το σπίτι, αν και τεχνικά, για να
είναι σούπερ, σούπερ ασφαλές, θα πρέπει να είναι

394
00:18:15,750 --> 00:18:17,890
κάνει κάποιο λάθος έλεγχο εδώ.

395
00:18:17,890 --> 00:18:19,040
Τι είναι το ένστικτό σας σας λέει;

396
00:18:19,040 --> 00:18:22,480
Τι θα πρέπει να είναι ο έλεγχος για
πριν απελευθερωθούν τι είναι ένα

397
00:18:22,480 --> 00:18:25,470
string, γνωστός και ως που μια χαρα *;

398
00:18:25,470 --> 00:18:33,460
>> Θα ήθελα πραγματικά να ελέγξει αν οι μαθητές
βραχίονα i dot όνομα δεν

399
00:18:33,460 --> 00:18:34,840
ίση null.

400
00:18:34,840 --> 00:18:40,400
Στη συνέχεια, αυτό θα είναι εντάξει για να πάει μπροστά και δωρεάν
ότι δείκτη, και το ίδιο ή το άλλο

401
00:18:40,400 --> 00:18:41,160
ένα επίσης.

402
00:18:41,160 --> 00:18:46,860
Αν οι μαθητές βραχίονα i dot σπίτι δεν είναι
ίση με null, αυτό τώρα θα προστατεύσει

403
00:18:46,860 --> 00:18:52,520
κατά περίπτωση γωνία στην οποία
GetString επιστρέφει κάτι σαν null.

404
00:18:52,520 --> 00:18:57,310
Και είδαμε πριν από λίγο, printf θα
προστασία μας εδώ με απλά λέγοντας

405
00:18:57,310 --> 00:18:58,990
null, η οποία πρόκειται να φαίνεται παράξενο.

406
00:18:58,990 --> 00:19:02,340
Αλλά τουλάχιστον δεν θα segfault,
όπως έχουμε δει.

407
00:19:02,340 --> 00:19:05,990
>> Λοιπόν, επιτρέψτε μου να κάνω κάτι άλλο εδώ.
structs-0 είναι το είδος ενός ηλίθιου προγράμματος

408
00:19:05,990 --> 00:19:09,700
γιατί μπαίνω όλα αυτά τα δεδομένα, και στη συνέχεια
είναι μια φορά έχασε τη λήξη του προγράμματος.

409
00:19:09,700 --> 00:19:10,940
Αλλά επιτρέψτε μου να προχωρήσει και να το κάνουμε αυτό.

410
00:19:10,940 --> 00:19:12,830
Επιτρέψτε μου να κάνω το τερματικό
παράθυρο είναι λίγο μεγαλύτερο.

411
00:19:12,830 --> 00:19:17,000
Επιτρέψτε μου να κάνω structs-1, η οποία
είναι μια νέα έκδοση του αυτό.

412
00:19:17,000 --> 00:19:18,520
>> Θα κάνετε ζουμ σε λίγο.

413
00:19:18,520 --> 00:19:21,620
Και τώρα επιτρέψτε μου να τρέξει dot
κάθετο structs-1.

414
00:19:21,620 --> 00:19:22,590
Όνομα Μαθητή -

415
00:19:22,590 --> 00:19:31,500
David Mather, ας κάνουμε Rob Kirkland,
ας κάνουμε Lauren Leverett.

416
00:19:31,500 --> 00:19:33,650
Αυτό που είναι ενδιαφέρον είναι τώρα προειδοποίηση -

417
00:19:33,650 --> 00:19:35,540
και ξέρω μόνο αυτό, διότι
Έγραψα το πρόγραμμα -

418
00:19:35,540 --> 00:19:38,930
υπάρχει ένα αρχείο τώρα για τις τρέχουσες μου
κατάλογο που ονομάζεται students.csv.

419
00:19:38,930 --> 00:19:40,420
Κάποιοι από εσάς μπορεί να έχετε δει
Αυτά στον πραγματικό κόσμο.

420
00:19:40,420 --> 00:19:42,980
>> Τι είναι ένα αρχείο CSV;

421
00:19:42,980 --> 00:19:44,170
Τιμές διαχωρισμένες με κόμμα.

422
00:19:44,170 --> 00:19:46,670
Είναι το είδος του σαν ένα φτωχού
έκδοση ενός αρχείου Excel.

423
00:19:46,670 --> 00:19:50,580
Είναι ένα πίνακα γραμμών και στηλών που
μπορείτε να ανοίξετε σε ένα πρόγραμμα όπως το Excel,

424
00:19:50,580 --> 00:19:51,800
ή αριθμών σε έναν υπολογιστή Mac.

425
00:19:51,800 --> 00:19:55,180
>> Και αν ανοίξω αυτό το αρχείο εδώ στο gedit,
Ανακοίνωση - και οι αριθμοί δεν είναι εκεί.

426
00:19:55,180 --> 00:19:57,360
Αυτό ακριβώς λέει το gedit
με αριθμούς γραμμών.

427
00:19:57,360 --> 00:19:59,740
Ανακοίνωση σχετικά με την πρώτη γραμμή αυτής της
το αρχείο είναι ο David και Mather.

428
00:19:59,740 --> 00:20:01,450
Η επόμενη γραμμή είναι Rob κόμμα Kirkland.

429
00:20:01,450 --> 00:20:04,170
Και η τρίτη γραμμή είναι Lauren
κόμμα Leverett.

430
00:20:04,170 --> 00:20:05,480
>> Έτσι, αυτό που έχω δημιουργήσει;

431
00:20:05,480 --> 00:20:09,580
Έχω γράψει τώρα ένα πρόγραμμα C που
αποτελεσματικά μπορεί να δημιουργήσει φύλλα

432
00:20:09,580 --> 00:20:11,840
που μπορεί να ανοίξει σε μια
πρόγραμμα όπως το Excel.

433
00:20:11,840 --> 00:20:15,520
Δεν είναι όλα αυτά συναρπαστικό ένα σύνολο δεδομένων, αλλά
αν έχετε πολύ μεγαλύτερα κομμάτια της

434
00:20:15,520 --> 00:20:18,440
δεδομένα που θέλετε πραγματικά να
χειραγωγήσουν και να κάνουν γραφικές παραστάσεις και τις

435
00:20:18,440 --> 00:20:21,260
αρέσει, αυτό είναι ίσως ένα
τρόπος για να δημιουργήσετε τα δεδομένα.

436
00:20:21,260 --> 00:20:25,370
Επιπλέον, CSVS είναι πραγματικά εξαιρετικά κοινά
μόνο για την αποθήκευση απλά δεδομένα -

437
00:20:25,370 --> 00:20:28,940
Yahoo Finance, για παράδειγμα, αν έχετε
τιμές των μετοχών τους, μέσω του λεγόμενου

438
00:20:28,940 --> 00:20:33,180
API, η δωρεάν υπηρεσία που σας επιτρέπει να
πάρει ρεύμα up-to-the-ημερομηνία απόθεμα

439
00:20:33,180 --> 00:20:35,650
εισαγωγικά για τις επιχειρήσεις, που
δώσει τα δεδομένα πίσω στην

440
00:20:35,650 --> 00:20:37,800
super απλή μορφή CSV.

441
00:20:37,800 --> 00:20:39,380
>> Λοιπόν, πώς θα το κάνουμε αυτό;

442
00:20:39,380 --> 00:20:42,530
Καλά παρατηρήσετε, τα περισσότερα από το πρόγραμμα της
σχεδόν το ίδιο.

443
00:20:42,530 --> 00:20:46,870
Να σημειωθεί όμως εδώ κάτω, αντί για εκτύπωση
οι φοιτητές έξω, on line 35

444
00:20:46,870 --> 00:20:51,040
και μετά, εγώ ισχυρίζομαι ότι είμαι η εξοικονόμηση
μαθητές στο δίσκο, έτσι την αποθήκευση ενός αρχείου.

445
00:20:51,040 --> 00:20:53,630
>> Έτσι παρατηρήσετε είμαι δηλώνοντας ένα αρχείο * -

446
00:20:53,630 --> 00:20:57,260
τώρα, αυτό είναι το είδος της μια ανωμαλία στη C.
Για οποιοδήποτε λόγο, το αρχείο είναι όλα τα καπάκια,

447
00:20:57,260 --> 00:21:00,690
το οποίο δεν είναι όπως τα περισσότερα άλλα είδη δεδομένων
στο C. Αλλά αυτό είναι ένα ενσωματωμένο

448
00:21:00,690 --> 00:21:02,320
τύπο δεδομένων, το αρχείο *.

449
00:21:02,320 --> 00:21:05,900
Και είμαι δηλώνοντας ένα δείκτη σε ένα αρχείο,
είναι το πώς μπορείτε να σκεφτείτε αυτό.

450
00:21:05,900 --> 00:21:08,070
>> fopen σημαίνει ανοικτό αρχείο.

451
00:21:08,070 --> 00:21:09,470
Ποιο αρχείο θέλετε να ανοίξετε;

452
00:21:09,470 --> 00:21:12,620
Θέλω να ανοίξω ένα αρχείο το οποίο θα
αυθαίρετα καλέσετε students.csv.

453
00:21:12,620 --> 00:21:14,480
Θα μπορούσαμε να πούμε ότι κάτι που θέλω.

454
00:21:14,480 --> 00:21:15,200
>> Και στη συνέχεια να λάβει μια εικασία.

455
00:21:15,200 --> 00:21:18,960
Τι κάνει το δεύτερο επιχείρημα
με fopen πιθανότατα σημαίνει;

456
00:21:18,960 --> 00:21:21,480
Δεξιά, w για write, θα μπορούσε να
είναι r για ανάγνωση.

457
00:21:21,480 --> 00:21:24,120
Υπάρχει ένα για προσάρτησης, αν
θέλετε να προσθέσετε γραμμές και όχι

458
00:21:24,120 --> 00:21:25,200
αντικαταστήσετε το όλο θέμα.

459
00:21:25,200 --> 00:21:28,005
>> Αλλά εγώ απλά θέλετε να δημιουργήσετε αυτό το αρχείο
μία φορά, γι 'αυτό θα χρησιμοποιήσει απόσπασμα unquote w.

460
00:21:28,005 --> 00:21:31,880
Και ξέρω ότι μόνο από το να έχουν διαβάσει
τα έγγραφα, ή η σελίδα man.

461
00:21:31,880 --> 00:21:35,100
Αν το αρχείο δεν είναι null - με άλλα λόγια,
αν τίποτα δεν πήγε στραβά εκεί -

462
00:21:35,100 --> 00:21:37,820
επιτρέψτε μου να επαναλάβει πάνω από το
φοιτητές από 0 έως 3.

463
00:21:37,820 --> 00:21:40,410
>> Και τώρα παρατηρήσετε ότι υπάρχει κάτι
πάντα τόσο ελαφρώς διαφορετική

464
00:21:40,410 --> 00:21:42,110
περίπου στη γραμμή 41 εδώ.

465
00:21:42,110 --> 00:21:42,960
Δεν είναι printf.

466
00:21:42,960 --> 00:21:46,530
Είναι fprintf για αυτό το αρχείο printf.

467
00:21:46,530 --> 00:21:47,790
Έτσι, πρόκειται να γράψει στο αρχείο.

468
00:21:47,790 --> 00:21:48,860
Ποιο αρχείο;

469
00:21:48,860 --> 00:21:53,630
Το ένα του οποίου δείκτη που καθορίζετε
ως το πρώτο επιχείρημα.

470
00:21:53,630 --> 00:21:55,940
>> Στη συνέχεια ορίζουμε ένα string format.

471
00:21:55,940 --> 00:21:59,660
Στη συνέχεια, ορίζουμε τί σειρά που θέλουμε να
plug in για το πρώτο s τοις εκατό, και

472
00:21:59,660 --> 00:22:04,320
τότε μια άλλη μεταβλητή ή
το δεύτερο s τοις εκατό.

473
00:22:04,320 --> 00:22:06,760
Στη συνέχεια, κλείστε το αρχείο με fclose.

474
00:22:06,760 --> 00:22:09,380
Than I ελευθερώσετε τη μνήμη όπως και πριν, αν και
Θα πρέπει να πάμε πίσω και να προσθέσετε

475
00:22:09,380 --> 00:22:10,540
κάποιοι έλεγχοι για το null.

476
00:22:10,540 --> 00:22:12,090
>> Και αυτό είναι όλο.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf, fclose μου δίνει το
δυνατότητα να δημιουργήσετε αρχεία κειμένου.

478
00:22:16,960 --> 00:22:19,640
Τώρα, θα δείτε το σύνολο πρόβλημα πέντε,
το οποίο περιλαμβάνει τις εικόνες, θα πρέπει να χρησιμοποιείτε

479
00:22:19,640 --> 00:22:20,990
δυαδικά αρχεία αντ 'αυτού.

480
00:22:20,990 --> 00:22:24,200
Όμως, ουσιαστικά, η ιδέα είναι η ίδια,
ακόμη και αν οι λειτουργίες που θα

481
00:22:24,200 --> 00:22:28,710
δείτε είναι λίγο διαφορετικό.

482
00:22:28,710 --> 00:22:32,580
>> Έτσι ανεμοστρόβιλος περιοδεία, αλλά θα πάρετε
όλοι πάρα πολύ εξοικειωμένοι με το αρχείο I/O--

483
00:22:32,580 --> 00:22:34,960
εισόδου και εξόδου - με το chipset πέντε.

484
00:22:34,960 --> 00:22:38,607
Και οποιεσδήποτε ερωτήσεις σχετικά με το
αρχική βασικά εδώ;

485
00:22:38,607 --> 00:22:39,857
Ναι;

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> Τι θα συμβεί αν προσπαθήσετε να ελευθερώσετε μια μηδενική τιμή;

488
00:22:43,710 --> 00:22:48,880
Πιστεύω ότι, αν δωρεάν έχει πάρει
λίγο πιο φιλική προς το χρήστη, μπορείτε να

489
00:22:48,880 --> 00:22:49,890
δυνητικά segfault.

490
00:22:49,890 --> 00:22:54,160
Περνώντας το null είναι άσχημα γιατί δεν
Πιστεύω δωρεάν μπαίνει στον κόπο να ελέγξει για σας,

491
00:22:54,160 --> 00:22:57,330
διότι θα μπορούσε δυνητικά να είναι μια σπατάλη
του χρόνου για να κάνει η ίδια για

492
00:22:57,330 --> 00:22:59,022
ο καθένας στον κόσμο.

493
00:22:59,022 --> 00:23:00,590
Καλή ερώτηση, όμως.

494
00:23:00,590 --> 00:23:04,300
>> Εντάξει, έτσι αυτό το είδος της παίρνει
μας σε ένα ενδιαφέρον θέμα.

495
00:23:04,300 --> 00:23:07,010
Το θέμα της παύσης προβλήματος
πέντε είναι εγκληματολογίας.

496
00:23:07,010 --> 00:23:08,420
Τουλάχιστον αυτό είναι ένα τμήμα
του συνόλου προβλήματος.

497
00:23:08,420 --> 00:23:12,030
Ιατροδικαστικών αναφέρεται γενικά στο
ανάκτηση των πληροφοριών που μπορεί να είναι ή

498
00:23:12,030 --> 00:23:14,110
μπορεί να μην έχουν διαγραφεί
εσκεμμένα.

499
00:23:14,110 --> 00:23:18,680
Και έτσι σκέφτηκα να σας δώσω μια γρήγορη
γεύση του τι πραγματικά συμβαίνει σε όλα

500
00:23:18,680 --> 00:23:21,230
αυτή τη φορά κάτω από την
κουκούλα του υπολογιστή σας.

501
00:23:21,230 --> 00:23:23,960
>> Για παράδειγμα, αν έχετε μέσα σας
φορητό ή επιτραπέζιο υπολογιστή σας ένα

502
00:23:23,960 --> 00:23:28,040
σκληρό δίσκο, είναι είτε ένα μηχανικό
συσκευή που στην πραγματικότητα γυρίζει -

503
00:23:28,040 --> 00:23:31,650
υπάρχει εγκύκλιος πράγματα που λέγονται platters
που μοιάζουν αρκετά αρέσει αυτό που

504
00:23:31,650 --> 00:23:34,540
μόλις είχε στην οθόνη εδώ, αν και
Αυτό είναι όλο και πιο παλιό σχολείο.

505
00:23:34,540 --> 00:23:37,370
Αυτό είναι ένα τρεις-και-α-μισό-ιντσών
σκληρό δίσκο.

506
00:23:37,370 --> 00:23:40,070
Και τρεισήμισι ίντσες αναφέρεται από
με του πράγματος, όταν μπορείτε να το εγκαταστήσετε

507
00:23:40,070 --> 00:23:40,890
σε έναν υπολογιστή.

508
00:23:40,890 --> 00:23:44,890
>> Πολλοί από εσάς παιδιά σε φορητούς υπολογιστές σας τώρα
έχουν solid-state drives ή SSDs,

509
00:23:44,890 --> 00:23:46,260
τα οποία δεν έχουν κινούμενα μέρη.

510
00:23:46,260 --> 00:23:49,170
Είναι περισσότερο σαν RAM και λιγότερο σαν
αυτές οι μηχανικές συσκευές.

511
00:23:49,170 --> 00:23:51,450
Αλλά οι ιδέες είναι ακόμα το ίδιο,
βεβαίως που αφορούν

512
00:23:51,450 --> 00:23:52,790
για το πρόβλημα που έχει πέντε.

513
00:23:52,790 --> 00:23:57,400
>> Και αν σκεφτείτε τώρα ένα σκληρό δίσκο
αντιπροσωπεύει είναι ένας κύκλος, ο οποίος

514
00:23:57,400 --> 00:23:58,930
Θα επιστήσω σαν αυτό εδώ.

515
00:23:58,930 --> 00:24:02,290
Όταν δημιουργείτε ένα αρχείο στον υπολογιστή σας,
είτε πρόκειται για ένα SSD, ή

516
00:24:02,290 --> 00:24:06,610
Στην περίπτωση αυτή, ένα παλαιότερο σχολείο σκληρό δίσκο,
ότι το αρχείο περιλαμβάνει πολλαπλά κομμάτια.

517
00:24:06,610 --> 00:24:10,510
Ας πούμε ότι είναι αυτό 0 και 1,
ένα σωρό από 0 και 1.

518
00:24:10,510 --> 00:24:11,660
Έτσι, αυτό είναι ολόκληρο το σκληρό δίσκο μου.

519
00:24:11,660 --> 00:24:13,225
Αυτό είναι προφανώς ένα αρκετά μεγάλο αρχείο.

520
00:24:13,225 --> 00:24:18,080
Και χρησιμοποιεί το 0s και 1s σε αυτό
τμήμα της φυσικής πιατέλα.

521
00:24:18,080 --> 00:24:19,750
>> Λοιπόν, αυτό είναι ότι η φυσική μερίδα;

522
00:24:19,750 --> 00:24:25,310
Λοιπόν, αποδεικνύεται ότι σε έναν σκληρό δίσκο,
τουλάχιστον αυτού του τύπου, δεν υπάρχει

523
00:24:25,310 --> 00:24:27,340
αυτά τα μικροσκοπικά μαγνητικά σωματίδια.

524
00:24:27,340 --> 00:24:32,630
Και έχουν ουσιαστικά βόρεια και
νότια πόλους τους, έτσι ώστε αν

525
00:24:32,630 --> 00:24:35,710
μετατρέψει ένα από αυτά τα μαγνητικά σωματίδια
Με αυτό τον τρόπο, θα μπορούσαμε να πούμε ότι είναι

526
00:24:35,710 --> 00:24:36,720
αντιπροσωπεύουν 1.

527
00:24:36,720 --> 00:24:39,340
Και αν είναι ανάποδα νότια έως
βόρεια, θα μπορούσαμε να πούμε ότι είναι

528
00:24:39,340 --> 00:24:40,390
αντιπροσωπεύει μια 0.

529
00:24:40,390 --> 00:24:43,660
>> Έτσι, στον πραγματικό φυσικό κόσμο, αυτό είναι
πώς θα μπορούσε να αποτελέσει κάτι

530
00:24:43,660 --> 00:24:45,670
δυαδική κατάσταση του 0 και 1.

531
00:24:45,670 --> 00:24:46,720
Έτσι, αυτό είναι όλο ένα αρχείο είναι.

532
00:24:46,720 --> 00:24:49,300
Υπάρχει μια ολόκληρη δέσμη των μαγνητικών
σωματίδια που είναι με αυτό τον τρόπο τους ή

533
00:24:49,300 --> 00:24:51,920
Με αυτό τον τρόπο, η δημιουργία προτύπων
από 0 και 1.

534
00:24:51,920 --> 00:24:56,760
>> Αλλά τελικά, όταν αποθηκεύετε ένα αρχείο,
κάποιες πληροφορίες αποθηκεύονται ξεχωριστά.

535
00:24:56,760 --> 00:25:00,000
Έτσι, αυτό είναι ένα μικρό τραπέζι,
έναν κατάλογο, να το πω έτσι.

536
00:25:00,000 --> 00:25:05,810
Και εγώ θα καλέσει αυτό το όνομα στήλης, και
Θα πάρω αυτή τη θέση της στήλης.

537
00:25:05,810 --> 00:25:08,850
>> Και Πάω να πω, ας υποθέσουμε
Αυτό είναι το βιογραφικό μου.

538
00:25:08,850 --> 00:25:14,050
Resume.doc μου αποθηκεύεται στους
θέση, ας πούμε 123.

539
00:25:14,050 --> 00:25:15,390
Πάντα πάμε για το συγκεκριμένο αριθμό.

540
00:25:15,390 --> 00:25:18,810
Αλλά αρκεί να πούμε ότι ακριβώς όπως
στη μνήμη RAM, μπορείτε να πάρετε ένα σκληρό δίσκο

541
00:25:18,810 --> 00:25:22,350
Αυτό είναι ένα gigabyte gigabytes ή 200
ή ένα terabyte, και μπορείτε να

542
00:25:22,350 --> 00:25:23,750
Αριθμός όλα τα bytes.

543
00:25:23,750 --> 00:25:26,480
Μπορείτε να αριθμηθούν όλα τα κομμάτια των 8 bits.

544
00:25:26,480 --> 00:25:29,030
>> Έτσι, εμείς θα πούμε ότι αυτή η
είναι 123 θέση.

545
00:25:29,030 --> 00:25:32,070
Έτσι, αυτό το εσωτερικό κατάλογο της λειτουργίας μου
σύστημα θυμάται ότι μου

546
00:25:32,070 --> 00:25:34,250
βιογραφικό είναι στη θέση 123.

547
00:25:34,250 --> 00:25:36,850
Αλλά αυτό παίρνει ενδιαφέρον όταν
διαγράφετε ένα αρχείο.

548
00:25:36,850 --> 00:25:37,820
>> Έτσι, για παράδειγμα -

549
00:25:37,820 --> 00:25:40,790
και ευτυχώς, το μεγαλύτερο μέρος του κόσμου έχει
αλιεύονται σε αυτό - αυτό συμβαίνει όταν

550
00:25:40,790 --> 00:25:45,040
σύρετε ένα αρχείο στο Mac OS Trash σας
ή Windows Recycle Bin σας;

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
Ποιος είναι ο σκοπός της να κάνει αυτό;

553
00:25:50,510 --> 00:25:53,860
Είναι προφανές ότι για να απαλλαγούμε από το αρχείο,
αλλά τι κάνει η πράξη της μεταφοράς και

554
00:25:53,860 --> 00:25:57,550
πτώση σε κάδο απορριμμάτων σας ή
Recycle Bin κάνετε σε έναν υπολογιστή;

555
00:25:57,550 --> 00:25:59,230
>> Απολύτως τίποτα, πραγματικά.

556
00:25:59,230 --> 00:26:00,320
Είναι ακριβώς όπως ένα φάκελο.

557
00:26:00,320 --> 00:26:01,800
Είναι ένας ειδικός φάκελος, να είστε σίγουροι.

558
00:26:01,800 --> 00:26:04,460
Αλλά μήπως αυτό πραγματικά να διαγράψετε το αρχείο;

559
00:26:04,460 --> 00:26:06,780
>> Λοιπόν, όχι, γιατί κάποιοι από εσάς ίσως
ήταν όπως, OH βλασφημία, δεν έχετε

560
00:26:06,780 --> 00:26:07,420
σημαίνει να το κάνουμε αυτό.

561
00:26:07,420 --> 00:26:09,130
Έτσι, κάνετε διπλό κλικ στο
Άχρηστα ή Recycle Bin.

562
00:26:09,130 --> 00:26:11,630
Έχετε έσπρωξε γύρω και έχετε ανακτηθεί
το αρχείο απλά σύροντάς

563
00:26:11,630 --> 00:26:12,110
από εκεί.

564
00:26:12,110 --> 00:26:14,420
Έτσι, σαφώς, δεν είναι κατ 'ανάγκην
διαγράψετε.

565
00:26:14,420 --> 00:26:15,990
>> Εντάξει, είστε πιο έξυπνοι από αυτό.

566
00:26:15,990 --> 00:26:18,860
Γνωρίζετε ότι απλά σύροντας το ποντίκι στο
Άχρηστα ή Recycle Bin δεν σημαίνει

567
00:26:18,860 --> 00:26:19,930
είστε άδειασμα του κάδου απορριμμάτων.

568
00:26:19,930 --> 00:26:24,110
Έτσι θα πάμε μέχρι το μενού, και λέτε
Empty Trash ή Άδειασμα του κάδου ανακύκλωσης.

569
00:26:24,110 --> 00:26:25,360
Τότε τι συμβαίνει;

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> Ναι, γι 'αυτό διαγράφεται περισσότερο.

572
00:26:32,530 --> 00:26:37,660
Αλλά το μόνο που συμβαίνει είναι το εξής.

573
00:26:37,660 --> 00:26:45,350
Ο υπολογιστής ξεχνά, όπου
resume.doc ήταν.

574
00:26:45,350 --> 00:26:47,400
>> Αλλά αυτό που δεν έχει αλλάξει προφανώς
στην εικόνα;

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
Τα bits, το 0 και 1 που ισχυρίζονται ότι είναι
στο χώρο του κάποια φυσική πτυχή της

577
00:26:55,570 --> 00:26:56,280
το υλικό.

578
00:26:56,280 --> 00:26:57,110
Είναι ακόμα εκεί.

579
00:26:57,110 --> 00:26:58,930
Είναι ακριβώς ο υπολογιστής έχει
ξεχάσει τι είναι.

580
00:26:58,930 --> 00:27:03,160
>> Έτσι είναι ουσιαστικά απελευθερωθεί το αρχείο του
bits έτσι ώστε να μπορούν να επαναχρησιμοποιηθούν.

581
00:27:03,160 --> 00:27:06,940
Αλλά όχι μέχρι να δημιουργήσετε περισσότερα αρχεία,
και περισσότερα αρχεία, και τα περισσότερα αρχεία θα

582
00:27:06,940 --> 00:27:12,150
probabilistically, τα 0 και 1,
τα μαγνητικά σωματίδια, να επαναχρησιμοποιηθούν,

583
00:27:12,150 --> 00:27:16,220
ανάποδα ή δεξιά πλευρά προς τα πάνω, για
άλλα αρχεία, 0 και 1.

584
00:27:16,220 --> 00:27:17,980
>> Έτσι έχετε αυτό το παράθυρο του χρόνου.

585
00:27:17,980 --> 00:27:19,860
Και δεν είναι προβλέψιμης
μήκος, πραγματικά.

586
00:27:19,860 --> 00:27:22,240
Εξαρτάται από το μέγεθος του σκληρού σας
δίσκο και πόσα αρχεία που έχετε και

587
00:27:22,240 --> 00:27:23,490
πόσο γρήγορα μπορείτε να κάνετε νέες.

588
00:27:23,490 --> 00:27:27,050
Αλλά υπάρχει αυτό το παράθυρο του χρόνου κατά τη διάρκεια της
οποία η εν λόγω αρχείο είναι ακόμα απόλυτα

589
00:27:27,050 --> 00:27:27,770
αποδίδονται.

590
00:27:27,770 --> 00:27:31,050
>> Έτσι, αν χρησιμοποιείτε ποτέ προγράμματα όπως το McAfee
ή το Norton για να προσπαθήσει να ανακτήσει

591
00:27:31,050 --> 00:27:35,680
δεδομένων, το μόνο που κάνετε προσπαθεί να
ανακτήσει το λεγόμενο κατάλογο σε

592
00:27:35,680 --> 00:27:37,340
καταλάβω πού το αρχείο σας ήταν.

593
00:27:37,340 --> 00:27:40,605
Και μερικές φορές Norton και θα πουν,
το αρχείο είναι 93% αποδίδονται.

594
00:27:40,605 --> 00:27:42,020
Λοιπόν, τι σημαίνει αυτό;

595
00:27:42,020 --> 00:27:45,690
Αυτό απλά σημαίνει ότι κάποιο άλλο αρχείο
συμπτωματικά κατέληξαν χρησιμοποιώντας, για παράδειγμα,

596
00:27:45,690 --> 00:27:48,920
τα κομμάτια από το αρχικό σας αρχείο.

597
00:27:48,920 --> 00:27:51,950
>> Έτσι, αυτό που είναι πραγματικά εμπλέκονται
στην ανάκτηση των δεδομένων;

598
00:27:51,950 --> 00:27:55,720
Λοιπόν, αν δεν έχετε κάτι σαν
Norton προ-εγκατεστημένο στον υπολογιστή σας,

599
00:27:55,720 --> 00:27:59,510
το καλύτερο που μπορεί μερικές φορές να κάνουμε είναι να κοιτάξουμε
σε ολόκληρο τον σκληρό δίσκο που αναζητούν

600
00:27:59,510 --> 00:28:00,510
μοτίβα των bits.

601
00:28:00,510 --> 00:28:05,350
Και ένα από τα θέματα της σειράς προβλήματος
πέντε είναι ότι θα ψάξει το

602
00:28:05,350 --> 00:28:09,570
ισοδύναμο ενός σκληρού δίσκου, η ιατροδικαστική
εικόνα ενός συμπαγή κάρτα λάμψης από μια

603
00:28:09,570 --> 00:28:13,660
ψηφιακή φωτογραφική μηχανή, που ψάχνουν για το 0s
και 1s ότι συνήθως, με την υψηλή

604
00:28:13,660 --> 00:28:16,720
πιθανότητα, αντιπροσωπεύουν το
έναρξη μιας εικόνας JPEG.

605
00:28:16,720 --> 00:28:21,120
>> Και εσείς μπορεί να ανακτήσει αυτές τις εικόνες από
υποθέτοντας, αν δείτε αυτό το πρότυπο της

606
00:28:21,120 --> 00:28:24,380
bits για την εγκληματολογική εικόνα, με
μεγάλη πιθανότητα, που σηματοδοτεί

607
00:28:24,380 --> 00:28:25,650
η αρχή μιας JPEG.

608
00:28:25,650 --> 00:28:29,520
Και αν δω το ίδιο μοτίβο,
που σηματοδοτεί ίσως την έναρξη της

609
00:28:29,520 --> 00:28:32,440
άλλο JPEG, και ένα άλλο
JPEG, και ένα άλλο JPEG.

610
00:28:32,440 --> 00:28:34,970
Και αυτό είναι ακριβώς το πώς
ανάκτηση δεδομένων θα λειτουργήσει.

611
00:28:34,970 --> 00:28:37,870
Τι ωραία για αρχεία JPEG είναι ακόμη και αν
Η μορφή του αρχείου είναι κάπως

612
00:28:37,870 --> 00:28:44,400
πολύπλοκη, η αρχή κάθε τέτοια
το αρχείο είναι στην πραγματικότητα αρκετά αναγνωρίσιμο

613
00:28:44,400 --> 00:28:47,370
και απλό, όπως θα δείτε,
Εάν δεν έχετε ήδη.

614
00:28:47,370 --> 00:28:50,270
>> Έτσι, ας ρίξουμε μια πιο προσεκτική ματιά από κάτω
Η κουκούλα ως προς το τι ακριβώς ήταν

615
00:28:50,270 --> 00:28:53,360
συμβαίνει, και ποια είναι αυτά τα 0 και 1
είναι, για να σας δώσει λίγο περισσότερο από ένα

616
00:28:53,360 --> 00:28:55,330
πλαίσιο για τη συγκεκριμένη πρόκληση.

617
00:28:55,330 --> 00:28:55,510
>> [PLAYBACK VIDEO]

618
00:28:55,510 --> 00:28:58,700
>> -Σε περίπτωση που το PC σας αποθηκεύει περισσότερο
των μόνιμων στοιχείων του.

619
00:28:58,700 --> 00:29:03,390
Για να γίνει αυτό, τα δεδομένα ταξιδεύει από RAM
μαζί με τα σήματα του λογισμικού που λένε

620
00:29:03,390 --> 00:29:06,110
ο σκληρός δίσκος Πώς να αποθηκεύσετε τα δεδομένα.

621
00:29:06,110 --> 00:29:09,410
Το σκληρό δίσκο κυκλώματα μεταφράσει
αυτά τα σήματα σε τάση

622
00:29:09,410 --> 00:29:10,870
διακυμάνσεις.

623
00:29:10,870 --> 00:29:14,970
Αυτά, με τη σειρά της, τον έλεγχο του σκληρού δίσκου
κινούμενα μέρη, μερικά από τα λίγα

624
00:29:14,970 --> 00:29:17,910
κινούμενα μέρη αριστερά στην
σύγχρονο υπολογιστή.

625
00:29:17,910 --> 00:29:22,130
>> Μερικά από τα σήματα που ελέγχουν ένα μοτέρ
το οποίο περιστρέφεται επικαλυμμένα με μέταλλο platters.

626
00:29:22,130 --> 00:29:25,470
Τα δεδομένα σας είναι πραγματικά αποθηκεύονται
σε αυτά τα platters.

627
00:29:25,470 --> 00:29:28,610
Άλλα σήματα κινούνται την ανάγνωση / εγγραφή
κεφάλια για να διαβάσετε ή να

628
00:29:28,610 --> 00:29:30,710
εγγραφή δεδομένων στο platters.

629
00:29:30,710 --> 00:29:35,450
Αυτά τα μηχανήματα τόσο ακριβής που ένας άνθρωπος
μαλλιά δεν θα μπορούσε ακόμη και να περάσει μεταξύ των

630
00:29:35,450 --> 00:29:37,280
κεφάλια και νηματοποίηση platters.

631
00:29:37,280 --> 00:29:40,316
Ωστόσο, λειτουργεί όλα σε καταπληκτική ταχύτητα.

632
00:29:40,316 --> 00:29:40,660
>> [PLAYBACK VIDEO END]

633
00:29:40,660 --> 00:29:42,190
>> DAVID MALAN: Zoom σε λίγο
βαθύτερη τώρα σε ό, τι είναι

634
00:29:42,190 --> 00:29:44,360
στην πραγματικότητα σε αυτές τις πιατέλες.

635
00:29:44,360 --> 00:29:44,720
>> [PLAYBACK VIDEO]

636
00:29:44,720 --> 00:29:47,660
>> -Ας δούμε τι ακριβώς
είδε σε αργή κίνηση.

637
00:29:47,660 --> 00:29:51,710
Όταν μια σύντομη παλμό της ηλεκτρικής ενέργειας είναι
αποστέλλονται στην κεφαλή ανάγνωσης / εγγραφής, εάν flips

638
00:29:51,710 --> 00:29:54,650
σε ένα μικροσκοπικό ηλεκτρομαγνητικές
ένα κλάσμα του δευτερολέπτου.

639
00:29:54,650 --> 00:29:58,970
Ο μαγνήτης δημιουργεί ένα πεδίο, το οποίο
αλλάζει η πολικότητα του ένα μικρό, πολύ μικρό

640
00:29:58,970 --> 00:30:02,850
τμήμα των σωματιδίων μετάλλου τα οποία
παλτό κάθε επιφάνεια πιατέλα.

641
00:30:02,850 --> 00:30:05,940
>> Μια σειρά μοτίβο αυτών των μικροσκοπικών,
φορτισμένη-up περιοχές στο δίσκο

642
00:30:05,940 --> 00:30:08,470
αντιπροσωπεύει ένα μόνο κομμάτι της
δεδομένα στο δυαδικό αριθμό

643
00:30:08,470 --> 00:30:10,530
σύστημα που χρησιμοποιείται από τους υπολογιστές.

644
00:30:10,530 --> 00:30:13,775
Τώρα, εάν το ρεύμα στέλνεται ένας τρόπος
μέσω της ανάγνωσης / εγγραφής κεφάλι, η περιοχή

645
00:30:13,775 --> 00:30:15,970
είναι πολωμένο σε μια κατεύθυνση.

646
00:30:15,970 --> 00:30:17,950
Αν το ρεύμα στέλνεται στο
αντίθετη κατεύθυνση, η

647
00:30:17,950 --> 00:30:19,930
πόλωση αντιστρέφεται.

648
00:30:19,930 --> 00:30:22,370
>> Πώς μπορείτε να πάρετε τα δεδομένα από το σκληρό δίσκο;

649
00:30:22,370 --> 00:30:24,090
Απλά αντιστραφεί η διαδικασία.

650
00:30:24,090 --> 00:30:26,550
Έτσι είναι τα σωματίδια στο δίσκο
που παίρνουν το ρεύμα στο

651
00:30:26,550 --> 00:30:27,960
ανάγνωσης / εγγραφής κεφάλι κινείται.

652
00:30:27,960 --> 00:30:30,700
Βάλτε μαζί τα εκατομμύρια από αυτά
μαγνητισμένα τμήματα, και

653
00:30:30,700 --> 00:30:32,160
έχετε ένα αρχείο.

654
00:30:32,160 --> 00:30:36,060
>> Τώρα, τα κομμάτια από ένα ενιαίο αρχείο μπορεί να
είναι διάσπαρτα σε όλο το αυτοκίνητο του

655
00:30:36,060 --> 00:30:39,970
platters, κάτι σαν το χάος
των εγγράφων στο γραφείο σας.

656
00:30:39,970 --> 00:30:43,500
Έτσι, μια ειδική πρόσθετη αρχείο παρακολουθεί
από όπου τα πάντα είναι.

657
00:30:43,500 --> 00:30:45,985
Μην επιθυμείτε είχατε
κάτι τέτοιο;

658
00:30:45,985 --> 00:30:46,470
>> [PLAYBACK VIDEO END]

659
00:30:46,470 --> 00:30:47,820
>> DAVID MALAN: Εντάξει, ίσως όχι.

660
00:30:47,820 --> 00:30:52,070
Έτσι, πόσοι από εσάς παιδιά
μεγάλωσε με αυτά;

661
00:30:52,070 --> 00:30:53,970
Εντάξει, έτσι είναι όλο και λιγότεροι
χέρια κάθε χρόνο.

662
00:30:53,970 --> 00:30:56,550
Αλλά είμαι ευτυχής να είστε τουλάχιστον εξοικειωμένοι
με αυτούς, επειδή αυτό και το δικό μας

663
00:30:56,550 --> 00:31:00,520
demo βιβλίο, δυστυχώς, πεθαίνουν πολύ
αργό θάνατο εδώ οικειότητας.

664
00:31:00,520 --> 00:31:04,010
>> Αλλά αυτό είναι ό, τι εγώ, τουλάχιστον, πίσω στο
γυμνάσιο, το οποίο χρησιμοποιείται για τη χρήση αντιγράφων ασφαλείας.

665
00:31:04,010 --> 00:31:08,110
Και ήταν εκπληκτικό, γιατί
θα μπορούσε να αποθηκεύσει 1,4 megabytes για

666
00:31:08,110 --> 00:31:08,930
αυτό το συγκεκριμένο δίσκο.

667
00:31:08,930 --> 00:31:12,260
Και αυτή ήταν η έκδοση υψηλής πυκνότητας,
όπως υποδεικνύεται από το HD, η οποία έχει

668
00:31:12,260 --> 00:31:14,240
δηλαδή πριν από τα βίντεο HD σήμερα.

669
00:31:14,240 --> 00:31:16,400
>> Πρότυπο πυκνότητα ήταν 800 kilobytes.

670
00:31:16,400 --> 00:31:18,640
Και πριν από αυτό, υπήρχαν
400 kilobyte δίσκους.

671
00:31:18,640 --> 00:31:23,120
Και πριν από αυτό, υπήρχαν 5 και 1/4
ιντσών δίσκους, που ήταν πραγματικά δισκέτα,

672
00:31:23,120 --> 00:31:25,680
και λίγο μεγαλύτερο και ψηλότερο
από αυτά τα πράγματα εδώ.

673
00:31:25,680 --> 00:31:29,150
Αλλά μπορείτε να δείτε πραγματικά το λεγόμενο
δισκέτα πτυχή αυτών των δίσκων.

674
00:31:29,150 --> 00:31:32,630
>> Και λειτουργικά, είναι στην πραγματικότητα
αρκετά παρόμοια με σκληρούς δίσκους σε

675
00:31:32,630 --> 00:31:33,570
τουλάχιστον αυτό το είδος.

676
00:31:33,570 --> 00:31:37,270
Και πάλι, SSDs σε νεότερα υπολογιστές
λειτουργούν λίγο διαφορετικά.

677
00:31:37,270 --> 00:31:41,530
Αλλά αν μετακινήσετε αυτό το μικρό μεταλλικό πτερύγιο,
μπορείτε πραγματικά να δείτε ένα μικρό μπισκότο,

678
00:31:41,530 --> 00:31:42,560
ή πιατέλα.

679
00:31:42,560 --> 00:31:43,830
>> Δεν είναι μέταλλο, όπως αυτό.

680
00:31:43,830 --> 00:31:46,000
Αυτό και μόνο είναι πραγματικά κάποια φθηνότερη
πλαστικό υλικό.

681
00:31:46,000 --> 00:31:46,750
Και μπορείτε να το είδος της κουνάω αυτό.

682
00:31:46,750 --> 00:31:50,310
Και έχετε trully μόλις σβηστεί κάποια
αριθμός των bits ή μαγνητικών σωματιδίων

683
00:31:50,310 --> 00:31:51,220
από αυτό το δίσκο.

684
00:31:51,220 --> 00:31:52,710
>> Έτσι, ευτυχώς, δεν υπάρχει τίποτα σε αυτό.

685
00:31:52,710 --> 00:31:55,790
Αν αυτό το πράγμα είναι στον τρόπο - και καλύπτουν
τα μάτια σας και αυτές του πλησίον σου -

686
00:31:55,790 --> 00:31:58,865
μπορείτε ακριβώς το είδος των τραβήξει αυτό
σύνολο off θήκη έτσι.

687
00:31:58,865 --> 00:32:01,900
Αλλά υπάρχει ένα μικρό ελατήριο, ώστε να είναι
γνωρίζει ότι με τα μάτια σας.

688
00:32:01,900 --> 00:32:03,620
Έτσι τώρα έχετε πραγματικά μια δισκέτα.

689
00:32:03,620 --> 00:32:07,090
>> Και αυτό που είναι αξιοσημείωτο για αυτό
είναι ότι σε όσο αυτό είναι ένα

690
00:32:07,090 --> 00:32:10,830
μικρής κλίμακας αναπαράσταση ενός μεγαλύτερου
σκληρό δίσκο, αυτά τα πράγματα είναι super,

691
00:32:10,830 --> 00:32:11,590
εξαιρετικά απλή.

692
00:32:11,590 --> 00:32:15,170
Αν τσιμπήσετε το κάτω μέρος του, τώρα που
αυτό το πράγμα μέταλλο είναι μακριά, και τη φλούδα

693
00:32:15,170 --> 00:32:20,990
τα ανοίξετε, όλα είναι εκεί είναι δύο κομμάτια
αισθητή και η λεγόμενη δισκέτα

694
00:32:20,990 --> 00:32:22,930
με ένα κομμάτι του μετάλλου στο εσωτερικό.

695
00:32:22,930 --> 00:32:25,990
>> Και εκεί πηγαίνει το ήμισυ του
περιεχόμενα του δίσκου μου.

696
00:32:25,990 --> 00:32:27,540
Πάει άλλο τα μισά από αυτά.

697
00:32:27,540 --> 00:32:31,375
Αλλά αυτό είναι το μόνο που περιστρέφεται μέσα σε
του υπολογιστή σας στο χτες.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> Και πάλι, για να το θέσουμε σε προοπτική,
πόσο μεγάλο είναι οι περισσότεροι από σας

700
00:32:38,310 --> 00:32:39,560
σκληρούς δίσκους αυτές τις μέρες;

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 gigabytes, ένα terabyte, ίσως
Ένας επιτραπέζιος υπολογιστής, 2 terabytes, 3

703
00:32:46,230 --> 00:32:47,630
terabytes, 4 terabytes, έτσι δεν είναι;

704
00:32:47,630 --> 00:32:52,480
Αυτό είναι ένα megabyte, ή να δώσει,
η οποία δεν μπορεί να χωρέσει ακόμα και ένα τυπικό MP3

705
00:32:52,480 --> 00:32:55,310
πια αυτές τις μέρες, ή κάποια
παρόμοιου αρχείου μουσικής.

706
00:32:55,310 --> 00:32:59,500
>> Έτσι, ένα μικρό ενθύμιο για σας σήμερα, και
και για να βοηθήσει contextualize τι

707
00:32:59,500 --> 00:33:03,570
θα πρέπει να λαμβάνουν ως δεδομένο
τώρα στο πρόβλημα που έχει πέντε.

708
00:33:03,570 --> 00:33:04,820
Έτσι, αυτά είναι δικά σας για να κρατήσει.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
Επιτρέψτε μου λοιπόν να μετάβαση στο σημείο όπου θα είναι
δαπάνες το επόμενο PSET, καθώς και.

711
00:33:13,370 --> 00:33:18,470
Έτσι έχουμε θέσει τώρα αυτή τη σελίδα για - ω,
ένα ζευγάρι των ανακοινώσεων γρήγορα.

712
00:33:18,470 --> 00:33:21,730
>> Αυτή την Παρασκευή, αν θα θέλατε ενταχθούν CS50
για το μεσημεριανό γεύμα, πηγαίνετε στο συνήθη τόπο,

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
Και τελικό σχέδιο -

715
00:33:25,100 --> 00:33:28,520
οπότε σύμφωνα με το αναλυτικό πρόγραμμα, έχουμε δημοσιεύτηκε το
τελικές προδιαγραφές του έργου έχουν ήδη.

716
00:33:28,520 --> 00:33:31,410
Συνειδητοποίησε ότι αυτό δεν σημαίνει ότι
Είναι οφείλεται ιδιαίτερα σύντομα.

717
00:33:31,410 --> 00:33:33,990
Είναι δημοσιεύτηκε, πραγματικά, μόνο και μόνο για να πάρει
εσείς το σκέφτομαι.

718
00:33:33,990 --> 00:33:37,620
Και πράγματι, ένα σούπερ σημαντική
το ποσοστό αυτών που θα ασχοληθεί

719
00:33:37,620 --> 00:33:40,780
τελικών σχεδίων για το υλικό που
δεν έχουν πάρει ακόμη και στην τάξη,

720
00:33:40,780 --> 00:33:42,730
αλλά θα είναι ήδη από την επόμενη εβδομάδα.

721
00:33:42,730 --> 00:33:45,530
>> Ανακοίνωση, όμως, ότι το spec ζητά
μερικές διαφορετικές συνιστώσες της

722
00:33:45,530 --> 00:33:46,190
τελικό σχέδιο.

723
00:33:46,190 --> 00:33:49,590
Η πρώτη, σε μερικές εβδομάδες, είναι ένα
προ-πρόταση, ένα αρκετά απλό email στο

724
00:33:49,590 --> 00:33:52,760
TF σας για να του πω ή τι είστε
σκεφτόμαστε για το έργο σας, με την

725
00:33:52,760 --> 00:33:53,650
καμία δέσμευση.

726
00:33:53,650 --> 00:33:56,710
Η πρόταση θα είναι ιδιαίτερα σας
δέσμευση, λέγοντας, εδώ, αυτό είναι ό, τι

727
00:33:56,710 --> 00:33:57,770
Θα ήθελα να κάνω για το έργο μου.

728
00:33:57,770 --> 00:33:58,250
Τι νομίζετε;

729
00:33:58,250 --> 00:33:58,650
Πάρα πολύ μεγάλο;

730
00:33:58,650 --> 00:33:59,145
Πάρα πολύ μικρό;

731
00:33:59,145 --> 00:34:00,330
Είναι εύχρηστο;

732
00:34:00,330 --> 00:34:02,230
Και θα δείτε το spec για περισσότερες λεπτομέρειες.

733
00:34:02,230 --> 00:34:05,060
>> Δυο εβδομάδες μετά από αυτό το καθεστώς
έκθεση, η οποία είναι μια παρόμοια

734
00:34:05,060 --> 00:34:08,260
απλό email στο TF σας για να πω πόσο
πολύ πίσω σας βρίσκονται στο τελικό σας

735
00:34:08,260 --> 00:34:12,360
υλοποίησης του έργου, που ακολουθείται από
η CS50 Hackathon την οποία καθένας

736
00:34:12,360 --> 00:34:17,520
καλείται, το οποίο θα είναι ένα γεγονός από
20:00 σε ένα βράδυ μέχρι τις 7:00

737
00:34:17,520 --> 00:34:19,150
Π.μ. το επόμενο πρωί.

738
00:34:19,150 --> 00:34:22,560
Pizza, όπως μπορεί να αναφέρεται στην εβδομάδα
μηδέν, wil να εξυπηρετούνται στις 9:00 μμ,

739
00:34:22,560 --> 00:34:24,120
Κινέζικο φαγητό στις 1:00 AM.

740
00:34:24,120 --> 00:34:27,929
Και αν είστε ακόμα ξύπνιοι στις 5:00 π.μ.,
θα σας πάρει για να IHop για πρωινό.

741
00:34:27,929 --> 00:34:31,310
>> Έτσι, η Hackathon είναι μια από τις πιο
αξέχαστες εμπειρίες στην τάξη.

742
00:34:31,310 --> 00:34:35,290
Στη συνέχεια, η εφαρμογή οφείλεται, και
τότε η κλιμακούμενη CS50 Fair.

743
00:34:35,290 --> 00:34:38,070
Περισσότερες λεπτομέρειες σχετικά με όλα αυτά
στις εβδομάδες που έρχονται.

744
00:34:38,070 --> 00:34:40,739
>> Αλλά ας πάμε πίσω σε κάτι
old school -

745
00:34:40,739 --> 00:34:41,920
πάλι, μία συστοιχία.

746
00:34:41,920 --> 00:34:45,040
Έτσι, μια σειρά ήταν ωραίο, διότι λύνει
προβλήματα, όπως είδαμε μόλις

747
00:34:45,040 --> 00:34:49,290
πριν από λίγο με τις δομές των φοιτητών
να πάρει λίγο έξω από τον έλεγχο, αν

748
00:34:49,290 --> 00:34:52,405
θέλουν να έχουν ένα μαθητή, φοιτητή δύο,
φοιτητής τρεις, φοιτητής dot dot dot,

749
00:34:52,405 --> 00:34:54,400
κάποιο αυθαίρετο αριθμό των φοιτητών.

750
00:34:54,400 --> 00:34:58,850
>> Έτσι συστοιχίες, πριν από λίγες εβδομάδες, όρμησε μέσα
και να επιλυθούν όλα τα προβλήματα μας δεν

751
00:34:58,850 --> 00:35:03,340
γνωρίζει εκ των προτέρων πόσα πράγματα
από κάποιο είδος θα μπορούσαμε να θέλουμε.

752
00:35:03,340 --> 00:35:07,390
Και έχουμε δει ότι structs μπορεί να μας βοηθήσει
περαιτέρω οργανώσει τον κωδικό μας και να κρατήσει

753
00:35:07,390 --> 00:35:11,660
εννοιολογικά παρόμοιες μεταβλητές, όπως η
όνομα και ένα σπίτι, από κοινού, έτσι ώστε να

754
00:35:11,660 --> 00:35:15,570
μπορεί να τους αντιμετωπίσουμε ως μία οντότητα, μέσα
από τα οποία υπάρχουν μικρότερα κομμάτια.

755
00:35:15,570 --> 00:35:17,810
>> Αλλά συστοιχίες έχουν κάποια μειονεκτήματα.

756
00:35:17,810 --> 00:35:19,780
Ποια είναι μερικά από τα μειονεκτήματα
έχουμε αντιμετωπίσει

757
00:35:19,780 --> 00:35:22,320
με συστοιχίες μέχρι στιγμής;

758
00:35:22,320 --> 00:35:23,450
Τι είναι αυτό;

759
00:35:23,450 --> 00:35:28,130
Σταθερό μέγεθος - έτσι ακόμα κι αν ίσως
να είναι σε θέση να διαθέσει μνήμης για μια

760
00:35:28,130 --> 00:35:32,310
array, μόλις ξέρετε πόσοι φοιτητές
έχετε, πόσους χαρακτήρες έχετε

761
00:35:32,310 --> 00:35:35,460
από το χρήστη, αφού έχετε διατεθεί
η σειρά, έχετε το είδος της ζωγραφισμένα

762
00:35:35,460 --> 00:35:36,740
τον εαυτό σας σε μια γωνία.

763
00:35:36,740 --> 00:35:40,600
>> Επειδή δεν μπορείτε να εισάγετε νέα στοιχεία
στη μέση ενός πίνακα.

764
00:35:40,600 --> 00:35:43,660
Δεν μπορείτε να τοποθετήσετε περισσότερα στοιχεία
στο τέλος του πίνακα.

765
00:35:43,660 --> 00:35:47,750
Πραγματικά, θα πρέπει να καταφύγουν για τη δημιουργία ενός
ολόκληρη νέα σειρά, όπως είπαμε,

766
00:35:47,750 --> 00:35:49,320
αντιγράφοντας το παλιό στο νέο.

767
00:35:49,320 --> 00:35:52,610
Και πάλι, αυτό είναι ότι ο πονοκέφαλος
GetString ασχολείται με σας.

768
00:35:52,610 --> 00:35:56,170
>> Αλλά και πάλι, δεν μπορείτε καν να εισάγετε
κάτι στη μέση της συστοιχίας

769
00:35:56,170 --> 00:35:58,200
Εάν το επιτόκιο δεν είναι εντελώς γεμάτο.

770
00:35:58,200 --> 00:36:03,010
Για παράδειγμα, εάν αυτή η συστοιχία εδώ μεγέθους
έξι έχει μόνο πέντε πράγματα σε αυτό,

771
00:36:03,010 --> 00:36:06,080
Καλά, θα μπορούσατε απλά καρφί
κάτι πάνω στο άκρο.

772
00:36:06,080 --> 00:36:08,200
Τι γίνεται όμως αν θέλετε να εισαγάγετε κάτι
στη μέση του

773
00:36:08,200 --> 00:36:11,280
array, έστω και αν θα μπορούσε να έχει
πέντε από τα έξι πράγματα σε αυτό;

774
00:36:11,280 --> 00:36:14,250
>> Λοιπόν, τι κάναμε εμείς όταν είχαμε όλοι
των εθελοντών μας επί σκηνής στο

775
00:36:14,250 --> 00:36:15,110
εβδομάδες παρελθόν;

776
00:36:15,110 --> 00:36:18,710
Αν θέλαμε να θέσει κάποιος εδώ, είτε
αυτοί οι άνθρωποι πώς να προχωρήσει αυτό

777
00:36:18,710 --> 00:36:22,540
τρόπο, ή αυτοί οι άνθρωποι πώς να προχωρήσει αυτό
τρόπο, και αυτό έγινε ακριβό.

778
00:36:22,540 --> 00:36:26,950
Η μετατόπιση των ατόμων εντός ενός
array κατέληξε προσθέτοντας και κοστολόγησης

779
00:36:26,950 --> 00:36:31,240
μας χρόνο, ως εκ τούτου, πολύ n τετράγωνο μας
χρόνους εκτέλεσης, όπως ταξινόμηση με εισαγωγή, για

780
00:36:31,240 --> 00:36:32,550
παράδειγμα, στη χειρότερη περίπτωση.

781
00:36:32,550 --> 00:36:36,520
Έτσι συστοιχίες είναι μεγάλη, αλλά θα πρέπει να
γνωρίζουν εκ των προτέρων πόσο μεγάλο θέλετε.

782
00:36:36,520 --> 00:36:38,030
>> Έτσι Εντάξει, εδώ είναι μια λύση.

783
00:36:38,030 --> 00:36:43,860
Αν δεν γνωρίζει εκ των προτέρων πόσα
οι μαθητές θα μπορούσα να έχω, και ξέρω φορά

784
00:36:43,860 --> 00:36:47,870
Έχω αποφασίσει, όμως, έχω κολλήσει με αυτό
πολλοί φοιτητές, γιατί δεν μπορώ απλά πάντα

785
00:36:47,870 --> 00:36:51,740
διαθέσει διπλάσιο χώρο
όπως θα μπορούσε κανείς να σκεφτεί χρειάζομαι;

786
00:36:51,740 --> 00:36:54,450
Δεν είναι ότι μια λογική λύση;

787
00:36:54,450 --> 00:36:58,240
>> Ρεαλιστικά, δεν νομίζω ότι είμαστε
θα χρειαστεί περισσότερα από 50 slots

788
00:36:58,240 --> 00:37:02,190
σε μια σειρά για μια κατηγορία μεσαίου μεγέθους,
οπότε ας στρογγυλοποιεί προς τα πάνω.

789
00:37:02,190 --> 00:37:07,040
Θα κάνω 100 θέσεις στη σειρά μου, απλά
έτσι ώστε να μπορούμε να πάρουμε σίγουρα το

790
00:37:07,040 --> 00:37:10,330
αριθμός των φοιτητών που περιμένω να
να είναι σε κάποια κατηγορία μεσαίου μεγέθους.

791
00:37:10,330 --> 00:37:14,320
Γιατί λοιπόν να μην απλά στρογγυλοποιεί προς τα πάνω και να διαθέσει
περισσότερη μνήμη, τυπικά, για μία συστοιχία

792
00:37:14,320 --> 00:37:16,290
από ό, τι νομίζετε ότι μπορεί να χρειαστεί ακόμη και;

793
00:37:16,290 --> 00:37:20,190
Τι είναι αυτή η απλή pushback
σε αυτή την ιδέα;

794
00:37:20,190 --> 00:37:21,440
>> Χάνεις απλά μνήμη.

795
00:37:21,440 --> 00:37:25,350
Κυριολεκτικά κάθε πρόγραμμα που γράφετε στη συνέχεια
χρησιμοποιεί ίσως διπλάσια μνήμη

796
00:37:25,350 --> 00:37:26,680
που πραγματικά χρειάζεστε.

797
00:37:26,680 --> 00:37:28,990
Και αυτό ακριβώς δεν αισθάνεται σαν μια
ιδιαίτερα κομψή λύση.

798
00:37:28,990 --> 00:37:31,990
Επιπλέον, μειώνεται μόνο η
πιθανότητα ενός προβλήματος.

799
00:37:31,990 --> 00:37:35,300
Αν συμβαίνει να έχουν ένα δημοφιλές μάθημα
ένα εξάμηνο και έχετε 101

800
00:37:35,300 --> 00:37:39,610
φοιτητές, το πρόγραμμα σας είναι ακόμα
ουσιαστικά αντιμετωπίζει το ίδιο θέμα.

801
00:37:39,610 --> 00:37:44,280
>> Έτσι, ευτυχώς, υπάρχει μια λύση για την
αυτή η διαφήμιση όλα τα προβλήματά μας με τη μορφή

802
00:37:44,280 --> 00:37:46,790
των δομών δεδομένων που είναι
πιο πολύπλοκη από αυτά

803
00:37:46,790 --> 00:37:47,970
έχουμε δει μέχρι στιγμής.

804
00:37:47,970 --> 00:37:50,530
Αυτό, ισχυρίζονται, είναι μια συνδεδεμένη λίστα.

805
00:37:50,530 --> 00:37:51,920
Αυτή είναι μια λίστα των αριθμών -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, και 34 -

807
00:37:54,970 --> 00:38:00,120
που έχουν συνδεθεί μεταξύ τους με τρόπο
από ό, τι έχω σχεδιάσει ως βέλη.

808
00:38:00,120 --> 00:38:03,580
>> Με άλλα λόγια, αν ήθελα να εκπροσωπεί
μια σειρά, θα μπορούσα να κάνω

809
00:38:03,580 --> 00:38:04,910
κάτι σαν αυτό.

810
00:38:04,910 --> 00:38:07,310
Και θα βάλω αυτό στην εναέρια
ακριβώς σε μια στιγμή.

811
00:38:07,310 --> 00:38:09,970
Θα μπορούσα να κάνω -

812
00:38:09,970 --> 00:38:12,520
γεια, εντάξει.

813
00:38:12,520 --> 00:38:14,470
Αναμείνατε.

814
00:38:14,470 --> 00:38:17,360
Νέο υπολογιστή εδώ, σαφές -

815
00:38:17,360 --> 00:38:18,090
Εντάξει.

816
00:38:18,090 --> 00:38:21,730
>> Έτσι, αν έχω αυτούς τους αριθμούς σε σειρά -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
όχι κατ 'ανάγκη σε κλίμακα.

819
00:38:30,530 --> 00:38:33,730
Εντάξει, τόσο εδώ είναι η σειρά μου -

820
00:38:33,730 --> 00:38:34,980
oh my god.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
Εντάξει, τόσο εδώ είναι η σειρά μου.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
Oh my god.

825
00:38:45,050 --> 00:38:48,820
>> [Γέλια]

826
00:38:48,820 --> 00:38:49,440
>> DAVID MALAN: υποκρινόμαστε.

827
00:38:49,440 --> 00:38:52,330
Είναι πάρα πολλή προσπάθεια για να πάει πίσω
και να διορθώσετε αυτό, ώστε εκεί -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
Έτσι έχουμε αυτή την σειρά των
9, 17, 22, 26, και 34.

830
00:38:57,650 --> 00:39:00,260
Για όσους από εσάς μπορεί να δει το
ενοχλητικό λάθος που μόλις έκανε,

831
00:39:00,260 --> 00:39:00,830
εκεί που είναι.

832
00:39:00,830 --> 00:39:04,490
>> Γι 'αυτό και ισχυρίζονται ότι αυτό είναι ένα
πολύ αποτελεσματική λύση.

833
00:39:04,490 --> 00:39:07,310
Έχω κατανέμονται ως πολλά ints ως
Χρειάζομαι - ένα, δύο, τρία,

834
00:39:07,310 --> 00:39:09,100
τέσσερα, πέντε, ή έξι -

835
00:39:09,100 --> 00:39:11,660
και έχω συνέχεια αποθηκεύονται στους αριθμούς
εσωτερικό αυτού του πίνακα.

836
00:39:11,660 --> 00:39:15,220
Αλλά ας υποθέσουμε, λοιπόν, θέλετε να εισαγάγετε
μια τιμή, όπως τον αριθμό 8;

837
00:39:15,220 --> 00:39:16,100
Λοιπόν, πού να πάει;

838
00:39:16,100 --> 00:39:18,530
Ας υποθέσουμε ότι θέλετε να εισαγάγετε
ένας αριθμός όπως 20.

839
00:39:18,530 --> 00:39:19,790
Λοιπόν, πού να πάει;

840
00:39:19,790 --> 00:39:23,160
Κάπου εκεί στη μέση,
ή ο αριθμός 35 έχει για να πάει

841
00:39:23,160 --> 00:39:24,010
κάπου στο τέλος.

842
00:39:24,010 --> 00:39:25,320
Αλλά είμαι όλοι έξω του χώρου.

843
00:39:25,320 --> 00:39:29,120
>> Και έτσι αυτή είναι μια θεμελιώδης πρόκληση
των πινάκων που δεν είναι η λύση.

844
00:39:29,120 --> 00:39:32,280
I υποστήριξε πριν από λίγο, GetString
λύνει αυτό το πρόβλημα.

845
00:39:32,280 --> 00:39:37,380
Εάν θέλετε να εισαγάγετε ένα έκτο αριθμό
σε αυτή την σειρά, τι είναι τουλάχιστον ένα

846
00:39:37,380 --> 00:39:40,090
λύση που μπορεί να πέσει πίσω για σίγουρα,
ακριβώς όπως κάνουμε με GetString;

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
Τι είναι αυτό;

849
00:39:46,030 --> 00:39:48,190
>> Λοιπόν, το κάνει μεγαλύτερο είναι
πιο εύκολο στα λόγια παρά στην πράξη.

850
00:39:48,190 --> 00:39:52,810
Δεν μπορούμε να κάνουμε κατ 'ανάγκη την συστοιχία
μεγαλύτερο, αλλά τι μπορούμε να κάνουμε;

851
00:39:52,810 --> 00:39:56,570
Κάντε μια νέα σειρά που είναι μεγαλύτερο, το μέγεθος
6, ή ίσως το μέγεθος 10, αν θέλουμε

852
00:39:56,570 --> 00:40:00,490
να πάρει μπροστά από τα πράγματα, και στη συνέχεια να αντιγράψετε
το παλιό συστοιχία στο νέο, και κατόπιν

853
00:40:00,490 --> 00:40:01,680
ελευθερώσει την παλιά σειρά.

854
00:40:01,680 --> 00:40:05,770
>> Αλλά τι είναι ο χρόνος εκτέλεσης
τώρα από αυτή τη διαδικασία;

855
00:40:05,770 --> 00:40:09,870
Είναι μεγάλη O Ν, διότι η αντιγραφή
πρόκειται να σας κοστίσει μερικές μονάδες

856
00:40:09,870 --> 00:40:13,480
χρόνο, οπότε δεν είναι τόσο ιδανική, αν πρέπει να
διαθέσει ένα νέο πίνακα, η οποία θα

857
00:40:13,480 --> 00:40:15,610
να καταναλώνουν διπλάσια
μνήμη προσωρινά.

858
00:40:15,610 --> 00:40:16,660
Αντιγράψτε τα παλιά σε νέα -

859
00:40:16,660 --> 00:40:18,800
Θέλω να πω, είναι απλώς ένας πονοκέφαλος, που
είναι, και πάλι, γιατί γράψαμε

860
00:40:18,800 --> 00:40:19,920
GetString για σας.

861
00:40:19,920 --> 00:40:21,380
>> Λοιπόν, τι θα μπορούσαμε να κάνουμε αντ 'αυτού;

862
00:40:21,380 --> 00:40:25,000
Λοιπόν, τι θα γίνει αν η δομή δεδομένων μας
στην πραγματικότητα έχει κενά σε αυτό;

863
00:40:25,000 --> 00:40:30,790
Ας υποθέσουμε ότι έχω χαλαρώσει ο στόχος μου να έχουν
συνεχόμενα κομμάτια της μνήμης, όπου το 9

864
00:40:30,790 --> 00:40:34,500
Είναι ακριβώς δίπλα στο 17, το οποίο είναι
δίπλα στο 22, και ούτω καθεξής.

865
00:40:34,500 --> 00:40:39,570
>> Και ας υποθέσουμε ότι 9 μπορεί να είναι εδώ στην
RAM, και 17 μπορούν να εδώ στη RAM,

866
00:40:39,570 --> 00:40:40,990
και 22 μπορούν να εδώ στη RAM.

867
00:40:40,990 --> 00:40:43,610
Με άλλα λόγια, εγώ δεν τα χρειάζεστε
ακόμη και πίσω στο πίσω πια.

868
00:40:43,610 --> 00:40:47,850
Απλά πρέπει να το νήμα με κάποιο τρόπο μια βελόνα
μέσω καθενός από αυτούς τους αριθμούς, ή κάθε

869
00:40:47,850 --> 00:40:51,010
από αυτούς τους κόμβους, όπως θα καλέσετε τον
ορθογώνια, όπως τους έχω που να

870
00:40:51,010 --> 00:40:55,670
θυμηθείτε πώς να φτάσουμε στην τελευταία
τέτοια κόμβο από την πρώτη.

871
00:40:55,670 --> 00:40:59,940
>> Έτσι, ποια είναι η δομή προγραμματισμού
έχουμε δει αρκετά πρόσφατα, με το οποίο

872
00:40:59,940 --> 00:41:03,030
μπορούν να εφαρμόσουν αυτό το νήμα, ή
που εδώ, με την οποία μπορώ να

873
00:41:03,030 --> 00:41:05,430
εφαρμόσουν τα βέλη αυτά;

874
00:41:05,430 --> 00:41:06,500
Έτσι, δείκτες, έτσι δεν είναι;

875
00:41:06,500 --> 00:41:09,560
Αν έχω διαθέσει δεν είναι απλώς μια
Int, αλλά ένας κόμβος - και από

876
00:41:09,560 --> 00:41:10,810
κόμβο, εννοώ μόνο το δοχείο.

877
00:41:10,810 --> 00:41:12,900
Και οπτικά, εννοώ ένα ορθογώνιο.

878
00:41:12,900 --> 00:41:16,420
Έτσι, ένας κόμβος χρειάζεται προφανώς
να περιέχει δύο τιμές -

879
00:41:16,420 --> 00:41:21,490
int η ίδια και, στη συνέχεια, όπως υπονοείται από
το κάτω μισό του ορθογωνίου,

880
00:41:21,490 --> 00:41:23,010
αρκετό χώρο για ένα int.

881
00:41:23,010 --> 00:41:26,130
>> Έτσι ακριβώς σκέφτεται το μέλλον εδώ,
πόσο μεγάλος είναι αυτός ο κόμβος, αυτό

882
00:41:26,130 --> 00:41:27,170
δοχείο ερώτηση;

883
00:41:27,170 --> 00:41:29,250
Πόσα bytes για int;

884
00:41:29,250 --> 00:41:31,310
Πιθανώς 4, αν είναι
το ίδιο με το συνηθισμένο.

885
00:41:31,310 --> 00:41:33,270
Και τότε πόσα bytes
για το δείκτη;

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
Έτσι, αυτό το δοχείο ή ο κόμβος, είναι
πρόκειται να είναι ένα 8-byte δομή.

888
00:41:37,940 --> 00:41:41,760
Ω, και αυτό είναι μια ευτυχής σύμπτωση το γεγονός ότι
παρουσιάσαμε ακριβώς αυτή την ιδέα της

889
00:41:41,760 --> 00:41:44,400
ένα struct ή μια δομή C.

890
00:41:44,400 --> 00:41:48,890
>> Γι 'αυτό και ισχυρίζονται ότι θέλω να πάρω ένα βήμα
προς αυτή την πιο εξελιγμένη

891
00:41:48,890 --> 00:41:52,560
εφαρμογή του καταλόγου των αριθμών, μια
συνδεδεμένη λίστα των αριθμών, πρέπει να κάνω μια

892
00:41:52,560 --> 00:41:56,920
λίγο περισσότερο τη σκέψη μπροστά και
δηλώνει όχι μόνο ένα int, αλλά ένα struct

893
00:41:56,920 --> 00:41:58,620
πως θα καλέσετε, συμβατικά
εδώ, ο κόμβος.

894
00:41:58,620 --> 00:42:01,630
Θα μπορούσαμε να το ονομάσουμε κάτι που θέλουμε, αλλά
κόμβος πρόκειται να είναι θεματικά σε μια παρτίδα

895
00:42:01,630 --> 00:42:03,560
από τα πράγματα να αρχίσουμε να εξετάζουμε τώρα.

896
00:42:03,560 --> 00:42:06,480
>> Στο εσωτερικό αυτού του κόμβου είναι ένα int n.

897
00:42:06,480 --> 00:42:09,350
Και τότε αυτό το συντακτικό, λίγο
παράξενο με την πρώτη ματιά -

898
00:42:09,350 --> 00:42:12,960
struct node * επόμενο.

899
00:42:12,960 --> 00:42:16,900
Λοιπόν, εικονογραφικά, τι είναι αυτό;

900
00:42:16,900 --> 00:42:21,000
Αυτό είναι το κάτω μισό της
το ορθογώνιο που είδαμε

901
00:42:21,000 --> 00:42:22,730
μόλις πριν από λίγο.

902
00:42:22,730 --> 00:42:27,600
>> Αλλά γιατί λέω struct node *
σε αντίθεση με μόνο κόμβο *;

903
00:42:27,600 --> 00:42:31,370
Διότι, αν η δείκτης δείχνει
σε έναν άλλο κόμβο, είναι ακριβώς το

904
00:42:31,370 --> 00:42:32,760
διεύθυνση ενός κόμβου.

905
00:42:32,760 --> 00:42:35,630
Αυτό είναι σύμφωνο με αυτό που έχουμε
συζήτησαν για δείκτες μέχρι σήμερα.

906
00:42:35,630 --> 00:42:39,690
Αλλά γιατί, αν ισχυρίζονται αυτή η δομή είναι
που ονομάζεται κόμβος, μπορώ να πω struct

907
00:42:39,690 --> 00:42:42,660
κόμβο εδώ μέσα;

908
00:42:42,660 --> 00:42:43,190
>> Ακριβώς.

909
00:42:43,190 --> 00:42:46,490
Είναι ένα είδος ηλίθια πραγματικότητα C.
Το typedef, να το πω έτσι, δεν έχει

910
00:42:46,490 --> 00:42:47,220
συμβεί ακόμα.

911
00:42:47,220 --> 00:42:48,510
C είναι εξαιρετικά κυριολεκτική.

912
00:42:48,510 --> 00:42:51,050
Διαβάζει κορυφή τον κωδικό σας
κάτω, αριστερά προς τα δεξιά.

913
00:42:51,050 --> 00:42:54,930
Και μέχρι να χτυπήσει αυτό το ερωτηματικό σχετικά με την
κατώτατη γραμμή, μάντεψε τι όχι

914
00:42:54,930 --> 00:42:57,590
υφίσταται ως τύπο δεδομένων;

915
00:42:57,590 --> 00:42:59,060
Κόμβου, παραθέτω κόμβο unquote.

916
00:42:59,060 --> 00:43:03,050
>> Όμως, λόγω της πιο φλύαρη
δήλωση που έκανα στην πρώτη γραμμή -

917
00:43:03,050 --> 00:43:05,340
typedef struct node -

918
00:43:05,340 --> 00:43:08,790
γιατί αυτό ήρθε πρώτη, πριν από την
άγκιστρα, που είναι περίπου όπως

919
00:43:08,790 --> 00:43:11,800
προ-εκπαίδευση Clang αυτό,
Ξέρεις κάτι, να μου δώσει μια struct

920
00:43:11,800 --> 00:43:13,570
ονομάζεται κόμβος struct.

921
00:43:13,570 --> 00:43:16,270
Ειλικρινά, δεν μου αρέσει καλώντας τα πράγματα
struct node, struct node όλα

922
00:43:16,270 --> 00:43:17,090
σε όλο τον κωδικό μου.

923
00:43:17,090 --> 00:43:20,660
Αλλά εγώ θα το χρησιμοποιήσετε μόνο μία φορά, μόνο στο εσωτερικό,
έτσι ώστε να μπορεί αποτελεσματικά να

924
00:43:20,660 --> 00:43:25,010
να δημιουργήσει ένα είδος κυκλικής αναφοράς, δεν
ένα δείκτη για τον εαυτό μου per se, αλλά ένα

925
00:43:25,010 --> 00:43:29,400
δείκτη σε άλλη
ιδίου είδους.

926
00:43:29,400 --> 00:43:32,330
>> Έτσι, αποδεικνύεται ότι σε μια δομή δεδομένων
όπως αυτό, υπάρχει μερικές

927
00:43:32,330 --> 00:43:34,470
ενέργειες που θα μπορούσαν να
που μας ενδιαφέρουν.

928
00:43:34,470 --> 00:43:37,460
Θα μπορούσαμε να θέλετε να εισαγάγετε
σε μια λίστα σαν αυτή.

929
00:43:37,460 --> 00:43:39,850
Θα μπορούσαμε να θέλετε να διαγράψετε
από μια λίστα σαν αυτή.

930
00:43:39,850 --> 00:43:43,490
Πρέπει να θέλετε να αναζητήσετε τη λίστα για ένα
αξία, ή, γενικότερα, τραβέρσα.

931
00:43:43,490 --> 00:43:46,410
Και ώθησης είναι μόνο ένα φανταχτερό τρόπο
λέγοντας ξεκίνημα στα αριστερά και να μετακινήσετε όλα

932
00:43:46,410 --> 00:43:47,650
το δρόμο προς τα δεξιά.

933
00:43:47,650 --> 00:43:52,640
>> Και ειδοποίηση, ακόμα και με αυτό το ελαφρώς πιο
εκλεπτυσμένη δομή δεδομένων, αφήστε

934
00:43:52,640 --> 00:43:56,510
Θέλω να προτείνω ότι μπορούμε να δανειστεί κάποια από
οι ιδέες των τελευταίων δύο εβδομάδων και

935
00:43:56,510 --> 00:43:58,410
εφαρμόσουν μια λειτουργία που ονομάζεται
αναζήτηση σαν αυτό.

936
00:43:58,410 --> 00:44:01,360
Είναι πρόκειται να επιστρέψει αλήθεια ή
ψευδείς, αναφέροντας, ναι ή

937
00:44:01,360 --> 00:44:03,390
όχι, το η είναι στη λίστα.

938
00:44:03,390 --> 00:44:05,960
Το δεύτερο επιχείρημα του είναι ένας δείκτης
στην ίδια τη λίστα, έτσι, ένα

939
00:44:05,960 --> 00:44:07,920
δείκτη σε έναν κόμβο.

940
00:44:07,920 --> 00:44:10,350
>> Όλα Πάω στη συνέχεια να κάνετε είναι να κηρύξει
μια προσωρινή μεταβλητή.

941
00:44:10,350 --> 00:44:12,730
Θα ονομάσουμε ptr κατά συνθήκη,
για το δείκτη.

942
00:44:12,730 --> 00:44:15,220
Και εγώ αναθέσετε ίσο με το
αρχή της λίστας.

943
00:44:15,220 --> 00:44:16,680
>> Και παρατηρήσετε τώρα τον βρόχο while.

944
00:44:16,680 --> 00:44:20,640
Εφ 'όσον δείκτης δεν είναι ίση
σε null, Πάω να ελέγξει.

945
00:44:20,640 --> 00:44:24,520
Είναι το βέλος του δείκτη n ίσο με
το n που ψηφίστηκε;

946
00:44:24,520 --> 00:44:26,410
Και περιμένετε ένα λεπτό - νέα
κομμάτι της σύνταξης.

947
00:44:26,410 --> 00:44:29,324
Τι είναι το βέλος ξαφνικά;

948
00:44:29,324 --> 00:44:30,574
Ναι;

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> Ακριβώς.

951
00:44:34,810 --> 00:44:38,860
Έτσι, ενώ πριν από λίγα λεπτά, χρησιμοποιήσαμε
ο συμβολισμός dot να αποκτήσετε πρόσβαση κάτι

952
00:44:38,860 --> 00:44:43,080
μέσα από ένα το struct, όταν η μεταβλητή
έχετε δεν είναι η struct

953
00:44:43,080 --> 00:44:47,420
η ίδια, αλλά ένας δείκτης σε μια struct,
Ευτυχώς, ένα κομμάτι της σύνταξης που

954
00:44:47,420 --> 00:44:48,620
Τέλος καθιστά διαίσθηση.

955
00:44:48,620 --> 00:44:52,360
Το βέλος σημαίνει να ακολουθήσει το δείκτη,
σαν βέλη μας συνήθως σημαίνει

956
00:44:52,360 --> 00:44:56,570
εικαστικά, και να πάει σε
δεδομένα στο εσωτερικό πεδίο.

957
00:44:56,570 --> 00:44:59,700
Έτσι, το βέλος είναι το ίδιο πράγμα με τελεία, αλλά
μπορείτε να το χρησιμοποιήσετε όταν έχετε ένα δείκτη.

958
00:44:59,700 --> 00:45:05,270
>> Έτσι απλά για να ανακεφαλαιώσουμε, στη συνέχεια, αν το πεδίο n
εσωτερικό του struct που ονομάζεται δείκτης

959
00:45:05,270 --> 00:45:07,760
ισούται ισούται με n, επιστρέφουν αλήθεια.

960
00:45:07,760 --> 00:45:11,970
Διαφορετικά, αυτή η γραμμή εδώ - δείκτη
ισούται με δείκτη επόμενο.

961
00:45:11,970 --> 00:45:17,540
Έτσι τι είναι αυτό που κάνει, ανακοίνωση, είναι αν
είμαι σήμερα δείχνοντας το struct

962
00:45:17,540 --> 00:45:21,430
που περιέχει 9, και 9 δεν είναι ο αριθμός
Ψάχνω για - ας υποθέσουμε ότι ψάχνω

963
00:45:21,430 --> 00:45:22,830
για το n ισούται με 50 -

964
00:45:22,830 --> 00:45:25,930
Πάω να ενημερώσετε προσωρινή δείκτη μου
όχι να επισημάνω σε αυτόν τον κόμβο

965
00:45:25,930 --> 00:45:31,190
πια, αλλά δείκτη βέλος δίπλα, η οποία
πρόκειται να με βάλει εδώ.

966
00:45:31,190 --> 00:45:34,270
>> Τώρα, συνειδητοποίησα ότι είναι ένας ανεμοστρόβιλος
εισαγωγή.

967
00:45:34,270 --> 00:45:37,380
Την Τετάρτη, θα κάνουμε πραγματικότητα αυτό
με μερικούς ανθρώπους και με κάποια πιο

968
00:45:37,380 --> 00:45:38,900
κώδικα με βραδύτερο ρυθμό.

969
00:45:38,900 --> 00:45:42,990
Αλλά συνειδητοποιούν, κάνουμε τώρα τα δεδομένα μας
δομές πιο περίπλοκη, έτσι ώστε μας

970
00:45:42,990 --> 00:45:45,780
αλγόριθμοι μπορούν να πάρουν πιο αποτελεσματική, η οποία
πρόκειται να είναι προϋπόθεση για

971
00:45:45,780 --> 00:45:50,500
PSET έξι, όταν φορτώνουμε σε, και πάλι, τα
150.000 λέξεις, αλλά πρέπει να το πράξουν

972
00:45:50,500 --> 00:45:55,650
αποτελεσματικά, και στην ιδανική περίπτωση, να δημιουργηθεί ένα
πρόγραμμα που τρέχει για τους χρήστες μας, δεν

973
00:45:55,650 --> 00:46:00,460
γραμμική, όχι σε n τετράγωνο, αλλά
σταθερό χρόνο, στην ιδανική.

974
00:46:00,460 --> 00:46:02,300
>> Θα σας δούμε την Τετάρτη.

975
00:46:02,300 --> 00:46:07,240
>> ΟΜΙΛΗΤΗΣ: Στην επόμενη CS50, David
ξεχνά βασική περίπτωση του.

976
00:46:07,240 --> 00:46:12,770
>> DAVID MALAN: Και αυτό είναι το πώς μπορείτε να στείλετε
μηνύματα κειμένου με C. Ποια η -

977
00:46:12,770 --> 00:46:14,020
>> [ΔΙΑΦΟΡΑ μήνυμα κειμένου
ΚΟΙΝΟΠΟΙΗΣΗ SOUNDS]

978
00:46:14,020 --> 00:46:19,734