Bibliothèque standard C -<signal.h>

Introduction

<signal.h>Il s'agit d'un fichier d'en-tête de la bibliothèque standard C utilisé pour gérer les signaux.

signal.hLe fichier d'en-tête définit un type de variablesig_atomic_tdeux appels de fonction, et des macros pour gérer différents signaux signalés pendant l'exécution du programme.

Un signal est un mécanisme de notification asynchrone qui permet à un processus d'exécuter une fonction de gestionnaire prédéfinie lorsqu'un événement spécifique se produit.

Voici un exemple simple de programme montrant comment utiliser la fonction signal pour intercepter le signal SIGINT (généralement généré par Ctrl+C).

Exemple

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// Variable globale indiquant si le programme doit quitter
volatile sig_atomic_t stop = 0;

void handle_sigint(int sig) {
printf("Signal intercepté %d\n", sig);
stop = 1; // Définir l'indicateur de sortie
}

int main() {
// Définir le gestionnaire du signal SIGINT sur la fonction handle_sigint
signal(SIGINT, handle_sigint);

while (!stop) { // Vérifier s'il faut quitter
printf("En cours d'exécution...\n");
sleep(1);
}

printf("Sortie...\n");

return 0;
}

Dans le code ci-dessus, lorsque le programme s'exécute, si l'utilisateur appuie surCtrl+C, il intercepte le signal SIGINT et appelle la fonction handle_sigint, en affichant le numéro du signal.

Compilez et exécutez le code ci-dessus, la sortie est la suivante :

Running...
Running...
Running...
^CCaught signal 2
Exiting...

Analyse du code :

volatile sig_atomic_t stop = 0;: définir une variable globalestop, utilisé pour indiquer si le programme doit se terminer. En utilisantvolatilele mot-clé garantit que le compilateur ne supprimera pas par optimisation les accès à cette variable, car elle peut être modifiée dans un gestionnaire de signal.sig_atomic_tLe type garantit que les accès à cette variable sont atomiques.
Danshandle_sigintDans la fonction de gestionnaire de signal, définissezstopà 1, ce qui indique que le programme doit se terminer.
Dans la boucle principale, vérifiezstopla valeur de la variable ; si elle est définie à 1, sortez de la boucle et terminez le programme.

Variables de la bibliothèque

Les types de variables suivants sont définis dans le fichier d'en-tête signal.h :

Numéro de série	Variables et description
1	sig_atomic_t Ceci estinttype, utilisé comme variable dans les gestionnaires de signaux. C'est un type entier pour un objet accessible comme une entité atomique même en présence de signaux asynchrones.
2	sigset_t Un type de données utilisé pour représenter un ensemble de signaux.

Macros de bibliothèque

Dans la bibliothèque standard C,SIG_Macros préfixées etsignalUtilisé avec des fonctions pour définir et gérer le comportement des signaux. Les suivantes sont courantesSIG_Macros et leurs utilisations :

Numéro de série	Macros & Description
1	SIG_DFL Représente le gestionnaire par défaut d'un signal. Utilisez cette macro pour restaurer le comportement par défaut d'un signal.
2	SIG_ERR Représente la valeur de retour lorsqu'une erreur se produit lors de la définition d'une fonction de gestionnaire de signal.
3	SIG_IGN Ignorer le signal.

Types de signaux :

Constantes	Description
`SIGABRT`	par`abort`Le signal généré par la fonction, indiquant une terminaison anormale
`SIGALRM`	par`alarm`Le signal d'expiration du minuteur défini par la fonction
`SIGBUS`	Accès mémoire illégal (par exemple, accès à une adresse mémoire non alignée)
`SIGCHLD`	L'état du processus enfant a changé (terminé ou arrêté)
`SIGCONT`	Continuer l'exécution d'un processus suspendu
`SIGFPE`	Erreurs arithmétiques (par exemple, division par zéro, exceptions de virgule flottante)
`SIGHUP`	Signal de raccrochage (généralement utilisé pour détecter une déconnexion du terminal)
`SIGILL`	Instruction illégale
`SIGINT`	Signal d'interruption (généralement généré par Ctrl+C)
`SIGKILL`	Signal de terminaison immédiate (ne peut pas être capturé ni ignoré)
`SIGPIPE`	Écrire des données dans un pipe sans processus de lecture
`SIGQUIT`	Signal d'arrêt du terminal (généralement généré par Ctrl+\), produit un vidage de mémoire
`SIGSEGV`	Erreur de segmentation (accès mémoire illégal)
`SIGSTOP`	Arrête l'exécution du processus (ne peut être capturé ni ignoré)
`SIGTERM`	Signal de terminaison
`SIGTSTP`	Suspend le processus (généralement généré par Ctrl+Z)
`SIGTTIN`	Signal généré lorsqu'un processus en arrière-plan lit des données depuis le terminal
`SIGTTOU`	Signal généré lorsqu'un processus en arrière-plan écrit des données sur le terminal
`SIGUSR1`	Signal défini par l'utilisateur 1
`SIGUSR2`	Signal défini par l'utilisateur 2
`SIGPOLL`	Événement d'E/S (remplace SIGIO)
`SIGPROF`	Signal d'expiration du minuteur (par`setitimer`le minuteur de profilage défini)
`SIGSYS`	Appel système illégal
`SIGTRAP`	Instruction de point d'arrêt ou de piège
`SIGURG`	Signal de condition urgente de socket
`SIGVTALRM`	Signal d'expiration du minuteur d'horloge virtuelle
`SIGXCPU`	Limite de temps CPU dépassée
`SIGXFSZ`	Limite de taille de fichier dépassée

Fonctions de bibliothèque

Les fonctions suivantes sont définies dans le fichier d'en-tête signal.h :

Fonction	Description
`void (signal(int sig, void (func)(int)))(int);`	Définir le gestionnaire de signal.
`int raise(int sig);`	Envoyer un signal au processus courant.
`int kill(pid_t pid, int sig);`	Envoyer un signal au processus spécifié.
`int sigprocmask(int how, const sigset_t set, sigset_t oldset);`	Vérifier ou modifier l'ensemble des signaux bloqués.
`int sigaction(int sig, const struct sigaction act, struct sigaction oldact);`	Vérifier ou modifier le gestionnaire de signal.
`int sigsuspend(const sigset_t *mask);`	Remplacer temporairement le masque de signaux actuel et suspendre le processus jusqu'à ce qu'un signal soit capté.
`int sigpending(sigset_t *set);`	Vérifier l'ensemble des signaux en attente.
`int sigemptyset(sigset_t *set);`	Initialiser l'ensemble de signaux à un ensemble vide.
`int sigfillset(sigset_t *set);`	Initialiser l'ensemble de signaux à l'ensemble complet des signaux.
`int sigaddset(sigset_t *set, int signum);`	Ajouter le signal spécifié à l'ensemble de signaux.
`int sigdelset(sigset_t *set, int signum);`	Supprimer le signal spécifié de l'ensemble de signaux.
`int sigismember(const sigset_t *set, int signum);`	Vérifier si le signal spécifié se trouve dans l'ensemble de signaux.
`void abort(void);`	raise`SIGABRT`Le signal provoque une terminaison anormale du processus.
`unsigned int alarm(unsigned int seconds);`	Après le nombre de secondes spécifié, envoyer`SIGALRM`signal au processus appelant.
`int pause(void);`	Suspendre le processus jusqu'à ce qu'un signal soit capté.
`void psignal(int sig, const char *s);`	Afficher les informations de description du signal.
`char *strsignal(int sig);`	Retourner la chaîne de description du signal.
`int sigwait(const sigset_t set, int sig);`	Bloquer en attendant un signal et le gérer.

autres extensions

C Bibliothèque standard