>> సల ఇప్పటివరకు, అది అవకాశం వార్తలు మీ కార్యక్రమాలు చాలా ఆ
ఒక బిట్ అశాశ్వత ఉన్నాయి.
మీరు మారియో లేదా గ్రీడీ వంటి ప్రోగ్రామ్ రన్.
ఇది బహుశా అడుగును చేస్తుంది ఏదో కొంత సమాచారాన్ని వినియోగదారు
స్క్రీన్ కొన్ని అవుట్పుట్ ప్రింట్ కానీ అప్పుడు మీ ప్రోగ్రామ్, ఓవర్
అక్కడ ఎటువంటి ఆధారం నిజంగా ఉంది అది ఎప్పుడూ మొదటి స్థానంలో నడిపించారు.
నేను ఖచ్చితంగా మీరు ఎడమ ఉండవచ్చు, అర్థం ఇది టెర్మినల్ విండో లో తెరవడానికి
మీరు మీ స్క్రీన్ క్లియర్ కానీ, అక్కడ ఇది ఉనికిలో నిజంగా ఎటువంటి ఆధారం.
మేము నిల్వ మార్గాల లేదు నిరంతర సమాచారం, సమాచారం
మా తర్వాత ఉనికిలో కార్యక్రమం అమలు ఆగిపోయింది,
లేదా మేము ఈ పాయింట్ వరకు లేదు.
అదృష్టవశాత్తూ అయితే, c చేస్తుంది సామర్థ్యం అందించండి
అమలు ద్వారా దీన్ని అనే విషయం
ఒక ఫైల్, ఒక నిర్మాణం ప్రాథమికంగా మీరు డబుల్ అని ఒక ఫైల్ సూచిస్తుంది
మీరు అయితే, మీ కంప్యూటర్ మీద క్లిక్ గ్రాఫికల్ యూజర్ ఎన్విరాన్మెంట్ ఉపయోగిస్తారు.
సాధారణంగా పనిచేసేటప్పుడు సి తో, మేము నిజానికి ఉన్నాము
పని కావడం గమనికలు ఫైలు ఫైళ్ళు కు stars--
కొద్దిగా తప్ప మేము ఒక జంట గురించి మాట్లాడినప్పుడు
విధులు యొక్క ఫైలు గమనికలు పని.
మీరు నిజంగా తవ్విన అవసరం లేదు అవగాహన గమనికలు చాలా లోతైన
తాము.
కొద్దిగా teeny బిట్ ఉంది మేము వాటిని గురించి చర్చ ఉంటుంది పేరు,
కానీ సాధారణంగా గమనికలు ఫైల్ మరియు గమనికలు, ఒకదాని మీద అయితే,
సరిగ్గా అదే విషయం కాదు.
>> ఇప్పుడు నేను ఏమి అర్థం లేదు నేను నిరంతర డేటా చెప్పటానికి?
నిరంతర డేటా ఏమిటి?
మేము దాని గురించి ఎందుకు శ్రద్ధ లేదు?
ఆ, ఉదాహరణకు, సే మీరు ఒక కార్యక్రమం అమలు చేస్తున్నారు
లేదా మీరు తిరిగి వ్రాయబడుతుంది చేసిన ఒక ఒక గేమ్ కార్యక్రమం
మరియు మీరు ట్రాక్ ఉంచాలని యూజర్ యొక్క ఎత్తుగడలు అన్ని యొక్క
కాబట్టి ఏదో తప్పు జరిగితే ఉంటే బహుశా, మీరు ఆట తర్వాత ఫైల్ సమీక్షించే.
ఆ ఉన్నప్పుడు మేము ఉద్దేశ్యం ఏమిటి నిరంతర డేటా గురించి మాట్లాడటానికి.
>> అమలు క్రమంలో మీ కార్యక్రమం, ఒక ఫైల్ రూపొందించినవారు ఉంటుంది.
మరియు మీ ప్రోగ్రామ్ అమలు ఆగిపోయింది,
ఆ ఫైల్ ఇంకా మీ సిస్టమ్ లో ఉందో.
మరియు మేము అది చూడండి మరియు అది పరిశీలించడానికి చేయవచ్చు.
కాబట్టి ఆ కార్యక్రమం సెట్ అవుతుంది కొన్ని నిరంతర డేటా సృష్టించిన,
డేటా కార్యక్రమం తర్వాత ఉనికిలో నడుస్తున్న పూర్తయింది.
>> ఇప్పుడు పని చేసే ఈ విధులను అన్ని ఫైళ్ళను సృష్టించడం మరియు అంగాలు తో
వివిధ మార్గాల్లో వాటిని ప్రామాణిక io.h నివసిస్తున్నారు,
ఇది ఒక శీర్షికా ఫైలును అని మీరు అవకాశం పౌండ్ ఉన్నాను
అందంగా ఎగువన సహా మీ కార్యక్రమాలు చాలా అన్ని
అది ఒక ఉన్నందున మాకు చాలా ఉపయోగకరమైన విధులు,
కూడా అనుమతించే printf, ప్రామాణిక io.h. నివసిస్తున్నారు
సో మీరు కూడా పౌండ్ అవసరం లేదు ఏ అదనపు ఫైళ్లు బహుశా
క్రమంలో ఫైలు గమనికలు తో పని.
>> ఇప్పుడు ప్రతి ఒక్క ఫైల్ పాయింటర్ ఫంక్షన్, లేదా ప్రతి ఒక్క ఫైలు I / O, ఇన్పుట్ అవుట్పుట్
ఫంక్షన్, ఒక స్వీకరించు దాని పారామితులు లేదా ప్రవేశాంశాల
తప్ప ఒక ఫైల్ పాయింటర్ ఒక కోసం, fopen, ఇది
మీరు ఫైల్ పొందడానికి ఉపయోగించే ఏమిటి మొదటి స్థానంలో పాయింటర్.
కానీ మీరు తెరిచిన తర్వాత ఫైల్ మరియు మీరు ఫైల్ గమనికలు పొందండి
మీరు వాటిని తరలిస్తారు వివిధ విధులకు వాదనలు
మేము గురించి మాట్లాడటానికి వెళుతున్న నేడు, అలాగే అనేక ఇతర
కాబట్టి మీరు ఫైళ్లను తో పని చేయవచ్చు.
>> కనుక ఆరు అందంగా ఉన్నాయి సాధారణ ప్రాథమిక వాటిని
మేము నేడు గురించి మాట్లాడటానికి వెళుతున్న.
fopen మరియు దాని సహచర ఫంక్షన్ fclose, fgetc
మరియు దాని సహచర ఫంక్షన్ fputc, మరియు fread మరియు దాని సహచర ఫంక్షన్,
fwrite.
కాబట్టి యొక్క కుడి అది పొందడానికి వీలు.
>> fopen-- ఇది ఏమి చేస్తుంది?
సరే, ఒక ఫైల్ తెరుచుకుంటుంది మరియు అది దానికి మీరు ఒక ఫైల్ పాయింటర్ ఇస్తుంది,
కాబట్టి మీరు ఆ ఉపయోగించవచ్చు ఒక వాదన వంటి పాయింటర్ ఫైల్
ఇతర ఫైలు I / O విధులు ఏ.
అతి ముఖ్యమైన విషయం fopen తో గుర్తు
మీరు తెరిచారు అని తర్వాత దాఖలు లేదా ఇక్కడ ఒక వంటి ఒక పిలుపుకు,
మీరు నిర్ధారించుకోండి తనిఖీ చెయ్యాలి మీరు తిరిగి వచ్చింది అని పాయింటర్
శూన్యం సమానం కాదు.
మీరు వీడియో వీక్షించారు ఉండకపోతే గమనికలు, ఈ సమంజసం కాదు.
కానీ మీరు ప్రయత్నించండి మరియు dereference ఉంటే ఒక నల్ పాయింటర్ రీకాల్
మీ కార్యక్రమాన్ని బహుశా నష్టపోవచ్చు సెగ్మెంటేషన్ [వినబడని].
మేము నిర్ధారించుకోండి చేయాలనుకుంటున్నారా మేము ఒక చట్టబద్ధమైన పాయింటర్ తిరిగి వచ్చింది.
సమయం మెజారిటీ మేము రెడీ తిరిగి న్యాయమైన పాయింటర్ ఉండాల్సిందని
మరియు అది ఒక సమస్య వుండదు.
>> సో ఎలా మేము ఒక కాల్ fopen సంపాదిస్తారు?
ఇది ఇలా అందంగా చాలా బాగుంది.
ఒక సాధారణ ఉండటం PTR ptr-- ఫైల్ స్టార్ పాయింటర్ fopen ఫైల్ కోసం పేరు
మరియు మేము రెండు విషయాలు ఒక ఫైల్ పేరు పాస్ మరియు ఒక ఆపరేషన్ మేము చేపట్టేందుకు కావలసిన.
కాబట్టి మేము వలె కనిపించే ఒక కాల్ ఉండవచ్చు దీన్ని ఫైలు స్టార్ PTR 1 fopen సమానం
file1.txt.
నేను ఎంచుకున్న ఆపరేషన్ r ఉంది.
>> సో వాట్ మీరు r ఇక్కడ ఉంది ఆలోచిస్తాడు?
విషయాలు రకాల ఏమిటి మేము ఫైళ్లు చేస్తామని కావచ్చు?
కాబట్టి r ఆపరేషన్ అని మేము మనం ఒక ఫైల్ చదవాలనుకుంటున్న ఉన్నప్పుడు ఎంచుకోండి.
కాబట్టి మేము ప్రధానంగా ఎప్పుడు మేము ఈ వంటి ఒక కాల్
మమ్మల్ని ఫైల్ పాయింటర్ పంపబడతాయి మేము అప్పుడు సమాచారాన్ని చదివి అని అటువంటి
file1.txt నుండి.
>> అదేవిధంగా, మేము ఫైల్ 2.txt తెరవాలని ptr2 రచనకు అందువలన మేము తరలిస్తారు
నేను ఇక్కడ సృష్టించాను ఫైలు పాయింటర్, ఏదైనా ఫంక్షన్ ఒక వాదన వంటి
ఒక ఫైల్ సమాచారం రాశారు.
మరియు రచన పోలి ఉంది కూడా ఎంపిక ఒక జోడించే.
మధ్య తేడా రాయడం మరియు అనుమతిస్తూ
ఉండటం మీరు ఒక ఫైల్ వ్రాయడం ఉన్నప్పుడు, మీరు రచనకు fopen ఒక కాల్ చేస్తే
మరియు ఫైల్ ఇప్పటికే అంతే, ఉనికిలో మొత్తం ఫైల్ ఓవర్రైట్ జరగబోతోంది.
ఇది ఆరంభమవుతుంది చాలా ప్రారంభంలో,
అన్ని సమాచారం తొలగించడం ఇప్పటికే ఉంది.
>> మీరు అనుమతిస్తూ కోసం అది తెరిస్తే అయితే, ఇది ఫైల్ చివర వెళ్తుంది
ఇప్పటికే టెక్స్ట్ ఉంది ఉంటే అది లేదా అందులోని సమాచారాన్ని,
మరియు అది ప్రారంభమౌతుంది అక్కడ నుండి వ్రాయడం.
సో మీరు ఏ కోల్పోతారు లేదు మీరు ముందు చేసిన సమాచారం.
మీరు వ్రాసే లేదా కలపవచ్చు నిశ్చఇ విధమైన పరిస్థితి ఆధారపడి ఉంటుంది.
కానీ మీరు బహుశా ఏమి చేస్తాము సమయం వచ్చినప్పుడు సరైన చర్య.
కాబట్టి ఆ fopen వార్తలు.
>> ఏం fclose గురించి?
బాగా, అందంగా కేవలం fclose కేవలం ఫైల్ పాయింటర్ అంగీకరిస్తుంది.
మరియు మీరు ఆశించిన విధంగా, అది ఆ ఫైల్ ముగుస్తాయి.
మేము ఒక ఫైలు మూసి చేసిన ఒకసారి, మేము కాదు ఏ మరింత ఫైలు I / O విధులు నిర్వహించడానికి
చదవడం లేదా ఫైల్లో, రచన.
మేము తిరిగి తెరిచి ఉంటుంది ఆర్డర్ లో మరొక సారి దాఖలు
తో పనిచేయడానికి ఇది I / O విధులు ఉపయోగించి.
మేము పూర్తి చేసిన సో fclose మార్గాల ఈ ఫైలు పని.
మరియు మేము పాస్ అవసరం అన్ని ఉంది ఒక ఫైల్ పాయింటర్ యొక్క పేరు.
ఒక జంట క్రితం మునిగి కాబట్టి, మేము పఠనం fopened ఫైలు 1 డాట్ టెక్స్ట్
మరియు మేము ఆ కేటాయించిన ptr1 పాయింటర్ దాఖలు.
ఇప్పుడు మనం ఉన్నాము నిర్ణయించుకుంది చేసిన ఆ ఫైల్ చదవడం పూర్తయింది.
మేము అది ఏ మరింత అవసరం లేదు.
మేము కేవలం fclose ptr1 చెయ్యవచ్చు.
మరియు అలాగే, మేము అనుకొనుట ఇతర వాటిని fclose.
అయితే సరే.
కాబట్టి ఆ తెరవడం మరియు మూసివేయడం.
ఆ రెండు ప్రాథమిక ఉంటాయి కార్యకలాపాలు ప్రారంభమయ్యాయి.
>> ఇప్పుడు మేము నిజంగా కావలసిన కొన్ని ఆసక్తికరమైన విషయాలను,
మరియు మొదటి చర్య, ఆ మేము చేస్తాము ఆ fgetc-- అని చేస్తాను చూడండి
ఒక పాత్ర పొందడానికి దాఖలు.
ఆ సాధారణంగా fgetc ఏమిటి కు అనువదించడానికి అని.
జీవితంలో దీని లక్ష్యం ఉంది తదుపరి పాత్ర చదవండి,
లేదా ఈ మీ చాలా ఉంటే fgetc మొదటి కాల్
ఒక ప్రత్యేక ఫైలు, మొదటి పాత్ర.
కానీ ఆ తర్వాత, మీరు తదుపరి ఒక పొందుటకు
ఆ ఫైల్ యొక్క చాలా తదుపరి పాత్ర ఒక పాత్ర వేరియబుల్ మరియు దుకాణాలు ఇది.
మేము ఇక్కడ చేసినట్లుగానే, చార్ ch, fgetc సమానం
ఒక ఫైల్ పాయింటర్ యొక్క పేరు లో పాస్.
మళ్ళీ, అది చాలా వార్తలు గుర్తు ఇక్కడ ముఖ్యమైన
క్రమంలో కలిగి ఈ ఆపరేషన్ విజయవంతం,
ఫైలు పాయింటర్ కూడా must've పఠనం కోసం తెరవబడింది.
మేము ఒక ఫైల్ నుండి ఒక పాత్ర చదువలేదు మేము రచనకు ప్రారంభమైన పాయింటర్.
కాబట్టి ఆ ఒకటి fopen యొక్క పరిధులు, కుడి?
మేము పరిమితం కలిగి మమ్మల్ని మాత్రమే చేస్తూ
ఒక ఫైల్ పాయింటర్ తో ఒక ఆపరేషన్.
మేము చదవడానికి కోరుకుంటే ఒకే ఫైల్ నుండి రాయడానికి,
మేము ఓపెన్ రెండు ప్రత్యేక వుంటుంది అదే ఫైల్ ఫైల్ గమనికలు
పఠనం కోసం ఒకటి, రచన కోసం ఒక.
>> మరలా, మాత్రమే కారణం నేను ఇప్పుడు ఆ తీసుకురావటానికి
మేము ఒక కాల్ చేయడానికి చూడాలని ఉంటే ఎందుకంటే fgetc, ఆ ఫైల్ పాయింటర్ must've
పఠనం కోసం తెరవబడింది.
ఆపై అందంగా కేవలం, అన్ని మేము చెయ్యాల్సిన
ఫైలు పాయింటర్ యొక్క పేరు లో పాస్ ఉంది.
కాబట్టి చార్ ch fgetc ptr1 సమానం.
>> మాకు పొందడానికి జరగబోతోంది తదుపరి పాత్ర
లేదా మళ్ళీ ఈ మొదటి, ఉంటే మేము ఈ కాల్ చేసిన సమయం,
మొదటి పాత్ర సంసార ఫైలు ptr1 చూపారు.
ఆ ఫైల్ 1 డాట్ టెక్స్ట్ అని గుర్తు.
ఇది ఆ మొదటి అక్షరం పొందుతారు మరియు మేము వేరియబుల్ CH నిల్వ చేస్తాము.
ప్రెట్టీ సూటిగా.
కాబట్టి మేము కేవలం మూడు చూశారు చేసిన విధులు మరియు మేము ఇప్పటికే
అందంగా చక్కగా ఏదో ఒకటి చెయ్యాలి.
>> మేము ఈ సామర్థ్యం పడుతుంది చేస్తే ఒక పాత్ర పొందడానికి
మరియు మేము లూప్ కాబట్టి దాన్ని మేము అక్షరాలు వస్తూ
ఒక ఫైల్ నుండి పైగా మరియు పైగా మరియు over-- ఇప్పుడు మేము
ప్రతి ఒక్క చదువుకోవచ్చు ఒక ఫైల్ యొక్క పాత్ర.
మరియు మేము ప్రతి పాత్ర ప్రింట్ ఉంటే మేము అది చదివి వెంటనే,
మేము ఇప్పుడు ఒక ఫైల్ నుండి చదివాను మరియు స్క్రీన్ దాని కంటెంట్లను ముద్రించబడింది.
మేము సమర్థవంతంగా ఒకదాని వెంబడి చేసిన తెరపై ఆ ఫైల్.
మరియు ఏ Linux కమాండ్ పిల్లి చేస్తుంది.
>> మీరు ఫైల్ పేరు లో పిల్లి టైప్ చేస్తే, అది మొత్తం కంటెంట్లను ప్రింట్
మీ టెర్మినల్ విండో లో ఫైల్.
మరియు ఇక్కడ ఈ చిన్న లూప్, కోడ్ మాత్రమే మూడు పంక్తులు,
కాని ప్రభావవంతంగా నకిలీలను Linux కమాండ్ పిల్లి.
కాబట్టి ఈ వాక్యనిర్మాణం ఉండవచ్చు ఒక చిన్న అసహజ చూడండి
కానీ ఇక్కడ ఏం ఉంది.
Ch fgetc సమానం అయితే, PTR కాదు అది మొత్తం మౌత్ఫుల్ EOF-- సమానంగా,
కానీ యొక్క అది కేవలం విచ్ఛిన్నం వీలు కాబట్టి అది వాక్యనిర్మాణం స్పష్టమవుతుంది.
నేను చాటుకుంది చేసిన స్థలం కొరకు,
అది కొద్దిగా అయితే పదము గమ్మత్తైన.
>> కాబట్టి గ్రీన్ కుడి లో ఈ భాగం ఇప్పుడు, అది ఏమి ఉంది?
Well, కేవలం మా fgetc కాల్ కుడి?
మేము ముందు చూసిన.
ఇది ఒక పొందడంలో లో ఫైలు నుండి పాత్ర.
అప్పుడు మేము ఆ సరిపోల్చండి EOF వ్యతిరేకంగా పాత్ర.
EOF అని ఒక ప్రత్యేక విలువ ప్రామాణిక io.h, లో నిర్వచించిన
ఫైల్ పాత్ర ముగింపు.
కాబట్టి ప్రాథమికంగా జరిగే అవకాశముంది ఏమి ఈ లూప్ ఒక పాత్ర చదువుతాను ఉంది,
, EOF పోల్చడం ఫైల్ పాత్ర ముగింపు.
వారు సరిపోలడం లేదు ఉంటే, మేము కలిగి ఫైలు ముగింపు చేరుకుంది
మేము ఆ పాత్రను ప్రింట్ చేస్తాము.
అప్పుడు మేము తిరిగి వెళ్తారో మళ్ళీ లూప్ ప్రారంభం.
మేము ఒక పాత్ర పొందుతారు, తనిఖీ EOF వ్యతిరేకంగా, కాబట్టి అది ముద్రించాలా, మరియు
అందువలన మరియు అందువలన న, ఆ విధంగా ద్వారా వెతికినా
మేము ఫైల్ ముగింపు చేరుకున్నారు వరకు.
ఆపై ఆ సమయంలో, మేము ముద్రించిన ఉంటుంది
ఫైలు యొక్క మొత్తం కంటెంట్లను.
మరలా, మేము మాత్రమే చూసిన fopen, fclose, మరియు fgetc
మరియు ఇప్పటికే మేము నకిలీ చేయవచ్చు ఒక లినక్సు టెర్మినల్ ఆదేశం.
>> నేను ప్రారంభంలో అన్నాడు, మేము fgetc మరియు fputc వచ్చింది,
మరియు fputc తోడుగా ఉంది fgetc ఫంక్షన్.
అందువలన, మీరు, ఊహించే ఉండవచ్చు అది రచన సమానం.
ఇది మాకు ఒక రాయడానికి అనుమతిస్తుంది ఒక ఫైల్ ఒకే పాత్ర.
>> మళ్ళీ, మినహాయింపు ఉండటం కేవలం ఇది fgetc తో లాగా, ఫైలు
మేము must've రాస్తున్నాం రచన రచనకు లేదా అనుమతిస్తూ తెరవబడ్డాయి.
మేము ప్రయత్నించండి మరియు ఒక ఫైల్ లో fputc ఉపయోగిస్తే మేము చదవడానికి తెరిచిన,
మనం అనుభవించే చూడాలని తప్పు యొక్క ఒక బిట్.
అయితే కాల్ అందంగా సులభం.
fputc రాజధాని ptr2, అన్ని అలా జరగబోతోంది ఉంది
లేఖ రాయాలో ఒక ఫైల్ లోకి 2 డాట్ లోకి
పేరు గ్రంథంలో మేము ప్రారంభమైంది మరియు కేటాయించిన దాఖలు
పాయింటర్ ptr2 కు.
కాబట్టి మేము ఒక రాయాలో రాజధాని A 2 డాట్ టెక్స్ట్ ఫైల్.
మరియు మేము ఒక ఆశ్చర్యార్థకం వ్రాయండి చేస్తాము 3 డాట్ ఫైలు పాయింటు
ptr3 ద్వారా చూపారు, ఇది టెక్స్ట్.
మరలా, ఇక్కడ అందంగా సూటిగా.
>> కానీ ఇప్పుడు మేము మరొక విషయం చేయవచ్చు.
మేము ఈ ఉదాహరణ ఉంది మేము కేవలం ఉండేవి
పిల్లి నకలు సామర్థ్యం గురించి Linux కమాండ్ బయటకు ముద్రిస్తుంది ఒక
స్క్రీన్.
Well, ఇప్పుడు మేము సామర్థ్యం కలిగి ఫైళ్లు నుండి అక్షరాలు చదవడానికి
మరియు, ఫైళ్లకు అక్షరాలు వ్రాయడానికి మనం కేవలం ఆ ప్రత్యామ్నాయంగా లేదు
fputc కాల్ తో printf కాల్.
>> మరియు ఇప్పుడు మేము cp నకిలీ చేసిన, చాలా ప్రాథమిక Linux కమాండ్
మేము మార్గం దీర్ఘ గురించి చర్చిస్తామని క్రితం Linux లో వీడియో ఆశిస్తాడు.
మేము సమర్థవంతంగా చేసిన ఇక్కడే ఆ నకిలీ.
మేము ఒక పాత్ర చదువుతున్న ఆపై మేము ఉన్నాము మరొక ఫైల్ ఆ పాత్ర రాయడం.
ఒక ఫైల్ నుండి పఠనం, రాయడం పైగా మరియు పైగా, మరొక
మరియు పైగా మళ్ళీ మేము EOF హిట్ వరకు.
మేము చివర పొందారు దాఖలు మేము నుండి కాపీ ప్రయత్నిస్తున్న.
మరియు ఆ ద్వారా మేము అన్ని వ్రాశారు చేస్తాము అక్షరాలు మేము ఫైల్ అవసరం
మేము రాస్తున్నాం.
కాబట్టి ఈ cp, Linux కాపీని ఆదేశం ఉంది.
>> చాలా ప్రారంభంలో ఈ వీడియో, నేను మినహాయింపు కలిగి
మేము ఒక మాట్లాడిన ఆ గమనికలు గురించి కొద్దిగా.
మేము ఎక్కడ ఇక్కడ ప్రత్యేకంగా గమనికలు గురించి మాట్లాడటానికి వెళ్ళడం
అదనంగా గమనికలు ఫైల్.
కాబట్టి ఈ ఫంక్షన్ రకమైన భయానకంగా కనిపిస్తోంది.
ఇది పలు కారకాలు కలిగియున్నారు.
ఇక్కడ జరగబోతోంది చాలా ఉంది.
వివిధ చాలా ఉంది రంగులు మరియు గ్రంథాలు.
కానీ నిజంగా, అది కేవలం fgetc యొక్క జెనెరిక్ వెర్షన్
మాకు ఏ పొందడానికి అనుమతిస్తుంది సమాచారం మొత్తం.
ఇది మేము ఉన్నాము ఉంటే ఒక బిట్ అసమర్థంగా కావచ్చు ఒక సమయంలో అక్షరాలు ఒక పొందడానికి,
ఫైలు ద్వారా iterating ఒక సమయంలో ఒక పాత్ర.
అది పొందుటకు NICER కాదు ఒక సమయంలో ఒక సమయంలో లేదా 500 100?
>> Well, fread మరియు దాని సహచర ఫంక్షన్ fwrite, మేము మాట్లాడదాము
రెండవ, మాకు కేవలం అలా అనుమతిస్తాయి.
మేము ఏకపక్ష మొత్తం చదువుకోవచ్చు ఒక ఫైల్ నుండి సమాచారాన్ని
మరియు మేము ఎక్కడో తాత్కాలికంగా నిల్వ.
బదులుగా కేవలం సామర్థ్యం ఒక వేరియబుల్ అది సరిపోయే,
మేము ఒక అర్రే లో నిల్వ అవసరం ఉండవచ్చు.
అందువలన, మేము నాలుగు పాస్ వాదనలు ఒక పాయింటర్ fread-- కు
మేము ఉన్నాము ప్రదేశాన్ని సమాచారం నిల్వ చేయడానికి వెళ్తున్నారు,
ఎలా సమాచారం యొక్క ప్రతి యూనిట్ పెద్ద ఉంటుంది, సమాచార ఎన్ని యూనిట్లు
మేము సాధించటం అనుకుంటున్నారా, మరియు నుండి ఇది ఫైల్ మేము వాటిని పొందడానికి కావలసిన.
బహుశా ఉత్తమ సోదాహరణ ఇక్కడ ఒక ఉదాహరణ తో.
కాబట్టి యొక్క మేము డిక్లేర్ అని పిలవబడు 10 పూర్ణాంకాల యొక్క వ్యూహం.
మేము న డిక్లేర్డ్ చేసిన ఏకపక్ష స్టేక్ చేరే 10 Int.
కాబట్టి ఆ అందంగా సూటిగా ఉంది.
ఇప్పుడు మేము అయితే చేస్తున్నా ఉంది frecall మేము Int యొక్క పరిమాణం చదువుతున్న ఉంది
సార్లు సమాచారాన్ని 10 బైట్లు.
పూర్ణాంకానికి జీవి యొక్క పరిమాణం ఆ వార్తలు four-- సి లో పూర్ణాంకం యొక్క పరిమాణం.
>> కాబట్టి మనం చేస్తున్న మేము చదువుతున్న ఉంది సమాచారం యొక్క విలువ 40 బైట్లు
ఫైలు నుండి PTR ద్వారా చూపారు.
మరియు మేము ఆ నిల్వ చేస్తున్నారు 40 బైట్లు ఎక్కడో
మేము కేటాయించారు పేరు మెమరీ విలువ 40 బైట్లు.
అదృష్టవశాత్తూ, మేము ఇప్పటికే ఆ చేసిన ఆ శ్రేణి అక్కడే చేరే ప్రకటించారు.
ఆ నిలుపుకునే సామర్థ్యం కలిగి ఉంటుంది 10 నాలుగు బైట్ యూనిట్లు.
మొత్తం సో, అది 40 జరపవచ్చని బైట్లు సమాచారం యొక్క విలువ.
మరియు మేము ఇప్పుడు 40 బైట్లు reading ఉంటాయి ఫైలు నుండి సమాచారాన్ని,
మరియు మేము చేరే లో నిల్వ చేస్తున్నారు.
>> గమనికలు వీడియో నుండి గుర్తు ఇటువంటి చేరే వ్యూహం పేరును
నిజంగా కేవలం ఒక పాయింటర్ ఉంది దాని మొదటి మూలకం.
కాబట్టి మేము అక్కడ చేరే లో పాస్ చేసినప్పుడు, మేము ఒక పాయింటర్ ప్రయాణిస్తున్న నిజానికి, ఉన్నాయి.
>> అదేవిధంగా మేము దీన్ని చెయ్యవచ్చు మేము తప్పనిసరిగా లేదు
స్టాక్ మా బఫర్ సేవ్ అవసరం.
మేము కూడా డైనమిక్ కేటాయించాలని కాలేదు ఒక malloc ఉపయోగించి, ఈ వంటి బఫర్.
ఉన్నప్పుడు మేము గుర్తుంచుకో డైనమిక్ మెమరీ కేటాయిస్తాయి
మేము దానిని పొదుపు చేస్తున్నారు కుప్ప, కాదు స్టాక్.
కానీ ఇప్పటికీ ఒక బఫర్ యొక్క.
>> ఇది ఇప్పటికీ ఈ విషయంలో, సమాచారం యొక్క 640 బైట్లు పట్టుకొని
ఒక డబుల్ ఎనిమిది బైట్లు తీసుకుంటుంది ఎందుకంటే.
మరియు మేము వాటిని 80 అభ్యర్థిస్తున్నాము.
మేము స్పేస్ కలిగి అనుకుంటున్నారా 80 డబుల్స్ పట్టుకోండి.
కాబట్టి 80 సార్లు 8 640 బైట్లు సమాచారం ఉంది.
మరియు fread ఆ పిలుపు సమాచారం యొక్క 640 బైట్లు సేకరించడం
ఫైలు ద్వారా చూపారు PTR మరియు arr2 ఇప్పుడు నిల్వ.
>> ఇప్పుడు మేము కూడా fread చికిత్స చేయవచ్చు కేవలం fgetc ఒక కాల్ వంటి.
ఈ సందర్భంలో, మనం కేవలం ప్రయత్నిస్తున్న ఫైల్ నుండి ఒక పాత్ర పొందడానికి.
మరియు మేము ఒక అవసరం లేదు అమరిక ఒక పాత్ర ఉంచి.
మేము దానిని నిల్వ చేసుకోవచ్చు ఒక పాత్ర వేరియబుల్.
>> క్యాచ్, అయితే, అని మేము కేవలం ఒక వేరియబుల్ ఉన్నప్పుడు,
మేము పాస్ అవసరం ఆ వేరియబుల్ చిరునామా
రీకాల్ ఆ ఎందుకంటే fread మొదటి వాదన
నగర మరియు స్మృతి ఒక పాయింటర్ ఉంది మేము సమాచారాన్ని నిల్వ ఎక్కడ.
మళ్లీ, ఒక పేరు శ్రేణి ఒక పాయింటర్ ఉంది.
కాబట్టి మేము ఆంపర్సండ్ శ్రేణి అవసరం లేదు.
కానీ సి, పాత్ర సి ఇక్కడ, ఒక శ్రేణి కాదు.
ఇది కేవలం ఒక వేరియబుల్.
కాబట్టి మేము ఒక పాస్ అవసరం ఆంపర్సండ్ చిహ్నం సి సూచించడానికి
మేము ఎక్కడ చిరునామా అని సమాచారం యొక్క ఈ ఒక బైట్ నిల్వ,
ఈ ఒక పాత్ర మేము PTR నుండి సేకరించడం చేస్తున్నారు.
నేను ద్వారా వెళ్తారో Fwrite-- ఈ కొంచెం
మీరు చేస్తే చాలా చక్కని ఉంది fread యొక్క ఖచ్చితమైన సమానమైన
రచనలకు తప్ప బదులుగా చదవడం, కేవలం
other-- వంటి మేము ఓపెన్ కలిగింది మరియు దగ్గరగా, ఒక పాత్ర పొందడానికి,
ఒక పాత్ర వ్రాయండి.
ఇప్పుడు అది ఏకపక్ష పొందుటకు వార్తలు సమాచారం మొత్తం,
సమాచార హక్కు ఏకపక్ష మొత్తం.
కాబట్టి ముందు వలె, మేము 10 పూర్ణాంకాల యొక్క వ్యూహం కలిగి
పేరు మేము ఇప్పటికే కలిగి సమాచారం బహుశా, నిల్వ.
>> ఇది బహుశా కోడ్ కొన్ని పంక్తులు ఉంది ఈ రెండు మధ్య వెళ్ళాలి
నేను చేరే సమయం నింపి పేరు అర్ధవంతమైన ఏదో.
నేను 10 విభిన్న పూర్ణాంకాల తో నింపండి.
మరియు బదులుగా, నేను ఏమి చేస్తున్నాను చేయడం చేరే నుండి రచన
మరియు బాణం నుండి సమాచారాన్ని సేకరించడం.
నేను ఆ సమాచారాన్ని తీసుకొని వెబ్ మరియు ఫైల్ గా పెట్టటం.
>> సో బదులుగా దాని నుండి ఉండటం బఫర్ ఫైలు,
మేము ఇప్పుడు నుండి చూడాలని ఫైల్ బఫర్.
కనుక ఇది కేవలం రివర్స్ ఉంది.
ముందు వలె మరలా, మేము కూడా మెమరీ కుప్ప భాగం కలిగి
మేము డైనమిక్ చేసిన కేటాయించబడింది మరియు ఆ నుండి చదవడానికి
మరియు ఫైల్ను వ్రాయడానికి.
>> మరియు మేము కూడా ఒక వేరియబుల్ కలిగి ఒక బైట్ సమర్ధుడు
అటువంటి పాత్ర వంటి సమాచారాన్ని.
కానీ మళ్ళీ, మేము పాస్ అవసరం ఆ వేరియబుల్ చిరునామా
మేము దాని నుండి చదవాలనుకుంటున్న ఉన్నప్పుడు.
కాబట్టి మేము సమాచారాన్ని వ్రాయండి మేము ఆ చిరునామా వద్ద కనుగొంటారు
ఫైలు పాయింటర్, PTR.
>> ఇతర ఎన్నో ఉన్నాయి గొప్ప ఫైలు I / O విధులు
ఆ పాటు వివిధ పనులను వాటిని మేము నేడు గురించి మాట్లాడారు చేసిన.
వాటిని ఒక జంట మీకు ఉపయోగకరంగా కనుగొనే
fgets మరియు fputs ఉన్నాయి, ఇది సమానంగా ఉంటాయి
fgetc మరియు fputc కానీ చదువుటకు ఒక ఫైల్ నుండి ఒక స్ట్రింగ్.
బదులుగా ఒక పాత్ర యొక్క, అది ఒక పూర్తి స్ట్రింగ్ చదువుతాను.
ప్రధానంగా అనుమతిస్తుంది fprintf, మీరు ఫైల్ వ్రాయడం printf ఉపయోగించడానికి.
మీరు చేయవచ్చు కాబట్టి కేవలం ఉపయోగించి వేరియబుల్ ప్రత్యామ్నాయం
placeholders శాతం నేను మరియు printf శాతం d, మరియు అందువలన న,
మీరు అదేవిధంగా పట్టవచ్చు printf స్ట్రింగ్ మరియు ముద్రణ ఏదో
ఒక ఫైల్ను వంటి.
>> fseek-- మీరు ఒక DVD ప్లేయర్ కలిగి ఉంటే నేను సాధారణంగా ఇక్కడ ఉపయోగించడానికి సామ్యం ఉంది
విధమైన ఉపయోగించి వంటిది మీ రివైండ్ మరియు ఫాస్ట్ ఫార్వార్డ్
బటన్లు చిత్రం చుట్టూ తరలించడానికి.
అదేవిధంగా, మీరు ఫైల్ చుట్టూ తరలించవచ్చు.
లోపల విషయాలు ఒకటి ఆ ఫైలు నిర్మాణం
మీరు ఒక సూచిక ఆ c సృష్టిస్తుంది ఇక్కడ మీరు ఫైల్ లో ఉన్నాయి.
మీరు చాలా వద్ద ఆర్ బైట్ సున్నా వద్ద ప్రారంభమైంది?
మీరు బైట్ 100 వద్ద ఉన్నాయి, బైట్ 1,000 మరియు అందువలన న?
మీరు ఏకపక్ష తరలించడానికి fseek ఉపయోగించవచ్చు ముందుకు లేదా వెనకకు సూచిక.
>> మరియు తిరిగి, ftell ఒక DVD ప్లేయర్ పోలి,
చెబుతుంది ఒక చిన్న గడియారం వంటిది మీరు ఎన్ని నిమిషాలు మరియు సెకన్లు మీరు
ఒక ఖచ్చితమైన చిత్రం శాఖలుగా వర్గీకరించారు.
అదేవిధంగా, ftell మీరు ఎలా చెబుతుంది అనేక బైట్లు మీరు ఫైల్లోకి ఉన్నాయి.
feof వేరే వెర్షన్ మీరు చేసిన లేదో గుర్తించే
ఫైల్ ముగింపు చేరుకున్నారు.
మరియు ferror ఒక ఫంక్షన్ ఉంది మీరు ఉపయోగించే
ఏదో ఉంది లేదో గుర్తించడం ఒక ఫైల్ తప్పు పని పోయింది.
మళ్ళీ, ఈ కేవలం ఉంది ఉపరితల గోకడం.
పుష్కలంగా మరింత ఫైలు I / O ఇప్పటికీ ఉంది ప్రామాణిక io.h. ఫంక్షన్లు
కానీ ఈ బహుశా మీరు పొందుతారు ఫైలు గమనికలు పని ప్రారంభించాడు.
నేను డౌ లాయిడ్ ఉన్నాను.
ఈ CS50 ఉంది.