Datové typy, bloky, deklarace a definice

• Základní datové typy
• Boolovské datové typy
• Bloky, deklarace a definice
• Ukazatele
• NULL

Základní datové typy

V prvním sloupci vidíte základní datové typy jazyka C. Ve druhém to, kolik zabírají bitů v paměti. Čím více bitů, tím větší číslo je možné zapsat. Na druhou stranu zabírají více paměti a práce s nimi je pomalejší! Ve třetím sloupci jsou významy čísel a ve čtvrtém příklady.

Typy char, short, int a long mohou být se znaménkem nebo bez znaménka. Určí se to pomocí klíčových slov signed (se znaménkem) nebo unsigned (beze znaménka). „signed“ je defaultní hodnota, proto jí není třeba psát. Vzpomeňte si na kapitolu o bitech a bajtech.

Na následujícím příkladě si osvětlíme použití datových typů.

  1: /*------------------------------------------------*/
  2: /* typy.c                                         */

  4: #include <stdio.h>
  5: int a;

  7: int main(void)
  8: {
  9:     /* deklarace promennych */
 10:     unsigned int b;
 11:     float c;

 13:     a = 5;
 14:     b = 11;
 15:     a = a / 2;
 16:     c = 5.0;
 17:     printf("a=%i\nb=%u\nc=%f\n", a, b, c / 2);

 19:     return 0;
 20: }

 22: /*------------------------------------------------*/

Výstup z tohoto programu bude následující:

a=2
b=11
c=2.500000

Všimněte si, že do proměnné a lze uložit pouze celé číslo. Vyzkoušejte si do proměnné b uložit záporné číslo. Uhodnete, co se stane?

Boolovské datové typy

V některých programovacích jazycích se používá datový typ bool, který může nabývat pouze hodnot True (pravda) nebo False (nepravda). Tyto hodnoty se používají ve vyhodnocování podmínek při řízení běhu programu a podmíněných operátorů. Oboje budeme probírat později. Na tomto místě si jen řekneme, že v jazyce C takovýto typ neexistuje.

V jazyce c se jako nepravda vrací 0 a jako pravda 1. A dále platí, že cokoliv nenulového se vyhodnocuje jako pravda (tj. vše kromě 0 a NULL).

Bloky, deklarace a definice

Blokem se rozumí vše, co je mezi špičatými závorkami { a }. V příkladě nahoře máme jediný blok, a to tělo funkce main(). Všechny proměnné, které deklarujeme v bloku, jsou tzv. lokální proměnné a proměnné mimo blok jsou globální. Lokální proměnné platí jen v těle bloku a v blocích vnořených (jinde je překladač neuvidí).

Proměnné jsou místa kdesi v paměti počítače, které definujeme v programu. Velikost místa v paměti závisí na datovém typu proměnné. Do proměnných lze vkládat hodnoty, měnit je a číst. V příkladě typy.c jsme vytvořili globální proměnnou a a dvě lokální proměnné b a c.

Deklarací proměnných určujeme jaké proměnné se v programu objeví. Nejdříve se určí datový typ a za ním názvy proměnných oddělené čárkou. Deklarace se ukončí středníkem. Při deklaraci je možné do proměnné rovnou vložit hodnotu. Názvy proměnných nesmí obsahovat mezeru, národní znaky (č, ř, š atp.) a nesmí začínat číslem. Jejich maximální délka je závislá na překladači. Jazyk C rozlišuje malá a velká písmena, takže můžete vytvořit proměnné se jmény Ahoj, ahoj, aHoj ... a program je bude chápat jako různé identifikátory. Dobrým zvykem je pro proměnné používat vždy jen malá písmena.

unsigned int i,j,k;
signed int cislo1, cislo2 = cislo3 = 25;

Dokud neurčíte jakou má proměnná hodnotu, může v ní být jakékoliv číslo. Např. proměnné cislo2 a cislo3 mají hodnotu 25, všechny ostatní mají náhodnou hodnotu!

Proměnné mohou být v jazyce C deklarovány pouze na začátku bloku funkce (tzv. lokální proměnné), nebo na začátku programu (globální proměnné). Lokální proměnné „existují“ jen v bloku, ve kterém jsou definovány (případně v blocích v něm vnořených) a nelze je tudíž používat mimo něj. V jazyce C++ je možné deklarovat proměnné téměř kdekoliv, ale stále platí, že proměnná má platnost pouze v bloku, ve kterém je deklarována.

Definice říká, jak bude nějaký objekt vypadat. V programu například definujeme funkci main(). Základní datové typy jsou definovány normou ANSI C. Můžeme definovat i vlastní typy dat, další funkce atd. K tomu se dostaneme později. Jen si nepleťte pojmy definice a deklarace. Definovat objekt můžeme jen jednou, deklarovat vícekrát.

Ukazatele

Ukazatele jsou jsou jednou z nejtěžších věcí na pochopení v jazyku C. Ukazatele jsou proměnné, které uchovávají adresu ukazující do paměti počítače. Při jejich deklaraci je třeba uvést, na jaký datový typ bude ukazatel ukazovat. Paměť počítače je adresována po bytech. Číslo 0 ukazuje na první bajt v paměti, číslo 1 na druhý bajt atd. Pokud máte šestnáctibitový překladač, bude velikost ukazatele 16 bitů, u 32 bitového překladače 32 bitů. Deklarace ukazatelů vypadá takto:

typ * jmeno;

Například:

float *uf;
int *ui;
void *uv;

Proměnné uf, ui a uv jsou ukazatele. Proměnná uf je ukazatel na typ float, ui je ukazatel na typ int a uv je tzv. prázdný ukazatel u kterého není určeno, na jaký datový typ se bude ukazovat. To překladači neumožňuje typovou kontrolu, proto je lepší jej nepoužívat, pokud to není nutné. Do všech třech proměnných lze vložit libovolné (celé) číslo, které pak bude překladačem chápáno jako adresa do paměti. K získání adresy nějaké proměnné slouží operátor & (viz příklad). K získání dat z adresy, která je uložena v ukazateli, slouží operátor * (viz příklad).

  1: /*------------------------------------------------*/
  2: /* ukazatel.c                                     */

  4: #include <stdio.h>

  6: int main(void)
  7: {
  8:     int i;        /* promenne int */
  9:     float f, f2;
 10:     int *ui;        /* ukazatel (na typ int) */
 11:     float *uf;

 13:     f = 5.5;
 14:     uf = 50;        /* v ukazateli uf je hodnota 50. Co je v pameti na 50 bajtu
 15:                    nikdo nemuze vedet, proto se takto do ukazatele adresa
 16:                    nikdy (!) neprirazuje */
 17:     uf = &f;        /* v ukazateli uf je hodnota adresy promenne f (tak je to
 18:                    spravne :-)) */
 19:     ui = &i;

 21:     f2 = *uf;        /* do f2 se priradi hodnota z promenne f, tedy 5.5 */
 22:     *ui = 10;        /* tam, kam ukazuje adresa v ui (tedy do i) se ulozi 10.
 23:                    Hodnota promenne ui se nezmeni (je to stale adresa    
 24:                    promenne i) */

 26:     printf("f = %f\n", f); /* hodnota v f se od prirazeni 5.5 nezmenila */
 27:     printf("f2 = %f\n", f2); /* do f2 se priradila hodnota z promenne f, na
 28:                                 kterou jsme se odkazovali pomoci ukazatele uf */
 29:     printf("i = %i\n", i); /* do i jsme pres ukazatel ui priradili 10 */

 31:     printf("uf = %u, *uf=%f\n", uf, *uf); /* vytiskneme si hodnotu uf a hodnotu
 32:                                              na teto adrese (tj. adresu f2 a
 33:                                              hodnotu f2) */
 34:     return 0;
 35: }
 36: /*------------------------------------------------*/

Výstup z programu bude následující:

f = 5.500000
f2 = 5.500000
i = 10
uf = 3221224276, *uf=5.500000

Proměnná uf obsahuje adresu paměti, na které byla proměnná f uložena. Ta se bude při každém spuštění programu lišit, neboť paměť přiřazuje programu operační systém. Do které části paměti program nahraje nelze předem vědět (alespoň mi, obyčejní smrtelníci, to nevíme).

V programu jsem se dopustil dvou chyb. Jednak to bylo přímé přiřazení hodnoty do proměnné uf (uf = 50;) a pak v poslední funkci printf, kde se tiskne hodnota ukazatele uf jako celé číslo bez znaménka (unsigned int). Je možné, že vám tyto konstrukce překladač nedovolí.

Za zmínku ještě stojí přiřazení f2 = *uf;. Jak to funguje? Nejdříve se vezme hodnota z uf a z této adresy se přečte číslo dlouhé tolik bitů, kolik bitů má typ, pro který je ukazatel určen. Proměnnou uf jsme deklarovali jako ukazatel na typ float, který má 32 bitů. Proto se vezme 32 bitů začínajících na adrese uložené v uf a toto číslo se pak chápe jako racionální a jako takové se uloží do f2. Kdybychom deklarovali uf jako ukazatel na typ char (char *uf;), pak by jsme se podívali sice na stejnou adresu, ale z ní přečetli jenom 8 bitů!

Asi vám v tuto chvíli není moc jasné, k čemu jsou ukazatele dobré. K tomu se však velice rychle dostaneme. Zatím je třeba, aby jste pochopili, k čemu slouží operátor & a * a také pochopili, že ukazatel, ať už ukazuje na jakýkoliv typ, je stále jen ukazatel.

NULL

NULL je speciální znak, který označuje velké nic. Používá se například v souvislosti s ukazateli. NULL můžete vložit do ukazatele a pak můžete testovat, zda ukazatel obsahuje NULL nebo adresu někam. NULL se také často používá jako argument funkcí, když tam, kde je argument vyžadován žádný argument vložit nechceme. Praktické využití této hodnoty si ukážeme později, například v ukázce použití NULL.

NULL je definováno v knihovně <stddef.h>, která je načítána např. pomocí <stdlib.h> a <stdio.h>.

¹⁾ long je ve skutečnosti zkratka pro long int a short pro short int.