Algorithme et programmation :

Programmer en C
Chap 1 - Les bases de la
programmation
Chap 2 Itrations et rcursivit
Chap 3 Structures de donnes
Chap 4 Pointeurs, passage par
adresse et fonctions, allocations
dynamique et tableaux dynamiques
Chap 1 :Les bases de la programmation
I.
II.
III.
IV.
V.
VI.

Objectifs et rappels introductifs

Structures dun programme en langage C
Types lmentaires, oprateur, variables, constante,
expressions
Les fonctions lmentaires
Instructions et blocs
Composition dinstruction

I.1. Langages / Programmes / Compilation

Trois types dobjets => entiers, rels, caractres
Code xecutable = texte du programme
Compilations vs interprtation ( compilateur, interprteur, vitesse, portabilit,
semi-interprts) = programme traduit vs traduction ( beaucoup plus lent )
Paradigmes de programmation : fonctionnel ; logique ; impratif

2. Algorithme (Ensemble de calculs qui dfinit un

procd)
Programme = traduction dun algorithme en langage de programmation
Caractristique :
*nombre fini de donnes
*ensemble fini dtapes ayant un nombre fini doprations
*Fournit toujours un rsultat
*tre dterministe
Remarque : Correction ( rponse aux spcifications) - Sret Efficacit
Convivialit

II. Structures dun programme en C (programme

impratif)
-Structure de donnes
-Instructions lmentaires ( des lignes, dans lordre des oprations) se terminant
par ;
-Modes de composition de ces oprations
En gnral, laffectation dun valeur une var dun type donne, une fonction sur
un ensemble darguments typs
Ex : #include<stdio.h>
typedef struct { inta; intb;} couple;

//ordres pr-processeurs
//dfinition de types

Int addition (couple c) {

return c.a + c.b; }

//dfinition de fonctions

intmain() {
couple c;
intz; c.a=2; c.b=9;
z = addition(c);
return 0 ;
}

//fonctionmain
//dclarations
//instructions : affectation
//instructions : appel de fonctions

III.1.Les types :
Entiers (relatifs) : int + - * / % ++ -- < > <= == != += (accumulation)
Rels : float ou double + - * / % ++ -- < > <= == !=
Caractre : char
a est cod par lentier 97
Boolen : nexiste pas en C, 0 -> faux
1-> vrai
&& (et) || (ou) ! (non)
Pour dfinir un boolen :
#define vrai 1 // dfinition dune constante
#define faux 0
typedef unsignedcharbooleen;
Attention: Toute entit manipule (variable, fonction,) devra tre dclare
avec son type.
Rem : il est prfrable dutiliser un double plutt quun float

2.Expressions
7/2 -> 3 (div entire)
7./2 -> 3.50
Attention aux mlanges de types dans les expressions

3.Variables
Variables globales != variable locales
Dclaration de la var : <type> <identificateur> ;

Ex :
intnombreEnfants ;
intnombreParents = 2 ;
double prix_de_vente,prix_achat= 10.5 ;

Rem : viter les accents, ne pas utiliser les espaces, pas de chiffre au dbut du
nom, pas @, ni -, ni les mots-cls rservs du C. La dclaration dune variable se
fait normalement en dbut de bloc dlimit par des {}. Les variables dclares
sont temporaires. Elles sont empiles sur la pile et dpiles en sortie de bloc.

4. Constantes
#define <var> = .. ; ou bien const <type> <var> = ;
Le plus souvent des Maj pour les variables des constantes

IV. Les fonctions lmentaires

fonctions
fonctions
fonctions
fonctions

avecparamtreset rsultats
sans rsultat(aussiappeles procdures)
ouprocdures sans paramtres
avecplusieursrsultats

1.Dfinition dune fonction

<type_retour> <nom_de_la_fonction> (<liste_de_paramtres_avec_types>) {
<dfinitions locales>
<intructions ou bloc>
return ( <resultat> ) ;
}

Ex : int addition (int a,int b)

{ intc;
c= a+b;
return c;
}

//la function prenddeux entiersen paramtres

//dclarations
//instructions : affectation

On conseille d'crire les commentaires suivants en dbut de fonction :

/* donnes ou paramtres : 2 entiers additionner */
/* rsultat : un entier reprsentant la somme des 2 paramtres */

2.Appel dune fonction

Ex :
inta=2, b=9, c;
// dclaration et initialisation
c= addition(a,b);
// a et b sont les arguments de la fonction
c = addition(2, addition(a,b)) Attention au type et lordre des arguments

3. Fonctions sans rsultat : procdures (Toujours

void )
// dfinition de la procdure
void afficheEntier(intx) {
printf("valeur : %d",x);
return; /* facultatif */
}
// appel de la procdure afficheEntier(age)

Mise en page :
*\n = retour chariot
*\t = tabulation

Fonction printf : (afficher quelque chose lcran)

printf ( <code_format>, <variable_li_au_format>
Une squence commenant par % sera remplace affichage par la valeur dun
argument

Fonction scanf :(assigner des variables des donnes tapes par l'utilisateur)
scanf(<format_entree>,&nom_variable)

Remarques:
Il y a un espace au dbut de <format_entree> pour que l'excution de plusieurs
scanf conscutifs fonctionnent, mme si les diffrentes valeurs saisies par
l'utilisateur sont spares par des espaces ou des retours-chariot
Avec un seul scanf on peut affecter plusieurs variables en mettant plusieurs
format d'entre dans le premier paramtre, et en spcifiant plusieurs variables
dans les paramtres suivants.

Exemple:
scanf(" %d %f",&i,&x);

4.Fonction sans paramtre

Ex : /* lecture d'un nombre entier au clavier */
// dfinition de la fonction
int lireEntier(void) {
int x;
scanf(" %d",&x);
return x;
}
// appel de la fonction y = lireEntier()

5.Notion deffet de bord

Cad quel modifie un tat autre que a valeur de retour (A viter) => Paradigme
de la programmation fonctionnelle.

6.Spcification dune fonction

Il est fortement conseiller de prciser les pr/post-conditions pour amliorer la
comprhension, la lisibilit, et rutilisabilit du code.

Pr-conditions : dfinissent les proprits que doivent avoir les donnes

Post-conditions : rsume les effets de bords
La programmation imprative :
tat mmoire
->
tat mmoire
/* <pr-condition> */ -> / *<post-condition>*/
La pr-condition peut-tre vue comme l'tat mmoire initial suppos et la postcondition comme l'tat mmoire rsultant de l'application de la fonction.

8.Passage par valeur

Les paramtres dune fonction ne sont jamais modifis par lappel de cette
fonction
Ex : void ajouterunalentier(intx){
x++;
}
intmain(){
inta = 2;
/* dclaration et initialisation */
printf("%d",a);
/* affiche 2 l'cran */
ajouterunalentier(a);
/* appel de fonction */
printf("%d",a);
/* affiche encore 2 l'cran ! */
}

V.Instructions et blocs
*Affectation
ex : age=age+1;
*Appel dune fonction
* ; pour sparer les instructions (squentialit)
* , deux instructions spares par une virgule peuvent tre excutes dans un
ordre quelconque *Oprateurs daccumulation : x *=2 => x
=x*2
*Oprateur dincrmentation ou de dcrmentation : i--

Exemples:
int i, j, k, l;
i = 3;
j = 2*i++ ;
k= 2*i ;
l = 2*++i ;
Il est important de regrouper sous forme de bloc, de plus les tabulations sont
primordiales lobtention dun programme lisible(Indentation). Une instruction
seul, peut tre lu comme un bloc.

VI.Composition dinstructions
1.Les conditionnelles si alors sinon finsi
Il faut faire attention lindentation, un else se rapporte toujours au dernier
if
If ( A == B )
if (B > C)
if (D != 8)

if ( A==B){
if (B > C){
if (D !=8){

E = 6.3 ;

E=6.3 ;

else

}
}

E = 5.1 ;
}
else {

E = 5.1 ;
}

2.Les conditionnelles switch ( A ne pas vraiment

utiliser)
switch (resultat){
case 1 : x = 10;
break;
case 2 :
break;
case 3 : x = x+1;
break;
case 4 : x = x-1;
break;
default : x=0;
}
if (resultat==1){
x=10; }
elseif (resultat==2){
}
elseif (resultat==3){ x=x+1;
}
elseif (resultat==4){
x=x-1;
}
else{
x=0;
}

Chap 2 : Itrations et rcursivit

I.Itrations
1.La boucle for
Itrations aussi appeles boucles sont un outil algorithmique qui permet de rexcuter certains traitementn soit un nombre de fois dtermin soit tant quune
condition nest pas vrifi
for (<initialisations>;<condition>;<itrations>)<instructions>
Ex : intx=2, N=10;
printf("x=%d\n", x);
for (int i=0;i<N;i++){
x = i+x;
}
printf("x=%d\n", x);

// l'affichage l'cran sera x=2

// l'affichage l'cran sera x=57

2.La boucle while

while(<condition>)<instructions>
Ex :inta = 3, f = 2;
while ( a>0 ){
f = a*f;
a--;
}
En fait les boucles for et while sont interchangeables :
for = <initialisations>
while (<condition>)
<instructions>
<itrations>
while = for ( ;<condition> ; <instructions>) ;
En effet les <initialisations> sont facultatives dans la boucle for

3.La boucle do.. while

do <instructions> while (<condition>)
Ex :inti=1, a=2, b=3;
do
a+=b;
while(i<0);

4.Utilisation des trois formes de boucles

-si le nombre de fois qu'on doit effectuer le traitement n'est pas connu
l'avance :
si le traitement peut ventuellement ne pas tre effectu, selon les donnes
boucle while
si le traitement doit tre effectu au moins une fois quelles que soient les
donnes
boucle do...while
-si le nombre de fois qu'on doit effectuer le traitement est connu l'avance
boucle for

Ex 1: dessiner un triangle de hauteur N avec des *

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

Ex 2 : dessiner un carr avec N # sur un cot.

####
# #
# #
####

II.Les fonctions rcursives

On peut utiliser la proprit de rcurrence pour les fonctions offrant une
alternative litration.
Ce sont des fonctions qui sappellent elles-mmes.

1.Fonctions rcursive versus fonctions itratives

Certaines versions prfrent la rcursivit, et dautres litration. Dune manire

gnral, il est possible de passer de lun vers lautre. Comme la drcursivation.

Ex : Voir feuille dexercice

Calcul du jour dans l'anne
Supposons que nous disposons d'une fonction nbJoursMois permettant d'obtenir
le nombre de jour de chaque mois (connaissant l'anne, pour les cas bissextiles).
Comment obtenir la position d'un jour dans l'anne

approche itrative :
int positionJourDansAnnee(int j, int m, int a){
int pos = j, mois;
for(mois = 1; mois < m; mois++)
pos += nbJoursMois(mois, a);
return pos;
}

approche rcursive :
int positionJourDansAnnee(int j, int m, int a){
return positionJourDansAnnebis(j, m, a, 1); // janvier
}
int positionJourDansAnneebis(int j, int m, int a, int moiscourant){
if (m==moiscourant)
return j;
else
return (nbJoursMois(moiscourant,a)
+ positionJourDansAnnebis(j, m, a, moiscourant + 1));
}

Chap 3 -Structures de donnes.

Le type n-uplet nexiste pas en C, mais on peut crer des nouveaux types
de donnes constitus de plusieurs informations

I. Structure
1.Dclaration de variable avec description de son
type.
Plusieurs types ventuellement diffrents.
struct
{
<type1> <id_element1> ;

<typen> <id_elementn> ;
}<id_nouvellevar> ;
Appel de champs :
<id_var> . <id_element> ;
exemple :
struc {double a ; double b ;} p ;
Accs au champs : p.a et p.b

2.Forme gnrale de la dclaration dun nouveau

type construit
struct <id_nouveautype>
{
<type1> <id_element1> ;

<typen> <id_elementn> ;
};
Exemple :
dclaration du type point
struct point {float a ; float b ;} ;
puis dclaration de la variable p par :
struct point p ;

Exercice :
Contruire le type segment parti du type point ci-dessus puis dclarer
ultrieurement un segment s, ie une var de type segment.
struct segment {struct point M ; struct point N ;} ;
struc segment s ;
s.M.a = 1.0 ;
s.M.b = 1.0 ;
s.N.a = 4.0 ;
s.N.b = 2.0 ;
Ecrire une fonction qui calcul la longueur du segment :
float longueur (struct segment s1=
{
float abs, ord, long ;
abs= s1.N.a s1.M.a ;
ord= s1.N.b s1.M.b ;
long = sqrt (abs*abs + ord*ord) ;
return long ;
}

II.Synonymie ou Typedef
Tout type a un nom dfini ( char, float, int) ou prdifine par le
programmeur (par construction)
On peut aussi lui dfinir un synonyme :
typedef <ancien-nom> <nouveau_synonyme> ;

Exemple :
typedef struct segment Seg ;
Ou bien directement au moment de la cration du type :
typedef struct {double a ; double b ;} Point ;
et dclarer ensuite la variable p par :
Point p ;
*typedef struct
{
double prix ;
int quantite ;
} Article ;
Article pain = {2.50, 4} ;

Article croissant = {1.10,3} ;

Remarque : Le type boolen nant pas dfini en C on peut le dfinir de
cette manire avec des valeurs entires pour vrai et faux ( 0 / 1 )
#define FAUX 0
#define VRAI (!FAUX)
typedef int bool ;
on peut donc lutiliser avec : bool b ;
Ne pas oublier les conditions pour lutilisateur.

III.Tableaux statiques
1. Dfinition et proprits
Il existe une sorte de variable appele variable indice ou tableau dont les
valeurs dun n-uplet de variables dun mme type :
Les lments du tableau sont appels occurrence, et leur numro appel
indice.
Dclaration :
<type> <nom_du_tableau>[<nombre_d_elements>] ;
<type> <nom_du_tableau>[<nombre_d_elements>] = {<valeur1>,
<valeur2>,} ;
Accs au lments
<nom_du_tableau> [<numro_de_l_indice>]

Exemple :
inttab [3];
int tab [3] = {10,-5} ;
tab[0] = 10;
tab[1] = -5;
tab[2] = 18;
Int x = tab[2]+5;
Ce tableau dsigne 3 emplacements mmoire dadresses conscutives.
Attention :
*Les indices commencent 0
* Laccs des lments non dclars est possible(erreur lors de
lexcution) do limportance de la taille ( mmoriser la taille dans une
autre variable)
*nombre dlments dclars :

#define N 100
int tab[N]
mais pas :
int n = 100 ;
int tab[n]
Ne fonctionne pas car n prend la valeur 100 quaprs la compilation. Avec
un ordre pr-processeur, on peut connaitre cette valeur au moment de la
compilation.
*les oprations sur les tableaux se font lment par lment
- on ne peut pas crire tab2=tab1
- de mme pour la comparaison de tab1 == tab2

Condition darrt :
int produit (int a, int b) {
if (a==1)
return b ;
else return produit (b, a-1)
}
si on test la fonction, avec produit(2,3), produit (3,2), produit(2,3)
On a une fonction qui
On a donc un crasement de la mmoire si on change une valeur dun
mme tableau sur lindice concern.

Typedef float vecteur [2 3]

/*dfinit un type vecteur constitu de 3 lments de type float */
rem : la taille du tableau avec un typedef se situe derire le nom
Par exemple :
define N 5 //ordre pr-processeur
typedef float vecteur [N] ;
vecteur u = {2.0 , 3.1, 8.2, 9.2 , 7.4}
/*declare une var u de type vecteur et ou lon a affect un 5 uplet */
vecteur v = {1. , 6. ,5. , 4. ,10.} ;

float produitscalaire (vecteur u, vecteur v){

int i ;
float s = 0 ;

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

s = s +u[i] * v[i]
}
}

2.Tableaux statiques et fonction

Passage par adresse
Un tableau en rsultat comme un paramtre de la fonction
Exemple :
void fonction_tab_rsultat_paramtre ( int t2[4]){
int i ;
for(i=0 ; i<n ; i++){
t2[i]=0 ;
}
return ;
}
main(){
int t1[4] ; //dlcaration dun tab de plusieurs lments ici t1[]
fonction_tab_resultat_parametre(t1) ; // t1 ne contient que des 0
}

Oprations classiques sur les tableaux

-On se donne 3 tab, t1, t2
#define N 100
tailles de tab, t1, t2 sont not n, n1, n2 avec <= N
Voir exercice sur les tableaux et structures
Tableau de caractres ou chaine de caractres
Syntaxe : char <nom_chaine> [<taille_chaine>] ;
Il est mieux de dfinir une taille de tableau automatique.
Exemple :
char texte[20] ;
La chaine possde donc un max qui est de 19 lments plus de caractre
de fin de chaine \0
char prenom[]= albert ;

char prenom2[]={a,b,e,r,t} ; (le \0 sajoute automatiquement)

char prenom3[20]= albert ;
char prenom4[20]={ albert , \0} ;
rem : lecture dune chaine
char nom[15] ;
scanf( %s , nom) ; rappel ( %c pour un char)
/*affichage*/
printf( %s , nom) ;

Tableaux et structures
exemple :
typedef struct{
float re ;
float im ;
} complexe ;
/*dclaration*/
complexe tabcomplexe[3] ; // tableau de 3 complexes (6 float)
exemple :
tabcomplexe[1].im = 2.3 ;
/*deuxime lement du tableau, et deuxime paramtre du type dfini
complexe */

Tableau plusieurs dimension

a) Tableau de tableau
On suppose la struct dun tab
Exemple :
typedef double ligne[3] ;
ligne matrice[7] ;

b) Tableau d dimension :
<type> <nom_var> [<n1>] [<n2>][<nd>] ;
exemple :
Int tab [3] [5] ;
Un tableau deux dimensions.
Int matrice [5] [2] = {{,},{,},{,},{,},{,}} ;

Chap. 4 : Pointeur, passage par adresse

et fonction, allocation dynamique et
tableaux dynamique.
I. Dfinition et oprateurs de manipulation
1.Dfinition
Un pointeur est une variable qui a pour valeur une adresse mmoire.
(pointeur = adresse)

2.Dclaration
<type de la valeur> * <identifiant> ;
-le * signifie dclaration
Exemple :
int*Pi
int*P1 , *P2, *P3 ;
float*Pf ;

// variable Pi, pointeur sur un type entier

// trois pointeur sur un type entier
//pointeur sur un type float

3.Initialisation
Pour un pointeur sur rien , on utilise la valeur NULL en C
int*p = NULL ;
// vite que p ne pointe nimporte o en mmoire
Il est important de ne pas oublier la library stdlib.h .
Il en va de mme quil ne faut pas oublier dinitialiser la valeur de p
NULL sinon il y a un risque de mauvaise lecture de la mmoire ou
dcriture.

4.Oprateur adresse & et contenu *

1.Loprateur adresse &
Nous lavons dj utilis de implicitement dans la fonction scanf qui crer
une adresse pour une entre.
& permet de rcuprer ladresse dune variable.
Exemple :
int i ;
//dclaration dune variable de type entier
int*Pi ;
//dclaration dun pointeur sur un type entier
Pi=&i ;
//affectation au contenu de la variable Pi de type
pointeur sur un int

2.Loprateur contenu *
Permet de rcuprer la valeur de la variable sur laquelle le pointeur pointe.
Exemple :
int i = 1 ;
int j = 2 ;
int k = 3 ;

//dclaration et initialisation de trois entiers

int *Pi = NULL ;

int *Pj = NULL ;
entier NULL

//dclaration et initialisation de deux pointeurs sur type

Pi = &i ;

//On accde la valeur pointe par Pi

Il est important de ne pas confondre * de la dclaration et loprateur * de

contenu.
On vitera de trop combiner les deux oprateur.

II.Passage par adresse des paramtre dune

fonction
En c, la majeur partie du temps les paramtres sont par copie valeur
On travaille sur une copie des variables au sein de la fonction.
/*Sans pointeur*/
void exchange (int x, int y)
{
int z ;
z=x;
x=y;
y=z;
return ;
}
Int main()
{
int a = 10 ;
int b = 52 ;
exchange(a,b) ;
printf(la valeur de a %d, valeur de b %d \n ,a,b) ;
return 0 ;
}

/*Avec pointeur*/
void exchange2 (int *Px, int *Py)
{
int z ;
z = *Pi ;
//on accde aux colonnes du pointeurs
*Px = *Py ;
*Py = z ;
return 0 ;
}
printf( %d , *Pi) ;
Pj = Pi ;
printf( %d , *Pi );
*Pj = j ;
k = *Pi ;
// k = z
int main()
{
int a = 10 ;
int b = 52 ;
exchange (&a,&b) ;
//change deux pointeurs en arguments
/*Printf a et b (adresse de a et b)*/
Le contenu des variables a et b ont t modifi directement en mmoire
( lextrieur de la fonction)
Il est ncessaire de prvenir les effets de bord dans les spcification du
programme.

int *p ; // dclaration dun pointeur sur un int

Le * est un oprateur de dclaration
*p = 2 ; // affctation de la valeur point
Le * est un oprateur de contenu
Int main()
{
int i = 1 ;
int j = 2 ;
int k = 3 ;
printf( %d %d %d \n ,i,j,k) ; // 1 2 3
//Pr-processeur : trois adresses en arguments
//Post-processeur : La fonction renvoie rien par contre elle modifie la
valeur des variables pointes (effet de bord)
void permutation ( int *Pi, int *Pj, int *Pk)
{
z = *Pk ;
*Pk = *Pj ;
*Pj = *Pi ;
*Pi = z ;
return ;
}
Printf ( %d %d %d \n,i,j,k) ; // 3 1 3
return 0 ;
}
Utilisation de la fonction : permut ( &i, &j, &k)

III. Allocation dynamique

1.Principe
int *p ; // cration dun pointeur (dclaration)
On veut linitialiser :
int i ;
p = &i ; // le pointeur prend ladresse de i
int *p1 = NULL ; //initialiser un pointeur sur un entier nul
int *p2 ;
p2 = p ; //initialiser en prenant un pointeur existant
Crer une zone en mmoire et le stocker ladresse indiqu :
malloc (allouer de la mmoire)
Sizeof (stdlib.h)

Exemple :
int *pi = (int*)malloc ( sizeof(int)) ;
dclaration = adresse de lentier avec sa taille
On peut allouer un nombre prcis de sizeof qui ont le mme type
//Exemple dallocation dynamique
Intrt dinit malloc NULL est de voir si il a fonctionn
2.Exemple de schma de mmoire
Int i = 52 ;
int j = 27 ;
int k = 382

int* p1 = &i ;
int* p2 = &j ;

Identifiant mmoire

adresse

int* p3 = (int*)malloc(sizeof(int)) ;
*p3 = j ;
Toute modification dune contenu dun pointeur, modifie alors les liens et
aussi la valeur initialiser en i , j , k.

3.Itration de la mmoire
Il est ncessaire dindiquer quon restitue la mmoire quon avait allou
avec malloc (fonction free)
malloc free
sizeof
Exemple :
malloc avec pi (prcdemment)
free(pi) ; // libr la mmoire pi

Pour chaque malloc, il y a un seul free

Exemple :
int* p1 = NULL; int* p2 = NULL ; // dclare des pointeurs NULL
//allocation dun espace mmoire
*p1 = 28 ; //modifie pointeur de p1

p2 = p1 ;

//p2 pointe vers la mme zone

free(p2) ; //on libre la zone de p2 (toute les adresses)

*p1 = 2 ; Erreur
Il existe un lien rciproque des valeurs.

IV. Pointeurs et retour de fonction

-Palier la destruction des variables locales
-Ce qui est allou avec malloc dans une fonction, le reste est en global.
Exemple : Fonction de suivie de char
char* saisiChar()
//On renvoie un pointeur sur char
{
char* car ;
car = (char*)malloc(sizeof(char)) ;
//Init du pointeur en
mmoire est globale
scanf( %c , car ) ;
//Il ny a pas de &
return car ;
}
int main()
{
char* lettre ;
// var globale, pointeur sur char
lettre = saisiChar() ;
//malloc cach (fct prcdente)
if (lettre !=NULL)
{
free(lettre)
//Pour justement viter la fuite de mmoire
}
return 0 ;
}

Il faut absolument grer les fautes ventuelles de mmoire ( un malloc =

un free)
//Version qui attribue de la mmoire global en local
//Renvoie la valeur par effet de bord

void saisiChar2 ( char* car)

{
scanf( %c , car) ;
return ;
}
int main()
{
char* lettre ;
lettre = (char*)malloc(sizeof(char)) ;
saisiChar2 (lettre) ;
//lettre est affect par effet de
bord
printf( %c , *lettre) ;
free(lettre) ;
return 0 ;
}

V.Pointeur sur structure

Exemple :
Typedef struct
{
int age ;
int numro ;
} Etudiant ;
Etudiant et1 ;

//dclaration dune structure

Etudiant* p_etudiant
(type repoint)

//dclaration dun pointeur sur la structure tudiant

p_etudiant = &et1 ;
structure et1 ;

//affectation du pointeur avec ladresse de la

Laccs aux champs est totalement diffrents en effet, on nutilise plus

et1.age mais plutt :
- p_etudiant age

- p_etudiant numero
Contenu de la structure point ( *p_etudiant.age et *p_etudiant.numero)
Complment :
int * ( *ppz) ;
//pointeur sur un pointeur entier
*ppz = &pz ;

VI.Tabeaux dynamiques
1.Limitation du tableau statique
Par exemple, crer un tableau dont la taille est donne par lutilisateur (On
connait la fonction malloc)
Exemple :
int* tab ;
/*dclaration dun pointeur sur entier (1re adresse de tout un bloc dont la
taille reste dfinir) */
tab = (int*)malloc(3*sizeof(int)) ; //dclaration dynamique dun tableau
3 lments
On utilise comme les tableaux statiques
tab[0], tab[1], tab[2]
int tab[3] ;
//malloc cach
Exemple :
Int* tab ;
tab = (int*)malloc(3*sizeof(int)) ;
for (i=0 ; i<3 ; i++)
{
tab[i]=0 ;
}
return tab ;

//utilisation du tableau

2.Tableau dynamique dans une fonction

//Fonction dinit
void init()
{
int i ;
int* tab ;
N = line_entier() ;
//Lutilisation entre la taille (sizeof)
tab = (int*)malloc(N*sizeof) ;
//Les mmoires rserves
}
Dans le main :
int* ptab ;

ptab = init() ;

3.Tableaux dynamique de structure

Exemple :
Typedef struct
{
int age ;
int numero ;
} Etudiant ;
Etudiant* tabEt ;
//dclaration dun tableau detudiant
(type)
tabEt = (Etudiant*)malloc(100*sizeof(Etudiant)) ;
/*On a rserv lespace mmoire pour un tableau dtudiant de 100
lments*/
tabEt[0].age = 25 ;
tabEt[0].numero = 2512 ; //Dclaration des deux lment du premire
lment du tableau

4.Tableau dynamique de pointeurs

Les pointeurs sont eux-mmes des variables.
(int*)* tabPtr ;
//On dclare un tableau dynamique de pointeur sur
entier
(type)
(tableau dynamique)
Les parenthses sont en fait inutiles !
int** tabPtr ;
tab_ptr = (int**)malloc(200*sizeof(int*)) ; //tableau dynamque de
200lments
int i = 12.
tabPtr[25]=&i ; //adresse de i (Init une case de Ptr)
//Autre mthode dinit
for ( i = 0 ; i <200 ; i++)
{
tabPtr[i] = (int*)malloc (sizeof(int)) ; //Il faut faire attention la taille
du malloc
}

//On remplit dans les conteneurs

*tab[0]=12 ;
(int)

5.Tableau dynamique de pointeur

Exemple :
Etudiant** tabPtrEt ; //Dclaration dun tableau dynamique de pointeur
sur structure
tabPtrEt = (Etudiant**)malloc(500*sizeof(Etudiant*)) ;

//Utilisation du tableau
int i ;
for (i=0 ;i<500 ; i++)
{
tabPtrEt[i] = (Etudiant*)malloc(sizeof(Etudiant)) ;
(adresse)
tabPtrEt[i] age = 25
}

6.Tableau dynamique de tableau dynamique

int** tab2D ;
tab2D = (int**)malloc(100*sizeof(int*)) ;
int i ;
for (i = 0 ; i<100 ; i++)
{
tab2D[i]=(int*)malloc(200*sizeof(int)) ;
(adresse)
}
//Utilisation du tableau initialisation
tab2D[99][150] = 3 ;