Newsgroup: it.comp.lang.c++
Titolo: Creazione di un array

Salve a tutti, devo leggere una serie di dati da un file ed inserirli in un
array.
Ho creato una funzione leggi(PRODOTTI *pd, *fi1) ed un'altra funzione che
richiama questa e che mi mette tutto in un array prodotti[N] con N
dichiarato a inizio programma. Quest'ultima funzione č lettura(PRODOTTI
prodotti[N], FILE *fi1)
 Mi sono accorta di aver un po' pasticciato, cosě volevo trasformare il
tutto in un'unica funzione, senza dichiarare all'inizio la grandezza
dell'array (la N). Come posso fare a far leggere i dati dal file e metterli
nell'array con una sola funzione (non posso semplicemente eliminare la
prima, dato che la "leggi" e la "lettura" non hanno lo stesso argomento)?
Spero che capiate la domanda...se volete dei chiarimenti sul problema
chiedete...
Grazie
Manuela


Non sono sicuro di aver capito (magari potresti postare qualche linea di
codice)
ma credo che tu possa fare una cosa del genere
a) Sostituire la tua leggi con
    PRODOTTI *nuovaLeggi(FILE *fi1) {
            PRODOTTI *pd;
            /* 1 - contare il numero dei record nel file (se i record
sono di dimensione
                   fissa si puo` fare dimensione del file/dimensione di
un record 
                   (La dimensione del file si trova portandosi alla fine
del file con
                    fseek e facendosi restituire la posizione in byte
con ftell. Invece
                    se il numero di record e` di dimensione variabile
devi trovare tu il
                    modo di contarli).
            */
            /* 2 - allocare spazio per l'array; ad esempio: */
            pd  =           
 
(PRODOTTI*)malloc(sizeof(PRODOTTI)*numero_di_record_di_cui_al_punto_1);          
            /* 3 - Riposizionamento all'inizio del file, lettura dei
record uno ad uno
                   e relativo inserimento nell'array */
            /*  4 - restituzione del puntatore */
            return pd;
    }
b)   chiamare questa funzione con chiamate del tipo:
 
      PRODOTTI *arrayProdotti;
      arrayProdotti = nuovaLeggi(puntatoreAlFile);
 
       /*a questo punto puoi usare l'array che e` stato allocato da
nuovaLeggi*/      
c) IMPORTANTE!!
    ricordarsi di eseguire 
    free(arrayProdotti) quando l'array non serve piu`.
ciao,
Marco Guidi

 chiedete...
NON sono sicuro di aver capito.  Comunque: 1) usa un vector e non un
array; cosi' non c'e' nessun bisogno di dichiarare la lunghezza; 2)
per una lettura in un'unica istruzione, puoi usare un iteratore.
Esempio (l'input sono due linee di dati seguite da un end-of-file):
MLO@axcdf4 24 $ cat foo.cxx
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
  vector<int> v;
  copy(istream_iterator<int>(cin), istream_iterator<int>(),
       back_inserter(v));
  sort(v.begin(), v.end());
  cout << "Hai dato (in ordine crescente):" << endl;
  copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n"));
}
MLO@axcdf4 25 $ KCC -o foo foo.cxx
C++ prelinker: Recompiling foo.cxx
MLO@axcdf4 26 $ ./foo
1 2 3
6 5 4
^D
^D
Hai dato (in ordine crescente):
1
2
3
4
5
6
MLO@axcdf4 27 $
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 MLO@axcdf4 24 $ cat foo.cxx
Scusa, mi spieghi cosa sono questi caratteri spuri che trovo sempre nei
tuoi (peraltro ottimi) esempi?
EMG

array.
Nelle faq (su 
www.programmazione.it
) sono spiegate diverse
tecniche per risolvere il tuo problema in modo elegante,
efficiente e con possibilita` di errori ridotti al minimo.
In particolare ci sono due possibilita`:
a) l'uso di std::vector (preferibile all'uso dei normali array C style).
b) sfruttare la deduzione implicita dei parametri di un template
     (che se non si fosse ancora capito, e una tecnica che apprezzo  
      molto :).
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 codice)
...
struct PRODOTTI
       {
        int code;
        char nome[15];
        int costo;
       };
struct PESATE
       {
        int code;
        float peso;
       };
int leggi(PRODOTTI *pd, FILE *fi1)
    {
     PRODOTTI d;
     int k;
     k=fscanf(fi1,"%d%s%d",&d.code,d.nome,&d.costo);
     if(k==3)
             {
              *pd=d;
              return 1;
             }
     return 0;
    }
int leggi(PESATE *pd, FILE *fi2)
      {
       PESATE pesata;
       int k;
       k=fscanf(fi2,"%d%f",&pesata.code,&pesata.peso);
       if (k==2)
          {
           *pd=pesata;
           return 1;
          }
       return 0;
      }
int lettura( PRODOTTI prodotti[N], FILE *fi1)
    {
     int i=0;
     int k;
     do
       {
        k=leggi(&prodotti[i],fi1);
        if (k)
           i++;
       }
     while (i<N && k);
     return i;
    }
float spesa(PRODOTTI prod, PESATE pesata)
    {
     float importo;
          importo=(prod.costo*pesata.peso);
          return(importo);
    }
int ricerca(PESATE pd,PRODOTTI prodotti[N],int b)
    {
     if (prodotti[b].code==pd.code)
     return (1);
     else
     return (0);
    }
void stampa(PRODOTTI prod, PESATE pesata, float spesa,FILE *fo)
     {
      PRODOTTI prodotti[N]; PESATE pes;
      int i,nele;
      fprintf(fo,"\n%2d\t  %-10s  %5d  £  %8.2f Kg  %10.2f
£",prod.code,prod.nome,prod.costo,pesata.peso,spesa);
     }
...
main()
      {
       PRODOTTI prodotti[N],d;PESATE pesata;
       int i=0,k,m,a,c,nele=0;
       float spes,totale;
       fprintf(fo,"\n\nCodice Prodotto   Costo unit.\t  Peso\t  Importo\n");
       a=lettura(prodotti,fi1);
       for(c=0; c<a; c++)
       {
        do
        {
          k=leggi(&pesata,fi2);
          if (k==1)
          {
           m=ricerca(pesata,prodotti,c);
           if(m==1)
                  {
                   spes=spesa(prodotti[c],pesata);
                   totale=totale+spes;
                   stampa(prodotti[c],pesata,spes,fo);
                   nele++;
                  };
          };
         }
        while(k!=0);
        rewind(fi2);
       };
        fprintf(fo,"\n\n N. pezzi :%2d \t Totale :%10.2f £ ",nele,totale);
        fclose(fo);
        fclose(fi1);
        fclose(fi2);
       return 0;
      }
Questa è una parte del codice, quello che vorrei fare è creare un'unica
funzione che mi sostituisca la prima leggi e la funzione lettura, e che,
possibilmente, mi eviti di definire all'inizio una costante N, vorrei in
pratica poter contare quanti elementi ho in lettura tra i prodotti e poi
adattare di conseguenza la dimensione degli array.
Per quanto riguarda l'uso dei vector...non so assolutamente come vadano
trattati, e comunque preferirei non dover modificare troppo radicalmente il
codice che ho già scritto...
Ancora grazie
manuela