Ez a cikk a mutató aritmetikáról szól C++ nyelven. A mutatók olyan változók, amelyek az adatok memóriacímét tárolják. A mutató aritmetika a C++ programozási nyelvek világában egy erőteljes ismertetőjegy, amely lehetővé teszi számunkra, hogy különböző aritmetikai műveletekkel foglalkozzunk, amelyekben az összeadás, szorzás, osztás, növekmény, csökkentés és kivonás egy mutatót tartalmaz az új memóriacím létrehozásához a memóriapuffereinkben. . A mutató aritmetika könnyen létrehozza a dinamikus memóriafoglalást. Ebben a C++ cikkben megtanuljuk, hogyan lehet a memóriacímet különböző módon manipulálni mutatók segítségével, és megfelelő útmutatókat és példákat adunk.
1. forgatókönyv: A mutató végrehajtja a növelési és csökkentési műveleteket
Itt megtanuljuk a mutató manipulációját, amellyel különböző memóriacímeket hozhatunk létre, amelyeknek különböző céljai vannak. A növelő és csökkentő mutatók egyben a tőkeáttételi mutatók aritmetikai elemei is, amelyek növelik vagy csökkentik a címet annak az adattípusnak a méretével szorozva, amelyre mutatnak. Az ehhez a forgatókönyvhöz kapcsolódó kódrészlet az alábbiakban található:
#include
névtér használata std;
const int Arr_Max = 5 ;
int fő ( ) {
int hol [ Arr_Max ] = { húsz , 150 , 270 } ;
int * ptr; // kijelent mutató
ptr = var;
számára ( int i = 0 ; én < Arr_Max; i++ ) {
std::cout << 'Az elem memóriacíme: [' << én << '] = ' ;
std::cout << ptr << endl;
cout << 'A címhez viszonyított érték [' << én << '] = ' ;
cout << * ptr << endl;
std::cout << 'a mutató sikeresen növelve' << endl;
ptr++;
}
std::cout << 'A mutató címe a csökkentés előtt' << ptr << endl;
ptr--;
std::cout << 'Mutató címe csökkentés után' << ptr << endl;
Visszatérés 0 ;
}
Itt a legelején meghatározunk egy szükséges könyvtárat a kódban: „
A tömböt átadjuk a mutatónak, hogy elérjük a címet. Mint mindannyian tudjuk, a tömbök mindig több elemet tartalmaznak különböző helyeken. Tehát szükségünk volt egy hurokra a „súgó” mutatóval, hogy elérjük a tömb minden elemét. Minden alkalommal, amikor a ciklus lefut, a memóriacímet és az értékeket ehhez a címhez viszonyítva kapjuk meg a „ptr++” mutató aritmetikai inkrementális operátor segítségével, amely a memóriacímet a memória következő címére tolja el. A ciklus végrehajtási ciklusa a tömb méretétől függ. A cikluson kívül a mutatót vissza akarjuk vinni az előző memóriacímre a „ptr--” csökkentési mutató használatával.
Futtassa ezt a kódot az Execute>Compile & Run opcióra kattintva, és a következő kimenetet kapja:
Remélhetőleg ez a kimenet könnyen érthető. A memória címe és értéke megváltozik. A mutató eltolása egy helyről csak a növekményes mutató aritmetikájából lehetséges a C++ nyelven.
2. forgatókönyv: Két mutató kivonása C++ nyelven
Ebben a forgatókönyvben megtanuljuk, hogyan lehet két vagy több mutatót kivonni a C++ nyelven. Az összes aritmetikai művelet, amelyben a kivonás jön, létfontosságú folyamat, mivel egyszerre csak akkor és csak akkor tudunk kivonni két mutatót, ha azonos adattípusúak.
A többi művelet, mint az összeadás, szorzás és osztás nem lehetséges a mutatóban, mert nincs értelme a memóriacímzésben. A kódrészlet az alábbiakban található:
#includeint fő ( ) {
int Arra [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Arra [ 3 ] ; // Mutasson a harmadik elemre ( 42 )
int * ptrr2 = & Arra [ 6 ] ; // Mutasson a hatodik elemre ( 89 )
ptrdiff_t ptrvonni = ptrr2 - ptrr1;
std::cout << 'A címek közötti különbség a következő: << ptrvonni << 'elemek' << std::endl;
Visszatérés 0 ;
}
A kivonási művelet a C++ memóriacímek közötti különbség megtalálása. A fő függvényben veszünk egy tömböt, amely különböző indexeken különböző értékeket tartalmaz. Egy tömbben minden indexnek más a memóriahelye. Két mutató közötti különbséget csak mutatóaritmetika segítségével találhatjuk meg. Itt egy speciális „ptrdiff_t” típusú mutatót használunk, amelyet arra kell használni, hogy megtaláljuk a különbségeket két vagy több mutató között a C++-ban.
Ennek a kódnak a kimenete az alábbiakban található:
A különbség ezek között a címek között satu elem szerint van, ami 3.
3. forgatókönyv: Hasonlítson össze két vagy több mutatót C++ nyelven
Ebben a forgatókönyvben megtanuljuk, hogyan hasonlítsuk össze a különböző mutatókat C++-ban különböző relációs operátorok használatával, mint például a „==”, „<=”, „>=”, „<”, ”>”. A mutatókat csak akkor tudjuk összehasonlítani, ha ugyanazon tömb elemeinek címére mutatnak. Ne feledje, hogy két különböző típusú mutató összehasonlítása meghatározatlan viselkedést okozhat. A mutató-összehasonlításhoz kapcsolódó kódrészlet az alábbiakban szerepel:
#includenévtér használata std;
int fő ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , tizenegy , 14 , 16 , 18 , húsz , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
ha ( ptr1 ==ptr2 )
{
std::cout << 'a mutatók egyenlőek' << endl;
}
más ha ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 kisebb vagy egyenlő, mint ptr4' << endl ;;
}
más
{
std::cout << 'a mutatókat egyik szakaszban sem hasonlítják össze' << endl;
}
Visszatérés 0 ;
}
Itt veszünk egy 10 elemből álló tömböt. Négy mutatót deklarálunk, amelyek a tömb másik indexére mutatnak. Ezt követően összehasonlítjuk ezt a négy mutatót az adott kódban látható különböző feltételek mellett. Az „if” feltételben ellenőrizze, hogy a „ptr1” mutató megegyezik-e a „ptr2” mutatóval, majd nyomtassa ki a „mutatók egyenlőek”. Ha több feltételünk van, amikor az „else if” feltételt használjuk annak ellenőrzésére, hogy a „ptr3” mutató kisebb-e, mint a „ptr4” mutató. Mindezek után kattintson a Végrehajtás > Fordítás és futtatás választási lehetőség.
Ennek a kódnak a kimenete az alábbiakban található:
Érvényes feltételt jelenít meg a konzol képernyőjén, és kilép a fordításból. A „ptr3” mutató olyan értéket tartalmaz, amely kisebb vagy egyenlő, mint a „ptr4” mutató mutató értéke.
4. forgatókönyv: Páratlan szám megjelenítése a mutató aritmetikával
Itt látni fogjuk, hogyan tudjuk dinamikusan lefoglalni a memóriát egy egész szám tömbje számára. Az ehhez az esethez kapcsolódó kódrészlet az alábbiakban található:
#includeint fő ( ) {
int számok [ ] = { 1 , 12 , 33 , 24 , tizenöt , 776 , 71 , 18 , 29 , ötven } ;
int * ptrr = számok;
std::cout << 'Páratlan számok a tömbökben:' ;
számára ( int i = 0 ; én < 10 ; ++i ) {
ha ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
Visszatérés 0 ;
}
A fő függvényben veszünk egy tömböt, amely 10 elemet tartalmaz. Szükségünk van egy mutatóra, amely rámutat a tömb összes elemére, hogy ellenőrizzük a páratlan számot a tömbben. A „for” ciklusban ellenőrizze a páratlan számot egy tömb aktuális elemének elosztásával. A mutatószámláló a tömb egy elemének ellenőrzése után növekszik.
A kód végrehajtása után a kimenet megjelenik a konzol képernyőjén, amely az alábbiak szerint van megadva:
Így a páratlan számokat a mutató aritmetikával tudjuk megjeleníteni a konzol képernyőjén.
Következtetés
Itt arra a következtetésre jutunk, hogy a mutató aritmetika a leghatékonyabb eszköz, amely különböző műveleteket hajt végre C++ nyelven. Győződjön meg arról, hogy a mutató növeli vagy csökkenti az azonos adattípusú tömb értékét. Egy tömb értékeit memóriacímeik alapján tudjuk összehasonlítani a C++ programozási nyelvben a pointer aritmetika segítségével. Mutatóaritmetika segítségével könnyedén bejárhatjuk a tömböt és kezelhetjük a memóriát.