Ukazatele v programování C: Co je to ukazatel, typy & Příklady

Co je ukazatel v C?

Pointer v C, je proměnná, která ukládá řešit jiné proměnné. Ukazatel lze také použít k odkazu na jinou funkci ukazatele. Ukazatel lze zvýšit / snížit, tj. Ukázat na další / předchozí místo v paměti. Účelem ukazatele je ušetřit místo v paměti a dosáhnout rychlejšího času provádění.

Jak používat ukazatele v jazyce C.

Pokud deklarujeme proměnnou v typu int, v skutečně uloží hodnotu.

v se nyní rovná nule.

Každá proměnná má však kromě hodnoty také svoji adresu (nebo jednoduše řečeno, kde se nachází v paměti). Adresu lze načíst vložením ampersand (&) před název proměnné.

Pokud vytisknete adresu proměnné na obrazovce, bude to vypadat jako zcela náhodné číslo (navíc se může lišit od běhu k běhu).

Zkusme to v praxi s ukazatelem v příkladu C.

Výstup tohoto programu je -480613588.

Co je to ukazatel? Místo uložení hodnoty ukazatel uloží adresu proměnné.

Proměnná ukazatele

Int * y = & v;

VARIABILNÍ	UKAZATEL
Hodnota uložena v pojmenované skladovací / adresa paměti	Variabilní , že odkazuje na storage / paměťovou adresou jiné proměnné

Deklarace ukazatele

Stejně jako proměnné musí být ukazatele v programování C deklarovány, než je lze ve vašem programu použít. Ukazatele lze pojmenovat, kamkoli chcete, pokud dodržují pravidla pojmenování C. Deklarace ukazatele má následující formulář.

data_type * pointer_variable_name;

Tady,

• data_type je základní typ ukazatele typů proměnných C a označuje typ proměnné, na kterou ukazatel ukazuje.
• Hvězdička (*: stejná hvězdička použitá pro násobení), což je operátor indirection, deklaruje ukazatel.

Podívejme se na některá platná deklarace ukazatele v tomto kurzu ukazatelů C:

int *ptr_thing; /* pointer to an integer */int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */double *ptr2; /* pointer to a double */float *ptr3; /* pointer to a float */char *ch1 ; /* pointer to a character */float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Inicializovat ukazatel

Po deklaraci ukazatele jej inicializujeme jako standardní proměnné s adresou proměnné. Pokud ukazatele v programování C nejsou neinicializovány a použity v programu, výsledky jsou nepředvídatelné a potenciálně katastrofické.

K získání adresy proměnné používáme operátor ampersand (&), umístěný před názvem proměnné, jejíž adresu potřebujeme. Inicializace ukazatele se provádí s následující syntaxí.

Syntaxe ukazatele

 pointer = &variable; 

Níže je uveden jednoduchý program pro ilustraci ukazatele:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Výstup:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operátor	Význam
*	Slouží 2 účelům Deklarace ukazatele Vrátí hodnotu odkazované proměnné
&	Slouží pouze 1 účelu Vrátí adresu proměnné

Typy ukazatelů v C.

Následují různé typy ukazatelů v jazyce C :

Nulový ukazatel

Můžeme vytvořit nulový ukazatel přiřazením hodnoty null během deklarace ukazatele. Tato metoda je užitečná, pokud ukazateli nemáte přiřazenou žádnou adresu. Nulový ukazatel vždy obsahuje hodnotu 0.

Následující program ilustruje použití nulového ukazatele:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Výstup:

The value inside variable p is:0

Prázdný ukazatel

V programování v C se ukazatel void také nazývá jako obecný ukazatel. Nemá žádný standardní datový typ. Ukazatel void je vytvořen pomocí klíčového slova void. Lze jej použít k uložení adresy jakékoli proměnné.

Následující program ilustruje použití ukazatele void:

#include int main(){void *p = NULL; //void pointerprintf("The size of pointer is:%d\n",sizeof(p));return 0;}

Výstup:

The size of pointer is:4

Divoký ukazatel

Ukazatel se říká, že je divoký ukazatel, pokud se na nic neinicializuje. Tyto typy ukazatelů C nejsou efektivní, protože mohou ukazovat na nějaké neznámé místo v paměti, což může způsobit problémy v našem programu a může to vést k havárii programu. Při práci s divokými ukazateli byste měli být vždy opatrní.

Následující program ilustruje použití divokého ukazatele:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Výstup

timeout: the monitored command dumped coresh: line 1: 95298 Segmentation fault timeout 10s main

Jiné typy ukazatelů v „c“ jsou následující:

• Visící ukazatel
• Složitý ukazatel
• Blízký ukazatel
• Daleko ukazatel
• Obrovský ukazatel

Ukazatele přímého a nepřímého přístupu

V jazyce C existují dva ekvivalentní způsoby přístupu a manipulace s proměnným obsahem

• Přímý přístup: používáme přímo název proměnné
• Nepřímý přístup: používáme ukazatel na proměnnou

Rozumíme tomu pomocí níže uvedeného programu

#include /* Declare and initialize an int variable */int var = 1;/* Declare a pointer to int */int *ptr;int main( void ){/* Initialize ptr to point to var */ptr = &var;/* Access var directly and indirectly */printf("\nDirect access, var = %d", var);printf("\nIndirect access, var = %d", *ptr);/* Display the address of var two ways */printf("\n\nThe address of var = %d", &var);printf("\nThe address of var = %d\n", ptr);/*change the content of var through the pointer*/*ptr=48;printf("\nIndirect access, var = %d", *ptr);return 0;}

Po kompilaci programu bez jakýchkoli chyb je výsledkem:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Aritmetika ukazatele v C

Operace ukazatele jsou shrnuty na následujícím obrázku

Prioritní operace (priorita)

Při práci s ukazateli C musíme dodržovat následující pravidla priority:

• Operátory * a & mají stejnou prioritu jako unární operátory (negace !, přírůstek ++, dekrement -).
• Ve stejném výrazu jsou unární operátory *, &,!, ++, - hodnoceny zprava doleva.

Pokud ukazatel P ukazuje na proměnnou X, pak lze * P použít všude tam, kde lze X napsat.

Následující výrazy jsou ekvivalentní:

int X = 10 int * P = & Y; U výše uvedeného kódu platí níže uvedené výrazy
Výraz	Ekvivalentní výraz
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

V druhém případě jsou potřeba závorky: protože unární operátory * a ++ se vyhodnocují zprava doleva, bez závorek by se zvýšil ukazatel P, nikoli objekt, na který P směřuje.

Níže uvedená tabulka ukazuje aritmetické a základní operace, které lze použít při práci s ukazateli C.

Úkon	Vysvětlení
Úkol	int * P1, * P2 P1 = P2; P1 a P2 ukazují na stejnou celočíselnou proměnnou
Inkrementace a dekrementace	Int * P1; P1 ++; P1--;
Přidání offsetu (konstantní)	To umožňuje ukazateli přesouvat N prvků v tabulce. Ukazatel se zvýší nebo sníží o N-násobek počtu bajtů typu proměnné. P1 + 5;

C ukazatele a pole s příklady

Tradičně přistupujeme k prvkům pole pomocí jeho indexu, ale tuto metodu lze eliminovat pomocí ukazatelů. Ukazatele usnadňují přístup ke každému prvku pole.

#include int main(){int a[5]={1,2,3,4,5}; //array initializationint *p; //pointer declaration/*the ptr points to the first element of the array*/p=a; /*We can also type simply ptr==&a[0] */printf("Printing the array elements using pointer\n");for(int i=0;i<5;i++) //loop for traversing array elements{printf("\n%x",*p); //printing array elementsp++; //incrementing to the next element, you can also write p=p+1}return 0;}

Výstup

12345

Přidáním konkrétního čísla do ukazatele přesunete umístění ukazatele na hodnotu získanou operací přidání. Předpokládejme, že p je ukazatel, který aktuálně ukazuje na paměťové místo 0, pokud provedeme následující operaci přidání, p + 1, pak se provede tímto způsobem:

Protože p aktuálně ukazuje na místo 0 po přidání 1, hodnota se stane 1, a proto ukazatel bude ukazovat na místo paměti 1.

C ukazatele a řetězce s příklady

Řetězec je pole char objektů, končící nulovým znakem '\ 0'. S řetězci můžeme manipulovat pomocí ukazatelů. Tento ukazatel v příkladu C vysvětluje tuto část

#include #include int main(){char str[]="Hello Guru99!";char *p;p=str;printf("First character is:%c\n",*p);p =p+1;printf("Next character is:%c\n",*p);printf("Printing all the characters in a string\n");p=str; //reset the pointerfor(int i=0;i
Výstup
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Dalším způsobem, jak řešit řetězce, je řada ukazatelů jako v následujícím programu:
#include int main(){char *materials[ ] = { "iron", "copper", "gold"};printf("Please remember these materials :\n");int i ;for (i = 0; i < 3; i++) {printf("%s\n", materials[ i ]);}return 0;}
Výstup:
Please remember these materials:ironcoppergold
 
Výhody ukazatelů v C

Ukazatele jsou užitečné pro přístup k paměti.
Ukazatele poskytují efektivní způsob přístupu k prvkům struktury pole.
Ukazatele se používají pro dynamické přidělování paměti i pro přidělení.
Ukazatele se používají k vytváření složitých datových struktur, jako je propojený seznam, graf, strom atd.


Nevýhody ukazatelů v C

Ukazatele jsou trochu složité na pochopení.
Ukazatele mohou vést k různým chybám, jako jsou poruchy segmentace, nebo mohou přistupovat k paměťovému místu, které není vůbec nutné.
Pokud je ukazatel poskytnuta nesprávná hodnota, může to způsobit poškození paměti.
Ukazatele jsou také zodpovědné za únik paměti.
Ukazatele jsou poměrně pomalejší než ukazatele proměnných.
Programátoři považují za velmi obtížné pracovat s ukazateli; proto je povinností programátora opatrně manipulovat s ukazatelem.

souhrn 

Ukazatel není nic jiného než paměťové místo, kde jsou uložena data.
Ukazatel se používá pro přístup k umístění paměti.
Existují různé typy ukazatelů, například nulový ukazatel, divoký ukazatel, ukazatel neplatnosti a další typy ukazatelů.
Ukazatele lze použít s polem a řetězcem pro efektivnější přístup k prvkům.
Můžeme vytvořit ukazatele funkcí pro dynamické vyvolání funkce.
Aritmetické operace lze provádět na ukazateli známém jako aritmetika ukazatele.
Ukazatele mohou také ukazovat na funkce, což usnadňuje volání různých funkcí v případě definování pole ukazatelů.
Chcete-li se zabývat různými datovými typy proměnných, můžete použít ukazatel typu void typucast.