• <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    2.3. Le while

    Le while permet d'exécuter des instructions en boucle tant qu'une condition est vraie. Sa syntaxe est la suivante :

    while (test) opération;
    opération est effectuée tant que test est vérifié. Comme pour le if, les parenthèses autour du test sont nécessaires. L'ordre d'exécution est :
    test
    opération

    Exemple 2-3. Boucle while

    somme = i = 0;
    while (somme<1000)
    {
        somme = somme + 2 * i / (5 + i);
        i = i + 1;
    }

    votre commentaire
  • <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    2.2. La boucle for

    La structure de contrôle for est sans doute l'une des plus importantes. Elle permet de réaliser toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d'une variable de contrôle. Sa syntaxe est la suivante :

    for (initialisation ; test ; itération) opération;
    initialisation est une instruction (ou un bloc d'instructions) exécutée avant le premier parcours de la boucle du for. test est une expression dont la valeur déterminera la fin de la boucle. itération est l'opération à effectuer en fin de boucle, et opération constitue le traitement de la boucle. Chacune de ces parties est facultative.

    La séquence d'exécution est la suivante :

    initialisation
    test : saut en fin du for ou suite
        opération
        itération
        retour au test
    fin du for.

    Exemple 2-2. Boucle for

    somme = 0;
    for (i=0; i<=10; i=i+1) somme = somme + i;

    Note : En C++, il est possible que la partie initialisation déclare une variable. Dans ce cas, la variable déclarée n'est définie qu'à l'intérieur de l'instruction for. Par exemple,

    for (int i=0; i<10; ++i);
    est strictement équivalent à :
    {
        int i;
        for (i=0; i<10; ++i);
    }

    Cela signifie que l'on ne peut pas utiliser la variable i après l'instruction for, puisqu'elle n'est définie que dans le corps de cette instruction. Cela permet de réaliser des variables muettes qui ne servent qu'à l'instruction for dans laquelle elles sont définies.

    Note : Cette règle n'est pas celle utilisée par la plupart des compilateurs C++. La règle qu'ils utilisent spécifie que la variable déclarée dans la partie initialisation de l'instruction for reste déclarée après cette instruction. La différence est subtile, mais importante. Cela pose assurément des problèmes de compatibilité avec les programmes C++ écrits pour ces compilateurs, puisque dans un cas la variable doit être redéclarée et dans l'autre cas elle ne le doit pas. Il est donc recommandé de ne pas déclarer de variables dans la partie initialisation des instructions for pour assurer une portabilité maximale.


    votre commentaire
  • <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    Chapitre 2. Les structures de contrôle

     

    Nous allons aborder dans ce chapitre un autre aspect du langage indispensable à la programmation, à savoir : les structures de contrôle. Ces structures permettent, comme leur nom l'indique, de contrôler l'exécution du programme en fonction de critères particuliers. Le C et le C++ disposent de toutes les structures de contrôle classiques des langages de programmation comme les tests, les boucles, les sauts, etc. Toutes ces structures sont décrites dans les sections suivantes.

    2.1. La structure conditionnelle if

    La structure conditionnelle if permet de réaliser un test et d'exécuter une instruction ou non selon le résultat de ce test. Sa syntaxe est la suivante :

    if (test) opération;
    test est une expression dont la valeur est booléenne ou entière. Toute valeur non nulle est considérée comme vraie. Si le test est vrai, opération est exécuté. Ce peut être une instruction ou un bloc d'instructions. Une variante permet de spécifier l'action à exécuter en cas de test faux :
    if (test) opération1;
    else opération2;

    Note : Attention ! Les parenthèses autour du test sont nécessaires !

    Les opérateurs de comparaison sont les suivants :

     

    Tableau 2-1. Opérateurs de comparaison

    == égalité
    != inégalité
    < infériorité
    > supériorité
    <= infériorité ou égalité
    >= supériorité ou égalité

    Les opérateurs logiques applicables aux expressions booléennes sont les suivants :

     

    Tableau 2-2. Opérateurs logiques

    && et logique
    || ou logique
    ! négation logique

    Il n'y a pas d'opérateur ou exclusif logique.

    Exemple 2-1. Test conditionnel if

    if (a<b && a!=0)
    {
        m=a;
        nouveau_m=1;
    }

     


    votre commentaire
  • <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    1.9. Exemple de programme complet

    Le programme suivant est donné à titre d'exemple. Il calcule la moyenne de deux nombres entrés au clavier et l'affiche :

    Exemple 1-23. Programme complet simple

    #include <stdio.h>  /* Autorise l'emploi de printf et de scanf. */
    
    long double x, y;
    
    int main(void)
    {
        printf("Calcul de moyennen");   /* Affiche le titre. */
        printf("Entrez le premier nombre : ");
        scanf("%Lf", &x);            /* Entre le premier nombre. */
        printf("nEntrez le deuxième nombre : ");
        scanf("%Lf", &y);            /* Entre le deuxième nombre. */
        printf("nLa valeur moyenne de %Lf et de %Lf est %Lf.n",
            x, y, (x+y)/2);
        return 0;
    }

    Dans cet exemple, les chaînes de format spécifient des flottants (f) en quadruple précision (L).


    votre commentaire
  • <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    1.7. La fonction main

    Lorsqu'un programme est chargé, son exécution commence par l'appel d'une fonction spéciale du programme. Cette fonction doit impérativement s'appeler « main » (principal en anglais) pour que le compilateur puisse savoir que c'est cette fonction qui marque le début du programme. La fonction main est appelée par le système d'exploitation, elle ne peut pas être appelée par le programme, c'est-à-dire qu'elle ne peut pas être récursive.

    Exemple 1-21. Programme minimal

    int main()   /* Plus petit programme C/C++. */
    {
        return 0;
    }

    La fonction main doit renvoyer un code d'erreur d'exécution du programme, le type de ce code est int. Elle peut aussi recevoir des paramètres du système d'exploitation. Ceci sera expliqué plus loin. Pour l'instant, on se contentera d'une fonction main ne prenant pas de paramètre.

    Note : Il est spécifié dans la norme du C++ que la fonction main ne doit pas renvoyer le type void. En pratique cependant, beaucoup de compilateurs l'acceptent également.

    La valeur 0 retournée par la fonction main indique que tout s'est déroulé correctement. En réalité, la valeur du code de retour peut être interprétée différemment selon le système d'exploitation utilisé. La bibliothèque C définit donc les constantes EXIT_SUCCESS et EXIT_FAILURE, qui permettent de supprimer l'hypothèse sur la valeur à utiliser respectivement en cas de succès et en cas d'erreur.


    votre commentaire