ஒரு குழாய் என்பது செயல்முறைகளுக்கு இடையிலான தொடர்புக்கான ஒரு ஊடகம். ஒரு செயல்முறை குழாயில் தரவை எழுதுகிறது, மற்றொரு செயல்முறை குழாயிலிருந்து தரவைப் படிக்கிறது. இந்த கட்டுரையில், சி மொழியைப் பயன்படுத்தி கருத்தை செயல்படுத்த குழாய் () செயல்பாடு எவ்வாறு பயன்படுத்தப்படுகிறது என்பதைப் பார்ப்போம்.
குழாய் பற்றி
குழாயில், தரவு ஒரு FIFO வரிசையில் பராமரிக்கப்படுகிறது, அதாவது குழாயின் ஒரு முனையில் தரவை தொடர்ச்சியாக எழுதவும் மற்றும் குழாயின் மற்றொரு முனையிலிருந்து தரவை அதே வரிசையில் படிக்கவும்.
குழாயிலிருந்து ஏதேனும் செயல்முறை படித்தால், ஆனால் வேறு எந்த செயல்முறையும் குழாயில் இன்னும் எழுதப்படவில்லை என்றால், கோப்பின் இறுதி பதிவுகளைப் படிக்கவும். ஒரு செயல்முறை ஒரு குழாயில் எழுத விரும்பினால், ஆனால் படிப்பதற்கு குழாயுடன் வேறு எந்த செயல்முறையும் இணைக்கப்படவில்லை என்றால், இது ஒரு பிழை நிலை, மற்றும் குழாய் ஒரு SIGPIPE சமிக்ஞையை உருவாக்குகிறது.
தலைப்பு கோப்பு
#சேர்க்கிறதுதொடரியல்
intகுழாய்(intதாக்கல் செய்கிறார்[2])
வாதங்கள்
இந்த செயல்பாடு ஒரு ஒற்றை வாதத்தை எடுக்கும், இரண்டு முழு எண்களின் வரிசை ( தாக்கல் செய்கிறார் ) தாக்கல் செய்யப்பட்டது [0] குழாயிலிருந்து படிக்க பயன்படுத்தப்படுகிறது, மற்றும் தாக்கல் செய்யப்பட்டது [1] குழாயில் எழுதப் பயன்படுகிறது. குழாயிலிருந்து படிக்க விரும்பும் செயல்முறை மூடப்பட வேண்டும் தாக்கல் [1], மற்றும் குழாயில் எழுத விரும்பும் செயல்முறை மூடப்பட வேண்டும் தாக்கல் செய்யப்பட்டது [0] . குழாயின் தேவையற்ற முனைகள் வெளிப்படையாக மூடப்படாவிட்டால், கோப்பின் இறுதி (EOF) ஒருபோதும் திரும்பாது.
திரும்ப மதிப்புகள்
வெற்றி குறித்து, தி குழாய் () 0 ஐத் தருகிறது, தோல்விக்கு செயல்பாடு திரும்பும் -1.
படமாக, நாம் பிரதிநிதித்துவம் செய்யலாம் குழாய் () செயல்பாடு பின்வருமாறு:
சி மொழியில் குழாய் செயல்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதை விவரிக்கும் சில எடுத்துக்காட்டுகள் கீழே உள்ளன.
உதாரணம் 1
இந்த எடுத்துக்காட்டில், குழாய் செயல்பாடு எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம். ஒரு செயல்பாட்டில் ஒரு குழாயைப் பயன்படுத்துவது மிகவும் பயனுள்ளதாக இல்லை என்றாலும், எங்களுக்கு ஒரு யோசனை கிடைக்கும்.
// உதாரணம் 1. சி#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
intஎன்;
intதாக்கல் செய்கிறார்[2];
கரிஇடையகம்[1025];
கரி *செய்தி= 'வணக்கம், உலகம்!';
குழாய்(தாக்கல் செய்கிறார்);
எழுது(தாக்கல் செய்கிறார்[1],செய்தி, strlen (செய்தி));
என்றால் ((என்=படி(தாக்கல் செய்கிறார்[0],இடையகம், 1024 ) ) > = 0) {
இடையகம்[என்] = 0; // சரத்தை நிறுத்தவும்
printf ('குழாயிலிருந்து %d பைட்டுகளைப் படிக்கவும்:'%கள்' n',என்,இடையகம்);
}
வேறு
துரோகம் ('படி');
வெளியேறு (0);
}
இங்கே நாம் முதலில் ஒரு குழாயைப் பயன்படுத்தி உருவாக்கியுள்ளோம் குழாய் () செயல்பாடு பின்னர் குழாயில் எழுதப்பட்டது தந்தம் [1] முடிவு பின்னர், குழாயின் மறுமுனையை பயன்படுத்தி தரவு படிக்கப்பட்டது, அதாவது தாக்கல் செய்யப்பட்டது [0] . கோப்பில் படிப்பதற்கும் எழுதுவதற்கும், நாங்கள் பயன்படுத்தினோம் படி() மற்றும் எழுது () செயல்பாடுகளை
உதாரணம் 2
இந்த எடுத்துக்காட்டில், பெற்றோர் மற்றும் குழந்தை செயல்முறைகள் குழாயைப் பயன்படுத்தி எவ்வாறு தொடர்பு கொள்கின்றன என்பதைப் பார்ப்போம்.
// உதாரணம் 2. சி#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
intதாக்கல் செய்கிறார்[2],nbytes;
pid_t குழந்தை;
கரிலேசான கயிறு[] = 'வணக்கம், உலகம்! n';
கரிவாசிப்பு[80];
குழாய்(தாக்கல் செய்கிறார்);
என்றால்((குழந்தைப்பிள்ளை=முள் கரண்டி()) == -1)
{
துரோகம் ('முள் கரண்டி');
வெளியேறு (1);
}
என்றால்(குழந்தைப்பிள்ளை== 0)
{
நெருக்கமான(தாக்கல் செய்கிறார்[0]);// குழந்தை செயல்முறைக்கு குழாயின் இந்த முடிவு தேவையில்லை
/ * குழாயின் வெளியீடு பக்கத்தின் வழியாக 'சரம்' அனுப்பவும் */
எழுது(தாக்கல் செய்கிறார்[1],லேசான கயிறு, ( strlen (லேசான கயிறு)+1));
வெளியேறு (0);
}
வேறு
{
/ * பெற்றோர் செயல்முறை குழாயின் வெளியீட்டுப் பக்கத்தை மூடுகிறது */
நெருக்கமான(தாக்கல் செய்கிறார்[1]);// பெற்றோர் செயல்முறைக்கு குழாயின் இந்த முடிவு தேவையில்லை
/ * குழாயிலிருந்து ஒரு சரத்தில் வாசிக்கவும் */
nbytes=படி(தாக்கல் செய்கிறார்[0],வாசிப்பு, அளவு(வாசிப்பு));
printf ('சரத்தைப் படிக்கவும்: %s',வாசிப்பு);
}
திரும்ப(0);
}
முதலில், குழாய் செயல்பாட்டைப் பயன்படுத்தி ஒரு குழாய் உருவாக்கப்பட்டது, பின்னர் ஒரு குழந்தை செயல்முறை முட்கரண்டி செய்யப்பட்டது. பின்னர், குழந்தை செயல்முறை வாசிப்பு முடிவை மூடி, குழாய்க்கு எழுதுகிறது. பெற்றோர் செயல்முறை எழுதும் முடிவை மூடி, குழாயிலிருந்து படித்து அதை காட்டுகிறது. இங்கே தரவு ஓட்டம் என்பது குழந்தையிலிருந்து பெற்றோருக்கு இருக்கும் ஒரே ஒரு வழி.
முடிவுரை:
குழாய் () லினக்ஸில் ஒரு சக்திவாய்ந்த கணினி அழைப்பு. இந்த கட்டுரையில், ஒரு வழி தரவு ஓட்டத்தை மட்டுமே நாம் பார்த்திருக்கிறோம், ஒரு செயல்முறை எழுதுகிறது, மற்றொரு செயல்முறை படிக்கிறது, இரண்டு குழாய்களை உருவாக்கி நாம் இரு திசை தரவு ஓட்டத்தையும் அடைய முடியும்.