Vous êtes sur la page 1sur 41
DEPARTEMENT DE GENIE ELECTRIQUE Fascicule de Travaux Pratiques en Programmation 1ère année Ingénieurs Mécatronique

DEPARTEMENT DE GENIE ELECTRIQUE

Fascicule de Travaux Pratiques en Programmation

1ère année Ingénieurs Mécatronique

ELABORE PAR :

SNOUSSI Jamila

KOUKI Olfa

Préface

Ce fascicule de programmation en langage C s’adresse aux étudiants de

première année Ingénieurs Mécatronique. Le fascicule comporte deux parties une pour

les travaux pratiques et l’autres pour le projet.

La première partie contient cinq TPs répartis comme suit :

TP1 : Eléments de base en langage C

TP2 : Les structures de contrôles conditionnelles et répétitives

TP3 : Les tableaux et les pointeurs

TP4 : Les chaines de caractères

TP5 : Les fonctions en langage C

Les TPs comportent une partie cours qui inclue la syntaxe des instructions en

langage C et des exercices à réaliser. Avant d’assister à la séance de TP, chaque étudiant

doit maitriser la partie cours se rapportant au TP qu’il va effectuer et ce à l’aide du

cours, du TD et du fascicule de TP.

Evaluation des séances de travaux pratiques Programmation C:

1) Au début de Chaque séance, il y a un test d’évaluation de 15 mn. L’étudiant doit répondre aux questions sur des feuilles d’examens et non pas sur l’ordinateur. Généralement, le test porte sur les problèmes traités dans l’énoncé du fascicule des travaux pratiques n°i.

2)

L’évaluation de ce test ( « Test » ) est comptée 50% de la note globale de la séance des Travaux Pratiques n°i ( « Note_TPi » ).

3) Lors de la séance des Travaux Pratiques n°i, les travaux effectués par les étudiants sont évalués par l’enseignant. Une note « Ev_Pl » est attribuée à chaque étudiant et elle sera comptée 50% de la note globale de la séance des Travaux Pratiques n°i ( « Note_TPi »).

« Note_TPi » = 0,5 . « Test » + 0,5 . « Ev_Pl »

1

4)

Chaque absence induit automatiquement à une note globale de la séance des Travaux Pratiques n°i égale à zéro( « Note_TPi=0 »).

5)

La moyenne des notes globales d’évaluation des Travaux pratiques présente 75% de la note module de Travaux Pratiques Programmation C.

Evaluation des projets des travaux pratiques Programmation C:

1)

Chaque binôme aura un seul sujet de projet choisi par l’enseignant des travaux pratiques.

2)

Les étudiants doivent remettre le rapport de projet muni d’un CD-ROM contenant le code source du programme avant la soutenance.

3) La date et le lieu de la soutenance des projets sont communiqués aux étudiants par voie d’affiche par l’enseignant des travaux pratiques. (Normalement pendant les deux dernières semaines du semestre et dans le même laboratoire des travaux pratiques)

4)

La durée totale d’une soutenance varie entre 15 et 25 mn (exposé, questions et délibération). L’exposé dure entre 10 et 15 minutes.

5)

Les appréciations de l’enseignant sont pondérées comme suit :

 

« Note_Projet » = 0,3. « Soutenance » + 0,3. « Rapport » + 0,4. « Programme »

où « Soutenance » représente la note d’évaluation de l’exposé, « Rapport » représente la note d’évaluation du rapport et « Programme » représente la note d’évaluation du programme.

6)

« Note_Projet »

présente

25%

de

la

note

module

de

Travaux

Pratiques

Programmation1.

« Note_Module_TP » = 0,25. « Note_Projet » + 0,75. ∑ i (« Note_TPi » /5) .

2

PARTIE I : TRAVAUX PRATIQUES

3

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

1.1 Création d’un programme en C

Les étapes de la création d’un programme en C sont l’édition, la compilation et l’édition de liens :

L’édition consiste en la création d’un programme source grâce à l’éditeur quelconque (Word sous Windows vi sous Unix), le fichier créé aura l’extension «*.CPP » ;

La compilation est la traduction du programme source en langage machine. Le résultat de cette étape porte le nom du module objet «*.OBJ » ;

L’édition de liens a pour but de compléter le programme objet par les différents modules correspondants aux fonctions prédéfinies (fonction standards) utilisées par le programme. Le résultat est un programme exécutable ne langage machine qui pourra être exécuté ultérieurement sans appel aux composants de l’environnement de programmation C «*.EXE ».

Un programme simple se compose de plusieurs parties :

Les directives de précompilation ;

Une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(), celle-ci constitue le programme principal et comporte 2 parties :

- la déclaration de toutes les variables et fonctions utilisées

- des instructions

Les commentaires débutent par /* et finissent par */, ils peuvent s’étendre sur plusieurs lignes.

1.1.1 Les directives de précompilation

Elles commencent toutes par un #.

Commande

signification

#include <stdio.h> #include <math.h>

permet d’utiliser les fonctions printf() et scanf(). permet d’utiliser les fonctions mathématiques.

#define PI 3.14159 #undef PI

définit la constante PI. à partir de cet endroit, la constante PI n’est plus définie.

#ifdef PI

si la constante PI est définie, on compile les instructions 1, sinon, on compile les instructions 2.

instructions 1

#else

 

instructions 2

#endif

Parmi ces directives, une seule est obligatoire pour le bon fonctionnement d’un programme :

#include<stdio.h>. En effet, sans elle, on ne peut pas utiliser les fonctions utiles pour l’affichage à l’écran : printf() et la lecture des données au clavier : scanf(). Nous verrons le fonctionnement de ces fonctions plus tard.

1.1.2 La fonction main()

Elle commence par une accolade ouvrante { et se termine par une accolade fermante }. À l’intérieur, chaque instruction se termine par un point-virgule. Toute variable doit être déclarée.

void main()

{

/* debut main*/

int i ; instruction_1 ;

/* declaration des variables */

4

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

Exemple :

instruction_2 ;

} /*fin main*/

#include <stdio.h>/* bibliothèque d'entrées-sorties standard */ /* Mon 1er programme en C */ void main() {*/debut main*/ clrscr(); /*permet d’effacer l’écran*/ printf("Hello world \n") ; }/*fin main*/

1.2

Les constantes et les variables en C

1.2.1

Les constantes

Le langage C autorise 2 méthodes pour définir des constantes.

1ère méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.

const type Nom_Const = valeur_cte;

Exemple:

void main()

{

const float PI = 3.14159; float perimetre,rayon = 8.7; perimetre = 2*rayon*PI;

}

Dans ce cas, le compilateur réserve de la place en mémoire (ici 4 octets), pour la variable PI, mais dont on ne peut changer la valeur.

2ème méthode: définition d'un symbole à l'aide de la directive de compilation #define.

#define Nom_Const valeur_cte

Exemple :

#define PI 3.14159 void main() {float perimetre,rayon = 8.7; perimetre = 2*rayon*PI;

}

1.2.2 Les variables

Le C fait la différence entres les MAJUSCULES et les minuscules. Donc pour éviter les confusions, on écrit les noms des variables en minuscule et on réserve les majuscules pour les constantes symboliques.

Pour déclarer une variable, on fait précéder son nom par son type :

type nom_var

5

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

Notons que :

Les noms doivent commencer par une lettre et ne contenir aucun blanc. Le seul caractère spécial admis est le soulignement (_).

dont on ne doit pas se servir pour

Il existe un certain nombre de noms réservés (while, if, case,

),

nommer les variables.

On ne doit pas utiliser les noms des fonctions pour des variables.

Il existe 6 types de variables :

Type

Signification

val. min

val. max

char

caractère codé sur 1 octet

-2 7

2

7 -1

short

entier codé sur 2 octets

-2 7

2

7 -1

int

entier codé sur 4 octets

-2 31

2

31 -1

long

entier codé sur 8 octets

-2 63

2

63 -1

float

réel codé sur 4 octets

~ -10 38

~

10 38

double

réel codé sur 8 octets

~ -10 308

~

10 308

On peut faire précéder chaque type par le préfixe unsigned, ce qui force les variables à prendre des valeurs uniquement positives. La déclaration et l’affectation d’une variable peuvent se faire au même temps.

Exemples :

int a ; int z=4 ; unsigned int x ; float zx, zy ; float zx=15.15 ; double z ; char zz ; char zz=’a’ ;

/* a est entier */ /* z est entier et vaut 4 */ /* x est un entier positif (non signé) */ /* zx et zy sont de type réel */ /* zx est de type réel et vaut 15.15 */ /* z est un réel en double précision */ /* zz est une variable caractère */ /* zz vaut ’a’* /

Remarques :

Il n’existe pas de type complexe en langage C.

Il n'existe pas de type booléen en Langage C. Lors de l'utilisation de booléen (tests logiques faudra se souvenir des conventions suivantes :

- un booléen est un entier,

- la valeur FAUX est un entier égal à zéro,

), il

- la valeur VRAI est un entier égal à 1 dans le cas du résultat d'une évaluation, différent de zéro quand on cherche à évaluer. Exemple: (3 > 4) a pour valeur 0 (FAUX) , (3 < 4) a pour valeur 1 (VRAI), et 3 est VRAI.

Il existe en C une fonction qui permet de renvoyer la taille en octets occupée par un type. C’est la fonction sizeof et elle a comme syntaxe :

sizeof(expression)

Exemples :

int a[10] ; char b[5][10] ;

6

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

printf("taille de a : %d\n",sizeof (a)) ; printf("taille de b : %d\n",sizeof (b)) ; printf("taille de 4.25 : %d\n",sizeof (4.25)) ;

printf("taille de Bonjour ! : %d\n",sizeof "Bonjour !");/* taille de Bonjour ! : 9*/

printf("taille d’un float : %d\n",sizeof(float)) ; printf("taille d’un double : %d\n",sizeof(double));

/* taille de a : 40*/ /* taille de b : 40*/ /* taille de 4.25 : 8

/* taille d’un float : 4*/ /* taille d’un double : 8*/

Remarque :

La taille d'une variable ne dépend pas uniquement de son type mais aussi de la taille du mot machine.

Exemple:

Taille du mot machine

16 bits

36 bits

sizeof (char)

1

octet

1octet

sizeof(int)

2

octets

4

octets

sizeof(short)

2

octets

2

octets

sizeof(long)

4

octets

4

octets

sizeof(unsigned)

2

octets

4

octets

sizeof(float)

4

octets

4

octets

sizeof(double)

8

octets

8

octets

On remarque ici que la taille du type short est la même quelque soit la taille du mot machine. En effet ce dernier sert à limiter la taille d'une variable à 2 octets uniquement et ce quelque soit la machine à utiliser

1.3 Les opérateurs :

Le premier opérateur à connaître est l’affectation "=". Exemple : {a=b+c ;}

Il sert à mettre dans la variable de gauche la valeur de ce qui est à droite. Le membre de droite est d’abord évalué, et ensuite, on affecte cette valeur à la variable de gauche.

Pour les opérations dites naturelles, on utilise les opérateurs +, -, *, /, %.

/ est l’opérateur quotient de la division et % est l’opération modulo : 5%2 est le reste de la division de 5 par 2. 5%2 est donc égal à 1.

D’autres opérateurs sont définis dans l’exemple qui suit :

Exemple :

i+=5 ; /* i=i+5 */ i-=3 ; /* i=i-3 */ i*=4 ; /* i=i*4 */ i/=2 ; /* i=i/2 */ i%=3 ; /* i=i%3 */

1.3.1 Conversion des types

Il est important de comprendre que lors de l’évaluation d’une opération arithmétique, l’opération sera effectuée dans le plus grand des deux types mis en jeu. Les types sont classés ainsi :

char < int < float < double

Exemple:

int i=2;

f loat f=4.3;

f=f*i ;

/*la multiplication f*i est effectuée en float*/

7

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

Remarques :

L’opérateur de division peut agir comme division entière ou division sur les nombres à virgule flottante.

int i = 2, j = 3; printf("%f \n",i/j);/* affiche la valeur 0 car puisque 2 et 3 sont des constantes de types entiers, la division est une division entière */

Dans ce cas on peut utiliser l’opérateur de conversion de type. L’opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d'un objet. On écrit

(type) objet

On écrira donc :

int i = 2, j = 3; printf("%f \n",(float)i/j); /* pour afficher 0.6666… */

l’opération ’a’+1 a un sens, elle a pour résultat le caractère suivant à ‘a’ dans le code ASCII.

1.3.2 Incrémentation et décrémentation

En C, il existe un certain nombre d’opérateurs spécifiques, qu’il faut utiliser prudemment sous peine d’erreurs.

++ incrémente la variable d’une unité. - - décrémente la variable d’une unité.

Ces 2 opérateurs ne s’utilisent pas avec des réels.

Exemples :

i++ ; /* effectue i=i+1 */

i-- ;

/* effectue i=i-1 */

Leur utilisation devient délicate quand on les utilise avec d’autres opérateurs.

Exemples:

int

i=1 , j ;

j=i++ ; /* effectue d’abord j=i et ensuite i=i+1 */ /* on a alors j=1 et i=2 */ j=++i ; /* effectue d’abord i=i+1 et ensuite j=i */

/* on a alors j=2 et i=2 */

Quand l’opérateur ++ (ou --) est placé avant une variable, l’incrémentation est effectuée en premier. L’incrémentation (la décrémentation) est faite en dernier quand ++ (ou--) est placé après la variable.

1.3.3 Les opérateurs de comparaison

Les opérateurs qui servent à comparer 2 variables sont :

==

égal à différent de inférieur inférieur ou égal

> supérieur >= supérieur ou égal && ’et’ logique || ’ou’ logique

!=

<

<=

ATTENTION ! Ne pas confondre l’opérateur d’affectation’ = ’ et l’opérateur de comparaison ‘ == ’.

8

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

1.4 Les entrées-sorties conversationnelles 1.4.1 La fonction printf()

Elle sert à afficher à l’écran la chaîne de caractère donnée en argument, c’est-à-dire entre parenthèses.

printf("Bonjour") ; /*affichera Bonjour à l’écran*/

Certains caractères ont un comportement spécial :

Caractère

Désignation

Valeur (code ASCII)

Nom ASCII

'\n'

interligne

0x0a

LF

'\t'

tabulation horizontale

0x09

HT

'\v'

tabulation verticale

0x0b

VT

'\r'

retour charriot

0x0d

CR

'\f'

saut de page

0x0c

FF

'\\'

backslash

0x5c

\

'\''

cote

0x2c

'

'\"'

guillemets

0x22

''

Mais printf() permet surtout d’afficher à l’écran la valeur d’une variable, dans ce cas la fonction printf exige l'utilisation de formats de sortie, avec la structure suivante:

printf("%format",nom_de_variable);

Le caractère % indique le format d’écriture à l’écran.

Exemple :

void main(){ int n=3, m=4 ; printf("%d",n) ; /* affiche la valeur de n au format d (decimal) */ printf("n=%d",n) ; /* affiche n=3 */ printf("n=%d, m=%d",n,m) ; /* affiche n=3, m=4 */ printf("n=%5d",n) ; /* affiche la valeur de n sur 5 caracteres : n=

printf("Bonjour\n") ; /*affichera Bonjour à l’écran et retourne à la ligne*/

3*/

}

Remarque : le compilateur n’empêche pas d’écrire un char sous le format d’un réel affichage de valeurs délirantes. Et si on écrit un char avec un format décimal, on affiche la valeur du code ASCII du caractère. Voici le tableau des formats utilisables :

%d

integer

entier (décimal)

%x

integer

entier (hexadécimal)

%u

unsigned

entier non signé (positif)

%hd

short

entier court

%d

long

entier long

%f

float

réel, notation avec le point décimal (ex. 123.15)

%e

float

réel, notation exponentielle (ex. 0.12315E+03)

%lf

double

réel en double précision, notation avec le point décimal

%le

double

réel en double précision, notation exponentielle

%c

char

Caractère

%s

char

chaîne de caractères

9

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

1.4.2 La fonction scanf()

Dans un programme, on peut vouloir qu’une variable n’ait pas la même valeur à chaque exécution. La fonction scanf() est faite pour cela. Elle permet de lire la valeur que l’utilisateur rentre au clavier et de la stocker dans la variable donnée en argument. Elle s’utilise ainsi :

En général :

void main(){ int a ;

scanf("%d",&a) ;

}

scanf("%format",liste_d’adresses);

Exemple:

void main(){ char alpha; int i; float r; scanf("%c",&alpha); scanf("%d",&i); scanf("%x",&i); scanf("%f",&r);

}

/* saisie d'un caractère */ /* saisie d'un nombre entier en décimal */ /* saisie d'un nombre entier en hexadécimal*/ /* saisie d'un nombre réel */

1.4.3 Autres fonctions d’entrée- sortie en C

la fonction putchar() : cette fonction existe dans la bibliothèque STDIO.H . putchar(c) ; permet d’écrire sur le fichier standard de sortie (l’écran) le caractère c avec c est de type char. Elle joue le même rôle que printf(″%c″,c).

la fonction getchar():cette fonction existe dans la bibliothèque STDIO.H . c=getchar(), permet de lire à partir de fichier standard d’entrée (le clavier) le caractère c. Elle joue le même rôle que scantf(″%c″,&c).

la fonction getch() : cette fonction existe dans la bibliothèque CONIO.H. Elle attend le prochain appui sur le clavier, et rend le caractère qui a été saisi. L'appui sur une touche se fait sans écho, c'est à dire que rien n'est affiché à l'écran. En cas de redirection du clavier, on prend le prochain caractère dans le fichier d'entrée.

10

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

TRAVAIL DEMANDE

Exercice1 :

Partie I

1) Lancer le BORLAND C et présenter le menue général. Voir avec détaille les items de File, Compile et Run.

2)

Partie II

En utilisant la fonction printf écrire un programme en C qui :

Afficher et fermer quelques fenêtres sous cet environnement (fenêtre du HELP).

- Efface l’écran avec la commande clrscr() ;

- Ecrire « SALUT » sur une première ligne ;

- Ecrire « je commence a apprendre le langage C » ;

- Attend l’appui d’une touche.

Exécuter ce programme sur machine.

ETAPES A SUIVRE :

1)

Lancer le BORLAND C

2)

S’il y a des fenêtres ouvrantes, fermer ces fenêtres

3)

Créer un nouveau fichier

4)

Taper le code du programme

5)

Enregistrer le programme sous votre répertoire de travail

6)

Compiler le programme

7)

Interpréter les messages d’erreurs et corriger le programme

8)

Voir le résultat de l’exécution dans la fenêtre de sortie

9)

Enregistrer de nouveau le programme (pour ne pas perdre les corrections apportées)

10) Quitter le BORLAND C 11) Lancer le BORLAND C de nouveau 12) Ouvrer le précédent programme 13) Modifier le programme en ajoutant des lignes sur les quelles vous afficher votre prénom, votre nom et votre groupe. 14) Faire toutes les opérations pour exécuter le programme.

Exercice 2 :

Commenter et tester le programme suivant :

#include <stdio.h> #define PI 3.1415 void main() {clrscr() ; double rayon; double perimetre; printf("Rayon = "); scanf("%f", &rayon); perimetre = 2 * PI * rayon; printf("Le périmètre est : %4.2f\n", perimetre);}

Que donne ce programme pour un rayon égal à 5 ?

11

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP1 : ELEMENTS DE BASE EN LANGAGE

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP1 : ELEMENTS DE BASE EN LANGAGE C

TP1 : ELEMENTS DE BASE EN LANGAGE C

Exercice 3 :

1)

2)

Écrire un programme qui affiche le carré et le cube d’un nombre réel saisi au clavier. Ecrire un programme qui affiche la somme s, la différence d, le produit p, le quotient q et le reste de la division r de deux entiers a et b saisis au clavier.

d , le produit p , le quotient q et le reste de la division r

Exercice 4 :

1)

Tester et compiler le programme suivant

#include <stdio.h>

#include <conio.h> void main()

{

int a, b, calcul ;

char u, v; puts("BONJOUR");

a = 5 ; b = 50 ;

u = 65 ;v = ‘A’ ;

calcul = (a + b)/2 ; printf(″la somme S=:%d″,a+b) ; printf(″ Voici le resultat : %d\n ″, calcul) ; printf(1 er affichage de u : %d\n ″,u) ;

printf(″ 2 ème affichage de u : %c\n ″,u) ; printf(″1 er affichage de v: %c\n ″,v) ; puts("Pour continuer frapper une touche getch();

}

");

Que donne ce programme comme résultat ? Conclure.

2)

Modifier ce programme afin d’obtenir le bon résultat.

3)

Afficher S en hexadécimal.

4)

Ajouter quelques instructions à ce programme afin de :

a) afficher le code ASCII de la lettre A

b) afficher le code ASCII des lettres B et C en utilisant la variable v

c) afficher les lettres B et C

d) afficher les lettres b et c.

12

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

Ce sont des instructions qui permettent de notamment faire des tests et des boucles dans un programme. Leur rôle est donc essentiel.

2.1 Les instructions conditionnelles 2.1.1 Les tests if (si…alors)

L’opérateur de test s’utilise comme suit :

if (expression)

{instruction ;}

/* Si expression est vraie alors instruction est exécutée */

La structure if…else (si…alors…sinon…alors) :

if (expression) {instruction 1 ;} /*une seule instruction ou un bloc d’instructions*/ else {instruction 2 ;} /*une seule instruction ou un bloc d’instructions*/

/* Si expression est vraie alors l’instruction 1 est exécutée */ /* Sinon, c’est l’instruction 2 qui est exécutée */

Exemple :

int x=4,y=12;

i f (x>y)

{printf ( "x est supérieur à y\n" ) ; x=x+y ;}

else

printf ( "x est inférieur à y\n" ) ;

i) Conditions imbriquées :

Exemple :

if (expression 1) instruction 1 ;

else if (expression 2) instruction 2 ;

else if (expression 3) instruction 3 ;

else instruction 4 ;

float note ;

i f (note>=10) printf ( "success\n" ) ; else if (note>=9) printf (″rachat″\n); else if (note>=8) printf(″controle\n″); else printf(″echec″);

/* 9<=note<10 */

/* 8<=note<9 */

/* note<8 */

13

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

/* chaque else se rapporte au if le plus proche sauf si on utilise des accolades comme dans le cas suivant */

ii) Regroupement d'instructions :

if (expression1) /* premier if */

else

Exemple :

{

if (expression2)

instruction1;

else if (expression3)

instruction2;

}

/* sinon se rapportant au premier if */

instruction3;

if (A !=B) {if (A>B) printf(″A est supérieur à B″); else if (A<B) printf(″A est inférieur à B″);}

else

printf(″A est égal à B″) ;

Remarques :

Les instructions à exécuter peuvent être des instructions simples {a=b ;} ou un bloc d’instructions

{a=b ; c=d ;

}.

Si on a une seule instruction, on peut ne pas mettre les accolades.

Test de NON logique : if (!(expression1))

/* si l'expression1 est fausse */

Si on a plus qu’une expression à tester :

test de ET logique: if ((expression1) && (expression2)) /* si l'expression1 ET l'expression2 sont vraies*/

test de OU logique : if ((expression1) || (expression2)) /* si l'expression1OU l'expression2 est vraie */

4.1.2 L’instruction switch(selon que…faire)

Cette instruction s’utilise quand un entier ou un caractère prend un nombre fini de valeurs et que chaque valeur implique une instruction différente.

switch (i)

{

case val1 : instruction 1 ;

break ; case val2 : instruction 2 ; break ;

.

.

.

case valN : instruction N ; break ; default : instruction N+1 ; break ;

/*i est un entier ou un caractère*/

/* si i=val1 on exécute l’instruction 1 */ /* sortie du switch */ /* si i=val2 on exécute l’instruction 2 */

/* si i=valN on exécute l’instruction N */

/* pour les autres valeurs de i on exécute l’instruction N+1*/

14

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

}

Exemple :

switch (n )

{

case 0 : printf("nul\n");

break; case 1 :printf(“un\n”);

break; case 2 :printf(“deux\n”); /*si on tape 2 le programme affiche ″deux″*/ break;

case 3 : printf("trois\n"); /*si on tape 3 le programme affiche ″trois″*/ break; default : printf("erreur\n");/*si on tape un entier différent de 0,1,2 ou 3 le programme affiche ″erreur″*/

}

/*si on tape 0 le programme affiche ″nul″*/

/*si on tape 1 le programme affiche ″un″*/

Le bloc "default" n'est pas obligatoire.

Remarque :

On peut ne pas mettre les break ; dans les blocs d’instructions. Mais alors on ne sort pas du switch, et on exécute toutes les instructions des case suivants, jusqu’à rencontrer un break ;.

Si on reprend l’exemple précédent en enlevant tous les break, alors :

si i=val1 on exécute les instructions 1, 2, 3, …, N+1.

si i=val2 on exécute les instructions 2, 3,…, N+1.

si i=valN on exécute les instructions N et N+1.

pour toutes les autres valeurs de i, on n’exécute que l’instruction N+1.

2.2 Les structures répétitives 2.2.1 La boucle for (pour…faire)

Elle permet d’exécuter des instructions plusieurs fois sans avoir à écrire toutes les itérations. Dans ce genre de boucle, on doit savoir le nombre d’itérations avant d’être dans la boucle. Elle s’utilise ainsi :

for (initialisation ; condition d'arrêt ; incrémentation)

Exemple :

{

instructions

;

}

#include <stdio.h> void main(){ int i; for (i=1; i<10; i++) printf("%d ",i); }

/*i est le compteur*/ /* ce programme affiche 1 2 3 4 5 6 7 8 9 */

Remarque : on ne peut pas enlever les points virgules qui séparent les instructions se trouvant entre les parenthèses même si on enlève une, deux ou toutes les instructions.

15

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

2.2.2 La boucle while (tant que…faire)

Contrairement à la boucle for, on n’est pas obligés ici de connaître le nombre d’itérations. Il n’y a pas de compteur.

while (expression)

{

instructions

;

/*les instructions ne s’exécutent que si expression est vrai*/

}

L’expression est évaluée à chaque itération. Tant qu’elle est vraie, les instructions sont exécutées. Si dès le début elle est fausse, les instructions ne sont jamais exécutées.

Exemple :

#include <stdio.h> void main()

{

float x,R ;

x=1.0 ;

R=1000 ;

while (x < R ) /*tant que x est inférieur à R */

{

x = x+0.1*x ; printf("x=%f",x) ;

} /*tant que x est inférieur à R on calcule la nouvelle valeur de x et on l’affiche à l’écran* /

} /*si la valeur de x devient supérieur ou égale à R on n’entre pas la boucle while*/

Remarque : Si rien ne vient modifier l’expression dans les instructions, on a alors fait une boucle infinie : while (1) { instructions } en est un exemple.

2.2.3 La boucle do

while (répéter…tant que)

À la différence d’une boucle while, les instructions sont exécutées au moins une fois : l’expression est évaluée en fin d’itération.

Exemple :

do

{

instructions

; } while (expression);

/*les instructions sont exécutées au moins une fois*/

#include <stdio.h> void main(){ int a; do

{

printf("\n Entrez un entier entre 1 et 10 : ");

scanf("%d",&a); /* la saisie se fait au moins une fois*/

}

while ((a <= 0) || (a > 10));} /*on répète la saisie si la condition (a <= 0) OU (a > 10) est vraie*/

Les risques de faire une boucle infinie sont les mêmes que pour une boucle while.

16

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TRAVAIL DEMANDE

LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Exerxice1 :

1)

Ecrire un programme en C qui permet de saisir deux entiers a et b et d’afficher leur maximum

2)

max. Ecrire un programme en C qui permet de saisir trois entiers et d’afficher l’entier le plus grand et celui le plus petit.

Exercice 2 :

Ecrire un programme qui permet de résoudre ax 2 +bx+c=0.

Exercice 3 :

1)

lettres. 2) Modifier ce programme afin d’afficher en toute lettre tous les entiers inférieur à ce nombre et supérieur à 0.

Ecrire un programme en C qui permet de saisir un nombre et d’afficher ce nombre en toutes

Exercice 4 :

Ecrire un programme en C qui permet de saisir une date sous le format jour mois année et qui permet de déterminer le nombre de jour à partir du 1 er jour de l’année.

LES INSTRUCTIONS DE CONTROLE REPETITIVES

Exercice 5 :

Ecrire un programme qui calcule la moyenne de N notes saisies au clavier. N est donné par l’utilisateur et différent de 0.

Indication : le calcul de la moyenne s'effectue en initialisant une variable initialisée à 0, puis en y ajoutant progressivement les notes saisies puis division par N.

Exercice 6 :

Ecrire un programme en C qui affiche toutes les puissances de 2, jusqu'à une valeur maximale donnée par l'utilisateur. On calculera la puissance par multiplications successives par 2.

LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

Exercice 7 :

1)

Ecrire un programme de jeu demandant de deviner un nombre entre 0 et 10 choisi par l'ordinateur.

2)

On ne donnera pas d'indications avant la découverte de la solution, où l'on indiquera le nombre d'essais nbr_essais. Modifier ce programme pour qu’il permet de :

- préciser au joueur à chaque essai si sa proposition est « trop grande » ou « trop petite » ;

- afficher « vous avez eu un peu de chance » si le nombre d’essais nbr_essais = 1 ;

- afficher « bravo» si le nombre d’essais nbr_essais < 4 ;

17

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

TP2 : LES INSTRUCTIONS DE CONTROLE CONDITIONNELLES ET REPETITIVES

- afficher « ce score me semble bien minable» si le nombre d’essais nbr_essais > 6.

Indication : la solution sera choisie par l'ordinateur par la fonction rand() qui rend un entier aléatoire (déclarée dans stdlib.h).

18

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

3.1 Les Tableaux

Un tableau est une suite de cellules consécutives en mémoire pouvant contenir des données de type identique.

3.1.1 Les tableaux à une dimension (vecteurs) i) Déclaration

type Nom_Tab [ TAIL_MAX ];

type est le type des éléments composant le vecteur, Nom_Tab est le nom qui désigne le tableau, TAIL_MAX est la taille ou la dimension de déclaration c'est-à-dire le nombre d'éléments maximum utilisables.

Exemple :

float tab[5] ; /*est un tableau de 5 réels*/ int tablo[8] ; /*est un tableau de 8 entiers*/ char p2[7]="Bonjour" ; /*est un tableau de 7 caractère*/

Lors de la déclaration, le compilateur réserve la mémoire nécessaire pour le tableau c'est-à-dire qu'il réserve TAIL_MAX*sizeof(type) octets.

Remarques et Définitions :

TAIL_MAX doit obligatoirement être une expression constante de type entier c'est-à-dire explicite ou définie grâce à une directive de compilation #define. Exemple :

#define N 10 void main(){ double tab[N] ; /* est un tableau de 10 doubles*/ }

Le nombre d’éléments à saisir dans un tableau ne doit pas dépasser TAIL_MAX pour ne pas déborder sa capacité.

Par définition, en langage C, Nom_Tab est l'adresse du premier élément du tableau, cette adresse est constante puisque c'est le compilateur qui lui a affecté une valeur lors de la déclaration du tableau. La valeur de cette adresse ne pourra en aucun cas être modifiée par le programme.

ii) Initialisation

L'initialisation d'un tableau peut se faire en même temps que sa déclaration.

Exemple :

type Nom_Tab [ TAIL_MAX ]={val1, val2,

};

float vect[ 4 ] = { -5.3 , 4.88 , 2.67 , -45.675 }; /*place -5.3 dans vect[ 0 ], 4.88 dans vect [ 1 ], 2.67 dans vect[ 2 ] et -45.675 dans vect[ 3 ] ;

float vect[ ] = { -5.3 , 4.88 , 2.67 , -45.675 }; /*place -5.3 dans vect [ 0 ], 4.88 dans vect[ 1 ], 2.67 dans vect[ 2 ] et -45.675 dans vect[ 3 ] et fixe sa dimension à 4*/

iii) Accès aux éléments d’un vecteur

Nom_Tab[i] désigne l'élément d'indice i du tableau (ATTENTION ! les indices commencent à 0, par conséquent i pourra varier de 0 à TAIL_MAX-1). Il désigne le contenu du tableau à la position i+1 ; il s'agit donc d'une valeur.

19

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

&Nom_Tab[i] caractérise l'adresse de l'élément Nom_Tab[i].

Nom_Tab :

Adresses

&Nom_Tab[TAIL_MAX-1]

&Nom_Tab[TAIL_MAX-2]

&Nom_Tab[2]

&Nom_Tab[1]

&Nom_Tab[0]

Valeurs

Nom_Tab[TAIL_MAX-1]

Nom_Tab[TAIL_MAX-2]

Valeurs Nom_Tab[TAIL_MAX-1] Nom_Tab[TAIL_MAX-2] Nom_Tab[2] Nom_Tab[1] Nom_Tab[0]

Nom_Tab[2]

Nom_Tab[1]

Nom_Tab[0]

iv) Manipulation d’un vecteur

La manipulation d’un vecteur est toujours liée à la manipulation des éléments du vecteur. C’est pourquoi le traitement des tableaux contient toujours des structures répétitives (for, while, do…while).

Exemple :

#include<stdio.h> #include<conio.h> void main(){ float MOY[50], X, Max; int i,j,N; clrscr();

/*Lecture du nombre d’élément N d’un vecteur MOY de type réel (de dimension max 50)*/

do

{

printf(″donner le nombre d’élément du tableau″) ;

scanf(%d,&N) ;

}while(N<=0 || N>50);

/* Remplissage du tableau*/

for(i=0;i<N;i++)

{

do{ printf(″donner la moyenne de l’étudiant %d″,i+1);

scanf(″%f″,&MOY[i]);

}while(MOY[i]<0 || MOY[i]>20); /* la moyenne doit être entre 0 et 20*/

}

/* Recherche d’un élément X dans le tableau*/

printf(″donner une valeur″) ; scanf(″%d″,&X) ; i=0 ; while(i<0 && MOY[i] !=X)

i=i+1;

if(i<N) printf(″%f existe dans Moy″,X) ;

20

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

else printf(″%f n’existe pas dans Moy″,X) ;

/* Recherche du maximum du tableau*/

Max=MOY[0] ;

for(i=0;i<N;i++)

{

 

if(Max<MOY[i])

Max=MOY[i];

}

printf(″la valeur maximale de Moy est %f″, Max) ;

/* Affichage du tableau*/

for(i=0;i<N;i++)

printf(″la moyenne de l’étudiant %d : %.3f\n″, i+1,MOY[i]) ;

/* Fin du programme*/

getch() ;

}

3.1.2 Les tableaux à deux dimensions (matrices)

Un tableau à 2 dimensions est similaire à une matrice.

i) Déclaration

type Nom_Tab [ LIG_MAX ] [ COL_MAX ];

type est le type des éléments composant la matrice, Nom_Tab est le nom qui désigne le tableau, LIG_MAX est la taille de déclaration de la longueur maximale des lignes, COL_MAX est la taille de déclaration de la longueur maximale des colonnes.

Exemple :

int Tab[2][2];

/*déclaraion d’une matrice 2x2*/

Remarque :

Les dimensions supérieures respectent le même principe.

int Tab[2][2][7][4];

/* déclaration d'un tableau de dimension 4*/

Lors de la déclaration, le compilateur réserve la mémoire nécessaire pour le tableau c'est-à-dire qu'il réserve LIG_MAX*COL_MAX*sizeof(type) octets. LIG_MAX et COL_MAX doivent obligatoirement être des expressions constantes de type entier.

ii) Initialisation

Exemple :

type Nom_Tab [ LIG_MAX ][COL_MAX]={{val11, val12,

Exemple : type Nom_Tab [ LIG_MAX ][COL_MAX]={{val11, val12, },{val21, avl22,…},….}; valeurs de la ligne 1 float

},{val21, avl22,…},….};

valeurs de la ligne 1

float Mat[2][4]= {{-5.3,4.88,2.67,-45.675} ,{3.72,-2.6,35.1,0.25}};/*déclaration et initialisation*/

21

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

iii) Accès aux éléments d’une matrice

Nom_Tab[i][j] désigne l'élément de la ligne i et de la colonne j (ATTENTION !les indices commencent à 0, par conséquent i pourra varier de 0 à LIG_MAX-1 et j pourra varier de 0 à

COL_MAX-1.

&Nom_Tab[i][j] désigne l'adresse de l'élément Nom_Tab[i][j].

 

Adresses

&Nom_Tab[LIG_MAX-1][COL_MAX-1]

&

Nom_Tab[LIG_MAX-1][1]

Nom_Tab[LIG_MAX-1]

&

Nom_Tab[LIG_MAX-1][0]

 
 

&

Nom_Tab[1][COL_MAX-1]

&Nom_Tab[1][1]

 

Nom_Tab[1]

&Nom_Tab[1][0]

 

&Nom_Tab[0][COL_MAX-1]

Nom_Tab

Nom_Tab[0]

&Nom_Tab[0][0]

Valeurs

Nom_Tab[LIG_MAX-1][COL_MAX-1]

Nom_Tab[LIG_MAX-1][1]

Nom_Tab[LIG_MAX-1][0]

Nom_Tab[1][COL_MAX-1]

Nom_Tab[1][1]

Nom_Tab[1][0]

Nom_Tab[0][COL_MAX-1]

Nom_Tab[0][1]

Nom_Tab[0][0]

iv) Manipulation d’une matrice

Pour manipuler un élément, on a besoin de préciser l’indice de la ligne et l’indice de la colonne. C’est pourquoi le traitement des matrices contient toujours deux structures répétitives imbriquées l’une pour parcourir les lignes et l’autre pour parcourir les colonnes.

Exemple :

#include<stdio.h> #include<conio.h> void main(){ float M[50][40], R[50][40]; int i,j,L,C,X; clrscr();

/*Lecture des dimensions L et C d’une matrice M de type réel (de dimension max 50 lignes et 40 colonnes) */

do

{

printf(″donner la taille réelle de M″) ; scanf(″%d%D″,&L,&C) ;

}while(L<=0 || L>50|| C<=0 || C>40);

/* Remplissage du tableau*/

for(i=0;i<L;i++)

for(j=0;j<C;j++)

{

printf(″donner la valeur de la case %d-%d″,i,j); scanf(″%f″,&M[i][j]) ;

}

22

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

/* Multiplication R=M*X */

printf(″donner une valeur″) ; scanf(″%d″,&X) ;

for(i=0;i<L;i++)

for(j=0;j<C;j++)

R[i][j]=M[i][j]*X ;

/* Affichage du tableau*/

for(i=0;i<L;i++)

for(j=0;j<C;j++)

printf(″R[%d,%d]=%.3f\n″,i,j,R[i][j]);

/* Fin du programme*/

getch() ;

}

3.2 Les Pointeurs

3.2.1 Définition et déclaration d’un pointeur

Un pointeur est une variable qui a pour valeur l’adresse d’une autre variable : celle sur laquelle elle pointe.

Un pointeur est toujours associé à un type de variable et un seul.

Au moment de la déclaration, on détermine le type de variable pointée par le pointeur, en écrivant le type concerné, puis le nom du pointeur avec une * devant :

type

* nom_Pointeur ;

Exemple :

int *pta ; /* la variable pta est un pointeur sur un entier*/

int a ;

/* la variable a est un entier*/

3.2.2 Opérateur d’adresse : &

Pour affecter l’adresse de la variable a au pointeur pta, on écrit l’instruction :

pta=&a ;

/*pta pointe sur a*/

Cet opérateur signifie donc adresse de.

3.2.3 Opérateur d’indirection : *

Cet opérateur, mis en préfixe d’un nom de pointeur signifie valeur de la variable pointée ou, plus simplement, le contenu de l’adresse.

Exemples :

int x=1 ; int *px ; px=&x ; *px=12 ; char *pc; *pc = 34 ; char *pa; *pa = 'a'; int *ad1, *ad2, *ad3 ;

/* déclaration d’un pointeur sur un entier */ /* px pointe sur x */ /* la variable pointée par px reçoit 12*/

/* le code ASCII de a est rangé dans la case mémoire pointée par pa */

23

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

int n=10,p=20;

ad1=&n;

ad2=&p;

*ad1=*ad2+2;

/*

n=p+2 */

*ad1+=3;

/*

*ad1=*ad1+3 ce qui signifie n=n+3

*/

*(ad1)++;

/*

*ad1=*ad1+1 ce qui signifie n++ */

ad2=ad1;

printf("x=%d\n",x) ;

printf("contenu de la case mémoire: %c\n",*pc) ; /* affiche contenu de la case mémoire: ″*/ printf("valeur de l'adresse en hexadécimal: %p\n",pc);/*affiche son adresse en hexadécimal*/

/* affiche x=12 */

3.2.4 Mémoire et Pointeurs

Les pointeurs et les noms des variables donnent accès à un emplacement en mémoire centrale.

Le nom d’une variable reste toujours lié à la même adresse mémoire

On prend l’exemple suivant :

int a=0xa ; short b=0x0 ; int c=0x14 ; int *ptint ; ptint=&a ;

/* ’a’ est un entier codé sur 4 octets */ /* ’b’ est un entier codé sur 2 octets */ /* ’c’ est un entier codé sur 4 octets */

On aura le tableau suivant :

Nom

Adresse

Valeur codée en hexadécimal

a

bfbff000

00

00 00 0a

b

bfbff004

00

00

c

bfbff006

00

00 00 14

ptint

bfbff010

bf bf f0 00

Les cases mémoire des variables a, b et c contiennent leurs valeurs. Celles de la variable ptint contiennent l’adresse de la valeur pointée. En effet, la valeur stockée est (bfbff000), ce qui est bien l’adresse de a.

Remarque :

On ne peut pas affecter directement une valeur à un pointeur. L’écriture suivante est interdite:

char *pc; pc = 0xfffe; /*faux*/

Exemple :

#include <stdio.h> void main(){ float *px ; float x=3.5 ; px=&x ; printf ("adresse de x : 0x%lx \n",&x) ; printf ("valeur de px : 0x%lx \n",px) ; printf ("valeur de x : %3.1f \n",x) ;

printf ("valeur pointée par px : %3.1f \n",*px) ; /* valeur pointée par px : 3.5*/

/*adresse de x : 0xbfbffa3c*/ /*valeur de px : 0xbfbffa3c*/ /*valeur de x : 3.5*/

24

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

}

3.3 Tableaux et Pointeurs

Le nom du tableau est un pointeur constant sur son premier élément.

int tab[10] ; int *p=&tab[0] ; /*la variable p reçoit l’adresse du premier élément du tableau*/

En partant de cet exemple, on peut écrire:

Notation

Equivalent

*p=10 ;

tab[0]=10

*(p+1)=20

tab[1]=20

*(p+i)=-15 ;

tab[i]=-15

ATTENSION ! Comme le nom du tableau est un pointeur constant donc les instructions d’affectation sont interdites.

tab=po ;

/*faux*/

tab++ ;

/*faux*/

tab-- ;

/*faux*/

tab+=i ;

/*faux*/

Pour expliquer d’avantage, on donne le tableau suivant :

Notation

Equivalent

&tab[0] ;

Tab;

p=&tab[0]

p=tab ;

p=tab+i ;

p=&tab[i] ;

p++ ;

p=&tab[i+1] ;

*(tab+i) ;

tab[i] ;

Initialisation de tab

En utilisant un pointeur

for(i=0 ;i<N ;i++)

for(i=0 ;i<N ;i++)

tab[i]=0;

*(tab+i)=0;

for(i=0, p=tab;i<N ;p++,i++)

*p=0;

3.4 Allocation dynamique de mémoire

Jusqu’à maintenant, lors de la déclaration d’un tableau, il fallait préciser les dimensions, soit de façon explicite soit de façon implicite. Dans ces deux cas on a déclare un tableau de dimension fixe.

Mais si l’on veut que le tableau change de taille d’une exécution à une autre, cela nous oblige à modifier le programme et à le recompiler à chaque fois, ou bien à déclarer un tableau d’une dimension très grande et n’utiliser que les n premières cases mais ce serait du gâchis.

Pour éviter cela, on fait appel à l’allocation dynamique de mémoire : au lieu de réserver de la place lors de la compilation, on la réserve pendant l’exécution du programme, de façon interactive.

25

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

3.4.1 La fonction malloc()

malloc(N) renvoie l’adresse d’un bloc de mémoire de N octets libres (ou la valeur 0 s’il n’y a pas assez de mémoire).

Exemple :

int *p ; p = malloc(800);/* fournit l’adresse d’un bloc de 800 octets libres et l’affecte au pointeur p */

/*Allocation dynamique d’un tableau à une dimension*/

int n ; int *tab ; printf("taille du tableau :\n") ; scanf("%d", &n) ; tab = (int *)malloc(n*sizeof(int));

/* le cast est nécessaire pour préciser le type de données sur lesquelles tab va pointer */

free(tab) ; /* on libère la place mémoire réservée*/

/*Allocation dynamique d’un tableau de deux dimensions*/

int i,j,n,m ; float **tab ; scanf("%d%d",n,m) ; tab = (float **)malloc(n*sizeof(float *)) ; for (i=0 ; i<n ; i++){ tab[i] = (float *)malloc(m*sizeof(float)) ;

}

for (i=0 ; i<n ; i++){ for (j=0 ; j<m ; j++){

tab[i][j] = 10*i+j ;

}

}

free(tab);

Remarque :

Ces

compilateur).

fonctions

sont

définies

dans

les

bibliothèques

26

STDLIB.H

ou

ALLOC.H

(suivant

votre

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

TRAVAIL DEMANDE

TABLEAUX A UNE SEULE DIMENSION

Exercice 1 :

Ecrire un programme C qui permet de :

1)

saisir N notes dans un tableau ;

2)

calculer et afficher la moyenne M de ces N notes ;

3)

déterminer et afficher la valeur de la meilleure note note_max .

Exercice 2 :

Ecrire un programme en C qui permet de :

1)

ranger N entiers positifs dans un tableau Tab (N ne dépasse pas 40) ;

2)

chercher le nombre d’occurrences d’une valeur X dans Tab.

Exercice 3 :

Ecrire un programme en C qui permet de :

1)

remplir un tableau T de N réels (0<N<20) ;

2)

trier T selon un ordre croissant puis selon un ordre décroissant ;

3)

insérer un réel X dans T tout en respectant l’ordre.

Exercice 4 :

Un programme contient la déclaration suivante:

int tab[20] = {4,-2,-23,4,34,-67,8,9,-10,11, 4,12,-53,19,11,-60,24,12,89,19};

Compléter ce programme de sorte d'afficher les éléments du tableau avec la présentation suivante:

4

-2

-23

4

34

-67

8

9

-10

11

4

12

-53

19

11

-60

24

12

89

19

TABLEAUX A DEUX DIMENSIONS

Exercice 5 :

Ecrire un programme en C qui permet de saisir deux matrices A et B de même dimension (nbre de ligne max est 20 et nbre de colonnes max est 20) et de déterminer leur somme.

Exercice 6 :

Soit le programme suivant :

void main(){

POINTEURS

27

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP3 : LES TABLEAUX ET LES POINTEURS

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP3 : LES TABLEAUX ET LES POINTEURS

TP3 : LES TABLEAUX ET LES POINTEURS

int A=1, B=2, C=3 ;

int

int A=1, B=2, C=3 ;

*p1, *p2 ;

p1=&A ;

p2=&C;

*p1=*p2 * B;

p1=p2;

p2=&B;

*p1- =*p2;

*p1* =*p2;

A=*p2**p1;

p1=&A;

*p1=*p1/*p2; }

Déterminer la valeur de chaque variable suite à l’exécution de chaque instruction.

Exercice 7 :

Soit P un pointeur qui pointe sur un tableau A.

int A[]={12, 23, 34, 45, 56, 67, 78, 89, 90} ; int *P ; P=A ; Quelles valeurs ou adresses fournissent les expressions suivantes :

*P+2 ;

*(P+2) ;

P++ ;

A+3 ;

TABLEAUX ET POINTEURS

Exercice 8 :

Ecrire un programme en C qui range les éléments d’un tableau A de type entier dans l’ordre décroissant. Le programme utilisera deux pointeurs p1 et p2 et une variable numérique AIDE pour la permutation des éléments.

Exercice 9 :

Ecrire un programme en C qui lit un entier X et un tableau A de type entier au clavier et qui élimine toutes les occurrences de X dans A en tassant les éléments restants.

Indication : le programme utilisera deux pointeurs P1 et P2 pour parcourir le tableau.

28

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP4 : LES CHAINES DE CARACTERES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP4 : LES CHAINES DE CARACTERES

TP4 : LES CHAINES DE CARACTERES

Le langage C offre quelques facilités d'écritures pour simuler les chaînes de caractères à l'aide de tableaux. En plus de cela, certaines fonctions de la bibliothèque standard (et les autres), principalement la bibliothèque STRING.H, permettent de faciliter leur gestion. À la différence d'un tableau, les chaînes de caractères respectent une convention : se terminer par le caractère nul, '\0' (antislash- zero). Ainsi, pour construire une chaîne de caractères « à la main », il ne faut pas oublier ce caractère final.

En langage C, les chaînes de caractères sont des tableaux de caractères. Leur manipulation est donc analogue à celle d'un tableau à une dimension.

4.1 Déclaration

char nom[dim];

/*ou bien*/

char *nom ; nom= (char*)malloc(dim) ;

Exemple:

char prénom[10]; char *message ; message=(char*)malloc(10) ;

Le compilateur réserve (dim-1) places en mémoire pour la chaîne de caractères: En effet, il ajoute toujours le caractère NULL ('\0') à la fin de la chaîne en mémoire.

4.2 Affichage à l'écran

On peut utiliser la fonction printf et le format %s:

Exemple :

char message[10] = "salut"; printf("voici le message: %s\n",message);

On utilisera si possible la fonction puts non formatée:

puts(message); /* est équivalent à printf("%s\n",message) */;

4.3 Saisie:

On peut utiliser la fonction scanf et le format %s.

Exemple :

char message[10]; printf("écrivez votre message: "); scanf("%s",message);

On utilisera de préférence la fonction gets non formatée.

gets(message); /*est équivalent à scanf("%s",message)*/

29

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP4 : LES CHAINES DE CARACTERES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP4 : LES CHAINES DE CARACTERES

TP4 : LES CHAINES DE CARACTERES

Remarques:

Les fonctions printf et sanf permettent de lire et d’afficher simultanément plusieurs informations le type quelconque. Par contre gets et puts ne traitent qu’une chaîne à la fois.

Avec le code %s de scanf, les délimiteurs sont classiquement l’espace, la tabulation ou la fin de ligne. Ceci interdit la lecture d’une chaîne contenant des espaces. Avec gets, seule la fin de ligne sert de délimiteur.

Dans les appels des fonctions scanf et puts, les identificateurs de tableaux comme nom, prénom ou ville ne doivent pas être précédés de l’opérateur & puisqu’ils représentent déjà des adresses.

La fonction puts réalise un changement de ligne en fin de l’affichage de la chaîne, ce qui n’est pas le cas de la fonction printf avec le code format %s.

La fonction gets fournit en résultat, soit un pointeur sur la chaîne lue, soit un pointeur nul on cas d’anomalie.

4.4 Fonctions sur les chaînes de caractères

Ces fonctions appartiennent à la bibliothèque STRING.H.

4.4.1 Comparaison des chaînes

strcmp(chaine1, chaine2);

Compare deux chaînes dont on lui fournit les adresses et elle fournit une valeur entière définie comme étant :

positive si chaine1 > chaine2 (c’est à dire chainel vient après chaine2 au sens de l’ordre défini par le code ASCII)

nulle si chaine1 = chaine2 (c’est à dire que chaine1 et chaine2 contiennent exactement la même suite de caractères).

négative si chaine 1 < chaine2

Exemple :

strcmp(”bonjour “, “monsieur’’) ; /*revoie un entier négatif*/

strcmp(”Tunis“,‘’Tunis’’) ;

/*revoie un entier positif*/

4.4.2 Longueur d’une chaîne

strlen(chaine);

Renvoie la longueur de la chaine (un entier) sans compter le caractère '\0'.

Exemple :

strlen("coincoin") ; /*renvoie 8*/

4.4.3 Concaténation et copie de chaînes

strcpy (destination,source); /*copie le contenu de source à l'adresse mémoire pointé par destination, incluant le caractère nul final*/

strncpy (destination, source, n); /*procède de manière analogue à strcpy, en faisant la recopie au nombre de caractères précisés par l’expression entière n*/

strcat (destination,source); /*concatène la chaîne source à la fin de la chaîne destination, en y rajoutant aussi le caractère nul final. Toutes ces fonctions renvoient le pointeur sur la chaîne destination*/

30

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP4 : LES CHAINES DE CARACTERES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP4 : LES CHAINES DE CARACTERES

TP4 : LES CHAINES DE CARACTERES

strncat (destination, source, n); /*procède de manière analogue à strcat, en offrant en outre un contrôle sur le nombre n de caractères qui seront concaténés à la chaine destination */

4.4.4 Recherche dans une chaine :

Ces fonctions renvoient l’adresse de l’information recherchée en cas de succès, sinon le pointeur NULL (c'est-à-dire le pointeur de valeur 0 ou encore le pointeur faux).

strchr(chaîne, caractère) ;

/* recherche le caractère dans chaîne*/.

strrchr(chaîne, caractère) ; /* recherche le caractère dans chaîne en commençant par la fin*/.

strstr(chaîne, sous-chaîne) ; /* recherche la sous-chaîne dans chaîne*/.

31

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP4 : LES CHAINES DE CARACTERES

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP4 : LES CHAINES DE CARACTERES

TP4 : LES CHAINES DE CARACTERES

TRAVAIL DEMANDE

SAISIE ET AFFICHAGE DES CHAINES DE CARACTRES

Exercice 1 :

Ecrire un programme qui affiche le code ASCII de chaque lettre de votre prénom.

Exercice 2 :

Ecrire un programme qui saisit successivement chaque caractère de votre prénom puis les affiche.

COMPARAISON, RECHERCHE ET CONCATENATION DES CHAINES DE CARACTRES

Exercice 3 :

Ecrire un programme qui saisit un caractère alphabétique et indique si celui-ci est une voyelle ou une consonne et s’il s’agit d’une majuscule ou non. Vous utiliserez la table du code ASCII.

Exercice 4 :

Saisir un texte. Ranger les caractères en mémoire. Lire le contenu de la mémoire et y compter le nombre d'espaces et de lettres e.

Exercice 5 :

1)

2)

Écrire un programme en C qui retourne le nombre de caractères que comporte une chaine ch saisie au clavier. Écrire un programme qui recopie le contenu d’une chaîne src dans la chaîne dest.

Exemple d'utilisation :

char mot[] = "Un beau dimanche"; /* une chaine initialisée. */ char tut[256]; /* au max 255 caractères */ /* ici tut = "Un beau dimanche" */

3)

4) Écrire un programme en C qui teste si les deux chaînes ch1 et ch2 sont identiques (c.à.d. ont le

même contenu), dans ce cas il affiche 0. Le programme affiche 1 si ch1 est après ch2 dans l'ordre lexicographique, -1 si ch1 est avant ch2.

Écrire un programme en C qui ajoute la chaîne src à la fin de la chaîne dest.

Exercice 6 :

Saisir un texte. Ranger les caractères en mémoire. Lire le contenu de la mémoire et y compter le nombre d'espaces et de lettres e.

Exercice 7 :

Ecrire un programme qui lit 5 mots, séparés par des espaces et qui les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les mots sont mémorisés dans un tableau de chaînes de caractères.

Exemple voici une petite phrase ! ! phrase petite une voici

32

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

5.1 Définition

On appelle fonction un sous-programme qui permet d'effectuer un ensemble d'instructions par simple appel de la fonction dans le corps du programme principal. Les fonctions permettent d'exécuter dans plusieurs parties du programme une série d'instructions, cela permet une simplicité du code et donc une taille de programme minimale.

En général, le nom d'une fonction apparaît à trois endroits dans un programme:

lors de la déclaration ;

lors de la définition ;

lors de l'appel.

5.2 La déclaration des prototypes

de sortie afin de pouvoir vérifier lors

déclaration de prototype se différencie de la

déclaration de fonction par l’ajout d’un point virgule ; en fin de ligne. Elle est située au début du

d'appel de fonction l'ordre de passage des paramètres. La

Elle permet de définir au compilateur les paramètres d'entrée et

programme. La syntaxe de déclaration des prototypes est la suivante :

Type_de_retour Nom_de_la_Fonction (TypeArg1 NomArg1, TypeArg2 NomArg2,

);

Type_de_retour est le type de la valeur renvoyée par la fonction. Nom_de_la_Fonction est le nom de

. NomArg1 : est le nom du 1 er

argument Arg1

Exemple :

la fonction. type1 (ou TypeArg1) est le type du 1 er argument Arg1

.

float affine(float f, int d) ;/* la fonction affine accepte en entée un réel f et un entier d et retourne un résultat de type réel.*/

5.2.1 Règles pour la déclaration des fonctions

De façon analogue aux déclarations de variables, nous pouvons déclarer une fonction localement ou globalement. La définition des fonctions joue un rôle spécial pour la déclaration. En résumé, nous allons considérer les règles suivantes:

Déclaration locale : Une fonction peut être déclarée localement dans la fonction qui l'appelle (avant la déclaration des variables). Elle est alors disponible à cette fonction.

Déclaration globale : Une fonction peut être déclarée globalement au début du programme (derrière les instructions #include). Elle est alors disponible à toutes les fonctions du programme.

Déclaration implicite par la définition : La fonction est automatiquement disponible à toutes les fonctions qui suivent sa définition.

Lors de la déclaration, le nombre et le type des paramètres doivent nécessairement correspondre à ceux de la définition de la fonction.

La fonction principale main n'a pas besoin d'être déclarée.

5.3 La définition

Avant d'être utilisée, une fonction doit être définie car pour l'appeler dans le corps du programme il faut que le compilateur la connaisse, c'est-à-dire qu'il connaisse son nom, ses arguments et les instructions qu'elle contient. La définition d'une fonction se fait selon la syntaxe suivante :

33

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

Type_de_retour Nom_de_la_Fonction( type1 arg1 , type2 arg2,

{

déclaration variables locales ; instructions ; return (expression) ;

}

, typen argn)

Type_de_retour est le type de la valeur renvoyée par la fonction. type1 est le type du 1 er argument

arg1

expression est évaluée lors de l’instruction return (expression) ; c’est la valeur que renvoie la fonction

quand elle est appelée depuis main().arg1 , arg2,

La 1 ` ère ligne de la déclaration est appelée le prototype de la fonction.

La valeur retournée est spécifiée à l’aide du mot réservé return.

Exemple:

. Les variables locales : sont des variables qui ne sont connues qu’à l’intérieur de la fonction.

, argn sont les paramètres formels.

float affine( float x ) { /* la fonction affine prend 1 argument réel */ /* et renvoie un argument réel */

int a,b ;

a=3 ; b=5 ; return (a*x+b) ; /* valeur renvoyée par la fonction */

}

/* paramètre locales*/

Il est possible en C de créer des fonctions sans paramètres ou ne renvoyant aucune valeur

(procédures). Pour

On utilise ce type pour des fonctions censées affichées uniquement des messages par exemple.

Exemple:

cela

on

utilise

un

type

prévu

à

cette

effet

: void .

void afficherBonjour()

/* pas de paramètres donc void */

{

 

printf("Bonjour !\n");

/* pas de return*/

}

Il

y a deux méthodes pour passer des variables en paramètre dans une fonction : le passage par valeur

et

le passage par variable.

5.3.1 Passage des paramètres par valeur

En C, le passage des paramètres se fait toujours par la valeur, c'est-à-dire les fonctions n'obtiennent que les valeurs de leurs paramètres et n'ont pas d'accès aux variables elles mêmes.

Les paramètres d'une fonction sont à considérer comme des variables locales qui sont initialisées automatiquement par les valeurs indiquées lors d'un appel.

A l'intérieur de la fonction, on peut donc changer les valeurs des paramètres sans influencer les valeurs

originales dans les fonctions appelantes.

34

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

Exemple :

/*La fonction ETOILES dessine une ligne de N étoiles. Le paramètre N est modifié à l'intérieur de la fonction*/ void ETOILES(int N)

{

while (N>0)

{ printf("*");

N--; }

printf("\n");

}

5.3.2 Passage de l'adresse d'une variable

Comme on l'a constaté ci-dessus, une fonction n'obtient que les valeurs de ses paramètres. Pour changer la valeur d'une variable de la fonction appelante, on va procéder comme suit:

la fonction appelante doit fournir l'adresse de la variable.

la fonction appelée doit déclarer le paramètre comme pointeur.

On peut alors atteindre la variable à l'aide du pointeur.

Exemple :

Pour pouvoir modifier le contenu de X et de Y, la fonction PERMUTER a besoin des adresses de X et Y. En utilisant des pointeurs, on écrit:

void PERMUTER (int *A, int *B)

{

int AIDE; AIDE = *A; *A = *B; *B = AIDE;

}

Nous appelons la fonction par:

PERMUTER(&X, &Y); /* le contenu des variables X et Y est échangé*/

5.4 L’appel de fonction

Il dirige le programme principal ou une autre fonction sur la fonction à exécuter en donnant les variables d'entrées et ou l'affectation de la variable de sortie. L’appel d'une fonction se fait selon la syntaxe suivante :

Cas d’une fonction revoyant aucune valeur de retour :

Var = Nom_de_la_fonction(Var_Arg1,Var_Arg2,…,Var_ArgN) ; Cas d’une procédure :

Nom_de_la_fonction(Var_Arg1,Var_Arg2,…,Var_ArgN) ;

Elle est exécutée, mais le programme appelant ne reçoit aucune valeur de retour. C’est une fonction de type void.

35

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

Var_Arg1,Var_Arg2,…,Var_ArgN sont les paramètres effectifs.

36

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

TRAVAIL DEMANDE

Exercice 1 :

1)

Ecrire une fonction de prototype void Bonjour() qui affiche le message « bonjour ».

2)

Ecrire une fonction de prototype void Classe() qui appelle la fonction Bonjour() et qui affiche le

3)

message « Nous sommes la classe 1 ere ING MECA ». Les mettre en œuvre dans main().

Exercice 2 :

1)

Ecrire une fonction de prototype void carré() qui calcule et affiche le carré de deux entiers a et b.

2)

La mettre en œuvre dans main().

Exercice 3 :

1)

Ecrire une fonction de prototype int puissance() qui calcule la puissance de deux entiers a b .

2)

La mettre en œuvre dans main().

Exercice 4 :

Ecrire une fonction C qui accepte en entrée un nombre et affiche ce nombre en toute lettre. Ecrire un programme C qui permet de saisir un nombre et d’afficher en toute lettre tous les entiers inférieur à ce nombre et supérieur à 0.

Exercice 5 :

Un programme contient la déclaration suivante:

int tab[10] = {15, 3,28,1,-6,32,42,-15,89,-19}; /* variable globale */

1)

Ecrire une fonction de prototype void affiche() qui affiche les éléments du tableau.

2)

Ecrire une fonction de prototype void Moyenne() qui calcule la moyenne du tableau.

3)

Ecrire une fonction int Max() qui renvoie la valeur maximale du tableau.

4)

Ecrire une fonction int Min() qui renvoie la valeur minimale du tableau.

5)

Les mettre en œuvre dans main().

Exercice 6 :

tab1 et tab2 sont des variables locales à main:

int tab1[10] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19}; int tab2[10] = {-19,18,-17,16,-15,14,-13,12,-11,10,-9,8,-7,6,-5,4,-3,2,-1,0};

1)

Ecrire une fonction de prototype void affiche(int *tab) qui permet d'afficher les 20 nombres

2)

suivant un tableau 4x5. La mettre en œuvre dans main() pour afficher tab1 et tab2.

Exercice 7 :

1)

Ecrire une fonction Permute, avec passage d’arguments par adresse, permettant de permuter deux

2)

entiers a et b. Dans le programme principal main() :

3)

a) saisir deux entiers x et y.

37

Département de Génie Electrique TRAVAUX PRATIQUES PROGRAMMATION C TP5 : LES FONCTIONS EN LANGAGE C

Département de Génie Electrique

TRAVAUX PRATIQUES PROGRAMMATION C

TRAVAUX PRATIQUES PROGRAMMATION C
TP5 : LES FONCTIONS EN LANGAGE C

TP5 : LES FONCTIONS EN LANGAGE C

b) permuter les valeurs de x et y en utilisant la fonction Permute.

Exercice 8:

Ecrire une fonction qui accepte en entrée un tableau et retourne ce tableau trié par ordre croissant. Ecrire une fonction qui affiche les n éléments d’un tableau. Ecrire un programme C qui saisie une liste de n entier et d’afficher cette liste triée.

38

PARTIE II : MINI PROJET EN PROGRAMMATION C

39

Département de Génie Electrique MINI PROJET EN PROGRAMMATION C REDACTION DU RAPPORT ET EXPOSE

Département de Génie Electrique

MINI PROJET EN PROGRAMMATION C

MINI PROJET EN PROGRAMMATION C
REDACTION DU RAPPORT ET EXPOSE

REDACTION DU RAPPORT ET EXPOSE

1 Rédaction du rapport :

Le rapport doit contenir

1)

Un sommaire ;

 

2)

Une introduction;

3)

Deux chapitres :

Un chapitre général qui décrit toute l’application

 

Un deuxième chapitre de description détaillée du travail réalisé :

 

i) le programme principal :

 

Les

différentes

variables

globales

ou

locales

du

programme

principal

et

leurs

significations.

 

ii) les différentes fonctions réalisées :

 
 

le prototype de chaque procédure ou fonction, liste des différentes variables

locales utilisées dans les fonctions et leurs significations ;

 

le code de chaque fonction doit être présenté par un organigramme bien structuré.

 

iii) les différentes structures proposées.

 

4)

Une conclusion ;

 

5)

Une liste bibliographique des références utilisées.

NOTONS :

Le rapport ne doit pas dépasser une vingtaine de pages. Une copie des codes sources de l’application doit être rendue sur CD.

2 Exposé

Chaque étudiant doit préparer un exposé décrivant l’application réalisée ainsi qu’une démonstration pratique.

40