Ce guide explique les différences entre...
Cet article vous montre comment déclarer un pointeur en C à travaers des cas pratique et s’étale aussi sur les méthodes qui permettent un débogage rapide.
Un pointeur en C est une variable qui stocke l’adresse d’une autre variable. Ce guide couvre la déclaration, l’utilisation et le débogage des pointeurs à travers un cas pratique.
Pour déclarer un pointeur :
type *nom_du_pointeur;
type : Type de données de la variable pointée.* : Indique que c’est un pointeur.nom_du_pointeur : Nom de la variable pointeur.int a = 10; // Variable normale
int *p; // Déclaration d'un pointeur
p = &a; // Initialisation du pointeur avec l'adresse de `a`
&a : Opérateur d’adresse qui donne l’adresse de a.p stocke l’adresse de a.#include <stdio.h>
int main() {
int a = 10;
int *p = &a; // Déclare et initialise un pointeur
printf("Valeur de a : %d\n", a); // Affiche la valeur de `a`
printf("Adresse de a : %p\n", (void *)&a); // Affiche l'adresse de `a`
printf("Valeur de p : %p\n", (void *)p); // Affiche l'adresse stockée dans `p`
printf("Valeur pointée par p : %d\n", *p); // Affiche la valeur pointée par `p`
return 0;
}
Un pointeur peut être utilisé pour modifier directement la valeur d’une variable :
*p = 20; // Modifie la valeur de `a` via le pointeur
NULL).int *p = NULL; // Initialisé pour éviter une utilisation indéfinie*p lorsque p == NULL entraîne une erreur d’exécution (segmentation fault).if (p != NULL) { printf("%d\n", *p); }free(p), l’adresse reste dans p mais la mémoire est inutilisable.NULL après un free.free(p); p = NULL;#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int *)malloc(sizeof(int)); // Allocation dynamique
if (p == NULL) {
printf("Erreur : allocation de mémoire échouée.\n");
return 1;
}
*p = 25; // Assigner une valeur
printf("Valeur pointée : %d\n", *p);
free(p); // Libérer la mémoire
p = NULL; // Éviter un pointeur dangling
return 0;
}
valgrind ./mon_programme%p) et les valeurs pointées pour valider vos pointeurs.gdb ./mon_programme break : Ajouter un point d’arrêt.run : Exécuter le programme.print : Inspecter les valeurs.-fsanitize=address pour détecter les erreurs de pointeurs.gcc -fsanitize=address -o mon_programme mon_programme.cNULL.Cas Avancés : Utilisation des Pointeurs en C
Les pointeurs permettent d’exploiter tout le potentiel du langage C, en particulier pour la manipulation avancée de données, la gestion dynamique de mémoire, et l’optimisation des performances. Voici des cas pratiques et avancés avec des explications.
Les pointeurs peuvent être utilisés pour manipuler directement les éléments d’un tableau :
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40};
int *p = arr; // Un tableau est équivalent à un pointeur vers son premier élément
for (int i = 0; i < 4; i++) {
printf("Element %d: %d\n", i, *(p + i)); // *(p + i) équivaut à arr[i]
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 5;
int *arr = (int *)malloc(n * sizeof(int)); // Allocation dynamique
if (arr == NULL) {
printf("Erreur d'allocation mémoire\n");
return 1;
}
for (int i = 0; i < n; i++) {
*(arr + i) = i * 10; // Assignation via le pointeur
}
for (int i = 0; i < n; i++) {
printf("Element %d: %d\n", i, arr[i]); // Accès via le tableau
}
free(arr); // Libérer la mémoire
arr = NULL;
return 0;
}
Utilisez des pointeurs pour modifier des variables dans une fonction appelée :
#include <stdio.h>
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int main() {
int a = 5, b = 10;
printf("Avant échange : a = %d, b = %d\n", a, b);
swap(&a, &b); // Passer les adresses des variables
printf("Après échange : a = %d, b = %d\n", a, b);
return 0;
}
Les chaînes en C sont des tableaux de caractères terminés par \0. Un pointeur peut naviguer dans une chaîne.
#include <stdio.h>
int main() {
char str[] = "Bonjour";
char *p = str;
while (*p != '\0') { // Parcourir jusqu'à la fin de la chaîne
printf("%c ", *p);
p++;
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *str = (char *)malloc(20 * sizeof(char)); // Allocation dynamique
if (str == NULL) {
printf("Erreur d'allocation mémoire\n");
return 1;
}
strcpy(str, "Expansion"); // Copier une chaîne
printf("Chaîne : %s\n", str);
free(str); // Libérer la mémoire
str = NULL;
return 0;
}
Utilisez l’opérateur -> pour accéder aux membres via un pointeur.
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int id;
char name[50];
} Student;
int main() {
Student *s = (Student *)malloc(sizeof(Student)); // Allocation dynamique
if (s == NULL) {
printf("Erreur d'allocation mémoire\n");
return 1;
}
s->id = 101; // Accès aux membres via le pointeur
strcpy(s->name, "Alice");
printf("ID: %d, Name: %s\n", s->id, s->name);
free(s); // Libérer la mémoire
s = NULL;
return 0;
}
Un pointeur de pointeur permet de manipuler l’adresse d’un autre pointeur.
#include <stdio.h>
int main() {
int a = 10;
int *p = &a; // Pointeur vers `a`
int **pp = &p; // Pointeur vers le pointeur `p`
printf("Valeur de a : %d\n", **pp); // Accès indirect à la valeur de `a`
return 0;
}
Créer un tableau dynamique à deux dimensions :
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows = 3, cols = 4;
int **matrix = (int **)malloc(rows * sizeof(int *)); // Tableau de pointeurs
for (int i = 0; i < rows; i++) {
matrix[i] = (int *)malloc(cols * sizeof(int)); // Allocation pour chaque ligne
}
// Remplir la matrice
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
matrix[i][j] = i * cols + j;
}
}
// Afficher la matrice
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
// Libérer la mémoire
for (int i = 0; i < rows; i++) {
free(matrix[i]);
}
free(matrix);
return 0;
}
Les pointeurs peuvent stocker l’adresse d’une fonction pour l’appeler dynamiquement.
#include <stdio.h>
void greet() {
printf("Bonjour !\n");
}
int main() {
void (*func_ptr)() = greet; // Pointeur vers une fonction
func_ptr(); // Appeler la fonction via le pointeur
return 0;
}
Résumé : Les pointeurs en C sont des outils puissants qui permettent de travailler avec des structures de données complexes, d’optimiser la mémoire et de développer des programmes modulaires et performants. La maîtrise des concepts avancés, tels que les pointeurs de pointeurs, les chaînes de caractères dynamiques, et les pointeurs de fonctions, ouvre la voie à des applications plus robustes et flexibles.
Dans toute organisation moderne — entreprise, association, service administratif ou bureau de projet — la…
Dans la pratique comptable, le bilan constitue l’un des documents les plus fondamentaux pour comprendre…
L’analyse linéaire impressionne souvent plus qu’elle ne le devrait. Au moment d’aborder l’oral du bac…
L’analyse linéaire occupe une place centrale à l’oral du bac français. C’est l’exercice qui permet…
Créer une fiche de suivi claire et adaptée à son activité prend souvent plus de…
Comment améliorer sa condition physique tout en travaillant la technique Quand on parle de préparation…
This website uses cookies.