Puntatore a Costante in C

Puntatore a costante in linguaggio C con esempi

In questo articolo parlerò di Puntatore a costante, Puntatore costante e Puntatore costante a una costante in C Lingua con esempi. Si prega di leggere i nostri articoli precedenti, in cui abbiamo discusso di Puntatore di caratteri in C Linguaggio con esempi. Quindi, alla fine di questo articolo, capirai in dettaglio i seguenti suggerimenti.

1. Cos'è Pointer to Constant?
2. Cos'è un puntatore costante?
3. Puntatore costante a una costante
4. Differenza tra Puntatore a costante, Puntatore costante e Puntatore costante a una costante nel linguaggio C

Cos'è Costante in C?

La parola chiave const nel linguaggio di programmazione C può essere applicata alla dichiarazione di qualsiasi variabile per specificare che il suo valore non verrà modificato. Il punto più importante che devi ricordare è che la parola chiave const si applica a tutto ciò che è immediatamente alla sua sinistra. Se non c'è nulla alla sua sinistra, si applica a tutto ciò che è immediatamente alla sua destra. Tenendo presente ciò, procediamo e comprendiamo il puntatore a costante, il puntatore costante e il puntatore costante a una costante in linguaggio C con esempi

Puntatore a costante in linguaggio C:

Il puntatore punterà a un indirizzo, in cui non può modificare il valore a quell'indirizzo. Ma è possibile che questo puntatore possa puntare ad altri indirizzi. Non è possibile assegnare valori nel puntatore a costante. Il valore del puntatore può essere incrementato o decrementato. Il puntatore punta agli oggetti dati costanti. Se questo non è chiaro al momento, non preoccuparti, cercheremo di capire questo concetto con alcuni esempi.

Sintassi:const * ;
Esempio:const int*p;

Programma da comprendere Puntatore a costante in linguaggio C

Nell'esempio seguente, abbiamo creato due variabili intere, ovvero aeb con rispettivamente i valori 10 e 20. Quindi abbiamo creato un puntatore alla costante utilizzando la parola chiave const, ad esempio const int *p; Una volta creato il puntatore costante, assegniamo l'indirizzo della variabile a a questo puntatore. Poiché è un puntatore alla costante, quindi non possiamo modificare l'indirizzo. Quindi, quando proviamo a cambiare il valore del puntatore, cioè *p =5; ci darà un errore. Ma è possibile cambiare l'indirizzo del puntatore in una variabile costante cioè p =&b;.

#include<stdio.h>
int main ()
{
    int a = 10, b = 20;
    const int *p;
    p = &a;
    printf ("value of a is %d, *p is %d \n", a, *p);
    *p = 5;		//wrong you can not change value at address
    printf ("value of a is %d, *p is %d \n", a, *p);
    p = &b;		//you can change address
    return 0;
}

Risultato:

Puntatore costante in linguaggio C:

Questo concetto è opposto al concetto Pointer to Constant. Qui, il puntatore punterà a un indirizzo che inizializzeremo al momento della dichiarazione. Dopodiché, non possiamo cambiare quell'indirizzo. Ma il valore a quell'indirizzo possiamo cambiare. Possiamo assegnare un valore a un puntatore costante. I valori non possono essere incrementati o decrementati. Il puntatore costante punta all'oggetto dati.

Sintassi: * const =;
Esempio:int*const p=&a;

Programma da comprendere Puntatore costante in linguaggio C

Nell'esempio seguente, abbiamo creato due variabili intere, ovvero aeb con rispettivamente i valori 10 e 20. Quindi abbiamo creato un puntatore costante utilizzando la parola chiave const, ovvero int *const p =&a; e assegniamo anche l'indirizzo della variabile a al momento di questa dichiarazione di puntatore costante. Poiché è una costante del puntatore, non possiamo modificare l'indirizzo. Quindi, quando proviamo a cambiare l'indirizzo del puntatore i.e.p =&b; ci darà un errore. Ma è possibile modificare il valore del puntatore costante cioè *p =5;

#include<stdio.h>
int main ()
{
    int a = 10, b = 20;
    int *const p = &a;
    printf ("value of a is %d, *p is %d \n ", a, *p);
    *p = 5;		//changing value at address
    printf ("value of a is %d, *p is %d \n ", a, *p);
    p = &b;		//changing address wrong
    return 0;
}

Risultato:

Qui, puoi vedere che riceviamo l'errore "assegnazione della variabile di sola lettura 'p' “. Significa che il valore della variabile 'p' che contiene 'p' non può essere modificato. Nel codice sopra, stiamo cambiando il valore di 'p' da &a a &b, cosa non possibile con puntatori costanti. Pertanto, possiamo dire che il puntatore costante, che punta a una variabile, non può puntare a un'altra variabile.

Puntatore costante a una costante in linguaggio C:

Un puntatore costante a una costante è un puntatore nel linguaggio di programmazione C, che è una combinazione dei due puntatori precedenti, ovvero Puntatore a costante e Puntatore costante. In questo caso, non si tratta né di modificare l'indirizzo della variabile a cui punta né di modificare il valore posto a tale indirizzo.
Sintassi:const * const ;
Esempio:const int* const ptr;

Capiamo il puntatore costante a una costante in linguaggio C con un esempio. Nell'esempio seguente, abbiamo dichiarato due variabili, ovvero aeb con rispettivamente i valori 10 e 20. Quindi dichiariamo un puntatore costante a una costante e quindi assegniamo l'indirizzo della variabile a. Quindi proviamo a cambiare il valore della variabile a tramite il puntatore ptr così come proviamo ad assegnare l'indirizzo della variabile b a questo puntatore ptr. Qui, in entrambi i casi, otterremo degli errori. E infine, stampiamo il valore della variabile, che è puntato dal puntatore 'ptr'.

#include <stdio.h>  
int main()  
{  
    int a=10, b=20;  
    const int* const ptr=&a;  
    *ptr=12;  //wrong
    ptr=&b;  //wrong
    printf("Value of ptr is :%d",*ptr);  
    return 0;  
}

Risultato:

Differenza tra Puntatore a costante, Puntatore costante e Puntatore costante a costante

Capiamo le differenze tra Pointer to Constant (const int *ptr), Constant Pointer int * const ptr) e Constant Pointer to a Constant (const int * const ptr) in lingua C.

Puntatore a costante (const int *ptr) :

Questo è un puntatore a un numero intero costante. In questo caso, non possiamo cambiare il valore che è puntato dal puntatore ptr, ma puoi cambiare il puntatore stesso cioè puoi cambiare l'indirizzo che è tenuto dal puntatore. Quindi, qui il valore del puntatore è costante ma l'indirizzo può essere modificato.

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a =10, b =20;
    const int *ptr = &a;
    //The following is illegal statement (assignment of read-only location *ptr) 
    //*ptr = b; 
    printf( "value pointed to by ptr: %d\n", *ptr);
    // ptr address can be changed and is legal
    ptr = &b;
    printf( "value pointed to by ptr: %d\n", *ptr);
}

Risultato:

Non c'è differenza tra const int *ptr e int const *ptr poiché entrambi sono puntatori a un numero intero const e anche la posizione di *(asterisco) è la stessa. Quindi, anche il seguente programma ti darà lo stesso output del precedente.

int main()
{
    int a =10, b =20;
    int const *ptr = &a;
    //The following is illegal statement (assignment of read-only location *ptr) 
    //*ptr = b; 
    printf( "value pointed to by ptr: %d\n", *ptr);
    // ptr address can be changed and is legal
    ptr = &b;
    printf( "value pointed to by ptr: %d\n", *ptr);
}     

Puntatore costante (int *const ptr):

Questo è un puntatore costante a un numero intero non costante. In questo caso, non è possibile modificare il puntatore ptr, ma è possibile modificare il valore indicato dal puntatore ptr. Quindi, qui l'indirizzo del puntatore è costante ma il valore può essere modificato.

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a =10, b =20;
    int *const ptr = &a;
    printf( "Value pointed to by ptr: %d\n", *ptr);
    printf( "Address ptr is pointing to: %d\n", ptr);
    
    //The following statement is illegal (assignment of read-only variable ptr)
    //ptr = &b; 
 
    // changing the value at the address ptr is pointing to
    *ptr = b;
    printf( "Value pointed to by ptr: %d\n", *ptr);
    printf( "Address ptr is pointing to: %d\n", ptr);
}  

Risultato:

Nota: Il puntatore punta sempre allo stesso indirizzo, viene modificato solo il valore nella posizione.

Puntatore costante a una costante (const int * const ptr):

Questo è un puntatore costante a un numero intero costante. Non è possibile modificare né il valore indicato da ptr né l'indirizzo del puntatore ptr. Quindi, qui sia l'indirizzo del puntatore che il valore sono costanti.

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a =10, b =20;
    int char *const ptr = &a;
     
    printf( "Value pointed to by ptr: %c\n", *ptr);
    printf( "Address ptr is pointing to: %d\n\n", ptr);
 
    //The following two statements are illegal
    // ptr = &b; illegal statement (assignment of read-only variable ptr)
    // *ptr = b; illegal statement (assignment of read-only location *ptr)
 
}

Nota: int const * const ptr è uguale a const int *const ptr.
Nel prossimo articolo parlerò di Puntatore nullo in C Linguaggio con esempi. Qui, in questo articolo, provo a spiegare Puntatore a costante in linguaggio C con esempi. Spero che questo articolo ti piaccia. Mi piacerebbe avere il tuo feedback. Pubblica il tuo feedback, domanda o commenti su questo articolo.