TD2 : les pointeurs Université de Batna 2 Algorithmique et structures de données

TD2

Exercice1 :

Quelle est la différence entre une variable statique et une variable dynamique ?

Exercice2 :

Soit P un pointeur qui "pointe" sur un tableau A:

int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
int *P;
P = A;
Sachant que A [0] prend l’adresse = #100 (en décimal). Quelles valeurs ou adresses (en décimal) fournissent ces expressions:
• *P+2
• *(P+2)
• P+1
• &A[4]-3
• A+3
• &A[7]-P
• *P+(*P-10)
• *(P+*(P+8)-A[7])

Exercice 3 :

a) Écrire un programme qui permet de créer et de lire deux tableaux A et B « leurs taille respective : N et M» en utilisant
seulement des pointeurs.

b) Ajouter l’ensemble d’instructions qui permet de fusionner ces 2 tableaux en un autre T (sa taille = N+M) et de supprimer A
et B.

c) Ecrire une fonction qui permet d’afficher le contenu d’un tableau T.

NB : Utiliser le formalisme pointeur à chaque fois que cela est possible.

Exercice4 :

La fonction sizeof(TYPE) en langage C permet de calculer l’espace mémoire nécessaire pour un type donné (simple ou structuré).

a) Expliquer le principe de calcule utilisé par cette fonction afin de calculer la taille d’un type structuré
b) Calculer la taille des types suivants :

Struct type1 { Struct type2 { Struct type3 { Struct type4 {

Char c1 ; Int x ; Char c ; Char S [9] ;
Char c2 ; Double y ; Int x ; Int x ;
Char c3 ; } Double y ; Double y ;
Int x ; } }
}

M. bada 1

TD2 : les pointeurs Université de Batna 2 Algorithmique et structures de données

Exo1 :
La différence :
Var Statique Var dynamique

Temps d’occupation Réservé jusqu'à la fin du pgm Pendant un temps fini (selon le besoin)

Allocation Au debut du pgm A n’importe quel moment

Identificateur Possède un identificateur Ne possède pas un identificateur (on

utilise le pointeur pour accéder a cette
variable *P)

Exo2 : int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
*P+2 ! 12 +2 = 14
*(P+2) ! *(#100 +2) = *(#108) = A[2] = 34
P+1 ! (#100+1) = (#104) = &A[1]
&A[4]-3 ! & A[1] = #104
A+3 ! &A[3] = #112
&A[7]-P ! (P+7)-P = 7 éléments
*P+(*P-10) ! 12 + (12-10) = 12+ 2 = 14
*(P+*(P+8)-A[7]) ! * (#100 + A[8] –A[7]) = *(#100 +90-89) = *(#100+1) = A[1]= 23

Exo3 :
Q1
main()
{
int N,M;
int* A;
int* B;

printf("\nEntrez la taille du tableau 1 \n");

scanf("%d",&N);

printf("\\nEntrez la taille du tableau 2\n");

scanf("%d",&M);

/*allocationmémoire*/
A=(int*)malloc(N*sizeof(int)); // réserver un espace memoire : N * 4 Octets
B=(int*)malloc(M*sizeof(int));

/*lire les elements */

int i;

printf("\\nEntrez les éléments du tableau 1\n");

for(i=0;i<N;i++){
scanf("%d", (A+i)); //&A[i] " (A+i) : dans scanf on met tjr l’@ de la variable
}

printf("\\nEntrez les éléments du tableau 2\n");

for(i=0;i<taille2;i++){
scanf("%d", (B+i) );
}
}

M. bada 2

TD2 : les pointeurs Université de Batna 2 Algorithmique et structures de données

Q2. Sol1 :

/*fusiondesdeuxtableaux*/
int* T;
int* debut;

T=(int*)malloc((N+M)*sizeof(int));

debut=T;

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

if(i<N)
{
*T=*A;
T++;
A++;

}
else
{
*T=*B;
T++;
B++;

}
T=debut;

Sol2

/*fusiondesdeuxtableaux*/
int* T;
int* debut;

T=(int*)malloc((N+M)*sizeof(int));

//copier les éléments du A dans la 1ere partie du T

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

*(T+i) = *(A+i) ;
}

//copier les éléments du B dans la 2eme partie du T

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

*(T+i) = *(B+j) ;
}

free (A) ;
free (B) ;

M. bada 3

TD2 : les pointeurs Université de Batna 2 Algorithmique et structures de données

Q3

Sol1 : sans pointeurs

void afficher (int TAB[],int N)
{
int i;
for(i=0;i<N;i++)
printf("%d",TAB[i]);
}

//l’appel dans le main :

afficher (T , N+M);

Sol1 : en utilisant seulement les pointeurs

void afficher(int* TAB ,int N)

{
int i;
for(i=0;i<N;i++)
printf("%d", *(TAB+i));

//l’appel dans le main :

afficher (T , N+M);

Exo4 :

1 . on utilise le principe de rembourrage (arranger les données du même type d’une manière contiguë de telle sorte on divise
la mémoire en un ensemble de blocs / taille = le type le plus grand ):

type1 : le type le plus grand dans cette structure est INT ! diviser la mémoire en bloc de 4 Octets

les 1er 4 octets (1er bloc) c’est pour X , le 2eme bloc (4 octets ) c’est pour c1, c2 et c3.

! gaspillage de 1 octet

type2 : le 1er bloc : 8 octets pour Y , le 2eme bloc : 4 octets pour X et 4 vide . ! total = 16 octets

type3 : 24 octets
type4 : 32 octets

M. bada 4