Dit artikel gaat over pointer-rekenkunde in C++. Pointers zijn variabelen die het geheugenadres van de gegevens opslaan. Pointer-rekenkunde is een krachtig kenmerk in de wereld van de C++-programmeertaal waarmee we verschillende rekenkundige bewerkingen kunnen uitvoeren waarbij het optellen, vermenigvuldigen, delen, verhogen, verlagen en aftrekken een aanwijzer inhoudt om het nieuwe geheugenadres in onze geheugenbuffers te ontwikkelen. . Een pointer-berekening creëert eenvoudig de dynamische geheugentoewijzing. In dit C++-artikel leren we hoe we het geheugenadres op verschillende manieren kunnen manipuleren met behulp van pointers en geven we de juiste richtlijnen en voorbeelden.
Scenario 1: Aanwijzer voert de bewerkingen voor verhogen en verlagen uit
Hier zullen we leren over pointermanipulatie om verschillende geheugenadressen te produceren die verschillende doeleinden hebben. De oplopende en aflopende pointers zijn ook de rekenkundige hefboompointers die het adres verhogen of verlagen met een factor één vermenigvuldigd met de grootte van het gegevenstype waarnaar ze verwijzen. Het codefragment met betrekking tot dit scenario is als volgt bijgevoegd:
#include
namespace std; gebruiken;
const int Arr_Max = 5 ;
int. hoofd ( ) {
int waar [ Arr_Max ] = { twintig , 150 , 270 } ;
int * ptr; // verklaren wijzer
ptr = var;
voor ( int ik = 0 ; i < Arr_Max; ik++ ) {
std::uit << 'Geheugenadres van het element is: [' << i << '] = ' ;
std::uit << ptr << eind;
uit << 'Waarde ten opzichte van het adres is [' << i << '] = ' ;
uit << * ptr << eind;
std::uit << 'aanwijzer succesvol verhoogd' << eind;
ptr++;
}
std::uit << 'Aanwijzeradres vóór verlaging' << ptr << eind;
ptr--;
std::uit << 'Aanwijzeradres na verlaging' << ptr << eind;
opbrengst 0 ;
}
Hier definiëren we helemaal aan het begin een vereiste bibliotheek in de code: “
We geven de array door aan de pointer om toegang te krijgen tot het adres. Zoals we allemaal weten, bevatten arrays altijd meerdere items op verschillende locaties. We hadden dus een lus nodig met de “help”-aanwijzer om toegang te krijgen tot elk element van een array. Elke keer dat de lus wordt uitgevoerd, krijgen we het geheugenadres en de waarden voor dit adres met behulp van de rekenkundige pointer-operator “ptr++” die het geheugenadres naar het volgende adres in het geheugen verschuift. De lusuitvoeringscyclus is afhankelijk van de grootte van een array. Buiten de lus willen we de pointer terugbrengen naar het vorige geheugenadres door simpelweg de “ptr- -” decrement pointer te gebruiken.
Voer deze code uit door op de optie Uitvoeren>Compileren en uitvoeren te klikken en u krijgt de volgende uitvoer:
Hopelijk is deze uitvoer gemakkelijk te begrijpen. Het geheugenadres en de waarde worden gewijzigd. Het verplaatsen van de aanwijzer vanaf één locatie is alleen mogelijk vanuit de rekenkunde van de oplopende aanwijzer in C++.
Scenario 2: Twee pointers aftrekken in C++
In dit scenario leren we hoe we twee of meer pointers in C++ kunnen aftrekken. Alle rekenkundige bewerkingen waarbij het aftrekken plaatsvindt, zijn vitale processen, omdat we alleen twee wijzers tegelijk kunnen aftrekken als en slechts als ze hetzelfde gegevenstype hebben.
De andere bewerkingen zoals optellen, vermenigvuldigen en delen zijn niet mogelijk in de pointer, omdat ze geen zin hebben bij geheugenadressering. Het codefragment is als volgt bijgevoegd:
#includeint. hoofd ( ) {
Hij wenkt [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Op dat [ 3 ] ; // Wijzer naar het derde element ( 42 )
int * ptrr2 = & Op dat [ 6 ] ; // Wijzer naar het zesde element ( 89 )
ptrdiff_t aftrekken = ptrr2 - ptrr1;
std::uit << 'Verschil tussen deze adressen is: ' << aftrekken << 'elementen' << std::endl;
opbrengst 0 ;
}
De aftrekbewerking is het vinden van het verschil tussen het geheugenadres in C++. In de hoofdfunctie nemen we een array die verschillende waarden bij verschillende indexen bevat. In een array heeft elke index een andere geheugenlocatie. We kunnen het verschil tussen twee wijzers alleen vinden met behulp van een aanwijzerberekening. Hier gebruiken we een speciaal pointertype “ptrdiff_t” dat moet worden gebruikt om de verschillen tussen twee of meer pointers in C++ te vinden.
De uitvoer van deze code is als volgt bijgevoegd:
Het verschil tussen deze adressen is per element bankschroef, namelijk 3.
Scenario 3: Vergelijk twee of meer pointers in C++
In dit scenario leren we hoe we de verschillende pointers in C++ kunnen vergelijken met behulp van verschillende relationele operatoren zoals “==”, “<=”, “>=”, “<”, ”>”. We kunnen de pointers alleen vergelijken als ze naar het adres van elementen van dezelfde array verwijzen. Houd er rekening mee dat het vergelijken van twee pointers met verschillende typen ongedefinieerd gedrag kan veroorzaken. Het codefragment dat betrekking heeft op de aanwijzervergelijking wordt hieronder vermeld:
#includenamespace std; gebruiken;
int. hoofd ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , elf , 14 , 16 , 18 , twintig , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
als ( ptr1 ==ptr2 )
{
std::uit << 'wijzers zijn gelijk' << eind;
}
anders als ( ptr3 < =ptr4 )
{
std::uit << 'ptr3 is kleiner dan of gelijk aan ptr4' << eindl ;;
}
anders
{
std::uit << 'Aanwijzingen worden in geen enkel stadium vergeleken' << eind;
}
opbrengst 0 ;
}
Hier nemen we een array met 10 elementen. We declareren vier pointers die naar een andere index van de array verwijzen. Daarna vergelijken we deze vier aanwijzingen onder verschillende omstandigheden, zoals te zien in de gegeven code. Controleer in de ‘if’-voorwaarde of de ‘ptr1’-aanwijzer gelijk is aan de ‘ptr2’-aanwijzer en druk vervolgens de ‘aanwijzers zijn gelijk’ af. Wanneer we meerdere voorwaarden hebben waarbij we de “else if”-voorwaarde gebruiken om te controleren of de “ptr3”-aanwijzer kleiner is dan gelijk aan de “ptr4”-aanwijzer. Klik daarna op de Uitvoeren > Compileren en uitvoeren keuze.
De uitvoer van deze code is als volgt bijgevoegd:
Er wordt een geldige voorwaarde weergegeven op het consolescherm en de compilatie wordt afgesloten. De “ptr3”-aanwijzer bevat een waarde die kleiner is dan of gelijk is aan de “ptr4”-aanwijzer.
Scenario 4: geef een oneven getal weer met aanwijzerberekening
Hier zullen we zien hoe we het geheugen voor een array van een geheel getal dynamisch kunnen toewijzen. Het codefragment met betrekking tot deze case wordt als volgt weergegeven:
#includeint. hoofd ( ) {
int-nummers [ ] = { 1 , 12 , 33 , 24 , vijftien , 776 , 71 , 18 , 29 , vijftig } ;
int * ptrr = getallen;
std::uit << 'Oneven getallen in de arrays: ' ;
voor ( int ik = 0 ; i < 10 ; ++ik ) {
als ( * prr % 2 ! = 0 ) {
std::uit << * prr << ' ' ;
}
ptrr++;
}
std::uit << std::endl;
opbrengst 0 ;
}
In de hoofdfunctie nemen we een array die 10 elementen bevat. We hebben een aanwijzer nodig die alle elementen in de array aanwijst om het oneven getal in de array te controleren. Controleer in de “for”-lus het oneven getal door het huidige element van een array te delen. De pointerteller wordt verhoogd nadat één element van een array is gecontroleerd.
Na het uitvoeren van de code wordt de uitvoer weergegeven op het consolescherm dat als volgt wordt weergegeven:
Op deze manier kunnen we de oneven getallen weergeven met behulp van de rekenkundige aanwijzer op het consolescherm.
Conclusie
We concluderen hier dat de pointer-rekenkunde het meest effectieve hulpmiddel is dat verschillende bewerkingen in C++ uitvoert. Zorg ervoor dat de aanwijzer de waarde van een array met hetzelfde gegevenstype verhoogt of verlaagt. We kunnen de waarden van een array vergelijken aan de hand van hun geheugenadressen met behulp van pointer-berekeningen in de programmeertaal C++. We kunnen de array doorkruisen en het geheugen eenvoudig beheren met behulp van pointer-berekeningen.