L'affectation d'un pointeur sur un entier

Puis-je attribuer un pointeur vers une variable de type entier? Comme ce qui suit.

int *pointer;
int array1[25];
int addressOfArray;

pointer = &array1[0];

addressOfArray = pointer;

Est-il possible de faire comme ça?

avez-vous donné un essai?
Qu'attendez-vous une telle tâche à accomplir? Dites-nous ce réel problème que vous essayez de résoudre, et nous pouvons vous aider.
Sauf si vous avez une bonne raison pour cela, ne pas le faire. Et si vous le faites, ne pas utiliser un int, depuis un int n'est pas nécessaire assez grand pour contenir un pointeur sur tous les systèmes (par exemple, la commune de LP64 et LLP64 modèles). Au lieu de cela, utiliser les intptr_t.

OriginalL'auteur user1293997 | 2012-05-07

  1. 3

    Pas sans un cast explicite, c'est à dire

    addressOfArray = (int) pointer;

    Il y a aussi cette mise en garde:

    6.3.2.3 les Pointeurs

    ...

    6 Tout type pointeur peut être converti en un type entier. Sauf tel que spécifié précédemment, l'
    le résultat est la mise en œuvre définies. Si le résultat ne peut pas être représenté dans le type integer,
    le comportement est indéfini. Le résultat n'a pas besoin d'être dans la plage de valeurs de n'importe quel entier
    type.

    De sorte que le résultat n'est pas garanti d'être une véritable valeur entière.

    Merci pour l'ajout de la mise en garde, j'ai trouvé (et a été confondu par) exemple de code enterré dans un lua mise en œuvre.
    Réponse correcte, mais vous pouvez inclure le raison pourquoi le casting est nécessaire (la contrainte sur l'opérateur d'affectation mentionnée par @ouah).
    De préférence, le type uintptr_t doit être utilisé au lieu de int, car il est livré avec un ensemble beaucoup moins de mise en œuvre définies par le comportement.

    OriginalL'auteur John Bode

  2. 4

    Non, il n'est pas valable pour affecter un pointeur vers un entier. C'est une violation de la contrainte de l'opérateur d'affectation (C99, 6.5.16.1p1). Un compilateur a le droit de refuser de traduire un programme avec un pointeur d'entier affectation.

    Vous POUVEZ faire un casting, mais je ne le recommande pas.

    OriginalL'auteur ouah

  3. 1

    Il est fait fréquemment dans la programmation embarquée avec quelques mises en garde:

    • l'opération (le plus probable) exige de la coulée, et
    • implique généralement que vous travaillez sans un système d'exploitation ou de travailler en très étroite collaboration avec les organismes touristiques (j'.e, pilote de développement de niveau)
    S'agit-il? Je n'ai jamais fait ça, sauf lors de la mise en œuvre de pointer_to_string. Toutefois, j'ai fait en entier(littérale) de pointeur un peu.
    Mon BRAS bsp peu de magie pendant le démarrage: "taille = (unsigned)&__romend - (non signé)&__romstart;" j'ai vu ce genre de chose souvent nu-metal applications.
    extern int8_t *__romend; extern int8_t *__romstart; size_t size=__romend-__romstart; Si les pointeurs sont de type correct, vous avez juste à soustraire l'un de l'autre pour obtenir l'une réponse, comme @Throwback1986.
    Bien sûr, il n'y a plus d'une façon de defur d'un félin. Un autre exemple: mon GreenHills RTOS permet la transmission de message à l'aide de Tampons (Buffer ne signifie pas un simple tampon de mémoire). Pour l'installation d'un Tampon, quelque chose comme ceci est fait: bufferControl.BufferType = DataBuffer | LastBuffer; bufferControl.TheAddress = (Address)&msgControl; bufferControl.Length = MAX_VAS_MESSAGE_SIZE; bufferControl.Transferred = 0; Depuis Address est juste un typedef pour unsigned long int, une situation similaire à l'OP de la question est présentée.
    Oui, c'est l'autre fois, vous avez besoin de le faire, mal écrit bibliothèques. Mais l'honnêteté (faites-moi confiance, je suis un ingénieur en logiciel ), vous n'avez pas besoin de le faire. Sauf si vous êtes à la mise en œuvre de print_pointer. Si jamais vous écrire un plâtre, puis posez-vous au moins 3 fois si vous le devez, alors demandez 3 autres personnes. Seulement alors considérer qu'il est peut-être la meilleure façon de le faire.

    OriginalL'auteur Throwback1986

  4. 1

    Nope.

    Vous tentez d'attribuer un "pointeur sur int" la valeur d'un "int" à la variable. Vous obtiendrez un avertissement du compilateur pour vous. Vous pourriez faire: 

    int *pointer;
int array1[25];
int *addressOfArray;

pointer = &array1[0];
//The following commented lines are equivalent to the pointer assignment above and are also valid
//pointer = array
//pointer = &array[0]

addressOfArray = pointer;

    Ce qui est connu comme une copie. Si vous n'êtes pas déjà familier avec le concept, je vous recommande fortement de le lire (Google "deep vs peu profonde de la copie").

    OriginalL'auteur DevNull

  5. 0

    Vous pourriez le faire comme ceci:

    memcpy(&addressOfArray, &pointer, sizeof(int));

    Qui permettrait de copier directement le sous-jacent d'octets et de supplanter l'opérateur de coulée, mais j'ai vraiment ne vous le recommande pas, sauf si vous savez certainement que sizeof(int) == sizeof(int *) sur votre système.

    OriginalL'auteur Richard J. Ross III