Concepts en C

Cohérence, logique et fonctionnement du C

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▲

À 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 donnent 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 un opérande dans un contexte d'objet▲

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

l'opérateur unaire & permettant d'obtenir l'adresse d'un objet.
Le résultat est une valeur.

&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).