[C]-Riempimento Array bi-dimensionale

[Manu_eighty_sev]

Salve a tutti, ho un problema con un Array bi-dimensionale. Supponiamo che io debba creare una funzione che mi riempie una matrice(nel caso specifico la voglio riempire di zeri), alla funzione passerò il puntatore alla matrice e le sue dimensioni:

riempi(int **matrice,int i,int j){
int x,y; 

for(x = 0;x<=i-1;x++){ 
  
   for(y = 0;y<=j-1;y++){ 
     
      *(*(matrice+x)+y) = 0; 

                 printf("%d",*(*(matrice + x)+y));

          } 
          printf("\n"); 
    } 
} 

nel main definisco la mia matrice, e poi richiamo su di essa la mia funzione:

main(){

int matrice[4][4]; 

riempi(matrice,4,4); 

system("pause"); 

} 

Il codice viene compilato, una volta lanciato va in crash dopo aver scritto la prima riga della matrice:



Il codice mi sembra "logicamente" corretto, ma evidentemente sbaglio in qualcosa.
Ho iniziato da poco con il C in ambito universitario.

PS Credo che il problema sia nel passaggio dei parametri alla funzione, in quanto lo stesso codice schiaffato direttamente nel main non crea alcun problema..
Grazie in anticipo

[antotan]

Guarda qui:

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

riempi(int** matrice,int i,int j){ 

int x,y; 

    for(x = 0;x<=i-1;x++)
    {    
        for(y = 0;y<=j-1;y++)
        {       
            *(*(matrice+x)+y) = x+y;
            printf("%d ",*(*(matrice + x)+y)); 
        } 
        printf("\n"); 
    } 
}

int main()
{
    const int n = 4;
    int i;
    
    int** mat = (int**)malloc(n * sizeof(int*));
    for(i = 0; i < n; i++)
        mat[i] = (int*)malloc(n * sizeof(int));
        
    riempi(mat, n, n);    
        
    for(i = 0; i < n; i++)
        free(mat[i]);
    free(mat);    
} 

nota la differenza (spero di non aver fatto errori sull'allocazione dinamica, sono un pò arrugginito col C).
Tra l'altro il compilatore non ti ha dato un warning tipo questo?

main.c: In function ‘main’:
main.c:22: warning: passing argument 1 of ‘riempi’ from incompatible pointer type
main.c:4: note: expected ‘int **’ but argument is of type ‘int (*)[4]’

[YuYevon]

Nel caso non avessi trattato ancora l'allocazione dinamica della memoria che suggeriva antotan

(

Ho iniziato da poco con il C in ambito universitario.

)

puoi risolvere la cosa anche con una matrice statica, ma il passaggio dei parametri alla funzione va fatto diversamente: in C le matrici vengono allocate per righe in memoria, e per farlo c'è bisogno di sapere ogni riga quanto è lunga, ossia in pratica quante colonne ha la matrice (il numero di colonne si chiama appunto "Leading Dimension of Array", LDA, che in Fortran ad esempio è invece il numero di righe giacché l'allocazione avviene per colonne).

Detto questo, puoi risolvere così:

#include <stdio.h>

void riempi(int matrice[][4], int i, int j)
{
        int x, y;

        for (x = 0; x < i; x++) {    
                for (y = 0; y < j; y++) {       
                        matrice[x][y] = x + y;
                        printf("%d ", matrice[x][y]);
                }
                putchar('\n');
        }
}

int main(void)
{
        int mat[4][4];
        
        riempi(mat, 4, 4);    
        
        return 0;    
}

senza contare comunque che la dimensione (o le dimensioni) statica dell'array potrebbe essere definita con una costante simbolica (direttiva #define) in maniera tale da rendere più semplice eventuali cambiamenti e anche da evitare il passaggio delle dimensioni come parametri della funzione, che risulterebbero inutili.