const array [] [] come parametro formale in C - mancata corrispondenza

Question

Voglio foo() non modificare la matrice. Così ho dichiarato array in foo() come const

Se compilo questo codice, il compilatore si lamenta:

#include <stdio.h> 

void foo(const int arr[5][5]) 
{ 
    int i,j; 
    for(i = 0; i < 5; i++) 
    { 
     for(j = 0; j < 5; j++) 
     {  
      printf("%d\n", arr[i][j]); 
     }  
    } 
} 
int main() 
{ 
    int val = 0; 
    int i,j; 
    int arr[5][5]; 
    for(i = 0; i < 5; i++) 
    { 
     for(j = 0; j < 5; j++) 
     {  
      arr[i][j] = val++; 
     }  
    } 
    foo(arr); 
} 

L'avvertimento è:

parametro

allocate.c: In function 'main': 
allocate.c:26:9: warning: passing argument 1 of 'foo' from incompatible pointer type 
    foo(arr); 
     ^
allocate.c:3:6: note: expected 'const int (*)[5]' but argument is of type 'int (*)[5]' 
void foo(const int arr[5][5]) 
    ^

Come altro posso dichiarare formale costante?

Answer 1

Suppongo che non si voglia che foo() sia in grado di modificare la matrice nell'interesse dell'incapsulamento.

Come probabilmente sapete, in C gli array vengono passati in funzioni per riferimento. Per questo motivo, tutte le modifiche che foo() effettua all'array dei valori verranno propagate nuovamente alla variabile in main(). Questo non è nell'interesse dell'incapsulamento.

const non impedirà a foo() di modificare l'array La parola chiave const const indica che qualcosa non è modificabile. Un puntatore const non può modificare l'indirizzo a cui punta. Il/i valore/i all'indirizzo può essere modificato. In c, per impostazione predefinita, non è possibile assegnare un nuovo valore puntatore a un nome di matrice. Non c'è bisogno di const. Simile a un puntatore const, i valori in questo array possono essere modificati. Il problema dell'incapsulamento non è risolto.

Per incapsulare foo() dalla funzione main(), posizionare l'array in una struttura. Le strutture vengono passate per valore e quindi foo() riceverà una copia dei dati. Poichè ha una copia, foo() non sarà in grado di alterare i dati originali. Le tue funzioni sono incapsulate.

Solution (che funziona!):

#include <stdio.h> 

typedef struct 
{ 
    int arr[5][5]; 
} stct; 

void foo(const stct bar) 
{ 
    int i,j; 
    for(i = 0; i < 5; i++) 
    { 
     for(j = 0; j < 5; j++) 
     {  
      printf("%d\n", bar.arr[i][j]); 
     }  
    } 
} 
int main() 
{ 
    int val = 0; 
    int i,j; 
    stct bar; 
    for(i = 0; i < 5; i++) 
    { 
     for(j = 0; j < 5; j++) 
     {  
      bar.arr[i][j] = val++; 
     }  
    } 
    foo(bar); 
} 

ho messo const nella foo() definizione perché hai chiesto come si potrebbe dichiarare il parametro formale come una costante. Funziona ma non è necessario.

void foo(stct bar) 

La rimozione di const non interromperà la funzione.