Programmation en C :

10. Fonctions et procédures

codecommentaire
/* prog10a.c */
#include <stdio.h>
int n;
float x; double y;

int estpositif(int entier) {
  return (entier>=0);
}
double puissance(float reel, int entier) {
  double resultat=1;
  while (entier>0) {
    resultat=resultat*reel;
    entier--;
  }
  return resultat;
}
main() {
  printf("\nentier? "); scanf("%d",&n);
  printf("\nreel? "); scanf("%f",&x);
  if (estpositif(n)) {
  y=puissance(x,n);
  printf("\n%f^%d=%g\n",x,n,y);
  }
} 		Les fonctions sont définies sur le même principe que la fonction main.

estpositif :
  Entiers relatif → Booléens,
  e → e est-il positif ?

puissance :
  Réels × Entiers naturels → Réels,
  (r,e) → re.
N.B. Cette fonction est robuste car elle retourne une valeur même si l'entier e n'est pas positif.
/* prog10b.c */
#include <stdio.h>
int n;
float x; double y;

int estpositif(int n) {
  return (n>=0);
}
double puissance(float x, int n) {
  double y=1;
  if (!estpositif(n)) return 0;
  while (n>0) {
    y=y*x;
    n--;
  }
  return y;
}
main() {
  printf("\nentier? "); scanf("%d",&n);
  printf("\nreel? "); scanf("%f",&x);
  y=puissance(x,n);
  printf("\n%f^%d=%g\n",x,n,y);
} 		Une fonction doit être définie avant toute autre fonction qui l'utilise.

Il peut y avoir plusieurs fois l'instruction return dans une fonction, mais une seule sera exécutée et mettra fin à la fonction.

Contrairement à la version précédente, les mêmes noms de variables ont été choisis ici pour des paramètres de fonction (variables locales) et pour des variables globales du programme. Les variables globales n, x, et y, ainsi que la variable locale n de la fonction estpositif, seront donc inaccessibles à l'intérieur de la fonction puissance (notion de portée des variables).
N.B. On préfèrera donner des noms différents et explicites aux paramètres des fonctions.
/* prog10c.c */
#include <stdio.h>
int n;

void saisir() {
  printf("entier ? ");
  scanf("%d",&n);
}
void afficher() {
  printf("n=%d\n",n);
}
main() {
  saisir();
  afficher();
} 		En C, une procédure est une fonction qui ne retourne rien. On s'est servi ici des procédures pour structurer lisiblement le programme.
/* prog10d.c */
#include <stdio.h>
int n, p;

void saisir(int * ae) {
  printf("entier ? ");
  scanf("%d",ae);
}
void afficherfois(int fois) {
  for (int i=0;i<fois;i++) printf("encore...");
}
main() {
  saisir(&n);
  afficherfois(n);
  saisir(&p);
  afficherfois(p);
} 		Une fonction (et donc aussi une procédure) peut prendre en paramètre l'adresse d'une variable. Ici, saisir(&n) prend en paramètre l'adresse de la variable globale n (passage par adresse) qui sera modifiée par effet de bord (side effect) ; par contre afficherfois(int fois) ne cherche pas à modifier la variable fois (passage par valeur).

N.B. A partir du C99, on peut déclarer une variable au niveau très local d'un for.
/* prog10d.c */
#include <stdio.h>
#define taillemax 10

int T[taillemax]={0};
int n;

int saisirtaille() {
  int e;
  printf("taille du tableau ? ");
  scanf("%d",&e);
  if (e<0) return 0;
  if (e>taillemax) return taillemax;
  return e;
}
void saisirtableau(int tableau[], int taille) {
  int i;
  for (i=0;i<taille;i++) {
    printf("tableau[%d] ? ",i);
    scanf("%d",&tableau[i]);
  }
}
void affichertableau(int tableau[], int taille) {
  int i;
  if (taille>taillemax) taille=taillemax;
  printf("\ntableau=[");
  for (i=0;i<taille;i++) printf(" %d",tableau[i]);
  printf(" ]");
}
main() {
  n=saisirtaille();
  printf("\n");
  saisirtableau(T,n);
  affichertableau(T,n);
} 		saisirtaille:
  void → Entiers
  → e∈[0..taillemax]
effet de bord : saisie au clavier d'une valeur entière.

saisirtableau:
  Tableaux d'entiers × Entiers → void
  Tableau[] × taille →
effet de bord : Tableau[] rempli de taille valeurs (avec un maximum de taillemax).

affichertableau:
  Tableaux d'entiers × Entiers → void
  Tableau[] × taille →
Effet de bord : Affichage des taille éléments de Tableau[] (dans la limite de taillemax éléments).

N.B. Comme les fonctions de C ne peuvent renvoyer que des types simples, il faut utiliser un effet de bord pour modifier un tableau passé en paramètre dans une fonction. (Un tableau T est en C un pointeur sur son premier élément T[0] et c'est ce pointeur qu'on passe en paramètre.)

Les fonctions de saisie et d'affichage du tableau contrôlent la taille du tableau afin qu'elle reste dans l'intervalle autorisé [0..taillemax].