టెక్స్ట్ ఫైల్ చదవడం మరియు అన్నింటినీ ప్రింట్ చేయడం తీగలను అనేది C ప్రోగ్రామర్లు తరచుగా చేసే కీలకమైన పని. యొక్క ప్రాథమికాలను అర్థం చేసుకోవడం ముఖ్యం చదవడం a టెక్స్ట్ ఫైల్ C లో మరియు ఎలా ముద్రణ ది తీగలను ఈ పనిని ప్రయత్నించే ముందు దాని నుండి.
టెక్స్ట్ ఫైల్ చదవడం మరియు అది కలిగి ఉన్న అన్ని స్ట్రింగ్‌ల ప్రింటింగ్ ఈ ఆర్టికల్‌లో సి ప్రోగ్రామింగ్‌ని ఉపయోగించి ప్రదర్శించబడుతుంది.
టెక్స్ట్ ఫైల్‌ని చదవండి మరియు C లో అన్ని స్ట్రింగ్‌లను ప్రింట్ చేయండి
టెక్స్ట్ ఫైల్‌ను చదవడానికి మరియు C లో అన్ని స్ట్రింగ్‌లను ప్రింట్ చేయడానికి నాలుగు ఫంక్షన్‌లు ఉన్నాయి, అవి క్రింది విధంగా ఉన్నాయి:
విధానం 1: fread() ఫంక్షన్
డేటా ఉంది ఫైల్ నుండి చదవండి మరియు C ఫంక్షన్‌ని ఉపయోగించి బఫర్‌లో నిల్వ చేయబడుతుంది fread() . శ్రేణి బఫర్‌లోని మూలకాలను లెక్కించడానికి, ది fread() ఫంక్షన్ పారామీటర్‌గా అందించబడిన ఇన్‌పుట్ స్ట్రీమ్ నుండి పద్ధతి రీడ్ అవుతుంది. ప్రతి అక్షరం ఫంక్షన్ చదివినప్పుడు, పేర్కొన్న ఇన్‌పుట్ స్ట్రీమ్ కోసం ఫైల్ స్థాన సూచిక ముందుకు కదులుతుంది.
ది fread() Cలోని పద్ధతిలో సింటాక్స్ ఉంటుంది.
size_t fread ( శూన్యం * అర్రే_బఫర్, size_t పరిమాణం , size_t కౌంట్, FILE * ఫైల్_స్ట్రీమ్ )
fread() ఫంక్షన్ పారామితులను మరింత వివరంగా చూద్దాం:
అర్రే బఫర్: డేటా తాత్కాలికంగా కంప్యూటర్ బఫర్, మెమరీ స్పేస్‌లో ఉంచబడుతుంది. ఈ ఆర్గ్యుమెంట్ అనేది డేటాను కలిగి ఉండే బఫర్ మెమరీలో ఉన్న స్థలాన్ని సూచించే పాయింటర్ చదవండి ఇన్‌పుట్ స్ట్రీమ్ నుండి.
పరిమాణం: ఈ ఆర్గ్యుమెంట్ ప్రతి బ్లాక్ కోసం ఇన్‌పుట్ స్ట్రీమ్ నుండి ఎన్ని బైట్‌ల డేటా చదవబడుతుందనే ఫంక్షన్‌ను నిర్దేశిస్తుంది.
గణన: డేటా ఇన్‌పుట్ స్ట్రీమ్ నుండి ఎన్ని అక్షరాలు చదవబడతాయో ఇది నిర్దేశిస్తుంది.
ఫైల్_స్ట్రీమ్: ఇది FILE వస్తువును సూచించే పాయింటర్.
##
పూర్ణాంక ప్రధాన ( ) {
ఫైల్ * ఫైల్ ;
చార్ బఫర్ [ 100 ] ;
ఫైల్ = ఫోపెన్ ( 'C_File.txt' , 'r' ) ;
ఉంటే ( ఫైల్ == శూన్యం ) {
printf ( 'లోపం: ఫైల్‌ని తెరవడం సాధ్యపడలేదు \n ' ) ;
తిరిగి 1 ;
}
int లెక్కించండి = భయము ( & బఫర్, పరిమాణం ( చార్ ) , 100 , ఫైల్ ) ;
fclose ( ఫైల్ ) ;
printf ( 'ఫైల్ నుండి చదవబడిన డేటా: %s \n ' , బఫర్ ) ;
printf ( 'చదివబడిన మూలకాల సంఖ్య: %d' , కౌంట్ ) ;
fclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము పరిమాణం యొక్క అక్షర శ్రేణి బఫర్‌ను నిర్వచించాము 100 ఉపయోగించే ముందు fopen() టెక్స్ట్ ఫైల్ తెరవడానికి C_File.txt రీడ్ మోడ్‌లో. if స్టేట్‌మెంట్ ఉపయోగించి, ఫైల్ విజయవంతంగా తెరవబడిందో లేదో మేము నిర్ణయిస్తాము. వరకు చదవడం క్రింది దశ 100 ఉపయోగించి ఫైల్ నుండి డేటా బైట్‌లు fread() . లక్ష్య బఫర్, ఈ సందర్భంలో బఫర్ శ్రేణి, దీనికి మొదటి పరామితి fread (). రెండవ వాదన, పరిమాణం , మనం అక్షరాల్లో చదువుతున్నప్పుడు చదవాల్సిన ప్రతి అంశం పరిమాణాన్ని నిర్ణయిస్తుంది . మూడవ ఇన్‌పుట్ చదవాల్సిన పరిమాణం, ఈ సందర్భంలో ఇది 100 . ది ఫైల్ పాయింటర్ నాల్గవ పరామితి. చివరగా, మేము ఉపయోగిస్తాము printf() ఫైల్ నుండి చదివిన డేటాను ప్రింట్ చేయడానికి మరియు fclose() ఫైల్‌ను మూసివేయడానికి. ఈ ప్రోగ్రామ్‌ని అమలు చేయడం వలన ఇలాంటి ఫలితాలు వస్తాయి C_File.txt :
అవుట్పుట్
విధానం 2: fgets() ఫంక్షన్
సి భాష fgets() మెథడ్ స్ట్రింగ్ నుండి స్ట్రింగ్ స్ట్రింగ్‌లోకి n అక్షరాలను చదువుతుంది. ది fgets() వరకు స్ట్రీమ్ నుండి అక్షరాలు చదవడం పద్ధతి కొనసాగుతుంది (n-1) అక్షరాలు చదవబడ్డాయి, కొత్త లైన్ అక్షరం కనుగొనబడింది లేదా ఫైల్ ముగింపు (EOF) చేరుకుంది.
#పూర్ణాంక ప్రధాన ( ) {
ఫైల్ * ఫైల్ ;
చార్ బఫర్ [ 100 ] ;
ఫైల్ = ఫోపెన్ ( 'C_File.txt' , 'r' ) ;
ఉంటే ( ఫైల్ == శూన్యం ) {
printf ( 'లోపం: ఫైల్‌ని తెరవడం సాధ్యపడలేదు \n ' ) ;
తిరిగి 1 ;
}
అయితే ( fgets ( బఫర్, 100 , ఫైల్ ) ) {
printf ( 'ఫైల్ నుండి స్ట్రింగ్ చదవబడింది: %s' , బఫర్ ) ;
}
fclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
ఈ ఉదాహరణ ఉపయోగిస్తుంది fopen() అనే టెక్స్ట్ ఫైల్‌ని తెరవడానికి C_File.txt పరిమాణంలోని అక్షర శ్రేణి బఫర్‌ను ముందుగా ప్రకటించిన తర్వాత రీడ్ మోడ్‌లో 100 . if స్టేట్‌మెంట్ ఉపయోగించి, ఫైల్ విజయవంతంగా తెరవబడిందో లేదో మేము నిర్ణయిస్తాము. ఆ తర్వాత, మేము కాసేపు లూప్‌ని ఉపయోగిస్తాము మరియు fgets() ఫైల్ పాయింటర్‌ని ఉపయోగించి ఫైల్ నుండి టెక్స్ట్ లైన్‌లను చదవడానికి. ఉపయోగించి printf() లూప్ లోపల, మేము టెక్స్ట్ యొక్క ప్రతి పంక్తిని ప్రింట్ చేస్తాము. ఈ ప్రోగ్రామ్‌ని అమలు చేయడం వలన అవుట్పుట్ అందించబడుతుంది:
అవుట్పుట్
విధానం 3: fscanf() ఫంక్షన్
అనే ప్రామాణిక లైబ్రరీ పద్ధతి fscanf() పారామితుల శ్రేణిని అంగీకరిస్తుంది మరియు వాటిని మీ అప్లికేషన్ ఉపయోగించగల విలువలుగా మారుస్తుంది. కాగా ఫైల్ నుండి చదవడం , ఇది లోపల చూడాలని ఊహించిన దాని స్థానంలో ఫార్మాట్ స్ట్రింగ్‌ను తిరిగి ఇస్తుంది. మీ సాఫ్ట్‌వేర్ దాని స్వంత సింటాక్స్‌లో భాగంగా ఫార్మాట్ స్ట్రింగ్‌ను అర్థం చేసుకోకుండా నిరోధించడానికి, అది తప్పనిసరిగా కోట్‌లలో ఉండాలి ('').
#పూర్ణాంక ప్రధాన ( ) {
ఫైల్ * ఫైల్ ;
int num1, num2, num3;
ఫైల్ = ఫోపెన్ ( 'C_File.txt' , 'r' ) ;
ఉంటే ( ఫైల్ == శూన్యం ) {
printf ( 'లోపం: ఫైల్‌ని తెరవడం సాధ్యపడలేదు \n ' ) ;
తిరిగి 1 ;
}
fscanf ( ఫైల్ , '%d %d %d' , & సంఖ్య 1, & సంఖ్య 2, & సంఖ్య3 ) ;
printf ( 'ఫైల్ నుండి చదివిన సంఖ్యలు: %d, %d, %d \n ' , num1, num2, num3 ) ;
fclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
ఈ ఉదాహరణ ఫైల్‌ను తెరుస్తుంది C_File.txt ముందుగా 3 int వేరియబుల్స్, num1, num2 మరియు num3ని ప్రకటించడం ద్వారా రీడ్ మోడ్‌లో. if స్టేట్‌మెంట్ ఉపయోగించి, ఫైల్ విజయవంతంగా తెరవబడిందో లేదో మేము నిర్ణయిస్తాము. కింది దశ ఫైల్ నుండి మూడు సంఖ్యలను చదవడం fscanf() ఇంకా %d ఫార్మాట్ స్పెసిఫైయర్. num1, num2 మరియు num3 అనే వేరియబుల్స్ విలువలు ఉంచబడతాయి. చివరగా, మేము ఉపయోగిస్తాము printf() ఈ వేరియబుల్స్ యొక్క విలువలను అవుట్పుట్ చేయడానికి మరియు fclose() ఫైల్‌ను మూసివేయడానికి. ఈ ప్రోగ్రామ్‌ని అమలు చేయడం వలన దిగువ చూపిన ఫలితాలు వస్తాయి:
అవుట్పుట్
విధానం 4: fgetc() ఫంక్షన్
ఫైల్ కావచ్చు చదవండి ఉపయోగించి పాత్ర ద్వారా పాత్ర fgetc() ఫంక్షన్. ఈ ఫంక్షన్ చదివే అక్షరానికి సంబంధించిన ASCII కోడ్ ఈ ఫంక్షన్ ద్వారా అందించబడుతుంది. ఫైల్ పాయింటర్ యొక్క పేర్కొన్న స్థానం నుండి అక్షరం తిరిగి ఇవ్వబడింది. ఫైల్ పాయింటర్ ప్రకారం అక్షరం చదివిన తర్వాత కింది అక్షరం చదవబడుతుంది. పాయింటర్ ఫైల్ చివరిలో ఉన్నట్లయితే లేదా సమస్య ఉన్నట్లయితే ఈ పద్ధతి EOF ఫైల్‌ని అందిస్తుంది.
#పూర్ణాంక ప్రధాన ( ) {
ఫైల్ * ఫైల్ ;
చార్ సి;
ఫైల్ = ఫోపెన్ ( 'C_File.txt' , 'r' ) ;
ఉంటే ( ఫైల్ == శూన్యం ) {
printf ( 'లోపం: ఫైల్‌ని తెరవడం సాధ్యపడలేదు \n ' ) ;
తిరిగి 1 ;
}
అయితే ( ( c = fgetc ( ఫైల్ ) ) ! = EOF ) {
printf ( '%c' , సి ) ;
}
fclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
ఈ సందర్భంలో, మేము ఉపయోగిస్తాము fopen() టెక్స్ట్ ఫైల్‌ను తెరవడానికి ఆదేశం C_File.txt రీడ్ మోడ్‌లో. if స్టేట్‌మెంట్ ఉపయోగించి, ఫైల్ విజయవంతంగా తెరవబడిందో లేదో మేము నిర్ణయిస్తాము. ఆ తర్వాత, మేము కాసేపు లూప్‌ని ఉపయోగిస్తాము మరియు fgetc() ఫైల్ నుండి అక్షరాలను చదవడానికి. ఫైల్ నుండి స్వీకరించబడిన అక్షరం వేరియబుల్‌కు కేటాయించబడుతుంది సి ఉపయోగించి ముద్రించడానికి ముందు లూప్ లోపల printf (). వరకు లూప్ నడుస్తూనే ఉంటుంది EOF (ఫైల్ ముగింపు) స్థిరాంకం ఫైల్ ముగింపును గుర్తిస్తుంది. ఈ ప్రోగ్రామ్‌ని అమలు చేయడం వలన క్రింది ఫలితాలు లభిస్తాయి C_File.txt అనే పదాన్ని కలిగి ఉంది 'Linuxin'.
అవుట్పుట్
ముగింపు
పైన వివరించిన దశలను ఉపయోగించడం ద్వారా, C ఉపయోగించవచ్చు ఒక టెక్స్ట్ ఫైల్ చదవండి మరియు అన్ని స్ట్రింగ్‌లను ప్రింట్ చేయండి అది కలిగి ఉంది. ఇది ఉపయోగించడం ద్వారా ప్రారంభమవుతుంది fopen() ఫైల్‌ని తెరవడానికి సిస్టమ్ కాల్, తర్వాత ఉపయోగం fscanf(), fread(), fgets(), fgetc() డేటాను చదవడానికి. తరువాత, ఫైల్ ఉపయోగించి మూసివేయబడుతుంది fclose() మరియు తీగలను ముద్రించడానికి a for loop ఉపయోగించబడుతుంది. ఈ పద్ధతులను ఉపయోగించడం ద్వారా, డేటాను సమర్థవంతంగా చదవడం మరియు ప్రింట్ చేయడంలో సహాయపడేందుకు Cని ఉపయోగించవచ్చు.