Tableau de pointeurs C ++

Array contient la liste des éléments en fonction de la taille que nous fournissons au moment de la création du tableau. Tandis que, en C ++, les pointeurs sont les variables qui ont les adresses d'autres variables. Ces pointeurs ont l'adresse d'une seule variable et peuvent stocker l'adresse des cellules du tableau. Les tableaux et les pointeurs sont très étroitement liés les uns aux autres comme dans C ++, le nom de Array est considéré comme un pointeur car il se compose de l'adresse de l'élément. Le tableau contient donc les éléments, et les pointeurs contiennent l'adresse des variables. Le tableau de pointeur ou le «tableau de pointeur» représente donc un tableau avec l'adresse des éléments présents dans le tableau. Ce sujet contiendra le phénomène du tableau des pointeurs en C++.

Syntaxe

En C ++, si nous devons déclarer un tableau de pointeurs, nous créons un tableau qui contient l'adresse des éléments présents à l'intérieur qui pointent vers certaines valeurs d'adresse.

# type * pointer_name [array_size];

Selon la syntaxe, si vous êtes prêt à créer un tableau de pointeur, nous définissons le type de pointeur de tableau. Après cela, le nom du tableau du pointeur est déclaré. Comme vous pouvez le voir dans la syntaxe que «*» est utilisé avec le nom d'un pointeur en C++. Après avoir nommé le tableau, la taille du tableau est déclarée qui montre combien d'éléments seront présents dans le tableau.

# Int * newp [5];

Fonctionnement du tableau des pointeurs en c++

La valeur du pointeur pointe vers l'adresse des valeurs présentes à l'intérieur du tableau. Si vous êtes prêt à accéder aux valeurs, nous pouvons accéder à chaque valeur en utilisant leur adresse car elle ne pointe que cette adresse spécifique. L'utilisation de pointeurs rend les opérations de fonctionnalité plus efficaces et affecte également le niveau de performance. Maintenant, nous verrons que comment déclarer un tableau de pointeur.

Comme nous avons utilisé une déclaration d'échantillon de tableau de pointeur ci-dessus.

# Int * newp [5];

Dans cette ligne ci-dessus, nous avons déclaré un éventail de pointeurs ayant 5 éléments. Ce tableau contiendra l'adresse des valeurs. L'adresse est l'emplacement de l'élément où le tableau est stocké à l'intérieur de la mémoire. Cette adresse mémoire tourne toujours le point vers l'élément qui est stocké à cet endroit.

Création d'un tableau de pointeurs en c++

Il y a quelques étapes pour créer un tableau de pointeurs en c++

Tout d'abord, nous créons un tableau ayant des éléments. Supposons que nous ayons 5 éléments.

# Int newArray [5] = 1,2,3,4,5;

Après cela, nous créons un tableau de pointeur qui stocke l'adresse des éléments du tableau.

# Int "newp [5];

Si vous souhaitez obtenir l'adresse des éléments dans le tableau, utilisez l'opérateur '&', cela nous donnera l'adresse des valeurs dans la mémoire.

# Newp [1] = & newp [1];

Après cela, l'adresse des éléments est stockée dans les tableaux de pointeurs en utilisant la boucle.

Maintenant, nous pouvons accéder aux éléments du tableau avec les pointeurs; il fournira la même valeur. Nous allons maintenant utiliser des exemples élémentaires ici qui vous aideront dans le concept de compréhension.

Exemple 1

Dans cet exemple, nous avons simplement affiché les valeurs à l'intérieur du tableau. Mais cette fois, cela ne se fait pas en affichant les valeurs à travers le nombre intérieur mais en utilisant des pointeurs. Donc première étape du programme principal, nous créons dynamiquement le tableau de taille 5.

# Int * p = new int [5];

Après cela, comme nous l'avons décrit auparavant dans la partie du sujet «Création d'un tableau de pointeurs en C ++», le tableau est initialisé avec les nombres. Nous utiliserons pour Loop pour entrer les valeurs dans les index respectifs. Cela se fait à travers les pointeurs. «10» est une constante ici qui est utilisée pour multiplier la valeur avec la prochaine; Ceci est une approche intelligente pour attribuer les valeurs.

# 2 [P]

Maintenant, la valeur de P est 1, donc après avoir multiplié, ce sera 2, au point.

Par exemple, lorsque la boucle itère pour la première fois, la valeur de «i» sera «0», donc quand dans la parenthèse, elle sera ajoutée avec 1, elle deviendra 1, et après avoir multiplié avec la constante, la constante, la constante, la constante, Le résultat sera égal à la constante elle-même. Pour le deuxième index, dans la prochaine itération, lorsque la valeur de i est «1», après addition avec 1, ce sera 2, donc quand il sera multiplié par 10, il deviendra 20. Et puis ainsi de suite dans chaque itération jusqu'à ce que la valeur à saisir soit 50. Dans le cas de l'affichage des valeurs via des pointeurs, nous avons utilisé différentes techniques; Ceux-ci seront sûrement bénéfiques pour vous dans la compréhension de la perspective. First Sorput Fourning Instruction Contient:

# * P

Comme nous savons que ce symbole '*' affiche l'adresse, une chose doit être gardée à l'esprit: lorsque nous utilisons un pointeur pour afficher la valeur sans utiliser l'index, il attribue automatiquement la première valeur par défaut, le résultat sera de 10. Le suivant est:

# * P + 1

Il ajoutera simplement la valeur par défaut avec un, donc la réponse est 11. Se diriger vers la valeur suivante,

# * (P + 1)

Maintenant cette fois, nous parlerons de l'index mais pas de l'adresse car «*» n'est pas avec P. Il désigne donc «0», ce 0 sera ajouté avec 1 et les formulaires * (1), donc en position 1, il est 20, donc il sera affiché.

De même, d'autres résultats seront affichés. En fin de compte, le pointeur est terminé car nous avons également pris le résultat de cette valeur incrémentée.

Pour la valeur résultante, accédez au terminal de Linux et utilisez le compilateur G ++ pour compiler et exécuter le code.

Array $ G ++ -O.c
$./déployer

Exemple 2

Cet exemple concerne l'affichage des adresses à l'aide de tableaux et de pointeurs pour afficher la différence entre eux. À cette fin, dans le programme principal, nous déclarons un tableau ayant un type de données flottantes. La variable du pointeur flottant est déclarée.

# * ptr;

Maintenant, avec l'aide de ce pointeur, nous pourrons afficher l'adresse. Mais d'abord, affichons l'adresse des éléments en utilisant un tableau. Cela se fait via une boucle pour. C'est le moyen facile et générique d'afficher le contenu du tableau via le numéro d'index.

# Ptr = arr;

En utilisant les notations du pointeur, nous afficherons l'adresse via les pointeurs. Encore une fois, une boucle est utilisée pour afficher l'adresse via le pointeur.

Utilisez à nouveau le compilateur G ++ pour compiler, puis exécutez le code dans le terminal Linux pour afficher les valeurs résultantes.

Lorsque vous exécutez le code, vous verrez que la réponse pour les deux méthodes est la même; soit par un tableau ou par les pointeurs, le même résultat est obtenu.

Conclusion

Un tableau de pointeurs est utilisé en C ++ dans le système d'exploitation Ubuntu Linux pour développer la récupération des données via l'adresse et les tableaux. Cet article était tout au sujet de la gamme de pointeurs en C++. Nous avons élaboré la syntaxe et quelques exemples liés aux pointeurs. Ces exemples peuvent être mis en œuvre sur n'importe quel compilateur selon le choix de l'utilisateur.