Přednáška 3

Témata

• Statická pole
  • Jednorozměrná pole
  • Vícerozměrná pole
• Typ ukazatel, proměnná typu ukazatel
• Dynamická alokace paměti, dynamická pole
  • Alokace paměti
  • Dealokace (uvolnění) paměti
• Ukazatelová aritmetika
  • Přístup k prvkům pole pomocí ukazatelů s využitím aritmetiky, statická versus dynamická pole
  • Operace rozdílu ukazatelů

Statická pole

Jednorozměrná pole

int A[10];

#define MAXPOCET 10
   .
   .
   .
int A[MAXPOCET];

Obrázek 1: Grafické znázornění jednorozměrného pole

A[3] = 0; y = A[i]*3;

Prvky pole lze inicializovat již při deklaraci pomocí tzv. konstruktoru pole:

int A[3] = { 25, 30, -5 };

Úloha:

Napište program, který uloží do statického pole násobky čísla 5 a vytiskne je. Vstupem programu (z klávesnice) je horní limit násobků: zadáme-li např. číslo 12, programu uloží násobky 0 x 5 až 12 x 5. Statické pole deklarujte o velikosti např. 50 prvků. Pokud zadaná mez překročí staticky deklarovanou velikost pole, program se ukončí s chybovým hlášením.

Řešení:

Dev C++:	nasob.dev, nasob.c
CodeBlocks:	nasob.cbp, nasob.c

Vícerozměrná pole

float mat[20][20];

  int pole[2][2]= {{1,2},{3,4}};

Obrázek 2: Dvourozměrné pole jako matice

Obrázek 3: Uložení statického dvourozměrného pole v paměti

Řešení:

Dev C++:	soucinmat.dev, soucinmat.c
CodeBlocks:	soucinmat.cbp, soucinmat.c

Typ ukazatel, proměnná typu ukazatel

int *p;

int x;
int *p;

p = &x;

Obrázek 4: Proměnná typu ukazatel

Přístup k hodnotě (k paměťové buňce), na kterou proměnná typu ukazatel ukazuje, se provádí pomocí operátoru dereference, což je hvězdička „*“:

*p = 3;

Shrneme si tedy ještě jednou situaci na obr. 4. Máme dvě proměnné x a p: proměnná x je typu int a v paměti je uložena na adrese 3426, druhá proměnná p je typu ukazatel na int a v paměti je uložena na adrese 2100. Proměnná p obsahuje adresu proměnné x, tedy hodnotu (číslo) 3426 (v paměťové buňce s adresou 2100 je hodnota 3426). Proměnná x obsahuje celé číslo 3 (v paměťové buňce s adresou 3426 je hodnota 3).

Dynamická alokace paměti

Alokace paměti

(void *)malloc(size_t n)

V souvislosti s ukazateli je nutná zmínka o konstantě NULL, která je definována jako symbolická (většinou má hodnotu 0). Znamená hodnotu „ukazatele nikam“ – je obdobou hodnoty nill v Pascalu. V případě, že operační systém nemá k dispozici dostatek volné paměti, vrací funkce malloc hodnotu NULL. Správně napsaný program by měl otestovat výsledek volání funkce malloc:

Příklad:

 
int *p;
p = (int *)malloc(512); // alokuji 512 bytu pameti
if (p == NULL)
{
  printf("Nedostatek pameti");
  return; 
}

 
int *p;
if ((p = (int *)malloc(512))== NULL)
{
  printf("Nedostatek pameti");
  return; 
}

int *p;
p = (int *)malloc(sizeof(int)*n);

Před ukončením činnosti (nebo v okamžiku, kdy ji již nepotřebuje) by měl program alokovanou paměti uvolnit (vrátit k dispozici operačnímu systému). K uvolnění paměti slouží funkce free z knihovny stdlib.h:

void free(void *block);

Hodnotu ukazatele je možné vytisknout pomocí specifikátoru %p: printf("%p",p) vytiskne šestnáctkově adresu, která je uložena v proměnné p.

Přístup k prvkům dynamicky alokovaného pole je stejný jako u pole statického, tedy pomocí indexů. K prvkům lze přistupovat i pomocí ukazatelové aritmetiky, kterou uvedeme později.

Nyní uvedeme jednoduchý příklad dynamické alokace pole pro uložení čísel a výpisu tohoto pole v opačném pořadí.

Příklad:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
  int *p;
  int n; // velikost pole
  int i;

  printf("Zadejte pocet zpracovavanych cisel: ");
  scanf("%d",&n);

  if ((p=(int*)malloc(sizeof(int)*n))==NULL)
  {
    printf("Neni dostatek dynamicke pameti.");
    return 1;
  }
  printf("Zadejte %d celych cisel odelenych mezerou:\n",n);

  // nacteni prvku pole
  for(i=0;i<n;i++) scanf("%d",&p[i]);
  putchar('\n');

  // vypis v opacnem poradi
  for(i=n-1;i>=0;i--) printf("%d ",p[i]);
  putchar('\n');
  free(p);
  return 0;
}

Kód je k dispozici i k přímému stažení:

Dev C++:	dyn_pole1.dev, dyn_pole1.c
CodeBlocks:	dyn_pole1.cbp, dyn_pole1.c

Ukazatelová aritmetika

Mějme např. následující deklarace a dynamicky alokované pole o velikosti 10 prvků typu int :

  int *pole;
  int *uk;
  
  pole = (int *)malloc(sizeof(int)*10);
  uk = pole+5;

Obrázek 5: Ukazatelová aritmetika

Přístup k datům pomocí ukazatelů, statická versus dynamická pole

  *pole = 2;
  *(pole+2) = 10;
  *uk= -4; // zde je možné napsat též *(uk+0) = -4;
  *(uk+2) = 5;

   *(pole+2) = 10;
   pole[2] = 10;

Ukazatelová aritmetika se efektivně využívá ve funkci scanf, kde se jako skutečné parametry uvádějí adresy paměti, na které se má uložit zkonvertovaná hodnota. Místo scanf("%d",&a[i]); je lépe psát scanf("%d",a+i);.

Využití operace rozdílu ukazatelů

  int *p = (int*)malloc(sizeof(int)*10);
  int *k;
  k = p + 5;

Na závěr ještě ukážeme, jak provést výpis prvků pole pouze s využitím ukazatelů, ukazatelové aritmetiky a porovnání ukazatelů. Výpis pozice hledaného prvku je proveden s využitím rozdílu ukazatelů:

  int A[5] = {1,2,3,4,5};
  int x;
  int *p,
  int *za_konec;

  za_konec = A+5;
  for(p=A;p<za_konec;p++) printf("%d ",*p);

  printf("Zadej hledane cislo: ");
  scanf("%d",&x);

  for(p=A;p<za_konec && *p != x;p++) ;  //strednik ma vyznam prazdneho prikazu
  if (p==za_konec) 
    printf("Cislo nenalezeno");
  else
    printf("Cislo je na pozici %d\n",p-A+1);
 

Dev C++:	priklad_ukaz.dev, priklad_ukaz.c
CodeBlocks:	priklad_ukaz.cbp, priklad_ukaz.c