MagPI 5 Page 21

De Le French MagPi
Aller à : Navigation, rechercher

le bloc d'instructions placé entre {} tant que la condition entre les parenthèses () est vraie.


La nouvelle fonction peut maintenant être utilisée dans un programme,

(début de code)

  • #include <stdio. h>
  • unsigned int factorial(unsigned int x);
  • int main()
  • {
  • unsigned int i = 3; /* Déclare un entier (int) et lui affecte la valeur trois. */
  • printf("%d! = %d\n" , i , factorial(i )); /* Affiche la factorielle de i */
  • return 0; /* Renvoie succès au système d'exploitation. */
  • }

(fin de code)

Quand une variable simple est passée en paramètre à une fonction, la valeur de la variable est copiée dans un nouvel emplacement en mémoire. Ce nouvel emplacement mémoire n'a aucun lien avec le premier emplacement mémoire. Par conséquent, si la valeur de x est modifiée à l'intérieur de la fonction factorial, la valeur de i restera trois après l'appel de la fonction. Les pointeurs peuvent être utilisés pour modifier ce comportement.


Pointeurs

Contrairement aux variables simples, un pointeur contient l'adresse d'un emplacement mémoire. L'emplacement mémoire peut être une variable simple, une fonction ou une structure quelconque. En général, le type du pointeur doit être le même que celui de la variable désignée par le pointeur. Quand ils sont implémentés correctement dans un programme, les pointeurs permettent d'obtenir un code très efficace. Un pointeur est déclaré en préfixant un nom de variable avec un astérisque. Par exemple, un pointeur de type int peut être déclaré avec,

(début de code)

  • int *p = 0; /* Déclare un pointeur p et lui affecte une adresse nulle. */

(fin de code)

L'adresse d'une autre variable peut alors être attribuée au pointeur,

(début de code)

  • int i ; /* Déclare un entier i . */
  • p = &i ; /* Affecte l'adresse de i à p. */

(fin de code)

L'affectation peut aussi se faire lors d'un appel de fonction,

(début de code)

  • #include <stdio. h>
  • void fun(int, int *); /* Une fonction sans valeur de retour. */
  • int main()
  • {
  • int np = 1, p = 1; /* Initialise deux variables entières */
  • printf("&np=%p, p=%p\n" , &np, &p); /* Affiche les adresses. */
  • printf(" Avant fun(): np=%d, p=%d\n" , np, p); /* Affiche les valeurs. */
  • fun(np, &p); /* Passe la valeur de np et l'adresse de p. */
  • return 0; /* Retourne succès au système d'exploitation. */
  • }
  • void fun(int np, int *p)
  • {
  • np = 2; /* Assigne 2 à la variable locale np. */
  • *p = 2; /* Assigne 2 à la mémoire pointée par p définie dans main. */
  • printf("&np=%p, p=%p\n" , &np, p); /* Affiche les adresses. */
  • }

(fin code)

Dans cet exemple, l'adresse de la variable p définie dans la fonction principale est passée au pointeur p de la fonction fun. La valeur dans cette adresse mémoire est alors modifiée par déréférencement du pointeur, grâce à l'utilisation d'un astérisque placé devant le nom du pointeur. Remarquez que lorsqu'un pointeur est déclaré il faut utiliser un astérisque. Cependant, lors de sa déclaration, il peut être se voir assigner une adresse au lieu d'une valeur.

Outils personnels
Espaces de noms

Variantes
Actions
Navigation
Boîte à outils