Concepts en C

Cohérence, logique et fonctionnement du C


précédentsommairesuivant

III. Contexte d'évaluation des grandeurs

Le contexte d'évaluation d'une grandeur précise si la grandeur attendue à cet endroit est une valeur ou un objet. On parlera alors de contexte de valeur ou de contexte d'objet.

On ne peut pas placer une valeur dans un contexte d'objet

Si on place un objet dans un contexte de valeur, ceci sera interprété comme la valeur de l'objet

III-A. Contexte des opérateurs

A chaque opérande d'un opérateur correspond un contexte. Le résultat de l'opération peut être un objet ou une valeur selon le cas.

La plupart des opérateurs ont leur(s) opérande(s) dans un contexte de valeur et donne une valeur pour résultat. Les cas particuliers sont énumérés ci-dessous.

III-A-1. Opérateurs donnant pour résultat un objet

Ce sont les deux opérateurs unaires * et . (point) ainsi que les opérateurs [] et ->.

  • l'opérateur unaire *, permettant d'obtenir l'objet placé à une adresse donnée.
    L'opérande est dans un contexte de valeur.
*Valeur   =>   Objet
  • l'opérateur unaire . (point) de sélection d'un champ d'une structure ou d'une union si l'opérande est un objet.
Objet.id   =>   Objet

Si l'opérande est une valeur, le résultat est une valeur: Valeur.id   =>   Valeur

Exemple
Sélectionnez
 struct s {int a ;};
 struct s st;
 struct s f(void);

 Alors :  st.a est un objet
         f().a est une valeur



Les deux opérateurs suivants sont en fait dérivés des deux opérateurs précédents mais permettent une écriture plus agréable :

  • l'opérateur de sélection d'un objet dans un tableau []. L'écriture a[b] est équivalente à *(a+b) (ce qui fait qu'on peut écrire indifféremment a[b] ou b[a])
    Les opérandes sont dans un contexte de valeur.
Valeur[Valeur]   =>   Objet
  • l'opérateur unaire -> de sélection d'un champ d'une structure ou d'une union à partir de l'adresse de la structure ou de l'union. L'écriture a->b est équivalente à (*a).b
    L'opérande est dans un contexte de valeur.
Valeur->id   =>   Objet

III-A-2. Opérateurs qui ont une opérande dans un contexte d'objet

Ce sont les 4 opérateurs & . (point) ++ -- ainsi que les opérateurs d'assignation simple ou composée =, +=, etc.

&Objet   =>   Valeur
  • l'opérateur unaire . (point) de sélection d'un champ d'une structure ou d'une union (voir aussi III-A-1).
    Le résultat est alors un objet.
Objet.id   =>   Objet
  • les opérateurs d'incrémentation ++ et de décrémentation --
    Le résultat est une valeur.
Objet++   =>   Valeur
  • les opérateurs d'assignation ( =, +=, etc.) pour leur opérande de gauche. L'opérande de droite est dans un contexte de valeur.
    Le résultat est une valeur.
Objet = valeur    =>   Valeur
Exemple
Sélectionnez
 Supposons que ObjEntier et ObjEntier1 soient deux objets.
 Il est possible d'écrire :
 (les parenthèses sont mises pour la clarté mais  sont ici superflues)
 
       ObjEntier = (ObjEntier1 = UnEntier) ;
       
 Le terme entre parenthèses s'évalue comme une valeur et ObjEntier est un objet
 et on a bien objet = valeur.

  Mais il est impossible de mettre les parenthèses comme ceci :
  
       (ObjEntier = ObjEntier1) = UnEntier2 ;
       
 Le terme entre parenthèses s'évalue comme une valeur et on a  valeur = valeur
 ce qui viole le contexte de l'opérateur =

III-A-3. L'opérateur sizeof

L'opérateur sizeof est une exception. Le contexte de l'opérande est un contexte d'objet. Toutefois, l'opérande peut être un type (entre parenthèses, comme l'opérateur de cast) ou une valeur. Le résultat est une valeur égale au nombre de bytes occupés en mémoire par un objet qui aurait ce type ou le même type que celui de son opérande.

sizeof Objet   =>   Valeur
sizeof (Type)   =>   Valeur
sizeof Valeur   =>   Valeur

III-B. Contexte des fonctions

Il y a deux aspects dans le cas des fonctions : l'appel à une fonction et la fonction elle-même.

- Lors d'un appel à une fonction, tous les arguments sont dans un contexte de valeur. Le résultat de l'appel à une fonction, autrement dit l'expression constituée par l'appel d'une fonction est une valeur. Cet appel ne peut figurer que dans un contexte de valeur.

fonction(Valeur,Valeur,.....)    =>   Valeur

- Les paramètres d'une fonction, qui figurent dans la déclaration de la fonction, représentent des objets locaux à la fonction (en allocation automatique) initialisés par les valeurs correspondantes figurant dans l'appel de la fonction.

- Le contexte de l'expression suivant l'instruction return est un contexte de valeur.

Il n'y a aucune exception à ces règles.

Exemple
Sélectionnez
 Il est impossible d'écrire
  
        f(---)= ...
 mais 
       *f(---)=...
 est possible (à la condition que la fonction f renvoie une adresse).

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.