Comment puis-je déterminer la valeur maximale d’un pid_t?

Comment puis-je déterminer la valeur maximale du type pid_t ? Il n’y a pas de PID_MAX constant sur mon système.

(Remarque: la valeur maximale autorisée par le type de données, et non la valeur maximale de facto que le système atsortingbue aux processus.)

Cas d’utilisation: Je convertis une spécification de chaîne fournie par l’utilisateur d’un pid en pid_t et pid_t veux m’assurer que l’entrée de l’utilisateur ne dépasse pas la capacité du type.

POSIX (2008) dit :

blksize_t, pid_t et ssize_t doivent être des types entiers signés.

Et:

L’implémentation doit prendre en charge un ou plusieurs environnements de programmation dans lesquels les largeurs de blksize_t, pid_t, size_t, ssize_t et suseconds_t ne sont pas supérieures à la longueur du type long.

Ainsi, vous pouvez convertir les chaînes utilisateur en long , puis vérifier le débordement du type pid_t à l’aide de long pid; .. pid == (pid_t)pid long pid; .. pid == (pid_t)pid .

Ce que j’ai parfois fait dans le passé est utilisé avec un type de données plus important, puis, lorsque je convertis mon type plus petit, reconvertis-le immédiatement au type plus grand et vérifie que la valeur n’a pas changé.

Par exemple, disons que vous avez plutôt utilisé un int64_t, alors vous pourriez avoir quelque chose comme:

 int64_t my_pid64; /* ... parse ssortingng value into my_pid64 ... */ pid_t my_pid = (pid_t) my_pid64; if ((int64_t) my_pid != my_pid64) /* check that value was not out of range of pid_t */ { /* ... handle error ... */ } 

Il n’y a pas de grande option pour le plus grand type de données à utiliser. “long” était le plus grand type de données entier primitif mais ce n’est plus le cas sur certains compilateurs / architectures courants, même pour Linux (voir les commentaires ci-dessous). Pendant ce temps, le type intmax_t prend peu en charge la bibliothèque. Le résultat est que int64_t est parfois plus utile dans la pratique.

Mais, fondamentalement, vos options pour un plus grand type de données sont probablement longues, int64_t et intmax_t.

La réponse de Steven est une bonne approche.

Mais si vous voulez vraiment déterminer la valeur max pid_t sans compter sur un comportement non défini, je pense que votre meilleur pari est:

 #include  #include  #include  static inline pid_t get_max_pid_t() { if (sizeof(pid_t) == sizeof(short)) return SHRT_MAX; if (sizeof(pid_t) == sizeof(int)) return INT_MAX; if (sizeof(pid_t) == sizeof(long)) return LONG_MAX; #if defined(LLONG_MAX) // C99 if (sizeof(pid_t) == sizeof(long long)) return LLONG_MAX; #endif abort(); } 

POSIX garantit que pid_t est un type intégral signé. Ce code suppose que la taille d’un type intégral signé détermine de manière unique ce type. Je pense que c’est une excellente hypothèse, mais je ne suis pas sûr que la norme le garantisse.

Tout compilateur décent va incorporer et propager constamment tout cela dans la non-existence, donc la performance n’est pas un problème.

(À part: En C ++, vous std::numeric_limits::max() et en std::numeric_limits::max() avec.)

Dans l’un de vos en-têtes:

 #ifndef PID_MAX #define PID_MAX INT_MAX // or whatever value you see fit #endif 

Vous pouvez également le faire en fonction de la définition du serveur / du système d’exploitation en fonction des variables d’environnement.

Look: Post similaire: PID maximum sous Linux