Cet article concerne l'arithmétique des pointeurs en C++. Les pointeurs sont des variables qui stockent l'adresse mémoire des données. L'arithmétique des pointeurs est une caractéristique puissante dans le monde du langage de programmation C++ qui nous permet de traiter différentes opérations arithmétiques dans lesquelles l'addition, la multiplication, la division, l'incrémentation, la décrémentation et la soustraction impliquent un pointeur pour développer la nouvelle adresse mémoire dans nos tampons mémoire. . Une arithmétique de pointeur crée facilement l’allocation dynamique de mémoire. Dans cet article C++, nous apprendrons comment manipuler l'adresse mémoire de différentes manières à l'aide de pointeurs et fournirons des directives et des exemples appropriés.
Scénario 1 : le pointeur effectue les opérations d'incrémentation et de décrémentation
Ici, nous allons découvrir la manipulation du pointeur pour produire différentes adresses mémoire ayant des objectifs différents. Les pointeurs d'incrémentation et de décrémentation sont également des pointeurs arithmétiques à effet de levier qui augmentent ou diminuent l'adresse d'un facteur de un multiplié par la taille du type de données vers lequel ils pointent. L'extrait de code lié à ce scénario est joint ci-dessous :
#include
en utilisant l'espace de noms std ;
const int Arr_Max = 5 ;
int main ( ) {
int où [ Arr_Max ] = { vingt , 150 , 270 } ;
int * ptr; // déclarer aiguille
ptr = var;
pour ( int je = 0 ; je < Arr_Max ; je++ ) {
std :: cout << 'L'adresse mémoire de l'élément est : [' << je << '] = ' ;
std :: cout << ptr << fin;
cout << 'La valeur par rapport à l'adresse est [' << je << '] = ' ;
cout << * ptr << fin;
std :: cout << 'le pointeur a été incrémenté avec succès' << fin;
ptr++;
}
std :: cout << 'Adresse du pointeur avant décrémentation' << ptr << fin;
ptr--;
std :: cout << 'Adresse du pointeur après décrémentation' << ptr << fin;
retour 0 ;
}
Ici, nous définissons une bibliothèque requise dans le code au tout début : «
Nous passons le tableau au pointeur pour accéder à l'adresse. Comme nous le savons tous, les tableaux contiennent toujours plusieurs éléments situés à différents emplacements. Nous avions donc besoin d'une boucle avec le pointeur « help » pour accéder à chaque élément d'un tableau. Chaque fois que la boucle s'exécute, nous obtenons l'adresse mémoire et les valeurs par rapport à cette adresse à l'aide de l'opérateur d'incrément arithmétique de pointeur « ptr++ » qui décale l'adresse mémoire vers l'adresse suivante de la mémoire. Le cycle d'exécution de la boucle dépend de la taille d'un tableau. En dehors de la boucle, nous voulons ramener le pointeur vers l'adresse mémoire précédente en utilisant simplement le pointeur de décrémentation « ptr- - ».
Exécutez ce code en cliquant sur l'option Exécuter>Compiler et exécuter et vous obtiendrez le résultat suivant :
Espérons que cette sortie soit facile à comprendre. L'adresse et la valeur de la mémoire sont modifiées. Le déplacement du pointeur d’un emplacement n’est possible qu’à partir de l’arithmétique du pointeur d’incrémentation en C++.
Scénario 2 : Soustraire deux pointeurs en C++
Dans ce scénario, nous apprendrons comment soustraire deux ou plusieurs pointeurs en C++. Toutes les opérations arithmétiques dans lesquelles intervient la soustraction sont des processus vitaux car nous ne pouvons soustraire deux pointeurs simultanément que si et seulement s'ils ont le même type de données.
Les autres opérations comme l'addition, la multiplication et la division ne sont pas possibles dans le pointeur car elles n'ont aucun sens en adressage mémoire. L'extrait de code est joint ci-dessous :
#includeint main ( ) {
Il fait signe [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Pour que [ 3 ] ; // Pointeur vers le troisième élément ( 42 )
int * ptrr2 = & Pour que [ 6 ] ; // Pointeur vers le sixième élément ( 89 )
ptrdiff_t ptrsoustraire = ptrr2 - ptrr1 ;
std :: cout << 'La différence entre ces adresses est : ' << ptrsoustraire << ' éléments' << std::endl;
retour 0 ;
}
L'opération de soustraction consiste à trouver la différence entre l'adresse mémoire en C++. Dans la fonction main, nous prenons un tableau qui contient différentes valeurs à différents index. Dans un tableau, chaque index possède un emplacement mémoire différent. Nous ne pouvons trouver la différence entre deux pointeurs qu’à l’aide d’une arithmétique de pointeur. Ici, nous utilisons un type de pointeur spécial « ptrdiff_t » qui doit être utilisé pour trouver les différences entre deux ou plusieurs pointeurs en C++.
La sortie de ce code est jointe ci-dessous :
La différence entre ces adresses se fait par élément étau qui est 3.
Scénario 3 : comparer deux ou plusieurs pointeurs en C++
Dans ce scénario, nous allons apprendre à comparer les différents pointeurs en C++ en utilisant différents opérateurs relationnels comme « == », « <= », « >= », « < », « > ». On ne peut comparer les pointeurs que s'ils pointent vers l'adresse d'éléments d'un même tableau. N'oubliez pas que la comparaison de deux pointeurs de types différents peut entraîner un comportement indéfini. L'extrait de code lié à la comparaison de pointeurs est mentionné dans ce qui suit :
#includeen utilisant l'espace de noms std ;
int main ( )
{
entier arr1 [ dix ] = { 4 , 7 , 9 , onze , 14 , 16 , 18 , vingt , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
si ( ptr1 ==ptr2 )
{
std :: cout << 'les pointeurs sont égaux' << fin;
}
autre si ( ptr3 < =ptr4 )
{
std :: cout << 'ptr3 est inférieur ou égal à ptr4' << fin ;;
}
autre
{
std :: cout << 'les pointeurs ne sont comparés à aucun moment' << fin;
}
retour 0 ;
}
Ici, nous prenons un tableau de 10 éléments. Nous déclarons quatre pointeurs qui pointent vers un index différent du tableau. Après cela, nous comparons ces quatre pointeurs dans des conditions différentes, comme le montre le code donné. Dans la condition « if », vérifiez si le pointeur « ptr1 » est égal au pointeur « ptr2 », puis imprimez les « pointeurs sont égaux ». Lorsque nous avons plusieurs conditions où nous utilisons la condition « else if » pour vérifier si le pointeur « ptr3 » est inférieur ou égal au pointeur « ptr4 ». Après tout cela, cliquez sur le Exécuter > Compiler et exécuter option.
La sortie de ce code est jointe ci-dessous :
Il affiche une condition valide sur l'écran de la console et quitte la compilation. Le pointeur « ptr3 » contient une valeur inférieure ou égale à la valeur de pointage du pointeur « ptr4 ».
Scénario 4 : Afficher un nombre impair avec l'arithmétique du pointeur
Ici, nous verrons comment allouer dynamiquement de la mémoire pour un tableau d’entiers. L'extrait de code lié à ce cas est donné comme suit :
#includeint main ( ) {
nombres entiers [ ] = { 1 , 12 , 33 , 24 , quinze , 776 , 71 , 18 , 29 , cinquante } ;
int * ptrr = nombres ;
std :: cout << 'Nombres impairs dans les tableaux : ' ;
pour ( int je = 0 ; je < dix ; ++je ) {
si ( * ptrr % 2 ! = 0 ) {
std :: cout << * ptrr << ' ' ;
}
ptrr++;
}
std :: cout << std::endl;
retour 0 ;
}
Dans la fonction principale, nous prenons un tableau contenant 10 éléments. Nous avons besoin d’un pointeur qui pointe tous les éléments du tableau pour vérifier le nombre impair du tableau. Dans la boucle « for », vérifiez le nombre impair en divisant l'élément actuel d'un tableau. Le compteur de pointeur est incrémenté après avoir vérifié un élément d'un tableau.
Après avoir exécuté le code, la sortie s'affiche sur l'écran de la console comme suit :
De cette façon, nous pouvons afficher les nombres impairs en utilisant l’arithmétique du pointeur sur l’écran de la console.
Conclusion
Nous concluons ici que l’arithmétique des pointeurs est l’outil le plus efficace pour effectuer différentes opérations en C++. Assurez-vous que le pointeur incrémente ou diminue la valeur d'un tableau ayant le même type de données. Nous pouvons comparer les valeurs d'un tableau par leurs adresses mémoire à l'aide de l'arithmétique des pointeurs dans le langage de programmation C++. Nous pouvons parcourir le tableau et gérer facilement la mémoire à l’aide de l’arithmétique des pointeurs.