[c-c++] array di dimensioni variabili

[suomi_viking_86]

ciao come posso creare degli array con dimensioni variabili, senza dover definire prima il numero di campi che li compongono?
in questo modo potrei rendere le mie "applicazioni" più flessibili e sprecare meno memoria

[bako]

puntatori?

[suomi_viking_86]

puntatori?

mi potresti dire qualcosa in più, non sono molto pratico ne di c, ne con i puntarori

[bako]

dovresti fare una lista una coda un albero.. per gli array nn so..

[LeleFT]

Allora ti conviene prima darti una studiatina ai puntatori (studiarli per bene, perchè non è un argomenti dei più semplici).
Comunque, per ottenere la dinamicità negli array si deve ricorrere ai puntatori, ovvero a delle particolari variabili che contengono indirizzi di memoria. L'indirizzo di memoria di un puntatore, lo dice il nome stesso, corrisponde ad una cella di memoria che contiene (o è atta a contenere) un valore. Questa cella di memoria viene detta "puntata" dalla variabile puntatore. Un array altro non è che un puntatore immutabile ad una porzione di memoria: una memoria limitata alla quantità descritta quando lo dichiari.

Senza dilungarmi troppo sull'argomento (che richiederebbe troppo tempo), per ottenere un array dinamico devi conoscere queste cose:

1) l'utilizzo della funzione malloc() (o una delle sue derivate (calloc(), ecc...);

2) la quantità di spazio richiesta per il tipo di dato che intendi inserire nell'array;

3) l'aritmetica dei puntatori.

Vediamo come si fa ad allocare, dinamicamente, un array di interi quando il numero dei suoi elementi viene preso in input da tastiera:

int main() {
   int *mioArray;  // Sarà il mio array
   int quantiElementi;  // Lo chiedo all'utente
   int i;   // Indice per scorrere l'array

   printf("Quanti elementi deve avere l'array? ");
   scanf("%d", &quantiElementi);

   // Alloco il mio array:
   mioArray = (int *) malloc(quantiElementi * sizeof(int));

   // Lo riempio:
   for(i=0; i<quantiElementi; i++) mioArray[i] = i;

   // Lo stampo a video:
   printf("\n\n");
   for(i=0; i<quantiElementi; i++) printf("%d ", mioArray[i]);
   printf("\n\n");

   return 0;
}

Come vedi la dimensione dell'array la chiedo all'utente e in base al valore che lui mi passa, io creo l'array.


Ciao.

[anx721]

se poi usi il gcc su linux o il mingw su windows puoi proprio dichiarare array la cui dimensione non è specificata a tempo di compilazione, senza usare quindi i puntatori

[suomi_viking_86]

grazie a tutti, darò un'occhiata ai puntatori, allora

@anx, quello che dici, funziona anche con il DEV-C++(dovrebbe essere un porting del gcc)? se si mi potresti dire come fare

[anx721]

con devc++ funzina perche usa il compilatore mingw; per istanzaire un array lo dichiari pasasndolgi come dimensione il valore di una variabile, che sarà stabilito durante l'esecuzione. Ad esempio:

int dim;
printf("inserisci la dimensione dell'array");
scanf("%d", &dim);
int array[dim];

[suomi_viking_86]

grazie mille,
proviamo a fare un passo in avanti, vorrei fare qualcosa simile alle liste in python (linguaggio che conosco un pochino meglio), che di default hanno 0 elementi ma alle quali posso aggiungerne uno in qualsiasi momento, anche questo è fattibile
P.S.

[ibykos]

Ciao! premetto che le liste in C non sono una struttura dati nativa, per cui è compito del programmatore scrivere tutte le funzioni relative.

Innanzitutto bisogna conoscere i puntatori: un puntatore è una variabile che contiene un indirizzo di memoria, e viene usato per accedere ai dati a partire dall'area in cui sono memorizzati.
Alcuni puntatori probabilmente li hai già visti ma non sono chiamati così, prendiamo ad esempio una stringa di caratteri

char stringa[10];

questo codice dichiara un vettore di dieci caratteri, ma allo stesso tempo un puntatore ad un'area di memoria.
La variabile stringa è infatti l'indirizzo del primo carattere, puoi fare una prova per vederlo

for(i=1;i<10;i++) 
    stringa[i]='a'; 

printf ("%s",stringa)

sullo schermo, se tutto va per il verso giusto, oltre alle 10 a previste dovrebbero comparrire un mucchio di segni strani, per il fatto che le funzioni di stampa delle stringhe leggono aree di memoria contigue fino a trovare quella che contiene il carattere NUL ('\0' ), cioè la terminazione delle stringhe.
Ora, come esempio creo un vettore di stringhe

#include <stdlib> /*serve per le funzioni di gestione della memoria*/
#include <stdio.h>
#include <string.h> /*contiene funzioni per gestire le stringhe*/ 

int main(){

    char buffer[30];

    char ** vett; /* doppio puntatore, un doppio puntatore
                   contiene può essere untilizzato per contenere 
                   un vettore di puntatori*/

    int i=0;

    vett = (char ** )malloc ( sizeof  (char *) * 10 );

    /*tanti asterischi, non hanno tutti lo stesso significato 
    innanzitutto va detto che la malloc restituisce un generico
    puntatore, che deve essere adattato alla variabile su cui si
    sta lavorand mediante un'operazione detta casting che corrisponde 
    a scrivere (char **) davanti alla funzione chiamata, così ora il 
    risultato calza a pennello.
    La malloc chiede quanta memoria vogliamo destinare al vettore;
    mediante l'operatore sizeof stabilisco la dimensione di un 
    generico puntatore a caratteri (char *) quindi mi basta
    moltiplicare il risultato ottenuto per il numero di stringhe che  
    desidero immettere nel mio vettore.*/

    for (i=0;i<10;i++){

        printf ("inserire stringa>>"); /*un prompt per chiarezza*/

        gets (buffer); /*prende una stringa da utente e la memorizza 
                       nel buffer che ho definito, aggiungendo il    
                       carattere NUL dopo la stringa immessa*/
        
        vett[i] = (char *) malloc (strlen(buffer)+1 );

        /*ecco la parte interessante, innanzitutto la funzione strlen
        restituisce la lunghezza di una stringa senza però tenere 
        conto del "tappo" (il carattere NUL che la termina), quindi  
        ho dovuto aggiungere un pezzo "a mano" ( il +1) in modo che   
        la memoria bastasse.
        Il risultato di questa operazione è che mi ritrovo con 
        un'area di memoria della stessa dimensione del dato che 
        l'utente ha immesso, così non spreco davvero nulla.*/

        strcpy(vett[i],buffer); /*questa funzione semplicemente copia 
                                il contenuto di buffer in vett[i]*/

        printf ("%s\n", vett[i]); /*stampare per credere*/

        exit(0);

    }

}

Con questo codice ho creato un vettore di 10 stringhe di lunghezza esattamente uguali a quelle digitate da utente, ma si può fare di meglio.

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

int main (){

    char ** vett ,
          * terminazione = "fine", 

             /*questa è una stringa di caratteri, effettuando 
             l'assegnazione in fase di dichiarazione, alla stringa   
             verrà assegnata d'ufficio un'area di memoria sufficiente
             a contenere la parola fine ed il carattere NUL*/

            buffer [30]='\0'; 

    int i=0;

    while (strcmp(buffer,terminazione)!=0){

        /*la strcmp confronta due stringhe e  restituisce 0 se sono 
        uguali, altri valori se sono diverse*/

        vett = (char ** ) realloc (sizeof (char *));

        /*la realloc agginge spazio ad una variabile, per esempio
        adesso ho aggiunto alla variabile vett lo spazio necessario   
        per ospitare un altro puntatore a caratteri*/

        printf ("inserire stringa>>"); /*un prompt per chiarezza*/

        gets (buffer); 
        
        vett[i] = (char *) malloc (strlen(buffer)+1 );

        strcpy(vett[i],buffer); 

        printf ("%s\n", vett[i]);

        i++;

    }

    exit(0);
}

Con questo codice ho creato un vettore a cui aggiungo dinamicamente la memoria necessaria per i nuovi elementi, senza sprecarne neanche una goccia.

Spero di essere stato utile, ciao!