Editions ENI Livres | Vidéos | e-Formations
Langage C - Algorithmique : initiation
Objectifs du chapitre
Les objectifs de ce chapitre sont de présenter la syntaxe du langage, les types de données utilisables, quelques fonctions, les opérateurs, les structures logiques.
À l’issue de ce chapitre, le lecteur sera capable de développer quelques applications structurées.
Tous les programmes en langage C sont écrits, compilés et exécutés en utilisant le logiciel Code::Blocks.
Premier programme
1. Programme complet
Le programme suivant présente les principales caractéristiques du langage C :
/* ========================================================================== */
/* Projet : initInt -- Saisie de deux nombres, affichage de la somme */
/* -------------------------------------------------------------------------- */
/* Auteur : M. Gineste */
/* ========================================================================== */
#include <stdio.h>
int main()
{
int a, b, sum;
printf("Introduisez deux nombres : ");
scanf("%d %d", &a, &b);
sum = a + b;
printf("La somme est %d\n\n", sum);
return 0;
}
Voici le résultat de l’exécution de ce programme :
2. Explications détaillées du programme
a. Les commentaires
En langage C, un commentaire débute par /* et se termine par */.
Le programme commence par cinq lignes de commentaires :
/* ========================================================================== */
/* Projet : initInt -- Saisie de deux nombres, affichage de la somme */
/* -------------------------------------------------------------------------- */
/* Auteur : M. Gineste */
/* ========================================================================== */
Un commentaire peut être écrit sur plusieurs lignes. On peut écrire :
/* ==========================================================================
Projet : initInt -- Saisie de deux nombres, affichage de la somme
--------------------------------------------------------------------------...Les types de base
1. Types entiers
Il existe trois types d’entiers : int, short (short int), long (long int).
Exemples
int i;
short s; /* ou short int s; */
long l ; /* ou long int l; */
i = 10;
s = 10;
l = 10L; /* Constante de type long */
Les trois types diffèrent par leur taille en nombre d’octets, et donc par l’étendue des valeurs qu’on peut y ranger.
Une variable de type int occupe quatre octets. Un short devrait être plus petit, un long plus grand. Mais ces tailles peuvent être différentes d’une machine à l’autre.
Le type char est également un type entier sur un octet. Il est parfait pour stocker le code ASCII d’un caractère, d’où son nom.
Tous ces types peuvent être déclarés non signés : unsigned, ce qui limite leur utilisation à des nombres entiers positifs. Cela change l’étendue des valeurs qu’on peut y stocker.
Exemple
Une variable char peut contenir des valeurs comprises entre -128 et +127.
Une variable unsigned char peut contenir des valeurs comprises entre 0 et +255.
2. Types flottants
Il existe deux types flottants (nombres avec des « virgules ») : float, double.
Exemple
float f;
double d;
f = 10.12F;
d = 10.12;
Les deux types diffèrent...
Exemples de formats numériques pour la fonction printf()
|
Format |
Variable à afficher |
|
%d |
Entier (int, short, char) |
|
%ld |
Entier (long) |
|
%6d |
Entier cadré à droite sur 6 colonnes |
|
%-6d |
Entier cadré à gauche sur 6 colonnes |
|
%f |
Réel (float, double) |
|
%17.3f |
Réel cadré à droite sur 17 colonnes, dont 3 chiffres après la virgule |
|
%-17.3f |
Réel cadré à gauche sur 17 colonnes, dont 3 chiffres après la virgule |
Le programme suivant montre quelques possibilités de la fonction printf() pour la présentation des données numériques :
int main()
{
int a;
float b;
a = 17;
b = 17.0;
printf("%%d : %d\n", a);
printf("%%6d : %6d\n", a);
printf("%%-6d : %-6d\n\n", a);
printf("%%f : %f\n", b);
printf("%%17.3f : %17.3f\n", b);
printf("%%-17.3f : %-17.3f\n\n", b);
return 0;
}
Le résultat de l’exécution est le suivant :
Principaux codes de format de la fonction scanf()
|
Format |
Entrée attendue |
Type du paramètre |
|
%c |
un caractère seul |
char* |
|
%s |
une chaîne de caractères |
char* |
|
%d |
un entier |
int* |
|
%ld |
un entier de type long |
float* |
|
%f |
un réel (nombre avec virgule) |
float* |
|
%lf |
un réel de type double |
double* |
L’étoile à côté du type de paramètre (Exemple : int*), signifie que le paramètre doit être une adresse de variable.
Exemple
double a;
printf("Entrer la valeur de a :");
scanf("%lf", &a);
a est une variable de type double, le format est %lf, &a est l’adresse de a.
Quelques opérateurs
1. Opérateurs arithmétiques
|
Opérateur |
Effet |
|
+ |
Addition |
|
- |
Soustraction |
|
* |
Multiplication |
|
/ |
Division |
|
% |
Modulo |
Les parenthèses ( et ) sont des opérateurs qui permettent de préciser l’ordre d’exécution des opérateurs.
Exemple
L’expression (a + b) % c additionne les variables a et b, puis calcule le reste de la division (modulo) de ce total par c.
2. Opérateurs de comparaison
|
Opérateur |
Effet |
|
> |
L’opérande placé à gauche est supérieur à l’opérande placé à droite. |
|
< |
L’opérande placé à gauche est inférieur à l’opérande placé à droite. |
|
>= |
L’opérande placé à gauche est supérieur ou égal à l’opérande placé à droite. |
|
<= |
L’opérande placé à gauche est inférieur ou égal à l’opérande placé à droite. |
|
== |
L’opérande placé à gauche est égal à l’opérande placé à droite. |
|
!= |
L’opérande placé à gauche est différent de l’opérande placé à droite. |
Exemple
if (a == b)
{
Instructions;
}
Les instructions sont exécutées si a et b contiennent la même valeur. Attention au double signe « égal » !
3. Opérateurs d’affectation
|
Opérateur |
Effet |
|
= |
Recopie de l’opérande placé à droite dans la variable placée à gauche. |
|
+= |
Ajout de l’opérande placé à droite à la variable placée à gauche. |
|
-= |
Soustraction de l’opérande placé à droite de la variable placée à gauche. |
Exemples
a = b ;
Recopie le contenu de b dans a.
a += b ;
Ajoute...
Structures logiques
if
Instruction de test.
Si l’expression est vraie, le programme exécute les instructions 1, sinon les instructions 2.
if(expression)
{
instructions 1
}
else
{
instructions 2
}
switch
Instruction de test à choix multiples.
switch (expression)
{
case constante 1 : instructions 1
case constante 2 : instructions 2
. . . .
case constante n : instructions n
default : instructions
}
while
Boucle répétitive.
Les instructions s’exécutent tant que l’expression est vraie. Le test est effectué en début de boucle.
while(expression)
{
instructions
}
for
Boucle répétitive.
-
expression 1 s’exécute une fois avant le début de la boucle.
-
la boucle s’exécute tant que expression 2 est vraie.
-
expression 3 s’exécute à la fin de chaque boucle.
for (expression 1; expression 2; expression 3)
{
instructions
}
do while
Boucle répétitive.
Les instructions s’exécutent tant que l’expression est vraie. Le test est effectué en fin de boucle.
do
{
instructions
}
while(expression);
break
Branchement à la fin d’un bloc d’instructions d’une structure switch ou d’une boucle (do...while, while, for). Le programme poursuit son exécution par l’instruction qui suit l’accolade fermante du bloc.
L’utilisation du break est indispensable dans la structure switch. Son utilisation dans une boucle traduit en général un mauvais choix de structure. Nous ne l’utilisons que dans le switch.
1. La structure alternative
a. Organigramme
Le schéma ci-dessus est un organigramme.
-
Les rectangles représentent des blocs d’instructions. Un bloc est une succession d’instructions comprises entre { et }.
-
Les losanges représentent les conditions que l’on teste. En C, une expression est fausse quand elle vaut 0, et vraie sinon.
b. Exemple...
Travail pratique : structures logiques
1. Sujet
Exercice 1
Afficher la liste des 10 premiers nombres avec leur racine carrée (*) et le cumul des racines carrées.
Exercice 2
Afficher la liste des premiers nombres avec leur racine carrée (*), le cumul des racines carrées, jusqu’à ce que le cumul soit > 30.
Exercice 3
Saisir des nombres jusqu’à ce que leur somme dépasse 100.
Exercice 4
Saisir un nombre (n).
Si ce nombre est premier, afficher : « n est un nombre premier », sinon, afficher : « n est divisible par div » (div : valeur du premier diviseur trouvé).
Recommencer cette opération cinq fois.
Exercice 5
Saisir un nombre (n).
Si ce nombre est premier, afficher : « n est un nombre premier », sinon, afficher : « n est divisible par div » (div : valeur du premier diviseur trouvé).
Recommencer cette opération jusqu’à ce que trois nombres premiers aient été saisis.
Renseignement utile : la fonction sqrt()
-
Le calcul de la racine carrée s’obtient en appelant la fonction sqrt(), de la bibliothèque de fonctions mathématiques.
-
Elle est décrite dans le fichier math.h, qu’il faut inclure dans notre programme : #include math.h
-
La description de la fonction est : double sqrt(double) : elle reçoit un paramètre de type double et retourne un double.
2. Structures logiques : proposition de correction
a. Exercice 1
L’affichage des dix premiers nombres est une boucle répétitive. On sait qu’il y aura dix lignes affichées. La boucle for est parfaitement adaptée :
#include <stdio.h>
#include <math.h>
int main()
{
int i;
double racine, cumul;
cumul = 0;
printf("\nNombre Racine Cumul\n\n");
for...
