Différences entre versions de « Pointeurs en langage C »

De Didaquest
Aller à la navigationAller à la recherche
 
(12 versions intermédiaires par le même utilisateur non affichées)
Ligne 41 : Ligne 41 :
 
|Définition= <!-- Ne pas Modifier  -->
 
|Définition= <!-- Ne pas Modifier  -->
 
<!-- *************** Commercez les modifications *******************-->
 
<!-- *************** Commercez les modifications *******************-->
 +
La plupart des langages de programmation offrent la possibilité d'accéder aux données dans la mémoire de l'ordinateur à l'aide de pointeurs, c.-à-d. à l'aide de variables auxquelles on peut attribuer les adresses d'autres variables.
  
−
*Un pointeur est une variable contenant l'adresse d'une autre variable d'un type donné. La notion de pointeur fait souvent peur car il s'agit d'une technique de programmation très puissante, permettant de définir des structures dynamiques, c'est-à-dire qui évoluent au cours du temps (par opposition aux tableaux par exemple qui sont des structures de données statiques, dont la taille est figée à la définition).
+
En C, les pointeurs jouent un rôle primordial dans la définition de fonctions: Comme le passage des paramètres en C se fait toujours par la valeur, les pointeurs sont le seul moyen de changer le contenu de variables déclarées dans d'autres fonctions. Ainsi le traitement de tableaux et de chaînes de caractères dans des fonctions serait impossible sans l'utilisation de pointeurs.
 +
 
 +
En outre, les pointeurs nous permettent d'écrire des programmes plus compacts et plus efficients et fournissent souvent la seule solution raisonnable à un problème. Ainsi, la majorité des applications écrites en C profitent des pointeurs.
 +
 
 +
'''Un pointeur''' est une variable contenant '''l'adresse''' d'une autre variable d'un type donné.  
 +
 
 +
La notion de pointeur fait souvent peur car il s'agit d'une technique de programmation très puissante, permettant de définir des structures dynamiques, c'est-à-dire qui évoluent au cours du temps.
  
 
<!-- ******** Fin Définition Générale ***************************** -->
 
<!-- ******** Fin Définition Générale ***************************** -->
Ligne 54 : Ligne 61 :
 
Ici, pointer signifie « faire référence à ». En pratique, un pointeur est une variable qui contient une valeur de type ‘adresse’ et pas la valeur d'un des types vus précédemment. C’est donc une variable dont le contenu est l'adresse mémoire d'une autre variable (objet), c'est-à dire la position en mémoire de cette autre variable (objet). Un pointeur permet donc de retrouver la valeur d'une variable (par son adresse) et d'y accéder. On dit aussi que le pointeur renvoie ou ‘pointe’ vers la variable concernée, cela via son contenu consistant en l’adresse de cette variable. La variable (objet) pointée peut être référencée via le pointeur.
 
Ici, pointer signifie « faire référence à ». En pratique, un pointeur est une variable qui contient une valeur de type ‘adresse’ et pas la valeur d'un des types vus précédemment. C’est donc une variable dont le contenu est l'adresse mémoire d'une autre variable (objet), c'est-à dire la position en mémoire de cette autre variable (objet). Un pointeur permet donc de retrouver la valeur d'une variable (par son adresse) et d'y accéder. On dit aussi que le pointeur renvoie ou ‘pointe’ vers la variable concernée, cela via son contenu consistant en l’adresse de cette variable. La variable (objet) pointée peut être référencée via le pointeur.
 
*Les pointeurs et les noms de variables ont le même rôle: Ils donnent accès à un emplacement dans la mémoire interne de l'ordinateur. Il faut quand même bien faire la différence:
 
*Les pointeurs et les noms de variables ont le même rôle: Ils donnent accès à un emplacement dans la mémoire interne de l'ordinateur. Il faut quand même bien faire la différence:
−
**Un pointeur est une variable qui peut ‘pointer’ sur différentes adresses.
+
#Un pointeur est une variable qui peut ‘pointer’ sur différentes adresses.
−
**Le nom d'une variable reste toujours lié à la même adresse.
+
#Le nom d'une variable reste toujours lié à la même adresse.
 
Il faut signaler que l’on parle parfois de pointeur dont la valeur est constante (adresse constante).
 
Il faut signaler que l’on parle parfois de pointeur dont la valeur est constante (adresse constante).
 
Par exemple, les noms des tableaux sont des pointeurs constants équivalents à l’adresse de la
 
Par exemple, les noms des tableaux sont des pointeurs constants équivalents à l’adresse de la
Ligne 113 : Ligne 120 :
 
}}<!-- ********************* FIN Fiche Didactique Mots-clés *******************-->
 
}}<!-- ********************* FIN Fiche Didactique Mots-clés *******************-->
  
−
= {{Widget:Exemples-applications-utilisations-Fiche}} =
+
'''Présentation des Pointeurs'''
−
 
 
  
 
<!-- *************** Début Fiche Didactique Explicitations ***************** -->
 
<!-- *************** Début Fiche Didactique Explicitations ***************** -->
Ligne 122 : Ligne 128 :
 
<!-- Compléter les pointillés et Supprimer les lignes non utilisées          -->
 
<!-- Compléter les pointillés et Supprimer les lignes non utilisées          -->
 
<!-- ****************** Commercez les modifications ***********************  -->
 
<!-- ****************** Commercez les modifications ***********************  -->
 +
== Comprendre la notion d'adresse ==
 +
un pointeur est une variable qui permet de stocker une adresse, il est donc nécessaire de comprendre ce qu'est une adresse.
  
−
Techniquement, il y a trois utilisations majeures des pointeurs en C :
+
Lorsque l'on exécute un programme, celui-ci est stocké en mémoire,cela signifie que d'une part le code à exécuter est stocké, mais aussi
 +
que chaque variable que l'on a défini a une zone de mémoire qui lui est réservée, et la taille de cette zone correspond au type de variable que l'on a déclaré.
  
−
*Le passage de références à des fonctions
+
En réalité la mémoire est constituée de plein de petites cases de 8 bits (un octet). Une variable, selon son type (donc sa taille), va ainsi occuper
−
*La manipulation de données complexes
+
une ou plusieurs de ces cases (une variable de type char occupera une seule case, tandis qu'une variable de type long occupera 4 cases consécutives).
−
*L’allocation dynamique de mémoire.
 
  
 +
Chacune de ces « cases » (appelées blocs) est identifiée par un numéro.Ce numéro s'appelle adresse.
  
−
'''{{Passage de références à des fonctions}}'''
+
On peut donc accéder à une variable de 2 façons :
−
* Il est parfois souhaitable de modifier une variable d'une fonction appelante. Dès lors, plutôt que de passer la valeur de la variable en argument, c’est une référence vers celle-ci qui sera envoyée à la fonction.
+
 
 +
#grâce à son nom
 +
#grâce à l'adresse du premier bloc alloué à la variable
 +
 
 +
Il suffit donc de stocker l'adresse de la variable dans un pointeur (il est prévu pour cela)
 +
afin de pouvoir accéder à celle-ci (on dit que l'on « pointe vers la variable »).
 +
 
 +
== Adressage ==
 +
 
 +
=== Adressage des variables ===
 +
les deux modes d'adressage principaux sont:
 +
 
 +
==== 1.Adressage direct ====
 +
 
 +
Dans la programmation, nous utilisons des variables pour stocker des informations. La valeur d'une variable se trouve à un endroit spécifique dans la mémoire interne de l'ordinateur. Le nom de la variable nous permet alors d'accéder directement à cette valeur.
 +
 
 +
Adressage direct: Accès au contenu d'une variable par le nom de la variable.
 +
 
 +
Exemple
 +
[[Fichier:adressage direct.gif]]
 +
 
 +
==== 2.Adressage indirect ====
 +
Si nous ne voulons ou ne pouvons pas utiliser le nom d'une variable A, nous pouvons copier l'adresse de cette variable dans une variable spéciale P, appelée pointeur. Ensuite, nous pouvons retrouver l'information de la variable A en passant par le pointeur P.
 +
Adressage indirect: Accès au contenu d'une variable, en passant par un pointeur qui contient l'adresse de la variable.
 +
 
 +
Exemple
 +
 
 +
Soit A une variable contenant la valeur 10 et P un pointeur qui contient l'adresse de A. En mémoire, A et P peuvent se présenter comme suit:
 +
[[Fichier:adressage indirect.gif]]
 +
 
 +
=== Adressage des tableaux ===
 +
le nom d'un tableau représente l'adresse de son premier élément. En d'autre termes:
 +
 
 +
&tableau[0] et tableau sont une seule et même adresse.
 +
 
 +
En simplifiant, nous pouvons retenir que le nom d'un tableau est un pointeur constant sur le premier élément du tableau.
 +
 
 +
Exemple
 +
 
 +
En déclarant un tableau A de type int et un pointeur P sur int,
 +
 
 +
  int A[10];
 +
  int *P;
 +
l'instruction:
 +
P = A; est équivalente à P = &A[0];
 +
 
 +
[[Fichier:Pointeur_et_tableau.gif]]
 +
Si P pointe sur une composante quelconque d'un tableau, alors P+1 pointe sur la composante suivante. Plus généralement,
 +
 
 +
P+i pointe sur la i-ième composante derrière P
 +
 
 +
P-i pointe sur la i-ième composante devant P.
 +
 
 +
Ainsi, après l'instruction,
 +
 
 +
  P = A;
 +
le pointeur P pointe sur A[0], et
 +
 
 +
1.*(P+1) désigne le contenu de A[1]
 +
 
 +
2.*(P+2) désigne le contenu de A[2]
 +
 
 +
...
 +
 
 +
...
 +
 
 +
n.*(P+i) désigne le contenu de A[i]
 +
 
 +
 
 +
== Allocation dynamique de mémoire ==
 +
 
 +
'''Problème'''
 +
 
 +
Souvent, nous devons travailler avec des données dont nous ne pouvons pas prévoir le nombre et la grandeur lors de la programmation. Ce serait alors un gaspillage de réserver toujours l'espace maximal prévisible. Il nous faut donc un moyen de gérer la mémoire lors de l'exécution du programme.
 +
 
 +
'''Exemple'''
 +
 
 +
Nous voulons lire 10 phrases au clavier et mémoriser les phrases en utilisant un tableau de pointeurs sur char. Nous déclarons ce tableau de pointeurs par:
 +
 
 +
'''char *TEXTE[10];'''
 +
 
 +
 
 +
Pour les 10 pointeurs, nous avons besoin de 10*p octets. Ce nombre est connu dès le départ et les octets sont réservés automatiquement. Il nous est cependant impossible de prévoir à l'avance le nombre d'octets à réserver pour les phrases elles-mêmes qui seront introduites lors de l'exécution du programme ...
 +
 
 +
La réservation de la mémoire pour les 10 phrases peut donc seulement se faire pendant l'exécution du programme. Nous parlons dans ce cas de '''l'allocation dynamique de la mémoire'''.
 +
 
 +
=== La fonction malloc() et l'opérateur sizeof ===
 +
 
 +
La fonction malloc de la bibliothèque <stdlib> nous aide à localiser et à réserver de la mémoire au cours d'un programme. La libération de la mémoire ainsi réservée s'effectue avec la fonction free.
 +
 
 +
Cette fonction est déclarée dans l'en-tête <stdlib.h>. le prototype de la fonction malloc() est le suivant :
 +
 
 +
void *malloc(size_t size)
 +
 
 +
Le seul paramètre à passer à malloc est le nombre d'octets à allouer. La valeur retournée est l'adresse du premier octet de la zone mémoire allouée. Si l'allocation n'a pu se réaliser (par manque de mémoire libre), la valeur de retour est la constante NULL.
 +
 
 +
'''Exemple'''
 +
 
 +
Nous voulons réserver de la mémoire pour X valeurs du type int; la valeur de X est lue au clavier:
 +
 
 +
int X;
 +
int *PNum;
 +
printf("Introduire le nombre de valeurs :");
 +
scanf("%d", &X);
 +
PNum = malloc(X*sizeof(int));
 +
 
 +
=== La fonction free() ===
 +
 
 +
Si nous n'avons plus besoin d'un bloc de mémoire que nous avons réservé à l'aide de malloc, alors nous pouvons le libérer à l'aide de la fonction free de la bibliothèque <stdlib>.
 +
 
 +
'''free( <Pointeur> )'''
 +
 
 +
libère le bloc de mémoire désigné par le <Pointeur>; n'a pas d'effet si le pointeur a la valeur zéro.
 +
 
 +
'''Attention !'''
 +
 
 +
* La fonction free peut aboutir à un désastre si on essaie de libérer de la mémoire qui n'a pas été allouée par malloc.
 +
 
 +
* La fonction free ne change pas le contenu du pointeur; il est conseillé d'affecter la valeur zéro au pointeur immédiatement après avoir libéré le bloc de mémoire qui y était attaché.
 +
 
 +
* Si nous ne libérons pas explicitement la mémoire à l'aide free, alors elle est libérée automatiquement à la fin du programme.
  
−
'''{{Manipulation de données complexe}}'''
 
−
*Jusqu’à présent, nous avons manipulé des données simples : int, double, char, etc. Cependant, le C nous permet également d’utiliser des données plus complexes qui sont en fait des agrégats (un regroupement si vous préférez) de données simples. Or, il n’est possible de manipuler ces agrégats qu’en les parcourant donnée simple par donnée simple, ce qui requiert de disposer d’une référence vers les données qui le composent.
 
  
−
'''{{L’allocation dynamique de mémoire}}'''
 
−
*Il n’est pas toujours possible de savoir quelle quantité de mémoire sera utilisée par un programme. En effet, si vous prenez le cas d’un logiciel de dessin, ce dernier ne peut pas prévoir quelle sera la taille des images qu’il va devoir manipuler. Pour pallier ce problème, les programmes recourent au mécanisme de l’allocation dynamique de mémoire : ils demandent de la mémoire au système d’exploitation lors de leur exécution. Pour que cela fonctionne, le seul moyen est que le système d’exploitation fournisse au programme une référence vers la zone allouée.
 
 
}}<!--************** Fin Fiche Didactique Explicitations ******************* -->
 
}}<!--************** Fin Fiche Didactique Explicitations ******************* -->
  
Ligne 151 : Ligne 276 :
  
 
* Confusion entre [[Contenu '*' - Adresse '&']]
 
* Confusion entre [[Contenu '*' - Adresse '&']]
 +
* La passage de paramètre dans une fonction
 
* Confusion entre [[Passage par Valeur - Passage par Pointeur]]
 
* Confusion entre [[Passage par Valeur - Passage par Pointeur]]
 
* Erreur fréquente: Ne pas faire l'allocation dynamique pour une variable de type pointeur avant son utilisation
 
* Erreur fréquente: Ne pas faire l'allocation dynamique pour une variable de type pointeur avant son utilisation
Ligne 164 : Ligne 290 :
 
<!-- ************ Commercez les modifications *********************-->
 
<!-- ************ Commercez les modifications *********************-->
  
 +
* [[Quels est l’intérêt des pointeurs]]?
 +
* [[Comment déclarer un pointeur]]?
 +
* [[Comment initialiser un pointeur]]?
 
* [[Quels sont les opérateurs possibles sur les pointeurs]]?
 
* [[Quels sont les opérateurs possibles sur les pointeurs]]?
 
* [[Quels est la différence entre un tableau et un pointeur]]?
 
* [[Quels est la différence entre un tableau et un pointeur]]?
 
* [[Comment allouer un tableau en utilisant les pointeurs]]?
 
* [[Comment allouer un tableau en utilisant les pointeurs]]?
 
* [[A quoi sert la fonction malloc() et quand est-ce qu'on l'utilise]]?
 
* [[A quoi sert la fonction malloc() et quand est-ce qu'on l'utilise]]?
 +
* [[Quelle est la différence entre malloc() et calloc()]]?
 +
* [[Que fait la fonction réalloc()]]?
 
* [[A quoi sert la fonction free()]]?
 
* [[A quoi sert la fonction free()]]?
 
* [[Que signifie allocation dynamique]]?
 
* [[Que signifie allocation dynamique]]?
Ligne 174 : Ligne 305 :
  
 
= {{Widget:Liens-enseignement-Fiche}} =
 
= {{Widget:Liens-enseignement-Fiche}} =
−
 
−
== {{Widget:Idées ou Réflexions liées à son enseignement-Fiche}} ==
 
−
 
−
 
−
<!-- ************** Début Fiche Didactique Idées-Enseignement ******************-->
 
−
{{Fiche Didactique Idées-Enseignement <!------------------------------------------>
 
−
<!-- Espace de réflexions et d'idées pour l'Enseignement lié à cette thématique -->
 
−
|Idées-Enseignement= <!-- ----------------------------------------------------  -->
 
−
<!-- Complétez les pointillés et Supprimez les lignes non utilisées          ----->
 
−
<!-- ****************** Commercez les modifications **************************  -->
 
−
 
−
* ..................                                               
 
−
:* .................
 
−
* ..................                                               
 
−
:* .................                                               
 
−
 
−
}}<!-- ************************* Fin Idées-Enseignement ********************** -->
 
−
 
  
 
== {{Widget:Aides et astuces-Fiche}} ==
 
== {{Widget:Aides et astuces-Fiche}} ==
Ligne 202 : Ligne 315 :
 
<!-- ****************** Commercez les modifications **************************  -->
 
<!-- ****************** Commercez les modifications **************************  -->
  
−
* ..................                                               
+
* https://koor.fr/C/Tutorial/Pointeurs.wp                                               
−
:* .................
 
−
* ..................                                               
 
−
:* .................                                                
 
  
 
}}<!-- ************************* Fin Astuces-Enseignement ********************** -->
 
}}<!-- ************************* Fin Astuces-Enseignement ********************** -->
Ligne 231 : Ligne 341 :
 
<!-- ****************** Commercez les modifications *********************-->
 
<!-- ****************** Commercez les modifications *********************-->
  
−
* ..................                                               
+
* https://zestedesavoir.com/tutoriels/755/le-langage-c-1/1043_aggregats-memoire-et-fichiers/4277_les-pointeurs/                                             
−
* ..................
+
* https://www.ltam.lu/cours-c/prg-c88.htm
−
* ..................                                               
+
* https://www.commentcamarche.net/contents/116-les-pointeurs-en-langage-c                                                                                           
−
* ..................                                               
 
  
 
}}<!-- ************* Fin Fiche Didactique Bibliographie *************** -->
 
}}<!-- ************* Fin Fiche Didactique Bibliographie *************** -->
  
 
{{Widget:Fiche-Conceptuelle-Bas}}
 
{{Widget:Fiche-Conceptuelle-Bas}}

Version actuelle datée du 5 juin 2020 à 15:43


Autres Fiches Conceptuelles
Posez une Question


(+)

Target Icon.pngVotre Publicité sur le Réseau Target Icon.png

Puce-didaquest.png Traduction

Emblem-important-blue.svg

Pointeur (Français) / Pointer (Anglais)

(+)


More-didaquest.png Traductions


Puce-didaquest.png Définition

Domaine, Discipline, Thématique


More-didaquest.png Justification


Définition écrite

Emblem-important-blue.svg

La plupart des langages de programmation offrent la possibilité d'accéder aux données dans la mémoire de l'ordinateur à l'aide de pointeurs, c.-à-d. à l'aide de variables auxquelles on peut attribuer les adresses d'autres variables.

En C, les pointeurs jouent un rôle primordial dans la définition de fonctions: Comme le passage des paramètres en C se fait toujours par la valeur, les pointeurs sont le seul moyen de changer le contenu de variables déclarées dans d'autres fonctions. Ainsi le traitement de tableaux et de chaînes de caractères dans des fonctions serait impossible sans l'utilisation de pointeurs.

En outre, les pointeurs nous permettent d'écrire des programmes plus compacts et plus efficients et fournissent souvent la seule solution raisonnable à un problème. Ainsi, la majorité des applications écrites en C profitent des pointeurs.

Un pointeur est une variable contenant l'adresse d'une autre variable d'un type donné.

La notion de pointeur fait souvent peur car il s'agit d'une technique de programmation très puissante, permettant de définir des structures dynamiques, c'est-à-dire qui évoluent au cours du temps.

(+)


  • La mémoire est découpée en octets. Chaque octet est repéré par son numéro d'ordre, ou adresse (emplacement en mémoire).
  • Un pointeur ‘pointe’ vers un octet en indiquant son adresse (une valeur).

Ici, pointer signifie « faire référence à ». En pratique, un pointeur est une variable qui contient une valeur de type ‘adresse’ et pas la valeur d'un des types vus précédemment. C’est donc une variable dont le contenu est l'adresse mémoire d'une autre variable (objet), c'est-à dire la position en mémoire de cette autre variable (objet). Un pointeur permet donc de retrouver la valeur d'une variable (par son adresse) et d'y accéder. On dit aussi que le pointeur renvoie ou ‘pointe’ vers la variable concernée, cela via son contenu consistant en l’adresse de cette variable. La variable (objet) pointée peut être référencée via le pointeur.

  • Les pointeurs et les noms de variables ont le même rôle: Ils donnent accès à un emplacement dans la mémoire interne de l'ordinateur. Il faut quand même bien faire la différence:
  1. Un pointeur est une variable qui peut ‘pointer’ sur différentes adresses.
  2. Le nom d'une variable reste toujours lié à la même adresse.

Il faut signaler que l’on parle parfois de pointeur dont la valeur est constante (adresse constante). Par exemple, les noms des tableaux sont des pointeurs constants équivalents à l’adresse de la première composante du tableau concerné.


More-didaquest.png Pointeurs en langage C - Historique (+)


Définition graphique

Emblem-important-blue.svg

  • Notion de pointeur


Emblem-important-blue.svg


Emblem-important-blue.svg

{{{AutresMedias}}}


Puce-didaquest.png Concepts ou notions associés


More-didaquest.png Pointeurs en langage C - Glossaire / (+)



Présentation des Pointeurs



Comprendre la notion d'adresse

un pointeur est une variable qui permet de stocker une adresse, il est donc nécessaire de comprendre ce qu'est une adresse.

Lorsque l'on exécute un programme, celui-ci est stocké en mémoire,cela signifie que d'une part le code à exécuter est stocké, mais aussi que chaque variable que l'on a défini a une zone de mémoire qui lui est réservée, et la taille de cette zone correspond au type de variable que l'on a déclaré.

En réalité la mémoire est constituée de plein de petites cases de 8 bits (un octet). Une variable, selon son type (donc sa taille), va ainsi occuper une ou plusieurs de ces cases (une variable de type char occupera une seule case, tandis qu'une variable de type long occupera 4 cases consécutives).

Chacune de ces « cases » (appelées blocs) est identifiée par un numéro.Ce numéro s'appelle adresse.

On peut donc accéder à une variable de 2 façons :

  1. grâce à son nom
  2. grâce à l'adresse du premier bloc alloué à la variable

Il suffit donc de stocker l'adresse de la variable dans un pointeur (il est prévu pour cela) afin de pouvoir accéder à celle-ci (on dit que l'on « pointe vers la variable »).

Adressage

Adressage des variables

les deux modes d'adressage principaux sont:

1.Adressage direct

Dans la programmation, nous utilisons des variables pour stocker des informations. La valeur d'une variable se trouve à un endroit spécifique dans la mémoire interne de l'ordinateur. Le nom de la variable nous permet alors d'accéder directement à cette valeur.

Adressage direct: Accès au contenu d'une variable par le nom de la variable.

Exemple Adressage direct.gif

2.Adressage indirect

Si nous ne voulons ou ne pouvons pas utiliser le nom d'une variable A, nous pouvons copier l'adresse de cette variable dans une variable spéciale P, appelée pointeur. Ensuite, nous pouvons retrouver l'information de la variable A en passant par le pointeur P. Adressage indirect: Accès au contenu d'une variable, en passant par un pointeur qui contient l'adresse de la variable.

Exemple

Soit A une variable contenant la valeur 10 et P un pointeur qui contient l'adresse de A. En mémoire, A et P peuvent se présenter comme suit: Adressage indirect.gif

Adressage des tableaux

le nom d'un tableau représente l'adresse de son premier élément. En d'autre termes:

&tableau[0] et tableau sont une seule et même adresse.

En simplifiant, nous pouvons retenir que le nom d'un tableau est un pointeur constant sur le premier élément du tableau.

Exemple

En déclarant un tableau A de type int et un pointeur P sur int, 

  int A[10];
  int *P;

l'instruction: P = A; est équivalente à P = &A[0];

Pointeur et tableau.gif Si P pointe sur une composante quelconque d'un tableau, alors P+1 pointe sur la composante suivante. Plus généralement,

P+i pointe sur la i-ième composante derrière P

P-i pointe sur la i-ième composante devant P.

Ainsi, après l'instruction, 

  P = A;

le pointeur P pointe sur A[0], et

1.*(P+1) désigne le contenu de A[1]

2.*(P+2) désigne le contenu de A[2]

...

...

n.*(P+i) désigne le contenu de A[i]


Allocation dynamique de mémoire

Problème

Souvent, nous devons travailler avec des données dont nous ne pouvons pas prévoir le nombre et la grandeur lors de la programmation. Ce serait alors un gaspillage de réserver toujours l'espace maximal prévisible. Il nous faut donc un moyen de gérer la mémoire lors de l'exécution du programme.

Exemple

Nous voulons lire 10 phrases au clavier et mémoriser les phrases en utilisant un tableau de pointeurs sur char. Nous déclarons ce tableau de pointeurs par:

char *TEXTE[10];


Pour les 10 pointeurs, nous avons besoin de 10*p octets. Ce nombre est connu dès le départ et les octets sont réservés automatiquement. Il nous est cependant impossible de prévoir à l'avance le nombre d'octets à réserver pour les phrases elles-mêmes qui seront introduites lors de l'exécution du programme ...

La réservation de la mémoire pour les 10 phrases peut donc seulement se faire pendant l'exécution du programme. Nous parlons dans ce cas de l'allocation dynamique de la mémoire.

La fonction malloc() et l'opérateur sizeof

La fonction malloc de la bibliothèque <stdlib> nous aide à localiser et à réserver de la mémoire au cours d'un programme. La libération de la mémoire ainsi réservée s'effectue avec la fonction free.

Cette fonction est déclarée dans l'en-tête <stdlib.h>. le prototype de la fonction malloc() est le suivant :

void *malloc(size_t size)

Le seul paramètre à passer à malloc est le nombre d'octets à allouer. La valeur retournée est l'adresse du premier octet de la zone mémoire allouée. Si l'allocation n'a pu se réaliser (par manque de mémoire libre), la valeur de retour est la constante NULL.

Exemple

Nous voulons réserver de la mémoire pour X valeurs du type int; la valeur de X est lue au clavier:

int X; int *PNum; printf("Introduire le nombre de valeurs :"); scanf("%d", &X); PNum = malloc(X*sizeof(int));

La fonction free()

Si nous n'avons plus besoin d'un bloc de mémoire que nous avons réservé à l'aide de malloc, alors nous pouvons le libérer à l'aide de la fonction free de la bibliothèque <stdlib>.

free( <Pointeur> )

libère le bloc de mémoire désigné par le <Pointeur>; n'a pas d'effet si le pointeur a la valeur zéro.

Attention !

  • La fonction free peut aboutir à un désastre si on essaie de libérer de la mémoire qui n'a pas été allouée par malloc.
  • La fonction free ne change pas le contenu du pointeur; il est conseillé d'affecter la valeur zéro au pointeur immédiatement après avoir libéré le bloc de mémoire qui y était attaché.
  • Si nous ne libérons pas explicitement la mémoire à l'aide free, alors elle est libérée automatiquement à la fin du programme.

(+)


Puce-didaquest.png Erreurs ou confusions éventuelles

Emblem-important-blue.svg

(+)



Puce-didaquest.png Questions possibles



Puce-didaquest.png Liaisons enseignements et programmes

Aides et astuces



Education: Autres liens, sites ou portails




Puce-didaquest.png Bibliographie

Emblem-important-blue.svg

Pour citer cette page: (en langage C) 

ABROUGUI, M & al, 2020. Pointeurs en langage C. In Didaquest [en ligne]. <http:www.didaquest.org/wiki/Pointeurs_en_langage_C>, consulté le 29, décembre, 2024


Récupérée de « https://didaquest.org/w/index.php?title=Pointeurs_en_langage_C&oldid=62715 »