Tento článek je o konceptu ukazatele na ukazatel v C++. Ukazatel na ukazatel ukazuje nebo ukládá adresu jiného ukazatele a umožňuje manipulaci se samotnými ukazateli. Pomocí tohoto konceptu můžeme snadno upravit ukazatel z jiného místa v paměti. Dvojité ukazatele jsou výhodné v dynamicky alokované paměti nebo vícerozměrných polích pro manipulaci s prvky pole. Tento ukazatel na práci a použití ukazatele v C++ probereme na správných příkladech.
Scénář 1: Reprezentace ukazatele na ukazatel v paměti
V tomto scénáři je deklarace dvojitého ukazatele podobná deklaraci ukazatele s další hvězdičkou (*) před názvem ukazatele. Paměťové umístění dvojitého ukazatele můžeme snadno znázornit v C++. Fragment kódu ukazatele na ukazatel je uveden v následujícím textu:
#include
pomocí jmenného prostoru std;
int main ( )
{
int číslice = padesáti ;
int * ptrr;
ptrr = & číslice;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Adresa paměti ukazatele je: \n ' ;
cout << 'ptrr (ukazatel): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dvojitý ukazatel): ' <<* ptrr1 << ' \n ' ;
cout << ' Hodnota uložená v ukazateli je: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (ukazatel na ukazatel) = ' <<** ptrr1 << endl;
vrátit se 0 ;
}
Ve funkci main vezmeme proměnnou, jejíž paměťovou adresu je potřeba uložit do ukazatele. Nyní inicializujeme proměnnou „digit“. Poté deklarujeme ukazatel „ptrr“, který ukládá „digitální“ adresu paměti. Nyní deklarujeme dvojitý ukazatel, jehož jméno je „**ptrr1“, který ukládá adresu ukazatele „*ptrr“. Na konci kódu zobrazíme na obrazovce konzoly paměť a hodnotu ukazatele a dvojitého ukazatele. Výstup tohoto kódu je uveden v následujícím textu:
Paměťová adresa ukazatele „ptrr“ je „0x6ffe04“ a ukazatel „*ptrr1“ také ukládá paměťovou adresu ukazatele „ptrr“. Hodnota, která je uložena uvnitř ukazatele, je „50“. V zásadě je adresa dvojitého ukazatele vždy stejná jako paměťová adresa ukazatele.
Scénář 2: Ukazatel na ukazatel jako parametr funkce
V tomto scénáři se naučíme, jak předat dvojitý ukazatel v jakékoli funkci jako parametr pro provedení dočasné alokace paměti v libovolné proměnné. Fragment kódu parametru funkce s dvojitým ukazatelem je uveden níže:
#include
void getMemoryAddress ( int ** double_ptr ) {
ty počasí = 200 ;
* double_ptr = & teplota;
}
int main ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << 'Hodnota **double_ptr je: ' << ** double_ptr << std::endl;
vrátit se 0 ;
}
Zde se naučíme, jak koncept ukazatele na ukazatel funguje v C++. Pamatujte, že jeden ukazatel je v programu deklarován pro práci s dvojitým ukazatelem. Vytvoříme tedy funkci „getMemoryAddress“. Tuto funkci navrhujeme tak, že když předáme parametr, automaticky získá paměťovou adresu dvojitého ukazatele.
Ve funkci vezmeme proměnnou „tempp“ a dvojitý ukazatel „**double_ptr“. Dvojitému ukazateli předáme adresu zadané proměnné, která je „tempp“ a hodnoty dvojitého ukazatele jako argument funkce. Program zobrazí výsledek kódu hlavní funkce na obrazovce konzoly, takže všechny věci, které jsou v hlavní funkci, jsou spustitelné. V hlavní funkci bereme ukazatel „ptr_1“ a dvojitý ukazatel jako „double_ptr“. Adresu ukazatele předáme dvojitému ukazateli.
Nyní předáme proměnnou dvojitého ukazatele ve funkci přepsání a předáme ukazatel na proměnnou ukazatele v příkazu výstupního proudu „cout“, abychom zobrazili výsledek dvojitého ukazatele.
Když kompilátor dosáhne funkce přepsání, kontrola kompilátoru, kde je tato funkce definována, spustí kód uvnitř funkce a vrátí výsledek hlavní funkci.
Výstup tohoto kódu je připojen v následujícím textu:
Výsledek: Hodnota dvojitého ukazatele je 200.
Scénář 3: Použití 2D pole s ukazatelem na ukazatel
V tomto příkladu se budeme zabývat 2D polem s dvojitým ukazatelem. Vezmeme pole a předáme adresu pole v ukazateli. Úplný kód tohoto scénáře je poskytován takto:
int main ( ) {const int rows = 3 ;
const int cols = 2 ;
int ** matice = new int * [ řádky ] ;
pro ( int i = 0 ; i < řádky; ++i ) {
matice [ i ] = nový int [ sloupce ] ;
}
pro ( int i = 0 ; i < řádky; ++i ) {
pro ( int j = 0 ; j < cols; ++j ) {
matice [ i ] [ j ] = i * cols + j;
}
}
pro ( int i = 0 ; i < řádky; ++i ) {
pro ( int j = 0 ; j < cols; ++j ) {
cout << matice [ i ] [ j ] << '' ;
}
cout << endl;
}
pro ( int i = 0 ; i < řádky; ++i ) {
vymazat [ ] matice [ i ] ;
}
vymazat [ ] matice;
vrátit se 0 ;
}
Jak všichni víme, máme mnoho řádků a několik sloupců ve 2D poli. Ve funkci main inicializujeme řádky a sloupce, které mají „const int“. Poté alokujeme paměťový prostor pro řádky a paměťový prostor pro sloupce podél každého řádku. Hodnotu počtu řádků předáme jako ukazatel v maticovém dvojitém ukazateli jako „**matrix“. V tomto dvojitém ukazateli se provede smyčka počtu řádků nebo true. Poté se provádí další vnitřní smyčka, dokud se podmínka nezmění na nepravdivou.
Po alokaci paměti opět přiřadíme hodnotu v poli: vnější smyčku pro řádky a vnitřní smyčku pro sloupce 2D pole. Ve vnitřní smyčce se hodnota řádků a sloupců přiřadí dvojitému ukazateli a provede požadovanou aritmetickou operaci. Zobrazujeme hodnoty 2D pole, jako je počet řádků a sloupců, které jsou alokovány v paměti. Počet řádků a sloupců vždy ukazuje na dvojitý ukazatel, který ukládá hodnoty řádků a sloupců. Nakonec vyčistíme paměť a uvolníme toto pole z paměti v C++.
Výstup 2D pole s dvojitým ukazatelem je připojen v následujícím:
Scénář 4: Výměna ukazatelů pomocí ukazatele za ukazatel
Zde se naučíme, jak zaměnit ukazatele v C++ deklarováním dvojitého ukazatele. Fragment kódu tohoto scénáře je připojen v následujícím textu:
#includeneplatná swap ( int ** ptrr_1, ty ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = patnáct , y = 25 ;
int * ptrA = & X, * ptrrB = & a;
std::cout << 'Před výměnou: *ptrrA je = ' << * ptrA << ', *ptrrB je = ' << * ptrrB << std::endl;
vyměnit ( & ptrA, & ptrrB ) ;
std::cout << 'Po výměně: *ptrrA is = ' << * ptrA << ', *ptrrB je = ' << * ptrrB << std::endl;
vrátit se 0 ;
}
Nejprve vytvoříme funkci swap a předáme oba ukazatele jako argument funkce. Ve funkci swap vezmeme ukazatel „temp“ a na nějakou dobu předáme hodnotu „pointer1“ v „temp“. Poté předáme hodnotu „pointer2“ do „pointer1“. Nakonec předáme hodnotu ukazatele „temp“ ukazateli „pointer2“.
V hlavní funkci potřebujeme dva ukazatele, které předáme nebo přepíšeme ve funkci „swap“. Adresy proměnných předáváme daným ukazatelům. Poté se zobrazí hodnota ukazatele před a po výměně ukazatele.
Výstup tohoto kódu je připojen v následujícím textu:
Jak vidíme, hodnoty ukazatele jsou úspěšně zaměněny pomocí dvojitého ukazatele v C++.
Závěr
Došli jsme k závěru, že ukazatel na ukazatel vždy ukládá paměťovou adresu libovolného ukazatele v C++. Dvojitý ukazatel můžeme kdykoli použít k dočasnému použití umístění libovolného ukazatele v paměti. Jedná se o velmi efektivní způsob, jak nepřímo manipulovat s adresou paměti a přistupovat k datům.