Come convertire in modo portabile una stringa in un tipo intero non comune?

Question

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 <=>.

Answer 1

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).

Answer 2

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.

Answer 3

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.