Kiwiki - Príspevky používateľa [sk]

Jazyk C - súbory

2020-05-26T13:51:07Z

Matej.F: /* Príklad */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__

==Súbory==
'''Súbor''' predstavuje postupnosť bajtov bez ohľadu na to, či ide o textový súbor alebo binárny súbor. Programovací jazyk C poskytuje prístup k funkciám na vysokej úrovni, ako aj k volaniam na nízkej úrovni (na úrovni OS) na spracúvanie súborov na pamäťových zariadeniach.
Okrem práce so štandardnými vstupnými a výstupnými zariadeniami je možné vykonávať zápis a čítanie informácií zo súborov. Táto činnosť je podporovaná dvoma skupinami štandardných funkcií pre dve úrovne práce so súbormi.
Nižšiu úroveň reprezentuje skupina funkcií, ktoré priamo využívajú služby operačného systému. Celú réžiu s tým spojenú musí zabezpečovať samotný program.
Vyššiu úroveň predstavuje práca s prúdmi (stream) údajov. Táto úroveň sa používa najčastejšie a je užívateľsky prijateľnejšia ako prv spomínaná nižšia úroveň.

Každá činnosť spojená s komunikáciou so súborom môže pozostávať z týchto krokov :

*otvorenie súboru
*manipulácia so súborom (čítanie, zápis, nastavenie)
*zatvorenie súboru

Pri práci so súbormi sa stretávame s niektorými preddefinovanými konštantami :

*EOF koniec súboru
*FOPEN_MAX maximálny počet súčasne otvorených súborov
*FILENAME_MAX maximálna dĺžka názvu súboru
*TMP_MAX maximálny počet súčasne otvorených pracovných prúdov

Pre prácu so súbormi v jazyku C musíme mať zahrnutú knižnicu ''stdio.h''. Ak ste si všimli, tak táto knižnica sa zahŕňa aj pri funkciách, ktoré buď vypisujú na monitor, alebo čítajú z klávesnice. Je to preto, pretože tieto funkcie vlastne len čítajú zo súborov alebo zapisujú do súborov, ktoré sú určené pre vstup z klávesnice a výstup na monitor.

==Otvorenie súboru==

Na otvorenie súboru slúži funkcia [[Fopen (jazyk C)|fopen]], ktorá má dva parametre. Prvý parameter určuje miesto (path) kde je súbor uložený, vrátane názvu a prípony súboru, druhý parameter určuje režim, v ktorom bude súbor otvorený. Režimy pre textové súbory sú v tabuľke nižšie. Funkcia [[Fopen (jazyk C)|fopen]] vráti adresu súboru. Po zavolaní funkcie [[Fopen (jazyk C)|fopen]] treba overiť, či ukazovateľ na súbor nie je ''NULL'', čiže či súbor existuje.
{| class="wikitable"
|-
! Režim !! Popis
|-
| r || Otvorí súbor len pre čítanie.
|-
| w || Otvorí súbor pre zapisovanie. Ak neexistuje, tak vytvorí nový súbor. V tomto režime sa začne zapisovať na začiatku súboru.
|-
| a || Otvorí súbor pre zapisovanie s funkciou pripájania. Ak neexistuje, tak vytvorí nový súbor. V tomto režime sa začne pripájať text na koniec súboru.
|-
| r+ || Otvorí súbor aj pre čítanie aj pre zapisovanie.
|-
| w+ || Otvorí súbor aj pre čítanie aj pre zapisovanie. Ako prvé vymaže dáta zo súboru, ak existujú, inak vytvorí nový súbor.
|-
| a+ || Otvorí súbor aj pre čítanie aj pre zapisovanie. Ak neexistuje, tak vytvorí nový súbor. Čítanie začne od začiatku, ale zapisovaný text môže byť len pripájaný.
|}<ref>https://www.tutorialspoint.com/cprogramming/c_file_io.htm</ref>

Ak chcete otvoriť binárne súbory, musíte použiť nasledovné režimy:
"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

==Funkcie na prácu so súbormi==
{| class="wikitable"
! Funckia !! Popis
|-
| [[Fopen (jazyk C)|fopen]]() || Vytvorí nový súbor, alebo otvorí existujúci súbor.
|-
| [[Fclose (jazyk C)|fclose]]() || Zatvorí otvorený súbor.
|-
| [[Getw (jazyk C)|getw]]() || Načíta celé číslo zo súboru.
|-
| [[Putw (jazyk C)|putw]]() || Zapíše celé číslo do súboru
|-
| [[Fgetc (jazyk C)|fgetc]]() || Načíta jeden znak zo súboru.
|-
| [[Fputc (jazyk C)|fputc]]() || Zapíše jeden znak do súboru.
|-
| [[Gets (jazyk C)|gets]]() || Načíta jeden riadok z klávesnice (''stdin'').
|-
| [[Puts (jazyk C)|puts]]() || Vypíše jeden riadok na monitor (''stdout'').
|-
| [[Fgets (jazyk C)|fgets]]() || Načíta reťazec zo súboru, jeden riadok naraz.
|-
| [[Fputs (jazyk C)|fputs]]() || Zapíše reťazec do súboru.
|-
| [[Feof (jazyk C)|feof]]() || Kontroluje koniec súboru.
|-
| [[Fgetchar (jazyk C)|fgetchar]]() || Načíta znak z klávesnice (''stdin'').
|-
| [[Fprintf (jazyk C)|fprintf]]() || Zapíše formátované dáta do súboru.
|-
| [[Fscanf (jazyk C)|fscanf]]() || Prečíta formátované dáta zo súboru.
|-
| [[Fputchar (jazyk C)|fputchar]]() || Na obrazovku (''stdout'') vypíše znak načítaný z klávesnice (''stdin'').
|-
| [[Fseek (jazyk C)|fseek]]() || Posunie kurzor v súbore na určité miesto.
|-
| SEEK_SET || Posunie kurzor na začiatok súboru.
|-
| SEEK_CUR || Posunie kurzor na presne určené miesto.
|-
| SEEK_END || Posunie kurzor na koniec súboru.
|-
| [[Ftell (jazyk C)|ftell]]() || Vráti aktuálnu pozíciu kurzora v súbore.
|-
| [[Rewind (jazyk C)|rewind]]() || Posunie kurzor na začiatok súboru.
|-
| [[Getc (jazyk C)|getc]]() || Načíta znak zo súboru.
|-
| [[Getch (jazyk C)|getch]]() || Načíta znak z klávesnice (''stdin'') aj bez stlačenia tlačidla enter.
|-
| [[Getche (jazyk C)|getche]]() || Zobrazí znak z klávesnice (''stdin'') na obrazovke (''stdout'') aj bez stlačenia tlačidla enter.
|-
| [[Getchar (jazyk C)|getchar]]() || Načíta znak z klávesnice (''stdin'').
|-
| [[Putc (jazyk C)|putc]]() || Zapíše znak do súboru.
|-
| [[Putchar (jazyk C)|putchar]]() || Vypíše znak na monitor (''stdout'').
|-
| [[Printf (jazyk C)|printf]]() || Vypíše formátované dáta na monitor (''stdout'').
|-
| [[Sprintf (jazyk C)|sprintf]]() || Uloží formátované dáta do textového reťazcu.
|-
| [[Scanf (jazyk C)|scanf]]() || Načíta formátované dáta z klávesnice (''stdout'').
|-
| [[Sscanf (jazyk C)|sscanf]]() || Načíta formátované dáta z textového reťazcu.
|-
| [[Remove (jazyk C)|remove]]() || Odstráni súbor.
|-
| [[Fflush (jazyk C)|fflush]]() || Vyčistí súbor.
|}

==Príklad==

Tento príklad zobrazuje, ako zapisovať a čítať zo súboru. Pre čítanie alebo zapisovanie sú zobrazené dva možné spôsoby zápisu ([[Fprintf (jazyk C)|fprintf]]() a [[Fputc (jazyk C)|fputc]]()/ [[Fscanf (jazyk C)|fscanf]]() a [[Fgetc (jazyk C)|fgetc]]()). V príklade je použitá funkcia [[Rewind (jazyk C)|rewind]](), ktorá vráti kurzor na začiatok súboru. Pred spustením tohoto príkladu je potrebné si zmeniť cestu súboru, podľa toho, kde chcete súbor vytvoriť.

<source lang="c" line>
#include <stdio.h>

int main()
{
//otvorenie súboru: musíme zadať cestu k súboru, a potom spôsob akým ho chceme otvoriť
//V ceste k súboru musia byť opačné lomítka zdvojené, pretože jedno lomítko spolu s ďalším znakom označuje špeciálne znaky
//napr. \n je znak new line
FILE *subor = fopen("C:\\Users\\USER\\Documents\\subor.txt", "w");

//overenie, či sa súbor otvoril
if (subor) {
printf("CHYBA: subor sa neotvoril!");
return 0;
}

//namiesto printf pri zapisovaní do súborov používame funkciu fprintf
fprintf(subor, "Toto je prvy riadok\n"); //zapísanie prvého riadku do súboru
fprintf(subor, "Toto je druhy riadok\n"); //zapísanie druhého riadku do súboru

//načítanie vstupu z klávesnice, a zapísanie do súboru
char text[100];
printf("Zadajte slovo, ktore bude zapisane do suboru: ");
scanf("%s", text);
fprintf(subor, "%s", text);

fputc('S', subor); //zapísanie len jedného znaku (char) do súboru

fclose(subor); //zatvorenie súboru

//Otvorenie súboru pre čítanie
subor = fopen("C:\\Users\\USER\\Documents\\subor.txt", "r");

//overenie, či sa súbor otvoril
if (subor) {
printf("CHYBA: subor sa neotvoril!");
return 0;
}

//namiesto funkcie scnaf používame pri súboroch funkciu fscanf
fscanf(subor, "%s", text); //načítanie jedného slova zo súboru
printf("%s ", text); //vypísanie daného slova

printf("\n");
rewind(subor); //vrátenie sa na začiatok súboru

//čítanie zo súboru po znakoch, čítanie sa zastaví, ak funkcie fgets vráti EOF, čiže koniec súboru
int znak = 0;
while ((znak = fgetc(subor)) != EOF) {
printf("%c", znak);
}

return 0;
}

</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:47:01Z

Matej.F: /* Návratová hodnota */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

;Parametre prenášané hodnotou: To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

;Parametre prenášané odkazom: Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{
double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c">
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
<source lang="c">
int a;
a=abs(-5);
char c=getchar();
</source>

*Funkcie bez návratovej hodnoty nemôžem priraďovať.
<source lang="c">
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
</source>
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{
// telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:45:37Z

Matej.F: /* Volanie funckie */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{
double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c">
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a;
a=abs(-5);
char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{
// telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:44:44Z

Matej.F: /* Návratová hodnota */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{
double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a;
a=abs(-5);
char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{
// telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:44:08Z

Matej.F: /* Definícia funkcie */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{
double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a;
a=abs(-5);
char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{
// telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:43:36Z

Matej.F: /* Funkcie s návratovou hodnotou */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{ double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a; a=abs(-5); char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{
// telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:43:24Z

Matej.F: /* Funkcie s návratovou hodnotou */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{ double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a; a=abs(-5); char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{ // telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:43:01Z

Matej.F: /* Funkcie bez návratovej hodnoty */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{ double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a; a=abs(-5); char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{ // telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:42:33Z

Matej.F: /* Použitie funkcií */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{ double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a; a=abs(-5); char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{ // telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie

int main()
{
parne(5); // použitie vlastnej funkcie v maine
}

void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}

int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - funkcie

2020-05-26T13:42:13Z

Matej.F: /* Použitie funkcií */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
==Funkcie==
'''Funkcia''' je skupina príkazov, ktoré spoločne vykonávajú úlohu. Každý program C má najmenej jednu funkciu, ktorá je hlavná (), a všetky najvýznamnejšie programy môžu definovať ďalšie funkcie.

Kód môžete rozdeliť do samostatných funkcií. Ako rozdelíte svoj kód medzi rôzne funkcie, je len na vás, ale logicky je rozdelenie také, že každá funkcia vykonáva konkrétnu úlohu.

Deklarácia funkcie hovorí kompilátoru o názve funkcie, type návratu a parametroch. Definícia funkcie poskytuje skutočné telo funkcie.

Knižnica v štandardnom jazyku C poskytuje množstvo vstavaných funkcií, ktoré môže váš program zavolať. Napríklad strcat () spája dva reťazce, memcpy () na kopírovanie jedného miesta na iné miesto a mnoho ďalších funkcií.

Funkcia môže byť tiež označovaná ako metóda alebo čiastková rutina alebo postup atď.<ref>https://www.tutorialspoint.com/cprogramming/c_functions.htm</ref>

Definícia funkcie v programovaní C sa skladá z hlavičky funkcie a tela funkcie. Tu sú všetky časti funkcie -

'''Return Type''' - Funkcia môže vrátiť hodnotu. Return_type je typ údajov hodnoty, ktorú funkcia vracia. Niektoré funkcie vykonávajú požadované operácie bez vrátenia hodnoty. V tomto prípade je návratovým typom kľúčové slovo neplatné.

'''Názov funkcie''' - Toto je skutočný názov funkcie. Názov funkcie a zoznam parametrov spolu tvoria funkčný podpis.

'''Parametre''' - parameter je ako zástupný symbol. Po vyvolaní funkcie odovzdáte hodnotu parametru. Táto hodnota sa označuje ako skutočný parameter alebo argument. Zoznam parametrov sa týka typu, poradia a počtu parametrov funkcie. Parametre sú voliteľné; to znamená, že funkcia nesmie obsahovať žiadne parametre.

'''Telo funkcie''' - telo funkcie obsahuje súbor príkazov, ktoré definujú, čo funkcia robí.

====Príkazy vo funkcií====
''Dovolené:''
*Používanie akýchkoľvek príkazov
*Volanie iných funkcií
*Volanie samej seba(rekurzia)

''Zakázané''
*Definovanie funckie v tele inej funkcie
*Volanie funckie main

''Doporučené''
*Písať krátke, jednoúlohové, ľahko pochopitelné funkcie
*Veľké funkcie rozdeliť na vhodnom mieste
*Ak to nie je nutné funkcia nebude vypisovať na obrazovku

===Parametre funkcie===
Argumety: zoznam premenných uzatvorených v zátvorkách pri mene funkcie
*a=getchar();
*putchar(a);
*clrscr();
*abs(b);
*power(x,y);

'''Parametre prenášané hodnotou'''

To znamená, že pri volaní funkcie (napr. abs(3) ) sa hodnota parametru funkcie skopíruje do novovytvorenej premennej (argumentu) / abs(int x=3) / danej funkcie. Takto sa prenášajú všetky argumenty (okrem výnimiek, a ak to neurčíme inak). Premenné vytvorené vo funkciách sú lokálne a po skončení funkcie zaniknú. Premenné definované v jednej funkcie nie sú viditeľné v inej funkcii (aj keď majú rovnaké meno).

'''Parametre prenášané odkazom.'''

Pri parametroch prenášaných odkazom je špecifické to, že pri volaní funkcie sa nekopírujú ich hodnoty, ale ich adresy (čo šetrí čas pri argumentoch s väčšími pamäťovými nárokmi). Dôsledok tejto zmeny je, že zmena hodnoty vo funkcii má za následok zmenu tejto premennej aj vo funkcii, z ktorej bola táto volaná. Upravme hlavičku funkcie abs, aby parameter x bol prenášaný odkazom: int abs(int &x); Operátor & (referencia) má význam adresy premennej. Premenné sa prenášajú odkazom, ak to určíme operandom &. Polia ako parametre funkcií sa prenášajú odkazom vždy (operátor & sa neuvádza).

===Deklaracia funkcie===
*Prototyp sa zapíše v súbore kde sa funkcia používa.
*Funkcia sa definuje pred jej prvým použitím (volaním). Definícia potom vystupuje aj ako deklarácia.
*Prototyp funkcie a jej definícia sa musia zhodovať v návratovom type, názve funkcie a type parametrov
*Názvy parametrov v deklarácii sú nepovinné a nemusia sa zhodovať s definíciou

===Definícia funkcie===
*Hlavička a telo funkcie
*Hlavička sa zhoduje s deklaráciou
*návratový typ, názov funkcie a zoznam parametrov
*nie je za ňou bodkočiarka!
*Telo začína a končí zloženou zátvorkou
*Príkazom return kdekoľvek v tele sa funkcia ukončí, pričom musí vrátiť hodnotu (okrem typu void)

<source lang="c" line>
void Plocha(double dlzka, double sirka) //hlavička
{ double plocha = dlzka*sirka;
printf("%f",plocha); //telo funkcie
return;
}
</source>

===Volanie funckie===
*Argumenty sú odovzdávané v rovnakom poradí ako sú parametre uvedené v deklarácii a definícii.
*Na názvoch argumentov nezáleží, odovzdáva sa len ich hodnota, dôležitý je typ.
*Ak funkcia nemá parametre, pri volaní sa uvádzajú len prázdne zátvorky ( )

<source lang="c" line>
double a, b;
printf("Zadaj dlzku a sirku obdlznika: ");
scanf("%lf %lf", &a, &b);
Plocha(a, b); //volanie funkcie a odovzdanie dvoch argumentov
</source>

===Návratová hodnota===
*Funkcie, ktoré vracajú nejakú hodnotu môžem priradiť k nejakej premennej:
int a; a=abs(-5); char c=getchar();
*Funkcie bez návratovej hodnoty nemôžem priraďovať.
a=clrscr();
chyba: clrscr() nemá návratovú hodnotu
*Správne použitie: clrscr();

==Funkcie s návratovou hodnotou==
Po skončení vykonávania funkcia vráti nejakú hodnotu, ktorú môžeme priradiť do premennej.
<source lang="c" line>
int abs(int x)
{ // telo funkcie
if(x<0)
return -x;
else
return x
}
</source>
*hlavička funkcie: typ návratovej hodnoty: int (celé číslo)
*argumenty: funkcia má jeden argument: x (x je celé číslo)
*telo funkcie obsahuje konkrétne príkazy
*hodnotu, ktorú má funkcia vrátiť, špecifikujeme kľúčovým slovom return, za ktorým nasleduje hodnota, ktorú chceme vrátiť. V príklade, ak je x<0, funkcia vráti hodnotu, čo je vlastne -x (kde x<0), čiže výsledok bude +x. V opačnom prípade vráti x.

==Funkcie bez návratovej hodnoty==
Tieto funkcie nič nevracajú. Ich návratový typ je void (prázdny).

<source lang="c" line>
void hlasenie(int cislo_chyby)
{
switch(cislo_chyby)
{
case 0: printf("Ziadna chyba"); break;
case 1: printf("Chybne vstupne hodnoty"); break;
case 2: printf("Chyba pocas vypoctu"); break;
default: printf("Neznama chyba");
}
}
</source>

Dana funkcia je bez návratovej hodnoty (void) a má jeden parameter: celé číslo cislo_chyby. Táto funkcia vypíše podľa hodnoty svojho parametra nejaké chybové hlásenie.

==Použitie funkcií==
<source lang="c" line>
void parne(int a); //Deklarácia funckie
int main()
{
parne(5); // použitie vlastnej funkcie v maine
}
void parne(int a) //Definícia funckie za hlavnou funkciou
{
if(a%2)
printf(“%d je neparne”,a);
else
printf(“%d je parne”,a);
}
</source>

'''Príklad na minimum'''
<source lang="c" line>
int min(int h1,int h2)
{
if (h1<h2)
return h1;
else
return h2;
}
int main()
{
int k=min(5,2);
printf("%d",k);
printf("%d",min(7,4));
int k2=min(min (7,8),k));
int k3=min(min(7,8),min(5,2)));
}
</source>

==Referencie==

Jazyk C - reťazce

2020-05-26T13:40:44Z

Matej.F:

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
Reťazce sú vlastne jednorozmerné pole znakov ukončené nulovým znakom '\0'. Reťazec teda obsahuje znaky a ako posledný znak je nulový znak '\0'.

Nasledujúce deklarácia a inicializácia vytvoria reťazec pozostávajúci zo slova „Ahoj“. Každý reťazec musí byť ukončený nulovým znakom '\0', preto veľkosť poľa znakov obsahujúceho reťazec je vždy o +1 väčší ako je počet písmen vo výraze.

'''Iniciálizácia'''
<source>
char slovo[5] = {'A', 'h', 'o', 'j','\0'};
</source>

Ak budete postupovať podľa pravidla inicializácie poľa, môžete vyššie uvedený príkaz napísať nasledovne.
<source>
char slovo[5] = "Ahoj";
</source>

Prezentácia pamäte vyššie definovaného reťazca v C.
{|class="wikitable" style="text-align: center;
|-
| Index || 0 || 1 || 2 || 3 || 4
|-
| Premenná || A || h || o || j || \0
|-
|}

V skutočnosti neukladáte nulový znak na koniec reťazcovej konštanty. Keď inicializuje pole, kompilátor C ho automaticky umiestni '\ 0' na koniec reťazca. Pokúsme sa vypísať vyššie uvedený reťazec.
<source lang="c" line>
#include <stdio.h>

int main () {

char slovo[5] = {'A', 'h', 'o', 'j','\0'};
/*poprípade môžme pole inicializovať takto:
char slovo[5] = "Ahoj";
*/

printf("Vypisane slovo: %s\n", slovo);
return 0;
}
</source>
Vystup.
<source>
Vypisane slovo: Ahoj
</source>

C podporuje širokú škálu funkcií, ktoré manipulujú s reťazcami ukončenými nulovou hodnotou.
{|class="wikitable" style="text-align: center;
|-
! !! Funkcia !! Účel
|-
| 1 || [[Strcpy (jazyk C)|strcpy (s1);]] || Skopíruje reťazec s2 do reťazca s1.
|-
| 2 || [[Strcat(jazyk C)|strcat (s1);]] || Pripojí reťazec s2 na koniec reťazca s1.
|-
| 3 || [[Strlen (jazyk C)|strlen (s1);]] || Vráti dĺžku reťazca s1.
|-
| 4 || [[Strcmp (jazyk C)|strcmp (s1);]] || Vráti 0, ak sú s1 a s2 rovnaké; menej ako 0, ak s1 <s2; väčšie ako 0, ak s1> s2.
|-
| 5 || [[Strchr (jazyk C)|strchr (s1);]] || Vracia ukazovateľ na prvý výskyt znaku ch v reťazci s1.
|-
| 6 || [[Strstr (jazyk C)|strstr (s1);]] || Vráti ukazovateľ na prvý výskyt reťazca s2 v reťazci s1.
|-
|}

Nasledujúci príklad používa niektoré z vyššie uvedených funkcií.
<source lang="c" line>
#include <stdio.h>
#include <string.h>
int main () {

char retazec1[12] = "Ahoj";
char retazec2[12] = "svet";
char retazec3[12];
int dlzka;

/* Skopírovanie reťazca 1 do reťazca 3 */
strcpy(retazec3, retazec1);
printf("strcpy( retazec3, retazec1) : %s\n", retazec3);

/* "Prilepenie" retazec2 za retazec1*/
strcat( retazec1, retazec2);
printf("strcat( retazec1, retazec2): %s\n", retazec1);

/* Celková dlážka reťazca 1 po pripojení reťazca 2*/
len = strlen(retazec1);
printf("strlen(retazec1): %d\n", dlzka);

return 0;
}
</source>
Vystup.
<source>
strcpy( retazec3, retazec1): Hello
strcat(retazec1, retazec2): HelloWorld
strlen(retazec1): 10
</source>

Jazyk C - reťazce

2020-05-26T13:39:57Z

Matej.F:

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
Reťazce sú vlastne jednorozmerné pole znakov ukončené nulovým znakom '\0'. Reťazec teda obsahuje znaky a ako posledný znak je nulový znak '\0'.

Nasledujúce deklarácia a inicializácia vytvoria reťazec pozostávajúci zo slova „Ahoj“. Každý reťazec musí byť ukončený nulovým znakom '\0', preto veľkosť poľa znakov obsahujúceho reťazec je vždy o +1 väčší ako je počet znakov v slove.

'''Iniciálizácia'''
<source>
char slovo[5] = {'A', 'h', 'o', 'j','\0'};
</source>

Ak budete postupovať podľa pravidla inicializácie poľa, môžete vyššie uvedený príkaz napísať nasledovne.
<source>
char slovo[5] = "Ahoj";
</source>

Prezentácia pamäte vyššie definovaného reťazca v C.
{|class="wikitable" style="text-align: center;
|-
| Index || 0 || 1 || 2 || 3 || 4
|-
| Premenná || A || h || o || j || \0
|-
|}

V skutočnosti neukladáte nulový znak na koniec reťazcovej konštanty. Keď inicializuje pole, kompilátor C ho automaticky umiestni '\ 0' na koniec reťazca. Pokúsme sa vypísať vyššie uvedený reťazec.
<source lang="c" line>
#include <stdio.h>

int main () {

char slovo[5] = {'A', 'h', 'o', 'j','\0'};
/*poprípade môžme pole inicializovať takto:
char slovo[5] = "Ahoj";
*/

printf("Vypisane slovo: %s\n", slovo);
return 0;
}
</source>
Vystup.
<source>
Vypisane slovo: Ahoj
</source>

C podporuje širokú škálu funkcií, ktoré manipulujú s reťazcami ukončenými nulovou hodnotou.
{|class="wikitable" style="text-align: center;
|-
! !! Funkcia !! Účel
|-
| 1 || [[Strcpy (jazyk C)|strcpy (s1);]] || Skopíruje reťazec s2 do reťazca s1.
|-
| 2 || [[Strcat(jazyk C)|strcat (s1);]] || Pripojí reťazec s2 na koniec reťazca s1.
|-
| 3 || [[Strlen (jazyk C)|strlen (s1);]] || Vráti dĺžku reťazca s1.
|-
| 4 || [[Strcmp (jazyk C)|strcmp (s1);]] || Vráti 0, ak sú s1 a s2 rovnaké; menej ako 0, ak s1 <s2; väčšie ako 0, ak s1> s2.
|-
| 5 || [[Strchr (jazyk C)|strchr (s1);]] || Vracia ukazovateľ na prvý výskyt znaku ch v reťazci s1.
|-
| 6 || [[Strstr (jazyk C)|strstr (s1);]] || Vráti ukazovateľ na prvý výskyt reťazca s2 v reťazci s1.
|-
|}

Nasledujúci príklad používa niektoré z vyššie uvedených funkcií.
<source lang="c" line>
#include <stdio.h>
#include <string.h>
int main () {

char retazec1[12] = "Ahoj";
char retazec2[12] = "svet";
char retazec3[12];
int dlzka;

/* Skopírovanie reťazca 1 do reťazca 3 */
strcpy(retazec3, retazec1);
printf("strcpy( retazec3, retazec1) : %s\n", retazec3);

/* "Prilepenie" retazec2 za retazec1*/
strcat( retazec1, retazec2);
printf("strcat( retazec1, retazec2): %s\n", retazec1);

/* Celková dlážka reťazca 1 po pripojení reťazca 2*/
len = strlen(retazec1);
printf("strlen(retazec1): %d\n", dlzka);

return 0;
}
</source>
Vystup.
<source>
strcpy( retazec3, retazec1): Hello
strcat(retazec1, retazec2): HelloWorld
strlen(retazec1): 10
</source>

Jazyk C - cykly

2020-05-26T13:33:41Z

Matej.F: /* Cykly */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
==Cykly==

'''Cykly''' v programovaní sa začnú používať, keď potrebujeme opakovane vykonávať blok príkazov. Napríklad: Predpokladajme, že chceme vytlačiť „Hello World“ 10-krát. Toto sa dá urobiť dvoma spôsobmi, ako je uvedené nižšie:

Spôsob, ako to urobiť, je napísať [[Printf (jazyk C)|printf]]() 10-krát.

<source lang="c" line>
#include <stdio.h>

int main()
{
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");

return 0;
}
</source>

V cykle musí byť príkaz napísaný iba raz a cyklus bude vykonaný 10-krát, ako je uvedené nižšie.
V počítačovom programovaní je cyklus postupnosť inštrukcií, ktorá sa opakuje, až kým sa nedosiahne určitá podmienka.

Existujú hlavne dva typy cyklov:

;Cyklus s podmienkou na začiatku: V tomto type cyklov sa testovacie podmienky testujú pred vstupom do cyklu. For cyklus a While cyklus sú vstupom riadené cykly.

;Cyklus s podmienkou na konci: V tomto type cyklov sa testovacie podmienky testujú alebo hodnotia na konci tela cyklu. Preto sa bude cyklus vykonávať aspoň raz, bez ohľadu na to, či je testovacia podmienka pravdivá alebo nepravdivá. do - while cyklus je s podmienkou na konci.

==For cyklus==
;Cyklus For: Sa používa na opakované vykonávanie bloku príkazov, kým sa daná podmienka vráti pravdivo. Cyklus nám umožňuje vykonať n počet krokov spolu na jednom riadku.

'''Cyklus for sa skláda z 3 častí'''
*Inicializačná premenná: V tomto výraze musíme inicializovať počítadlo slučky na nejakú hodnotu. napríklad: int i = 1;
*Testovací výraz: V tomto výraze musíme testovať stav. Ak sa stav vyhodnotí ako true, vykonáme telo slučky a prejdeme na aktualizáciu výrazu, inak opustíme slučku for. Napríklad: i <= 10;
*Aktualizácia výrazu: Po vykonaní tela slučky tento výraz zvyšuje alebo zmenšuje premennú slučky o nejakú hodnotu. napríklad: i ++;
'''Vývojový diagram pre cyklus For'''

[[Súbor:For cyklus.png|240px|none]]

'''Syntax'''

<source lang="c">
for (inicializátor; podmienka; inkrement)
{
// telo cyklu
}
</source>

''Hello World skrz cyklus for''
<source lang="c" line>
#include <stdio.h>

int main()
{
int i=0;

for (i = 1; i <= 10; i++)
{
printf( "Hello World\n");
}

return 0;
}
</source>

''Výstup:''
<source lang="c" >
10x Hello World
</source>

''Príklad vypíš čísla od 1 po 10:''
<source lang="c" line>

// Napíš čísla od 1 po 10
#include <stdio.h>

int main() {

for (int i = 1; i < 11; ++i)
{
printf("%d ", i);
}
return 0;
}
</source>
''Výstup:''
<source lang="c" >
1
2
3
4
5
6
7
8
9
10
</source>

V cykle for sa na riadenie cyklu používa premenná (v našom prípade i). Najprv inicializujte túto premennú cyklu na nejakú hodnotu, potom skontrolujte, či je táto premenná menšia alebo väčšia ako hodnota počítadla. Ak je príkaz pravdivý, vykoná sa telo cyklu a aktualizuje sa premenná. Kroky sa opakujú, až kým nedôjde k výstupu.

==Cyklus While==
Pri štúdiu cyklu for sme vedeli, že počet iterácií je známy vopred, t. j. Koľkokrát sa vykoná telo cyklu, zatiaľ čo while cyklus sa používa v situáciách, keď vopred nevieme presný počet iterácií slučky. Vykonanie slučky je ukončené na základe testovacích podmienok.

'''Syntax'''

'''Cyklus while''' pozostáva z inicializačného výrazu.

<source lang="c" >
inicializačná premenná;
while (testovací_výraz)
{
// tvrdenie

aktualizácia_výrazu;
}
</source>

'''Vlasnosti cyklu while:'''
*Na kontrolu stavu sa používa podmienený výraz. Príkazy definované vo vnútri cyklu while sa budú opakovane vykonávať až do zlyhania danej podmienky.
*Podmienka bude splnená, ak sa vráti 0. Podmienka bude neplatná, ak vráti akékoľvek nenulové číslo.
*V slučke while je podmienený výraz povinný.
*Je možné spustiť cyklus bez tela.
*V cykle while môžeme mať viac ako jeden podmienený výraz.
*Ak telo cyklu obsahuje iba jeden príkaz, sú zátvorky voliteľné.<ref>https://www.javatpoint.com/while-loop-in-c</ref>

'''Vývojový diagram:'''
[[Súbor:While (1).png|360px|none]]
'''Príklady v jazyku c'''

<source lang="c" line>
// C program ktorý ilustruje while cyklus
#include <stdio.h>

int main()
{
// inicializačný výraz
int i = 1;

// testovycí výraz
while (i < 6)
{
printf( "Hello World\n");

// aktualizovaný výraz
i++;
}

return 0;
}
</source>

''Výstup''
<source lang="c">
Hello World
Hello World
Hello World
Hello World
Hello World
</source>

''Vypíš čísla od 1 do 10''
<source lang="c" line>
#include<stdio.h>
int main(){
int i=1;
while(i<=10){
printf("%d \n",i);
i++;
}
return 0;
}
</source>

''Výstup''
<source lang="c" >
1
2
3
4
5
6
7
8
9
10
</source>

==Cyklus Do while==

Na rozdiel cyklov for a while ktoré testujú stav cyklu na začiatku, cyklus do while v programovaní v C testujú stav cyklu na konci. To znamená že ukončenie cyklu je podmienené na základe ukončovacích podmienok.
Cyklus do while je podobný ako cyklus while s výnimkou že cyklus do while sa vykoná aspoň raz.<ref>https://www.tutorialspoint.com/cprogramming/c_do_while_loop.htm</ref>

'''Syntax'''
<source lang="c" >
inicializačný výraz;
do
{
// výrok

aktualizovaný výraz;
} while (testovací_výraz);
</source>
'''Poznámka:''' Na konci cyklu while je bodkočiarka.

'''Vývojový diagram:'''
[[Súbor:DoWhile.png|300px|none]]

Všimnite si, že podmienený výraz sa objaví na konci cyklu, takže výrok v slučke sa vykoná raz pred testovaním podmienky.

Ak je podmienka splnená, tok kontroly vyskočí späť a príkaz sa v slučke znova vykoná. Tento proces sa opakuje, kým sa daná podmienka nestane nepravdivou.

'''Príklady v jazyku C'''
<source lang="c" line>
// C program na ilustráciu do while cyklu
#include <stdio.h>

int main()
{
int i = 2; // inicializačný výraz

do
{
// telo cyklu
printf( "Hello World\n");

// aktualizovaný_výraz
i++;

} while (i < 1); // testovací_výraz

return 0;
}
</source>

''Výstup''
<source lang="c" >
Hello world
</source>

Vo vyššie uvedenom programe sa testovacia podmienka (i <1) vyhodnotí ako nepravdivá. Ale aj keď je slučka ukončená - telo slučky sa vykoná raz.

''Výpis čísel od 1 po 10''
<source lang="c" line>
#include<stdio.h>
int main(){
int i=1;
do{
printf("%d \n",i);
i++;
}while(i<=10);
return 0;
}
</source>

''Výstup''
<source lang="c" >
1
2
3
4
5
6
7
8
9
10
</source>

''Program tabuľky pre dané číslo pomocou cyklu do while''
<source lang="c" line>
#include<stdio.h>
int main(){
int i=1,cislo=0;
printf("Vloz cislo: ");
scanf("%d",&cislo);
do{
printf("%d \n",(cislo*i));
i++;
}while(i<=10);
return 0;
}
</source>

''Výstup''
<source lang="c" >
Vloz cislo: 5
5
10
15
20
25
30
35
40
45
50
</source>

==Nekonečný cyklus==
Nekonečný cyklus je časť programovania, ktorá nemá funkčný výstup, takže sa opakuje donekonečna. Nekonečný cyklus nastane, keď sa stav vždy vyhodnocuje ako pravdivý. Zvyčajne sa jedná o chybu.

Cyklus do-while bude prebiehať donekonečna,keď ako podmienený výraz odovzdáme ľubovoľnú nenulovú hodnotu.
<source lang="c" >
do{
//výraz
}while(1);
</source>

<source lang="c" line>
// Program C na demonštráciu nekonečných cyklov pomocou for a while

#include <stdio.h>

int main ()
{
int i;

// Toto je podmienka pre nekonený cyklus
// výraz je prázdny
for ( ; ; )
{
printf("Tento cyklus bude bežať do nekonečna.\n");
}

// Nekonečný cyklus ako podmienka
// Ak je cyklus zadaný,opakuje sa do nekonečna
/*
while (i != 0)
{
i-- ;
printf( "Tento cyklus bude bežať do nekonečna.\n");
}
*/

// Nekonečný cyklus ako podmienka
// while cyklus je "true"
/*
while (true)
{
printf( "Tento cyklus bude bežať do nekonečna.\n");
}
*/
}
</source>

<source lang="c">
''Výstup''
Tento cyklus bude bežať do nekonečna.
Tento cyklus bude bežať do nekonečna.
Tento cyklus bude bežať do nekonečna.
..........
..........
Tento cyklus bude bežať do nekonečna.
</source>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:27:14Z

Matej.F: /* Integer */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel.
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|}

<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|}

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|}

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funkcie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10; //lokálna premenná (tiež automatická)
auto int y=20; //automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10; //externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:26:53Z

Matej.F: /* Float */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel.
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|}

<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|}

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funkcie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10; //lokálna premenná (tiež automatická)
auto int y=20; //automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10; //externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:26:15Z

Matej.F: /* Vonkajšia premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel.
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|}

<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funkcie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10; //lokálna premenná (tiež automatická)
auto int y=20; //automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10; //externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:26:05Z

Matej.F: /* Automatická premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel.
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|}

<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funkcie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10; //lokálna premenná (tiež automatická)
auto int y=20; //automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:25:46Z

Matej.F: /* Statická premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel.
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
</source>

<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funkcie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:24:58Z

Matej.F: /* Globálna premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20; //globalná premenná
void function1(){
int x=10; //lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:24:43Z

Matej.F: /* Lokálna premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10; //lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20;//globalná premenná
void function1(){
int x=10;//lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:24:31Z

Matej.F: /* Globálna premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10;//lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20;//globalná premenná
void function1(){
int x=10;//lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:24:13Z

Matej.F: /* Lokálna premenná */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(263) do (263)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10;//lokálna premenná
}</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20;//globalná premenná
void function1(){
int x=10;//lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:23:29Z

Matej.F: /* Char */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(2^63) do (2^63)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10-38 do 3.4 x 1038
|-
|double
|8 byte
|od 2.3 x 10-308 do 1.8 x 10308
|-
|long double
|12 byte
|od 3.4 x 10-4932 do 1.1 x 104932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || '''SPACE''' || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10;//lokálna premenná
} ;</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20;//globalná premenná
void function1(){
int x=10;//lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:19:18Z

Matej.F: /* Základné dátové typy */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Dátove Typy==
Typy údajov v jazyku C označujú rozsiahly systém, ich typ premenných sa určuje pri deklaracií a následne sa nedá meniť. Typ premennej určuje, koľko miesta zaberá v úložisku a ako sa interpretuje uložený bitový vzor.

===Základné dátové typy===
<ref>https://www.geeksforgeeks.org/data-types-in-c/</ref>
{| class="wikitable" style="text-align: center;
!Dátovy typ
!Pamäť
!Velkosť
|-
|char
|1 byte
|od -128 do 127 alebo od 0 do 255
|-
|unsigned char
|1 byte
|od -127 do 128
|-
|signed char
|1 byte
|od 0 do 255
|-
|short int
|2 byte
|od -32 768 do 32 767
|-
|unsigned short int
|2 byte
|od 0 do 62535
|-
|unsigned int
|4 byte
|od 0 do 4 294 967 295
|-
|int
|4 byte
|od -2 147 483 648
do 2 147 483 647
|-
|long int
|4 byte
|od -2 147 483 648
do 2 147 483 64
|-
|unsigned long int
|4 byte
|od 0 po 4 294 967 295
|-
|long long int
|8 byte
|od -(2^63) do (2^63)-1
|-
|unsigned long long int
|8 byte
|od 0 do 18,446,744,073,709,551,615
|-
|float
|4 byte
|od 1.12 x 10^-38 do 3.4 x 10^38
|-
|double
|8 byte
|od 2.3 x 10^-308 do 1.8 x 10^308
|-
|long double
|12 byte
|od 3.4 x 10^-4932 do 1.1 x 10^4932
|-
|}

====Integer====
'''Integer''' je označenie celočíselného dátoveho typu, ktorý predstavuje konečnú podmnožinu celých čísel
<source lang="c" line>
#include <stdio.h>

//súčet 3 čísel
int main()
{
int a,b,c,sucet;
scanf("%d %d %d",a,b,c);
sucet=a+b+c;
printf("%d",sucet);

return 0;
}
</source>

====Char====
'''Char'''(znak) je základný typ údajov v C. Ukladá jeden znak a vyžaduje jediný bajt pamäte takmer vo všetkých kompilátoroch.
Aby počítač mohol reprezentovať znaky, musí mapovať každé celé číslo zodpovedajúcim znakom pomocou číselného kódu. Najbežnejším číselným kódom je ASCII, čo znamená americký štandardný kód pre výmenu informácií. Nasledujúca tabuľka ilustruje kód ASCII:

'''ASCII Tabuľka'''
Hodnoty a význam znakov ASCII(American Standard Code for Information Interchange) tabuľky od 32 po 127
{| class="wikitable" style="text-align: center;
! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !! Kód !! Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak !!Kód !!Znak
|-
| 32 || SPACE || 44 || , || 56 || 8 || 68 || D || 80 || P || 92 || \ || 104 || h || 116 || t
|-
| 33 || ! || 45 || - || 57 || 9 || 69 || E || 81 || Q || 93 || ] || 105 || i || 117 || u
|-
| 34 || " || 46 || . || 58 || : || 70 || F || 82 || R || 94 || ^ || 106 || j || 118 || v
|-
| 35 || # || 47 || / || 59 || ; || 71 || G || 83 || S || 95 || _ || 107 || k || 119 || w
|-
| 36 || $ || 48 || 0 || 60 || < || 72 || H || 84 || T || 96 || ` || 108 || l || 120 || x
|-
| 37 || % || 49 || 1 || 61 || = || 73 || I || 85 || U || 97 || a || 109 || m || 121 || y
|-
| 38 || & || 50 || 2 || 62 || > || 74 || J || 86 || V || 98 || b || 110 || n || 122 || z
|-
| 39 || ´ || 51 || 3 || 63 || ? || 75 || K || 87 || W || 99 || c || 111 || o || 123 || {
|-
| 40 || ( || 52 || 4 || 64 || @ || 76 || L || 88 || X || 100 || d|| 112 || p || 124 || |
|-
| 41 || ) || 53 || 5 || 65 || A || 77 || M || 89 || Y || 101 || e|| 113 || q || 125 || }
|-
| 42 || * || 54 || 6 || 66 || B || 78 || N || 90 || Z || 102 || f|| 114 || r || 126 || ~
|-
| 43 || + || 55 || 7 || 67 || C || 79 || O || 91 || [ || 103 || g|| 115 || s || 127 || '''DEL'''
|}

'''Zobrazenie char v jazyku C'''

Ak chcete vypísať znaky v jazyku C, použite funkciu printf () s%.
Nasledujúci príklad ukazuje, ako zobraziť celočíselnú reprezentáciu znaku v C podla ASCII tabulky<ref>https://www.zentut.com/c-tutorial/c-character-type/</ref>

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main()
{
char ch = 'A';
printf("ch = %c\n",ch);
printf("ch = %d, prevod na integer\n",ch);

return 0;
}
</source>

====Float====
'''Float''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 7 desatinných miest. Podľa definície je to základný dátový typ zabudovaný do kompilátora, ktorý sa používa na definovanie číselných hodnôt s desatinnými desatinnými miestami. C, C ++, C # a mnoho ďalších programovacích jazykov rozpoznáva float ako typ údajov.

<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

//Príklad na podiel 2 čísel
int main()
{
//Podiel 2 čísel
int a,b;
float podiel;
printf("vloz cislo 1:");
scanf("%d",&a); //vložíme číslo 15
printf("vloz cislo 2:");
scanf("%d",&b); //vložíme číslo 2
podiel=a/b;
printf("podiel je:%f",podiel); //konzola vypíše 7,5
return 0;
}
</source>

====Double====
'''Double''' sa používa na ukladanie desatinných čísel (čísla s hodnotou s desatinnou čiarkou) s presnosťou na 15 desatinných miest.

==Premenné==

'''Premenná''' je názov oblasti úložiska, s ktorou môžu naše programy manipulovať. Každá premenná v jazyku C má špecifický typ, ktorý určuje veľkosť a rozloženie pamäte premennej; rozsah hodnôt, ktoré môžu byť uložené v tejto pamäti; a súbor operácií, ktoré možno použiť na premennú.

===Deklarácia premenných===

Pravidlá pre deklarovanie premenných v jazyku C
*Názov premennej musí začínať písmenom alebo znakom podčiarknutia.
*U premenných sa rozlišujú malé a veľké písmená
*Môžu byť obsahovať číslice a písmená.
*Okrem podčiarknutia nie sú povolené žiadne špeciálne symboly.
*Premenné by sa mali pred použitím deklarovať v programe C.
*Pamäťový priestor nie je pri deklarovaní pridelený premennej. Stáva sa to iba pri definícii premennej.

<big>Deklarácia a inicializácia premenných v jazyku C</big>

Obecný tvar deklarácie premennej v C:
<source lang="c">
popis typu deklarované objekty [=počiatočné hodnoty]

int a=1;
char o='p';
double g,j,h;
float e=2.4e+2, f=2.2154;
</source>
<ref>https://fresh2refresh.com/c-programming/c-variables/</ref>

====Definícia vs Deklarácia====

{| class="wikitable"
|-
! Definica !! Deklarácia
|-
| Definícia alokuje pamäť pre premennú. || Deklarácia hovorí kompilátoru o dátovom type a veľkosti premennej.
|-
| Môže sa to stať iba raz pre premennú v programe. || Premennú je možné v programe mnohokrát deklarovať
|-
| Priradenie úložného priestoru k premennej. || Priradenie vlastností a identifikácia premennej.
|}

Názov premennej môže pozostávať z písmen, číslic a znaku podčiarknutia. Musí začínať písmenom alebo znakom podčiarknutia. Veľké a malé písmená sú zreteľné, pretože v jazyku C sa rozlišujú malé a veľké písmená. Na základe základných typov vysvetlených v predchádzajúcej kapitole budú nasledovať tieto základné typy premenných

===Typy premenných v jazyku C===
*Lokálne premenné
*Globálne premenné
*Statické premenné
*Automatické premenné
*Vonkajšie premenné

====Lokálna premenná====

Premenná, ktorá je deklarovaná vo funkcii alebo bloku, sa nazýva lokálna premenná.

Musí sa uviesť na začiatku bloku.

<source lang="c">void function1()
{
int x=10;//lokálna premenná
} ;</source>

====Globálna premenná====
Premenná, ktorá je deklarovaná mimo funkcie alebo blok, sa nazýva globálna premenná. Akákoľvek funkcia môže zmeniť hodnotu globálnej premennej. Je k dispozícii pre všetky funkcie.

Musí sa uviesť na začiatku bloku.
<source lang="c">
int value=20;//globalná premenná
void function1(){
int x=10;//lokálna premenná
}
</source>

====Statická premenná====
Statické premenné majú tú vlastnosť, že si zachovajú svoju hodnotu aj po tom, ako sú mimo ich rozsah. Preto si statické premenné zachovávajú svoju predchádzajúcu hodnotu v ich predchádzajúcom rozsahu a nie sú znovu inicializované v novom.

<source lang="c">
static data_type var_name = var_value;
</source>

Počas chodu programu zostáva statická premenná int v pamäti. Automatická premenná zanikne keď sa skončí volanie funkcie kde bola deklarovaná.

Napríklad statickú premennú int môžeme použiť na spočítanie koľko krát bola funkcia volaná, v tomto prípade by sme nemohli použiť automatickú premennú.
Tento program vypíše "1 2"

<source lang="c">
#include<stdio.h>
int fun()
{
static int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); // vypíše 1
printf("%d ", fun()); // vypíše 2
return 0;
}
</source>

Nasledujúci program vypíše "1 1"
<source lang="c">
#include<stdio.h>
int fun()
{
int count = 0;
count++;
return count;
}

int main()
{
printf("%d ", fun()); //vypíše 1
printf("%d ", fun()); //vypíše 1
return 0;
}
</source>

*Statické premenné sú alokované pamäte v segmente údajov, nie v segmente zásobníkov.
*Statické premenné sú inicializované ako 0, ak nie sú inicializované explicitne.
*V C môžu byť statické premenné inicializované iba pomocou konštanty.
*Statické globálne premenné a funkcie je tiež možné vytvoriť v C/C++. Ich účelom je obmedziť rozsah premennej alebo funckie.
*Statické premenné by sa nemali deklarovať vo vnútri štruktúry. Dôvodom je, že kompilátor C vyžaduje, aby boli všetky prvky štruktúry umiestnené spolu.

====Automatická premenná====

Toto je predvolená trieda úložiska pre všetky premenné deklarované vo funkcii alebo bloku. Pri písaní programov v jazyku C sa preto kľúčové slovo auto používa zriedka. K automatickým premenným sa dá pristupovať iba v rámci bloku / funkcie, ktoré boli deklarované, a nie mimo nich. Prístup k nim je samozrejme možný vo vnútri vnorených blokov funkcie, v ktorej bola deklarovaná automatická premenná.

<source lang="c">
void main(){
int x=10;//lokálna premenná (tiež automatická)
auto int y=20;//automatická premenná
}
</source>

====Vonkajšia premenná====
Môžeme zdieľať premennú vo viacerých zdrojových súboroch C pomocou externej premennej. Ak chcete deklarovať externú premennú, musíte použiť externé kľúčové slovo.

''mojsubor.h''

<source lang="c">
extern int x=10;//externá premenná (tiež globálna)
</source>

''program1.c''
<source lang="c">
#include "mojsubor.h"
#include <stdio.h>
void printValue(){
printf("Global variable: %d", global_variable);
}
</source><ref>https://www.javatpoint.com/variables-in-c</ref>

==Referencie==

Jazyk C - príkazy preprocesora

2020-05-26T07:54:48Z

Matej.F: /* Podmienený preklad */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}

==Príkazy preprocesora <ref> http://people.tuke.sk/igor.podlubny/C/Kap2.htm#vkladanie </ref>==
Príkazy preprocesora umožňujú vkladanie a skladanie textu z rôznych súborov, podmienený preklad a definíciu symbolických konštánt a makier.
Každý príkaz pre preprocesor sa začína znakom #, za ktorým nasleduje príkaz a jeho parametre.

V nasledujúcej časti sú vymenované všetky dôležité makrá.

{|class="wikitable" style="text-align: center;
|-
! !! Makro !! Popis
|-
| 1 || #define || Definuje makro procesora.
|-
| 2 || #include || Vloží konkrétnu hlavičku z iného súboru.
|-
| 3 || #undef || Zruší definiciu makra predprocesora.
|-
| 4 || #ifdef || Vráti true, ak je toto makro definované.
|-
| 5 || #ifndef || Vráti true, ak toto makro nie je definované.
|-
| 6 || #if || Testuje, či je splnená podmienka.
|-
| 7 || #else || Vykoná sa ak neplatí podmienka if.
|-
| 8 || #elif || Vykoná sa ak neplatí podmienka if a zároveň obsahuje ďalšiu podmienku.
|-
| 9 || #endif || Ukončí podmieneneneho spracovania (použiva sa len s if ).
|-
| 10 || #error || Vypíše chybové hlásenie na stderr.
|-
| 11 || #pragma || Vydáva špeciálne príkazy kompilátoru pomocou štandardizovanej metódy.
|-

|}

==Definícia symbolických konštánt a makier <ref>https://www.tutorialspoint.com/cprogramming/c_preprocessors.htm</ref>==
Príkaz na definíciu symbolických konštánt má tvar:
<source lang="c">
#define NAME konštantný_výraz
</source>
Kde NAME je názov symbolickej konštanty a konštantný_výraz je hodnota, ktorú symbolická konštanta nadobúda.
Príklad symbolickej konštanty:

<source lang="c">
#define MAX 100
#define LINE 80
#define PI 3.14
#define NAME1 Pavel
#define NAME2 "Peter"
</source>

Prvé tri sú číselné symbolické konštanty. MAX nadobudne hodnotu 100, LINE hodnotu 80, PI 3,14. NAME1 je znaková konštanta s hodnotou Pavel (všade namiesto NAME1 sa dosadí Pavel), NAME2 je reťazec "Peter".
Symbolické konštanty sa používajú napríklad na definovanie polí z konštantnou veľkostnou napr:

<source lang="c">
#define M 10
#define N 5
...
int a[M];
float b[N], c[M][N];
char d[M+1];
</source>

==Vkladanie textu==
Príkaz na vkladanie textu #include [meno súboru] spôsobí vloženie obsahu súboru "meno súboru" pred prekladom do zdrojového súboru, v ktorom sa vyššie uvedený príkaz nachádza.
To umožňuje vkladanie tak systémových súborov (tzv. hlavičkových súborov, s príponou .h, napr. <stdio.h>), ako aj vlastných užívateľských súborov, čo predstavuje jednu z možností modulárnej výstavby programu.Príkaz na vloženie môže mať dva tvary (v prvom prípade je názov súboru uvedený v lomených zátvorkách, v druhom prípade v dvojitých úvodzovkách):

<source lang="c">
#include <file.h>
#include "path_file"
</source>

Prvý tvar sa používa pre vkladanie systémových súborov, ktoré sú uložené v príslušnom systémovom podadresári (INCLUDE).Všetky štandardné funkcie, konštanty a makrá v jazyku C sú deklasované v takýchto súboroch. Pri popise danej funkcie je vždy uvedená adresár v ktorom sa daná funkcia nachádza. Vloženie daného súboru umožňuje kompilátoru kontrolu správnosti volania štandardnej funkcie.
Druhý tvar sa používa pre vkladanie užívateľských súborov, pričom sa prehľadáva aktuálny adresár, resp. adresár, uvedený v špecifikácii vkladaného súboru.

==Podmienený preklad==
Príkazy pre podmienený preklad majú tvar:
<source lang="c">
#undef FILE_SIZE
#define FILE_SIZE 42
</source>
Tieto príkazy povedia preprocesoru aby nedefinoval existujúci FILE_SIZE a definuj ho ako FILE_SIZE s hodnotou 42.

<source lang="c">
#ifndef SPRAVA
#define SPRAVA "Čo potrebuješ?"
#endif
</source>
Povie CPP, aby definoval SPRAVA , iba ak SPRAVA ešte nie je definovaná.
Každý z príkazov #if, #ifdef, resp. #ifndef musí byť ukončený príkazom #endif.

==Preddefinované makrá==
ANSI C definuje niekoľko makier. Aj keď je každé z nich k dispozícii na použitie v programovaní, preddefinované makrá by sa nemali priamo upravovať.

{|class="wikitable" style="text-align: center;
|-
! !! Makro !! popis
|-
| 1 || __DÁTUM__ || Aktuálny dátum ako znakový literál vo formáte „MMM DD RRRR“.
|-
| 2 || __TIME__ || Aktuálny čas ako znakový literál vo formáte „HH: MM: SS“.
|-
| 3 || __FILE__ || Toto obsahuje aktuálny názov súboru ako reťazcový literál.
|-
| 4 || __LINE__ || Toto obsahuje aktuálne číslo riadku ako desatinnú konštantu.
|-
| 5 || __STDC__ || Definovaný ako 1, keď kompilátor vyhovuje štandardu ANSI.
|-
|}
Vyskúšajte nasledujúci príklad -
<source lang="c">
#include <stdio.h>

int main() {

printf("File :%s\n", __FILE__ );
printf("Date :%s\n", __DATE__ );
printf("Time :%s\n", __TIME__ );
printf("Line :%d\n", __LINE__ );
printf("ANSI :%d\n", __STDC__ );

}
</source>
Po skompilovaní a spustení vyššie uvedeného kódu v súbore test.c sa získa nasledujúci výsledok -
File :test.c
Date :Jun 2 2012
Time :03:36:24
Line :8
ANSI :1
==Parametrizované makrá==
Na výpočet obsahu štvorca môžeme použiť napr. nasledovnú funkciu:
<source lang="c">
int štvorec(int x) {
return x * x;
}
</source>
Táto funkcia nám načíta rozmer štvorca x a vráti nám jeho obsah. Avšak túto funkciu môžme nahradiť nasledovným makrom:
<source lang="c">
#define štvorec(x) (x*x)

</source>

Definícia makra spočíva v pridaní jedného či viacerých parametrov k názvu symbolickej konštanty (symbolickú konštantu je možné pokladať za makro bez parametrov) a doplnení výrazu pre jeho výpočet napr:

<source lang="c">
#define KOCKA(a) (a*a*a)
#define VALEC(v,p) (PI*p*p*v)
#define GULA(r) (4*PI/3*r*r*r)
</source>

Uvedené makrá slúžia pre výpočet objemu príslušných geometrických telies. Identifikátory v hlavičke makra a, v, p, r predstavujú formálne parametre, ktoré sú pri vyvolaní makra textovo nahradené skutočnými. Počet formálnych a skutočných parametrov musí byť rovnaký. Poradie vykonávania jednotlivých operácií v rámci makra možno riadiť zátvorkami.

==Referencie==

Strncat (jazyk C)

2020-05-19T21:28:16Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strcat==
<properties>
knižnica=string.h
popis=Pripoji retazec na koniec 2 retazca.
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strcat.htm</ref>:
<source lang="c">
char *strncat(char *dest, const char *src, size_t n)
</source>

==Podrobný popis funkcie==
Funkcia pripojí reťazec z dĺžkou n znakov na ktorý odkazuje src, na koniec reťazca.

==Parametre==
;dest: Toto je ukazovateľ na cieľové pole ktoré by malo obsahovať reťazec C a mal by byť dostatočne veľký na to, aby obsahoval zreťazený výsledný reťazec.

;src: Toto je reťazec, ktorý sa má pripojiť.
;n: Toto je maximálny počet znakov, ktoré sa majú pripojiť.

==Návratová hodnota==
Táto funkcia vráti ukazovateľ na výsledný cieľový reťazec.

==Príklad==
<source lang="c">
#include <stdio.h>
#include <string.h>

int main () {
char src[50], dest[50];

strcpy(src, "Toto je zdroj");
strcpy(dest, "Toto je ciel");

strncat(dest, src, 13);

printf("Finálny retazec : |%s|", dest);
return(0);
}
</source>

''Výstup:''
Finálny retazec: |Toto je cielToto je zdroj|

==Referencie==

Strcat (jazyk C)

2020-05-19T21:28:01Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strcat==
<properties>
knižnica=string.h
popis=Pripoji retazec na koniec 2 retazca.
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strcat.htm</ref>:
<source lang="c">
char *strcat(char *dest, const char *src);
</source>

==Podrobný popis funkcie==
Funkcia pripojí reťazec na ktorý odkazuje src na koniec reťazca, na ktorý odkazuje dest.

==Parametre==
;dest: Toto je ukazovateľ na cieľové pole, ktoré by malo obsahovať reťazec C a mal by byť dostatočne veľký na to, aby obsahoval zreťazený výsledný reťazec.

;src: Toto je reťazec, ktorý sa má pripojiť.

==Návratová hodnota==
Táto funkcia vráti ukazovateľ na výsledný cieľový reťazec.

==Príklad==
<source lang="c">
#include <stdio.h>
#include <string.h>

int main () {
char src[50], dest[50];

strcpy(src, "Toto je zdroj");
strcpy(dest, "Toto je ciel");

strcat(dest, src);

printf("Finálny retazec : |%s|", dest);
return(0);
}
</source>

''Výstup:''
Finálny retazec: |Toto je cielToto je zdroj|

==Referencie==

Strstr (jazyk C)

2020-05-19T21:27:47Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strstr==
<properties>
knižnica=string.h
popis=Nájde prvý výskyt podreťazca v retazci
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strstr.htm</ref>:
<source lang="c">
char *strstr(const char *haystack, const char *needle)
</source>

==Podrobný popis funkcie==
Funkcia nájde prvý výskyt podreťazca v retazci. Ukončovacie znaky '\0' sa neporovnávajú.

==Parametre==
;haystack: Toto je hlavný reťazec C, ktorý sa má skenovať.

;needle: Toto je reťazec, ktorý sa má hľadá v reťazci haystack.

==Návratová hodnota==
Táto funkcia vracia ukazovateľ k prvého výskytu v hlavnom retazci akejkoľvek z celej postupnosti znakov zadaných v podretazci alebo nulový ukazovateľ, ak sa sekvencia v retazci nenachádza.
Vráti sa ukazovateľ na cieľový reťazec dest.

==Príklad==
<source lang="c">
#include <stdio.h>
#include <string.h>

int main () {
const char retazec[20] = "Kiwiki";
const char podretazec[10] = "wiki";
char *ret;

ret = strstr(haystack, needle);

printf("Podretazec je: %s\n", ret);

return(0);
}
</source>

''Výstup:''
Podretazec je: wiki

==Referencie==

Strcpy (jazyk C)

2020-05-19T21:27:33Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strcpy==
<properties>
knižnica=string.h
popis= Skopíruje reťazec do iného reťazca.
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strcpy.htm</ref>:
<source lang="c">
char *strcpy(char *dest, const char *src)
</source>

==Podrobný popis funkcie==
Funkcia skopíruje reťazec, na ktorý odkazuje, zo src do dest .

==Parametre==
;dest: Toto je ukazovateľ na cieľové pole, do ktorého sa má obsah skopírovať.

;src: Toto je reťazec, ktorý sa má skopírovať.

==Návratová hodnota==

Vráti sa ukazovateľ na cieľový reťazec dest

==Príklad==
<source lang="c">
#include <stdio.h>
#include <string.h>

int main () {
char src[40];
char dest[100];

memset(dest, '\0', sizeof(dest));
strcpy(src, "Toto je http://www.kiwiki.info/index.php");
strcpy(dest, src);

printf("Skopírovaný retazec: %s\n", dest);

return(0);
}
</source>
''Výstup:''
Skopírovaný retazec: Toto je http://www.kiwiki.info/index.php

==Referencie==

Strchr (jazyk C)

2020-05-19T21:27:20Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strchr==
<properties>
knižnica=string.h
popis=Hľadá prvý výskyt znaku c v reťazci
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strchr.htm</ref>:
<source lang="c">
char *strchr(const char *str, int c)
</source>

==Podrobný popis funkcie==
Funkcia hľadá prvý výskyt znaku c (nepodpísaný znak) v reťazci, na ktorý odkazuje argument str.

==Parametre==
;str: Toto je reťazec C, ktorý sa má skenovať.

;c: Toto je znak, ktorý sa má prehľadávať v str.

==Návratová hodnota==
Vráti sa ukazovateľ na prvý výskyt znaku c v reťazci str alebo NULL, ak sa znak nenájde.

==Príklad==
<source lang="c">
#include <stdio.h>
#include <string.h>

int main () {
const char str[] = "http://www.kiwiki.info/index.php";
const char ch = '.';
char *ret;

ret = strchr(str, ch);

printf("Retazec po znaku: |%c| je - |%s|\n", ch, ret);

return(0);
}
</source>
''Výstup:''
Retazec po znaku: |.| je - kiwiki.info/index.php

==Referencie==

Strcmp (jazyk C)

2020-05-19T21:26:29Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strcmp==
<properties>
knižnica=string.h
popis=Porovná dva textové reťazce.
</properties>

Úplný funkčný prototyp<ref>https://www.tutorialspoint.com/c_standard_library/c_function_strcmp.htm</ref>:
<source lang="c">
int strcmp ( const char * str1, const char * str2 );
</source>

==Podrobný popis funkcie==
Táto funkcia začne porovnávať od prvého znaku oboch reťazcov. Ak sú si navzájom rovnaké, pokračuje s nasledujúcimi pármi, až kým sa znaky nebudú líšiť alebo kým sa nedosiahne koncový nulový znak. Táto funkcia vykoná binárne porovnanie znakov.

==Parametre==
;str1: Prvý textový reťazec, ktorý budeme porovnávať s druhým textovým reťazcom.
;str2: Druhý textový reťazec.

==Návratová hodnota==
Vráti integrálnu hodnotu označujúcu vzťah medzi reťazcami:
{| class="wikitable"
! Vrátená hodnota !! Indikuje
|-
| <0 || Prvý znak, ktorý sa nezhoduje, má v ''ptr1'' nižšiu hodnotu ako v ''ptr2''.
|-
| 0 || Obsah oboch reťazcov je rovnaký.
|-
| >0 || Prvý znak, ktorý sa nezhoduje, má v ''ptr1'' väčšiu hodnotu ako v ''ptr2''.
|}

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <string.h>

int main ()
{
char kluc[] = "jablko";
char buffer[80];
do {
printf ("Uhadnes moje oblubene jedlo? ");
fflush (stdout); //vymaže výstup
scanf ("%79s",buffer); //načíta textový reťazec s maximálnou dĺžkou 79 znakov
} while (strcmp (kluc,buffer) != 0); //Porovná reťazec kluc a reťazec buffer
puts ("Spravne!");
return 0;
}
</source>
''Výstup:''
Uhadnes moje oblubene ovocie? hruska
Uhadnes moje oblubene ovocie? pomaranc
Uhadnes moje oblubene ovocie? jablko
Spravne!

==Referencie==

Strlen (jazyk C)

2020-05-19T21:26:06Z

Matej.F:

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia strlen==
<properties>
knižnica=string.h
popis=Vráti dĺžku textového reťazca.
</properties>

Úplný funkčný prototyp <ref>https://www.tutorialspoint.com/c_standard_library/c_function_strlen.htm</ref>:
<source lang="c">
size_t strlen(const char *str);
</source>

==Podrobný popis funkcie==
Funkcia vráti dĺžku textového reťazca. Dĺžka je definovaná ako počet znakov,ktoré sa nachádzajú pred ukončovacím znakom.

==Parametre==
;str: Textový reťazec ktorého dĺžku chceme vedieť.

==Návratová hodnota==
Vráti dĺžku textového reťazca.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <string.h>

int main ()
{
char text[256];
printf ("Zadajte vetu: ");
gets (text);
printf ("Veta, ktoru ste zadali ma %u znakov.\n",(unsigned)strlen(text));
return 0;
}
</source>
''Výstup:''
Zadajte vetu: Padlo mydlo vedľa umývadla.
Veta, ktoru ste zadali ma 27 znakov.

==Referencie==

Cos (jazyk C)

2020-05-19T21:25:42Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia Cos==
<properties>
knižnica=math.h
popis=vracia cosínus uhla
</properties>

Úplný funkčný prototyp:
<source lang="c">
double cos(double x)
</source>

==Podrobný popis funkcie==
Funkcia cos(double x) vracia kosínus uhla x v radiánoch. Funkcia cos() vezme argument v radiánoch a vráti hodnotu typu double.
Hodnota vrátená pomocou cos() je vždy v rozsahu: -1 až 1.

==Parametre==
;x: Hodnota vyjadrená v radiánoch (nie v stupňoch).

==Návratová hodnota==
Funkcia vracia hodnotu cosínus x.<ref>https://www.tutorialspoint.com/c_standard_library/c_function_cos.htm</ref>

==Príklad==
<source lang="c">
#include <stdio.h>
#include <math.h>

#define PI 3.14159265

int main () {
double x, ret, val;

x = 60.0; //počet stupňov
val = PI / 180.0; // premena stupňov na radiány
ret = cos(x*val);
printf("Cosínus %lf stupňov je %lf\n", x, ret); //výpis výsledku

return(0);
}
</source>
''Výstup:''
<source lang="c">
Cosínus 60 stupňov je 0,5
</source>
<ref>https://www.techonthenet.com/c_language/standard_library_functions/math_h/cos.php</ref>

==Referencie==

Sin (jazyk C)

2020-05-19T21:25:29Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia Sin==
<properties>
knižnica=math.h
popis=vracia sínus uhla
</properties>

Úplný funkčný prototyp:
<source lang="c">
double sin(double x)
</source>

==Podrobný popis funkcie==
Funkcia sin(double x) vracia sínus uhla x. Uhol x je definovaný v radiánoch.

==Parametre==
;x: Hodnota vyjadrená v radiánoch(nie v stupňoch)

==Návratová hodnota==
Funkcia sin(double x) vráti sínus x.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

#define PI 3.14159265 //zadefinovanie Pí z knižnice math.h

int main () {
double x, ret, val;

x = 45.0; // počet stupňov
val = PI / 180; // prevod stupňov na radiány
ret = sin(x*val);
printf("Sínus %lf stupňov je %lf ", x, ret); // výpis výsledku

return(0);
}
</source>
''Výstup:''
<source lang="c">
Sínus 45 stupňov je 0.707107
</source>
<ref>https://www.techonthenet.com/c_language/standard_library_functions/math_h/sin.php</ref>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_sin.htm</ref>

==Referencie==

Ceil (jazyk C)

2020-05-19T21:25:13Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia ceil==
<properties>
knižnica=math.h
popis=vracia celočíselnu hodnotu
</properties>

Úplný funkčný prototyp
<source lang="c">
double ceil(double x)
</source>

==Podrobný popis funkcie==
Funkcia ceil vráti najmenšie celé číslo väčšie alebo rovné x (zaokrúhli na najbližšie celé číslo).

==Parametre==
;x: Hodnota zaokrúhlená nahor na najbližšie celé číslo

==Návratová hodnota==
Funkcia ceil vracia najmenšie celé číslo, ktoré je väčšie alebo rovné x.
<ref>https://www.techonthenet.com/c_language/standard_library_functions/math_h/ceil.php</ref>
==Príklad==
<source lang="c">
#include <stdio.h>
#include <math.h>

int main () {
float val1, val2, val3, val4;

val1 = 1.6;
val2 = 1.2;
val3 = 2.8;
val4 = 2.3;

printf ("hodnota1 = %.1lf\n", ceil(val1));
printf ("hodnota2 = %.1lf\n", ceil(val2));
printf ("hodnota3 = %.1lf\n", ceil(val3));
printf ("hodnota4 = %.1lf\n", ceil(val4));

return(0);
}
</source>

''Výstup:''
<source lang="c">
hodnota1 = 2.0
hodnota2 = 2.0
hodnota3 = 3.0
hodnota4 = 3.0
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_ceil.htm</ref>

==Referencie==

Sqrt (jazyk C)

2020-05-19T21:24:57Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia sqrt==
<properties>
knižnica=math.h
popis=Vypočíta druhú odmocninu čísla x.
</properties>

Úplný funkčný prototyp:
<source lang="c">
double sqrt ( double x );
float sqrt ( float x );
long double sqrt ( long double x );
</source>
==Parametre==
;x:číslo s reálnou hodnotou. Ak je x záporné, nastane chyba v definičnom obore (domain error) a globálna premenná ''errno'' bude mať hodnotu EODM.

==Návratová hodnota==
druhá odmocnina čísla x: <math>\sqrt{x}</math>

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main ()
{
double param, result;
param = 1024.0;
result = sqrt (param);
printf ("sqrt(%lf) = %lf\n", param, result );
return 0;
}
</source>
''Výstup:''
sqrt(1024.000000) = 32.000000

Log10(jazyk C)

2020-05-19T21:24:41Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia Log10==
<properties>
knižnica=math.h
popis=počíta desiatkový logaritmus
</properties>

Úplný funkčný prototyp:
<source lang="c">
double log10(double x);
</source>

==Podrobný popis funkcie==
Funkcia log10 vráti hodnotu dekadického logaritmu.

==Parametre==
;x: Hodnota použitá pri výpočte logaritmu x so základom 10. Ak je x záporné, funkcia log10 vráti chybu definičného oboru (domain error). Ak je x nula, funkcia log10 vráti chybu rozsahu.

==Návratová hodnota==
Funkcia log10x vracia hodnotu logaritmu.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main () {
double x, ret;
x = 10000;

/* hladanie logaritmusus pre hodnotu 10000 */
ret = log10(x);
printf("log10(%lf) = %lf\n", x, ret); //vypíše logartimus hodnoty 10000

return(0);
}
</source>
''Výstup:''
<source lang="c">
log10(10000.000000) = 4.000000
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_log10.htm</ref>

==Referencie==

Log(jazyk C)

2020-05-19T21:24:15Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia log==
<properties>
knižnica=math.h
popis=Vypočíta prirodzený logaritmus
</properties>

Úplný funkčný prototyp:
<source lang="c">
double log ( double x );
float log ( float x );
long double log ( long double x );
</source>

==Podrobný popis funkcie==
Vráti hodnotu prirodzeného logaritmu hodnoty x.

Prirodzený logaritmus je logaritmus pri základe ''e''. Je to inverzná funkcie e exponenciálnej funkcii ([[Exp(jazyk C)|exp]]). Pre výpočet dekadického logaritmu existuje funkcia log10.

==Parametre==
;x:Reálne číslo.
Ak je x záporné, nastane chyba oboru (domain error). Hodnota globálnej premennej ''errno'' sa nastaví na hodnotu EDOM.

Ak je x nula, funkcia vráti hodnotu -HUGE_VAL a nastaví hodnotu globálnej premennej ''errno'' na hodnotu ERANGE.
==Návratová hodnota==
Prirodzený logaritmus z ''x''.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main ()
{
double param, result;
param = 5.5;
result = log (param);
printf ("ln(%lf) = %lf\n", param, result );
return 0;
}
</source>
''Výstup:''
ln(5.500000) = 1.704748

Exp (jazyk C)

2020-05-19T21:24:01Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia exp==
<properties>
knižnica=math.h
popis=Vypočíta hodnotu exponenciálnej funkcie so základom ''e'' a mocniteľom ''x''. (<math>e^x</math>)
</properties>

Úplný funkčný prototyp:
<source lang="c">
double exp ( double x );
float exp ( float x );
long double exp ( long double x );
</source>
==Podrobný popis funkcie==
Vypočíta hodnotu <math>e^x</math>. Ak je výsledok mimo rozsah použitého dátového typu, funkcia vráti hodnotu HUGE_VAL a nastaví hodnotu globálnej premennej ''errno'' na hodnotu ERANGE.

==Parametre==
;x:číslo s reálnou hodnotou

==Návratová hodnota==
Hodnota <math>e^x</math>

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main ()
{
double param, result;
param = 5.0;
result = exp (param);
printf ("e ^ %lf = %lf.\n", param, result );
return 0;
}
</source>
''Výstup:''
e ^ 5.000000 = 148.413159.

Fabs (jazyk C)

2020-05-19T21:23:46Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia fabs==
<properties>
knižnica=math.h
popis=Vypočíta absolútnu hodnotu reálneho čísla
</properties>

Úplný funkčný prototyp:
<source lang="c">
double fabs ( double x );
float fabs ( float x );
long double fabs ( long double x );
</source>

==Podrobný popis funkcie==
Vypočíta absolútnu hodnotu parametra ''x''.

==Parametre==
;x:číslo s reálnou hodnotou

==Návratová hodnota==
Absolútna hodnota vstupného parametra ''x''.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main ()
{
printf ("Absolutna hodnota cisla 3.1416 je %lf\n", fabs (3.1416) );
printf ("Absolutna hodnota cisla -10.6 je %lf\n", fabs (-10.6) );
return 0;
}
</source>
''Výstup:''
Absolutna hodnota cisla 3.1416 je 3.141600
Absolutna hodnota cisla -10.6 je 10.600000

Pow (jazyk C)

2020-05-19T21:23:31Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia pow==
<properties>
knižnica=math.h
popis=Umocní číslo na daný exponent
</properties>

Úplný funkčný prototyp:
<source lang="c">
double pow ( double zaklad, double exponent );
long double pow ( long double zaklad, long double exponent );
float pow ( float zaklad, float exponent );
double pow ( double zaklad, int exponent );
long double pow ( long double zaklad, int exponent );
</source>

==Podrobný popis funkcie==
Vypočíta základ umocnený na exponent: <math>zaklad^{exponent}\,\!</math>

==Parametre==
;zaklad: reálne číslo.
;exponent: reálne číslo.
==Návratová hodnota==
Základ umocnený na exponent.

Ak je hodnota výsledku príliš veľká a nedá sa reprezentovať návratovým typom, vygeneruje sa chyba rozsahu, kedy funkcia vráti hodnotu HUGE_VAL s daným znamienkom. Hodnota globálnej premennej ''errno'' bude mať hodnotu ERANGE.

Ak je základ záporný a exponent nie je celé číslo, alebo ak je základ nulový a exponent je záporný, vygeneruje sa chyba oboru (domain error). Hodnota globálnej premennej ''errno'' sa nastaví na hodnotu EDOM.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <math.h>

int main ()
{
printf ("7 ^ 3 = %lf\n", pow (7,3));
printf ("4.73 ^ 12 = %lf\n", pow (4.73,12));
printf ("32.01 ^ 1.54 = %lf\n", pow (32.01,1.54));
return 0;
}
</source>
''Výstup:''
7 ^ 3 = 343.000000
4.73 ^ 12 = 125410439.217423
32.01 ^ 1.54 = 208.036691

Labs (jazyk C)

2020-05-19T21:23:14Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia labs==
<properties>
knižnica=stdlib.h
popis=Vráti absolútnu hodnotu čísla.
</properties>

Úplný funkčný prototyp:
<source lang="c">
long int labs(long int x)
</source>

==Podrobný popis funkcie==
Funkcia vráti absolútnu hodnotu čísla ''x''.

==Parametre==
;''x'': Číslo, ktorého absolútna hodnota bude vrátená.

==Návratová hodnota==
Funkcia vráti vráti absolútnu hodnotu čísla ''x''.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
long int a, b;

a = labs(65987L);
printf("Hodnota cisla a = %ld\n", a);

b = labs(-1005090L);
printf("Hodnota cisla b = %ld\n", b);

return 0;
}
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_labs.htm</ref>

''Výstup:''
Hodnota cisla a = 65987
Hodnota cisla b = 1005090

==Referencie==

Abs (jazyk C)

2020-05-19T21:22:50Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia abs==
<properties>
knižnica=stdlib.h
popis=Vypočíta absolútnu hodnotu celého čísla
</properties>

Úplný funkčný prototyp:
<source lang="c">
int abs ( int n );
long abs ( long n );
</source>
==Podrobný popis funkcie==
Vypočíta absolútnu hodnotu parametra ''n''.

==Parametre==
;n:celočíselná hodnota

==Návratová hodnota==
Absolútna hodnota vstupného parametra ''n''.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main ()
{
int n,m;
n=abs(23);
m=abs(-11);
printf ("n=%d\n",n);
printf ("m=%d\n",m);
return 0;
}
</source>
''Výstup:''
n=23
m=11

Div (jazyk C)

2020-05-19T21:22:34Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia div==
<properties>
knižnica=stdlib.h
popis=Vydelí čitateľa menovateľom.
</properties>

Úplný funkčný prototyp:
<source lang="c">
div_t div(int numer, int denom)
</source>

==Podrobný popis funkcie==
Táto funkcia vydelí čitateľa menovateľom a vráti štruktúru v ktorej sa nachádza celočíselný podiel a zvyšok.

==Parametre==
;''numer'': Čitateľ
;''denom'': Menovateľ

==Návratová hodnota==
Funkcia vráti štruktúru ''div_t'', ktorá obsahuje celočíselný podiel a zvyšok. Deklaráciu tejto štruktúry, ktorá je v knižnici ''<cstdlib.h>'' môžete vidieť nižšie:
<source lang="c">
typedef struct {
int quot; //celočíselný podiel
int rem; //zvyšok
} div_t;
</source>

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
div_t vysledok;

vysledok = div(27, 4);
printf("Podiel cisla (27/4) = %d\n", vysledok.quot);
printf("Zvysok cisla (27/4) = %d\n", vysledok.rem);

vysledok = div(27, 3);
printf("Podiel cisla (27/3) = %d\n", vysledok.quot);
printf("Zvysok cisla (27/3) = %d\n", vysledok.rem);

return 0;
}
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_div.htm</ref>

''Výstup:''
Podiel cisla (27/4) = 6
Zvysok cisla (27/4) = 3
Podiel cisla (27/3) = 9
Zvysok cisla (27/3) = 0

==Referencie==

Atof (jazyk C)

2020-05-19T21:22:09Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atof==
<properties>
knižnica=stdlib.h
popis=Prevedie string na reálne číslo
</properties>

Úplný funkčný prototyp:
<source lang="c">
double atof(const char *str)
</source>

==Podrobný popis funkcie==
Funkcia double atof(const char *str) prevádza string na reálne číslo.

==Parametre==
;str: vyjadrenie čísla v parametri string reprezentujúce reálne číslo

==Návratová hodnota==
Táto funkcia vráti prevedené číslo zo stringu na reálne číslo. Ak nie je možné vykonať premenu vráti nulu

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main () {
float val;
char str[20];

strcpy(str, "98993489");
val = atof(str);
printf("Hodnota stringu = %s, Hodnota reálneho čísla = %f\n", str, val);

strcpy(str, "MTF STU");
val = atof(str);
printf("Hodnota stringu = %s, Hodnota reálneho čísla = %f\n", str, val);

return 0;
}
</source>

''Výstup:''
<source lang="c">
Hodnota stringu = 98993489, Hodnota reálneho čísla = 98993489
Hodnota stringu = MTF STU, Hodnota reálneho čísla = 0.000000
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_atof.htm</ref>

==Referencie==

Atol (jazyk C)

2020-05-19T21:21:53Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atol==
<properties>
knižnica=stdlib.h
popis=Prevedie string na číslo typu long int
</properties>

Úplný funkčný prototyp:
<source lang="c">
long int atol(const char *str)
</source>

==Podrobný popis funkcie==
Funkcia long int atol(const char * str) prevádza argument string na číslo typu long int.

==Parametre==
;str: vyjadrenie čísla v parametri string reprezentujúce integer

==Návratová hodnota==
Táto funkcia vráti prevedené číslo typu string na long integer. Ak nebolo možné vykonať platný prevod, vráti nulu.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main () {
long val;
char str[20];

strcpy(str, "98993489");
val = atol(str);
printf("Hodnota stringu = %s, Hodnota long int = %ld\n", str, val);

strcpy(str, "MTF STU");
val = atol(str);
printf("Hodnota stringu = %s, Hodnota long int = %ld\n", str, val);

return 0;
}
</source>

''Výstup:''
<source lang="c">
Hodnota stringu = 98993489, Hodnota long int = 98993489
Hodnota stringu = MTF STU, Hodnota long int = 0
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_atol.htm</ref>

==Referencie==

Atoi (jazyk C)

2020-05-19T21:21:26Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atoi==
<properties>
knižnica=stdlib.h
popis=Prevedie string na celé číslo int
</properties>

Úplný funkčný prototyp:
<source lang="c">
int atoi(const char *str)
</source>

==Podrobný popis funkcie==
Interpretuje reťazec v parametri ako celé číslo typu integer.

==Parametre==
;str: vyjadrenie čísla v parametri string reprezentujúce integer

==Návratová hodnota==
Táto funkcia vráti prevedené číslo typu string na integer. Ak nebolo možné vykonať platný prevod, vráti nulu.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main () {
int val;
char str[20];

strcpy(str, "98993489");
val = atoi(str);
printf("Hodnota stringu = %s, Hodnota integeru = %d\n", str, val);

strcpy(str, "MTF STU");
val = atoi(str);
printf("Hodnota stringu = %s, Hodnota integeru = %d\n", str, val);

return 0;
}
</source>

''Výstup:''
<source lang="c">
Hodnota stringu = 98993489, Hodnota integeru = 98993489
Hodnota stringu = MTF STU, Hodnota long int = 0
</source>
<ref>https://www.tutorialspoint.com/c_standard_library/c_function_atoi.htm</ref>

==Referencie==

Srand (jazyk C)

2020-05-19T21:20:58Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia srand==
<properties>
knižnica=stdlib.h
popis=Nastaví ''seed'' generátoru pseudonáhodných čísel.
</properties>

Úplný funkčný prototyp:
<source lang="c">
void srand(unsigned int seed)
</source>

==Podrobný popis funkcie==
Inicializuje generátor pseudonáhodných čísel, ktorý využíva funkcia [[Rand (jazyk C)|rand]]. Inicializácia spočíva v nastavení parametru ''seed'', teda počiatočnej iniciačnej hodnoty. Zvyčajne sa ako ''seed'' používa systémový čas, pretože nikdy nie je rovnaký.

==Parametre==
;''seed'': Celé číslo, ktoré sa má použiť ako ''seed'' generátoru pseudonáhodných čísel.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int random(int min, int max) {
return (rand() % (max - min + 1)) + min;
}

int main() {
time_t t;
int n = 5; //počet vypísaných čísel
srand((unsigned)time(&t)); //inicializuje generátor náhodných čísel podľa času

for (int i = 0; i < n; i++) {
printf("%d\n", random(1,50)); //vypíše náhodné číslo od 1 po 50
}
return 0;
}
</source>

''Výstup (môže sa líšiť):''
7
33
31
30
43

==Referencie==

Rand (jazyk C)

2020-05-19T21:20:22Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia rand==
<properties>
knižnica=stdlib.h
popis=Vygeneruje náhodné číslo.
</properties>

Úplný funkčný prototyp:
<source lang="c">
int rand (void);
</source>

==Podrobný popis funkcie==
Funkcia [[Rand (jazyk C)|rand]] sa používa v jazyku C na generovanie náhodných čísel. Ak vygenerujeme sekvenciu náhodných čísel pomocou funkcie [[Rand (jazyk C)|rand]], tak vytvorí rovnakú sekvenciu znova a znova pri každom spustení programu. Povedzme, že ak generujeme 5 náhodných čísel v C pomocou cyklu [[Rand (jazyk C)|rand]] v cykle, potom vždy, keď kompilujeme a spustíme program, náš výstup musí byť rovnakou sekvenciou čísel. Riešením je použiť funkciu [[Srand (jazyk C)|srand]], ktorá zmení ''seed'' generátoru.

==Návratová hodnota==
Funkcia vráti celé číslo v rozmedzí 0 až ''RAND_MAX''.<ref>https://www.tutorialspoint.com/c_standard_library/c_function_rand.htm</ref>

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int random(int min, int max) {
return (rand() % (max - min + 1)) + min;
}

int main() {
time_t t;
int n = 5; //počet vypísaných čísel

srand((unsigned)time(&t)); //inicializuje generátor náhodných čísel podľa času

for (int i = 0; i < n; i++) {
printf("%d\n", random(1,50)); //vypíše náhodné číslo od 1 po 50
}

return 0;
}
</source>

''Výstup (môže sa líšiť):''
7
33
31
30
43

==Referencie==

Malloc (jazyk C)

2020-05-19T21:19:40Z

Matej.F: /* Príklad */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia malloc==
<properties>
knižnica=stdlib.h
popis=Pridelí (alokuje) požadovanú veľkosť pamäte.
</properties>

Úplný funkčný prototyp:
<source lang="c">
void *malloc(size_t size)
</source>

==Podrobný popis funkcie==
Funkcia pridelí (alokuje) požadovanú veľkosť pamäte a vráti [[Jazyk C - smerník (pointer)|smerník]] odkazujúci na túto časť pamäte.<ref>https://www.tutorialspoint.com/c_standard_library/c_function_malloc.htm</ref>

==Parametre==
;''size'': Veľkosť vyžadovanej pamäte v bajtoch.

==Návratová hodnota==
Vráti [[Jazyk C - smerník (pointer)|smerník]] odkazujúci na pridelenú (alokovanú) časť pamäte. Ak sa nepodarilo prideliť (alokovať) pamäť, tak vráti ''NULL''.

==Príklad==
<source lang="c" line>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
char *str;

str = (char *)malloc(7); //pridelí pamäť s veľkosťou 7 bajtov smerníku str
strcpy(str, "kiwiki");
printf("Textovy retazec = %s, Adresa = %u\n", str, str);

str = (char *)realloc(str, 13); //zmení veľkosť pridelenej pamäte zo 7 bajtov na 13 bajtov
strcat(str, ".info");
printf("Textovy retazec = %s, Adresa = %u\n", str, str);

free(str); //zruší pridelenie pamäte

return 0;
}
</source>

''Výstup:''
Textovy retazec = kiwiki, Adresa = 14313456
Textovy retazec = kiwiki.info, Adresa = 14313912

==Referencie==