Peut un pointeur jamais pointer vers lui-même?

Ma question est: Si un pointeur de variable a la même adresse que sa valeur, est-il vraiment pointant vers lui-même?

Par exemple - dans le morceau de code suivant, est a un pointeur à lui-même?

#include<stdio.h>

int main(){
   int* a;
   int b = (int)&a;
   a = b;
   printf("address of a = %d\n", &a);
   printf("  value of a = %d\n", a);
}

Si a n'est pas un pointeur à lui-même, puis la même question se pose à nouveau: Peut un pointeur pointe vers lui-même?

Aussi, comment un auto pointage pointeur utile?

  • Oui. __________
  • ppl, pourquoi le negvotes? trop facile pour vous??
  • Mon question est... - un "doute" est tout autre chose.
  • Même si il est légal, je me demande ce que le compilateur ne fait lorsqu'il rencontre quelque chose comme ça. Puisque le compilateur met en quelques optimisation de son propre, je serais prêt à parier qu'il le prend. Mais, je ne pouvais pas dire à coup sûr.
  • Vous pouvez avoir un pointeur vers un int stocker son propre emplacement de mémoire au lieu de stocker l'emplacement d'un int, si c'est ce que tu veux dire.
  • J'ai trouvé cette question quand j'essayais de comprendre Obj C contexte vide pointeurs, comme dans "observeValueForKeyPath:(NSString *)chemin d'accès clé ofObject:(id)modification de l'objet:(NSDictionary *)changement de contexte:(void *)contexte". Le pointeur lui-même a été utilisé pour créer un cadre unique, qui je le comprends maintenant, à cause de cette question et la réponse. Merci.
  • Possible, mais ce qui est le point ?
  • Voici un lien à cette question: stackoverflow.com/questions/2532102/...
  • Ne pas 2d+ tableaux le faire pour eux-mêmes de toute façon? Pour chaque "niveau" le tableau est imbriqué, vous devez déférence que beaucoup de fois pour arriver à la première valeur réelle, et le long de la façon dont elle renvoie la même adresse (À la première valeur), jusqu'à ce que vous y arrivez. Qui au moins se lit comme c'est un pointeur pointant sur lui-même, à plusieurs reprises. Ou... c'est Que c'est le pseudo de les éliminer de l'indice des itérateurs. Je suppose que c'est une question d'interprétation. Il semble vraiment inutile si vous le faites vous même, mais je suppose qu'il a une place quelque part.
  • Ce que vous avez besoin est un pointeur vers votre propre commentaire.

InformationsquelleAutor Lazer | 2010-03-28
  1. 34

    Ce que vous faites réellement, il est pas avoir le pointeur pointe vers lui-même. Vous êtes à l'aide de l'espace mémoire alloué pour le pointeur pour stocker l'emplacement du pointeur de la. Un pointeur vers un int points à ints - jamais à d'autres pointeurs vers des entiers, y compris lui-même.

    Par exemple, disons que vous créer un pointeur a:

    int * a;

    Il obtient sa propre place dans la mémoire:

       4     a (5)    6
[....][00000000][....]

    Dans cet exemple simple, disons que a est à l'emplacement de la mémoire '5'.

    Si vous étiez pour ce faire:

    a = (int*)&a;

    ...la suite arrivera:

       4     a (5)    6
[....][00000005][....]

    Ce qui se passe ici est que a vers ce qu'il pense est un entier au lieu de 5. Cela se passe aussi pour être le même emplacement mémoire que &a pointe, mais dans le contexte de ce a pointe, il est maintenant de pointage à l'entier au lieu de 5 et de ce nombre entier est 5.

    Par exemple à la fois de ces travaux:

    cout<<(int)a;//outputs 5
cout<<*a;//Outputs the integer at memory location 5 - which is 5.

    Si vous vouliez créer un pointeur vers un, vous avez très certainement pu - l'une de ces façons:

    int **b = (int**)a;

    ou

    int ** b = &a;

    Mais il est très important de réaliser que a n'est pas un pointeur à lui-même. C'est un pointeur vers la entier à l'emplacement des magasins de - qui se trouve être la même que celle de son propre emplacement.

    À plus de montrer (par un moyen encore plus simple exemple) ce qu'il se passe quelque chose de semblable pourrait se produire avec une int. Qui est, vous pouvez stocker la mémoire de l'emplacement d'un int à l'intérieur de lui-même:

    int a=999;

    a a maintenant un emplacement dans la mémoire, et a une valeur de 999 (nous allons faire semblant il a été placé dans l'emplacement de mémoire '46'):

      45     a (46)   47
[....][00000999][....]

    C'est dans l'emplacement '46" - si nous le voulions, nous pourrions stocker ce nombre par un nombre entier à l'intérieur de a:

    a=(int)&a;

  45     a (46)   47
[....][00000046][....]

    et maintenant a est égal à &a en valeur, mais pas dans le type - a est juste un entier, il n'a pas de point à lui-même comme par magie maintenant, juste parce que nous l'avons utilisé pour stocker son propre emplacement de mémoire.

    • Je ne comprends pas pourquoi, dans le premier exemple, a ne pointe pas vers lui-même, puisque son contenu est une mémoire d'adresses (définition d'un pointeur, n'est-ce pas?) -dans ce cas, sa propre adresse, et non d'un nombre entier (il a été castée pour un int*). Alors, évidemment, &a et a produire le même résultat lors de l'impression, dire 0xABCD. Mais maintenant, je peux légalement écrire *a = 0x1234, et cout << a montre que le pointeur déréférencé, a a été modifié le : &a = 0xABCD mais a = 0x1234. Je me trompe quelque part?
    • Parce que, par définition, de int *a;, a doit être dirigée vers un int mais après a=(int*)&a; la variable a serait pointant vers un int * qu'il ne faut pas faire. (Pour mémoire, le type de &a est int **) Car les pointeurs sont traités comme des entiers (au moins d'habitude et peut-être dictée par les normes C, je ne sais pas), les choses fonctionnent, mais il n'a pas besoin d'être le cas dans une langue ou de l'architecture qui a traité des pointeurs différemment à partir de nombres entiers.
    InformationsquelleAutor Cam
  2. 38
    void* p = &p;

    Il n'est pas très utile, mais les structures qui pointent vers eux-mêmes sont utiles dans la circulaire des listes de longueur 1:

    typedef struct A {
  struct A* next;
} A;

A a = { &a };

    Par votre exemple précis, je crois que vous vouliez dire:

    int* a;
int b = (int)&a;
a = (int*)b;

//which can be simplified to:
int* a = (int*)&a;
    • +1, un peu plus détaillé que ma réponse.
    • Notez que ce que vous avez fait avec la structure est différente de ce qu'il était en train de faire. Un pointeur qui pointe vers lui-même est très différent d'une structure qui a un pointeur à lui-même. +1 pour l'exemple si, comme c'est probablement ce qu'il doit penser à de l'auto-référentielle des pointeurs.
    • Il est conceptuellement différent, et c'est là tout l'avantage vient de la, mais note que::next n'est point à lui-même, comme c'est le premier membre de la structure, de sorte &a == &a.next.
    • Le premier exemple est en effet utile: il crée un unique pointeur de la valeur au moment de la compilation qui pourrait être utile pour marquer certains objets ou de transmettre une information qui n'est pas possible de faire autrement dans certaines situations (par exemple, inmodifiable Api). Mais pour que la définition de l'indicateur à lui seul, suffirait... en l'affectant seulement les pièces de rechange l'un de l'utilisation de & de plus 🙂
    InformationsquelleAutor
  3. 16

    L'adresse mémoire à FFFFFFFF pouvez stocker la valeur FFFFFFFF

    • En supposant un espace d'adressage 32 bits, pas de. Il n'y a pas de place pour stocker une valeur de 4 octets à cette adresse. 🙂
    InformationsquelleAutor astronought
  4. 6

    Bien, d'abord, je voudrais modifier le code autour de:

    int **a;
a = (int **)&a;  //otherwise you get a warning, since &a is int ***

    Je ne suis pas sûr de savoir pourquoi vous voulez faire cela, mais il est permis.

    printf("The address of a is %p\n", &a);
printf("a holds the address %p\n", a);
printf("The value at %p is %p\n", a, *a); //the *a is why we made a an int **

    Ils doivent imprimer la même chose.

    The address of a is 0x7fffe211d078
a holds the address 0x7fffe211d078
The value at 0x7fffe211d078 is 0x7fffe211d078

    Noter que ce n'est pas une bonne idée, en tant que tout premier casting a = (int **)&a est un hack de la force a pour contenir une valeur qui ne devrait pas tenir. Vous déclarez un int ** mais essayer de forcer un int *** en elle. Techniquement, les tailles sont les mêmes, mais, en général, ne pas le faire parce que les gens attendent qu'une int * contient l'adresse de quelque chose qui peut être utilisé comme un int, une sorte de suite.

    InformationsquelleAutor Phil
  5. 4

    Oui et non, parce que le pointeur est de type presque aussi important que la valeur du pointeur.

    Oui, un pointeur peut contenir la position d'un pointeur à lui-même; encore un long peut contenir la position d'un pointeur à lui-même. (Ints, habituellement, mais je ne sais pas si c'est garantie partout.)

    Cependant, il n'y a pas de type pour représenter cette relation. Si vous avez un pointeur qui pointe vers lui-même, vous avez réellement un type différent lorsque vous déréférencement d'elle. Donc:

    void *p = &p;
//*p is illegal, even though you probably wanted it to equal 'p'
if( *p != p ) {
    printf("Something's wrong");
}

int *i = (int*)&i;
//The following statement is still illegal
if( *i == i ) {
    printf("The universe works!");
}

    Je dirais que la réponse est "non", car il ne fonctionnera pas, sauf si vous allez pour abus de ce type de système. Je pense que c'est une indication que vous êtes en train de faire quelque chose de mal (bien que parfois il est certainement nécessaire).

    InformationsquelleAutor CWF
  6. 3

    Déréférencement d'un pointeur de résultat une valeur de son type de valeur (par exemple, de déréférencer un int* vous donne un int, un int*s valeur type). Pour une variable pour pointer vers un pointeur de son type de valeur devrait être int*, ce qui n'est pas le cas pour un int* comme indiqué précédemment. Donc, pour un pointeur sur lui-même, il faudrait faire une sorte de casting pour l'obtenir par le compilateur:

    int* a;
a = reinterpret_cast<int*>(&a);

    Déréférencer a, alors, vous avez une int dont la valeur se trouve être l'adresse à laquelle a est situé (mod troncature de l'adresse pour s'adapter à la nature), mais il est encore une int et pas un int*, qui aurait besoin d'une autre fonte.

    Un pointeur vers un pointeur est souvent connu comme un poignée, qui est un autre type (int**) qu'un pointeur (int*). (Notez qu'une int** poignée a une valeur de type int*.)

    • C'est un C++ de réponse C question. Autrement réponse intéressante.
    InformationsquelleAutor fbrereto
  7. 1

    Oui, un pointeur peut pointer vers lui-même comme mentionné dans les réponses.

    Un possible cas d'utilisation, nous pouvons utiliser cette astuce, au lieu de pointeurs NULL. Vous pouvez initialiser int * p = (int *)&p, et de vérifier plus tard pour voir si le pointeur est valide ou pas. Cela aurait pu être utilisé si dire dans un système où nous voulions 0x0 et de l'ensemble de la plage d'adresses pour les adresses valides.

    Vous pouvez également utiliser cette astuce dans la spéciale des programmes en C qui ne serait pas de crash sur pointeur NULL utilisation que parce que vous ne les éviter et de déréférencement système ne va pas planter. Cela conduira à des erreurs de comportement, mais il peut aider au débogage dans certaines situations.

    InformationsquelleAutor user3922199
  8. 0

    Oui, il est possible de pointer vers lui-même.

    int* a;
a = &a;

    Mais pas tout utiliser, au moins explicitement comme ça.

    • Ce qui amène les types. &un a le type int**, en attribuant qu'à a qui est un int* est un comportement indéfini (bien moins que si vous essayez d'utiliser le pointeur.
    • erreur: impossible de convertir de ‘int**’ int*’ lors de l'initialisation
    InformationsquelleAutor zaharpopov
  9. 0

    Juste:

    int *a = (int*)&a;
cout<<"checking: \n"<<&a<<"\n"<<a;

    Il pointe vers lui-même.

    InformationsquelleAutor Giuliano