ప్రోగ్రామింగ్‌లో ఫైల్ మేనేజ్‌మెంట్ అనేది ప్రోగ్రామర్ నిష్ణాతులుగా ఉండాల్సిన పని. వివిధ ఓపెన్, రీడ్ మరియు రైట్ ఫంక్షన్‌ల గురించి తెలుసుకోవడం చాలా అవసరం ఎందుకంటే ఫైల్‌లలో నిల్వ చేయబడిన సమాచారాన్ని నిల్వ చేయడానికి లేదా పారవేసేందుకు మనకు ఎల్లప్పుడూ అవసరం.
ఈ Linux సూచన కథనంలో, ఫైల్‌లను వ్రాయడానికి రైట్() ఫంక్షన్‌ను ఎలా ఉపయోగించాలో మీరు నేర్చుకుంటారు.
మేము ఈ ఎల్లా గురించి, దాని సింటాక్స్, కాల్ పద్ధతి, ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఆర్గ్యుమెంట్‌లు, ప్రతి సందర్భంలో అది అంగీకరించే డేటా రకం మరియు దానిని ఎలా సరిగ్గా ప్రకటించాలి అనే దాని గురించి ప్రతిదీ వివరిస్తాము.
ఆ తర్వాత, ఈ ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మేము నేర్చుకున్న వాటిని కోడ్ స్నిప్పెట్‌లు మరియు చిత్రాలతో మీ కోసం సిద్ధం చేసిన ఆచరణాత్మక ఉదాహరణలలోకి వర్తింపజేస్తాము, C భాషలో వ్రాయడం() వినియోగాన్ని చూపుతాము.
మీరు వ్రాత() ఫంక్షన్‌ను ఉపయోగించడం గురించి సమగ్ర పరిజ్ఞానం కలిగి ఉండటానికి, మేము ఈ ఫంక్షన్‌ను ఉపయోగిస్తున్నప్పుడు సంభవించే వ్యక్తిగత లోపాలను, అలాగే వాటి గుర్తింపు మరియు గుర్తింపును వివరించే ప్రత్యేక విభాగాన్ని జోడించాము, తద్వారా మీరు వాటి సంభవించిన సందర్భంలో త్వరిత పరిష్కారం కోసం అవసరమైన పద్ధతులు.
సి లాంగ్వేజ్‌లో రైట్() ఫంక్షన్ యొక్క సింటాక్స్
int వ్రాయడానికి ( int ఎఫ్ డి , శూన్యం * buf , పరిమాణం_t n ) ;C లాంగ్వేజ్‌లో వ్రాయడం() ఫంక్షన్ యొక్క వివరణ
రైట్() ఫంక్షన్ ఓపెన్ ఫైల్‌కి వ్రాస్తుంది. ఈ ఫంక్షన్ 'fd' ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లో దాని డిస్క్రిప్టర్ ద్వారా పేర్కొనబడిన ఫైల్‌కు 'buf' ద్వారా సూచించబడిన బఫర్ యొక్క కంటెంట్‌లను వ్రాస్తుంది. ఫైల్‌కు వ్రాయవలసిన బ్లాక్ పరిమాణం తప్పనిసరిగా “n” ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లో పేర్కొనబడాలి.
రైట్() ఫంక్షన్‌తో వ్రాయడానికి, ఫైల్ తప్పనిసరిగా ఓపెన్() ఫంక్షన్‌తో తెరవబడాలి మరియు O_RDONLY లేదా O_RDWR లక్షణాలలో పేర్కొనబడాలి. లేకపోతే, ఈ ఫంక్షన్ ఎటువంటి ప్రభావం చూపదు.
కాల్ విజయవంతమైతే, అది నమోదు చేసిన అక్షరాల సంఖ్యను అందిస్తుంది. వ్రాసేటప్పుడు లోపం సంభవించినట్లయితే, అది -1కి సమానమైన ఫలితాన్ని అందిస్తుంది. 'errno.h' హెడర్‌లో నిర్వచించబడిన ఎర్రనో గ్లోబల్ వేరియబుల్ నుండి లోపాన్ని సూచించే గుర్తింపు కోడ్‌ని తిరిగి పొందవచ్చు.
తరువాత, ఈ ఫంక్షన్ యొక్క అత్యంత సాధారణ లోపాలను ఎలా గుర్తించాలో మరియు గుర్తించాలో మేము వివరించే విభాగాన్ని మీరు కనుగొంటారు.
వ్రాయడం() ఫంక్షన్ “unistd.h” హెడర్‌లో నిర్వచించబడింది. ఫైల్‌ను తెరవడానికి లక్షణాలను మరియు మోడ్‌ను నిర్వచించే ఫ్లాగ్‌లు “fcntl.h”లో నిర్వచించబడ్డాయి. ఓపెన్() మరియు రైట్() ఫంక్షన్‌లను ఉపయోగించడానికి, మీరు ఈ క్రింది విధంగా మీ కోడ్‌లో ఈ హెడర్‌లను తప్పనిసరిగా చేర్చాలి:
##
సి లాంగ్వేజ్‌లోని రైట్() ఫంక్షన్‌ని ఉపయోగించి ఫైల్‌కి ఎలా వ్రాయాలి
ఈ ఉదాహరణలో, మేము 'పత్రాలు' డైరెక్టరీలో ఇంతకు ముందు సృష్టించిన 'example.txt' పేరుతో ఖాళీ టెక్స్ట్ ఫైల్‌ను వ్రాస్తాము.
అవసరమైన శీర్షికలను చొప్పించడం మొదటి దశ. ప్రధాన() ఫంక్షన్ లోపల, ఓపెన్() ఫంక్షన్‌తో ఫైల్‌ను తెరవండి. దీన్ని చేయడానికి, ఫైల్ డిస్క్రిప్టర్‌గా పనిచేసే “fd” పూర్ణాంకాన్ని మరియు మనం ఫైల్‌కి వ్రాయాలనుకుంటున్న టెక్స్ట్‌ను కలిగి ఉన్న 1024-అక్షరాల “బఫ్” బఫర్ శ్రేణిని ప్రకటించాలి. ఈ బఫర్‌లో, 'example.txt' ఫైల్‌కి వ్రాయడానికి GCC మ్యాన్ పేజీ యొక్క మొదటి పేరాను మేము నిల్వ చేస్తాము.
రీడ్/రైట్ మోడ్‌లో ఓపెన్() ఫంక్షన్‌తో ఫైల్‌ను తెరిచిన తర్వాత, రైట్() ఫంక్షన్‌కి కాల్ చేసి, “fd” ఫైల్ డిస్క్రిప్టర్‌ను మొదటి ఇన్‌పుట్ ఆర్గ్యుమెంట్‌గా, “buf” పాయింటర్‌ను రెండవదిగా పాస్ చేయడం ద్వారా ఫైల్‌కి వ్రాస్తాము. ఆర్గ్యుమెంట్, మరియు మూడవ ఆర్గ్యుమెంట్‌గా శ్రేణిలో ఉన్న స్ట్రింగ్ పరిమాణం, మేము strlen() ఫంక్షన్‌తో పొందుతాము. ఈ ఉదాహరణ కోసం ఇక్కడ కోడ్ ఉంది:
##
#
#include
#
#
#include
శూన్యం ప్రధాన ( )
{
int ఎఫ్ డి ;
చార్ బఫర్ [ 1024 ] = 'మీరు GCCని ప్రారంభించినప్పుడు, ఇది సాధారణంగా ప్రీప్రాసెసింగ్, కంపైలేషన్, అసెంబ్లీ మరియు లింకింగ్ చేస్తుంది. మొత్తం ఎంపికలు ఈ ప్రక్రియను ఇంటర్మీడియట్ దశలో ఆపడానికి మిమ్మల్ని అనుమతిస్తాయి. ఉదాహరణకు, -c ఎంపిక లింకర్‌ను అమలు చేయకూడదని చెబుతుంది. తర్వాత అవుట్‌పుట్ వీటిని కలిగి ఉంటుంది అసెంబ్లర్ ద్వారా ఆబ్జెక్ట్ ఫైల్స్ అవుట్‌పుట్.' ;
ఎఫ్ డి = తెరవండి ( 'Documents/example.txt' , O_RDWR ) ;
వ్రాయడానికి ( ఎఫ్ డి , & బఫర్ , strlen ( బఫర్ ) ) ;
దగ్గరగా ( ఎఫ్ డి ) ;
}
కింది చిత్రంలో, రైట్() ఫంక్షన్ ద్వారా వ్రాయబడిన ఓపెన్ ఫైల్‌తో కలిపి ఈ కోడ్ యొక్క సంకలనం మరియు అమలును మనం చూస్తాము:
C లాంగ్వేజ్‌లో రైట్() ఫంక్షన్‌తో ఫైల్ చివరిలో వచనాన్ని ఎలా జోడించాలి
O_WRONLY లేదా O_RDWR ఫ్లాగ్‌లను పేర్కొనడం ద్వారా ఫైల్‌ను తెరిచినప్పుడు, కర్సర్ మొదటి స్థానానికి వెళ్లి అక్కడ నుండి రాయడం ప్రారంభిస్తుంది.
ఫైల్ చివరిలో వచనాన్ని జోడించడానికి, ఫైల్ తెరిచినప్పుడు ఓపెన్() ఫంక్షన్‌లోని ఇన్‌పుట్ ఫ్లాగ్‌ల ఆర్గ్యుమెంట్‌లో O_WRONLY లేదా O_RDWR ఫ్లాగ్‌లు మరియు O_ APPEND ఫ్లాగ్‌ల మధ్య లాజికల్ లేదా ఆపరేషన్ ద్వారా తప్పనిసరిగా పేర్కొనబడాలి. ఈ విధంగా, కర్సర్ ఫైల్ చివరిలో ఉంచబడుతుంది మరియు అక్కడ నుండి రాయడం ప్రారంభమవుతుంది. అలాగే, fcntl() ఫంక్షన్‌తో ఫైల్‌ని ఓపెన్ చేసిన తర్వాత అట్రిబ్యూట్‌లు మరియు రైట్ మోడ్‌ని మార్చవచ్చు.
కింది ఉదాహరణలో, మేము మునుపటి ఉదాహరణలో వ్రాసిన ఫైల్ చివరిలో వచనాన్ని జోడించే కోడ్‌ను మీరు చూడవచ్చు:
##
#
#include
#
#
#include
శూన్యం ప్రధాన ( )
{
int ఎఫ్ డి ;
చార్ బఫర్ [ 1024 ] = 'ఈ వచనం జోడించబడింది. ఈ వచనం జోడించబడింది.' ;
ఎఫ్ డి = తెరవండి ( 'Documents/example.txt' , O_RDWR | O_APPEND ) ;
వ్రాయడానికి ( ఎఫ్ డి , & బఫర్ , strlen ( బఫర్ ) ) ;
దగ్గరగా ( ఎఫ్ డి ) ;
}
కింది చిత్రం జోడించిన వచనాన్ని చూపుతుంది. మీరు చూడగలిగినట్లుగా, ఈ ప్రారంభ పద్ధతిలో, వ్రాయడం() ఫంక్షన్ ఫైల్‌కు వ్రాయబడిన చివరి అక్షరం యొక్క స్థానం వద్ద వ్రాయడం ప్రారంభిస్తుంది:
సి లాంగ్వేజ్‌లో రైట్() ఫంక్షన్‌ని ఉపయోగిస్తున్నప్పుడు సంభవించే లోపాలను ఎలా గుర్తించాలి మరియు గుర్తించాలి
వ్రాయడం()ని ఉపయోగించడం వలన వివిధ లోపాలు ఏర్పడవచ్చు. ఇది జరిగినప్పుడు, ఈ ఫంక్షన్ -1కి సమానమైన ఫలితాన్ని అందిస్తుంది.
లోపం సంభవించిందో లేదో నిర్ధారించడానికి సులభమైన మార్గం ఏమిటంటే, షరతు -1 యొక్క రిటర్న్ విలువ అయిన “if” కండిషన్‌ను ఉపయోగించడం. ఇప్పుడు, లోపం సంభవించిందో లేదో తెలుసుకోవడానికి మీరు ఈ పద్ధతిని ఎలా ఉపయోగించవచ్చో చూద్దాం:
int n ;n = వ్రాయడానికి ( ఎఫ్ డి , & బఫర్ , strlen ( బఫర్ ) ) ;
ఉంటే ( n == - 1 ) {
printf ( 'ఫైల్‌ను వ్రాయడానికి ప్రయత్నిస్తున్నప్పుడు లోపం సంభవించింది.' ) ;
}
వ్రాయడం() ఫంక్షన్ లోపంతో తిరిగి వచ్చినట్లయితే, అది “if” స్టేట్‌మెంట్‌కి మారుతుంది మరియు సందేశాన్ని ప్రింట్ చేస్తుంది, “ ఫైల్‌ను వ్రాయడానికి ప్రయత్నిస్తున్నప్పుడు లోపం సంభవించింది '.
లోపం సంభవించినప్పుడు, 'errno.h' హెడర్‌లో నిర్వచించబడిన ఎర్రనో గ్లోబల్ వేరియబుల్‌లో సంఖ్యా కోడ్ స్వయంచాలకంగా నిల్వ చేయబడుతుంది. సంభవించిన లోపాన్ని గుర్తించడానికి ఈ కోడ్‌ని ఉపయోగించవచ్చు.
ప్రతి లోపం మరియు అనుబంధిత పూర్ణాంకం విలువ యొక్క క్లుప్త వివరణతో పాటుగా “errno.h” హెడర్‌లో నిర్వచించబడిన వ్రాత() ఫంక్షన్ రూపొందించగల ఎర్రర్‌లతో కూడిన సారాంశం క్రిందిది:
| నిర్వచనం | తప్పులో విలువ | లోపం |
|---|---|---|
| మళ్ళీ | పదకొండు | మళ్లీ ప్రయత్నించండి. |
| EBADF | 9 | ఫైల్ నంబర్ తప్పు. |
| EDESTADDRREQ | 89 | గమ్యం చిరునామా అవసరం. |
| EDQUOT | 122 | కోటా మించిపోయింది. |
| EFAULT | 14 | తప్పు చిరునామా. |
| EFBIG | 27 | ఫైల్ చాలా పెద్దది. |
| EINTR | 4 | సిస్టమ్ కాల్ అంతరాయం కలిగింది. |
| సింగిల్ ఛాయిస్ | 22 | చెల్లని వాదన. |
| EIO | 5 | I/O లోపం. |
| ENOSPC | 28 | పరికరంలో ఖాళీ లేదు. |
| ఎగువ | 1 | ఆపరేషన్ అనుమతించబడదు. |
ఎర్రర్నో వేరియబుల్ జంప్ కండిషన్ మరియు ప్రతి కేస్ ఒక ఎర్రర్ డెఫినిషన్ అయిన స్విచ్‌ని తెరవడం లోపాన్ని గుర్తించడానికి సులభమైన మార్గం.
తరువాత, ప్రతికూల గుర్తుతో డిస్క్రిప్టర్‌ను నమోదు చేయడానికి ప్రయత్నించే ఉదాహరణను చూద్దాం, ఫలితంగా లోపం ఏర్పడుతుంది. లోపాన్ని గుర్తించడానికి, మేము మునుపటి స్నిప్పెట్‌లో చూసిన “if” షరతును ఉపయోగిస్తాము. దీన్ని గుర్తించడానికి, మేము ఈ ఫంక్షన్ ఉత్పత్తి చేయగల మూడు అత్యంత సాధారణ ఎర్రర్‌లతో స్విచ్‌ని తెరుస్తాము.
##
#include
#
#
#include
#
శూన్యం ప్రధాన ( )
{
int ఎఫ్ డి ;
int n ;
చార్ బఫర్ [ 1024 ] = 'హలో వరల్డ్' ;
ఎఫ్ డి = తెరవండి ( 'Documents/example.txt' , O_RDWR ) ;
n = వ్రాయడానికి ( - 2 , & బఫర్ , strlen ( బఫర్ ) ) ;
ఉంటే ( n == - 1 ) {
మారండి ( తప్పు ) {
కేసు EBADF : {
printf ( 'చెడ్డ ఫైల్ నంబర్. లోపం: %i \n ' , తప్పు ) ;
బ్రేక్ ; }
కేసు సింగిల్ ఛాయిస్ : {
printf ( 'చెల్లని వాదన. లోపం: %i \n ' , తప్పు ) ;
బ్రేక్ ; }
కేసు EIO : {
printf ( 'I/O లోపం . లోపం: %i \n ' , తప్పు ) ;
బ్రేక్ ; }
}
}
}
కింది చిత్రంలో మనం చూడగలిగినట్లుగా, చెల్లని డిస్క్రిప్టర్‌ను ఇన్‌పుట్ ఆర్గ్యుమెంట్‌గా పాస్ చేసినప్పుడు రైట్() ఫంక్షన్ లోపాన్ని అందిస్తుంది. ఎర్రనో వేరియబుల్ నుండి తిరిగి పొందబడిన విలువ జంప్ కండిషన్‌గా ఉపయోగించబడుతుంది, ఇది మేము EBADF కేసును నమోదు చేసినప్పుడు లోపాన్ని గుర్తించడానికి అనుమతిస్తుంది.
ముగింపు
ఈ Linux సూచన కథనంలో, ఫైల్‌లకు వ్రాయడానికి రైట్() ఫంక్షన్‌ను ఎలా ఉపయోగించాలో మేము మీకు చూపించాము. మేము ఈ ఫంక్షన్ యొక్క సింటాక్స్ మరియు సైద్ధాంతిక వివరణను మీకు చూపించాము. మేము లోపాన్ని గుర్తించడం మరియు గుర్తించే పద్ధతులను కూడా వివరించాము, తద్వారా మీరు ఈ సమస్యలను త్వరగా పరిష్కరించడానికి అవసరమైన సాధనాలు మరియు సాంకేతికతలను కలిగి ఉంటారు.
వ్రాయడం() ఎలా పని చేస్తుందో చూడటంలో మీకు సహాయపడటానికి, మేము ఈ ఫంక్షన్ యొక్క ఉపయోగాన్ని ఆచరణాత్మక ఉదాహరణలలో కోడ్‌లు మరియు చిత్రాలతో అమలు చేసాము, ఇది మరియు ఇతర ఫైల్ ప్రాసెసింగ్ ఫంక్షన్‌ల వినియోగాన్ని చూపుతుంది.
ఫైల్ ప్రారంభంలో లేదా చివరిలో వచనాన్ని చొప్పించడానికి ఫైల్ ఓపెన్ మోడ్‌ను ఎలా ఎంచుకోవాలో మరియు ఈ లక్షణాలను మార్చడానికి ఏ విధులు అందుబాటులో ఉన్నాయో కూడా మేము మీకు చూపించాము.