PASSAGGGIO PER VALORE E PER RIFERIMENTO

In informatica, quando una funzione o un metodo riceve degli argomenti, questi possono essere passati in due
modi principali: per valore o per riferimento. Il modo in cui i parametri vengono passati influisce su come
vengono manipolati all'interno della funzione e se le modifiche fatte a quei parametri influenzano i valori originali
fuori dalla funzione.
1. Passaggio per valore
Quando un parametro viene passato per valore, la funzione riceve una copia del valore dell'argomento originale.
Ogni modifica fatta a questo parametro all'interno della funzione non influisce sul valore originale al di fuori della
funzione.
Esempio (in linguaggio C):
void incrementa(int a) {
a = a + 1;
}

int main() {
int x = 5;
incrementa(x);
// x rimane 5, perché solo una copia di x è stata passata alla funzione
return 0;
}
In questo caso, il valore di x rimane invariato fuori dalla funzione, perché è stata passata una copia di x.
2. Passaggio per riferimento
Quando un parametro viene passato per riferimento, la funzione riceve un riferimento o un "puntatore"
all'argomento originale, quindi ogni modifica fatta al parametro influenza direttamente il valore originale.
Esempio (in linguaggio C++):
void incrementa(int &a) {
a = a + 1;
}

int main() {
int x = 5;
incrementa(x);
// x diventa 6, perché è stato passato per riferimento
return 0;
}
Qui, il valore di x viene effettivamente modificato perché la funzione ha un riferimento diretto alla variabile x, non
una copia.
Differenze principali:
 Passaggio per valore: la funzione lavora su una copia del dato, quindi le modifiche fatte all'interno della funzione non
alterano il dato originale.
 Passaggio per riferimento: la funzione lavora sul dato originale attraverso un riferimento, quindi le modifiche fatte
nella funzione alterano direttamente il dato originale.

MATRICI
n C++, una matrice (o array multidimensionale) è una struttura di dati che permette di memorizzare valori in più
dimensioni. La più comune è la matrice bidimensionale (o array 2D), che può essere vista come una tabella con
righe e colonne. Le matrici consentono di gestire e accedere a insiemi di dati organizzati in più direzioni o livelli,
facilitando l'elaborazione di informazioni complesse, come immagini, tabelle, grafici e molto altro.

Dichiarazione di una matrice in C++

Per dichiarare una matrice in C++, è necessario specificare il tipo di dati, il numero di righe e colonne.
Sintassi per una matrice bidimensionale (array 2D):
tipo nome_matrice[righe][colonne];
Ad esempio, per dichiarare una matrice di interi 3x4 (3 righe e 4 colonne):
cpp
Copia codice
int matrice[3][4];
Questa matrice ha 3 righe e 4 colonne, e ciascun elemento può essere identificato con un doppio indice, dove il
primo indice rappresenta la riga e il secondo indice rappresenta la colonna.
Inizializzazione di una matrice
È possibile inizializzare una matrice al momento della dichiarazione.
Esempio:
int matrice[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
In questo esempio, la matrice ha 2 righe e 3 colonne, e gli elementi vengono riempiti con i valori indicati.
Accesso agli elementi di una matrice
Gli elementi di una matrice possono essere accessibili utilizzando gli indici delle righe e delle colonne.
Esempio:
int x = matrice[1][2]; // Accede all'elemento della seconda riga, terza colonna
Iterare su una matrice
Puoi usare due cicli annidati per iterare su una matrice bidimensionale: uno per le righe e uno per le colonne.
Esempio:
#include <iostream>
using namespace std;

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

// Iterare su tutte le righe e le colonne

for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
cout << matrice[i][j] << " ";
}
cout << endl;
}

return 0;
}
Matrici di dimensioni maggiori
C++ supporta anche matrici con più di due dimensioni. Una matrice tridimensionale, ad esempio, può essere vista
come una serie di "tabelle" bidimensionali.
Esempio di una matrice tridimensionale:
int matrice[2][3][4]; // 2 livelli, con 3 righe e 4 colonne ciascuno
Allocazione dinamica delle matrici
Se non si conosce in anticipo la dimensione della matrice, è possibile utilizzare l'allocazione dinamica per creare
una matrice con dimensioni definite durante l'esecuzione del programma. Questo può essere fatto usando
puntatori e la funzione new.
Esempio di allocazione dinamica di una matrice 2D:
int righe = 3, colonne = 4;
int** matrice = new int*[righe];
for (int i = 0; i < righe; i++) {
matrice[i] = new int[colonne];}

FUNZIONI
In C++, una funzione è un blocco di codice riutilizzabile che esegue un'operazione specifica. Le funzioni
consentono di dividere il codice in moduli, facilitando la leggibilità, la manutenzione e il riuso. Ciascuna funzione
può accettare degli argomenti (input) ed eventualmente restituire un valore (output).
Struttura di una funzione in C++
Una funzione in C++ ha generalmente la seguente struttura:
tipo_di_ritorno nome_funzione(tipi_parametri parametri) {
// corpo della funzione
return valore; // opzionale, dipende dal tipo di ritorno}
 tipo_di_ritorno: indica il tipo di dato che la funzione restituirà (ad esempio, int, float, void se la funzione non restituisce
alcun valore).
 nome_funzione: il nome identificativo della funzione.
 parametri: (opzionale) sono le variabili passate alla funzione come input. Possono essere di diversi tipi.
 corpo della funzione: il blocco di codice che definisce cosa fa la funzione.
 return: (opzionale) restituisce un valore, che deve essere dello stesso tipo del tipo_di_ritorno della funzione.
Dichiarazione e definizione di una funzione
Le funzioni possono essere dichiarate prima del loro utilizzo e definite separatamente.
Dichiarazione (prototipo):
Una dichiarazione di funzione indica il tipo di ritorno, il nome e i parametri della funzione senza il corpo. Viene fatta
prima di chiamare la funzione, solitamente all'inizio del programma.
int somma(int a, int b); // prototipo della funzione
Definizione:
La definizione della funzione contiene il codice effettivo che esegue l'operazione.
int somma(int a, int b) {
return a + b;
}
Esempio completo:
#include <iostream>
using namespace std;

// Prototipo della funzione

int somma(int a, int b);
int main() {
int x = 5, y = 3;

// Chiamata della funzione

int risultato = somma(x, y);

cout << "La somma è: " << risultato << endl;

return 0;
}

// Definizione della funzione

int somma(int a, int b) {
return a + b;}

Chiamata di una funzione

Per richiamare una funzione, basta usare il suo nome seguito dai parametri tra parentesi, se ne ha.
risultato = somma(5, 3);

Tipi di funzioni
1. Funzioni senza parametri e senza valore di ritorno
Se una funzione non riceve parametri e non restituisce alcun valore, il tipo di ritorno sarà void.
void saluto() {
cout << "Ciao!" << endl;
}

int main() {
saluto(); // Chiamata della funzione
return 0;
}
2. Funzioni con parametri
Una funzione può accettare uno o più parametri. Durante la chiamata della funzione, i parametri vengono passati
per valore o per riferimento.
int moltiplica(int a, int b) {
return a * b;
}
3. Funzioni con valore di ritorno
Le funzioni possono restituire un valore, che può essere utilizzato successivamente.
double dividi(double a, double b) {
return a / b;}

Passaggio di parametri per valore e per riferimento

Passaggio per valore:
Quando i parametri vengono passati per valore, la funzione lavora su una copia dei dati, quindi le modifiche ai
parametri non influenzano le variabili originali.
void incrementa(int a) {
a = a + 1;}
Passaggio per riferimento:
Quando i parametri vengono passati per riferimento, la funzione lavora sui dati originali, quindi le modifiche ai
parametri modificano direttamente le variabili originali.
void incrementa(int &a) {
a = a + 1;}
Funzioni ricorsive
Una funzione ricorsiva è una funzione che si richiama da sola.
Esempio di funzione ricorsiva per calcolare il fattoriale:
int fattoriale(int n) {
if (n <= 1) return 1;
return n * fattoriale(n - 1);
}
int main() {
cout << "Fattoriale di 5: " << fattoriale(5) << endl;
return 0;
}
In questo esempio, la funzione fattoriale continuaa chiamare se stessa fino a quando il valore di n non è uguale o
inferiore a 1, risolvendo il problema in modo iterativo.
Conclusione
Le funzioni in C++ sono un potente strumento per organizzare il codice in blocchi riutilizzabili e modulari. Usarle in
modo efficace migliora la leggibilità del programma e rende il codice più facile da mantenere e aggiornare.