Citation : do, while

do, while

Norme : toutes
Description : ces mot-clefs permettent de répéter une instruction ou un bloc d'instructions tant qu'une ou plusieurs conditions sont remplies. Dès qu'une des condition devient fausse, la boucle s'arrête. Ils sont cependant légèrement différent.

Une boucle de type while teste d'abord la condition avant d'exécuter le code, ce qui fait que si la condition est fausse dès le départ le code ne sera pas exécuté du tout. Schématiquement parlant elle fonctionne ainsi :

La boucle do while est quand à elle différente car elle exécute d'abord le code avant de tester la condition, et ce même si la condition est fausse dès le départ. Ainsi, on a l'assurance qu'une boucle do while sera toujours exécutée au moins une fois. Schématiquement parlant, elle fonctionne ainsi :

Les deux boucles sont également différentes sur leur syntaxe :

while (condition)
{
    /* code */
}


do
{
    /* code */
} while (condition);

Exemple et / ou commentaire :

Exemple illustrant la différence entre les deux boucles :

while (0)
{
    puts("while");
}

do
{
    puts("do while");
} while (0);

Cette particularité fait qu'on utilise souvent do while conjointement avec le préprocesseur :

#define VAL(x) \
    do \
    { \
        if (x < 0) \
            printf("Inferieur a 0.\n"); \
        else if (x > 0) \
            printf("Superieur a 0\n"); \
        else \
            printf("Egal a 0"); \
    } while (0)

Citation : const

const, volatile

Norme : toutes
Description : const sert à déclarer un objet comme étant constant, c'est à dire qui ne peut en théorie pas être modifié. Il devient nécessaire de donner une valeur dès la déclaration.

Exemple simple ci-dessous.

const double e = 2.718281828;
e++;  /* interdit ! */

Le mot-clef volatile sert quand à lui à spécifier qu'une variable peut être modifiée indépendamment de la volonté du programmeur ; ce peut être par un autre programme, une interruption, un périphérique, etc. Ainsi, au lieu d'être habituellement placée dans un registre, une variable déclarée avec volatile sera placée uniquement en mémoire vive. Il est important de noter que, excepté dans de rares cas, ce mot-clef ne sert à rien.

Exemple et / ou commentaire :

Toutes les explications qui suivent utilisent const, mais le principe est le même pour volatile.

Le mot-clef const s'applique sur ce qui le précède, excepté s'il est en premier dans l'expression, auquel cas il s'applique sur ce qui le suit immédiatement. Cela n'est pas important dans le cas de variables simples, mais prend son importante dans le cas des pointeurs.

Pointeurs et const

Le mot-clef const peut changer la signification d'un pointeur en fonction de sa position. En effet, s'il est placé avant le type T, on obtient un pointeur sur un T constant. Dans ce cas, la modification de l'objet pointé est interdite ; la modification du pointeur reste autorisée.

int a = 2, b = 3;
const int * ptr = &a;

*ptr = 3;    /* interdit ! */
ptr = &b;    /* autorisé */

A l'inverse, si const est situé juste après * alors on obtient un pointeur constant sur un T. La modification du pointeur est interdite mais pas la modification de l'objet pointé.

int a = 2, b = 3;
int * const ptr = &a;

ptr = &b;    /* interdit ! */
*ptr = 3;    /* autorisé */

Bien entendu, les deux possibilités sont combinables. Dans ce cas on obtient un pointeur constant sur un T constant, ce qui interdit de modifier le pointeur ou l'objet pointé.

int a = 2, b = 3;
const int * const ptr = &a;

ptr = &b;    /* interdit ! */
*ptr = 3;    /* interdit ! */

Pointeurs de pointeurs

Cette règle s'applique également aux pointeurs de pointeurs, et ce peu importe leur nombre. Dans notre exemple, pptr est un pointeur sur un pointeur constant sur un int constant.

const int * const * pptr;

pptr = OK;
*pptr = KO;
**pptr = KO;

Autre exemple dans lequel ptr est un pointeur sur un pointeur constant sur un pointeur sur un pointeur constant sur un int constant.

const int * const ** const * ptr;

ptr = OK;
*ptr = KO;
**ptr = OK;
***ptr = KO;
****ptr = KO;

Tableaux et const

Dans le cas d'un tableau, s'il est déclaré avec const, alors tous les éléments du tableau sont constants, et il faut donc l'initialiser dès sa déclaration.

const int tab[3] = {0, 10, 20};

tab[1] = 0;   /* interdit */

Structures, unions et const

struct Point
{
    int x, y;
};

int main(void)
{
    const struct Point point = {0, 0};

    point.x = 2;  /* interdit ! */ 
  
    return 0;
}

const vraiment constante ?

/* Avec scanf */

const int a = 5;

printf("Donnez a : ");
scanf("%d", &a);
printf("a = %d", a);

a = 5
Donnez a : 5454
a = 5454

/* Avec un pointeur */

const int a = 5;
int * ptr = &a;

printf("a = %d\n", a);
*ptr = 5 * 5;
printf("a = %d\n", a);

a = 5
a = 25

warning: writing into constant object

warning: initialization discards qualifiers from pointer target type

const int a = 5;
int tab[a];

#define N 10

const int N = 10;

const et volatile ensembles

const int * volatile ptr;

• break permet de quitter la boucle en cours ;
• continue permet de passer au tour suivant d'une boucle sans terminer celui en cours ;
• goto permet carrément de sauter à une autre portion de code identifiée par un label.

int i;

puts("Avant la boucle");

for (i = 0 ; i < 10 ; i++)
{
    if (i == 5)
        break;

    printf("i = %d\n", i);
}

puts("Après la boucle")

Avant la boucle

i = 0
i = 1
i = 2
i = 3
i = 4

Après la boucle

#include <stdio.h>

int main(void)
{
    int i;

    for (i = 0; i < 10; i++)
    {
        printf("[for] i = %d\n", i);

        while (i < 5)
        {
            if (i == 4)
                break;

            printf("[while] i = %d\n", i);
            i++;
        }
    }

    return 0;
}

[for] i = 0
[while] i = 0
[while] i = 1
[while] i = 2
[while] i = 3
[for] i = 5
[for] i = 6
[for] i = 7
[for] i = 8
[for] i = 9

for (i = 0 ; i < 10 ; i++)
{
     if (i == 5)
        continue;

     else
         printf("%d\n", i);
}

i = 0
i = 1
i = 2
i = 3
i = 4
i = 6
i = 7
i = 8
i = 9

int i;

for (i = 0 ; i < 10 ; i++)
{
     if (i == 5)
         goto Erreur;

     printf("i = %d\n", i);
}

Erreur:
     puts("\ni vaut 5");

i = 0
i = 1
i = 2
i = 3
i = 4

i vaut 5

int i;

/* code plus court et plus lisible */
for (i = 0 ; i < 10 ; i++)
{
     if (i == 5)
     {
         puts("i vaut 5");
         break;
     }

     printf("i = %d\n", i);
}

switch(/* variable */)
{
    case /* comparant_1 */ :
        /* Instructions */
        break;

    case /* comparant_2 */ :
        /* Instructions */
        break;

    /*Etc...*/

    default: /* si aucune comparaison n'est juste */
        /* instructions à exécuter dans ce cas */
        break;
}

int main(void)
{
    int note;

    scanf("Quelle note as-tu obtenu : ");
    scanf("%d", &note);

    switch(note)
    {
        /* si la note est comprise entre 0 et 4 inclus */
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
            printf("Tu n'as pas la moyenne.\n");
            break;

        /* si au contraire la note est égale ou supérieure à 5 */

        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
        case 10:
            printf("Tu as la moyenne.\n");
            break;

        default:
            printf("Erreur : note impossible\n");
            break;
    }

    return 0;
}

#include        <stdio.h>

int             main(void)
{
  int const     a = 21;
  int*          p = (int*)&a;

  ++*p;

  printf("%d\n", *p); /* 22 */
  printf("%d\n", a);  /* 21 ??? alors d'ou vient le 22 d'au dessus? */

  printf("%p\n", &a);
  printf("%p\n", p);  /* Même adresse que &a */

  return 0;
}

#include        <stdio.h>

void            plop(int const* a)
{
  printf("%d\n", *a); /* Je retrouve mon 22 \o/ */
}

int             main(void)
{
  int const     a = 21;
  int*          p = (int*)&a;

  ++*p;

  printf("%d\n", *p); /* 22 */
  printf("%d\n", a);  /* encore 21  */

  printf("%d\n", a * 2); /* 42 et non 44  */

  printf("%p\n", (void*)&a); /* Meme adresses */
  printf("%p\n", (void*)p);  /* qu'ici */

  plop(&a); /* mais... */

  return 0;
}