Come convertire in modo portabile una stringa in un tipo intero non comune?
Domanda
Alcuni retroscena: se volessi usare, ad esempio, scanf()
per convertire una stringa in un tipo intero standard, come uint16_t
, I & # 8217; d usa SCNu16
da <inttypes.h>
, in questo modo:
#include <stdio.h>
#include <inttypes.h>
uint16_t x;
char *xs = "17";
sscanf(xs, "%" SCNu16, &x);
Ma un tipo intero più insolito come pid_t
non ha nulla del genere; solo i tipi interi normali sono supportati da printf()
. Per convertire l'altro modo, in intmax_t
a PRIdMAX
, posso lanciarlo in <=> e usare <=>, in questo modo:
#include <stdio.h>
#include <inttypes.h>
#include <sys/types.h>
pid_t x = 17;
printf("%" PRIdMAX, (intmax_t)x);
Tuttavia, non sembra esserci un modo per portare <=> in un <=>. Quindi questa è la mia domanda: come farlo in modo portabile?
#include <stdio.h>
#include <sys/types.h>
pid_t x;
char *xs = 17;
sscanf(xs, "%u", &x); /* Not portable! pid_t might not be int! /*
Ho pensato di <=> passare a un <=> e quindi verificare che il valore rientri nei limiti di <=> & # 8217; s prima di eseguire il casting su <=>, ma non sembra esserci un modo per ottenere i valori massimo o minimo per <=>.
Soluzione
Esiste una soluzione solida e portatile, che consiste nell'utilizzare strtoimax()
e verificare la presenza di overflow.
Cioè, analizzo un intmax_t
, cerco un errore da pid_t
, e poi vedo anche se " si adatta " in scanf()
lanciandolo e confrontandolo con il valore strtoll()
originale.
#include <inttypes.h>
#include <stdio.h>
#include <iso646.h>
#include <sys/types.h>
char *xs = "17"; /* The string to convert */
intmax_t xmax;
char *tmp;
pid_t x; /* Target variable */
errno = 0;
xmax = strtoimax(xs, &tmp, 10);
if(errno != 0 or tmp == xs or *tmp != '\0'
or xmax != (pid_t)xmax){
fprintf(stderr, "Bad PID!\n");
} else {
x = (pid_t)xmax;
...
}
Non è possibile utilizzare <=>, perché, (come ho detto in un commento) <=> non rileveranno overflow . Ma ho sbagliato a dire che nessuna delle funzioni relative a <=> accetta un <=>; <=> lo fa!
Inoltre, non funzionerà per utilizzare nient'altro che <=> a meno che non si conosca la dimensione del tipo intero (<=>, in questo caso).
Altri suggerimenti
Dipende esattamente da quanto portatile vuoi essere. POSIX afferma che pid_t
è un tipo intero con segno utilizzato per memorizzare gli ID di processo e gli ID gruppo di processi. In pratica, puoi presumere con sicurezza che long
sia abbastanza grande. In caso contrario, il tuo intmax_t
deve essere abbastanza grande (quindi accetterà qualsiasi <inttypes.h>
valido); il problema è che quel tipo potrebbe accettare valori non legittimi in <unistd.h>
. Sei bloccato tra una roccia e un luogo difficile.
Userei <sys/types.h>
e non mi preoccuperei molto, tranne per un oscuro commento da qualche parte che un archeologo di software di 100 anni quindi troverà e osserverà un motivo per cui la CPU a 256 bit si ferma scricchiolando quando viene consegnata un valore di 512 bit come <=>.
POSIX 1003.1-2008 è ora disponibile sul Web (tutti 3872 pagine di esso, in PDF e HTML). Devi registrarti (gratuitamente). Ci sono arrivato dal Open Group Bookstore .
Tutto quello che vedo lì è che deve essere un tipo intero con segno. Chiaramente, tutti i valori interi con segno validi si adattano a <=>. Non riesco a trovare alcuna informazione in <=> o <=> che indichi PID_T_MAX o PID_T_MIN o altri valori simili (ma solo stasera ho avuto accesso ad esso, quindi potrebbe essere nascosto dove non l'ho cercato) . OTOH, sostengo il mio commento originale - credo che i valori a 32 bit siano pragmaticamente adeguati e utilizzerei comunque <=>, che sarebbe 64-bit su macchine a 8 bit. Suppongo che all'incirca la cosa peggiore che possa accadere sia che un processo "opportunamente privilegiato" legga un valore troppo grande e invii un segnale al processo sbagliato a causa di una mancata corrispondenza dei tipi. Non sono convinto che sarei preoccupato per questo.
... oooh! ... p400 in <=>
L'implementazione deve supportare uno o più ambienti di programmazione in cui le larghezze di blksize_t, pid_t, size_t, ssize_t e suseconds_t non sono maggiori della larghezza del tipo long.
Se sei veramente preoccupato puoi _assert(sizeof(pid_t) <= long)
o qualunque tipo tu scelga per le tue cose '%'.
Come spiegato in questa risposta , la specifica dice signed int
. Se 'int' cambia, il tuo '% u' per definizione cambia con esso.