Quali sono le migliori pratiche relative agli ints non firmati?

Uso ints ovunque non firmati e non sono sicuro che dovrei. Questo può essere dalle colonne ID chiave primaria del database ai contatori, ecc. Se un numero non deve mai essere negativo, userò sempre un int senza segno.

Tuttavia noto dal codice di altri che nessun altro sembra farlo. C'è qualcosa di cruciale che sto trascurando?

Modifica: da questa domanda ho anche notato che in C, la restituzione di valori negativi per errori è all'ordine del giorno piuttosto che generare eccezioni come in C ++.

C'è qualcosa di cruciale che sto trascurando?

Quando i calcoli coinvolgono sia tipi firmati e non firmati che dimensioni diverse, le regole per la promozione dei tipi possono essere complesse e comportare comportamenti imprevisti .

Credo che questo sia il motivo principale per cui Java ha omesso i tipi int senza segno.

Penso che Michael abbia un punto valido, ma IMO il motivo per cui tutti usano int continuamente (specialmente in for (int i = 0; i < max, i++) è che l'abbiamo imparato in quel modo. Quando ogni singolo esempio in un libro " come imparare a programmare " viene utilizzato intin un forciclo, pochissimi metteranno mai in discussione questa pratica.

L'altra ragione è che intè più corta del 25% rispetto a uint, e siamo tutti pigri ... ;-)

La codifica delle informazioni sull'intervallo in tipi è una buona cosa. Fa rispettare l'uso di numeri ragionevoli al momento della compilazione.

Molte architetture sembrano avere istruzioni specializzate per gestire int-> floatconversioni. La conversione da unsignedpuò essere più lenta (un pochino) .

Mescolare tipi firmati e non firmati può farti entrare in un mondo di dolore. E non puoi usare tutti i tipi senza segno perché incontrerai cose che hanno un intervallo valido che include numeri negativi o hai bisogno di un valore per indicare un errore e -1 è più naturale. Quindi il risultato netto è che molti programmatori usano tutti i tipi di numeri interi con segno.

Per me i tipi riguardano molto la comunicazione. Usando esplicitamente un int senza segno mi dici che i valori con segno non sono valori validi. Questo mi consente di aggiungere alcune informazioni durante la lettura del codice oltre al nome della variabile. Idealmente, un tipo non anonimo mi direbbe di più, ma mi dà più informazioni che se avessi usato ints ovunque.

Sfortunatamente non tutti sono molto consapevoli di ciò che comunica il loro codice, e questa è probabilmente la ragione per cui si vede ovunque ovunque anche se i valori sono almeno non firmati.

Uso unsigned intin C ++ per gli indici di array, principalmente, e per qualsiasi contatore che inizia da 0. Penso che sia bene dire esplicitamente "questa variabile non può essere negativa".

Dovresti preoccuparti di questo quando hai a che fare con un numero intero che potrebbe effettivamente avvicinarsi o superare i limiti di un int firmato. Poiché il massimo positivo di un numero intero a 32 bit è 2.147.483.647, è necessario utilizzare un int senza segno se si sa che a) non sarà mai negativo eb) potrebbe raggiungere 2.147.483.648. Nella maggior parte dei casi, incluse chiavi e contatori del database, non mi accingo mai nemmeno a questo tipo di numeri, quindi non mi preoccupo di preoccuparmi di preoccuparmi se il bit di segno viene utilizzato per un valore numerico o per indicare il segno.

Direi: usa int se non sai di aver bisogno di un int senza segno.

È un compromesso tra semplicità e affidabilità. Più bug possono essere rilevati in fase di compilazione, più affidabile è il software. Persone e organizzazioni diverse si trovano su punti diversi lungo quello spettro.

Se fai mai una programmazione ad alta affidabilità in Ada, usi persino tipi diversi per variabili come la distanza in piedi contro la distanza in metri, e il compilatore lo contrassegna se lo assegni accidentalmente all'altro. È perfetto per programmare un missile guidato, ma è eccessivo (gioco di parole intenzionale) se stai convalidando un modulo web. Non c'è necessariamente nulla di sbagliato in entrambi i casi, purché si adatti ai requisiti.

Sono propenso a concordare con il ragionamento di Joel Etherton, ma giungo alla conclusione opposta. Per come la vedo io, anche se sai che è improbabile che i numeri si avvicinino mai ai limiti di un tipo con segno, se sai che i numeri negativi non accadranno, allora ci sono pochissime ragioni per usare la variante firmata di un tipo.

Per lo stesso motivo per cui ho usato, in alcuni casi selezionati BIGINT(intero a 64 bit) anziché INTEGER( intero a 32 bit) nelle tabelle di SQL Server. La probabilità che i dati raggiungano il limite di 32 bit entro un ragionevole lasso di tempo è minima, ma se ciò accade, le conseguenze in alcune situazioni potrebbero essere piuttosto devastanti. Assicurati di mappare correttamente i tipi tra le lingue, o finirai con una stranezza interessante molto in fondo alla strada ...

Detto questo, per alcune cose, come i valori della chiave primaria del database, firmati o non firmati non importa davvero, perché a meno che tu non stia riparando manualmente dati rotti o qualcosa del genere, non hai mai a che fare direttamente con il valore; è un identificatore, niente di più. In questi casi, la coerenza è probabilmente più importante dell'esatta scelta della firma. Altrimenti, si finiscono con alcune colonne di chiavi esterne che sono firmate e altre che non sono firmate, senza alcun modello apparente ad esso - o quella strana interessante di nuovo.

Vorrei raccomandare che al di fuori dei contesti di archiviazione e scambio di dati con spazio limitato, si dovrebbero generalmente usare tipi firmati. Nella maggior parte dei casi in cui un numero intero con segno a 32 bit sarebbe troppo piccolo ma un valore senza segno a 32 bit sarebbe sufficiente per oggi, non passerà molto tempo prima che il valore senza segno a 32 bit non sia abbastanza grande.

I tempi principali in cui si dovrebbero usare tipi senza segno sono quando si stanno assemblando più valori in uno più grande (ad es. Convertendo quattro byte in un numero a 32 bit) o ​​decomponendo valori più grandi in quelli più piccoli (ad es. Memorizzando un numero a 32 bit come quattro byte ) o quando si ha una quantità che si prevede che si "capovolga" periodicamente e si deve occuparsene (si pensi a un contatore di servizi residenziali; la maggior parte di loro ha cifre sufficienti per assicurarsi che non possano scorrere tra le letture se vengono letti tre volte all'anno, ma non abbastanza per garantire che non si ribaltino entro la vita utile del misuratore). I tipi senza segno spesso hanno abbastanza "stranezze" che dovrebbero essere usati solo nei casi in cui la loro semantica è necessaria.

Uso ints non firmati per rendere più chiaro il mio codice e le sue intenzioni. Una cosa che faccio per evitare conversioni implicite impreviste quando faccio l'aritmetica con tipi sia firmati che non firmati è usare un short senza segno (2 byte di solito) per le mie variabili senza segno. Questo è efficace per un paio di motivi:

• Quando si esegue l'aritmetica con variabili e letterali brevi senza segno (che sono di tipo int) o variabili di tipo int, ciò garantisce che la variabile senza segno venga sempre promossa a un int prima di valutare l'espressione, poiché int ha sempre un rango superiore rispetto a breve . Questo evita qualsiasi comportamento imprevisto che fa l'aritmetica con tipi firmati e non firmati, supponendo che il risultato dell'espressione rientri naturalmente in un int firmato.
• La maggior parte delle volte, le variabili senza segno che stai utilizzando non supereranno il valore massimo di un corto di 2 byte senza segno (65.535)

Il principio generale è che il tipo delle variabili non firmate dovrebbe avere un rango inferiore rispetto al tipo delle variabili firmate al fine di garantire la promozione al tipo firmato. Quindi non avrai alcun comportamento di overflow imprevisto. Ovviamente non puoi assicurarlo tutto il tempo, ma (la maggior parte) spesso è possibile assicurarlo.

Ad esempio, recentemente ne ho avuti alcuni per loop qualcosa del genere:

const unsigned short cuint = 5;
for(unsigned short i=0; i<10; ++i)
{
    if((i-2)%cuint == 0)
    {
       //Do something
    }
}

Il letterale "2" è di tipo int. Se fossi un int senza segno anziché un abbreviato senza segno, nella sottoespressione (i-2), 2 verrebbe promosso a un int senza segno (poiché int senza segno ha una priorità più alta di int con segno). Se i = 0, la sottoespressione è uguale a (0u-2u) = un valore enorme dovuto all'overflow. Stessa idea con i = 1. Tuttavia, poiché i è un abbreviato senza segno, viene promosso allo stesso tipo di "2" letterale, che è firmato int e tutto funziona bene.

Per una maggiore sicurezza: nel raro caso in cui l'architettura su cui si sta implementando causa int come 2 byte, ciò potrebbe far sì che entrambi gli operandi nell'espressione aritmetica vengano promossi in int senza segno nel caso in cui la variabile breve senza segno non si adatti nell'int a 2 byte con segno, quest'ultimo dei quali ha un valore massimo di 32.767 <65.535. (Vedi https://stackoverflow.com/questions/17832815/c-implicit-conversion-signed-unsigned per maggiori dettagli). Per evitare ciò, puoi semplicemente aggiungere un static_assert al tuo programma come segue:

static_assert(sizeof(int) == 4, "int must be 4 bytes");

e non verrà compilato su architetture in cui int è 2 byte.