Tento článek je o aritmetice ukazatelů v C++. Ukazatele jsou proměnné, které ukládají paměťovou adresu dat. Aritmetika ukazatele je silným znakem ve světě programovacího jazyka C++, který nám umožňuje vypořádat se s různými aritmetickými operacemi, ve kterých sčítání, násobení, dělení, inkrementace, dekrementace a odčítání zahrnuje ukazatel k vytvoření nové adresy paměti v našich vyrovnávací paměti. . Aritmetika ukazatele snadno vytvoří dynamickou alokaci paměti. V tomto článku C++ se naučíme, jak různými způsoby manipulovat s adresou paměti pomocí ukazatelů, a poskytneme správné pokyny a příklady.
Scénář 1: Ukazatel Provádí operace zvýšení a snížení
Zde se naučíme o manipulaci s ukazateli pro vytvoření různých adres paměti, které mají různé účely. Inkrementační a dekrementační ukazatele jsou také aritmetikou ukazatelů páky, které zvyšují nebo snižují adresu faktorem jedna vynásobeným velikostí datového typu, na který ukazují. Fragment kódu související s tímto scénářem je připojen v následujícím textu:
#include
pomocí jmenného prostoru std;
const int Arr_Max = 5 ;
int main ( ) {
int kde [ Arr_Max ] = { dvacet , 150 , 270 } ;
int * ptr; // prohlásit ukazatel
ptr = var;
pro ( int i = 0 ; i < Arr_Max; i++ ) {
std::cout << 'Paměťová adresa prvku je: [' << i << '] = ' ;
std::cout << ptr << endl;
cout << 'Hodnota oproti adrese je [' << i << '] = ' ;
cout << * ptr << endl;
std::cout << 'ukazatel úspěšně zvýšen' << endl;
ptr++;
}
std::cout << 'Adresa ukazatele před snížením' << ptr << endl;
ptr--;
std::cout << 'Adresa ukazatele po snížení' << ptr << endl;
vrátit se 0 ;
}
Zde definujeme požadovanou knihovnu v kódu na samém začátku: „
Pole předáme ukazateli pro přístup k adrese. Jak všichni víme, pole vždy obsahují více položek na různých místech. Potřebovali jsme tedy smyčku s ukazatelem „help“ pro přístup ke každému prvku pole. Pokaždé, když se smyčka spustí, získáme adresu paměti a hodnoty proti této adrese pomocí aritmetického inkrementačního operátoru ukazatele „ptr++“, který posouvá adresu paměti na další adresu paměti. Cyklus provádění smyčky závisí na velikosti pole. Mimo smyčku chceme dostat ukazatel zpět na předchozí adresu paměti pouhým použitím ukazatele dekrementu „ptr--“.
Spusťte tento kód kliknutím na možnost Execute>Compile & Run a získáte následující výstup:
Doufejme, že tento výstup je snadno srozumitelný. Adresa paměti a hodnota se změní. Posunutí ukazatele z jednoho místa je možné pouze z aritmetiky inkrementálního ukazatele v C++.
Scénář 2: Odečtení dvou ukazatelů v C++
V tomto scénáři se naučíme, jak odečíst dva nebo více ukazatelů v C++. Všechny aritmetické operace, ve kterých dochází k odčítání, jsou životně důležité procesy, protože můžeme odečíst dva ukazatele současně pouze tehdy, pokud mají stejný datový typ.
Ostatní operace jako sčítání, násobení a dělení nejsou v ukazateli možné, protože nedávají smysl při adresování paměti. Fragment kódu je připojen v následujícím textu:
#includeint main ( ) {
Vábí [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & K tomu [ 3 ] ; // Ukazatel na třetí prvek ( 42 )
int * ptrr2 = & K tomu [ 6 ] ; // Ukazatel na šestý prvek ( 89 )
ptrdiff_t ptr odečíst = ptrr2 - ptrr1;
std::cout << 'Rozdíl mezi těmito adresami je:' << ptr odečíst << ' Prvky' << std::endl;
vrátit se 0 ;
}
Operace odečítání je nalezení rozdílu mezi adresou paměti v C++. Ve funkci main vezmeme pole, které obsahuje různé hodnoty na různých indexech. V poli má každý index jiné umístění paměti. Rozdíl mezi dvěma ukazateli můžeme najít pouze pomocí aritmetiky ukazatele. Zde používáme speciální typ ukazatele „ptrdiff_t“, který je nutné použít k nalezení rozdílů mezi dvěma nebo více ukazateli v C++.
Výstup tohoto kódu je připojen v následujícím textu:
Rozdíl mezi těmito adresami je podle prvku svěráku, což je 3.
Scénář 3: Porovnání dvou nebo více ukazatelů v C++
V tomto scénáři se naučíme, jak porovnat různé ukazatele v C++ pomocí různých relačních operátorů, jako jsou „==“, „<=“, „>=“, „<“, „>“. Ukazatele můžeme porovnávat pouze v případě, že ukazují na adresu prvků stejného pole. Pamatujte, že porovnávání dvou ukazatelů s různými typy může způsobit nedefinované chování. Fragment kódu, který souvisí s porovnáním ukazatelů, je zmíněn v následujícím textu:
#includepomocí jmenného prostoru std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , jedenáct , 14 , 16 , 18 , dvacet , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
-li ( ptr1 ==ptr2 )
{
std::cout << 'ukazatele jsou stejné' << endl;
}
jiný -li ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 je menší nebo roven než ptr4' << endl ;;
}
jiný
{
std::cout << 'ukazatele se v žádné fázi neporovnávají' << endl;
}
vrátit se 0 ;
}
Zde vezmeme pole s 10 prvky. Deklarujeme čtyři ukazatele, které ukazují na jiný index pole. Poté porovnáme tyto čtyři ukazatele za různých podmínek, jak je vidět v daném kódu. Ve stavu „if“ zkontrolujte, zda se ukazatel „ptr1“ rovná ukazateli „ptr2“, a poté vytiskněte „ukazatele se rovnají“. Když máme více podmínek, kde používáme podmínku „else if“ ke kontrole, zda je ukazatel „ptr3“ menší než roven ukazateli „ptr4“. Po tom všem klikněte na Provést > Kompilovat a spustit volba.
Výstup tohoto kódu je připojen v následujícím textu:
Zobrazí platnou podmínku na obrazovce konzoly a ukončí kompilaci. Ukazatel „ptr3“ obsahuje hodnotu, která je menší nebo rovna ukazovací hodnotě ukazatele „ptr4“.
Scénář 4: Zobrazte liché číslo pomocí aritmetiky ukazatele
Zde uvidíme, jak můžeme dynamicky alokovat paměť pro pole celého čísla. Fragment kódu související s tímto případem je uveden v následujícím textu:
#includeint main ( ) {
int čísla [ ] = { 1 , 12 , 33 , 24 , patnáct , 776 , 71 , 18 , 29 , padesáti } ;
int * ptrr = čísla;
std::cout << 'Lichá čísla v polích:' ;
pro ( int i = 0 ; i < 10 ; ++i ) {
-li ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << '' ;
}
ptrr++;
}
std::cout << std::endl;
vrátit se 0 ;
}
Ve funkci main vezmeme pole, které obsahuje 10 prvků. Potřebujeme ukazatel, který ukazuje na všechny prvky v poli, abychom zkontrolovali liché číslo v poli. Ve smyčce „for“ zkontrolujte liché číslo vydělením aktuálního prvku pole. Čítač ukazatele se zvýší po kontrole jednoho prvku pole.
Po provedení kódu se výstup zobrazí na obrazovce konzoly, která je uvedena v následujícím textu:
Tímto způsobem můžeme zobrazit lichá čísla pomocí aritmetiky ukazatele na obrazovce konzoly.
Závěr
Zde docházíme k závěru, že ukazatelová aritmetika je nejúčinnějším nástrojem, který provádí různé operace v C++. Ujistěte se, že ukazatel zvyšuje nebo snižuje hodnotu pole, které má stejný datový typ. Hodnoty pole můžeme porovnat podle jejich paměťových adres pomocí ukazatelové aritmetiky v programovacím jazyce C++. Můžeme procházet pole a spravovat paměť snadno pomocí aritmetiky ukazatele.