Les pointeurs sont le cauchemar de chaque nouveau programmeur C. Cependant, ils sont également la caractéristique qui a fait de C le langage de programmation puissant et répandu qu’il est jusqu’à ce jour. Comme beaucoup d'autres fonctions et concepts de programmation, il existe une approche systématique pour créer et utiliser des pointeurs C. Cet article est un guide étape par étape pour créer et utiliser des pointeurs de manière claire et simple.

Informations préalables

  • Les pointeurs sont des variables qui contiennent l'adresse d'un emplacement de mémoire en général (cet emplacement de mémoire peut contenir les données de la variable ou ne pas être encore attribué).
  • Les références sont des variables contenant l'adresse mémoire d'une autre variable.
  • La principale différence entre une référence et un pointeur réside dans le fait que les références pointent vers des emplacements mémoire alloués tandis que les pointeurs peuvent pointer vers des emplacements mémoire non alloués.
  • Il y a une différence entre l'opérateur d'adresse (utilisé sur les variables pour renvoyer leur adresse en mémoire), l'opérateur de déclaration de référence (utilisé dans une déclaration de référence pour indiquer que la variable déclarée est une référence) et l'opérateur "et" tous ayant le même symbole (&)
  • Les pointeurs peuvent être incrémentés et décrémentés (ce qui vous permet de modifier l’emplacement du pointeur).
  • Les pointeurs peuvent être affectés en utilisant l'une des méthodes suivantes:
    • Assigner une référence au pointeur faisant pointer le pointeur vers le même emplacement en mémoire que la référence.
    • Affecter n'importe quel autre pointeur du même type au pointeur, les deux pointant vers le même emplacement.
    • L'affectation d'une valeur numérique au pointeur (au format hexadécimal) fait pointer le pointeur sur l'emplacement de mémoire spécifique adressé par ce chiffre.
    • Affecter l'adresse d'une variable du type du pointeur au pointeur faisant pointer le pointeur sur l'emplacement mémoire du premier octet de la représentation binaire de la variable en mémoire.
  • Les références peuvent être attribuées à l'aide de l'une des méthodes suivantes:
    • Assigner une autre référence à la référence.
    • L'affectation d'une variable du même type que la référence fera référence à la variable.
  • Les pointeurs et les références ont des types de données, indiquant le type de données pointé par le pointeur / référence.
  • Le type d'une référence limite l'affectation de cette référence aux variables / références de ce même type de données. Par exemple, si nous déclarons une référence entière (int & d;), nous ne pouvons affecter qu’une autre référence entière ou une variable entière à cette référence (int i = 0; d = i;)
  • Le type d'un pointeur limite l'affectation du pointeur aux références, aux adresses des variables / pointeurs de ce même type de données. Cela affecte également la récupération des données pointées afin qu'un pointeur entier récupère un nombre d'octets égal au nombre d'octets pris par un entier sur le système. En outre, le choix du type de données affecte la manière dont les pointeurs sont incrémentés et décrémentés. Lorsqu'un pointeur est incrémenté, il pointe vers la valeur de type de données suivante à partir de l'emplacement actuel. Par exemple, si une valeur entière prend 4 octets en mémoire, incrémenter un pointeur entier, le fera pointer sur le nombre entier suivant, soit 4 octets après l’emplacement actuel. La valeur du pointeur lui-même est donc incrémentée de 4.
  • Les noms de variable tableau sont considérés comme des pointeurs statiques / constants pointant vers le premier octet du premier élément du tableau et ayant le même type que les éléments du tableau.

Pas

  1. 1 Déterminez le type du pointeur (c'est-à-dire le type de données sur lequel le pointeur pointera). Les conseils suivants pourraient vous aider:
    • Si vous déclarez un tableau dynamique, utilisez le type de données des éléments du tableau.
    • Si vous déclarez le pointeur pour accéder aux données d'une variable, utilisez le même type de données que la variable.
    • Si vous déclarez que le pointeur traverse une structure de liste, utilisez le type de données du nœud de liste (généralement un utilisateur créé). struct).
    • Si vous déclarez que le pointeur traverse une arborescence, utilisez le type de données du nœud de l'arborescence ou un pointeur sur le type de nœud de l'arborescence comme type (pointeur sur un pointeur de type de nœud d'arborescence!).
  2. 2 Déclarez le pointeur en utilisant une syntaxe comme celle-ci: Type de données * identificateur de pointeur; où
    • Type de données est le type que vous avez décidé à l'étape 1
    • identifiant de pointeur est l'identifiant ou le nom de la variable de pointeur
  3. 3 Attribuez le pointeur à un emplacement mémoire initial. Cela peut être fait en utilisant l'une des méthodes suivantes:
    1. Allouer de la mémoire et lui indiquer par le pointeur: int * i = malloc(taille de(int) * n); où n est le nombre de blocs de mémoire à attribuer.
    2. Affecter l'adresse d'une variable au pointeur: int * i = & x; où "x" est un entier et (&) signifie adresse de.
    3. Affectation d'un identificateur de tableau au pointeur: int * i = array1; où array1 est un tableau entier (int[] array1;).
    4. Assigner une référence au pointeur: int * i = a; où "a" est une référence entière (int & une;).
    5. Assigner un autre pointeur au pointeur: int * i = z; ou "z" est un autre pointeur entier (int * z;)
  4. 4 Chaque fois que vous devez extraire l'élément de données actuellement pointé par le pointeur, utilisez l'opérateur value-at-address (*): int x = * i; où i est un pointeur entier.
  5. 5 Utilisez l'opérateur d'indexation sur le pointeur comme s'il s'agissait d'un tableau à chaque fois que vous souhaitez obtenir un emplacement de mémoire à côté du pointeur sans faire avancer le pointeur. Par exemple, si vous avez un pointeur entier i, vous pouvez utiliser i [2] qui récupérera l'entier situé après l'entier immédiatement après l'entier pointé par la référence (entier égal à 2 entiers après l'emplacement actuel). Le pointeur sera toujours dirigé vers le même emplacement mémoire.Une autre alternative à cela est d'obtenir la valeur du pointeur 2 étapes après ce pointeur: * (i + 2)
  6. 6 Utilisez l'incrément (++), décrémentez (-), + = et - = opérateurs chaque fois que vous devez changer l'emplacement actuel. i + = 5; fera avancer le pointeur entier i 5 entiers vers l’avant.
  7. 7 Une fois que vous avez fini d'utiliser le pointeur, si vous avez alloué de la mémoire à ce pointeur, assurez-vous de libérer la mémoire allouée à l'aide de la fonction free (). (gratuit (i); où je suis un pointeur)