CyBWarrior

Pour fonctionner, un programme à generalement besoin de pouvoir utiliser des données. Pour cela, il doit pouvoir
stocker les valeurs, et pouvoir y acceder par la suite. Le programme poura ensuite les controler, et pourquoi
pas, les modifier.
Pour cela, il existe un moyen simple qui est l’utilisation des variables.

Mais avant de voir tout ceci en détail, il nous faut tout d’abord distinguer les différents types de données
existants.
On peut commencer par distinguer les chiffres (données numeriques) du texte (chaînes de caractères).
Pour les nombres, rien de bien compliqué. En revanche, l’exploitation des chaînes de caractères est relativement complexe
en comparaison à d’autres langages plus accessibles comme le Basic ou le Pascal. C’est pourquoi nous les aborderons dans des sections futures, quand
nous serons plus calés .

Mais compliquons quand même un peu : dans les données numériques, on peut encore trouver des « sous-catégories », comme par exemple, les nombres entiers,
decimaux, signés (uniquement positifs)…

Commençons par les types de variables entiers, que voici :

Types de variables en langage C

Type	Description	Intervalle Signé	Intervalle Non-Signé	Memoire requise
char	Destiné à recevoir le code ASCII d’un caractère	-128 à 127	0 à 255	1 octets
short	Entier court	-32768 à 32767	0 à 65535	2 octets
int	Entier standard (très utilisé)	-32768 à 32767	0 à 65535	2 octets
long	Entier long	-2147483648 à 2147483647	0 à 4294967295	4 octets

En C, la déclaration d’une variable se fait selon la syntaxe suivante :

type identificateur;

type represente le type de la variable et identificateur le nom de cette variable.
Un identificateur doit suivre certaines regles, comme :

• Ne pas contenir d’espaces ou de carctères dits spéciaux comme les accents, la ponctuation (à l’execption du trait de soulignement),
  etc…
• Ne pas commencer par un chiffre (il peut par contre en contenir)
• Ne pas prendre le nom d’une fonction déjà existante

De plus, un identificateur de variable doit s’efforcer d’être explicite au maximum. C’est à dire que l’on devrai pouvoir savoir ce que représente
une variable rien qu’en lisant son nom.

Voici quelques exemples de déclaration de variables valides :

int i;/* Entier normal*/
char touchepressee;/* Caractère */

La déclaration des variables doit se faire avant toute instruction, sinon une erreur de compilation se produit. À notre stade, nous délarerons les
variables dans la fonction main(). Il est possible de les déclarer à l’exterieur, mais cela n’est utile que pour un programme possedant
plusieurs fonctions, ce qui n’est pas le cas pour l’instant.

Pour affecter une valeur à une variable, on utilise tout simplement l’opérateur = (égal). Ce qui est du coté droit de cet opérateur sera
alors affecté au coté gauche. Par exemple, pour affecter la valeur 5 à la variable nombre, on écrira :

int main(){
int nombre;/* Declaration de la variable nombre */
nombre = 5;/* Affectation de 5 à nombre */
return 0;
}

Bien evidement, le coté gauche de cet opérateur ne peut en aucun cas être une constante, puisque la valeur d’une constante est par définition invariable.
En revanche, on peut parfaitement affecter la valeur d’une variable à une autre :

int main(){
int nombre, autrenombre;
nombre = 5;/* Affectation de 5 à nombre */
autrenombre = nombre;/* Affectation de nombre à autrenombre */
return 0;
}

Vous remarquez que on a déclaré la variable nombre et la variable autrenombre sur la même ligne. Cette syntaxe est également
possible.
Maintenant que nous avons vu comment affecter une valeur à une variable, nous allons voir comment afficher sont contenu. Pour cela, nous allons utiliser
la fonction printf de la bibliothéque stdio.
La syntaxe de cette fonction est extrement complexe (ou plutôt très complete) et nous ne l’aborderons pas en détail dans cette section.
Pour afficher le contenu d’une variable numérique, nous utiliserons simplement la syntaxe suivante :

printf("Ceci est du texte %u", variable);

Vous avez reconnu la première partie de cette fonction, "Ceci est du texte %u". Il s’agit d’une chaîne de caractères qui sera affichée
à l’écran, à un petit détail près : la séquence %u sera remplacée par la variable variable passée comme second argument.
Si nous avions plusieurs variables, nous aurons pu écrire :

printf("A vaut %d et B vaut %d", A, B);

Le premier %d sera remplacé par le contenu de la variable A, et le second %d par celui de B.
Ainsi, pour afficher le contenu de notre variable nombre, nous écrirons :

#include <stdio.h>

int main(){
int nombre=5;/* Déclaration et affectation */

printf("Le contenu de nombre est %d", nombre);/* Sortie -> 5 */
return 0;
}

La première ligne (en fait, la seconde) permet de gagner du temps en déclarant une variable et en lui affectant une valeur initiale (ici, 5).

Maintenant, revenons à notre histoire de type signé et non-signé. Pour déclarer une variable non-signée, c’est à dire uniquement positive, il suffit
de rajouter le mot-clef unsigned devant la déclaration de la variable :

unsigned short MaVariable;/* Intervalle : 0 à 65535 */

Maintenant, si on affecte une valeur négative à MaVariable, aucune erreur ne se produira, mais le résultat sera arbitraire :

#include <stdio.h>

int main(){
unsigned short MaVariable=-10;

printf("Cet valeur n'est pas garantie %u", MaVariable);
return 0;
}

Il faut donc faire très attention aux valeurs utilisées.
Mais passons maintenant aux types flottants. Les voici répertoriés dans le tableau ci-dessous :

Types de variables en langage C

Type	Description	Intervalle	Memoire requise
float	Nombres réels	3.4 x 10-38 à 3.4 x 10+38	4 octets
double	Nombres réels longs	1.7 x 10-308 à 1.7 x 10+308	8 octets
long double	Nombres réels très longs	3.4 x 10-4932 à 3.4 x 10+4932	10 octets

L’utilisation de ces types est identique que pour les types entiers.
Par contre, l’utilisation de printf sera differente. On poura par exemple écrire :

#include <stdio.h>

int main(){
float Nombre=3.1415;

printf("%f", Nombre);
return 0;
}

1. Opérateurs arithmétiques
2. Opérateurs d’assignation
3. Opérateurs d’incrémentation / décrémentation
4. Opérateurs logiques
   1. Le non !
   2. Le ou ||
   3. Le et &&
5. Opérateurs binaires
   1. Le non ~
   2. Le ou |
   3. Le et &
   4. Le ou exclusif ^
   5. Le décalage de bits << et >>
6. Opérateurs relationnels

Le opérateurs sont des elements du langage C lui permettant de traiter les données. On y retrouve ainsi des opérateurs
arithmetiques, logiques, binaires, etc…
Si vous connaissez d’autres langages, certains (voir tous) de ces opérateurs vous paraitront familiers.

Opérateurs arithmétiques

Pour réaliser les 4 opérations, le C utilise les opérateurs suivants :

Opérateur	Fonction	Exemple de code	Résultat
+	Addition	printf( »%d », 5 + 5);	10
-	Soustraction	printf( »%d », 25 – 10);	15
*	Multiplication	printf( »%d », 5 * 5);	25
/	Division	printf( »%d », 63 / 7);	9
%	Modulo (reste d’une division)	printf( »%d », 20 % 3);	2

On peut bien sur utiliser ces opérateurs avec des variables :

#include 
int main(){
int a=5;
int b=1;
int c=10;

a = a + b * c;
printf("Resultat : %d", a);/* Sortie -> 15 */
return 0;
}

Opérateurs d’assignation

Vous connaissez déjà un des ces opérateurs : l’opérateur =.
Vous serez peut-être surpris mais il n’est pas tout seul.
Prenons un exemple. Pour ajouter 5 à une variable et enregistrer le résultat de cette opération
dans cette même variable, vous serez certainement tenté d’écrire :

int a=10;

a = a + 5;/* a = 15 */

Ce n’est pas faux et c’est même tout à fait correct.
Mais le C peut faire mieux dans ce cas là avec l’opérateur += qui ajoute les opérandes
de droite à la variable placée à gauche et place le résultat dans cette même variable.
Ainsi, on peut écrire :

int a=10;

a+=5;/* Reviens à écrire a = a + 5 */

Cette possibilité est étendue aux 4 autres opérateurs :

Opérateur	Exemple	Equivalence
+=	a += b;	a = a + b;
-=	a -= b;	a = a – b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Opérateurs d’incrémentation / décrémentation

Prenons la variable x. Nous voulons lui ajouter 1 et seulement 1.
On peut écrire :

int x=0;

x += 1;/* Reviens à écrire x = x + 1 */

Là aussi le C permet d’aller encore plus vite en écrivant à la place :

int x=0;

x++;/* Reviens à écrire x += 1, ce qui revient à écrire x = x + 1 */

La décrémentation (enlever une unité) se passe de la même façon, mais avec – au lieu de
++ :

int x=0;

x--;/* Reviens à écrire x -= 1, ce qui revient à écrire x = x - 1 */

Attention ! Il convient de distinguer la pré-incrémentation / décrémentation de la
post-incrémentation / décrémentation.
Lors de cette dernière, l’opérateur est placé après la variable, comme dans :

int x=0;

x++;/* Post-incrémentation */

Pour effectuer une pré-incrémentation, on écrira :

int x=0;

++x;/* Pré-incrémentation */

Quel est l’intérêt ?
Voici un exemple :

#include 
int main(){
int a=5;
int b=5;
/*  a et b ont tout les deux pour valeur 5  */

printf("a++ = %d", a++);/* Sortie -> a++ = 5*/
printf("++b = %d", ++b);/* Sortie -> ++b = 6*/
return 0;
}

La voilà la différence :

• Dans le 1^er cas, la variable est incrémentée après avoir renvoyée sa valeur
• Dans le 2^ème, la variable est incrémentée avant d’avoir renvoyée sa valeur

Opérateurs logiques

Les opérateurs logiques permettent d’effectuer des opérations logiques dites booleennes.
Un ordinateur etant un système electrique, il ne comprend que deux états : ouvert (1) ou fermé (0).
C’est sur ces valeurs (1 et 0) que les opérateurs logiques permettent de travailler.
Le C définit une expression comme étant à 1 si celle-ci est différente de 0. Ainsi,
21 sera considéré comme 1.
Ces opérateurs seront très utilisés plus tard, avec les conditions et les boucles.
Il existe 3 opérateurs logiques : le non (!), le et (&&) et le ou (||).

Le non !

Le non effectue une inversion. On utilise le point d’exclamation (!).

Argument	Résultat
0	1
1	0

Exemple :

#include 
int main(){
int variable=32;

printf("%d", !variable);/* Sortie -> 0 */
printf("%d", !!variable);/* Sortie -> 1 */
return 0;
}

Le ou ||

Le ou renvoi 1 si l’une des deux opérandes au moins est à 1.
On utilise l’opérateur ||.

1er argument	2ème argument	Résultat
0	0	0
0	1	1
1	0	1
1	1	1

Exemple :

#include 
int main(){
printf("%d", 0 || 0);/* Sortie -> 0 */
printf("%d", 0 || 20);/* Sortie -> 1 */
printf("%d", 20 || 30);/* Sortie -> 1 */
return 0;
}

Le et &&

Le et renvoi 1 si les des deux opérandes sont à 1.
On utilise l’opérateur &&.

1er argument	2ème argument	Résultat
0	0	0
0	1	0
1	0	0
1	1	1

Exemple :

#include 
int main(){
printf("%d", 0 && 0);/* Sortie -> 0 */
printf("%d", 0 && 12);/* Sortie -> 0 */
printf("%d", 78 && 0);/* Sortie -> 0 */
printf("%d", 42 && 9);/* Sortie -> 1 */
return 0;
}

Opérateurs binaires

Pour bien comprendre à quoi servent les opérateurs binaires, vous devez tout d’abord savoir qu’est
ce que le binaire. C’est pourquoi je vous invite à lire ceci : La numération.
Ensuite, ce qui suit deviendra compréhensible

Le non ~

Le non ne permet non pas d’inverser tout les bits d’un nombre, mais d’effectuer le complément
à deux de ce nombre. On utilise l’opérateur ~ :

#include 
int main(){
int nombre=3;/* 11 en binaire */

nombre = ~ nombre;
printf("%d", nombre);/* Sortie -> -4 */
}

Le ou |

Le ou effectue un ou (!) entre chaques bits des deux opérandes. On utilise l’opérateur
| :

#include 
int main(){
int a=2;/* 2 -> 10 en binaire */
int b=1;/* 1 -> 01 en binaire */
int resultat=a | b;
/*1 | 0 -> 1
0 | 1 -> 1
resultat = 11 = 3*/
printf("%d", resultat);/* Sortie -> 3*/
return 0;
}

Le et &

Comme le ou, le et effectue un et entre chaques bits des deux opérandes. On utilise l’opérateur
& :

#include 
int main(){
int a=255;/* 255 -> 11111111 en binaire*/
int b=170;/* 170 -> 10101010 en binaire*/
int resultat=a & b;
/*1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
resultat = 10101010 = 170*/
printf("%d", resultat);/* Sortie -> 170 */
return 0;
}

Le ou exclusif ^

Le ou exclusif effectue un ou exclusif (en l’aurait deviné ) entre les bits des deux opérandes. On
utilise l’opérateur ^ :

#include 
int main(){
int a=255;/* 255 -> 11111111 en binaire*/
int resultat = a ^ a;
/*1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
resultat = 00000000 = 0*/
printf("%d", resultat);/* Sortie -> 0 */
return 0;
}

Le décalage de bits << et >>

On peut facilement décaler les bits d’un nombre vers la gauche ou la droite d’un certain nombre
de bits.
Pour décaler les bits vers la gauche, on utilise l’opérateur <<. Pour les décaler vers
la droite, c’est >> qui est utiliser.
Dans tout les cas, on place à gauche de l’opérande le nombre à modifier, et à sa droite le nombre
de bits à décaler :

#include 
int main(){
int a=3;// 3 -> 11 en binaire

a = a << 4;
/*On décale de 4 rang vers la gauche, donc :
11 - > 110000 = 48*/
printf("%d", a);/* Sortie -> 48 */

a = a >> 8;
/*On décale de 8 rand vers la droite, donc :
110000 -> 0*/
printf("%d", a);/* Sortie -> 0 */

return 0;
}

À noter que comme pour les opérateurs d’affectation énoncés ci-dessus, ces opérateurs peuvent dans
certains cas être résumés ainsi :

Opérateur	Exemple	Equivalence
|=	a |= b;	a = a | b;
&=	a &= b;	a = a & b;
~=	a ~= b;	a = a ~ b;
<<=	a <<= b;	a = a << b;
>>=	a >>= b;	a = a >> b;

Opérateurs relationnels

Les opérateurs relationnels permettent de comparer des données.
Le résultat de ces opérateurs est un résultat booleen, c’est à dire que l’expression sera évaluée soit à 1,
soit à 0. On peut ainsi combiner ces expressions avec les opérateurs logiques énoncés plus haut.
Voici un tableau récapitulatif :

Opérateur	Description	Exemple de code	Résultat
==	Egualité	int a=25; int b=a; printf( »%d », a==b);	1
!=	Inégalité	int a=120; int b=350; printf( »%d », a != b);	1
<	Inférieur	int a=10; int b=100; printf( »%d », a < b);	1
<=	Inférieur ou égal	int a=100; int b=100; printf( »%d », a <= b);	1
>	Supérieur	int a=100; int b=10; printf( »%d », a > b);	1
>=	Supérieur ou égal	int a=100; int b=100; printf( »%d », a >= b);	1

Le C possede encore d’autres opérateurs, mais nous les decouvrirons plus tard, car ils concernent des choses
specifiquent que nous n’avons pas encore découvertes.

1. if…else
2. ?:

if…else

Comme son nom semble l’indiquer, la structure conditionnelle permet d’influer sur le deroulement du programme, suivant certains conditions.
On utilise pour cela if, dont voici la syntaxe :

if(condition)instruction;

Si condition est évalué comme vrai (c’est à dire comme étant diférent de 0), instruction est executé.
Exemple :

#include <stdio.h>

int main(){
int heure=21;

if(heure >= 19)puts("Bonsoir");/* SI heure > 19 ALORS Bonsoir*/

return 0;
}

Le code ci-dessus affiche la chaïne Bonsoir si la variable heure est supérieur à 19. Dans le cas contraire,
rien ne se passe. On peut alors modifier ce comportement, en utilisant une syntaxe plus élaborée, avec else.
Voici la syntaxe d’une telle structure :

if(condition)instruction;
else instructionalternative;

Nous pouvons alors developper un peu plus notre programme :

#include <stdio.h>

int main(){
int heure=21;

if(heure >= 19)puts("Bonsoir");/* SI heure > 19 ALORS Bonsoir*/
else puts("Bonjour");/* SINON Bonjour*/

return 0;
}

Il est egalement possible de combiner des if dans des else. On peut ainsi utiliser plusieurs conditions dans une même structure :

#include <stdio.h>

int main(){
int heure=21;

if(heure >= 23)
puts("Bonne nuit");/* SI heure > 23 ALORS Bonne nuit   */
else if(heure >= 19)
puts("Bonsoir");/* SINON SI heure > 19 ALORS Bonsoir   */
else if(heure == 12)
puts("Bon appetit");/* SINON SI heure == 12 ALORS Bon appetit  */
else
puts("Bonjour");/* SINON Bonjour   */

return 0;
}

Vous remarquez que nous avons étudié soigneusement l’ordre d’apparition des conditions : si nous avions placé if(heure > 19) en première
position, le programme n’aurai jamais affiché Bonne nuit même si heure était quand même supérieur à 23.

Mais que ferions-nous si nous avions plusieurs instructions à executer pour une seule condition ?
Et bien nous utiliserions tout simplement ce que l’on appelle un bloc d’instructions. Un bloc d’instructions est composé d’une série d’instructions
placées entre accolades ({ et }).
On peut alors écrire :

#include <stdio.h>

int main(){
int age=19;

if(age >= 77){/* SI age >= 77 ALORS ...*/
printf("Hé pépé!\n");/* ... Hé pépé! ...*/
printf("C'est pas pour toi!");/* ... C'est pas pour toi!*/
}
else if(age >= 18){/* SI age >= 18 ALORS ...*/
printf("C'est bon!\n");/* ... C'est bon! ...*/
printf("Vous pouvez rentrer");/* ... Vous pouvez renter*/
}
else{/* SINON ...*/
printf("Dégage, minus!\n");/* ... dégage, minus !*/
printf("Rentre vite chez toi");/* ... Rentre vite chez toi*/
}

return 0;
}

Note : le caractère \n dans les chaînes de caractères permet d’effectuer un retour à la ligne.

?:

Le C possede un opérateur bien pratique dans certains cas : ?:.
Ce drole de signe doit se comprendre ainsi :

condition ? ValeurSiVrai : ValeurSiFaux;

Si condition est évalué comme vrai, l’opérateur renvoi ValeurSiVrai. Si il est évalué comme étant faux, il renvoi ValeurSiFaux.
Bien que nous n’ayons pas encore étudié les chaînes de caractères, l’exemple suivant est tout de même instructif :

#include <stdio.h>

int main(){
int nombre = 5;
char *etat = (nombre % 2 == 0 ? "paire" : "impaire");

printf("Le nombre %d est %s", nombre, etat);

return 0;
}

En dehors de la classique structure if...else, le C possede une autre structure lui permettant
de tester les variables : il s’agit de la structure switch.
switch va executer un groupe d’instructions correspondant à une valeur bien précise de la variable.
Ces groupes sont appellés des cas.
Voici la syntaxe d’une structure switch « classique » :

switch(variable){
case constante1 :
instruction1;
instruction2;
break;

case constante1 :
instruction1;
instruction2;
break;

default :
instruction1;
instruction2;
}

Lorsque le programme rencontre cette structure, il regarde le cas dont constante correspond à
la valeur de variable.
Si il trouve une constante remplissant cette condition, il execute les instructions situés juste en dessous,
jusqu’à ce qu’il rencontre un break ou bien jusqu’à la fin de la structure si aucun break
n’est rencontré.
break force le programme à sortir de la structure switch. On verra par la suite
que son utilisation n’est pas seulement limitée à la seule structure switch.
Cela signifie qu’en l’abscence de break des instructions appartenant à plusieurs cas peuvent être
executées. Ceci peut, comme dans l’exemple ci-dessous, être un effet recherché.
Si aucun cas, ne correspond à la valeur de variable, les instructions placées après default
seront executées.

Les constantes utilisées dans les case ne peuvent être que des entiers ou des caractères (nous en
apprendrons plus sur les caractères par la suite).

Voici un exemple d’utilisation de la structure switch :

#include <stdio.h>

int main(){
int combien=5;/* Assignez le nombre que vous voulez*/

switch(combien){
case 0 :/* Si combien == 0*/
puts("Vous connaissez la sortie...");
break;/* On sort du switch*/

case 1 :/* Si combien == 1*/
puts("Une table pour une personne, une !");
break;/* On sort du switch*/

case 2 :/* Si combien == 2*/
puts("Haha! Un dîner en tête à tête ?");
break;/* On sort du switch*/

case 7 :/* Si combien == 7
   Pas de break on ne sort
   pas du switch*/

case 13 :/* ou Si conbien == 13*/
puts("Désolé, ici on est superstiteux ");
puts("et on ne sert pas se nombre de couverts");
break;/* On sort du switch*/

default :/* Sinon...
   On teste avec des if...else
   pour trouver le cas approprié*/
if(combien > 2 && combien < 13){
puts("C'est un repas en famille ?");
}
else if(combien > 12){
puts("Mais vous êtes une armée !");
}
else{
puts("Très drôle");
}
break;
}

return 0;
}

1. La boucle while
2. La boucle do…while
3. La boucle for
4. Imbrication
5. break et continue

Les boucles (ou structures repetitives) permettent de repeter des instructions que l’on veut executer plusieurs fois.
Il existe 3 sortes de boucles en langages C.

La boucle while

La boucle while est composée de deux choses :

• d’une instruction ou d’un bloc d’instruction.
• une condition

while peut être traduit par tant que. Les instructions seront donc executées tant que
la condition sera analysée comme vrai (c’est à dire valant 1).
Voici la syntaxe de while :

while(condition)instruction;

while(condition){
instruction1;
instruction2;
instruction3;
}

Voici un exemple de code, qui permet d’afficher la table de 7 :

#include <stdio.h>

int main(){
int i=0;

printf("Apprenons la table de 7\n\n");

while(i < 10){/* TANT QUE i < 10     */
i++;/* repeter les instructions */
printf("%d x 7 = %d\n", i, i * 7);/* suivantes    */
}

return 0;
}

La boucle do...while

do...while est une variante de while.
Dans une structure en while, la condition est testé en entrant dans la boucle. Dans l'exemple
précedent, si on avait affecté une valeur supérieur à 10 à i avant while,
la boucle n'aurait pas été executée.
Pour preuve :

#include <stdio.h>

int main(){
int i=20;/* 20 > 10  (!) */

printf("Apprenons la table de 7\n\n");

while(i < 10){/* i > 10 -> la boucle n'est pas executée */
i++;
printf("%d x 7 = %d\n", i, i * 7);
}

return 0;
}

Avec une boucle do...while, la condition est testée à la sortie de la boucle. Les instructions
seront donc obligatoirement executées au moins une fois, quoi qu'il arrive.
Voici la syntaxe de la boucle do...while :

do{
instruction1;
instruction2;
instruction3;
}while(condition);

Voici un exemple :

#include <stdio.h>

int main(){
int age=32;

do{
printf("Quel est votre age ? ");
scanf("%d", &age);
}while(age < 18);

return 0;
}

Dans ce programme, une instruction nouvelle intervient : scanf. Comme pour printf, l'utilisation
de scanf est assez complexe. Nous l'etudierons donc plus tard.
Pour l'instant, gardez juste à l'esprit que cette instruction permet à l'utilisateur d'affecter une valeur
à la variable age dans notre cas.
Dans notre code, l'utilisation de la boucle do...while permet de demender l'age de l'utilisateur
jusqu'a ce que celui ci soit supérieur à 18. On voit également que bien que nous ayons initalisé
la variable age avec une valeur supérieur à 32, les instructions sont bien executées
au moins une fois.

La boucle for

Dans le premier exemple, avec la boucle while, nous incrementions la variable i à
chaque iteration (execution) de la boucle. La boucle for permet de simplifier tout ce code.
En effet, for est une boucle disposant d'un compteur, c'est à dire qu'a chaque iteration de la boucle,
for va incrementer (ou décrementer, c'est selon) la variable, mais aussi tester une condtion. Si cette
condition est vrai, alors les instructions sont executées. Sinon, on sort de la boucle.
Voici la syntaxe de cette boucle :

for([initialisation], [condition], [incrementation]){
instruction1;
instruction2;
instruction3;
}

for([initialisation], [condition], [incrementation])
instruction1;

initialisation, condition et incrementation peuvent tous être optionels.
À la toute première iteration de la boucle, initialisation est executé. Ce peut être une instruction
du genre i=0.
Ensuite, à la fin de chaque iteration, incrementation est executé. On utilise en general des instructions
comme i++ ou i--.
Voici un exemple, permettant d'afficher la table de 7 :

#include <stdio.h>

int main(){
int i=0;

for(i=0; i < 10; i++)
printf("%d x 7 = %d\n", i, i * 7);

return 0;
}

Imbrication

On designe par imbrication le fait d'utiliser une ou plusieurs boucles les unes dans les autres. Cette opération
est tout à fait possible et dans certains cas, très interessante, comme le montre l'exemple suivant :

#include <stdio.h>

int main(){
int i,j;

/* On calcule toute les tables de 0 à 9 */

for(i=0; i < 10; i++){
for(j=0; j < 10; j++){
printf("%d x %d = %d\n", i, j, i * j);
}
}

return 0;
}

break et continue

Dans certains cas, on peut souhaiter que pour une raison X, l'execution d'une boucle soit stoppée avant
sa fin.
On utilise pour cela break, le même que pour sortir d'une structure en switch.
Par exemple, pour quitter la boucle precedente lorsque la variable i vaut 5, on aurait
écrit :

#include <stdio.h>

int main(){
int i=0;

for(i=0; i < 10; i++){
if(i==5)break;/* Si i==5, alors on quitte */
printf("%d x 7 = %d\n", i, i * 7);
}

return 0;
}

continue et similaire à break, à la difference que continue ne quitte pas
la boucle mais termine l'iteration de celle-ci.
Donc, dans notre exemple, remplacer break par continue reviendrai à ne pas executer
les instructions de la boucle lorsque la variable i est égale à 5 :

#include <stdio.h>

int main(){
int i=0;

for(i=0; i < 10; i++){
if(i==5)continue;/* Si i==5, alors on termine l'iteration */
printf("%d x 7 = %d\n", i, i * 7);
}

return 0;
}

1. Variables locales et globales
2. Fonctions ne renvoyant pas de valeurs
3. Variables statiques
4. À propos de la déclaration des prototypes

Depuis maintenant quelques temps, nous sommes capable d’utiliser des fonctions : printf, puts…
Mais avec le C, il est possible au programmeur de créer ses propres fonctions (à ce titre, main en est une).

Voici la syntaxe d’une déclaration de fonction :

type identificateur(type argument){
[instructions]
return [valeur];
}

identificateur est un identificateur valide, qui doit suivre les même régles que pour les variables.
Il s’agit du nom de la fonction qui sera utilisé pour l’appeler.
type (devant indentificateur et argument) represente le type de donnée
renvoyé par la fonction ou le type de l’argument à transmettre (int, double …).
return permet de sortir de la fonction. valeur, qui est situé juste est facultatif.
Si on l’omet, la fonction ne renvera pas de valeur (voir plus bas).

Donc, pour écrire une fonction qui calculera la surface d’un cercle, on poura écrire :

double Cercle(double Rayon){
double Surface = Rayon * Rayon * 3.14159;/* Calcul de la surface*/

return Surface;/* Renvoi de la valeur*/
}

On peut ensuite appeler cette fonction à partir de la fonction principale. Voici le programme au complet :

#include <stdio.h>

double Cercle(double Rayon){
double Surface = Rayon * Rayon * 3.14159;

return Surface;
}

int main(){
int Rayon = 50;
double Aire = Cercle(Rayon);

printf("L'aire d'un cercle de rayon %d est %f", Rayon, Aire);

return 0;
}

Comme ceci, tout va bien : ça fonctionne. Mais pour des raisons qui paraitrons plus claires par la suite, on préfere
souvent écrire les fonctions à la suite de la fonction main.
Mais dans ce cas, si on laisse notre programme dans cet état, une erreur se produira (vous pouvez essayer).
Il nous faudra alors déclarer préalablement le protoype da la fonction Cercle.
Le prototype d’une fonction n’est rien d’autre que la première ligne de cette fonction. Dans notre cas, ce sera :

double Cercle(double Rayon);

Pour l’instant, nous écrirons ce prototype dans la fonction main.
Notre programme devient donc :

#include <stdio.h>

int main(){
double Cercle(double Rayon);/* Déclaration du prototype*/
int Rayon = 50;
double Aire = Cercle(Rayon);

printf("L'aire d'un cercle de rayon %d est %f", Rayon, Aire);

return 0;
}

double Cercle(double Rayon){
double Surface = Rayon * Rayon * 3.14159;

return Surface;
}

Variables locales et globales

Pour l’instant, nous n’avons travaillé qu’avec des variables locales à une fonction. Une variable
locale est une variable qui est uniquement accessible dans le bloc où elle a été déclarée. Par exemple, la
variable Aire de la fonction main de notre exemple précédent n’est pas accessible
par la fonction Cercle.

En fait, cette rêgle peut être étendue non pas aux fonctions, mais aux blocs d’instructions. Un bloc d’instructions,
vous le savez, est délimité par des accolades ({ et }).
Soit le code suivant :

#include <stdio.h>
int main(){
{
int i=5;
}
printf("i vaut %d", i);/* ERREUR! Undefined symbol i */
return 0;
}

Ce code provoque une erreur : la variable i est locale au bloc d’instruction situé au dessus.
Elle n’est donc pas accessible à l’instruction printf qui est placé en dehors du bloc.
Le code suivant est par contre correct :

#include <stdio.h>
int main(){
{
int i=5;
printf("i vaut %d", i);
}
return 0;
}

De même que celui-ci :

#include <stdio.h>
int main(){
int i=5;
{
printf("i vaut %d", i);
}
return 0;
}

On remarque qu’une variable est accessible uniquement dans le bloc où elle est déclarée, mais aussi dans tout
les blocs située dans ce même bloc.

Question : et si dans notre dernier exemple, on avait déclaré une autre variable i dans le bloc
imbriqué, que se serait-il passé ?
Reponse : une variable déclarée dans un bloc imbriqué est toujours prioritaire.
Conséquences :

#include <stdio.h>
int main(){
int i=5;
{
int i=3;
printf("i vaut %d", i);/* Sortie -> 3*/
i++;/* i = 4*/
}
printf("i vaut %d", i);/* Sortie -> 5*/
return 0;
}

Donc, pour déclarer une variable qui sera globale (une variable est dite globale lorsqu’elle est accessible
par tous les blocs, sans exceptions, d’un programme), on la déclarera tout simplement en début de programme :

#include <stdio.h>

int Compteur=0;/* Compteur est une variable globale*/

int main(){
void Incremente(void);/* Déclaration du prototype de Incremente  */
int i;

printf("Avant, Compteur = %d\n", Compteur);
for(i=0; i < 10; i++)
Incremente();
printf("Après, Compteur = %d", Compteur);
return 0;
}

void Incremente(void){
Compteur++;/* incrementation de la variable globale Compteur*/
}

Comme prévu, Compteur est bien accessible par la fonction Incremente.

Fonctions ne renvoyant pas de valeurs

Dans l'exemple précedent, nous avons fait intervenir un nouvel element : void.
void est en fait un type de données à part entière. L'aide en ligne de Turbo C nous dit : Empty
data type (Type de données vide).
Autrement dit, la fonction Incremente utilisée dans l'exemple ci-dessus ne renvera pas de valeur.
Le second void est situé entre les parenthèses de la fonction. Cela veut simplement dire que la
fonction ne prend pas d'arguments.
L'emploi de void est également possible avec les variables, mais cela conserne l'utilisation
des pointeurs que nous étudierons plus tard.

Variables statiques

Par défaut, une variable locale à un bloc perd sa valeur entre les differents appels de celui-ci :

#include <stdio.h>

void MaFonction(void);

int main(){
int i;

for(i=0; i < 10; i++)
MaFonction();

return 0;
}

void MaFonction(void){
int MaVariable=0;

MaVariable++;/* MaVariable = 0 + 1 = 1 */

printf("MaVariable = %d\n", MaVariable);/* Sortie -> toujours 1   */
}

On voit bien que, malgrès tout nos efforts en appelant MaFonction 10 fois, la variable MaVariable
vaut toujours 0 (enfin, 1).
Pour remedier à ce probleme, il suffit de rajouter le mot-clef static devant la déclaration de MaVariable.
La variable ne sera ainsi initialiser qu'une seule fois à 0, et conservera sa valeur entre les appels :

#include <stdio.h>

void MaFonction(void);

int main(){
int i;

for(i=0; i < 10; i++)
MaFonction();

return 0;
}

void MaFonction(void){
static int MaVariable=0;

MaVariable++;/* Incrementation     */

printf("MaVariable = %d\n", MaVariable);/* Sortie -> MaVariable + 1 */
}

À propos de la déclaration des prototypes

La déclaration des prototypes suivent les même rêgles que pour la déclaration des variables.
Completons notre première exemple avec une fonction permettant de calculer le volume d'un cylindre. On écrira :

double Cylindre(double Rayon, double Hauteur){
double Aire = Cercle(Rayon);
double Volume = Aire * Hauteur;

return Volume;
}

Maintenant, insérons cette fonction dans notre programme. Cela donne :

#include <stdio.h>

int main(){
double Cylindre(double Rayon, double Hauteur);/* Déclaration de Cylindre */
int Rayon = 50;
int Hauteur = 100;
double Volume = Cylindre(Rayon, Hauteur);

printf("Le volume d'un cylindre de rayon %d et de hauteur %d est %f",
Rayon, Hauteur, Volume);

return 0;
}

double Cylindre(double Rayon, double Hauteur){
double Aire = Cercle(Rayon);
double Volume = Aire * Hauteur;

return Volume;
}

double Cercle(double Rayon){
double Surface = Rayon * Rayon * 3.14159;

return Surface;
}

Tel quel, ce code provoquera une erreur, car le prototype de la fonction Cercle n'est pas déclaré
lors de son appel dans la fonction Cylindre. On peut alors le déclarer dans la fonction Cylindre :

double Cylindre(double Rayon, double Hauteur){
double Cercle(double Rayon);/* Déclaration de Cercle*/
double Aire = Cercle(Rayon);
double Volume = Aire * Hauteur;

return Volume;
}

Mais ainsi, la fonction Cercle ne sera pas accessible dans la fonction main.
Pour schematiser, on pourai dire que la fonction Cercle est locale à la fonction Cylindre
(c'est un raccourci rapide).
Toujours d'un point de vue schematique, si on veut que la fonction Cercle soit accessbile partout dans
le programme, il suffit de la déclarer en début de celui ci, comme pour les variables globales :

#include <stdio.h>

double Cercle(double Rayon);/* Cercle est accessible partout dans
le programme*/

int main(){
double Cylindre(double Rayon, double Hauteur);
int Rayon = 50;
int Hauteur = 100;
double Volume = Cylindre(Rayon, Hauteur);

printf("Le volume d'un cylindre de rayon %d et de hauteur %d est %f",
Rayon, Hauteur, Volume);

return 0;
}

double Cylindre(double Rayon, double Hauteur){
double Aire = Cercle(Rayon);
double Volume = Aire * Hauteur;

return Volume;
}

double Cercle(double Rayon){
double Surface = Rayon * Rayon * 3.14159;

return Surface;
}

1. La mémoire
2. Syntaxe

Les pointeurs permettent de transmettre d’une manière plus efficace les données que traditionnellement.
Mais d’abord, qu’est-ce qu’un pointeur ?
Un pointeur est tout simplement une variable qui stocke l’adresse d’une autre donnée dans la mémoire de l’ordinateur.
La taille occupée par un pointeur est donc très petite : 2 octets sur les plateformes 16 bits, 3 octets pour
les systèmes 32 bits.
Les opérations sur les pointeurs sont donc très rapide et peu gourmandes en ressources système, ce qui permet
de réaliser des opérations très puissantes, irréalisables autrement, comme l’utilisation des listes chainées.
C’est en raison de ces quelques points que la syntaxe des pointeurs peu apparaitre un peu hermetique et complexe
au premier abord. Mais avec de la pratique, on se rend compte que ce n’est peut-être pas si compliqué que ça …

La mémoire

La mémoire d’un ordinateur est décomposée en 2¹⁶ segments, c’est à dire 65536 segments. Lors
de l’execution, un programme est chargé dans l’un de ces 65536 segments.
Ce n’est pas tout. Chaque « morceau » de segment est reperé par une adresse, ou offset.
Le contenu d’une variable est donc stockée en mémoire et reperé par un segment et un offset.
Pour obtenir l’adresse d’une variable, on utilise l’opérateur & (et commercial, ou esperluette) devant le
nom de la variable.
L’exemple suivant n’a aucun interet : il affiche simplement l’adresse d’une variable.

#include <stdio.h>

int main(){
int variable;

printf("L'adresse la variable est %u", &variable);

return 0;
}

L’adresse transmise en sortie est variable et est susceptible de changer entre deux execution du programme.

Syntaxe

On déclare un pointeur comme on le ferait pour une variable, mais on rajoute l’opérateur * (étoile)
devant son identificateur lors de la déclaration :

type *identificateur[=initialisation];

Le type utilisé doit être celui qui sera pointé par le pointeur (normal !). L’initialisation est facultative,
mais il est recommandé de toujours initialisé un pointeur avant toute utilisation.
En effet, si on ne prend pas cette précaution, le pointeur est suceptible de pointer sur un emplacement arbitraire
de la mémoire de l’ordinateur, ce qui peut avoir des effets terriblement désastreux si on y prend pas garde.

Pour accéder au contenu d’une variable (et non pas à son adresse !), on utilise encore l’opérateur * (étoile)
devant l’identificateur de la variable.
L’utilisation de l’indentificateur sans l’opérateur * permet d’acceder à l’adresse du pointeur,
comme le montre l’exemple suivant :

#include <stdio.h>

int main(){
int *pointeur;

*pointeur=500;/* initialisation du contenu */

printf("L'adresse du pointeur est %u\n", pointeur);
printf("Ca valeur est %i", *pointeur);
return 0;
}

Attention! L’initialisation d’une variable lors de sa déclaration initialise l’adresse et non le
contenu!
Maintenant, voyons une utilisation concréte des pointeurs. Nous allons faire pointer un pointeur vers une
variable :

#include <stdio.h>

int main(){
int variable = 500;
int *pointeur = &variable;/* pointeur pointe sur variable*/

printf("Avant\nvariable : %i\npointeur : %i\n", variable, *pointeur);

variable++;/* On incrémente 'variable'*/
/* variable == 501*/

printf("Après\nvariable : %i\npointeur : %i\n", variable, *pointeur);

return 0;
}

On constate que la valeur renvoyée par variable et par *pointeur est indentique.
C’est tout à fait normal, puisque l’emplacement de la mémoire utilisé est le même pour les deux variables.
Lorsque l’on ne se sert plus d’un pointeur, il suffit de lui affecter comme adresse la valeur NULL :

int *pointeur = NULL;/* pointeur ne pointe sur rien*/

Bien que la tendance actuelle soit à l’utilisation de la programmation orientée objet, avec des langages tel
que Java ou C++, le langage C reste toujours très utilisé.
Contrairement à des langages comme le Basic qui sont plus ou moins interprétés, et donc lents, le C permet de réaliser des programmes compilés et
rapides.
Mais ce n’est pas non plus un langage de bas niveau, comme l’assembleur (bien que certaines personnes qualifient le C de super-assembleur).

Avec le Pascal, le C reste le plus aprécié dans l’enseignement, pour offrir une première approche de la programmation
dite « structurée ». C’est également un passage presque obligé pour celui qui veut un jour programmer en C++ (pour simplifier, du C orienté objet).
De plus, des tas de nouveaux langages tirent le gros de leurs syntaxe (les boucles, les structures conditionnelles…) du C. On peut par exemple
citer PHP ou Java … Si vous connaissez le C, vous vous sentirez alors beaucoup plus à l’aise en abordant ces langages.
C’est également un langage très utilisé sur d’autres plateformes : citons par exemples les calculatrices TI-89 et TI-92 qui dispose d’un formidable
SDK, TIGCC.

Le C est un langage relativement ancien, puisque son invention remonte aux années 70. Il fut créé par Denis Ritchie et Brian Kerminghan afin de créer
un langage permettant la construction d’un système d’exploitation solide pour les machines UNIX, ce qui prouve que le C est un langage très puissant.

Les pages qui vont suivre vont tenter d’offrir une approche du C à l’aide d’un très vieux compilateur, mais gratuit et simple à utiliser. Il s’agit
de Borland Turbo C 2.01, qui est disponible sur le site de Borland, à la page téléchargement.
Nous ne crérons donc pas d’applications Windows. Tout se passera sous ce bon vieux DOS.

Pour un premier programme, nous allons faire simple : nous allons juste afficher la très celebre phrase Hello World
à l’écran.
Lancez Turbo C 2.01 et saisissez le code suivant :

#include <stdio.h>

int main(){
puts("Hello World!");

return 0;
}

Pour tester ce programme, il vous suffit d’utiliser la commande Run du menu … Run, ou bien
en utilisant le raccourci clavier Ctrl + F9.
L’execution du programme étant très rapide, il est fort possible que vous n’ayez rien vu de son déroulement.
Vous pouvez alors accéder à la fenêtre de sortie en utilisant la commande User screen de ce même menu
Run, ou bien en utilisant également le raccourci clavier Alt + F5.
Et là, on s’aperçoit que l’ordinateur a bien écrit Hello World dans le coin supérieur gauche de
l’écran.
À ce stade, quelques explications seront certainement les bienvenues.

Déjà, précisons que le C est, comme le disent les anglais, case sensitive, c’est à dire qu’il est sensible
à la casse (les majuscules et les minuscules). Vous pouvez d’ailleurs vous en rendre compte facilement en remplacant
puts par PUTS. Ça ne manque pas : le linker signale une erreur, Undefined symbol.
Forcement, puisqu’en C, PUTS et puts sont deux choses totalement différentes.

En anglais, main signifie principal. Nous les étudierons plus loin, mais vous devez savoir que main.
est une fonction. Et elle porte bien son nom puisque c’est la fonction principale. Pour simplifier, on pourai dire
que l’ensemble du programme est contenu dans les accolades ({ et }) de main.

Passons maintenant à puts. Vous l’aurez certainement devinez, puts sert à afficher le texte
Hello World à l’écran.
Comme main(), puts() est également une fonction. Vous pouvez avoir une description de
celle-ci en vous plaçant dessus avec le curseur texte et en effectuant la combinaison de touches Ctrl + F1.
L’aide en ligne (en anglais) s’affiche et il est écrit :

puts: outputs a string to stdout
      (and appends a newline character)

int puts(const char *s);

Prototype in stdio.h

On successful completion, puts returns the
last character written. Otherwise a value
of EOF is returned.

Petite traduction pour les non-anglophones : puts: outputs a string to stdout (and appends a newline
character) signifie puts: envoi une chaîne de caractères à la sortie standard (et ajoute un
caractère de nouvelle ligne).
Pour nous, la sortie standard représente l’écran. La chaîne de caractères, c’est Hello World.
Le caractère de nouvelle ligne permet d’aller à la ligne, tout simplement.

Ensuite, il est écrit : Prototype in stdio.h. Autrement dit, Le prototype
est dans stdio.h. Toute fonction à (normalement) son prototype. Nous verrons en détail ce que c’est qu’un
prototype plus tard, au moment d’étudier les fonctions. Pour le moment, vous devez savoir que puts est une fonction
standard d’entrée/sortie, et que les prototypes des fonctions standards d’entrée/sortie sont située dans le fichier stdio.h.
stdio.h est ce que l’on appelle un fichier d’en-tête. On peut comparer un fichier d’en-tête à un index ou à un
annuaire dans lequel le compilateur vient chercher le code correspondant à une fonction.
Les fichiers d’en-tête doivent être inclus grâce à la directive #include, en début de programme (c’est le pourquoi de la 1^er ligne,
de notre programme, #include <stdio.h>).
Le nom du fichier à inclure doit être placé entre guillemets (« ) ou bien entre < et >. Quelle est la différence entre ces deux syntaxes ?
Les fichiers placés entre < et > sont recherchés uniquement dans le répertoire include du compilateur.
Pour les fichiers placés entre guillemets, la recherche s’effectue tout d’abord dans le répertoire courant, en général celui du fichier
source.
Pour les fichiers de la bibliothèque standard, dont stdio fait parti, on place donc le nom du fichier entre <
et >.

Et pour finir, on peut lire On successful completion, puts returns the last character written.
Otherwise a value of EOF is returned qui signifie grosso modo : En cas de réussite, puts
retourne le dernier caractère écrit. Autrement, une valeur de EOF (End Of File -> fin de fichier) est retournée.
Et oui, parce que les fonctions renvoient une valeur (on verra plus loin que pas toujours). Et c’est la raison d’être de la ligne
suivante : return 0. Là encore, nous étudierons plus en détail l’instruction return au moment de découvrir plus
largement les fonctions.
Dans notre cas, return 0 fait renvoyer la valeur 0 à la fonction main. Vu que main est la fonction
principale, la valeur renvoyée sera en fait le code de sortie du programme. Renvoyer la valeur 0 permet de dire que l’execution du programme
c’est bien passée.

Encore une dernière chose et nous en aurons fini avec ce premier programme. Cette chose concerne le point virgule (;).
En C, chaque instruction doit être terminée par ce point virgule. En effet, contrairement à un langage comme le basic qui considére une instruction
par ligne, le C (et avec lui d’autres langages comme Java, Pascal…) considére une instruction par point-virgule. Si vous l’ommetez, une erreur
Statement missing ; se produira.

Comme tout langage, le C permet l’inclusion de commentaires dans le code source.
Un commentaire permet d’inclure du langage de tout les jours dans le programme. Cela permet de moins
se perdre dans le programme lorsque l’on re-travaille dessus quelques mois plus tard, quand on travaille à
plusieurs sur un même projets, ou tout simplement quand le code commence à se compliquer sérieusement.
Bien évidement, les commentaires ne sont pas executés. Il sont tout simplement ignorés par le compilateur.

En C, un commentaire commence par /* et s’acheve par */. Il n’en existe pas d’autre. Tout ce qui
est compris entre /* et */ est alors ignoré :

/*Ceci est mon premier programme en langage C
Et ceci est un commentaire dans lequel je peux écrire
ce que je veux ! */

#include <stdio.h>

int main(){
puts("Hello World!");/* Cette ligne affiche "Hello World" à l'écran */
return 0;
}

Bien entendu, il faut tout de même observer certaines rêgles. Ça peut paraitre évident, mais on ne peut
pas inclure de caractères */ à l’intérieur d’un commentaire. Sinon comment le compilateur pourai-t-il s’en
sortir ?
Le commentaire ci-dessous est donc incorrect :

/* On utilise */ pour terminer un commentaire */

Comme on peut le voir dans l’exemple ci-dessus, un commentaire peut se trouver sur plusieurs lignes. Cette particularité est
très utile lors de la mise au point d’un programme. On peut ainsi forcer le compilateur à ignorer certaines parties du code
sans pour autant avoir à les effacer :

#include <stdio.h>

int main(){
puts("Bonjour");
puts("Joyeux noël");
puts("Bonne année");
/*puts("Joyeuses paques");
puts("et bon anniversaire!");*/
return 0;
}

Dans cette exemple, les lignes Joyeuses paques et et bon anniversaire! ne seront pas
affichées, car pas executées.