Ukazatele v C: Co je Ukazatel v programování C? Typy

Co je ukazatel v jazyce C?

A ukazatel V jazyce C je proměnná, která ukládá adresu jiné proměnné. Ukazatel může také odkazovat na jiný ukazatel nebo na funkci. Ukazatel lze inkrementovat nebo snižovat, aby ukazoval na další nebo předchozí místo v paměti. Účelem ukazatele je ušetřit místo v paměti a dosáhnout rychlejšího výkonu.

Jak používat ukazatele v C

Pokud deklarujeme proměnnou v typu int, v ukládá hodnotu. Každá proměnná má kromě své hodnoty také adresu, tedy místo, kde se nachází v paměti. Adresu lze získat tak, že před název proměnné umístíme znak ampersand (&). Pokud vypíšeme adresu proměnné, bude vypadat jako náhodné číslo, které se může lišit od spuštění ke spuštění.

Místo ukládání hodnoty ukládá ukazatel adresu proměnné. Například:

int *y = &v;

Vyhlášení ukazatele

Stejně jako proměnné, ukazatele in C programování musí být deklarovány před použitím. Deklarace ukazatele má následující tvar:

data_type *pointer_variable_name;

Zde, datový typ je základní typ ukazatele a označuje typ proměnné, na kterou ukazatel odkazuje. Hvězdička (*), stejný symbol jako pro násobení, je operátor indirection, který deklaruje ukazatel. Mezi platné deklarace ukazatelů patří:

int    *ptr_thing;       /* pointer to an integer */
int    *ptr1, thing;     /* ptr1 points to an int; thing is an int */
double *ptr2;           /* pointer to a double */
float  *ptr3;           /* pointer to a float */
char   *ch1;            /* pointer to a character */

Inicializace ukazatele

Po deklaraci ukazatele jej inicializujeme adresou proměnné. Pokud je ukazatel neinicializovaný a použitý, mohou být výsledky nepředvídatelné a potenciálně katastrofální. Chcete-li získat adresu proměnné, použijte před názvem proměnné operátor ampersand (&):

pointer = &variable;

Jednoduchý program, který ilustruje ukazatel, je uveden níže:

#include <stdio.h>
int main()
{
   int a = 10;     // variable declaration
   int *p;         // pointer variable declaration
   p = &a;        // store address of a in pointer p
   printf("Address stored in p is: %x\n", p);  // access the address
   printf("Value stored in p is: %d\n", *p);    // access the value
   return 0;
}

Výstup:

Address stored in p is: 60ff08
Value stored in p is: 10

Typy ukazatelů v C

Nulová ukazatel

Nulový ukazatel vytvoříme přiřazením hodnoty NULL během deklarace. To je užitečné, když ukazateli ještě není přiřazena žádná adresa. Nulový ukazatel vždy obsahuje hodnotu 0:

#include <stdio.h>
int main()
{
   int *p = NULL;     // null pointer
   printf("The value inside variable p is: %x", p);
   return 0;
}

Void Ukazatel

Void ukazatel, nazývaný také generický ukazatel, nemá žádný standardní datový typ. Je vytvořen pomocí klíčového slova void a může uchovávat adresu libovolné proměnné:

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

Divoký ukazatel

Ukazatel se nazývá divoký ukazatel, pokud není ničím inicializován. Tyto ukazatele nejsou efektivní, protože mohou ukazovat na neznámé místo v paměti, což může způsobit problémy a pád programu. S divokými ukazateli buďte vždy opatrní:

#include <stdio.h>
int main()
{
   int *p;          // wild pointer
   printf("%d", *p);
   return 0;
}

Mezi další typy ukazatelů v jazyce C patří visící ukazatel, komplexní ukazatel, blízký ukazatel, vzdálený ukazatel a obrovský ukazatel.

Přímé a nepřímé přístupové ukazatele

V jazyce C existují dva ekvivalentní způsoby přístupu a manipulace s obsahem proměnné. Přímý přístup používá přímo název proměnné, zatímco nepřímý přístup používá ukazatel na proměnnou:

#include <stdio.h>
int var = 1;        /* declare and initialize an int variable */
int *ptr;           /* declare a pointer to int */
int main(void)
{
   ptr = &var;       /* point ptr to var */
   printf("\nDirect access, var = %d", var);
   printf("\nIndirect access, var = %d", *ptr);
   *ptr = 48;        /* change var through the pointer */
   printf("\nIndirect access, var = %d", *ptr);
   return 0;
}

Aritmetika ukazatele v C

Při práci s ukazateli dodržujte tato pravidla priority. Operátory * a & mají stejnou prioritu jako unární operátory (negace !, inkrementace ++, dekrementace –). Ve stejném výrazu se unární operátory *, &, !, ++ a — vyhodnocují zprava doleva. Pokud ukazatel P ukazuje na proměnnou X, pak lze *P použít všude, kde lze zapsat X. Následující výrazy jsou ekvivalentní:

V posledním případě jsou závorky povinné: protože unární operátory * a ++ jsou vyhodnocovány zprava doleva, bez závorek by se inkrementoval ukazatel P, nikoli objekt, na který ukazuje. Aritmetické operace dostupné s ukazateli jsou přiřazení, inkrementace a dekrementace a sčítání nebo odčítání.traczadáním celočíselného posunu, který posune ukazatel o daný počet prvků (každý krok se rovná velikosti základního typu v bajtech).

Ukazatele a pole v jazyce C s příklady

Tradičně přistupujeme k prvkům pole pomocí indexu, ale ukazatele to také usnadňují. Ukazatel nastavený na název pole ukazuje na první prvek:

#include <stdio.h>
int main()
{
   int a[5] = {1, 2, 3, 4, 5};   // array initialization
   int *p;                       // pointer declaration
   p = a;                       // p points to the first element; same as &a[0]
   for (int i = 0; i < 5; i++)
   {
      printf("%d\n", *p);            // print element
      p++;                      // move to the next element
   }
   return 0;
}

Přidání čísla k ukazateli jej posune o daný počet prvků vpřed. Pokud p ukazuje na paměťovou pozici 0, pak p + 1 způsobí, že ukazatel bude ukazovat na paměťovou pozici 1.

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

Řetězec je pole objektů typu char končících nulovým znakem '\0'. S řetězci můžeme manipulovat pomocí ukazatelů:

#include <stdio.h>
#include <string.h>
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);
   p = str;                     // reset the pointer
   for (int i = 0; i < strlen(str); i++)
   {
      printf("%c\n", *p);
      p++;
   }
   return 0;
}

Dalším způsobem, jak pracovat s řetězci, je pomocí pole ukazatelů:

#include <stdio.h>
int main()
{
   char *materials[] = {"iron", "copper", "gold"};
   for (int i = 0; i < 3; i++)
      printf("%s\n", materials[i]);
   return 0;
}

Výhody ukazatelů v C

• Ukazatele jsou užitečné pro přímý přístup k paměťovým místům.
• Poskytují efektivní způsob přístupu k prvkům pole.
• Používají se pro dynamickou alokaci a dealokaci paměti.
• Používají se k vytváření složitých datových struktur, jako jsou propojené seznamy, grafy a stromy.

Nevýhody ukazatelů v C

• Ukazatele jsou trochu složité na pochopení.
• Mohou způsobovat chyby, jako jsou segmentační chyby nebo přístup k nezamýšlenému umístění v paměti.
• Nesprávná hodnota přiřazená ukazateli může způsobit poškození paměti.
• Ukazatele jsou také zodpovědné za úniky paměti, pokud paměť není uvolněna.
• Je odpovědností programátora zacházet s ukazatelem opatrně.

Nejčastější dotazy