anguy T - INSA Lyon...intro duction Les bases du C fonctions entrées-sorties GP: A rithmiqueAlgo et...

introdu tion Les bases du C Les fon tions Les entrées-sorties

AGP: Algorithmique et programmation

tanguy.risset�insa-lyon.fr

Lab CITI, INSA de Lyon

Version du August 1, 2017

Tanguy Risset

August 1, 2017

Tanguy Risset AGP: Algorithmique et programmation 1


Table of Contents

1

introdu tion

2

Les bases du C

3

Les fon tions

4

Les entrées-sorties



Présentation du ours

Enseignants:

Cours 12h

TD 20h

TP 32h

Déroulement du ours:

Prin ipes de la programmation en C

Prin ipes de l'algorithmique

Notions de ulture générale en informatique

En 2016, les notions d'algorithmique des graphes ont étés transférées

dans le ours NET.

Moddle (ouvert): frames, sujet, do uments divers

http://moodle.insa-lyon.fr/ ourse/view.php?id=473

Attention: pensez à vous ins rire au ours avant d'y faire une a tion

nominative (dépot de � hier, QCM, et ..)



Comment rentabiliser son AGP

Ne pas négliger l'importan e des ompéten es et onnaissan es

abordées dans AGP:

Fondements et prin ipes fondamentaux de l'informatique.

Connaître le fon tionnement des ordinateurs.

Con evoir et réaliser un programme.

Modéliser un problème réel pour pouvoir le résoudre ave l'outil

informatique.

⇒ S'adapter rapidement aux nouvelles te hnologie informatique (en les

restituant par rapport à elles que vous onnaissez)

⇒ Vous maîtrisez la ma hine...

Ne pas sous-estimer l'expérien e a quise (dans la di� ulté

quelquefois)

Apprendre la rigueur dans la produ tion

Comprendre l'utilité de la phase de on eption

Apprendre à travailler ave l'autre

On n'est pas tous égaux devant AGP...



Référen es utiles

livres:

Le langage C, Kernighan & Rit hie, Masson, 1990

la référen e pour la programmation en C ANSI

Introdu tion à l'algorithmique, T. Cormen, C. Leiserson, R. Rivest, 1994,

Dunod

Appro he omplète et pédagogique de l'algorithmique

Sur le web

Poly de Bernard Cassagne (votre poly):

http://www- lips.imag.fr/ ommun/bernard. assagne/Introdu tion_ANSI_C.html

C referen e manual (version épurée du Kernighan & Rit hie ave

grammaire du langage):

http:// m.bell-labs. om/ m/ s/who/dmr/ man.pdf

C library referen e guide:

http://www.a m.uiu .edu/webmonkeys/book/ _guide/

Cours d'Anne Canteaut (beau oup utilisé dans es transparents)

http://www-ro q.inria.fr/ odes/Anne.Canteaut/COURS_C/



Un mot sur le plagiat

Le plagiat selon Wikipedia: Le plagiat est une faute morale, ivile,

ommer iale et/ou pénale onsistant à opier un auteur ou réateur

sans le dire, ou à fortement s'inspirer d'un modèle que l'on omet

délibérément ou par négligen e de désigner. Il est souvent assimilé à

un vol immatériel.

En programmation, on utilise très souvent des programmes é rits par

d'autre personne ⇒ mais on les ite!!!

I i, vous etes en formation initiale:

On vous demande de produire du ode et des rapports,

La produ tion est la meilleure manière pour vous d'apprendre

Il est normal de vous lasser sur vos apa ité à produire plutot qu'à

reproduire

Soyez honnête ave vous-même..



Introdu tion

Historique

Créé par Dennis Rit hie pour é rire Unix pour le pdp-11 (publi ation

1978)

Standard ANSI C (1990)

Pourquoi C?

Avantages

Performan e (http://shootout.alioth.debian.org), portabilité,

standard, pro he de la ma hine

Permet de omprendre les mé anismes de l'exé ution de programmes ⇒bonnes bases pour tous les autres langages (bibliothèques, portabilité,

et .).

In onvénients

Dangereux (bugs!), né essite beau oup de rigueur, programmation bas

niveau,

Peu adapté aux ordinateurs non standard (temps réel, systèmes

distribués, parallélisme, et .)



Rappels sur l'ar hite ture d'un ordinateur

Un ordinateur de bureau est omposé (au moins):

D'un pro esseur

D'une mémoire (dite vive: rapide et non rémanente)

D'un espa e de sto kage (disque dur: lent, rémanent)

De périphériques d'entrée/sortie (é ran, laviers, et .)

Prin ipe du pro esseur programmable:

Le pro esseur lit un programme en mémoire (programme exé utable,

dépendant du type de pro esseur).

En fon tion de e programme

Il lit ou é rit des données en mémoire à une ertaine adresse mémoire

(nombre entier sur 32 bits)

Il e�e tue des al uls entre es données



Rappels d'ar hite ture

Main

memory

I/O

controller

I/O

controller

I/O

controller

Disk Graphics

output

Network

Memory–I/O bus

Processor

Cache

Interrupts

Disk

Dynamic data

Static data

Reserved

Stack segment

Data segment

Text segment

7fffffffhex

10000000hex

400000hex



Ar hite ture vue du programmeur

Les systèmes modernes permettent

D'exé uter plusieurs programmes indépendant en parallèle (pro essus)

D'a éder à un espa e mémoire plus grand que la mémoire physique

disponible (mémoire virtuelle)

Pour le programmeur: tout ela est transparent

Un seul programme s'exé ute ave une mémoire très grande disponible

La mémoire vue du pro esseur ontient:

Le ode à exé uter

Les données statiques (taille onnue à la ompilation)

Les données dynamiques (taille onnues à l�exé ution: le tas, et l'espa e

ne essaire à l'exé ution elle-meme: la pile)

Le programmeur lui ne voit que les données (statiques et

dynamiques)



Pro essus de ompilation

le pro essus omplet va traduire un programme C en ode exé utable

(le hargement et l'exé ution auront lieu plus tard).

code asmassembleur

liens

édition des

exechargement

compilateurobj

.o

Simulation

Exécution

.c .s

.a

lib

On nomme souvent ompilation l'ensemble ompilateur+assembleur

Le ompilateur g in lut aussi un assembleur et un éditeur de lien

(a essibles par des options)



Votre pro essus de ompilation

Le programmeur:

É rit le programme C: i i le dans le � hier ex.

Compile vers un programme objet ex.o

Fait l'édition de lien pour générer l'exe utable ex

ontenu de ex.

#in lude <stdio.h>

int main()

{

printf("hello World\n");

return(0);

}

ex.ogcc −c ex.c

exgcc ex.c −o ex

stdio.h

ex.c

libstdio.agcc ex.o −o ex



Dénomination à retenir

Le programme C que vous é rivez est le programme sour e (ex. )

Le programme sour e est ompilé en un programme objet par le

ompilateur (ex.o)

Le programme sour e in lut un � hier d'en-tete (stdio.h) pour

véri�er les noms des fon tions externes utilisées (printf)

le programme exe utable est onstruit par l'éditeur de liens grâ e aux

programmes objets et aux bibliothèques.

Les bibliothèques (library en

anglais) sont des odes

assembleurs (i.e. déjà ompilés) de

fon tions fréquements utilisées. I i

la bibliothèque utilisée est

libstdio.a qui ontient le ode

de la fon tion printf

ex.ogcc −c ex.c

exgcc ex.c −o ex

stdio.h

ex.c

libstdio.agcc ex.o −o ex



Notions de génie logi iel

Pour développer une appli ation, on parle de logi iel plut�t que de

programme

Un logi iel est plus qu'un programme

Le y le de vie du logi iel in lut:

L'analyse du problème à résoudre

La on eption d'une solution (spé i� ation)

Le développement de la solution (programme)

Le test du programme

La livraison ave do umentation asso iée

La maintenan e



Outils pour le développement logi iel

Méthodes

Ré�é hir avant d'agir !

règles de développement (programmation agile, programmation par test)

Language objet: C++, Java

Outils

Commentaire en Doxygen

Gestionnaire de ompilation : make

Debugger : gbd, ddd, ....

Environnements de développement (intègrent tout): e lipse,

VisualC++



Table of Contents

1

introdu tion

2

Les bases du C

3

Les fon tions

4




Les bases du C

Instru tion, expression, programme

Éléments de base

Variable et types de base

Opérateurs

Types onstruits

Opération de Contr�le de ��t

Fon tions et passage de paramètres

Entrées-sorties

Visibilité et durée de vie des variables

Exemple: le tri d'un tableau d'entier



Syntaxe

La syntaxe est dé�nie par des règles de grammaire.

Extrait de la grammaire:

expression::

primary

| expression binop expression

| expression asgnop expression

| ....

primary::

identifier

| string

| onstant

| ...

asgnop::

=

| +=

| ...

binop::

+

| -

| ...

x = 0 , a + b, a+=1 sont syntaxiquement orre ts (respe tent la

grammaire)

Un programme syntaxiquement orre t n'est pas for ément un

programme C valide. Exemple: 1 = 0 est syntaxiquement orre t

mais sémantiquement in orre t.



Expression, Instru tion

Une expression est une suite de omposants élémentaires syntaxiquement orre te, par

exemple: x = 0 ou bien

(i >= 0) && (i < 10)

En C haque expression produit:

une a tion (modi� ation possible de l'état des variables en mémoire)

un résultat (valeur renvoyée par l'expression)

Une instru tion est une expression suivie d'un point-virgule. Le point-virgule signi�e en

quelque sorte �évaluer ette expression et oublier le resultat�.

Plusieurs instru tions peuvent être rassemblées par des a olades { et } pour former une

instru tion omposée (ou blo ) qui est syntaxiquement équivalent à une instru tion. Par

exemple,

if (x != 0)

{

z = y / x;

t = y % x;

}



Stru ture d'un programme C

Un programme C se présente de la façon suivante :

dire tives au prépro esseur

dé larations de variables globales

fon tions se ondaires

int main()

{ dé larations de variables internes

instru tions

}

#in lude <stdio.h>

int main()

{

printf("hello World\n");

return(0);

}

La fon tion main est exé utée lors de l'exé ution du programme.

Le résultat de la fon tion main est le résultat de l'exé ution du

programme ( ode d'erreur en général)



Variables

La notion de variable est très importante en programmation

Du point de vue sémantique, une variable est une entité qui ontient

une information :

Une variable possède un nom, on parle d'identi�ant

Une variable possède une valeur qui hange au ours de l'exé ution du

programme

Une variable possède un type qui ara térise l'ensemble des valeurs

qu'elle peut prendre

Du point de vue pratique, une variable est une manière

mnémote hnique pour désigner une partie de la mémoire.

En C les noms des variables sont omposés de la manière suivante:

une suite de ara tères parmis :

les lettres (minus ules ou majus ules, mais non a entuées),

les hi�res (sauf en début de nom),

le �blan souligné� (_).



Types de base en C

En C, les variables doivent être dé larées avant d'être utilisées, on dit

que C est un langage typé

Les types de base en C sont désignés par des spé i� ateurs de type

qui sont des mots lefs du langages:

les ara tères ( har),

les entiers (int, short, , unsigned long)

les �ottants (nombres réels, float, double).

Il n'y a pas de type booleen, ils sont odés par des int

Une instru tion omposée d'un spé i� ateur de type et d'une liste

d'identi� ateurs éventuellement initialisés séparés par une virgule est

une dé laration. Par exemple:

int a;

int b = 1, ;

double x = 2.38e4;

har message[80℄;

Il existe de nombreuses onversions de types impli ites



Représentation de l'information

Le type d'une variable indique au ompilateur la manière de sto ker

la variables en mémoire

Il est important de onnaître omment sont sto kées les variables ar

C propose de nombreuses manipulations au niveau bit.

La mémoire est une suite de bit stru turée en o tets (8 bits) puis en

mots (4 o tets, 32 bits).

L'adresse 1084 doit se lire omme �le 1084

eme

o tet de la mémoire�

On utilisera trois notations pour représenter les valeurs entières en

mémoire.

La notation dé imale usuelle (10 hi�res): 12

de

vaut la valeur 12

La notation binaire (2 hi�res): 1100

bin

vaut la valeur 12

La notation hexadé imale (16 hi�res) C

hex

vaut la valeur 12

(essentiellement pour représenter les adresses).



Les types entiers

mot- lef taille dénomination remarques

har 8 bits ara tère peut être utilisé omme entier

short 16 bits entier ourt

int 32 bits entier

long >=32 bits entier long souvent 64 bits

En C les entiers signés sont représentés en omplément à 2, 'est à

dire (pour un entier n sur 32 bit):

le bit de poids fort (bit 32) représente le signe (0 pour positif, 1 pour

négatif)

Si l'entier est positif: les 31 autres bits orrespondent à la dé omposition

de l'entier en base 2.

Si l'entier est négatif les 31 autres bits orrespondent à la dé omposition

de l'entier 2

31 − |n|pour int n; on a don les ontraintes: −2

31 <= n < 2

31



Les types entier

Les mots- lef des types peuvent être pré édés d'attributs. Par

exemple unsigned int n indique que l'entier n est positif, la

représentation en omplément à deux n'est pas utilisée on a alors

0 <= n < 2

32

signed har [−2

7; 27[

unsigned har [0; 28[

short int [−2

15; 215[

unsigned short int [0; 216[

int [−2

31; 231[

unsigned int [0; 232[

Le fon tion sizeof al ul la taille d'un type ou d'une expression. Le

résultat est un entier égal au nombre d'o tets né essaires pour

sto ker le type ou l'objet. Par exemple i-dessous taille prendra la

valeur 2 les deux fois

unsigned short x;

taille = sizeof(unsigned short);

taille = sizeof(x);



Les types �ottants

mot- lef taille DEC Alpha Taille PC Intel

float 32 bits 32 bits �ottant

double 64 bits 64 bits �ottant double pré ision

long double 64 bits 128 bits �ottant quadruple pré ision

Les �ottants sont généralement sto kés en mémoire sous la représentation

de la virgule �ottante normalisée. On é rit le nombre sous la forme

signe 0,mantisse B

exposant

(12, 3 ⇔ 0.123 ∗ 102). En général, B=2. Le digit de poids fort de la

mantisse n'est jamais nul.

Par exemple dans le standard EE754, en simple pré ision ( 32 bits):

signe Mantisse Exposant

1bit 8 bits 23 bits



Les ara tères

Un har peut ontenir n'importe quel élément du jeu de ara tères de la ma hine

utilisée.

un har est odé sur un o tet ;

Le jeu de ara tères utilisé orrespond généralement au odage ASCII (sur 7 bits).

La plupart des ma hines utilisent désormais le jeu de ara tères ISO-8859-1 (aussi

appelée ISO-LATIN-1) dont les 128 premiers ara tères orrespondent aux ara tères

ASCII.

extrait de la table ASCII:

ara tère valeur valeur · ara tère valeur valeur

représenté (de ) (hex) représenté (de ) (hex)

! 33 21

hex

A 65 41

hex

" 34 22

hex

B 66 42

hex

# 35 23

hex

C 67 43

hex

. . . . . . . . . . . . . . . . . .

0 48 30

hex

a 97 61

hex

1 49 31

hex

b 98 62

hex

2 50 32

hex

. . . . . . . . .



Les onstantes

Les valeurs exprimées dans un programme C sont des onstantes

Les onstantes entières peuvent être exprimées en dé imal (int

i=12) ou en hexadé imal (int i=0xA),

On peut aussi indiquer qu'elle doivent être sto kées sur un long

(12L) ou en unsigned (12U).

Les onstantes réelles suivent le même prin ipe

12.34 (double), 12.3e-4, (double), 12.34F (float), 12.34L

(Long)

Les ara tères imprimable sont repérentés entre otes ('): har

a='Z'

Les ara tères non imprimables sont représentés en ode o tal (base

8) pré édé d'un antislash, Les plus fréquent ont des représentations

standard: \n nouvelle ligne,

\r retour hariot,

\t tabulation horizontale

\f saut de page,



Constantes et variables

La notion de onstante n'est pas limitée aux valeurs �xes

Une onstante est une valeur non modi�able, par exemple l'adresse

d'une variable.

Il existe une di�éren e fondamentale ave les variables: il n'y a pas

de pla e réservée pour une onstante dans la mémoire lors de

l'exé ution d'un programme.

C'est le ompilateur qui met en dur la valeur de la onstante lorsqu'il

génère l'instru tion:

j=i+10⇒ add Rj,Ri,#10



Les opérateurs

a�e tation: variable = expression

opérateurs arithmétiques +,-,*,/,%,

expression-1 op expression-2

opérateurs relationnels >,<, >=,<=,==,!=

opérateurs logiques booléens &&, ||, !

opérateurs logiques bit à bit &, |, ˆ,˜,�,�

opérateurs d'a�e tation omposée +=, -=, *=, /=, expression-1

op= expression-2

⇔expression-1 = expression-1 op expression-2

opérateurs d'in rémentation et de dé rémentation, ++, - -

opérateur de onversion de type (type) objet

a=(int)

opérateur adresse &,

a=&b



Règles de priorité des opérateurs

les opérateurs sont plus ou moins prioritaires,

Dans le as de priorité égales on a un ordre d'évaluation (asso iatifs

à droite ou à gau he)

ordre de priorité:

opérateurs asso iativité

() [℄ -> . droite

! ++ � -(unaire) (type) *(indire tion) &(adresse) sizeof gau he

* / % droite

+ -(binaire) droite

� � droite

< <= > >= droite

== != droite

&(et bit-à-bit) droite

| droite

&& droite

|| droite

? : gau he

= += -= *= /= %= &=

�

= |= �= �= gau he

, droite



Types onstruits

À partir des types prédé�nis du C ( ara tères, entiers, �ottants), on

peut réer de nouveaux types, appelés types ontruits, qui

permettent de représenter des ensembles de données organisées.

Les tableaux

Les stru tures

Les unions

Les énumérations

Les onstru teurs de type



Les tableaux

Un tableau est un ensemble �ni d'éléments de même type, sto kés en

mémoire à des adresses ontiguës.

La dé laration d'un tableau tab de 10 entiers se fait de la façon

suivante : int tab[10℄;

On a ède au troisième élément du tableau tab par l'expression

tab[2℄. Les tableaux en C ommen ent toujours à 0.

On peut dé�nir des tableaux multidimensionnels. Exemple: matri e M

d'entiers de 10 lignes 5 olonnes int M[10℄[5℄

Important: un tableau en C peut être vu omme un pointeur sur le

premier élément du tableau:

int *tab; ⇔ int tab[℄;

Mais il faut savoir qu'en C un tableau est une onstante



Tableaux: exemple

har tab[10℄ = {'e','x','e','m','p','l','e','\0'};

main()

{

int i;

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

printf("tab[%d℄ = % \n",i,tab[i℄);

}

tab[0℄ = e

tab[1℄ = x

tab[2℄ = e

tab[3℄ = m

tab[4℄ = p

tab[5℄ = l

tab[6℄ = e

tab[7℄ =

tab[8℄ =

tab[9℄ =



Tableaux: exemple

#define M 2

#define N 3

int tab[M℄[N℄ = {{1, 2, 3}, {4, 5, 6}};

main()

{

int i, j;

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

{

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

printf("tab[%d℄[%d℄=%d\n",i,j,tab[i℄[j℄);

}

}

tab[0℄[0℄=1

tab[0℄[1℄=2

tab[0℄[2℄=3

tab[1℄[0℄=4

tab[1℄[1℄=5

tab[1℄[2℄=6



Retour sur les types: les haînes de ara tères

En C une haine de ara tères n'est pas un type de base: 'est un

tableau de ara tères terminé par le ara tère spé ial '\0' (ou NULL:

o tet valant 0).

On peut la noter entre double ote:

har haine[10℄="bonjour"

Où omme un tableau de ara tère (jamais utilisé):

har haine[10℄={'b','o','n','j','o','u','r','\0'}

Comme un tableau en C est assimilé à un pointeur sur le début du

tableau on trouvera souvent des haines de ara tères dé larées

omme:

har * haine;

Pour l'instant on preferera la dé laration statique (tableau).

Attention il faut une ase de plus que le nombre de lettres (pour

'\0').



Les stru tures

Une stru ture est une suite �nie d'objets de types di�érents.

Contrairement aux tableaux, les di�érents éléments d'une stru ture

n'o upent pas né essairement des zones ontiguës en mémoire.

Chaque élément de la stru ture, appelé membre ou hamp, est

désigné par un identi� ateur.

Deux manières équivalentes de dé�nir une variable z omplexe:

stru t omplexe

{

double reelle;

double imaginaire;

} z;

stru t omplexe

{

double reelle;

double imaginaire;

};

stru t omplexe z;

norme=sqrt(z.reelle*z.reelle+z.imaginaire*z.imaginaire);



Les stru tures de ontr�le de �ot

Les objets que nous avons ren ontrés permettent de faire des al uls,

pas de ontr�ler quels al uls sont faits

Les stru tures de ontr�les sont de deux types:

Les bou les

Les instru tions de bran hement



Les bou les

Bou les while:

while (expression )

instru tion

i = 1;

while (i < 10)

{

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

i++;

}

Bou les for

for (expr 1 ;expr 2 ;expr 3)

instru tion

⇔

expr 1;

while (expr 2 )

{instru tion

expr 3;

}



Les instru tions de bran hement

Bran hement onditionnel

if (expression-1 )

instru tion-1

else instru tion-2

ou

if (expression-1 )

instru tion-1

Bran hement multiple swit h:

swit h (expression )

{ ase onstante-1:

liste d'instru tions 1

break;

ase onstante-2:


break;

ase onstante-3:


break;

default:

liste d'instru tions defaut

break;

}

Bran hement non onditionnel: break, ontinue

Bran hement à ne pas utiliser: goto



Table of Contents

1

introdu tion

2

Les bases du C

3

Les fon tions

4




Les fon tions

On peut en C dé ouper un programme en plusieurs fon tions.

Seule la fon tion main est obligatoire.

Même si vous ne dé�nissez pas de fon tion, vous utilisez les fon tions

des biblothèques C standard (return, printf par exemple)

Dé�nition de fon tion:

type nom (type-1 arg-1,...,type-n arg-n)

{[dé larations de variables lo ales ℄

liste d'instru tions

}

int fa torielle(int n)

{

int i, fa t=1;

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

fa t *= i;

return(fa t);

}

La première ligne int fa torielle(int n) s'appelle l'en-tête (ou

prototype, ou en ore signature) de la fon tion.

Appel de fon tion : x=fa torielle(10);



Passage de paramètres

Une fon tion ommunique des valeurs ave son environnement

appelant à travers les paramêtres et le résultats.

dans int fa torielle(int n), n est le paramètre formel de la

fon tion. Il peut être utilisé dans le orps de la fon tion omme une

variable lo ale.

dans x=fa torielle(10);, 10 est le paramètre e�e tif utilisé lors

de et appel.

En C, tout e passe lors de ette appel omme si on exé utait le

orps de la fon tion ave la ase mémoire pour n ontenant une

opie de la ase mémoire ontenant 10. On dit que les paramètres

sont passés par valeur.

Lorsque l'appel est terminé, la ase mémoire de n disparait.

Don : on peut modi�er la valeur du paramètre formel n dans le orps

de la fon tion mais ela ne modi�era pas la valeur du paramètre

e�e tif (10).



Imbri ation de fon tions

En C on ne peut pas dé�nir une fon tion à l'intérieur d'une fon tion

En revan he on peut utiliser une fon tion dans une fon tion.

Pour ela il y a deux ontraintes:

1

Au moment de la ompilation, lorsque le ompilateur ren ontre l'appel à

une fon tion fa torielle, il faut qu'il ai déjà ren ontré l'en-tète de la

fon tion int fa torielle(int n)

2

Au moment de l'édition de lien, il faut que l'un des odes objet

ontienne le ode ompilé de la fon tion fa torielle.

On a plusieurs moyens pour assurer es ontraintes:

1

Un seul � hier

2

Dé larer les en-têtes de fon tions en début de � hier

3

Compilation séparée



Fon tions dans Un seul � hier

//fon tion fa torielle

// al ule n! ou n entier


{int i, fa t=1;

//double initialisation

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

fa t *= i;

return(fa t);

}

//fon tion main

//affi he 10! à l'e ran

int main()

{int x;

x=fa torielle(10);

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

return(0);

}

Compilation:

g fa t1. -o fa t



Fon tion ave dé laration des en-têtes

//De laration en-tetes

int fa torielle(int n);

//fon tion main

int main()

{ int x;

x=fa torielle(10);


return(0);

}




{ int i, fa t=1;

//double initialisation

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

fa t *= i;

return(fa t);

}

attention au ; après

l'en-tête.

Commande de

ompilation:

g fa t1. -o

fa t



Deux � hiers

//fi hier fa t3.




{ int i, fa t=1;

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

fa t *= i;

return(fa t);

}

//fi hier main1.



//fon tion main


int main()

{ int x;

x=fa torielle(10);


return(0);

}

Commandes de ompilation:

g - fa t3. -o fa t3.o

g - main1. -o main1.o

g main1.o fa t3.o -o main1



Fon tions: La bonne manière de faire

//fi hier fa t3.




{ int i, fa t=1;

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

fa t *= i;

return(fa t);

}

On dé�nit les en-têtes dans un

� hier d'en-têtes pour la

réutilisation par d'autres

programmes.

Commandes de ompilation:

g - fa t3. -o fa t3.o

g - main2. -o main2.o

g main2.o fa t3.o -o main2

//fi hier fa t3.h



//fi hier main2.

#in lude "fa t3.h"

//fon tion main


int main()

{

int x;

x=fa torielle(10);


return(0);

}



Ré ursivité

Une fon tion peu s'appeler elle-même, 'est alors une fon tion

ré ursive.

la ré ursion est une autre manière d'e�e tuer des bou les.

//fon tion fa tRe urs

// al ule n! ou n entier>0

//de manière ré ursive

int fa tRe urs(int n)

{

int fa t;

if (n==1) // ondition d'arret

fa t=1;

else

fa t=n*fa tRe urs(n-1);

return(fa t);

}



Ré ursivité

La ré ursivité est très importante dans ertains paradigmes de

programmation (programmation fon tionnelle).

Elle orrespond à une méthode naturelle de dé omposition d'un

problème en problèmes plus simple:

pour al uler n!, je a ule (n − 1)! (plus simple)

puis je al ule n ∗ (n − 1)!

Pour s'assurer que. que le programme ne va pas bou ler

indé�niement, il est impératif de;

Dé�nir la ondition d'arret: i i 'est n==1

Dé�nir une quantité qui va roître (ou dé roître) lors des appels

su essifs de la fon tion jusqu'à e que la ondition d'arret soit véri�ée,

i i ette quantitée est n la valeur du paramètre.

On peut formaliser ela ave la notion d'invariant



Portée des variable

Les variables manipulées dans un programme C ne sont pas toutes

traitées de la même manière. En parti ulier, elles n'ont pas toutes la

même durée de vie. On distingue deux atégories de variables.

Les variables permanentes (ou statiques)

Les variables temporaires

Chaque variable dé larée a une portée (ou durée de vie) qui est la

portion de ode dans laquelle elle est onnue.

On peut dé larer des variables au début de haque blo (début d'une

fon tion ou portion de ode entre a olade). La portée (ou durée de

vie) de es variables est limitée au blo .

Les blo s sont for ément imbriqués lexi alement, lors d'une

utilisation d'une variable n, elle peut avoir été dé larée deux fois dans

la suite des blo s englobant. L'utilisation orrespond à elle de la

première dé�nition ren ontrée lorsque l'on remonte dans les blo s

(i.e. la dernière e�e tuée temporellement).



Portée: exemple

int n = 10;

void fon tion();

void fon tion()

{int n = 0;

n++;

printf("appel numero %d\n",n);

return;

}

main()

{int i;

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

fon tion();

}

----------------

appel numero 1

appel numero 1

appel numero 1

appel numero 1

appel numero 1



Portée: exemple

int n;

void fon tion();

void fon tion()

{ n++;

printf("appel numero %d\n",n);

return;

}

main()

{ int i;

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

fon tion();

}

-----------------

appel numero 1

appel numero 2

appel numero 3

appel numero 4

appel numero 5



Table of Contents

1

introdu tion

2

Les bases du C

3

Les fon tions

4





La librairie standard libstdio.a propose des fon tions pour faire

des entrées-sorties sur les périphériques standard: l'é ran et le lavier.

Ces fon tions sont printf pour é rire et s anf pour lire

Il faut in lure la dire tive #in lude <stdio.h> au début du � hier

si on désire les utiliser.

Ce sont des fon tions d'impression formatée, e qui signi�e que les

données sont onverties selon le format parti ulier hoisi.



La fon tion printf

La syntaxe de la fon tion printf est:

printf(" haîne de ontr�le ",expr-1, ..., expr-n);

La " haîne de ontr�le" ontient le texte à a� her et les

spé i� ations de format orrespondant à haque expression à a� her.

%d indique l'a� hage d'un entier signé en dé imal.

%u indique l'a� hage d'un entier non signé en dé imal.

% indique l'a� hage d'un ara tère.

%f indique l'a� hage d'un réel (double) en dé imale.

exemples:

int a;

a=10;

printf("a vaut %d \n",a);

int a;

a=10;

printf("a vaut %4d \n",a);

résultats:

a vaut 10 a vaut 10



printf: exemples

%x indique l'a� hage d'un entier non signé en hexadé imal.

exemples:

int a;

a=10;

printf("a vaut (en hexa) %x \n",a);

short a;

a=10;

// onversion en int


résultats:

a vaut (en hexa) A a vaut 10

Attention ! Il y a une onversion de type:

exemples:

har a;

a=66;

// onversion en int


short a;

a=66;

// onversion en har

printf("a vaut % \n",a);

résultats:

a vaut 66 a vaut B



En ore printf

exemples: %f, %e

double x = 1e-8 + 1000;

printf("x vaut %f \n",a);

double x = 1e-8 + 1000;

printf("x vaut %e \n",a);

résultats:

x vaut 1000.000000 x vaut 1.000000e+03

exemples: ( onversion vers unsigned)

int a;

a=-23674;;


int a;

a=-23674;;

// onversion en unsigned

printf("a vaut %u \n",a);

résultats:

a vaut -23674 a vaut 4294943622



En ore printf

programme:

##in lude <stdio.h>

int main()

{

fprintf(stdout,"As ii[%d℄=% , en o tal: %o en hexa: %x\n",

'\101','\101','\101','\101');

fprintf(stdout,"As ii[%d℄=% , en o tal: %o en hexa: %x\n",

65,65,65,65);

return(0);

}

résultat:

trisset�hom:~/ ours/2005/AGP/ ours_tri/transp$ exChar

As ii[65℄=A, en o tal: 101 en hexa: 41

As ii[65℄=A, en o tal: 101 en hexa: 41

trisset�hom:~/ ours/2005/AGP/ ours_tri/transp$



Attention aux haines!

programme:

##in lude <stdio.h>

int main()

{int i;

har haine[4℄={'\101','\101','\101','0'};

har fausseChaine[3℄={'\101','\101','\101'};

fprintf(stdout," haine=%s,\n", haine);

fprintf(stdout,"fausseChaine=%s,\n",fausseChaine);

return(0);

}

résultat:

trisset�hom:~/ ours/2005/AGP/ ours_tri/transp$ exChar2

haine=AAA,

fausseChaine=AAA·ö¸�ö¸¾;<nAAA,trisset�hom:~/ ours/2005/AGP/ ours_tri/transp$



La fon tion s anf

La syntaxe de la fon tion s anf est:

s anf(" haîne de ontr�le ",expr-1, ..., expr-n);

I i, la " haîne de ontr�le" ne ontient que les formats

Les données à entrer au lavier doivent être séparées par des blan s ou des

<RETURN> sauf s'il s'agit de ara tères (<RETURN> est un ara tère).

Les formats sont légèrement étendus par rapport à eux de printf

exemple:

##in lude <stdio.h>

main()

{

int i;

printf("entrez un entier sous forme hexade imale i = ");

s anf("%x",&i);

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

}

Si on entre au lavier la valeur 1a, le programme a� he i = 26.

Attention à bien donner l'adresse de la variable à a�e ter.



Passage de paramêtre par référen e

Tout se passe omme si la fon tion s anf modi�ait un de ses

argument.

En fait omme les argument sont passé par valeurs, on doit passer en

paramêtre un pointeur sur l'objet à modi�er (don passer l'adresse

de l'objet)

La fon tion s anf ne peut modi�er son argument, mais elle peut

modi�er l'objet pointé par l'argument.

Ce me hanisme est utilisé systématiquement en C, pour que la

fon tion modi�e un objet, il est passé en argument par référen e.



Fi hiers

Les a ès à un � hier se font par l'intermédiaire d'un tampon

(bu�er) qui permet de réduire le nombre d'a ès aux périphériques

(disque...).

Pour pouvoir manipuler un � hier, un programme a besoin d'un

ertain nombre d'informations : l'adresse du tampon, position dans

le � hier, mode d'a ès (le ture ou é riture) ...

Ces informations sont rassemblées dans une stru ture dont le type,

FILE *, est dé�ni dans stdio.h. Un objet de type FILE * est un

stream (�ot).

Avant de lire ou d'é rire dans un � hier, on l'ouvre par la ommande

fi h=fopen("nom-de-fi hier","r"). Cette fon tion dialogue

ave le système d'exploitation et initialise un stream fi h, qui sera

ensuite utilisé lors de l'é riture ou de la le ture.

Après les traitements, on ferme le � hier grâ e à la fon tion

f lose(fi h).



Fi hiers

on peut ouvrir un � hier sous plusieurs modes: le ture ("r"), é riture au début ("w"),

é riture à la �n ("a"). fopen retourne 0 en as d'e he .

Exemple:

FILE *fi h;

fi h=fopen("./monFi hier.txt","r");

if (!fi h) fprintf(stderr,"Erreur d'ouverture : %s\n","./monFi hier.txt");

Un objet de type FILE est quelquefois appelé un dés ripteur de � hier, 'est un entier

désignant quel est le � hier manipulé.

Trois des ripteurs de � hier peuvent être utilisés sans qu'il soit né essaire de les ouvrir

(à ondition d'utiliser stdio.h):

stdin (standard input) : unité d'entrée (par défaut, le lavier, valeur du

des ripteur: 1) ;

stdout (standard output) : unité de sortie (par défaut, l'é ran, valeur

du des ripteur: 0) ;

stderr (standard error) : unité d'a� hage des messages d'erreur (par

défaut, l'é ran, valeur du des ripteur: 2).

Il est fortement onseillé d'a� her systématiquement les messages d'erreur sur stderr

a�n que es messages apparaissent à l'é ran même lorsque la sortie standard est

redirigée.



Autres fon tion de le ture/e riture

Entrée/sorties de ara tères

int fget (FILE* flot);

int fput (int ara tere, FILE *flot)

Entrée/sorties de haînes de ara tères

har *fgets( har * haine, int taille, FILE* flot);

int fputs( onst har * haine, FILE *flot)

Entrée/sorties binaires

size_t fread(void *pointeur, size_t taille, size_t

nombre, FILE *flot);

size_t fwrite(void *pointeur, size_t taille, size_t

nombre, FILE *flot);

positionnement dans un � hier

int fseek(FILE *flot, long depla ement, int origine);

trois valeurs possibles pour origine: SEEK_SET (égale à 0) : début du

� hier ,SEEK_CUR : position ourante, SEEK_END (égale à 2) : �n du

� hier.



fget , fput : exemple

##in lude <stdio.h>

##in lude <stdlib.h>

##define ENTREE "entree.txt"

##define SORTIE "sortie.txt"

int main(void)

{FILE *f_in, *f_out;

int ;

if ((f_in = fopen(ENTREE,"r")) == NULL)

{

fprintf(stderr, "\nErreur: Impossible de lire le fi hier %s\n",ENTREE);

return(EXIT_FAILURE);

}

if ((f_out = fopen(SORTIE,"w")) == NULL)

{

fprintf(stderr, "\nErreur: Impossible d'e rire dans le fi hier %s\n",

SORTIE);


}

while (( = fget (f_in)) != EOF)

fput ( , f_out);

f lose(f_in);

f lose(f_out);

return(EXIT_SUCCESS);

}



Arguments de la fon tion main

La fon tion main doit être présente si le programme est utilisé

dire tement (pas omme une librairie), par exemple: appelé depuis le

shell.

En général, la fon tion main retourne un ode d'erreur de type int.

Lorsque l'on ompile ave la ommande g monProg. -o

monProg, l'exé ution de la ommand monProg dans un shell appelle

la fon tion main

Si on lan e la ommande monProg ave des arguments (ex: monProg

fi hier1.txt, il est possible de ré upérer dans la fon tion main la

valeur de es arguments sous forme de haînes de ara tères: on

utilise les arguments standard de la fon tion main: int arg

(argument ount), har *argv[℄ (argument values) (on peut aussi

ré uperer des variables d'environnement grâ e à envp)



Exemple de fon tion main

Multipli ation de deux entier: g mult. -o mult

shell> mult 8 32

Le produit de 8 par 32 vaut: 256

##in lude <stdio.h>

##in lude <stdlib.h>

int main(int arg , har *argv[℄)

{

int a, b;

if (arg != 3)

{

printf("\nErreur : nombre invalide d'arguments");

printf("\nUsage: %s int int\n",argv[0℄);


}

a = atoi(argv[1℄);

b = atoi(argv[2℄);

printf("\nLe produit de %d par %d vaut : %d\n", a, b, a * b);

return(EXIT_SUCCESS);

}



Convention d'é riture en C

Il existe très peu de ontraintes dans l'é riture d'un programme C.

Toutefois ne prendre au une pré aution aboutirait à des programmes

illisibles.

On n'é rit qu'une seule instru tion par ligne : le point virgule d'une

instru tion ou d'une dé laration est toujours le dernier ara tère de

la ligne.

Les instru tions sont disposées de telle façon que la stru ture

modulaire du programme soit mise en éviden e.

une a olade ouvrante marquant le début d'un blo doit être seule sur sa

ligne ou pla ée à la �n d'une ligne.

Une a olade fermante est toujours seule sur sa ligne.

Les instru tions doivent être indentées a�n que toutes les

instru tions d'un même blo soient alignées. Le mieux est d'utiliser

le mode C d'ema s ou de vi.

On ommente abondament le ode



Commentaire en doxygen

Utilisation d'un � hier de on�guration ommun (doxyfile)

La ommande doxygen fi hierConfig génère la do umentation

désirée (html par défaut).

Avant les dé larations de fon tion:

\brief pour la des ription de la fon tion

\param pour haque paramètre

\result pour le résultats

\warning pour les mises en garde parti ulières

Avant les dé larations de stru ture de donnée

\brief pour la des ription de la stru ture de donnée

éventuellement//! pour la des ription des hamps de la stru ture

Avant les dé�nitions de ma ros ommunes (dans les � hier .h)

\def pour la dé�nition de la ma ro



exemple de ommentaire en doxygen

/*!

************************************************

* \brief remplit un tableau trié de 2N element en

* fusionnant deux tableaux de N elements triés (N>1)

* \param T tableau de N entiers

* \param S tableau de N entiers

* \param TS tableau de 2N entiers résultat de la fusion

* \warning Le tableau TS est déjà alloué mais vide

**************************************************/

void fusion (int T[N℄,int S[N℄, int TS[2*N℄)

{int s,t,fus;

//initialisation des pointeurs sur les tableaux:

// t est l'index dans T

[....℄

}


anguy T - INSA Lyon...intro duction Les bases du C fonctions entrées-sorties GP: A rithmiqueAlgo et...

Documents

Transcript of anguy T - INSA Lyon...intro duction Les bases du C fonctions entrées-sorties GP: A rithmiqueAlgo et...