Le type char porte son nom car il est souvent employé pour traiter des caractères. En effet, il n'y a pas de type "caractère" spécifique : un caractère est identifié à sa valeur, c'est-à-dire à sa place dans le jeu de caractères de la machine (il s'agit souvent du jeu de caractères appelé ASCII).
Les caractères peuvent aussi être représentés par leur symbole usuel entre deux apostrophes (c = 97 est équivalent à c='a').
Signalons qu'il n'y a pas non plus de type booléen. On peut pour le remplacer utiliser le type char. Une expression qui vaut 0 est considérée
comme fausse ; si elle prend toute autre valeur, elle est considérée comme vraie.
Sans paramètre
Avec paramètre
Il est très important de ne pas confondre le symbole == du test d'égalité avec le symbole = de l'affectation.
Losque l'expression :
Il s'agit ici d'une instruction conditionnelle. Si la condition mise entre parenthèses derrière le mot "if" est vraie (c'est-à-dire de valeur non nulle), c'est l'instruction qui est juste derrière le "if" qui est effectuée ; sinon, c'est celle qui est derrière le mot "else".
N'oubliez pas que si la syntaxe attend une instruction et que vous devez en écrire plusieurs, vous devez encadrer vos instructions par des accolades
(symboles "{" et "}") pour en faire un bloc, qui est alors considéré comme une seule instruction dite composée.
Contrairement à la syntaxe du Pascal, toute instruction (non composée) devant se terminer par un ";", la (ou les) instruction(s) qui suivent la condition du "if" contiennent ce ";". Il en est bien entendu de même après le "else".
Le type "int" est un type défini par le langage qui sert à décrire des variables entières.
(*) 1 octet = 8 bits .
Lorsque l'exécution d'un programme écrit en C est lancée,
ce sont les instructions écrites dans la fonction "main" qui sont exécutées.
L'en-tête de la fonction main peut être :
Toute instruction se termine par un point-virgule.
L'instruction break;
L'instruction continue;
Une instruction commençant par le mot réservé "switch" est une instructiondite "de sélection", qui généralise l'instruction conditionnelle "if-else".
On indique derrière le mot switch, entre parenthèses, une expression (qui est souvent une variable) puis on indique entre deux accolades les traitements à effectuer selon la valeur de cette expression. Pour cela, on utilise le mot réservé "case" que l'on fait suivre d'une valeur (entière et constante) puis du symblole ":". On indique alors la liste des instructions à effectuer
si l'expression vaut la valeur indiquée.
On aura par exemple :
Au même niveau que les
IMPORTANT : chaque valeur indiquée dans les "case" correspond à un point
d'entrée dans l'ensemble de toutes les instructions figurant dans le "switch" ; une fois franchi ce point d'entrée, le programme ne quitte la suite des
instructions que lorsque le mot réservé "break" est rencontré, à moins que l'on sorte de la fonction où se trouve le switch grâce à l'instruction return. En l'absence d'une telle barrière, le programme passe d'un "case" au suivant. Dans le petit exemple ci-dessus, si la variable n vaut 2, les instructions 3 et 4 se succéderont.
De même, si on écrit :
Ecrire :
Affectation
L'affectation se fait en C à l'aide du signe =. Le test d'égalité se fait avec ==, il ne faut certainement pas confondre affectation et test d'égalité.
Le type "char"
Le type char n'est rien d'autre qu'un type entier. C'est un type entier
codé sur un octet. Il y a en fait, de même que pour les autres types entiers, deux sous-types du type char qui sont :
Le premier n'a pas besoin de bit de signe : il peut servir à coder des entiers entre 0 et 255. Le second utilisant 1 bit pour le signe sert à coder des entiers entre -128 et +127.
Le type char représente l'un ou l'autre des deux sous-types selon la machine utilisée.
Si on a la déclaration :
on peut écrire l'instruction c = 97; (97 est la valeur de 'a' dans la table ASCII).
#define
Cette directive permet d'associer à un mot (sans espace) auquel sont éventuellement associés des paramètres une chaîne de caractères. Avant la compilation, un préprocesseur remplace dans le fichier source chaque occurrence du mot par la chaîne de caractères. La chaîne de caractères considérée s'arrête à la fin de la ligne, sauf si le dernier caractère de la ligne est le caractère "\", auquel cas la chaîne de caractères est poursuivie par celle de la ligne suivante.
Cette directive peut être utilisée avec ou sans paramètre.
Prenons l'exemple de :
Chaque fois qu'il est écrit LONGMAX dans le programme, le préprocesseur remplace ce mot par 25.
Prenons l'exemple de :
Si, dans le programme, a et b sont deux variables de type int et qu' il y a :
alors tout se passe comme si on avait en fait :
echange(int, a, b) conduit donc à l'échange des valeurs de a et b.
Différent
!= signifie différent
égalité
Le double symbole == (deux fois le signe =) permet le "test d'égalité".
Par exemple, si x et y sont deux variables de même type, l'expression x==y est vraie (c'est-à-dire vaut 1) si et seulement si x et y ont la même valeur ; sinon, l'expression x==y vaut 0.
Si x vaut 2 et que y vaut 5, l'expression x==y vaut 0 alors que l'expression x=y conduira à mettre dans x la valeur 5 et par ailleurs cette dernière expression (c'est-à-dire (x=y)...) vaut 5, puisque toute expression a une valeur et que la valeur d'une affectation est la valeur du second membre de cette affectation.
Le "et" logique
&& signifie "et" et suit les règles usuelles de cet opérateur logique.
Lorsque les deux opérandes sont vrais (c'est-à-dire non nuls), l'expression est vraie (c'est-à-dire qu'elle vaut 1), sinon elle est fausse (c'est-à-dire qu'elle vaut 0).
est évaluée, la valeur de condition2 n'est calculée que si condition1 est vraie.
Les conditions doivent être entourées de parenthèses.
Les types "réels"
A côté des types entiers, le C dispose de deux types réels, le type "float" et le type "double". La différence entre eux est de même nature que la différence entre les types "int" et "long", c'est-à-dire qu'en général les réels déclarés de type "double" sont codés sur plus d'octets que ceux de type "float" et permettent d'obtenir dans les calculs des résultats avec une meilleure précision.
Lorsque l'on fera appel à des bibliothèques mathématiques pour travailler sur des réels, on les déclarera systématiquement de type "double".
La boucle for
Le mot clé for est toujours suivi de parenthèses entre lesquelles on trouve trois champs séparés par deux point-virgules. On a ensuite une instruction ou bien un bloc. On obtient ce qu'on appelle une boucle for.
Prenons un exemple pour expliquer la boucle for.
i et fact sont deux variables de type int et fact vaut 1.
Lorsque cette expression est rencontrée, sucessivement :
On aurait aussi pu écrire la même boucle :
for (i = 2; i < 4; i++)
{
fact = fact*i;
}
ou bien encore, mais c'est un peu plus lourd :
i = 2;
while (i<4)
{
fact = fact*i;
i++;
}
if-else
#include
La directive #include suivie d'un nom de fichier
est traitée par le préprocesseur, avant la compilation.
S'il s'agit d'un fichier d'une bibliothèque standard,
son nom doit être encadré par les caractères < et >.
S'il s'agit d'un fichier du répertoire courant,
son nom doit être entre " et ".
Lorsque cette directive est rencontrée, le contenu
du fichier nommé est reproduit ("inclus") dans le programme
à la place de la directive #include.
Le symbole # annonce une directive pour le préprocesseur.
Les types "entiers"
En mémoire, toute valeur est traduite sous forme binaire. Pour traduire un "int", la place réservée peut être de 2 ou 4 octets selon l'implémentation (*). Considérons le cas où le type int est codé sur deux octets.
Sachant que le premier des 16 bits (dit "de poids fort") consacrés à un "int" permet (en général) de traduire le signe (0 pour positif, 1 pour négatif),
le plus grand "int" positif que l'on peut coder vaut 2 puissance 15 - 1, c'est-à-dire 32767.
Si vous n'utilisez que des entiers positifs ou nuls, vous pouvez adopter le type unsigned int qui n'utilise pas de "bit de signe" et permet ainsi dans le cas considéré, de travailler avec des entiers non négatifs valant au plus 65535.
Vous pouvez aussi essayer d'utiliser le
type : long int, que l'on peut noter long. Celui-ci a droit a au moins
autant d'octets que le type int (souvent 4 octets) et peut donc éventuellement vous permettre de travailler sur de plus grands entiers.
Un bit est l'unité-mémoire et porte l'information 0 ou 1.
main
Le "ou" logique
Le double symbolle || signifie ou (inclusif) et suit les règles usuelles de cet opérateur logique.
Le point-virgule
La ligne qui annonce la définition d'une fonction n'étant pas
une instruction, une telle ligne n'est pas terminée par un point-virgule.
break
continue
placée dans une boucle, fait que les instructions suivantes incluses dans la boucle sont ignorées. Le programme reprend :
return
Le mot réservé return conduit à la sortie de la fonction en cours d'exécution.
Le programme reprend alors à l'instruction de la fonction "appelante" qui suit l'appel de la fonction qui vient de "retourner".
Le mot return peut être suivi d'une expression : la fonction "retourne" alors la valeur de l'expression. L'instruction :
conduira à attribuer à maVariable la valeur "retournée" par maFonction.
L'instruction :
à la fin de la fonction main permet de renvoyer la valeur 0 au système, ce qui signifie (par convention) que le programme s'est terminé dans des conditions normales. Le renvoi d'une telle valeur entière est rendu obligatoire par l'en-tête de la fonction main qui annonce le retour d'un int :
sizeof
sizeof permet de connaître
exemples :
sizeof(char) vaut 1 alors que sizeof(int) vaut 2 ou 4 selon l'implémentation.
exemple : si c est une variable de type char, on pourra écrire sizeof(c)) ou bien sizeof c ); les deux expressions ont la valeur 1
switch
switch (n)
{
case 1 : instruction1;
instruction2;
break;
case 2 : instruction3;
case 3 : instruction4;
break;
default : instruction4;
}
on peut utiliser
"default :" ;
si l'expression n'est pas égale à l'une des valeurs listées, ce sont alors les instructions du "default" qui seront excutées.
typedef
Ce mot clé sert à renommer des types.
Prenons l'exemple de :
Il s'agit de donner un autre nom au "type" enum tour.
Tour se trouve tout simplement être synonyme de enum tour.
hauteur est synonyme de int. On a alors le droit de déclarer :
une_hauteur est une variable de type int (cela peut améliorer la lisibilité
d'un programme).
while
Lorsque le programme rencontre une boucle "while", il évalue l'expression qui se trouve entre les parenthèses (d'ailleurs indispensables) derrière le mot while. Si sa valeur n'est pas 0 (ce qui revient à dire que l'expression entre parenthèses est vraie), le programme effectue les instructions qui sont à l'intérieur de la boucle while puis "remonte" à la condition du while et ainsi de suite ; si la valeur de l'expression vaut 0, le programme ne passe pas dans la boucle "while" et va à l'instruction qui suit cette boucle. Si plusieurs instructions sont à faire dans la boucle while, celles-ci doivent être regroupées en un bloc, ce qui signifie qu'on doit les encadrer par des accolades.
Il est essentiel de s'assurer, avant de lancer l'exécution d'un programme, que l'on n'a pas écrit une boucle infinie. Une des instructions contenues dans le corps de la boucle doit donc pouvoir modifier le résultat du test
effectué au début de la boucle.
->
Le symbole double "->" ("tiret" suivi de "supérieur") est un raccourci.
Si debut est l'adresse d'une structure contenant un champ entier valeur, l'expression :
est synonyme de :
*debut est la structure sur laquelle pointe debut (ce qui signifie "dont debut est l'adresse") : l'expression (*debut).valeur représente donc le champ valeur de cette structure .
n'aurait pas de sens car le "." est prioritaire sur le symbole "*".