1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [File I / O]

2
00:00:02,000 --> 00:00:04,000
[Jason Hirschhorn, Πανεπιστήμιο Χάρβαρντ]

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

4
00:00:07,000 --> 00:00:11,000
Όταν σκεφτόμαστε ένα αρχείο, τι έρχεται στο μυαλό είναι ένα έγγραφο του Microsoft Word,

5
00:00:11,000 --> 00:00:14,000
μια εικόνα JPEG, MP3 ή ένα τραγούδι,

6
00:00:14,000 --> 00:00:17,000
και εμείς αλληλεπιδρούν με κάθε ένα από αυτούς τους τύπους των αρχείων με διαφορετικούς τρόπους.

7
00:00:17,000 --> 00:00:20,000
Για παράδειγμα, σε ένα έγγραφο του Word προσθέσουμε κείμενο

8
00:00:20,000 --> 00:00:24,000
ενώ με μια εικόνα JPEG που μπορεί να προκύψουν από τις άκρες ή να διορθώσετε τα χρώματα.

9
00:00:24,000 --> 00:00:28,000
Ωστόσο, κάτω από την κουκούλα όλα τα αρχεία στον υπολογιστή μας δεν είναι τίποτα περισσότερο

10
00:00:28,000 --> 00:00:31,000
από μια μακρά σειρά από μηδενικά και μονάδες.

11
00:00:31,000 --> 00:00:33,000
Είναι μέχρι την συγκεκριμένη εφαρμογή που αλληλεπιδρά με το αρχείο

12
00:00:33,000 --> 00:00:38,000
να αποφασίσουν πώς θα επεξεργαστεί αυτή τη μακρά ακολουθία και να το παρουσιάσει στο χρήστη.

13
00:00:38,000 --> 00:00:41,000
Από τη μία πλευρά, ένα έγγραφο μπορεί να φανεί σε ένα μόνο byte,

14
00:00:41,000 --> 00:00:45,000
ή 8 μηδενικά και μονάδες, και να εμφανίσει ένα ASCII χαρακτήρα στην οθόνη.

15
00:00:45,000 --> 00:00:48,000
Από την άλλη μεριά, μια εικόνα bitmap μπορεί να κοιτάξει 3 bytes,

16
00:00:48,000 --> 00:00:50,000
ή 24 μηδενικά και μονάδες,

17
00:00:50,000 --> 00:00:53,000
και να τους ερμηνεύουν ως 3 δεκαεξαδικούς αριθμούς

18
00:00:53,000 --> 00:00:56,000
που αντιπροσωπεύουν τις τιμές για το κόκκινο, το πράσινο και το μπλε

19
00:00:56,000 --> 00:00:58,000
σε ένα εικονοστοιχείο μιας εικόνας.

20
00:00:58,000 --> 00:01:01,000
Ό, τι μπορεί να μοιάζει στην οθόνη σας, στον πυρήνα τους,

21
00:01:01,000 --> 00:01:05,000
τα αρχεία δεν είναι τίποτα περισσότερο από μια ακολουθία από μηδενικά και μονάδες.

22
00:01:05,000 --> 00:01:08,000
Έτσι, ας βουτιά σε και να δούμε πώς θα χειριστεί αυτά τα πραγματικά μηδενικά και μονάδες

23
00:01:08,000 --> 00:01:12,000
όταν πρόκειται για γραφή και την ανάγνωση από ένα αρχείο.

24
00:01:12,000 --> 00:01:15,000
>> Θα ξεκινήσω με το σπάσιμο προς τα κάτω σε μια απλή διαδικασία 3-μέρος.

25
00:01:15,000 --> 00:01:19,000
Στη συνέχεια, θα βουτήξει σε δύο παραδείγματα κώδικα που αποδεικνύουν αυτά τα τρία μέρη.

26
00:01:19,000 --> 00:01:23,000
Τέλος, θα επανεξετάσει τη διαδικασία και μερικά από τα πιο σημαντικά στοιχεία του.

27
00:01:23,000 --> 00:01:25,000
Όπως και με οποιοδήποτε αρχείο που βρίσκεται στην επιφάνεια εργασίας σας,

28
00:01:25,000 --> 00:01:28,000
το πρώτο πράγμα που πρέπει να κάνετε είναι να το ανοίξετε.

29
00:01:28,000 --> 00:01:31,000
Στην Γ κάνουμε αυτό, δηλώνοντας ένα δείκτη σε μια προκαθορισμένη struct

30
00:01:31,000 --> 00:01:33,000
που αντιπροσωπεύει ένα αρχείο στο δίσκο.

31
00:01:33,000 --> 00:01:38,460
Σε αυτή την κλήση της συνάρτησης, μπορούμε επίσης να αποφασίσουμε αν θέλουμε να γράψετε ή να διαβάσετε από το αρχείο.

32
00:01:38,460 --> 00:01:41,660
Στη συνέχεια, κάνουμε την πραγματική ανάγνωση και τη γραφή.

33
00:01:41,660 --> 00:01:44,800
Υπάρχουν μια σειρά από εξειδικευμένες λειτουργίες που μπορούμε να χρησιμοποιήσουμε σε αυτό το μέρος,

34
00:01:44,800 --> 00:01:48,790
και σχεδόν όλοι τους αρχίζουν με το γράμμα F, το οποίο ξεχωρίζει για το αρχείο.

35
00:01:48,790 --> 00:01:53,560
Τελευταία, παρόμοια με τα μικρά κόκκινα Χ στην επάνω γωνία του τα αρχεία ανοίγουν στον υπολογιστή σας,

36
00:01:53,560 --> 00:01:56,680
κλείνουμε το αρχείο με την τελική κλήση της συνάρτησης.

37
00:01:56,680 --> 00:01:59,540
Τώρα που έχουμε μια γενική ιδέα για το τι θα πάμε να κάνουμε,

38
00:01:59,540 --> 00:02:02,000
ας βουτιά στον κώδικα.

39
00:02:02,000 --> 00:02:06,100
>> Σε αυτόν τον κατάλογο, έχουμε δύο αρχεία και C αντίστοιχα εκτελέσιμα αρχεία τους.

40
00:02:06,100 --> 00:02:09,710
Το πρόγραμμα γραφομηχανή παίρνει ένα όρισμα της γραμμής εντολών,

41
00:02:09,710 --> 00:02:12,060
το όνομα του εγγράφου που θέλουμε να δημιουργήσουμε.

42
00:02:12,060 --> 00:02:16,160
Σε αυτή την περίπτωση, θα καλέσουμε το doc.txt.

43
00:02:16,160 --> 00:02:19,080
Ας τρέξει το πρόγραμμα και εισάγετε ένα ζευγάρι των γραμμών.

44
00:02:19,080 --> 00:02:23,660
Γεια σας. Το όνομά μου είναι Jason.

45
00:02:23,660 --> 00:02:26,710
Τέλος, θα πληκτρολογήσετε "σταματήσουν το κάπνισμα."

46
00:02:26,710 --> 00:02:29,720
Αν τώρα λίστα όλα τα αρχεία σε αυτόν τον κατάλογο,

47
00:02:29,720 --> 00:02:33,770
βλέπουμε ότι ένα νέο έγγραφο που ονομάζεται doc.txt υπάρχει.

48
00:02:34,190 --> 00:02:36,110
Αυτό είναι το αρχείο αυτό το πρόγραμμα μόλις δημιουργήσατε.

49
00:02:36,110 --> 00:02:40,520
Και φυσικά, είναι πολύ τίποτα περισσότερο από μια μακρά ακολουθία από μηδενικά και μονάδες.

50
00:02:41,100 --> 00:02:43,260
Εάν ανοίξετε αυτό το νέο αρχείο,

51
00:02:43,260 --> 00:02:45,870
βλέπουμε τις 3 γραμμές κώδικα μπήκαμε στο πρόγραμμά μας -

52
00:02:46,060 --> 00:02:49,060
Γεια σας. Μαΐου όνομα είναι Jason.

53
00:02:49,580 --> 00:02:52,090
Αλλά τι πραγματικά συμβαίνει όταν typewriter.c τρέχει;

54
00:02:52,810 --> 00:02:55,520
Η πρώτη γραμμή του ενδιαφέροντος για μας είναι η γραμμή 24.

55
00:02:55,560 --> 00:02:58,490
Σε αυτή τη γραμμή, έχουμε δηλώσει δείκτη του αρχείου μας.

56
00:02:59,080 --> 00:03:03,140
Η συνάρτηση που επιστρέφει το δείκτη, fopen, παίρνει δύο επιχειρήματα.

57
00:03:03,140 --> 00:03:07,440
Το πρώτο είναι το όνομα του αρχείου, συμπεριλαμβανομένης της επέκτασης αρχείου ανάλογα με την περίπτωση.

58
00:03:07,440 --> 00:03:10,980
Θυμηθείτε ότι μια επέκταση αρχείου δεν επηρεάζει το αρχείο στο χαμηλότερο επίπεδό της.

59
00:03:10,980 --> 00:03:14,640
Είμαστε πάντα ασχολούνται με μια μεγάλη σειρά από μηδενικά και μονάδες.

60
00:03:14,640 --> 00:03:19,630
Αλλά αυτό δεν επηρεάζει το πώς ερμηνεύονται τα αρχεία και οι εφαρμογές που χρησιμοποιούνται τι να τα ανοίξετε.

61
00:03:19,630 --> 00:03:22,290
Το δεύτερο επιχείρημα για fopen είναι ένα μεμονωμένο γράμμα

62
00:03:22,290 --> 00:03:25,300
που ξεχωρίζει για το τι σκοπεύουμε να κάνουμε εμείς μετά το άνοιγμα του αρχείου.

63
00:03:25,300 --> 00:03:30,630
Υπάρχουν τρεις επιλογές για αυτό το επιχείρημα - W, R, και Α.

64
00:03:30,630 --> 00:03:34,900
Έχουμε επιλέξει w σε αυτή την περίπτωση, γιατί θέλουμε να γράψουμε στο αρχείο.

65
00:03:34,900 --> 00:03:38,820
R, όπως μπορείτε να μαντέψετε, είναι για την ανάγνωση του αρχείου.

66
00:03:38,820 --> 00:03:41,760
Και μια είναι για προσαρτώντας στο αρχείο.

67
00:03:41,760 --> 00:03:44,960
Ενώ και οι δύο νν και ένας μπορεί να χρησιμοποιηθεί για γραφή σε αρχεία,

68
00:03:44,960 --> 00:03:47,460
νν θα αρχίσει να γράφει από την αρχή του αρχείου

69
00:03:47,460 --> 00:03:50,810
και ενδεχομένως να αντικαταστήσετε όλα τα δεδομένα που έχουν ήδη αποθηκευτεί.

70
00:03:50,810 --> 00:03:54,070
Από προεπιλογή, το αρχείο θα ανοίξει, εάν δεν υπάρχει ήδη,

71
00:03:54,070 --> 00:03:57,180
δημιουργείται στην παρούσα κατάλογο εργασίας μας.

72
00:03:57,180 --> 00:04:00,540
Ωστόσο, αν θέλουμε να έχουν πρόσβαση ή να δημιουργήσετε ένα αρχείο σε διαφορετική θέση,

73
00:04:00,540 --> 00:04:02,650
κατά το πρώτο επιχείρημα της fopen,

74
00:04:02,650 --> 00:04:05,840
μπορούμε να καθορίσετε μια διαδρομή αρχείου εκτός από το όνομα του αρχείου.

75
00:04:05,840 --> 00:04:09,490
Ενώ το πρώτο μέρος αυτής της διαδικασίας είναι μόνο μία γραμμή κώδικα μακρύ,

76
00:04:09,490 --> 00:04:12,350
είναι πάντα καλή πρακτική να περιλαμβάνουν ένα άλλο σύνολο των γραμμών

77
00:04:12,350 --> 00:04:15,930
ότι το check για να βεβαιωθείτε ότι το αρχείο με επιτυχία ανοίξει ή δημιουργήσει.

78
00:04:15,930 --> 00:04:20,300
Αν fopen επιστρέφει null, δεν θα θέλαμε να προχωρήσουμε με το πρόγραμμά μας,

79
00:04:20,300 --> 00:04:23,270
και αυτό μπορεί να συμβεί εάν το λειτουργικό σύστημα είναι έξω από τη μνήμη

80
00:04:23,270 --> 00:04:27,940
ή αν προσπαθείτε να ανοίξετε ένα αρχείο σε έναν κατάλογο για τον οποίο δεν είχαμε τα κατάλληλα δικαιώματα.

81
00:04:27,940 --> 00:04:31,780
>> Το δεύτερο μέρος της διαδικασίας λαμβάνει χώρα στο βρόχο, ενώ γραφομηχανή του.

82
00:04:31,780 --> 00:04:35,000
Χρησιμοποιούμε ένα CS50 λειτουργία της βιβλιοθήκης για να πάρετε είσοδο από το χρήστη,

83
00:04:35,000 --> 00:04:37,190
και με την παραδοχή ότι δεν θέλουν να σταματήσουν το πρόγραμμα,

84
00:04:37,190 --> 00:04:41,940
χρησιμοποιούμε τα fputs λειτουργία για να λάβει το string και να το γράψετε στο αρχείο.

85
00:04:41,940 --> 00:04:46,700
fputs είναι μόνο μία από τις πολλές λειτουργίες που θα μπορούσαμε να χρησιμοποιήσουμε για να γράψουμε στο αρχείο.

86
00:04:46,700 --> 00:04:51,920
Άλλοι περιλαμβάνουν fwrite, fputc, ακόμη και fprintf.

87
00:04:51,920 --> 00:04:54,840
Ανεξάρτητα από την συγκεκριμένη λειτουργία καταλήγουμε χρησιμοποιώντας, όμως,

88
00:04:54,840 --> 00:04:57,480
όλα αυτά πρέπει να γνωρίζουν, μέσω των επιχειρημάτων τους,

89
00:04:57,480 --> 00:04:59,670
τουλάχιστον δύο πράγματα -

90
00:04:59,670 --> 00:05:03,140
τι πρέπει να γραφτεί και όπου χρειάζεται να γραφτεί σε.

91
00:05:03,140 --> 00:05:07,240
Στην περίπτωσή μας, η είσοδος είναι η συμβολοσειρά που πρέπει να γραφτεί

92
00:05:07,240 --> 00:05:11,290
και fp είναι ο δείκτης που μας κατευθύνει εκεί που γράφουμε.

93
00:05:11,290 --> 00:05:15,330
Σε αυτό το πρόγραμμα, το δεύτερο μέρος της διαδικασίας είναι μάλλον απλή.

94
00:05:15,330 --> 00:05:17,360
Παίρνουμε απλά μια σειρά από τον χρήστη

95
00:05:17,360 --> 00:05:22,120
και προσθέτοντας απευθείας στο αρχείο μας με λίγο έως καθόλου επικύρωση των εισροών ή οι έλεγχοι ασφαλείας.

96
00:05:22,120 --> 00:05:26,160
Συχνά, όμως, το δεύτερο μέρος θα αναλάβει το μεγαλύτερο μέρος του κώδικα σας.

97
00:05:26,160 --> 00:05:30,580
Τέλος, το τρίτο μέρος είναι στη γραμμή 58, όπου κλείνουμε το αρχείο.

98
00:05:30,580 --> 00:05:34,860
Εδώ καλούμε fclose και να περάσει το αρχικό δείκτη του αρχείου μας.

99
00:05:34,860 --> 00:05:39,500
Στην επόμενη γραμμή, θα επιστρέψουμε το μηδέν, σηματοδοτώντας το τέλος του προγράμματός μας.

100
00:05:39,500 --> 00:05:42,630
Και, ναι, το τρίτο μέρος είναι τόσο απλό.

101
00:05:42,630 --> 00:05:45,260
>> Ας προχωρήσουμε στην ανάγνωση από αρχεία.

102
00:05:45,260 --> 00:05:48,220
Επιστροφή στον κατάλογο μας έχουμε ένα αρχείο που ονομάζεται printer.c.

103
00:05:48,220 --> 00:05:50,910
Ας το τρέξετε με το αρχείο που μόλις δημιουργήσατε -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
Το πρόγραμμα αυτό, όπως υποδηλώνει το όνομα, απλά θα εκτυπώσει από το περιεχόμενο του αρχείου για να το περάσει.

106
00:05:58,150 --> 00:06:00,230
Και εκεί έχουμε.

107
00:06:00,230 --> 00:06:03,780
Οι γραμμές του κώδικα που είχε πληκτρολογήσει νωρίτερα και να αποθηκευτεί σε doc.txt.

108
00:06:03,780 --> 00:06:06,980
Γεια σας. Το όνομά μου είναι Jason.

109
00:06:06,980 --> 00:06:09,120
Αν βουτήξει printer.c,

110
00:06:09,120 --> 00:06:13,570
βλέπουμε ότι ένα μεγάλο μέρος του κώδικα μοιάζει με αυτό που μόλις μπήκε μέσα στο typewriter.c.

111
00:06:13,570 --> 00:06:16,720
Πράγματι γραμμή 22, όπου ανοίξαμε το αρχείο,

112
00:06:16,720 --> 00:06:19,220
και η γραμμή 39, όπου κλείσαμε το αρχείο,

113
00:06:19,220 --> 00:06:23,890
είναι και οι δύο σχεδόν πανομοιότυπα με typewriter.c, εκτός fopen δεύτερο επιχείρημα.

114
00:06:23,890 --> 00:06:26,510
Αυτή τη φορά είμαστε ανάγνωση από ένα αρχείο,

115
00:06:26,510 --> 00:06:29,040
έτσι έχουμε επιλέξει, αντί του r w.

116
00:06:29,040 --> 00:06:31,950
Έτσι, ας επικεντρωθεί στο δεύτερο μέρος της διαδικασίας.

117
00:06:31,950 --> 00:06:36,060
Στη γραμμή 35, ως δεύτερη προϋπόθεση σε 4 βρόχο μας,

118
00:06:36,060 --> 00:06:38,590
κάνουμε μια κλήση με fgets,

119
00:06:38,590 --> 00:06:42,190
η λειτουργία σύντροφος για fputs από πριν.

120
00:06:42,190 --> 00:06:44,660
Αυτή τη φορά έχουμε τρία επιχειρήματα.

121
00:06:44,660 --> 00:06:48,810
Ο πρώτος είναι ο δείκτης προς τη συστοιχία των χαρακτήρων, όπου η συμβολοσειρά θα αποθηκευτεί.

122
00:06:48,810 --> 00:06:52,670
Ο δεύτερος είναι ο μέγιστος αριθμός των χαρακτήρων που θα διαβάσετε.

123
00:06:52,670 --> 00:06:56,010
Και το τρίτο είναι ο δείκτης στο αρχείο με το οποίο δουλεύουμε.

124
00:06:56,010 --> 00:07:00,780
Θα παρατηρήσετε ότι ο βρόχος for τελειώνει όταν fgets επιστρέφει null.

125
00:07:00,780 --> 00:07:02,940
Υπάρχουν δύο λόγος για τον οποίο αυτό μπορεί να συμβεί.

126
00:07:02,940 --> 00:07:05,380
Κατ 'αρχάς, ένα λάθος μπορεί να έχει συμβεί.

127
00:07:05,380 --> 00:07:10,740
Δεύτερον, και πιο πιθανό, το τέλος του αρχείου επιτεύχθηκε και πλέον χαρακτήρες είχαν διαβάσει.

128
00:07:10,740 --> 00:07:14,040
Σε περίπτωση που αναρωτιέστε, δύο λειτουργίες υπάρχουν ότι θα μας επιτρέψουν να πει

129
00:07:14,040 --> 00:07:17,160
οποία λόγος είναι η αιτία για αυτό το συγκεκριμένο δείκτη null.

130
00:07:17,160 --> 00:07:21,090
Και, όπως ήταν αναμενόμενο, δεδομένου ότι έχουν να κάνουν με την εργασία με τα αρχεία,

131
00:07:21,090 --> 00:07:26,940
τόσο η λειτουργία π.χ. η ferror και η έναρξη λειτουργίας feof με το γράμμα f.

132
00:07:26,940 --> 00:07:32,130
>> Τέλος, πριν ολοκληρώσουμε, μια γρήγορη σημείωση σχετικά με το τέλος της λειτουργίας του αρχείου,

133
00:07:32,130 --> 00:07:36,690
το οποίο, όπως μόλις ανέφερα, είναι γραμμένο ως feof.

134
00:07:36,690 --> 00:07:41,550
Συχνά θα βρείτε τον εαυτό σας με τη χρήση, ενώ και για βρόχους να διαβάσετε σταδιακά το δρόμο σας μέσα από τα αρχεία.

135
00:07:41,550 --> 00:07:45,790
Έτσι, θα χρειαστείτε έναν τρόπο για να σταματήσει αυτές τις θηλιές αφού φτάσετε στο τέλος αυτών των αρχείων.

136
00:07:45,790 --> 00:07:50,510
Κλήση για feof δείκτη αρχείο σας και τον έλεγχο για να δούμε αν είναι αλήθεια

137
00:07:50,510 --> 00:07:52,310
θα κάνουν ακριβώς αυτό.

138
00:07:52,310 --> 00:07:59,820
Έτσι, ένα βρόχο, ενώ με τον όρο (! Feof (fp)) μπορεί να φαίνεται σαν μια τέλεια κατάλληλη λύση.

139
00:07:59,820 --> 00:08:03,770
Ωστόσο, λένε ότι έχουμε μία γραμμή αριστερά στο αρχείο κειμένου μας.

140
00:08:03,770 --> 00:08:07,130
Θα τεθεί βρόχο, ενώ μας και όλα θα πάνε όπως είχε προγραμματιστεί.

141
00:08:07,130 --> 00:08:12,750
Στο επόμενο γύρο μέσω του προγράμματος μας θα ελέγξει για να δει εάν feof του fp είναι αλήθεια,

142
00:08:12,750 --> 00:08:15,430
αλλά - και αυτό είναι το κρίσιμο σημείο για να καταλάβουμε εδώ -

143
00:08:15,430 --> 00:08:17,770
δεν θα ισχύει ακόμα.

144
00:08:17,770 --> 00:08:21,110
Αυτό συμβαίνει γιατί ο σκοπός του δεν είναι feof να ελέγξετε

145
00:08:21,110 --> 00:08:24,400
αν η επόμενη κλήση σε μια λειτουργία ανάγνωσης θα χτυπήσει το τέλος του αρχείου,

146
00:08:24,400 --> 00:08:28,190
αλλά μάλλον για να ελέγξετε αν ή όχι το τέλος του αρχείου έχει ήδη επιτευχθεί.

147
00:08:28,190 --> 00:08:30,140
Στην περίπτωση του παραδείγματος αυτού,

148
00:08:30,140 --> 00:08:32,780
διαβάζοντας την τελευταία γραμμή του αρχείου μας πηγαίνει τέλεια ομαλά,

149
00:08:32,780 --> 00:08:36,210
αλλά το πρόγραμμα δεν γνωρίζει ακόμη ότι έχουμε χτυπήσει το τέλος του αρχείου μας.

150
00:08:36,210 --> 00:08:40,549
Δεν είναι μέχρι να κάνει μια επιπλέον ανάγνωση ότι μετρητές το τέλος του αρχείου.

151
00:08:40,549 --> 00:08:43,210
Ετσι, μια σωστή προϋπόθεση θα είναι η ακόλουθη:

152
00:08:43,210 --> 00:08:49,330
fgets και τρία επιχειρήματα του - παραγωγή, το μέγεθος της παραγωγής, και fp -

153
00:08:49,330 --> 00:08:52,570
και όλα αυτά δεν είναι ίσο με το μηδέν.

154
00:08:52,570 --> 00:08:55,260
Αυτή είναι η προσέγγιση που κάναμε στο printer.c,

155
00:08:55,260 --> 00:08:57,890
και στην περίπτωση αυτή, μετά από τις εξόδους βρόχου,

156
00:08:57,890 --> 00:09:04,290
μπορείτε να καλέσετε ή feof π.χ. η ferror να ενημερώσει το χρήστη με τη συγκεκριμένη αιτιολογία για την έξοδο από αυτή βρόχο.

157
00:09:04,290 --> 00:09:08,100
>> Γράφοντας και την ανάγνωση από ένα αρχείο είναι, στο πιο βασικό του,

158
00:09:08,100 --> 00:09:10,150
ένα απλό 3-μέρος της διαδικασίας.

159
00:09:10,150 --> 00:09:12,530
Πρώτον, το άνοιγμα του αρχείου.

160
00:09:12,530 --> 00:09:16,740
Δεύτερον, βάζουμε κάποια πράγματα στο αρχείο μας ή να πάρετε κάποια πράγματα έξω από αυτό.

161
00:09:16,740 --> 00:09:19,200
Τρίτον, κλείστε το αρχείο.

162
00:09:19,200 --> 00:09:21,170
Η πρώτη και η τελευταία μέρη είναι εύκολο.

163
00:09:21,170 --> 00:09:23,920
Το μεσαίο τμήμα είναι όπου η ουσία βρίσκεται δύσκολη.

164
00:09:23,920 --> 00:09:27,760
Και όμως κάτω από το καπό είμαστε πάντα ασχολούνται με μια μεγάλη σειρά από μηδενικά και μονάδες,

165
00:09:27,760 --> 00:09:30,710
βοηθάει όταν κωδικοποίησης για να προσθέσετε ένα στρώμα αφαίρεσης

166
00:09:30,710 --> 00:09:35,350
που μετατρέπει την ακολουθία σε κάτι που μοιάζει περισσότερο με αυτό που έχουμε συνηθίσει να βλέπουμε.

167
00:09:35,350 --> 00:09:39,570
Για παράδειγμα, εάν εργάζεστε με μια 24-bit αρχείο bitmap,

168
00:09:39,570 --> 00:09:43,290
εμείς μάλλον θα πρέπει να διαβάζει ή να γράφει τρία bytes κάθε φορά.

169
00:09:43,290 --> 00:09:46,450
Σε αυτή την περίπτωση, θα ήταν λογικό να καθορίζουν κατάλληλα και το όνομα

170
00:09:46,450 --> 00:09:48,980
ένα struct που είναι 3 bytes μεγάλο.

171
00:09:48,980 --> 00:09:51,410
>> Αν εργάζεστε με αρχεία μπορεί να φαίνεται περίπλοκη,

172
00:09:51,410 --> 00:09:54,530
χρησιμοποιώντας τους μας επιτρέπει να κάνουμε κάτι πραγματικά αξιόλογο.

173
00:09:54,530 --> 00:09:58,880
Μπορούμε να αλλάξουμε την κατάσταση του κόσμου έξω από το πρόγραμμά μας,

174
00:09:58,880 --> 00:10:01,730
μπορούμε να δημιουργήσουμε κάτι που ζει πέρα ​​από τη διάρκεια ζωής του προγράμματος μας,

175
00:10:01,730 --> 00:10:07,190
ή μπορούμε να αλλάξουμε κάτι ακόμη που δημιουργήθηκε πριν από το πρόγραμμά μας άρχισε να τρέχει.

176
00:10:07,190 --> 00:10:11,210
Αλληλεπίδραση με τα αρχεία είναι ένα πραγματικά ισχυρό μέρος του προγραμματισμού σε C.

177
00:10:11,210 --> 00:10:15,300
και είμαι ενθουσιασμένος για να δείτε τι πρόκειται να δημιουργηθεί με αυτό τον κωδικό για να έρθει.

178
00:10:15,300 --> 00:10:19,770
Το όνομά μου είναι Jason Hirschhorn. Αυτό είναι CS50.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [Γέλια]

181
00:10:25,940 --> 00:10:29,330
Εντάξει. Ένα λάβει. Εδώ πάμε.

182
00:10:49,000 --> 00:10:52,140
Όταν σκεφτόμαστε ένα αρχείο - >> Αχ, περιμένετε. Λυπάμαι.

183
00:10:52,140 --> 00:10:56,800
[Γέλια] Εντάξει.

184
00:11:06,620 --> 00:11:09,970
Hey εκεί.

185
00:11:13,670 --> 00:11:16,310
Όταν σκεφτόμαστε ένα αρχείο -

186
00:11:17,610 --> 00:11:20,710
Όταν σκέφτεστε από ένα αρχείο - Εντάξει. Πείτε μου, όταν είστε έτοιμοι.

187
00:11:20,710 --> 00:11:22,520
Ω, μεγάλη.

188
00:11:22,520 --> 00:11:26,180
Αν και την ανάγνωση από μια teleprompter μπορεί να φαίνεται - όχι. Κακή μου.