Appeler-par-référence
Faire une appeler-par-référence de fonction, au lieu de passer la variable elle-même, passent l'adresse de la variable. L'adresse de la variable peut être prise en employant et l'opérateur. Les appels suivants une fonction d'échange passant l'adresse des variables au lieu des valeurs réelles.
swap(&x, &y);
Déréférencier
Le problème que nous avons est maintenant que l'échange de fonction a été passé à l'adresse plutôt qu'à la variable, ainsi nous devons déréférencier les variables de sorte que nous regardions les valeurs réelles plutôt que les adresses des variables afin de les permuter.
Déréférencier est réalisé dans C en employant la notation d'indicateur (*). En termes simples, ceci signifie placer a * avant chacun variable avant de l'employer pour qu'il se rapporte à la valeur de la variable plutôt qu'à son adresse. Le programme suivant illustre la passer-par-référence pour permuter deux valeurs.
#include <stdio.h>
void swap(int *x, int *y);
int main()
{
int x=6, y=10;
printf("Before the function swap, x = %d and y =
%d\n\n", x, y);
swap(&x, &y);
printf("After the function swap, x = %d and y =
%d\n\n", x, y);
return 0;
}
void swap(int *x, int *y)
{
int temp = *x;
*x = *y;
*y = temp;
}
Voyons le rendement du programme :
Before the function swap, x = 6 and y = 10
After the function swap, x = 10 and y = 6 |
Les fonctions peuvent être récursives qui est une fonction peut s'appeler. Chaque appel à lui-même exige que l'état actuel de la fonction est poussé sur la pile. Il est important de se rappeler ce fait car il est facile de créer un débordement de pile, c.-à-d. la pile a manqué de l'espace à l'endroit plus de données.
L'exemple suivant calcule le factoriel d'un nombre en utilisant la récursion. Un factoriel est un nombre multiplié par chaque autre nombre entier au-dessous de lui-même, vers le bas à 1. Par exemple, le factoriel du numéro 6 est :
Factorial 6 = 6 * 5 * 4 * 3 * 2 * 1
Par conséquent le factoriel de 6 est 720. Il peut voir de l'exemple ci-dessus ces 6 factoriels = 6 * 5 factoriels. De même, 5 factoriels = 5 * 4 factoriels, et ainsi de suite.
Ce qui suit est la règle générale pour calculer des nombres factoriels.
factorial(n) = n * factorial(n-1)
La règle ci-dessus se termine quand n = 1, en tant que factoriel de 1 est 1. Essayons de la comprendre mieux avec l'aide de l'exemple :
#include <stdio.h>
long int factorial(int num);
int main()
{
int num;
long int f;
printf("Enter a number: ");
scanf("%d", &num);
f = factorial(num);
printf("factorial of %d is %ld\n", num, f);
return 0;
}
long int factorial(int num)
{
if (num == 1)
return 1;
else
return num * factorial(num-1);
}
Voyons le rendement de l'exécution de ce programme :
Enter a number: 7
factorial of 7 is 5040 |
|
