cazh-CNendeeliwhiiditjakoptrues

     

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 ! cool

   Maintenant, nous allons encore franchir une grande marche dans les 2 prochains chapitres, alors accrochez-vous ! C'est parti ! smiley

   Première chose importante à ajouter : une variable peut en contenir une ou plusieurs, de taille semblable ou plus petite, et d'un type différent, nous appellerons cette règle, la règle des poupées-russes.

   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 wink :

 
#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à ! wink
                          // 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

 

Maintenant, attaquons du lourd : les outils de programmation !

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. wink

 

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 wink). 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]:
   //code contenu
   //souvent une instruction break;

   //... d'autres "case"

  default:
   //code contenu
   //souvent une instruction break;

} //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 cheeky. 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. wink 

    @ bientôt !

            Jay et the Ludovyc. 

 

Connexion

CoalaWeb Traffic

Today207
Yesterday236
This week2308
This month968
Total1645544

4/12/22