యొక్క వాక్యనిర్మాణం పైపు () ఫంక్షన్:
intపైపు(intపైప్‌ఎఫ్‌డి[2]);
ఇక్కడ, పైప్ () ఫంక్షన్ ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ కోసం ఏకదిశాత్మక డేటా ఛానెల్‌ని సృష్టిస్తుంది. మీరు ఒక పాస్ int (పూర్ణాంకం) రకం శ్రేణి పైప్‌ఎఫ్‌డి ఫంక్షన్ పైప్ () కు 2 శ్రేణి మూలకాన్ని కలిగి ఉంటుంది. అప్పుడు పైప్ () ఫంక్షన్ రెండు ఫైల్ డిస్క్రిప్టర్‌లను సృష్టిస్తుంది పైప్‌ఎఫ్‌డి అమరిక.
యొక్క మొదటి మూలకం పైప్‌ఎఫ్‌డి అమరిక, పైప్‌ఎఫ్‌డి [0] పైప్ నుండి డేటాను చదవడానికి ఉపయోగిస్తారు.
రెండవ అంశం పైప్‌ఎఫ్‌డి అమరిక, పైప్‌ఎఫ్‌డి [1] పైపుకు డేటాను వ్రాయడానికి ఉపయోగిస్తారు.
విజయం సాధించినప్పుడు, పైప్ () ఫంక్షన్ 0. తిరిగి వస్తుంది. పైప్ ప్రారంభ సమయంలో లోపం సంభవించినట్లయితే, అప్పుడు పైప్ () ఫంక్షన్ -1 తిరిగి వస్తుంది.
పైప్ () ఫంక్షన్ హెడర్‌లో నిర్వచించబడింది unistd.h . మీ సి ప్రోగ్రామ్‌లో పైప్ () ఫంక్షన్‌ను ఉపయోగించడానికి, మీరు తప్పనిసరిగా హెడర్‌ని చేర్చాలి unistd.h కింది విధంగా:
#చేర్చండి
పైప్ () సిస్టమ్ ఫంక్షన్ గురించి మరింత సమాచారం కోసం, కింది ఆదేశంతో పైప్ () యొక్క మ్యాన్ పేజీని తనిఖీ చేయండి:
$ మనిషి2పైపుపైప్ యొక్క మ్యాన్ పేజీ().
ఉదాహరణ 1:
మొదటి ఉదాహరణ కోసం, కొత్త C సోర్స్ ఫైల్‌ని సృష్టించండి 1_pipe.c మరియు కోడ్‌ల కింది పంక్తులను టైప్ చేయండి.
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(శూన్యం) {
intపైప్‌ఫ్డ్‌లు[2];
ఉంటే(పైపు(పైప్‌ఫ్డ్‌లు) == -1) {
పెరర్ ('పైపు');
బయటకి దారి (EXIT_FAILURE);
}
printf ('ఫైల్ డిస్క్రిప్టర్ విలువ చదవండి: %d n',పైప్‌ఫ్డ్‌లు[0]);
printf ('ఫైల్ డిస్క్రిప్టర్ విలువ వ్రాయండి: %d n',పైప్‌ఫ్డ్‌లు[1]);
తిరిగిEXIT_SUCCESS;
}
ఇక్కడ, నేను పైప్ () యొక్క హెడర్ ఫైల్‌ను చేర్చాను unistd.h కింది పంక్తితో మొదట.
#చేర్చండిఅప్పుడు, లో ప్రధాన () ఫంక్షన్, నేను నిర్వచించాను పైప్‌ఫ్డ్‌లు కింది లైన్‌తో రెండు మూలకాల పూర్ణాంక శ్రేణి.
intపైప్‌ఫ్డ్‌లు[2];అప్పుడు, ఫైల్ డిస్క్రిప్టర్ల శ్రేణిని ప్రారంభించడానికి నేను పైప్ () ఫంక్షన్‌ను అమలు చేసాను పైప్‌ఫ్డ్‌లు క్రింది విధంగా.
పైపు(పైప్‌ఫ్డ్‌లు)పైప్ () ఫంక్షన్ యొక్క రిటర్న్ విలువను ఉపయోగించి నేను లోపాల కోసం కూడా తనిఖీ చేసాను. నేను ఉపయోగించాను బయటకి దారి() పైప్ ఫంక్షన్ విఫలమైతే ప్రోగ్రామ్‌ను టెర్మినల్ చేయడానికి ఫంక్షన్.
ఉంటే(పైపు(పైప్‌ఫ్డ్‌లు) == -1) {పెరర్ ('పైపు');
బయటకి దారి (EXIT_FAILURE);
}
అప్పుడు, నేను చదివే మరియు వ్రాసే పైప్ ఫైల్ డిస్క్రిప్టర్ల విలువను ముద్రించాను పైప్‌ఫ్డ్స్ [0] మరియు పైప్‌ఫ్డ్స్ [1] వరుసగా.
printf ('ఫైల్ డిస్క్రిప్టర్ విలువ చదవండి: %d n',పైప్‌ఫ్డ్‌లు[0]);printf ('ఫైల్ డిస్క్రిప్టర్ విలువ వ్రాయండి: %d n',పైప్‌ఫ్డ్‌లు[1]);
మీరు ప్రోగ్రామ్‌ను రన్ చేస్తే, మీరు ఈ క్రింది అవుట్‌పుట్‌ను చూడాలి. మీరు గమనిస్తే, చదివిన పైప్ ఫైల్ డిస్క్రిప్టర్ విలువ పైప్‌ఫ్డ్స్ [0] ఉంది 3 మరియు పైప్ ఫైల్ డిస్క్రిప్టర్ వ్రాయండి పైప్‌ఫ్డ్స్ [1] ఉంది 4 .
ఉదాహరణ 2:
మరొక సి సోర్స్ ఫైల్‌ని సృష్టించండి 2_pipe.c మరియు కోడ్‌ల కింది పంక్తులను టైప్ చేయండి.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన(శూన్యం) {
intపైప్‌ఫ్డ్‌లు[2];
చార్బఫర్[5];
ఉంటే(పైపు(పైప్‌ఫ్డ్‌లు) == -1) {
పెరర్ ('పైపు');
బయటకి దారి (EXIT_FAILURE);
}
చార్ *పిన్= '4128 0';
printf ('పైప్‌కు పిన్ రాయడం ... n');
వ్రాయడానికి(పైప్‌ఫ్డ్‌లు[1],పిన్, 5);
printf ('పూర్తి. n n');
printf ('పైప్ నుండి పిన్ చదువుతోంది ... n');
చదవండి(పైప్‌ఫ్డ్‌లు[0],బఫర్, 5);
printf ('పూర్తి. n n');
printf ('పైప్ నుండి పిన్: %s n',బఫర్);
తిరిగిEXIT_SUCCESS;
}
ఈ ప్రోగ్రామ్ ప్రాథమికంగా పైప్‌కు ఎలా వ్రాయాలో మరియు మీరు పైప్ నుండి వ్రాసిన డేటాను ఎలా చదవాలో చూపుతుంది.
ఇక్కడ, నేను 4-అక్షరాల PIN కోడ్‌ను a లోకి నిల్వ చేసాను చార్ అమరిక. శ్రేణి యొక్క పొడవు 5 (NULL అక్షరం 0 తో సహా).
చార్ *పిన్= '4128 0';ప్రతి ASCII అక్షరం C. లో 1 బైట్ పరిమాణంలో ఉంటుంది, కాబట్టి, పైప్ ద్వారా 4 అంకెల PIN ను పంపడానికి, మీరు తప్పనిసరిగా 5 బైట్లు (4 + 1 NULL అక్షరం) డేటాను పైపులో రాయాలి.
5 బైట్ల డేటా రాయడానికి ( పిన్ ) పైపులోకి, నేను ఉపయోగించాను వ్రాయడానికి() రైట్ పైప్ ఫైల్ డిస్క్రిప్టర్ ఉపయోగించి ఫంక్షన్ పైప్‌ఫ్డ్స్ [1] క్రింది విధంగా.
వ్రాయడానికి(పైప్‌ఫ్డ్‌లు[1],పిన్, 5);ఇప్పుడు నేను పైపులో కొంత డేటాను కలిగి ఉన్నాను, దానిని ఉపయోగించి పైప్ నుండి చదవగలను చదవండి() రీడ్ పైప్ ఫైల్ డిస్క్రిప్టర్‌పై ఫంక్షన్ పైప్‌ఫ్డ్స్ [0] . నేను 5 బైట్ల డేటాను వ్రాసినట్లుగా ( పిన్ ) పైపులోకి, నేను పైప్ నుండి 5 బైట్ల డేటాను చదువుతాను. చదివిన డేటా ఇందులో నిల్వ చేయబడుతుంది బఫర్ అక్షర శ్రేణి. నేను పైప్ నుండి 5 బైట్ల డేటాను చదువుతున్నందున, ది బఫర్ అక్షర శ్రేణి కనీసం 5 బైట్ల పొడవు ఉండాలి.
నేను నిర్వచించాను బఫర్ ప్రారంభంలో అక్షర శ్రేణి ప్రధాన () ఫంక్షన్
చార్బఫర్[5];ఇప్పుడు, నేను పైప్ నుండి పిన్ చదవగలను మరియు దానిని అందులో నిల్వ చేయవచ్చు బఫర్ కింది లైన్‌తో శ్రేణి.
చదవండి(పైప్‌ఫ్డ్‌లు[0],బఫర్, 5);ఇప్పుడు నేను పైప్ నుండి పిన్ చదివాను, నేను దానిని ఉపయోగించి ప్రింట్ చేయవచ్చు printf () యథావిధిగా పనిచేస్తాయి.
printf ('పైప్ నుండి పిన్: %s n',బఫర్);నేను ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత, మీరు చూడగలిగినట్లుగా సరైన అవుట్‌పుట్ ప్రదర్శించబడుతుంది.
ఉదాహరణ 3:
క్రొత్త సి సోర్స్ ఫైల్‌ను సృష్టించండి 3_pipe.c కోడ్‌ల కింది పంక్తులలో టైప్ చేయండి.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన(శూన్యం) {
intపైప్‌ఫ్డ్‌లు[2];
చార్ *పిన్;
చార్బఫర్[5];
ఉంటే(పైపు(పైప్‌ఫ్డ్‌లు) == -1) {
పెరర్ ('పైపు');
బయటకి దారి (EXIT_FAILURE);
}
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్== 0) { // పిల్లల ప్రక్రియలో
పిన్= '4821 0'; // పిన్ పంపాలి
దగ్గరగా(పైప్‌ఫ్డ్‌లు[0]); // fd ని దగ్గరగా చదవండి
వ్రాయడానికి(పైప్‌ఫ్డ్‌లు[1],పిన్, 5); // పైప్‌కు పిన్ రాయండి
printf ('పిల్లలలో పిన్ జనరేట్ చేయడం మరియు తల్లిదండ్రులకు పంపడం ... n');
నిద్ర(2); // ఉద్దేశపూర్వక ఆలస్యం
బయటకి దారి (EXIT_SUCCESS);
}
ఉంటే(పిడ్> 0) { // ప్రధాన ప్రక్రియలో
వేచి ఉండండి(శూన్య); // పిల్లల ప్రక్రియ పూర్తయ్యే వరకు వేచి ఉండండి
దగ్గరగా(పైప్‌ఫ్డ్‌లు[1]); // fd ని వ్రాయండి
చదవండి(పైప్‌ఫ్డ్‌లు[0],బఫర్, 5); // పైప్ నుండి పిన్ చదవండి
దగ్గరగా(పైప్‌ఫ్డ్‌లు[0]); // fd ని దగ్గరగా చదవండి
printf ('పేరెంట్ పిన్'%s 'అందుకున్నారు n',బఫర్);
}
తిరిగిEXIT_SUCCESS;
}
ఈ ఉదాహరణలో, ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ కోసం పైప్‌ను ఎలా ఉపయోగించాలో నేను మీకు చూపించాను. నేను పైప్ ఉపయోగించి పిల్లల ప్రక్రియ నుండి మాతృ ప్రక్రియకు పిన్ పంపాను. అప్పుడు మాతృ ప్రక్రియలో పైప్ నుండి పిన్ చదవండి మరియు మాతృ ప్రక్రియ నుండి ముద్రించండి.
మొదట, నేను ఫోర్క్ () ఫంక్షన్ ఉపయోగించి పిల్లల ప్రక్రియను సృష్టించాను.
pid_t పిడ్=ఫోర్క్();అప్పుడు, పిల్లల ప్రక్రియలో ( పిడ్ == 0 ), నేను ఉపయోగించి పైప్‌కు పిన్ వ్రాసాను వ్రాయడానికి() ఫంక్షన్
వ్రాయడానికి(పైప్‌ఫ్డ్‌లు[1],పిన్, 5);పిల్లల ప్రక్రియ నుండి పైప్‌కు పిన్ వ్రాయబడిన తర్వాత, మాతృ ప్రక్రియ ( పిడ్> 0 ) ఉపయోగించి పైప్ నుండి చదవండి చదవండి() ఫంక్షన్
చదవండి(పైప్‌ఫ్డ్‌లు[0],బఫర్, 5);తర్వాత, పేరెంట్ ప్రాసెస్ ఉపయోగించి పిన్ ముద్రించబడింది printf () యథావిధిగా పనిచేస్తాయి.
printf ('పేరెంట్ పిన్'%s 'అందుకున్నారు n',బఫర్);మీరు గమనిస్తే, ప్రోగ్రామ్‌ను అమలు చేయడం ఆశించిన ఫలితాన్ని ఇస్తుంది.
ఉదాహరణ 4:
క్రొత్త సి సోర్స్ ఫైల్‌ను సృష్టించండి 4_pipe.c కోడ్‌ల కింది పంక్తులలో టైప్ చేయండి.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
#PIN_LENGTH 4 ని నిర్వచించండి
#PIN_WAIT_INTERVAL 2 ని నిర్వచించండి
శూన్యంgetPIN(చార్పిన్[PIN_LENGTH+ 1]) {
చిరాకు (గెట్‌పిడ్() +getppid());
పిన్[0] = 49 + వరుస () % 7;
కోసం(inti= 1;i<PIN_LENGTH;i++) {
పిన్[i] = 48 + వరుస () % 7;
}
పిన్[PIN_LENGTH] = ' 0';
}
intప్రధాన(శూన్యం) {
అయితే(1) {
intపైప్‌ఫ్డ్‌లు[2];
చార్పిన్[PIN_LENGTH+ 1];
చార్బఫర్[PIN_LENGTH+ 1];
పైపు(పైప్‌ఫ్డ్‌లు);
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్== 0) {
getPIN(పిన్); // పిన్ రూపొందించండి
దగ్గరగా(పైప్‌ఫ్డ్‌లు[0]); // fd ని దగ్గరగా చదవండి
వ్రాయడానికి(పైప్‌ఫ్డ్‌లు[1],పిన్,PIN_LENGTH+ 1); // పైప్‌కు పిన్ రాయండి
printf ('పిల్లలలో పిన్ జనరేట్ చేయడం మరియు తల్లిదండ్రులకు పంపడం ... n');
నిద్ర(PIN_WAIT_INTERVAL); // ఉద్దేశపూర్వకంగా పిన్ జనరేషన్ ఆలస్యం.
బయటకి దారి (EXIT_SUCCESS);
}
ఉంటే(పిడ్> 0) {
వేచి ఉండండి(శూన్య); // పిల్లల పూర్తి కోసం వేచి ఉంది
దగ్గరగా(పైప్‌ఫ్డ్‌లు[1]); // fd ని వ్రాయండి
చదవండి(పైప్‌ఫ్డ్‌లు[0],బఫర్,PIN_LENGTH+ 1); // పైప్ నుండి పిన్ చదవండి
దగ్గరగా(పైప్‌ఫ్డ్‌లు[0]); // fd ని దగ్గరగా చదవండి
printf ('పేరెంట్ పిల్లల నుండి పిన్'%s 'అందుకున్నాడు. n n',బఫర్);
}
}
తిరిగిEXIT_SUCCESS;
}
ఈ ఉదాహరణ అదే ఉదాహరణ 3 . ఒకే వ్యత్యాసం ఏమిటంటే, ఈ కార్యక్రమం నిరంతరం పిల్లల ప్రక్రియను సృష్టిస్తుంది, పిల్లల ప్రక్రియలో పిన్‌ని ఉత్పత్తి చేస్తుంది మరియు పైప్‌ను ఉపయోగించి పిన్‌ని మాతృ ప్రక్రియకు పంపుతుంది.
పేరెంట్ ప్రక్రియ తర్వాత పైప్ నుండి పిన్ చదివి ప్రింట్ చేస్తుంది.
ఈ కార్యక్రమం ప్రతి PIN_WAIT_INTERVAL సెకన్లకు కొత్త PIN_LENGTH పిన్‌ను ఉత్పత్తి చేస్తుంది.
మీరు గమనిస్తే, ప్రోగ్రామ్ ఊహించిన విధంగా పనిచేస్తుంది.
మీరు నొక్కడం ద్వారా మాత్రమే ప్రోగ్రామ్‌ను ఆపవచ్చు + సి .
కాబట్టి, మీరు సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో పైప్ () సిస్టమ్ కాల్‌ని ఈ విధంగా ఉపయోగిస్తారు. ఈ కథనాన్ని చదివినందుకు ధన్యవాదాలు.