Techniques de Programmation Techniques de Programmation Algorithmique & Langage C Algorithmique & Langage C

Techniques de Programmation Techniques de Programmation

Algorithmique & Langage C Algorithmique & Langage C

Manuel Munier

IUT des Pays de l’Adour - Mont de Marsan Département GTR

2004-2005

Plan du cours

•

Algorithmique & Python

– variables, opérateurs, expressions – séquence d’instructions

– conditionnelle (if) – boucles (while, for) – fonctions

•

Langage C

– types, instructions C, compilation, fonctions, tableaux, pointeurs, listes, arbres, fichiers,

Partie n°2 Partie n°2

Langage C

Langage C

Norme ANSI

Norme ANSI

Quelques liens

• http://www.multimania.com/dancel

• http://www.inf.enst.fr/~charon/CFacile

• http://www.ltam.lu/Tutoriel_Ansi_C

• http://www.esil.univ-mrs.fr/~tourai/main/Enseignement.html

• http://www-ipst.u-strasbg.fr/pat/program/index.htm

• http://www-igm.univ-mlv.fr/~dr/Cours.html

CC

Introduction

•

Historique

– 1971 : D.Ritchie et K.Thompson pour Unix – 1983 : début de normalisation par l’A.N.S.I.

– 1988 : norme "C ANSI" approuvée en 1988

•

Evolution

– C++ : langage C enrichi des concepts objet – Java : langage orienté objets (GTR2)

CC

Introduction

•

Caractéristiques

– Structuré, typé, "portable", puissant, flexible

– À mi-chemin entre un langage de haut niveau et un assembleur

– Langage réduit mais complété par des bibliothèques de fonctions normalisées

– Utilisable sur matériel et système quelconque CC

Généralités

•

Structure d’un programme C (3 niveaux)

CC

variables du fichier fonction₁

…

fonction_n

en-tête de fonction bloc (corps de la fonction)

{

variables du bloc <suite

d’instructions>

}

Fichier Fonction Bloc

Généralités

•

Création d’un programme C

CC

Éditeur de texte

Pré-processeur C

fichier source

fichier source modifié

Compilateur C

fichier

autres fichiers objet, bibliothèques standard

Généralités

•

Premier programme en C

CC

#include <stdio.h> /* fichiers d’en-têtes */

#include <math.h>

main() /* En-tête de la fonction principale */

{ /* Début du corps de la fonction principale */

float x; /* Variable de bloc (de la fonction) */

printf("Entrez le nombre dont vous voulez la racine carree\n");

scanf("%f",&x);

if (x<0.)

printf("Le nombre %f ne possède pas de racine carree\n",x);

else {

float racx; /* Variable locale à ce bloc */

racx = sqrt(x);

Généralités

•

Quelques règles d’écriture

– Notion d’identificateur

– Lettres, chiffres, caractère souligné

• corrects : iut_gtr2 GTR54_14

• incorrects : 6_de_pique 66

– Différence minuscules/majuscules

• GTR, gtr et Gtr sont 3 identificateurs différents

CC

Généralités

•

Mots réservés (toujours en minuscules !)

CC

auto break case char const

continue default do

else enum extern float for goto if int

register return short signed sizeof static struct switch

union

unsigned void

volatile while

Généralités

•

Mise en forme

– Séparateurs entre les mots (espace, return) – Indentation  meilleure lisibilité

•

Commentaires

– Texte explicatif destiné au lecteur

/* ceci est un commentaire */

/* ceci est un commentaire

CC

Généralités

•

Fichiers en-tête

– Ensemble de déclarations et de définitions pour l’utilisation de fonctions prédéfinies

•

Directive d’inclusion

#include nom_fichier

#include <stdio.h>

CC

<assert.h>

<ctype.h>

<errno.h>

<float.h>

<limits.h>

<locale.h>

<math.h>

<setjmp.h>

<signal.h>

<stdarg.h>

<stddef.h>

<stdio.h>

<stdlib.h>

<string.h>

<time.h>

Plan

•

Instructions élémentaires

– types,variables, opérateurs, expressions

– affichage/lecture de données (printf/scanf)

•

Instructions de contrôle

– exécution conditionnelle (if,switch) – boucles (for,while,do…while)

•

Tableaux, chaînes de caractères

•

Fonctions

•

Pointeurs

CC

Types & Variables

•

Notion de type (de données)

– Pourquoi des types ?

– A quoi fait référence un type ?

• Signification de l’information

• Règles de représentation technologique: codage

• Ensemble de définitions et d’opérateurs

– Taille d’un type

• Nombre d’octets nécessaires pour représenter les

CC

Types & Variables

•

Types simples

– Donnée élémentaire: entier, réel, caractère – Type identifié par un seul mot-clé

•

Types dérivés

CC

Type Mot-clé nombre entier int

nombre réel float caractère char

Types & Variables

•

Déclaration de variable

[<id_classe_stockage>] <id_type> <id_variable> ;

– Exemples

• int compteur; /* variable entière */

• float moyenne; /* variable réelle */

• char reponse; /* variable caractère */

• static int i; /* entier i avec

classe de stockage */

CC

Types & Variables

•

Déclaration étendue

• int i,j,k,t;

•

Initialisation à la déclaration

• int i = 1;

• float moy = 0.0;

• char rep = 'O';

CC

Types & Variables

•

Les types entiers

• int

• short /* abréviation de short int */

• long /* abréviation de long int */

•

Les entiers non signés

CC

Type Taille habituelle Borne inférieure Borne supérieure

short 2 octets -32 768 +32 767

2 octets -32 768 +32 767

ou

4 octets -2 147 483 648 +2 147 483 647 long 4 octets -2 147 483 648 +2 147 483 647

int

Types & Variables

•

Notation des constantes entières

– Notation décimale

• 56 +467 -140

• 1896534L /* constante entier long */

• 55228U /* constante entier non signé */

– Notation octale

• 0177

• 027

– Notation hexadécimale

CC

Types & Variables

•

Rapidement…

– Déclarer des variables entières

int a,i,j;

short cpt;

unsigned int stock;

long lim_inf = -2563424L, lim_sup;

– Lire des variables entières

scanf("%d",&a); /* un int */

scanf("%d%d",&i,&j); /* 2 entiers i et j */

scanf("%hd",&cpt); /* un short */

CC

Types & Variables

•

Rapidement…

– Déclarer des variables entières

int a,i,j;

short cpt;

unsigned int stock;

long lim_inf = -2563424L, lim_sup;

– Afficher des variables entières

printf("%d",a); /* un int */

printf("%hd",cpt); /* un short */

CC

Types & Variables

•

Les types flottants

• float /* simple précision (erreur < à 10^-6) */

• double /* double précision (erreur < à 10^-10) */

• long double /* précision étendue */

•

Notations de constantes réelles

– Notation décimale

• 56. -140.125 .14 /* doubles par défaut */

• 326.46F /* simple précision */

• -125365474.L /* flottant long */

– Notation scientifique

CC

Types & Variables

•

Rapidement…

– Déclarer des variables réelles

float note,montant;

double mesure;

long double dist = 2563424L;

...

– Lire et afficher des variables réelles

...

scanf("%f",&note); /* lire un float */

CC

Types & Variables

•

Le type caractère: char

– Codé sur un octet

– Considéré comme un type entier

•

Notations des constantes

– Caractères imprimables:

• 'a' 'B' '+' '$'

– Caractères spéciaux:

• notation particulière telle que '\n' ou '\t'

– Notations octales et héxadécimales:

CC

Types & Variables

•

Rapidement…

– Lire et afficher un caractère: 1^ère méthode

char rep;

...

scanf("%c",&rep); fflush(stdin);

printf("%c",rep); fflush(stdout);

– Lire et afficher un caractère: 2^ème méthode (on considère ici le caractère comme un entier)

int rep;

CC

Types & Variables

•

Les chaînes de caractères

– Plus vraiment un type simple

– Suite de caractères (tableau) terminée par un caractère '\0'

•

Notations

• "Bonjour" "Bonjour\n" "\t\tBonjour\n"

• "B" " " ""

•

Édition de constantes chaînes

CC

Types & Variables

•

Un type spécial: le type indéfini void

– Ex: quand une fonction de renvoie pas résultat

•

Et les valeurs logiques ?

– Pas de type booléen en C – Convention:

• FAUX ⇔ zéro (valeur nulle du type)

CC

Types & Variables

•

Les constantes littérales

– Directive du pré-processeur

#define <nom_symbolique> <constante>

– Notations

• #define PI 3.14159

• #define FAUX 0

• #define VRAI 1

• #define LIMITE 326

– Utilisation

void main()

{ float rayon = 3.54;

CC

Types & Variables

•

Les constantes littérales (suite)

– En fait, la directive #define indique au pré-processeur de remplacer chaque occurrence du nom symbolique par la valeur indiquée

•

Les variables à valeur constante

const float e = 2.7183;

CC

Opérateurs

•

Généralités

– Notion d’opérateur

opérateurs unaires, binaires

– Notion d’expression

combinaison d’opérateurs, de constantes, d’identificateurs et/ou d’expressions

– Comment une expression est-elle évaluée ? – Et les expressions mixtes ?

CC

Opérateurs

•

Les opérateurs arithmétiques

CC

Nombre Type Type

d'opérandes opérande(s) résultat

unaire valeur positive entier entier

réel réel

- unaire valeur opposée idem idem

binaire addition entier entier

réel réel

entier,réel réel

- binaire soustraction idem idem

* binaire multiplication idem idem

Opération +

+ Symbole

Opérateurs

•

Expressions mixtes: règles de conversion

– Conversion d’ajustement de type

int → long → float → double → long double

– Promotion numérique (conversion systématique)

char → int

CC

Opérateurs

•

Les opérateurs relationnels

•

Les opérateurs logiques

CC

Symbole Opération

== égal à

!= différent de

< inférieur strictement à

<= inférieur ou égal à

> supérieur strictement à

>= supérieur ou égal à

Symbole Opération

FAUX  0 VRAI  1

Opérateurs

•

Table de vérité des opérateurs logiques

CC

Opérande 1 Opération Opérande 2 Résultat

0 && 0 0

0 && Non Zéro 0

Non Zéro && 0 0

Non Zéro && Non Zéro 1

0 || 0 0

0 || Non Zéro 1

Non Zéro || 0 1

Non Zéro || Non Zéro 1

! 0 1

! Non Zéro 0

FAUX  0 VRAI  1

Opérateurs

•

Particularités des opérateurs logiques en C

– Dans le cas d’un ET, l’évaluation des opérandes s’arrête dès qu’un des opérandes est évalué à FAUX

• faux ET qqch  faux

– Dans le cas d’un OU, l’évaluation s’arrête dès qu’un opérande est évalué à VRAI

CC

Opérateurs

•

L’opérateur d’affectation simple

– Notion de lvalue (left value) – Syntaxe d’une affectation

<lvalue> = <expression>

– Principe d’évaluation

• on évalue l’expression à droite du signe =

• le résultat (une valeur) est recopié dans la lvalue

– Dans le cas d’expression mixte

CC

Opérateurs

•

Les opérateurs d’affectation élargie

– la notation

<lvalue> <op>= <expression>

– est équivalente à

<lvalue> = <lvalue> <op> (<expression>)

– avec

• <op> ∈ { +, -, *, /, %, >>, <<, &, |, ^ }

CC

+= -= *= /= %= >>= <<= &= |= ^=

Opérateurs

•

Quelques opérateurs spéciaux

– post in(dé)crémentation

• <lvalue> ++ /* post incrémentation */

• <lvalue> -- /* post décrémentation */

– pré in(dé)crémentation

• ++ <lvalue> /* pré incrémentation */

• -- <lvalue> /* pré décrémentation */

– Fonction: ajouter (soustraire) 1 à une lvalue CC

Opérateurs

•

Quelques opérateurs spéciaux

– Exemple de post incrémentation

a=5; b=3; c=0; /* a vaut 5, b vaut 3, c vaut 0 */

a++; /* a vaut 6, b vaut 3, c vaut 0 */

c=b+(a++); /* a vaut 7, b vaut 3, c vaut 9 */

– Exemple de pré incrémentation

a=5; b=3; c=0; /* a vaut 5, b vaut 3, c vaut 0 */

++a; /* a vaut 6, b vaut 3, c vaut 0 */

CC

Opérateurs

•

L’opérateur de conversion de type (cast)

(<type_cible>) <opérande_expression>

– Exemple:

...

int n=7, p=2, q_entier;

float q_reel;

...

q_entier = n/p; /* q_entier vaut 3 */

q_reel = (float)(n/p); /* q_reel vaut 3.0 */

q_reel = (float)n/p; /* q_reel vaut 3.5 */

CC

Opérateurs

•

L’opérateur sizeof

– Renvoie la taille en octets...

• sizeof <objet> /* taille d’une variable */

• sizeof (<id_type>) /* taille d’un type */

– Exemples:

...

double x;

int a;

...

CC

Opérateurs

•

L’opérateur séquentiel

<expression_1>, <expression_2>

– Exemple:

• i++, j+=k; /* est équivalent à i++; j+=k; */

•

L’opérateur conditionnel

<expr_1> ? <expr_2> : <expr_3>

– Exemple:

• max = (a>b) ? a : b; /* max reçoit le plus grand

CC

Opérateurs (priorités)

Catégorie Opérateurs Associativité

référence ( ) [ ] -> . →

unaires + - ++ -- ! * & (cast) sizeof ←

multiplicatifs * / % →

additifs + - →

décalage << >> →

relationnels < <= > >= →

relationnels == != →

manip. bits & →

manip. bits ^ →

manip. bits | →

logique && →

logique || →

priorité décroissante

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = -3 + 4 * 5 - 6;

x = 3 + 4 % 5 - 6;

x = -3 * 4 % 6 + 5;

x *= 3 + 5;

x *= (y = (z = 4));

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

z = x++ - 1;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = 3 + 4 % 5 - 6;

x = -3 * 4 % 6 + 5;

x *= 3 + 5;

x *= (y = (z = 4));

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = -3 * 4 % 6 + 5;

x *= 3 + 5;

x *= (y = (z = 4));

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

z = x++ - 1;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= 3 + 5;

x *= (y = (z = 4));

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4));

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

z = x++ - 1;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = y == z;

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z);

x=0; y=-1; z=0;

x = x && y || z;

z = x++ - 1;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 1 4 4 0

x=0; y=-1; z=0;

x = x && y || z;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 0 4 4 0

x=0; y=-1; z=0; 0 -1 0

x = x && y || z;

z = x++ - 1;

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 0 4 4 0

x=0; y=-1; z=0; 0 -1 0

x = ((x && y) || z); 0 -1 0 0

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 0 4 4 0

x=0; y=-1; z=0; 0 -1 0

x = ((x && y) || z); 0 -1 0 0

z = (x++) - 1; 1 -1 -1 -1

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 0 4 4 0

x=0; y=-1; z=0; 0 -1 0

x = ((x && y) || z); 0 -1 0 0

Opérateurs & Expressions

Instructions x y z expr. gauche

int x,y,z;

x = (((-3) + (4 * 5)) - 6); 11 11

x = ((3 + (4 % 5) - 6); 1 1

x = ((((-3) * 4) % 6) + 5); 5 5

x *= (3 + 5); 40 40

x *= (y = (z = 4)); 160 4 4 160

x = (y == z); 1 4 4 1

x == (y = z); 0 4 4 0

x=0; y=-1; z=0; 0 -1 0

x = ((x && y) || z); 0 -1 0 0

z = (x++) - 1; 1 -1 -1 -1

Plan

•

Instructions élémentaires

– types,variables, opérateurs, expressions

– affichage/lecture de données (printf/scanf)

•

Instructions de contrôle

– exécution conditionnelle (if,switch) – boucles (for,while,do…while)

•

Tableaux, chaînes de caractères

•

Fonctions

•

Pointeurs

CC

Instructions

•

4 "catégories" d’instructions:

– instruction nulle

• syntaxe:

– instruction simple

• syntaxe:

– instruction composée (ou bloc d’instructions)

• syntaxe:

CC

<expression> ;

{ <liste de déclarations>

<liste d’instructions>

}

;

!

ANSI C

Instructions de contrôle

•

Objectif (rappel): modifier la structure séquentielle du programme

– répétition

– prise de décision conditionnelle – déroutement inconditionnel

•

2 catégories

CC

Instructions de contrôle

•

Classification:

CC

instructions instructions structurées de branchement for

while

do … while if [… else]

else if

break continue return boucles

choix

déroutements

switch

Conditionnelle if

•

Instruction if

if (<expression_booleenne>) <instruction>

– Ex (instruction simple ou expression)

float note;

scanf("%f",&note);

if ( (note>=0.0) && (note<=20.0) ) print("Note valide\n");

CC

Conditionnelle if

•

Instruction if

if (<expression_booleenne>) <instruction>

– Ex (instruction composée ou bloc)

...

delta = b*b - (4*a*c);

if (delta > 0.0) { float x1,x2;

x1 = (-b - sqrt(delta)) / (2*a);

x2 = (-b + sqrt(delta)) / (2*a);

CC

Conditionnelle if

/* Programme qui calcule, à partir d’un horaire donné

(hh:mm:ss), l’horaire une seconde après (même format) */

#include <stdio.h>

main()

{ short h,m,s;

printf("Entrer Heures/Minutes/Secondes\n");

scanf("%hd %hd %hd",&h,&m,&s);

s++;

if (s==60) { s=0; m++;

if (m==60) { m=0; h++;

if (h==24) h=0;

CC

Conditionnelle if

•

Instruction if ... else

if (<expression_booleenne>) <instruction_1>

else

<instruction_2>

– Exemple

...

if (moyenne >= 10.0)

printf("Etudiant RECU\n");

else

CC

Conditionnelle if

•

Instruction if ... else

– Règle (imbrication des if): un else se rapporte toujours au dernier if rencontré auquel aucun else n’a encore été attribué

– Exemple

if (a<=b) if (b<=c) printf("Vrai\n");

else printf("Faux\n");

• Ce programme affiche:

CC

Conditionnelle switch

•

Passage du if ... else au switch

CC

/* Programme qui simule une calculatrice arithmétique */

#include <stdio.h>

main()

{ int a,b; /* les 2 opérandes */

char op; /* le symbole de l’opérateur */

printf("Entrer les deux opérandes entières:\n");

scanf("%d %d",&a,&b);

printf("Entrer un opérateur (+,-,* ou /):\n");

scanf("%c",&op);

printf("Le résultat est: ");

if (op=='+') printf("%d\n",a+b);

else if (op=='-') printf("%d\n",a-b);

else if (op=='*') printf("%d\n",a*b);

Conditionnelle switch

•

Instruction switch

– Syntaxe:

switch (<expression_entière>)

{ case <constante_1>: [<suite_inst_1>];

case <constante_2>: [<suite_inst_2>];

...

case <constante_n>: [<suite_inst_n>];

[default: <suite_inst_par_defaut>]

}

CC

Conditionnelle switch

•

Instruction switch

CC

/* Programme qui simule une calculatrice arithmétique */

#include <stdio.h>

main()

{ int a,b; /* les 2 opérandes */

char op; /* le symbole de l’opérateur */

...

switch (op) {

case '+': printf("%d\n",a+b);

case '-': printf("%d\n",a-b);

case '*': printf("%d\n",a*b);

case '/': printf("%d\n",a/b);

Conditionnelle switch

•

Instruction switch

CC

Entrer les deux opérandes entières:

3 4

Entrer un opérateur (+,-,* ou /):

+

Le résultat est: 7 -1

12 0

cas + cas -

cas *

cas / default

Conditionnelle switch

•

Instruction switch + break

CC

/* Programme qui simule une calculatrice arithmétique */

#include <stdio.h>

main()

{ int a,b; /* les 2 opérandes */

char op; /* le symbole de l’opérateur */

...

switch (op) {

case '+': printf("%d\n",a+b); break;

case '-': printf("%d\n",a-b); break;

case '*': printf("%d\n",a*b); break;

case '/': printf("%d\n",a/b); break;

!

notez l’absence de bloc pour les différents cas

Conditionnelle switch

•

Instruction switch + break

– Le break interrompt l’exécution du switch

• en fait, on n’a qu’un seul bloc d’instructions

• les différents case peuvent être vus comme des

« étiquettes »

 pas de délimiteur de bloc pour les cas

– C’est la seule et uniqueseule et unique utilisation du break qui CC

Boucle while

•

Instruction while

while (<expression_booléenne>) <instruction>

CC

/* Nombre de chiffres composant un nombre */

#include <stdio.h>

main()

{ int n,q,nbc;

printf("Entrer un nombre entier:\n"); scanf("%d",&n);

nbc = 1;

q = n/10;

while (q != 0) { q = q/10;

nbc++;

Boucle while

•

Variante: instruction do ... while

do

<instruction>

while (<expression_booléenne>)

CC

/* Contrôle de la validité d’une valeur numérique */

...

do {

printf("Entrer la note de l’étudiant:\n");

scanf("%f",&note);

Boucle while

• while ^• do...while

CC

exécuter l’instruction

évaluer la évaluer la condition condition

...

faux vrai

évaluer la évaluer la condition condition

exécuter l’instruction

...

faux vrai

Boucle for

•

Instruction for

for (<expr_init>;<expr_bool>;<expr_evol>) <instruction>

– <expr_init> : initialisation de la boucle

• exécutée une seule fois avant d’entrer dans la boucle

– <expr_bool> : condition booléenne

• on continue tant que cette condition est évaluée à vrai

– <expr_evol> : modification des itérateurs CC

Boucle for

•

Instruction for

for (<expr_init>;<expr_bool>;<expr_evol>) <instruction>

CC

exécuter <expr_init>

évaluer <expr_bool>

évaluer <expr_bool>

<instruction>

exécuter <expr_evol>

vrai faux

Boucle for

/* Moyenne des notes */

#include <stdio.h>

main() {

int i,n;

float note,somme=0.0;

printf("Entrer le nombre de notes:\n");

scanf("%d",&n);

for (i=1; i<=n; i++) {

printf("Note %d:\n",i);

scanf("%f",&note);

Boucle for

•

Exemple

/* somme des n premiers entiers */

somme = 0;

for (i=1; i<=n; i++) somme = somme+i;

•

Formes particulières

– regroupement

/* dans la partie initialisation */

for (i=1,somme=0; i<=n; i++) {...}

CC

Boucle for

•

Formes particulières

– absence

/* partie initialisation absente */

/* => on suppose i initialisé avant le for */

for (; i<=n; i++) {...}

/* partie évolution absente */

/* (ici, condition et évolution sont regroupées) */

for (i=1,somme=0; i++<=n;) {...}

/* corps vide */

for (i=1,somme=0; i<=n; somme+=i++);

CC

Instructions prohibées prohibées

•

Instruction break

– Permet de sortir immédiatement de la boucle la plus interne

CC

/* exemple de break dans une boucle for */

...

printf("Vous avez 10 essais pour trouver le nombre caché\n");

for (i=1; i<=10; i++) { scanf("%d",&nb);

if (nb == 963) break;

}

if (i>10)

printf("PERDU...\n");

Instructions prohibées prohibées

•

Même programme sans break

CC

/* comment se passer d’un break */

...

printf("Vous avez 10 essais pour trouver le nombre caché\n");

i=1;

do {

scanf("%d",&nb);

i++;

} while ( (i<=10) && (nb!=963) );

if (nb!=963)

Instructions prohibées prohibées

•

Instruction continue

– Interrompt l’exécution du corps de la boucle et passe directement à l’évaluation de la condition

CC

/* on ne veut traiter que les valeurs positives */

...

for (somme=0.0,i=1; i<=n; i++) {

scanf("%d",&nb);

if (nb<=0) continue;

somme += sqrt(nb);

}

Instructions prohibées prohibées

•

Même programme sans continue

CC

/* comment se passer d’un continue */

...

for (somme=0.0,i=1; i<=n; i++) {

scanf("%d",&nb);

if (nb>0) /* condition opposée */

{

/* ce qu’on voulait éviter avec le continue */

somme += sqrt(nb);

} }

Instructions prohibées prohibées

•

Instruction goto

– On n’en parlera même pas;

vous risqueriez de casser la machine en l’utilisant ;-)

CC

goto

Plan

•

Instructions élémentaires

– types,variables, opérateurs, expressions

– affichage/lecture de données (printf/scanf)

•

Instructions de contrôle

– exécution conditionnelle (if,switch) – boucles (for,while,do…while)

•

Tableaux, chaînes de caractères

•

Fonctions

•

Pointeurs

CC

Tableaux

•

Rappel

– Un tableau permet de mémoriser un ensemble de valeurs de même type avec une seule variable

•

Vocabulaire

– taille: nombre maximum d’éléments (de valeurs)

à vous de gérer le nombre réel d’éléments (une variable entière par ex)

– rang d’un élément: sa position dans le tableau CC

Tableaux

•

Syntaxe: déclarateur []

<id_type_elts> <id_tab>[<cste_taille>];

– Ceci déclare une variable tableau

• dont le nom est <id_tab>,

• pouvant contenir <cste_taille> éléments,

• chaque élément étant du type <id_type_elts>

– Allocation statique (octets contigus)

CC

Tableaux

•

Exemples

– Déclarations correctes

/* tableau de 5 entiers (int) */

int tab[5];

/* tableau de 12 entiers courts (short) */

#define NBMOIS 12 short tmois[NBMOIS];

– A ne jamais faire !!!

int n;

float tnotes[n]; /* à cet instant n vaut 0 ! */

CC

Tableaux

•

Accès aux éléments

– Syntaxe: opérateur []

<id_tableau>[<indice>]

– Illustration:

CC

tab 23 ← tab[0]

48 ← tab[1]

57 ← tab[2]

12 ← tab[3]

14 ← tab[4]

← tab[5]

les éléments sont numérotés à partir de 0

débordement d’indice

 sortie du tableau

Tableaux

#include <stdio.h>

main() {

int n; /* nombre d'étudiants au contrôle */

int i; /* compteur de notes (indice du tab.) */

int nbSup; /* nbre de notes sup. à la moyenne */

float somme; /* somme de toutes les notes */

float moy; /* moyenne de toutes les notes */

float tabNotes[72]; /* tableau contenant les notes */

/* Lecture du nombre de notes à saisir */

printf("Entrer le nombre de notes à saisir: ");

scanf("%d",&n);

Tableaux

/* Lecture des notes. Au fur et à mesure que celles-ci sont enregistrées dans le tableau, on en profite

également pour faire la somme de toutes ces notes */

for (somme=0.0,i=0; i<n; i++) {

printf("Entrer le note N°%d: ",i);

scanf("%f",&tabNotes[i]&tabNotes[i]);

somme += tabNotes[i]tabNotes[i];

}

/* Calcul et édition de la moyenne de la promo pour ce contrôle */

moy = somme/n;

printf("La moyenne est de %f\n",moy);

Tableaux

/* Calcul et édition du nombre de notes supérieures à la moyenne du contrôle */

for (nbSup=0,i=0; i<n; i++) if (tabNotes[i]tabNotes[i] >= moy) nbSup++;

printf("Il y a %d notes sup. à cette moyenne\n",nbSup);

} /* fin du programme (main) */

Tableaux

•

Initialisation lors de la déclaration

– Initialisation complète

• int tab[5] = {23, 48, 57, 12, 14};

• short tmois[NBMOIS] = {21,28,31,30,31,30,31,31,30,31,30,31};

– Initialisation partielle

• int tab2[5] = {23, 48, 57}; /* 23, 48, 57, ??, ?? */

• static int tab3[5] = {23, 48, 57}; /* 23, 48, 57, 0, 0 */

– Taille non précisée

CC

Tableaux

•

Tableaux à plusieurs dimensions

– Déclaration d’une matrice

<id_type_elts> <id_tab>[<nb_lignes>][<nb_col>];

• Exemple: int mat[5][3];

– /* délaration d’un tableau de 15 entiers organisés en 5 lignes comportant chacune 3 éléments */

– Accès à un élément

<id_tab>[<indice_ligne>][<indice_colonne>]

CC

Tableaux

•

Tableaux à plusieurs dimensions

– Rangement en mémoire

• tableau « à plat »

• tous les éléments se suivent

– Initialisation d’une matrice

• int mat2[3][4]={ {12,23,-4,36}, /* 1^ère ligne */

{33,-2,21,78}, /* 2^ème ligne */

CC

mat[0][0]

mat[0][1]

mat[0][2]

mat[1][0]

mat[1][1]

mat[1][2]

… mat[4][0]

mat[4][1]

mat[4][2]

Chaînes de caractères

•

Convention de représentation

– « suite d’octets terminée par un \0 »

•

Constantes chaînes

– sizeof("IUT GTR")  8

CC

'I' 'U' 'T' ' ' 'G' 'T' 'R' '\0'

Chaînes de caractères

•

Variables chaînes

– Principe

• pas de type prédéfini

 on utilise un tableau de caractères pour y affecter une suite de caractères qui respecte la convention du \0 (NULL)

– Déclaration (idem tableaux)

• char prenom[31];

• char nom[]; /* interdit */

CC

Chaînes de caractères

•

Initialisation des variables chaînes lors de la déclaration

– Vision éléments

• char prenom1[31]={'C','a','m','i','l','l','e','\0'};

prenom1 peut être manipulée en tant que chaîne; 31 octets sont réservés

• char prenom2[31] = {'C','a','m','i','l','l','e'};

prenom2 ne peut pas être manipulée en tant que chaîne (pas de \0 à la fin)

• char prenom3[] = {'C','a','m','i','l','l','e','\0'};

CC

Chaînes de caractères

•

Initialisation des variables chaînes lors de la déclaration

– Vision globale

• char prenom4[31] = "Camille";

prenom4 peut être manipulée en tant que chaîne; 31 octets sont réservés

initialisation équivalente à celle de prenom1

• char prenom5[] = "Camille";

prenom5 peut être manipulée en tant que chaîne; 8

CC

Chaînes de caractères

•

Utilisation des chaînes

– Au niveau éléments

– Au niveau global

CC

#include <stdio.h>

main()

{ char chaine[]="Lorraine: pays de la mirabelle";

short i,cpt; /* indice, compteur de 'a' */

for (cpt=0,i=0; chaine[i]!='\0'; i++) if (chaine[i]=='a') cpt++;

printf("Le caractère 'a' apparaît %d fois\n",cpt);

}