ITA - Appunti Cpp 011 - Funzioni

August 2024 (1767 Words, 10 Minutes)

Funzioni

Introduzione

Una funzione è un blocco di codice che viene eseguito solo quando viene chiamato. È possibile passare dati, parametri e informazioni alle funzioni. Le funzioni sono utilizzate per isolare il codice che esegue determinate operazioni, rendendolo più riutilizzabile e gestibile.

Il linguaggio C++ fornisce funzioni predefinite, come main(), che contiene il codice principale del programma. È possibile importare altre librerie e utilizzare le funzioni definite in esse.

La chiamata a una funzione richiede:

• il push dell’indirizzo di ritorno nello stack,
• il push degli argomenti nello stack,
• il passaggio al corpo della funzione e l’esecuzione di un’istruzione return al termine della funzione.

Come dichiarare una funzione

Per definire o dichiarare una funzione è necessario specificare il nome, seguito dai parametri:

void Funzione(/* parametri */) {
  // codice
}

Parametri e valori di ritorno

Parametri passati per valore

Il passaggio di parametri per valore è un modo comune per passare informazioni a una funzione. In questo modo, la funzione lavora su una copia del dato.

#include <iostream>

// Definizione del prototipo
int somma(int x, int y);

int main() {
    int a = 5;
    int b = 6;
    int risultato = somma(a, b);
    std::cout << "Il risultato della somma è: " << risultato << std::endl;
    return 0;
}

// Definizione della funzione
int somma(int x, int y) {
    return x + y;
}

Parametri passati per riferimento

Nel passaggio di parametri per riferimento, alla funzione viene passato l’indirizzo dell’argomento, non il valore. Questo approccio richiede meno memoria rispetto al passaggio per valore e consente di modificare il valore delle variabili esterne alla funzione.

#include <iostream>

// Definizione del prototipo
int somma(int &x, int &y);

int main() {
    int a = 5;
    int b = 6;
    int risultato = somma(a, b);
    std::cout << "Il risultato della somma è: " << risultato << std::endl;
    return 0;
}

// Definizione della funzione
int somma(int &x, int &y) {
    return x + y;
}

Parametri passati per puntatore

Il passaggio per indirizzo è simile a quello per riferimento, ma è necessario passare alla funzione i puntatori degli argomenti.

#include <iostream>

// Definizione del prototipo
int somma(int* x, int* y);

int main() {
    int a = 5;
    int b = 6;
    int risultato = somma(&a, &b);
    std::cout << "Il risultato della somma è: " << risultato << std::endl;
    return 0;
}

// Definizione della funzione
int somma(int* x, int* y) {
    return *x + *y;
}

Valori di ritorno

Per restituire un valore, la funzione può usare l’istruzione return.

Valori di default per i parametri

È possibile fornire valori predefiniti per i parametri della funzione. Ad esempio:

#include <iostream>

// Definizione del prototipo con valori di default
int somma(int x = 0, int y = 0);

int main() {
    int a = 5;
    int b = 6;
    std::cout << "Il risultato della somma è: " << somma(a, b) << std::endl;
    std::cout << "Il risultato della somma di default è: " << somma() << std::endl;
    return 0;
}

// Definizione della funzione
int somma(int x, int y) {
    return x + y;
}

Questo esempio stampa 11 quando la funzione è chiamata con parametri e 0 quando è chiamata con i valori di default.

Overloading delle Funzioni

L’overloading permette di definire più funzioni con lo stesso nome ma con parametri diversi. I parametri possono differire per tipo, numero o ordine.

#include <iostream>

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

int main() {
    int ia = 1, ib = 2;
    double da = 3, db = 4;
    float fa = 5, fb = 6;

    std::cout << "Somma int: " << somma(ia, ib) << std::endl;
    std::cout << "Somma double: " << somma(da, db) << std::endl;
    std::cout << "Somma float: " << somma(fa, fb) << std::endl;

    return 0;
}

Passare Array a Funzioni

In C e C++ ci sono tre modi per passare un array a una funzione:

return_type foo(array_type array_name[size], ...);
return_type foo(array_type* array_name, int size, ...);
return_type foo(tipo_array* nome_array, ...);

Per gli array multidimensionali:

#include <iostream>

const int M = 3;
const int N = 3;

void print(int arr[M][N]) {
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << arr[i][j] << " ";
        }
    }
}

int main() {
    int arr[M][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    print(arr);
    return 0;
}

Oppure:

#include <iostream>

const int N = 3;

void print(int arr[][N], int m) {
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << arr[i][j] << " ";
        }
    }
}

int main() {
    int arr[3][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    print(arr, 3);
    return 0;
}

Regole degli Scope

Le variabili dichiarate all’interno del blocco di codice di una funzione possono essere accedute solo dall’interno della funzione stessa.

Funzioni Inline

Le funzioni inline sono definite con la keyword inline e vengono sostituite dal loro corpo durante la compilazione, riducendo l’overhead della chiamata alla funzione.

Funzioni Ricorsive

La ricorsione è il processo di definizione di un’operazione in termini di se stessa. Un esempio classico è il calcolo del fattoriale:

Versione Iterativa:

#include <iostream>
using namespace std;

int fat(int n) {
    int f = 1;
    for (int j = 1; j <= n; ++j) f *= j;
    return f;
}

int main() {
    cout << fat(4);
    return 0;
}

Versione Ricorsiva:

#include <iostream>
using namespace std;

int rfat(int n) {
    if (n == 1) return 1;
    return rfat(n - 1) * n;
}

int main() {
    cout << rfat(5);
    return 0;
}

La funzione ricorsiva rfat chiama se stessa fino a raggiungere il caso base n == 1. La ricorsione può essere più naturale per alcuni algoritmi, ma può comportare un maggior utilizzo dello stack e può essere più lenta delle soluzioni iterative.

Conclusione

Le funzioni sono un concetto fondamentale in C++ che migliorano la modularità e la riusabilità del codice. Sia che tu stia passando parametri per valore, puntatore o riferimento, utilizzando l’overloading o scrivendo funzioni ricorsive, la comprensione e l’uso efficace delle funzioni sono essenziali per diventare un programmatore C++ competente.

Riferimenti

• parametri-per-valore-o-per-riferimento
• functions-default-arguments-in-c-c-only
• function-overloading-c
• how-arrays-are-passed-to-functions-in-cc
• scope-rules
• inline-functions-cpp
• inline-functions-cpp/
• cpp_functions_recursion
• ricorsione

© 2024 Stefano Prina

Quest'opera è distribuita con Licenza Creative Commons Attribuzione - Condividi allo stesso modo 4.0 Internazionale


Theme  Moonwalk