www.amapro.cz & David Bazala [Programování]

Otevře webové stránky AmaPro


Otevře hlavní stránku společnosti AmaPro
Internetové stránky určené pro studenty středních a vysokých odborných škol.


amapro.cz/odkazy Projekt eliminuje vyhledávání klíčových slov na komerčních stránkách a v e-schopech.



Nový projekt AmaPro

 

struct

 

Příkaz typedef je standardní příkaz Céčka, který se používá pro definice různých struktur datových položek. Dosud nám C umožňoval vytvářet pouze tzv. pole, která jsou tvořena pouze jedním datovým polem. Struct nám umožní vytvářet různé struktury datových typů a umožňuje pracovat z takovouto strukturou jako s celkem. Je možné přistupovat k prvkům a vytvářet strukturu v jiné struktuře. Struktury jsou velmi silným nástrojem C pro zpracování dat.

 

Obecná konstrukce využití struktury:

 

struct

  {

 int a,b,;

  } X;

X.a=6;

Cout<<X.b;

 

Tato konstrukce definuje novou bezejmennou strukturu s prvky int a,b a proměnnou X. Přístup k prvku je pomocí tečkové notace X.a jako promenná.prvek.

 

Nejjednodušší konstrukce struct bez jména struktury:

 

struct

  {

 int a,b,c;

  } X,Y,Z;

 

Jedná se o nejjednodušší příklad využití. Struktura nemá svůj identifikátor a nelze ji již dále v programu modifikovat. Proměnné X,Y,Z jsou všechny, ke kterým lze se strukturou bez jména přistupovat. Již další později nelze deklarovat.

 

Jednoduchá konstrukce struct se jménem struktury:

 

struct jmeno

  {

 int a,b,c;

  } X,Y,Z;

 

 Struktura má svůj identifikátor a lze ji ještě dále v programu modifikovat. Proměnné X,Y,Z jsou momentálně všechny, ke kterým lze se strukturou jména přistupovat. Další proměnné později lze deklarovat pomocí identifikátoru jmeno.

 

Základní konstrukce struct se jménem struktury:

 

struct jmeno

  {

 int a,b,c;

  } ;

struct jmeno X,Y,Z;

 

Konstrukce příkazu struct se jménem struktury jmeno dovoluje předdefinovat si strukturu s identifikátorem jmeno bez určení použitých proměnných. Proměnné X,Y a Z lze tímto příkazovým řádkem kdykoliv deklarovat.

POZNÁMKA: častá chyba : jmeno X,Y,Z;  // chybí struct jako navigátor pro překladač

 

Předefinovaná konstrukce strukt bez jména pomocí typedef:

 

typedef struct

  {

 int a,b,c;

  } nahrada;

nahrada X,Y,Z;

 

Konstrukce struct pro definici bezejmenné struktury je příkazem typedef předefinovaná na synonymum nahrada. Deklarace proměnné pro danou bezejmennou strukturu je provedena jako synonymum proměnná.

POZNÁMKA: častá chyba: struct nahrada X,Y,Z;  //struct je navíc, je nahrazené synonymem

 

Nejčastější použití konstrukce struct s názvem struktury:

 

typedef struct jmeno

  {

 int a,b,c;

  } nahrada;

nahrada X,Y,Z;

 

Tato konstrukce je příkazově nejúplnější. Je pojmenováno jméno struktury i nový datový typ náhrada jako synonymum. Pomocí identifikátoru nahrada lze kdykoliv deklarovat novou proměnnou s strukturou jmeno.

POZNÁMKA: tohoto způsobu se využívá když se struktura odkazuje sama na sebe. Potom musí mít svůj název, byť by byla jediná.

 

 

 

PŘÍKLAD: struct_1

struct                                                    //hlavička pro deklaraci struktury BEZ NÁZVU

        {                                                     //počátek těla struct

        int vyska;                                     //deklarace proměnné jako int

        int vaha;                                       //deklarace proměnné jako int

        char svobod;                               //deklarace proměnné jako char

        } david, pavel, alena; //deklarace prvků struktury

 

//* * * * * * * * * * * * * * * * * * inicializace prvků struktury

david.vyska=174;

david.vaha=65;

david.svobod='A';

 

pavel.vyska=178;

pavel.vaha=73;

pavel.svobod='N';

 

alena.vyska=164;

alena.vaha=58;

alena.svobod='A';

//* * * * * * * * * * * * * * * * * * * výstup jednotlivých prvků na obrazovku

cout<<"david: vyska="<<david.vyska<<endl;

cout<<"david: vaha="<<david.vaha<<endl;

cout<<"david: svobodny="<<david.svobod<<endl;

cout<<"pavel: vyska="<<pavel.vyska<<endl;

cout<<"pavel: vaha="<<pavel.vaha<<endl;

cout<<"pavel: svobodny="<<pavel.svobod<<endl;

cout<<"alena: vyska="<<alena.vyska<<endl;

cout<<"alena: vaha="<<alena.vaha<<endl;

cout<<"alena: svobodny="<<alena.svobod<<endl;

getchar();

return 0;

 

Program demonstruje vytvoření bez jmenné struktury, která obsahuje dva prvky int a jeden prvek char. Proměnné pro tuto strukturu jsou uvedené přímo za deklarací struktury struct a jsou to david, pavel a alena. Zde je jediná možnost deklarovat názvy proměnných a to proto, že struktura nemá identifikátor (jméno). Následně jsou inicializovány jednotlivé prvky v proměnných a vypsány na obrazovku.

 

 

PŘÍKLAD: struct_2

struct mnozina                                     //hlavička pro deklaraci mnozina jako struktury

        {                                                     //počátek těla struct

        int vyska;                                     //deklarace prvků jako int

        int vaha;                                       //deklarace prvků jako int

        char svobod;                               //deklarace prvků jako char

        } david, pavel, alena; //deklarace proměnných struktury

 

//* * * * * * * * * * * * * * * * * * inicializace prvků struktury

david.vyska=174;

david.vaha=65;

david.svobod='A';

 

pavel.vyska=178;

pavel.vaha=73;

pavel.svobod='N';

 

alena.vyska=164;

alena.vaha=58;

alena.svobod='A';

//* * * * * * * * * * * * * * * * * * * výstup jednotlivých prvků na obrazovku

cout<<"david: vyska="<<david.vyska<<endl;

cout<<"david: vaha="<<david.vaha<<endl;

cout<<"david: svobodny="<<david.svobod<<endl;

cout<<"pavel: vyska="<<pavel.vyska<<endl;

cout<<"pavel: vaha="<<pavel.vaha<<endl;

cout<<"pavel: svobodny="<<pavel.svobod<<endl;

cout<<"alena: vyska="<<alena.vyska<<endl;

cout<<"alena: vaha="<<alena.vaha<<endl;

cout<<"alena: svobodny="<<alena.svobod<<endl;

getchar();

return 0;

 

Program demonstruje vytvoření struktury jménem mnozina, která obsahuje dva prvky int a jeden prvek char. Proměnné pro tuto strukturu jsou uvedené přímo za deklarací struktury struct mnozina a jsou to david, pavel a alena. Zde je možnost deklarovat názvy proměnných přímo v deklaraci struct , nebo pomocí toho, že struktura má identifikátor (jméno). Následně jsou inicializovány jednotlivé prvky v proměnných a vypsány na obrazovku.

 

 

PŘÍKLAD: struct_3

struct mnozina                                     //hlavička pro deklaraci mnozina jako struktury

        {                                                     //počátek těla struct

        int vyska;                                     //deklarace prvků jako int

        int vaha;                                       //deklarace prvků jako int

        char svobod;                               //deklarace prvků jako char

        };

struct mnozina david;                        //individuální deklarace proměnných struktury mnozina

struct mnozina pavel;                         //individuální deklarace proměnných struktury mnozina

struct mnozina alena;                         //individuální deklarace proměnných struktury mnozina

/*

mnozina david, pavel, alena;             //chybná deklarace, chybí struct!!!

*/

//* * * * * * * * * * * * * * * * * * inicializace prvků struktury

david.vyska=174;

david.vaha=65;

david.svobod='A';

 

pavel.vyska=178;

pavel.vaha=73;

pavel.svobod='N';

 

alena.vyska=164;

alena.vaha=58;

alena.svobod='A';

//* * * * * * * * * * * * * * * * * * * výstup jednotlivých prvků na obrazovku

cout<<"david: vyska="<<david.vyska<<endl;

cout<<"david: vaha="<<david.vaha<<endl;

cout<<"david: svobodny="<<david.svobod<<endl;

cout<<"pavel: vyska="<<pavel.vyska<<endl;

cout<<"pavel: vaha="<<pavel.vaha<<endl;

cout<<"pavel: svobodny="<<pavel.svobod<<endl;

cout<<"alena: vyska="<<alena.vyska<<endl;

cout<<"alena: vaha="<<alena.vaha<<endl;

cout<<"alena: svobodny="<<alena.svobod<<endl;

getchar();

return 0;

 

Program demonstruje vytvoření struktury jménem mnozina, která obsahuje dva prvky int a jeden prvek char. Proměnné pro tuto strukturu  nejsou uvedené přímo za deklarací struktury struct mnozina. Proměnné david, pavel a alena jsou deklarovány později, ale vždy musí být dříve než jsou použité. Následně jsou inicializovány jednotlivé prvky v proměnných a vypsány na obrazovku.

 

 

PŘÍKLAD: struct_4

typedef struct mnozina                      //hlavička pro deklaraci mnozina jako struktury

        {                                                     //počátek těla struct

        int vyska;                                     //deklarace prvků jako int

        int vaha;                                       //deklarace prvků jako int

        char svobod;                               //deklarace prvků jako char

        } MNOZINA;             //název synonyma nového datového typu pro typedef

MNOZINA david;                              //individuální deklarace přes synonymum

MNOZINA pavel;                              //individuální deklarace přes synonymum

MNOZINA alena;                               //individuální deklarace přes synonymum

 

//* * * * * * * * * * * * * * * * * * inicializace prvků struktury

david.vyska=174;

david.vaha=65;

david.svobod='A';

 

pavel.vyska=178;

pavel.vaha=73;

pavel.svobod='N';

 

alena.vyska=164;

alena.vaha=58;

alena.svobod='A';

//* * * * * * * * * * * * * * * * * * * výstup jednotlivých prvků na obrazovku

cout<<"david: vyska="<<david.vyska<<endl;

cout<<"david: vaha="<<david.vaha<<endl;

cout<<"david: svobodny="<<david.svobod<<endl;

cout<<"pavel: vyska="<<pavel.vyska<<endl;

cout<<"pavel: vaha="<<pavel.vaha<<endl;

cout<<"pavel: svobodny="<<pavel.svobod<<endl;

cout<<"alena: vyska="<<alena.vyska<<endl;

cout<<"alena: vaha="<<alena.vaha<<endl;

cout<<"alena: svobodny="<<alena.svobod<<endl;

getchar();

return 0;

 

Program demonstruje vytvoření struktury jménem mnozina, která obsahuje dva prvky int a jeden prvek char. Struktura je pomocí příkazu typedef  přejmenována na synonymum MNOZINA. Poznámka: z konvenčních důvodů se pro název struktury a typu používá stejných znaků s rozlišením malá/VELKÁ písmena. Proměnné david, pavel a alena jsou deklarovány později a jako identifikátor datového typu je použito synonymum s deklarace typedef. Následně jsou inicializovány jednotlivé prvky v proměnných a vypsány na obrazovku.

 

PŘÍKLAD: struct_5

typedef struct mnozina                                      //hlavička pro deklaraci mnozina jako struktury

       {                                                                     //počátek těla struct

       char jmeno[20];                            //deklarace prvku jako pole 20 charů

       int vek;                                                          //deklarace prvku jako int

       } MNOZINA, *ukMNOZINA;                  //název synonyma struktury pro typedef

MNOZINA A;                                                    //individuální deklarace přes synonymum

MNOZINA B;                                                     //individuální deklarace přes synonymum

ukMNOZINA uk1;                                             //deklarace uk1 jako ukazatele na strukturu

strcpy(A.jmeno,"Pavel");                                 //inicializace pomocí funkce strcpy()

A.vek=24;                                                            //inicializace int pro prvek A.vek

strcpy(B.jmeno,"Kamil");                                  //inicializace pomocí funkce strcpy()

B.vek=46;                                                             //inicializace int pro prvek B.vek

uk1=&A;                                                              //inicializace ukazatele uk1 na strukturu A

cout<<uk1->jmeno<<endl;                               //výstup prvku jmeno ze struktury na kterou ukazuje uk1

cout<<uk1->vek<<endl;                                    //výstup prvku jmeno ze struktury na kterou ukazuje uk1

cout<<(*uk1).vek<<endl;                                 //POZN:(*uk1).vek je to samé co uk1->vek

uk1=&B;                                                              //inicializace ukazatele uk1 na strukturu A

cout<<uk1->jmeno<<endl;                               //výstup prvku jmeno ze struktury na kterou ukazuje uk1

cout<<uk1->vek<<endl;                                    //výstup prvku jmeno ze struktury na kterou ukazuje uk1

cout<<(*uk1).vek<<endl;                                 //POZN:(*uk1).vek je to samé co uk1->vek

getchar();                                                             //čekání na entr

return 0;                                                               //výstup z konzolové aplikace

 

Program demonstruje vytvoření ukazatele pro dvě struktury A, B s jedním prvkem jmeno jako pole 20 charů a s jedním int. Proměnné struktury množina je MNOZINA a ukazatel na strukturu ukMNOZINA. Dále jsou deklarovány dvě struktury A, B a jejich prvkům jsou přiřazeny nějaké hodnoty. Demonstračně je deklarován uk1 jako ukazatel na strukturu množina. Ten je inicializován uk1=&A a ukazuje na strukturu A. Do funkce cout vstupují prvky struktury na které ukazuje uk1 (jmeno jako pole charů a vek jako int). Potom je uk1 modifikován aby ukazoval na strukturu B. Opět proveden výstup prvků na které ukazuje uk1. Poznámka: strcpy(B.jmeno,"Kamil"); je nutné, nelze napsat B->jmeno=“Kamil“, a to z důvodů dosud nealokované paměti. Poznámka: uk1=&A; je nutné předat skutečnou adresu, kde leží počátek struktury A.

 

 

PŘÍKLAD: struct_6

struct A                                                //hlavička pro deklaraci A jako struktury

      {                                                       //počátek těla struct

      int a;                                                //deklarace prvku  jako int

      int b;                                               //deklarace prvku jako int

      } david;                                          //deklarace proměnné struktury

struct B                                                 //hlavička pro deklaraci B jako struktury

      {                                                       //počátek těla struct

      int a;                                                //deklarace prvku jako int

      int b;                                               //deklarace prvku jako int

      struct A c;                                      //deklarace prvku jako strukturu A

      } alena;                           //deklarace proměnné struktury

 

david.a=10;                                          //inicializace prvku 'a' proměnné david struktury A

david.b=20;                                          //inicializace prvku 'b' proměnné david struktury A

alena.a=100;                                         //inicializace prvku 'a' proměnné alena struktury B

alena.b=200;                                        //inicializace prvku 'b' proměnné alena struktury B

alena.c.a=1000;                                    //inicializace prvku 'c' jako struktury A pro prvek 'a'

alena.c.b=2000;                                   //inicializace prvku 'c' jako struktury A pro prvek 'a'

 

cout<<david.a<<endl;                       //výpis prvků na obrazovku

cout<<david.b<<endl;                       //-..-

cout<<alena.a<<endl;                        //-..-

cout<<alena.b<<endl;                        //-..-

cout<<alena.c.a<<endl;                     //-..-

cout<<alena.c.b<<endl;                     //výpis prvků na obrazovku

 

getchar();                                             //čekání na entr

return 0;                                //výstup z konzolové aplikace

 

Tento program demonstruje možnost deklarace prvku v jedné struktuře jako datový typ jiné struktury. Podmínkou je, aby daná struktura byla již deklarovaná. Prvotně je deklarovaná struktura A s prvky int a,b a proměnnou david. Potom je deklarovaná struktura B, která má dva prvky int a,b a prvek c, který má datový typ tvořen strukturou A. Jedná se tedy o struktura v struktuře. Prvek c je tedy tvořen dvěma int ze struktury A, ke kterým se přistupuje c.a, c.b. Protože proměnnou struktury B je alena, bude se k jednotlivým prvkům přistupovat jako alena.c.a, alena.c.b. Dále jsou přiřazeny všem prvkům struktury A i B hodnoty a vypsány na obrazovku.

 

PŘÍKLAD: struct_7

typedef struct                                                     //hlavička pro deklaraci bezejmenné struktury

        {                                                                    //počátek těla struct

        double re;                                     //deklarace prvku pro reálnou část jako double

        double im;                                                    //deklarace prvku pro imaginární část jako double

        } komplex;                                                    //název synonyma nového datového typu pro typedef

komplex soucet(komplex a, komplex b)           //úvodní hlavička nové funkce soucet

        {                                                                    //počátek těla nové funkce soucet

        komplex c;                                                    //alokace paměti dle struktury pro synonymum komplex

        c.re=a.re+b.re;                                             //modifikace double prvku pro proměnnou C struktury komplex

        c.im=a.im+b.im;                                           //modifikace double prvku pro proměnnou C struktury komplex

        return komplex (c);                                     //vrací dvě double jako strukturu komplex

        }                                                                    //konec těla nové funkce soucet

int main(int argc, char* argv[])                         //hlavička hlavní funkce

{                                                                            //počátek těla hlavní funkce

komplex A;                                                          //deklarace proměnné A jako struktury komplex

komplex B;                                                           //deklarace proměnné B jako struktury komplex

komplex C;                                                           //deklarace proměnné C jako struktury komplex

A.re=4.23;A.im=3.12;                                         //inicializace prvků double proměnné A

B.re=6.13;B.im=4.98;                                          //inicializace prvků double proměnné B

C=soucet(A,B);                                                  //volání funkce soucet s parametry proměnných A, B

cout<<C.re<<endl;                                             //výstup jednoho prvku proměnné C jako double

cout<<C.im<<endl;                                            //výstup druhého prvku proměnné C jako double

getchar();                                             //čekání na entr

return 0;                                                //výstup z konzolové aplikace

 

Program demonstruje volání nové funkce soucet(), do které vstupují dvě proměnné se strukturou předefinovanou na synonymum komplex. Volaná funkce soucet()vrací opět hodnotu typu komplex. Předávání je prováděno přímo jako skutečný parametr hodnotou. Struktura komplex definuje dva prvky re, im jako double. Nová funkce soucet() provede součet jednotlivých prvků ve struktuře komplex pro proměnné A, B a výsledek uloží do proměnné C, kterou bude vracet. Vše se děje v zásobníku. Hlavní program deklaruje tři proměnné komplex A,B a C. Proměnné A,B jsou inicializovány a C má doposud neurčitou hodnotu. Voláním funkce soucet() se předávají parametry jako hodnoty. Po provedení funkce soucet(), která modifikuje double v C, je proveden výstup jednotlivých prvků na monitor.

 

 

PŘÍKLAD: struct_8

typedef struct                                                                     //hlavička pro deklaraci bezejmenné struktury

      {                                                                                      //počátek těla struct

      double re;                                                      //deklarace prvku pro reálnou část jako double

      double im;                                                                     //deklarace prvku pro imaginární část jako double

      } komplex;                                                                     //název synonyma nového datového typu pro typedef

void soucet(komplex *A,komplex *B, komplex *C)      //úvodní hlavička nové funkce soucet

      {                                                                                      //počátek těla nové funkce soucet

      C->re=A->re+B->re;                                                    //modifikace jednoho double pomocí pointerů

      C->im=A->im+B->im;                                   //modifikace druhého double pomocí pointerů

      }                                                                                      //konec těla nové funkce soucet

int main(int argc, char* argv[])                                        //hlavička hlavního programu

{                                                                                            //začátek těla hlavního programu

komplex A;                                                                          //deklarace proměnné A jako struktury komplex

komplex B;                                                                           //deklarace proměnné B jako struktury komplex

komplex C;                                                                           //deklarace proměnné C jako struktury komplex

A.re=4.23;A.im=3.12;                                                         //inicializace prvků double proměnné A

B.re=6.13;B.im=4.98;                                                          //inicializace prvků double proměnné B

soucet(&A,&B,&C);                                                         //volání funkce s par. předanými odkazem pomocí pointru

cout<<C.re<<endl;                                                             //výstup jednoho prvku proměnné C jako double

cout<<C.im<<endl;                                                            //výstup druhého prvku proměnné C jako double

getchar();                                                             //čekání na entr

return 0;                                                               //výstup z konzolové aplikace

}

 

Příklad demonstruje využití struktury při volání jiné funkce s tím, že parametry do funkce jsou předány odkazem, referencí nebo-li adresou v paměti. Nová funkce součet() je void, takže do ní nic nevstupuje. Ve funkci součet() se k jednotlivým přístupům k prvkům používá direktiva ->. Do zásobníků nevstupují skutečné hodnoty proměnných, ale pouze adresy. Hlavní program deklaruje tři proměnné typu komplex. A,B inicializuje hodnotami double. Proměnná C má zatím nedefinované double. Voláním funkce soucet() dojde k modifikaci paměťových buněk tvořících double pro proměnnou C. Následně jsou obě double tvořící proměnnou C poslány na obrazovku.

 

 

 

 



Abecední seznam všech článků Vyhledání pojmů ve článcích




Programování PHP
Články o programování webových stránek pomocí PHP.
internet/katalog_programovani_php
JavaScript - ukázky
Příklady užití některých často používaných efektů na stránky.
katalogy/javascript
Mikropočítače a jejich programování
Nízká forma programování, assembler a struktura procesorů.
knihy/mikropocitace/obsah_mikro1.php
Weby o programování
Odkazy na velké servery o programování a vývoji SW
odkazy/programovani
Procesory a mikroprocesory
Obecný úvod do základů mikroprocesorové techniky, architektury počítačů
knihy/mikroprocesory/obsah_mikro2.php
Mikropočítače
Seznámení s obecnou problematikou počítačů a mikropočítačů.
programovani/mikropocitace
Mikroprocesory IV.
Varianty návrhu číslicových řídících systémů realizovaných jako sekvenční obvody.
programovani/procesory_4
CSS html vlasnosti
Přehled CSS vlastností pro tvorbu webu
datove_zdroje/stranky/css
PHP práce s poli
Práce s poli a položkamy v PHP.
stranky/php_array
Otevře stránky Fulltextové vyhledávání na celém serveru
Digitalizované odborné knihy
Velká encyklopedie pojmů a zkratek
Česko - anglicko - německý technický slovník
Klasický katalog firem, služeb a stránek
OnLine překladač  vět a textů (nepoužívá Google)
Stránky pro chvíle oddechu od studia, relaxace
Katalog českých firem dle technologií
Internetový odkazník
Otevře hlavní stranu pro oddíl programování




 Wikipedie   Seznam stránek   Kapitoly témat   Významné servery   Klíčová slova 








Otevře hlavní stranu společnosti AmaPro

Všechna práva vyhrazena. Určeno jen pro osobní využití. Bez předchozího písemného souhlasu správce www.amapro.cz je zakázána jakákoli další publikace, přetištění nebo distribuce jakéhokoli materiálu nebo části materiálu zveřejněného na www.amapro.cz a to včetně šíření prostřednictvím elektronické pošty. Články, jejichž přímým autorem není amapro.cz lze publikovat pouze se souhlasem jejich majitelů či administrátoru příslušného webu.