Échange de nombres avec des pointeurs en C

Introduction

En programmation C, les pointeurs sont des fonctionnalités puissantes qui nous permettent de manipuler des données en accédant directement aux emplacements mémoire et en les modifiant. Une application courante des pointeurs consiste à échanger les valeurs de deux variables sans utiliser une troisième variable.

Dans ce labo (LabEx), nous allons apprendre à créer un programme C qui échange deux nombres en utilisant des pointeurs. Cette technique est fondamentale dans divers scénarios de programmation et illustre l'utilisation pratique des pointeurs pour la manipulation de la mémoire.

Le labo (LabEx) vous guidera tout au long de la création d'un programme à partir de zéro, de sa compilation et de son exécution pour voir l'échange en action.

Comprendre les pointeurs en C

Avant de commencer à coder, comprenons ce qu'est un pointeur et comment il fonctionne en C.

Qu'est-ce qu'un pointeur ?

Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable. Les pointeurs sont essentiels en C car ils permettent d'accéder directement à la mémoire et d'effectuer une manipulation plus efficace des données.

Syntaxe des pointeurs

En C, les pointeurs sont déclarés à l'aide du symbole astérisque (*) :

int *ptr;    // Déclare un pointeur vers un entier

Lorsque l'on travaille avec des pointeurs, nous utilisons deux opérateurs importants :

L'opérateur d'adresse (&) - obtient l'adresse mémoire d'une variable
L'opérateur de déréférencement (*) - accède à la valeur stockée à l'adresse contenue dans un pointeur

Création de notre premier fichier

Commençons par créer notre fichier C principal dans le répertoire du projet. Ouvrez l'IDE et créez un nouveau fichier nommé main.c :

Dans le panneau de l'explorateur de fichiers (côté gauche), accédez à /home/labex/project
Cliquez avec le bouton droit et sélectionnez "Nouveau fichier"
Nommez le fichier main.c
Ajoutez la structure de base suivante au fichier :

#include <stdio.h>

int main() {
    // Nous allons ajouter notre code ici

    return 0;
}

Cela crée un simple programme C avec la bibliothèque standard d'entrée/sortie incluse et une fonction principale qui retourne 0 lorsque le programme se termine avec succès.

Création de la structure du programme d'échange

Maintenant que nous comprenons les pointeurs, construisons notre programme d'échange étape par étape.

Déclaration des variables et des pointeurs

Nous devons déclarer :

Deux variables entières (a et b) pour stocker les valeurs que nous voulons échanger
Deux pointeurs entiers (ptra et ptrb) pour stocker les adresses de a et b
Une variable temporaire (temp) pour faciliter l'opération d'échange

Mettez à jour votre fichier main.c avec le code suivant :

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // We will add more code here in the next step

    return 0;
}

Compréhension du code

Analysons ce que nous avons fait jusqu'à présent :

Nous avons déclaré deux entiers a et b qui stockeront les valeurs que nous voulons échanger
Nous avons déclaré deux pointeurs entiers ptra et ptrb qui stockeront les adresses mémoire de a et b
Nous avons déclaré un entier temporaire temp qui nous aidera dans l'opération d'échange
Nous avons ajouté du code pour inviter l'utilisateur à entrer des valeurs pour a et b
Nous avons ajouté du code pour afficher les valeurs originales de a et b

Remarquez que dans la fonction scanf, nous utilisons l'opérateur d'adresse (&) pour indiquer à la fonction où stocker les valeurs d'entrée en mémoire.

Implémentation de la logique d'échange

Maintenant, mettons en œuvre la logique d'échange réelle en utilisant des pointeurs.

Attribution des adresses aux pointeurs

Tout d'abord, nous devons faire pointer nos pointeurs vers nos variables en attribuant les adresses de a et b respectivement à ptra et ptrb :

// Assign addresses to pointers
ptra = &a;
ptrb = &b;

Algorithme d'échange utilisant des pointeurs

La clé pour échanger des valeurs avec des pointeurs est de manipuler les valeurs aux emplacements mémoire, pas seulement les pointeurs eux-mêmes. Voici comment nous allons procéder :

Stockez la valeur de a (accédée via *ptra) dans la variable temporaire temp
Attribuez la valeur de b (accédée via *ptrb) à a (en utilisant *ptra)
Attribuez la valeur temporaire (valeur originale de a) à b (en utilisant *ptrb)

Mettez à jour votre fichier main.c en ajoutant le code suivant à l'endroit indiqué à l'étape précédente :

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // Assign addresses to pointers
    ptra = &a;
    ptrb = &b;

    // Display memory addresses (optional but helpful for understanding)
    printf("\nMemory addresses:\n");
    printf("Address of a: %p\n", ptra);
    printf("Address of b: %p\n", ptrb);

    // Swap the values using pointers
    temp = *ptra;    // Store value of a in temp
    *ptra = *ptrb;   // Assign value of b to a
    *ptrb = temp;    // Assign original value of a to b

    // Display swapped values
    printf("\nAfter swapping:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    return 0;
}

Compréhension de la logique d'échange

Comprenons exactement comment l'échange fonctionne :

temp = *ptra; - L'opérateur * déréférence le pointeur, accédant à la valeur à l'emplacement mémoire. Cette ligne stocke la valeur de a dans temp.
*ptra = *ptrb; - Cela attribue la valeur de b à l'emplacement mémoire de a, modifiant effectivement la valeur de a.
*ptrb = temp; - Cela attribue la valeur originale de a (stockée dans temp) à l'emplacement mémoire de b, achevant l'échange.

Après ces opérations, les variables a et b ont échangé leurs valeurs sans être directement modifiées - nous avons seulement modifié les valeurs à leurs emplacements mémoire.

Compilation et test du programme d'échange

Maintenant que nous avons terminé notre programme, compilons-le et exécutons-le pour voir les résultats.

Compilation du programme

Pour compiler le programme, nous utiliserons le compilateur GNU C (gcc). Ouvrez un terminal dans le WebIDE et exécutez la commande suivante :

cd ~/project
gcc main.c -o swap_program

Cette commande compile notre fichier main.c et crée un exécutable nommé swap_program.

Exécution du programme

Maintenant, exécutons notre programme pour voir s'il échange correctement les valeurs :

./swap_program

Vous serez invité à entrer des valeurs pour a et b. Par exemple, entrons :

a = 5
b = 10

Le programme devrait afficher :

Les valeurs originales : a = 5, b = 10
Les adresses mémoire de a et b
Les valeurs échangées : a = 10, b = 5

Compréhension de la sortie

Lorsque vous exécutez le programme, vous verrez plusieurs sections de sortie :

Valeurs originales - Affiche les valeurs avant l'échange
Adresses mémoire - Affiche où les variables sont stockées en mémoire (elles seront différentes à chaque exécution du programme)
Après l'échange - Affiche les valeurs après l'opération d'échange

Essayez d'exécuter le programme plusieurs fois avec différentes valeurs d'entrée pour confirmer que l'échange fonctionne de manière cohérente.

Comment cela fonctionne-t-il en coulisse ?

Visualisons ce qui se passe en mémoire :

Initialement, si a = 5 et b = 10, elles ont chacune leur propre emplacement mémoire
ptra pointe vers l'emplacement mémoire de a
ptrb pointe vers l'emplacement mémoire de b
Pendant l'échange :
- temp reçoit la valeur à ptra (qui est 5)
- La valeur à ptra est changée pour la valeur à ptrb (qui est 10)
- La valeur à ptrb est changée pour temp (qui est 5)
Après l'échange, a = 10 et b = 5, échangeant effectivement leurs valeurs

Cela démontre la puissance des pointeurs - ils nous permettent de modifier indirectement des valeurs en manipulant directement les emplacements mémoire.

Résumé

Dans ce laboratoire (lab), nous avons appris à utiliser les pointeurs en C pour échanger les valeurs de deux variables. Les concepts clés abordés sont les suivants :

Pointeurs : Variables qui stockent les adresses mémoire d'autres variables
Adresses mémoire : Emplacements uniques dans la mémoire de l'ordinateur où les données sont stockées
Opérations sur les pointeurs :
- L'opérateur d'adresse (&) pour obtenir l'adresse mémoire d'une variable
- L'opérateur de déréférencement (*) pour accéder à la valeur à une adresse mémoire
Algorithme d'échange : Utilisation d'une variable temporaire et de pointeurs pour échanger des valeurs

Cette technique est un concept fondamental en programmation C et démontre la puissance des pointeurs pour la manipulation de la mémoire. Elle peut être appliquée dans diverses situations de programmation telles que les algorithmes de tri, les opérations sur les structures de données et les implémentations de fonctions.

En comprenant comment manipuler les données via les adresses mémoire, vous avez franchi une étape importante dans la maîtrise de la programmation C et des concepts de mémoire de l'ordinateur.