Ik wil het verschil weten tussen
const int* ptr;
en
int * const ptr;
en hoe het werkt.
Het is best moeilijk voor mij om dit te begrijpen of te onthouden.
Help alstublieft.
Antwoord 1, autoriteit 100%
const int* ptr;
verklaart ptreen verwijzing naar het type const int. U kunt ptrzelf wijzigen, maar het object waarnaar wordt verwezen door ptrzal niet worden gewijzigd.
const int a = 10;
const int* ptr = &a;
*ptr = 5; // wrong
ptr++; // right
Terwijl
int * const ptr;
verklaart ptreen const-aanwijzer naar het type int. U mag ptrniet wijzigen, maar het object waarnaar wordt verwezen door ptrkan worden gewijzigd.
int a = 10;
int *const ptr = &a;
*ptr = 5; // right
ptr++; // wrong
Over het algemeen zou ik de voorkeur geven aan een verklaring zoals deze die het gemakkelijk te lezen en te begrijpen maakt (lees van rechts naar links):
int const *ptr; // ptr is a pointer to constant int
int *const ptr; // ptr is a constant pointer to int
Antwoord 2, autoriteit 10%
const int * ptr;
betekent dat de puntige gegevens constant en onveranderlijk zijn, maar de aanwijzer niet.
int * const ptr;
betekent dat de aanwijzer constant en onveranderlijk is, maar de puntige gegevens niet.
Antwoord 3, autoriteit 3%
1) Constante aanwijzers :Dit soort aanwijzers zijn degene die het adres waarnaar ze verwijzen niet kunnen veranderen. Dit betekent dat stel dat er een aanwijzer is die naar een variabele verwijst (of het adres van die variabele opslaat). Als we nu proberen de aanwijzer naar een andere variabele te verwijzen (of proberen de aanwijzer het adres van een andere variabele te maken), dan zijn constante aanwijzers hiertoe niet in staat.
Een constante aanwijzer wordt gedeclareerd als: int *const ptr(de locatie van ‘const’ maakt de aanwijzer ‘ptr’ als constante aanwijzer)
2) Pointer naar Constant :Dit type pointers is degene die de waarde waarnaar ze verwijzen niet kan veranderen. Dit betekent dat ze de waarde van de variabele waarvan ze het adres hebben, niet kunnen veranderen.
Een pointer naar een constante wordt gedeclareerd als: const int *ptr(de locatie van ‘const’ maakt de pointer ‘ptr’ als een pointer naar constante.
Voorbeeld
Constante aanwijzer
#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;
}
Als we de bovenstaande code compileren, klaagt de compiler:
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’
Vandaar dat we heel duidelijk boven zijn die compiler klaagt dat we het adres niet door een constante aanwijzer kunnen wijzigen.
aanwijzer naar constanten
#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;
}
Nu, wanneer de bovenstaande code is gecompileerd, klaagt de compiler:
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’
Vandaar hier ook, we zien dat de compiler de aanwijzer niet toestaat om de waarde van de variabele te wijzigen.
Antwoord 4, Autoriteit 2%
const int* ptr;
is een aanwijzer naar constant (inhoud). U mag de aanwijzer wijzigen. b.v. ptr = NULL, ptr++, maar de wijziging van de inhoud is niet mogelijk.
int * const ptr;
is een constante aanwijzer. Het tegenovergestelde is mogelijk. U bent niet toegestaan om de aanwijzer te wijzigen, maar u bevindt zich toegestaan om te wijzigen wat het wijst naar b.v. *ptr += 5.
Antwoord 5, Autoriteit 2%
referentie
deze draad < / kbd>
Constant Pointers
Laten we eerst begrijpen wat een constante aanwijzer is. Een constante aanwijzer is een aanwijzer die het adres ervan niet kan veranderen. Met andere woorden, we kunnen zeggen dat zodra een constante aanwijzer naar een variabele wijst, dan kan het niet wijzen op een andere variabele.
Een constante aanwijzer wordt als volgt verklaard:
<type of pointer> * const <name of pointer>
Een voorbeeldverklaring zou eruit zien:
int * const ptr;
Laten we een kleine code innemen om dit type wijzers te illustreren:
#include<stdio.h>
int main(void)
{
int var1 = 0, var2 = 0;
int *const ptr = &var1;
ptr = &var2;
printf("%d\n", *ptr);
return 0;
}
In het bovenstaande voorbeeld:
- We hebben twee variabelen Var1 en Var2
- Een constante wijzer 'PTR' werd verklaard en gemaakt om Var1 op te geven
- Volgende, PTR wordt gemaakt om VAR2 te plaatsen.
- Ten slotte proberen we de waarde af te drukken, PTR wijst naar.
aanwijzer naar constant
Zoals duidelijk uit de naam, een aanwijzer waarmee men de waarde van variabele IT-punten niet kan wijzigen, staat bekend als een aanwijzer naar constant. Dit type aanwijzers kunnen het adres dat ze wijzen op, maar kunnen de waarde niet wijzigen op het adres.
Een aanwijzer naar constant wordt gedefinieerd als:
const <type of pointer>* <name of pointer>
Een voorbeeld van definitie kan zijn:
const int* ptr;
Laten we een kleine code innemen om een aanwijzer naar een constante te illustreren:
#include<stdio.h>
int main(void)
{
int var1 = 0;
const int* ptr = &var1;
*ptr = 1;
printf("%d\n", *ptr);
return 0;
}
In de bovenstaande code:
- We hebben een variabele var1 gedefinieerd met waarde 0
- We hebben een aanwijzer naar een constante gedefinieerd die wijst naar variabele var1
- Nu, via deze aanwijzer probeerden we de waarde van VAR1
- gebruikt printf om de nieuwe waarde af te drukken.
te wijzigen
Antwoord 6
int i;
int j;
int * const ptr1 = &i;
De compiler stopt u met het wijzigen van ptr1.
const int * ptr2 = &i;
De compiler stopt u met het wijzigen van *ptr2.
ptr1 = &j; // error
*ptr1 = 7; // ok
ptr2 = &j; // ok
*ptr2 = 7; // error
Merk op dat u nog steeds wilt wijzigen *ptr2, alleen niet door letterlijk te typen *ptr2:
i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error
U kunt ook een aanwijzer hebben met beide functies:
const int * const ptr3 = &i;
ptr3 = &j; // error
*ptr3 = 7; // error
Antwoord 7
Raadpleeg de volgende link voor beter begrip van het verschil tussen Const-aanwijzer en aanwijzer op een constante waarde.
Constante wijzer vs-aanwijzer op een constante waarde
Antwoord 8
const int* ptr; hier denken zoals * PTR is constant en * PTR kan niet opnieuw veranderen
int * const ptr;terwijl hier denkt zoals PTR als een constante en die niet meer kan worden veranderd