Funzioni nella programmazione C con esempi: ricorsivo e inline

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 funzione significa scrivere il nome di un programma. È una parte obbligatoria per l'utilizzo delle funzioni nel codice. In una dichiarazione di funzione, specifichiamo semplicemente il nome di una funzione che utilizzeremo nel nostro programma come dichiarazione di variabile. Non possiamo usare una funzione a meno che non sia dichiarata in un programma. Una dichiarazione di funzione è anche chiamata “Funzione prototipo. "

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);

• Migliori tipo_dati_ritorno: è il tipo di dati della funzione valore restituita all'istruzione chiamante.
• Migliori nome_funzione: è seguito da parentesi
• argomenti i nomi con le rispettive dichiarazioni del tipo di dati vengono opzionalmente 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 in cui 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 è possibile fare riferimento all'esterno della funzione. Tuttavia, le variabili dichiarate all'esterno di tutte le funzioni sono globali e accessibili dall'intero programma. Costanti dichiarate con a #define in cima a un programma sono accessibili dall'intero programma. Consideriamo il seguente programma che stampa il valore della variabile globale sia dalla funzione principale che da quella 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

Considera il fattoriale di un numero calcolato 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.

Sintesi

• Una funzione è un miniprogramma o un sottoprogramma.
• Le funzioni vengono utilizzate per modularizzare il programma.
• Libreria e definita dall'utente sono due tipi di funzioni.
• Una funzione è costituita da una dichiarazione, un corpo della funzione e una parte di chiamata di funzione.
• La dichiarazione della funzione e il corpo sono obbligatori.
• Una chiamata di funzione può essere facoltativa in un programma.
• Il programma C ha almeno una funzione; è la funzione principale ().
• Ogni funzione ha un nome, un tipo di dati, un valore restituito o un vuoto, parametri.
• Ogni funzione deve essere definita e dichiarata nel programma C.
• Tieni presente che è ordinario variabili in una funzione C vengono distrutti non appena usciamo dalla chiamata di funzione.
• Gli argomenti passati a una funzione non verranno modificati perché sono passati per valore e nessuno per indirizzo.
• L'ambito variabile viene definito visibilità delle variabili all'interno di un programma
• Sono presenti variabili globali e locali Programmazione C.