Den här artikeln handlar om pekaritmetik i C++. Pekare är variabler som lagrar minnesadressen för datan. Pekarritmetik är ett kraftfullt kännetecken inom programmeringsspråket C++ som tillåter oss att hantera olika aritmetiska operationer där addition, multiplikation, division, ökning, dekrementering och subtraktion involverar en pekare för att utveckla den nya minnesadressen i våra minnesbuffertar . En pekarritmetik skapar enkelt den dynamiska minnesallokeringen. I den här C++-artikeln kommer vi att lära oss hur man manipulerar minnesadressen på olika sätt med hjälp av pekare och ger ordentliga riktlinjer och exempel.
Scenario 1: Pekaren utför steg- och minskningsoperationerna
Här kommer vi att lära oss om pekarmanipulation för att producera olika minnesadresser som har olika syften. De inkrementerande och dekrementerande pekarna är också aritmetiken för hävstångspekare som ökar eller minskar adressen med en faktor på ett multiplicerat med storleken på den datatyp som de pekar mot. Kodavsnittet relaterat till detta scenario bifogas i följande:
#inkludera
använder namnutrymme std;
const int Arr_Max = 5 ;
int main ( ) {
int var [ Arr_Max ] = { tjugo , 150 , 270 } ;
int * ptr; // deklarera pekare
ptr = var;
för ( int i = 0 ; i < Arr_Max; i++ ) {
std::cout << 'Minnesadress för elementet är: [' << i << '] = ' ;
std::cout << ptr << endl;
cout << 'Värde mot adressen är [' << i << '] = ' ;
cout << * ptr << endl;
std::cout << 'pekaren har ökat framgångsrikt' << endl;
ptr++;
}
std::cout << 'Pekaradress före minskning' << ptr << endl;
ptr--;
std::cout << 'Pekaradress efter minskning' << ptr << endl;
lämna tillbaka 0 ;
}
Här definierar vi ett obligatoriskt bibliotek i koden i början: '
Vi skickar arrayen till pekaren för att komma åt adressen. Som vi alla vet innehåller arrayer alltid flera objekt på olika platser. Så vi behövde en loop med 'hjälp'-pekaren för att komma åt varje element i en array. Varje gång loopen körs får vi minnesadressen och värden mot denna adress med hjälp av pekarritmetiken 'ptr++' inkrementoperator som flyttar minnesadressen till nästa adress i minnet. Slingexekveringscykeln beror på storleken på en array. Utanför slingan vill vi få tillbaka pekaren till den tidigare minnesadressen genom att bara använda 'ptr--' dekrementeringspekaren .
Kör den här koden genom att klicka på alternativet Execute>Compile & Run och du får följande utdata:
Förhoppningsvis är denna utgång lätt att förstå. Minnesadressen och värdet ändras. Att flytta pekaren från en plats är endast möjligt från inkrementpekarens aritmetik i C++.
Scenario 2: Subtrahera två pekare i C++
I det här scenariot kommer vi att lära oss hur man subtraherar två eller flera pekare i C++. Alla aritmetiska operationer där subtraktionen kommer är viktiga processer eftersom vi bara kan subtrahera två pekare samtidigt om och bara om de har samma datatyp.
De andra operationerna som addition, multiplikation och division är inte möjliga i pekaren eftersom de inte är meningsfulla i minnesadressering. Kodavsnittet bifogas i följande:
#includeint main ( ) {
Han vinkar [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Till det [ 3 ] ; // Pekare till det tredje elementet ( 42 )
int * ptrr2 = & Till det [ 6 ] ; // Pekare till det sjätte elementet ( 89 )
ptrdiff_t ptrsubtrahera = ptr2 - ptrl;
std::cout << 'Skillnaden mellan dessa adresser är:' << ptrsubtrahera << 'element' << std::endl;
lämna tillbaka 0 ;
}
Subtraktionsoperationen är att hitta skillnaden mellan minnesadressen i C++. I huvudfunktionen tar vi en array som innehåller olika värden vid olika index. I en array har varje index en annan minnesplats. Vi kan bara hitta skillnaden mellan två pekare med hjälp av en pekare aritmetik. Här använder vi en speciell pekare typ 'ptrdiff_t' som måste användas för att hitta skillnaderna mellan två eller flera pekare i C++.
Utdata från denna kod bifogas i följande:
Skillnaden mellan dessa adresser beror på elementskruven som är 3.
Scenario 3: Jämför två eller fler pekare i C++
I det här scenariot kommer vi att lära oss hur man jämför de olika pekarna i C++ med olika relationsoperatorer som '==', '<=', '>=', '<', '>'. Vi kan bara jämföra pekarna om de pekar på adressen till element i samma array. Kom ihåg att att jämföra två pekare med olika typer kan orsaka odefinierat beteende. Kodavsnittet som är relaterat till pekarjämförelsen nämns i följande:
#includeanvänder namnutrymme std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , elva , 14 , 16 , 18 , tjugo , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
om ( ptr1 ==ptr2 )
{
std::cout << 'pekare är lika' << endl;
}
annan om ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 är mindre än eller lika med ptr4' << endl ;;
}
annan
{
std::cout << 'pekare jämförs inte i något skede' << endl;
}
lämna tillbaka 0 ;
}
Här tar vi en array med 10 element. Vi förklarar fyra pekare som pekar på ett annat index för arrayen. Efter det jämför vi dessa fyra pekare vid olika förhållanden som ses i den givna koden. I 'if'-tillståndet, kontrollera om 'ptr1'-pekaren är lika med 'ptr2'-pekaren och skriv sedan ut 'pekarna är lika'. När vi har flera villkor där vi använder villkoret 'annat om' för att kontrollera om 'ptr3'-pekaren är mindre än lika med 'ptr4'-pekaren. Efter allt det, klicka på Kör > Kompilera och kör alternativ.
Utdata från denna kod bifogas i följande:
Den visar ett giltigt villkor på konsolskärmen och avslutar kompileringen. 'ptr3'-pekaren innehåller ett värde som är mindre än eller lika med 'ptr4'-pekarens pekarvärde.
Scenario 4: Visa ett udda tal med Pointer Arithmetic
Här kommer vi att se hur vi dynamiskt kan allokera minnet för en array av ett heltal. Kodavsnittet relaterat till detta fall ges i följande:
#includeint main ( ) {
int siffror [ ] = { 1 , 12 , 33 , 24 , femton , 776 , 71 , 18 , 29 , femtio } ;
int * ptrr = siffror;
std::cout << 'Uda tal i arrayerna:' ;
för ( int i = 0 ; i < 10 ; ++i ) {
om ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
lämna tillbaka 0 ;
}
I huvudfunktionen tar vi en array som innehåller 10 element. Vi behöver en pekare som pekar ut alla element i arrayen för att kontrollera det udda numret i arrayen. I 'för'-loopen, kontrollera det udda talet genom att dividera det aktuella elementet i en array. Pekarräknaren inkrementeras efter kontroll av ett element i en array.
Efter exekvering av koden visas utdata på konsolskärmen som ges i följande:
På så sätt kan vi visa de udda talen med hjälp av pekarens aritmetik på konsolskärmen.
Slutsats
Vi drar slutsatsen här att pekararitmetiken är det mest effektiva verktyget som utför olika operationer i C++. Se till att pekaren ökar eller minskar värdet på en array som har samma datatyp. Vi kan jämföra värdena för en array med deras minnesadresser med hjälp av pekaritmetik i programmeringsspråket C++. Vi kan korsa arrayen och hantera minnet enkelt med hjälp av pekaritmetik.