LU1IN002 : Éléments de programmation 2

Cours 3
Tableaux et pointeurs

Cours : Jean-Lou Desbarbieux, François Bouchet,

Mathilde Carpentier
et toute l’équipe de l’UE
LU1IN002 Sorbonne Université 2023/2024
Structures linéaires

En C : les tableaux
▶ suites de valeurs contiguës en mémoire
▶ les valeurs sont toutes du même type
Deux types de tableaux en C :
▶ les tableaux “statiques”
▶ de taille fixe (exemple float tab [12]; )
▶ localisés en mémoire dans la pile
▶ les tableaux “dynamiques” => au cours suivant
▶ de taille variable, mais la mémoire est gérée par le
programmeur avec les fonctions malloc et free principalement
▶ localisés en mémoire dans le tas
Les tableaux statiques en C

1 int main () {
2 int tab [12]; // d é claration
3 tab [0]=2; // affectation
4 tab [5]=4;
5 tab [9]= tab [5]+ tab [0];
6 tab [5]= tab [5]+1;
7 printf ( " tab [5]:% d \ n " , tab [5]) ;
8 return 0;
9 }

Attention : pas d’indice négatif !

Les tableaux statiques en C

Attention : pour afficher un tableau entier, il faut

afficher chacune des valeurs (avec une boucle)

1 int main () {
2 float tab [5]={1.1 ,10.9 ,5.0 ,1.5 ,5.6};
3 // d é claration et initialisation
4 int i ;
5 for ( i =0; i <5; i ++) {
6 printf ( " tab [% d ]:% f \ n " , i , tab [ i ]) ;
7 }
8 return 0;
9 }
Les tableaux statiques en C
Le nombre de cases du tableau est souvent défini avec une
directive #define
1 # define N 5 // instruction pour le pr é processeur
2 int main () {
3 float tab [ N ]={1.1 ,10.9 ,5.0 ,1.5 ,5.6};
4 // d é claration et initialisation
5 int i ;
6 for ( i =0; i < N ; i ++) {
7 printf ( " tab [% d ]:% f \ n " , i , tab [ i ]) ;
8 }
9 return 0;
10 }

Attention : Le N défini ici n’est PAS une variable. On

ne peut pas modifier sa valeur pendant l’exécution du
programme.
Exemple

1 #d e f i n e N 5
2 i n t main ( ) {
3 f l o a t t a b [ N]=
{1.1 ,10.9 ,5.0 ,1.5 ,5.6}; i 5
4 int i ;
5 f o r ( i =0; i <N ; i ++){ 0 1.1
6 p r i n t f ( ” t a b [%d ] : % f \n” , i ,
tab [ i ] ) ;
1 10.9
7 } // ( 1 )
main tab 2 5.0
8 return 0;
9 }
3 1.5
4 5.6
pile (1)
Les tableaux statiques en C

Déclarations des tableaux :

1
2 # define NB 14
3
4 int main () {
5 int tab [ NB ]; // d é claration
6
7 float t2 [4]={1.2 , 9 , 5.6}; // d é claration et
affectation
8
9 tab [0]=2; // affectation
10
11 // Attention : tab ={1 ,2 ,3} interdit en dehors des
d é clarations
12 return 0;
13 }
Les tableaux statiques en C
Exemple :
1 int main () {
2 int tab [5]; // d é claration
3 int i ;
4 for ( i =0; i <5; i ++) {
5 tab [ i ]= i * i ;
6 }
7 for ( i =0; i <5; i ++) {
8 printf ( " tab [% d ]=% d \ n " , i , tab [ i ]) ;
9 }
10 return 0;
11 }

Qu’affiche ce programme ?
Les tableaux statiques en C
Exemple :
1 int main () {
2 int tab [5]; // d é claration
3 int i ;
4 for ( i =0; i <5; i ++) {
5 tab [ i ]= i * i ;
6 }
7 for ( i =0; i <5; i ++) {
8 printf ( " tab [% d ]=% d \ n " , i , tab [ i ]) ;
9 }
10 return 0;
11 }

Qu’affiche ce programme ?
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Que se passe t-il avec ce code ?

1 i n t main ( ) {
2 i n t t a b [ 1 0 ] ; // dé c l a r a t i o n
3 int i ;
4 f o r ( i =0; i <5; i ++){
5 t a b [ i ]= i ∗ i ;
6 }
7 // ( . . . )
8 f o r ( i =0; i <10; i ++){
9 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i
]) ;
10 }
11 return 0;
12 }
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Que se passe t-il avec ce code ?

i 5
1 i n t main ( ) {
2 i n t t a b [ 1 0 ] ; // dé c l a r a t i o n 0 0
3 int i ;
4 f o r ( i =0; i <5; i ++){
1 1
5 t a b [ i ]= i ∗ i ; 2 4
6 }
7 // ( . . . )
3 9
8 f o r ( i =0; i <10; i ++){ 4 16
9 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i
]) ;
5 ?
10 } 6 ?
11 return 0; main tab 7 ?
12 }
8 ?
9 ?
pile (1)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Que se passe t-il avec ce code ?

i 5
1 i n t main ( ) {
2 i n t t a b [ 1 0 ] ; // dé c l a r a t i o n 0
3 int i ;
1
4 f o r ( i =0; i <5; i ++){
5 t a b [ i ]= i ∗ i ; 2
6 }
3
7 // ( . . . )
8 f o r ( i =0; i <10; i ++){ 4
9 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i
5
]) ;
10 } 6
11 return 0; main tab 7
12 }
8
9

pile (1)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i
6 } 0
7 f o r ( i =0; i <10; i ++){
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1
]) ; main tab 2
9 }
10 return 0; 3
11 } 4

pile (1)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i 0
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1
]) ; main tab 2
9 }
10 return 0; 3
11 } 4

pile (2)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i 1
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1 1
]) ; main tab 2
9 }
10 return 0; 3
11 } 4

pile (2)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i 2
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1 1
]) ; main tab 2 4
9 }
10 return 0; 3
11 } 4

pile (2)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i 3
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1 1
]) ; main tab 2 4
9 }
10 return 0; 3 9
11 } 4

pile (2)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
i 4
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1 1
]) ; main tab 2 4
9 }
10 return 0; 3 9
11 } 4 16
pile (2)
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 ) i 5
6 }
7 f o r ( i =0; i <10; i ++){
0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i 1 1
]) ; main tab 2 4
9 }
10 return 0; 3 9
11 }
4 16
25
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE

Et celui-ci ?

1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){ i
5 t a b [ i ]= i ∗ i ; // ( 2 )
6 } 0
0
7 f o r ( i =0; i <10; i ++){ 1 1
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i
]) ;
main tab 2 4 n
tio
9 } 3 9nta
return 0; e
gm16ult
10
11 } Se4 F a
25
Les tableaux statiques en C
https://app.wooclap.com/HPEDPE
Et celui-ci ?
1 i n t main ( ) {
2 i n t t a b [ 5 ] ; // dé c l a r a t i o n
3 i n t i ; // ( 1 )
4 f o r ( i =0; i <10; i ++){
5 t a b [ i ]= i ∗ i ; // ( 2 )
6 }
i
7 f o r ( i =0; i <10; i ++){ 0 0
8 p r i n t f ( ” t a b [%d]=%d \n” , i , t a b [ i
]) ; 1 1
9 } main tab 2 4
10 return 0;
11 } 3 9
4 16

Attention : Il n’y a aucun contrôle du compilateur des

bornes du tableau : on peut tout à fait essayer d’afficher
une case qui n’existe pas, ce qui peut générer une erreur
à l’exécution (typiquement un segmentation fault).
Tableau, mémoire et adresse

Un tableau tab de taille n en C est une zone mémoire dont on a

l’adresse du premier octet dans laquelle on pourra mettre n
données ayant toute la même taille. tab contient l’adresse du
premier octet du tableau.
Équivalence pointeurs et adresses
tab est en fait l’adresse de la première case du tableau.
4 #d e f i n e T 5
5 i n t main ( ) {
6 i n t tab [T ] ;
7 int i ;
8 i n t ∗ a=t a b +1;
9 f o r ( i =0; i <T ; i ++){
10 t a b [ i ]= i ∗ i ;
11 } i 5 0x[..]314
12 p r i n t f ( ” t a b :%p &t a b [ 0 ] : % p\n” ,
tab , &t a b [ 0 ] ) ; 0 0 0x[..]260
13 p r i n t f ( ” t a b [ 1 ] : % d &t a b [ 1 ] : % p\
n” , t a b [ 1 ] , &t a b [ 1 ] ) ;
1 1 0x[..]264

14 p r i n t f ( ” t a b [ 2 ] : % d &t a b [ 2 ] : % p\
main tab 2 2 0x[..]268
n” , t a b [ 2 ] , &t a b [ 2 ] ) ; //
(1)
3 4 0x[..]26c

15 p r i n t f ( ” a:%p %d\n” , a , ∗ a ) ; 4 16 0x[..]270

16
17 return 0; pile (1)
18 }
Équivalence pointeurs et adresses
tab est en fait l’adresse de la première case du tableau.
4 #d e f i n e T 5
5 i n t main ( ) {
6 i n t tab [T ] ;
7 int i ;
8 i n t ∗ a=t a b +1;
9 f o r ( i =0; i <T ; i ++){
10 t a b [ i ]= i ∗ i ;
11 } i 5 0x[..]314
12 p r i n t f ( ” t a b :%p &t a b [ 0 ] : % p\n” ,
tab , &t a b [ 0 ] ) ; 0 0 0x[..]260
13 p r i n t f ( ” t a b [ 1 ] : % d &t a b [ 1 ] : % p\
n” , t a b [ 1 ] , &t a b [ 1 ] ) ;
1 1 0x[..]264

14 p r i n t f ( ” t a b [ 2 ] : % d &t a b [ 2 ] : % p\
main tab 2 2 0x[..]268
n” , t a b [ 2 ] , &t a b [ 2 ] ) ; //
(1)
3 4 0x[..]26c

15 p r i n t f ( ” a:%p %d\n” , a , ∗ a ) ; 4 16 0x[..]270

16
17 return 0; pile (1)
18 }
Tableaux et fonctions

Il est possible de passer un tableau en argument d’une fonction.

Exemple : une fonction retournant la somme des éléments du
tableau :
▶ float somme tab(float tab [], int len ) ;
▶ float somme tab(float ∗tab, int len ) ;
Ces deux prototypes sont équivalents mais le premier est plus
explicite et est donc conseillé quand on manipule des tableaux.
De Python à C : schéma d’accumulation
Avec les listes en Python

En Python :
1 def somme liste (L) :
2 ””” l i s t [ Number ] −> Number
3 R e t o u r n e l a somme d e s é l é ments de l a liste L.
”””
4 # s : Number
5 s = 0 # l a somme cumul é e d e s é l é ments
6 # n : Number ( é l é ment c o u r a n t )
7 for n in L :
8 s=s+n
9 return s

:-( il n’y a pas de boucle for ... in en C

De Python à C : schéma d’accumulation
Avec les listes en Python

En Python :
1 def somme liste (L) :
2 ””” l i s t [ Number ] −> Number
3 R e t o u r n e l a somme d e s é l é ments de l a liste L.
”””
4 # s : Number
5 s = 0 # l a somme cumul é e d e s é l é ments
6 # n : Number ( é l é ment c o u r a n t )
7 for i in range ( len (L) ) :
8 s=s+L [ i ]
9 return s

:-) Il y a en C une boucle ressemblant au for i in range (...) du

Python.
Tableau, taille et boucle
En C :
1 f l o a t somme tab ( f l o a t t a b [ ] , i n t l e n ) {
2 /∗ donne l a somme d e s é l é ments du t a b l e a u t a b
3 Hypoth è s e : t a b e s t de l o n g u e u r l e n
4 ∗/
5 float s = 0;
6 int i
7 f o r ( i =0; i < l e n ; i ++) {
8 s = s + tab [ i ] ;
9 }
10 return s ;
11 }

Attention :
▶ déclaration sans indication de taille ( float tab [] )
▶ pas de fonction len (tab) ⇒ le paramètre len
Tableau, taille et boucle

En C :
1 #d e f i n e N 4
2 f l o a t somme tab ( f l o a t t a b [ ] , i n t l e n ) {
3 /∗ donne l a somme d e s é l é ments du t a b l e a u t a b
4 Hypoth è s e : t a b e s t de l o n g u e u r l e n ∗/
5 float s = 0;
6 int i ;
7 f o r ( i =0; i < l e n ; i ++) {
8 s = s + tab [ i ] ;
9 }
10 return s ;
11 }
12 i n t main ( ) {
13 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ;
14 p r i n t f ( ”somme %f \n” , somme tab ( t , N) ) ;
15 return 0;
16 }
Tableau, taille et boucle
Et avec un while ?

En Python :
1 def somme liste (L) :
2 ””” l i s t [ Number ] −> Number
3 R e t o u r n e l a somme d e s é l é ments de l a liste L.
”””
4 # s : Number
5 s = 0 # l a somme cumul é e d e s é l é ments
6 # i : Number ( é l é ment c o u r a n t )
7 i =0
8 w h i l e ( i <l e n ( L ) ) :
9 s=s+L [ i ]
10 i=i +1
11 return s
Tableau, taille et boucle

En C :
1 #d e f i n e N 4
2 f l o a t somme tab ( d o u b l e t a b [ ] , i n t l e n ) {
3 /∗ donne l a somme d e s é l é ments du t a b l e a u t a b
4 Hypoth è s e : t a b e s t de l o n g u e u r l e n ∗/
5 float s = 0;
6 i n t i =0;
7 w h i l e ( i <l e n ) { // f o r ( i =0; i < l e n ; i ++) {
8 s = s + tab [ i ] ;
9 i=i +1;
10 }
11 return s ;
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ;
15 p r i n t f ( ”somme %f \n” , somme tab ( t , N) ) ;
16 return 0;
17 }
Passage par adresse

Attention : Les tableaux sont passés par adresse et leur

contenu peut être modifié par une fonction.
Passage par adresse

Attention : Les tableaux sont passés par adresse et leur

contenu peut être modifié par une fonction.

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) {
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
10 }
11 return ;
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ;
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
18 } // ( 1 )
19 m e t t r e a u c a r r e ( t , N) ;
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) {
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) )
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
Passage par adresse

Attention : Les tableaux sont passés par adresse et leur

contenu peut être modifié par une fonction.

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) {
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
10 }
11 return ;
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ;
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
18 } // ( 1 )
19 m e t t r e a u c a r r e ( t , N) ;
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) {
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) )
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) {
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
10 }
11 return ;
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; i 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18 } // ( 1 ) main t1 4 0x268
19 m e t t r e a u c a r r e ( t , N) ;
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 2 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 6 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (1)
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/ i 0
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) { mettre au carre
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
len 4
10 }
11 return ; tab 0x264
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18
19
} // ( 1 )
m e t t r e a u c a r r e ( t , N) ;
main 1 4 0x268
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 2 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 6 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (2)
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/ i 1
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) { mettre au carre
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
len 4
10 }
11 return ; tab 0x264
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18
19
} // ( 1 )
m e t t r e a u c a r r e ( t , N) ;
main 1 16 0x268
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 2 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 6 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (2)
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/ i 2
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) { mettre au carre
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
len 4
10 }
11 return ; tab 0x264
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18
19
} // ( 1 )
m e t t r e a u c a r r e ( t , N) ;
main 1 16 0x268
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 4 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 6 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (2)
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/ i 3
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) { mettre au carre
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
len 4
10 }
11 return ; tab 0x264
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18
19
} // ( 1 )
m e t t r e a u c a r r e ( t , N) ;
main 1 16 0x268
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 4 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 36 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (2)
Passage par adresse

4 #d e f i n e N 4
5 void m e t t r e a u c a r r e ( f l o a t tab [ ] , i n t l e n ) {
6 /∗ Met au c a r r é t o u s l e s é l é ments de t a b ∗/
7 int i ;
8 f o r ( i =0; i < l e n ; i ++) {
9 t a b [ i ] = t a b [ i ] ∗ t a b [ i ] ; // ( 2 )
10 }
11 return ;
12 }
13 i n t main ( ) {
14 f l o a t t [ N] = { 1 , 4 , 2 , 6 } ; i 4 0x314
15 int i ;
16 f o r ( i =0; i < N ; i ++) {
17 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ; 0 1 0x264
18 } // ( 1 ) main t 1 16 0x268
19 m e t t r e a u c a r r e ( t , N) ;
20 p r i n t f ( ”\n A p r e s l ’ a p p e l \n ” ) ;
21 f o r ( i =0; i < N ; i ++) { 2 4 0x26c
22 p r i n t f ( ” t a b [%d ] : % f ” , i , t [ i ] ) ;
23 } ( // ( 3 ) ) 3 36 0x270
24 p r i n t f ( ”\n” ) ;
25 return 0;
26 }
pile (3)
Comment initialiser un tableau d’entiers avec des valeurs
saisies au clavier ?

Il faut utiliser la fonction scanf de la bibliothèque stdio .h :

1 i n t main ( ) {
2 char c ;
3 int i ;
4
5 p r i n t f ( ” S a i s i r un c a r a c t è r e : ” ) ;
6 s c a n f ( ”%c ” , &c ) ; // I l f a u t d o n n e r l ’ a d r e s s e de c
7 p r i n t f ( ” C a r a c t è r e l u : %c \n” , c ) ;
8
9 p r i n t f ( ” S a i s i r un e n t i e r : ” ) ;
10 s c a n f ( ”%d” , & i ) ;
11 p r i n t f ( ” e n t i e r l u : %d\n” , i ) ;
12
13 return 0;
14 }

=> Dessiner la mémoire au tableau

Fonctions et pointeurs : scanf

La fonction scanf :
1 void i n i t t a b ( i n t tab [ ] , i n t t a i l l e )
2 {
3 int i = 0;
4 f o r ( i =0; i < t a i l l e ; i ++) {
5 p r i n t f ( ” t a b [%d ] = ? : ”, i);
6 s c a n f ( ”%d” , &t a b [ i ] ) ; // a d r e s s e de l a i e m e c a s e , s ’ é c r i t
a u s s i t a b+i
7 }
8 p r i n t f ( ” \n” ) ;
9 }
10
11 i n t main ( ) {
12 i n t tab [ 5 ] ;
13 i n i t t a b ( tab , 5 ) ;
14 return 0;
15 }

=> Dessiner la mémoire au tableau

Calcul d’adresse
Dans un tableau, les indices indiquent un décalage par rapport à
l’adresse de base du tableau.
En C : on peut calculer un décalage d’adresse.

Arithmétique des pointeurs : addition pointeur + entier

Soit les variables suivantes :
int ns [42];
int ∗a=ns;
ns [0] ≡ a+0 ≡ a
ns [1] ≡ a+1
Adresses :
...
ns [41] ≡ a+41

ns [0] ≡ ∗(a+0) ≡ ∗a
ns [1] ≡ ∗(a+1)
Valeurs contenues :
...
ns [41] ≡ ∗(a+41)
Calcul d’adresse
Dans un tableau, les indices indiquent un décalage par rapport à
l’adresse de base du tableau.
En C : on peut calculer un décalage d’adresse.

Arithmétique des pointeurs : addition pointeur + entier

Soit les variables suivantes :
int ns [42];
int ∗a=ns;
ns [0] ≡ a+0 ≡ a
ns [1] ≡ a+1
Adresses :
...
ns [41] ≡ a+41

ns [0] ≡ ∗(a+0) ≡ ∗a
ns [1] ≡ ∗(a+1)
Valeurs contenues :
...
ns [41] ≡ ∗(a+41)
Boucles et pointeurs

MATH : ajout apres le cours − > vérifier en 2024 s’il n’y a pas des
redites avec la suite somme tab avec arithmétique pointeur.
1 f l o a t somme tab ( f l o a t t a b [ ] , i n t l e n ) {
2 /∗ donne l a somme d e s é l é ments du t a b l e a u t a b
3 Hypoth è s e : t a b e s t de l o n g u e u r l e n
4 ∗/
5 float r = 0;
6 f l o a t ∗a = tab ;
7 int d;
8 f o r ( d =0; d < l e n ; d++) {
9 r = r + ∗ ( a+d ) ;
10 }
11 return r ;
12 }
Boucles et pointeurs (suite)
MATH : ajout apres le cours − > vérifier en 2024 s’il n’y a pas des
redites avec la suite Arithmétique pointeur : opérateur d’incrément
On fait ≪avancer≫ le pointeur
1 f l o a t somme tab ( f l o a t tab [ ] , i n t l e n ) {
2 /∗ donne l a somme d e s é l é ments du t a b l e a u t a b
3 Hypoth è s e : t a b e s t de l o n g u e u r l e n
4 ∗/
5 float r = 0;
6 f l o a t ∗a ;
7 f o r ( a = tab ; a < t a b+l e n ; a++) {
8 r = r + ∗a ;
9 }
10 return r ;
11 }

Rappel : addition et incrément de pointeurs dépendent du type

pointé
Ici :
tab+len ajoute en fait sizeof ( float ) octets à l’adresse de tab
Fonctions et pointeurs
MATH : ajout apres le cours − > vérifier en 2024 s’il n’y a pas des
redites avec la suite
Qu’affiche ce programme ?
1 void AfficheTab ( int t [] , int n ) {
2 int i ;
3 printf ( " t =% p t :% p \ n " , t , t +1) ;
4 for ( i =0; i < n ; i ++) {
5 printf ( " t [% d ]:% d \ n " , i , t [ i ]) ;
6 }
7 }
8
9 int main () {
10 int tI [4]={1 ,2 ,3 ,4};
11 printf ( " tI =% p tI +1:% p \ n " , tI , tI +1) ;
12 AfficheTab ( tI ,4) ;
13 AfficheTab ( tI +1 ,3) ;
14 return 0;
15 }
Fonctions et pointeurs : scanf

La fonction scanf :
1 void i n i t t a b ( i n t tab [ ] , i n t t a i l l e )
2 {
3 int i = 0;
4 f o r ( i =0; i < t a i l l e ; i ++) {
5 p r i n t f ( ” t a b [%d ] = ? : ”, i);
6 s c a n f ( ”%d” , t a b+i ) ; // a d r e s s e de l a i e m e c a s e
7 }
8 p r i n t f ( ” \n” ) ;
9 }
10
11 i n t main ( ) {
12 i n t tab [ 5 ] ;
13 i n i t t a b ( tab , 5 ) ;
14 return 0;
15 }
Fonctions et pointeurs
https://app.wooclap.com/HPEDPE

Qu’affiche ce programme ?
1 void AfficheTab ( int t [] , int n ) {
2 int i ;
3 printf ( " t =% p t :% p \ n " , t , t +1) ;
4 for ( i =0; i < n ; i ++) {
5 printf ( " t [% d ]:% d \ n " , i , t [ i ]) ;
6 }
7 }
8
9 int main () {
10 int tI [4]={1 ,2 ,3 ,4};
11 printf ( " tI =% p tI +1:% p \ n " , tI , tI +1) ;
12 AfficheTab ( tI ,4) ;
13 AfficheTab ( tI +1 ,3) ;
14 return 0;
15 }
C’est tout pour aujourd’hui !