Newsgroup: it.comp.lang.c
Titolo: Superamento dimensioni array

Ciao a tutti,
cercavo di capire i problemi relativi al superamento delle dimesioni di un
array, prendiamo questo codice di esempio:
#include <stdio.h>
#define SIZE 10
int main(void) {
        int s[SIZE], j;
 
        for (j=0; j<=SIZE + 4; j++) 
                s[j] = 2 + 2 * j;
 
        printf("%s%13s\n", "Element", "Value");
        for (j=0; j<=SIZE + 4; j++)
                printf("%7d%13d\n", j, s[j]);
 
        return 0;
}
come potete vedere è fatto in modo da superare di 5 posizioni il limite
fissato.
Il programmino funziona e da come output:
[shishii@marco studio]$ ./over_vector5
Element        Value
      0            2
      1            4
      2            6
      3            8
      4           10
      5           12
      6           14
      7           16
      8           18
      9           20
     10           22
     11           24
     12           26
     13           28
     14           30
Se invece cerco di superarlo di 6 posizioni produce:
[shishii@marco studio]$ ./over_vector6
Element        Value
      0            2
      1            4
      2            6
      3            8
      4           10
      5           12
      6           14
      7           16
      8           18
      9           20
     10           22
     11           24
     12           26
     13           28
     14           30
     15           32
Segmentation fault
e così via per qualunque dimensione superiore abbia provato.
Esegue il programma fino alla fine e, solo dopo, produce il segmentation
fault.
Qualcuno può spiegarmi cosa succede? e possibilmente perchè?
Grazie.
-- 
-- Marco Allegretti --
http://www.shishii.com

Puo' anche dipendere da cosa c'era gia' in memoria


[...]
Ah! Pessima idea. Non si deve _mai_ superare la dimensione di un array.
Il comportamento che il programma puo` avere e` abbastanza imprevedibile.
Quando va in segmentation fault e` probabilmente perche' sta cercando di
scrivere in aree di memoria non appartenenti allo stesso processo e il
sistema operativo lo impedisce.
Altrimenti, puo` anche accadere che il programma vada in crash in altri
momenti, perche' (per esempio) ha scritto un NULL in una posizione della
memoria che contiene un puntatore e successivamente tenta di usare il
puntatore.
O puo` anche succedere che il programma non vada mai in crash, ma dia
risultati sballati in modo imprevedibile. O addirittura che non succeda
nulla.
In generale, il comportamento di un programma quando tenta di scrivere
(la lettura non mi pare che crei problemi) in aree non allocate e` da
considerarsi imprevedibile, per cui non ha molto senso cercare di
_capire_ quello che succede. Va solo evitato come la peste!
Saluti,
Marco
-- 
To reply this message, please remove the no_ and _spam from my address.

 (la lettura non mi pare che crei problemi) [...]
Anche la lettura può creare problemi.  Il problema non è "scrivere", è
"accedere".
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Andrea Laforgia ha scritto:
Vi ringrazio, ma la mia domanda non voleva essere banale. Lo so bene che non
si deve cercare di accedere ad aree di memoria non allocate. Però io
cercavo di capire il meccanismo effettivo del problema. 
Ci sono molti articoli sul buffer overflow e un'idea ora ce l'ho, ma questo
discorso degli array non mi è chiaro, infatti è indipendente da quali altri
programmi sono in esecuzione o da cosa c'è scritto nelle locazioni
interessate, tanto che, in riferimento al codice che ho postato, si produce
sempre e solo al superamento di 5 delle dimensioni fissate.


 sempre e solo al superamento di 5 delle dimensioni fissate.
Non ha senso chiedersi perché accade ciò che accade quando sfori un array
di tot posizioni.  La ripetitività della condizione (sempre 5 elementi)
dipende molto probabilmente dal tuo sistema.
