இன் தொடரியல் குழாய் () செயல்பாடு:
intகுழாய்(intகுழாய்[2]);
இங்கே, குழாய் () செயல்பாடு இடை-செயல்முறை தொடர்புக்கு ஒரு திசை தரவு சேனலை உருவாக்குகிறது. நீங்கள் ஒரு தேர்ச்சி int (முழு எண்) வகை வரிசை குழாய் செயல்பாட்டு குழாய் () க்கு 2 வரிசை உறுப்பு கொண்டது. பின்னர் குழாய் () செயல்பாடு இரண்டு கோப்பு விளக்கங்களை உருவாக்குகிறது குழாய் வரிசை.
முதல் உறுப்பு குழாய் வரிசை, பைப்எஃப்டி [0] குழாயிலிருந்து தரவைப் படிக்க பயன்படுகிறது.
இரண்டாவது உறுப்பு குழாய் வரிசை, பைப்எஃப்டி [1] குழாயில் தரவை எழுத பயன்படுகிறது.
வெற்றியில், குழாய் () செயல்பாடு திரும்பும்
குழாய் () செயல்பாடு தலைப்பில் வரையறுக்கப்பட்டுள்ளது unistd.h . உங்கள் சி நிரலில் குழாய் () செயல்பாட்டைப் பயன்படுத்த, நீங்கள் தலைப்பை சேர்க்க வேண்டும் unistd.h பின்வருமாறு:
#சேர்க்கிறது
குழாய் () கணினி செயல்பாடு பற்றிய கூடுதல் தகவலுக்கு, பின்வரும் கட்டளையுடன் குழாயின் மேன் பக்கத்தை () சரிபார்க்கவும்:
$ மனிதன்2குழாய்குழாயின் மனிதர் பக்கம்().
எடுத்துக்காட்டு 1:
முதல் எடுத்துக்காட்டுக்கு, புதிய சி மூலக் கோப்பை உருவாக்கவும் 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 ('PIN ஐ குழாயில் எழுதுதல் ... 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 pid=முள் கரண்டி();
என்றால்(பிட்== 0) { // குழந்தை செயல்பாட்டில்
முள்= '4821 0'; // அனுப்ப வேண்டிய PIN
நெருக்கமான(குழாய்கள்[0]); // fd ஐ நெருக்கமாக வாசிக்கவும்
எழுது(குழாய்கள்[1],முள், 5); // குழாய்க்கு PIN எழுதவும்
printf (குழந்தைக்கு PIN ஐ உருவாக்கி பெற்றோருக்கு அனுப்புதல் ... n');
தூங்கு(2); // வேண்டுமென்றே தாமதம்
வெளியேறு (EXIT_SUCCESS);
}
என்றால்(பிட்> 0) { // முக்கிய செயல்பாட்டில்
காத்திரு(ஏதுமில்லை); // குழந்தை செயல்முறை முடிவடையும் வரை காத்திருங்கள்
நெருக்கமான(குழாய்கள்[1]); // fd ஐ மூடு
படி(குழாய்கள்[0],இடையகம், 5); // குழாயிலிருந்து பின்னைப் படிக்கவும்
நெருக்கமான(குழாய்கள்[0]); // fd ஐ நெருக்கமாக வாசிக்கவும்
printf ('பெற்றோர் PIN'%s 'பெற்றனர் n',இடையகம்);
}
திரும்பEXIT_SUCCESS;
}
இந்த எடுத்துக்காட்டில், இடை-செயல்முறை தொடர்புக்கு குழாயை எவ்வாறு பயன்படுத்துவது என்பதை நான் உங்களுக்குக் காட்டினேன். நான் குழாய் பயன்படுத்தி குழந்தை செயல்முறை இருந்து பெற்றோர் செயல்முறைக்கு ஒரு PIN அனுப்பியுள்ளேன். பெற்றோர் செயல்பாட்டில் உள்ள குழாயிலிருந்து பின்னைப் படித்து, பெற்றோர் செயல்முறையிலிருந்து அச்சிடவும்.
முதலில், நான் ஃபோர்க் () செயல்பாட்டைப் பயன்படுத்தி ஒரு குழந்தை செயல்முறையை உருவாக்கியுள்ளேன்.
pid_t pid=முள் கரண்டி();பின்னர், குழந்தை செயல்பாட்டில் ( பிட் == 0 ), நான் குழாயைப் பயன்படுத்தி PIN ஐ எழுதினேன் எழுது () செயல்பாடு
எழுது(குழாய்கள்[1],முள், 5);குழந்தை செயல்பாட்டிலிருந்து குழாய்க்கு PIN எழுதப்பட்டவுடன், பெற்றோர் செயல்முறை ( pid> 0 ) அதை பயன்படுத்தி குழாயிலிருந்து படிக்கவும் படி() செயல்பாடு
படி(குழாய்கள்[0],இடையகம், 5);பின்னர், பெற்றோர் செயல்முறை பின்னைப் பயன்படுத்தி அச்சிடப்பட்டது printf () வழக்கம் போல் செயல்படும்.
printf ('பெற்றோர் PIN'%s 'பெற்றனர் n',இடையகம்);நீங்கள் பார்க்க முடியும் என, நிரலை இயக்குவது எதிர்பார்த்த முடிவை அளிக்கிறது.
எடுத்துக்காட்டு 4:
புதிய சி மூலக் கோப்பை உருவாக்கவும் 4_pipe.c குறியீடுகளின் பின்வரும் வரிகளில் தட்டச்சு செய்க.
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#PIN_LENGTH ஐ வரையறுக்கவும் 4
#PIN_WAIT_INTERVAL 2 ஐ வரையறுக்கவும்
வெற்றிடம்getPIN(கரிமுள்[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
முள்[0] = 49 + வரிசை () % 7;
க்கான(intநான்= 1;நான்<PIN_LENGTH;நான்++) {
முள்[நான்] = 48 + வரிசை () % 7;
}
முள்[PIN_LENGTH] = ' 0';
}
intமுக்கிய(வெற்றிடம்) {
போது(1) {
intகுழாய்கள்[2];
கரிமுள்[PIN_LENGTH+ 1];
கரிஇடையகம்[PIN_LENGTH+ 1];
குழாய்(குழாய்கள்);
pid_t pid=முள் கரண்டி();
என்றால்(பிட்== 0) {
getPIN(முள்); // PIN ஐ உருவாக்கவும்
நெருக்கமான(குழாய்கள்[0]); // fd ஐ நெருக்கமாக வாசிக்கவும்
எழுது(குழாய்கள்[1],முள்,PIN_LENGTH+ 1); // குழாய்க்கு PIN எழுதவும்
printf (குழந்தைக்கு PIN ஐ உருவாக்கி பெற்றோருக்கு அனுப்புதல் ... n');
தூங்கு(PIN_WAIT_INTERVAL); // PIN தலைமுறை வேண்டுமென்றே தாமதமாகும்.
வெளியேறு (EXIT_SUCCESS);
}
என்றால்(பிட்> 0) {
காத்திரு(ஏதுமில்லை); // குழந்தை முடியும் வரை காத்திருக்கிறேன்
நெருக்கமான(குழாய்கள்[1]); // fd ஐ மூடு
படி(குழாய்கள்[0],இடையகம்,PIN_LENGTH+ 1); // குழாயிலிருந்து பின்னைப் படிக்கவும்
நெருக்கமான(குழாய்கள்[0]); // fd ஐ நெருக்கமாக வாசிக்கவும்
printf ('பெற்றோர் குழந்தையிலிருந்து PIN'%s 'பெற்றனர். n n',இடையகம்);
}
}
திரும்பEXIT_SUCCESS;
}
இந்த உதாரணம் ஒன்றே உதாரணம் 3 . ஒரே ஒரு வித்தியாசம் என்னவென்றால், இந்தத் திட்டம் தொடர்ச்சியாக ஒரு குழந்தை செயல்முறையை உருவாக்குகிறது, குழந்தை செயல்பாட்டில் ஒரு PIN ஐ உருவாக்குகிறது மற்றும் ஒரு குழாயைப் பயன்படுத்தி பெற்றோர் செயல்முறைக்கு PIN ஐ அனுப்புகிறது.
பெற்றோர் செயல்முறை பின்னர் குழாயிலிருந்து PIN ஐப் படித்து அதை அச்சிடுகிறது.
இந்த திட்டம் ஒவ்வொரு PIN_WAIT_INTERVAL வினாடிக்கும் ஒரு புதிய PIN_LENGTH பின்னை உருவாக்குகிறது.
நீங்கள் பார்க்க முடியும் என, திட்டம் எதிர்பார்த்தபடி வேலை செய்கிறது.
அழுத்துவதன் மூலம் மட்டுமே நீங்கள் நிரலை நிறுத்த முடியும் + சி .
எனவே, சி நிரலாக்க மொழியில் நீங்கள் குழாய் () கணினி அழைப்பை எவ்வாறு பயன்படுத்துகிறீர்கள். இந்தக் கட்டுரையைப் படித்ததற்கு நன்றி.