Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - esercizio C - vettore e matrice
Forum - C/C++ - esercizio C - vettore e matrice

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
dodo154 (Normal User)
Newbie


Messaggi: 14
Iscritto: 07/02/2011

Segnala al moderatore
Postato alle 9:37
Lunedì, 07/02/2011
salve a tutti!
sono nuovo del sito, avrei un quesito da proporre a voi che sicuramente siete più esperti.
Ho quest'esercizio:
In un file binario è memorizzata una sequenza non ordinata di numeri(pari e dispari);
il numero di questi interi è dispari;
dichiarare, chiamare e definire opportune funzioni che sono in grado di allocare in memoria dinamica, una matrice quadrata la cui dimensione è uguale all'elemento che sta al centro della sequenza;
inizializzare la matrice con tutti gli interi presenti nel file (escluso l'intero che stabilisce la dimensione);
riempire le restanti celle della matrice allocata con zero.

ho abbozzato qualche riga di codice ma... non funge; qualcuno di voi può darmi una mano?
vi ringrazio in anticipo
Codice sorgente - presumibilmente C++

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. int** carica(int*,int***);
  5. void stampa(int,int***);  
  6.  
  7. int main(void)
  8. {
  9.        
  10.         int** matrice=NULL;
  11.         int dim=0;
  12.         matrice=carica(&dim,&matrice);
  13.         stampa(dim,&matrice);
  14.         return 0;
  15. }
  16.  
  17. int** carica(int* dim, int*** mat)
  18. {
  19. FILE* fp;
  20. int i,j,ele;
  21. int conta=0;
  22. int k=0;
  23. int z=0;  // indice del vettore
  24. int* vett;
  25.  
  26. fp=fopen("immagine.dat","rb");
  27.  
  28. while(!feof(fp))
  29.         conta++;  //voglio sapere il numero degli elementi
  30.  
  31. conta= conta/2;  // ho il numero degli elementi della prima parte
  32.  
  33. rewind(fp);
  34.  
  35. for(i=0;i<conta+1;i++)
  36.         fread(dim,sizeof(int), 1, fp);
  37.  
  38. rewind(fp);
  39.  
  40. //allocazione dinamica vettore
  41. conta=conta*2;    // vettore di soli elementi escluso l'elemento centrale del file binario
  42. vett=malloc(sizeof(int)*conta);
  43. i=0;
  44.  
  45. for(;i<conta/2;i++)
  46.         fread(&vett[i],sizeof(int),1,fp);
  47.  
  48.         fseek(fp,4,1); //salto i 4 byte dell'elemento centrale
  49.  
  50.         for(;i<conta/2;i++)
  51.                 fread(&vett[i],sizeof(int),1,fp);
  52.  
  53.         fclose(fp);
  54. //allocazione dinamica matrice
  55.  
  56. *mat=malloc((*dim)*sizeof(int*));
  57.  
  58.         for(i=0;i<*dim;i++)
  59.                 *mat[i]=malloc(sizeof(int)*(*dim));
  60.  
  61.  
  62. /*inserimento in matrice*/
  63.  
  64.  
  65. for(i=0;i<*dim && z<conta;i++)
  66.         {
  67.                
  68.                 for(j=0;j<*dim && z<conta;j++)
  69.                         {
  70.                         (*mat)[i][j]=vett[z];
  71.                         z++;
  72.                         }
  73.                
  74.         }
  75.  
  76.         if(z==(*dim)*(*dim))     //caso particolare in cui il numero degli elementi dell'array concide esattamente con gli elementi della matrice
  77.                 return *mat;
  78.  
  79.                
  80.         else if(j==*dim)
  81.                         {
  82.                                 i++;    // altrimenti passa alla nuova  riga
  83.                                 j=0;
  84.                                 if(i==*dim)
  85.                                         return *mat;
  86.                         }
  87.  
  88. // ora avrò i e j corrispondenti alla posizione dove comincia l'assegnamento degli zeri
  89.  
  90.  
  91.         while(j!=*dim)
  92.         {
  93.                 (*mat)[i][j]= 0; // completo la riga di zeri
  94.                 j++;
  95.         }
  96.  
  97.  
  98. for(;i<*dim;i++)
  99.         {
  100.                 for(j=0;j<*dim ;j++)
  101.                         {
  102.                         (*mat)[i][j]=0;
  103.                         }
  104.         }
  105. return *mat;
  106.  
  107. }
  108.  
  109. void stampa(int dim, int*** mat)
  110. {
  111.         int i,j;
  112.         for(i=0;i<dim;i++)
  113.         {
  114.                 for(j=0;j<dim;j++)
  115.                 {
  116.                         printf("%d\t", (*mat)[i][j]);
  117.                 }
  118.                 printf("\n\n");
  119.         }


PM Quote
Avatar
Premoli (Normal User)
Pro


Messaggi: 108
Iscritto: 25/06/2009

Segnala al moderatore
Postato alle 10:42
Lunedì, 07/02/2011
Ciao!!!

Premetto che non ho visto per bene il codice, comunque i primi errori che mi sono saltati all'occhio sono i seguenti:

Codice sorgente - presumibilmente Plain Text

  1. while(!feof(fp))
  2.         conta++;



in questo modo il puntatore al file rimarrà sempre all'inizio, per scorrere il file devi fare, almeno, una lettura fittizia.

Poi non mi spiego un'altra cosa perché ritorni il puntatore alla matrice? Stai passando la matrice per indirizzo quindi non c'è bisogno di far ritornare alcunché, inoltre stai commettendo un errore nell'allocazione della matrice, piccolo suggerimento ricordati la precedenza degli operatori.

Poi non mi è chiara tutta la parte finale della funzione carica, ma probabilmente questo è dovuto al fatto che non ho ben capito l'esercizio, se puoi posta la traccia.

PM Quote
Avatar
dodo154 (Normal User)
Newbie


Messaggi: 14
Iscritto: 07/02/2011

Segnala al moderatore
Postato alle 12:59
Lunedì, 07/02/2011
allora....
la traccia è quella che ho scritto prima; cerco di spiegarla meglio.

Allora io ho in un file binario una sequenza di numeri. La sequenza è dispari.
L'elemento centrale(medio) della sequenza, deve essere l'elemento che genererà la matrice quadrata.
Nella matrice generata dinamicamente dovrò allocare prima la sequenza dei numeri (tranne il numero centrale) e poi se avanzano dei posti, in quelli restanti inserire zero.
Alla fin fine stampare a video  o a file la matrice.
Esempio:
ho memorizzato in un file binario questa sequenza di 5 numeri:
1  2  3  4  5
l'elemento centrale(medio) è il 3; 3 sarà il numero che allocherà la matrice quindi la matrice sarà 3x3 quindi di 9 "celle".
x x x
x x x
x x x
Nella matrice allocata dinamicamente, dovrò inserire prima la sequenza dei numeri (o se vogliamo chiamarla vettore)  [tranne l'elemento centrale] e dopo nei restanti posti zero.
Quindi se ho 9 posti la matrice sarà questa:
1 2 4
5 0 0  
0 0 0
E poi stamparla a schermo o a file.

Spero di esser stato più chiaro....

Attendo tue...
ti ringrazio per l'aiuto!

PM Quote
Avatar
Premoli (Normal User)
Pro


Messaggi: 108
Iscritto: 25/06/2009

Segnala al moderatore
Postato alle 14:16
Lunedì, 07/02/2011
allora io farei così

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define DIM 5
  5.  
  6. void carica(int*, int***);
  7. void stampa(int, int**);
  8.  
  9. int main(void)
  10. {
  11.     int **matrice=NULL;
  12.     int dim=0, i;
  13.     int vet[DIM];
  14.     FILE *fp;
  15.  
  16.     for(i=0; i<DIM; i++){
  17.         printf("\nInserire un numero: ");
  18.         scanf("%d", &vet[i]);
  19.     }
  20.  
  21.     fp=fopen("immagine.dat", "wb");
  22.  
  23.     fwrite(vet, sizeof(int), DIM, fp);
  24.     fclose(fp);
  25.  
  26.     printf("\nFile creato...\n");
  27.     getchar();
  28.  
  29.     carica(&dim, &matrice);
  30.     stampa(dim, matrice);
  31.     return 0;
  32. }
  33.  
  34. void carica(int* dim, int*** mat)
  35. {
  36.     FILE* fp;
  37.     int i,j;
  38.     int conta=0;
  39.     int z=0;
  40.     int* vett;
  41.  
  42.     fp=fopen("immagine.dat","rb");
  43.  
  44.     while(!feof(fp)){
  45.         conta++;  //voglio sapere il numero degli elementi
  46.         fread(dim, sizeof(int), 1, fp);
  47.     }
  48.  
  49.     conta--;
  50.     conta= conta/2;  // ho il numero degli elementi della prima parte
  51.  
  52.     rewind(fp);
  53.  
  54.     for(i=0;i<conta+1;i++)
  55.         fread(dim,sizeof(int), 1, fp);
  56.  
  57.     rewind(fp);
  58.  
  59. //allocazione dinamica vettore
  60.  
  61.     conta=(conta*2);    // vettore di soli elementi escluso l'elemento centrale del file binario
  62.     vett=malloc(sizeof(int)*conta);
  63.     i=0;
  64.  
  65.     for(;i<conta/2;i++)
  66.         fread(&vett[i],sizeof(int),1,fp);
  67.  
  68.     fseek(fp,sizeof(int),1); //salto i 4 byte dell'elemento centrale
  69.  
  70.     for(;i<conta;i++)
  71.         fread(&vett[i],sizeof(int),1,fp);
  72.  
  73. //allocazione dinamica matrice
  74.     fclose(fp);
  75.  
  76.     *mat=(int **)malloc((*dim)*sizeof(int*));
  77.  
  78.     for(i=0;i<*dim;i++)
  79.         (*mat)[i]=(int *)malloc(sizeof(int)*(*dim));
  80.  
  81. /*inserimento in matrice*/
  82.  
  83.     for(i=0; i<*dim; i++){
  84.         for(j=0; j<*dim; j++){
  85.             (*mat)[i][j]=0;
  86.         }
  87.     }
  88.  
  89.     for(i=0;i<*dim && z<conta;i++){
  90.         for(j=0;j<*dim && z<conta;j++){
  91.             (*mat)[i][j]=vett[z];
  92.             z++;
  93.         }
  94.     }
  95. }
  96.  
  97. void stampa(int dim, int** mat)
  98. {
  99.     int i,j;
  100.  
  101.     printf("\n\n");
  102.  
  103.     for(i=0;i<dim;i++){
  104.         for(j=0;j<dim;j++){
  105.             printf("%d\t", mat[i][j]);
  106.         }
  107.         printf("\n\n");
  108.     }
  109. }



ho modificato un po' il main per creare di volta in volta il file, se vuoi puoi togliere quella parte.
Dimmi se c'è qualcosa che non capisci.

PM Quote
Avatar
dodo154 (Normal User)
Newbie


Messaggi: 14
Iscritto: 07/02/2011

Segnala al moderatore
Postato alle 15:20
Lunedì, 07/02/2011
perfetto... ho capito come hai ragionato...
soltanto che, al posto di rendera statica la dimensione e cioè al posto di definirla con define, non si può dire:
inserire il numero di componenti del vettore?
e quindi poi di li prendere il tutto...?
ti ringrazio per l'aiuto..

Ultima modifica effettuata da dodo154 il 07/02/2011 alle 15:25
PM Quote
Avatar
Premoli (Normal User)
Pro


Messaggi: 108
Iscritto: 25/06/2009

Segnala al moderatore
Postato alle 16:38
Lunedì, 07/02/2011
Certo che si può...

PM Quote
Avatar
dodo154 (Normal User)
Newbie


Messaggi: 14
Iscritto: 07/02/2011

Segnala al moderatore
Postato alle 18:42
Lunedì, 07/02/2011
se non ti chiedo troppo... puoi gentilmente... farmi veder come...?

PM Quote
Avatar
Premoli (Normal User)
Pro


Messaggi: 108
Iscritto: 25/06/2009

Segnala al moderatore
Postato alle 20:57
Lunedì, 07/02/2011
Puoi usare l'allocazione dinamica, esattamente come hai fatto per il vettore nella funzione carica.

Provaci se poi non ci riesci chiedi pure...

PM Quote
Avatar
dodo154 (Normal User)
Newbie


Messaggi: 14
Iscritto: 07/02/2011

Segnala al moderatore
Postato alle 22:25
Lunedì, 07/02/2011
così dovrebbe andare....
dammi conferma...
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4.  
  5. void carica(int*, int***);
  6. void stampa(int, int**);
  7.  
  8. int main(void)
  9. {
  10.     int **matrice=NULL;
  11.     int i=0, j;
  12.     FILE *fp;
  13.     int N;
  14.     int *v;
  15.  
  16.     fp=fopen("immagine.dat", "wb");
  17.     printf("creazione del file binario\n");
  18.     do{
  19.       printf("inserisci il numero di componenti del vettore: \n");
  20.       scanf("%d", &N);
  21.     }while(N%2==0);
  22.    
  23.     v=(int*)malloc(sizeof(int)*N);
  24.     N=N/2;
  25.    
  26.     for(i=0; i<N; i++){
  27.         printf("\nInserisci la %d^componente: ",i+1);
  28.         scanf("%d", &v[i]);
  29.         fwrite(&v[i],sizeof(int),1,fp);
  30.     }
  31.    
  32.     printf("\n inserisci elemento centrale: ");
  33.     scanf("%d", &v[i]);
  34.     fwrite(&v[i],sizeof(int),1,fp);
  35.     i++;
  36.      
  37.     for(j=0;j<N;j++){
  38.         printf("\n inserisci la %d^ componente: ", i+1);
  39.         scanf("%d", &v[i]);
  40.         fwrite(&v[i],sizeof(int),1,fp);
  41.         i++;
  42.     }
  43.  
  44.    
  45.     fclose(fp);
  46.  
  47.     printf("\nFile creato...\n");
  48.     getchar();
  49.  
  50.     carica(&N, &matrice);
  51.     stampa(N, matrice);
  52.     return 0;
  53. }
  54.  
  55. void carica(int* N, int*** mat)
  56. {
  57.     FILE* fp;
  58.     int i,j;
  59.     int conta=0;
  60.     int z=0;
  61.     int* vett;
  62.  
  63.     fp=fopen("immagine.dat","rb");
  64.  
  65.     while(!feof(fp)){
  66.         conta++;  //voglio sapere il numero degli elementi
  67.         fread(N, sizeof(int), 1, fp);
  68.     }
  69.  
  70.     conta--;
  71.     conta= conta/2;  // ho il numero degli elementi della prima parte
  72.  
  73.     rewind(fp);
  74.  
  75.     for(i=0;i<conta+1;i++)
  76.         fread(N,sizeof(int), 1, fp);
  77.  
  78.     rewind(fp);
  79.  
  80. //allocazione dinamica vettore
  81.  
  82.     conta=(conta*2);    // vettore di soli elementi escluso l'elemento centrale del file binario
  83.     vett=malloc(sizeof(int)*conta);
  84.     i=0;
  85.  
  86.     for(;i<conta/2;i++)
  87.         fread(&vett[i],sizeof(int),1,fp);
  88.  
  89.     fseek(fp,sizeof(int),1); //salto i 4 byte dell'elemento centrale
  90.  
  91.     for(;i<conta;i++)
  92.         fread(&vett[i],sizeof(int),1,fp);
  93.  
  94. //allocazione dinamica matrice
  95.     fclose(fp);
  96.  
  97.     *mat=(int **)malloc((*N)*sizeof(int*));
  98.  
  99.     for(i=0;i<*N;i++)
  100.         (*mat)[i]=(int *)malloc(sizeof(int)*(*N));
  101.  
  102. /*inserimento in matrice*/
  103.  
  104.     for(i=0; i<*N; i++){
  105.         for(j=0; j<*N; j++){
  106.             (*mat)[i][j]=0;
  107.         }
  108.     }
  109.  
  110.     for(i=0;i<*N && z<conta;i++){
  111.         for(j=0;j<*N && z<conta;j++){
  112.             (*mat)[i][j]=vett[z];
  113.             z++;
  114.         }
  115.     }
  116. }
  117.  
  118. void stampa(int N, int** mat)
  119. {
  120.     int i,j;
  121.    
  122.     printf("\n\n");
  123.  
  124.     for(i=0;i<N;i++){
  125.         for(j=0;j<N;j++){
  126.             printf("%d\t", mat[i][j]);
  127.         }
  128.         printf("\n\n");
  129.     }
  130. }


PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo