[C]Matrice dinamica di dimensione presa da file

di Anonimizzato8302 il 08 feb 2011, 21:02

23 risposte

Anonimizzato8302

Utente anonimizzato

08 feb 2011, 21:34

Ho un file di interi e sò solo che il numero totale degli interi è dispari. Della sequenza del file devo leggere l'intero centrale (ad es. se ho 13 interi devo leggere il 7). Il valore di questo intero è la dimensione della matrice quadrata che devo allocare dinamicamente. Dopo averla allocata dinamicamente, la devo riempire con gli interi del file, tranne quello che mi ha dato la dimensione. Se gli interi del file sono di meno degli elementi che può contenere la matrice, allora quelli rimanenti gli inizializzo a zero.

Non ho errori in compilazione, ma in esecuzione

Ecco il codice che ho scritto:

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

void alloca_matrice(int***,int*,int*);
void riempi_matrice(int***,int,int);
void stampa(int**,int);

int main()
{
    int** matrice;
    int dimensione=0;
    int elementi=0;
    
    alloca_matrice(&matrice,&dimensione,&elementi);
    riempi_matrice(&matrice,dimensione,elementi);
    stampa(matrice,dimensione);
    system("pause");
    return 0;    
}

void alloca_matrice(int***m,int*dim,int*num)
{
     FILE* fp=NULL;
     int i;
     int end=0;
     fp=fopen("seq.dat","rb");
     fseek(fp,0,SEEK_END);
     end=ftell(fp);
     fseek(fp,0,SEEK_SET);
     while((ftell(fp))!=end)
     {
                            (*num)++;
                            fseek(fp,sizeof(int),SEEK_CUR);
                          
     }
     *dim=((*num)/2);
     fseek(fp,(*dim)*sizeof(int),SEEK_SET);
     fread(dim,sizeof(int),1,fp);
     if(((*dim)*(*dim))<(*num))
     {
         printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
         exit(1);
     }
     else
     {    
          *m=malloc((*dim)*sizeof(int));
          for(i=0;i<(*dim);i++);
          {
                         (*m)=malloc((*dim)*sizeof(int));
          }
      }    
     fclose(fp);
  
}  

void riempi_matrice(int*** m,int dim,int num)
{
     FILE*fp=NULL;
     int i,j;
     int flag=0;
     fp=fopen("seq.dat","rb");
     do
     {
          for(i=0;i<dim;i++)
          {
                    for(j=0;j<dim;j++)
                    {
                        if(flag==((num/2)+1))
                        {}
                        else
                        {
                            fread((&m)[j],sizeof(int),1,fp);   f21 
                            flag++;
                          
                        }
                    }
          }    
     }
     while((i+j)<num);
     for(;i<dim;i++)
          {
                    for(;j<dim;j++)
                    {
                           (*m)[j]=0;
                    }
          }
     fclose(fp);
    
}

void stampa(int** m,int dim)
{
     int i,j;
     for(i=0;i<dim;i++)
     {
                       for(j=0;j<dim;j++)
                       {
                                         printf("%d", m[j]);
                       }
                       printf("/n");
     }
}

indica dove attraverso il debug ho notato che mi dà errore. Per la precisione mi dà errore la seconda volta che la esegue, a causa del ciclo

23 Risposte

Anonimizzato7532

Utente anonimizzato

08 feb 2011, 22:00

Parti da correggere


*m=malloc((*dim)*sizeof(int));
for(i=0;i<(*dim);i++);
{
      (*m)=malloc((*dim)*sizeof(int));
}


fread((&m)[j],sizeof(int),1,fp);

usa il debugger e trova gli errori.

/
Anonimizzato8302
Utente anonimizzato
09 feb 2011, 16:24
Ho usato il debugger e il problema è l'fread della funzione riempi_matrice. Mi dà errore la seconda volta che il ciclo passa da lì, Errore di segmentazione
/
Anonimizzato7532
Utente anonimizzato
09 feb 2011, 16:52
Ti ho detto di correggere gli errori, cosa hai corretto?
/
Anonimizzato8302
Utente anonimizzato
09 feb 2011, 17:21
Ho aggiustato gli errori da te segnalati e qualcun altro sempre dello stesso tipo
/
Anonimizzato7532
Utente anonimizzato
09 feb 2011, 17:29
E così dificile piazzare il codice corretto?

Anonimizzato8302

Utente anonimizzato

09 feb 2011, 17:36

Scusa....


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

void alloca_matrice(int***,int*,int*);
void riempi_matrice(int***,int,int);
void stampa(int**,int);

int main()
{
    int** matrice=NULL;
    int dimensione=0;
    int elementi=0;
    
    alloca_matrice(&matrice,&dimensione,&elementi);
    riempi_matrice(&matrice,dimensione,elementi);
    stampa(matrice,dimensione);
    system("pause");
    return 0;    
}

void alloca_matrice(int***m,int*dim,int*num)
{
     FILE* fp=NULL;
     int i;
     int end=0;
     fp=fopen("seq.dat","rb");
     fseek(fp,0,SEEK_END);
     end=ftell(fp);
     fseek(fp,0,SEEK_SET);
     while((ftell(fp))!=end)
     {
                            (*num)++;
                            fseek(fp,sizeof(int),SEEK_CUR);
                         
     }
     *dim=((*num)/2);
     fseek(fp,(*dim)*sizeof(int),SEEK_SET);
     fread(dim,sizeof(int),1,fp);
     if(((*dim)*(*dim))<(*num))
     {
         printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
         exit(1);
     }
     else
     {    
          *m=malloc((*dim)*sizeof(int));
          for(i=0;i<(*dim);i++);
          {
                         (*m)[i]=malloc((*dim)*sizeof(int));
          }
      }    
     fclose(fp);
    
}

void riempi_matrice(int*** m,int dim,int num)
{
     FILE*fp=NULL;
     int i,j;
     int flag=0;
     fp=fopen("seq.dat","rb");
     do
     {
          for(i=0;i<dim;i++)
          {
                    for(j=0;j<dim;j++)
                    {
                        if(flag==((num/2)+1))
                        {}
                        else
                        {
                            fread((&m)[i][j],sizeof(int),1,fp);
                            flag++;
                            printf("\n%d    %d      %d        %d",i,j,num,flag);
                        }
                    }
          }    
     }
     while((i+j)<num);
     for(;i<dim;i++)
     {
                    for(;j<dim;j++)
                    {
                        (*m)[i][j]=0;
                    }
     }        
     fclose(fp);
 
}

void stampa(int** m,int dim)
{
     int i,j;
     for(i=0;i<dim;i++)
     {
                       for(j=0;j<dim;j++)
                       {
                                         printf("%d", m[i][j]);
                       }
                       printf("/n");
     }
}

/
Anonimizzato7532
Utente anonimizzato
09 feb 2011, 17:38
Continuiamo a non esserci. Non ti voglio dire l'errore perche voglio che ci arrivi da solo (tanto so che c'è la fai).
```
*m=malloc((*dim)*sizeof(int));
```
e
```
fread((&m)[i][j],sizeof(int),1,fp);
```
/
Anonimizzato8302
Utente anonimizzato
09 feb 2011, 18:07
Ho cambiato la prima funzione, passando il doppio puntatore per argomento, visto che era inutile passarlo per indirizzo.
Per quanto riguarda la seconda linea di codice la matrice essendo passata per indirizzo la sintassi dovrebbe essere questa. Cmq ho fatto alcune prove e togliendo la & mi dà errore di segmentazione sulla fread, e nn al terzo giro del ciclo, e quindi questa nn è la soluzione.
Nn so che pesci pigliare
/
Anonimizzato7532
Utente anonimizzato
09 feb 2011, 18:10
Il primo allocamento si fa col doppio puntatore.
```
*m=malloc((*dim)*sizeof(int *));
```
il secondo se hai cambiato i parametri non so.
/
Anonimizzato8302
Utente anonimizzato
09 feb 2011, 23:40
Quindi devo presumere che il secodo errore che avevi trovato era la e commerciale(&). giusto?
/
Anonimizzato7532
Utente anonimizzato
09 feb 2011, 23:47
Posta le modifiche che hai fatto nel pasaggio parametri.

Anonimizzato8302

Utente anonimizzato

10 feb 2011, 00:34

Con passaggio del doppio puntatore per indirizzo:


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

void alloca_matrice(int***,int*,int*);
void riempi_matrice(int***,int,int);
void stampa(int**,int);

int main()
{
    int** matrice=NULL;
    int dimensione=0;
    int elementi=0;
    
    alloca_matrice(&matrice,&dimensione,&elementi);
    riempi_matrice(&matrice,dimensione,elementi);
    stampa(matrice,dimensione);
    system("pause");
    return 0;    
}

void alloca_matrice(int***m,int*dim,int*num)
{
     FILE* fp=NULL;
     int i;
     int end=0;
     fp=fopen("seq.dat","rb");
     fseek(fp,0,SEEK_END);
     end=ftell(fp);
     fseek(fp,0,SEEK_SET);
     while((ftell(fp))!=end)
     {
                            (*num)++;
                            fseek(fp,sizeof(int),SEEK_CUR);
     }
     *dim=((*num)/2);
     fseek(fp,(*dim)*sizeof(int),SEEK_SET);
     fread(dim,sizeof(int),1,fp);
     if(((*dim)*(*dim))<(*num))
     {
         printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
         exit(1);
     }
     else
     {    
          *m=malloc((*dim)*sizeof(int));
          for(i=0;i<(*dim);i++);
          {
                         (**m)[i]=malloc((*dim)*sizeof(int));
          }
      }    
     fclose(fp);
}

void riempi_matrice(int*** m,int dim,int num)
{
     FILE*fp=NULL;
     int i,j;
     int flag=0;
     fp=fopen("seq.dat","rb");
     do
     {
          for(i=0;i<dim;i++)
          {
                    for(j=0;j<dim;j++)
                    {
                        if(flag==((num/2)+1))
                        {}
                        else
                        {
                            fread((&m)[i][j],sizeof(int),1,fp);
                            flag++;
                            printf("\n%d    %d      %d        %d",i,j,num,flag);
                        }
                    }
          }    
     }
     while((i+j)<num);
     for(;i<dim;i++)
     {
                    for(;j<dim;j++)
                    {
                        (*m)[i][j]=0;
                    }
     }        
     fclose(fp);
}

void stampa(int** m,int dim)
{
     int i,j;
     for(i=0;i<dim;i++)
     {
                       for(j=0;j<dim;j++)
                       {
                                         printf("%d", m[i][j]);
                       }
                       printf("/n");
     }
}

Con passaggio del doppio puntatore per argomento:


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

void alloca_matrice(int***,int*,int*);
void riempi_matrice(int***,int,int);
void stampa(int**,int);

int main()
{
    int** matrice=NULL;
    int dimensione=0;
    int elementi=0;
    
    alloca_matrice(&matrice,&dimensione,&elementi);
    riempi_matrice(&matrice,dimensione,elementi);
    stampa(matrice,dimensione);
    system("pause");
    return 0;    
}

void alloca_matrice(int**m,int*dim,int*num)
{
     FILE* fp=NULL;
     int i;
     int end=0;
     fp=fopen("seq.dat","rb");
     fseek(fp,0,SEEK_END);
     end=ftell(fp);
     fseek(fp,0,SEEK_SET);
     while((ftell(fp))!=end)
     {
                            (*num)++;
                            fseek(fp,sizeof(int),SEEK_CUR);
     }
     *dim=((*num)/2);
     fseek(fp,(*dim)*sizeof(int),SEEK_SET);
     fread(dim,sizeof(int),1,fp);
     if(((*dim)*(*dim))<(*num))
     {
         printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
         exit(1);
     }
     else
     {    
          m=malloc((*dim)*sizeof(int));
          for(i=0;i<(*dim);i++);
          {
                         (*m)[i]=malloc((*dim)*sizeof(int));
          }
      }    
     fclose(fp);
}

void riempi_matrice(int*** m,int dim,int num)
{
     FILE*fp=NULL;
     int i,j;
     int flag=0;
     fp=fopen("seq.dat","rb");
     do
     {
          for(i=0;i<dim;i++)
          {
                    for(j=0;j<dim;j++)
                    {
                        if(flag==((num/2)+1))
                        {}
                        else
                        {
                            fread((&m)[i][j],sizeof(int),1,fp);
                            flag++;
                            printf("\n%d    %d      %d        %d",i,j,num,flag);
                        }
                    }
          }    
     }
     while((i+j)<num);
     for(;i<dim;i++)
     {
                    for(;j<dim;j++)
                    {
                        (*m)[i][j]=0;
                    }
     }        
     fclose(fp);
}

void stampa(int** m,int dim)
{
     int i,j;
     for(i=0;i<dim;i++)
     {
                       for(j=0;j<dim;j++)
                       {
                                         printf("%d", m[i][j]);
                       }
                       printf("/n");
     }
}

Anonimizzato7532

Utente anonimizzato

10 feb 2011, 00:42

Prendiamo il primo caso visto che è in coerenza con le dichiarazioni delle funzioni mentre il secondo non lo è.


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

    void alloca_matrice(int***,int*,int*);
    void riempi_matrice(int***,int,int);
    void stampa(int**,int);

    int main()
    {
        int** matrice=NULL;
        int dimensione=0;
        int elementi=0;
       
        alloca_matrice(&matrice,&dimensione,&elementi);
        riempi_matrice(&matrice,dimensione,elementi);
        stampa(matrice,dimensione);
        system("pause");
        return 0;   
    }

    void alloca_matrice(int***m,int*dim,int*num)
    {
         FILE* fp=NULL;
         int i;
         int end=0;
         fp=fopen("seq.dat","rb");
         fseek(fp,0,SEEK_END);
         end=ftell(fp);
         fseek(fp,0,SEEK_SET);
         while((ftell(fp))!=end)
         {
                                (*num)++;
                                fseek(fp,sizeof(int),SEEK_CUR);
         }
         *dim=((*num)/2);
         fseek(fp,(*dim)*sizeof(int),SEEK_SET);
         fread(dim,sizeof(int),1,fp);
         if(((*dim)*(*dim))<(*num))
         {
             printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
             exit(1);
         }
         else
         {   
              *m=malloc((*dim)*sizeof(int*));
              for(i=0;i<(*dim);i++);
              {
                             (*m)[i]=malloc((*dim)*sizeof(int));
              }
          }   
         fclose(fp);
    }

    void riempi_matrice(int*** m,int dim,int num)
    {
         FILE*fp=NULL;
         int i,j;
         int flag=0;
         fp=fopen("seq.dat","rb");
         do
         {
              for(i=0;i<dim;i++)
              {
                        for(j=0;j<dim;j++)
                        {
                            if(flag==((num/2)+1))
                            {}
                            else
                            {
                                fread(&(*m)[i][j],sizeof(int),1,fp);
                                flag++;
                                printf("\n%d    %d      %d        %d",i,j,num,flag);
                            }
                        }
              }   
         }
         while((i+j)<num);
         for(;i<dim;i++)
         {
                        for(;j<dim;j++)
                        {
                            (*m)[i][j]=0;
                        }
         }       
         fclose(fp);
    }

    void stampa(int** m,int dim)
    {
         int i,j;
         for(i=0;i<dim;i++)
         {
                           for(j=0;j<dim;j++)
                           {
                                             printf("%d", m[i][j]);
                           }
                           printf("/n");
         }
    }

/
Anonimizzato8302
Utente anonimizzato
10 feb 2011, 01:33
Ok

Devi accedere o registrarti per scrivere nel forum

23 risposte

Recruiting IT

Vuoi inserire un Annuncio di Lavoro su iProgrammatori.it?

OFFRO LAVORO

Aziende che cercano personale IT

Pubblica offerte lavoro IT
Accedi al Database CV

Iscrizione Aziende

CERCO LAVORO

Sviluppatori e informatici che cercano lavoro

Crea un profilo professionale
Candidati alle offerte di lavoro

Iscrizione Informatici

Discussioni recenti

Conta gli 1 di un numero binario

25/08/2026 Sgrubak
Come sostituire un Vector compatibile con ChannelSftp?

25/08/2026 ZioCrick
determinazione data

25/08/2026 sihsandrea
Errore di lettura di una cella di un file ods

25/08/2026 ZioCrick
Dall'editoria con curiosità e fascinazione

21/08/2026 lele2006

Ultime offerte di lavoro

Tech Lead Android
Dev world srl

25/08/2026 Remoto
Remote Working
Tech Lead IOS
Dev world srl

25/08/2026 Remoto
Remote Working
React & React Native Developer
Faboci Srl

25/08/2026 Milano
Smart Working
Android Developer
Itconsulting srl

24/08/2026 Milano
Smart Working
Senior Network Engineer CISCO ACI
Herzum Software S.R.L. Unipersonale

24/08/2026 Verona
In sede

Vai alle offerte di lavoro

[C]Matrice dinamica di dimensione presa da file

23 Risposte

Chi siamo

Link utili

Contatti