Techniques Et Implementation Circuit

Module TC2
Master 1 EEA-AEETS
Nicolas Rivire
Universit Toulouse III
Septembre 2013
Nicolas Rivire (Universit Toulouse III)
Module TC2 - Master 1 EEA-AEETS
Septembre 2013
1 / 123
Sommaire
Introduction lAlgorithmique
Langage C : Bases
Gnralits
Variables
Oprateurs
Instructions
Langage C : Fonctions
Les fonctions
Rcursivit
Entres/Sorties standards
Langage C : Bases pour les structures de donnes
Les tableaux
Les pointeurs
Les structures
Les unions
Septembre 2013
2 / 123
Sommaire
Structures de donnes volues

Piles
Files
Listes
Algorithmes de tri
Tri par slection
Tri par insertion
Tri rapide
Tri bulles
Compilation modulaire
Septembre 2013
3 / 123
Objectifs
I
Problme numrique : quelles sont les solutions de lquation

ax 2 + bx + c = 0 ?
But : rsoudre le problme avec un systme informatique
Les ordinateurs ont besoin de procdures automatiques pour rsoudre

un problme
Trouver une procdure automatique permettant de rsoudre ce

problme Trouver un algorithme
Un bon algorithme doit :

- tre efficace,
- avoir un bon niveau dabstraction, ce qui permet de dcomposer les
problmes complexes
- tre rutilisable, ce qui implique une bonne dcomposition des
problmes
Septembre 2013
4 / 123
Moyens
Un algorithme manipule des informations
Pour reprsenter les informations du problme, un algorithme utilise

des structures de donnes
Quelle structure de donnes pour notre exemple ? Comment

reprsenter le polynme ax 2 + bx + c ?
Le choix de la "bonne" structure de donnes aura un impact sur

lefficacit de lalgorithme
Les critres pour les structures de donnes sont les mmes que pour
lalgorithme : efficacit, abstraction, rutilisabilit
Septembre 2013
5 / 123
Mise en uvre
I
Un algorithme est un enchanement dactions logiques dcrit en

langage naturel :
- Lire les valeurs de a, b et c
- Calculer le dterminant
- etc.
Ces actions logiques sont ralises au moyen doprations de base
(affectation, oprations arithmtiques, oprations logiques, etc.)
Linterprtation de ces actions logiques par le systme informatique se
fait par le biais dun langage de programmation
Il existe des langages de haut niveau o les commandes sont
directement interprtes par le systme laide logiciels spcifiques
(Matlab, Maple, etc.)
Nous utiliserons un langage de programmation impratif procdural o
la suite logique des oprations est dterminante pour obtenir le
rsultat escompt : langage C
Septembre 2013
6 / 123
Langage C : Bases
Du programme lexcution.
Structure dun programme C.
Gnralits
Septembre 2013
7 / 123
Langage C : Bases
Gnralits
Du programme lexcution
Fichier source C (extension .c)

Prprocesseur
Fichier C
Compilateur
Ficher objet (extension .o)

Editeur de liens
Programme excutable
Septembre 2013
8 / 123
Langage C : Bases
Gnralits
Structure dun programme C (1)
/* 1 - directives du preprocesseur */
/* 2 - dfinition des constantes */
/* 3 - dfinition des types crs */
/* 4 - dfinition des variables globales */
/* 5 - dclaration des fonctions */
/* 6 - dfinition de la fonction principale */
/* 7 - dfinition des autres fonctions */
Septembre 2013
9 / 123
Langage C : Bases
Gnralits
/* Le cours commence ici */

/* ceci est un commentaire */
/* 1 - directives du preprocesseur */
#include <stdio.h>
/* 2 - dfinition des constantes */
#define N 10
/* 4 - dfinition des variables globales */
long int resultat[N];
/* 5 - dclaration des fonctions */
long int puissance(long int X, int Y);
Septembre 2013
10 / 123
Langage C : Bases
Gnralits
/* 6 - dfinition de la fonction principale */

int main()
{
int i, N=10; /* definition de variables locales */
for (i=0; i<=N; i++)
{
resultat[i]=puissance(2,i);
printf("2 puissance %d = %ld \n",i,resultat[i]);
}
return 0;
}
Septembre 2013
11 / 123
Langage C : Bases
Gnralits
/* 7 - dfinition des autres fonctions */

long int puissance(long int X, int Y)
{
int i;
/* definition de variables */
long int P=1;
/* locales la fonction */
for (i=0; i<Y; i++)
{
P=X*P;
}
return P;
}
Septembre 2013
12 / 123
Langage C : Bases
Identificateurs.
Variables.
Constantes.
Type numr.
Variables
Septembre 2013
13 / 123
Langage C : Bases
Variables
Identificateurs
I
Nom donn aux composantes : variables, fonctions, . . .
Taille : 31 caractres maximum

Caractres permis :
1.
2.
3.
4.
a-z
A-Z
0-9
caractre soulignement (underscore) _ ( viter en dbut de nom)
Toujours commencer par une lettre

Ne pas commencer par un chiffre !
Le nom 2_resultat est interdit
Le nom resultat_2 est bon
Septembre 2013
14 / 123
Langage C : Bases
Variables
Types (1)
Trois familles de variables simples :

1. caractre : char (1 octet)
2. entier : short (2 octets), int (2 ou 4 octets), long int (4 octets) et
long long int (8 octets) dans le C99
3. flottant (ou rel en virgule flottante) : float (4 octets), double (8
octets)
Par dfaut, ces types sont signs
Possibilit dutiliser les types NON signs
Septembre 2013
15 / 123
Langage C : Bases
Variables
Types (2)
Existence de quatre qualificatifs : unsigned pour les entiers et les

caractres, short et long pour les entiers, long pour les rels de type
double.
Exemples de types en C :
I
I
I
unsigned char : entiers naturels sur 1 octet (0 255),

short ou short int : Entiers relatifs sur 2 octets (-32768 32767),
unsigned long int ou unsigned long : Entiers naturels sur 4
octets,
long double : Rels sur 10 octets (3, 4e 4932 3, 4e 4932 )
Septembre 2013
16 / 123
Langage C : Bases
Variables
Types (3)
Diffrentes possibilits daffectation pour le type caractre :

1.
2.
3.
4.
alphabtique (8)
hexadcimal (0x38)
octal (\070)
caractres spciaux (\n)
Absence de type boolen : la valeur 0 signifie Faux et toute autre

valeur signifie Vrai
Type bool introduit dans le C99 avec true (1) et false (0)
Septembre 2013
17 / 123
Langage C : Bases
Variables
Les constantes
I
Il existe 4 types de valeurs constantes :

1.
2.
3.
4.
entire en dcimal ou hexadcimal (12,0xC)

relle en base 10 : [.]Chiffres[.][Chiffres][Exposant]
caractre (a, T)
chane de caractres ("une chaine")
Les expressions constantes :

#define identificateur_expression valeur_expression
Les constantes numres ou type numr (valeurs entires) :

enum identificateur_type_numr ...
...{identificateurs_des_valeurs};
Pour les constantes numres, affectation automatique ou manuelle

des valeurs possible, dmarre 0 sauf si explicit
Septembre 2013
18 / 123
Langage C : Bases
Variables
Les dclarations
Dclaration dune variable : type identificateur;
Initialisation la dclaration : type identificateur = valeur;
Une dclaration rserve un espace mmoire gal au type de la variable

dclare.
Utilisation du mot rserv const pour indiquer que la variable nest

pas modifiable : const type identificateur = valeur;
Septembre 2013
19 / 123
Langage C : Bases
Oprateurs
Oprateurs
Deux types doprateurs :

I
Oprateur unaire : sapplique une seule oprande
Oprateur binaire : sapplique deux oprandes
On appelle expression une combinaison doprateurs et doprandes

qui conduit un rsultat unique.
Type du rsultat dpend des oprandes.
Ordre de conversion : char int float double
Conversion explicite (casting) et implicite
Septembre 2013
20 / 123
Langage C : Bases
Oprateurs
Oprateurs arithmtiques
5 oprateurs : +, -, *, /, %
Opration effectue avec deux oprandes du mme type (casting si

ncessaire)
(float) 2/3 vaut 0.677777
(float) (2/3) vaut 0
Conversion possible au moment de laffectation : int toto = 4.8;

donne un entier (4)
Septembre 2013
21 / 123
Langage C : Bases
Oprateurs
Oprateurs relationnels
Il y a six oprateurs relationnels
Ils renvoient une valeur entire (type int) gale : 0 faux, 1 vrai
Egalit : ==
Diffrence : !=
Comparaison : > , >= , <= , <
Septembre 2013
22 / 123
Langage C : Bases
Oprateurs
Oprateurs logiques
Il y a trois oprateurs logiques
Ils sappliquent aux oprandes qui ont la valeur logique Faux (0) ou
Vrai
Le rsultat renvoy est 0 ou 1
ET logique : &&
OU logique : ||
Ngation logique : !
Septembre 2013
23 / 123
Langage C : Bases
Oprateurs
Oprateurs de manipulation de bits
Il y a six oprateurs manipulant les bits
ET bit bit : & ; utile pour les masques
OU inclusif : |
OU exclusif : ^
Complment 1 : ~
Dcalage gauche : << avec introduction de zros par la droite
Dcalage droite : >> avec extension du bit de signe si sign sinon 0
Septembre 2013
24 / 123
Langage C : Bases
Oprateurs
Affectation
Ralisation : variable = expression
Possibilit daffectation entre des types diffrents mais dangereux !

Variantes :
I
I
val = val <oprateur> oprande

val <oprateur>= oprande (affectation combine)
Septembre 2013
25 / 123
Langage C : Bases
Oprateurs
Oprateurs dincrmentation et dcrmentation
La position de loprateur (avant ou aprs) indique si lutilisation de la

valeur se fait avant ou aprs lopration
val++ quivaut val = val + 1 (ou ++val)
val-- quivaut val = val -1 (ou --val)
Utilisation exclusive avec des variables considres isolment
Post-<opration> : utilisation de la variable avant incrmentation
Pr-<opration> : utilisation de la variable aprs incrmentation
Septembre 2013
26 / 123
Langage C : Bases
Oprateurs
Oprateurs dincrmentation et dcrmentation (exemples)
Val = 5;
/* Incrmentation de Val avant la multiplication par 3 */
Page = ++Val * 3;
/* Val = 6 et Page=18 */
/* Incrmentation de Val aprs la multiplication par 3 */
Delta = (Val++) * 3;
/* Val=7 et Delta=18 */
Septembre 2013
27 / 123
Langage C : Bases
Oprateurs
Exercice-1 : Evaluer les expressions suivantes

1. ((5%3) 7)/3
2. (0x24 + 0x12)/2
3. 5 <= 7 == 1
4. 5 + 3 == 8 6
5. (5 + 3 == 8) 6
6. (6 > 5 && 5 < 6)||(5 > 3 && 3 2 > 6.3)
7. 6 > 5 && (5 < 6 || 5 > 3) && 3 2 > 6.3
8. (0x34 << 2)|0x27
9. 0xFF & (1 << 3)
10. 0|1 << 3
11. 102. (5/255)
12. 102. (5./255.)
Septembre 2013
28 / 123
Langage C : Bases
De contrle
Itratives
Instructions
Septembre 2013
29 / 123
Langage C : Bases
Instructions
Instructions de contrle : if-else
if (<condition>)
< corps du alors >
[ else
< corps du sinon > ]
I
Si condition est value vrai, alors corps du alors excut,

sinon corps du sinon est excut
Plusieurs instructions de type if-else imbriques possibles, attention

aux accolades
Pas obligation de corps du sinon
corps peut tre une seule instruction pas daccolade
Septembre 2013
30 / 123
Langage C : Bases
Instructions
Instructions de contrle : oprateur conditionnel ?
<condition> ? <expression-si-vrai> : <expression-si-faux>

I
Si condition est value vrai, alors la valeur de lopration sera

expression-si-vrai, sinon elle sera expression-si-faux.
Max = (4 > 8) ? 4 : 8;
Min = (4 < 8) ? 4 : 8;
Septembre 2013
31 / 123
Langage C : Bases
Instructions
Instructions de contrle : switch

switch (<expression>)
{
case <etiquette_1> : <instructions_1>
case <etiquette_2> : <instructions_2>
...
case <etiquette_n> : <instructions_n>
default : <instructions_def>
}
I
Une expression est de type entier (ou caractre).
Une tiquette est de type entier (ou caractre) qui peut tre une
constante explicite ou construite partir doprateurs (logiques,
logiques bit bit, arithmtiques, relationnels, conditionnel)
Septembre 2013
32 / 123
Langage C : Bases
Instructions
Instructions de contrle : switch (suite)
Lexpression est value et compare aux tiquettes
Sil y a galit avec une tiquette i, alors les instructions

instructions_i . . . instructions_n et instructions_d sont
excutes.
Si pas dgalit dtiquette alors on excute instructions_d.
Possibilit de grouper plusieurs entres :

case <etiquette_1> :
case <etiquette_2> : <instructions_12>;
Septembre 2013
33 / 123
Langage C : Bases
Instructions
Instructions de droutement : break
Permet de sortir dune boucle avant terme
Trs utilis avec switch

for (i=0; i<5; i++)
{
...
if (i==limite) break;
Exemples :
...
}
switch(i) {
{
case 0 :
printf("bonjour");
break;
case 1 :
...
}
Septembre 2013
34 / 123
Langage C : Bases
Instructions
Instructions de droutement : continue
Permet de passer au dbut de litration suivante dans une boucle.
Jamais dans un switch !
La condition de boucle sera immdiatement teste aprs continue .
Exemples :
for (i=0; i<5; i++)
{
if (i==3) continue;
printf("%d\n",i);
}
Septembre 2013
35 / 123
Langage C : Bases
Instructions
Instructions itratives : for

for (<pre-actions> ; <conditions> ; <post-actions>)
<corps de boucle>
I
pre-actions : effectues une seule fois au dbut de la boucle. En

gnral, initialisation de variable.
conditions : conditions de poursuite de boucle.
post-actions : effectues la fin de chaque itration.
corp de boucle : une seule instruction ou un ensemble dinstuctions

{...}.
Les pr-actions, les conditions et les post-actions sont facultatives.
Si plusieurs pr-actions, conditions ou post-actions : sparation par

une virgule.
Septembre 2013
36 / 123
Langage C : Bases
Instructions
Instructions itratives : for (suite)

I
Les pr-actions peuvent tre :

I
I
I
une valeure numrique

une expression
une valeur retourne par une fonction
Si pas de condition, boucle infinie (test=1).
Si plusieurs conditions "ET logique" des conditions.
Imbrication de boucles for possible

for ( ; ; );
for ( ; ; )
for ( ; ; )
for ( ; ; );
for ( ; ; )
for ( ; ; )
{
{
...
...
}
}
for ( ; ; )
for ( ; ; )
for ( ; ; );
{
...
}
Septembre 2013
37 / 123
Langage C : Bases
Instructions
Instructions itratives : while
while (<conditions>)
<corps de boucle>
I
corps de boucle : une seule instruction ou un ensemble

dinstuctions {...}.
Si condition vraie (6= 0) alors on excute le corps de boucle.
Le corps de la boucle peut ne jamais tre excut !
La condition peut tre une expression daffectation :

while (reste=dividende%diviseur)
Imbrication de boucles while possible
Septembre 2013
38 / 123
Langage C : Bases
Instructions
Instructions itratives : do-while
do
<corps de boucle>
while (<conditions>);
I
corps de boucle : une seule instruction ou un ensemble

dinstuctions {...}.
Le corps de la boucle est excut au moins une fois.
while (condition) ; peut tre la fin dun do-while ou un while sans

corps Prfrer un while (condition) {};
Septembre 2013
39 / 123
Langage C : Bases
Instructions
Exercice-2 : Donner la valeur des variables aprs excution

I
int i;
int S=0;
for (i=0; i<6; i++)
{
S+=i;
if (S>12) break;
}
int S=1;
while (S<12)
{
S=2*S+1;
}
int S=15;
do
{
S=2*S+1;
}while (S<12)
int A=3;
int B=5;
if (B>A) A=2*A;
else B=2*B;
double X=0.5;
int A;
if (X>0 && X<0.2) A=1;
else if (X<0.4) A=2;
else if (X<0.8) A=3;
else A=4;
Septembre 2013
40 / 123
Dfinition
Paramtres
Exemples
Rcursivit
Les fonctions
Septembre 2013
41 / 123
Les fonctions
Prsentation
Une fonction permet de "modulariser" un programme en le dcoupant

en actions simples :
programmation structure
compilation spare, cration de bibliothques
Traitement de donnes :
I
I
I
locales,
globales,
passes par des paramtres formels.
En C, que des fonctions !
La fonction main est la fonction principale
Septembre 2013
42 / 123
Les fonctions
Dfinition
<type du resultat> nom_fonction (<declaration arguments>)
{
<corps de la fonction>
}
I
La premire ligne termine par un " ;" est une dclaration.
Rsultat peut tre un type (int, char, . . . ) ou void ("vide")
Exemples :
double Pi()
{
...
}
int calcul(int valeur)

{
...
}
void Rien()
{}
Septembre 2013
43 / 123
Les fonctions
Paramtres
Les paramtres ou arguments sont dclars la suite, spars par une

virgule, avec le type de chacun prcdant le nom (pas obligatoire lors
de la dclaration).
Le stockage des arguments se fait dans la pile.
Linstruction return permet de quitter une fonction et de renvoyer un

rsultat si souhait :
return; pour une fonction de type void (pas indispensable)
return <expression> ; dans les autres cas
Pas dimbrications de fonction possible toutes surs.
Pas de dclaration de fonction dans une autre fonction.
Septembre 2013
44 / 123
Les fonctions
Passage de paramtres et appels de fonction

I
Deux types de passage de paramtres :

- par valeur : lappel de la fonction, une copie de la valeur de
largument est passe la fonction pas de modification de
largument initial
- par adresse : la fonction utilise largument car cest ladresse qui est
passe la fonction appele utilisation de pointeurs.
Les tableaux sont toujours passs par adresse.
Choix libre du passage pour les autres variables.
Lappel de fonction peut constituer une instruction simple ou tre

utilise dans une expression.
Parenthses obligatoires lors de lappel mme si pas dargument.
Une fonction appele doit tre dclare ou dfinie avant son appel.
Septembre 2013
45 / 123
Les fonctions
Exemples
int f1(char b)
{
...
}
int main(void)
{
int i;
i = f1(c);
}
int f1(char);
int f2(double b)
{
int i;
i = f1(c);
}
int f1(char b)
{
...
}
int main(void)
{ ... }
Septembre 2013
46 / 123
Rcursivit
Principe
I
Une fonction rcursive est une fonction qui sappelle elle-mme.
Lors de lexcution, il y a une phase de descente et une phase de

remonte
La phase de descente se termine par une condition terminale
La phase de remonte se termine par la fin de la rcursion
Formellement, cela correspond la dfinition dune fonction

mathmatique itrative avec condition initiale
Exemple : Calcul de factorielle : n! = n (n 1) (n 2)...3 2 1

1
si n = 0 ou n = 1
F (n) =
nF (n 1) si n > 1
Septembre 2013
47 / 123
Rcursivit
Exemple
Sans rcursivit :
long int factorielle(int n)
{
long int Facto=1;
int i;
for (i=1;i<=N;i++)
Facto = Facto*i;
return Facto;
}
Septembre 2013
48 / 123
Rcursivit
Exemple
De manire rcursive : Facto(n)=n*Facto(n-1) avec F(0)=1

long int factorielle(int n)
{
if (N==0)
return 1;
else
return N*factorielle(N-1);
}
Septembre 2013
49 / 123
Rcursivit
Simulation dexcution rcursive

I
Prenons lexemple du calcul de 4!
Phase de descente :
F(4)=4.F(3)
F(3)=3.F(2)
F(2)=2.F(1)
F(1)=1 (condition terminale)
Phase de monte :
F(2)=(2).(1)
F(3)=(3).(2)
F(4)=(4).(6)
24 (fin de la rcursion)
F (4) = 4! = 24
Septembre 2013
50 / 123
Accs par caractre.
Formates.
Accs par ligne.
Fichier.
Pour avoir accs aux entres/sorties, il faut utiliser la bibliothque

stdio.h laide de la directive : #include <stdio.h>
Septembre 2013
51 / 123
Accs par caractre ou standard
Trois flux standards en C : stdin (entre), stdout (sortie) et stderr

(sortie erreur).
int getchar(void) : lecture dun seul caractre sur lentre

standard.
int getc(<flux dentre>) : idem getchar() dans le flux spcifi.
La saisie est valide par validation avec la touche "entre".
int putchar(int) : criture dun seul caractre sur la sortie

standard.
int putc(int, <flux de sortie>) : idem putchar() dans le flux

spcifi.
Septembre 2013
52 / 123
Formates ou mises en formes (1)
int printf(char *format, <arguments>)

int * sprintf(char *chaine, char *format, <arguments>)
I
Met en forme des arguments (optionnels) et les envoie vers la sortie

standard (printf) ou vers une chane de caractre (sprintf).
La chane de caractres "char *format" contrle laffichage
Conversion spcifie par % suivi dun caractre : c (caractre), d ou i

(int dcimal), s (chane de caractres), f (double), x (int hexadcimal).
Septembre 2013
53 / 123
Formates ou mises en formes (2)

int scanf(char *format, <arguments>)
int * sscanf(char *chaine, char *format, <arguments>)
I
Lit des donnes dont le nombre et le type sont spcifis dans la chane
format.
Pour sscanf(), les donnes sont lues partir dune chane.
Stockage des donnes lues dans les arguments.
Conversion spcifie par % suivi dun caractre : c (caractre), d ou i

(int dcimal), s (chane de caractres), f (double), x (int hexadcimal).
La conversion sarrte ds quil y a un sparateur implicite (espace,

tabulation, interligne) ou explicite (prcis dans le format), un
caractre incompatible avec un type du format.
Les arguments sont des paramtres de sortie Passage par adresse !
Septembre 2013
54 / 123
Accs par ligne
char * gets(char * Ligne) : lit une chane de caractres sur

lentre standard et la range en mmoire dans le tableau de caractres
partir de ladresse Ligne en ajoutant \0 et supprimant \n.
int puts(char * Ligne) : affiche la chane de caractres Ligne sur

la sortie standard (retour chariot ajout automatiquement ici).
Septembre 2013
55 / 123
Fichier (1)
Pour traiter les donnes contenues dans un fichier, fonctions de

manipulation.
FILE * fopen(char * nomfic, char * mode) : ouverture dun

fichier
Renvoi ladresse dune structure de type FILE qui sera accessible

suivant le mode spcifi en paramtre ("r", "w")
Association du fichier un tampon (bloc mmoire) par un flux
int fclose(FILE * pfic) : fermeture dun fichier
Transfert du contenu du tampon sur le disque
Septembre 2013
56 / 123
Fichier (2)
I
Les entres-sorties par caractre sont effectues avec les mmes

primitives que prcdemment avec comme flux dentre FILE * :
int getc(FILE *)
int putc(char, FILE *)
Les entres-sorties formates sont effectues avec les primitives

fprintf et fscanf qui sont drives respectivement de sprintf et
sscanf :
int fprintf(FILE *pfic, char * format, <arguments>)
int fscanf(FILE * pfic, char * format, <arguments>)
Les entres-sorties par ligne sont effectues comme gets et puts avec
les fonctions fgets et fputs :
char * fgets(char * Ligne, int Max, FILE * pfic)
int fputs(char * Ligne, FILE * pfic)
Septembre 2013
57 / 123
Dfinition.
De caractres.
Multidimensionnels.
Les tableaux
Septembre 2013
58 / 123
Les tableaux
Dfinition
Collection de variables de mme type ranges conscutivement en

mmoire, sans trou.
Premier indice du tableau est toujours 0.
Dclaration comme une variable mais taille en plus :

type_elements_contenus identificateur[nombre_elements];
Initialisation possible lors de la dclaration avec des accolades.
Chaque lment est indic par une valeur entire.
Remarque : pas de dtection de dbordement de tableau par le

compilateur !
Septembre 2013
59 / 123
Les tableaux
Chane de caractres
Une chane de caractres nexiste pas en C : utilisation dun tableau de

caractres
Dernier lment est le caractre null (\0)
Initialisation caractre par caractre ou globalement
char chaine[10] = "UPS"; nest possible qu la dfinition
char chaine[10] = {U,P,S}; idem ci-dessus
Il y aura ici 4 caractres dans la chane.
char chaine[10]; chaine = "UPS"; est impossible ! !
Septembre 2013
60 / 123
Les tableaux
Tableaux multi-dimensionnels
Tableaux plusieurs dimensions Tableaux de tableaux de . . .
Tableau 2 dimensions (matrice) :

type identificateur[nb_ligne][nb_colonne] ;
Accession aux lments en donnant un indice par dimension.
int matrice[2][3]={{1,2,3},{4,5,6}} avec 1 dans la case (0,0)
Septembre 2013
61 / 123
Principes.
Pointeurs et tableaux.
Tableaux de pointeurs.
Pointeurs et fonctions.
Indirections multiples.
Allocation dynamique.
Les pointeurs
Septembre 2013
62 / 123
Les pointeurs
Principes
I
Un pointeur est une variable qui contient ladresse dune autre variable.
Dclaration dun pointeur : <type> * pointeur

Ex : int * pointeur est un pointeur sur entier.
Ladresse dune variable est obtenue laide de loprateur unaire &.
Lobjet sur lequel pointe un pointeur est obtenu avec loprateur

unaire * : * pointeur;
int * p_entier;
int pointee;
int largeur;
p_entier=&pointee;
largeur=*p_entier;
Septembre 2013
63 / 123
Les pointeurs
Pointeurs et tableaux
int tableau[7];
int * p_jour;
I
Le nom tableau est ladresse du 1er lment du tableau

(&tableau[0])
Lopration suivante est correcte : p_jour = tableau;
Le pointeur peut tre utilis pour se dplacer dans le tableau :

*(p_jour+4) est le 5 lment du tableau soit tableau[4]
Que fait lopration suivante ? : p_jour=tableau+4
Une chane de caractres est un tableau (de caractres) donc son nom
est ladresse du premier caractre.
Septembre 2013
64 / 123
Les pointeurs
Tableaux de pointeurs
type_pointe * Nom_tableau[taille_tableau];
I
Un tableau de pointeur contient des pointeurs vers des variables du

type spcifi.
Nom_tableau est un tableau de taille_tableau pointeurs sur

type_pointe.
Nom_tableau est ladresse du premier lment du tableau.
Nom_tableau est ladresse dun pointeur.
Un tableau de chanes de caractres est un tableau de longueur

automatiquement ajuste.
char * journee[] = {"matin","midi","apres-midi","soir"};
Septembre 2013
65 / 123
Les pointeurs
Pointeurs et fonctions
I
Passage des arguments de fonctions par adresse
Pour les tableaux, quivalence entre [] et * en tant que paramtres

formels :
void fonction1(int vecteur[])
void fonction2(int * vecteur)
Pour les scalaires :

void fonction3(double * valeur) {
*valeur +=2.0;
}
int main() {
double reel=0.0;
fonction3(&reel);
return 0;
}
Septembre 2013
66 / 123
Les pointeurs
Indirections multiples
I
On parle dindirections multiple lorsquon a des pointeurs de pointeurs

de ...
Indirection simple pointeur
Indirection double pointeur de pointeur
Exemple :
int un_entier;
int * p_sur_entier;
int ** p_sur_p_sur_entier;
p_sur_p_sur_entier est un pointeur sur un pointeur
p_sur_p_sur_entier = &un_entier cest faux !
Septembre 2013
67 / 123
Les pointeurs
Allocation mmoire
I
La dclaration dun pointeur provoque la rservation mmoire pour le

pointeur mais pas pour la variable sur laquelle il pointe !
Lallocation mmoire pour la variable seffectue au moment de

laffectation sauf sauf pour les tableaux !
Possibilit dallocation dynamique avec les fonctions malloc et

calloc
void * malloc(int taille) : provoque la rservation mmoire de

taille octets contigus.
void * calloc(int nb, int taille) : provoque la rservation

dun tableau de nb lments de taille octets.
Libration de la mmoire avec la fonction free.
Septembre 2013
68 / 123
Les pointeurs
Pointeurs gnriques
Le langage C ne permet pas daffecter des pointeurs de types diffrents
Possibilit de crer des fonctions indpendamment du types des

paramtres
pointeurs gnriques de type void *
Problme car on ne peut accder au contenu avec loprateur *
Utilisation de la fonction memcpy() pour copier le contenu dun

variable pointe vers une autre :
void *memcpy(void * pa, void * pb, unsigned int taille)
On copie "taille" octets de adresse "pb" vers adresse "pa"
Pour obtenir la taille : fonction sizeof()
Septembre 2013
69 / 123
Les pointeurs
Pointeurs gnriques : exemple

Une fonction qui permute nimporte quel type de valeurs
void permuter(void* pa, void* pb, unsigned int taille)
{
void * pc;
pc = malloc(taille);
memcpy(pc,pa, taille);
memcpy(pa,pb,taille);
memcpy(pb,pc,taille);
free(pc);
}
Septembre 2013
70 / 123
Les pointeurs
Pointeurs gnriques : exemple
Elle pourra tre utiliser ainsi :

int ia=4,ib=5;
float fa=2.1,fb=1.2;
permuter(&ia,&ib,sizeof(ia));
permuter(&fa,&fb,sizeof(fa));
Septembre 2013
71 / 123
Les pointeurs
Exercice-3 : Que donne lcran ces excutions ?

I
#include <stdio.h>
/*-------------------------*/
int main()
{
float x;
float* px;
x=0.5;
px=&x;
x/=2.0;
printf("%f
return 0;
}
%f
\n",x,*px);
Septembre 2013
72 / 123
Les pointeurs
#include <stdio.h>
#include <stdlib.h> /* pour malloc() */
/*-------------------------*/
int main()
{
float x;
float* px;
/* reserve memoire pour un float */
px=(float*) malloc(sizeof(float));
x=0.5;
*px=x;
x/=2.0;
printf("%f %f \n",x,*px);
free(px); /* libere memoire */
return 0;
}
Septembre 2013
73 / 123
Les pointeurs
#include <stdio.h>
/*-------------------------*/
int main()
{
float x;
float y;
float* p;
x=0.5;
y=0.3;
p=&x;
*p+=y;
p=&y;
*p-=x;
printf("%f
return 0;
}
%f
\n",x,y);
Septembre 2013
74 / 123
Les pointeurs
#include <stdio.h>
/*-------------------------*/
int main()
{
int tab[4]={4,3,2,1};
int* p;
int i;
p=tab;
(*p)++;
p++;
*(p+2)=5;
(*p)+=2;
for (i=0; i<4; i++) printf("%d ",tab[i]);
printf("\n");
return 0;
}
Septembre 2013
75 / 123
Les pointeurs
I
I
#include <stdio.h>
void f1(int a, int b)
{ a=b; }
void f2(int* a, int* b)
{ *a=*b; }
void f3(int a, int* b)
{ a=*b; }
void f4(int* a, int b)
{ *a=b; }
int main()
{
int n1=5, n2=7, n3=9;
f1(n1,n2);
printf("%d %d
f2(&n1,&n2);
printf("%d %d
f3(n2,&n3);
printf("%d %d
f4(&n2,n3);
printf("%d %d
%d\n",n1,n2,n3);
%d\n",n1,n2,n3);
%d\n",n1,n2,n3);
%d\n",n1,n2,n3);
return 0;
}
Septembre 2013
76 / 123
Les pointeurs
#include <stdio.h>
/*-------------------------*/
int main()
{
int i=0,j;
j=++i;
printf("%d %d\n",i,j);
j=i++;
printf("%d %d\n",i,j);
return 0;
}
Septembre 2013
77 / 123
Principes.
Utilisation.
Pointeurs et structure.
Les structures
Septembre 2013
78 / 123
Les structures
Principes
I
Structure de donnes avec plusieurs champs de types diffrents
Dclaration dune structure :

struct <etiquette>
{
/* corps de la structure */
};
Dclaration dune variable dont le type est une structure :

struct <etiquette> a;
Une structure est compose de champs :
struct Personne
{ char nom[15];
char prenom[15];
int age;
};
Septembre 2013
79 / 123
Les structures
Manipulations
I
Accession un champ dune structure par le . (point) :

struct Personne etudiant1;
etudiant1.age = 19;
Pour affecter une chane de caractres, utilisation de strcpy :

strcpy(etudiant1.nom,"Ekins");
strcpy(etudiant1.prenom,"Bud");
Possibilit dinitialiser lors de la dfinition :

struct Personne etudiant1 = {"Ekins","Bud",19};
Affectation directe de deux structures de mme type :

struct Personne etudiant1,etudiant2;
etudiant2=etudiant1;
Septembre 2013
80 / 123
Les structures
Imbrication
I
Les structures peuvent tre imbriques.

struct Identification
{
int numero;
struct Personne Etudiants;
}
Accession aux champs laide du point ou globalement :

struct Identification un_etudiant;
un_etudiant.numero = 24056012;
un_etudiant.Etudiants = etudiant1;
strcpy(un_etudiant.Etudiants.nom, "Durand");
un_etudiant.Etudiants.age = 20;
Septembre 2013
81 / 123
Les structures
Structures et pointeurs
Lors de lappel de fonction avec une structure en paramtre, il est

prfrable de passer ladresse plutt que les valeurs pour un souci
dconomie de mmoire.
Dclaration : struct Identification * p_structure;
Accs aux champs par loprateur ->

p_structure = &un_etudiant;
p_structure->numero=150;
(*p_structure).numero=150;
strcpy(p_structure->Etudiants.nom,"Dupont");
Septembre 2013
82 / 123
Les structures
Tableaux de structure
Tableaux dont les lments sont des structures identiques.
struct Identification classe[21];
classe est ladresse de la premire structure du tableau.
classe[1].numero = 121;
strcpy(classe[1].Etudiants.nom, "toto");
Septembre 2013
83 / 123
Les unions
Principes de lUnion
Structure de donnes avec plusieurs champs de types diffrents
Un seul espace mmoire pour lunion
Un seul membre dune variable de type union contient une valeur un

instant donn
Le programmeur doit savoir dans quel membre a t rang une valeur :

Association dune variable lunion
Utilisation conjointe avec une structure afin de pouvoir indiquer le

champ de lunion utilis
Septembre 2013
84 / 123
Les unions
Manipulations
I
Dclaration dune union :

union <etiquette>
{
/* corps de lunion */
/* compos de champs */
/* comme une structure */
};
Dclaration dune variable dont le type est une union :

union <etiquette> u;
Affectation par le biais du champ :

u.champ=valeur;
Septembre 2013
85 / 123
Les unions
Manipulations avec une structure

I
Dclaration dun type pour indiquer le champ manipul :

enum quel_champ {champ_1,champ_2,...,champ_n};
Dclaration de la structure contenant une union :

struct <etiquette_struct>
{
enum quel_champ le_champ;
union <etiquette> u;
};
Dclaration dune variable dont le type est une structure :

struct <etiquette_struct> <identificateur_var>;
Affectation par le biais des champs de la structure :

<identificateur_var>.u.champ=valeur;
<identificateur_var>.le_champ=champ_x;
Septembre 2013
86 / 123
Les unions
Exemple
union nombre
{ int i;
float f;
};
enum type {Entier,Flottant};
struct calcul
{
enum type type_val;
union nombre u;
};
struct calcul n;
n.typ_val=Entier;
n.u.i=10;
Septembre 2013
87 / 123
Piles.
Files.
Listes.
Septembre 2013
88 / 123
Piles
Piles : dfinition
I
Une pile est un ensemble de donnes auxquelles on accde dans lordre

inverse o elles sont insres : Last Input First Output, LIFO.
Seul le sommet de la pile est accessible.

Trois oprations sur une pile :
I
I
empiler lment : rajoute un lment sur la pile ;

dpiler lment : renvoie la valeur de llment au sommet de la pile et
le supprime ;
vide : renvoie VRAI si et seulement si la pile est vide.
Utilisation dune pile (1) : gestion des appels et retours de fonctions.
Utilisation dune pile (2) : passage des paramtres une fonction ou

stockage des variables locales.
Implmentation simple par tableau ; liste chane possible.
Septembre 2013
89 / 123
Piles
Piles : Exemple dutilisation
Calcul en notation polonaise inverse (chaque oprateur vient aprs

son dernier argument)
Forme postfixe donc pas de parenthse
Soit lopration :
la liste suivante reprsente cette opration :

{(, 4, +, 2, *, sqrt, (, 16, ), ), /, 6}
sous forme polonaise inverse : {4, 2, 16, sqrt, *, +, 6, /}
Un algorithme peut tre...
4+2 16
6
Septembre 2013
90 / 123
Piles
Piles : Exemple dutilisation

pour chaque lment=valeur
si lment=valeur
empiler(valeur)
si lment=oprateur unaire
opration=lment
rsultat=opration(dpiler)
empiler(rsultat)
si lment=oprateur binaire
opration=lment
oprande1=dpiler
oprande2=dpiler
rsultat=opration(oprande1,oprande2)
empiler(rsultat)
Septembre 2013
91 / 123
Files
Files
Une file est un ensemble de donnes qui sont ajoutes en queue de file
et supprimes en tte : First Input First Output, FIFO.
Trois oprations sur une file :
I
I
empiler lment : rajoute un lment en queue de la file ;

dpiler lment : renvoie la valeur de llment en tte de la file et le
supprime ;
vide : renvoie VRAI si et seulement si la file est vide.
Utilisation dune file : applications pilotes par des vnements.
Utiles pour simuler des files dattente.
Septembre 2013
92 / 123
Listes
Listes
I
Une liste est un ensemble fini dlments ordonns not

L = e1 , e2 , ..., en
Utilises pour grer des ensembles de donnes.
Efficaces pour des oprations dinsertion et de suppression dlments.
Manipulation de lallocation dynamique car taille variable en cours

dexcution.
Oprations effectues lment par lment.

Trois types de listes :
I
I
I
simplement chanes
doublement chanes
circulaires
Septembre 2013
93 / 123
Listes
Oprations sur une liste
Crer une liste
Supprimer une liste
Rechercher un lment particulier
Insrer un lment
Supprimer un lment particulier
Permuter deux lments
Concatner deux listes
etc.
Septembre 2013
94 / 123
Listes
Listes simplement chanes(1)
I
I
Liaison entre les diffrents lments par un simple pointeur

Chaque lment est form de 2 parties :
1. un champ contenant une donne ou un pointeur vers une donne
2. un pointeur vers llment suivant de la liste
Le premier lment est la tte.
Le dernier lment est la queue.
Le dernier lment est initialis une valeur fixe : NULL en C.
Septembre 2013
95 / 123
Listes
Listes simplement chanes(2)

I
Sens unique : Accs un lment en parcourant la liste de la tte vers

la queue.
Elments crs par allocation dynamique donc pas contigus en

mmoire.
La suppression dun lment sans prcaution ne permet plus daccder

aux lments suivants
struct s_element
{
int donnee;
struct s_element* suivant;
};
typedef struct s_element t_element;
Septembre 2013
96 / 123
Listes
Listes doublement chanes

I
I
Liaison entre les diffrents lments par deux pointeurs

Chaque lment est form de 3 parties :
1. un champ contenant une donne ou un pointeur vers une donne,
2. un pointeur vers llment suivant de la liste,
3. un pointeur vers llment prcdent de la liste.
struct s_element
{
int donnee;
struct s_element* suivant;
struct s_element* precedent;
};
typedef struct s_element t_element;
Septembre 2013
97 / 123
Listes
Listes circulaires
Liaison entre les diffrents lments par un seul pointeur.
Pas de queue !
Chaque lment est form de 2 ou 3 parties :
1. un champ contenant une donne ou un pointeur vers une donne,

2. un pointeur vers llment suivant de la liste,
3. un pointeur vers llment prcdent de la liste, si doublement chane.
Septembre 2013
98 / 123
Listes
Oprations sur une liste (1) : Insertion
Insertion peut se faire :

I
I
I
en tte
en queue
nimporte o
Oprations effectuer dans lordre :

I
I
I
allouer de la mmoire pour le nouvel lment

copier les donnes
faire pointer le nouvel lment ves le suivant de celui point par courant
Septembre 2013
99 / 123
Listes
Insertion : Exemple dimplmentation
void insertion(t_element** tete, t_element* courant, int data)

{
t_element* nouveau;
nouveau=(t_element*) malloc(sizeof(t_element));
nouveau->donnee=data;
if (courant!=NULL)
{
nouveau->suivant=courant->suivant;
courant->suivant=nouveau;
}
else /* insertion en tete ou liste vide*/
{
nouveau->suivant=*tete;
*tete=nouveau;
}
}
Septembre 2013
100 / 123
Listes
Oprations sur une liste (1) : Suppression
Oprations effectuer dans lordre :

I
I
I
I
I
I
rcuprer le pointeur de tte par adresse pour pouvoir le modifier si la

suppression rend la liste vide ou si llment supprimer tait le
premier de la liste.
distinguer sil sagit du premier lment
dans ce cas, chercher le prcdent de courant
et rcuprer le lien contenu dans le champ "suivant" de llment
supprimer
sinon modifier le pointeur de tte.
librer la mmoire !
Septembre 2013
101 / 123
Listes
Suppression : Exemple dimplmentation

void suppression(t_element** tete, t_element* courant)
{
t_element* precedent;
precedent=(t_element*) malloc(sizeof(t_element));
if (courant!=*tete) /* pas le premier element */
{
precedent=*tete;
while (precedent->suivant!=courant)
precedent=precedent->suivant;
precedent->suivant=courant->suivant;
}
else /* suppression du premier element*/
*tete=courant->suivant;
free(courant);
}
Septembre 2013
102 / 123
Listes
Suppression : Exemple dutilisation(1)

int main()
{
t_element* tete=NULL;
t_element* courant=NULL;
/* insertion du premier element : liste=1 */
insertion(&tete,courant,1);
/* deuxieme insertion : liste=1 2 */
courant=tete;
/* troisieme insertion : liste=1 2 3*/
courant=courant->suivant;
...
Septembre 2013
103 / 123
Listes
Suppression : Exemple dutilisation (2)

/* courant pointe sur 2 : liste = 1 2 4 3 */
/* insertion en tete : liste = 5 1 2 4 3 */
insertion(&tete,NULL,5);
/* suppression de llment 1 : liste = 5 2 4 3 */
courant=tete->suivant;
suppression(&tete,courant);
/* suppression de la tete : liste = 2 4 3 */
courant=tete;
suppression(&tete,courant);
return 0;
}
Septembre 2013
104 / 123
Algorithmes de tri
Tri par slection.
Tri par insertion.
Tri rapide
Tri bulles.
Septembre 2013
105 / 123
Algorithmes de tri
Tri par slection
Principe
I
Tri basique trs lent dun ensemble de n valeurs (ici tri croissant)
I
I
I
I
I
Soit un ensemble de n lments indics de 0 (n-1)

On suppose les m premiers lments tris : 0 (m-1)
On cherche la position k du plus petit lment parmi les lments
restant trier indics de m (n-1)
On le permute avec llment m : ensemble tri de 0 m
On parcourt donc lensemble de m=0 (n-2), ce qui fait que lorsque
m=n-2, on compare avec la dernire valeur lindice (n-1)
18
2
2
Exemple
2
2
2
10
10
3
3
3
3
3
3
10
9
9
9
25
25
25
25
10
10
9
9
9
10
25
18
2
18
18
18
18
25
Septembre 2013
106 / 123
Algorithmes de tri
Tri par slection
Algorithme
I
I
Manipulation de tableau de n valeurs

Trier (Tab)
1. for i = 0 to (n-2) do
2.
imin = Rechercher_min(Tab, i, n)
3.
if (imin != i) then
4.
Permuter(Tab[imin],Tab[i])
end
Rechercher_min (Tab, pos, taille)
1. min = pos
2. val_min = Tab[pos]
3. for i = pos to (n-2) do
4.
if (val_min>Tab[i+1]) then
5.
val_min = Tab[i+1]
6.
min = i+1
end
Permuter(...)
Septembre 2013
107 / 123
Algorithmes de tri
Tri par insertion
Principe
Tri trs rapide sur de petits ensembles de valeurs

I
I
I

On prend 2 lments et on les met dans lordre
On prend un 3 lment quon insre entre les 2 lments dj tris et
ainsi de suite
Un lment dindice pos va tre insr dans lensemble des lments
tris de 0 (pos-1)
Il faut donc chercher llment de valeur immdiatement suprieure ou
gale celle de llment insrer
Si k est lindice de cet lment alors on dcale les lments k (pos-1)
vers (k+1) pos
Llment insrer est plac en position k
Septembre 2013
108 / 123
Algorithmes de tri
Tri par insertion
Exemple
18
18
10
10
10
3
3
3
3
3
3
3
3
3
3
3
2
10
18
18
18
10
10
10
10
10
10
9
9
9
9
9
3
3
3
3
3
18
18
18
18
18
18
10
10
10
10
10
9
9
9
25
25
25
25
25
25
25
25
18
18
18
18
18
10
10
10
10
9
9
9
9
9
9
9
25
25
25
25
25
18
18
18
18
18
2
2
2
2
2
2
2
2
2
2
2
25
25
25
25
25
25
Septembre 2013
109 / 123
Algorithmes de tri
Tri par insertion
Algorithme
I
I
Manipulation de tableau de n valeurs

Trier (Tab)
1. for i = 1 to (n-1) do
2.
Inserer(Tab, i, Tab[i])
end
Inserer (Tab, pos, valeur)
1. i = pos - 1
2. while (i 0 and Tab[i] > valeur) do
3.
Tab[i+1] = Tab[i]
4.
i=i-1
5. Tab[i+1] = valeur
end
Septembre 2013
110 / 123
Algorithmes de tri
Tri rapide
Principe
Le meilleur tri sur des ensembles de valeurs moyens grands

I
I

Nous divisons cet ensemble en 2 sous-ensembles autour dune valeur
"pivot"
Nous choisissons la valeur pivot en prenant soit une valeur alatoire
soit la valeur mdiane de 3 valeurs alatoires de lensemble
Septembre 2013
111 / 123
Algorithmes de tri
Tri rapide
Exemple
24
24
11
11
52
14
14
14
11
11
24
24
94
28
28
28
28
94
36
36
36
36
52
52
14
52
94
80
80
80
80
94
partition donne pivot = 3

tableau tri
Septembre 2013
112 / 123
Algorithmes de tri
Tri rapide
Algorithme
I
I
Manipulation de tableau de n valeurs en utilisant la rcursivit

Trier (Tab, gauche, droite)
1. if (gauche < droite) then //fin rcursivit
2.
pivot = Partitionner(Tab, gauche, droite) // partition en 2
3.
Trier(Tab, gauche, pivot-1) // tri de la 1 partie
4.
Trier(Tab, pivot+1, droite) // tri de la 2 partie
end
Partitionner (Tab, gauche, droite)
1. pivot = Choisir_pivot(Tab[gauche], Tab[droite]) // plusieurs manires
2. memo = gauche
3. for i = gauche to (droite-1) do
4.
if (Tab[i] Tab[pivot]) then // si llment est infrieur au pivot
5.
memo = memo + 1 // on incrmente le compteur
6.
// on place llment la position finale du pivot
Permuter (Tab[i], Tab[memo])
7. Permuter (Tab[memo], Tab[droite]) // on place le pivot sa place
8. return memo // on renvoie la position finale du pivot
end
Septembre 2013
113 / 123
Algorithmes de tri
Tri bulles
Principe
Soit trier un tableau de N lments
Il faut parcourir les lments de lensemble de i=0 N-1 en

permuttant les lments conscutifs non ordonns.
On recommence de i=0 N-2 et ainsi de suite
Si pas de permutation alors ensemble tri
Septembre 2013
114 / 123
Algorithmes de tri
Tri bulles
Exemple
18
10
10
10
10
10
3
3
3
3
3
3
3
3
3
2
10
18
3
3
3
3
10
10
10
10
10
9
9
9
2
3
3
3
18
18
18
18
18
18
9
9
9
10
2
2
9
9
25
25
25
25
9
9
9
9
18
2
2
2
10
10
10
10
9
9
9
9
25
2
2
2
2
18
18
18
18
18
18
18
2
2
2
2
2
25
25
25
25
25
25
25
25
25
25
25
Le curseur i est positionn sur le 1er

lment et on le compare
llment repr en (i+1). Ici, on
compare donc 18 avec 10 et on
inverse suivant lordre (croissant ou
dcroissant) voulu.
Septembre 2013
115 / 123
Algorithmes de tri
Tri bulles
Algorithme
I
I
Manipulation de tableau de N valeurs

Trier (Tab)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
n=N
permutation = FAUX
do
for i = 0 to (n-2) do
if (Tab[i] > Tab[i+1])
Permuter (Tab[i], Tab[i+1])
permutation = VRAI
if (n > 0) do
n = n-1
while (permutation = VRAI)
end
Septembre 2013
116 / 123
Prprocesseur
Lors de chaque compilation, le compilateur C fait appel lors du

premier passage au prprocesseur
Le prprocesseur est un traitement spcialis qui permet
I
I
I
la macro-substitution
linclusion de fichiers
la compilation conditionnelle
Le prprocesseur nobit quaux lignes de commande commennt par

le caractre #, qui doit tre plac en premire colonne
Septembre 2013
117 / 123
La macro-substitution(1)
Permet de remplacer dans le texte du fichier, un identificateur (mot,

oprateur, symbole, ...) par un texte de substitution
#define identificateur texte_de_substitution
#define TAILLE 10
Utilisation des majuscules pour les constantes
Allgement du programme
Si le texte de substitution scrit sur plus dune ligne alors utiliser le

caractre \
#define TROG_LONG "attention! cette phrase est trop \
longue pour tenir sur une seule ligne"
Septembre 2013
118 / 123
La macro-substitution(2)
Possibilit de dfinir des macro-instructions

#define CUBE(X) X*X*X
int puiss3, val=4;
puiss3 = CUBE(val);
dans le cadre dexpressions numriques, utiliser les parenthses autour

de lexpression et de chaque arguments :
#define CUBE(X) ((X)*(X)*(X))
dans le cas dinstructions, utiliser des accolades autour de lexpression

#define ERREUR(num) {printf("\nErreur %d\n", (num));}
Septembre 2013
119 / 123
Le prprocesseur
Inclusion de fichiers :
I
Le contenu dun fichier texte peut tre insr dans un autre fichier
grce la directive include
les fichiers inclus contiennent en gnral des dclarations de fonctions,

de types, de constantes : leur suffixe est .h
Un grand nombre des fichiers standards se trouvent dans

/usr/include
Leur inclusion seffectue avec des chevrons "<,>" ainsi :

#include <stdio.h>
Linclusion de fichiers crs par lutilisateur se fait avec des

guillemets : #include "ma-biblio.h"
Septembre 2013
120 / 123
Compilation conditionnelle
I
Il est possible de choisir des parties de programme source qui seront

compiles ou pas dans le programme objet selon les valeurs prises par
des expressions constantes.
Directives pour la compilation conditionnelle :

if else endif ifdef ifndef elif
Exemple :
#ifndef TAILLE
#define TAILLE 100
#endif
Problme des inclusions multiples : lorsquun fichier est inclus, faire en

sorte quil le soit bien une seule fois.
Septembre 2013
121 / 123
Construction dun fichier ".h"
Une bonne manire de construire les fichiers den-tte .h :

#ifndef MA-BIBLIO_H
#define MA-BIBLIO_H
struct S{
int i;
int j;
};
void mafonction(void);
#endif
Septembre 2013
122 / 123
Paramtres de ligne de commande
Possibilit de passer des arguments (paramtres) lexcution dun

programme : le_prog Jean Dupont
int main(int argc, char * argv[])
argc est un entier contenant le nombre darguments
argv est un tableau de chanes de caractres dont la 1 chane

argv[0] est le nom du programme
Les chanes peuvent tre converties au besoin

fonctions de la librairie stdlib.h
Septembre 2013
123 / 123

Techniques Et Implementation Circuit

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Techniques Et Implementation Circuit

Încărcat de

Drepturi de autor:

Formate disponibile

Module TC2

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Module TC2 - Master 1 EEA-AEETS

Structures de donnes volues

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Problme numrique : quelles sont les solutions de lquation

But : rsoudre le problme avec un systme informatique

Les ordinateurs ont besoin de procdures automatiques pour rsoudre

Trouver une procdure automatique permettant de rsoudre ce

Un bon algorithme doit :

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Un algorithme manipule des informations

Pour reprsenter les informations du problme, un algorithme utilise

Quelle structure de donnes pour notre exemple ? Comment

Le choix de la "bonne" structure de donnes aura un impact sur

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Un algorithme est un enchanement dactions logiques dcrit en

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Structure dun programme C.

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Fichier source C (extension .c)

Ficher objet (extension .o)

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Structure dun programme C (1)

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Structure dun programme C (2)

/* Le cours commence ici */

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Structure dun programme C (3)

/* 6 - dfinition de la fonction principale */

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Structure dun programme C (4)

/* 7 - dfinition des autres fonctions */

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Nom donn aux composantes : variables, fonctions, . . .

Taille : 31 caractres maximum

Toujours commencer par une lettre

Le nom 2_resultat est interdit

Le nom resultat_2 est bon

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Trois familles de variables simples :

Par dfaut, ces types sont signs

Possibilit dutiliser les types NON signs

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Existence de quatre qualificatifs : unsigned pour les entiers et les

unsigned char : entiers naturels sur 1 octet (0 255),

Nicolas Rivire (Universit Toulouse III)

Module TC2 - Master 1 EEA-AEETS

Diffrentes possibilits daffectation pour le type caractre :