enum
type { idf [ = constante] [, ...] } ;
permet de définir une liste d'identificateurs dont chaque élément
est associé à la valeur d'une constante obligatoirement
entière : int.
Définition
des énumérations : enum
bool {faux = 0, vrai = 1} enum
direction { N, NW, W, SW, S, SE, E, NE } ; enum
symbole { ajouter = 'a', modifier = 'm', ...
Déclaration
des variables : enum
bool b ; enum
symbole s ;
Utilisation
: if
(b == faux) ... switch
(s) { modifier
: ...
Les énumérations
:
enum bool {faux = 0, vrai = 1} définit
le type enum bool constitué des deux identificateurs faux
et vrai ayant respectivement les valeurs entières 0
et 1.
enum direction { N, NW, W, SW, S, SE, E, NE } ; montre
qu'il n'est pas nécessaire de donner une valeur explicite à
chaque identificateur : les
constantes entières prennent les valeurs consécutives à
partir de 0; par exemple, N vaut 0, NW vaut 1,...
enum symbole { ajouter = 'a', modifier = 'm', supprimer = 's' } ; enum symbole s = getchar
() ; une
constante caractère est en fait de type int et peut être
utilisée dans une énumération, le caractère
'a' a pour valeur entière 97. La
fonction getchar ( ) retourne également une valeur de type
int.
#define est une directive
de compilation : #define TAILLE 10 #define PI 3.1415927 #define EOF -1 #define LF '\n' #define CHEMIN "/users/toto/projet/sys"
La directive #define est interprétée par le préprocesseur
C, c'est un mécanisme de substitution : toutes les occurences de
nom sont remplacées par le texteavant la
compilation.
Par convention
: le nom d'une macro-constante est en lettres majuscules.
La directive #define est également présentée
plus loin.
#define VAL .3
void main(void) {
float
f ; f
= 2. * VAL ; }
gcc prog.c -o prog "prog.c", line
6: syntax error near or at symbol ;
Option du compilateur : -E : demande l'exécution
seule du préprocesseur C qui transforme les fichiers sources .c
en fichiers textes prêts à être compilés.
gcc fichier.c -E > fichier.res
L'option -P, à utiliser conjointement avec l'option -E,
supprime les lignes commençant par le caractère #.
Compacité du code généré
Déclaration
de variables : BOOLEAN
b ; CHAINE
nom ; CHAINE
tab[100] ; P_ENTIER
p ; P_ENTIER
*p ;
Exemple de déclaration de type pour une structure Le
type de structure est présenté plus
loin. typedef struct
{ double
réel ; double
imaginaire ; } COMPLEXE ;
Où la déclaration d'objets s'écrit sous la forme
: COMPLEXE nb ; COMPLEXE tab[N]
; COMPLEXE *p ; ...
Le langage C offre un jeu très étendu d'opérateurs,
ce qui permet l'écriture d'une grande variété d'expressions.
Un principe général est que toute expression retourne
une valeur. On peut donc utiliser le résultat d'une expression
comme partie d'une autre expression. De plus, le parenthésage permet
de forcer l'ordre d'évaluation.
Liste des opérateurs arithmétiques& logiques
+-*/
% : modulo
>> : décalage à droite
<< : décalage à gauche
& : et logique (bit à bit)
| : ou logique (bit à bit)
^ : ou exclusif (XOR)
~ : complément à 1 (NOT)
Les opérateurs arithmétiques
+addition -soustraction *multiplication /division
(entière ou réelle) %modulo
(sur les entiers)
Les opérateurs logiques
Ce sont les opérateurs permettant d'effectuer des opérations
au niveau des bits (masquages,...) : & AND exemple
:a & 0x000F extrait les 4 bits de poids faible de a
| OR exemple
: b = b | 0x100 met à 1 le 9ième bit de b ~ XOR
<< décalage
à gauche exemple
: a = b << 2 met dans a la valeur de b où tous les bits ont
été décalés de 2 positions vers la gauche >> décalage
à droite ~ complément à
1 (opérateur unitaire)
L'affectation
est une expression qui possède une valeur. Son
résultat est égal à la valeur finale du membre gauche
(ici 0) : i
= j = k = 0 ; est
équivalent à : i
= (j = (k = 0 )) ; Simplification
d'écriture : x
opérateur_binaire = expression
+=-=*=/=<<=,
...
x += 3 ;
est équivalent àx = x + 3
L'affectation : elle
a pour symbol =
Il
faut bien noter que le signe = est l'opérateur d'affection,
et non de comparaison; cela prête parfois à confusion et
entraîne des erreurs difficiles à discerner. A
noter aussi que l'affection est une expression comme les autres, c'est-à-dire
qu'elle retourne une valeur. Il est donc possible d'écrire : a
= b = c + 2 ; ceci revenant à affecter à b le résultat de l'évaluation
de c + 2, puis à a le résultat de l'affection b
= c + 2, c'est-à-dire la valeur qu'on a donné à
b.
Remarquez
l'ordre d'évaluation de la droite vers la gauche.
Modifier la valeur d'une variable Il
arrive très souvent qu'on calcule la nouvelle valeur d'une variable
en fonction de son ancienne valeur. Le langage C fournit pour cela un
jeu d'opérateurs combinés, de la forme <variable>
<op> = <expr>, où <op> est un opérateur.
Une telle expression est équivalente à l'expression :
<variable> = <variable> <op>
<expr>
Par exemple pour += :a
+= béquivaut
àa = a + b
de même pour : -=*=/=%=<<=>>=&=|=^=
Les opérateurs d'incrémentation et de décrémentation ++incrémentation --décrémentation
Exemples : a ++ ; équivaut à a = a + 1 ;
b = a++ ; équation de l'expression avant d'incrémenter a, équivaut
à : b
= a ; a
= a + 1 ;
b = ++a ; évaluation
de l'expression après avoir incrémenté a. équivaut
à : a
= a + 1 ; b
= a;
Ces
opérateurs, qui ne peuvent être appliqués que sur
les types scalaires, peuvent s'employer de deux matières : en principe,
s'ils préfixent une variable, celle-ci sera incrémentée
(ou décrémentée) avant utilisation dans le reste
de l'expression; s'ils la postfixent, elle ne sera modifiée qu'après
utilisation. Ainsi : a
= 5 ; b
= 6 ; c
= ++a - b ; donnera à c la
valeur 0, alors que
a
= 5 ; b
= 6 ; c
+ a++ - b ; lui donnera la
valeur -1.
Faites
cependant attention dans les expressions un peu complexes où on
réutilise la même variable plusieurs fois : l'ordre d'évaluation
n'est pas garanti, et l'expression peut donc avoir des résultats
différents suivant la machine utilisée.
Ici, les contenus des variables b et i dépendent du compilateur
utilisé : a = 5 ; b = a++ + a*2;