Big Tuto : Programmez avec le langage C
De la théorie à la pratique
Chapitre 7 - partie 1 : Les instructions
Tutoriel présenté par : The Ludovyc et Jérémie F. Bellanger (Jay)
The Ludovyc
Date de publication : 8 juin 2014
Dernière mise à jour : 17 avril 2016
Nous voici rendus au chapitre 7. Et nous avons déjà fait beaucoup de chemin : en partant du plus simple programme jusqu'à l'intégration de variables ainsi que leur affichage, leur utilisations et les opérations que l'on peut faire avec ! 
Maintenant, nous allons encore franchir une grande marche dans les 2 prochains chapitres, alors accrochez-vous ! C'est parti ! 
Voici la liste des types entiers rangés dans l'ordre décroissant en fonction de leur taille :
long(8) -> int(4) -> short(2) -> char(1)
Nous pouvons donc faire :
int i;
char c = 1;
i = c;
mais pas :
c = i;
et nous pouvons aussi faire pendant les opérations :
int i;
char c;
char c1;
short s;
i = c + c1 + s;
Note : vous ne pourrez pas dépasser les valeurs maximums de chaque type de variables lors des opérations.
Bien, après cette petite précision, venons-en donc au corrigé de l'exercice défi 
:
|
#include <stdio.h>
#include <stdlib.h>
int main(){
long resultat; //Pour pouvoir additionner les deux nombres
int a;
int b;
printf("Veuillez entrer des nombres compris entre 0 et 2 147 483 647\n");
printf("Entrez le premier nombre : ");
scanf("%d", &a);
printf("Entrez le seconde nombre : ");
scanf("%d", &b);
resultat=a+b;
printf("Le resultat est : %d\n", resultat);
return 0;
}
|
Voici maintenant une simplification des opérations sur les variables, qui nous sera utile lors de l'écriture de programmes :
|
[type] => le type de la variable choisi
[var] => le nom de la variable choisi
<=> symbole mathématique de l’équivalence
Opération avec 1 :
[type] [var];
[var]=[var]+1; <=> [var]++; //incrémentation de 1
[var]=[var]-1; <=> [var]--; //décrémentation de 1
Opération avec x, où x est une variable respectant la règle Poupée-Russe :
[type] [var];
[var]=[var]+x; <=> [var]+=x; //addition
[var]=[var]-x; <=> [var]-=x; //soustraction
[var]=[var]*x; <=> [var]*=x; //multiplication
[var]=[var]/x; <=> [var]/=x; //division
|
Exemples avec le type char :
Opération avec 1 :
char c=0;
c=c+1; <=> c++; //Oui, le nom du langage de programmation c++ vient de là !
// c(0)=c(0)+1; c sera égal à 1
c=c-1; <=> c--; // c(0)=c(0)-1; c sera égal à -1
Opérations avec 2 :
char c=1;
c=c+2; <=> c+=2; //c(1)=c(1)+2; c sera égal à 3
c=c-2; <=> c-=2; //c(1)=c(1)-2; c sera égal à -1
c=c*2; <=> c*=2; //c(1)=c(1)*2; c sera égal à 2
c=c/2; <=> c/=2; //c(1)=c(1)/2; c sera égal à 0
//Car c est le nom d'une variable de type char qui est un entier
Définition : Un pseudo-programme est écrit en pseudo-code sans véritable norme, mais il doit être lisible par tout programmeur et il a pour but de fournir une ébauche à la rédaction d'un programme dans un langage de programmation choisi.
Voici donc un pseudo-programme en français qui a pour but d'afficher un rectangle vide formé avec des "*" dont la longueur et la largeur on été définis par l'utilisateur :
|
Initialisation :
longueur égale 0 //vertical
largeur égale 0 //horizontal
ligne égale 0
colonne égale 0
Début du programme rectangle vide :
saisie longueur par l'utilisateur
saisie largeur par l'utilisateur
pour ligne inférieure à longueur on incrémente ligne de 1 //for
commutateur sur colonne : //switch
si égale à 0 //switch case
//ne rien faire
par défaut //switch default
colonne égale 0
si ligne égale 0 ou a longueur-1 //if
tant que colonne est inférieure à largeur
si colonne est inférieure à largeur-1 //if
afficher "*"
sinon //else
afficher "*\n"
incrémenter colonne de 1
sinon //else
faire //do...
si colonne égale 0 //if
afficher "*"
de plus si colonne égale largeur-1 //else if
afficher "*\n"
sinon //else
afficher " "
incrémenter colonne de 1
tant que colonne est inférieure à largeur //...while
Fin du programme rectangle vide.
|
J'ai mis en bleu ce que vous savez actuellement coder, en noir ce que vous ne savez pas encore et en vert les commentaires et autre indications.
Je décrirai ce que sont l'initialisation, la condition et la réinitialisation après avoir décrit chaque outil séparément. J'y rajouterai aussi quelques exemples avec les différentes conditions existantes.
A savoir : Les outils For, While et Do-While sont des boucles. L'accolade "{" représente l'entrée de la boucle, "}" la sortie de la boucle. Dans le code contenu dans ces accolades, si une instructions est :
- break : la boucle sera stoppée, et le programme sortira de celle-ci, sans lire la suite du code contenu s'il y en a.
- continue : la boucle sera stoppée, et le programme exécutera directement un autre tour de boucle sans lire la suite du code contenu après l'instruction s'il y en a.
Il est d'usage de décaler le code contenu d'une tabulation par rapport à l'en-tête pour une meilleur lisibilité.
L'instruction For (pour) :
|
for (initialisation; condition; réinitialisation)
{
//code contenu } //sortie |
Fonctionnement :
For est une boucle qui exécute une seule fois l'initialisation. Puis, à chaque tour, elle exécute la réinitialisation, vérifie si la condition est vraie, et ensuite exécute le code contenu. Si la condition est fausse, le programme ira à la sortie. Lors de l'initialisation, vous pouvez initialiser plusieurs variables en les séparant avec des virgules (ex: x=0, y=0, z=0,...). Lors de la vérification de la condition, vous pouvez vérifier plusieurs conditions en les séparant par des virgules (ex : condition1, condition2,...). C'est tout comme une multiple condition "et" ou les virgules remplacent les && (la multiple condition "et" est décrite plus loin dans ce chapitre ). Lors de la réinitialisation, vous pouvez aussi réinitialiser plusieurs variables en les séparant par des virgules (ex: x++, y++, z++,...).
L'instruction Switch (commutateur) :
|
switch ([nom de variable])
{
case [valeur possible de la variable]: //... d'autres "case"
default:
} //sortie
|
Fonctionnement :
Le Switch prend en paramètre une variable. A chaque "case", une comparaison d'égalité est faite avec la valeur possible. Si la condition est vraie, alors le code contenu est exécuté. S'il n'y a pas d'instruction break, les "case" suivants sont lus par le programme, cela est souvent source d'erreur, d'ailleurs 
. Le "default" est un "case" unique et optionnel dont la condition d'égalité est toujours vraie.
L'instruction If (si, de plus, sinon) :
|
if (condition 1) //Si
{
//code contenu 1
}
else if (condition 2) //De plus si
{
//code contenu 2
}
else //Sinon
{
//code contenu 3
} //sortie
|
Fonctionnement :
Le if est unique et obligatoire, le "else if" est optionnel, et le "else" est unique mais optionnel.
Si la condition 1 est vraie, le code contenu 1 sera exécuté et le programme ira ensuite à la sortie. Si la condition 1 est fausse et que la condition 2 est vraie, le code contenu 2 sera exécuté et le programme ira ensuite à la sortie. Enfin, si la condition 1 est fausse et que la condition 2 est aussi fausse, le code contenu 3 sera exécuté par défaut et le programme ira ensuite à la sortie.
Vous pouvez rajouter autant de "else if (condition X)" que vous le souhaitez dans l'ordre suivant :
|
if (condition 1)
{
//code
}
else if (condition 2)
{
//code
}
else if (condition 3)
{
//code
}
//etc...
else //Optionnel
{
//code
}
|
L'instruction While (tant que) :
|
while (condition)
{
//code contenu
} //sortie
|
Fonctionnement :
While est une boucle qui vérifie si la condition est vraie puis exécute le code contenu à chaque tour. Si la condition est fausse, le programme ira à la sortie. Cest l'inverse de l'outil do-while qui exécute puis vérifie.
L'instruction Do-while (fait... tant que) :
|
do
{
//code contenu
} while (condition); //sortie
|
Fonctionnement :
Do-While est une boucle qui exécute le code contenu puis vérifie si la condition est vraie à chaque tour. Si la condition est fausse le programme ira à la sortie (après le ";"). C'est l'inverse de l'outil While qui vérifie puis exécute.
Et voilà ce premier chapitre sur les instructions est fini ! Dans le prochain chapitre, nous verrons comment les initialiser et quelles sont les conditions que vous pouvez utiliser.
@ bientôt !
Jay et the Ludovyc.
