1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> సల ఇప్పటివరకు, అది అవకాశం వార్తలు
మీ కార్యక్రమాలు చాలా ఆ

3
00:00:07,870 --> 00:00:10,170
ఒక బిట్ అశాశ్వత ఉన్నాయి.

4
00:00:10,170 --> 00:00:13,310
మీరు మారియో లేదా గ్రీడీ వంటి ప్రోగ్రామ్ రన్.

5
00:00:13,310 --> 00:00:17,350
ఇది బహుశా అడుగును చేస్తుంది ఏదో
కొంత సమాచారాన్ని వినియోగదారు

6
00:00:17,350 --> 00:00:20,400
స్క్రీన్ కొన్ని అవుట్పుట్ ప్రింట్
కానీ అప్పుడు మీ ప్రోగ్రామ్, ఓవర్

7
00:00:20,400 --> 00:00:23,252
అక్కడ ఎటువంటి ఆధారం నిజంగా ఉంది
అది ఎప్పుడూ మొదటి స్థానంలో నడిపించారు.

8
00:00:23,252 --> 00:00:25,960
నేను ఖచ్చితంగా మీరు ఎడమ ఉండవచ్చు, అర్థం
ఇది టెర్మినల్ విండో లో తెరవడానికి

9
00:00:25,960 --> 00:00:29,770
మీరు మీ స్క్రీన్ క్లియర్ కానీ, అక్కడ
ఇది ఉనికిలో నిజంగా ఎటువంటి ఆధారం.

10
00:00:29,770 --> 00:00:33,720
మేము నిల్వ మార్గాల లేదు
నిరంతర సమాచారం, సమాచారం

11
00:00:33,720 --> 00:00:36,890
మా తర్వాత ఉనికిలో
కార్యక్రమం అమలు ఆగిపోయింది,

12
00:00:36,890 --> 00:00:39,241
లేదా మేము ఈ పాయింట్ వరకు లేదు.

13
00:00:39,241 --> 00:00:41,490
అదృష్టవశాత్తూ అయితే, c చేస్తుంది
సామర్థ్యం అందించండి

14
00:00:41,490 --> 00:00:44,220
అమలు ద్వారా దీన్ని
అనే విషయం

15
00:00:44,220 --> 00:00:48,330
ఒక ఫైల్, ఒక నిర్మాణం ప్రాథమికంగా
మీరు డబుల్ అని ఒక ఫైల్ సూచిస్తుంది

16
00:00:48,330 --> 00:00:53,826
మీరు అయితే, మీ కంప్యూటర్ మీద క్లిక్
గ్రాఫికల్ యూజర్ ఎన్విరాన్మెంట్ ఉపయోగిస్తారు.

17
00:00:53,826 --> 00:00:55,700
సాధారణంగా పనిచేసేటప్పుడు
సి తో, మేము నిజానికి ఉన్నాము

18
00:00:55,700 --> 00:00:59,965
పని కావడం
గమనికలు ఫైలు ఫైళ్ళు కు stars--

19
00:00:59,965 --> 00:01:02,090
కొద్దిగా తప్ప
మేము ఒక జంట గురించి మాట్లాడినప్పుడు

20
00:01:02,090 --> 00:01:04,560
విధులు యొక్క
ఫైలు గమనికలు పని.

21
00:01:04,560 --> 00:01:08,990
మీరు నిజంగా తవ్విన అవసరం లేదు
అవగాహన గమనికలు చాలా లోతైన

22
00:01:08,990 --> 00:01:09,730
తాము.

23
00:01:09,730 --> 00:01:12,870
కొద్దిగా teeny బిట్ ఉంది
మేము వాటిని గురించి చర్చ ఉంటుంది పేరు,

24
00:01:12,870 --> 00:01:18,090
కానీ సాధారణంగా గమనికలు ఫైల్ మరియు
గమనికలు, ఒకదాని మీద అయితే,

25
00:01:18,090 --> 00:01:20,290
సరిగ్గా అదే విషయం కాదు.

26
00:01:20,290 --> 00:01:22,440
>> ఇప్పుడు నేను ఏమి అర్థం లేదు
నేను నిరంతర డేటా చెప్పటానికి?

27
00:01:22,440 --> 00:01:23,650
నిరంతర డేటా ఏమిటి?

28
00:01:23,650 --> 00:01:25,232
మేము దాని గురించి ఎందుకు శ్రద్ధ లేదు?

29
00:01:25,232 --> 00:01:27,190
ఆ, ఉదాహరణకు, సే
మీరు ఒక కార్యక్రమం అమలు చేస్తున్నారు

30
00:01:27,190 --> 00:01:29,850
లేదా మీరు తిరిగి వ్రాయబడుతుంది చేసిన ఒక
ఒక గేమ్ కార్యక్రమం

31
00:01:29,850 --> 00:01:32,960
మరియు మీరు ట్రాక్ ఉంచాలని
యూజర్ యొక్క ఎత్తుగడలు అన్ని యొక్క

32
00:01:32,960 --> 00:01:36,620
కాబట్టి ఏదో తప్పు జరిగితే ఉంటే బహుశా,
మీరు ఆట తర్వాత ఫైల్ సమీక్షించే.

33
00:01:36,620 --> 00:01:39,970
ఆ ఉన్నప్పుడు మేము ఉద్దేశ్యం ఏమిటి
నిరంతర డేటా గురించి మాట్లాడటానికి.

34
00:01:39,970 --> 00:01:43,930
>> అమలు క్రమంలో మీ
కార్యక్రమం, ఒక ఫైల్ రూపొందించినవారు ఉంటుంది.

35
00:01:43,930 --> 00:01:45,680
మరియు మీ ప్రోగ్రామ్
అమలు ఆగిపోయింది,

36
00:01:45,680 --> 00:01:48,689
ఆ ఫైల్ ఇంకా మీ సిస్టమ్ లో ఉందో.

37
00:01:48,689 --> 00:01:50,230
మరియు మేము అది చూడండి మరియు అది పరిశీలించడానికి చేయవచ్చు.

38
00:01:50,230 --> 00:01:53,670
కాబట్టి ఆ కార్యక్రమం సెట్ అవుతుంది
కొన్ని నిరంతర డేటా సృష్టించిన,

39
00:01:53,670 --> 00:01:57,390
డేటా కార్యక్రమం తర్వాత ఉనికిలో
నడుస్తున్న పూర్తయింది.

40
00:01:57,390 --> 00:02:02,320
>> ఇప్పుడు పని చేసే ఈ విధులను అన్ని
ఫైళ్ళను సృష్టించడం మరియు అంగాలు తో

41
00:02:02,320 --> 00:02:04,940
వివిధ మార్గాల్లో వాటిని
ప్రామాణిక io.h నివసిస్తున్నారు,

42
00:02:04,940 --> 00:02:08,210
ఇది ఒక శీర్షికా ఫైలును అని
మీరు అవకాశం పౌండ్ ఉన్నాను

43
00:02:08,210 --> 00:02:10,910
అందంగా ఎగువన సహా
మీ కార్యక్రమాలు చాలా అన్ని

44
00:02:10,910 --> 00:02:14,130
అది ఒక ఉన్నందున
మాకు చాలా ఉపయోగకరమైన విధులు,

45
00:02:14,130 --> 00:02:16,130
కూడా అనుమతించే printf,
ప్రామాణిక io.h. నివసిస్తున్నారు

46
00:02:16,130 --> 00:02:20,400
సో మీరు కూడా పౌండ్ అవసరం లేదు
ఏ అదనపు ఫైళ్లు బహుశా

47
00:02:20,400 --> 00:02:23,540
క్రమంలో ఫైలు గమనికలు తో పని.

48
00:02:23,540 --> 00:02:29,980
>> ఇప్పుడు ప్రతి ఒక్క ఫైల్ పాయింటర్ ఫంక్షన్,
లేదా ప్రతి ఒక్క ఫైలు I / O, ఇన్పుట్ అవుట్పుట్

49
00:02:29,980 --> 00:02:33,310
ఫంక్షన్, ఒక స్వీకరించు
దాని పారామితులు లేదా ప్రవేశాంశాల

50
00:02:33,310 --> 00:02:35,822
తప్ప ఒక ఫైల్ పాయింటర్
ఒక కోసం, fopen, ఇది

51
00:02:35,822 --> 00:02:38,280
మీరు ఫైల్ పొందడానికి ఉపయోగించే ఏమిటి
మొదటి స్థానంలో పాయింటర్.

52
00:02:38,280 --> 00:02:41,010
కానీ మీరు తెరిచిన తర్వాత
ఫైల్ మరియు మీరు ఫైల్ గమనికలు పొందండి

53
00:02:41,010 --> 00:02:43,510
మీరు వాటిని తరలిస్తారు
వివిధ విధులకు వాదనలు

54
00:02:43,510 --> 00:02:46,720
మేము గురించి మాట్లాడటానికి వెళుతున్న
నేడు, అలాగే అనేక ఇతర

55
00:02:46,720 --> 00:02:48,520
కాబట్టి మీరు ఫైళ్లను తో పని చేయవచ్చు.

56
00:02:48,520 --> 00:02:50,980
>> కనుక ఆరు అందంగా ఉన్నాయి
సాధారణ ప్రాథమిక వాటిని

57
00:02:50,980 --> 00:02:52,870
మేము నేడు గురించి మాట్లాడటానికి వెళుతున్న.

58
00:02:52,870 --> 00:02:57,160
fopen మరియు దాని సహచర
ఫంక్షన్ fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
మరియు దాని సహచర ఫంక్షన్ fputc,
మరియు fread మరియు దాని సహచర ఫంక్షన్,

60
00:03:02,670 --> 00:03:03,820
fwrite.

61
00:03:03,820 --> 00:03:05,180
కాబట్టి యొక్క కుడి అది పొందడానికి వీలు.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- ఇది ఏమి చేస్తుంది?

63
00:03:07,050 --> 00:03:10,050
సరే, ఒక ఫైల్ తెరుచుకుంటుంది మరియు అది
దానికి మీరు ఒక ఫైల్ పాయింటర్ ఇస్తుంది,

64
00:03:10,050 --> 00:03:14,000
కాబట్టి మీరు ఆ ఉపయోగించవచ్చు
ఒక వాదన వంటి పాయింటర్ ఫైల్

65
00:03:14,000 --> 00:03:16,730
ఇతర ఫైలు I / O విధులు ఏ.

66
00:03:16,730 --> 00:03:19,100
అతి ముఖ్యమైన విషయం
fopen తో గుర్తు

67
00:03:19,100 --> 00:03:24,222
మీరు తెరిచారు అని తర్వాత
దాఖలు లేదా ఇక్కడ ఒక వంటి ఒక పిలుపుకు,

68
00:03:24,222 --> 00:03:26,930
మీరు నిర్ధారించుకోండి తనిఖీ చెయ్యాలి
మీరు తిరిగి వచ్చింది అని పాయింటర్

69
00:03:26,930 --> 00:03:28,320
శూన్యం సమానం కాదు.

70
00:03:28,320 --> 00:03:31,320
మీరు వీడియో వీక్షించారు ఉండకపోతే
గమనికలు, ఈ సమంజసం కాదు.

71
00:03:31,320 --> 00:03:35,639
కానీ మీరు ప్రయత్నించండి మరియు dereference ఉంటే
ఒక నల్ పాయింటర్ రీకాల్

72
00:03:35,639 --> 00:03:38,180
మీ కార్యక్రమాన్ని బహుశా నష్టపోవచ్చు
సెగ్మెంటేషన్ [వినబడని].

73
00:03:38,180 --> 00:03:40,540
మేము నిర్ధారించుకోండి చేయాలనుకుంటున్నారా మేము
ఒక చట్టబద్ధమైన పాయింటర్ తిరిగి వచ్చింది.

74
00:03:40,540 --> 00:03:43,665
సమయం మెజారిటీ మేము రెడీ
తిరిగి న్యాయమైన పాయింటర్ ఉండాల్సిందని

75
00:03:43,665 --> 00:03:45,280
మరియు అది ఒక సమస్య వుండదు.

76
00:03:45,280 --> 00:03:46,760
>> సో ఎలా మేము ఒక కాల్ fopen సంపాదిస్తారు?

77
00:03:46,760 --> 00:03:48,051
ఇది ఇలా అందంగా చాలా బాగుంది.

78
00:03:48,051 --> 00:03:52,690
ఒక సాధారణ ఉండటం PTR ptr-- ఫైల్ స్టార్
పాయింటర్ fopen ఫైల్ కోసం పేరు

79
00:03:52,690 --> 00:03:57,300
మరియు మేము రెండు విషయాలు ఒక ఫైల్ పేరు పాస్
మరియు ఒక ఆపరేషన్ మేము చేపట్టేందుకు కావలసిన.

80
00:03:57,300 --> 00:04:01,690
కాబట్టి మేము వలె కనిపించే ఒక కాల్ ఉండవచ్చు
దీన్ని ఫైలు స్టార్ PTR 1 fopen సమానం

81
00:04:01,690 --> 00:04:04,040
file1.txt.

82
00:04:04,040 --> 00:04:07,020
నేను ఎంచుకున్న ఆపరేషన్ r ఉంది.

83
00:04:07,020 --> 00:04:08,639
>> సో వాట్ మీరు r ఇక్కడ ఉంది ఆలోచిస్తాడు?

84
00:04:08,639 --> 00:04:11,180
విషయాలు రకాల ఏమిటి మేము
ఫైళ్లు చేస్తామని కావచ్చు?

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
కాబట్టి r ఆపరేషన్ అని మేము
మనం ఒక ఫైల్ చదవాలనుకుంటున్న ఉన్నప్పుడు ఎంచుకోండి.

87
00:04:17,500 --> 00:04:20,260
కాబట్టి మేము ప్రధానంగా ఎప్పుడు
మేము ఈ వంటి ఒక కాల్

88
00:04:20,260 --> 00:04:25,440
మమ్మల్ని ఫైల్ పాయింటర్ పంపబడతాయి
మేము అప్పుడు సమాచారాన్ని చదివి అని అటువంటి

89
00:04:25,440 --> 00:04:27,770
file1.txt నుండి.

90
00:04:27,770 --> 00:04:34,190
>> అదేవిధంగా, మేము ఫైల్ 2.txt తెరవాలని
ptr2 రచనకు అందువలన మేము తరలిస్తారు

91
00:04:34,190 --> 00:04:38,210
నేను ఇక్కడ సృష్టించాను ఫైలు పాయింటర్,
ఏదైనా ఫంక్షన్ ఒక వాదన వంటి

92
00:04:38,210 --> 00:04:40,080
ఒక ఫైల్ సమాచారం రాశారు.

93
00:04:40,080 --> 00:04:43,767
మరియు రచన పోలి ఉంది
కూడా ఎంపిక ఒక జోడించే.

94
00:04:43,767 --> 00:04:45,600
మధ్య తేడా
రాయడం మరియు అనుమతిస్తూ

95
00:04:45,600 --> 00:04:50,920
ఉండటం మీరు ఒక ఫైల్ వ్రాయడం ఉన్నప్పుడు,
మీరు రచనకు fopen ఒక కాల్ చేస్తే

96
00:04:50,920 --> 00:04:54,761
మరియు ఫైల్ ఇప్పటికే అంతే, ఉనికిలో
మొత్తం ఫైల్ ఓవర్రైట్ జరగబోతోంది.

97
00:04:54,761 --> 00:04:56,510
ఇది ఆరంభమవుతుంది
చాలా ప్రారంభంలో,

98
00:04:56,510 --> 00:04:58,820
అన్ని సమాచారం తొలగించడం
ఇప్పటికే ఉంది.

99
00:04:58,820 --> 00:05:02,210
>> మీరు అనుమతిస్తూ కోసం అది తెరిస్తే అయితే,
ఇది ఫైల్ చివర వెళ్తుంది

100
00:05:02,210 --> 00:05:04,340
ఇప్పటికే టెక్స్ట్ ఉంది ఉంటే
అది లేదా అందులోని సమాచారాన్ని,

101
00:05:04,340 --> 00:05:06,040
మరియు అది ప్రారంభమౌతుంది
అక్కడ నుండి వ్రాయడం.

102
00:05:06,040 --> 00:05:08,570
సో మీరు ఏ కోల్పోతారు లేదు
మీరు ముందు చేసిన సమాచారం.

103
00:05:08,570 --> 00:05:12,110
మీరు వ్రాసే లేదా కలపవచ్చు నిశ్చఇ
విధమైన పరిస్థితి ఆధారపడి ఉంటుంది.

104
00:05:12,110 --> 00:05:16,840
కానీ మీరు బహుశా ఏమి చేస్తాము
సమయం వచ్చినప్పుడు సరైన చర్య.

105
00:05:16,840 --> 00:05:18,020
కాబట్టి ఆ fopen వార్తలు.

106
00:05:18,020 --> 00:05:18,930
>> ఏం fclose గురించి?

107
00:05:18,930 --> 00:05:21,600
బాగా, అందంగా కేవలం fclose
కేవలం ఫైల్ పాయింటర్ అంగీకరిస్తుంది.

108
00:05:21,600 --> 00:05:24,000
మరియు మీరు ఆశించిన విధంగా,
అది ఆ ఫైల్ ముగుస్తాయి.

109
00:05:24,000 --> 00:05:29,270
మేము ఒక ఫైలు మూసి చేసిన ఒకసారి, మేము కాదు
ఏ మరింత ఫైలు I / O విధులు నిర్వహించడానికి

110
00:05:29,270 --> 00:05:31,420
చదవడం లేదా ఫైల్లో, రచన.

111
00:05:31,420 --> 00:05:36,444
మేము తిరిగి తెరిచి ఉంటుంది
ఆర్డర్ లో మరొక సారి దాఖలు

112
00:05:36,444 --> 00:05:38,610
తో పనిచేయడానికి
ఇది I / O విధులు ఉపయోగించి.

113
00:05:38,610 --> 00:05:41,520
మేము పూర్తి చేసిన సో fclose మార్గాల
ఈ ఫైలు పని.

114
00:05:41,520 --> 00:05:44,690
మరియు మేము పాస్ అవసరం అన్ని ఉంది
ఒక ఫైల్ పాయింటర్ యొక్క పేరు.

115
00:05:44,690 --> 00:05:50,010
ఒక జంట క్రితం మునిగి కాబట్టి, మేము
పఠనం fopened ఫైలు 1 డాట్ టెక్స్ట్

116
00:05:50,010 --> 00:05:52,854
మరియు మేము ఆ కేటాయించిన
ptr1 పాయింటర్ దాఖలు.

117
00:05:52,854 --> 00:05:55,020
ఇప్పుడు మనం ఉన్నాము నిర్ణయించుకుంది చేసిన
ఆ ఫైల్ చదవడం పూర్తయింది.

118
00:05:55,020 --> 00:05:56,561
మేము అది ఏ మరింత అవసరం లేదు.

119
00:05:56,561 --> 00:05:58,890
మేము కేవలం fclose ptr1 చెయ్యవచ్చు.

120
00:05:58,890 --> 00:06:01,950
మరియు అలాగే, మేము అనుకొనుట
ఇతర వాటిని fclose.

121
00:06:01,950 --> 00:06:02,450
అయితే సరే.

122
00:06:02,450 --> 00:06:03,700
కాబట్టి ఆ తెరవడం మరియు మూసివేయడం.

123
00:06:03,700 --> 00:06:05,780
ఆ రెండు ప్రాథమిక ఉంటాయి
కార్యకలాపాలు ప్రారంభమయ్యాయి.

124
00:06:05,780 --> 00:06:08,050
>> ఇప్పుడు మేము నిజంగా కావలసిన
కొన్ని ఆసక్తికరమైన విషయాలను,

125
00:06:08,050 --> 00:06:11,940
మరియు మొదటి చర్య, ఆ మేము చేస్తాము
ఆ fgetc-- అని చేస్తాను చూడండి

126
00:06:11,940 --> 00:06:14,110
ఒక పాత్ర పొందడానికి దాఖలు.

127
00:06:14,110 --> 00:06:17,350
ఆ సాధారణంగా fgetc ఏమిటి
కు అనువదించడానికి అని.

128
00:06:17,350 --> 00:06:20,190
జీవితంలో దీని లక్ష్యం ఉంది
తదుపరి పాత్ర చదవండి,

129
00:06:20,190 --> 00:06:22,079
లేదా ఈ మీ చాలా ఉంటే
fgetc మొదటి కాల్

130
00:06:22,079 --> 00:06:23,870
ఒక ప్రత్యేక ఫైలు,
మొదటి పాత్ర.

131
00:06:23,870 --> 00:06:26,210
కానీ ఆ తర్వాత,
మీరు తదుపరి ఒక పొందుటకు

132
00:06:26,210 --> 00:06:31,500
ఆ ఫైల్ యొక్క చాలా తదుపరి పాత్ర
ఒక పాత్ర వేరియబుల్ మరియు దుకాణాలు ఇది.

133
00:06:31,500 --> 00:06:34,490
మేము ఇక్కడ చేసినట్లుగానే,
చార్ ch, fgetc సమానం

134
00:06:34,490 --> 00:06:36,389
ఒక ఫైల్ పాయింటర్ యొక్క పేరు లో పాస్.

135
00:06:36,389 --> 00:06:38,180
మళ్ళీ, అది చాలా వార్తలు
గుర్తు ఇక్కడ ముఖ్యమైన

136
00:06:38,180 --> 00:06:41,430
క్రమంలో కలిగి
ఈ ఆపరేషన్ విజయవంతం,

137
00:06:41,430 --> 00:06:45,690
ఫైలు పాయింటర్ కూడా must've
పఠనం కోసం తెరవబడింది.

138
00:06:45,690 --> 00:06:50,589
మేము ఒక ఫైల్ నుండి ఒక పాత్ర చదువలేదు
మేము రచనకు ప్రారంభమైన పాయింటర్.

139
00:06:50,589 --> 00:06:52,630
కాబట్టి ఆ ఒకటి
fopen యొక్క పరిధులు, కుడి?

140
00:06:52,630 --> 00:06:55,470
మేము పరిమితం కలిగి
మమ్మల్ని మాత్రమే చేస్తూ

141
00:06:55,470 --> 00:06:57,710
ఒక ఫైల్ పాయింటర్ తో ఒక ఆపరేషన్.

142
00:06:57,710 --> 00:07:00,220
మేము చదవడానికి కోరుకుంటే
ఒకే ఫైల్ నుండి రాయడానికి,

143
00:07:00,220 --> 00:07:03,840
మేము ఓపెన్ రెండు ప్రత్యేక వుంటుంది
అదే ఫైల్ ఫైల్ గమనికలు

144
00:07:03,840 --> 00:07:05,670
పఠనం కోసం ఒకటి, రచన కోసం ఒక.

145
00:07:05,670 --> 00:07:08,400
>> మరలా, మాత్రమే కారణం
నేను ఇప్పుడు ఆ తీసుకురావటానికి

146
00:07:08,400 --> 00:07:11,920
మేము ఒక కాల్ చేయడానికి చూడాలని ఉంటే ఎందుకంటే
fgetc, ఆ ఫైల్ పాయింటర్ must've

147
00:07:11,920 --> 00:07:14,172
పఠనం కోసం తెరవబడింది.

148
00:07:14,172 --> 00:07:15,880
ఆపై అందంగా కేవలం,
అన్ని మేము చెయ్యాల్సిన

149
00:07:15,880 --> 00:07:17,546
ఫైలు పాయింటర్ యొక్క పేరు లో పాస్ ఉంది.

150
00:07:17,546 --> 00:07:21,060
కాబట్టి చార్ ch fgetc ptr1 సమానం.

151
00:07:21,060 --> 00:07:23,200
>> మాకు పొందడానికి జరగబోతోంది
తదుపరి పాత్ర

152
00:07:23,200 --> 00:07:25,575
లేదా మళ్ళీ ఈ మొదటి, ఉంటే
మేము ఈ కాల్ చేసిన సమయం,

153
00:07:25,575 --> 00:07:29,750
మొదటి పాత్ర సంసార
ఫైలు ptr1 చూపారు.

154
00:07:29,750 --> 00:07:32,210
ఆ ఫైల్ 1 డాట్ టెక్స్ట్ అని గుర్తు.

155
00:07:32,210 --> 00:07:36,490
ఇది ఆ మొదటి అక్షరం పొందుతారు
మరియు మేము వేరియబుల్ CH నిల్వ చేస్తాము.

156
00:07:36,490 --> 00:07:37,941
ప్రెట్టీ సూటిగా.

157
00:07:37,941 --> 00:07:40,190
కాబట్టి మేము కేవలం మూడు చూశారు చేసిన
విధులు మరియు మేము ఇప్పటికే

158
00:07:40,190 --> 00:07:43,070
అందంగా చక్కగా ఏదో ఒకటి చెయ్యాలి.

159
00:07:43,070 --> 00:07:46,320
>> మేము ఈ సామర్థ్యం పడుతుంది చేస్తే
ఒక పాత్ర పొందడానికి

160
00:07:46,320 --> 00:07:48,943
మరియు మేము లూప్ కాబట్టి దాన్ని మేము
అక్షరాలు వస్తూ

161
00:07:48,943 --> 00:07:51,390
ఒక ఫైల్ నుండి పైగా మరియు
పైగా మరియు over-- ఇప్పుడు మేము

162
00:07:51,390 --> 00:07:54,500
ప్రతి ఒక్క చదువుకోవచ్చు
ఒక ఫైల్ యొక్క పాత్ర.

163
00:07:54,500 --> 00:07:58,670
మరియు మేము ప్రతి పాత్ర ప్రింట్ ఉంటే
మేము అది చదివి వెంటనే,

164
00:07:58,670 --> 00:08:01,960
మేము ఇప్పుడు ఒక ఫైల్ నుండి చదివాను మరియు
స్క్రీన్ దాని కంటెంట్లను ముద్రించబడింది.

165
00:08:01,960 --> 00:08:05,610
మేము సమర్థవంతంగా ఒకదాని వెంబడి చేసిన
తెరపై ఆ ఫైల్.

166
00:08:05,610 --> 00:08:09,670
మరియు ఏ
Linux కమాండ్ పిల్లి చేస్తుంది.

167
00:08:09,670 --> 00:08:13,250
>> మీరు ఫైల్ పేరు లో పిల్లి టైప్ చేస్తే, అది
మొత్తం కంటెంట్లను ప్రింట్

168
00:08:13,250 --> 00:08:15,160
మీ టెర్మినల్ విండో లో ఫైల్.

169
00:08:15,160 --> 00:08:19,010
మరియు ఇక్కడ ఈ చిన్న లూప్,
కోడ్ మాత్రమే మూడు పంక్తులు,

170
00:08:19,010 --> 00:08:23,270
కాని ప్రభావవంతంగా నకిలీలను
Linux కమాండ్ పిల్లి.

171
00:08:23,270 --> 00:08:25,210
కాబట్టి ఈ వాక్యనిర్మాణం ఉండవచ్చు
ఒక చిన్న అసహజ చూడండి

172
00:08:25,210 --> 00:08:26,670
కానీ ఇక్కడ ఏం ఉంది.

173
00:08:26,670 --> 00:08:31,460
Ch fgetc సమానం అయితే, PTR కాదు
అది మొత్తం మౌత్ఫుల్ EOF-- సమానంగా,

174
00:08:31,460 --> 00:08:34,669
కానీ యొక్క అది కేవలం విచ్ఛిన్నం వీలు
కాబట్టి అది వాక్యనిర్మాణం స్పష్టమవుతుంది.

175
00:08:34,669 --> 00:08:37,169
నేను చాటుకుంది చేసిన
స్థలం కొరకు,

176
00:08:37,169 --> 00:08:39,049
అది కొద్దిగా అయితే
పదము గమ్మత్తైన.

177
00:08:39,049 --> 00:08:41,194
>> కాబట్టి గ్రీన్ కుడి లో ఈ భాగం
ఇప్పుడు, అది ఏమి ఉంది?

178
00:08:41,194 --> 00:08:42,860
Well, కేవలం మా fgetc కాల్ కుడి?

179
00:08:42,860 --> 00:08:44,530
మేము ముందు చూసిన.

180
00:08:44,530 --> 00:08:49,500
ఇది ఒక పొందడంలో లో
ఫైలు నుండి పాత్ర.

181
00:08:49,500 --> 00:08:53,220
అప్పుడు మేము ఆ సరిపోల్చండి
EOF వ్యతిరేకంగా పాత్ర.

182
00:08:53,220 --> 00:08:57,470
EOF అని ఒక ప్రత్యేక విలువ
ప్రామాణిక io.h, లో నిర్వచించిన

183
00:08:57,470 --> 00:08:59,390
ఫైల్ పాత్ర ముగింపు.

184
00:08:59,390 --> 00:09:03,450
కాబట్టి ప్రాథమికంగా జరిగే అవకాశముంది ఏమి
ఈ లూప్ ఒక పాత్ర చదువుతాను ఉంది,

185
00:09:03,450 --> 00:09:07,445
, EOF పోల్చడం
ఫైల్ పాత్ర ముగింపు.

186
00:09:07,445 --> 00:09:10,070
వారు సరిపోలడం లేదు ఉంటే, మేము కలిగి
ఫైలు ముగింపు చేరుకుంది

187
00:09:10,070 --> 00:09:11,490
మేము ఆ పాత్రను ప్రింట్ చేస్తాము.

188
00:09:11,490 --> 00:09:13,740
అప్పుడు మేము తిరిగి వెళ్తారో
మళ్ళీ లూప్ ప్రారంభం.

189
00:09:13,740 --> 00:09:18,310
మేము ఒక పాత్ర పొందుతారు, తనిఖీ
EOF వ్యతిరేకంగా, కాబట్టి అది ముద్రించాలా, మరియు

190
00:09:18,310 --> 00:09:21,094
అందువలన మరియు అందువలన న,
ఆ విధంగా ద్వారా వెతికినా

191
00:09:21,094 --> 00:09:22,760
మేము ఫైల్ ముగింపు చేరుకున్నారు వరకు.

192
00:09:22,760 --> 00:09:24,593
ఆపై ఆ సమయంలో,
మేము ముద్రించిన ఉంటుంది

193
00:09:24,593 --> 00:09:26,210
ఫైలు యొక్క మొత్తం కంటెంట్లను.

194
00:09:26,210 --> 00:09:29,450
మరలా, మేము మాత్రమే చూసిన
fopen, fclose, మరియు fgetc

195
00:09:29,450 --> 00:09:34,950
మరియు ఇప్పటికే మేము నకిలీ చేయవచ్చు
ఒక లినక్సు టెర్మినల్ ఆదేశం.

196
00:09:34,950 --> 00:09:38,850
>> నేను ప్రారంభంలో అన్నాడు,
మేము fgetc మరియు fputc వచ్చింది,

197
00:09:38,850 --> 00:09:41,860
మరియు fputc తోడుగా ఉంది
fgetc ఫంక్షన్.

198
00:09:41,860 --> 00:09:44,880
అందువలన, మీరు, ఊహించే ఉండవచ్చు
అది రచన సమానం.

199
00:09:44,880 --> 00:09:49,440
ఇది మాకు ఒక రాయడానికి అనుమతిస్తుంది
ఒక ఫైల్ ఒకే పాత్ర.

200
00:09:49,440 --> 00:09:53,290
>> మళ్ళీ, మినహాయింపు ఉండటం కేవలం
ఇది fgetc తో లాగా, ఫైలు

201
00:09:53,290 --> 00:09:56,660
మేము must've రాస్తున్నాం రచన
రచనకు లేదా అనుమతిస్తూ తెరవబడ్డాయి.

202
00:09:56,660 --> 00:10:00,820
మేము ప్రయత్నించండి మరియు ఒక ఫైల్ లో fputc ఉపయోగిస్తే
మేము చదవడానికి తెరిచిన,

203
00:10:00,820 --> 00:10:02,760
మనం అనుభవించే చూడాలని
తప్పు యొక్క ఒక బిట్.

204
00:10:02,760 --> 00:10:04,440
అయితే కాల్ అందంగా సులభం.

205
00:10:04,440 --> 00:10:08,000
fputc రాజధాని ptr2, అన్ని
అలా జరగబోతోంది ఉంది

206
00:10:08,000 --> 00:10:12,040
లేఖ రాయాలో
ఒక ఫైల్ లోకి 2 డాట్ లోకి

207
00:10:12,040 --> 00:10:14,760
పేరు గ్రంథంలో
మేము ప్రారంభమైంది మరియు కేటాయించిన దాఖలు

208
00:10:14,760 --> 00:10:17,280
పాయింటర్ ptr2 కు.

209
00:10:17,280 --> 00:10:20,430
కాబట్టి మేము ఒక రాయాలో
రాజధాని A 2 డాట్ టెక్స్ట్ ఫైల్.

210
00:10:20,430 --> 00:10:24,592
మరియు మేము ఒక ఆశ్చర్యార్థకం వ్రాయండి చేస్తాము
3 డాట్ ఫైలు పాయింటు

211
00:10:24,592 --> 00:10:27,330
ptr3 ద్వారా చూపారు, ఇది టెక్స్ట్.

212
00:10:27,330 --> 00:10:29,730
మరలా, ఇక్కడ అందంగా సూటిగా.

213
00:10:29,730 --> 00:10:32,727
>> కానీ ఇప్పుడు మేము మరొక విషయం చేయవచ్చు.

214
00:10:32,727 --> 00:10:34,560
మేము ఈ ఉదాహరణ ఉంది
మేము కేవలం ఉండేవి

215
00:10:34,560 --> 00:10:38,950
పిల్లి నకలు సామర్థ్యం గురించి
Linux కమాండ్ బయటకు ముద్రిస్తుంది ఒక

216
00:10:38,950 --> 00:10:40,500
స్క్రీన్.

217
00:10:40,500 --> 00:10:43,510
Well, ఇప్పుడు మేము సామర్థ్యం కలిగి
ఫైళ్లు నుండి అక్షరాలు చదవడానికి

218
00:10:43,510 --> 00:10:46,590
మరియు, ఫైళ్లకు అక్షరాలు వ్రాయడానికి
మనం కేవలం ఆ ప్రత్యామ్నాయంగా లేదు

219
00:10:46,590 --> 00:10:50,720
fputc కాల్ తో printf కాల్.

220
00:10:50,720 --> 00:10:54,090
>> మరియు ఇప్పుడు మేము cp నకిలీ చేసిన,
చాలా ప్రాథమిక Linux కమాండ్

221
00:10:54,090 --> 00:10:59,100
మేము మార్గం దీర్ఘ గురించి చర్చిస్తామని
క్రితం Linux లో వీడియో ఆశిస్తాడు.

222
00:10:59,100 --> 00:11:01,070
మేము సమర్థవంతంగా చేసిన
ఇక్కడే ఆ నకిలీ.

223
00:11:01,070 --> 00:11:04,790
మేము ఒక పాత్ర చదువుతున్న ఆపై మేము ఉన్నాము
మరొక ఫైల్ ఆ పాత్ర రాయడం.

224
00:11:04,790 --> 00:11:07,660
ఒక ఫైల్ నుండి పఠనం, రాయడం
పైగా మరియు పైగా, మరొక

225
00:11:07,660 --> 00:11:11,350
మరియు పైగా మళ్ళీ మేము EOF హిట్ వరకు.

226
00:11:11,350 --> 00:11:14,250
మేము చివర పొందారు
దాఖలు మేము నుండి కాపీ ప్రయత్నిస్తున్న.

227
00:11:14,250 --> 00:11:18,500
మరియు ఆ ద్వారా మేము అన్ని వ్రాశారు చేస్తాము
అక్షరాలు మేము ఫైల్ అవసరం

228
00:11:18,500 --> 00:11:19,500
మేము రాస్తున్నాం.

229
00:11:19,500 --> 00:11:24,270
కాబట్టి ఈ cp, Linux కాపీని ఆదేశం ఉంది.

230
00:11:24,270 --> 00:11:26,550
>> చాలా ప్రారంభంలో
ఈ వీడియో, నేను మినహాయింపు కలిగి

231
00:11:26,550 --> 00:11:29,840
మేము ఒక మాట్లాడిన ఆ
గమనికలు గురించి కొద్దిగా.

232
00:11:29,840 --> 00:11:32,480
మేము ఎక్కడ ఇక్కడ ప్రత్యేకంగా
గమనికలు గురించి మాట్లాడటానికి వెళ్ళడం

233
00:11:32,480 --> 00:11:34,800
అదనంగా గమనికలు ఫైల్.

234
00:11:34,800 --> 00:11:37,870
కాబట్టి ఈ ఫంక్షన్ రకమైన భయానకంగా కనిపిస్తోంది.

235
00:11:37,870 --> 00:11:39,120
ఇది పలు కారకాలు కలిగియున్నారు.

236
00:11:39,120 --> 00:11:40,430
ఇక్కడ జరగబోతోంది చాలా ఉంది.

237
00:11:40,430 --> 00:11:42,760
వివిధ చాలా ఉంది
రంగులు మరియు గ్రంథాలు.

238
00:11:42,760 --> 00:11:47,100
కానీ నిజంగా, అది కేవలం
fgetc యొక్క జెనెరిక్ వెర్షన్

239
00:11:47,100 --> 00:11:50,110
మాకు ఏ పొందడానికి అనుమతిస్తుంది
సమాచారం మొత్తం.

240
00:11:50,110 --> 00:11:53,560
ఇది మేము ఉన్నాము ఉంటే ఒక బిట్ అసమర్థంగా కావచ్చు
ఒక సమయంలో అక్షరాలు ఒక పొందడానికి,

241
00:11:53,560 --> 00:11:55,770
ఫైలు ద్వారా iterating
ఒక సమయంలో ఒక పాత్ర.

242
00:11:55,770 --> 00:12:00,230
అది పొందుటకు NICER కాదు
ఒక సమయంలో ఒక సమయంలో లేదా 500 100?

243
00:12:00,230 --> 00:12:03,250
>> Well, fread మరియు దాని సహచర ఫంక్షన్
fwrite, మేము మాట్లాడదాము

244
00:12:03,250 --> 00:12:05,490
రెండవ, మాకు కేవలం అలా అనుమతిస్తాయి.

245
00:12:05,490 --> 00:12:08,480
మేము ఏకపక్ష మొత్తం చదువుకోవచ్చు
ఒక ఫైల్ నుండి సమాచారాన్ని

246
00:12:08,480 --> 00:12:10,290
మరియు మేము ఎక్కడో తాత్కాలికంగా నిల్వ.

247
00:12:10,290 --> 00:12:12,980
బదులుగా కేవలం సామర్థ్యం
ఒక వేరియబుల్ అది సరిపోయే,

248
00:12:12,980 --> 00:12:15,790
మేము ఒక అర్రే లో నిల్వ అవసరం ఉండవచ్చు.

249
00:12:15,790 --> 00:12:19,980
అందువలన, మేము నాలుగు పాస్
వాదనలు ఒక పాయింటర్ fread-- కు

250
00:12:19,980 --> 00:12:23,940
మేము ఉన్నాము ప్రదేశాన్ని
సమాచారం నిల్వ చేయడానికి వెళ్తున్నారు,

251
00:12:23,940 --> 00:12:29,180
ఎలా సమాచారం యొక్క ప్రతి యూనిట్ పెద్ద
ఉంటుంది, సమాచార ఎన్ని యూనిట్లు

252
00:12:29,180 --> 00:12:35,192
మేము సాధించటం అనుకుంటున్నారా, మరియు నుండి
ఇది ఫైల్ మేము వాటిని పొందడానికి కావలసిన.

253
00:12:35,192 --> 00:12:37,150
బహుశా ఉత్తమ సోదాహరణ
ఇక్కడ ఒక ఉదాహరణ తో.

254
00:12:37,150 --> 00:12:41,640
కాబట్టి యొక్క మేము డిక్లేర్ అని పిలవబడు
10 పూర్ణాంకాల యొక్క వ్యూహం.

255
00:12:41,640 --> 00:12:45,080
మేము న డిక్లేర్డ్ చేసిన
ఏకపక్ష స్టేక్ చేరే 10 Int.

256
00:12:45,080 --> 00:12:46,970
కాబట్టి ఆ అందంగా సూటిగా ఉంది.

257
00:12:46,970 --> 00:12:51,970
ఇప్పుడు మేము అయితే చేస్తున్నా ఉంది
frecall మేము Int యొక్క పరిమాణం చదువుతున్న ఉంది

258
00:12:51,970 --> 00:12:54,180
సార్లు సమాచారాన్ని 10 బైట్లు.

259
00:12:54,180 --> 00:12:59,040
పూర్ణాంకానికి జీవి యొక్క పరిమాణం ఆ వార్తలు four--
సి లో పూర్ణాంకం యొక్క పరిమాణం.

260
00:12:59,040 --> 00:13:02,790
>> కాబట్టి మనం చేస్తున్న మేము చదువుతున్న ఉంది
సమాచారం యొక్క విలువ 40 బైట్లు

261
00:13:02,790 --> 00:13:05,850
ఫైలు నుండి PTR ద్వారా చూపారు.

262
00:13:05,850 --> 00:13:08,600
మరియు మేము ఆ నిల్వ చేస్తున్నారు
40 బైట్లు ఎక్కడో

263
00:13:08,600 --> 00:13:12,080
మేము కేటాయించారు పేరు
మెమరీ విలువ 40 బైట్లు.

264
00:13:12,080 --> 00:13:15,970
అదృష్టవశాత్తూ, మేము ఇప్పటికే ఆ చేసిన
ఆ శ్రేణి అక్కడే చేరే ప్రకటించారు.

265
00:13:15,970 --> 00:13:19,770
ఆ నిలుపుకునే సామర్థ్యం కలిగి ఉంటుంది
10 నాలుగు బైట్ యూనిట్లు.

266
00:13:19,770 --> 00:13:22,860
మొత్తం సో, అది 40 జరపవచ్చని
బైట్లు సమాచారం యొక్క విలువ.

267
00:13:22,860 --> 00:13:26,540
మరియు మేము ఇప్పుడు 40 బైట్లు reading ఉంటాయి
ఫైలు నుండి సమాచారాన్ని,

268
00:13:26,540 --> 00:13:30,330
మరియు మేము చేరే లో నిల్వ చేస్తున్నారు.

269
00:13:30,330 --> 00:13:35,470
>> గమనికలు వీడియో నుండి గుర్తు
ఇటువంటి చేరే వ్యూహం పేరును

270
00:13:35,470 --> 00:13:38,370
నిజంగా కేవలం ఒక పాయింటర్ ఉంది
దాని మొదటి మూలకం.

271
00:13:38,370 --> 00:13:43,680
కాబట్టి మేము అక్కడ చేరే లో పాస్ చేసినప్పుడు, మేము
ఒక పాయింటర్ ప్రయాణిస్తున్న నిజానికి, ఉన్నాయి.

272
00:13:43,680 --> 00:13:46,120
>> అదేవిధంగా మేము దీన్ని చెయ్యవచ్చు
మేము తప్పనిసరిగా లేదు

273
00:13:46,120 --> 00:13:51,200
స్టాక్ మా బఫర్ సేవ్ అవసరం.

274
00:13:51,200 --> 00:13:54,990
మేము కూడా డైనమిక్ కేటాయించాలని కాలేదు
ఒక malloc ఉపయోగించి, ఈ వంటి బఫర్.

275
00:13:54,990 --> 00:13:57,340
ఉన్నప్పుడు మేము గుర్తుంచుకో
డైనమిక్ మెమరీ కేటాయిస్తాయి

276
00:13:57,340 --> 00:14:00,550
మేము దానిని పొదుపు చేస్తున్నారు
కుప్ప, కాదు స్టాక్.

277
00:14:00,550 --> 00:14:02,110
కానీ ఇప్పటికీ ఒక బఫర్ యొక్క.

278
00:14:02,110 --> 00:14:06,810
>> ఇది ఇప్పటికీ ఈ విషయంలో,
సమాచారం యొక్క 640 బైట్లు పట్టుకొని

279
00:14:06,810 --> 00:14:09,230
ఒక డబుల్ ఎనిమిది బైట్లు తీసుకుంటుంది ఎందుకంటే.

280
00:14:09,230 --> 00:14:11,570
మరియు మేము వాటిని 80 అభ్యర్థిస్తున్నాము.

281
00:14:11,570 --> 00:14:13,770
మేము స్పేస్ కలిగి అనుకుంటున్నారా
80 డబుల్స్ పట్టుకోండి.

282
00:14:13,770 --> 00:14:17,210
కాబట్టి 80 సార్లు 8 640 బైట్లు సమాచారం ఉంది.

283
00:14:17,210 --> 00:14:21,880
మరియు fread ఆ పిలుపు
సమాచారం యొక్క 640 బైట్లు సేకరించడం

284
00:14:21,880 --> 00:14:27,770
ఫైలు ద్వారా చూపారు
PTR మరియు arr2 ఇప్పుడు నిల్వ.

285
00:14:27,770 --> 00:14:32,770
>> ఇప్పుడు మేము కూడా fread చికిత్స చేయవచ్చు
కేవలం fgetc ఒక కాల్ వంటి.

286
00:14:32,770 --> 00:14:37,140
ఈ సందర్భంలో, మనం కేవలం ప్రయత్నిస్తున్న
ఫైల్ నుండి ఒక పాత్ర పొందడానికి.

287
00:14:37,140 --> 00:14:40,070
మరియు మేము ఒక అవసరం లేదు
అమరిక ఒక పాత్ర ఉంచి.

288
00:14:40,070 --> 00:14:43,170
మేము దానిని నిల్వ చేసుకోవచ్చు
ఒక పాత్ర వేరియబుల్.

289
00:14:43,170 --> 00:14:46,390
>> క్యాచ్, అయితే, అని
మేము కేవలం ఒక వేరియబుల్ ఉన్నప్పుడు,

290
00:14:46,390 --> 00:14:50,290
మేము పాస్ అవసరం
ఆ వేరియబుల్ చిరునామా

291
00:14:50,290 --> 00:14:52,550
రీకాల్ ఆ ఎందుకంటే
fread మొదటి వాదన

292
00:14:52,550 --> 00:14:59,210
నగర మరియు స్మృతి ఒక పాయింటర్ ఉంది
మేము సమాచారాన్ని నిల్వ ఎక్కడ.

293
00:14:59,210 --> 00:15:01,550
మళ్లీ, ఒక పేరు
శ్రేణి ఒక పాయింటర్ ఉంది.

294
00:15:01,550 --> 00:15:04,200
కాబట్టి మేము ఆంపర్సండ్ శ్రేణి అవసరం లేదు.

295
00:15:04,200 --> 00:15:07,270
కానీ సి, పాత్ర సి
ఇక్కడ, ఒక శ్రేణి కాదు.

296
00:15:07,270 --> 00:15:08,390
ఇది కేవలం ఒక వేరియబుల్.

297
00:15:08,390 --> 00:15:11,840
కాబట్టి మేము ఒక పాస్ అవసరం
ఆంపర్సండ్ చిహ్నం సి సూచించడానికి

298
00:15:11,840 --> 00:15:15,350
మేము ఎక్కడ చిరునామా అని
సమాచారం యొక్క ఈ ఒక బైట్ నిల్వ,

299
00:15:15,350 --> 00:15:20,479
ఈ ఒక పాత్ర
మేము PTR నుండి సేకరించడం చేస్తున్నారు.

300
00:15:20,479 --> 00:15:22,270
నేను ద్వారా వెళ్తారో Fwrite--
ఈ కొంచెం

301
00:15:22,270 --> 00:15:25,440
మీరు చేస్తే చాలా చక్కని ఉంది
fread యొక్క ఖచ్చితమైన సమానమైన

302
00:15:25,440 --> 00:15:27,720
రచనలకు తప్ప
బదులుగా చదవడం, కేవలం

303
00:15:27,720 --> 00:15:31,610
other-- వంటి మేము ఓపెన్ కలిగింది
మరియు దగ్గరగా, ఒక పాత్ర పొందడానికి,

304
00:15:31,610 --> 00:15:32,530
ఒక పాత్ర వ్రాయండి.

305
00:15:32,530 --> 00:15:35,040
ఇప్పుడు అది ఏకపక్ష పొందుటకు వార్తలు
సమాచారం మొత్తం,

306
00:15:35,040 --> 00:15:37,170
సమాచార హక్కు ఏకపక్ష మొత్తం.

307
00:15:37,170 --> 00:15:39,790
కాబట్టి ముందు వలె, మేము
10 పూర్ణాంకాల యొక్క వ్యూహం కలిగి

308
00:15:39,790 --> 00:15:43,210
పేరు మేము ఇప్పటికే కలిగి
సమాచారం బహుశా, నిల్వ.

309
00:15:43,210 --> 00:15:46,580
>> ఇది బహుశా కోడ్ కొన్ని పంక్తులు ఉంది
ఈ రెండు మధ్య వెళ్ళాలి

310
00:15:46,580 --> 00:15:49,990
నేను చేరే సమయం నింపి పేరు
అర్ధవంతమైన ఏదో.

311
00:15:49,990 --> 00:15:51,880
నేను 10 విభిన్న పూర్ణాంకాల తో నింపండి.

312
00:15:51,880 --> 00:15:54,920
మరియు బదులుగా, నేను ఏమి చేస్తున్నాను
చేయడం చేరే నుండి రచన

313
00:15:54,920 --> 00:15:58,600
మరియు బాణం నుండి సమాచారాన్ని సేకరించడం.

314
00:15:58,600 --> 00:16:02,390
నేను ఆ సమాచారాన్ని తీసుకొని వెబ్
మరియు ఫైల్ గా పెట్టటం.

315
00:16:02,390 --> 00:16:05,410
>> సో బదులుగా దాని నుండి ఉండటం
బఫర్ ఫైలు,

316
00:16:05,410 --> 00:16:08,790
మేము ఇప్పుడు నుండి చూడాలని
ఫైల్ బఫర్.

317
00:16:08,790 --> 00:16:10,580
కనుక ఇది కేవలం రివర్స్ ఉంది.

318
00:16:10,580 --> 00:16:16,680
ముందు వలె మరలా, మేము
కూడా మెమరీ కుప్ప భాగం కలిగి

319
00:16:16,680 --> 00:16:19,600
మేము డైనమిక్ చేసిన
కేటాయించబడింది మరియు ఆ నుండి చదవడానికి

320
00:16:19,600 --> 00:16:21,570
మరియు ఫైల్ను వ్రాయడానికి.

321
00:16:21,570 --> 00:16:24,900
>> మరియు మేము కూడా ఒక వేరియబుల్ కలిగి
ఒక బైట్ సమర్ధుడు

322
00:16:24,900 --> 00:16:27,200
అటువంటి పాత్ర వంటి సమాచారాన్ని.

323
00:16:27,200 --> 00:16:29,830
కానీ మళ్ళీ, మేము పాస్ అవసరం
ఆ వేరియబుల్ చిరునామా

324
00:16:29,830 --> 00:16:31,840
మేము దాని నుండి చదవాలనుకుంటున్న ఉన్నప్పుడు.

325
00:16:31,840 --> 00:16:35,280
కాబట్టి మేము సమాచారాన్ని వ్రాయండి
మేము ఆ చిరునామా వద్ద కనుగొంటారు

326
00:16:35,280 --> 00:16:39,050
ఫైలు పాయింటర్, PTR.

327
00:16:39,050 --> 00:16:41,630
>> ఇతర ఎన్నో ఉన్నాయి
గొప్ప ఫైలు I / O విధులు

328
00:16:41,630 --> 00:16:44,650
ఆ పాటు వివిధ పనులను
వాటిని మేము నేడు గురించి మాట్లాడారు చేసిన.

329
00:16:44,650 --> 00:16:46,450
వాటిని ఒక జంట
మీకు ఉపయోగకరంగా కనుగొనే

330
00:16:46,450 --> 00:16:50,840
fgets మరియు fputs ఉన్నాయి,
ఇది సమానంగా ఉంటాయి

331
00:16:50,840 --> 00:16:56,190
fgetc మరియు fputc కానీ చదువుటకు
ఒక ఫైల్ నుండి ఒక స్ట్రింగ్.

332
00:16:56,190 --> 00:16:59,020
బదులుగా ఒక పాత్ర యొక్క,
అది ఒక పూర్తి స్ట్రింగ్ చదువుతాను.

333
00:16:59,020 --> 00:17:02,940
ప్రధానంగా అనుమతిస్తుంది fprintf,
మీరు ఫైల్ వ్రాయడం printf ఉపయోగించడానికి.

334
00:17:02,940 --> 00:17:05,619
మీరు చేయవచ్చు కాబట్టి కేవలం
ఉపయోగించి వేరియబుల్ ప్రత్యామ్నాయం

335
00:17:05,619 --> 00:17:09,900
placeholders శాతం నేను మరియు
printf శాతం d, మరియు అందువలన న,

336
00:17:09,900 --> 00:17:14,690
మీరు అదేవిధంగా పట్టవచ్చు
printf స్ట్రింగ్ మరియు ముద్రణ ఏదో

337
00:17:14,690 --> 00:17:16,800
ఒక ఫైల్ను వంటి.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- మీరు ఒక DVD ప్లేయర్ కలిగి ఉంటే
నేను సాధారణంగా ఇక్కడ ఉపయోగించడానికి సామ్యం ఉంది

339
00:17:20,720 --> 00:17:23,109
విధమైన ఉపయోగించి వంటిది మీ
రివైండ్ మరియు ఫాస్ట్ ఫార్వార్డ్

340
00:17:23,109 --> 00:17:25,819
బటన్లు చిత్రం చుట్టూ తరలించడానికి.

341
00:17:25,819 --> 00:17:28,369
అదేవిధంగా, మీరు ఫైల్ చుట్టూ తరలించవచ్చు.

342
00:17:28,369 --> 00:17:30,250
లోపల విషయాలు ఒకటి
ఆ ఫైలు నిర్మాణం

343
00:17:30,250 --> 00:17:34,270
మీరు ఒక సూచిక ఆ c సృష్టిస్తుంది
ఇక్కడ మీరు ఫైల్ లో ఉన్నాయి.

344
00:17:34,270 --> 00:17:36,420
మీరు చాలా వద్ద ఆర్
బైట్ సున్నా వద్ద ప్రారంభమైంది?

345
00:17:36,420 --> 00:17:39,290
మీరు బైట్ 100 వద్ద ఉన్నాయి,
బైట్ 1,000 మరియు అందువలన న?

346
00:17:39,290 --> 00:17:44,340
మీరు ఏకపక్ష తరలించడానికి fseek ఉపయోగించవచ్చు
ముందుకు లేదా వెనకకు సూచిక.

347
00:17:44,340 --> 00:17:46,744
>> మరియు తిరిగి, ftell
ఒక DVD ప్లేయర్ పోలి,

348
00:17:46,744 --> 00:17:49,660
చెబుతుంది ఒక చిన్న గడియారం వంటిది
మీరు ఎన్ని నిమిషాలు మరియు సెకన్లు మీరు

349
00:17:49,660 --> 00:17:52,480
ఒక ఖచ్చితమైన చిత్రం శాఖలుగా వర్గీకరించారు.

350
00:17:52,480 --> 00:17:56,990
అదేవిధంగా, ftell మీరు ఎలా చెబుతుంది
అనేక బైట్లు మీరు ఫైల్లోకి ఉన్నాయి.

351
00:17:56,990 --> 00:18:00,210
feof వేరే వెర్షన్
మీరు చేసిన లేదో గుర్తించే

352
00:18:00,210 --> 00:18:01,700
ఫైల్ ముగింపు చేరుకున్నారు.

353
00:18:01,700 --> 00:18:03,600
మరియు ferror ఒక ఫంక్షన్ ఉంది
మీరు ఉపయోగించే

354
00:18:03,600 --> 00:18:06,959
ఏదో ఉంది లేదో గుర్తించడం
ఒక ఫైల్ తప్పు పని పోయింది.

355
00:18:06,959 --> 00:18:08,750
మళ్ళీ, ఈ కేవలం ఉంది
ఉపరితల గోకడం.

356
00:18:08,750 --> 00:18:12,730
పుష్కలంగా మరింత ఫైలు I / O ఇప్పటికీ ఉంది
ప్రామాణిక io.h. ఫంక్షన్లు

357
00:18:12,730 --> 00:18:16,620
కానీ ఈ బహుశా మీరు పొందుతారు
ఫైలు గమనికలు పని ప్రారంభించాడు.

358
00:18:16,620 --> 00:18:17,640
నేను డౌ లాయిడ్ ఉన్నాను.

359
00:18:17,640 --> 00:18:19,750
ఈ CS50 ఉంది.

360
00:18:19,750 --> 00:18:21,669