[Powered by Google Translate] [File I / O]
[జాసన్ Hirschhorn, హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ, CS50.TV CS50 ఉంది]
మేము ఒక ఫైల్ యొక్క ఆలోచించినప్పుడు, ఏమిటి, ఒక Microsoft Word పత్రం స్ఫురణకు వచ్చింది
ఒక చిత్రం, లేదా ఒక MP3 పాట,
మరియు మేము రకాలుగా ఫైళ్ళను ఈ రకమైన ప్రతి సంకర్షణ.
ఉదాహరణకు, ఒక పద పత్రంలో వచనం జోడించండి
ఒక చిత్రం తో మేము అంచులు అవుట్ క్రాప్ లేదా రంగులు retouch ఉండవచ్చు, అయితే.
ఇంకా హుడ్ కింద మా కంప్యూటర్ లో ఫైళ్ళను అన్ని ఇంకేమీ ఉంటాయి
సున్నాలు మరియు వాటిని సుదీర్ఘ శ్రేణి కంటే.
ఫైలు సంకర్షణ నిర్దిష్ట అప్లికేషన్ ఇష్టం
ఈ దీర్ఘ శ్రేణి ప్రాసెస్ మరియు వినియోగదారుకు ప్రస్తుత ఎలా అనుకుంటారు.
ఒక వైపు, ఒక పత్రం, కేవలం ఒక బైట్ చూడవచ్చు
లేదా 8 సున్నాలు మరియు వాటిని, మరియు స్క్రీన్ మీద ఒక ASCII అక్షరాల ప్రదర్శిస్తాయి.
మరోవైపు, బిట్మ్యాప్ను చిత్రం, 3 బైట్లు చూడవచ్చు
లేదా 24 సున్నాలు మరియు వాటిని,
మరియు 3 హెక్సాడెసిమల్ సంఖ్యలను వాటిని అర్థం
ఆ ఎరుపు, ఆకుపచ్చ, నీలం మరియు విలువలను సూచిస్తాయి
ఒక చిత్రం యొక్క ఒక పిక్సెల్ లో.
ఏది జరిగినా వారు, ముఖ్యంగా, మీ తెరపై ఎలా ఉంటుంది
ఫైళ్లను సున్నాలు మరియు వాటిని ఒక క్రమంలో కంటే ఎక్కువ ఏమీ ఉంటాయి.
కాబట్టి లెట్స్ లో ఈత కొట్టడానికి మరియు మేము నిజంగా ఈ సున్నాలు మరియు వాటిని సర్దుబాటు ఎలా చూడండి
ఇది వ్రాయడం మరియు ఒక ఫైల్ చదవడం విషయానికి వస్తే.
>> నేను ఒక సాధారణ 3 భాగాల ప్రక్రియ లో విభజించడం ద్వారా ప్రారంభించగలరు.
తరువాత, నేను ఈ మూడు భాగాలు ప్రదర్శించేందుకు రెండు కోడ్ ఉదాహరణలు ప్రవేశిస్తాడు చేస్తాము.
చివరగా, నేను ప్రక్రియ సమీక్షించడానికి మరియు దాని అతి ముఖ్యమైన వివరాలు కొన్ని చేస్తాము.
మీ డెస్క్టాప్ మీద ఉండే ఏ ఫైల్ తో,
ఇది మొదటి విషయం ఇది తెరవాలి.
సి లో మేము ఒక ముందే నిర్వచించిన struct ఒక పాయింటర్ ప్రకటించారు ద్వారా
డిస్కు లో ఫైలు సూచిస్తుంది.
ఈ ఫంక్షన్ కాల్ లో, మేము కూడా మేము వ్రాయండి లేదా ఫైల్ నుండి చదవడానికి లేదో నిర్ణయించుకుంటారు.
తరువాత, మేము నిజమైన మరియు చదవడంలో చేయండి.
మేము ఈ భాగం లో ఉపయోగించవచ్చు ప్రత్యేక పనితీరు అనేక ఉన్నాయి
మరియు దాదాపు అన్ని వాటిని ఫైల్ కోసం నిలుచునే లేఖ F, ప్రారంభం.
ఆఖరి ఫైళ్ళ ఎగువ మూలలో చిన్న ఎరుపు X పోలిన, మీ కంప్యూటర్ పై
మేము ఒక చివరి చర్యను కాల్ ఫైల్ మూసివేయండి.
ఇప్పుడు మనం చేయబోతున్నామని ఏమి ఒక సాధారణ ఆలోచన కలిగి,
కోడ్ ప్రవేశిస్తాడు చూద్దాం.
>> ఈ డైరెక్టరీ లో, మేము రెండు సి ఫైళ్ళను మరియు వాటి సంబంధిత ఎగ్జిక్యూటబుల్ ఫైళ్లు ఉన్నాయి.
టైప్రైటర్ను కార్యక్రమం, ఒక కమాండ్ లైన్ వాదన పడుతుంది
మేము సృష్టించాలనుకునే పత్రం యొక్క పేరు.
ఈ సందర్భంలో, మనం అది doc.txt పిలుస్తాను.
యొక్క అమలు మరియు రేఖల జంట ఎంటర్ లెట్.
హాయ్. నా పేరు జాసన్ ఉంది.
చివరగా, మేము "నిష్క్రమించాడు." టైప్ చేస్తాము
మేము ఇప్పుడు, ఈ డైరెక్టరీ లో ఫైళ్ళను అన్ని జాబితా ఉంటే
మేము ఒక కొత్త పత్రాన్ని doc.txt అని ఉందని చూడండి.
ఫైలు కేవలం రూపొందించినవారు ఈ కార్యక్రమం పేర్కొంది.
అంతే కాకుండా, చాలా సున్నాలు మరియు వాటిని సుదీర్ఘ శ్రేణి కంటే ఎక్కువ కాదు.
మేము ఈ కొత్త ఫైలు తెరిస్తే,
మేము మా కార్యక్రమం నమోదు కోడ్ 3 లైన్లు చూడండి -
హాయ్. మే పేరు జాసన్ ఉంది.
కాని వాస్తవానికి typewriter.c నడుస్తుంది ఉన్నప్పుడు జరగబోతోంది?
మాకు ఆసక్తి మొదటి పంక్తి పంక్తి 24.
ఈ లైన్ లో మేము మా ఫైలు పాయింటర్ ప్రకటిస్తాయి.
ఈ పాయింటర్, fopen తిరిగి ఆ ఫంక్షన్, రెండు వాదనలు పడుతుంది.
మొదటి ఫైల్ పొడిగింపు సరైన సహా ఫైలు పేరు.
ఒక ఫైల్ పొడిగింపు దాని యొక్క కనిష్ట స్థాయికి ఫైలు ప్రభావితం లేదు గుర్తుచేసుకున్నారు.
మేము ఎల్లప్పుడూ సున్నాలు మరియు వాటిని సుదీర్ఘ శ్రేణి వ్యవహరించే చేస్తున్నారు.
కానీ ఫైళ్ళను అంచనా మరియు అనువర్తనాలు తెరవడానికి ఉపయోగించే ఎలా ప్రభావం చేస్తుంది.
fopen రెండో వాదన ఒక అక్షరం
మనం ఫైల్ ఓపెన్ తర్వాత చేయడానికి ప్లాన్ ఏమి సూచిస్తుంది.
W, R, మరియు A. - ఈ వాదన కోసం మూడు ఎంపికలు ఉన్నాయి
మేము ఫైల్ వ్రాయాలనుకుంటున్న ఎందుకంటే మేము ఈ సందర్భంలో W ఎంచుకున్నారు.
R, మీరు బహుశా అంచనా వంటి, ఫైలుకు చదవడానికి ఉంది.
మరియు ఒక ఫైల్ ను అనుమతిస్తూ కోసం.
అయితే W మరియు ఒక ఫైళ్లను వ్రాయడం కోసం ఉపయోగించవచ్చు రెండు,
W ఫైలు యొక్క ప్రారంభం నుండి రాయడం ప్రారంభమౌతుంది
మరియు శక్తివంతంగా గతంలో నిల్వ చేసిన ఏ డేటా తిరిగి రాస్తుంది.
అప్రమేయంగా, అది ఇప్పటికే లేకపోతే మేము, ఫైల్ను తెరువు,
మన ప్రస్తుత పని డైరెక్టరీ సృష్టించబడుతుంది.
అయితే, మేము వేరే ప్రదేశంలో ఒక ఫైల్ యాక్సెస్ లేదా సృష్టించాలని మీరు అనుకుంటే,
fopen మొదటి వాదన లో,
మేము ఫైల్ పేరు పాటు ఒక ఫైల్ మార్గం వివరించవచ్చు.
ఈ ప్రక్రియ యొక్క మొదటి భాగం పొడవు కోడ్ మాత్రమే లైన్, కాగా
అది పంక్తులు మరొక సమితి ఎల్లప్పుడూ మంచి పద్ధతి యొక్క
ఫైల్ విజయవంతంగా ప్రారంభించబడింది లేదా రూపొందించినవారు చేసింది తనిఖీ.
Fopen శూన్య తిరిగి ఉంటే, మేము, మా కార్యక్రమం ముందుకు నకలు మీరు కాదు
ఆపరేటింగ్ సిస్టమ్లో మెమరీ ఉంటే ఈ జరిగే
లేదా మేము సరైన అనుమతులు లేని ఒక డైరెక్టరీ లో ఒక ఫైల్ తెరిచేందుకు ప్రయత్నించండి ఉంటే.
>> ప్రాసెస్ యొక్క భాగం రెండు టైప్రైటర్ను స్ లూప్ జరుగుతుంది.
మేము, వినియోగదారు నుండి ఇన్పుట్ పొందడానికి CS50 లైబ్రరీ ఫంక్షన్ ఉపయోగించేందుకు
మరియు, వారు ప్రోగ్రామ్ విడిచి చేయకూడదని భావించి
మేము స్ట్రింగ్ తీసుకుని దానికి ఫైలు వ్రాయడానికి ఫంక్షన్ fputs ఉపయోగించండి.
fputs మేము ఫైల్కు వ్రాయడం వాడేవారు చాలా విధులను మాత్రమే ఒకటి.
ఇతరులు fwrite, fputc మరియు fprintf ఉన్నాయి.
సంబంధం లేకుండా ప్రత్యేక చర్యను మేము, అయితే, ఉపయోగించి ముగుస్తుంది
వాటిని అన్ని వారి వాదనలు ద్వారా తెలుసుకోవాలి
కనీసం రెండు విషయాలు -
ఏది రాసిన అవసరం పేరు వ్రాసిన మరియు అవసరం.
మా సందర్భంలో, ఇన్పుట్ రాసిన అవసరం స్ట్రింగ్
మరియు fp మేము వ్రాస్తున్నాము పేరు మాకు నిర్దేశిస్తుంది ఆ పాయింటర్ ఉంది.
ఈ కార్యక్రమంలో, విధానంలో భాగంగా రెండు కాకుండా సూటిగా ఉంటుంది.
మేము కేవలం యూజర్ నుండి ఒక స్ట్రింగ్ వేస్తున్నాము
మరియు మా నేరుగా ఫైలుకు జోడించడం చిన్న నుండి ఏ ఇన్పుట్ ధ్రువీకరణ లేదా భద్రతా తనిఖీలను.
అయితే తరచూ భాగంగా రెండు మీ కోడ్ అత్యధికంగా పడుతుంది.
మేము ఫైల్ దగ్గరగా పేరు చివరగా, మూడవ భాగం, లైన్ 58 న ఉంది.
ఇక్కడ మేము మా అసలు ఫైల్ పాయింటర్ fclose మరియు పాస్ కాల్.
తదుపరి లైన్ లో మేము మా కార్యక్రమం ముగింపును సంకేతాలను సున్నా తిరిగి.
అవును, భాగం మూడు అంత సులభం.
>> యొక్క ఫైళ్ళు చదవడం కొనసాగండి లెట్.
తిరిగి మా డైరెక్టరీలో మేము printer.c గా పిలువబడే ఒక ఫైల్ ఉంటుంది.
యొక్క మేము సృష్టించిన ఫైల్ తో దీన్ని అమలు లెట్ -
doc.txt.
ఈ కార్యక్రమం పేరు సూచించినట్లు, కేవలం ఫైల్ యొక్క కంటెంట్లు దానికి ఆమోదించింది అవుట్ ముద్రిస్తుంది.
మరియు అక్కడ మేము కలిగి.
లైన్స్ ఆఫ్ కోడ్ మేము ముందుగా టైప్ మరియు doc.txt లో సేవ్ చేసింది.
హాయ్. నా పేరు జాసన్ ఉంది.
ఉంటే printer.c లోకి మేము డైవ్,
మేము కోడ్ యొక్క చాలా మేము typewriter.c లో సంచరించింది విధంగా కనిపించే చూడండి.
మేము మోపడం పేరు నిజానికి లైన్ 22,
మేము ఫైలు మూసి పేరు మరియు లైన్ 39,
రెండు typewriter.c దాదాపు సమానంగా ఉంటాయి, fopen రెండవ వాదన సేవ్ చెయ్యండి.
మేము ఒక ఫైల్ నుండి చదువుతున్న సమయంలో,
కాబట్టి మేము W బదులుగా r ఎంచుకున్నారు.
అందువలన, యొక్క ప్రక్రియ యొక్క రెండవ భాగం పై దృష్టి కేంద్రీకరించే తెలియజేయండి.
లైన్ 35 లో, మా 4 లూప్ రెండవ పరిస్థితి,
మేము, fgets ఒక కాల్
ముందు నుండి fputs కంపానియన్ ఫంక్షన్.
మేము మూడు వాదనలు ఉన్నాయి ఈ సమయంలో.
మొదటి స్ట్రింగ్ నిల్వ చేయబడతాయి పాత్రలు శ్రేణి పాయింటర్ ఉంది.
రెండవ చదవడానికి అక్షరాల గరిష్ఠ సంఖ్య.
మరియు మూడవ మేము పని చేస్తున్నాము తో ఫైలుకు పాయింటర్ ఉంది.
మీరు fgets శూన్య వచ్చినప్పడు లూప్ ముగిసే మీరు గమనించవచ్చు.
ఈ జరిగి ఉంటుంది ఆ రెండు కారణం ఉన్నాయి.
మొదటి, ఒక లోపం సంభవించింది.
రెండవది, మరియు చాలా ఫైలు ముగింపు కుదిరింది మరియు no more అక్షరాలు పరిగణించింది.
మీరు వొండరింగ్ చేస్తున్న సందర్భంలో, రెండు విధులు మాకు అనుమతించే ఉన్నాయి
ఇది కారణం ఈ ప్రత్యేక నల్ పాయింటర్ కోసం కారణం.
మరియు ఆశ్చర్యం కాకుండా, వారు ఫైళ్ళను పని తో లేదు నుండి,
ferror ఫంక్షన్ మరియు feof ఫంక్షన్ ప్రారంభ అక్షరం F తో. రెండు
>> చివరగా, మేము ముగించారు ముందు, ఫైలు ఫంక్షన్ ముగింపులో ఒక త్వరిత గమనిక,
ఇది కేవలం పేర్కొన్న feof గా రాస్తారు.
తరచుగా మీరు అయితే మరియు ఉచ్చులు కోసం క్రమంగా ఫైళ్ళ ద్వారా మీ మార్గం చదవడానికి ఉపయోగించి మీరే చూడండి.
మీరు ఈ ఫైళ్లను ముగింపు చేరుకోవడానికి తర్వాత కాబట్టి, మీరు ఈ వలయాలు ముగించడానికి ఒక మార్గం ఉంటుంది.
మీ ఫైల్ పాయింటర్ ఆన్ feof కాలింగ్ మరియు ఇది నిజం ఉంటే చూడటానికి తనిఖీ
ఆ చేయరు.
అందువలన, పరిస్థితి (! Feof (fp)) తో కొంత లూప్ సంపూర్ణ తగిన పరిష్కారం వంటి కనిపిస్తుంది ఉండవచ్చు.
అయితే, మేము మా టెక్స్ట్ ఫైల్ లో ఒక్క లైన్ కలిగి చెప్పారు.
మేము మా అయితే లూప్ నమోదు చేస్తారు మరియు ప్రణాళిక వంటి ప్రతిదీ పని చేస్తుంది.
ద్వారా తరువాతి రౌండ్, మా కార్యక్రమం, fp యొక్క feof నిజమైతే చూడటానికి తనిఖీ చేస్తుంది
కానీ - ఈ ఇక్కడ అర్థం కీలకమైన విషయం -
అది ఇంకా నిజమైన ఉండదు.
Feof ప్రయోజనం తనిఖీ లేదు ఎందుకంటే ఆ
ఒక చదివి ఫంక్షన్ పక్కన కాల్ ఫైలు ముగింపు హిట్ ఉంటే,
కానీ ఫైలు ముగింపు ఇప్పటికే చేరుకుంది లేదో తనిఖీ చేయడానికి.
ఈ ఉదాహరణ యొక్క సందర్భంలో,
మా ఫైలు యొక్క చివరి మాటకు ఖచ్చితంగా సరిగ్గా జరుగుతాయి,
కానీ ప్రోగ్రామ్ ఇంకా మేము మా ఫైలు ముగింపు హిట్ చేసిన తెలియదు.
అది ఒక అదనపు రీడ్ చేస్తుంది వరకు ఇది కాదు అది కౌంటర్లు ఫైలు యొక్క చివర.
కాబట్టి, సరైన పరిస్థితి క్రింది ఉంటుంది:
fgets మరియు దాని మూడు వాదనలు - అవుట్పుట్, అవుట్పుట్ యొక్క పరిమాణం, మరియు fp -
మరియు ఆ సమానం కాదు అన్ని శూన్యం కు.
ఇది మేము printer.c సాధించింది విధానం
మరియు ఈ సందర్భంలో, లూప్ నిష్క్రమించిన తరువాత,
మీరు feof లేదా ferror ఈ లూప్ నిష్క్రమించే కోసం ప్రత్యేక తర్కం కోసం యూజర్ తెలియజేయడానికి కాల్ కాలేదు.
>> కు రాయడం మరియు ఒక ఫైల్ చదవడం, అతి సామాన్య వద్ద ఉంది
సాధారణ 3 భాగాల ప్రక్రియ.
మొదటి, మేము ఫైల్ ను తెరవండి.
రెండవది, మేము మా ఫైల్లోకి కొన్ని విషయాలు ఉంచండి లేదా బయటకు కొన్ని విషయాలు పడుతుంది.
మూడవ, మేము ఫైల్ మూసివేయండి.
మొదటి మరియు చివరి భాగాలు సులభం.
గమ్మత్తైన విషయం భాగానికి మధ్య భాగం.
మరియు అయితే హుడ్ కింద మేము ఎల్లప్పుడూ సున్నాలు మరియు వాటిని సుదీర్ఘ శ్రేణి వ్యవహరించే చేస్తున్నారు
సంక్షిప్తత యొక్క ఒక పొర జోడించడానికి కోడింగ్ అది సహాయం లేదు
మరింత దగ్గరగా మేము చూసిన ఉపయోగిస్తారు ఏమి పోలి దానిని క్రమం మారుతుంది.
ఉదాహరణకు, ఒక 24-bit Bitmap ఫైల్ పని చేస్తుంటే,
మేము అవకాశం చదవడం లేదా సమయంలో మూడు బైట్లు రాయడం వస్తారు.
ఈ సందర్భంలో, ఇది నిర్వచిస్తుంది మరియు తగిన పేరు కోణంలో చేస్తుంది
3 బైట్లు పెద్ద ఒక struct.
>> ఫైళ్ళను పని క్లిష్టమైన అనిపించే అవకాశం ఉన్నప్పటికీ,
వాటిని ఉపయోగించి మాకు నిజంగా అద్భుతమైన ఏదో ఒకటి చేయడానికి అనుమతిస్తుంది.
మేము, మా కార్యక్రమం బయట ప్రపంచానికి మార్చవచ్చు
మేము, మా కార్యక్రమం జీవితం మించి నివసిస్తుంది ఏదో సృష్టించవచ్చు
లేదా మేము కూడా మా ప్రోగ్రామ్ను అమలు ప్రారంభమైంది ముందు సృష్టించిన ఏదో మార్చవచ్చు.
ఫైళ్లను పరిచయాత్మకంగా C. లో ప్రోగ్రామింగ్ యొక్క నిజమైన శక్తివంతమైన భాగం
మరియు నేను మీరు వచ్చిన కోడ్ దానితో సృష్టించడానికి వెళ్లి ఏమి చూడండి ఉత్తేజం పొందుతున్నాను.
నా పేరు జాసన్ Hirschhorn ఉంది. ఈ CS50 ఉంది.
[CS50.TV]
>> [లాఫర్]
సరే. ఒక టేక్. ఇక్కడ మేము వెళ్ళండి.
మేము ఒక ఫైల్ యొక్క ఆలోచించినప్పుడు - >> ఓహ్, వేచి. క్షమించాలి.
[లాఫర్] సరే.
అక్కడ హే.
మేము ఒక ఫైల్ యొక్క ఆలోచించినప్పుడు -
మీరు ఒక ఫైల్ యొక్క ఆలోచించినప్పుడు - సరే. మీరు సిద్ధంగా ఉన్నప్పుడు నాకు చెప్పండి.
ఓహ్, గొప్ప.
ఒక teleprompter చదవడం ఉన్నప్పటికీ విధంగా - ఏ. నా చెడు.