Newsgroup: it.comp.programmare
Titolo: Signal e Kill

Considerate questo esercizio:
 
Scrivere un programma che attivi un figlio che prima di terminare si
metta in attesa di un segnale (ad es. SIGUSR1) proveniente dal
processo padre. Scrivere il codice del processo figlio e della funzione
che dovr� gestire il segnale in un file diverso.
 
 
 
Io ho provato, scrivendo questi due codici.
 
Il padre:
 
#include <unistd.h>
#include<stdio.h>
#include<signal.h>
 
int main()
{
int status;
int pid=fork();
if (pid==-1) { perror("fork"); _exit (1);}
if (pid==0) {
execl("/home/massimo/figlio","figlio",(char *) 0);
}
 
else {
  sleep(2); //cos� da essere sicuro che lanci kill dopo
            //che il figlio ha settato la nuova "isr"
  kill(pid, SIGUSR2); int a=wait(&status);
  }
}
 
 
Il figlio:
 
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
 
void gestione(int n){printf("Funzione di gestione del segnale n: %d\n",n);}
 
int main(){
 
signal(SIGUSR2,gestione);
if (pause()==-1) {perror("Pause"); exit (1);}
return 0;
}
 
 
 
 
 
 
Ovviamente ho compilato il secondo codice col nome "figlio" nella 
directory di esecuzione del padre.

 directory di esecuzione del padre.
 
 
 
Dimenticato l'output:
 
Funzione di gestione del segnale n: 12
Pause: Interrupted system call
 
 
 
 
altro dubbio: come si passa il parametro alla funzione indicata in 
signal? Non facciamo una normale chiamata a funzione, ma passiamo solo 
il puntatore...
 
 
 
 
 


 
Proprio a livello semantico i segnali servono solo come.. segnali :) non
per fare IPC. Se vuoi comunicare cose la filosofia unix prevede pipes e
sockets, a seconda del caso.
 
Ciao!

 sockets, a seconda del caso.
 
Mi riferisco al parametro "int n" che pu� essere usato dalla funzione 
passata a signal per gestire pi� segnali e non usare una funzione 
diversa per ogni segnale.
 
 


Quel parametro sarà settato con il numero di segnale che ha fatto scattare
la callback (perché puoi registrare la sessa callback per più segnali).
Non è infrequente fare signal() sulla stessa funzione, dentro la quale
fai uno switch (o if in cascata) per i vari casi.
 
Ciao!

 la callback (perché puoi registrare la sessa callback per più segnali).
 
Si, si, questo l'avevo capito.
Quello che non sapevo è che è signalche automaticamente ci mette quel 
parametro e non noi :-)
E' un tipo di chiamata a funzione che non avevo mai visto: una funzione 
che richiama un'altra funzione e gli passa lei il parametro.
 
Grazie di tutto!
 
 


Anche questa è una roba più che comune, eh.. per capirci:
 
int sum(int a, int b) { return a+b; }
int sub(int a, int b) { return a-b; }
void print_func(int(*f)(int,int), int a, int b)
{
    printf("%d\n", f(a, b));
}
 
int main(void)
{
    print_func(sum, 5, 3);
    print_func(sub, 5, 3);
    return 0;
}
 
Ne farai a milioni...
 
Ciao!

 void print_func(int(*f)(int,int), int a, int b)
 
qua capire la sintassi � dura per me :-(


Cio� ho capito dal contesto, ma � dura comunque, allora vediamo:
 
int(*f)(int,int)
 
Il parametro � un puntatore a funzione che accetta due parametri interi
 
Quindi il nome di una funzione � un puntatore, giusto?
Come il nome degli oggetti in Java...


it.comp.lang.c :)
 
Comunque sì, è un puntatore a funzione.
 
Ciao!

 Come il nome degli oggetti in Java...
 
 
No, una variabile (temporanea o no) punta ad una istanza di un oggetto, 
non è l' oggetto stesso (cosi è in java ed in C++)
 
 

 non è l' oggetto stesso (cosi è in java ed in C++)
 
Non son proprio convinto, sai? Anzi..
In C assegnare un puntatore a funzione significa scrivere l'indirizzo in
memoria della funzione; non c'è alcuno stato, per cui come nomenclatura
direi che punti all'oggetto, non all'istanza.
 
Non che abbia molto senso la discussione in ogni caso, è giusto che ho letto
ora e ci sto pensando mentre scrivo.. :/ Magari mi correggo da solo tra
cinque minuti..
 
Ciao!

 
 
Ok, sì, mi son convinto :)
La definizione di una funzione è un'oggetto, un'istanza di una funzione
potrebbe essere ad esempio una funzione parzialmente applicata.
In C 'sta cosa non si può fare (c'ho pensato pure troppo senza arrivare a
nulla) per cui, al contrario di quasi tutti i linguaggi fuzionali dove invece
si può, direi che in C sì, punta all'oggetto :D
 
(si vede che non c'ho voglia di lavorare oggi, eh?)
 
Ciao!


In C e C++ una funzione non è un oggetto, è solo un puntatore
Un oggetto è l' istanza di una struct  o di una class ed il suo 
indirizzo sta in un puntatore
La differenza è che per un oggetto occorre crearne l' istanza (con new o 
malloc) e poi distruggerla (con delete o free) quando non serve più
Per una funzione non si crea nessuna istanza, si prende il suo indirizzo 
e basta
 
 
 
 


 
Ok, correggiti
 

 e basta
 
Ma sì, infatti, è solo questione di dare i nomi alle cose..
Avevo scritto così perché, mutuando da altri linguaggi, viene IMO più
naturale.
Poi alla fine l'importante è che l'OP abbia capito come funziona, il fatto
che noi lo sappiamo non gli serve a molto :)
 
Ciao!

 Ok, correggiti
 
Più o meno fatto, nell'altro ramo.
 
Ciao!

 Prova a compilare ;)
 
 
Non serve, ho fatto un refuso
