[C] Dimensione array definita dinamicamente

[Gica78R]

Salve ragazzi!

Sto riprendendo il linguaggio C a distanza di oltre un anno, ed improvvisamente mi è crollata una certezza
Per quanto ne so, quando si definisce un array la sua dimensione deve essere nota in fase di compilazione, ed in particolare essa deve essere una costante. Ora, facendo un po' di prove, mi accorgo che compilando ed eseguendo un programma del genere:

#include <stdio.h>

int main(void)
{
   int c;
   int DIM;
   printf("Inserisci dimensione array: ");
   scanf("%d", &DIM);
   int stringa[DIM];
   for (c = 0; c < DIM; c++)
     stringa[c] = c;
   printf("\nFine\n");
   return 0;
}

non solo non ottengo errori in compilazione (gcc dovrebbe come minimo sputarmi in faccia), ma non avviene nemmeno un segmentation fault in fase di esecuzione.

Qualcuno saprebbe spiegarmi come mai?

Preciso che uso gcc versione 4.2.4 su Linux 2.6.24 64 bit

[wizard1993]

per il c99 si può fare, è il c++ che non lo supporta

[Gica78R]

Ho provato anche a compilare questo con g++, e non ricevo errori nemmeno a runtime...

#include <iostream>

using namespace std;

int main(void)
{
   int d;
   
   cout << "Inserisci dimensione array: ";
   cin >> d;
   
   int vettore[d];
   
   for (int i = 0; i < d-1; i++)
     vettore[i] = i;
   
   cout << "Fatto!"<<endl;
   
   return 0;
}

EDIT: solo se compilo passando a gcc l'opzione -pedantic ricevo il warning sulla dimensione variabile dell'array, ma non un errore...

Originariamente inviato da gcc

warning: ISO C90 forbids variable-size array ‘stringa’

[wizard1993]

Originariamente inviato da Gica78R

Ho provato anche a compilare questo con g++, e non ricevo errori nemmeno a runtime...

#include <iostream>

using namespace std;

int main(void)
{
   int d;
   
   cout << "Inserisci dimensione array: ";
   cin >> d;
   
   int vettore[d];
   
   for (int i = 0; i < d-1; i++)
     vettore[i] = i;
   
   cout << "Fatto!"<<endl;
   
   return 0;
}

EDIT: solo se compilo passando a gcc l'opzione -pedantic ricevo il warning sulla dimensione variabile dell'array, ma non un errore...

proprio perchè lo vieta il c90 ma non il c99 e visto che il gcc è un compilatore c99 quella stringa viene accettata, e la sua validità "importata" in c++

[Dr. Cox]

Originariamente inviato da Gica78R

#include <stdio.h>

int main(void)
{
   int c;
   int DIM;
   printf("Inserisci dimensione array: ");
   scanf("%d", &DIM);
   int stringa[DIM];
   for (c = 0; c < DIM; c++)
     stringa[c] = c;
   printf("\nFine\n");
   return 0;
}

anche io lavoro con il gcc, in ambiente Cygwin.
se vuoi inizializzare un array puoi ovviamente farlo durante il programma, ma la dimensione (la dimensione MASSIMA) deve essere definita in modo statico, magari con un #define

il tuo frammento di codice io lo farei cosi:

#include <stdio.h>
#include <stdlib.h>

#define MAXDIM 128

int main(void)
{
   int c, dim;
   int stringa[MAXDIM];

   printf("Inserisci dimensione array: ");
   scanf("%d", &dim);
   
   for (c = 0; c < dim; c++)
     stringa[c] = c;

   printf("\nFine\n");

   return EXIT_SUCCESS;
}

[Gica78R]

Originariamente inviato da Dr. Cox

il tuo frammento di codice io lo farei cosi:

Anch'io lo farei così, e l'ho sempre fatto così!
Però la mia era una curiosità, scaturita dopo aver letto questa frase su un libro di Kernighan e Pike del 1999 (The practice of programming) a proposito delle differenze tra C e C++:

Anche C ha valori di tipo const, ma non possono essere usati come limite di un array, così l'istruzione enum rimane il metodo migliore in C.

Quindi ho provato a istanziare un array usando per la sua dimensione un intero costante al posto di una macro o un enum, verificando che non ottenevo alcun errore né in compilazione né a runtime; a quel punto ho provato ad istanziarlo usando addirittura una variabile, ed il non ricevere errori mi ha un po' disorientato.

Ora mi chiedo: il fatto che lo standard C99 permetta una cosa del genere, implica anche che sia corretto? Ovvero, posso istanziare array usando per dimensione una variabile senza preoccuparmi delle conseguenze a runtime o, pur essendo consentito dallo standard, la cosa rimane sbagliata?

Grazie

[cionci]

Dipende tutto da chi deve guardare quel codice...se è un professore, mediamente poco informato sugli standard "nuovi", usa l'allocazione dinamica. Altrimenti puoi fare quello che vuoi...quello è C standard
In C++ ad esempio non lo farei.

[wizard1993]

Originariamente inviato da cionci

mediamente poco informato sugli standard "nuovi"

hai detto bene, mediamente. i professori che conosco io sono sempre stati i primi ad aggiornarsi ai nuovi standard

[cionci]

Originariamente inviato da wizard1993

hai detto bene, mediamente. i professori che conosco io sono sempre stati i primi ad aggiornarsi ai nuovi standard

Fra tutti quelli che ho avuto, un dettaglio del genere lo conoscerebbero in due o tre

[Gica78R]

Originariamente inviato da cionci

Dipende tutto da chi deve guardare quel codice...se è un professore, mediamente poco informato sugli standard "nuovi", usa l'allocazione dinamica. Altrimenti puoi fare quello che vuoi...quello è C standard
In C++ ad esempio non lo farei.

Non lo deve guardare nessuno, però deve essere corretto

A questo punto credo che usare lo standard C90 può essere utile solo per compatibilità con compilatori più vecchi, no?

[wizard1993]

Originariamente inviato da Gica78R

Non lo deve guardare nessuno, però deve essere corretto

A questo punto credo che usare lo standard C90 può essere utile solo per compatibilità con compilatori più vecchi, no?

visto che la borland si ostina a distribuire un compilatore che non supporta nemmeno le costanti nelle classi, figurati questi "dettagli"

[cionci]

Originariamente inviato da Gica78R

A questo punto credo che usare lo standard C90 può essere utile solo per compatibilità con compilatori più vecchi, no?

Sì, tipo Microsoft e Borland che non supportano il C99.

[Gica78R]

Originariamente inviato da cionci

Sì, tipo Microsoft e Borland che non supportano il C99.

Beh, non dovrei aver bisogno di compilatori (o sistemi operativi, o applicazioni) Microsoft, almeno per i prossimi 150 anni

[fero86]

Originariamente inviato da Gica78R

Qualcuno saprebbe spiegarmi come mai?

bah, banalissimo: l'allocazione di un vettore in memoria automatica avviene sottraendo una determinata quantitá allo stack pointer; la semantica che tu riporti (dichiarazione di un array con una variabile come dimensione anziché una costante) fa si' che il codice generato dal compilatore sottragga allo stack pointer il valore contenuto in una certa variabile anziché un valore costante. si ha segmentation fault solo quando si accede ad un array per la cui dichiarazione é stato sottratto un valore che ha fatto andare lo stack pointer oltre il limite dello stack.

[Gica78R]

Ah, ok! Grazie della spiegazione

[cionci]

Originariamente inviato da fero86

bah, banalissimo: l'allocazione di un vettore in memoria automatica avviene sottraendo una determinata quantitá allo stack pointer; la semantica che tu riporti (dichiarazione di un array con una variabile come dimensione anziché una costante) fa si' che il codice generato dal compilatore sottragga allo stack pointer il valore contenuto in una certa variabile anziché un valore costante. si ha segmentation fault solo quando si accede ad un array per la cui dichiarazione é stato sottratto un valore che ha fatto andare lo stack pointer oltre il limite dello stack.

Secondo la tua spiegazione questo sarebbe un errore. In C95 è come dici, in C99 invece non è un errore, è perfettamente lecito.

[fero86]

Originariamente inviato da cionci

Secondo la tua spiegazione questo sarebbe un errore. In C95 è come dici, in C99 invece non è un errore, è perfettamente lecito.

a cosa ti riferisci, alla situazione che provoca il segmentation fault?

penso che ci siano solo due modi di allocare dati dinamicamente: nello stack e nell'heap; il primo ha un limite (ad esempio impostato dal linker su Windows, non so su Linux), il secondo invece non ha virtualmente limite poiché é limitato solo dalla disponibilitá di indirizzi virtuali e di risorse di sistema; peró mentre per allocare nel primo é sufficiente una sottrazione, per allocare nel secondo é necessaria una chiamata di sistema con eventuale switch in kernel mode, quindi é inefficiente.

se sta scritto da qualche parte che in C99 gli array la cui dimensione é espressa da una variabile devono essere allocati nell'heap allora é un motivo in piu per non usare il C99

[cionci]

No, intendevo una cosa diversa, tu l'hai trattato come se fosse un errore, ma in realtà non lo è.
Che finisca lo stack può succedere, ma al pari dell'allocazione classica se io utilizzo un intero troppo grande

[cionci]

Ecco l'implementazione di questo codice:

void f()
{
   int n;
   scanf("%d", &n);
   int v[n];
   while(n--);
}

f:
.LFB2:
	pushq	%rbp
.LCFI0:
	movq	%rsp, %rbp
.LCFI1:
	subq	$48, %rsp
.LCFI2:
	movq	%fs:40, %rax
	movq	%rax, -8(%rbp)
	xorl	%eax, %eax
	movq	%rsp, %rax
	movq	%rax, -40(%rbp)
	leaq	-12(%rbp), %rsi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	scanf
	movl	-12(%rbp), %eax
	cltq
	salq	$2, %rax
	addq	$15, %rax
	addq	$15, %rax
	shrq	$4, %rax
	salq	$4, %rax
	subq	%rax, %rsp
	movq	%rsp, -48(%rbp)
	movq	-48(%rbp), %rax
	addq	$15, %rax
	shrq	$4, %rax
	salq	$4, %rax
	movq	%rax, -48(%rbp)
	movq	-48(%rbp), %rax
	movq	%rax, -24(%rbp)
.L2:
	movl	-12(%rbp), %eax
	testl	%eax, %eax
	setne	%dl
	subl	$1, %eax
	movl	%eax, -12(%rbp)
	testb	%dl, %dl
	jne	.L2
	movq	-40(%rbp), %rsp
	movq	-8(%rbp), %rax
	xorq	%fs:40, %rax
	je	.L4
	call	__stack_chk_fail
.L4:
	leave
	ret

Sinceramente mi sembra un po' contorta come operazione Non ho voglia di mettermi a leggerlo Comunque viene usato lo stack.

[Braga83]

Originariamente inviato da fero86

bah, banalissimo: l'allocazione di un vettore in memoria automatica avviene sottraendo una determinata quantitá allo stack pointer; la semantica che tu riporti (dichiarazione di un array con una variabile come dimensione anziché una costante) fa si' che il codice generato dal compilatore sottragga allo stack pointer il valore contenuto in una certa variabile anziché un valore costante. si ha segmentation fault solo quando si accede ad un array per la cui dichiarazione é stato sottratto un valore che ha fatto andare lo stack pointer oltre il limite dello stack.

Quoto. L'array viene allocato nello stack. Riguardo ai motivi del perche' il compilatore permatta questa zozzeria non saprei. Credo sia una morivazione filosofica piu' che tecnica: nel C ( e in parte nel c++ ) si cercano di mettere meno vincoli possibili al programmatore per non limitare la "potenza del linguaggio". Se questo crea, o meglio facilita, gli errori pazienza.

Comunque evita come la peste questo costrutto: segmentation fault e' il migliore degli errori che possano accadere. Mi ricordo un esempio simile in c++ in cui se si usciva dalla lunghezza dell'array, si andava a modificare il valore di altre variabili automatiche presenti nello stack, senza controllo dei tipi. Poi voglio vedere a debuggare codice del genere.