1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Walkthrough - Σετ Πρόβλημα 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla Chan - Πανεπιστήμιο του Χάρβαρντ]

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

4
00:00:08,210 --> 00:00:11,670
Εντάξει. Γεια σας, όλοι, και καλωσορίζουμε στο Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Σήμερα PSET μας είναι ιατροδικαστικών.

6
00:00:14,270 --> 00:00:18,080
Ιατροδικαστικών είναι ένα πραγματικά διασκεδαστικό PSET που συνεπάγεται επαφή με τα αρχεία bitmap

7
00:00:18,080 --> 00:00:21,550
να ανακαλύψουν που διέπραξαν ένα έγκλημα.

8
00:00:21,550 --> 00:00:24,200
Στη συνέχεια θα πάμε για να αλλάξετε το μέγεθος κάποια αρχεία bitmap,

9
00:00:24,200 --> 00:00:27,780
τότε είμαστε, επίσης, πρόκειται να ασχοληθεί με ένα πραγματικά διασκεδαστικό μέρος που ονομάζεται Ανάκτηση,

10
00:00:27,780 --> 00:00:31,160
στην οποία είμαστε ουσιαστικά παρέδωσε μια κάρτα μνήμης

11
00:00:31,160 --> 00:00:34,350
στην οποία κάποιος έχει διαγραφεί κατά λάθος όλα τα αρχεία τους,

12
00:00:34,350 --> 00:00:38,860
και θα σας ζητηθεί να ανακτήσει αυτά τα αρχεία.

13
00:00:38,860 --> 00:00:42,910
>> Αλλά πρώτα, πριν φτάσουμε στο PSET, εγώ πραγματικά θέλουν απλά να συγχαρώ όλους.

14
00:00:42,910 --> 00:00:45,230
Είμαστε περίπου στο μέσο του μαθήματος.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 είναι πίσω μας, και είμαστε σε pset4, τόσο ουσιαστικά, είμαστε στα μισά του δρόμου.

16
00:00:50,070 --> 00:00:55,490
Έχουμε διανύσει πολύ δρόμο, αν κοιτάξουμε πίσω στο psets σας, pset0 και pset1,

17
00:00:55,490 --> 00:00:57,300
έτσι τον εαυτό σας συγχαρώ γι 'αυτό,

18
00:00:57,300 --> 00:01:00,760
και θα πάμε να μπει σε κάποια πραγματικά διασκεδαστικό πράγματα.

19
00:01:00,760 --> 00:01:07,070
>> Έτσι εργαλειοθήκη μας για αυτό το PSET, πάλι, αντί να τρέχει sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
είμαστε σε θέση να τρέξει μόνο update50 αν είστε στην έκδοση 17,3 και πάνω από τη συσκευή.

21
00:01:13,890 --> 00:01:17,380
Έτσι να είστε βέβαιος να τρέξει update50 - είναι πολύ πιο εύκολο, μερικές λιγότερο χαρακτήρες -

22
00:01:17,380 --> 00:01:20,640
για να βεβαιωθείτε ότι είστε στην τελευταία έκδοση της συσκευής.

23
00:01:20,640 --> 00:01:25,410
Ιδιαίτερα σημαντικό είναι να update50 όταν αρχίσετε να χρησιμοποιείτε CS50 Έλεγχος.

24
00:01:25,410 --> 00:01:28,700
Έτσι, βεβαιωθείτε ότι έχετε κάνει αυτό.

25
00:01:28,700 --> 00:01:30,760
>> Για όλα τα τμήματα αυτής PSET,

26
00:01:30,760 --> 00:01:34,350
θα πάμε να ασχολούνται με εισόδους και εξόδους αρχείο, το αρχείο I / O.

27
00:01:34,350 --> 00:01:38,140
Εμείς πάμε για να πηγαίνει πέρα ​​από πολλά προγράμματα που ασχολούνται με συστοιχίες

28
00:01:38,140 --> 00:01:40,350
δείχνουν σε αρχεία και τέτοια πράγματα,

29
00:01:40,350 --> 00:01:43,050
έτσι θέλετε να βεβαιωθείτε ότι είμαστε πραγματικά οικεία και άνετα

30
00:01:43,050 --> 00:01:47,990
που ασχολούνται με το πώς να εισόδου και εξόδου σε αρχεία.

31
00:01:47,990 --> 00:01:52,080
>> Στον κώδικα της διανομής για αυτό το PSET είναι ένα αρχείο που ονομάζεται copy.c,

32
00:01:52,080 --> 00:01:55,280
και αυτό είναι που θα πάμε να βρούμε πρόκειται να είναι πραγματικά χρήσιμο να μας

33
00:01:55,280 --> 00:02:00,340
επειδή θα πάμε να καταλήξετε στην πραγματικότητα αντιγραφή του αρχείου copy.c

34
00:02:00,340 --> 00:02:05,350
και αλλάζοντας απλώς ελαφρά για να είναι σε θέση να επιτύχει τα πρώτα 2 μέρη του σετ προβλήματος.

35
00:02:05,350 --> 00:02:09,030
>> Και έτσι στη συνέχεια, όπως ανέφερα και πριν, έχουμε να κάνουμε με εικόνες bitmap, καθώς και JPEG.

36
00:02:09,030 --> 00:02:13,170
Έτσι, πραγματικά κατανόηση της δομής του πώς οργανώνονται τα αρχεία,

37
00:02:13,170 --> 00:02:16,170
πώς μπορούμε να μετατρέψουμε πραγματικά την 0s και 1s σε structs

38
00:02:16,170 --> 00:02:19,040
και πράγματα που μπορούμε πραγματικά να κατανοήσουν και να ερμηνεύσουν και να επεξεργαστείτε,

39
00:02:19,040 --> 00:02:21,000
αυτό θα είναι πολύ σημαντικό,

40
00:02:21,000 --> 00:02:25,970
ώστε να υπεισέλθω σε JPEG και αρχεία bitmap και την κατανόηση της δομής αυτών.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, ως συνήθως, ξεκινά με ένα τμήμα των ερωτήσεων.

42
00:02:30,780 --> 00:02:36,600
Εκείνοι που θα ασχοληθούν με το αρχείο I / O και να σας συνηθίσει σε αυτό.

43
00:02:36,600 --> 00:02:42,520
Στη συνέχεια, μέρος 1 είναι Whodunit, στο οποίο σας δίνεται ένα αρχείο bitmap

44
00:02:42,520 --> 00:02:45,630
που μοιάζει κάτι σαν κόκκινα στίγματα πάνω από όλα.

45
00:02:45,630 --> 00:02:52,180
Και τότε ουσιαστικά αυτό που πάμε να κάνουμε είναι να πάρετε αυτό το αρχείο και απλά να το επεξεργαστείτε λίγο

46
00:02:52,180 --> 00:02:54,010
σε μια εκδοχή που μπορεί να διαβάσει.

47
00:02:54,010 --> 00:02:56,000
Ουσιαστικά, μόλις τελειώσουμε, θα έχουμε το ίδιο αρχείο,

48
00:02:56,000 --> 00:03:02,630
εκτός θα είναι σε θέση να δείτε το κρυμμένο μήνυμα που είναι κρυμμένο από όλες αυτές τις κόκκινες κουκίδες.

49
00:03:02,630 --> 00:03:07,310
Στη συνέχεια Resize είναι ένα πρόγραμμα που, δεδομένης ένα αρχείο

50
00:03:07,310 --> 00:03:11,490
και στη συνέχεια δίνεται το όνομα του αρχείου που εξάγει και στη συνέχεια δίνεται ένας αριθμός, καθώς,

51
00:03:11,490 --> 00:03:16,850
Θα αλλάξετε το μέγεθος πραγματικά ότι bitmap από το εν λόγω ακέραια τιμή.

52
00:03:16,850 --> 00:03:19,240
Στη συνέχεια, τέλος, έχουμε την PSET Ανάκτηση.

53
00:03:19,240 --> 00:03:24,160
Μας δίνεται μια κάρτα μνήμης και στη συνέχεια να ανακτήσει όλες τις φωτογραφίες

54
00:03:24,160 --> 00:03:25,920
που έχουν διαγραφεί κατά λάθος,

55
00:03:25,920 --> 00:03:31,420
αλλά, όπως θα μάθουμε, στην πραγματικότητα δεν διαγράφονται και αφαιρείται από το αρχείο?

56
00:03:31,420 --> 00:03:38,470
έχουμε ακριβώς το είδος των χαμένων όπου ήταν το αρχείο, αλλά θα πάμε για να ανακτήσει αυτό.

57
00:03:38,470 --> 00:03:44,950
>> Μεγάλη. Έτσι, πηγαίνει στο αρχείο I / O Συγκεκριμένα, πρόκειται για μια ολόκληρη λίστα με τις λειτουργίες που θα χρησιμοποιείτε.

58
00:03:44,950 --> 00:03:49,840
Έχετε ήδη δει ένα μικρό κομμάτι από τα βασικά fopen, fread, και fwrite,

59
00:03:49,840 --> 00:03:54,350
αλλά εμείς πάμε να δούμε περαιτέρω σε κάποιο αρχείο I / O λειτουργίες όπως fputc,

60
00:03:54,350 --> 00:03:56,930
στην οποία μπορείτε να γράψετε μόνο ένα χαρακτήρα σε ένα χρόνο,

61
00:03:56,930 --> 00:04:02,000
να fseek, όπου κατά κάποιο τρόπο να μετακινήσετε το δείκτη θέσης αρχείου προς τα εμπρός και προς τα πίσω,

62
00:04:02,000 --> 00:04:05,770
και στη συνέχεια κάποιοι άλλοι. Αλλά θα πάμε σε ότι λίγο αργότερα, κατά τη διάρκεια της PSET.

63
00:04:08,050 --> 00:04:13,100
>> Έτσι, η πρώτη, μόνο και μόνο για να μπει στο αρχείο I / O πριν πάμε στο PSET,

64
00:04:13,100 --> 00:04:19,860
για να ανοίξετε ένα αρχείο, για παράδειγμα, αυτό που έχετε να κάνετε είναι να ρυθμίσετε πραγματικά ένα δείκτη σε αυτό το αρχείο.

65
00:04:19,860 --> 00:04:22,710
Έτσι έχουμε ένα δείκτη FILE *.

66
00:04:22,710 --> 00:04:27,140
Σε αυτή την περίπτωση, είμαι καλώντας το ένα στο δείκτη, διότι αυτό πρόκειται να είναι infile μου.

67
00:04:27,140 --> 00:04:33,340
Και έτσι είμαι πρόκειται να χρησιμοποιήσετε τη συνάρτηση fopen και στη συνέχεια το όνομα του αρχείου

68
00:04:33,340 --> 00:04:36,360
και στη συνέχεια ο τρόπος με τον οποίο Πάω να ασχολούνται με το αρχείο.

69
00:04:36,360 --> 00:04:42,080
Έτσι υπάρχει "r" στη συγκεκριμένη περίπτωση για την ανάγνωση, "w" για το γράψιμο, και στη συνέχεια "α" για προσάρτηση.

70
00:04:42,080 --> 00:04:44,270
Για παράδειγμα, όταν έχουμε να κάνουμε με μια infile

71
00:04:44,270 --> 00:04:47,310
και το μόνο που θέλετε να κάνετε είναι να διαβάσετε τα bits και bytes αποθηκεύονται εκεί,

72
00:04:47,310 --> 00:04:50,420
τότε πρόκειται πιθανώς να θέλετε να χρησιμοποιήσετε "r" ως τρόπος σας.

73
00:04:50,420 --> 00:04:54,520
Όταν θέλετε πραγματικά να γράφουν, το είδος του κάνει ένα νέο αρχείο,

74
00:04:54,520 --> 00:04:57,220
τότε τι θα πάμε να κάνουμε είναι να πάμε για να ανοίξετε το νέο αρχείο

75
00:04:57,220 --> 00:05:02,410
και να χρησιμοποιήσετε το "w" λειτουργία για το γράψιμο.

76
00:05:02,410 --> 00:05:07,540
>> Έτσι, στη συνέχεια, όταν είστε πραγματικά ανάγνωση σε αρχεία, η δομή έχει ως εξής.

77
00:05:07,540 --> 00:05:14,930
Πρώτα θα περιλαμβάνουν το δείκτη στο struct που θα περιέχει τα bytes που διαβάζετε.

78
00:05:14,930 --> 00:05:19,830
Έτσι, αυτό πρόκειται να είναι η θέση τέλος των bytes που διαβάζετε.

79
00:05:19,830 --> 00:05:23,360
Είσαι τότε θα δείχνουν το μέγεθος, όπως και βασικά πόσα bytes

80
00:05:23,360 --> 00:05:30,100
το πρόγραμμά σας θα πρέπει να διαβάζονται στο αρχείο, το μέγεθος ουσιαστικά είναι ένα στοιχείο,

81
00:05:30,100 --> 00:05:32,620
και στη συνέχεια θα πάμε για να καθορίσετε πόσα στοιχεία που θέλετε να διαβάσετε.

82
00:05:32,620 --> 00:05:34,980
Και τελικά, θα πρέπει να ξέρετε πού διαβάζετε από,

83
00:05:34,980 --> 00:05:37,580
έτσι ώστε να πρόκειται να είναι στο δείκτη σας.

84
00:05:37,580 --> 00:05:41,780
I χρωματικό κώδικα αυτά επειδή fread είναι επίσης πολύ παρόμοια με fwrite,

85
00:05:41,780 --> 00:05:47,050
εκτός από εσάς θέλετε να βεβαιωθείτε ότι χρησιμοποιείτε τη σωστή σειρά,

86
00:05:47,050 --> 00:05:51,960
βεβαιωθείτε ότι είστε πραγματικά γράφει ή διαβάζει από το αρχείο δεξιά.

87
00:05:54,910 --> 00:05:58,610
>> Έτσι στη συνέχεια όπως και πριν, αν έχουμε το μέγεθος του στοιχείου, καθώς και τον αριθμό των στοιχείων,

88
00:05:58,610 --> 00:06:00,600
τότε μπορούμε να παίξουμε γύρω εδώ λίγο.

89
00:06:00,600 --> 00:06:06,810
Πείτε Έχω ένα struct DOG και έτσι τότε θα θέλετε να διαβάσετε δύο σκυλιά σε ένα χρόνο.

90
00:06:06,810 --> 00:06:12,450
Τι θα μπορούσα να κάνω είναι να πω το μέγεθος ενός στοιχείου θα είναι το μέγεθος ενός DOG

91
00:06:12,450 --> 00:06:14,770
και Πάω να διαβάσετε στην πραγματικότητα δύο από αυτούς.

92
00:06:14,770 --> 00:06:18,290
Εναλλακτικά, τι θα μπορούσα να κάνω είναι να πω ότι είμαι απλώς πρόκειται να διαβάσετε ένα στοιχείο

93
00:06:18,290 --> 00:06:21,340
και ότι ένα στοιχείο πρόκειται να είναι το μέγεθος των δύο σκυλιά.

94
00:06:21,340 --> 00:06:24,320
Έτσι, αυτό είναι ανάλογο με το πώς μπορείτε να το είδος του παιχνιδιού γύρω με το μέγεθος και τον αριθμό

95
00:06:24,320 --> 00:06:28,250
ανάλογα με το τι είναι πιο διαισθητικό σε σας.

96
00:06:28,250 --> 00:06:30,810
>> Εντάξει. Έτσι τώρα έχουμε την ευκαιρία να τα αρχεία γραπτώς.

97
00:06:30,810 --> 00:06:36,880
Όταν θέλετε να γράψετε ένα αρχείο, το πρώτο επιχείρημα είναι πραγματικά όπου είστε ανάγνωση από.

98
00:06:36,880 --> 00:06:42,050
Έτσι, αυτό είναι βασικά τα δεδομένα που θα έχετε την ευκαιρία να γράψει στο αρχείο,

99
00:06:42,050 --> 00:06:44,490
η οποία είναι η έξω δείκτη στο τέλος.

100
00:06:44,490 --> 00:06:47,670
Έτσι, όταν έχουμε να κάνουμε με την PSET, φροντίστε να μην μπερδευτείτε.

101
00:06:47,670 --> 00:06:50,480
Ίσως να έχουν την πλευρά τους ορισμούς από την πλευρά.

102
00:06:50,480 --> 00:06:58,090
Μπορείτε να τραβάτε μέχρι τους ορισμούς στο εγχειρίδιο πληκτρολογώντας τον άνθρωπο και στη συνέχεια fwrite, για παράδειγμα,

103
00:06:58,090 --> 00:06:59,950
στον τερματικό σταθμό, ή μπορείτε να ανατρέχετε σε αυτό το slide

104
00:06:59,950 --> 00:07:03,570
και βεβαιωθείτε ότι χρησιμοποιείτε το σωστό.

105
00:07:03,570 --> 00:07:08,700
Έτσι, και πάλι, για fwrite, όταν έχετε ένα αρχείο που θέλετε να γράψετε σε,

106
00:07:08,700 --> 00:07:14,290
που πρόκειται να είναι το τελευταίο επιχείρημα και ότι πρόκειται να είναι ένας δείκτης σε αυτό το αρχείο.

107
00:07:14,290 --> 00:07:18,670
Έτσι, τότε αυτό είναι το πώς θα αντιμετωπίσουμε με το γράψιμο ίσως αρκετά bytes κάθε φορά,

108
00:07:18,670 --> 00:07:21,820
αλλά ας πούμε ότι θέλετε να γράψετε μόνο σε μία και μόνο χαρακτήρα.

109
00:07:21,820 --> 00:07:25,940
Όπως θα δούμε αργότερα σε αυτό το παράδειγμα, στις εικόνες bitmap θα πρέπει να χρησιμοποιήσετε αυτό.

110
00:07:25,940 --> 00:07:32,180
Αυτό είναι όταν μπορούμε να χρησιμοποιήσουμε fputc, βάζοντας ουσιαστικά μόνο ένα χαρακτήρα τη φορά, chr,

111
00:07:32,180 --> 00:07:37,050
στο δείκτη αρχείου, και ότι είναι ο δείκτης μας εκεί έξω.

112
00:07:38,700 --> 00:07:41,560
Έτσι λοιπόν κάθε φορά που ζητούν ή γράφουν σε ένα αρχείο,

113
00:07:41,560 --> 00:07:44,690
το αρχείο παρακολούθηση του πού βρισκόμαστε.

114
00:07:44,690 --> 00:07:47,810
Γι 'αυτό είναι ένα είδος του δρομέα, ο δείκτης θέσης αρχείου.

115
00:07:47,810 --> 00:07:54,330
Και έτσι κάθε φορά που γράφουν ή να διαβάζουν και πάλι σε ένα αρχείο,

116
00:07:54,330 --> 00:07:56,760
το αρχείο θυμάται πραγματικότητα όπου είναι,

117
00:07:56,760 --> 00:07:59,270
και έτσι συνεχίζει από όπου βρίσκεται ο δρομέας.

118
00:07:59,270 --> 00:08:03,970
Αυτό μπορεί να είναι ευεργετική, όταν θέλετε να, ας πούμε, σε ένα ορισμένο ποσό για να κάνει κάτι

119
00:08:03,970 --> 00:08:06,160
και στη συνέχεια σε συνδυασμό με το ακόλουθο ποσό,

120
00:08:06,160 --> 00:08:10,700
αλλά μερικές φορές μπορεί να θέλετε να πάτε πίσω ή στην πραγματικότητα ξεκινούν από μια συγκεκριμένη τιμή αναφοράς.

121
00:08:10,700 --> 00:08:16,870
Έτσι λοιπόν η λειτουργία fseek, αυτό που κάνει είναι να μας επιτρέπει να μετακινήσετε το δρομέα σε ένα συγκεκριμένο αρχείο

122
00:08:16,870 --> 00:08:19,680
ένας ορισμένος αριθμός των bytes.

123
00:08:19,680 --> 00:08:24,260
Και τότε αυτό που έχουμε να κάνουμε είναι να καθορίσετε όπου η τιμή αναφοράς είναι.

124
00:08:24,260 --> 00:08:31,520
Έτσι, είτε κινείται προς τα εμπρός ή προς τα πίσω, από όπου ο δρομέας είναι επί του παρόντος,

125
00:08:31,520 --> 00:08:35,750
ή μπορούμε να δηλώσουμε ότι θα πρέπει να προχωρήσουμε σε μόλις από την αρχή του αρχείου

126
00:08:35,750 --> 00:08:37,090
ή από το τέλος του αρχείου.

127
00:08:37,090 --> 00:08:41,230
Και έτσι μπορείτε να περάσετε σε αρνητικές ή θετικές τιμές για το ποσό,

128
00:08:41,230 --> 00:08:44,960
και ότι θα το είδος της μετακινήσετε το δρομέα προς τα εμπρός ή προς τα πίσω.

129
00:08:46,170 --> 00:08:51,920
>> Πριν φτάσουμε στις άλλες psets, οποιεσδήποτε ερωτήσεις σχετικά με το αρχείο I / O;

130
00:08:53,860 --> 00:08:59,990
Εντάξει. Όπως έχουμε μπει σε περισσότερα παραδείγματα, μην διστάσετε να με σταματήσει για ερωτήσεις.

131
00:08:59,990 --> 00:09:06,930
>> Έτσι, σε Whodunit, είστε παρέδωσε ένα αρχείο bitmap παρόμοιο με αυτό κόκκινο στη διαφάνεια,

132
00:09:06,930 --> 00:09:14,510
και μοιάζει με αυτό - ένα μάτσο κόκκινα στίγματα - και εσείς δεν ξέρει πραγματικά τι είναι γραμμένο.

133
00:09:14,510 --> 00:09:23,310
Αν στραβισμός, μπορείτε να είστε σε θέση να δείτε μια μικρή μπλε χρώμα μέσα στη μέση.

134
00:09:23,310 --> 00:09:26,270
Ουσιαστικά, αυτό είναι όπου το κείμενο είναι αποθηκευμένο.

135
00:09:26,270 --> 00:09:30,270
Υπήρξε μια δολοφονία που συνέβη, και πρέπει να βρούμε ποιος το έκανε.

136
00:09:30,270 --> 00:09:36,760
Για να το κάνουμε αυτό, θα πρέπει να μετατρέψετε το είδος της αυτή την εικόνα σε αναγνώσιμη μορφή.

137
00:09:36,760 --> 00:09:42,740
Αν έχετε παιδιά που αντιμετωπίζουν ποτέ αυτό, μερικές φορές θα υπάρξει μικρή κιτ

138
00:09:42,740 --> 00:09:48,510
όπου θα έχετε ένα μεγεθυντικό φακό με ένα κόκκινο ταινία. Όποιος; Ναι.

139
00:09:48,510 --> 00:09:52,770
Έτσι, θα είναι σε χέρια κάτι τέτοιο, θα έχετε ένα μεγεθυντικό φακό

140
00:09:52,770 --> 00:09:58,130
με την κόκκινη ταινία πάνω του, θα το θέσω πάνω από την εικόνα,

141
00:09:58,130 --> 00:10:03,410
και θα είναι σε θέση να δείτε το μήνυμα που είναι κρυμμένο σ 'αυτό.

142
00:10:03,410 --> 00:10:07,080
Δεν έχουμε ένα μεγεθυντικό φακό με κόκκινο ταινία, έτσι ώστε αντί να πάμε να το είδος του δημιουργήσουν τα δικά μας

143
00:10:07,080 --> 00:10:09,060
σε αυτή PSET.

144
00:10:09,060 --> 00:10:15,760
Και έτσι ο χρήστης θα αστυνομικό θεατρικό έργο εισόδου, τότε η ένδειξη,. Bmp,

145
00:10:15,760 --> 00:10:18,800
έτσι ώστε να είναι η infile, που είναι η κόκκινη κουκκίδα μήνυμα,

146
00:10:18,800 --> 00:10:23,550
και στη συνέχεια να λένε verdict.bmp πρόκειται να είναι outfile μας.

147
00:10:23,550 --> 00:10:27,900
Έτσι, πρόκειται να δημιουργηθεί μια νέα εικόνα bitmap παρόμοια με την ιδέα ενός

148
00:10:27,900 --> 00:10:32,600
εκτός σε αναγνώσιμη μορφή, όπου μπορούμε να δούμε το κρυμμένο μήνυμα.

149
00:10:32,600 --> 00:10:37,550
>> Από τη στιγμή που πάμε να ασχολείται με την επεξεργασία και το χειρισμό των bitmaps κάποιου είδους,

150
00:10:37,550 --> 00:10:42,400
θα πάμε να το είδος της κατάδυσης σε στη δομή αυτών των αρχείων bitmap.

151
00:10:42,400 --> 00:10:48,130
Πήγαμε πάνω από αυτά λίγο σε διάλεξη, αλλά ας ρίξουμε μια ματιά σε αυτά λίγο περισσότερο.

152
00:10:48,130 --> 00:10:51,740
Bitmaps είναι ουσιαστικά μόνο μια διάταξη των bytes

153
00:10:51,740 --> 00:10:55,790
όπου έχουμε ορίζεται bytes το οποίο σημαίνει τι.

154
00:10:55,790 --> 00:11:00,540
Έτσι, εδώ είναι κάτι σαν ένα χάρτη της εικόνα bitmap

155
00:11:00,540 --> 00:11:08,550
λέγοντας ότι αρχίζει με ορισμένα αρχεία κεφαλίδας, ξεκινά με κάποιες πληροφορίες εκεί.

156
00:11:08,550 --> 00:11:16,540
Βλέπετε ότι σε περίπου αριθμό 14 byte το μέγεθος υποδεικνύεται από την εικόνα bitmap,

157
00:11:16,540 --> 00:11:18,520
και συνεχίζεται.

158
00:11:18,520 --> 00:11:23,810
Αλλά τότε τι είμαστε πραγματικά ενδιαφέρει εδώ είναι που αρχίζει γύρω byte αριθμό 54.

159
00:11:23,810 --> 00:11:26,060
Έχουμε αυτές τις τριάδες RGB.

160
00:11:26,060 --> 00:11:30,760
Τι το οποίο πρόκειται να κάνουμε είναι να περιέχει τα πραγματικά pixels, οι τιμές χρώματος.

161
00:11:30,760 --> 00:11:35,950
Τα πάντα πάνω από ότι στην κεφαλίδα είναι μερικές πληροφορίες

162
00:11:35,950 --> 00:11:41,240
που αντιστοιχεί στο μέγεθος της εικόνας, το πλάτος της εικόνας, και το ύψος.

163
00:11:41,240 --> 00:11:44,930
Όταν πάμε σε padding αργότερα, θα δούμε γιατί το μέγεθος της εικόνας

164
00:11:44,930 --> 00:11:48,670
θα μπορούσε να είναι διαφορετικό από το πλάτος ή το ύψος του.

165
00:11:48,670 --> 00:11:54,240
Έτσι, στη συνέχεια, να εκπροσωπούν αυτές - οι bitmap εικόνες είναι ακολουθίες από bytes -

166
00:11:54,240 --> 00:11:59,370
τι θα μπορούσαμε να κάνουμε είναι να πω εντάξει, θα πάω να θυμόμαστε ότι στο δείκτη 14,

167
00:11:59,370 --> 00:12:03,380
αυτό είναι όπου το μέγεθος είναι, για παράδειγμα, αλλά τι θα πάμε να κάνουμε για να κάνουν αυτό το πιο εύκολο

168
00:12:03,380 --> 00:12:06,020
είναι αυτό εγκλεισμό σε ένα struct.

169
00:12:06,020 --> 00:12:08,880
Και έτσι έχουμε δύο structs γίνονται για εμάς, μια BITMAPFILEHEADER

170
00:12:08,880 --> 00:12:10,440
και ένα BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
και έτσι κάθε φορά που διαβάζουμε σε σε αυτό το αρχείο, από προεπιλογή πρόκειται να πηγαίνουν σε τάξη,

172
00:12:14,840 --> 00:12:22,360
και έτσι ώστε να είναι, επίσης, πρόκειται να συμπληρώσετε σε μεταβλητές όπως biWidth και biSize.

173
00:12:25,270 --> 00:12:31,230
Και τελικά, κάθε pixel αντιπροσωπεύεται από τρία bytes.

174
00:12:31,230 --> 00:12:35,500
Η πρώτη είναι η ποσότητα του μπλε του εικονοστοιχείου, η δεύτερη είναι η ποσότητα του πράσινου,

175
00:12:35,500 --> 00:12:41,120
και τέλος, η ποσότητα του κόκκινου, όπου το 0 είναι ουσιαστικά όχι μπλε ή καθόλου πράσινο ή όχι κόκκινο

176
00:12:41,120 --> 00:12:43,720
και στη συνέχεια ff είναι η μέγιστη τιμή.

177
00:12:43,720 --> 00:12:46,800
Αυτά είναι δεκαεξαδικές τιμές.

178
00:12:46,800 --> 00:12:53,870
Έτσι λοιπόν, αν έχουμε ff0000, στη συνέχεια, ότι αντιστοιχεί στο μέγιστο ποσό των μπλε

179
00:12:53,870 --> 00:12:58,890
και στη συνέχεια, δεν υπάρχει κανένα πράσινο και κόκκινο χρώμα, έτσι τότε αυτό θα μας δώσει μια μπλε pixel.

180
00:12:58,890 --> 00:13:04,190
Στη συνέχεια, αν έχουμε όλα τα ff του σε όλους τους τομείς, τότε αυτό σημαίνει ότι έχουμε ένα λευκό pixel.

181
00:13:04,190 --> 00:13:11,370
Αυτό είναι το είδος της απέναντι συνήθως όταν λέμε RGB. Είναι πρόκειται πραγματικά BGR.

182
00:13:12,750 --> 00:13:18,990
>> Έτσι, αν θέλουμε πραγματικά να κοιτάξουμε σε ένα παράδειγμα από μια εικόνα bitmap - επιτρέψτε μου ένα τραβήξει μέχρι εδώ.

183
00:13:31,560 --> 00:13:33,830
Είναι λίγο μικρό.

184
00:13:39,890 --> 00:13:47,840
Είμαι μεγέθυνση, και μπορούμε να δούμε ότι είναι pixelated. Μοιάζει με μπλοκ του χρώματος.

185
00:13:47,840 --> 00:13:50,110
Έχετε λευκό μπλοκ και στη συνέχεια κόκκινο μπλοκ.

186
00:13:50,110 --> 00:13:53,700
Αν παίζετε στη Ζωγραφική της Microsoft, για παράδειγμα, θα μπορούσατε να κάνετε κάτι τέτοιο

187
00:13:53,700 --> 00:13:58,960
με βασικά ζωγραφική μόνο κάποια τετράγωνα σε μια συγκεκριμένη σειρά.

188
00:13:58,960 --> 00:14:08,060
Και τότε τι αυτό μεταφράζεται στο bitmap έχει ως εξής.

189
00:14:08,060 --> 00:14:15,710
Εδώ έχουμε πρώτα λευκά pixels, ότι όλες οι 6 είναι της f, και τότε θα έχουμε κόκκινα εικονοστοιχεία,

190
00:14:15,710 --> 00:14:19,910
υποδεικνύεται από 0000FF.

191
00:14:19,910 --> 00:14:27,940
Και έτσι η ακολουθία των bytes που έχουμε δείχνουν πως η εικόνα bitmap πρόκειται να δούμε.

192
00:14:27,940 --> 00:14:32,230
Έτσι, ό, τι έχω κάνει εδώ ακριβώς είναι γραμμένο από όλα αυτά τα bytes και στη συνέχεια χρώμα στο κόκκινο

193
00:14:32,230 --> 00:14:37,550
ώστε να μπορείτε να δείτε το είδος του, αν στραβισμός λίγο, πώς αυτό το είδος του δείχνει ένα χαμογελαστό πρόσωπο.

194
00:14:40,180 --> 00:14:46,390
>> Ο τρόπος που bitmap εικόνες είναι έργο μου οραματίζονται ουσιαστικά ως ένα πλέγμα.

195
00:14:46,390 --> 00:14:54,940
Και έτσι από προεπιλογή, κάθε γραμμή του πλέγματος πρέπει να είναι πολλαπλάσιο του 4 bytes.

196
00:15:00,520 --> 00:15:07,060
Αν κοιτάξουμε σε μια εικόνα bitmap, είστε συμπληρώνοντας κάθε αξία.

197
00:15:07,060 --> 00:15:17,370
Για παράδειγμα, μπορεί να έχετε ένα κόκκινο, ένα πράσινο εδώ εδώ, ένα μπλε εδώ,

198
00:15:17,370 --> 00:15:24,950
αλλά θα πρέπει να βεβαιωθείτε ότι η εικόνα συμπληρώνεται με ένα πολλαπλάσιο του τέσσερα bytes.

199
00:15:24,950 --> 00:15:32,200
Έτσι, αν θέλω να μου εικόνα είναι τρία τετράγωνα ευρύ, τότε θα πρέπει να βάλετε μια κενή τιμή

200
00:15:32,200 --> 00:15:35,640
στο τελευταίο να καταστεί ένα πολλαπλάσιο των τεσσάρων.

201
00:15:35,640 --> 00:15:39,530
Έτσι λοιπόν θα ήθελα να προσθέσω κάτι στο οποίο είμαστε καλώντας padding.

202
00:15:39,530 --> 00:15:43,750
Είμαι ακριβώς πρόκειται να δείξει ότι υπάρχουν με x.

203
00:15:44,920 --> 00:15:54,160
Τώρα λέμε ότι θέλουμε μια εικόνα που είναι 7 pixels καιρό, για παράδειγμα.

204
00:15:54,160 --> 00:15:59,550
Έχουμε 1, 2, 3, 4, 5, 6, 7,

205
00:16:04,750 --> 00:16:07,000
και όλα αυτά είναι γεμάτη με χρώμα.

206
00:16:07,000 --> 00:16:10,620
Ο τρόπος που λειτουργεί bitmap εικόνες είναι ότι χρειαζόμαστε μια 8ο.

207
00:16:10,620 --> 00:16:12,460
Αυτή τη στιγμή έχουμε 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Χρειαζόμαστε 8 θέσεις για την εικόνα bitmap να διαβάσει σωστά.

209
00:16:19,360 --> 00:16:25,600
Και τότε τι θα πρέπει να κάνετε είναι να προσθέσετε σε μόλις ένα κομμάτι του padding

210
00:16:25,600 --> 00:16:29,430
για να βεβαιωθείτε ότι όλα τα πλάτη είναι ενιαίες

211
00:16:29,430 --> 00:16:34,260
και ότι όλα τα πλάτη είναι πολλαπλάσιο του 4.

212
00:16:42,110 --> 00:16:47,310
Και γι 'αυτό αναφέρθηκε προηγουμένως, ως γεμίσει x ή μια κυματιστή γραμμή,

213
00:16:47,310 --> 00:16:53,880
αλλά στις πραγματικές εικόνες bitmap το παραγέμισμα υποδεικνύεται από ένα δεκαεξαδικό 0.

214
00:16:53,880 --> 00:16:57,340
Έτσι, αυτό θα ήταν ένα μεμονωμένο χαρακτήρα, 0.

215
00:16:58,980 --> 00:17:06,329
Τι θα μπορούσε να έρθει σε πρακτικό είναι το xxd εντολή.

216
00:17:06,329 --> 00:17:11,220
Αυτό που κάνει είναι πραγματικά σας δείχνει, όπως και παρόμοιο με αυτό που έκανα πριν με το smiley

217
00:17:11,220 --> 00:17:15,630
Εγώ πραγματικά όταν εκτυπώνεται κάθε τι χρώμα θα είναι για το pixel

218
00:17:15,630 --> 00:17:21,800
και στη συνέχεια το χρωματικό κώδικα, όταν εκτελείτε xxd με τις ακόλουθες εντολές,

219
00:17:21,800 --> 00:17:28,670
τότε θα είναι πραγματικά ό, τι εκτυπώσετε τα χρώματα είναι για τις pixels.

220
00:17:28,670 --> 00:17:33,810
Τι έχετε να κάνετε είναι πάνω από εδώ μου δείχνουν, όπως το s-54

221
00:17:33,810 --> 00:17:36,530
λέει ότι είμαι πρόκειται να ξεκινήσει στην 54η byte

222
00:17:36,530 --> 00:17:40,820
γιατί πριν από αυτό, να θυμάστε, αν κοιτάξουμε πίσω στο χάρτη των bitmaps,

223
00:17:40,820 --> 00:17:42,690
Αυτό είναι όλες οι πληροφορίες κεφαλίδας και τέτοια πράγματα.

224
00:17:42,690 --> 00:17:46,280
Αλλά αυτό που πραγματικά νοιάζονται για τα πραγματικά είναι εικονοστοιχεία που δείχνουν το χρώμα.

225
00:17:46,280 --> 00:17:52,700
Έτσι, με την προσθήκη σε αυτή τη σημαία, s-54, τότε θα είστε σε θέση να δείτε τις τιμές χρώματος.

226
00:17:52,700 --> 00:17:56,020
Και μην ανησυχείτε για τις περίπλοκες σημαίες και τέτοια πράγματα.

227
00:17:56,020 --> 00:18:05,020
Στο σύνολο spec πρόβλημα, θα έχετε οδηγίες για το πώς να χρησιμοποιήσετε xxd να εμφανίσετε τα pixels.

228
00:18:07,070 --> 00:18:15,590
Έτσι, αν δείτε εδώ, αυτό το είδος της μοιάζει με ένα πράσινο κουτί, αυτό το μικρό πράγμα.

229
00:18:15,590 --> 00:18:23,610
Έχω χρωματικό κώδικα της 00FF00 ως βασικά λέγοντας ότι δεν μπλε, πολύ πράσινο, κόκκινο και καμία.

230
00:18:23,610 --> 00:18:26,370
Έτσι που αντιστοιχεί στο πράσινο.

231
00:18:26,370 --> 00:18:31,920
Όπως μπορείτε να δείτε εδώ, βλέπουμε ένα πράσινο ορθογώνιο.

232
00:18:31,920 --> 00:18:36,660
Αυτό το πράσινο ορθογώνιο είναι μόνο 3 pixels πλάτος, έτσι τότε τι πρέπει να κάνουμε

233
00:18:36,660 --> 00:18:44,350
για να βεβαιωθείτε ότι η εικόνα είναι πολλαπλάσιο του 4 είναι να προσθέσετε πλάτος στο επιπλέον padding.

234
00:18:44,350 --> 00:18:49,460
Και έτσι στη συνέχεια, αυτό είναι το πώς βλέπετε αυτά τα 0s εδώ.

235
00:18:49,460 --> 00:18:54,510
Αυτό θα είναι πράγματι το αποτέλεσμα της PSET Resize σας,

236
00:18:54,510 --> 00:19:01,350
λαμβάνοντας κατ 'ουσίαν το μικρό bitmap και στη συνέχεια υπέβαλε διευρύνοντας 4.

237
00:19:01,350 --> 00:19:09,380
Και έτσι αυτό που βλέπουμε είναι ότι στην πραγματικότητα η εικόνα αυτή είναι 12 pixels πλάτος, αλλά 12 είναι πολλαπλάσιο του 4,

238
00:19:09,380 --> 00:19:12,940
και γι 'αυτό πραγματικά δεν βλέπω καμία 0s στο τέλος, επειδή δεν χρειάζεται να προσθέσετε οποιοδήποτε

239
00:19:12,940 --> 00:19:19,070
επειδή είναι πλήρως παραγεμισμένο. Δεν έχει πια δωμάτιο.

240
00:19:20,720 --> 00:19:23,470
>> Εντάξει. Οποιεσδήποτε ερωτήσεις σχετικά με την επένδυση;

241
00:19:25,150 --> 00:19:27,460
Εντάξει. Cool.

242
00:19:27,460 --> 00:19:32,520
>> Όπως ανέφερα και πριν, οι εικόνες bitmap είναι μόνο μια ακολουθία από bytes.

243
00:19:32,520 --> 00:19:39,170
Και έτσι αυτό που έχουμε είναι αντί να χρειάζεται να παρακολουθείτε ποια ακριβώς τον αριθμό των byte

244
00:19:39,170 --> 00:19:47,050
αντιστοιχεί σε ένα συγκεκριμένο στοιχείο, που πραγματικά έχουν δημιουργήσει ένα struct που να εκπροσωπεί.

245
00:19:47,050 --> 00:19:50,930
Έτσι, αυτό που έχουμε είναι μια RGBTRIPLE struct.

246
00:19:50,930 --> 00:19:54,590
Κάθε φορά που έχετε ένα παράδειγμα από μία τριάδα RGB,

247
00:19:54,590 --> 00:20:00,970
διότι αυτό είναι ένα είδος καθορίζουν struct, τότε μπορείτε να αποκτήσετε πρόσβαση στο rgbtBlue μεταβλητή,

248
00:20:00,970 --> 00:20:09,520
ομοίως το πράσινο και το κόκκινο μεταβλητές, οι οποίες θα καταδεικνύουν πόσο μπλε, πράσινο και κόκκινο,

249
00:20:09,520 --> 00:20:11,580
αντίστοιχα, έχετε.

250
00:20:11,580 --> 00:20:16,800
>> Έτσι, αν έχουμε το μπλε σύνολο μεταβλητών στο 0, το πράσινο σύνολο σε ff,

251
00:20:16,800 --> 00:20:22,060
η οποία είναι η μέγιστη τιμή που μπορείτε να έχετε, και στη συνέχεια η κόκκινη μεταβλητή οριστεί σε 0,

252
00:20:22,060 --> 00:20:27,870
τότε τι χρώμα θα ήταν η συγκεκριμένη τριάδα RGB αντιπροσωπεύουν; >> [Φοιτητής] Πράσινο.

253
00:20:27,870 --> 00:20:29,150
Πράσινο. Ακριβώς.

254
00:20:29,150 --> 00:20:34,480
Είναι πρόκειται να είναι χρήσιμο να γνωρίζουμε ότι κάθε φορά που έχετε ένα παράδειγμα από μία τριάδα RGB,

255
00:20:34,480 --> 00:20:41,340
μπορείτε να έχετε πρόσβαση στην πραγματικότητα την ποσότητα του χρώματος - μπλε, πράσινο, κόκκινο και - ξεχωριστά.

256
00:20:43,350 --> 00:20:54,900
>> Τώρα που έχουμε μιλήσει για τη δομή του ότι, ας ρίξουμε μια ματιά στο αρχείο BMP.

257
00:20:54,900 --> 00:20:57,870
Αυτά είναι structs για εσάς.

258
00:20:57,870 --> 00:21:01,820
Εδώ έχουμε ένα struct BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
Του ενδιαφέροντος είναι το μέγεθος.

260
00:21:07,610 --> 00:21:12,660
Αργότερα, έχουμε την κεφαλίδα πληροφορίες, το οποίο έχει μερικά περισσότερα πράγματα που έχουν ενδιαφέρον για μας,

261
00:21:12,660 --> 00:21:15,480
δηλαδή το μέγεθος, το πλάτος και το ύψος.

262
00:21:15,480 --> 00:21:19,170
Όπως θα πάμε σε αργότερα, όταν έχετε διαβάσει μέσα στο αρχείο,

263
00:21:19,170 --> 00:21:25,500
διαβάζει αυτόματα γιατί έχουμε ορίσετε τη σειρά να είναι το ίδιο.

264
00:21:25,500 --> 00:21:31,990
Έτσι, η biSize θα περιέχει τις σωστές bytes που αντιστοιχούν στο πραγματικό μέγεθος της εικόνας.

265
00:21:34,700 --> 00:21:40,500
Και στη συνέχεια, εδώ, τέλος, όπως έχουμε μιλήσει, έχουμε την RGBTRIPLE typedef struct.

266
00:21:40,500 --> 00:21:46,840
Έχουμε μια rgbtBlue, πράσινο, κόκκινο και να σχετίζεται με αυτήν.

267
00:21:48,210 --> 00:21:49,340
>> Μεγάλη. Εντάξει.

268
00:21:49,340 --> 00:21:56,360
Τώρα που καταλαβαίνουμε bitmaps λίγο, να καταλάβουν ότι έχουμε μια κεφαλίδα του αρχείου

269
00:21:56,360 --> 00:22:00,790
και μια κεφαλίδα πληροφορίες που συνδέονται με αυτό και στη συνέχεια, μετά από αυτό, έχουμε την ενδιαφέροντα πράγματα

270
00:22:00,790 --> 00:22:05,110
των χρωμάτων, και τα χρώματα εκπροσωπούνται από RGBTRIPLE structs,

271
00:22:05,110 --> 00:22:12,710
και εκείνες, με τη σειρά τους, έχουν τρεις τιμές που σχετίζονται με το μπλε, το πράσινο, το κόκκινο και.

272
00:22:12,710 --> 00:22:17,270
>> Μέχρι τώρα, μπορούμε να το είδος των σκέφτονται Ανάκτηση για λίγο.

273
00:22:17,270 --> 00:22:20,130
Λυπάμαι. Σκεφτείτε Whodunit.

274
00:22:20,130 --> 00:22:25,750
Όταν έχουμε ιδέα μας αρχείο, τότε αυτό που θέλουμε να κάνουμε είναι να διαβάσει για να το pixel προς pixel

275
00:22:25,750 --> 00:22:33,860
και στη συνέχεια να αλλάξετε με κάποιο τρόπο τα pixels, έτσι ώστε να μπορούμε να το εξάγει σε αναγνώσιμη μορφή.

276
00:22:33,860 --> 00:22:41,020
Και έτσι για να εξάγει, θα πάμε να γράψω pixel προς pixel στο αρχείο verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Αυτό είναι το είδος της μια πολλά να κάνουμε. Αντιλαμβανόμαστε ότι.

278
00:22:45,120 --> 00:22:49,860
Έτσι, αυτό που έχουμε κάνει είναι ότι έχουμε την προϋπόθεση ότι έχετε πραγματικά με copy.c.

279
00:22:49,860 --> 00:22:57,610
Τι copy.c κάνει είναι απλά κάνει ένα ακριβές αντίγραφο ενός αρχείου bitmap και στη συνέχεια, εξάγει το.

280
00:22:57,610 --> 00:23:01,900
Έτσι, αυτό ανοίγει ήδη το αρχείο για εσάς, αναφέρει σε pixel προς pixel,

281
00:23:01,900 --> 00:23:04,510
και γράφει στη συνέχεια σε σε ένα αρχείο εξόδου.

282
00:23:04,510 --> 00:23:07,080
>> Ας ρίξουμε μια ματιά σε αυτό.

283
00:23:13,390 --> 00:23:18,290
Αυτή είναι η εξασφάλιση της ορθής χρήσης,

284
00:23:18,290 --> 00:23:22,640
να πάρει τα ονόματα εδώ.

285
00:23:22,640 --> 00:23:29,940
Αυτό που κάνει είναι να θέτει το αρχείο εισόδου να είναι ό, τι έχουμε περάσει μέσα στο infile εδώ,

286
00:23:29,940 --> 00:23:34,750
το οποίο είναι το δεύτερο όρισμα της γραμμής εντολών μας.

287
00:23:34,750 --> 00:23:37,640
Έλεγχοι για να βεβαιωθείτε ότι μπορούμε να ανοίξουμε το αρχείο.

288
00:23:38,960 --> 00:23:44,860
Έλεγχοι για να βεβαιωθείτε ότι μπορούμε να κάνουμε μια νέα outfile εδώ.

289
00:23:45,630 --> 00:23:53,270
Τότε τι κάνει αυτό εδώ, απλά ουσιαστικά ξεκινά την ανάγνωση του αρχείου bitmap από την αρχή.

290
00:23:53,270 --> 00:23:56,700
Η αρχή, όπως γνωρίζουμε, περιέχει το BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
και έτσι οι ακολουθίες των bits άμεσα θα συμπληρώσουν το BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Έτσι, αυτό που έχουμε εδώ λέει ότι BITMAPFILEHEADER bf -

293
00:24:07,940 --> 00:24:13,150
ότι είναι νέα μεταβλητή μας BITMAPFILEHEADER του τύπου -

294
00:24:13,150 --> 00:24:22,560
θα πάμε να βάλουμε μέσα bf τι διαβάζουμε από το δείκτη, η οποία είναι infile μας.

295
00:24:22,560 --> 00:24:23,970
Πόσο μπορώ να διαβάζουμε;

296
00:24:23,970 --> 00:24:32,160
Διαβάζουμε σε πόσα bytes πρέπει να περιέχουν το σύνολο BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Ομοίως, αυτό είναι που κάνουμε για την κεφαλίδα πληροφορίες.

298
00:24:34,660 --> 00:24:39,010
Έτσι είμαστε συνεχίζει κατά μήκος αρχείο μας στην infile,

299
00:24:39,010 --> 00:24:44,360
και είμαστε ανάγνωση των bits και bytes, και εμείς να τους συνδέσετε απευθείας σε

300
00:24:44,360 --> 00:24:47,880
σε αυτές τις περιπτώσεις από τις μεταβλητές που φτιάχνουμε.

301
00:24:49,370 --> 00:24:53,800
Εδώ είμαστε απλώς να διασφαλίσουμε ότι το bitmap είναι ένα bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Τώρα έχουμε μια outfile, έτσι δεν είναι;

303
00:25:01,030 --> 00:25:04,420
Έτσι ως έχει, όταν το δημιουργείτε, αυτό είναι ουσιαστικά άδειο.

304
00:25:04,420 --> 00:25:07,710
Γι 'αυτό πρέπει να δημιουργήσουμε ουσιαστικά ένα νέο bitmap από το μηδέν.

305
00:25:07,710 --> 00:25:12,280
Αυτό που κάνουμε είναι ότι πρέπει να βεβαιωθείτε ότι θα αντιγράψει στην κεφαλίδα του αρχείου

306
00:25:12,280 --> 00:25:16,850
και η επικεφαλίδα πληροφορίες ακριβώς όπως το έχει infile.

307
00:25:16,850 --> 00:25:22,850
Αυτό που κάνουμε είναι να γράφουμε - και να θυμάστε ότι bf είναι η μεταβλητή

308
00:25:22,850 --> 00:25:29,300
BITMAPFILEHEADER του τύπου, έτσι ώστε αυτό που κάνουμε είναι να χρησιμοποιήσουμε ακριβώς αυτό το περιεχόμενο

309
00:25:29,300 --> 00:25:34,980
να γράψετε στο outfile.

310
00:25:36,550 --> 00:25:38,510
Εδώ, θυμηθείτε μιλήσαμε για επένδυση,

311
00:25:38,510 --> 00:25:47,820
τρόπο με τον οποίο είναι σημαντικό να βεβαιωθείτε ότι το ποσό των pixel που έχουμε είναι πολλαπλάσιο του 4.

312
00:25:47,820 --> 00:25:52,790
Αυτό είναι ένα πολύ χρήσιμο τύπο για να υπολογίσει πόσο έχετε γεμίσει

313
00:25:52,790 --> 00:25:57,670
δίνεται το πλάτος του αρχείου σας.

314
00:25:57,670 --> 00:26:04,120
Θέλω εσείς να θυμάστε ότι σε copy.c έχουμε μια φόρμουλα για τον υπολογισμό padding.

315
00:26:04,120 --> 00:26:07,970
Εντάξει; Έτσι, να θυμάστε ότι ο καθένας. Μεγάλη.

316
00:26:07,970 --> 00:26:14,050
Και τότε τι κάνει copy.c επόμενο είναι επαναλαμβάνεται σε όλες τις scanlines.

317
00:26:14,050 --> 00:26:23,730
Στη συνέχεια μέσα από τις γραμμές και στη συνέχεια αποθηκεύει κάθε τριπλή ότι διαβάζει

318
00:26:23,730 --> 00:26:26,920
και το γράφει στη συνέχεια στο outfile.

319
00:26:26,920 --> 00:26:33,120
Μέχρι τότε εδώ είμαστε ανάγνωση μόνο ένα τριπλό RGB σε ένα χρόνο

320
00:26:33,120 --> 00:26:39,860
και στη συνέχεια τη θέση ότι η ίδια τριπλή στο outfile.

321
00:26:41,120 --> 00:26:48,340
Το δύσκολο μέρος είναι ότι η επένδυση δεν είναι ένα τριπλό RGB,

322
00:26:48,340 --> 00:26:55,200
και γι 'αυτό δεν μπορεί να διαβάσει μόνο το ποσό της συμπλήρωσης τριάδες RGB.

323
00:26:55,200 --> 00:27:01,460
Αυτό που έχουμε να κάνουμε είναι να προχωρήσουμε στην πραγματικότητα μόνο το αρχείο δείκτης μας θέση, μετακινήστε τον κέρσορα μας,

324
00:27:01,460 --> 00:27:06,840
το είδος της παραλείψετε πάνω από όλα την επένδυση ώστε να είμαστε στην επόμενη σειρά.

325
00:27:06,840 --> 00:27:12,990
Και τότε τι είναι αυτό που κάνει είναι αντίγραφο που δείχνει πώς μπορεί να θέλετε να προσθέσετε το παραγέμισμα.

326
00:27:12,990 --> 00:27:14,990
Έτσι έχουμε υπολογιστεί πόση πλήρωση χρειαζόμαστε,

327
00:27:14,990 --> 00:27:18,220
έτσι αυτό σημαίνει ότι χρειαζόμαστε τον αριθμό συμπλήρωσης των 0s.

328
00:27:18,220 --> 00:27:24,510
Αυτό που κάνει είναι για το βρόχο που βάζει τον αριθμό συμπλήρωσης των 0s σε outfile μας.

329
00:27:24,510 --> 00:27:31,170
Και τελικά, να κλείσετε και τα δύο αρχεία. Θα κλείσει το infile καθώς και την outfile.

330
00:27:31,170 --> 00:27:34,870
>> Έτσι, αυτό είναι το πώς copy.c έργα,

331
00:27:34,870 --> 00:27:37,430
και ότι πρόκειται να είναι αρκετά χρήσιμο.

332
00:27:39,720 --> 00:27:43,750
Αντί ακριβώς στην πραγματικότητα απευθείας αντιγραφή και επικόλληση

333
00:27:43,750 --> 00:27:46,800
ή απλά κοιτάζοντας το και πληκτρολογώντας σε ό, τι θέλετε,

334
00:27:46,800 --> 00:27:49,440
ίσως απλά θέλετε να εκτελέσετε αυτή την εντολή στο τερματικό,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, η οποία θα δημιουργήσει ένα νέο αρχείο, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
που περιέχει ακριβώς το ίδιο περιεχόμενο με αντίγραφο κάνει.

337
00:27:58,330 --> 00:28:03,880
Έτσι, τότε τι μπορούμε να κάνουμε είναι να χρησιμοποιήσουμε αυτό ως ένα πλαίσιο πάνω στο οποίο θα χτίσει και να επεξεργαστείτε

338
00:28:03,880 --> 00:28:06,900
για το αρχείο αστυνομικό θεατρικό έργο μας.

339
00:28:08,500 --> 00:28:14,670
>> Αυτά είναι για μας-dos για να κάνετε Whodunit, αλλά τι κάνει copy.c

340
00:28:14,670 --> 00:28:16,730
είναι παίρνει πραγματικά τη φροντίδα του τα περισσότερα από αυτά για μας.

341
00:28:16,730 --> 00:28:21,900
Έτσι, το μόνο που χρειάζεται να κάνετε στη συνέχεια είναι να αλλάξει τα pixels, όπως απαιτείται

342
00:28:21,900 --> 00:28:25,920
πραγματικά να κάνει το αρχείο αναγνώσιμο.

343
00:28:25,920 --> 00:28:32,960
Να θυμάστε ότι για ένα δεδομένο pixel τρίκλινα, έτσι για μια δεδομένη μεταβλητή του τύπου RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
μπορείτε να έχετε πρόσβαση στα μπλε, πράσινο, κόκκινο και αξίες.

345
00:28:35,990 --> 00:28:38,670
Αυτό πρόκειται να έρθει σε πρακτικό, διότι αν μπορείτε να έχετε πρόσβαση,

346
00:28:38,670 --> 00:28:41,770
αυτό σημαίνει ότι μπορείτε να ελέγξετε τους επίσης,

347
00:28:41,770 --> 00:28:45,430
και αυτό σημαίνει ότι μπορείτε να αλλάξετε τους επίσης.

348
00:28:45,430 --> 00:28:49,430
>> Έτσι, όταν πήγαμε πίσω στο κόκκινο παράδειγμα ποτήρι μας φακό,

349
00:28:49,430 --> 00:28:53,390
βασικά, που δρούσε ως ένα είδος φίλτρου για εμάς.

350
00:28:53,390 --> 00:28:58,160
Έτσι, αυτό που θέλουμε να κάνουμε είναι να θέλουμε να φιλτράρει όλες τις τριάδες που έρχονται in

351
00:28:58,160 --> 00:29:01,240
Υπάρχουν αρκετοί διαφορετικοί τρόποι να γίνει αυτό.

352
00:29:01,240 --> 00:29:07,100
Βασικά, μπορείτε να έχετε ό, τι τύπο του φίλτρου που θέλετε.

353
00:29:07,100 --> 00:29:09,890
Ίσως θέλετε να αλλάξετε όλα τα κόκκινα εικονοστοιχεία

354
00:29:09,890 --> 00:29:13,570
ή ίσως θέλετε να αλλάξετε ένα διαφορετικό χρώμα pixel σε ένα διαφορετικό χρώμα.

355
00:29:13,570 --> 00:29:15,400
Αυτό είναι στο χέρι σας.

356
00:29:15,400 --> 00:29:19,580
Να θυμάστε ότι μπορείτε να ελέγξετε τι χρώμα είναι το pixel

357
00:29:19,580 --> 00:29:23,000
και στη συνέχεια μπορείτε να αλλάξετε επίσης ως περνάτε.

358
00:29:24,410 --> 00:29:26,420
>> Εντάξει. Έτσι, αυτό είναι Whodunit.

359
00:29:26,420 --> 00:29:32,760
Αφού εκτελέσετε Whodunit, θα ξέρετε ποιος είναι ο ένοχος του εγκλήματος ήταν.

360
00:29:32,760 --> 00:29:35,540
>> Τώρα θα πάμε για να πάει στο Αλλαγή μεγέθους.

361
00:29:35,540 --> 00:29:37,990
Εμείς πάμε για να συνεχίσουν να ασχολούνται με bitmap.

362
00:29:37,990 --> 00:29:40,750
Τι θα πάμε να κάνουμε είναι θα πάμε να έχουν ένα bitmap εισόδου

363
00:29:40,750 --> 00:29:45,890
και στη συνέχεια θα πάμε να περάσει σε μια σειρά και στη συνέχεια να πάρει ένα outfile bitmap

364
00:29:45,890 --> 00:29:51,380
όπου αυτό είναι βασικά infile μας κλιμακώνεται από n.

365
00:29:54,670 --> 00:30:01,450
Πείτε το αρχείο μου ήταν μόνο ένα μεγάλο pixel.

366
00:30:01,450 --> 00:30:09,100
Στη συνέχεια, αν n μου ήταν 3, κλιμάκωση από 3, τότε θα ήθελα να επαναλάβω ότι pixel n φορές,

367
00:30:09,100 --> 00:30:14,410
έτσι 3 φορές, και στη συνέχεια, κλιμάκωση επίσης κάτω από 3 φορές, καθώς και.

368
00:30:14,410 --> 00:30:17,840
Βλέπετε λοιπόν ότι είμαι κλιμάκωση κάθετα όσο και οριζόντια.

369
00:30:17,840 --> 00:30:19,680
>> Και τότε εδώ είναι ένα παράδειγμα.

370
00:30:19,680 --> 00:30:27,590
Αν έχετε n = 2, θα δείτε ότι η πρώτη μπλε pixel επαναλαμβάνεται δύο φορές

371
00:30:27,590 --> 00:30:30,930
οριζόντια όσο και κάθετα δύο φορές.

372
00:30:30,930 --> 00:30:38,040
Και τότε αυτό συνεχίζεται, και έτσι έχετε άμεση κλιμάκωση της αρχικής εικόνας από δύο.

373
00:30:40,920 --> 00:30:47,600
>> Έτσι λοιπόν, αν ήμασταν στη λεπτομέρεια τον ψευδοκώδικα για αυτό, θέλουμε να ανοίξετε το αρχείο.

374
00:30:47,600 --> 00:30:49,880
Και στη συνέχεια, γνωρίζοντας ότι αν πάμε πίσω εδώ,

375
00:30:49,880 --> 00:30:54,540
βλέπουμε ότι το πλάτος για την outfile πρόκειται να είναι διαφορετική από ό, τι το πλάτος του εσώτερου αρχείου.

376
00:30:54,540 --> 00:30:56,130
Τι σημαίνει αυτό;

377
00:30:56,130 --> 00:31:01,230
Αυτό σημαίνει ότι πληροφορίες κεφαλίδας μας πρόκειται να αλλάξει.

378
00:31:01,230 --> 00:31:03,790
Και έτσι αυτό που θα θελήσετε να κάνετε είναι να ενημερώσετε τις πληροφορίες κεφαλίδας,

379
00:31:03,790 --> 00:31:11,820
γνωρίζοντας ότι όταν διαβάζουμε στα αρχεία αν λειτουργούν στο πλαίσιο copy.c,

380
00:31:11,820 --> 00:31:17,570
έχουμε ήδη μια μεταβλητή που δείχνει ποιο είναι το μέγεθος και τέτοια πράγματα.

381
00:31:17,570 --> 00:31:24,060
Έτσι, μόλις έχετε ότι, ό, τι μπορεί να θέλετε να κάνετε είναι να αλλάξετε αυτές τις συγκεκριμένες μεταβλητές.

382
00:31:24,060 --> 00:31:29,380
Να θυμάστε, αν έχετε ένα struct, πώς θα αποκτήσετε πρόσβαση στις μεταβλητές μέσα σε αυτό.

383
00:31:29,380 --> 00:31:32,080
Μπορείτε να χρησιμοποιήσετε τον τελεστή τελεία, έτσι δεν είναι;

384
00:31:32,080 --> 00:31:36,420
Έτσι, στη συνέχεια, χρησιμοποιώντας ότι, ξέρετε ότι θα πρέπει να αλλάξετε τις πληροφορίες κεφαλίδας.

385
00:31:36,480 --> 00:31:41,030
Έτσι, εδώ είναι μόνο μια λίστα των πραγματικών στοιχείων που πρόκειται να αλλάζει στο αρχείο σας.

386
00:31:41,030 --> 00:31:45,180
Το μέγεθος αρχείου πρόκειται να αλλάζει, η εικόνα, καθώς και το πλάτος και το ύψος.

387
00:31:45,180 --> 00:31:50,080
Έτσι, στη συνέχεια πηγαίνει πίσω στο χάρτη των bitmaps,

388
00:31:50,080 --> 00:31:57,730
εξετάσει κατά πόσον είναι η κεφαλίδα του αρχείου ή η επικεφαλίδα πληροφορίες που περιέχει τις πληροφορίες

389
00:31:57,730 --> 00:32:00,920
και στη συνέχεια να αλλάξετε ανάλογα με τις ανάγκες.

390
00:32:05,010 --> 00:32:12,470
Και πάλι, λένε cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Αυτό σημαίνει ότι τώρα resize.c περιέχει όλα όσα περιέχονται μέσα σε αντίγραφο

392
00:32:19,270 --> 00:32:24,490
επειδή μας παρέχει αντίγραφο έναν τρόπο ανάγνωσης σε κάθε pixel προς pixel scanline.

393
00:32:24,490 --> 00:32:29,860
Μόνο που τώρα, όχι μόνο την αλλαγή των τιμών, όπως κάναμε σε Whodunit,

394
00:32:29,860 --> 00:32:37,980
αυτό που θέλουμε να κάνουμε είναι να θέλουμε να γράψουμε σε πολλές pixels

395
00:32:37,980 --> 00:32:43,580
εφ 'όσον το η μας είναι μεγαλύτερος από 1.

396
00:32:43,580 --> 00:32:47,110
>> Στη συνέχεια, αυτό που θέλουμε να κάνουμε είναι να θέλουμε να τεντώσει από n οριζόντια,

397
00:32:47,110 --> 00:32:50,490
καθώς και τεντώστε ως κάθετα με το n.

398
00:32:50,490 --> 00:32:52,710
Πώς να το κάνουμε αυτό;

399
00:32:52,710 --> 00:32:56,890
Πείτε ν σας είναι 2 και έχετε αυτό το δεδομένο infile.

400
00:32:56,890 --> 00:32:58,730
Ο δρομέας πρόκειται να ξεκινήσει στο πρώτο,

401
00:32:58,730 --> 00:33:03,530
και τι θέλετε να κάνετε, αν n είναι 2, που θέλετε να εκτυπώσετε σε 2 από αυτά.

402
00:33:03,530 --> 00:33:05,490
Έτσι, εκτυπώνετε σε 2 από αυτά.

403
00:33:05,490 --> 00:33:10,830
Στη συνέχεια, ο δρομέας πρόκειται να προχωρήσουμε στο επόμενο pixel, η οποία είναι η κόκκινη,

404
00:33:10,830 --> 00:33:18,400
και πρόκειται να εκτυπώσετε 2 των εν λόγω κόκκινα, προσαρτώντας το σε ό, τι έχει κάνει στο παρελθόν.

405
00:33:18,400 --> 00:33:26,280
Στη συνέχεια, ο κέρσορας θα μετακινηθεί στο επόμενο pixel και σχεδιάστε σε 2 από αυτά.

406
00:33:26,280 --> 00:33:37,180
Αν κοιτάξουμε πίσω στο copy.c πλαίσιο, τι κάνει αυτό το δικαίωμα εδώ

407
00:33:37,180 --> 00:33:42,830
είναι ότι δημιουργεί ένα νέο στιγμιότυπο του μία τριάδα RGB, μια νέα μεταβλητή που ονομάζεται τριπλό.

408
00:33:42,830 --> 00:33:50,500
Και εδώ όταν διαβάζει σε αυτό, διαβάζει από το infile 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
και αποθηκεύει στο εσωτερικό της εν λόγω τριπλής μεταβλητής.

410
00:33:53,470 --> 00:33:57,590
Έτσι, τότε έχετε πραγματικά μια μεταβλητή που αντιπροσωπεύει το συγκεκριμένο pixel.

411
00:33:57,590 --> 00:34:05,290
Στη συνέχεια, όταν γράφετε, τι μπορεί να θέλετε να κάνετε είναι να περιβάλλουν την fwrite δήλωση σε ένα for loop

412
00:34:05,290 --> 00:34:11,080
που γράφει σε outfile σας όσες φορές χρειάζεται.

413
00:34:17,449 --> 00:34:20,100
Αυτό είναι αρκετά απλό.

414
00:34:20,200 --> 00:34:27,590
Απλώς επαναλαμβάνουν ουσιαστικά τη διαδικασία γραφής n αριθμός των φορές να την περιορίσουμε σε οριζόντια θέση.

415
00:34:27,590 --> 00:34:32,969
>> Αλλά τότε θα πρέπει να θυμόμαστε ότι η επένδυση μας πρόκειται να αλλάξει.

416
00:34:47,350 --> 00:34:53,020
Προηγουμένως, είχαμε πει κάτι μήκους 3.

417
00:34:53,020 --> 00:35:00,130
Στη συνέχεια θα προσθέσω μόνο στο πόσο επένδυση; Απλά ένα περισσότερο για να κάνουν ένα πολλαπλάσιο του 4.

418
00:35:00,130 --> 00:35:10,480
Αλλά πούμε ότι είμαστε κλιμάκωση αυτή τη συγκεκριμένη εικόνα από n = 2.

419
00:35:10,480 --> 00:35:16,300
Έτσι λοιπόν πόσα μπλε pixels θα έχουμε στο τέλος; Θα είχαμε 6.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. Εντάξει.

421
00:35:21,470 --> 00:35:26,580
6 δεν είναι πολλαπλάσιο του 4. Ποιο είναι το πλησιέστερο πολλαπλάσιο του 4; Αυτό πρόκειται να είναι 8.

422
00:35:26,580 --> 00:35:33,200
Έτσι, είμαστε πραγματικά πρόκειται να έχουν 2 χαρακτήρες του padding εκεί.

423
00:35:33,200 --> 00:35:38,720
>> Θυμάται κανείς αν έχουμε μια φόρμουλα για τον υπολογισμό padding

424
00:35:38,720 --> 00:35:41,350
και όπου αυτό θα μπορούσε να είναι;

425
00:35:41,350 --> 00:35:45,160
[Ακούγεται ανταπόκριση των φοιτητών] >> Ναι, copy.c. Δεξιά.

426
00:35:45,160 --> 00:35:49,800
Υπάρχει ένας τύπος σε copy.c να υπολογίσετε πόσο έχετε γεμίσει

427
00:35:49,800 --> 00:35:53,810
δίνεται ένα συγκεκριμένο πλάτος του bitmap εικόνας.

428
00:35:53,810 --> 00:36:02,950
Έτσι, τότε αυτό πρόκειται να είναι χρήσιμο όταν θέλετε να προσθέσετε σε ένα ορισμένο ποσό των padding

429
00:36:02,950 --> 00:36:06,160
πραγματικά να καταλάβω πόσο επένδυση θα πρέπει να προσθέσετε.

430
00:36:10,820 --> 00:36:15,850
Αλλά ένα σημείωμα, όμως, είναι ότι θέλετε να βεβαιωθείτε ότι χρησιμοποιείτε το σωστό μέγεθος.

431
00:36:15,850 --> 00:36:21,410
Απλά να είστε προσεκτικοί, γιατί είστε ουσιαστικά πρόκειται να ασχολούνται με δύο εικόνων bitmap.

432
00:36:21,410 --> 00:36:23,410
Θέλετε να βεβαιωθείτε ότι χρησιμοποιείτε το σωστό.

433
00:36:23,410 --> 00:36:26,820
Όταν τον υπολογισμό του padding για την outfile, θέλετε να χρησιμοποιήσετε το πλάτος του outfile

434
00:36:26,820 --> 00:36:29,860
και όχι το πλάτος της προηγούμενης.

435
00:36:29,860 --> 00:36:37,240
>> Μεγάλη. Αυτό το είδος της φροντίζει εκτείνεται σε ολόκληρη την εικόνα bitmap σε οριζόντια θέση.

436
00:36:37,240 --> 00:36:41,290
Αλλά αυτό που θέλουμε να κάνουμε είναι να τεντώσει πραγματικά κατακόρυφα, καθώς και.

437
00:36:41,290 --> 00:36:48,760
Αυτό πρόκειται να είναι λίγο πιο περίπλοκη, διότι όταν έχουμε τελειώσει την αντιγραφή μιας γραμμής

438
00:36:48,760 --> 00:36:51,580
και εγγράφως ότι η σειρά, δρομέας μας θα είναι στο τέλος.

439
00:36:51,580 --> 00:36:56,210
Έτσι, αν διαβάσετε ξανά, τότε αυτό είναι ακριβώς πρόκειται να διαβάζονται στην επόμενη γραμμή.

440
00:36:56,210 --> 00:37:03,660
Έτσι, αυτό που θέλουμε να κάνουμε είναι το είδος του βρει κάποιο τρόπο για την αντιγραφή αυτών των γραμμών και πάλι

441
00:37:03,660 --> 00:37:12,500
ή ακριβώς το είδος λήψη της εν λόγω γραμμής και στη συνέχεια να το ξαναγράψουν πάλι.

442
00:37:14,380 --> 00:37:17,940
Όπως το είδος του αναφέρθηκα, υπάρχουν διάφοροι τρόποι για να γίνει αυτό.

443
00:37:17,940 --> 00:37:23,040
Τι θα μπορούσατε να κάνετε είναι ως περνάτε και την ανάγνωση μέσα από το συγκεκριμένο scanline

444
00:37:23,040 --> 00:37:28,560
και αλλάζοντας ως αναγκαίο, στη συνέχεια το είδος του καταστήματος όλα αυτά τα εικονοστοιχεία σε μία συστοιχία.

445
00:37:28,560 --> 00:37:36,350
Στη συνέχεια, αργότερα ξέρετε ότι θα πρέπει να εκτυπώσετε και πάλι αυτού του πίνακα,

446
00:37:36,350 --> 00:37:39,830
και έτσι μπορείτε να χρησιμοποιήσετε μόνο αυτού του πίνακα για να το κάνουμε αυτό.

447
00:37:39,830 --> 00:37:44,500
Ένας άλλος τρόπος για να το κάνετε είναι να μπορείτε να αντιγράψετε τα κάτω κατά μία γραμμή,

448
00:37:44,500 --> 00:37:47,950
κατανοήσουν ότι θα πρέπει να αντιγράψετε ότι και πάλι, έτσι ώστε να μετακινήσετε τον κέρσορα στην πραγματικότητα,

449
00:37:47,950 --> 00:37:50,950
και ότι πρόκειται να χρησιμοποιεί τη μέθοδο fseek.

450
00:37:50,950 --> 00:37:56,410
Μπορείτε να μετακινήσετε το δρομέα σας όλος ο τρόπος πίσω και στη συνέχεια επαναλάβετε τη διαδικασία αντιγραφής και πάλι.

451
00:37:56,410 --> 00:38:03,960
>> Έτσι, εάν ο αριθμός κλιμάκωσης μας είναι n, τότε πόσες φορές θα πρέπει να πάμε πίσω

452
00:38:03,960 --> 00:38:10,500
και να ξαναγράψει μια γραμμή; >> [Φοιτητής] n - 1. >> Ναι, τέλεια. ν - 1.

453
00:38:10,500 --> 00:38:14,390
Έχουμε κάνει ήδη μια φορά, οπότε τότε θα θελήσετε να επαναλάβετε τη διαδικασία πηγαίνει πίσω

454
00:38:14,390 --> 00:38:17,460
n - 1 το ποσό των φορές.

455
00:38:22,730 --> 00:38:25,860
Εντάξει. Έτσι εκεί έχετε τη λειτουργία αλλαγής μεγέθους σας.

456
00:38:25,860 --> 00:38:34,360
>> Τώρα, μπορούμε να φτάσουμε σε ένα πραγματικά διασκεδαστικό μέρος, το αγαπημένο μου PSET, η οποία είναι Ανάκτηση.

457
00:38:34,360 --> 00:38:39,580
Αντί bitmaps, αυτή τη φορά έχουμε να κάνουμε με αρχεία JPEG.

458
00:38:39,580 --> 00:38:43,370
Είμαστε στην πραγματικότητα δεν έδωσε μόνο ένα αρχείο από αρχεία JPEG,

459
00:38:43,370 --> 00:38:46,600
μας δίνεται ουσιαστικά μια ακατέργαστη μορφή κάρτας μνήμης.

460
00:38:46,600 --> 00:38:51,790
Και έτσι αυτό περιέχει ένα κομμάτι του πληροφορίες και τα σκουπίδια αξίες στην αρχή,

461
00:38:51,790 --> 00:38:57,240
και τότε αρχίζει και έχει μια δέσμη των αρχείων JPEG.

462
00:38:57,240 --> 00:39:03,430
Ωστόσο, είμαστε παρέδωσε μια κάρτα που έχουμε διαγράψει τις φωτογραφίες?

463
00:39:03,430 --> 00:39:08,300
ουσιαστικά, έχουμε ξεχάσει, όπου οι φωτογραφίες που βρίσκονται μέσα στην κάρτα.

464
00:39:08,300 --> 00:39:12,770
Έτσι λοιπόν το καθήκον μας στο Ανάκτηση είναι να περάσει από αυτή τη μορφή κάρτας

465
00:39:12,770 --> 00:39:16,500
και να βρει ξανά αυτές τις εικόνες.

466
00:39:16,500 --> 00:39:23,990
>> Ευτυχώς, η δομή των αρχείων JPEG και το αρχείο της κάρτας είναι λίγο χρήσιμη.

467
00:39:23,990 --> 00:39:28,850
Σίγουρα θα μπορούσε να ήταν λίγο πιο περίπλοκη, αν δεν ήταν στη συγκεκριμένη μορφή.

468
00:39:28,850 --> 00:39:40,160
Κάθε αρχείο JPEG ξεκινά στην πραγματικότητα με δύο πιθανές ακολουθίες, που αναφέρονται παραπάνω.

469
00:39:40,160 --> 00:39:42,970
Βασικά, κάθε φορά που έχετε ένα νέο αρχείο JPEG,

470
00:39:42,970 --> 00:39:52,720
ξεκινά είτε με την αλληλουχία ffd8 ffe0 ή ο άλλος, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Ένα άλλο χρήσιμο πράγμα που πρέπει να ξέρετε είναι ότι αρχεία JPEG αποθηκεύονται συνεχόμενα.

472
00:39:59,530 --> 00:40:03,380
Έτσι, κάθε φορά που ένα αρχείο JPEG τελειώνει, η άλλη ξεκινά.

473
00:40:03,380 --> 00:40:07,070
Έτσι, δεν υπάρχει κανενός είδους σε-μεταξύ των τιμών εκεί.

474
00:40:07,070 --> 00:40:15,510
Μόλις χτυπήσει την έναρξη μιας JPEG, αν έχετε ήδη την ανάγνωση ενός JPEG,

475
00:40:15,510 --> 00:40:21,800
ξέρετε ότι έχετε χτυπήσει το τέλος της προηγούμενης και την αρχή της επόμενης.

476
00:40:21,800 --> 00:40:25,890
>> Για να απεικονίσει το είδος αυτό, έκανα μια σχηματική.

477
00:40:25,890 --> 00:40:36,910
Ένα άλλο πράγμα για αρχεία JPEG είναι ότι μπορούμε να τα διαβάσετε σε ακολουθίες από 512 bytes σε ένα χρόνο,

478
00:40:36,910 --> 00:40:39,380
παρομοίως με την έναρξη της κάρτας.

479
00:40:39,380 --> 00:40:43,370
Δεν χρειάζεται να ελέγχουν κάθε byte μόνο γιατί αυτό θα πιπιλίζουν.

480
00:40:43,370 --> 00:40:48,200
Έτσι, αντ 'αυτού, αυτό που μπορούμε να κάνουμε είναι στην πραγματικότητα απλά διαβάστε το 512 bytes σε ένα χρόνο

481
00:40:48,200 --> 00:40:54,700
και, στη συνέχεια, αντί να το check-in μεταξύ εκείνων σε αυτά τα μικροσκοπικά φετάκια,

482
00:40:54,700 --> 00:40:58,640
μπορούμε να ελέγξουμε είναι μόνο η αρχή των 512 bytes.

483
00:40:58,640 --> 00:41:02,570
Ουσιαστικά, σε αυτή την εικόνα, αυτό που βλέπετε είναι στην αρχή της κάρτας,

484
00:41:02,570 --> 00:41:08,700
έχετε αξίες που δεν είναι πραγματικά σχετικό με τα πραγματικά αρχεία JPEG τους.

485
00:41:08,700 --> 00:41:15,830
Στη συνέχεια, όμως αυτό που έχω είναι ένα αστέρι για να δείξει μία από τις δύο σειρές εκκίνησης για ένα JPEG.

486
00:41:15,830 --> 00:41:19,910
Έτσι, κάθε φορά που βλέπετε ένα αστέρι, ξέρετε ότι έχετε ένα αρχείο JPEG.

487
00:41:19,910 --> 00:41:25,030
Και στη συνέχεια, κάθε αρχείο JPEG πρόκειται να είναι κάποιο πολλαπλάσιο των 512 bytes

488
00:41:25,030 --> 00:41:27,880
αλλά όχι απαραίτητα το ίδιο πολλαπλάσιο.

489
00:41:27,880 --> 00:41:32,050
Ο τρόπος που ξέρετε ότι έχετε χτυπήσει ένα άλλο JPEG είναι αν χτυπήσει ένα άλλο αστέρι,

490
00:41:32,050 --> 00:41:39,090
άλλο ξεκινώντας ακολουθία από bytes.

491
00:41:39,090 --> 00:41:43,330
Στη συνέχεια, αυτό που έχουμε εδώ είναι που έχουν το κόκκινο JPEG αρχείο συνεχίζοντας μέχρι να χτυπήσει ένα αστέρι,

492
00:41:43,330 --> 00:41:45,150
η οποία υποδεικνύεται με ένα νέο χρώμα.

493
00:41:45,150 --> 00:41:48,510
Θα συνεχίσει και στη συνέχεια να χτυπήσει ένα άλλο αστέρι, να χτυπήσει ένα άλλο JPEG,

494
00:41:48,510 --> 00:41:50,590
θα συνεχίσει σε όλη τη διαδρομή μέχρι το τέλος.

495
00:41:50,590 --> 00:41:53,180
Είσαι στην τελευταία εικόνα εδώ, το ροζ ένα.

496
00:41:53,180 --> 00:41:58,220
Μπορείτε να πάτε μέχρι το τέλος, μέχρι να χτυπήσει το τέλος του αρχείου χαρακτήρα.

497
00:41:58,220 --> 00:42:00,820
Αυτό πρόκειται να είναι πραγματικά χρήσιμο.

498
00:42:00,820 --> 00:42:03,170
>> Μερικές βασικές takeaways εδώ:

499
00:42:03,170 --> 00:42:06,670
Το αρχείο της κάρτας δεν ξεκινά με ένα JPEG,

500
00:42:06,670 --> 00:42:13,350
αλλά άπαξ και αρχίσει ένα JPEG, όλα τα αρχεία JPEG αποθηκεύονται παράπλευρα ο ένας στον άλλο.

501
00:42:17,520 --> 00:42:20,420
>> Μερικά ψευδοκώδικα για την Ανάκτηση.

502
00:42:20,420 --> 00:42:22,570
Κατ 'αρχάς, θα πάμε για να ανοίξετε το αρχείο της κάρτας μας,

503
00:42:22,570 --> 00:42:27,500
και ότι πρόκειται να χρησιμοποιεί το αρχείο μας λειτουργίες I / O.

504
00:42:27,500 --> 00:42:32,430
Εμείς πάμε για να επαναλάβετε την ακόλουθη διαδικασία μέχρι να έχουμε φτάσει στο τέλος του αρχείου.

505
00:42:32,430 --> 00:42:36,450
Εμείς πάμε για να διαβάσει 512 byte σε μια στιγμή.

506
00:42:36,450 --> 00:42:39,180
Και αυτό που είπα εδώ είναι θα πάμε να το αποθηκεύσετε σε ένα ρυθμιστικό,

507
00:42:39,180 --> 00:42:46,230
τόσο βασικά για να κρατήσει αυτές τις 512 bytes μέχρι να μάθουμε ακριβώς τι να κάνει με αυτούς.

508
00:42:46,230 --> 00:42:50,300
Στη συνέχεια, αυτό που θέλουμε να κάνουμε είναι να θέλουμε να ελέγξουμε αν έχουμε χτυπήσει ένα αστέρι ή όχι.

509
00:42:50,300 --> 00:42:57,960
Αν έχουμε χτυπήσει ένα αστέρι, αν έχουμε χτυπήσει ένα από τα αρχικά ακολουθίες,

510
00:42:57,960 --> 00:42:59,980
τότε ξέρουμε ότι έχουμε χτυπήσει ένα νέο αρχείο JPEG.

511
00:42:59,980 --> 00:43:08,860
Αυτό που θα θελήσετε να κάνετε είναι να πάμε να θέλετε να δημιουργήσετε ένα νέο αρχείο στο κατάλογο μας pset4

512
00:43:08,860 --> 00:43:14,480
να συνεχίσει να κάνει αυτό το αρχείο.

513
00:43:14,480 --> 00:43:18,220
Αλλά επίσης, αν έχουμε κάνει ήδη πριν από JPEG,

514
00:43:18,220 --> 00:43:25,620
τότε θέλουμε να τελειώσει αυτό το αρχείο και πιέστε το στο pset4 φάκελο,

515
00:43:25,620 --> 00:43:29,780
όπου θα έχουμε αυτό το αρχείο αποθηκεύεται γιατί αν δεν διευκρινίζουν ότι έχουμε κατέληξε ότι το αρχείο JPEG,

516
00:43:29,780 --> 00:43:37,290
τότε θα έχουμε ουσιαστικά ένα απροσδιόριστο ποσό. Τα αρχεία JPEG δεν θα τελειώσει ποτέ.

517
00:43:37,290 --> 00:43:40,840
Έτσι, θέλετε να βεβαιωθείτε ότι όταν είμαστε σε ανάγνωση σε ένα αρχείο JPEG και εγγράφως ότι,

518
00:43:40,840 --> 00:43:46,590
θέλουμε να κλείσουμε συγκεκριμένα ότι, προκειμένου να ανοίξει το επόμενο.

519
00:43:46,590 --> 00:43:48,430
Θα θελήσετε να ελέγξετε διάφορα πράγματα.

520
00:43:48,430 --> 00:43:52,880
Θέλουμε να ελέγξετε αν είμαστε στην αρχή μιας νέας JPEG με ρυθμιστικό μας

521
00:43:52,880 --> 00:43:56,780
και επίσης αν ήδη έχουν βρει ένα JPEG πριν

522
00:43:56,780 --> 00:44:03,930
επειδή αυτό θα αλλάξει τη διαδικασία σας ελαφρώς.

523
00:44:03,930 --> 00:44:07,880
Έτσι, στη συνέχεια, αφού περάσουν από όλα τον τρόπο και χτυπάτε το τέλος του αρχείου,

524
00:44:07,880 --> 00:44:11,570
τότε τι θα θέλετε να κάνετε είναι θα θελήσετε να κλείσετε όλα τα αρχεία που είναι ανοιχτές.

525
00:44:11,570 --> 00:44:14,100
Αυτό θα είναι πιθανότατα το τελευταίο αρχείο JPEG που έχετε,

526
00:44:14,100 --> 00:44:18,930
καθώς και το αρχείο της κάρτας που έχετε ήδη ασχολούνται με.

527
00:44:21,940 --> 00:44:28,670
>> Το τελευταίο εμπόδιο που πρέπει να αντιμετωπίσουμε είναι το πώς να κάνουν πραγματικά ένα αρχείο JPEG

528
00:44:28,670 --> 00:44:31,950
και πώς να ωθήσει πραγματικά στο φάκελο.

529
00:44:33,650 --> 00:44:39,850
Η PSET απαιτεί ότι κάθε JPEG που θα βρείτε είναι με την ακόλουθη μορφή,

530
00:44:39,850 --> 00:44:43,990
όπου έχετε τον αριθμό. jpg.

531
00:44:43,990 --> 00:44:50,750
Ο αριθμός, ακόμα κι αν είναι 0, λέμε 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Όταν βρείτε ένα JPEG στο πρόγραμμά σας,

533
00:44:55,730 --> 00:44:58,040
θα πάμε να θέλουν να το αναφέρουμε με τη σειρά που έχει βρει.

534
00:44:58,040 --> 00:44:59,700
Τι σημαίνει αυτό;

535
00:44:59,700 --> 00:45:03,530
Πρέπει να το είδος του να παρακολουθείτε πόσα έχουμε βρεθεί

536
00:45:03,530 --> 00:45:08,680
και ό, τι ο αριθμός των κάθε JPEG πρέπει να είναι.

537
00:45:08,680 --> 00:45:13,800
Εδώ θα πάμε να επωφεληθούν από την sprintf λειτουργία.

538
00:45:13,800 --> 00:45:17,480
Παρόμοια με την printf, η οποία ακριβώς το είδος των εκτυπώσεων από μια τιμή στο τερματικό,

539
00:45:17,480 --> 00:45:23,910
sprintf εκτυπώνει το αρχείο έξω στο φάκελο.

540
00:45:23,910 --> 00:45:30,870
Και έτσι ό, τι αυτό θα κάνω, αν είχα sprintf, τον τίτλο, και στη συνέχεια το string εκεί,

541
00:45:30,870 --> 00:45:36,660
θα εκτυπώσετε 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Αν υποθέσουμε ότι έχω κλείσει σωστά τα αρχεία μου,

543
00:45:41,020 --> 00:45:47,210
που θα περιέχει το αρχείο που είχα γράψει έξω.

544
00:45:47,210 --> 00:45:50,320
Αλλά ένα πράγμα είναι ότι ο κώδικας που έχω εδώ

545
00:45:50,320 --> 00:45:53,360
δεν ικανοποιεί αρκετά το τι PSET απαιτεί.

546
00:45:53,360 --> 00:46:02,410
Η PSET απαιτεί ότι το δεύτερο αρχείο JPEG πρέπει να ονομαστεί 002 αντί των μόλις 2.

547
00:46:02,410 --> 00:46:09,160
Έτσι, κατά την εκτύπωση από το όνομα, τότε ίσως να θέλετε να αλλάξει ελαφρώς το σύμβολο κράτησης θέσης.

548
00:46:09,160 --> 00:46:18,140
>> Θυμάται κανείς πώς θα επιτρέπουν την επιπλέον χώρους όταν τυπώνουμε κάτι;

549
00:46:18,140 --> 00:46:22,530
Ναι. >> [Φοιτητής] Βάζετε ένα 3 μεταξύ του σημείου τοις εκατό και το 2. >> Ναι, τέλεια.

550
00:46:22,530 --> 00:46:25,610
Θα βάλει ένα 3 στην περίπτωση αυτή, επειδή θέλουμε χώρο για 3.

551
00:46:25,610 --> 00:46:32,590
3d% θα μπορούσε πιθανότατα να σας δώσει 002.jpg αντί για 2.

552
00:46:32,590 --> 00:46:40,120
Το πρώτο επιχείρημα στην sprintf λειτουργία είναι στην πραγματικότητα ένα char array,

553
00:46:40,120 --> 00:46:42,520
οποία προηγουμένως ήξερε ως χορδές.

554
00:46:42,520 --> 00:46:50,700
Εκείνοι βούληση, το είδος της περισσότερο σαν μια προσωρινή αποθήκευση, την αποθήκευση μόνο η προκύπτουσα σειρά.

555
00:46:50,700 --> 00:46:54,950
Δεν θα είναι πραγματικά ασχολούνται με αυτό, αλλά θα πρέπει να το συμπεριλάβει.

556
00:46:54,950 --> 00:47:00,710
>> Γνωρίζοντας ότι κάθε όνομα αρχείου έχει τον αριθμό, το οποίο καταλαμβάνει τρεις χαρακτήρες,

557
00:47:00,710 --> 00:47:06,770
και στη συνέχεια. jpg, πόσο καιρό θα πρέπει να είναι αυτός ο πίνακας;

558
00:47:09,070 --> 00:47:14,310
Ρίξτε μια σειρά. Πόσοι χαρακτήρες στον τίτλο, στο όνομα;

559
00:47:18,090 --> 00:47:26,320
Έτσι, υπάρχουν 3 hashtags, περίοδο, jpg. >> [Φοιτητής] 7. >> 7. Δεν είναι αρκετά.

560
00:47:26,320 --> 00:47:32,000
Εμείς πάμε να θέλουν 8, διότι θέλουμε να καταστεί δυνατή η μηδενική τερματισμού, καθώς και.

561
00:47:45,340 --> 00:47:49,730
>> Τέλος, μόνο και μόνο για να σκιαγραφήσει τη διαδικασία που θα πρέπει να κάνει για την Ανάκτηση,

562
00:47:49,730 --> 00:47:55,420
έχετε κάποιες πληροφορίες αρχή.

563
00:47:55,420 --> 00:48:02,460
Θα συνεχίσουμε μέχρι να βρείτε την αρχή ενός αρχείου JPEG,

564
00:48:02,460 --> 00:48:07,900
και αυτό μπορεί να είναι είτε μία από τις δύο αρχικών ακολουθιών.

565
00:48:07,900 --> 00:48:12,510
Θα εξακολουθήσουν να διαβάζουν. Κάθε κάθετος εδώ αντιπροσωπεύει 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Μπορείτε να κρατήσει την ανάγνωση, να κρατήσει την ανάγνωση μέχρι να συναντήσετε μια άλλη σειρά εκκίνησης.

567
00:48:22,630 --> 00:48:29,790
Μόλις έχετε ότι, μπορείτε να τερματίσετε την τρέχουσα JPEG - σε αυτή την περίπτωση, είναι το κόκκινο,

568
00:48:29,790 --> 00:48:31,030
έτσι θέλετε να τελειώσει αυτό.

569
00:48:31,030 --> 00:48:35,540
Θέλετε να sprintf το όνομα του ότι σε pset4 φάκελο σας,

570
00:48:35,540 --> 00:48:41,580
τότε θα θέλετε να ανοίξετε ένα νέο JPEG και στη συνέχεια να κρατήσει την ανάγνωση

571
00:48:41,580 --> 00:48:46,370
μέχρι να συναντήσει την επόμενη.

572
00:48:46,370 --> 00:48:49,040
Κρατήστε την ανάγνωση, συνεχίστε το διάβασμα,

573
00:48:49,040 --> 00:48:56,290
και στη συνέχεια, τελικά, τελικά, θα πάμε για να φτάσετε στο τέλος του αρχείου,

574
00:48:56,290 --> 00:49:00,360
και έτσι θα θελήσετε να κλείσετε την τελευταία JPEG που εργάζονταν με,

575
00:49:00,360 --> 00:49:08,380
sprintf ότι σε pset4 φάκελο σας, και στη συνέχεια να εξετάσουμε όλες τις εικόνες που έχετε πάρει.

576
00:49:08,380 --> 00:49:12,050
Αυτές οι εικόνες είναι πραγματικά εικόνες από CS50 προσωπικό,

577
00:49:12,050 --> 00:49:16,430
και έτσι αυτό είναι όπου η διασκέδαση μπόνους μέρος της PSET έρχεται σε

578
00:49:16,430 --> 00:49:26,310
είναι ότι ανταγωνίζονται σε τμήματα σας για να βρείτε τα TFs στις εικόνες

579
00:49:26,310 --> 00:49:34,610
και να βγάλετε φωτογραφίες μαζί τους για να αποδείξουν ότι έχετε κάνει την PSET

580
00:49:34,610 --> 00:49:37,030
και έτσι μπορείτε να δείτε ποια μέλη του προσωπικού είναι στις φωτογραφίες.

581
00:49:37,030 --> 00:49:41,510
Μέχρι τότε μπορείτε να τραβήξετε φωτογραφίες με το προσωπικό. Μερικές φορές θα πρέπει να τους κυνηγήσει.

582
00:49:41,510 --> 00:49:44,680
Ίσως μερικοί από αυτούς θα προσπαθήσει να τρέξει μακριά από εσάς.

583
00:49:44,680 --> 00:49:47,320
Μπορείτε να βγάλετε φωτογραφίες μαζί τους.

584
00:49:47,320 --> 00:49:51,190
Αυτό είναι σε εξέλιξη. Δεν είναι απαιτητοί, όταν το PSET οφείλεται.

585
00:49:51,190 --> 00:49:53,340
Η προθεσμία θα ανακοινωθεί στο spec.

586
00:49:53,340 --> 00:49:58,060
Στη συνέχεια, μαζί με το τμήμα σας, όποιο τμήμα παίρνει τις περισσότερες φωτογραφίες

587
00:49:58,060 --> 00:50:04,430
με τα περισσότερα μέλη του προσωπικού θα κερδίσει ένα αρκετά φοβερό βραβείο.

588
00:50:04,430 --> 00:50:08,890
Αυτό είναι το είδος των κινήτρων για να πάρει pset4 σας τελειώσει όσο το δυνατόν γρηγορότερα

589
00:50:08,890 --> 00:50:10,820
επειδή τότε μπορείτε να πιάσουμε δουλειά

590
00:50:10,820 --> 00:50:14,570
κυνήγι κάτω όλα τα διαφορετικά CS50 μέλη του προσωπικού.

591
00:50:14,570 --> 00:50:17,500
Αυτό δεν είναι υποχρεωτική, αν και, έτσι μόλις πάρετε τις εικόνες,

592
00:50:17,500 --> 00:50:20,310
τότε έχετε τελειώσει με pset4.

593
00:50:20,310 --> 00:50:23,970
>> Και είμαι τελειώσει με Walkthrough 4, οπότε σας ευχαριστώ όλους που ήρθατε.

594
00:50:23,970 --> 00:50:29,330
Καλή τύχη με ιατροδικαστικές. [Χειροκροτήματα]

595
00:50:29,330 --> 00:50:31,000
[CS50.TV]