Funzioni nella programmazione C con esempi: ricorsivo e inline

Cos'è una funzione in C?

Funzione nella programmazione in C Una funzione è un blocco di codice riutilizzabile che rende un programma più facile da comprendere, testare e modificare senza dover cambiare il programma chiamante. Le funzioni dividono il codice e modularizzano il programma per ottenere risultati migliori ed efficaci. In breve, un programma più grande viene suddiviso in vari sottoprogrammi chiamati funzioni.

Quando si divide un programma di grandi dimensioni in varie funzioni, diventa facile gestire ciascuna funzione individualmente. Ogni volta che si verifica un errore nel programma, puoi facilmente indagare sulle funzioni difettose e correggere solo quegli errori. È possibile richiamare e utilizzare facilmente le funzioni ogni volta che sono necessarie, il che porta automaticamente a risparmiare tempo e spazio.

Biblioteca contro Funzioni definite dall'utente

Ogni programma 'C' ha almeno una funzione che è la funzione principale, ma un programma può avere un numero qualsiasi di funzioni. La funzione main () in C è il punto di partenza di un programma.

Nella programmazione 'C' le funzioni si dividono in due tipologie:

1. Funzioni di libreria
2. Funzioni definite dall'utente

La differenza tra la libreria e le funzioni definite dall'utente in C è che non è necessario scrivere un codice per una funzione di libreria. È già presente all'interno del file header che inseriamo sempre all'inizio di un programma. Devi solo digitare il nome di una funzione e usarlo insieme alla sintassi corretta. Printf, scanf sono esempi di funzioni di libreria.

Considerando che una funzione definita dall'utente è un tipo di funzione in cui dobbiamo scrivere il corpo di una funzione e chiamare la funzione ogni volta che richiediamo che la funzione esegua qualche operazione nel nostro programma.

Una funzione definita dall'utente in C è sempre scritta dall'utente, ma in seguito può essere parte della libreria 'C'. È un vantaggio importante della programmazione 'C'.

Le funzioni di programmazione C sono divise in tre attività come,

1. Dichiarazione di funzione
2. Definizione della funzione
3. Chiamata di funzione

Dichiarazione di funzione

La dichiarazione di una funzione consiste nello specificare il nome di una funzione all'interno di un programma. È un passaggio obbligatorio per poter utilizzare le funzioni nel codice. In una dichiarazione di funzione, specifichiamo semplicemente il nome della funzione che useremo nel nostro programma, proprio come avviene per la dichiarazione di una variabile. Non possiamo utilizzare una funzione se non è dichiarata nel programma. La dichiarazione di una funzione è anche chiamata "prototipo di funzione".

Le dichiarazioni di funzione (chiamate prototipo) vengono solitamente eseguite sopra la funzione main() e assumono la forma generale:

return_data_type function_name (data_type arguments);

• Il parametro return_data_type: indica il tipo di dati della funzione valore restituita all'istruzione chiamante.
• Il nome della funzione è seguito da parentesi
• I nomi degli argomenti, con le relative dichiarazioni di tipo di dati (facoltativamente), vengono inseriti tra parentesi.

Consideriamo il seguente programma che mostra come dichiarare una funzione cubo per calcolare il valore cubo di una variabile intera

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

Tieni presente che una funzione non restituisce necessariamente un valore. In questo caso viene utilizzata la parola chiave void.

Ad esempio, la dichiarazione della funzione output_message indica che la funzione non restituisce un valore: void output_message();

Definizione della funzione

La definizione di funzione significa semplicemente scrivere il corpo di una funzione. Il corpo di una funzione è costituito da istruzioni che eseguiranno un compito specifico. Il corpo di una funzione è costituito da una singola o da un blocco di istruzioni. È anche una parte obbligatoria di una funzione.

int add(int a,int b)	//function body	
{
	int c;
	c=a+b;
	return c;
}

Chiamata di funzione

Una chiamata di funzione significa chiamare una funzione ogni volta che è richiesta in un programma. Ogni volta che chiamiamo una funzione, questa esegue un'operazione per la quale è stata progettata. Una chiamata di funzione è una parte opzionale di un programma.

  result = add(4,5);

Ecco il codice completo:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

Produzione:

Addition:30

Argomenti della funzione

Gli argomenti di una funzione vengono utilizzati per ricevere i valori necessari dalla chiamata di funzione. Sono abbinati per posizione; il primo argomento viene passato al primo parametro, il secondo al secondo parametro e così via.

Per impostazione predefinita, gli argomenti vengono passati per valore, ovvero una copia dei dati viene fornita alla funzione chiamata. La variabile effettivamente passata non cambierà.

Consideriamo il seguente programma che dimostra i parametri passati per valore:

int add (int x, int y); 
int main() {
  int a, b, result;
  a = 5;
  b = 10;
  result = add(a, b);
  printf("%d + %d\ = %d\n", a, b, result);
return 0;}
int add (int x, int y) { 
x += y;
  return(x);}

L'output del programma è:

5 + 10 = 15

Tieni presente che i valori di a e b passati alla funzione di aggiunta non sono stati modificati perché solo il suo valore è stato passato nel parametro x.

Ambito variabile

Per ambito variabile si intende la visibilità delle variabili all'interno di un codice del programma.

In C, le variabili dichiarate all'interno di una funzione sono locali a quel blocco di codice e non possono essere referenziate dall'esterno della funzione. Tuttavia, le variabili dichiarate al di fuori di tutte le funzioni sono globali e accessibili dall'intero programma. Le costanti dichiarate con #define all'inizio di un programma sono accessibili dall'intero programma. Consideriamo il seguente programma che stampa il valore della variabile globale sia dalla funzione main che da una funzione definita dall'utente:

#include <stdio.h>
int global = 1348;
void test();
int main() {
  printf("from the main function : global =%d \n", global);
  test () ;
return 0;}

void test (){
printf("from user defined function : global =%d \n", global);}

Risultato:

from the main function : global =1348
from user defined function : global =1348

Discutiamo i dettagli del programma:

1. Dichiariamo una variabile globale intera con 1348 come valore iniziale.
2. Dichiariamo e definiamo una funzione test() che non accetta argomenti né restituisce un valore. Questa funzione stampa solo il valore della variabile globale per dimostrare che è possibile accedere alle variabili globali ovunque nel programma.
3. Stampiamo la variabile globale all'interno della funzione principale.
4. Chiamiamo la funzione test per stampare il valore della variabile globale.

In C, quando gli argomenti vengono passati ai parametri della funzione, i parametri agiscono come variabili locali che verranno distrutte all'uscita dalla funzione.

Quando si utilizza variabili globali, usateli con cautela perché possono causare errori e possono cambiare in qualsiasi punto del programma. Dovrebbero essere inizializzati prima dell'uso.

Variabili statiche

Le variabili statiche hanno un ambito locale. Tuttavia, non vengono distrutti quando si esce dalla funzione. Pertanto, una variabile statica mantiene il suo valore per sempre ed è possibile accedervi quando si reinserisce la funzione. Una variabile statica viene inizializzata quando dichiarata e necessita del prefisso static.

Il seguente programma utilizza una variabile statica:

#include <stdio.h>
void say_hi();
int main() {    
  int i;
  for (i = 0; i < 5; i++) { say_hi();}
   return 0;}
void say_hi() {
  static int calls_number = 1;
  printf("Hi number %d\n", calls_number);
  calls_number ++; }

Il programma visualizza:

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

Funzioni ricorsive

Consideriamo il fattoriale di un numero che si calcola come segue: 6! = 6 * 5 * 4 * 3 * 2 * 1.

Questo calcolo viene eseguito calcolando ripetutamente il fatto * (fatto -1) finché il fatto non equivale a 1.

Una funzione ricorsiva è una funzione che richiama se stessa e include una condizione di uscita per terminare le chiamate ricorsive. Nel caso del calcolo dei numeri fattoriali, la condizione di uscita è infatti pari a 1. La ricorsione funziona “impilando” le chiamate finché la condizione di uscita non è vera.

Per esempio:

#include <stdio.h>
int factorial(int number);
int main() {    
  int x = 6;
  printf("The factorial of %d is %d\n", x, factorial(x)); 
  return 0;}
int factorial(int number) {
 if (number == 1)    return (1); /* exiting condition */
  else
    return (number * factorial(number - 1));
}

Il programma visualizza:

 The factorial of 6 is 720

Qui di seguito, discutiamo i dettagli del programma:

1. Dichiariamo la nostra funzione fattoriale ricorsiva che accetta un parametro intero e restituisce il fattoriale di questo parametro. Questa funzione si chiamerà e diminuirà il numero fino all'uscita, o al raggiungimento della condizione base. Quando la condizione è vera, i valori generati in precedenza verranno moltiplicati tra loro e verrà restituito il valore fattoriale finale.
2. Dichiariamo e inizializziamo una variabile intera con valore”6″ e quindi stampiamo il suo valore fattoriale chiamando la nostra funzione fattoriale.

Considera il seguente schema per comprendere meglio il meccanismo ricorsivo che consiste nel chiamare la funzione stessa fino al caso base o all'arrestoping quando la condizione viene raggiunta, dopodiché raccogliamo i valori precedenti:

Funzioni in linea

La funzione nella programmazione C viene utilizzata per memorizzare le istruzioni utilizzate più frequentemente. Viene utilizzato per modularizzare il programma.

Ogni volta che viene chiamata una funzione, il puntatore dell'istruzione salta alla definizione della funzione. Dopo aver eseguito una funzione, il puntatore dell'istruzione ritorna all'istruzione da cui è passato alla definizione della funzione.

Ogni volta che usiamo le funzioni, abbiamo bisogno di qualcosa in più pointer head per passare alla definizione della funzione e tornare all'istruzione. Per eliminare la necessità di tali teste di puntamento, utilizziamo funzioni inline.

In una funzione inline, una chiamata di funzione viene sostituita direttamente da un codice di programma vero e proprio. Non salta a nessun blocco perché tutte le operazioni vengono eseguite all'interno della funzione inline.

Le funzioni inline vengono utilizzate principalmente per piccoli calcoli. Non sono adatti quando sono coinvolti calcoli di grandi dimensioni.

Una funzione inline è simile alla funzione normale, tranne per il fatto che la parola chiave inline è posizionata prima del nome della funzione. Le funzioni inline vengono create con la seguente sintassi:

inline function_name ()
{
    //function definition
}

Scriviamo un programma per implementare una funzione inline.

inline int add(int a, int b)		//inline function declaration
{
	return(a+b);
}
int main()
{
	int c=add(10,20);
	printf("Addition:%d\n",c);
	getch();
}

Produzione:

Addition: 30

Il programma sopra mostra l'uso di una funzione in linea per l'addizione di due numeri. Come possiamo vedere, abbiamo restituito l'addizione di due numeri solo all'interno della funzione inline senza scrivere righe aggiuntive. Durante la chiamata alla funzione abbiamo appena passato i valori sui quali dobbiamo eseguire l'addizione.

DOMANDE FREQUENTI