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.TV CS50 ఉంది]

4
00:00:07,000 --> 00:00:11,000
మేము ఒక ఫైల్ యొక్క ఆలోచించినప్పుడు, ఏమిటి, ఒక Microsoft Word పత్రం స్ఫురణకు వచ్చింది

5
00:00:11,000 --> 00:00:14,000
ఒక చిత్రం, లేదా ఒక MP3 పాట,

6
00:00:14,000 --> 00:00:17,000
మరియు మేము రకాలుగా ఫైళ్ళను ఈ రకమైన ప్రతి సంకర్షణ.

7
00:00:17,000 --> 00:00:20,000
ఉదాహరణకు, ఒక పద పత్రంలో వచనం జోడించండి

8
00:00:20,000 --> 00:00:24,000
ఒక చిత్రం తో మేము అంచులు అవుట్ క్రాప్ లేదా రంగులు retouch ఉండవచ్చు, అయితే.

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
ఒక వైపు, ఒక పత్రం, కేవలం ఒక బైట్ చూడవచ్చు

14
00:00:41,000 --> 00:00:45,000
లేదా 8 సున్నాలు మరియు వాటిని, మరియు స్క్రీన్ మీద ఒక ASCII అక్షరాల ప్రదర్శిస్తాయి.

15
00:00:45,000 --> 00:00:48,000
మరోవైపు, బిట్మ్యాప్ను చిత్రం, 3 బైట్లు చూడవచ్చు

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
ఆఖరి ఫైళ్ళ ఎగువ మూలలో చిన్న ఎరుపు 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
>> ఈ డైరెక్టరీ లో, మేము రెండు సి ఫైళ్ళను మరియు వాటి సంబంధిత ఎగ్జిక్యూటబుల్ ఫైళ్లు ఉన్నాయి.

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
హాయ్. నా పేరు జాసన్ ఉంది.

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
హాయ్. మే పేరు జాసన్ ఉంది.

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, మరియు A. - ఈ వాదన కోసం మూడు ఎంపికలు ఉన్నాయి

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
అయితే W మరియు ఒక ఫైళ్లను వ్రాయడం కోసం ఉపయోగించవచ్చు రెండు,

68
00:03:44,960 --> 00:03:47,460
W ఫైలు యొక్క ప్రారంభం నుండి రాయడం ప్రారంభమౌతుంది

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 శూన్య తిరిగి ఉంటే, మేము, మా కార్యక్రమం ముందుకు నకలు మీరు కాదు

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 ఉపయోగించండి.

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
హాయ్. నా పేరు జాసన్ ఉంది.

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
కాబట్టి మేము W బదులుగా r ఎంచుకున్నారు.

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
మీరు fgets శూన్య వచ్చినప్పడు లూప్ ముగిసే మీరు గమనించవచ్చు.

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
రెండవది, మరియు చాలా ఫైలు ముగింపు కుదిరింది మరియు no more అక్షరాలు పరిగణించింది.

128
00:07:10,740 --> 00:07:14,040
మీరు వొండరింగ్ చేస్తున్న సందర్భంలో, రెండు విధులు మాకు అనుమతించే ఉన్నాయి

129
00:07:14,040 --> 00:07:17,160
ఇది కారణం ఈ ప్రత్యేక నల్ పాయింటర్ కోసం కారణం.

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
ద్వారా తరువాతి రౌండ్, మా కార్యక్రమం, fp యొక్క feof నిజమైతే చూడటానికి తనిఖీ చేస్తుంది

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
మేము అవకాశం చదవడం లేదా సమయంలో మూడు బైట్లు రాయడం వస్తారు.

169
00:09:43,290 --> 00:09:46,450
ఈ సందర్భంలో, ఇది నిర్వచిస్తుంది మరియు తగిన పేరు కోణంలో చేస్తుంది

170
00:09:46,450 --> 00:09:48,980
3 బైట్లు పెద్ద ఒక struct.

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
సరే. ఒక టేక్. ఇక్కడ మేము వెళ్ళండి.

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
అక్కడ హే.

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 చదవడం ఉన్నప్పటికీ విధంగా - ఏ. నా చెడు.