C++ Puntatori con esempi

Dovresti vedere un puntatore come una rappresentazione simbolica di un indirizzo di memoria. Con i puntatori, i programmi possono simulare la chiamata per riferimento. Possono anche creare e manipolare strutture dati dinamiche. In C++, una variabile puntatore si riferisce a una variabile che punta a un indirizzo specifico in una memoria puntata da un'altra variabile.

Indirizzi in C++

Capire C++ puntatori, è necessario comprendere come i computer memorizzano i dati.

Quando crei una variabile nel tuo C++ programma, gli viene assegnato uno spazio nella memoria del computer. Il valore di questa variabile viene memorizzato nella posizione assegnata.

Per conoscere la posizione nella memoria del computer in cui sono archiviati i dati, C++ fornisce il & operatore (di riferimento). L'operatore restituisce l'indirizzo occupato da una variabile.

Ad esempio, se x è una variabile, &x restituisce l'indirizzo della variabile.

Sintassi della dichiarazione del puntatore

La dichiarazione di C++ assume la seguente sintassi:

datatype *variable_name; 

• Il tipo di dati è il tipo base del puntatore che deve essere valido C++ tipo di dati.
• Il variable_name dovrebbe essere il nome della variabile puntatore.
• L'asterisco utilizzato sopra per la dichiarazione del puntatore è simile all'asterisco utilizzato per eseguire l'operazione di moltiplicazione. È l'asterisco che contrassegna la variabile come puntatore.

Ecco un esempio di dichiarazioni di puntatori valide in C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Operatore di riferimento (&) e Operatore di deferenza (*)

L'operatore di riferimento (&) restituisce l'indirizzo della variabile.

L'operatore di dereferenziazione (*) ci aiuta a ottenere il valore che è stato memorizzato in un indirizzo di memoria.

Per esempio:

Se abbiamo una variabile con il nome num, memorizzata nell'indirizzo 0x234 e memorizzando il valore 28.

L'operatore di riferimento (&) restituirà 0x234.

L'operatore di dereferenziazione (*) restituirà 5.

Esempio 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Produzione:

Come funziona:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Importa il file di intestazione iostream. Questo ci consentirà di utilizzare le funzioni definite nel file header senza ottenere errori.
2. Includere lo spazio dei nomi std per utilizzare le sue classi senza chiamarlo.
3. Chiama la funzione main(). La logica del programma dovrebbe essere aggiunta all'interno del corpo di questa funzione. Il { segna l'inizio del corpo della funzione.
4. Dichiarare una variabile intera x e assegnarle il valore 27.
5. Dichiarare una variabile puntatore *ip.
6. Memorizza l'indirizzo della variabile x nella variabile puntatore.
7. Stampa del testo sulla console.
8. Stampa il valore della variabile x sullo schermo.
9. Stampa del testo sulla console.
10. Stampa l'indirizzo della variabile x. Il valore dell'indirizzo è stato memorizzato nella variabile ip.
11. Stampa del testo sulla console.
12. Stampa il valore memorizzato all'indirizzo del puntatore.
13. Il programma dovrebbe restituire valore dopo l'esecuzione riuscita.
14. Fine del corpo della funzione main().

Puntatori e array

Array e puntatori funzionano in base a un concetto correlato. Ci sono diverse cose da notare quando si lavora con array dotati di puntatori. Il nome stesso dell'array indica l'indirizzo di base dell'array. Ciò significa che per assegnare l'indirizzo di un array a un puntatore non è necessario utilizzare la e commerciale (&).

Per esempio:

p = arr;

Quanto sopra è corretto poiché arr rappresenta l'indirizzo degli array. Ecco un altro esempio:

p = &arr;

Quanto sopra non è corretto.

Possiamo convertire implicitamente un array in un puntatore. Per esempio:

int arr [20];
int * ip;

Di seguito è riportata un'operazione valida:

ip = arr;

Dopo la dichiarazione di cui sopra, ip e arr saranno equivalenti e condivideranno le proprietà. Tuttavia si può assegnare un indirizzo diverso a ip, ma non possiamo assegnare nulla ad arr.

Esempio 2:

Questo esempio mostra come attraversare un array utilizzando i puntatori:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Dichiara una variabile puntatore intero ip.
2. Dichiara un array chiamato arr e memorizza in esso 6 numeri interi.
3. Assegna arr a ip. L'ip e l'arr diventeranno equivalenti.
4. Crea un ciclo for. La variabile del ciclo x è stata creata per scorrere gli elementi dell'array dall'indice 0 a 5.
5. Stampa i valori memorizzati all'indirizzo del puntatore IP. Verrà restituito un valore per ogni iterazione e verranno eseguite un totale di 6 ripetizioni. La fine è a C++ parola chiave che indica la linea di fine. Questa azione consente di spostare il cursore sulla riga successiva dopo la stampa di ciascun valore. Ogni valore verrà stampato in una riga individuale.
6. Per spostare il puntatore alla posizione int successiva dopo ogni iterazione.
7. Fine del ciclo for.
8. Il programma deve restituire qualcosa dopo l'esecuzione riuscita.
9. Fine del corpo della funzione main().

Puntatore NULL

Se non c'è un indirizzo esatto da assegnare, alla variabile puntatore può essere assegnato un NULL. Dovrebbe essere fatto durante la dichiarazione. Un puntatore di questo tipo è noto come puntatore nullo. Il suo valore è zero ed è definito in molte librerie standard come iostream.

Esempio 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Dichiarare una variabile puntatore ip e assegnarle il valore NULL.
2. Stampa il valore della variabile puntatore ip accanto al testo sulla console.
3. Il programma deve restituire valore in caso di completamento positivo.
4. Fine del corpo della funzione main().

Puntatori di variabili

Con C++, puoi manipolare i dati direttamente dalla memoria del computer.

Lo spazio di memoria può essere assegnato o riassegnato come si desidera. Ciò è reso possibile dalle variabili Pointer.

Le variabili puntatore puntano a un indirizzo specifico nella memoria del computer puntato da un'altra variabile.

Può essere dichiarato come segue:

int *p;

oro,

int* p;

Nel tuo esempio, abbiamo dichiarato la variabile puntatore p.

Conterrà un indirizzo di memoria.

L'asterisco è l'operatore di dereferenziazione che indica un puntatore a.

Il puntatore p punta a un valore intero nell'indirizzo di memoria.

Esempio 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Dichiarare una variabile puntatore p e una variabile x con un valore di 30.
2. Assegnare l'indirizzo della variabile x a p.
3. Stampa il valore della variabile puntatore p insieme al testo sulla console.
4. Il programma deve restituire valore in caso di completamento positivo.
5. Fine del corpo della funzione main().

Applicazione dei puntatori

Funzioni in C++ può restituire un solo valore. Inoltre, tutte le variabili dichiarate in una funzione vengono allocate nello stack di chiamate della funzione. Non appena la funzione ritorna, tutte le variabili dello stack vengono distrutte.

Gli argomenti alla funzione vengono passati per valore e qualsiasi modifica apportata alle variabili non modifica il valore delle variabili effettive che vengono passate. Il seguente esempio aiuta a illustrare questo concetto:-

Esempio 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Crea un prototipo di una funzione denominata test che richiederà due parametri interi.
2. Chiama la funzione main(). Aggiungeremo la logica del programma all'interno del suo corpo.
3. Dichiara due variabili intere a e b, ciascuna con un valore 5.
4. Stampa del testo sulla console. Endl (fine riga) sposterà il cursore per iniziare la stampa nella riga successiva.
5. Stampa il valore della variabile a sulla console insieme ad altro testo. Endl (fine riga) sposterà il cursore per iniziare la stampa nella riga successiva.
6. Stampa il valore della variabile b sulla console insieme ad altro testo. Endl (fine riga) sposterà il cursore per iniziare la stampa nella riga successiva.
7. Crea una funzione denominata test() che accetta gli indirizzi delle variabili a e b come parametri.
8. Stampa del testo sulla console. \n creerà una nuova riga vuota prima che il testo venga stampato. Endl (riga finale) sposterà il cursore per iniziare la stampa nella riga successiva dopo la stampa del testo.
9. Stampa il valore della variabile a sulla console insieme ad altro testo. Endl (fine riga) sposterà il cursore per iniziare la stampa nella riga successiva.
10. Stampa il valore della variabile b sulla console insieme ad altro testo. Endl (fine riga) sposterà il cursore per iniziare la stampa nella riga successiva.
11. Il programma deve restituire valore in caso di completamento positivo.
12. Fine del corpo della funzione main().
13. Definizione della funzione test(). La funzione dovrebbe accettare due variabili puntatore intero *n1 e *n2.
14. Assegnando alla variabile puntatore *n1 un valore pari a 10.
15. Assegnando alla variabile puntatore *n2 un valore pari a 11.
16. Fine del corpo della funzione test().

Anche se nuovi valori vengono assegnati alle variabili a e b all'interno del test della funzione, una volta completata la chiamata della funzione, lo stesso non si riflette nella funzione esterna main.

L'uso dei puntatori come argomenti della funzione aiuta a passare l'indirizzo effettivo della variabile nella funzione e tutte le modifiche eseguite sulla variabile si rifletteranno nella funzione esterna.

Nel caso precedente, la funzione "test" ha l'indirizzo delle variabili "a" e "b". Queste due variabili sono direttamente accessibili dalla funzione "test" e quindi qualsiasi modifica apportata a queste variabili si riflette nella funzione chiamante "main".

Vantaggi dell'utilizzo dei puntatori

Ecco i vantaggi/vantaggi dell'utilizzo dei puntatori

• I puntatori sono variabili che memorizzano l'indirizzo di altri variabili in C++.
• Più di una variabile può essere modificata e restituita dalla funzione utilizzando i puntatori.
• La memoria può essere allocata e deallocata dinamicamente utilizzando i puntatori.
• I puntatori aiutano a semplificare la complessità del programma.
• La velocità di esecuzione di un programma migliora utilizzando i puntatori.

Sommario

• Un puntatore si riferisce a una variabile che contiene l'indirizzo di un'altra variabile.
• Ogni puntatore ha un tipo di dati valido.
• Un puntatore è una rappresentazione simbolica di un indirizzo di memoria.
• I puntatori consentono ai programmi di simulare la chiamata per riferimento e di creare e manipolare strutture di dati dinamiche.
• Array e i puntatori utilizzano un concetto correlato.
• Il nome dell'array indica la base dell'array.
• Se vuoi assegnare l'indirizzo di un array a un puntatore, non utilizzare la e commerciale (&).
• Se non esiste un indirizzo specifico a cui assegnare una variabile puntatore, assegnarle un NULL.