• Instruction et operation

    <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.5. Instructions et opérations

    Les instructions sont généralement identifiées par le point virgule. C'est ce caractère qui marque la fin d'une instruction.

    Exemple 1-10. Instruction vide

    ;    /* Instruction vide : ne fait rien ! */

    Il existe plusieurs types d'instructions, qui permettent de réaliser des opérations variées. Les instructions les plus courantes sont sans doute les instructions qui effectuent des opérations, c'est-à-dire les instructions qui contiennent des expressions utilisant des opérateurs.

    Les principales opérations utilisables en C/C++ sont les suivantes :

    • les affectations :

      variable = valeur

      Note : Les affectations ne sont pas des instructions. Ce sont bien des opérations qui renvoient la valeur affectée. On peut donc effectuer des affectations multiples :

      i=j=k=m=0;   /* Annule les variables i, j, k et m. */
    • les opérations de base du langage :

      valeur op valeur
      op est l'un des opérateurs suivants : +, -, *, /, %, &, |, ^, ~, <<, >>.

      Note : '/' représente la division euclidienne pour les entiers et la division classique pour les flottants.

      '%' représente la congruence (c'est-à-dire le reste de la division euclidienne). '|' et '&' représentent respectivement le ou et le et binaire (c'est-à-dire bit à bit : 1 et 1 = 1, 0 et x = 0, 1 ou x = 1 et 0 ou 0 = 0). '^' représente le ou exclusif (1 xor 1 = 0, 0 xor 0 = 0 et 1 xor 0 = 1). '~' représente la négation binaire (1 devient 0 et vice versa). '<<' et '>>' effectuent un décalage binaire vers la gauche et la droite respectivement, d'un nombre de bits égal à la valeur du second opérande.

    • les opérations des autres opérateurs du langage. Le C et le C++ disposent d'opérateurs un peu plus évolués que les opérateurs permettant de réaliser les opérations de base du langage. Ces opérateurs sont les opérateurs d'incrémentation et de décrémentation ++ et --, l'opérateur ternaire d'évaluation conditionnelle d'une expression (opérateur ?:) et l'opérateur virgule (opérateur ,). La syntaxe de ces opérateurs est décrite ci-dessous.

    • les appels de fonctions. Nous verrons comment écrire et appeler des fonctions dans les sections suivantes.

    Bien entendu, la plupart des instructions contiendront des affectations. Ce sont donc sans doute les affectations qui sont les plus utilisées parmi les diverses opérations réalisables, aussi le C et le C++ permettent-ils l'utilisation d'affectations composées. Une affectation composée est une opération permettant de réaliser en une seule étape une opération normale et l'affectation de son résultat dans la variable servant de premier opérande. Les affectations composées utilisent la syntaxe suivante :

    variable op_aff valeur
    op_aff est l'un des opérateurs suivants : '+=', '-=', '*=', etc. Cette syntaxe est strictement équivalente à :
    variable = variable op valeur
    et permet donc de modifier la valeur de variable en lui appliquant l'opérateur op.

    Exemple 1-11. Affectation composée

    i*=2;        /* Multiplie i par 2 : i = i * 2. */

    Les opérateurs d'incrémentation et de décrémentation ++ et -- s'appliquent comme des préfixes ou des suffixes sur les variables. Lorsqu'ils sont en préfixe, la variable est incrémentée ou décrémentée, puis sa valeur est renvoyée. S'ils sont en suffixe, la valeur de la variable est renvoyée, puis la variable est incrémentée ou décrémentée. Par exemple :

    int i=2,j,k;
    
    j=++i;   /* À la fin de cette instruction, i et j valent 3. */
    k=j++;   /* À la fin de cette ligne, k vaut 3 et j vaut 4. */

    Note : On prendra garde à n'utiliser les opérateurs d'incrémentation et de décrémentation postfixés que lorsque cela est réellement nécessaire. En effet, ces opérateurs doivent contruire un objet temporaire pour renvoyer la valeur de la variable avant incrémentation ou décrémentation. Si cet objet temporaire n'est pas utilisé, il est préférable d'utiliser les versions préfixées de ces opérateurs.

    L'opérateur ternaire d'évaluation conditionnelle ?: est le seul opérateur qui demande 3 paramètres (à part l'opérateur fonctionnel () des fonctions, qui admet n paramètres, et que l'on décrira plus tard). Cet opérateur permet de réaliser un test sur une condition et de calculer une expression ou une autre selon le résultat de ce test. La syntaxe de cet opérateur est la suivante :

    test ? expression1 : expression2

    Dans cette syntaxe, test est évalué en premier. Son résultat doit être booléen ou entier. Si test est vrai (ou si sa valeur est non nulle), expression1 est calculée et sa valeur est renvoyée. Sinon, c'est la valeur de expression2 qui est renvoyée. Par exemple, l'expression :

    Min=(i<j)?i:j;
    calcule le minimum de i et de j.

    L'opérateur virgule, quant à lui, permet d'évaluer plusieurs expressions successivement et de renvoyer la valeur de la dernière expression. La syntaxe de cet opérateur est la suivante :

    expression1,expression2[,expression3[...]]
    expression1, expression2, etc. sont les expressions à évaluer. Les expressions sont évaluées de gauche à droite, puis le type et la valeur de la dernière expression sont utilisés pour renvoyer le résultat. Par exemple, à l'issue des deux lignes suivantes :
    double r = 5;
    int i = r*3,1;
    r vaut 5 et i vaut 1. r*3 est calculé pour rien.

    Note : Ces deux derniers opérateurs peuvent nuire gravement à la lisibilité des programmes. Il est toujours possible de réécrire les lignes utilisant l'opérateur ternaire avec un test (voir la section 2.1 pour la syntaxe des tests en C/C++). De même, on peut toujours décomposer une expression utilisant l'opérateur virgule en deux instructions distinctes. Ce dernier opérateur ne devra donc jamais être utilisé.

    Il est possible de créer des instructions composées, constituées d'instructions plus simples. Les instructions composées se présentent sous la forme de bloc d'instructions où les instructions contenues sont encadrées d'accolades ouvrantes et fermantes (caractères '{ et '}').

    Exemple 1-12. Instruction composée

    {
        i=1;
        j=i+3*g;
    }

    Note : Un bloc d'instructions est considéré comme une instruction unique. Il est donc inutile de mettre un point virgule pour marquer l'instruction, puisque le bloc lui-même est une instruction.

    Enfin, il existe tout un jeu d'instructions qui permettent de modifier le cours de l'exécution du programme, comme les tests, les boucles et les sauts. Ces instructions seront décrites en détail dans le chapitre traitant des structures de controles.


  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :