1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [ΕΒΔΟΜΑΔΑ 5]

2
00:00:02,760 --> 00:00:04,760
[David J. Malan, Πανεπιστήμιο Χάρβαρντ]

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

4
00:00:11,990 --> 00:00:17,780
[Γυναίκα] Λέει ψέματα? Για το τι, δεν ξέρω.

5
00:00:17,780 --> 00:00:20,300
[Άνθρωπος] Λοιπόν, τι ξέρουμε;

6
00:00:20,300 --> 00:00:24,120
[Γυναίκα] Αυτό στις 9:15, Ray Santoya ήταν στο ΑΤΜ.

7
00:00:24,120 --> 00:00:27,420
[Άνθρωπος] Έτσι, το ερώτημα είναι, τι κάνει αυτός στις 9:16;

8
00:00:27,420 --> 00:00:29,980
[Γυναίκα] Σκοποβολή το 9 mm σε κάτι.

9
00:00:29,980 --> 00:00:31,900
Ίσως είδε τον ελεύθερο σκοπευτή.

10
00:00:31,900 --> 00:00:34,000
[Άνθρωπος] Ή δούλευε μαζί του.

11
00:00:34,000 --> 00:00:36,330
[Γυναίκα] Περιμένετε. Επιστροφή στο προηγούμενο.

12
00:00:36,330 --> 00:00:38,330
[Άνθρωπος] Τι βλέπεις;

13
00:00:38,330 --> 00:00:44,520
[♫ ♫ suspenseful μουσική]

14
00:00:44,520 --> 00:00:48,320
[Γυναίκα] Φέρτε το πρόσωπό του επάνω. Πλήρης οθόνη.

15
00:00:48,320 --> 00:00:51,230
[Άνθρωπος] γυαλιά του. >> Υπάρχει μια αντανάκλαση.

16
00:00:51,230 --> 00:01:00,810
[♫ ♫ suspenseful μουσική]

17
00:01:00,810 --> 00:01:03,580
[Άνθρωπος] Αυτό είναι ομάδα μπέιζμπολ του Nuevita του. Αυτό είναι το λογότυπο τους.

18
00:01:03,580 --> 00:01:07,790
[Γυναίκα] Και μιλάει σε όποιον φοράει μπουφάν αυτό.

19
00:01:07,790 --> 00:01:13,730
>> [David Malan] Έτσι, αυτό είναι CS50 εβδομάδα 5, και σήμερα έχουμε καταστρέψει ένα κομμάτι της τηλεόρασης και του κινηματογράφου για σας.

20
00:01:13,730 --> 00:01:16,170
Έτσι, κάθε φορά που βλέπετε μια εκπομπή όπως αυτή εδώ,

21
00:01:16,170 --> 00:01:19,910
και οι μπάτσοι λένε "Μπορείς να καθαρίσει ότι μέχρι;" ή "Ενίσχυση"

22
00:01:19,910 --> 00:01:21,900
δεν υπάρχει ενίσχυση στον πραγματικό κόσμο.

23
00:01:21,900 --> 00:01:25,220
Στην πραγματικότητα, αυτό που πραγματικά να είναι λίγο κάτι σαν αυτό.

24
00:01:25,220 --> 00:01:27,570
Έχω τράβηξε μία από τις φωτογραφίες από το προσωπικό της σελίδας.

25
00:01:27,570 --> 00:01:30,980
Πρόκειται για ένα πρόγραμμα που ονομάζεται Photoshop. Αυτό είναι 1 από 2 Bowdens,

26
00:01:30,980 --> 00:01:36,300
1 από 3 Bowdens πραγματικότητα, σήμερα, επειδή έχουμε κα Bowden εδώ, καθώς, με τον Rob και Παύλου.

27
00:01:36,300 --> 00:01:41,950
Αλλά εδώ είναι Rob στην οθόνη, και αν κάνετε ζουμ σε αυτή λάμψη που πάντα είχε στο μάτι του,

28
00:01:41,950 --> 00:01:47,600
αυτό που πραγματικά βλέπουμε είναι ότι αυτό που βλέπετε είναι αυτό που παίρνετε.

29
00:01:47,600 --> 00:01:51,690
Αυτή είναι η "βελτιωμένη", ώστε "CSI" έχετε λίγο λάθος.

30
00:01:51,690 --> 00:01:55,190
Υπάρχει ένα άλλο clip, αν μπορούμε να τα βάζουμε με "CSI" και λίγο περισσότερο.

31
00:01:55,190 --> 00:01:58,500
Αυτό είναι ένα ωραίο φράση πλέον να λέμε, αν θέλετε να

32
00:01:58,500 --> 00:02:10,280
καλή τεχνική με τους φίλους σας όταν, πραγματικά, λέτε απολύτως τίποτα.

33
00:02:10,280 --> 00:02:12,970
>> [Άνθρωπος] Για τις εβδομάδες έχω τη διερεύνηση των δολοφονιών Cabby Killer

34
00:02:12,970 --> 00:02:15,360
με μια ορισμένη γοητεία νοσηρή.

35
00:02:15,360 --> 00:02:17,160
[Γυναίκα # 1] Αυτό είναι σε πραγματικό χρόνο.

36
00:02:17,160 --> 00:02:22,930
[Γυναίκα # 2] Θα δημιουργήσει μια διεπαφή GUI χρήση της Visual Basic, να δω αν μπορώ να παρακολουθείτε μια διεύθυνση IP.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] Έτσι ήχου εκτός συγχρονισμού μέρος, δημιουργώντας ένα γραφικό περιβάλλον διεπαφής με τη χρήση της Visual Basic

38
00:02:29,570 --> 00:02:31,820
για να παρακολουθείτε μια διεύθυνση IP είναι πλήρης ανοησία.

39
00:02:31,820 --> 00:02:33,840
Αυτές τις μέρες δεν θα χρησιμοποιήσετε το Visual Basic,

40
00:02:33,840 --> 00:02:38,920
δεν υπάρχει καμία ανάγκη για ένα GUI, και τη διεύθυνση IP ήταν τεχνικά ακριβής όρος.

41
00:02:38,920 --> 00:02:41,730
Έτσι, κρατήστε ένα μάτι έξω για αυτά, και ένα από τα αγαπημένα μου:

42
00:02:41,730 --> 00:02:45,070
Αυτό και μόνο είναι λίγο πιο απόκρυφες, γιατί θα πρέπει να γνωρίζουν μια άλλη γλώσσα.

43
00:02:45,070 --> 00:02:47,860
Υπάρχει μια γλώσσα που ονομάζεται Objective-C, το οποίο είναι ένα υπερσύνολο της C.

44
00:02:47,860 --> 00:02:51,960
Πράγμα που σημαίνει ότι το C συν κάποια επιπλέον χαρακτηριστικά, μεταξύ των οποίων και αντικειμενοστραφή προγραμματισμό.

45
00:02:51,960 --> 00:02:55,070
Και αυτή είναι η γλώσσα που η Apple έχει διαδοθεί για τον προγραμματισμό iOS.

46
00:02:55,070 --> 00:02:58,760
Και έτσι εδώ είναι ένα απόσπασμα από ένα διαφορετικό show συνολικά, από το "Numbers"

47
00:02:58,760 --> 00:03:02,450
ότι αν πραγματικά εξετάσουμε προσεκτικά την παύση TiVo και σας την κατάλληλη στιγμή,

48
00:03:02,450 --> 00:03:07,700
θα δείτε ότι αυτό που κοιτάτε δεν είναι αρκετά αυτό που περιγράφεται.

49
00:03:07,700 --> 00:03:11,170
Και επιτρέψτε μου να δοκιμάσετε μια διαφορετική υποδοχή ήχου εδώ και να δούμε αν δεν μπορούμε να

50
00:03:11,170 --> 00:03:13,780
κρατήσει τον ήχο σε συγχρονισμό αυτή τη φορά.

51
00:03:13,780 --> 00:03:20,530
Σας δίνω "Αριθμοί".

52
00:03:20,530 --> 00:03:23,240
>> [Man # 1] Είναι ένα 32-bit διεύθυνση IPv4.

53
00:03:23,240 --> 00:03:38,930
[Man # 2] IP, αυτό είναι το Διαδίκτυο. >> Ιδιωτικό δίκτυο. Είναι το ιδιόκτητο δίκτυο της Ανίτας.

54
00:03:38,930 --> 00:03:43,810
[Malan] Εντάξει. Αυτό είναι Objective-C, και είναι για το πρόγραμμα χρωματισμό κάποιου παιδιού,

55
00:03:43,810 --> 00:03:51,140
όπως ίσως μπορείτε να συναγάγει από το όνομα της μεταβλητής εκεί.

56
00:03:51,140 --> 00:03:54,410
Έτσι ώστε, στη συνέχεια, ήταν «Αριθμοί». Έτσι, σήμερα και αυτή την εβδομάδα έχουμε εισαγάγει

57
00:03:54,410 --> 00:03:57,740
ένα μικρό κομμάτι του κόσμου της εγκληματολογίας και το πλαίσιο των προβλημάτων αυτών.

58
00:03:57,740 --> 00:04:00,590
Σήμερα θα είναι μια συνοπτική διάλεξη, επειδή υπάρχει μια ειδική εκδήλωση εδώ

59
00:04:00,590 --> 00:04:05,530
αργότερα, οπότε θα ρίξουμε μια ματιά, και να δώσουμε έμφαση τόσο οι μαθητές όσο και οι γονείς σήμερα

60
00:04:05,530 --> 00:04:07,420
με μερικά από τα πράγματα που είναι στον ορίζοντα.

61
00:04:07,420 --> 00:04:12,240
Ανάμεσά τους, από τη Δευτέρα, θα έχετε μερικές ακόμα συμμαθητές.

62
00:04:12,240 --> 00:04:16,050
EDX, του Χάρβαρντ και MITs νέα σύνδεση πρωτοβουλία για ανοικτές εκπαιδευτικού

63
00:04:16,050 --> 00:04:19,120
και περισσότερο, ξεκινά στην πανεπιστημιούπολη του Χάρβαρντ τη Δευτέρα.

64
00:04:19,120 --> 00:04:21,490
Που σημαίνει ότι έρχονται Δευτέρα θα έχετε - από την τελευταία καταμέτρηση,

65
00:04:21,490 --> 00:04:26,210
86.000 επιπλέον συμμαθητές θα ακολουθεί μαζί με διαλέξεις του CS50

66
00:04:26,210 --> 00:04:29,170
και τμήματα και walkthroughs και σύνολα πρόβλημα.

67
00:04:29,170 --> 00:04:32,350
Και στο πλαίσιο αυτό, θα γίνουν μέλη της εναρκτήριας κατηγορίας

68
00:04:32,350 --> 00:04:35,090
CS50 και τώρα CS50x.

69
00:04:35,090 --> 00:04:39,310
>> Στο πλαίσιο αυτό, τώρα, να συνειδητοποιήσουν ότι θα υπάρξουν κάποιες upsides, καθώς και.

70
00:04:39,310 --> 00:04:43,790
Για να ετοιμαστείτε για αυτό, για τον τεράστιο αριθμό των φοιτητών,

71
00:04:43,790 --> 00:04:47,180
αρκεί να πούμε ότι ακόμα κι αν έχουμε 108 TFs και ΑΠ,

72
00:04:47,180 --> 00:04:50,790
δεν είναι αρκετά η καλύτερη αναλογία φοιτητών / καθηγητών τη στιγμή που θα χτυπήσει 80.000 άλλους μαθητές.

73
00:04:50,790 --> 00:04:52,850
Γι 'αυτό και δεν πρόκειται να ταξινόμησης τόσα πολλά θέτει πρόβλημα χειροκίνητα.

74
00:04:52,850 --> 00:04:55,920
Έτσι εισήγαγε αυτή την εβδομάδα στο σύνολο πρόβλημα θα είναι CS50 Έλεγχος,

75
00:04:55,920 --> 00:04:58,450
η οποία πρόκειται να είναι ένα βοηθητικό πρόγραμμα γραμμής εντολών εντός της συσκευής

76
00:04:58,450 --> 00:05:01,200
ότι θα πάρετε τη στιγμή που θα ενημερώσετε αργότερα αυτό το Σαββατοκύριακο,

77
00:05:01,200 --> 00:05:03,200
και θα είστε σε θέση να εκτελέσετε μια εντολή, ελέγξτε 50,

78
00:05:03,200 --> 00:05:06,500
με δική PSET σας, και θα πάρετε κάποιες πληροφορίες για το αν το πρόγραμμά σας είναι

79
00:05:06,500 --> 00:05:11,160
σωστό ή λάθος, σύμφωνα με διάφορες προδιαγραφές σχεδιασμού που έχουμε παράσχει.

80
00:05:11,160 --> 00:05:13,580
Έτσι, περισσότερα για αυτό και οι προδιαγραφές σετ πρόβλημα και

81
00:05:13,580 --> 00:05:17,240
CS50x οι συμμαθητές θα πρέπει να χρησιμοποιούν αυτό ως καλά.

82
00:05:17,240 --> 00:05:19,230
>> Έτσι, το πρόβλημα σύνολο 4 είναι όλα σχετικά με εγκληματολογίας.

83
00:05:19,230 --> 00:05:21,940
Και αυτό το κομμάτι εμπνεύστηκε από κάποια πραγματική ζωή τα πράγματα,

84
00:05:21,940 --> 00:05:24,620
σύμφωνα με την οποία όταν ήμουν μεταπτυχιακή φοιτήτρια, εγώ εγκλεισθούν για λίγο με

85
00:05:24,620 --> 00:05:28,650
Επαρχιακό Γραφείο του Middlesex County του πληρεξούσιου κάνει εγκληματολογικής εργασίας

86
00:05:28,650 --> 00:05:31,650
με επικεφαλής ερευνητής ιατροδικαστική τους, και ό, τι αυτό ανήλθε σε

87
00:05:31,650 --> 00:05:35,260
είναι, νομίζω ότι ανέφερα το παρελθόν ολίγων εβδομάδων, είναι η μάζα της αστυνομίας κράτος ή άλλοι

88
00:05:35,260 --> 00:05:39,000
θα έρθει, θα πέσει από τα πράγματα όπως σκληρούς δίσκους και CD και δισκέτες

89
00:05:39,000 --> 00:05:42,340
και τα παρόμοια, και στη συνέχεια, ο στόχος του γραφείου εγκληματολογίας ήταν να εξακριβωθεί αν

90
00:05:42,340 --> 00:05:44,600
υπήρχε ή δεν ήταν απόδειξη κάποιου είδους.

91
00:05:44,600 --> 00:05:48,010
Αυτή ήταν η Μονάδα Ειδικών Ερευνών, γι 'αυτό ήταν υπαλληλικό έγκλημα,

92
00:05:48,010 --> 00:05:52,350
ήταν πιο ανησυχητικό είδος των εγκλημάτων,

93
00:05:52,350 --> 00:05:55,990
κάτι που περιλαμβάνει κάποιο είδος των ψηφιακών μέσων? αποδεικνύεται ότι δεν είναι ότι πολλοί άνθρωποι

94
00:05:55,990 --> 00:05:59,370
γράψετε ένα e-mail λέγοντας ότι "το έκανα."

95
00:05:59,370 --> 00:06:03,290
Έτσι, αρκετά συχνά αυτές οι αναζητήσεις εγκληματολογίας δεν εμφανίζονται και τόσο πολύ τα φρούτα,

96
00:06:03,290 --> 00:06:05,850
αλλά μερικές φορές οι άνθρωποι θα έγραφε τέτοια emails.

97
00:06:05,850 --> 00:06:08,490
Έτσι, μερικές φορές οι προσπάθειες ανταμείβονται.

98
00:06:08,490 --> 00:06:14,420
>> Αλλά για να οδηγήσει μέχρι αυτό το ιατροδικαστική PSET, εμείς θα πρέπει να εισάγει στην PSET 4 α κομμάτι των γραφικών.

99
00:06:14,420 --> 00:06:18,260
Έτσι, θα είναι κατά πάσα πιθανότητα αυτά τα πράγματα για χορηγημένος, JPEG, GIF και όπως αυτές τις μέρες,

100
00:06:18,260 --> 00:06:21,640
αλλά αν πραγματικά το σκέφτομαι, μια εικόνα, μοιάζει πολύ με το πρόσωπο του Rob,

101
00:06:21,640 --> 00:06:24,430
θα μπορούσε να απεικονιστεί ως μια ακολουθία των κουκκίδων ή εικονοστοιχεία.

102
00:06:24,430 --> 00:06:26,680
Τώρα, στην περίπτωση του προσώπου του Rob, υπάρχει κάθε λογής χρώματα,

103
00:06:26,680 --> 00:06:29,940
και αρχίσαμε να βλέπουμε τις μεμονωμένες κουκίδες, otherwide γνωστό ως pixel,

104
00:06:29,940 --> 00:06:31,610
τη στιγμή που θα αρχίσει να μεγεθύνετε

105
00:06:31,610 --> 00:06:35,590
Αλλά αν έχουμε απλοποιήσει τον κόσμο λίγο, και να πω ότι αυτό εδώ είναι Rob

106
00:06:35,590 --> 00:06:40,560
σε μαύρο και άσπρο, και, για να αντιπροσωπεύουν μαύρο και άσπρο μπορούμε να χρησιμοποιήσουμε μόνο δυαδικό.

107
00:06:40,560 --> 00:06:44,960
Και αν θα πάμε να χρησιμοποιούν δυαδικό, 1 ή 0, μπορούμε να εκφράσουμε την ίδια εικόνα

108
00:06:44,960 --> 00:06:51,970
χαμογελαστό πρόσωπο του Rob με αυτό το μοτίβο των bits: 11000011 αντιπροσωπεύει

109
00:06:51,970 --> 00:06:55,160
άσπρο, λευκό, μαύρο, μαύρο, μαύρο, μαύρο, λευκό λευκό.

110
00:06:55,160 --> 00:06:59,290
Και γι 'αυτό δεν είναι ένα τεράστιο άλμα, στη συνέχεια, να αρχίσουμε να μιλάμε για πολύχρωμες φωτογραφίες.

111
00:06:59,290 --> 00:07:01,920
Τα πράγματα που θα δείτε στο Facebook ή να με μια ψηφιακή φωτογραφική μηχανή,

112
00:07:01,920 --> 00:07:04,730
αλλά, σίγουρα, όταν πρόκειται για τα χρώματα, θα πρέπει να έχετε περισσότερα bits.

113
00:07:04,730 --> 00:07:08,470
Και αρκετά κοινό στον κόσμο των φωτογραφιών είναι να χρησιμοποιήσετε δεν 1-bit χρώματος,

114
00:07:08,470 --> 00:07:12,730
όπως αυτό προτείνει, αλλά 24-bit χρώμα, όπου μπορείτε να πάρετε πραγματικά εκατομμύρια χρώματα.

115
00:07:12,730 --> 00:07:15,430
Έτσι, όπως στην περίπτωση όταν μεγεθύνεται στο μάτι του Rob,

116
00:07:15,430 --> 00:07:19,270
που ήταν οποιοσδήποτε αριθμός εκατομμυρίων διαφορετικών δυνατοτήτων πολύχρωμα.

117
00:07:19,270 --> 00:07:22,260
>> Γι 'αυτό και θα εισαγάγει αυτό το σύνολο το πρόβλημα 4, καθώς και στην περιδιάβαση,

118
00:07:22,260 --> 00:07:27,050
η οποία θα είναι σήμερα στις 3:30 αντί της συνήθους 2:30 λόγω διάλεξη της Παρασκευής εδώ.

119
00:07:27,050 --> 00:07:29,930
Αλλά το βίντεο θα είναι σε απευθείας σύνδεση, ως συνήθως, αύριο.

120
00:07:29,930 --> 00:07:31,880
Θα σας παρουσιάσουμε επίσης σε άλλη μορφή αρχείου.

121
00:07:31,880 --> 00:07:34,150
Έτσι, αυτό σήμαινε σκόπιμα να δούμε τον εκφοβισμό κατά την πρώτη,

122
00:07:34,150 --> 00:07:38,980
αλλά αυτό είναι μόνο μερικά έγγραφα για struct C.

123
00:07:38,980 --> 00:07:42,280
Φαίνεται ότι η Microsoft, πριν από χρόνια, βοήθησε να διαδώσει αυτή τη μορφή,

124
00:07:42,280 --> 00:07:46,630
ονομάζεται η μορφή αρχείου bitmap, BMP, και αυτό ήταν ένα σούπερ-απλή,

125
00:07:46,630 --> 00:07:50,390
πολύχρωμα γραφικά μορφή αρχείου που χρησιμοποιείται εδώ και αρκετό καιρό

126
00:07:50,390 --> 00:07:53,640
και μερικές φορές ακόμα για ταπετσαρίες για επιτραπέζιους υπολογιστές.

127
00:07:53,640 --> 00:07:57,410
Αν νομίζετε ότι πίσω στα Windows XP και τους λόφους και τον μπλε ουρανό,

128
00:07:57,410 --> 00:08:00,660
που ήταν συνήθως μια BMP, ή bitmap εικόνα, και bitmaps

129
00:08:00,660 --> 00:08:03,340
είναι διασκέδαση για μας, επειδή έχουν λίγο περισσότερο την πολυπλοκότητα.

130
00:08:03,340 --> 00:08:05,640
Δεν είναι τόσο απλό όσο αυτό το πλέγμα των 0 και 1 του?

131
00:08:05,640 --> 00:08:10,680
Αντ 'αυτού, έχετε τα πράγματα όπως μια κεφαλίδα στην αρχή ενός αρχείου.

132
00:08:10,680 --> 00:08:15,520
Έτσι με άλλα λόγια, μέσα σε ένα αρχείο. Bmp είναι ένα σωρό του 0 και 1,

133
00:08:15,520 --> 00:08:18,070
αλλά υπάρχει κάποια επιπλέον 0 και 1 στην εκεί.

134
00:08:18,070 --> 00:08:21,450
Και αποδεικνύεται ότι αυτό που έχουμε κατά πάσα πιθανότητα θεωρείται δεδομένη για τα επόμενα χρόνια,

135
00:08:21,450 --> 00:08:27,040
μορφές αρχείων όπως. doc ή. xls ή. mp3 ή. mp4,

136
00:08:27,040 --> 00:08:29,910
ανεξάρτητα από τις μορφές αρχείων που είστε εξοικειωμένοι με.

137
00:08:29,910 --> 00:08:31,900
Λοιπόν, τι σημαίνει αυτό ακόμα να είναι μια μορφή αρχείου;

138
00:08:31,900 --> 00:08:35,740
Διότι στο τέλος της ημέρας, όλα αυτά τα αρχεία που χρησιμοποιούμε έχουν μόνο 0 και του 1

139
00:08:35,740 --> 00:08:39,950
και ίσως εκείνους 0 και το 1 αντιπροσωπεύουν α, β, γ, μέσω ASCII ή τα παρόμοια,

140
00:08:39,950 --> 00:08:42,030
αλλά μέχρι το τέλος της ημέρας, είναι ακριβώς το 0 και 1.

141
00:08:42,030 --> 00:08:45,300
>> Έτσι, οι άνθρωποι απλώς περιστασιακά αποφασίσει να εφεύρει μια νέα μορφή αρχείου

142
00:08:45,300 --> 00:08:49,420
όπου τυποποίηση τι σχέδια των bits θα σημαίνει πραγματικά.

143
00:08:49,420 --> 00:08:52,790
Και σε αυτή την περίπτωση εδώ, οι λαοί που σχεδίασε το bitmap μορφή αρχείου

144
00:08:52,790 --> 00:08:58,260
είπε ότι στο πρώτο byte σε ένα αρχείο bitmap, όπως υποδηλώνεται από offset 0, εκεί,

145
00:08:58,260 --> 00:09:02,320
υπάρχει μετάβαση να είναι κάποια μυστική ονομασία μεταβλητή που ονομάζεται bfType,

146
00:09:02,320 --> 00:09:06,510
η οποία στέκεται μόνο για τον τύπο αρχείου bitmap? τι είδους αρχείο bitmap αυτό είναι.

147
00:09:06,510 --> 00:09:10,780
Μπορείτε να συμπεράνουμε, ίσως, από τη δεύτερη γραμμή που αντισταθμίζεται 2, αριθμός byte 2,

148
00:09:10,780 --> 00:09:15,980
έχει ένα σχέδιο του 0 και του 1 που αντιπροσωπεύει ό, τι;

149
00:09:15,980 --> 00:09:18,320
Το μέγεθος του κάτι, και συνεχίζει από εκεί.

150
00:09:18,320 --> 00:09:20,660
Έτσι, στο σύνολο πρόβλημα 4, θα πρέπει να περάσει μέσα από κάποια από αυτά τα πράγματα.

151
00:09:20,660 --> 00:09:24,480
>> Εμείς δεν θα καταλήξουν να νοιάζονται για όλα αυτά, αλλά παρατηρήσετε ότι αρχίζει να παίρνει ενδιαφέρον

152
00:09:24,480 --> 00:09:30,780
γύρω από τη γραμμή ή byte 54, rgbtBlue, πράσινο και κόκκινο.

153
00:09:30,780 --> 00:09:35,280
Εάν έχετε ακούσει ποτέ το ακρωνύμιο RGB, κόκκινο πράσινο μπλε, αυτό είναι μια αναφορά σε αυτό.

154
00:09:35,280 --> 00:09:37,840
Επειδή αποδεικνύεται μπορείτε να ζωγραφίσει όλα τα χρώματα του ουράνιου τόξου

155
00:09:37,840 --> 00:09:41,580
με κάποιο συνδυασμό του κόκκινου και του μπλε και του πράσινου.

156
00:09:41,580 --> 00:09:46,560
Και, στην πραγματικότητα, οι γονείς στο δωμάτιο θα μπορούσε να υπενθυμίσουμε μερικά από τα πρώτα προβολείς.

157
00:09:46,560 --> 00:09:49,360
Αυτές τις μέρες, μπορείτε απλά να βλέπετε 1 λαμπερό φως που βγαίνει από ένα φακό.

158
00:09:49,360 --> 00:09:52,870
Αλλά πίσω στην ημέρα, θα έπρεπε το κόκκινο φακό, το μπλε φακό, και το πράσινο φακό

159
00:09:52,870 --> 00:09:56,620
και μαζί με στόχο την οθόνη και σχηματίζεται μια πολύχρωμη εικόνα.

160
00:09:56,620 --> 00:09:59,590
Και αρκετά συχνά γυμνάσια και λύκεια θα έχουν αυτές οι φακοί

161
00:09:59,590 --> 00:10:02,680
πάντα-έτσι-ελαφρώς στραβό, έτσι ώστε να ήταν το είδος του βλέποντας διπλά ή τριπλά εικόνες,

162
00:10:02,680 --> 00:10:07,500
αλλά αυτή ήταν η ιδέα. Είχες κόκκινο και πράσινο και μπλε φως ζωγραφική μια εικόνα.

163
00:10:07,500 --> 00:10:09,570
Και ότι η ίδια αρχή χρησιμοποιείται σε υπολογιστές.

164
00:10:09,570 --> 00:10:12,000
>> Έτσι, μεταξύ των προκλήσεων, τότε, για το πρόβλημα σας σετ 4

165
00:10:12,000 --> 00:10:16,080
πρόκειται να είναι μερικά πράγματα? το ένα είναι στην πραγματικότητα να αλλάξετε το μέγεθος μιας εικόνας.

166
00:10:16,080 --> 00:10:18,050
Για να ληφθεί σε ένα μοτίβο των 0 και 1, η

167
00:10:18,050 --> 00:10:22,840
καταλάβω ποια κομμάτια του 0 και του 1 αντιπροσωπεύουν ό, τι σε μια δομή όπως αυτή,

168
00:10:22,840 --> 00:10:26,800
και στη συνέχεια να καταλάβω πώς να αναπαράγουν τα pixels: τα κόκκινα, τα μπλε, τα πράσινα

169
00:10:26,800 --> 00:10:32,460
μέσα, έτσι ώστε, όταν μια εικόνα μοιάζει με αυτό αρχικά, θα μπορούσε να μοιάζει με αυτό αντί μετά από αυτό.

170
00:10:32,460 --> 00:10:35,590
Μεταξύ των άλλων προκλήσεων, επίσης, πρόκειται να είναι ότι θα πρέπει να παραδοθεί

171
00:10:35,590 --> 00:10:38,900
η ιατροδικαστική εικόνα ενός πραγματικού αρχείου από μια ψηφιακή φωτογραφική μηχανή

172
00:10:38,900 --> 00:10:42,410
και για την κάμερα, μια φορά κι έναν καιρό, ήταν ένα σωρό φωτογραφίες.

173
00:10:42,410 --> 00:10:47,030
Το πρόβλημα είναι, θα διαγραφούν κατά λάθος ή η εικόνα είχε καταστραφεί κατά κάποιο τρόπο.

174
00:10:47,030 --> 00:10:51,040
Κακά πράγματα συμβαίνουν με τις ψηφιακές φωτογραφικές μηχανές, και γι 'αυτό αντιγράφονται γρήγορα όλα του 0 και του 1

175
00:10:51,040 --> 00:10:55,410
μακριά από αυτή την κάρτα για σας, τους έσωσε όλα σε 1 μεγάλο αρχείο, και στη συνέχεια θα τα παραδώσουμε σε σας

176
00:10:55,410 --> 00:11:00,000
στο πρόβλημα που 4 έτσι ώστε να μπορείτε να γράψετε ένα πρόγραμμα σε C με την οποία να ανακτήσει

177
00:11:00,000 --> 00:11:02,660
όλα αυτά τα αρχεία JPEG, ιδανικά.

178
00:11:02,660 --> 00:11:06,280
Και αποδεικνύεται ότι τα αρχεία JPEG, ακόμα κι αν είναι κάπως από μια σύνθετη μορφή αρχείου,

179
00:11:06,280 --> 00:11:09,580
ότι είναι πολύ πιο περίπλοκη από ό, τι αυτό το χαμογελαστό πρόσωπο εδώ.

180
00:11:09,580 --> 00:11:14,320
Αποδεικνύεται ότι κάθε JPEG ξεκινά με τα ίδια πρότυπα του 0 και 1.

181
00:11:14,320 --> 00:11:18,820
Έτσι, χρησιμοποιώντας ένα βρόχο while ή ένα βρόχο for ή παρόμοια,

182
00:11:18,820 --> 00:11:22,350
μπορείτε να επαναλάβει πάνω από όλα το 0 και 1 σε αυτό το ιατροδικαστική εικόνα

183
00:11:22,350 --> 00:11:26,670
και κάθε φορά που θα δείτε το ειδικό σχέδιο που έχει προσδιοριστεί στο σύνολο προδιαγραφές του προβλήματος,

184
00:11:26,670 --> 00:11:29,770
μπορείτε να υποθέσετε, «Ω, εδώ είναι, με πολύ μεγάλη πιθανότητα,

185
00:11:29,770 --> 00:11:33,520
η αρχή μιας JPEG, και το συντομότερο θα βρείτε το ίδιο μοτίβο,

186
00:11:33,520 --> 00:11:36,050
κάποια αριθμός των bytes ή kilobytes ή megabytes αργότερα,

187
00:11:36,050 --> 00:11:40,550
μπορείτε να υποθέσετε, "Ooh! Εδώ είναι ένα δεύτερο JPEG, η φωτογραφία πήρα μετά την πρώτη.

188
00:11:40,550 --> 00:11:44,720
Επιτρέψτε μου να σταματήσετε να διαβάζετε αυτό το πρώτο αρχείο, αρχίστε να γράφετε το νέο. "

189
00:11:44,720 --> 00:11:49,980
Και η έξοδος του προγράμματος σας για PSET 4 πρόκειται να είναι όσο το 50 αρχεία JPEG.

190
00:11:49,980 --> 00:11:52,400
Και αν δεν είναι 50 αρχεία JPEG, έχετε ένα κομμάτι ενός βρόχου.

191
00:11:52,400 --> 00:11:55,580
Εάν έχετε έναν άπειρο αριθμό των αρχεία JPEG, έχετε ένα άπειρο βρόχο.

192
00:11:55,580 --> 00:11:58,280
Έτσι ώστε, επίσης, θα είναι μια αρκετά συνηθισμένη περίπτωση.

193
00:11:58,280 --> 00:12:00,280
Αυτό είναι ό, τι είναι στον ορίζοντα.

194
00:12:00,280 --> 00:12:03,740
>> Quiz 0, πίσω μας. Συνειδητοποιήστε, ανά e-mail μου, που πάντα υπάρχει λαοί

195
00:12:03,740 --> 00:12:06,820
που είναι τόσο ευτυχισμένος, είδος ουδέτερο, και λυπημένος κουίζ γύρω από το χρόνο 0.

196
00:12:06,820 --> 00:12:10,160
Και παρακαλώ να φτάσει σε μένα, οι TFs κεφάλι, Zamyla, τη δική σας TF

197
00:12:10,160 --> 00:12:14,120
ή μία από τις αρμόδιες αρχές ότι ξέρετε αν θα θέλατε να συζητήσουμε για το πώς πήγαν τα πράγματα.

198
00:12:14,120 --> 00:12:16,460
>> Έτσι για να εντυπωσιάσουν τους γονείς εδώ στην αίθουσα,

199
00:12:16,460 --> 00:12:23,990
ποια είναι η CS50 βιβλιοθήκη; Καλή δουλειά.

200
00:12:23,990 --> 00:12:32,280
Ποια είναι η CS50 βιβλιοθήκη; Ναι; [Απαντήσεις σπουδαστών, ακατάληπτο]

201
00:12:32,280 --> 00:12:35,730
>> Εντάξει, καλά. Έτσι είναι ένας έτοιμος σύνολο του κώδικα που εμείς, το προσωπικό, έγραψε,

202
00:12:35,730 --> 00:12:38,460
σας παρέχουμε, να παρέχουν ορισμένες κοινές λειτουργίες.

203
00:12:38,460 --> 00:12:42,290
Γεμίζουμε ήθελα να μου βρεις ένα string? Πάρτε μια int, όλες οι λειτουργίες που αναφέρονται εδώ.

204
00:12:42,290 --> 00:12:45,260
Ξεκινώντας τώρα, αρχίζουμε να πάρει πραγματικά αυτές τις ρόδες μακριά.

205
00:12:45,260 --> 00:12:48,230
Έτσι θα πάμε για να ξεκινήσει να πάρει μια «σειρά» από εσάς,

206
00:12:48,230 --> 00:12:52,790
η οποία, ανάκληση, ήταν απλά ένα συνώνυμο για το τι πραγματικά τύπο δεδομένων; char *.

207
00:12:52,790 --> 00:12:57,020
Έτσι, για τους γονείς, που ήταν κατά πάσα πιθανότητα - αυτό είναι καλό, έτσι char * θα αρχίσουμε να βλέπουμε

208
00:12:57,020 --> 00:13:00,810
στην οθόνη όλες οι περισσότερο ως αφαιρούμε "string" από το λεξιλόγιό μας,

209
00:13:00,810 --> 00:13:02,760
τουλάχιστον όταν πρόκειται για την πραγματικότητα γράφοντας κώδικα.

210
00:13:02,760 --> 00:13:06,240
Ομοίως, θα σταματήσει να χρησιμοποιεί κάποια από αυτές τις λειτουργίες, όπως πολύ,

211
00:13:06,240 --> 00:13:08,390
επειδή τα προγράμματά μας πρόκειται να πάρει πιο εξελιγμένα

212
00:13:08,390 --> 00:13:11,370
αντί να γράφουν απλά προγράμματα που κάθονται εκεί με μια προτροπή να αναβοσβήνει,

213
00:13:11,370 --> 00:13:13,580
περιμένει το χρήστη να τυπώσει κάτι in

214
00:13:13,580 --> 00:13:15,220
Θα πάρετε τις εισροές σας από κάπου αλλού.

215
00:13:15,220 --> 00:13:18,720
Για παράδειγμα, θα τα πάρετε από μια σειρά από bits στον τοπικό σκληρό δίσκο.

216
00:13:18,720 --> 00:13:23,340
Θα τους πάρει αντ 'αυτού στο μέλλον από μια σύνδεση δικτύου, κάποια ιστοσελίδα κάπου.

217
00:13:23,340 --> 00:13:27,460
Ας φλούδα πίσω αυτό το στρώμα για πρώτη φορά, και τραβήξτε τη συσκευή CS50

218
00:13:27,460 --> 00:13:32,300
και αυτό το αρχείο ονομάζεται CS50.h, που ήσουν απότομη ακόμη και για εβδομάδες.

219
00:13:32,300 --> 00:13:34,380
>> Αλλά ας δούμε τι πραγματικά είναι μέσα από αυτό.

220
00:13:34,380 --> 00:13:38,250
Έτσι, η κορυφή του αρχείου στο μπλε είναι απλώς ένα σωρό σχόλια,

221
00:13:38,250 --> 00:13:41,340
πληροφορίες εγγύησης και τη χορήγηση αδειών. Αυτό είναι ένα είδος κοινό παράδειγμα

222
00:13:41,340 --> 00:13:44,600
το λογισμικό, επειδή πολλά από λογισμικό αυτές τις μέρες είναι αυτό που λέμε "open source"

223
00:13:44,600 --> 00:13:46,940
πράγμα που σημαίνει ότι κάποιος έχει γράψει τον κώδικα

224
00:13:46,940 --> 00:13:50,060
και έκανε ελεύθερα διαθέσιμα, όχι μόνο για να τρέξει και να χρησιμοποιήσει,

225
00:13:50,060 --> 00:13:53,660
αλλά στην πραγματικότητα διαβάζουν και να αλλάξει και να ενσωματώσει στο δικό σας έργο.

226
00:13:53,660 --> 00:13:55,790
Έτσι, αυτό είναι ό, τι έχετε χρησιμοποιήσει, το λογισμικό ανοιχτού κώδικα,

227
00:13:55,790 --> 00:13:58,030
αν και σε πολύ μικρή μορφή.

228
00:13:58,030 --> 00:14:01,860
Αν μετακινηθείτε προς τα κάτω μετά από τα σχόλια, όμως, θα αρχίσουμε να βλέπουμε κάποια πράγματα πιο οικεία.

229
00:14:01,860 --> 00:14:08,090
Έτσι παρατηρούμε στην κορυφή εδώ, ότι το αρχείο CS50.h περιλαμβάνει ένα σωρό αρχεία κεφαλίδας.

230
00:14:08,090 --> 00:14:11,160
Τώρα, τα περισσότερα από αυτά δεν έχουμε δει πριν, αλλά ένα είναι

231
00:14:11,160 --> 00:14:15,640
εξοικειωμένοι? ποια από αυτά τα έχουμε δει, έστω και για λίγο, μέχρι στιγμής;

232
00:14:15,640 --> 00:14:18,720
Ναι, τυποποιημένες βιβλιοθήκες. Stdlib.h έχει malloc,

233
00:14:18,720 --> 00:14:21,590
έτσι όταν αρχίσαμε να μιλάμε για δυναμική κατανομή μνήμης,

234
00:14:21,590 --> 00:14:24,960
το οποίο θα επανέλθουμε την επόμενη εβδομάδα, καθώς, όπως αρχίσαμε αυτό το αρχείο.

235
00:14:24,960 --> 00:14:29,660
Αποδεικνύεται ότι bool και αληθινό και το ψεύτικο, δεν υπάρχει στην πραγματικότητα σε C, per se,

236
00:14:29,660 --> 00:14:32,460
εκτός και αν έχετε συμπεριλάβει αυτό το αρχείο εδώ.

237
00:14:32,460 --> 00:14:35,770
Έτσι έχουμε, για εβδομάδες, συμπεριλαμβανομένων και των τυποποιημένων έχουν bool.h

238
00:14:35,770 --> 00:14:39,020
έτσι ώστε να μπορείτε να χρησιμοποιήσετε την έννοια του ένα bool, αληθής ή ψευδής.

239
00:14:39,020 --> 00:14:41,830
Χωρίς αυτό, θα πρέπει να ταξινομήσετε από το ψεύτικο και να χρησιμοποιήσετε ένα int

240
00:14:41,830 --> 00:14:45,920
και μόλις αυθαίρετα υποθέσουμε ότι 0 είναι ψευδής και 1 είναι αλήθεια.

241
00:14:45,920 --> 00:14:49,980
>> Τώρα, αν έχουμε περαιτέρω κύλιση προς τα κάτω, εδώ είναι ο ορισμός μας από μια σειρά.

242
00:14:49,980 --> 00:14:54,820
Αποδεικνύεται, όπως έχουμε ξαναπεί, ότι όταν αυτό * δεν πειράζει πραγματικά.

243
00:14:54,820 --> 00:14:56,750
Μπορείτε να έχετε ακόμη χώρο γύρω.

244
00:14:56,750 --> 00:15:01,550
Εμείς, αυτό το εξάμηνο, έχουν την προώθηση και αυτό να καταστεί σαφές ότι η * έχει να κάνει με το είδος.

245
00:15:01,550 --> 00:15:05,370
Αλλά συνειδητοποιούν, όπως ακριβώς κοινή, αν όχι λίγο πιο κοινό, είναι να το βάλετε εκεί

246
00:15:05,370 --> 00:15:07,480
αλλά λειτουργικά είναι το ίδιο πράγμα.

247
00:15:07,480 --> 00:15:11,070
Αλλά τώρα, αν διαβάσουμε μειωθεί περαιτέρω, ας ρίξουμε μια ματιά στο λόγο, GetInt,

248
00:15:11,070 --> 00:15:15,350
επειδή χρησιμοποιήσαμε ότι, ίσως, πριν από οτιδήποτε άλλο αυτό το εξάμηνο.

249
00:15:15,350 --> 00:15:19,620
Και εδώ είναι GetInt. Αυτό είναι ό, τι;

250
00:15:19,620 --> 00:15:24,650
Αυτό είναι το πρωτότυπο. Έτσι, συχνά, έχουμε θέσει πρωτότυπα στις κορυφές των μας. Γ αρχεία,

251
00:15:24,650 --> 00:15:28,190
αλλά μπορείτε να βάλετε επίσης σε πρωτότυπα αρχεία κεφαλίδας, αρχεία. h,

252
00:15:28,190 --> 00:15:32,110
όπως αυτή εδώ, έτσι ώστε όταν γράφετε ορισμένες λειτουργίες

253
00:15:32,110 --> 00:15:36,790
που θέλετε άλλους ανθρώπους για να είναι σε θέση να χρησιμοποιήσει, το οποίο είναι ακριβώς η περίπτωση με τη βιβλιοθήκη CS50,

254
00:15:36,790 --> 00:15:40,900
μπορείτε όχι μόνο να εφαρμόσουν τις λειτουργίες σας σε κάτι σαν CS50.c,

255
00:15:40,900 --> 00:15:46,720
βάζετε επίσης τα πρωτότυπα όχι στην κορυφή του εν λόγω αρχείου, αλλά στην κορυφή ενός αρχείου κεφαλίδας,

256
00:15:46,720 --> 00:15:50,810
τότε αυτό το αρχείο κεφαλίδας είναι αυτό που περιλαμβάνει τους φίλους και τους συναδέλφους,

257
00:15:50,810 --> 00:15:52,800
με αιχμηρά περιλαμβάνουν τον δικό τους κώδικα.

258
00:15:52,800 --> 00:15:55,440
Έτσι, όλο αυτό το διάστημα που έχετε συμπεριλαμβανομένων όλων αυτών των πρωτοτύπων

259
00:15:55,440 --> 00:15:59,870
αποτελεσματικά στην κορυφή του αρχείου σας, αλλά με τον τρόπο του αυτό το αιχμηρό περιλαμβάνουν μηχανισμό

260
00:15:59,870 --> 00:16:03,320
ότι ουσιαστικά αντίγραφα και πάστες αυτό το αρχείο στο δικό σας.

261
00:16:03,320 --> 00:16:06,400
Τώρα, εδώ είναι μερικές αρκετά λεπτομερή τεκμηρίωση.

262
00:16:06,400 --> 00:16:08,880
>> Έχουμε λίγο πολύ δεδομένο ότι GetInt παίρνει μια int,

263
00:16:08,880 --> 00:16:10,740
αλλά αποδεικνύεται ότι υπάρχει σε ορισμένες περιπτώσεις γωνία, έτσι δεν είναι;

264
00:16:10,740 --> 00:16:14,320
Τι θα συμβεί αν ο χρήστης πληκτρολογεί σε έναν αριθμό που είναι πάρα πολύ μεγάλο;

265
00:16:14,320 --> 00:16:17,350
Μια τετράκις εκατομμύρια, που απλά δεν μπορεί να χωρέσει μέσα από έναν int;

266
00:16:17,350 --> 00:16:21,180
Ποια είναι η αναμενόμενη συμπεριφορά; Λοιπόν, στην ιδανική περίπτωση, είναι προβλέψιμη.

267
00:16:21,180 --> 00:16:23,460
Έτσι, σε αυτή την περίπτωση, αν διαβάσει πραγματικά τα ψιλά γράμματα,

268
00:16:23,460 --> 00:16:27,850
θα δείτε ότι αν η γραμμή δεν μπορεί να διαβάσει, αυτό το INT_MAX επιστρέφει.

269
00:16:27,850 --> 00:16:30,800
Εμείς ποτέ δεν έχω μιλήσει για αυτό, αλλά με βάση την κεφαλαιοποίησή της,

270
00:16:30,800 --> 00:16:33,030
Τι είναι αυτό, ίσως;

271
00:16:33,030 --> 00:16:36,610
Είναι μια σταθερή, έτσι είναι κάποια ειδική σταθερά που είναι πιθανόν να κηρυχθεί

272
00:16:36,610 --> 00:16:39,460
σε ένα από αυτά τα αρχεία κεφαλίδας που είναι ψηλότερα στο αρχείο,

273
00:16:39,460 --> 00:16:43,400
και INT_MAX είναι πιθανώς κάτι σαν, περίπου, 2 δισ. ευρώ.

274
00:16:43,400 --> 00:16:48,160
Η ιδέα είναι ότι επειδή πρέπει να δηλώσουν κατά κάποιο τρόπο ότι κάτι πήγε στραβά,

275
00:16:48,160 --> 00:16:51,090
εμείς, ναι, έχουν 4 δισεκατομμύρια αριθμούς στη διάθεσή μας,

276
00:16:51,090 --> 00:16:53,980
αρνητικό 2 δισεκατομμύρια έως 2 δισ. ευρώ, ή να δώσει.

277
00:16:53,980 --> 00:16:58,030
Λοιπόν, αυτό που είναι κοινό στον προγραμματισμό είναι να κλέψει ένα μόνο από αυτούς τους αριθμούς.

278
00:16:58,030 --> 00:17:02,250
Ίσως 0, ίσως 2 δισ. ευρώ, ίσως αρνητικό 2 δισ. ευρώ.

279
00:17:02,250 --> 00:17:06,720
Έτσι ξοδεύετε μία από τις πιθανές τιμές σας, έτσι ώστε να μπορείτε να δεσμευτούν για τον κόσμο

280
00:17:06,720 --> 00:17:10,089
ότι αν κάτι πάει στραβά, θα επιστρέψει αυτό το σούπερ-μεγάλη αξία.

281
00:17:10,089 --> 00:17:13,329
Αλλά δεν θέλετε ο χρήστης πληκτρολογώντας κάτι αινιγματικά σαν "2, 3, 4 ..."

282
00:17:13,329 --> 00:17:17,079
πραγματικά μεγάλο αριθμό, όπου θα γενικεύσει αντί ως σταθερή.

283
00:17:17,079 --> 00:17:19,380
Έτσι, πραγματικά, αν ήταν να πρωκτικό τις τελευταίες εβδομάδες,

284
00:17:19,380 --> 00:17:23,800
ανά πάσα στιγμή να καλέσετε GetInt, θα πρέπει να έχουν τον έλεγχο με αν κατάσταση.

285
00:17:23,800 --> 00:17:27,109
Μήπως ο τύπος χρήστη σε INT_MAX, ή πιο συγκεκριμένα,

286
00:17:27,109 --> 00:17:29,900
έκανε GetInt INT_MAX επιστροφή; Διότι αν το έκανε,

287
00:17:29,900 --> 00:17:35,140
αυτό σημαίνει ότι στην πραγματικότητα δεν το πληκτρολογήστε? κάτι πήγε στραβά σε αυτή την περίπτωση.

288
00:17:35,140 --> 00:17:38,970
Έτσι, αυτό είναι ό, τι είναι γενικά γνωστό ως «φρουρός» αξία, που σημαίνει ακριβώς το ιδιαίτερο.

289
00:17:38,970 --> 00:17:41,020
>> Λοιπόν, ας στραφούμε τώρα για να τα αρχεία. C.

290
00:17:41,020 --> 00:17:44,500
Το αρχείο C υπήρχε στη συσκευή για κάποιο χρονικό διάστημα,

291
00:17:44,500 --> 00:17:47,540
και, στην πραγματικότητα, η συσκευή αυτή έχει μεταγλωττισμένα για σας

292
00:17:47,540 --> 00:17:49,720
σε αυτό το πράγμα που ονομάζεται "αντικειμενικό κώδικα"

293
00:17:49,720 --> 00:17:52,940
αλλά αυτό ακριβώς δεν έχει σημασία για εσάς, όπου είναι γιατί το σύστημα ξέρει,

294
00:17:52,940 --> 00:17:54,780
στην περίπτωση αυτή, όπου είναι, η συσκευή.

295
00:17:54,780 --> 00:18:00,620
Αλλά ας μετακινηθείτε προς τα κάτω για να GetInt τώρα, και να δούμε πώς GetInt έχει εργαστεί όλο αυτό το διάστημα.

296
00:18:00,620 --> 00:18:02,380
Έτσι, εδώ έχουμε παρόμοια σχόλια από πριν.

297
00:18:02,380 --> 00:18:04,930
Επιτρέψτε μου να μεγεθύνετε μόνο το τμήμα κώδικα,

298
00:18:04,930 --> 00:18:07,410
και ό, τι έχουμε για GetInt είναι η ακόλουθη.

299
00:18:07,410 --> 00:18:12,770
Δεν λαμβάνει εισόδου και επιστρέφει ένα int, ενώ η (πραγματική), έτσι έχουμε μια εσκεμμένη άπειρο βρόχο

300
00:18:12,770 --> 00:18:16,560
αλλά, κατά πάσα πιθανότητα, θα ξεφύγει από αυτό με κάποιο τρόπο, ή να επιστρέψουν μέσα από αυτό.

301
00:18:16,560 --> 00:18:19,890
Ας δούμε λοιπόν πώς αυτό λειτουργεί. Λοιπόν, φαίνεται να χρησιμοποιούν GetString

302
00:18:19,890 --> 00:18:22,550
σε αυτή την πρώτη γραμμή στο εσωτερικό του βρόγχου, 166.

303
00:18:22,550 --> 00:18:25,320
Αυτό τώρα είναι καλή πρακτική, διότι κάτω από ποιες συνθήκες

304
00:18:25,320 --> 00:18:30,820
θα μπορούσε να επιστρέψει GetString αυτό το ειδικό κλειδί, NULL;

305
00:18:30,820 --> 00:18:38,460
Αν κάτι πάει στραβά. Τι θα μπορούσε να πάει στραβά, όταν σας καλούν κάτι σαν GetString;

306
00:18:38,460 --> 00:18:42,550
Ναι; [Απάντηση Φοιτητής, ακατάληπτο] >> Ναι. Έτσι ίσως malloc αποτύχει.

307
00:18:42,550 --> 00:18:45,310
Κάπου κάτω από την κουκούλα GetString καλεί malloc,

308
00:18:45,310 --> 00:18:48,210
η οποία διαθέτει μνήμη, η οποία επιτρέπει το κατάστημα ηλεκτρονικών υπολογιστών

309
00:18:48,210 --> 00:18:50,950
το σύνολο των χαρακτήρων που ο χρήστης πληκτρολογεί στο πληκτρολόγιο.

310
00:18:50,950 --> 00:18:53,270
Και ας υποθέσουμε ότι ο χρήστης είχε ένα πάρα πολύ ελεύθερο χρόνο

311
00:18:53,270 --> 00:18:56,470
και πληκτρολογείται περισσότερο, για παράδειγμα, από 2 δισεκατομμύρια χαρακτήρες.

312
00:18:56,470 --> 00:18:59,600
Περισσότεροι χαρακτήρες από τον υπολογιστή έχει ακόμη RAM.

313
00:18:59,600 --> 00:19:02,350
Λοιπόν, GetString πρέπει να είναι σε θέση να σημαίνει ότι σε εσάς,

314
00:19:02,350 --> 00:19:05,650
ακόμη και αν αυτό είναι ένα σούπερ, σούπερ ασυνήθιστο περίπτωση γωνία.

315
00:19:05,650 --> 00:19:08,490
Πρέπει με κάποιο τρόπο να είναι σε θέση να χειριστεί το θέμα, και έτσι GetString,

316
00:19:08,490 --> 00:19:11,850
αν πάμε πίσω και να διαβάσετε τα έγγραφα του, έχει, στην πραγματικότητα, επιστρέφει NULL.

317
00:19:11,850 --> 00:19:16,150
Τώρα, αν αποτύχει GetString με την επιστροφή NULL, GetInt πρόκειται να αποτύχει

318
00:19:16,150 --> 00:19:19,370
επιστρέφοντας INT_MAX, ακριβώς ως φρουρός.

319
00:19:19,370 --> 00:19:22,650
Αυτά είναι μόνο τα ανθρώπινα. Ο μόνος τρόπος θα ξέρετε αυτή είναι η περίπτωση

320
00:19:22,650 --> 00:19:24,840
είναι με την ανάγνωση των εγγράφων.

321
00:19:24,840 --> 00:19:28,200
Ας μετακινηθείτε προς τα κάτω για να όπου η int είναι πραγματικά GotInt.

322
00:19:28,200 --> 00:19:34,220
>> Έτσι, αν μετακινηθείτε προς τα κάτω λίγο περισσότερο, σε γραμμή 170 έχουμε ένα σχόλιο πάνω από αυτές τις γραμμές.

323
00:19:34,220 --> 00:19:38,470
Έτσι δηλώνουμε, σε 172, μια int n και ένα char c, και στη συνέχεια, αυτή η νέα λειτουργία

324
00:19:38,470 --> 00:19:41,870
που ορισμένοι από εσάς έχετε σκόνταψε σε πριν, αλλά sscanf.

325
00:19:41,870 --> 00:19:44,190
Αυτό σημαίνει στ σειρά σάρωσης.

326
00:19:44,190 --> 00:19:48,580
Με άλλα λόγια, να μου δώσει μια σειρά και θα το σαρώσει για κομμάτια των πληροφοριών που παρουσιάζουν ενδιαφέρον.

327
00:19:48,580 --> 00:19:53,820
Λοιπόν, τι σημαίνει αυτό; Λοιπόν, ας υποθέσουμε ότι θα πληκτρολογήσετε, κυριολεκτικά, 1 2 3 στο πληκτρολόγιο,

328
00:19:53,820 --> 00:19:59,730
και στη συνέχεια χτύπησε αρχίζει. Ποιος είναι ο τύπος δεδομένων του 1 2 3 όταν επέστρεψε από GetString;

329
00:19:59,730 --> 00:20:05,010
Είναι προφανώς μια σειρά, έτσι δεν είναι; Πήρα μια σειρά, έτσι ώστε 1 2 3 είναι πραγματικά «1 2 3»

330
00:20:05,010 --> 00:20:07,260
με το \ 0 στο τέλος της. Αυτό δεν είναι ένα int.

331
00:20:07,260 --> 00:20:10,420
Αυτό δεν είναι ένας αριθμός. Μοιάζει με έναν αριθμό αλλά δεν είναι πραγματικά.

332
00:20:10,420 --> 00:20:14,680
Έτσι, αυτό που κάνει GetInt πρέπει να κάνω; Πρέπει να σαρώσει ότι η σειρά αριστερά προς τα δεξιά,

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, και με κάποιο τρόπο να το μετατρέψει σε μια πραγματική ακέραιο.

334
00:20:19,010 --> 00:20:21,010
Τώρα, μπορείτε να καταλάβω πώς να το κάνουμε αυτό.

335
00:20:21,010 --> 00:20:24,240
Αν νομίζετε ότι πίσω PSET 2, που προφανώς πήρε λίγο άνετα

336
00:20:24,240 --> 00:20:26,810
με Καίσαρα ή Vigenere ώστε να μπορείτε να επαναλάβει πάνω από ένα string,

337
00:20:26,810 --> 00:20:29,800
μπορείτε να μετατρέψετε σε χαρακτήρες ints με επιλογή. Αυτό είναι ένα πάρα πολύ δουλειά.

338
00:20:29,800 --> 00:20:32,800
Γιατί να μην καλέσετε μια συνάρτηση όπως sscanf που το κάνει αυτό για σας;

339
00:20:32,800 --> 00:20:37,520
Έτσι sscanf αναμένει ένα επιχείρημα, στην περίπτωση αυτή ονομάζεται γραμμή, η οποία είναι μια συμβολοσειρά.

340
00:20:37,520 --> 00:20:41,310
Μπορείτε στη συνέχεια, καθορίστε, σε εισαγωγικά, είναι πολύ παρόμοια με printf,

341
00:20:41,310 --> 00:20:44,960
τι περιμένετε να δείτε σε αυτή τη σειρά;

342
00:20:44,960 --> 00:20:52,980
Αυτό που λέω εδώ είναι, περιμένω να δω ένα δεκαδικό αριθμό και ίσως ένα χαρακτήρα.

343
00:20:52,980 --> 00:20:54,990
Και θα δούμε γιατί συμβαίνει αυτό σε μια στιγμή.

344
00:20:54,990 --> 00:20:58,440
Αποδεικνύεται ότι αυτή η σημείωση είναι πλέον θυμίζει πράγματα

345
00:20:58,440 --> 00:21:00,840
αρχίσαμε να μιλάμε για μόλις πάνω από μία εβδομάδα πριν.

346
00:21:00,840 --> 00:21:05,430
>> Τι είναι & n & c και κάνει για μας εδώ; [Απαντήσεις σπουδαστών, ακατάληπτο]

347
00:21:05,430 --> 00:21:07,610
Ναι >>. Είναι που μου δίνετε τη διεύθυνση του n και τη διεύθυνση του c.

348
00:21:07,610 --> 00:21:10,440
Τώρα, γιατί είναι τόσο σημαντικό; Λοιπόν, ξέρετε ότι με τις λειτουργίες σε C

349
00:21:10,440 --> 00:21:13,440
μπορείτε να επιστρέψετε πάντα μια τιμή ή καμία αξία σε όλα.

350
00:21:13,440 --> 00:21:16,630
Μπορείτε να επιστρέψετε ένα int, μια σειρά, μια float, ένα char, οτιδήποτε.

351
00:21:16,630 --> 00:21:21,150
Ή μπορείτε να επιστρέψετε κενό, αλλά μπορείτε να επιστρέψετε μόνο 1 πράγμα μέγιστο βαθμό.

352
00:21:21,150 --> 00:21:26,100
Αλλά εδώ θέλουμε sscanf να μου επιστρέψει ίσως ένα int, ένας δεκαδικός αριθμός,

353
00:21:26,100 --> 00:21:29,240
και επίσης μια χαρα, και θα εξηγήσω γιατί το char σε μια στιγμή.

354
00:21:29,240 --> 00:21:34,250
Έτσι, μπορείτε πραγματικά θέλουν να επιστρέψουν στ 2 πράγματα? Αυτό είναι όχι μόνο δυνατή σε C.

355
00:21:34,250 --> 00:21:38,460
Έτσι, μπορείτε να εργαστείτε γύρω από αυτό με το πέρασμα σε 2 διευθύνσεις,

356
00:21:38,460 --> 00:21:43,710
επειδή μόλις ένα χέρι τη λειτουργία 2 διευθύνσεις, τι μπορεί να κάνει με τη λειτουργία τους;

357
00:21:43,710 --> 00:21:49,880
Δεν μπορεί να γράψει σε αυτές τις διευθύνσεις. Μπορείτε να χρησιμοποιήσετε τη λειτουργία * και "go there" σε κάθε μία από αυτές τις διευθύνσεις.

358
00:21:49,880 --> 00:21:54,320
Είναι αυτό το είδος του μηχανισμού κερκόπορτα, αλλά πολύ κοινό για αλλαγή των τιμών των μεταβλητών

359
00:21:54,320 --> 00:21:58,020
σε περισσότερες από μόλις 1 θέση, σε αυτή την περίπτωση 2.

360
00:21:58,020 --> 00:22:04,590
Τώρα, παρατηρούμε Φεύγω για == μέχρι1, και στη συνέχεια επιστρέφουν n αν αυτό σημαίνει, στην πραγματικότητα, να αξιολογήσει αλήθεια.

361
00:22:04,590 --> 00:22:09,340
Λοιπόν, τι συμβαίνει; Καλά, τεχνικά, όλοι θέλουμε πραγματικά να συμβεί σε GetInt είναι αυτό.

362
00:22:09,340 --> 00:22:12,340
Θέλουμε να αναλύσει, να το πω έτσι? Θέλουμε να διαβάσετε το string

363
00:22:12,340 --> 00:22:16,210
«1 2 3» και αν φαίνεται σαν να υπάρχει ένας αριθμός εκεί,

364
00:22:16,210 --> 00:22:21,360
τι λέμε sscanf να κάνουμε είναι να βάλετε τον αριθμό, 1 2 3, σε αυτή τη μεταβλητή n για μένα.

365
00:22:21,360 --> 00:22:26,060
Γιατί, λοιπόν, δεν είχα αυτό, καθώς;

366
00:22:26,060 --> 00:22:33,750
Ποιος είναι ο ρόλος της και λέγοντας, sscanf, μπορείτε να πάρετε επίσης ένα χαρακτήρα εδώ.

367
00:22:33,750 --> 00:22:36,890
[Μιλώντας Φοιτητών, ακατάληπτο] >> Δεν είναι - ένα δεκαδικό σημείο θα μπορούσε να λειτουργήσει.

368
00:22:36,890 --> 00:22:40,650
Ας κρατήσει ότι σκέφτηκε για μια στιγμή. Τι άλλο;

369
00:22:40,650 --> 00:22:42,570
[Φοιτητών, ακατάληπτο] >> Έτσι, καλή σκέψη, θα μπορούσε να είναι ο χαρακτήρας NULL.

370
00:22:42,570 --> 00:22:44,970
Είναι πραγματικά δεν είναι, σε αυτή την περίπτωση. Ναι; [Φοιτητών, ακατάληπτο]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. Ή, επιτρέψτε μου να γενικεύσει ακόμη περισσότερο.

372
00:22:47,100 --> 00:22:49,670
Το γ% δεν είναι μόνο για έλεγχο σφαλμάτων.

373
00:22:49,670 --> 00:22:52,510
Δεν θέλουμε να υπάρξει χαρακτήρα μετά από τον αριθμό,

374
00:22:52,510 --> 00:22:54,980
αλλά αυτό που μου επιτρέπει να κάνω είναι η εξής:

375
00:22:54,980 --> 00:23:01,270
Αποδεικνύεται ότι sscanf, εκτός από την αποθήκευση των τιμών σε n και c, σε αυτό το παράδειγμα εδώ,

376
00:23:01,270 --> 00:23:08,170
ό, τι δεν είναι, επίσης, να επιστρέφει τον αριθμό των μεταβλητών έθεσε αξίες μέσα

377
00:23:08,170 --> 00:23:13,330
Έτσι, αν πληκτρολογήσετε μόνο το 1 2 3, τότε το μόνο% d πρόκειται να ταιριάζει με

378
00:23:13,330 --> 00:23:18,830
και μόνο n παίρνει αποθηκεύονται με μια τιμή, όπως 1 2 3 και τίποτα δεν παίρνει θέσει σε γ?

379
00:23:18,830 --> 00:23:20,870
γ παραμένει μια αξία σκουπίδια, να το πω έτσι.

380
00:23:20,870 --> 00:23:23,550
Σκουπίδια, διότι ποτέ δεν έχει αρχικοποιηθεί ως κάποια αξία.

381
00:23:23,550 --> 00:23:29,390
Έτσι, στην περίπτωση αυτή, sscanf επιστρέφει 1, γιατί κατοικείται μία από αυτές τις υποδείξεις,

382
00:23:29,390 --> 00:23:33,650
στην οποία περίπτωση, μεγάλη. Έχω ένα int, γι 'αυτό ελευθερώσει τη γραμμή για να ελευθερώσετε τη μνήμη

383
00:23:33,650 --> 00:23:37,150
GetString που πραγματικά διατεθεί, και στη συνέχεια θα επιστρέψει n.

384
00:23:37,150 --> 00:23:42,210
Αλλιώς, αν ποτέ αναρωτηθεί όπου η επανάληψη δήλωση προέρχεται από, έρχεται από τα δεξιά εδώ.

385
00:23:42,210 --> 00:23:45,770
Εάν, αντίθετα, θα πληκτρολογήσετε 1 2 3 foo,

386
00:23:45,770 --> 00:23:48,640
μερικά μόνο τυχαία ακολουθία του κειμένου, sscanf πρόκειται να δει,

387
00:23:48,640 --> 00:23:51,500
ooh, αριθμός, ooh, αριθμός, ooh, αριθμός, ooh - f.

388
00:23:51,500 --> 00:23:54,190
Και πρόκειται να θέσει το 1 2 3 σε n.

389
00:23:54,190 --> 00:23:59,970
Είναι πρόκειται να θέσει το f στο c, και στη συνέχεια επιστρέφουν 2.

390
00:23:59,970 --> 00:24:02,980
Έτσι έχουμε, απλά χρησιμοποιώντας το βασικό ορισμό της συμπεριφοράς της scanf,

391
00:24:02,980 --> 00:24:06,170
ένας πολύ απλός τρόπος - καλά, σύμπλοκο με την πρώτη ματιά, αλλά στο τέλος της ημέρας,

392
00:24:06,170 --> 00:24:11,460
αρκετά απλό μηχανισμό του λέγοντας, υπάρχει ένα int, και αν ναι, είναι ότι το μόνο πράγμα που βρήκα;

393
00:24:11,460 --> 00:24:14,950
Και ο λευκός χώρος εδώ είναι σκόπιμη. Αν διαβάσετε την τεκμηρίωση για sscanf,

394
00:24:14,950 --> 00:24:18,690
σας λέει ότι αν έχετε συμπεριλάβει ένα κομμάτι από λευκό κενό διάστημα στην αρχή ή το τέλος,

395
00:24:18,690 --> 00:24:24,990
sscanf επίσης θα επιτρέψει στο χρήστη, για οποιονδήποτε λόγο, να χτυπήσει το spacebar 1 2 3, και αυτό θα είναι νόμιμο.

396
00:24:24,990 --> 00:24:28,310
Δεν θα φωνάζω στο χρήστη μόνο και μόνο επειδή χτύπησε το spacebar στην αρχή ή το τέλος,

397
00:24:28,310 --> 00:24:32,160
το οποίο είναι λίγο πιο φιλική προς το χρήστη.

398
00:24:32,160 --> 00:24:34,160
>> Όλες οι ερωτήσεις, τότε, για GetInts; Ναι;

399
00:24:34,160 --> 00:24:36,820
[Ερώτηση Φοιτητών, ακατάληπτο]

400
00:24:36,820 --> 00:24:40,740
Καλή ερώτηση >>. Τι γίνεται αν έχετε μόλις πληκτρολογήσατε σε ένα char, όπως και στ, και πατήστε enter

401
00:24:40,740 --> 00:24:47,830
χωρίς ποτέ να πληκτρολογήσετε 1 2 3? τι νομίζετε ότι η συμπεριφορά της αυτή τη γραμμή του κώδικα θα είναι τότε;

402
00:24:47,830 --> 00:24:50,500
Έτσι sscanf μπορεί να καλύψει ότι πάρα πολύ, γιατί σε αυτή την περίπτωση,

403
00:24:50,500 --> 00:24:56,280
δεν πρόκειται να γεμίσει ή ν γ? πρόκειται να επιστρέψει αντί 0.

404
00:24:56,280 --> 00:25:01,540
Σε αυτή την περίπτωση, είμαι αλίευση, επίσης, ότι το σενάριο, επειδή η αναμενόμενη αξία που θέλω είναι 1.

405
00:25:01,540 --> 00:25:07,310
Θέλω μόνο 1, και μόνο 1 πράγμα που πρέπει να πληρωθεί. Καλή ερώτηση. Άλλοι;

406
00:25:07,310 --> 00:25:09,610
>> Εντάξει, έτσι ας μην περάσει από όλες τις λειτουργίες εδώ,

407
00:25:09,610 --> 00:25:11,820
αλλά αυτό που φαίνεται να είναι, ίσως, το ενδιαφέρον των υπόλοιπων

408
00:25:11,820 --> 00:25:14,530
GetString είναι επειδή αποδεικνύεται ότι GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
GetDouble, GetLongLong όλων punt πολλές λειτουργίες τους σε GetString.

410
00:25:19,490 --> 00:25:22,860
Έτσι, ας ρίξουμε μια ματιά στο πώς εφαρμόζεται εδώ.

411
00:25:22,860 --> 00:25:27,040
Αυτός φαίνεται λίγο περίπλοκη αλλά χρησιμοποιεί τα ίδια βασικά

412
00:25:27,040 --> 00:25:29,680
ότι αρχίσαμε να μιλάμε για την τελευταία εβδομάδα. Έτσι, σε GetString,

413
00:25:29,680 --> 00:25:32,670
η οποία λαμβάνει κανένα επιχείρημα σύμφωνα με το κενό μέχρι εδώ,

414
00:25:32,670 --> 00:25:37,110
και επιστρέφει ένα string? έτσι δηλώνω μια σειρά που ονομάζεται buffer.

415
00:25:37,110 --> 00:25:39,670
Πραγματικά, δεν ξέρω τι πρόκειται να χρησιμοποιηθεί για ακόμα, αλλά θα δούμε.

416
00:25:39,670 --> 00:25:42,950
Μοιάζει με ικανότητα είναι, εξ ορισμού, 0? Δεν είναι αρκετά βέβαιοι πού αυτό θα είναι.

417
00:25:42,950 --> 00:25:44,920
Δεν είστε σίγουροι για το τι πρόκειται ν να χρησιμοποιηθεί για ακόμα.

418
00:25:44,920 --> 00:25:47,860
Αλλά τώρα είναι να πάρει λίγο πιο ενδιαφέρουσα, ώστε σε γραμμή 243,

419
00:25:47,860 --> 00:25:51,760
δηλώνουμε μια int c, αυτό είναι το είδος της μια ηλίθια λεπτομέρεια.

420
00:25:51,760 --> 00:25:58,080
Μια χαρα είναι 8 bit, 8 bits και μπορεί να αποθηκεύσει πόσες διαφορετικές τιμές;

421
00:25:58,080 --> 00:26:03,310
256. Το πρόβλημα είναι, αν θέλετε να έχετε 256 διαφορετικά χαρακτήρες ASCII,

422
00:26:03,310 --> 00:26:06,210
που υπάρχουν, αν νομίζετε ότι πίσω, και αυτό δεν είναι κάτι για να απομνημονεύσουν.

423
00:26:06,210 --> 00:26:09,100
Αλλά αν νομίζετε ότι πίσω σε εκείνη την μεγάλη ASCII διάγραμμα είχαμε εβδομάδες πριν,

424
00:26:09,100 --> 00:26:13,780
υπήρξαν, στην περίπτωση αυτή, 128 ή 256 χαρακτήρες ASCII.

425
00:26:13,780 --> 00:26:16,220
Χρησιμοποιήσαμε όλα τα πρότυπα του 0 και 1 στο χέρι.

426
00:26:16,220 --> 00:26:19,410
Αυτό είναι ένα πρόβλημα, αν θέλετε να είναι σε θέση να ανιχνεύσει ένα σφάλμα.

427
00:26:19,410 --> 00:26:23,290
Διότι αν χρησιμοποιείτε ήδη 256 τιμές για τους χαρακτήρες σας,

428
00:26:23,290 --> 00:26:26,390
δεν έχετε πραγματικά προγραμματίσουν το μέλλον, διότι τώρα δεν έχετε κανέναν τρόπο να πούμε,

429
00:26:26,390 --> 00:26:29,750
"Αυτό δεν είναι μια legit χαρακτήρας? Αυτό είναι κάποια λανθασμένη μήνυμα."

430
00:26:29,750 --> 00:26:32,430
Έτσι, αυτό που κάνει ο κόσμος είναι να χρησιμοποιήσετε την επόμενη μεγαλύτερη αξία,

431
00:26:32,430 --> 00:26:35,790
κάτι σαν int, έτσι ώστε να έχουν μια τρελή αριθμός των bits,

432
00:26:35,790 --> 00:26:39,610
32 για 4 δισεκατομμύρια δυνατές τιμές, έτσι ώστε να μπορείτε απλά να καταλήξετε με τη χρήση,

433
00:26:39,610 --> 00:26:44,800
κατ 'ουσίαν, 257 από αυτούς, 1 εκ των οποίων έχει κάποια ιδιαίτερη σημασία ως σφάλμα.

434
00:26:44,800 --> 00:26:49,190
>> Ας δούμε λοιπόν πώς αυτό λειτουργεί. Στη γραμμή 246, έχω αυτό το μεγάλο βρόχο, ενώ

435
00:26:49,190 --> 00:26:54,530
που ζητά fgetc? στ αρχείο έννοια, getc, και στη συνέχεια stdin.

436
00:26:54,530 --> 00:26:59,030
Βγάζει αυτό είναι μόνο η πιο ακριβής τρόπος για να πούμε "διαβάσουμε είσοδο από το πληκτρολόγιο."

437
00:26:59,030 --> 00:27:02,730
Πρότυπο πληκτρολόγιο μέσο εισόδου, εξόδου σημαίνει πρότυπο οθόνη,

438
00:27:02,730 --> 00:27:06,920
και τυπικό σφάλμα, το οποίο θα δούμε σε PSET 4, σημαίνει την οθόνη,

439
00:27:06,920 --> 00:27:09,670
αλλά ένα ειδικό μέρος της οθόνης έτσι ώστε να είναι δεν συγχέονται

440
00:27:09,670 --> 00:27:13,760
με πραγματική παραγωγή που προορίζεται για την εκτύπωση? αλλά περισσότερο για αυτό στο μέλλον.

441
00:27:13,760 --> 00:27:19,430
Έτσι fgetc σημαίνει απλώς διαβάσει ένα χαρακτήρα από το πληκτρολόγιο, και το κατάστημα όπου;

442
00:27:19,430 --> 00:27:24,000
Αποθηκεύστε το στο γ, και στη συνέχεια ελέγξτε, έτσι είμαι χρησιμοποιώντας μόνο μερικές boolean σύνδεσμοι εδώ,

443
00:27:24,000 --> 00:27:28,430
βεβαιωθείτε ότι δεν ίσες \ n, έτσι ώστε ο χρήστης έχει πατήστε enter.

444
00:27:28,430 --> 00:27:31,510
Θέλουμε να σταματήσει σε εκείνο το σημείο, τέλος του βρόχου, και θέλουμε επίσης να ελέγξετε

445
00:27:31,510 --> 00:27:36,170
για το ειδικό σταθερά, ΕΟΦ, η οποία, αν γνωρίζετε ή να μαντέψει - τι ηρεμήσει;

446
00:27:36,170 --> 00:27:39,860
Τέλος του αρχείου. Έτσι, αυτό είναι το είδος της νόημα, γιατί αν είμαι πληκτρολογώντας στο πληκτρολόγιο,

447
00:27:39,860 --> 00:27:41,900
πραγματικά δεν υπάρχει αρχείο που συμμετέχουν σε αυτό,

448
00:27:41,900 --> 00:27:44,330
αλλά αυτό είναι ακριβώς το είδος της γενικός όρος που χρησιμοποιείται για να σημάνει

449
00:27:44,330 --> 00:27:50,320
ότι τίποτα άλλο δεν έρχεται από τα δάχτυλα του ανθρώπου. ΕΟΦ. Τέλος του αρχείου.

450
00:27:50,320 --> 00:27:52,600
Ως μέρος, αν έχετε χτυπήσει ποτέ τον έλεγχο d στο πληκτρολόγιό σας,

451
00:27:52,600 --> 00:27:54,680
όχι ότι θα έχετε ακόμα? έχετε χτυπήσει τον έλεγχο c.

452
00:27:54,680 --> 00:27:57,920
Αλλά ελέγχου δ στέλνει αυτή την ειδική σταθερά που ονομάζεται ΕΟΦ.

453
00:27:57,920 --> 00:28:03,100
>> Μέχρι τώρα έχουμε μόνο κάποια δυναμική κατανομή μνήμης.

454
00:28:03,100 --> 00:28:06,460
Έτσι, αν n + 1> ικανότητα, τώρα θα εξηγήσω n.

455
00:28:06,460 --> 00:28:09,380
n είναι ακριβώς πόσα bytes είναι επί του παρόντος στο ρυθμιστικό,

456
00:28:09,380 --> 00:28:11,970
η σειρά που είστε σήμερα δημιουργία από το χρήστη.

457
00:28:11,970 --> 00:28:16,240
Εάν έχετε περισσότερους χαρακτήρες στο ρυθμιστικό σας από ό, τι έχετε την ικανότητα στο ρυθμιστικό,

458
00:28:16,240 --> 00:28:20,760
διαισθητικά, τι πρέπει να κάνουμε στη συνέχεια διαθέτουν μεγαλύτερη χωρητικότητα.

459
00:28:20,760 --> 00:28:24,490
Πάω να προσπεράσει μερικές από τις αριθμητικές εδώ

460
00:28:24,490 --> 00:28:26,900
και να επικεντρωθεί μόνο σε αυτήν την λειτουργία εδώ.

461
00:28:26,900 --> 00:28:29,170
Ξέρεις τι είναι malloc, ή τουλάχιστον γενικά εξοικειωμένοι.

462
00:28:29,170 --> 00:28:32,380
Πάρτε μια εικασία τι κάνει realloc. [Απάντηση Φοιτητής, ακατάληπτο]

463
00:28:32,380 --> 00:28:35,690
Ναι >>. Και αυτό δεν είναι αρκετά προσθέτοντας μνήμη? Να αναδιανέμει μνήμη ως εξής:

464
00:28:35,690 --> 00:28:40,530
Αν υπάρχει ακόμα περιθώριο στο τέλος του string για να σας δώσουμε περισσότερες της μνήμης

465
00:28:40,530 --> 00:28:43,370
από ό, τι σας δίνει αρχικά, τότε θα πάρετε αυτό το επιπλέον μνήμη.

466
00:28:43,370 --> 00:28:46,640
Έτσι, μπορείτε να θέτει απλώς τους χαρακτήρες χορδές πλάτη με πλάτη με πλάτη με πλάτη.

467
00:28:46,640 --> 00:28:49,290
Αλλά αν αυτό δεν είναι η περίπτωση, επειδή περίμενα πολύ καιρό

468
00:28:49,290 --> 00:28:51,700
και κάτι τυχαία πήρε plopped στη μνήμη εκεί, αλλά υπάρχει επιπλέον

469
00:28:51,700 --> 00:28:56,480
μνήμη εδώ κάτω, αυτό είναι εντάξει. Realloc πρόκειται να κάνει όλη τη δύσκολη δουλειά για εσάς,

470
00:28:56,480 --> 00:28:58,810
μετακινήσετε τη σειρά που έχετε διαβάσει στο έτσι μακριά από εδώ,

471
00:28:58,810 --> 00:29:02,550
έβαλε εκεί κάτω, και στη συνέχεια να σας δώσει κάποιες περισσότερες διάδρομο σε εκείνο το σημείο.

472
00:29:02,550 --> 00:29:05,610
Έτσι, με μια κίνηση του χεριού, επιτρέψτε μου να πω ότι αυτό που κάνει GetString

473
00:29:05,610 --> 00:29:09,540
είναι αυτό που αρχίζει με ένα μικρό ρυθμιστικό, ίσως 1 μονό χαρακτήρα,

474
00:29:09,540 --> 00:29:12,300
και εάν ο χρήστης τύποι στο 2 χαρακτήρες, GetString καταλήγει

475
00:29:12,300 --> 00:29:15,210
καλώντας realloc και λέει, «Ω, 1 χαρακτήρας δεν ήταν αρκετό.

476
00:29:15,210 --> 00:29:18,480
Δώσε μου 2 χαρακτήρες. Στη συνέχεια, αν μπορείτε να διαβάσετε μέσα από τη λογική του βρόχου,

477
00:29:18,480 --> 00:29:21,070
πρόκειται να πει, «Ω, ο χρήστης πληκτρολογήσει 3 χαρακτήρες.

478
00:29:21,070 --> 00:29:25,690
Δώσε μου τώρα όχι 2, αλλά 4 χαρακτήρες, τότε να μου δώσει 8, τότε δώσε μου 16 και 32. "

479
00:29:25,690 --> 00:29:28,180
Το γεγονός ότι είμαι ο διπλασιασμός της χωρητικότητας κάθε φορά

480
00:29:28,180 --> 00:29:30,320
σημαίνει ότι το ρυθμιστικό δεν πρόκειται να αυξηθεί σιγά-σιγά.

481
00:29:30,320 --> 00:29:35,870
Είναι πρόκειται να αυξηθεί σούπερ γρήγορα, και τι θα μπορούσε να είναι το πλεονέκτημα του ότι;

482
00:29:35,870 --> 00:29:38,540
Γιατί είμαι διπλασιάζοντας το μέγεθος της ενδιάμεσης μνήμης, παρόλο που ο χρήστης

483
00:29:38,540 --> 00:29:41,450
θα μπορούσε απλώς να χρειαστεί 1 επιπλέον χαρακτήρα από το πληκτρολόγιο;

484
00:29:41,450 --> 00:29:44,830
[Απάντηση Φοιτητής, ακατάληπτο]. >> Τι είναι αυτό;

485
00:29:44,830 --> 00:29:46,750
Ακριβώς. Δεν χρειάζεται να αναπτυχθεί τόσο συχνά.

486
00:29:46,750 --> 00:29:48,870
Και αυτό είναι ακριβώς το είδος του ένα - Μπορείτε πλέον αντιστάθμισης στοιχήματά σας εδώ.

487
00:29:48,870 --> 00:29:54,150
Η ιδέα είναι ότι δεν θέλετε να καλέσετε realloc πολύ, επειδή τείνει να είναι αργή.

488
00:29:54,150 --> 00:29:56,840
Κάθε φορά που θα ζητήσει από το λειτουργικό σύστημα για τη μνήμη, όπως θα δείτε σύντομα

489
00:29:56,840 --> 00:30:00,620
σε ένα μελλοντικό πρόβλημα σύνολο, τείνει να πάρει κάποιο χρόνο.

490
00:30:00,620 --> 00:30:04,980
Έτσι, ελαχιστοποιώντας το ποσό του χρόνου, ακόμα και αν σπαταλάτε κάποιο διάστημα, τείνει να είναι ένα καλό πράγμα.

491
00:30:04,980 --> 00:30:07,250
>> Αλλά αν διαβάσετε το τελευταίο μέρος της GetString εδώ,

492
00:30:07,250 --> 00:30:10,880
και πάλι, την κατανόηση κάθε γραμμή εδώ δεν είναι τόσο σημαντικό σήμερα.

493
00:30:10,880 --> 00:30:14,830
Να σημειωθεί όμως ότι τελικά malloc καλεί και πάλι, και διαθέτει

494
00:30:14,830 --> 00:30:16,980
ακριβώς όπως ο αριθμός των bytes που χρειάζεται για το string

495
00:30:16,980 --> 00:30:21,620
και στη συνέχεια ρίχνει μακριά καλώντας δωρεάν, το υπερβολικά μεγάλο buffer,

496
00:30:21,620 --> 00:30:23,510
αν πράγματι πήρε διπλασίασε πάρα πολλές φορές.

497
00:30:23,510 --> 00:30:25,970
Με λίγα λόγια, αυτό είναι το πώς GetString έχει εργαστεί όλο αυτό το διάστημα.

498
00:30:25,970 --> 00:30:30,100
Το μόνο που κάνει είναι να διαβάσει ένα χαρακτήρα σε μια στιγμή ξανά και ξανά και ξανά

499
00:30:30,100 --> 00:30:37,930
και κάθε φορά που χρειάζεται κάποια επιπλέον μνήμη, ζητεί από το λειτουργικό σύστημα για να καλώντας realloc.

500
00:30:37,930 --> 00:30:41,660
Οποιεσδήποτε ερωτήσεις; Εντάξει.

501
00:30:41,660 --> 00:30:45,220
>> Μια επίθεση. Τώρα που καταλαβαίνουμε δείκτες, ή τουλάχιστον

502
00:30:45,220 --> 00:30:47,560
είναι όλο και πιο εξοικειωμένοι με δείκτες,

503
00:30:47,560 --> 00:30:50,020
ας αναλογιστούμε πως όλος ο κόσμος αρχίζει να καταρρέει

504
00:30:50,020 --> 00:30:53,160
αν δεν είναι αρκετά υπερασπιστεί κατά αντιμωλία των χρηστών,

505
00:30:53,160 --> 00:30:55,180
οι άνθρωποι που προσπαθούν να χαράξει στο σύστημά σας.

506
00:30:55,180 --> 00:31:00,260
Οι άνθρωποι που προσπαθούν να κλέψουν το λογισμικό σας με παράκαμψη κάποιο κωδικό εγγραφής

507
00:31:00,260 --> 00:31:02,150
ότι θα μπορούσαν διαφορετικά να πληκτρολογήσετε μέσα

508
00:31:02,150 --> 00:31:04,860
Ρίξτε μια ματιά σε αυτό το παράδειγμα εδώ, το οποίο είναι απλά κώδικας C

509
00:31:04,860 --> 00:31:07,920
που έχει μια κύρια λειτουργία στο κάτω μέρος, που καλεί μια συνάρτηση foo,

510
00:31:07,920 --> 00:31:12,100
και τι είναι αυτό που περνά για foo; [Φοιτητικό] Ένα μοναδικό επιχείρημα.

511
00:31:12,100 --> 00:31:15,660
Ενιαία >> επιχείρημα. Έτσι, argv [1], το οποίο σημαίνει ότι η πρώτη λέξη ο χρήστης πληκτρολογήσει

512
00:31:15,660 --> 00:31:19,150
στη γραμμή εντολών μετά το a.out ή οτιδήποτε άλλο, το πρόγραμμα ονομάζεται.

513
00:31:19,150 --> 00:31:24,920
Έτσι foo, στην κορυφή, παίρνει σε ένα char *, char * αλλά είναι ακριβώς αυτό;

514
00:31:24,920 --> 00:31:28,860
String. Δεν υπάρχει τίποτα νέο εδώ, και ότι η σειρά είναι αυθαίρετα που ονομάζεται μπαρ.

515
00:31:28,860 --> 00:31:36,090
Σε αυτή τη γραμμή εδώ, char c [12], το είδος των ημι-τεχνικά Αγγλικά, τι είναι αυτή η γραμμή να κάνει;

516
00:31:36,090 --> 00:31:40,640
Array της -; Χαρακτήρες. Δώσε μου μια σειρά από 12 χαρακτήρες.

517
00:31:40,640 --> 00:31:44,970
Έτσι, θα μπορούσαμε να ονομάσουμε αυτό ένα ρυθμιστικό. Είναι τεχνικά ονομάζεται c, αλλά ένα ρυθμιστικό στον προγραμματισμό

518
00:31:44,970 --> 00:31:47,890
ακριβώς σημαίνει ένα σωρό χώρο που μπορείτε να βάλετε κάποια πράγματα μέσα

519
00:31:47,890 --> 00:31:49,940
>> Στη συνέχεια, τέλος, memcpy, δεν έχουμε χρησιμοποιήσει στο παρελθόν.

520
00:31:49,940 --> 00:31:52,380
Αλλά μπορείτε να μαντέψετε τι κάνει. Αυτό αντιγράφει τη μνήμη.

521
00:31:52,380 --> 00:31:58,790
Τι κάνει; Λοιπόν, προφανώς αντιγράφει μπαρ, εισαγωγή του, στο γ,

522
00:31:58,790 --> 00:32:03,420
αλλά μόνο μέχρι το μήκος της ράβδου.

523
00:32:03,420 --> 00:32:07,440
Αλλά υπάρχει ένα bug εδώ.

524
00:32:07,440 --> 00:32:14,500
Εντάξει, έτσι τεχνικά θα πρέπει να κάνουμε πραγματικά strlen (bar) x sizeof (char), το οποίο είναι σωστό.

525
00:32:14,500 --> 00:32:17,920
Όμως, στη χειρότερη περίπτωση εδώ, ας υποθέσουμε ότι that's - έτσι, εντάξει.

526
00:32:17,920 --> 00:32:23,760
Στη συνέχεια υπάρχουν 2 σφάλματα. Έτσι, sizeof (char), εντάξει, ας κάνουμε αυτό το λίγο μεγαλύτερο.

527
00:32:23,760 --> 00:32:28,860
Έτσι τώρα υπάρχει ακόμα ένα bug, το οποίο είναι αυτό;

528
00:32:28,860 --> 00:32:31,630
[Απάντηση Φοιτητής, ακατάληπτο] >> Έλεγχος για τι; Εντάξει, γι 'αυτό πρέπει να τον έλεγχο

529
00:32:31,630 --> 00:32:35,010
για NULL, επειδή κακά πράγματα συμβαίνουν όταν ο δείκτης σας είναι NULL,

530
00:32:35,010 --> 00:32:38,490
Επειδή μπορεί να καταλήξουν εκεί, και δεν θα πρέπει ποτέ να πρόκειται να NULL

531
00:32:38,490 --> 00:32:40,890
με την εύρεση τιμών με το χειριστή *.

532
00:32:40,890 --> 00:32:45,250
Έτσι, αυτό είναι καλό, και ό, τι άλλο κάνουμε; Λογικά υπάρχει ένα ελάττωμα εδώ.

533
00:32:45,250 --> 00:32:47,650
[Απάντηση Φοιτητής, ακατάληπτο]

534
00:32:47,650 --> 00:32:51,340
>> Ελέγξετε Έτσι, αν argc ≥ 2;

535
00:32:51,340 --> 00:32:54,130
Εντάξει, έτσι είναι υπάρχουν 3 σφάλματα σε αυτό το πρόγραμμα εδώ.

536
00:32:54,130 --> 00:33:00,080
Δεν είμαστε έλεγχο αν ο χρήστης πληκτρολογήσει πραγματικά σε οτιδήποτε σε argv [1], καλό.

537
00:33:00,080 --> 00:33:02,240
Έτσι, αυτό που είναι το τρίτο σφάλμα; Ναι;

538
00:33:02,240 --> 00:33:04,420
[Απάντηση Φοιτητής, ακατάληπτο] >> Καλή.

539
00:33:04,420 --> 00:33:09,590
Γι 'αυτό και ελέγχεται ένα σενάριο. Θα ελέγχεται εμμέσως μην αντιγράψετε περισσότερη μνήμη

540
00:33:09,590 --> 00:33:12,800
από ό, τι θα μπορούσε να υπερβαίνει το μήκος της ράβδου.

541
00:33:12,800 --> 00:33:15,720
Έτσι, αν το string ο χρήστης πληκτρολογήσει είναι 10 χαρακτήρες,

542
00:33:15,720 --> 00:33:18,260
αυτό που λέει, «μόνο αντιγράψετε 10 χαρακτήρες.

543
00:33:18,260 --> 00:33:21,140
Και αυτό είναι εντάξει, αλλά τι γίνεται αν ο χρήστης πληκτρολογήσει σε μια λέξη στη γραμμή εντολών

544
00:33:21,140 --> 00:33:29,360
σαν μια λέξη 20 χαρακτήρων? αυτό, λέγοντας αντίγραφο 20 χαρακτήρες από τη γραμμή σε ό, τι;

545
00:33:29,360 --> 00:33:32,840
γ, αλλιώς γνωστή ως ρυθμιστικό μας, το οποίο σημαίνει ότι έγραψε μόνο τα δεδομένα

546
00:33:32,840 --> 00:33:35,950
έως 8 θέσεις byte που δεν έχουν στην ιδιοκτησία τους,

547
00:33:35,950 --> 00:33:38,320
και δεν τα κατέχουν, με την έννοια ότι ποτέ δεν τους διατίθενται.

548
00:33:38,320 --> 00:33:41,190
Έτσι, αυτό είναι ό, τι είναι γενικά γνωστή ως η επίθεση υπερχείλισης buffer,

549
00:33:41,190 --> 00:33:46,650
ή ρυθμιστικό υπέρβασης επίθεση, και αυτό είναι επίθεση με την έννοια ότι αν ο χρήστης

550
00:33:46,650 --> 00:33:50,650
ή το πρόγραμμα που σας καλεί η λειτουργία σας κάνει αυτό κακόβουλα,

551
00:33:50,650 --> 00:33:53,780
τι συμβαίνει στην πραγματικότητα επόμενο μπορούσε να είναι αρκετά κακό.

552
00:33:53,780 --> 00:33:55,690
>> Ας ρίξουμε μια ματιά σε αυτή την εικόνα εδώ.

553
00:33:55,690 --> 00:33:59,070
Αυτή η εικόνα αντιπροσωπεύει το stack σας μνήμη.

554
00:33:59,070 --> 00:34:01,050
Και θυμάμαι ότι κάθε φορά που θα καλέσετε μια συνάρτηση,

555
00:34:01,050 --> 00:34:04,520
μπορείτε να πάρετε αυτό το μικρό πλαίσιο στη στοίβα και στη συνέχεια ένα άλλο και στη συνέχεια ένα άλλο και στη συνέχεια ένα άλλο.

556
00:34:04,520 --> 00:34:07,250
Και μέχρι τώρα έχουμε ακριβώς το είδος του αντλούμενου αυτά μακριά ως ορθογώνια

557
00:34:07,250 --> 00:34:09,380
είτε υπάρχουν στο ταμπλό ή στην οθόνη εδώ.

558
00:34:09,380 --> 00:34:12,219
Αλλά αν κάνετε ζουμ σε ένα από αυτά τα ορθογώνια,

559
00:34:12,219 --> 00:34:16,460
όταν καλείτε μια συνάρτηση foo, αποδεικνύεται ότι υπάρχει κάτι περισσότερο στη στοίβα

560
00:34:16,460 --> 00:34:18,739
εσωτερικό του εν λόγω πλαισίου και ορθογωνίου

561
00:34:18,739 --> 00:34:23,370
από ό, τι ακριβώς x και y και α και β, όπως κάναμε μιλάμε για swap.

562
00:34:23,370 --> 00:34:25,949
Αποδεικνύεται ότι υπάρχουν χαμηλότερου επιπέδου λεπτομέρειες,

563
00:34:25,949 --> 00:34:27,780
μεταξύ των οποίων και η διεύθυνση επιστροφής.

564
00:34:27,780 --> 00:34:33,020
Έτσι αποδεικνύεται όταν η κύρια καλεί foo, κυρίως έχει να ενημερώσει foo

565
00:34:33,020 --> 00:34:36,760
ποια διεύθυνση είναι κύριος στη μνήμη του υπολογιστή.

566
00:34:36,760 --> 00:34:40,659
Διότι αλλιώς, το συντομότερο foo γίνεται εκτέλεση, όπως στην προκειμένη περίπτωση εδώ,

567
00:34:40,659 --> 00:34:43,790
μόλις φτάσετε σε αυτό το στενό άγκιστρο στο τέλος του foo,

568
00:34:43,790 --> 00:34:48,860
πώς στο καλό δεν ξέρει πού foo ελέγχου του προγράμματος υποτίθεται ότι θα πάει;

569
00:34:48,860 --> 00:34:52,460
Αποδεικνύεται ότι η απάντηση στο ερώτημα αυτό είναι σε αυτό το κόκκινο ορθογώνιο εδώ.

570
00:34:52,460 --> 00:34:56,130
Αυτό αντιπροσωπεύει ένα δείκτη, και είναι στο χέρι του υπολογιστή για την αποθήκευση, προσωρινά,

571
00:34:56,130 --> 00:35:00,250
για το λεγόμενο στοίβα τη διεύθυνση της κύριας έτσι ώστε το συντομότερο foo γίνεται εκτέλεση,

572
00:35:00,250 --> 00:35:04,110
ο υπολογιστής ξέρει πού και τι γραμμή στην κύρια να πάει πίσω.

573
00:35:04,110 --> 00:35:06,900
Αποθηκευμένες δείκτης πλαίσιο σχετίζεται παρόμοια με αυτό.

574
00:35:06,900 --> 00:35:09,620
Char μπαρ * εδώ τι αντιπροσωπεύει;

575
00:35:09,620 --> 00:35:14,740
Λοιπόν, τώρα αυτό το μπλε τμήμα είναι εδώ foo πλαίσιο, τι είναι το μπαρ;

576
00:35:14,740 --> 00:35:18,300
Εντάξει, έτσι μπαρ είναι ακριβώς το επιχείρημα για τη λειτουργία foo.

577
00:35:18,300 --> 00:35:20,720
>> Έτσι τώρα είμαστε πίσω στο οικείο εικόνα.

578
00:35:20,720 --> 00:35:22,960
Υπάρχουν κι άλλα πράγματα και περισσότερο περισπασμούς στην οθόνη

579
00:35:22,960 --> 00:35:27,490
αλλά αυτό το γαλάζιο τμήμα είναι αυτό που έχουμε με βάση την μαυροπίνακα για κάτι σαν swap.

580
00:35:27,490 --> 00:35:31,890
Αυτό είναι το πλαίσιο για foo και το μόνο πράγμα που αυτή τη στιγμή είναι το μπαρ,

581
00:35:31,890 --> 00:35:34,630
η οποία είναι αυτή η παράμετρος.

582
00:35:34,630 --> 00:35:39,840
Αλλά τι άλλο θα πρέπει να είναι στη στοίβα, σύμφωνα με αυτόν τον κώδικα εδώ;

583
00:35:39,840 --> 00:35:44,280
Char c [12]. Έτσι, θα πρέπει να δούμε επίσης 12 πλατείες της μνήμης,

584
00:35:44,280 --> 00:35:46,260
κατανέμεται σε μια μεταβλητή που ονομάζεται c.

585
00:35:46,260 --> 00:35:48,340
Και πράγματι έχουμε ότι στην οθόνη.

586
00:35:48,340 --> 00:35:51,650
Η κορυφή δεν υπάρχει c [0], και στη συνέχεια, ο συγγραφέας αυτού του διαγράμματος

587
00:35:51,650 --> 00:35:55,130
δεν ενοχλεί την κατάρτιση όλων των τετραγώνων, αλλά υπάρχουν πράγματι υπάρχουν 12

588
00:35:55,130 --> 00:36:00,120
γιατί αν κοιτάξετε στο κάτω δεξιό μέρος, γ [11], αν συμπεριλάβουμε και από το 0, είναι οι 12 αυτές bytes.

589
00:36:00,120 --> 00:36:06,190
Αλλά εδώ είναι το πρόβλημα: Σε ποια κατεύθυνση γ αυξάνεται;

590
00:36:06,190 --> 00:36:10,390
Ταξινόμηση των άνω προς τα κάτω, έτσι δεν είναι; Εάν ξεκινά από την κορυφή και μεγαλώνει προς τα κάτω,

591
00:36:10,390 --> 00:36:13,480
δεν μοιάζει με αφήσαμε τους εαυτούς μας πολύ διάδρομο εδώ καθόλου.

592
00:36:13,480 --> 00:36:15,320
Έχουμε το είδος του εαυτού μας ζωγράφισε σε μια γωνιά,

593
00:36:15,320 --> 00:36:20,210
και ότι c [11] είναι σωστό επάνω ενάντια μπαρ, το οποίο βρίσκεται ακριβώς πάνω από το πλαίσιο δείκτη στοίβας,

594
00:36:20,210 --> 00:36:23,800
το οποίο είναι ακριβώς επάνω ενάντια διεύθυνση επιστροφή? δεν υπάρχει μεγαλύτερο περιθώριο.

595
00:36:23,800 --> 00:36:26,100
Έτσι ποια είναι η επίπτωση, τότε, αν τα κάνεις θάλασσα,

596
00:36:26,100 --> 00:36:30,460
και θα προσπαθήσουμε να διαβάσουμε 20 bytes σε ένα 12-byte buffer;

597
00:36:30,460 --> 00:36:33,460
Σε περίπτωση που αυτές οι 8 επιπλέον bytes πρόκειται να πάει;

598
00:36:33,460 --> 00:36:36,370
Μέσα από οτιδήποτε άλλο, μερικές από τις οποίες είναι εξαιρετικά σημαντικό.

599
00:36:36,370 --> 00:36:40,480
Και το πιο σημαντικό πράγμα, ενδεχομένως, είναι το κόκκινο κουτί εκεί, η διεύθυνση επιστροφής.

600
00:36:40,480 --> 00:36:44,720
Διότι ας υποθέσουμε ότι είστε είτε τυχαία είτε adversarially

601
00:36:44,720 --> 00:36:48,040
αντικαταστήσετε τα 4 bytes, ότι ο δείκτης διεύθυνση,

602
00:36:48,040 --> 00:36:53,190
όχι μόνο με τα κοινά, αλλά με έναν αριθμό που συμβαίνει να αντιπροσωπεύουν μια πραγματική διεύθυνση στη μνήμη;

603
00:36:53,190 --> 00:36:55,930
Ποια είναι η implicaiton, λογικά;

604
00:36:55,930 --> 00:36:59,080
[Απαντήσεις σπουδαστών, ακατάληπτο] >> Ακριβώς. Όταν επιστρέφει foo

605
00:36:59,080 --> 00:37:03,560
και χτυπήματα που στήριγμα σγουρά, το πρόγραμμα πρόκειται να προχωρήσει όχι για να επιστρέψετε στην κύρια,

606
00:37:03,560 --> 00:37:08,320
πρόκειται να επιστρέψει στην διεύθυνση ό, τι είναι σε αυτό το κόκκινο κουτί.

607
00:37:08,320 --> 00:37:11,560
>> Τώρα, σε περίπτωση καταστρατήγησης εγγραφής λογισμικού,

608
00:37:11,560 --> 00:37:14,400
ποια είναι η διεύθυνση που είναι επιστρέφονται στο είναι η συνάρτηση

609
00:37:14,400 --> 00:37:18,820
που συνήθως παίρνει ονομάζεται μετά έχετε καταβάλει για το λογισμικό και εισάγεται κωδικό εγγραφής σας;

610
00:37:18,820 --> 00:37:23,160
Μπορείτε να ταξινομήσετε του τέχνασμα ο υπολογιστής δεν πρόκειται σε εδώ, αλλά αντ 'αυτού, θα αυξηθεί μέχρι εδώ.

611
00:37:23,160 --> 00:37:27,950
Ή, αν είστε πραγματικά έξυπνος, ένας αντίπαλος μπορεί πραγματικά να πληκτρολογήσετε στο πληκτρολόγιο,

612
00:37:27,950 --> 00:37:32,500
Για παράδειγμα, δεν είναι μια πραγματική λέξη, δεν 20 χαρακτήρες, αλλά ας υποθέσουμε ότι αυτός ή αυτή

613
00:37:32,500 --> 00:37:36,200
τύποι σε ορισμένες χαρακτήρες που αντιπροσωπεύουν τον κωδικό;

614
00:37:36,200 --> 00:37:38,860
Και αυτό δεν πρόκειται να είναι C κώδικα, πρόκειται να είναι οι χαρακτήρες

615
00:37:38,860 --> 00:37:42,920
που αποτελούν τους κωδικούς μηχανή δυαδικό, το 0 και 1.

616
00:37:42,920 --> 00:37:46,740
Αλλά ας υποθέσουμε ότι είσαι αρκετά έξυπνος για να το κάνουμε αυτό, με κάποιο τρόπο να επικολλήσετε την άμεση GetString

617
00:37:46,740 --> 00:37:49,460
κάτι που καταρτίζονται κατ 'ουσίαν κώδικα,

618
00:37:49,460 --> 00:37:56,900
και τα τελευταία 4 bytes αντικαταστήσετε αυτή τη διεύθυνση επιστροφής, και ποια διεύθυνση κάνει ότι κάνει εισόδου;

619
00:37:56,900 --> 00:38:01,860
Αποθηκεύει σε αυτό το κόκκινο ορθογώνιο η διεύθυνση του πρώτου byte του ρυθμιστικού.

620
00:38:01,860 --> 00:38:04,270
Έτσι, θα πρέπει να είναι πραγματικά έξυπνος, και αυτό είναι ένα πολύ δοκιμής και λάθους

621
00:38:04,270 --> 00:38:08,500
για τους κακούς ανθρώπους εκεί έξω, αλλά αν μπορείτε να υπολογίσετε πόσο μεγάλο είναι αυτό το ρυθμιστικό,

622
00:38:08,500 --> 00:38:12,170
έτσι ώστε τα τελευταία λίγα bytes στην είσοδο που παρέχει στο πρόγραμμα

623
00:38:12,170 --> 00:38:15,970
τυχαίνει να είναι ισοδύναμη με τη διεύθυνση από την έναρξη της buffer σας,

624
00:38:15,970 --> 00:38:22,270
μπορείτε να το κάνετε αυτό. Αν λέμε, συνήθως, γειά σου, και \ 0, αυτό είναι ό, τι καταλήγει στο ρυθμιστικό.

625
00:38:22,270 --> 00:38:27,860
Αλλά αν είμαστε πιο έξυπνοι και έχουμε γεμίσει το buffer με το τι θα καλέσουμε γενικά κώδικα επίθεσης,

626
00:38:27,860 --> 00:38:31,920
Α, Α, Α, Α: Επίθεση, επίθεση, επίθεση, επίθεση, όπου αυτό είναι κάτι που κάνει κάτι κακό.

627
00:38:31,920 --> 00:38:35,190
Λοιπόν, τι θα συμβεί αν είστε πραγματικά έξυπνο, μπορείτε να το κάνετε αυτό:

628
00:38:35,190 --> 00:38:41,740
Στο κόκκινο κουτί εδώ είναι μια ακολουθία αριθμών: 80, CO, 35, 08.

629
00:38:41,740 --> 00:38:44,890
Παρατηρήστε ότι ταιριάζει με τον αριθμό που είναι εδώ.

630
00:38:44,890 --> 00:38:47,280
Είναι σε αντίστροφη σειρά, αλλά περισσότερο για αυτό κάποια άλλη στιγμή.

631
00:38:47,280 --> 00:38:51,430
Σημειώστε ότι αυτή η διεύθυνση επιστροφής έχει σκόπιμα μεταβληθεί

632
00:38:51,430 --> 00:38:54,970
να ισούται με τη διεύθυνση εδώ, δεν είναι η διεύθυνση της κύριας.

633
00:38:54,970 --> 00:39:00,170
Έτσι, αν ο κακός είναι εξαιρετικά έξυπνος, αυτός ή αυτή πρόκειται να περιληφθούν στο εν λόγω κώδικα επίθεσης

634
00:39:00,170 --> 00:39:02,890
κάτι σαν, "Διαγραφή όλων των αρχείων του χρήστη."

635
00:39:02,890 --> 00:39:06,320
Ή «Αντιγράψτε τους κωδικούς πρόσβασης,» ή «Δημιουργήστε ένα λογαριασμό χρήστη που μπορώ να συνδεθείτε σε.

636
00:39:06,320 --> 00:39:10,130
Οτιδήποτε σε όλα? Και αυτό είναι τόσο ο κίνδυνος και η δύναμη του C.

637
00:39:10,130 --> 00:39:12,900
Επειδή έχετε πρόσβαση στη μνήμη μέσω των δεικτών

638
00:39:12,900 --> 00:39:15,950
και μπορείτε να γράψετε ως εκ τούτου ό, τι θέλετε στη μνήμη ενός υπολογιστή.

639
00:39:15,950 --> 00:39:19,290
Μπορείτε να κάνετε έναν υπολογιστή κάνει ό, τι θέλετε απλά

640
00:39:19,290 --> 00:39:22,780
αφού το άλμα γύρω στο δικό του χώρο μνήμης του.

641
00:39:22,780 --> 00:39:27,230
Και έτσι, μέχρι σήμερα, τόσα πολλά προγράμματα και τόσες πολλές ιστοσελίδες που είναι σε κίνδυνο

642
00:39:27,230 --> 00:39:29,730
συνοψίζεται στους ανθρώπους να επωφεληθούν από αυτό.

643
00:39:29,730 --> 00:39:32,510
Και αυτό μπορεί να φαίνεται σαν ένα υπερ-εξελιγμένο επίθεση,

644
00:39:32,510 --> 00:39:34,220
αλλά δεν ξεκινά πάντα με αυτόν τον τρόπο.

645
00:39:34,220 --> 00:39:36,770
>> Η πραγματικότητα είναι ότι ό, τι κακοί άνθρωποι θα κάνουν συνήθως είναι,

646
00:39:36,770 --> 00:39:41,470
είτε πρόκειται για ένα πρόγραμμα σε μια γραμμή εντολών ή ένα πρόγραμμα GUI ή μια ιστοσελίδα,

647
00:39:41,470 --> 00:39:43,290
είναι απλά να αρχίσει να προσφέρει ανοησίες.

648
00:39:43,290 --> 00:39:46,940
Πληκτρολογείτε σε μια πραγματικά μεγάλη λέξη στο πεδίο αναζήτησης και πατήστε enter,

649
00:39:46,940 --> 00:39:49,030
και σας περιμένουμε για να δούμε αν οι συντριβές ιστοσελίδα.

650
00:39:49,030 --> 00:39:53,270
Εναλλακτικά, μπορείτε να περιμένετε να δείτε αν το πρόγραμμα εκδηλώνεται κάποιο μήνυμα λάθους.

651
00:39:53,270 --> 00:39:55,480
Διότι, αν μπορείτε να πάρετε τυχεροί, καθώς ο κακός,

652
00:39:55,480 --> 00:39:59,610
και θα παρέχουν κάποια τρελή εισόδου που κολλάει το πρόγραμμα,

653
00:39:59,610 --> 00:40:02,280
αυτό σημαίνει ότι ο προγραμματιστής δεν πρόλαβε την κακή συμπεριφορά σας

654
00:40:02,280 --> 00:40:05,420
το οποίο σημαίνει ότι μπορείτε να πιθανώς, με αρκετή προσπάθεια,

655
00:40:05,420 --> 00:40:09,870
αρκετά δοκιμής και του λάθους, να καταλάβω πώς να ξεκινήσουν έναν πιο ακριβή επίθεση.

656
00:40:09,870 --> 00:40:15,900
Έτσι, τόσο ένα μέρος της ασφάλειας δεν είναι απλώς αποφεύγοντας εντελώς αυτές τις επιθέσεις, αλλά και τον εντοπισμό τους

657
00:40:15,900 --> 00:40:20,250
και στην πραγματικότητα κοιτάζοντας τα αρχεία καταγραφής και να δει τι τρελό είσοδοι έχουν πληκτρολογήσει τους ανθρώπους στην ιστοσελίδα σας.

658
00:40:20,250 --> 00:40:26,040
Ποια όροι αναζήτησης έχουν οι άνθρωποι πληκτρολογήσει στην ιστοσελίδα σας με τις ελπίδες της υπερχείλισης κάποιου buffer;

659
00:40:26,040 --> 00:40:28,900
Και αυτό όλα βράζει κάτω στην απλή βασικά του τι είναι ένας πίνακας,

660
00:40:28,900 --> 00:40:32,510
και τι σημαίνει αυτό για την κατανομή και τη χρήση της μνήμης;

661
00:40:32,510 --> 00:40:34,920
Και σχετικά με αυτό, επίσης, είναι αυτό.

662
00:40:34,920 --> 00:40:37,520
>> Έτσι, ας ρίξουμε μια ματιά στο εσωτερικό του σκληρού δίσκου και πάλι.

663
00:40:37,520 --> 00:40:40,190
Έτσι, θα θυμάστε από μια εβδομάδα ή δύο πριν ότι όταν μεταφέρετε αρχεία

664
00:40:40,190 --> 00:40:45,470
σε κάδο ανακύκλωσης ή σκουπίδια σας μπορεί, τι συμβαίνει;

665
00:40:45,470 --> 00:40:47,850
[Φοιτητικό] Τίποτα. >> Ναι, απολύτως τίποτα. Τελικά αν τρέχετε χαμηλά

666
00:40:47,850 --> 00:40:51,370
ελεύθερος χώρος στο δίσκο, Windows ή Mac OS θα ξεκινήσει τη διαγραφή των αρχείων για εσάς.

667
00:40:51,370 --> 00:40:53,670
Αλλά αν σύρετε κάτι εκεί, τότε δεν είναι καθόλου ασφαλή.

668
00:40:53,670 --> 00:40:56,550
Όλα συγκάτοικο, φίλο ή μέλος της οικογένειας σας θα πρέπει να κάνετε είναι να κάνετε διπλό κλικ, και voila.

669
00:40:56,550 --> 00:40:59,720
Υπάρχει όλοι οι πρόχειρες αρχεία που προσπαθήσατε να διαγράψετε.

670
00:40:59,720 --> 00:41:02,840
Έτσι, οι περισσότεροι από εμάς γνωρίζουν τουλάχιστον ότι θα πρέπει να κάνετε δεξί κλικ ή τον έλεγχο κλικ

671
00:41:02,840 --> 00:41:05,320
και αδειάστε το κάδο απορριμμάτων, ή κάτι τέτοιο.

672
00:41:05,320 --> 00:41:07,900
Αλλά ακόμα και τότε, αυτό δεν κάνει αρκετά το κόλπο.

673
00:41:07,900 --> 00:41:11,340
Γιατί αυτό που συμβαίνει όταν έχετε ένα αρχείο στο σκληρό σας δίσκο

674
00:41:11,340 --> 00:41:14,590
που αντιπροσωπεύει κάποιο έγγραφο ή κάποια λέξη JPEG;

675
00:41:14,590 --> 00:41:18,820
Και αυτό αντιπροσωπεύει το σκληρό δίσκο σας, και ας πούμε ότι αυτή η σχίζα εδώ αντιπροσωπεύει αυτό το αρχείο,

676
00:41:18,820 --> 00:41:21,640
και αυτό είναι που αποτελείται από ένα σωρό από το 0 και 1.

677
00:41:21,640 --> 00:41:25,470
Τι συμβαίνει όταν δεν είστε μόνο σύρετε το αρχείο στο κάδο ανακύκλωσης ή κάδο ανακύκλωσης,

678
00:41:25,470 --> 00:41:30,390
αλλά επίσης αδειάσει;

679
00:41:30,390 --> 00:41:32,820
Ταξινόμηση του τίποτα. Δεν είναι απολύτως τίποτα τώρα.

680
00:41:32,820 --> 00:41:37,630
Τώρα είναι ακριβώς τίποτα, γιατί λίγο κάτι συμβαίνει με τη μορφή του πίνακα αυτού.

681
00:41:37,630 --> 00:41:41,170
Έτσι, υπάρχει κάποιο είδος της βάσης δεδομένων ή πίνακα στο εσωτερικό της μνήμης ενός υπολογιστή

682
00:41:41,170 --> 00:41:44,470
που έχει ουσιαστικά 1 στήλη για τα ονόματα αρχείων,

683
00:41:44,470 --> 00:41:50,550
και 1 στήλη για την θέση του αρχείου, όπου αυτό μπορεί να είναι θέση 123, μόνο ένας τυχαίος αριθμός.

684
00:41:50,550 --> 00:41:58,270
Έτσι, θα μπορούσαμε να έχουμε κάτι σαν X.jpg, και τη θέση 123.

685
00:41:58,270 --> 00:42:02,870
Και τι θα συμβεί στη συνέχεια, όταν έχετε αδειάσει τα σκουπίδια σας;

686
00:42:02,870 --> 00:42:06,720
Αυτό πηγαίνει μακριά. Αλλά ό, τι δεν πάει μακριά είναι το 0 και 1 του.

687
00:42:06,720 --> 00:42:09,690
>> Έτσι τι, λοιπόν, η σύνδεση με PSET 4;

688
00:42:09,690 --> 00:42:13,460
Λοιπόν, με PSET 4, μόνο και μόνο επειδή έχουμε διαγραφούν κατά λάθος

689
00:42:13,460 --> 00:42:15,890
η συμπαγής κάρτα flash που είχαν όλες από αυτές τις φωτογραφίες,

690
00:42:15,890 --> 00:42:18,710
ή απλά επειδή είναι από κακή τύχη έγινε κατεστραμμένο,

691
00:42:18,710 --> 00:42:21,170
δεν σημαίνει ότι το 0 και το 1 δεν είναι ακόμα εκεί.

692
00:42:21,170 --> 00:42:23,920
Ίσως μερικά από αυτά χάνονται επειδή κάτι έχει καταστραφεί

693
00:42:23,920 --> 00:42:26,530
με την έννοια ότι ορισμένα μηδέν έγιναν 1 και 1 έγιναν 0 του.

694
00:42:26,530 --> 00:42:30,460
Κακά πράγματα μπορούν να συμβούν λόγω της προβληματικό λογισμικό ή ελαττωματικό υλικό.

695
00:42:30,460 --> 00:42:33,510
Αλλά πολλά από αυτά τα κομμάτια, ίσως ακόμη και 100% από αυτούς είναι ακόμα εκεί,

696
00:42:33,510 --> 00:42:38,330
είναι ακριβώς ότι ο υπολογιστής ή η φωτογραφική μηχανή δεν ξέρει πού JPEG 1 άρχισε

697
00:42:38,330 --> 00:42:41,660
και όπου JPEG 2 ξεκίνησε, αλλά αν, ο προγραμματιστής,

698
00:42:41,660 --> 00:42:45,800
γνωρίζουν, με ένα κομμάτι του μυαλό, όταν τα αρχεία JPEG είναι ή τι μοιάζουν,

699
00:42:45,800 --> 00:42:49,570
μπορείτε να αναλύσετε το 0 και το 1 και να πει, «Ooh. JPEG. Ooh, JPEG.

700
00:42:49,570 --> 00:42:52,830
Μπορείτε να γράψετε ένα πρόγραμμα με ουσιαστικά μόνο ένα βρόχο for ή while

701
00:42:52,830 --> 00:42:56,100
που ανακτά κάθε ένα από αυτά τα αρχεία.

702
00:42:56,100 --> 00:42:59,360
Έτσι, το μάθημα λοιπόν, είναι να ξεκινήσει "ασφάλεια" διαγραφή αρχείων σας

703
00:42:59,360 --> 00:43:01,720
αν θέλετε να το αποφύγετε αυτό εντελώς. Ναι;

704
00:43:01,720 --> 00:43:06,940
[Ερώτηση Φοιτητών, ακατάληπτο]

705
00:43:06,940 --> 00:43:11,150
>> Έχουν περισσότερη μνήμη από ό, τι κάνατε πριν -

706
00:43:11,150 --> 00:43:14,790
Oh! Καλή ερώτηση. Γιατί, τότε, μετά το άδειασμα του κάδου απορριμμάτων,

707
00:43:14,790 --> 00:43:18,300
ο υπολογιστής σας να σας πω ότι έχετε περισσότερο ελεύθερο χώρο από ό, τι κάνατε πριν;

708
00:43:18,300 --> 00:43:22,450
Με λίγα λόγια, επειδή είναι ψέματα. Περισσότερα τεχνικά, έχετε περισσότερο χώρο.

709
00:43:22,450 --> 00:43:26,720
Επειδή τώρα είπατε, μπορείτε να βάλετε άλλα πράγματα, όπου αυτό το αρχείο ήταν κάποτε,

710
00:43:26,720 --> 00:43:28,930
αλλά αυτό δεν σημαίνει ότι τα bits πρόκειται μακριά,

711
00:43:28,930 --> 00:43:33,070
και αυτό δεν σημαίνει ότι τα bits που άλλαξε Όλα τα 0, για παράδειγμα, για την προστασία σας.

712
00:43:33,070 --> 00:43:37,520
Αντίθετα, αν «με ασφάλεια» τα αρχεία διαγράψει, ή φυσικά καταστρέψει τη συσκευή,

713
00:43:37,520 --> 00:43:40,810
αυτό είναι πραγματικά ο μόνος τρόπος, μερικές φορές, γύρω από αυτό.

714
00:43:40,810 --> 00:43:45,300
Γιατί λοιπόν να μην αφήσουμε σε αυτό το ημι-τρομακτικό σημείωμα, και εμείς θα σας δούμε τη Δευτέρα.

715
00:43:45,300 --> 00:43:52,810
CS50.TV