Programmation C/Tests

Les tests permettent d'effectuer des opérations différentes suivant qu'une condition est vérifiée ou non.

Test if

Les sauts conditionnels permettent de réaliser une instruction si une condition est vérifiée. Si la condition n'est pas vérifiée, l'exécution se poursuit séquentiellement.

Syntaxe

Première forme :

/* Ce code est volontairement incomplet */
    if (condition)
        instruction
    instruction suivante

Si la condition est vérifiée, alors on exécute l'instruction, sinon on exécute directement l'instruction suivante.

/* Ce code est volontairement incomplet*/
    if (condition) instruction; /* ... */
    instruction suivante; /* ... */ ;

Deuxième forme

Deuxième forme :

if ( condition )
{
instructions
}

/* Ce code est volontairement incomplet */
    if (condition)
        instructions
    instruction suivante

Si la condition est vérifiée, alors on exécute le bloc d'instructions, sinon on exécute directement l'instruction suivante.

/* Ce code est volontairement incomplet */
    if (condition) 
    {
       instruction 1; /* ... */
       instruction 2; /* ... */
    }
    instruction suivante; /* ... */ ;

Troisième forme

Troisième forme :

/* Ce code est volontairement incomplet */
    if (condition)
        instructions
    else
        autre instructions
    instruction suivante; /* ... */ ;

Si la condition est vérifiée, alors on exécute le bloc d'instructions, sinon on exécute l'autre bloc.

    /* Ce code est volontairement incomplet*/
    if (condition) 
    {
       instruction 1; /* ... */
       instruction 2; /* ... */
    } else {
       instruction 3; /* ... */
       instruction 4; /* ... */
    }
    instruction suivante; /* ... */ ;

Quatrième forme :

    /* Ce code est volontairement incomplet*/
    if (condition 1)
        instructions
    else if (condition 2)
        autre instructions
    else
        autre instructions
    instruction suivante; /* ... */ ;

Si la condition est vérifiée, alors on exécute le bloc d'instructions, sinon on exécute l'autre if comme la troisième forme.

/* Ce code est volontairement incomplet */
    if (condition 1) 
    {
       instruction 1; /* ... */
       instruction 2; /* ... */
    } else if (condition 2) {
       instruction 3; /* ... */
       instruction 4; /* ... */
    } else {
       instruction 5; /* ... */
       instruction 6; /* ... */
    }
    instruction suivante; /* ... */ ;

Exemple de code :

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

int main(void)
{
    int a;
    a = 3; /* assignation d'une valeur pour l'exemple*/

    if (a >= 5)
        printf("Le nombre a est supérieur ou égal à 5 \n");
    else
        printf("Le nombre a est inférieur à 5 \n");
    return 0;
}

D'ailleurs, lorsqu'un if contient une instruction (for, do, while, switch, goto, return, etc.) il est conseillé de la mettre entre accolades.

Test switch

Cette instruction permet de tester si une expression coïncide avec un certain nombre de constantes, et d'exécuter une action par défaut dans le cas où aucune valeur ne correspond à celle de l'expression. Cela permet un traitement beaucoup plus efficace et lisible qu'une succession de if/else imbriqués. Insistons sur le terme constante : il est en effet impossible d'utiliser des expressions dont la valeur n'est pas connue à la compilation (c'est à dire de variable dans les instructions case).

Syntaxe

switch (expression)
{
    case valeur1:
        bloc1
    case valeur2:
        bloc2
    /*...*/
    case valeurN:
        blocN
    default:
        blocD
}

Compare la valeur de l'expression à celles de valeur1, valeur2, ..., valeurN. En cas d'égalité entre expression et valeurI les blocs sont exécutés séquentiellement à partir de blocI, et ce jusqu'à la fin de l'instruction switch. Si expression est égale à valeur2, dans cet exemple, les blocs bloc2 à blocN et même blocD seront exécutés. Pour empêcher ce comportement on utilise l'instruction break, que l'on peut placer à n'importe quel endroit pour sortir (aller à la fin) de l'instruction switch. En général, on retrouve plus fréquemment l'instruction switch écrite de la sorte :

switch (expression)
{
    case valeur1:
        bloc1
        break;
    case valeur2:
        bloc2
        break;
    /*...*/
    case valeurN:
        blocN
        /* pas de break; */
    default:
        blocD
}

C'est en fait tellement rare de ne pas mettre de break entre les différents cas, qu'il est conseillé de mettre un commentaire pour les cas où cette instruction est délibérément omise, ça permet de bien signaler au lecteur qu'il ne s'agit pas d'un oubli.

Expression conditionnelle

condition ? expression_si_vrai : expression_si_faux ;

Exemple

#include <stdio.h>

int main(int argc, char * argv[])
{
    /*
        program                      argc=1  argv[0]="program"
        program argument             argc=2  argv[0]="program"  argv[1]="argument"
        program argument argument    argc=3  argv[0]="program"  argv[1]="argument"  argv[2]="argument"
        ...
    */
    printf("%s\n", argc < 2 ? "Vous n'avez pas donné d'argument." : "Vous avez donné au moins un argument.");
    return 0;
}

Ce mini-programme teste si le nombre d'arguments passé à main est inférieur à 2 avec l'expression argc < 2 et renvoie "vous n'avez pas donné d'argument" si l'expression est vraie et "vous avez donné au moins un argument" sinon. Le résultat de l'évaluation est alors passé à la fonction printf qui affiche le résultat. (si argc vaut 2 alors il y a 1 argument : voir "la fonction main" dans le chapitre "fonctions")

On note le manque de clarté de l'exemple: l'opérateur ternaire ne doit être utilisé que dans de rares cas, c'est à dire lorsque son utilisation ne se fait pas au détriment de la lisibilité du code.