Menu

Pointeurs et opérations de pointeur en C ++

pointers pointer operations c

Essayez Notre Instrument Pour Éliminer Les Problèmes

Une étude approfondie des pointeurs et de leurs utilisations en C ++.

Un pointeur est l'une des fonctionnalités les plus puissantes du langage C ++. Un pointeur aide à manipuler les variables via son adresse.

arguments de ligne de commande dans les exemples de script shell

Dans ce didacticiel, nous explorerons en détail tout sur les pointeurs et leurs utilisations en C ++.

=> Regardez la série de formations C ++ simple ici.

POinters en c ++

Ce que vous apprendrez:

Qu'est-ce qu'un pointeur?

Un pointeur est une variable qui contient l'adresse d'un emplacement mémoire. Nous savons que toutes les variables que nous déclarons ont une adresse spécifique en mémoire. Nous déclarons une variable pointeur pour pointer vers ces adresses en mémoire.

La syntaxe générale pour déclarer une variable de pointeur est:

datatype * variable_name;

Par exemple, la déclaration int * ptr;

Cela signifie que ptr est un pointeur qui pointe vers une variable de type int. Par conséquent, une variable de pointeur contient toujours un emplacement ou une adresse de mémoire. Voyons le fonctionnement des variables de pointeur ci-dessous.

Considérez que nous avons les déclarations suivantes:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

En mémoire, ces déclarations seront représentées comme suit:

allocation de mémoire de pointeurs

Il s'agit de la représentation interne du pointeur en mémoire. Lorsque nous affectons la variable d'adresse à la variable de pointeur, elle pointe vers la variable comme indiqué dans la représentation ci-dessus.

Comme ptr a une adresse de variable p, * ptr donnera la valeur de la variable p (variable vers laquelle pointe la variable pointeur ptr).

Noter: L'opérateur * que nous utilisons avec le pointeur est utilisé pour indiquer qu'il s'agit d'une variable de pointeur.

Voyons quelques-uns des concepts de pointeur utilisés en C ++.

Arithmétique du pointeur

Nous savons qu'une variable pointeur pointe toujours vers l'adresse en mémoire. Parmi les opérations que nous pouvons effectuer, nous avons les opérations arithmétiques suivantes qui sont effectuées sur des pointeurs.

  • Opérateur d'incrémentation (++)
  • Opérateur de décrémentation (-)
  • Ajout (+)
  • Soustraction (-)

Voyons l'utilisation de ces opérations dans un programme d'exemple.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Production:

Premier élément du tableau: 2
élément suivant du tableau: 4
élément suivant du tableau: 6
élément suivant du tableau: 4
élément suivant dans le tableau: 2

Nous avons vu les opérations arithmétiques effectuées sur les pointeurs. Notez que l'opérateur d'incrémentation ++ incrémente le pointeur et pointe vers l'élément suivant du tableau. De même, l'opérateur de décrémentation décrémente la variable du pointeur de 1 afin qu'elle pointe vers l'élément précédent du tableau.

Nous utilisons également les opérateurs + et -. Tout d'abord, nous avons ajouté 1 à la variable pointeur. Le résultat montre qu'il pointe vers l'élément suivant du tableau. De même, l'opérateur - fait pointer la variable pointeur vers l'élément précédent du tableau.

En dehors de ces opérateurs arithmétiques, nous pouvons également utiliser des opérateurs de comparaison comme ==,.

Pointeurs Null And Void

Si dans le cas, une variable de pointeur ne reçoit pas une adresse de variable, il est recommandé d'attribuer une valeur NULL à la variable de pointeur. La variable de pointeur avec une valeur NULL est appelée le pointeur NULL.

Un pointeur nul est un pointeur constant avec la valeur zéro définie dans l'en-tête iostream. La mémoire à l'adresse 0 est réservée par le système d'exploitation et nous ne pouvons pas accéder à cet emplacement.

En utilisant le pointeur nul, nous pouvons éviter l'utilisation abusive de pointeurs inutilisés et empêcher les variables de pointeur de se voir attribuer des valeurs de garbage.

Les pointeurs vides sont les pointeurs spéciaux qui pointent vers les valeurs sans type. Les pointeurs vides sont plus flexibles car ils peuvent pointer vers n'importe quel type. Mais ils ne peuvent pas être directement déréférencés. Pour le déréférencement, le pointeur void doit être converti en un pointeur qui pointe vers une valeur avec le type de données concret.

Nous avons montré le fonctionnement du pointeur NULL et du pointeur void dans l'exemple de code suivant.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Production:

Valeur du pointeur NULL: 0
Pointeur de vide vptr pointe vers: A
Pointeur de vide vptr pointe vers: 10

Dans le programme ci-dessus, nous déclarons d'abord un pointeur entier auquel une valeur NULL est attribuée. Lorsque nous imprimons ce pointeur, nous voyons que la valeur est 0 comme nous l'avons vu précédemment.

Ensuite, nous déclarons un pointeur vide. Tout d'abord, nous attribuons une adresse de variable de caractère à ce pointeur de vide. Ensuite, nous attribuons un pointeur void à un pointeur de caractère et le transtypons avec char *. Ensuite, nous affichons la valeur charptr qui pointe vers le char A qui était une variable de caractère que nous avons déclarée précédemment et qui est pointée par le pointeur void.

Ensuite, nous avons affecté une variable entière au pointeur void, puis nous effectuons les mêmes étapes de déréférencement de ce pointeur void en utilisant un pointeur entier.

Tableaux et pointeurs

Les tableaux et les pointeurs sont fortement associés les uns aux autres. Nous savons que le nom du tableau pointe vers le premier élément du tableau et qu'il s'agit d'un pointeur constant.

Nous pouvons affecter ce pointeur à une variable de pointeur, puis accéder au tableau en décrémentant le pointeur ou en utilisant l'opérateur indice.

Nous verrons cette association entre la variable de pointeur et le tableau dans l'exemple de code suivant.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Production:

1 1 2 3 5

Dans le programme ci-dessus, nous affectons le nom du tableau à une variable de pointeur. Comme le nom du tableau pointe vers le premier élément du tableau, nous pouvons imprimer le contenu du tableau entier en utilisant une variable de pointeur et l'incrémenter à l'aide de l'opérateur ++. Ceci est indiqué dans la sortie.

Tableau de pointeurs

Parfois, nous avons besoin de plus d'une variable de pointeur dans un programme. Au lieu de déclarer chaque variable de pointeur individuelle, nous pouvons déclarer un tableau de pointeurs.

Prenons tout de suite un exemple pour démontrer un tableau de pointeurs.

convertir youtube en mp3 gratuit en toute sécurité
#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Production:

Valeur de myarray (0) = 2
Valeur de myarray (1) = 4
Valeur de myarray (2) = 6
Valeur de myarray (3) = 8
Valeur de myarray (4) = 10

Dans la déclaration ci-dessus,

int * ptr (5);

Nous pouvons interpréter comme; ptr est un tableau de 5 pointeurs entiers. Par conséquent, chaque élément de ptr pointera vers une variable de type entier.

Nous utilisons un tableau d'entiers et attribuons l'adresse de chaque élément du tableau à chacun des éléments ptr. Ensuite, nous affichons le contenu du tableau ptr en produisant «* ptr (i)».

Pointeur de pointeurs

Le pointeur des pointeurs n'est rien d'autre que de multiples indirections. C'est une sorte de chaîne de pointeurs. Lorsque nous définissons un pointeur de pointeurs, le premier pointeur a une adresse du deuxième pointeur, qui à son tour a l'adresse de la variable vers laquelle il pointe.

En mémoire, cela sera représenté par:

Allocation de mémoire de pointeur de pointeurs

Un pointeur de pointeurs est déclaré comme suit:

int** intptr;

On prend directement un exemple de code pour mieux comprendre le pointeur des pointeurs.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Production:

Var variable: 10
Pointeur vers la variable: 10
Pointeur vers pointeur vers une variable: 10

Dans le programme ci-dessus, nous déclarons une variable entière, un pointeur entier et un pointeur d'un pointeur vers un entier. Comme indiqué dans le programme, la variable pointeur reçoit la valeur d'une variable. Le pointeur de la variable pointeur reçoit l'adresse de la variable pointeur.

Au final, nous imprimons les trois variables qui affichent la même valeur 10 égale à une variable entière.

Passer des pointeurs aux fonctions

La transmission de pointeurs à la fonction est la même que les autres techniques de passage de paramètres dans lesquelles nous transmettons des variables de pointeur à la fonction.

Nous revisitons notre échange de deux valeurs et les modifions pour passer des variables de pointeur en tant que paramètres.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '<

Pointeurs de fonction

de la même manière, comme nous avons des pointeurs vers des variables, des tableaux, etc., nous pouvons également avoir des pointeurs vers des fonctions. Mais la différence est que le pointeur de fonction pointe vers le code exécutable et non vers des données telles que des variables ou des tableaux.

Nous prenons un exemple pour illustrer les pointeurs de fonction.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Production:

La valeur de a est 100

qu'est-ce qu'un deque c ++

Dans le programme ci-dessus, nous avons une fonction «displayVal» qui imprime juste une valeur entière qui lui est passée. Dans la fonction main, nous avons défini un pointeur de fonction «func_ptr» qui prend un int comme argument et renvoie un type void.

void (* func_ptr) (entier)

Noter: Nous devons enfermer le pointeur de fonction dans (). Si nous l'omettons, il deviendra un prototype de fonction.

Nous avons attribué l’adresse de la fonction «displayVal» à ce pointeur de fonction. Ensuite, en utilisant ce pointeur de fonction 'func_ptr', nous passons la valeur d'argument 100 qui équivaut à appeler displayVal avec l'argument 100.

Maintenant, si nous avons une autre fonction avec le même prototype, alors nous pouvons utiliser le même pointeur de fonction en lui affectant l'adresse de la fonction. C'est l'utilisation principale des pointeurs de fonction.

Conclusion

Tout cela concerne les pointeurs, ses définitions et ses utilisations en C ++.

Dans notre prochain tutoriel, nous en apprendrons plus sur les références en C ++. Les références ont également une utilisation particulière en C ++ et sont souvent utilisées comme alias pour les variables.

=> Cliquez ici pour la série de formations Absolute C ++.

lecture recommandée

^