In questo articolo abbiamo spiegato la differenza tra * e ** puntatore in C e C++.
Indice:
1. Cosa sono i puntatori?
2. Esempi di puntatore
3. Implementazione di puntatori utilizzando C
4. *p rispetto a **p puntatore
5. Implementazione di *p e **p usando C
Cosa sono i puntatori?
Il puntatore è una variabile utilizzata per memorizzare l'indirizzo in memoria di un'altra variabile.
I due operatori utilizzati nei puntatori:
- Operatore &:- Fornisce l'indirizzo di una variabile
- Operatore * :- Fornisce i valori nella posizione
Alcuni punti:
- L'indirizzo non può essere negativo.
- La variabile puntatore occupa gli stessi byte di memoria indipendentemente dal tipo di dati.
- La dimensione della variabile del puntatore varia da sistema a sistema a seconda del sistema operativo.
- La variabile puntatore può dereferenziare n. di byte a seconda del tipo di dati.
* Il puntatore intero può dereferenziare due byte di dati.
* Il puntatore del carattere può accedere a un byte di dati.
* Il puntatore mobile può accedere a quattro byte di dati. - La variabile puntatore verrà dichiarata utilizzando '*'(asterisco).
Esempi di puntatore:
int * p ; // Declaration of pointer ‘p’
int a = 10 ;
p = &a ; //Assigning
//now pointer ‘p’ is pointing at variable ‘a’.
Qui stiamo dichiarando e assegnando il blocco di memoria 'a' a un puntatore 'p'.
- 'p' è la variabile puntatore di tipo intero in cui possiamo memorizzare l'indirizzo di qualsiasi variabile intera.
- 'a' è una variabile intera che memorizza il valore 10.
int * p ;
int a = 10 , b ;
b = &a ; //ERROR
Qui vediamo un errore perché stiamo cercando di memorizzare l'indirizzo di un intero 'a' in un altro intero 'b'
int a = 10 ;
printf(" a = %d " , * &a ); // output will be a = 10
Qui stiamo stampando il valore di 'a' rappresentandolo come un puntatore. Dì semplicemente a=``*&a .
int * p ;
int a = 10 ;
p = &a ;
printf(" %d " , a * p ) ; // ERROR
printf(" %d " , a * * p ); // No ERROR
Qui vediamo un ERRORE, perché 'a' ha un valore(=10) e *p ha anche un valore (=10) ma il compilatore confonderà cosa vogliamo fare perché il compilatore lo vede come printf(" %d ", (a) (*p ) ); , non ci sono operatori aritmetici per il compilatore.
Ma nella prossima istruzione printf() non vediamo alcun ERRORE perché il compilatore Now darà un output come 100 mentre stiamo facendo Moltiplicazione di 'a' e *p ed entrambi contengono value(=10).
Implementazione di puntatori utilizzando C
#include<stdio.h>
int main(){
int a=10;
int * p = &a ;
printf(" a = %d \n " , * p ) ; // It gives output a = 10
printf(" Address of a = %p \n ", p ) ; // It gives output Address of a
printf(" Address of p = %p \n ", & p ) ; // It gives output Address of p
return 0;
}
Qui stampiamo il valore di 'a' e l'indirizzo di 'a' e 'p'.
Uscita:
a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
*p rispetto a **p puntatore
*p è un puntatore, significa che contiene un indirizzo di un valore o un blocco di memoria riservata, può accedere fino a un livello.
Viene utilizzato se desideri conservare un blocco di memoria in cui si trovano i tuoi valori.
**p è un puntatore a un puntatore, significa che contiene un indirizzo che contiene un indirizzo di un valore o un blocco di memoria riservata, può accedere fino a due livelli.
Viene utilizzato se si desidera passare un puntatore a cui viene allocata la memoria in una funzione diversa.
#include<stdio.h>
int main(){
int a=10;
int * p = & a ; // b is a single pointer or a pointer
int ** c = &p; // c is a double pointer or pointer to a pointer
printf("using p \n ");
printf(" value of a = %d \n " , * p ) ; // It gives output value of a = 10
printf(" Address of a = %p \n ", p ) ; // It gives output Address of a
printf(" Address of p = %p \n", & p ) ; // It gives output Address of p
printf("using c \n ");
printf(" value of a = %d \n ", ** c ) ; // It gives output value of a
printf(" Address of a = %p \n ", * c ) ; // It gives output Address of a
printf(" Address of c = %p \n ", &c ) ; // It gives output Address of c
printf(" Address of p = %p \n ", c ) ; // It gives output Address of p
return 0;
}
Qui stiamo stampando i valori e gli indirizzi utilizzando un puntatore e un puntatore doppio.
Uscita:
using p
value of a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
using c
value of a = 10
Address of a = 000000000061FE1C
Address of c = 000000000061FE08
Address of p = 000000000061FE10
Implementazione di *p e **p usando C
#include<stdio.h>
void swap(int * x ,int * y ){
int t = * x ;
* x = * y ;
* y = t ;
}
int main(){
int a = 10 , b = 20 ;
printf(" Value of 'a' before swap = %d \n", a );
printf(" Value of 'b' before swap = %d \n", b );
swap( & a , & b ) ; //function call
printf(" Value of 'a' after swap = %d \n", a );
printf(" Value of 'b' after swap = %d \n", b );
return 0;
}
Eccoci a Scambiare due numeri usando i puntatori.
Quando chiamiamo la funzione swap(), inviamo gli indirizzi dei blocchi di memoria (cioè a, b) e per prendere quegli indirizzi, prendiamo puntatori interi come argomenti in swap() (cioè x, y).
Nella funzione swap(), stiamo scambiando i valori sugli indirizzi.
Uscita:
Value of 'a' before swap = 10
Value of 'b' before swap = 20
Value of 'a' after swap = 20
Value of 'b' after swap = 10
#include<stdio.h>
void func(int ** p1 )
{
int b = 2;
* p1 = & b;
}
int main()
{
int a = 10;
int * p = &a;
printf("Before the function, value of the p : %d \n", * p) ;
func(&p); //function Call
printf("After the function, new value of the p : %d \n", * p) ;
return 0;
}
Qui prendiamo prima un intero 'a' e gli assegniamo il valore 10,
quindi prendendo un puntatore intero 'p' e assegnando l'indirizzo di 'a' a 'p'.
Ora nella chiamata di funzione func(), stiamo dando l'indirizzo di 'p' che è un puntatore, per prendere l'indirizzo di un puntatore, la funzione func() dovrebbe avere un puntatore intero a un puntatore come argomento (cioè p1 in func (p1)).
In func() stiamo cambiando il valore da 10 a 2.
Uscita:
Before the function, value of the p : 10
After the function, new value of the p : 2
Con questo articolo su OpenGenus, devi avere un'idea completa del puntatore * vs ** in C.