Denne artikel handler om pointer-aritmetik i C++. Pointere er variabler, der gemmer dataenes hukommelsesadresse. Pointer-aritmetik er et kraftfuldt kendetegn i C++-programmeringssprogets verden, der gør det muligt for os at håndtere forskellige aritmetiske operationer, hvor addition, multiplikation, division, inkrementering, dekrementering og subtraktion involverer en markør til at udvikle den nye hukommelsesadresse i vores hukommelsesbuffere . En pointer-aritmetik skaber nemt den dynamiske hukommelsesallokering. I denne C++-artikel lærer vi, hvordan man manipulerer hukommelsesadressen på forskellige måder ved hjælp af pegepinde og giver ordentlige retningslinjer og eksempler.
Scenarie 1: Pointeren udfører trin- og sænkningsoperationerne
Her vil vi lære om pointermanipulation for at producere forskellige hukommelsesadresser, der har forskellige formål. De stigende og dekrementerende pointere er også gearing pointer-aritmetikken, der øger eller formindsker adressen med en faktor på én ganget med størrelsen af den datatype, som de peger på. Kodestykket relateret til dette scenarie er vedhæftet i følgende:
#include
bruger navneområde std;
const int Arr_Max = 5 ;
int main ( ) {
int hvor [ Arr_Max ] = { tyve , 150 , 270 } ;
int * ptr; // erklære pointer
ptr = var;
til ( int i = 0 ; jeg < Arr_Max; i++ ) {
std::cout << 'Hukommelsesadressen for elementet er: [' << jeg << '] = ' ;
std::cout << ptr << endl;
cout << 'Værdi i forhold til adressen er [' << jeg << '] = ' ;
cout << * ptr << endl;
std::cout << 'markøren er steget med succes' << endl;
ptr++;
}
std::cout << 'Pejladresse før formindskelse' << ptr << endl;
ptr--;
std::cout << 'Pejladresse efter formindskelse' << ptr << endl;
Vend tilbage 0 ;
}
Her definerer vi et påkrævet bibliotek i koden helt fra starten: '
Vi sender arrayet til markøren for at få adgang til adressen. Som vi alle ved, indeholder arrays altid flere elementer på forskellige steder. Så vi havde brug for en løkke med 'hjælp'-markøren for at få adgang til hvert element i et array. Hver gang løkken udføres, får vi hukommelsesadressen og værdierne mod denne adresse ved hjælp af pointer-aritmetikken 'ptr++' inkrementoperator, der flytter hukommelsesadressen til den næste adresse i hukommelsen. Løkkeudførelsescyklussen afhænger af størrelsen af et array. Uden for løkken ønsker vi at få markøren tilbage til den tidligere hukommelsesadresse ved blot at bruge 'ptr--' decrement pointer .
Udfør denne kode ved at klikke på Udfør>Kompilér og kør, og du vil få følgende output:
Forhåbentlig er dette output let at forstå. Hukommelsesadressen og værdien ændres. Det er kun muligt at flytte markøren fra et sted fra inkrement-pointer-aritmetikken i C++.
Scenarie 2: Strahering af to pointere i C++
I dette scenarie lærer vi at trække to eller flere pointere fra i C++. Alle de aritmetiske operationer, som subtraktionen kommer i, er vitale processer, da vi kun kan trække to pointere fra samtidigt, hvis og kun hvis de har samme datatype.
De andre operationer som addition, multiplikation og division er ikke mulige i markøren, fordi de ikke giver nogen mening i hukommelsesadressering. Kodestykket er vedhæftet i følgende:
#includeint main ( ) {
Han vinker [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Til den [ 3 ] ; // Marker til det tredje element ( 42 )
int * ptrr2 = & Til den [ 6 ] ; // Marker til det sjette element ( 89 )
ptrdiff_t ptr trække fra = ptrr2 - ptrr1;
std::cout << 'Forskellen mellem disse adresser er:' << ptr trække fra << 'elementer' << std::endl;
Vend tilbage 0 ;
}
Subtraktionsoperationen er at finde forskellen mellem hukommelsesadressen i C++. I hovedfunktionen tager vi et array, der indeholder forskellige værdier ved forskellige indekser. I et array har hvert indeks en anden hukommelsesplacering. Vi kan kun finde forskellen mellem to pointere ved hjælp af en pointer-aritmetik. Her bruger vi en speciel pointertype 'ptrdiff_t', som skal bruges til at finde forskellene mellem to eller flere pointere i C++.
Outputtet af denne kode er vedhæftet i følgende:
Forskellen mellem disse adresser er ved element skruestik, som er 3.
Scenarie 3: Sammenlign to eller flere pointere i C++
I dette scenarie lærer vi, hvordan man sammenligner de forskellige pointere i C++ ved hjælp af forskellige relationelle operatorer som '==', '<=', '>=', '<', '>'. Vi kan kun sammenligne pointerne, hvis de peger på adressen på elementer i samme array. Husk, at sammenligning af to pointere med forskellige typer kan forårsage udefineret adfærd. Kodestykket, der er relateret til pointer-sammenligningen, er nævnt i det følgende:
#includebruger navneområde std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , elleve , 14 , 16 , 18 , tyve , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
hvis ( ptr1 ==ptr2 )
{
std::cout << 'pointere er lige' << endl;
}
andet hvis ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 er mindre end eller lig med ptr4' << endl ;;
}
andet
{
std::cout << 'pointere sammenlignes ikke på noget tidspunkt' << endl;
}
Vend tilbage 0 ;
}
Her tager vi et array med 10 elementer. Vi erklærer fire pointere, der peger på et andet indeks for arrayet. Derefter sammenligner vi disse fire pointere ved forskellige forhold, som det ses i den givne kode. I tilstanden 'hvis' skal du kontrollere, om 'ptr1'-markøren er lig med 'ptr2'-markøren, og derefter udskrive 'pegerne er ens'. Når vi har flere betingelser, hvor vi bruger betingelsen 'else hvis' til at kontrollere, om 'ptr3'-markøren er mindre end lig med 'ptr4'-markøren. Efter alt det, klik på Udfør > Kompiler og kør mulighed.
Outputtet af denne kode er vedhæftet i følgende:
Den viser en gyldig tilstand på konsolskærmen og afslutter kompileringen. 'ptr3'-markøren indeholder en værdi, der er mindre end eller lig med 'ptr4'-markørens pegeværdi.
Scenarie 4: Vis et ulige tal med pointer-aritmetik
Her vil vi se, hvordan vi dynamisk kan allokere hukommelsen til et array af et heltal. Kodestykket relateret til denne sag er givet i følgende:
#includeint main ( ) {
int tal [ ] = { 1 , 12 , 33 , 24 , femten , 776 , 71 , 18 , 29 , halvtreds } ;
int * ptrr = tal;
std::cout << 'Ulige tal i arrays:' ;
til ( int i = 0 ; jeg < 10 ; ++i ) {
hvis ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
Vend tilbage 0 ;
}
I hovedfunktionen tager vi et array, der indeholder 10 elementer. Vi har brug for en pointer, der peger på alle elementerne i arrayet for at kontrollere det ulige tal i arrayet. I 'for'-løkken skal du kontrollere det ulige tal ved at dividere det aktuelle element i en matrix. Pointertælleren øges efter kontrol af et element i et array.
Efter eksekvering af koden vises outputtet på konsolskærmen, der er angivet i følgende:
På denne måde kan vi vise de ulige tal ved hjælp af pointer-aritmetikken på konsolskærmen.
Konklusion
Vi konkluderer her, at pointer-aritmetikken er det mest effektive værktøj, der udfører forskellige operationer i C++. Sørg for, at markøren øger eller mindsker værdien af et array, der har samme datatype. Vi kan sammenligne værdierne af et array ved deres hukommelsesadresser ved hjælp af pointer-aritmetik i C++-programmeringssproget. Vi kan krydse arrayet og håndtere hukommelsen nemt ved hjælp af pointer-aritmetik.