Examinons le programme ci‑dessous :

#include <stdio.h>

double cube(double x)
{
  return x * x * x;
}

int main(void)
{ 
  for (int a = 0; a <= 10; a++) {
    printf("%2d³ = %g\n", a, cube(a));
  }
  return 0;
}

On y trouve les éléments suivants :

• Aux lignes nº 3 à 6 est codée la définition de la fonction mathématique cube : x ⟼ x³ (ℝ ⟶ ℝ).
• La ligne nº 3 constitue son en‑tête de définition (header) avec dans l'ordre :
• son type de valeurs retournées double ;
• son identificateur cube ;
• son (seul) argument formel identifié par x, qui est de type double.
• Le corps de définition de la fonction est un bloc ne comprenant qu'une seule instruction (ligne nº 5), laquelle code la valeur retournée par la fonction, déterminée par l'expression x * x * x codée après le mot‑clef return.
• Aux lignes nº 8 à 14 est codée la fonction principale main, qui programme l'affichage en sortie standard des valeurs prises par la fonction cube pour x allant de 0 à 10 par valeurs entières.
À la ligne nº 11, l'expression cube(a) constitue un appel de la fonction cube dont l'argument effectif est l'expression a.

Lors de l'exécution, par exemple avec OnlineGDB, ce programme produit l'affichage suivant (abrégé), conforme aux attentes :

 0³ = 0
 1³ = 1
 2³ = 8
 3³ = 27
    ⁝
10³ = 1000

Il constitue un jeu d'essais partiel de la fonction.

Examinons le programme ci‑dessous :

#include <stdio.h>

unsigned long long fact(unsigned n)
{
  unsigned long long f = 1;
  for (unsigned k = 1U; k <= n; k++) {
    f *= k;
  }
  return f;
}

int main(void)
{ 
  for (int a = 0; a < = 10; a++) {
    printf("%2u! = %llu\n", a, fact(a));
  }
  return 0;
}

On y trouve les éléments suivants :

• Aux lignes nº 3 à 10 est codée la définition de la fonction mathématique factorielle : n ⟼ n! = 1 × 2 … × n (ℕ⁺ ⟶ ℕ⁺).
• La ligne nº 3 constitue son en‑tête de définition (header) avec dans l'ordre :
• son type de valeurs retournées unsigned long long (parce que ces valeurs sont rapidement très grandes) ;
• son identificateur fact ;
• son (seul) argument formel identifié par n, qui est de type unsigned (la fonction n'est pas définie sur ℕ⁻).
• Les lignes nº 4 à 10 forment le corps de définition de la fonction. C'est un bloc comprenant notamment :
• à la ligne nº 5, la déclaration d'une variable locale f ;
• aux lignes nº 6 à 8, une boucle for qui calcule dans f le produit itératif 1 × 2 … × n ;
• à la ligne nº 9, l'instruction qui détermine la valeur retournée par la fonction, déterminée par l'expression f codée après le mot‑clef return.
• Aux lignes nº 12 à 18 est codée la fonction principale qui programme l'affichage en sortie standard des valeurs prises par la fonction fact pour n allant de 0 à 10.
À la ligne nº 13, l'expression fact(a) constitue un appel de la fonction fact dont l'argument effectif est l'expression a.

Dans le terminal d'exécution, par exemple avec OnlineGDB, ce programme produit l'affichage suivant (abrégé), conforme aux attentes :

 0! = 1
 1! = 1
 2! = 2
 3! = 6
    ⁝
10! = 3628800

Il constitue un jeu d'essais partiel de la fonction.

Le programme Arduino pour traiter l'exercice nº 3  du sujet de TP C2‑2 (Led & bouton), à savoir la génération en code morse d'un signal SOS répétitif – gagne en lisibilité à être décomposé à l'aide de fonctions, comme ci‑dessous :

const int LED_PIN = 2;

void setup()
{
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
}

// Morse code durations in milliseconds
const int DASH_DURATION          = 750;
const int DOT_DURATION           = 250;
const int INTER_SYMBOLS_DURATION = 250;
const int INTER_LETTERS_DURATION = 750;
const int INTER_WORDS_DURATION   = 3500;

void loop()
{
  letter_S();
  delay(INTER_LETTERS_DURATION);
  letter_O();
  delay(INTER_LETTERS_DURATION);
  letter_S();
  delay(INTER_WORDS_DURATION);
}

void letter_S()
{
  for (int dot = 1; dot <= 3; dot++) {
    digitalWrite(LED_PIN, HIGH);
    delay(DOT_DURATION);
    digitalWrite(LED_PIN, LOW);
    if (dot < 3) delay(INTER_SYMBOLS_DURATION);
  }
}

void letter_O()
{
  for (int dash = 1; dash <= 3; dash++) {
    digitalWrite(LED_PIN, HIGH);
    delay(DASH_DURATION);
    digitalWrite(LED_PIN, LOW);
    if (dot < 3) delay(INTER_SYMBOLS_DURATION);
  }
}

Ici, on a défini deux fonctions, letter_S (lignes nº 26 à 34) et letter_O (lignes nº 36 à 44), qui sont l'une comme l'autre :

• sans valeur de retour, d'où le type void ;
• sans argument formel, d'où le code () qui exprime un liste vide d'arguments.

Ces deux fonctions servent à regrouper des instructions de sorties booléennes dans un bloc respectif pour chacune. On peut ensuite appeler à volonté l'une ou l'autre pour qu'elle s'exécute dans le code d'une autre fonction, sans y répéter leur code. Ainsi, dans loop, on trouve :

• deux appels de letter_S (lignes nº 18 & 22) ;
• un appel de letter _0 (ligne nº 20).

Il en résulte que le code de la fonction loop devient très court, et donc très facile à lire. Il n'est pas encombré du détail des actions qu'il accomplit (détail qui peut être obtenu si nécessaire en consultant le code des fonctions appelées).

On souhaite implémenter une fonction qui détermine si deux nombres entiers strictement positifs sont premiers entre eux W, c'est‑à‑dire s'ils n'ont aucun diviseur commun hormis le nombre 1. Donc, cette fonction doit :

• prendre deux arguments formels (les deux nombres entiers à tester) déclarés par exemple dans le type unsigned ;
• retourner une valeur booléenne :
• true si les arguments passés lors d'un appel sont des nombres premiers entre eux,
• false dans le cas contraire.

Ainsi, l'en‑tête de cette fonction peut se coder par exemple comme ci‑dessous :

bool arePrime(unsigned a, unsigned b) //...

Reprenons l'exemple supra  d'une fonction qui détermine si deux nombres entiers positifs sont premiers entre eux. Après l'en‑tête, le corps de définition de cette fonction peut se coder comme ci‑dessous (à partir de l'accolade ouvrante { à la ligne nº 5, et jusqu'à l'accolade fermante } de la ligne nº 13) en appliquant une version itérative de l'algorithme d'Euclide W :

#include <stdlib.h>
#include <stdbool.h>

bool arePrime(unsigned a, unsigned b)
{
  if (a == 0 || b == 0) exit(1);  // because algorithm would fail
  while (b != 0) {
    unsigned c = b;
    b = a % b;     // if (b) gets 0, then (b) is a multiple of (a)
    a = c;
  }
  return (a == 1); // if (a == 1), then (b) had no higher dividers
}

//...

Ce bloc de définition code un processus récursif de calcul de reste de la division d'un nombre par l'autre, itéré tant que ce reste est différent de 0. On y trouve :

• une variable locale c déclarée en ligne nº 8 ; elle sert à garder en mémoire la valeur de l'argument formel b pour la recopier ensuite dans l'argument formel a ;
• des modifications des arguments formels (lignes nº 9 & 10), ce qui est possible puisqu'ils n'ont pas été déclarés constants ;
• un point de retour normal à la fonction appelante (ligne nº 12), afin de retourner soit la valeur booléenne 1 (équivalente à true), soit 0 (équivalente à false).
• un point de sortie anormale (ligne nº 6), si l'un des deux arguments formels est nul, car dans ce cas, l'algorithme ne peut aboutir (cf. la remarque supra en version INITIÉ).

Reprenons le cas de la fonction arePrime définie dans un exemple précédent .

1. Une expression d'appel comme par exemple arePrime(10, 3) affecte les valeurs des arguments effectifs 10 et 3 respectivement aux arguments formels a et b de la fonction arePrime. Tout se passe comme si, au début du corps de la fonction, s'ajoutaient les instructions :
   unsigned a = 10;      et     unsigned b = 10;
   Ensuite, l'évaluation de l'expression arePrime(10, 3) prend la valeur 1 (« vrai ») qui est retournée par la fonction arePrime puisque les entiers 10 et 3 sont premiers entre eux.
2. Considérons maintenant le code de la fonction principale main d'un programme qui fait appel à la fonction arePrime (à la ligne nº 26).

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool arePrime(unsigned a, unsigned b)
{
  if (a == 0 || b == 0) exit(1);  // because algorithm would fail
  while (b != 0) {
    unsigned c = b;
    b = a % b;     // if (b) gets 0, then (b) is a multiple of (a)
    a = c;
  }
  return (a == 1); // if (a == 1), then (b) had no higher dividers
}

int main(void) // test if two numbers are prime
{ 
  unsigned nb1 = 0, nb2 = 0;
  while (true) {
    printf("Nombre entier 1 (taper 0 pour sortir) : ");
    scanf("%u", &nb1);
    if (nb1 == 0) break;
    printf("Nombre entier 2 (taper 0 pour sortir) : ");
    scanf("%u", &nb2);
    if (nb2 == 0) break;

    if (arePrime(nb1, nb2)) {
      printf("%u et %u sont PREMIERS ENTRE EUX.\n\n", nb1, nb2);
    }
    else {
      printf("%u et %u ne sont PAS premiers entre eux.\n\n", nb1, nb2);
    }
  }
  printf("Au revoir.\n");
  return 0;
}

• À la ligne nº 27, l'expression arePrime(nb1, nb2) appelle la fonction arePrime avec comme arguments effectifs les variables nb1 et nb2 (elles sont locales à la fonction main).
• Lors de l'exécution, les valeurs courantes (préalablement saisies sur terminal par un utilisateur) de ces deux variables seront respectivement affectées aux arguments formels a et b de la fonction arePrime.
• Les valeurs des variables nb1 et nb2 ne sont pas modifiées par l'appel de la fonction arePrime. Ce sont seulement leurs valeurs qui sont affectées aux arguments formels a et b de façon temporaire lors de l'exécution.
C'est pourquoi même après l'évaluation de l'expression d'appel arePrime(nb1, nb2), lors des appels de la fonction printf aux lignes nº 28 et 31, les expressions nb1 et nb2 gardent chacune la valeur qui a été saisie par l'utilisateur (par les appels de la fonction scanf codés aux lignes nº 21 et 24).

Pour la fonction arePrime codée précédemment , on propose le jeu d'essais mis en œuvre dans la fonction main ci‑dessous :

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool arePrime(unsigned a, unsigned b)
{
  if (a == 0 || b == 0) exit(1);  // because algorithm would fail
  while (b != 0) {
    unsigned c = b;
    b = a % b;     // if (b) gets 0, then (b) is a multiple of (a)
    a = c;
  }
  return (a == 1); // if (a == 1), then (b) had no higher dividers
}

int main(void) // test combinations of (a) and (b) < 10
{
  unsigned nb1 = 10;
  for (unsigned nb2 = nb1; nb2 >= 1; nb2--) {
    if (arePrime(nb1, nb2)) {
      printf("%u et %u sont PREMIERS ENTRE EUX. \n", nb1, nb2);
    }
    else {
      printf("%u et %u ne sont PAS premiers entre eux. \n", nb1, nb2);
    }
    if (arePrime(nb1, nb2) != arePrime(nb2, nb1)) {
      printf("ERREUR pour %d et %d !!! \n", nb1, nb2);
    }
  }
  arePrime(0, 1); // you must test also arePrime(0, 1) and arePrime(0, 0)
  return 0;
}

Avec OnlineGDB, on obtient en sortie standard l'affichage suivant :

10 et 10 ne sont PAS premiers entre eux. 
10 et 9 sont PREMIERS ENTRE EUX. 
10 et 8 ne sont PAS premiers entre eux. 
10 et 7 sont PREMIERS ENTRE EUX. 
10 et 6 ne sont PAS premiers entre eux. 
10 et 5 ne sont PAS premiers entre eux. 
10 et 4 ne sont PAS premiers entre eux. 
10 et 3 sont PREMIERS ENTRE EUX. 
10 et 2 ne sont PAS premiers entre eux. 
10 et 1 sont PREMIERS ENTRE EUX. 

...Program finished with exit code 1

On voit donc que ce jeu d'essais, bien que très limité, vise à opérer plusieurs vérifications essentielles :

• Il affiche le résultat de la fonction pour dix combinaisons de valeurs en fixant le premier entier à 10 et décrémentant le deuxième de 10 à 1 (tous les résultats obtenus sont faciles à vérifier de tête). On peut aisément vérifier de tête qu'on obtient des résultats conformes aux attentes.
• Il permet aussi de s'assurer automatiquement que la fonction retourne bien la même valeur lorsqu'on permute les valeurs des deux arguments effectifs ; sinon, il signalerait l'erreur (ici, ce n'est pas le cas donc tout va bien).
• Enfin, il tester le cas limites où le premier argument effectif est nul ; et on obtient bien, comme attendu, le code de sortie 1 (et non pas 0) du programme en fin d'exécution.
Comme indiqué en commentaire de la ligne nº 28, pour bien faire, il faut aussi tester les cas arePrime(0, 1) et arePrime(0, 0), mais cela n'est pas possible en une seule exécution, puisqu'une sortie anticipée du programme ne peut intervenir qu'une seule fois par exécution. Il faut donc modifier le code source et exécuter le programme pour chaque cas.

Le programme académique de l'exemple 2 supra  pour déterminer si deux nombres sont premiers entre eux peut encore être décomposé. En particulier, dans la fonction principale main :

int main(void) // test if two numbers are prime
{ 
  unsigned nb1 = 0, nb2 = 0;
  while (true) {
    printf("Nombre entier 1 (taper 0 pour sortir) : ");
    scanf("%u", &nb1);
    if (nb1 == 0) break;
    printf("Nombre entier 2 (taper 0 pour sortir) : ");
    scanf("%u", &nb2);
    if (nb2 == 0) break;

    if (arePrime(nb1, nb2)) {
      printf("Les entiers %u et %u sont PREMIERS ENTRE EUX.\n", nb1, nb2);
    }
    else {
      printf("Les entiers %u et %u ne sont PAS premiers entre eux.\n", nb1, nb2);
    }
  }
  printf("Au revoir.\n")
  return 0;
}

la saisie des deux nombres à tester emploie deux fois un code similaire (lignes nº 20 à 22 et nº 23 à 25).

On a donc intérêt factoriser ce code dans une nouvelle une nouvelle fonction comme celle nommée enteringNumber codée ci‑dessous aux lignes nº 20 à 22 (effectuant un passage d'argument par adresse, elle utilise un pointeur – un concept qui sera étudié au chap. C5‑I ) :

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool arePrime(unsigned a, unsigned b)
{
  if (a == 0 || b == 0) exit(1);  // because algorithm would fail
  while (b != 0) {
    unsigned c = b;
    b = a % b;     // if (b) gets 0, then (b) is a multiple of (a)
    a = c;
  }
  return (a == 1); // if (a == 1), then (b) had no higher dividers
}

void enteringNumber(unsigned order, unsigned * number)
{
  printf("Nombre entier %u (taper 0 pour sortir) : ", order);
  scanf("%u", number);
  if (*number == 0) {
    printf("Au revoir.\n");
    exit(0);
  }
}

int main(void) // test if two numbers are prime
{ 
  unsigned nb1 = 0, nb2 = 0;
  while (true) {
    enteringNumber(1, &nb1);
    enteringNumber(2, &nb2);
    if (arePrime(nb1, nb2)) {
      printf("%u et %u sont PREMIERS ENTRE EUX.\n\n", nb1, nb2);
    }
    else {
      printf("%u et %u ne sont PAS premiers entre eux.\n\n", nb1, nb2);
    }
  }
}

Avec deux fonctions auxiliaires au lieu d'une seule, ce programme est plus procédural que dans sa version précédente.

Le prototype de la fonction arePrime définie supra  se code tout simplement :
bool arePrime(unsigned a, unsigned b);

Le programme académique des exemples précédents, qui teste en boucle si deux entiers saisis par l'utilisateur sont premiers entre eux, peut finalement se coder de façon plus conforme aux usages de la programmation procédurale, comme ci‑dessous :

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

void enteringNumber(unsigned n, unsigned * number);
bool arePrime(unsigned a, unsigned b);


int main(void) // test if two numbers are relatively prime
{ 
  unsigned nb1 = 0, nb2 = 0;
  while (true) {
    enteringNumber(1, &nb1);
    enteringNumber(2, &nb2);
    if (arePrime(nb1, nb2)) {
      printf("%u et %u sont PREMIERS ENTRE EUX.\n\n", nb1, nb2);
    }
    else {
      printf("%u et %u ne sont PAS premiers entre eux.\n\n", nb1, nb2);
    }
  }
  return 0;
}

void enteringNumber(unsigned n, unsigned * number)
{
  printf("Nombre entier %u (taper 0 pour sortir) : ", n);
  scanf("%u", number);
  if (*number == 0) {
    printf("Au revoir.\n");
    exit(0);
  }
}

bool arePrime(unsigned a, unsigned b)
{
  if (a == 0 || b == 0) exit(1);  // because algorithm would fail
  while (b != 0) {
    unsigned c = b;
    b = a % b;     // if (b) gets 0, then (b) is a multiple of (a)
    a = c;
  }
  return (a == 1); // if (a == 1), then (b) had no higher dividers
}

Ici :

• les fonctions auxiliaires ont été placées après la fonction principale main.
• Leurs prototypes respectifs sont codés en préambule, après les directives d'inclusion.

Dans un programme pilotant des led, il est usuel de regrouper tous les appels de fonctions pour la configuration et l'initialisation des broches d'entrées‑sorties numériques dans une fonction auxiliaire de type void nommée par exemple initPins.

De même, on peut utilement coder un bloc de clignotement paramétré par la période et la durée du clignotement dans une fonction auxiliaire de type void, nommée par exemple busyBlink.

Le programme académique ci‑dessous met en œuvre ces deux fonctions avec un bouton‑poussoir qui déclenche une telle séquence de clignotement d'une led. Il peut être testé sur Tinkercad avec le montage du sujet de TP C2‑1 .

const int LED_PIN    = 2;
const int BUTTON_PIN = 7;
 
void setup()
{
  initPins();
}

bool previousButtonLevel = LOW;   
bool currentButtonLevel  = LOW;

void loop()
{
  previousButtonLevel = currentButtonLevel;
  currentButtonLevel  = digitalRead(BUTTON_PIN); 
  if (currentButtonLevel == HIGH && previousButtonLevel == LOW) { // rising edge
    busyBlink(200, 1000);
  }
}

void initPins()
{
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  pinMode(BUTTON_PIN, INPUT);
}

void busyBlink(uint16_t halfPeriod, uint32_t duration)
{
  uint32_t millisecondsCounter = 0;
  while (millisecondsCounter <= duration - halfPeriod) {
    digitalWrite(LED_PIN, HIGH);
    delay(halfPeriod);
    millisecondsCounter += halfPeriod;
    digitalWrite(LED_PIN, LOW);
    if (millisecondsCounter > duration - halfPeriod) {
      return;
    } // else
    delay(halfPeriod);
    millisecondsCounter += halfPeriod;
  }
}