Newsgroup: it.comp.lang.c
Titolo: Vettori...

Una domanda da un neofita di C
E' possibile dichiarare un vettore senza impostarne le dimensioni massime
nella dichiarazione?
e quindi dimensionarlo durante l'esecuzione del programma in base elle
esigenze?
grazie mille a tutti!
sperando in una risposta
marco.

 esigenze?
Si e no: 
una cosa del tipo:
int a[];
...
a.resize(size);
non e' possibile, ma e' possibile ottenere lo stesso risultato
usando un puntatore e malloc (o calloc) e free:
<CODE>
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int *a;
	int size,i;
	puts("Dimensione array:");
	scanf("%d",&size);
	if(size<=0){
		puts("Devi mettere un numero maggiore di 0!");
		return 0;
	}
 
	a=calloc(size,sizeof(int));
	if(!a){
		puts("Non sono riuscito!");
		return 0;
	}
	for(i=0;i<size;++i){
		a[i]=337;
	}
	printf("%d\n",a[0]);
	free(a);
	return 0;
}
<\CODE>
In pratica di questo esempio che ti ho fatto il riassunto e:
int *a;  // il puntatore
a=calloc(size,sizeof(int));   // allocare size elementi di dimensione
sizeof int
// ora a punta a questa area di memoria allocata
a[i]=337;   // e' possibile accedere agli elementi come con un normale
array (vettore)
free(a);   // devi tuttavia ricordarti di deallocare!
Ok ?!?
Tommy
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Grazie mille!
Avevo pensato che si potesse fare tramite i puntatori ma non avevo bene in
testa come!
Ma cosa fanno di preciso le funzioni calloc e malloc?
ciao!
marco

 Ma cosa fanno di preciso le funzioni calloc e malloc?
void *malloc(size_t size);
Alloca almeno size bytes e  restituisce un puntatore all'area di memoria
cosi` riservata. Nel caso l'allocazione fallisca la funzione restituisce
NULL.
void *calloc(size_t nmemb, size_t size);
Alloca  lo spazio  necessario  per contenere  almeno  nmemb elementi  di
dimensione size (quindi almeno nmemb * size bytes) e azzera il contenuto
della memoria. In caso di fallimento restituisce NULL.
void *realloc(void *ptr, size_t size);
Rialloca  un'area di  memoria ottenuta  con  malloc o  calloc. ptr  deve
puntare  al blocco  restituito da  malloc/calloc oppure  deve essere  un
puntatore nullo; in questo caso  la funzione si comporta come malloc. Il
contenuto  precedente *non*  viene  sovrascritto. size  indica la  nuova
dimensione. In caso di fallimento restituisce NULL[1].
void free(void *ptr);
Libera  un blocco  di memoria  ottenuto con  malloc o  calloc. E` lecito
chiamare free quando  ptr e` NULL ed  in questo caso la  funzione non fa
nulla.
[1] Fai attenzione con realloc, perche` in alcuni casi potresti perdere
i dati:
ptr = realloc(ptr, new_size);
if (ptr == NULL {
	L'allocazione e` fallita, ma i miei dati sono ancora da qualche
	parte in memoria. Non posso piu` recuperarli, perche` ptr adesso
	contiene NULL.
	exit(EXIT_FAILURE);
}
Molto meglio cosi`:
p = realloc(ptr, new_size);
if (p == NULL) {
	L'allocazione e` fallita, ma posso accedere ai miei dati tramite
	il puntatore ptr che non e` stato modificato.
	exit(EXIT_FAILURE);
}
ptr = p;
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"La teoria e` quando sappiamo come funzionano le cose ma non funzionano.
 La pratica e` quando le cose funzionano ma non sappiamo perche`.
 Abbiamo unito la teoria e la pratica: le cose non funzionano piu` e non
 sappiamo il perche`." -- A. Einstein