web-dev-qa-db-fra.com

Pointeur constant vs Pointeur à constante

Je veux connaître la différence entre

const int* ptr;

et

int * const ptr;

et comment ça marche.

Il m'est difficile de comprendre ou de garder cela à l'esprit. S'il vous plaît aider.

cpointersconst
108
vengets
const int* ptr;

déclare ptr un pointeur sur le type const int. Vous pouvez modifier ptr lui-même, mais l'objet pointé par ptr ne doit pas être modifié.

const int a = 10;
const int* ptr = &a;  
*ptr = 5; // wrong
ptr++;    // right

Tandis que

int * const ptr;

déclare ptr un const pointeur sur le type int. Vous n'êtes pas autorisé à modifier ptr mais l'objet pointé par ptr.

int a = 10;
int *const ptr = &a;  
*ptr = 5; // right
ptr++;    // wrong

Généralement, je préférerais une déclaration comme celle-ci, qui facilite la lecture et la compréhension (lecture de droite à gauche):

int const  *ptr; // ptr is a pointer to constant int 
int *const ptr;  // ptr is a constant pointer to int
185
haccks
const int * ptr;

signifie que les données pointées sont constantes et immuables mais que le pointeur ne l’est pas.

int * const ptr;

signifie que le pointeur est constant et immuable, mais pas les données pointées.

22
Itachi

1) Pointeurs constants: Ces types de pointeurs sont ceux qui ne peuvent pas changer l'adresse vers laquelle ils pointent. Cela signifie que supposons qu'il existe un pointeur qui pointe vers une variable (ou stocke l'adresse de cette variable). Maintenant, si nous essayons de faire pointer le pointeur vers une autre variable (ou d'essayer de faire en sorte que l'adresse du pointeur enregistre l'adresse d'une autre variable), les pointeurs constants sont incapables de le faire.

Un pointeur constant est déclaré comme: int *const ptr (l'emplacement de 'const' fait en sorte que le pointeur 'ptr' devienne un pointeur constant)

2) Pointeur sur constante: Ces types de pointeurs sont ceux qui ne peuvent pas changer la valeur vers laquelle ils pointent. Cela signifie qu'ils ne peuvent pas changer la valeur de la variable dont ils ont l'adresse.

Un pointeur sur une constante est déclaré en tant que: const int *ptr (l'emplacement de 'const' rend le pointeur 'ptr' en tant que pointeur sur une constante.

Exemple

Pointeur constant 

#include<stdio.h>

int main(void)
{
    int a[] = {10,11};
    int* const ptr = a;

    *ptr = 11;

    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    ptr++;
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    return 0;
}

Maintenant, lorsque nous compilons le code ci-dessus, le compilateur se plaint:

practice # gcc -Wall constant_pointer.c -o constant_pointer
constant_pointer.c: In function ‘main’:
constant_pointer.c:13: error: increment of read-only variable ‘ptr’

Nous voyons donc très clairement ci-dessus que le compilateur se plaint de ne pas pouvoir modifier l'adresse détenue par un pointeur constant.

Pointeur sur les constantes 

#include<stdio.h>

int main(void)
{
    int a = 10;
    const int* ptr = &a;


    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    *ptr = 11;

    return 0;
}

Maintenant, lorsque le code ci-dessus est compilé, le compilateur se plaint:

practice # gcc -Wall pointer_to_constant.c -o pointer_to_constant
pointer_to_constant.c: In function ‘main’:
pointer_to_constant.c:12: error: assignment of read-only location ‘*ptr’

Nous voyons donc également ici que le compilateur ne permet pas au pointeur sur une constante de changer la valeur de la variable pointée.

devis

8
MustafaP

Renvoi de This Thread

Pointeurs constants

Permet de comprendre ce qu'est un pointeur constant. Un pointeur constant est un pointeur qui ne peut pas changer l'adresse qu'il détient. En d'autres termes, nous pouvons dire qu'une fois qu'un pointeur constant pointe vers une variable, il ne peut pas pointer vers une autre variable.

Un pointeur constant est déclaré comme suit:
<type of pointer> * const <name of pointer>
Un exemple de déclaration ressemblerait à ceci:
int * const ptr;
Prenons un petit code pour illustrer ces types de pointeurs:

#include<stdio.h>

int main(void)
{
    int var1 = 0, var2 = 0;
    int *const ptr = &var1;
    ptr = &var2;
    printf("%d\n", *ptr);

    return 0;
}

Dans l'exemple ci-dessus:

  • Nous avons déclaré deux variables var1 et var2
  • Un pointeur constant "ptr" a été déclaré et créé pour pointer var1
  • Ensuite, ptr est créé pour pointer var2.
  • Enfin, nous essayons d’imprimer la valeur pointée par ptr.

Pointeur sur constante

Comme son nom l’indique, un pointeur par lequel on ne peut pas changer la valeur de la variable qu’il pointe est appelé pointeur sur une constante. Ces types de pointeurs peuvent changer l'adresse vers laquelle ils pointent mais ne peuvent pas changer la valeur conservée à cette adresse.

Un pointeur sur une constante est défini comme suit: const <type of pointer>* <name of pointer> Un exemple de définition pourrait être: const int* ptr; Prenons un petit code pour illustrer un pointeur sur une constante:

 #include<stdio.h>

int main(void)
{
    int var1 = 0;
    const int* ptr = &var1;
    *ptr = 1;
    printf("%d\n", *ptr);

    return 0;
}

Dans le code ci-dessus:

  • Nous avons défini une variable var1 avec la valeur 0
  • nous avons défini un pointeur sur une constante qui pointe sur la variable var1
  • Maintenant, à travers ce pointeur, nous avons essayé de changer la valeur de var1
  • Printf utilisé pour imprimer la nouvelle valeur.
4
G one
const int* ptr;

est un pointeur sur une constante (contenu). Vous êtes autorisé à modifier le pointeur. par exemple. ptr = NULL, ptr++, mais la modification du contenu est non possible.

int * const ptr;

Est un pointeur constant. Le contraire est possible. Vous êtes pas autorisé à modifier le pointeur, mais vous êtes autorisé à modifier son objet, par exemple. *ptr += 5.

3
Sergey L.
int i;
int j;

int * const ptr1 = &i;

Le compilateur vous arrêtera de changer ptr1.

const int * ptr2 = &i;

Le compilateur vous arrêtera de changer *ptr2.

ptr1 = &j; // error
*ptr1 = 7; // ok

ptr2 = &j; // ok
*ptr2 = 7; // error

Notez que vous pouvez toujours changer *ptr2, mais pas en tapant littéralement *ptr2:

i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error

Vous pouvez également avoir un pointeur avec les deux fonctionnalités:

const int * const ptr3 = &i;

ptr3 = &j; // error
*ptr3 = 7; // error
2
immibis

const int* ptr; pense ici comme * ptr est constant et * ptr ne peut plus être changé

int * const ptr; alors qu'ici pense comme une constante et ne peut plus être changé

1
user2760375

Veuillez vous référer au lien suivant pour une meilleure compréhension de la différence entre le pointeur Const et le pointeur sur une valeur constante.

pointeur constant vs pointeur sur une valeur constante

1
SridharKritha