Paip adalah media untuk komunikasi antara proses. Satu proses menulis data ke paip, dan proses lain membaca data dari paip. Dalam artikel ini, kita akan melihat bagaimana fungsi paip () digunakan untuk menerapkan konsep menggunakan bahasa C.
Mengenai Paip
Di dalam paip, data disimpan dalam urutan FIFO, yang bermaksud menulis data ke satu hujung paip secara berurutan dan membaca data dari hujung paip yang lain dalam urutan yang sama.
Sekiranya ada proses yang dibaca dari paip, tetapi belum ada proses lain yang belum ditulis ke paip, maka baca mengembalikan akhir fail. Sekiranya proses ingin menulis ke paip, tetapi tidak ada proses lain yang dilekatkan pada paip untuk dibaca, maka ini adalah keadaan ralat, dan paip menghasilkan isyarat SIGPIPE.
Fail Tajuk
#sertakanSintaks
intpaip(intdifailkan[2])
Hujah
Fungsi ini mengambil satu argumen, susunan dua bilangan bulat ( difailkan ). difailkan [0] digunakan untuk membaca dari paip, dan difailkan [1] digunakan untuk menulis ke paip. Proses yang ingin dibaca dari paip harus ditutup difailkan [1], dan proses yang ingin ditulis ke paip harus ditutup difailkan [0] . Sekiranya hujung paip yang tidak diperlukan tidak ditutup secara eksplisit, maka fail akhir (EOF) tidak akan dikembalikan.
Nilai pulangan
Pada kejayaan, paip () mengembalikan 0, kerana kegagalan fungsi kembali -1.
Secara bergambar, kita boleh mewakili paip () berfungsi seperti berikut:
Berikut adalah beberapa contoh yang menggambarkan cara menggunakan fungsi paip dalam bahasa C.
Contoh1
Dalam contoh ini, kita akan melihat bagaimana fungsi paip berfungsi. Walaupun menggunakan paip dalam satu proses tidak begitu berguna, tetapi kita akan mendapat idea.
// Contoh1.c#sertakan
#sertakan
#sertakan
#sertakan
intutama()
{
intn;
intdifailkan[2];
charpenyangga[1025];
char *mesej= 'Hai dunia!';
paip(difailkan);
tulis(difailkan[1],mesej, strlen (mesej));
sekiranya ((n=membaca(difailkan[0],penyangga, 1024 ) ) > = 0) {
penyangga[n] = 0; // tamatkan rentetan
printf ('baca% d bait dari paip:'%s' n',n,penyangga);
}
yang lain
kesalahan ('baca');
jalan keluar (0);
}
Di sini kita pertama kali membuat paip menggunakan paip () berfungsi kemudian ditulis ke paip menggunakan gading [1] akhir. Kemudian, data telah dibaca menggunakan hujung paip yang lain, iaitu difailkan [0] . Untuk membaca dan menulis ke fail, kami biasa baca () dan tulis () fungsi.
Contoh2
Dalam contoh ini, kita akan melihat bagaimana proses ibu bapa dan anak berkomunikasi menggunakan paip.
// Contoh2.c#sertakan
#sertakan
#sertakan
#sertakan
#sertakan
intutama()
{
intdifailkan[2],nbytes;
pid_t kanak-kanak;
chartali[] = 'Hai dunia! n';
charpembaca baca[80];
paip(difailkan);
sekiranya((kanak-kanak=garpu()) == -1)
{
kesalahan ('garpu');
jalan keluar (1);
}
sekiranya(kanak-kanak== 0)
{
tutup(difailkan[0]);// Proses kanak-kanak tidak memerlukan hujung paip ini
/ * Kirim 'string' melalui bahagian output paip * /
tulis(difailkan[1],tali, ( strlen (tali)+1));
jalan keluar (0);
}
yang lain
{
/ * Proses ibu bapa menutup bahagian output paip * /
tutup(difailkan[1]);// Proses ibu bapa tidak memerlukan hujung paip ini
/ * Baca dalam rentetan dari paip * /
nbytes=membaca(difailkan[0],pembaca baca, saiz(pembaca baca));
printf ('Baca rentetan:% s',pembaca baca);
}
kembali(0);
}
Pertama, satu paip telah dibuat menggunakan fungsi paip kemudian proses kanak-kanak telah dibentuk. Kemudian, proses anak menutup akhir membaca dan menulis ke paip. Proses induk menutup akhir menulis dan membaca dari paip dan memaparkannya. Di sini aliran data hanya satu cara iaitu dari anak ke ibu bapa.
Kesimpulan:
paip () adalah panggilan sistem yang kuat di Linux. Dalam artikel ini, kita hanya melihat aliran data sehala, satu proses menulis, dan proses lain berbunyi, membuat dua saluran yang kita dapat mencapai aliran data dua arah juga.