' పోపెన్() ఫంక్షన్ స్ట్రింగ్ యొక్క కమాండ్ ద్వారా ఇవ్వబడిన ఆదేశాన్ని అమలు చేస్తుంది. కాలింగ్ అప్లికేషన్ మరియు ఎగ్జిక్యూటెడ్ కమాండ్ మధ్య పైప్‌ను క్రియేట్ చేస్తున్నప్పుడు ఫంక్షన్ పైపును చదవడానికి లేదా వ్రాయడానికి ఉపయోగించే స్ట్రీమ్‌కు పాయింటర్‌ను తిరిగి అందించాలి. Popen ఫంక్షన్ I/O ఫంక్షన్ యొక్క ప్రామాణిక లైబ్రరీలో అందుబాటులో ఉంది మరియు టెర్మినల్ కమాండ్‌ను అమలు చేయడానికి రెండవ ప్రక్రియను అందిస్తుంది. popen() యొక్క ఓపెన్ ఫేజ్ fopen() ఫంక్షన్‌లోని ఓపెన్ ఫేజ్ వలె ఉంటుంది. పోపెన్() ఫంక్షన్ ఫోర్కింగ్, పైపును నిర్మించడం మరియు షెల్‌ను అమలు చేయడం ద్వారా ప్రక్రియను ప్రారంభిస్తుంది. ఒక పైపు డిఫాల్ట్‌గా ఏకదిశలో ఉంటుంది కాబట్టి; ఫలితంగా, స్ట్రీమ్ చదవడానికి-మాత్రమే లేదా వ్రాయడానికి-మాత్రమే. పోపెన్() ఫంక్షన్ విజయవంతమైన అమలులో, పైపు చదవడానికి మరియు వ్రాయడానికి ఉపయోగించే ఓపెన్ స్ట్రీమ్ పొందబడుతుంది.'
ఉదాహరణ 1
కింది ఉదాహరణ ప్రోగ్రామ్‌తో, మేము పోపెన్ సిస్టమ్ కాల్‌ని ఉపయోగించి ప్రస్తుత డైరెక్టరీ లేదా ఫోల్డర్‌లో ఉన్న ఫైల్‌లను చదువుతాము. ముందుగా, మేము C స్టాండర్డ్ లైబ్రరీ యొక్క stdio.h హెడర్ ఫైల్‌ను ఇన్‌పుట్ చేసాము. అప్పుడు, మేము పోపెన్ ఫంక్షన్‌ని అమలు చేసిన ప్రోగ్రామ్ int మెయిన్()ఫంక్షన్‌ని కలిగి ఉన్నాము. దీనికి ముందు, మేము 'FILE' క్లాస్ నుండి పాయింటర్ వేరియబుల్ 'FileOpen'ని ఏర్పాటు చేసాము. ఫైల్ యొక్క పాయింటర్ వేరియబుల్ చదవడానికి లేదా వ్రాయడానికి తదుపరి బైట్‌ను సూచిస్తుంది.
ఆ తర్వాత, మేము చదవడానికి అక్షర పరిమితి విలువను కేటాయించాము. వేరియబుల్ 'FileOpen' అప్పుడు 'popen' ఫంక్షన్‌ను ప్రారంభించింది. “popen” ఫంక్షన్ Linux యొక్క “ls -l” ఆదేశాన్ని తీసుకుంటుంది, ఇది ప్రస్తుత డైరెక్టరీలోని అన్ని ఫైల్‌లను జాబితా చేస్తుంది. అంతేకాకుండా, మేము పాపెన్ ఫంక్షన్‌లో “r” పరామితిని ఇన్‌పుట్ చేసాము, ఇది రీడ్ మోడ్‌ను సూచిస్తుంది.
ఇక్కడ, మేము పోపెన్ ఫంక్షన్‌ని ఉపయోగించడం ద్వారా ఫైల్స్ రీడ్ ప్రాసెస్‌ను పైప్ చేసాము. తరువాత, మేము అయితే లూప్‌తో సృష్టించిన పైపును ప్రాసెస్ చేసాము. అయితే లూప్ fgets పద్ధతులను ఉపయోగిస్తుంది, ఇది 'లైన్', 'లైన్ యొక్క పరిమాణం' మరియు 'FileOpen' అనే వాదనలను తీసుకుంటుంది. fgets పైప్ చేయబడిన ప్రక్రియను చదివి, దానిని స్ట్రింగ్ యొక్క “%s” చిహ్నంలో నిల్వ చేస్తుంది. ఈ ప్రత్యేక చిహ్నాన్ని 'లైన్' ఆర్గ్యుమెంట్‌తో పాటు printf పద్ధతిలో పిలుస్తారు. పిప్‌క్లోజ్డ్ ఫంక్షన్‌తో మేము పైప్‌ను ప్రాసెస్ చేసిన తర్వాత, పైప్‌డ్ ప్రాసెస్‌ను దిగువ ప్రోగ్రామ్ చివరిలో అమలు చేసిన విధంగా మూసివేయవచ్చు.
#
పూర్ణాంక ప్రధాన ( )
{
ఫైల్ * ఫైల్ ఓపెన్;
చార్ లైన్ [ 130 ] ;
FileOpen = పాపెన్ ( 'ls -l' , 'r' ) ;
అయితే ( fgets ( లైన్, లైన్ పరిమాణం, ఫైల్ ఓపెన్ ) )
{
printf ( '%s' , లైన్ ) ;
}
pclose ( ఫైల్ తెరవండి ) ;
}
C ప్రోగ్రామ్ యొక్క పోపెన్ ఫంక్షన్ పై ప్రక్రియను ఫోర్క్ చేసి ఆపై పైప్‌ను సృష్టించింది. ఇప్పుడు, మేము C కంపైలేషన్ కమాండ్‌తో షెల్‌లోని స్ట్రీమ్ యొక్క ప్రాసెస్ చేయబడిన పైప్‌ను అమలు చేసాము. మేము ఆ డైరెక్టరీలో ప్రోగ్రామ్ను అమలు చేసినందున అవుట్‌పుట్ “హోమ్” డైరెక్టరీలోని అన్ని ఫైల్‌లను జాబితా చేసింది.
ఉదాహరణ 2
మునుపటి పోపెన్ ప్రోగ్రామ్‌లో, ఫైల్‌లను చదివే స్ట్రీమింగ్ ప్రక్రియను పైపింగ్ చేయడానికి ఉపయోగించే పోపెన్ ప్రోగ్రామ్ యొక్క కార్యాచరణ యొక్క సాధారణ ప్రదర్శనను మేము కలిగి ఉన్నాము. ఇప్పుడు, మేము వ్రాసే మోడ్‌తో ప్రక్రియను పైప్ చేసిన పోపెన్ ఫంక్షన్‌కు మరొక ఉదాహరణను తీసుకున్నాము. ప్రధాన విధితో ప్రోగ్రామ్ను పరిశీలిద్దాం. మేము ప్రధాన ఫంక్షన్ లోపల ఫైల్ పాయింటర్ వేరియబుల్‌ను “ఫైల్”గా నిర్మించాము. ఫైల్ పాయింటర్ పోపెన్ ఫంక్షన్‌తో అమలు చేయబడుతుంది.
పోపెన్ ఫంక్షన్ రైట్ మోడ్ కోసం “క్యాట్” ఆదేశాన్ని మరియు “w”ని తీసుకుంటుంది. ఇక్కడ, ప్రతి ఫైల్ ఆర్గ్యుమెంట్ క్యాట్ కమాండ్ ద్వారా వరుసగా చదవబడుతుంది మరియు ప్రామాణిక అవుట్‌పుట్‌కి పంపబడుతుంది. for loop బాడీలో, మేము '%d' చిహ్నాన్ని పేర్కొన్నందున సంఖ్యా గణన విలువలను ముద్రించడానికి fprintf ఫంక్షన్‌ని ఉపయోగించాము. తర్వాత మూసివేయబడింది, pclose సిస్టమ్ కాల్‌తో పోపెన్ పైప్ ప్రక్రియ.
#పూర్ణాంక ప్రధాన ( int argc, చార్ ** argv ) {
ఫైల్ * ఫైల్ = పోపెన్ ( 'పిల్లి' , 'లో' ) ;
int x = 0 ;
కోసం ( x = 0 ;x < 5 ;x++ ) {
fprintf ( ఫైల్ , 'నా కౌంట్ = %d \n ' , x ) ;
}
pclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
మేము పైన సృష్టించిన ప్రక్రియను అమలు చేసినప్పుడు, ఇది క్రింది పద్ధతిలో గణన విలువలను ముద్రిస్తుంది.
ఉదాహరణ 3
ఇప్పుడు, ఒక ప్రక్రియ యొక్క డేటాను మరొక ప్రక్రియకు బదిలీ చేసే మరొక ప్రోగ్రామ్ మాకు ఉంది. మేము పోపెన్ ఫంక్షన్ నుండి పైపుతో దీన్ని చేస్తాము. మేము C యొక్క ప్రామాణిక లైబ్రరీలను ఉపయోగించడం ద్వారా ప్రోగ్రామ్ను అమలు చేసాము. అప్పుడు, ప్రోగ్రామ్‌ని అమలు చేయడానికి మాకు పూర్ణాంక ప్రధాన విధి ఉంది. ఇక్కడ, మేము 'బఫర్' ఆర్గ్యుమెంట్‌తో స్ప్రింట్ఎఫ్ ఫంక్షన్‌లో స్ట్రింగ్‌ను పేర్కొన్నాము. స్ప్రింట్ఎఫ్() ఫంక్షన్ ఫలితాన్ని ప్రాంప్ట్‌కు పంపకుండా sprintf అందించిన చార్ బఫర్‌పై ఉంచుతుంది.
ఆ తరువాత, మేము 'రీడ్' వేరియబుల్ లోపల ఉన్న పోపెన్ ఫంక్షన్ అని పిలుస్తాము. అక్కడ, పోపెన్ ఫంక్షన్‌లో మనకు రెండు ప్రక్రియలు ఉన్నాయి. అందించిన అక్షరాలను లెక్కించడానికి ఉపయోగించే మొదటి ప్రక్రియ “wc -c” మరియు రెండవ ప్రక్రియ “w”, ఇది పైపు రైటింగ్ మోడ్‌లో తెరిచి ఉందని సూచిస్తుంది. ఆ తర్వాత, మేము డేటాను వ్రాయడానికి పైప్‌ను ఉపయోగించే “fwrite” ఫంక్షన్‌ని కలిగి ఉన్నాము. డేటా “wc” ద్వారా స్వీకరించబడుతుంది, ఆపై అక్షరాన్ని లెక్కించి షెల్‌లో ప్రదర్శించబడుతుంది.
#include#include
#include
#include
పూర్ణాంక ప్రధాన ( )
{
ఫైల్ * చదవండి ;
చార్ బఫర్ [ యాభై ] ;
స్ప్రింట్ఎఫ్ ( బఫర్, 'Linux సిస్టమ్ కాల్' ) ;
చదవండి = పోపెన్ ( 'wc -c' , 'లో' ) ;
fwrite ( బఫర్, పరిమాణం ( చార్ ) ,strlen ( బఫర్ ) , చదవండి ) ;
pclose ( చదవండి ) ;
}
ప్రాంప్ట్‌లో ప్రదర్శించబడే అక్షరాలు “17” ఎందుకంటే మనం పైన పేర్కొన్న స్ట్రింగ్‌లో “17” అక్షరాలు ఉన్నాయి. “wc -c” ప్రక్రియ ఈ అక్షరాలను చదివి అవుట్‌పుట్‌గా ముద్రిస్తుంది.
ఉదాహరణ 4
పోపెన్ యొక్క పై ఉదాహరణ డేటాను ఒక ప్రక్రియ నుండి మరొకదానికి పంపుతుంది. ఇక్కడ, మేము పైప్ ద్వారా ఒక ప్రక్రియ నుండి మరొక ప్రక్రియకు డేటాను అందుకుంటాము. ప్రోగ్రామ్ యొక్క ప్రధాన విధి బఫర్‌ను నిర్మించడం, ఇది '50' విలువలను తీసుకుంటుంది. అప్పుడు, మేము వేరియబుల్ 'r'ని సృష్టించాము, ఇక్కడ పోపెన్ ఫంక్షన్ ప్రక్రియను సృష్టించింది. డైరెక్టరీ యొక్క ఫైల్‌లను జాబితా చేయడానికి “ls” ప్రక్రియ ఉపయోగించబడుతుంది మరియు పైప్ నుండి డేటాను చదవడానికి “r” ప్రక్రియ ఉపయోగించబడుతుంది. “ls” ప్రక్రియ చదవడానికి డేటాను “r” ప్రక్రియకు ప్రసారం చేస్తుంది. దీని తరువాత, మనకు fread ఫంక్షన్ ఉంది, ఇది డేటాను చదివి, బఫర్‌లో డేటాను నిల్వ చేస్తుంది. అప్పుడు, ప్రింట్ స్టేట్‌మెంట్ బఫర్‌లో నిల్వ చేయబడిన డేటాను ప్రింట్ చేస్తుంది.
#include#include
#include
#include
పూర్ణాంక ప్రధాన ( )
{
ఫైల్ * r;
చార్ బఫర్ [ యాభై ] ;
r = పోపెన్ ( 'ls' , 'r' ) ;
భయం ( బఫర్, 1 , 25 , ఆర్ ) ;
printf ( '%s \n ' , బఫర్ ) ;
pclose ( ఆర్ ) ;
}
ఇక్కడ పని చేసే డైరెక్టరీ నుండి ఇప్పటికే ఉన్న ఫైల్‌ల యొక్క “50” అక్షరాలు మాత్రమే ప్రదర్శించబడతాయి. కాబట్టి, అవుట్‌పుట్‌లో 50 అక్షరాలు మాత్రమే ఉంటాయి.
ముగింపు
మేము C భాషలో Linux popen సిస్టమ్ కాల్‌ల వివరణాత్మక ప్రదర్శనను అందించాము. మేము పోపెన్ ఫంక్షన్‌ని అమలు చేసిన నాలుగు ఉదాహరణలను అమలు చేసాము. పోపెన్ ఫంక్షన్ మేము కేటాయించిన మోడ్ ప్రకారం పైప్ స్ట్రీమ్‌ను తిరిగి అందిస్తుంది. ఉదాహరణలలో, ఫైల్ హ్యాండ్లింగ్ ఫంక్షన్లు fread మరియు fwriteతో మేము రీడ్ మరియు రైట్ మోడ్ రెండింటినీ ఉపయోగించాము. మేము popen() ఫంక్షన్‌లో ప్రోగ్రామ్ పేరును దాని మొదటి వాదనగా ఉపయోగించాము. రెండవ ఆర్గ్యుమెంట్ ఫైల్ “r” రీడ్ లేదా “w” రైట్ మోడ్‌గా ఉంటుంది.