Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Développement informatique
  3. Langage C
Extrait - Développement informatique Apprenez à concevoir avant de programmer
Extraits du livre
Développement informatique Apprenez à concevoir avant de programmer
3 avis
Revenir à la page d'achat du livre

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 :

images/01012a.png

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 :

images/01014a.png

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

images/01016a.png

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