Se un numero è troppo grande, passa alla posizione di memoria successiva?

Ho rivisto la programmazione in C e ci sono solo un paio di cose che mi danno fastidio.

Prendiamo ad esempio questo codice:

int myArray[5] = {1, 2, 2147483648, 4, 5};
int* ptr = myArray;
int i;
for(i=0; i<5; i++, ptr++)
    printf("\n Element %d holds %d at address %p", i, myArray[i], ptr);

So che un int può contenere un valore massimo di 2.147.483.647 positivi. Quindi superandone uno, "si riversa" sul successivo indirizzo di memoria che fa apparire l'elemento 2 come "-2147483648" a quell'indirizzo? Ma allora non ha davvero senso perché nell'output dice ancora che l'indirizzo successivo contiene il valore 4, quindi 5. Se il numero si fosse trasferito all'indirizzo successivo, allora non cambierebbe il valore memorizzato in quell'indirizzo ?

Ricordo vagamente dalla programmazione in MIPS Assembly e osservando gli indirizzi cambiare i valori durante il programma passo dopo passo che i valori assegnati a quegli indirizzi sarebbero cambiati.

A meno che non mi ricordi in modo errato, ecco un'altra domanda: se il numero assegnato a un indirizzo specifico è più grande del tipo (come in myArray [2]), non influisce sui valori memorizzati nell'indirizzo successivo?

Esempio: abbiamo int myNum = 4 miliardi all'indirizzo 0x10010000. Naturalmente myNum non può memorizzare 4 miliardi, quindi appare come un numero negativo a quell'indirizzo. Nonostante non sia in grado di memorizzare questo numero elevato, non ha alcun effetto sul valore memorizzato all'indirizzo successivo di 0x10010004. Corretta?

Gli indirizzi di memoria hanno spazio sufficiente per contenere determinate dimensioni di numeri / caratteri e se la dimensione supera il limite, verrà rappresentata in modo diverso (come tentare di archiviare 4 miliardi nell'int ma apparirà come un numero negativo) e quindi non ha alcun effetto sui numeri / caratteri memorizzati al prossimo indirizzo.

Scusa se sono andato in mare. Da questo giorno ho avuto una grande scoreggia cerebrale.

No non lo fa. In C, le variabili hanno un set fisso di indirizzi di memoria con cui lavorare. Se stai lavorando su un sistema con 4 byte intse imposti una intvariabile su 2,147,483,647e poi aggiungi 1, la variabile di solito conterrà -2147483648. (Sulla maggior parte dei sistemi. Il comportamento in realtà non è definito.) Non verranno modificate altre posizioni di memoria.

In sostanza, il compilatore non ti permetterà di assegnare un valore troppo grande per il tipo. Ciò genererà un errore del compilatore. Se lo forzate con un caso, il valore verrà troncato.

Osservato in modo bit a bit, se il tipo può memorizzare solo 8 bit e si tenta di forzare il valore 1010101010101in un caso, si finiranno con gli 8 bit inferiori, oppure 01010101.

Nel tuo esempio, indipendentemente da ciò che fai myArray[2], myArray[3]conterrà "4". Non è possibile "riversarsi". Stai provando a mettere qualcosa che è più di 4 byte, eliminerà tutto dalla fascia alta, lasciando i 4 byte inferiori. Sulla maggior parte dei sistemi, ciò comporterà -2147483648.

Da un punto di vista pratico, vuoi solo assicurarti che ciò non accada mai e poi mai. Questi tipi di overflow spesso causano difetti difficili da risolvere. In altre parole, se pensi che ci sia qualche possibilità che i tuoi valori siano in miliardi, non usare int.

L'overflow di numeri interi con segno è un comportamento indefinito. In questo caso, il programma non è valido. Il compilatore non è tenuto a verificarlo, quindi potrebbe generare un eseguibile che sembra fare qualcosa di ragionevole, ma non è garantito che lo farà.

Tuttavia, l'overflow di numeri interi senza segno è ben definito. Avvolgerà il modulo UINT_MAX + 1. La memoria non occupata dalla variabile non sarà interessata.

Vedi anche https://stackoverflow.com/q/18195715/951890

Quindi, ci sono due cose qui:

• il livello linguistico: quali sono le semantiche di C
• il livello della macchina: quali sono le semantiche dell'assembly / CPU che usi

A livello di lingua:

In C:

• overflow e underflow sono definiti come modulo aritmetico per numeri interi senza segno, quindi il loro valore "loop"
• troppo pieno e underflow sono comportamento non definito per firmati interi, quindi tutto può succedere

Per quelli che vorrebbero un esempio "qualunque cosa", ho visto:

for (int i = 0; i >= 0; i++) {
    ...
}

trasformarsi in:

for (int i = 0; true; i++) {
    ...
}

e sì, questa è una trasformazione legittima.

Significa che ci sono effettivamente potenziali rischi di sovrascrivere la memoria in caso di overflow a causa di una strana trasformazione del compilatore.

Nota: su Clang o gcc utilizzare -fsanitize=undefinedin Debug per attivare il disinfettante comportamentale indefinito che si interromperà in caso di underflow / overflow degli interi con segno.

Oppure significa che è possibile sovrascrivere la memoria usando il risultato dell'operazione per indicizzare (non spuntato) in un array. Ciò è purtroppo molto più probabile in assenza di rilevamento di underflow / overflow.

Nota: su Clang o gcc usare -fsanitize=addressin Debug per attivare Address Sanitizer che si interromperà in caso di accesso fuori limite.

A livello di macchina :

Dipende molto dalle istruzioni di assemblaggio e dalla CPU che usi:

• su x86, ADD utilizzerà il complemento 2 su overflow / underflow e imposta OF (Flag di overflow)
• sulla futura CPU Mill, ci saranno 4 diverse modalità di overflow per Add:
  • Modulo: modulo a 2 complementi
  • Trap: viene generata una trap, arrestando il calcolo
  • Saturi: il valore viene bloccato al minimo su underflow o max su overflow
  • Doppia larghezza: il risultato viene generato in un registro a doppia larghezza

Si noti che se le cose accadono nei registri o nella memoria, in nessun caso la CPU sovrascrive la memoria in caso di overflow.

Per approfondire la risposta di @ StevenBurnap, la ragione per cui ciò accade è dovuta al modo in cui i computer lavorano a livello di macchina.

L'array è archiviato in memoria (ad es. Nella RAM). Quando viene eseguita un'operazione aritmetica, il valore in memoria viene copiato nei registri di ingresso del circuito che esegue l'aritmetica (ALU: Arithmetic Logic Unit ), l'operazione viene quindi eseguita sui dati nei registri di ingresso, producendo un risultato nel registro di output. Questo risultato viene quindi copiato nuovamente in memoria all'indirizzo corretto in memoria, lasciando intatte le altre aree della memoria.

Innanzitutto (assumendo lo standard C99), potresti voler includere <stdint.h>un'intestazione standard e utilizzare alcuni dei tipi qui definiti, in particolare int32_tche è esattamente un uint64_tintero con segno a 32 bit o che è esattamente un numero intero senza segno a 64 bit e così via. Potresti voler utilizzare tipi come int_fast16_tper motivi di prestazioni.

Leggi le altre risposte spiegando che l'aritmetica senza segno non si riversa (o trabocca mai) in posizioni di memoria adiacenti. Fai attenzione al comportamento indefinito in caso di overflow firmato .

Quindi, se hai bisogno di calcolare numeri interi esattamente enormi (ad es. Vuoi calcolare fattoriale di 1000 con tutte le sue 2568 cifre in decimali), vuoi i nati come numeri di precisione arbitrari (o bignum). Gli algoritmi per un'aritmetica bigint efficiente sono molto intelligenti e di solito richiedono l'uso di istruzioni specializzate per la macchina (ad esempio alcuni aggiungono parola con carry, se il tuo processore lo possiede). Quindi consiglio vivamente in tal caso di utilizzare alcune librerie bigint esistenti come GMPlib