Sei sulla pagina 1di 7

Funzioni con matrici e vettori

Una volta dichiarati o inizializzati dei vettori o delle matrici in un programma, per agire su di esse mediante
delle funzioni, necessariamente dovremo usare funzioni by reference. Nel caso (che non analizzeremo) in
cui vettori e matrici verranno letti (o determinati) e stampati all’interno di una funzione di tipo void (e non
nel main), non sarà necessario l’impiego delle funzioni by reference.

Invece, per agire tramite funzioni su vettori e matrici già dichiarati, usiamo funzioni di tipo by reference
perché quando un array è passato ad una funzione, quello che deve essere passato è l’indirizzo di memoria
del suo elemento iniziale. Dunque struttureremo funzioni di questo tipo tramite l’ausilio di puntatori a
vettori e le proprietà che legano questi ultimi ai vettori.

ESEMPIO:

// Questo programma stampa tramite una funzione un vettore inizializzato nel main

#include<stdio.h>

#define DIM 5

void input_vett(int* puntatore);

int main() { int conta[DIM] = {1,2,3,4,5};

int* pnt;
pnt = &conta[0];

input_vett(pnt);

void input_vett(int* puntatore) { int vett[DIM];


int cnt;

printf("Il vettore letto e': ");


for(cnt=0; cnt<DIM; cnt++) printf("%d ", *(puntatore+cnt));
}
Ora, ricordando che se pnt = &conta[0] -> pnt = conta, possiamo sfoltire il codice ulteriormente. Solo,
bisogna specificare che nell’argomento della funzione, al posto del puntatore, non possiamo mettere
solamente, ad esempio, “int vett”, perché la funzione deve trattare la variabile che riceve dal main come un
vettore e non come un intero; dunque sarà necessario inserire “int vett[]”. Ricordiamo infatti che anche se
c’è equivalenza di notazione e, spesso, di uso, i puntatori e i vettori sono due cose differenti, dunque è più
corretto usare “vett[]”. Vediamo il codice:

#include<stdio.h>

#define DIM 5

void input_vett(int vett[]);

int main() { int conta[DIM] = {1,2,3,4,5};

input_vett(conta); // Qui non ci sono problemi nell’inserire “conta”, perchè nel main conta è
definito come un vettore e sarà trattato come tale

void input_vett(int vett[]) { int cnt;

printf("Il vettore letto e': ");


for(cnt=0; cnt<DIM; cnt++) printf("%d ", vett[cnt]);
}
Se la dimensione del vettore è dinamica, o comunque non è espressa da una costante define esterna al
main, allora è necessario inserirla fra i parametri che la funzione attende in input. Questo perché la
funzione non lavorerà con le stesse variabili del main, dunque non possiamo usare il nome della variabile
usata per la dimensione del vettore (dim, ad esempio), come tetto per il ciclo for di riempimento e, per
questo, la passiamo come informazione in input alla funzione.

ESEMPIO:

// Questo programma legge un vettore nel main ed usa una funzione per stamparlo

#include<stdio.h>

void input_vett(int vett[], int dim);

int main() { int dim_conta = 5;

int conta[dim_conta], cnt;

for(cnt=0; cnt<dim_conta; cnt++) { printf("Inserisci l’elemento %d del vettore: ", cnt);


scanf("%d", &conta[cnt]);
}

input_vett(conta, dim_conta);

void input_vett(int vett[], int dim) { int cnt;

printf("Il vettore letto e': ");


for(cnt=0; cnt<dim; cnt++) printf("%d ", vett[cnt]);
}

Per le matrici, il procedimento è molto simile (ricordiamo che anche le matrici sono vettori). Alcune
precisazioni, tuttavia, sono necessarie.

Prima di tutto, ricordiamo che il computer non “vede” le matrici come tabelle, o griglie, ma come un
vettore in cui ogni elemento è esso stesso un vettore. Per questo motivo (non approfondiremo perché è un
discorso complesso e non utile ai fini pratici, in questa fase) nel passare il puntatore della matrice alla
funzione, dobbiamo specificare il numero di colonne. Basti sapere che il compilatore userà un certo indice
k, calcolato come segue, per muoversi all’interno della matrice attraverso gli indirizzi di memoria:

k = ( i * DIM_COLONNE ) + j

Dove i e j sono gli indici che usiamo per muoverci all’interno della matrice.
ESEMPIO:

Si faccia il caso di una matrice con 4 righe e 6 colonne. Consideriamo il numero corrispondente alla
posizione (1,3) della matrice. Per come stiamo procedendo, vogliamo che il compilatore faccia riferimento
al contenuto dell’indirizzo di memoria corrispondente all’indirizzo di memoria della prima cella più un certo
valore, che sarà proprio l’indice k.

k = (1 * 6) + 3 = 9

Infatti, l’elemento corrispondente alla posizione (1,3) si trova a 9 celle di distanza dal primo elemento:
ESEMPIO:
// Questo programma usa una funzione per leggere e stampare una matrice quadrata di dimensione prefissata
ESEMPIO:
// Questo programma usa una funzione per leggere e stampare una matrice quadrata di stabilita dall’utente (bisogna inserire la dimensione fra i parametri della
funzione, in maniera analoga a quanto si è visto con i vettori)
ESEMPIO:
// Questo programma usa una funzione per leggere e stampare una matrice con dimensione di righe e colonne di stabilita dall’utente (bisogna inserire la dimensione
delle righe e quella delle colonne fra i parametri della funzione, in maniera analoga a quanto si è visto con i vettori)