Questo articolo riguarda l'aritmetica dei puntatori in C++. I puntatori sono variabili che memorizzano l'indirizzo di memoria dei dati. L'aritmetica dei puntatori è un potente segno distintivo nel mondo del linguaggio di programmazione C++ che ci consente di gestire diverse operazioni aritmetiche in cui l'addizione, la moltiplicazione, la divisione, l'incremento, il decremento e la sottrazione coinvolgono un puntatore per sviluppare il nuovo indirizzo di memoria nei nostri buffer di memoria . Un'aritmetica del puntatore crea facilmente l'allocazione dinamica della memoria. In questo articolo su C++ impareremo come manipolare l'indirizzo di memoria in diversi modi con l'aiuto di puntatori e forniremo linee guida ed esempi adeguati.
Scenario 1: il puntatore esegue le operazioni di incremento e decremento
Qui impareremo la manipolazione dei puntatori per produrre indirizzi di memoria diversi che hanno scopi diversi. I puntatori di incremento e decremento sono anche i puntatori di leva aritmetici che aumentano o diminuiscono l'indirizzo di un fattore uno moltiplicato per la dimensione del tipo di dati a cui puntano. Lo snippet di codice relativo a questo scenario è allegato di seguito:
#include
utilizzando lo spazio dei nomi std;
const int Arr_Max = 5 ;
int principale ( ) {
int dove [ Arr_Max ] = { venti , 150 , 270 } ;
int * ptr; // dichiarare puntatore
ptr = var;
per ( int io = 0 ; io < Arr_Max; i++ ) {
std::cout << 'L'indirizzo di memoria dell'elemento è: [' << io << '] = ' ;
std::cout << ptr << fine;
cout << 'Il valore rispetto all'indirizzo è [' << io << '] = ' ;
cout << * ptr << fine;
std::cout << 'puntatore incrementato con successo' << fine;
ptr++;
}
std::cout << 'Indirizzo del puntatore prima del decremento' << ptr << fine;
ptr--;
std::cout << 'Indirizzo del puntatore dopo il decremento' << ptr << fine;
ritorno 0 ;
}
Qui definiamo fin dall'inizio una libreria richiesta nel codice: “
Passiamo l'array al puntatore per accedere all'indirizzo. Come tutti sappiamo, gli array contengono sempre più elementi in posizioni diverse. Quindi, avevamo bisogno di un ciclo con il puntatore 'help' per accedere a ogni elemento di un array. Ogni volta che il ciclo viene eseguito, otteniamo l'indirizzo di memoria e i valori rispetto a questo indirizzo con l'aiuto dell'operatore di incremento aritmetico del puntatore 'ptr++' che sposta l'indirizzo di memoria all'indirizzo successivo della memoria. Il ciclo di esecuzione del ciclo dipende dalla dimensione di un array. Al di fuori del ciclo, vogliamo riportare il puntatore all'indirizzo di memoria precedente semplicemente utilizzando il puntatore di decremento 'ptr- -'.
Esegui questo codice facendo clic sull'opzione Esegui>Compile ed esegui e otterrai il seguente output:
Si spera che questo output sia facile da capire. L'indirizzo e il valore della memoria vengono modificati. Lo spostamento del puntatore da una posizione è possibile solo dall'aritmetica di incremento del puntatore in C++.
Scenario 2: sottrazione di due puntatori in C++
In questo scenario impareremo come sottrarre due o più puntatori in C++. Tutte le operazioni aritmetiche in cui avviene la sottrazione sono processi vitali poiché possiamo sottrarre due puntatori contemporaneamente solo se e solo se hanno lo stesso tipo di dati.
Le altre operazioni come addizione, moltiplicazione e divisione non sono possibili nel puntatore perché non hanno senso nell'indirizzamento della memoria. Lo snippet di codice è allegato di seguito:
#includeint principale ( ) {
Fa un cenno [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & A tale [ 3 ] ; // Puntatore al terzo elemento ( 42 )
int * ptrr2 = & A tale [ 6 ] ; // Puntatore al sesto elemento ( 89 )
ptrdiff_t ptrsubtract = ptrr2 - ptrr1;
std::cout << 'La differenza tra questi indirizzi è: ' << ptrsubtract << ' elementi' << std::endl;
ritorno 0 ;
}
L'operazione di sottrazione consiste nel trovare la differenza tra l'indirizzo di memoria in C++. Nella funzione main, prendiamo un array che contiene valori diversi in indici diversi. In un array, ogni indice ha una posizione di memoria diversa. Possiamo trovare la differenza tra due puntatori solo con l'aiuto dell'aritmetica dei puntatori. Qui utilizziamo un puntatore speciale di tipo 'ptrdiff_t' che deve essere utilizzato per trovare le differenze tra due o più puntatori in C++.
L'output di questo codice è allegato di seguito:
La differenza tra questi indirizzi è dovuta all'elemento vise che è 3.
Scenario 3: confrontare due o più puntatori in C++
In questo scenario, impareremo come confrontare i diversi puntatori in C++ utilizzando diversi operatori relazionali come “==”, “<=”, “>=”, “<”, ”>”. Possiamo confrontare i puntatori solo se puntano all'indirizzo di elementi dello stesso array. Ricordare che il confronto di due puntatori con tipi diversi può causare un comportamento indefinito. Il frammento di codice correlato al confronto dei puntatori è menzionato di seguito:
#includeutilizzando lo spazio dei nomi std;
int principale ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , undici , 14 , 16 , 18 , venti , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
Se ( ptr1 ==ptr2 )
{
std::cout << 'i puntatori sono uguali' << fine;
}
altro Se ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 è inferiore o uguale a ptr4' << fine ;;
}
altro
{
std::cout << 'i puntatori non vengono confrontati in nessuna fase' << fine;
}
ritorno 0 ;
}
Qui prendiamo un array con 10 elementi. Dichiariamo quattro puntatori che puntano a un indice diverso dell'array. Successivamente, confrontiamo questi quattro puntatori in condizioni diverse come visto nel codice fornito. Nella condizione 'if', controlla se il puntatore 'ptr1' è uguale al puntatore 'ptr2', quindi stampa il risultato 'i puntatori sono uguali'. Quando abbiamo più condizioni in cui utilizziamo la condizione 'else if' per verificare se il puntatore 'ptr3' è inferiore a uguale al puntatore 'ptr4'. Dopo tutto ciò, fai clic su Esegui > Compila ed esegui opzione.
L'output di questo codice è allegato di seguito:
Visualizza una condizione valida sullo schermo della console ed esce dalla compilazione. Il puntatore 'ptr3' contiene un valore inferiore o uguale al valore di puntamento del puntatore 'ptr4'.
Scenario 4: visualizzare un numero dispari con l'aritmetica del puntatore
Qui vedremo come allocare dinamicamente la memoria per un array di numeri interi. Lo snippet di codice relativo a questo caso è riportato di seguito:
#includeint principale ( ) {
numeri interi [ ] = { 1 , 12 , 33 , 24 , quindici , 776 , 71 , 18 , 29 , cinquanta } ;
int * ptrr = numeri;
std::cout << 'Numeri dispari negli array: ' ;
per ( int io = 0 ; io < 10 ; ++i ) {
Se ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
prr++;
}
std::cout << std::endl;
ritorno 0 ;
}
Nella funzione main, prendiamo un array che contiene 10 elementi. Abbiamo bisogno di un puntatore che indichi tutti gli elementi nell'array per verificare il numero dispari nell'array. Nel ciclo 'for', controlla il numero dispari dividendo l'elemento corrente di un array. Il contatore del puntatore viene incrementato dopo aver controllato un elemento di un array.
Dopo aver eseguito il codice, l'output viene visualizzato sulla schermata della console riportata di seguito:
In questo modo possiamo visualizzare i numeri dispari utilizzando l'aritmetica del puntatore sullo schermo della console.
Conclusione
Concludiamo qui che l'aritmetica dei puntatori è lo strumento più efficace per eseguire diverse operazioni in C++. Assicurarsi che il puntatore incrementi o diminuisca il valore di un array con lo stesso tipo di dati. Possiamo confrontare i valori di un array in base ai loro indirizzi di memoria con l'aiuto dell'aritmetica dei puntatori nel linguaggio di programmazione C++. Possiamo attraversare l'array e gestire facilmente la memoria con l'aiuto dell'aritmetica dei puntatori.