====== Strukturované datové typy ======
    * [[dox>strukturovane-datove-typy/studenti.c|Studenti]]
    * [[dox>strukturovane-datove-typy/soucet-zlomku.c|Součet_zlomků]]
    * [[dox>strukturovane-datove-typy/strukt.c|Pokusy/demo struktur, unionů]]
======Odvozené datové typy======
V jazyku C je možné definovat si vlastní datové typy.
K tomuto účelu používáme konstukci [[:c:typedef]].
Syntaxe (obecně):
  typedef zápis_ve_tvaru_deklarace;
Příklady definice typu:
<code c>
typedef int cele_cislo; /* přejmenování typu; nepoužívá se */
typedef int male_pole[10]; /* vytvoření typu pro pole 10 prvků typu int */
typedef unsigned long ULong; /* přejmenování typu za účelem zkrácení zápisu; používá se zřídka */
typedef const ULong CULong; /* v definici typu je možné využít všechny dříve definované typy */
</code>
<del>Deklarace</del>Definice proměnné odvozeného typu:
<code>
male_pole moje_cisla;
ULong velke_cislo;
</code>
======Výčtový datový typ======
Výčtový datový typ se používá se pro definici většího počtu spolu souvisejících
celočíselných konstant. K vytváření výčtových typů používáme konstrukci [[:c:enum]].
Syntaxe:
  enum identifikátor_typu{
  id_clenu_1 = konst_výraz_1,
  ...
  id_clenu_N = konst_výraz_N
  } id_prom_1 = hodnota_1, ... , id_prom_M = hodnota_M;

kde //identifikátor_typu// je identifikátor nově vytvářeného výčtového typu,
//id_clenu_1// až //id_clenu_N// jsou identifikátory vytvářených konstant,
//konst_výraz_1// až //konst_výraz_N// hodnoty vytvářených konstant.

Pokud není hodnota konstanty v definici typu specifikována, je nastavena na hodnotu předchozí
konstatny zvětšenou o 1 (na hodnotu 0 v případě první konstanty v definici).

Součástí definice výčtového typu může být také deklarace libovolného množství
proměnných tohoto typu //id_prom_1// až //id_prom_M// a jejich případná inicializace
hodnotami //hodnota_1// až //hodnota_M//.

Příklady definice výčtového typu:
<code c>
enum Bool{TRUE = 1, FALSE = 0 }; /* pouze definice typu */
enum Bool{TRUE = 1, FALSE = 0 } splnen=TRUE; /* definice typu s definicí a inicializací proměnné */
enum {FALSE, TRUE} splnen = 1; /* definice bezejmenného typu s využitím implicitních hodnot konstant */
enum Den{Po,Ut,St,Ct,Pa,So=10,Ne} muj_den; /* kombinace implicitních a explicitně zadaných hodnot */
</code>
Příklady <del>deklarace</del>definice proměnných výčtového typu:
<code c>
enum Bool splneno; /* definice bez inicializace */
enum Bool splneno = 0; /* inicializace číselnou hodnotou */
enum Den muj_den = Po; /* inicializace identifikátorem konstanty */
</code>
Příklady použití výčtového typu:
<code c>
splneno = TRUE; /* využití symbolického jména */
muj_den = 3; /* využití číselné hodnoty */
cislo = muj_den * So + splneno; /* s konstantami lze provádět jakékoli operace */
</code>
======Výčtový typ pomocí typedef======
Jedná se o nejpřehlednější a v praxi nejpoužívanější způsob definice výčtových typů.
Typ se nepojmenovává v konstrukci **enum**, ale až v konstrukci **typedef**. viz [[:c:namespace]]
Příklady definice typu:
<code c>
typedef enum{TRUE = 1, FALSE = 0} Bool;
typedef enum{Po,Ut,St,Ct,Pa,So=10,Ne} Den;
</code>
Příklady deklarace proměnných výčtového typu:
<code c>
Bool splneno;
Bool splneno = 0;
Den muj_den = Po;
</code>
======Strukturovaný datový typ======
Strukturovaný datový typ se používá se pro uložení více spolu souvisejících
prvků, které mohou být různého typu (na rozdíl od pole).
K vytváření struktur používáme konstrukci [[:c:struct]].
Syntaxe:
  struct identifikátor_typu{
  typ_clenu_1 id_clenu_1;
  ...
  typ_clenu_N id_clenu_N;
  } id_prom_1 = {inic_1}, ..., id_prom_M = {inic_M};
kde
  * //identifikátor_typu// je identifikátor nově vytvářeného strukturovaného typu,
  * //typ_clenu_1// až //typ_clenu_N// jsou datové typy členů struktury a
  * //id_clenu_1// až //id_clenu_N// jsou identifikátory členů struktury.
Člen struktury může být libovolného typu,
pouze ne stejného typu jako právě definovaná struktura (lze obejít užitím ukazatelů).

Součástí definice strukturovaného typu může být také
<del>deklarace</del>definice libovolného množství proměnných tohoto typu //id_prom_1// až //id_prom_M//
a jejich případná inicializace výrazy //inic_1// až //inic_M// (podobně jako inicializace polí).

Příklady definic strukturovaného typu:
<code c>
struct Datum{char Den, Mesic; short Rok;}; /* pouze definice typu, h0nza: ne! struct tag! */
struct Datum{char Den, Mesic; short Rok;} narozen = {24, 3, 1972}; /* definice typu i proměnné s inicializací */
struct {char Den, Mesic; short Rok;} narozen = {24, 3, 1972}; /* definice typu beze jména */
</code>
Příklady deklarací proměnných strukturovaného typu:
<code c>
struct Datum narozen; /* definice bez inicializace */
struct Datum narozen = {24, 3, 1972}; /* definice s inicializací */
</code>
======Struktura pomocí typedef======
Jedná se o nejpřehlednější a v praxi nejpoužívanější způsob definice struktur.
Typ se nepojmenovává v konstrukci struct, ale až v konstrukci typedef.
Příklad definice typu:
<code c>
typedef struct {
   char Den, Mesic; short Rok;
} Datum;
</code>
Příklady <del>deklarace</del>definice proměnných strukturovaného typu:
<code c>
Datum narozen;
Datum narozen = {24, 3, 1972};
</code>
======Přístup ke členům struktury======
K jednotlivým členům struktury přistupujeme pomocí operátoru tečka,
před kterým je uveden identifikátor proměnné strukturovaného typu
a za ním identifikátor členu struktury, ke kterému přistupujeme.
Příklady:
<code c>
Datum muj_den, narozen, dnes;
int vek;

muj_den.Den = 24;
muj_den.Mesic = (muj_den.Mesic + 3) % 12;
vek = dnes.Rok - narozen.Rok;
</code>
======Další======
  * ukazatel na strukturu
  * struktura jako parametr funkce
  * funkce vracející strukturu
  * struktura struktur
  * padding, offsetof() makro
  * union
  * bitfield