Menu

Ukazatele a operace ukazatele v C ++

pointers pointer operations c

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Intenzivní studium ukazatelů a jejich použití v C ++.

Ukazatel je jednou z nejmocnějších funkcí jazyka C ++. Ukazatel pomáhá manipulovat s proměnnými prostřednictvím jeho adresy.

Algoritmus třídění bublin C ++

V tomto kurzu podrobně prozkoumáme všechny ukazatele a jejich použití v C ++.

=> Dávejte pozor na jednoduchou sérii školení C ++ zde.

Ukazatele v c ++

Co se naučíte:

Co je to ukazatel?

Ukazatel je proměnná, která obsahuje adresu umístění paměti. Víme, že všechny proměnné, které deklarujeme, mají v paměti konkrétní adresu. Deklarujeme proměnnou ukazatele, která ukazuje na tyto adresy v paměti.

Obecná syntaxe pro deklaraci proměnné ukazatele je:

datatype * variable_name;

Například, prohlášení int * ptr;

To znamená, že ptr je ukazatel, který ukazuje na proměnnou typu int. Proměnná ukazatele proto vždy obsahuje místo v paměti nebo adresu. Podívejme se níže na práci s ukazateli proměnných.

Vezměte v úvahu, že máme následující prohlášení:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

V paměti budou tyto deklarace reprezentovány následovně:

alokace ukazatelů do paměti

Toto je interní reprezentace ukazatele v paměti. Když přiřadíme proměnnou adresy do proměnné ukazatele, ukazuje na proměnnou, jak je znázorněno na obrázku výše.

Protože ptr má adresu proměnné p, * ptr dá hodnotu proměnné p (proměnná, na kterou ukazuje proměnná ukazatele ptr).

Poznámka: Operátor *, který používáme s ukazatelem, se používá k označení, že jde o proměnnou ukazatele.

Podívejme se na některé koncepty ukazatelů, které se používají v C ++.

Aritmetika ukazatele

Víme, že proměnná ukazatele vždy ukazuje na adresu v paměti. Mezi operacemi, které můžeme provádět, máme následující aritmetické operace, které se provádějí na ukazatelích.

  • Operátor přírůstku (++)
  • Operátor snížení (-)
  • Sčítání (+)
  • Odečtení (-)

Podívejme se na využití těchto operací v ukázkovém programu.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Výstup:

První prvek v poli: 2
další prvek v poli: 4
další prvek v poli: 6
další prvek v poli: 4
další prvek v poli: 2

Viděli jsme aritmetické operace prováděné na ukazatelích. Všimněte si, že operátor přírůstku ++ zvýší ukazatel a ukazuje na další prvek v poli. Podobně operátor dekrementace sníží proměnnou ukazatele o 1, takže ukazuje na předchozí prvek v poli.

Používáme také operátory + a -. Nejprve jsme do proměnné ukazatele přidali 1. Výsledek ukazuje, že ukazuje na další prvek v poli. Podobně - operátor vytvoří proměnnou ukazatele tak, aby ukazovala na předchozí prvek v poli.

Kromě těchto aritmetických operátorů můžeme také použít operátory porovnání jako ==,.

Ukazatele Null and Void

Pokud v případě proměnné ukazatele není přiřazena adresa proměnné, je dobrým zvykem přiřadit proměnné ukazatele hodnotu NULL. Proměnná ukazatele s hodnotou NULL se nazývá ukazatel NULL.

Null pointer je konstantní ukazatel s hodnotou nula definovanou v záhlaví iostream. Paměť na adrese 0 je rezervována operačním systémem a do tohoto umístění nemáme přístup.

Pomocí nulového ukazatele se můžeme vyhnout zneužití nepoužitých ukazatelů a zabránit tomu, aby proměnné ukazatele měly přiřazené nějaké hodnoty smetí.

Void pointers jsou speciální ukazatele, které ukazují na hodnoty bez typu. Ukazatele void jsou flexibilnější, protože mohou ukazovat na jakýkoli typ. Nelze je však přímo dereferencovat. Pro dereferencování je třeba ukazatel void převést na ukazatel, který ukazuje na hodnotu s konkrétním datovým typem.

Ukázali jsme fungování ukazatele NULL a ukazatele void v následujícím příkladu kódu.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Výstup:

Hodnota ukazatele NULL: 0
Void pointer vptr points to: A
Void pointer vptr points to: 10

Ve výše uvedeném programu nejprve deklarujeme celočíselný ukazatel, kterému je přiřazena hodnota NULL. Když vytiskneme tento ukazatel, vidíme, že hodnota je 0, jak jsme již diskutovali dříve.

Dále deklarujeme prázdný ukazatel. Nejprve tomuto ukazateli neplatnosti přiřadíme adresu znakové proměnné. Poté přiřadíme ukazatel prázdnoty ukazateli znaků a obsadíme jej znakem char *. Dále vytiskneme hodnotu charptr, která ukazuje na char A, což byla znaková proměnná, kterou jsme deklarovali dříve a na kterou ukazuje ukazatel void.

Dále jsme ukazateli prázdnoty přiřadili celočíselnou proměnnou a poté provedeme stejné kroky dereferencování tohoto prázdného ukazatele pomocí celočíselného ukazatele.

Pole a ukazatele

Pole a ukazatele jsou navzájem silně spojeny. Víme, že název pole ukazuje na první prvek v poli a jedná se o konstantní ukazatel.

Tento ukazatel můžeme přiřadit k proměnné ukazatele a poté přistupovat k poli buď snížením ukazatele, nebo pomocí operátoru dolního indexu.

Toto přidružení mezi proměnnou ukazatele a polem uvidíme v následujícím příkladu kódu.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Výstup:

1 1 2 3 5

Ve výše uvedeném programu přiřadíme název pole proměnné ukazatele. Protože název pole ukazuje na první prvek v poli, můžeme vytisknout obsah celého pole pomocí proměnné ukazatele a zvýšit jej pomocí operátoru ++. To se zobrazuje na výstupu.

Pole ukazatelů

Někdy v programu potřebujeme více než jednu proměnnou ukazatele. Místo deklarování každé jednotlivé proměnné ukazatele můžeme deklarovat pole ukazatelů.

Pojďme si hned vzít příklad, abychom předvedli řadu ukazatelů.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Výstup:

Hodnota myarray (0) = 2
Hodnota myarray (1) = 4
Hodnota myarray (2) = 6
Hodnota myarray (3) = 8
Hodnota myarray (4) = 10

Ve výše uvedeném prohlášení

nedefinovaná referenční chyba c ++

int * ptr (5);

Můžeme interpretovat jako; ptr je pole 5 celočíselných ukazatelů. Proto každý prvek ptr bude ukazovat na proměnnou typu integer.

Využíváme celočíselné pole a každému z prvků ptr přiřadíme adresu každého prvku pole. Poté zobrazíme obsah pole ptr výstupem „* ptr (i)“.

Ukazatel ukazatelů

Ukazatel ukazatelů není nic jiného než vícenásobné směrování. Je to druh řetězce ukazatelů. Když definujeme ukazatel ukazatelů, první ukazatel má adresu druhého ukazatele, který má zase adresu proměnné, na kterou ukazuje.

V paměti to bude reprezentováno jako:

Ukazatel přidělení paměti ukazatelů

Ukazatel ukazatelů je deklarován takto:

int** intptr;

Přímo vezmeme příklad kódu, abychom lépe porozuměli ukazatelům ukazatelů.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Výstup:

Variabilní var: 10
Ukazatel na proměnnou: 10
Ukazatel na ukazatel na proměnnou: 10

Ve výše uvedeném programu deklarujeme celočíselnou proměnnou, celočíselný ukazatel a ukazatel ukazatele na celé číslo. Jak je znázorněno v programu, proměnné ukazatele je přiřazena hodnota proměnné. Ukazatel proměnné ukazatele je přiřazena adresa proměnné ukazatele.

Nakonec vytiskneme tři proměnné, které zobrazují stejnou hodnotu 10 rovnou celočíselné proměnné.

Předávání ukazatelů na funkce

Předávání ukazatelů do funkce je stejné jako u jiných technik předávání parametrů, kdy do funkce předáváme proměnné ukazatele.

Znovu se vrátíme k naší výměně dvou hodnot a upravíme ji tak, aby předávala proměnné ukazatele jako parametry.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Ukazatele funkcí

stejným způsobem, protože máme ukazatele na proměnné, pole atd., můžeme mít také ukazatele na funkce. Rozdíl je však v tom, že ukazatel funkce ukazuje na spustitelný kód, a nikoli na data, jako jsou proměnné nebo pole.

Vezmeme příklad, abychom demonstrovali ukazatele funkcí.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Výstup:

Hodnota a je 100

převodník z youtube na mp3, který funguje

Ve výše uvedeném programu máme funkci ‘displayVal’, která právě vytiskne celočíselnou hodnotu, která mu byla předána. V hlavní funkci jsme definovali ukazatel funkce „func_ptr“, který bere int jako argument a vrací void typ.

void (* func_ptr) (int)

Poznámka: Musíme uzavřít ukazatel funkce inside (). Pokud to vynecháme, stane se prototypem funkce.

Tomuto ukazateli funkce jsme přiřadili adresu funkce „displayVal“. Potom pomocí tohoto funkčního ukazatele „func_ptr“ předáme hodnotu argumentu 100, která odpovídá volání displayVal argumentem 100.

Nyní, pokud máme jinou funkci se stejným prototypem, můžeme použít stejný ukazatel funkce tak, že jí přiřadíme adresu funkce. Toto je hlavní použití ukazatelů funkcí.

Závěr

Jedná se o všechny ukazatele, jeho definice a použití v C ++.

V našem dalším kurzu se dozvíme více o referencích v C ++. Odkazy mají také speciální použití v C ++ a často se používají jako aliasy proměnných.

=> Klikněte sem a získejte Absolute C ++ Training Series.

Doporučené čtení

^