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
[ჯეისონ 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 image, ან 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
Yet ქვეშ Hood ყველა ფაილი ჩვენს კომპიუტერში არიან და მეტი არაფერი

10
00:00:28,000 --> 00:00:31,000
ვიდრე ხანგრძლივი თანმიმდევრობა zeros და პირობა.

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
ერთი მხრივ, დოკუმენტში შეიძლება შევხედოთ მხოლოდ ერთი ბაიტი,

14
00:00:41,000 --> 00:00:45,000
ან 8 zeros და პირობა, და არიან ASCII ხასიათი ეკრანზე.

15
00:00:45,000 --> 00:00:48,000
მეორეს მხრივ, bitmap გამოსახულება შეიძლება შევხედოთ 3 ბაიტი,

16
00:00:48,000 --> 00:00:50,000
ან 24 zeros და პირობა,

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
ერთ pixel of გამოსახულება.

20
00:00:58,000 --> 00:01:01,000
რაც მათ შეიძლება გამოიყურებოდეს თქვენს ეკრანზე, მათი ძირითადი,

21
00:01:01,000 --> 00:01:05,000
ფაილი მეტი არაფერი თანმიმდევრობა zeros და პირობა.

22
00:01:05,000 --> 00:01:08,000
მოდით ჩაყვინთვის და გაიხსენოთ ჩვენ რეალურად მანიპულირება ამ zeros და პირობა

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
In C ჩვენ ამას ვაკეთებთ მიერ გამოცხადების მომცეთ წინასწარგანსაზღვრული 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
ბოლო, akin რომ პატარა წითელი X ზედა კუთხეში ფაილი გასახსნელად თქვენს კომპიუტერში,

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
საბეჭდი მანქანა პროგრამა იღებს ერთ command line არგუმენტი,

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
Hi. ჩემი სახელია ჯეისონ.

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
და რა თქმა უნდა, ეს ძალიან, მეტი არაფერი ხანგრძლივი თანმიმდევრობა zeros და პირობა.

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
Hi. მაისი სახელია ჯეისონ.

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
ჩვენ ყოველთვის საქმე ხანგრძლივი თანმიმდევრობა zeros და პირობა.

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
და არის appending ფაილი.

67
00:03:41,760 --> 00:03:44,960
მიუხედავად იმისა, რომ ორივე W და შეიძლება გამოყენებულ იქნეს წერილობით ფაილი

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
რომ შეამოწმოთ, რათა უზრუნველყოს, რომ ფაილი წარმატებით გახსნა ან შექმნილი.

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
>> ნაწილი ორი პროცესი ხდება საბეჭდი მანქანა ს ხოლო loop.

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 მიიღოს სიმებიანი და დაწეროთ ის ფაილი.

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
ჩვენ უბრალოდ აღების string საწყისი მომხმარებლის

95
00:05:17,360 --> 00:05:22,120
და შეავსოთ იგი პირდაპირ ჩვენს ფაილი პატარა-ს არ შეყვანის Validation ან უსაფრთხოების ამოწმებს.

96
00:05:22,120 --> 00:05:26,160
ხშირად, თუმცა, ნაწილს ორი დაიწყებს ნაყარი თქვენი კოდი.

97
00:05:26,160 --> 00:05:30,580
საბოლოოდ, ნაწილი სამი არის on line 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
Hi. ჩემი სახელია ჯეისონ.

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 loop,

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
თქვენ შეამჩნევთ, რომ ამისთვის loop დამთავრდა, როდესაც 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 ფუნქცია იწყება წერილი ვ.

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 of 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
და ყველა რომ არ უტოლდება null.

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 ინფორმირება მომხმარებლის როგორც კონკრეტული მიზეზის ამისთვის არსებული ამ loop.

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
და თუმცა ქვეშ Hood ჩვენ ყოველთვის საქმე ხანგრძლივი თანმიმდევრობა zeros და პირობა,

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
ჩვენ სავარაუდოდ კითხულობს ან წერილობით სამი ბაიტი დროს.

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
ჩემი სახელია ჯეისონ 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
Okay. ერთი მიიღოს. Here We Go.

182
00:10:49,000 --> 00:10:52,140
როდესაც ჩვენ ვფიქრობთ of file - >> Oh, დაველოდოთ. უკაცრავად.

183
00:10:52,140 --> 00:10:56,800
[სიცილის] Okay.

184
00:11:06,620 --> 00:11:09,970
Hey არსებობს.

185
00:11:13,670 --> 00:11:16,310
როდესაც ჩვენ ვფიქრობთ of file -

186
00:11:17,610 --> 00:11:20,710
როდესაც ფიქრობთ ფაილი - Okay. მითხარით, როდესაც თქვენ მზად.

187
00:11:20,710 --> 00:11:22,520
ოჰ, დიდი.

188
00:11:22,520 --> 00:11:26,180
თუმცა კითხულობს საწყისი teleprompter ჩანდეს - არ. ჩემი ცუდი.