ఫంక్షన్ నిర్వచనం
మీ కోడ్‌లో రీడ్ ఫంక్షన్‌ను నిర్వచించే ముందు, మీరు కొన్ని అవసరమైన ప్యాకేజీలను చేర్చాలి.
#చేర్చండి
POSIX రీడ్ ఫంక్షన్‌ను మీరు ఎలా నిర్వచిస్తారో ఇక్కడ ఉంది:
>>ssize_t ప్రీయాడ్(intదంతము,శూన్యం *బఫ్,పరిమాణం_టిnbyte, ఆఫ్_టి ఆఫ్‌సెట్);
>>ssize_t చదవండి(intఎఫ్ డి,శూన్యం *బఫ్,పరిమాణం_టిnbytes);
రీడ్ మెథడ్ కాల్ నుండి మూడు పారామీటర్ ఆర్గ్యుమెంట్‌లు తీసుకోవచ్చు:
int fd: సమాచారం చదవాల్సిన ఫైల్ యొక్క ఫైల్ డిస్క్రిప్టర్. మేము ఓపెన్ సిస్టమ్ కాల్ ద్వారా పొందిన ఫైల్ డిస్క్రిప్టర్‌ని ఉపయోగిస్తూ ఉండవచ్చు లేదా సాధారణ ఇన్‌పుట్, రెగ్యులర్ అవుట్‌పుట్ లేదా రెగ్యులర్ ఎర్రర్‌ని సూచిస్తూ 0, 1, లేదా 2 ని ఉపయోగించవచ్చు.
శూన్యమైన *బఫ్: చదివిన డేటాను సేవ్ చేసి ఉంచాల్సిన బఫర్ లేదా అక్షర శ్రేణి.
పరిమాణం_టి nbyte: కత్తిరించే ముందు పత్రం నుండి చదవాల్సిన బైట్ల సంఖ్య. చదవాల్సిన సమాచారం nbytes కంటే తక్కువగా ఉంటే మొత్తం సమాచారాన్ని బఫర్‌లో నిల్వ చేయవచ్చు.
వివరణ
రీడ్ () పద్ధతి ఓపెన్ డాక్యుమెంట్ డిస్క్రిప్టర్ 'Fildes' లేదా 'fd' తో అనుసంధానించబడిన ఫైల్ నుండి 'buf' ద్వారా సూచించబడే బఫర్ కాష్‌లోకి 'nbyte' బైట్‌లను చదవడానికి ప్రయత్నిస్తుంది. ఇది ఒకే స్ట్రీమ్, FIFO లేదా టెర్మినల్ యూనిట్‌లో అనేక ఏకకాల రీడ్‌ల స్వభావాన్ని నిర్వచించదు.
పఠనాన్ని ప్రారంభించే పత్రాలపై, పత్రం ఆఫ్‌సెట్‌లో పఠన ప్రక్రియ ప్రారంభమవుతుంది మరియు చదివిన బైట్ల సంఖ్యతో ఆఫ్‌సెట్ పెరుగుతుంది. డాక్యుమెంట్ ఆఫ్‌సెట్ ఫైల్ అంచు వద్ద లేదా మించి ఉంటే, చదివిన బైట్లు లేవు మరియు చదివిన () ఏదీ ఇవ్వదు.
కౌంట్ 0 అయినప్పుడు, చదవండి () దిగువ పేర్కొన్న లోపాలను గుర్తిస్తుంది. ఏవైనా తప్పులు లేకపోయినా, లేదా చదివినట్లయితే () లోపాలతో లెక్కించబడకపోతే, చదివిన () 0 లెక్కింపుతో సున్నాను ఇస్తుంది మరియు అందువల్ల ఇతర పర్యవసానాలు లేవు.
POSIX.1 ప్రకారం SSIZE_MAX కంటే ఎక్కువ ఉంటే, ఫలితం అమలు ద్వారా నిర్ణయించబడుతుంది.
రిటర్న్ వాల్యూ
సాధించిన తర్వాత తిరిగి చదివిన బైట్ల సంఖ్య ‘రీడ్’ మరియు ‘ప్రీయాడ్’ తప్పనిసరిగా నెగెటివ్ కాని పూర్ణాంకం అయి ఉండాలి, అయితే ఫైల్ చివరలో సున్నా పాయింట్లు ఉండాలి. డాక్యుమెంట్ స్థానం ఈ నంబర్ ద్వారా పురోగమిస్తుంది, లేదంటే, దోషాన్ని సూచించడానికి, పద్ధతులు -1 కి తిరిగి వచ్చి 'ఎర్నో' ని కేటాయించాయి. ఈ సంఖ్య అభ్యర్థించిన బైట్ల సంఖ్య కంటే తక్కువగా ఉన్నప్పుడు, అది తప్పు బైట్ కాదు. ప్రస్తుతానికి తక్కువ బైట్లు అందుబాటులో ఉండే అవకాశం ఉంది.
లోపాలు
ఈ లోపాలు సంభవించినట్లయితే ప్రీఎడ్ మరియు రీడ్ ఫంక్షన్ విజయవంతం కాదు:
ఈగైన్:
డాక్యుమెంట్ లేదా ఫైల్ డిస్క్రిప్టర్ 'fd' నాన్-సాకెట్ ఫైల్‌కు చెందినది, ఇది నాన్-బ్లాకింగ్ (O NONBLOCK) అని లేబుల్ చేయబడింది మరియు రీడింగ్‌ను బ్లాక్ చేస్తుంది.
ఈవోల్డ్‌బ్లాక్:
డిస్క్రిప్టర్ ‘ఎఫ్‌డి’ సాకెట్‌కు చెందినది, ఇది నాన్-బ్లాకింగ్ (O_NONBLOCK) అని లేబుల్ చేయబడింది మరియు రీడింగ్‌ను బ్లాక్ చేస్తుంది.
EBADF:
'Fd' అనేది ఉపయోగించదగిన వివరణ కాకపోవచ్చు లేదా చదవడానికి తెరవబడకపోవచ్చు.
ఎఫాల్ట్:
మీ 'బఫ్' మీ చేరుకోగల చిరునామా స్థలానికి వెలుపల ఉన్నప్పుడు ఇది జరుగుతుంది.
EINTR:
సమాచార డేటాను చదవడానికి ముందు, కాల్ సిగ్నల్ ద్వారా విడిపోయి ఉండవచ్చు.
ఎంపిక:
మీ 'fd' డిస్క్రిప్టర్ ఒక వస్తువులో చేరినప్పుడు ఈ లోపం సంభవిస్తుంది, ఇది చదవడానికి తగినది కాదు, లేదా O_DIRECT ఫ్లాగ్‌తో పత్రం విప్పబడింది మరియు 'buf' లో పేర్కొన్న ఒకటి లేదా మరొక చిరునామా, 'కౌంట్‌లో సూచించిన విలువ ', లేదా డాక్యుమెంట్ ఆఫ్‌సెట్ తగిన విధంగా అనుబంధించబడలేదు.
ఎంపిక:
టైమర్‌ఎఫ్‌డి_క్రియేట్ (2) కి కాల్ ఉపయోగించి డిస్క్రిప్టర్ ‘ఎఫ్‌డి’ ఏర్పడి ఉండవచ్చు మరియు తప్పు సైజ్ బఫర్ చదవడానికి ఇవ్వబడింది.
EIO:
ఇది ఇన్‌పుట్/అవుట్‌పుట్ లోపం. నేపథ్య ప్రక్రియ సమూహం దాని రెగ్యులేటరీ టెర్మినల్ నుండి చదవడానికి ప్రయత్నించినప్పుడు ఇది సంభవిస్తుంది, మరియు ఒకటి లేదా మరొకటి SIGTTIN ని పట్టించుకోవడం లేదా నిరోధించడం, లేదా దాని ప్రక్రియ సమూహం కోల్పోయినప్పుడు. ఈ లోపానికి మరొక కారణం తక్కువ-స్థాయి ఇన్‌పుట్/అవుట్‌పుట్ లోపం అయితే హార్డ్ డిస్క్ లేదా టేప్ నుండి చదువుతుంది. నెట్‌వర్క్ డేటా ఫైల్‌లపై EIO యొక్క మరొక సంభావ్య కారణం ఫైల్ డిస్క్రిప్టర్‌లోని సలహా లాకింగ్‌ను తొలగించడం మరియు ఆ లాక్ వైఫల్యం.
EISDIR:
ఫైల్ డిస్క్రిప్టర్ 'fd' డైరెక్టరీకి చెందినది.
గమనికలు:
అనేక ఇతర లోపాలు కూడా సంభవించవచ్చు, డిస్క్రిప్టర్ 'fd' తో లింక్ చేయబడిన వస్తువుపై ఆకస్మికంగా. Size_t మరియు ssize_t ఫారమ్‌లు రెండూ గుర్తించబడలేదు మరియు POSIX.1 ద్వారా నిర్వచించబడిన సంఖ్యా డేటా రకాలు గుర్తించబడ్డాయి. Linux లో, గరిష్టంగా 0x7ffff000 (2,147,479,552) బైట్‌లను రీడింగ్ ఫంక్షన్ (మరియు సమానమైన సిస్టమ్ కాల్‌లు) ద్వారా ప్రసారం చేయవచ్చు, మొదట ప్రసారం చేయబడిన బైట్ల సంఖ్యను తిరిగి అందిస్తుంది (32-బిట్ మరియు 64-బిట్ ప్లాట్‌ఫారమ్‌లలో). NFS ఫైల్‌సిస్టమ్‌లతో, చిన్న స్ట్రీమ్‌లను చదవడం ద్వారా టైమ్‌స్టాంప్ మార్చబడిన మొదటి క్షణం, తదుపరి కాల్‌లు అలా చేయవు. ఇది క్లయింట్-వైపు లక్షణాల క్యాచింగ్ ద్వారా ప్రేరేపించబడింది, అయినప్పటికీ, అన్నీ కానప్పటికీ, NFS క్లయింట్‌లు st_atime (చివరి ఫైల్ యాక్సెస్ సమయం) ద్వారా సర్వర్‌కు అప్‌డేట్ చేయడాన్ని విడిచిపెట్టారు మరియు క్లయింట్ యొక్క బఫర్ నుండి నెరవేర్చిన క్లయింట్-సైడ్ రీడ్‌లు st- కు మార్పులను ప్రేరేపించవు. సర్వర్-వైపు రీడింగ్‌లు అందుబాటులో లేనందున సర్వర్‌లో కొంత సమయం. క్లయింట్-సైడ్ అట్రిబ్యూట్ క్యాషింగ్‌ని తీసివేయడం ద్వారా, యునిక్స్ మెటాడేటాను యాక్సెస్ చేయవచ్చు, కానీ ఇది సర్వర్‌లో లోడ్‌ను గణనీయంగా పెంచుతుంది మరియు చాలా సందర్భాలలో ఉత్పాదకతను ప్రభావితం చేస్తుంది.
ఉదాహరణ 01:
Linux సిస్టమ్‌లో రీడ్ ఫంక్షన్ కాల్‌ను ప్రదర్శించడానికి ఇక్కడ C ప్రోగ్రామ్ ఉంది. క్రొత్త ఫైల్‌లో ఉన్నట్లుగా కింది ఆదేశాన్ని వ్రాయండి. లైబ్రరీలను జోడించండి మరియు ప్రధాన ఫంక్షన్‌లో, డిస్క్రిప్టర్ మరియు పరిమాణాన్ని ప్రారంభించండి. డిస్క్రిప్టర్ ఫైల్‌ను తెరుస్తోంది మరియు ఫైల్ డేటాను చదవడానికి పరిమాణం ఉపయోగించబడుతుంది.
పై-కోడ్ కొరకు అవుట్‌పుట్ క్రింది చిత్రంలో చూపిన విధంగా ఉంటుంది.
ఉదాహరణ 02:
రీడ్ ఫంక్షన్ యొక్క పనిని వివరించడానికి మరొక ఉదాహరణ క్రింద ఇవ్వబడింది.
మరొక ఫైల్‌ను సృష్టించి, దిగువ ఉన్న కోడ్‌ని అందులో ఉన్నట్లుగా వ్రాయండి. ఇక్కడ రెండు డిస్క్రిప్టర్లు, fd1 & fd2, రెండూ వారి స్వంత ఓపెన్ టేబుల్ ఫైల్ యాక్సెస్ కలిగి ఉంటాయి. Foobar.txt కోసం, ప్రతి డిస్క్రిప్టర్ దాని ఫైల్ స్థానాన్ని కలిగి ఉంటుంది. Foobar.txt యొక్క మొట్టమొదటి బైట్ fd2 నుండి అనువదించబడింది, మరియు ఫలితం c = f, c = o కాదు.
ముగింపు
మేము C ప్రోగ్రామింగ్‌లో POSIX రీడ్ ఫంక్షన్‌ను సమర్థవంతంగా చదివాము. ఆశాజనక, ఎటువంటి సందేహాలు మిగిలి లేవు.