Le QCM en langage C peut être simulé dans un...
L’arithmétique des pointeurs est une fonctionnalité puissante en langage C qui permet de manipuler les adresses mémoire et de naviguer dans des structures de données comme les tableaux en utilisant des pointeurs. Elle repose sur le fait que les pointeurs stockent des adresses, et que ces adresses sont manipulables à l’aide d’opérateurs arithmétiques.
En C, un pointeur ne représente pas seulement une adresse mémoire, il est aussi associé à un type de données (par exemple int*, char*, etc.). Cela permet au compilateur de savoir combien d’octets doivent être “sautés” lors des opérations arithmétiques sur ce pointeur. Voici les principales opérations d’arithmétique des pointeurs :
++)--)+)-)Ces opérations sont couramment utilisées pour parcourir des tableaux ou manipuler des données en mémoire.
++)Lorsque vous incrémentez un pointeur, il ne s’incrémente pas d’un octet mais du nombre d’octets correspondant au type de données vers lequel il pointe.
#include <stdio.h>
int main() {
int tableau[3] = {10, 20, 30};
int *p = tableau; // p pointe vers le premier élément du tableau
printf("Valeur initiale pointée par p : %d\n", *p); // Affiche 10
p++; // Incrémentation du pointeur (il "saute" à l'adresse du prochain entier)
printf("Valeur après incrémentation : %d\n", *p); // Affiche 20
return 0;
}p++ incrémente le pointeur p pour qu’il pointe vers l’élément suivant du tableau.p est un pointeur vers un int, et que chaque int fait généralement 4 octets, le pointeur “saute” de 4 octets pour pointer vers l’élément suivant.--)Similaire à l’incrémentation, mais dans le sens inverse : le pointeur est décrémenté pour pointer vers l’élément précédent.
#include <stdio.h>
int main() {
int tableau[3] = {10, 20, 30};
int *p = &tableau[2]; // p pointe vers le dernier élément
printf("Valeur initiale pointée par p : %d\n", *p); // Affiche 30
p--; // Décrémentation du pointeur
printf("Valeur après décrémentation : %d\n", *p); // Affiche 20
return 0;
}p-- fait en sorte que le pointeur p recule vers l’adresse de l’élément précédent dans le tableau.+, -)En plus des incrémentations et décrémentations unitaires, vous pouvez ajouter ou soustraire des entiers à un pointeur. Cela est utile pour parcourir un tableau ou manipuler des blocs de mémoire.
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau; // p pointe vers le premier élément du tableau
printf("Valeur de tableau[3] via arithmétique des pointeurs : %d\n", *(p + 3)); // Affiche 40
return 0;
}*(p + 3) signifie “l’adresse pointée par p, plus trois entiers”, ce qui correspond à tableau[3]. Le pointeur avance de 3 fois la taille d’un int (généralement 4 octets).#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = &tableau[4]; // p pointe vers le dernier élément du tableau
printf("Valeur après soustraction de 2 : %d\n", *(p - 2)); // Affiche 30
return 0;
}*(p - 2) déplace le pointeur p deux éléments en arrière, ce qui correspond à tableau[2] (valeur 30).Lorsque deux pointeurs pointent vers des éléments du même tableau, il est possible de calculer la distance entre eux en utilisant la soustraction. Le résultat est le nombre d’éléments qui séparent les deux pointeurs.
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p1 = &tableau[1]; // Pointeur sur tableau[1]
int *p2 = &tableau[4]; // Pointeur sur tableau[4]
printf("Distance entre p1 et p2 : %ld\n", p2 - p1); // Affiche 3
return 0;
}p2 - p1 calcule le nombre d’éléments entre tableau[1] et tableau[4], ce qui donne 3.L’arithmétique des pointeurs dépend du type de données auquel le pointeur fait référence, car chaque type a une taille en mémoire différente. Par exemple, un pointeur vers un char (1 octet) incrémente de 1 octet, tandis qu’un pointeur vers un int (4 octets) incrémente de 4 octets.
#include <stdio.h>
int main() {
char c = 'A';
int i = 100;
char *p_char = &c;
int *p_int = &i;
printf("Adresse de c : %p, après incrémentation de p_char : %p\n", p_char, p_char + 1);
printf("Adresse de i : %p, après incrémentation de p_int : %p\n", p_int, p_int + 1);
return 0;
}p_char + 1 incrémente l’adresse de 1 octet (car char est sur 1 octet).p_int + 1 incrémente l’adresse de 4 octets (car int est généralement sur 4 octets).Certaines opérations arithmétiques ne sont pas autorisées avec les pointeurs, car elles n’ont pas de sens en termes d’adresses mémoire :
*) et division (/) : Vous ne pouvez pas multiplier ou diviser des pointeurs.👉 L’arithmétique des pointeurs permet de manipuler efficacement des structures de données comme les tableaux, en déplaçant les pointeurs pour accéder aux différents éléments. Les opérations les plus courantes incluent l’incrémentation, la décrémentation, l’addition et la soustraction, mais il est important de toujours comprendre ce que vous faites, car une mauvaise manipulation des pointeurs peut entraîner des erreurs graves telles que des dépassements de mémoire ou des accès invalides.
Voici quelques exercices corrigés sur l’arithmétique des pointeurs en C, avec des explications détaillées pour vous aider à comprendre chaque étape.
Écrivez un programme qui utilise un pointeur pour accéder et afficher les éléments d’un tableau d’entiers.
#include <stdio.h>
int main() {
int tableau[5] = {1, 2, 3, 4, 5};
int *p = tableau; // Pointeur vers le premier élément du tableau
for (int i = 0; i < 5; i++) {
printf("Élément %d : %d\n", i, *(p + i)); // Accès via l'arithmétique des pointeurs
}
return 0;
}p pointe vers le premier élément du tableau (tableau[0]).*(p + i) permet d’accéder à chaque élément du tableau en utilisant l’arithmétique des pointeurs.Modifiez l’exercice précédent pour afficher les éléments du tableau en incrémentant le pointeur à chaque itération de la boucle.
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau; // Pointeur vers le premier élément du tableau
for (int i = 0; i < 5; i++) {
printf("Élément %d : %d\n", i, *p); // Affiche la valeur pointée par p
p++; // Incrémentation du pointeur pour pointer vers l'élément suivant
}
return 0;
}p++ incrémente le pointeur pour passer à l’élément suivant dans le tableau.Écrivez un programme qui calcule la distance entre deux pointeurs dans un tableau.
#include <stdio.h>
int main() {
int tableau[6] = {5, 10, 15, 20, 25, 30};
int *p1 = &tableau[1]; // Pointeur vers le deuxième élément
int *p2 = &tableau[4]; // Pointeur vers le cinquième élément
// Calcul de la distance entre les deux pointeurs
int distance = p2 - p1;
printf("Distance entre p1 et p2 : %d éléments\n", distance);
return 0;
}p2 - p1 calcule la distance entre les deux pointeurs en termes d’éléments du tableau.tableau[4] - tableau[1] = 3).Écrivez une fonction qui prend deux pointeurs vers des éléments d’un tableau et échange leurs valeurs.
#include <stdio.h>
void echanger(int *p1, int *p2) {
int temp = *p1; // Sauvegarde de la valeur pointée par p1
*p1 = *p2; // p1 prend la valeur pointée par p2
*p2 = temp; // p2 prend la valeur temporaire (ancienne valeur de p1)
}
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
// Affichage du tableau avant l'échange
printf("Avant l'échange : %d, %d\n", tableau[1], tableau[3]);
// Appel de la fonction pour échanger tableau[1] et tableau[3]
echanger(&tableau[1], &tableau[3]);
// Affichage du tableau après l'échange
printf("Après l'échange : %d, %d\n", tableau[1], tableau[3]);
return 0;
}echanger() prend deux pointeurs en argument, qui pointent vers les deux éléments à échanger.p1 et p2 sont échangées à l’aide d’une variable temporaire.tableau[1] (valeur 20) et tableau[3] (valeur 40).Écrivez un programme qui utilise des pointeurs pour inverser les éléments d’un tableau.
#include <stdio.h>
void inverser_tableau(int *arr, int taille) {
int *debut = arr; // Pointeur vers le début du tableau
int *fin = arr + taille - 1; // Pointeur vers la fin du tableau
int temp;
// Inversion des éléments en utilisant des pointeurs
while (debut < fin) {
temp = *debut;
*debut = *fin;
*fin = temp;
debut++; // Avancer le pointeur vers le début
fin--; // Reculer le pointeur vers la fin
}
}
int main() {
int tableau[6] = {1, 2, 3, 4, 5, 6};
// Affichage avant inversion
printf("Avant inversion : ");
for (int i = 0; i < 6; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
// Inversion du tableau
inverser_tableau(tableau, 6);
// Affichage après inversion
printf("Après inversion : ");
for (int i = 0; i < 6; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}inverser_tableau() utilise deux pointeurs : debut pour parcourir le tableau depuis le début et fin depuis la fin.Écrivez une fonction qui trouve et retourne la plus grande valeur d’un tableau d’entiers en utilisant des pointeurs.
#include <stdio.h>
int trouver_max(int *arr, int taille) {
int *p = arr;
int max = *p; // Initialiser le max avec le premier élément
// Parcourir le tableau
for (int i = 1; i < taille; i++) {
p++; // Avancer le pointeur
if (*p > max) {
max = *p; // Mettre à jour le maximum
}
}
return max;
}
int main() {
int tableau[5] = {15, 30, 25, 40, 10};
int max = trouver_max(tableau, 5);
printf("La plus grande valeur du tableau est : %d\n", max);
return 0;
}trouver_max() parcourt le tableau en utilisant un pointeur p, en le déplaçant à chaque itération avec p++.max actuel et met à jour le max si une valeur plus grande est trouvée.Ces exercices couvrent différentes applications de l’arithmétique des pointeurs en C, depuis l’accès aux éléments de tableaux jusqu’à la manipulation plus complexe de structures de données. En pratiquant ces exemples, vous apprendrez à utiliser les pointeurs pour parcourir et modifier des données en mémoire de manière efficace.
Voici une série d’exercices corrigés sur l'utilisation du diagramme de Pareto dans le cadre de…
Télécharger des modèles Excel de gestion de la maintenance industrielle 👇 Ce guide a pour…
Voici un exemple de QCM (Questionnaire à Choix Multiples) sur le thème de la maintenance…
La gestion des mouvements d’entrée et de sortie des marchandises est essentielle pour assurer une…
La méthode ABC en gestion des stocks est une technique de classement qui permet d'optimiser…
Télécharger une Application gestion de stock gratuit Excel 👇🟡🟢 Ce modèle Application gestion de stock…
This website uses cookies.