Array e dimensione MAX

[mister bianchi]

Ciao a tutti,

sto imparando le basi del C, ho fatto questo piccolo programmino per imparare gli array.

#include<stdio.h>

int main()

{
	int intero[5], i;
	
	for (i=0; i<10; i++)
		{
			intero[i]=i;
		}
       for (i=0; i<10; i++)
                {
			printf("intero[i]: %d\n", intero[i]);
		}
		
	return 0;
}

Come mai anche se ho dichiarato l'array con dimensione 5 riesco comunque a scrivere oltre questa dimensione? Non dovrei ottenere un errore?

[Silvia2003]

"Crocedelizia" del c/c++... lui te lo lascia fare ma il risultato è imprevedibile (probabile crash completo!).

Se vuoi che il compilatore si "accorga" dell'errore cambia linguaggio.

[mister bianchi]

Non voglio cambiare linguaggio (almeno per ora! ), voglio capire perchè me lo fa fare senza darmi nè errori nè warnings. In pratica cosa succede? Vado a scrivere fuori dall'array? Eseguendo il programma tutto fila liscio senza crash come se avessi realmente dichiarato un array di 10 elementi.

[Silvia2003]

Non voglio cambiare linguaggio

e allora bisogna accettarlo per com'è, apprezzandone le caratteristiche (è parte della "potenza" di C e C++) e studiandolo per evitare di incappare in errori.

Te lo fa fare semplicemente perché non è previsto alcun controllo. Il fatto che il programma possa girare senza produrre alcun errore è del tutto casuale (e insidioso in fase di debug).

[mister bianchi]

Originariamente inviato da Silvia2003

(e insidioso in fase di debug).

Cioè? Scusa ma sono un neofita...

[Silvia2003]

Significa che quando il tuo programma andrà in errore (e scrivendo oltre i limiti del dimensionamento dell'array primo o poi accadrà) sarà più ostico trovare l'origine di tale errore: l'insidia sta proprio nel fatto che eseguendo più volte il programma non sempre si ottiene l'errore (è un errore ottenibile a run-time).

Fai qualche test ad esempio dichiarando qualche altro array o scrivendo qualche elemento in più dei 5 aggiuntivi proposti nell'esempio...

[Silvia2003]

Prova questo esempio...

#include <stdio.h>

int main()
{
    int ar1[5], ar2[10], i;
    for(i = 0; i < 20; ++i) {ar1[i] = i;}
    for(i = 0; i < 10; ++i) {ar2[i] = i;}
    for(i = 0; i < 10; ++i) {
        printf("%d - %d\n",ar1[i], ar2[i]);
    }
    return 0;
}

[mister bianchi]

Ottengo questo

0 - 0
1 - 1
2 - 2
3 - 3
4 - 4
5 - 5
6 - 6
7 - 7
8 - 8
9 - 9
Errore di segmentazione

[Silvia2003]

si è solo "stressato" maggiormente l'esempio (aggiunto un array, scritto qualche elemento in più...) e, improvvisamente, ciò che prima sembrava funzionare ora non funziona più.

In un esempio così semplice è molto semplice capire l'origine del problema ma, prova a pensare cosa accadrebbe in codice molto più corposo e frazionato.

[Silvia2003]

Io ho compilato con GCC abilitando tutti i possibili warnings senza alcun avviso.

Non ho provato con VC.

[Silvia2003]

... anche VC 2013 compila senza problemi

Impostazioni compilatore C/C++
Livello avvisi : Abilita tutti gli avvisi (/Wall)
Considera gli avvisi come errori : Si (/WX)

In ogni caso, a prescindere dal possibile specifico supporto eventualmente offerto dal compilatore (quale?) rimane il fatto che il linguaggio consente di farlo: C e C++ lasciano al programmatore la responsabilità di gestire questo e altri aspetti (qualsiasi testo di base utilizzato per apprendere il C o il C++ credo ponga in buona evidenza questa caratteristica).

[wingman87]

Originariamente inviato da Silvia2003

Prova questo esempio...

#include <stdio.h>

int main()
{
    int ar1[5], ar2[10], i;
    for(i = 0; i < 20; ++i) {ar1[i] = i;}
    for(i = 0; i < 10; ++i) {ar2[i] = i;}
    for(i = 0; i < 10; ++i) {
        printf("%d - %d\n",ar1[i], ar2[i]);
    }
    return 0;
}

Una curiosità: ultimamente vedo spesso l'incremento di i nei cicli utilizzando un preincremento invece di un postincremento... c'è un motivo o è solo cambiata la moda? Immagino la seconda ma sono curioso anche dell'origine di questa moda.

[Silvia2003]

Non è un moda ma una questione di performance.

il pre-incremento (++i) equivale a:

i = i +1

il post-incremento (i++) equivale a:

tmp = i; //(necessità di conservare il valore prima dell'incremento = valore ritornato)
i = i + 1;

[wingman87]

Interessante, grazie.

[sottovento]

Originariamente inviato da Silvia2003

Non è un moda ma una questione di performance.

il pre-incremento (++i) equivale a:

i = i +1

il post-incremento (i++) equivale a:

tmp = i; //(necessità di conservare il valore prima dell'incremento = valore ritornato)
i = i + 1;

A dire il vero ci sono molti processori che hanno nativamente sia istruzioni di post sia di pre incremento/decremento, e il post incremento risulta decisamente piu' performante.
Quanto scrivi e' vero soprattutto quando si devono manipolare oggetti, in quel caso occorre sicuramente ricorrere implicitamente ad una variabile temporanea

[Silvia2003]

Può essere ma si tratta ugualmente di good-practice. I compilatori eseguono comunque una serie di ottimizzazioni più o meno "aggressive" ma una buona codifica iniziale aiuta sempre.

Premesso che la differenza in termini di tempo di esecuzione tra pre-incremento e post-incremento è praticamente trascurabile (almeno nel caso dell'esempio proposto), preferisco ricorrere ad una soluzione piuttosto che l'altra in base alla "logica" necessità.

[Freaxxx]

Originariamente inviato da mister bianchi

Ciao a tutti,

sto imparando le basi del C, ho fatto questo piccolo programmino per imparare gli array.

#include<stdio.h>

int main()

{
	int intero[5], i;
	
	for (i=0; i<10; i++)
		{
			intero[i]=i;
		}
       for (i=0; i<10; i++)
                {
			printf("intero[i]: %d\n", intero[i]);
		}
		
	return 0;
}

Come mai anche se ho dichiarato l'array con dimensione 5 riesco comunque a scrivere oltre questa dimensione? Non dovrei ottenere un errore?

Accedere a locazioni di memoria contenute oltre il limite espresso al momento della dichiarazione dell'array è undefined behaviour in C .

In altre parole il linguaggio non asserisce nulla di definitivo e specifico sull'argomento e il compilatore non è tenuto a fare o dire nulla; si suppone che tu in qualità di programmatore C semplicemente non dovresti mai fare nulla di simile .

[Silvia2003]

... tu in qualità di programmatore C semplicemente non dovresti mai fare nulla di simile ...

L'uso del condizionale sintetizza pienamente il concetto!

[das]

Originariamente inviato da mister bianchi

Ciao a tutti,

sto imparando le basi del C, ho fatto questo piccolo programmino per imparare gli array.

#include<stdio.h>

int main()

{
	int intero[5], i;
	
	for (i=0; i<10; i++)
		{
			intero[i]=i;
		}
       for (i=0; i<10; i++)
                {
			printf("intero[i]: %d\n", intero[i]);
		}
		
	return 0;
}

Come mai anche se ho dichiarato l'array con dimensione 5 riesco comunque a scrivere oltre questa dimensione? Non dovrei ottenere un errore?

Non c'è modo di sapere che è sbagliato prima di eseguire il codice. Come fa il compilatore a sapere che i sarà maggiore di 5 ? Deve interpretare il significato del comando for e delle eventuali formule. Infatti nel mezzo ci potrebbe essere scritto

i=i-3

anche questa formula dovrebbe essere valutata. In altre parole il codice dovrebbe essere eseguito.

Ma quando lo esegui non sai cosa c'è al di là della quinta locazione di memoria, magari c'è qualcosa che in quel frangente non serve più, per cui anche sovrascrivendola non si hanno errori.

Però non c'è garanzia.

Diverso è se scrivi i[7]=2; allora il compilatore sa che l'array è al massimo di 5 ma tu stai scrivendo nella 7ma locazione

[Silvia2003]

Non credo, prova questo

int main()
{
    int i[5];
    i[7] = 500;
    printf("%d", i[7]);
    return 0;
}

... compilazione pulita e senza alcun warning (GCC)

x86_64-w64-mingw32-gcc.exe -Wall -pedantic -Wextra -g -Winline -Wunreachable-code -pedantic-errors -pedantic -g  -c A:\prova1\main.c -o obj\Debug\main.o
x86_64-w64-mingw32-g++.exe  -o bin\Debug\prova1.exe obj\Debug\main.o   
Output file is bin\Debug\prova1.exe with size 125.40 KB
Process terminated with status 0 (0 minute(s), 0 second(s))
0 error(s), 0 warning(s) (0 minute(s), 0 second(s))

credo di avere abilitato tutti i flag relativi ai possibili warning.
Il compilatore semplicemente non esegue alcun controllo degli indici poiché, come già stato ben evidenziato, in C (ma anche in C++) ciò non è previsto.