Big Tuto : Programmez avec le langage C
De la théorie à la pratique
Chapitre 7 - partie 2 : Initialisation et conditions
Tutoriel présenté par : The Ludovyc et Jérémie F. Bellanger (Jay)
The Ludovyc
Pulication : 9 juin 2014
Dernière révision : 17 avril 2016
Maintenant que nous avons vu les instructions au chapitre 7-1, voyons comment les initialiser et quelles conditions utiliser.
C'est parti ! 
L'initialisation :
C'est un procédé qui permet d'assigner une valeur à une variable.
Par exemple :
|
int i=0; //Ceci est la déclaration et initialisation de la variable i
//Plus exactement : int i est la déclaration
// et i = 0; est l'initialisation
//On peut aussi dissocier les 2 et écrire :
int i;
i=0;
|
Ce code déclare la variable de nom i, de type int et l’initialise à zéro.
Les conditions :
Je vous invite à recopier les programmes de tests suivants, c'est à dire d'éviter autant que possible le copier/coller, car on apprend également en faisant et en recopiant. 
Remplacez les [valeurs] par celles de votre choix sans oublier de correspondre au mieux au type désigné. Vous pourrez aussi remplacer les valeurs des variables initialisées au début du programme (Par exemple, vous pourrez changer "int i = 0" en "int i = 2"). C'est en programmant, en testant, en modifiant, et en faisant bugger des programmes (si, si 
), que vous deviendrez programmeur !
La condition d'égalité :
|
[nom de variable] == [valeur ou nom de variable]
Exemples :
a == 2
b == c
|
La condition est vraie si la valeur de la variable à gauche est égale à la valeur / ou à la valeur de la variable, à droite.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
int i1 = 0; int i2 = 0; if(i1 == [valeur])
{
printf("i1 est egal a [valeur]\n"); }
else if(i1 == i2)
{
printf("i1 est egal a i2\n"); } printf("Fin du programme de test d'egalite.\n"); } |
La condition de non-égalité :
|
[nom de variable] != [valeur ou nom de variable]
Exemples :
a != 2
b != c
|
La condition est vraie si la valeur de la variable à gauche n'est pas égale à la valeur / ou à la valeur de la variable, à droite.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
int i1 = 0; int i2 = 0; if(i1 != [valeur])
{
printf("i1 n'est pas egal a [valeur]\n"); }
else if(i1 != i2)
{
printf("i1 n'est pas egal a i2\n"); } printf("Fin du programme de test de non-egalite.\n"); } |
La condition de stricte infériorité :
|
[nom de variable] < [valeur ou nom de variable]
Exemples :
a < 2
b < c
|
La condition est vraie si la valeur de la variable à gauche est strictement inférieure à la valeur / ou à la valeur de la variable, à droite.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
int i;
for(i = 0; i < [valeur]; i++)
{
printf("Coucou numero : %d !\n", i); }
printf("Fin du programme de test de stricte inferiorite.\n");
} |
La condition de stricte supériorité :
|
[nom de variable] > [valeur ou nom de variable]
Exemples :
a > 2
b > c
|
La condition est vraie si la valeur de la variable à gauche est strictement supérieure à la valeur / ou à la valeur de la variable, à droite.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
int i = 3;
do
{
printf("Fin du programme dans : %d !\n", i);
i--;
}
printf("Fin du programme de test de stricte superiorite.\n");
} |
La condition d'inférieur ou égal :
|
[nom de variable] <= [valeur ou nom de variable]
Exemples :
a <= 2
b <= c
|
C'est une variante de l'infériorité stricte. La condition est vraie si la valeur de la variable à gauche est inférieure ou égale à la valeur / ou à la valeur de la variable, à droite.
La condition de supérieur ou égal :
|
[nom de variable] >= [valeur ou nom de variable]
Exemples :
a >= 2
b >= c
|
Même principe. La condition est vraie si la valeur de la variable à gauche est supérieure ou égale à la valeur / ou à la valeur de la variable, à droite.
L'anti condition :
|
!(condition1)
|
La condition est vraie si la condition1 est fausse et inversement.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
int i = 0; //Modifiez la valeur de i pour tester
if (!(i == 0))
{
printf("i n'est pas egal a zero.\n");
}
else
{
printf("i est egal a zero.\n");
}
printf("Fin du programme de test d'anti-condition.\n");
} |
La multiple condition ET ( && ) :
|
code minimum : condition1&&condition2
code : condition1&&condition2&&condition3&&...
|
La condition est vraie si la condition1 et toutes les autres séparées par les symboles && sont vraies.
A noter pour l'optimisation du code : le programme analyse d'abord la condition1 puis la condition2 et ainsi de suite. Si l'une d'elles est fausse, il stoppe l'analyse pour passer à l'étape suivante. Si elles sont toutes vraies, le programme continue son exécution normalement.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
char c='a';
char c1=97;
//Code sans &&
if(c=='a')
{
if(c==97)
{
if(c==c1)
{
printf("vrai\n"); }
else
{
printf("faux\n"); } }
else
{
printf("faux\n");
} }
else
{
printf("faux\n"); }
//Code avec && (fonctionne pareillement que le code sans && précédent)
if(c=='a'&&c==97&&c==c1)
{
printf("vrai\n"); }
else
{
printf("faux\n"); }
}
|
La multiple condition OU ( || ) :
|
code minimum : condition1||condition2
code : condition1||condition2||condition3||...
|
La condition est vraie si la condition1 est vraie ou si l'une des conditions suivantes, séparées par des || est vraie.
A noter pour l'optimisation du code : le programme analyse d'abord la condition1 puis la condition2 et ainsi de suite. Si l'une d'elles est vraie, il stoppe l'analyse pour continuer son exécution normalement. Si elles sont toutes fausses, alors le programme passe à l'étape suivante.
Voici un petit programme de test :
|
#include <stdio.h>
int main()
{
char c='a';
char c1=97;
//Code sans ||
if(c=='a')
{
printf("vrai\n");
} else if(c==97)
{
printf("vrai\n");
}
else if(c==c1)
{
printf("vrai\n");
}
else
{
printf("faux\n"); }
//Code avec || (fonctionne pareillement que le code sans || précédent)
if(c=='a'||c==97||c==c1)
{
printf("vrai\n"); }
else
{
printf("faux\n"); }
}
|
| (condition1&&condition2)||condition3 |
La condition est vraie si la condition1 et la condition2 sont vraies ou si la condition1 et la condition2 sont fausses et que la condition3 est vraie.
| condition1&&(condition2||condition3) |
La condition est vraie si la condition1 est vraie et si la condition2 ou la condition3 est vraie.
En langage C, faux a pour valeur 0 et vrai n'importe quelle autre valeur, mais nous utiliserons plutôt la valeur 1 pour rappeler le système binaire.
Voici donc un petit programme de test :
|
#include <stdio.h>
int main()
{
//Je vous invite à changer ces valeurs pour vos propres tests
char condition1 = 0; //la condition1 est fausse
char condition2 = 0; //la condition2 est fausse
char condition3 = 1; //la condition3 est vraie
if((condition1&&condition2)||condition3)
{
printf("vrai\n");
}
else
{
printf("faux\n"); } } |
Les boucles infinies :
Cette hantise du programmeur qui se déclenche quand on ne vérifie pas son algorithme fait boucler votre programme interminablement. Votre programme ne s'interrompt donc jamais ce qui est vraiment très problématique. Mais dans certains logiciel qui nécessitent un rafraîchissement constant, comme les jeux vidéos par exemple, vous serez dans l'obligation de les utiliser, et elles auront alors cette forme :
|
while(1)
{
...
}
//ou
do
{
...
}while(1);
//ou encore
for( ; ; )
{
...
}
|
A utiliser avec précaution donc, en vérifiant qu'il y ait toujours une instruction break présente dans le code contenu et qui pourra être exécuté, pour sortir de la boucle (et, par exemple, quitter le jeu vidéo ).
Exemple de Switch :
|
#include <stdio.h>
int main()
{
int i=0;
switch(i)
{
case 0: printf("i est egal a 0.\n"); i++;
break;
case 1: printf("i est egal a 1.\n"); i++; break;
case 2:
printf("i est egal a 2.\n"); break;
default:
printf("Default.\n"); i++; //le break est optionnel car le default est en fin de switch } printf("Resultat = %d.\n", i); } |
Exercice défi :
Transcodez en langage C le pseudo-programme du rectangle vide vu dans la première partie de ce chapitre (Chapitre 7-1, ici). Seule la boucle Do-While n'a pas eu d'exemple lors de ce chapitre mais vous n'aurez aucune difficulté à l'utiliser.
Voila un bon gros chapitre, en deux parties, de fini ! Rendez-vous pour le prochain chapitre, qui devrait lui aussi être conséquent ! En effet, nous y verrons les fonctions et la modularité (ainsi que la correction de l'exercice défi, bien sûr ) ! Ensuite viendra le premier chapitre de Travail Pratique et Personnel (T2P) à réaliser !
@ bientôt !
Jay et the Ludovyc.
