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

Jazyk C - polia

2020-05-26T13:47:34Z

PatrikC: /* Dvojrozmerné polia */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
{{Skripta_ZI}}
__TOC__
'''Polia''' sa používajú na ukladanie kolekcie údajov, ale často je užitočnejšie myslieť na pole ako kolekciu premenných rovnakého typu.
Namiesto deklarovania jednotlivých premenných, ako napríklad číslo 0, číslo 1, ... a číslo 99, deklarujete jednu premennú poľa, ako sú čísla a na reprezentáciu použite čísla [0], čísla [1] a ..., čísla [99]. jednotlivé premenné.
Konkrétny prvok v poli je prístupný indexom.

==Jednorozmerné polia==

'''Deklarácia jednorozmerného poľa'''

Na deklarovanie poľa v C programátor špecifikuje typ prvkov a počet prvkov požadovaných poľom takto
<source>
typ menoPola[veľkosť];
</source>
Toto sa nazýva jednorozmerné pole. Veľkosť musí byť celočíselná konštanta väčšia ako nula a typ môže byť akýkoľvek platný typ v jazyku C.
Napríklad deklarácia pola o veľkosti 10:
<source>
int pole[10];
</source>

'''Iniciálizácia'''

Prvky pola môžeme inicializovať po jednom alebo pomocou jedného príkazu nasledovne.

<source>
int pole[5] = {1000,5,70,64,1};
</source>
Počet hodnôt medzi zátvorkami {} nemôže byť väčší ako počet prvkov(veľkosť pola), ktoré uvádzame pre pole medzi hranatými zátvorkami [].
Ak vynecháte veľkosť poľa, vytvorí sa pole ktoré je dostatočne veľké na to aby mohlo udržať inicializáciu.

Preto, ak napíšeme
<source>
int pole[] = {1000,5,70,64,1};
</source>
Vytvorí sa rovnaké pole ako v predchádzajúcom príkladne.

'''Prístup k prvkom poľa'''

K prvku sa pristupuje indexovaním názvu poľa. To sa dosiahne umiestnením indexu prvku do hranatých zátvoriek za názvom poľa.

Napríklad
<source>
int cislo = n[8] ;
</source>
Do premennej cislo sa priradí hodnota(číslo) z pola n ktoré sa nachádza na indexe 8.

Nasledujúci príklad ukazuje, ako používať všetky tri vyššie uvedené koncepty, viď. deklaráciu, priradenie a prístup k poliam
<source lang="c" line>

#include <stdio.h>

int main () {

int n[ 10 ]; /* n je pole o veľkosti 10 prvkov */
int i,j;

/* inicializácia pola n od 0 po 10 */
for ( i = 0; i < 10; i++ ) {
n[ i ] = i + 100; /* zapíše prvok na mieste i hodnotou i + 100 */
}

/* výstup hodnoty každého prvku z pola */
for (j = 0; j < 10; j++ ) {
printf("Prvok[%d] = %d\n", j, n[j] );
}

return 0;
}
</source>
Výstup
<source>
Prvok[0] = 100
Prvok[1] = 101
Prvok[2] = 102
Prvok[3] = 103
Prvok[4] = 104
Prvok[5] = 105
Prvok[6] = 106
Prvok[7] = 107
Prvok[8] = 108
Prvok[9] = 109
</source>

==Viacrozmerné polia==

'''Deklarácia viacrozmerného poľa'''

Programovací jazyk C umožňuje vytvárať aj viacrozmerné polia. Toto je všeobecná deklarácia viacrozmerného poľa.
<source>
typ menoPola[veľkosť_1][veľkosť_2]...[veľkosť_N];
</source>
Nasledujúca deklarácia je pre inicializáciu trojrozmerného pola
<source>
typ trojrozmerne[2][5][4];
</source>
==Dvojrozmerné polia==
Najjednoduchšou formou viacrozmerného poľa je dvojrozmerné pole. Dvojrozmerné pole je v podstate zoznam jednorozmerných polí. Na deklarovanie dvojrozmerného celočíselného poľa veľkosti [ROZMER1][ROZMER2] by ste napísali takto.
<source>
typ menoPola[ROZMER1][ROZMER2];
</source>
Kde typ môže byť akýkoľvek platný typ údajov C a menoPolabude platný identifikátor C. Dvojrozmerné pole možno považovať za tabuľku, ktorá bude mať x počet riadkov a počet stĺpcov y. Taktiež môžme považovať dvojrozmerné pole za maticu čísel. Dvojrozmerné pole maticaA, ktoré obsahuje tri riadky a štyri stĺpce, je možné zobraziť takto.
{|class="wikitable" style="text-align: center;
|-
! !! Stĺpec 0 !! Stĺpec 1 !! Stĺpec 2 !! Stĺpec 3
|-
| Riadok 0 || maticaA[0][0] || maticaA[0][1] || maticaA[0][2] || maticaA[0][3]
|-
| Riadok 1 || maticaA[1][0] || maticaA[1][1] || maticaA[1][2] || maticaA[1][3]
|-
| Riadok 2 || maticaA[2][0] || maticaA[2][1] || maticaA[2][2] || maticaA[2][3]
|-
|}
Každý prvok v poli a je teda identifikovaný názvom prvku vo forme a[i][j], kde „a“ je názov poľa a „i“ a „j“ sú indfexy „bunky“ kde sa daný prvok nachádza.

'''Inicializácia dvojrozmerných polí'''

Viacrozmerné polia sa môžu inicializovať zadaním hodnôt v zátvorkách pre každý riadok. Nasleduje pole s 3 riadkami a každý riadok má 4 stĺpce.

<source lang="c" line>
int a[3][4] = {
{0, 1, 2, 3} , /* inicializácia pre riadok 0 */
{4, 5, 6, 7} , /* inicializácia pre riadok 1 */
{8, 9, 10, 11} /* inicializácia pre riadok 2 */
};
</source>
Alebo môžme napísať inicializáciu aj do jedného riadka. Nasledujúca inicializácia je ekvivalentná s predchádzajúcim príkladom.
<source lang="c" line>
int a[3][4] = {
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
};
</source>

'''Prístup k prvkom dvojrozmerného poľa'''

K prvku v dvojrozmernom poli sa pristupuje pomocou indexu riadka a indexu stĺpca poľa. Napríklad
<source>
int val = a[2][3];
</source>

'''Práca z dvojrozmerným polom'''

Ukážme si príklad pre vypísanie dvojrozmerného pola.
<source lang="c" line>
#include <stdio.h>

int main () {

/* inicializácia dvojrozmerného pola ktoré má 5 riadkov a 2 stĺpce*/
int maticaA[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
int i, j;

/* výstup každého prvku pola, najprv sa vypíšu všetky stĺpce daného riadku až potom sa prejde na ďalší riadok */
for ( i = 0; i < 5; i++ ) {
for ( j = 0; j < 2; j++ ) {
printf("maticaA[%d][%d] = %d\n", i,j, maticaA[i][j] );
}
}
return 0;
}
</source>

Po skompilovaní a spustení vyššie uvedeného kódu sa získa nasledujúci výsledok.
<source>
maticaA[0][0]: 0
maticaA[0][1]: 0
maticaA[1][0]: 1
maticaA[1][1]: 2
maticaA[2][0]: 2
maticaA[2][1]: 4
maticaA[3][0]: 3
maticaA[3][1]: 6
maticaA[4][0]: 4
maticaA[4][1]: 8
</source>

Šablóna:Funkcie jazyka c

2020-05-26T13:43:28Z

PatrikC:

[[Kategória:Jazyk C]]
{| class="wikitable" style="width:480px"
|+ Rozdelenie funkcií jazyka C podľa knižníc, v ktorých sú definované
|-
! [[C standard library - ctype.h|<ctype.h>]]
!<limits.h>
!<stdio.h>
!<stdlib.h>
!<math.h>
!<string.h>
!<time.h>
|-
| style="vertical-align:top"|
isalnum 
isalpha 
isdigit 
isgraph 
islower 
isprint 
ispunct 
isspace 
isupper 
isxdigit 
|
| style="vertical-align:top"|
[[printf (jazyk C)|printf]] 
[[scanf (jazyk C)|scanf]] 
[[getc (jazyk C)|getc]] 
[[putc (jazyk C)|putc]] 
[[getchar(jazyk C)|getchar]] 
[[putchar(jazyk C)|putchar]] 
[[fprintf (jazyk C)|fprintf]] 
[[fscanf (jazyk C)|fscanf]] 
[[fgetc (jazyk C)|fgetc]] 
[[fputc (jazyk C)|fputc]] 
[[fopen (jazyk C)|fopen]] 
[[fclose (jazyk C)|fclose]] 
[[feof (jazyk C)|feof]] 
| style="vertical-align:top"|
[[system (jazyk C)|system]] 
[[malloc (jazyk C)|malloc]] 
[[qsort (jazyk C)|qsort]] 
[[rand (jazyk C)|rand]] 
[[srand (jazyk C)|srand]] 
[[atoi (jazyk C)|atoi]] 
[[atol (jazyk C)|atol]] 
[[atof (jazyk C)|atof]] 
[[itoa (jazyk C)|itoa]] 
[[div (jazyk C)|div]] 
[[abs (jazyk C)|abs]] 
[[labs (jazyk C)|labs]] 
| style="vertical-align:top"|
[[pow (jazyk C)|pow]] 
[[fabs (jazyk C)|fabs]] 
[[exp (jazyk C)|exp]] 
[[log(jazyk C)|log]] 
[[log10(jazyk C)|log10]] 
[[sqrt (jazyk C)|sqrt]] 
[[ceil (jazyk C)|ceil]] 
[[sin (jazyk C)|sin]] 
[[cos (jazyk C)|cos]] 
| style="vertical-align:top"|
[[strlen (jazyk C)|strlen]] 
[[strcmp (jazyk C)|strcmp]] 
[[strchr (jazyk C)|strchr]] 
[[strcpy (jazyk C)|strcpy]] 
[[strstr (jazyk C)|strstr]] 
[[strcat (jazyk C)|strcat]] 
[[strncat (jazyk C)|strncat]] 
| style="vertical-align:top"|
[[clock (jazyk C)|clock ]] 
[[time (jazyk C)|time ]]
|}

Jazyk C - vstupno/výstupné operácie

2020-05-26T13:43:26Z

PatrikC: /* Funkcie getchar(), putchar() */

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

{{Skripta_ZI}}
Keď povieme '''Vstup''' , znamená to, že niektoré údaje vložíme do programu. Vstup môže byť zadaný vo forme súboru alebo z príkazového riadku. Programovanie C poskytuje sadu vstavaných funkcií na čítanie daného vstupu a jeho posielanie do programu podľa potreby.

Keď povieme '''Výstup''' , znamená to zobraziť niektoré údaje na obrazovke, tlačiarni alebo v akomkoľvek súbore. Programovanie v jazyku C poskytuje sadu vstavaných funkcií na výstup údajov na obrazovke počítača a ich ukladanie do textových alebo binárnych súborov.

Pre prácu zo vstupom a výstupom je potrebné vložiť knižnicu <stdio.h><ref>https://www.tutorialspoint.com/c_standard_library/stdio_h.htm</ref> hlavičky definuje tri typy premenných, niekoľko makrá a rôzne funkcie pre vykonávanie vstupu a výstupu.

==Štandardné súbory <ref>https://www.tutorialspoint.com/cprogramming/c_input_output.htm</ref> ==
{| class="wikitable" style = "text-align: center;
|-
!scope="col" | Štandardný súbor
! Ukazovateľ súboru
! Zariadenie
|-
| Štandardný vstup || stdin || klávesnica
|-
| Štandardný výstup || stdout || obrazovka
|-
| Štandardná chyba || stderr|| Vaša obrazovka

|}

==Funkcie [[getchar (jazyk C)|putc]], [[putchar(jazyk C)|putchar]]==
'''Deklarácia:'''
<source lang="c" >
int getchar(void) // pre vstup znaku
int putchar(int) // pre výstup znaku
</source>

Funkcia '''getchar()''' dokáže načítať znak z klávesnice a vráti ho ako celé číslo. Táto funkcia dokáže načítať naraz iba jeden znak.

Funkcia '''putchar()''' dokáže vypísať jeden znak z klávesnice a vráti rovnaký znak.
Pre načítanie alebo vypísanie viacerých znakov je potrebné použiť cyklus.
Príklad:
<source lang="c" >
#include <stdio.h>
main( ) {
int c;

printf( "Vstup:");
c = getchar( );

printf( "\nVýstup: ");
putchar(c);
}
</source>
Po skompilovaní a spustení vyššie uvedeného kódu čaká na vloženie textu. Keď zadáte text a stlačíte Enter, program pokračuje a načíta iba jeden znak a zobrazí ho nasledovne -
<source >
Vstup: Toto je test.
Výstup: T
</source>

==Funkcie [[getc (jazyk C)|getc]],[[putc (jazyk C)|putc]]<ref>https://www.javatpoint.com/c-gets-puts</ref>==

'''Deklarácia:'''
<source lang="c" >
char* gets(char[]);
int puts(char[])
</source>
Funkcia '''get()''' umožňuje užívateľovi zadať niektoré znaky, za ktorými nasleduje kláves Enter. Všetky zadané znaky sa uložia do poľa znakov.Na koniec poľa sa pridá nulový znak aby sa vytvoril retazec. Get() umožňuje užívateľovi zadať reťazce oddelené medzerami. Funkcia vracia string/retazec.
Priklad:
<source lang="c" >
#include<stdio.h>
void main () {
char s[30];

printf("Zadajte retazec: ");
gets(s);

printf("Zadaný retazec: %s",s);
}
</source>
Výstup:
<source >
Zadajte retazec: Toto je test.
Zadaný retazec: Toto je test.
</source>

Funkcia '''puts()''' je veľmi podobná funkcii printf(). Funkcia puts() sa používa na výpis reťazca na obrazovku, ktorý sa predtým čítal pomocou funkcie gets () alebo scanf (). Funkcia puts () vracia celočíselnú hodnotu predstavujúcu počet vypísaných znakov. Ak je úspešná, vráti sa nezáporná hodnota. Pri chybe funkcia vráti EOF.
Príklad:
<source lang="c" >
#include <stdio.h>
#include <string.h>
void main () {
znak char [50];

printf ( "Zadajte svoje meno:" );
gets (meno); // prečíta reťazec od používateľa

printf ( "Vaše meno je:" );
puts (názov); // zobrazuje reťazec
}
</source>
Výstup:
<source >
Zadajte svoje meno: Ferko Mrkvička
Vaše meno je: Ferko Mrkvička
</source>

==Funkcie [[printf (jazyk C)|printf]], [[scanf (jazyk C)|scanf]]==
Funkcie printf () a scanf () sa používajú na formátovaný vstup a výstup v jazyku C. Obe funkcie sú vstavané knižničné funkcie definované v stdio.h (súbor hlavičky).

'''Deklarácia:'''
<source lang="c" >
printf ( "formátovací reťazec" , premenná);
scanf ( "formátovací reťazec" , premenná);
</source>
'''Formátovací reťazec''' môže byť %d (celé číslo), %c (znak), %s (reťazec), %f (float) atď.

'''Premenná''' je miesto odkiaľ alebo kam sa čísla, znaky, reťazce zapisujú alebo odkiaľ sa čítajú.
Funkcia '''scanf()''' načítava znaky z klávesnice ako formátovaný vstup a ukladá ich do premennej či už ako reťazec, číslo, znak.
Funkcia '''printf()''' vypíše na obrazovku formátovaný výstup premennej či už ako reťazec, číslo, znak, atď.

Príklad:
<source lang="c" >
#include <stdio.h>
int main( ) {
char str[100];
int i;

printf( "Zadajte text:");
scanf("%s %d", str, &i);

printf( "\nZadali ste: %s %d ", str, i);

return 0;
}
</source>
Výstup:
<source>
Zadajte text: sedem 7
Zadali ste: sedem 7
</source>

==Referencie==

Jazyk C - vstupno/výstupné operácie

2020-05-26T13:42:12Z

PatrikC: /* Funkcie gets(), puts()https://www.javatpoint.com/c-gets-puts */

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

{{Skripta_ZI}}
Keď povieme '''Vstup''' , znamená to, že niektoré údaje vložíme do programu. Vstup môže byť zadaný vo forme súboru alebo z príkazového riadku. Programovanie C poskytuje sadu vstavaných funkcií na čítanie daného vstupu a jeho posielanie do programu podľa potreby.

Keď povieme '''Výstup''' , znamená to zobraziť niektoré údaje na obrazovke, tlačiarni alebo v akomkoľvek súbore. Programovanie v jazyku C poskytuje sadu vstavaných funkcií na výstup údajov na obrazovke počítača a ich ukladanie do textových alebo binárnych súborov.

Pre prácu zo vstupom a výstupom je potrebné vložiť knižnicu <stdio.h><ref>https://www.tutorialspoint.com/c_standard_library/stdio_h.htm</ref> hlavičky definuje tri typy premenných, niekoľko makrá a rôzne funkcie pre vykonávanie vstupu a výstupu.

==Štandardné súbory <ref>https://www.tutorialspoint.com/cprogramming/c_input_output.htm</ref> ==
{| class="wikitable" style = "text-align: center;
|-
!scope="col" | Štandardný súbor
! Ukazovateľ súboru
! Zariadenie
|-
| Štandardný vstup || stdin || klávesnica
|-
| Štandardný výstup || stdout || obrazovka
|-
| Štandardná chyba || stderr|| Vaša obrazovka

|}

==Funkcie getchar(), putchar()==
'''Deklarácia:'''
<source lang="c" >
int getchar(void) // pre vstup znaku
int putchar(int) // pre výstup znaku
</source>

Funkcia '''getchar()''' dokáže načítať znak z klávesnice a vráti ho ako celé číslo. Táto funkcia dokáže načítať naraz iba jeden znak.

Funkcia '''putchar()''' dokáže vypísať jeden znak z klávesnice a vráti rovnaký znak.
Pre načítanie alebo vypísanie viacerých znakov je potrebné použiť cyklus.
Príklad:
<source lang="c" >
#include <stdio.h>
main( ) {
int c;

printf( "Vstup:");
c = getchar( );

printf( "\nVýstup: ");
putchar(c);
}
</source>
Po skompilovaní a spustení vyššie uvedeného kódu čaká na vloženie textu. Keď zadáte text a stlačíte Enter, program pokračuje a načíta iba jeden znak a zobrazí ho nasledovne -
<source >
Vstup: Toto je test.
Výstup: T
</source>
==Funkcie [[getc (jazyk C)|getc]],[[putc (jazyk C)|putc]]<ref>https://www.javatpoint.com/c-gets-puts</ref>==

'''Deklarácia:'''
<source lang="c" >
char* gets(char[]);
int puts(char[])
</source>
Funkcia '''get()''' umožňuje užívateľovi zadať niektoré znaky, za ktorými nasleduje kláves Enter. Všetky zadané znaky sa uložia do poľa znakov.Na koniec poľa sa pridá nulový znak aby sa vytvoril retazec. Get() umožňuje užívateľovi zadať reťazce oddelené medzerami. Funkcia vracia string/retazec.
Priklad:
<source lang="c" >
#include<stdio.h>
void main () {
char s[30];

printf("Zadajte retazec: ");
gets(s);

printf("Zadaný retazec: %s",s);
}
</source>
Výstup:
<source >
Zadajte retazec: Toto je test.
Zadaný retazec: Toto je test.
</source>

Funkcia '''puts()''' je veľmi podobná funkcii printf(). Funkcia puts() sa používa na výpis reťazca na obrazovku, ktorý sa predtým čítal pomocou funkcie gets () alebo scanf (). Funkcia puts () vracia celočíselnú hodnotu predstavujúcu počet vypísaných znakov. Ak je úspešná, vráti sa nezáporná hodnota. Pri chybe funkcia vráti EOF.
Príklad:
<source lang="c" >
#include <stdio.h>
#include <string.h>
void main () {
znak char [50];

printf ( "Zadajte svoje meno:" );
gets (meno); // prečíta reťazec od používateľa

printf ( "Vaše meno je:" );
puts (názov); // zobrazuje reťazec
}
</source>
Výstup:
<source >
Zadajte svoje meno: Ferko Mrkvička
Vaše meno je: Ferko Mrkvička
</source>

==Funkcie [[printf (jazyk C)|printf]], [[scanf (jazyk C)|scanf]]==
Funkcie printf () a scanf () sa používajú na formátovaný vstup a výstup v jazyku C. Obe funkcie sú vstavané knižničné funkcie definované v stdio.h (súbor hlavičky).

'''Deklarácia:'''
<source lang="c" >
printf ( "formátovací reťazec" , premenná);
scanf ( "formátovací reťazec" , premenná);
</source>
'''Formátovací reťazec''' môže byť %d (celé číslo), %c (znak), %s (reťazec), %f (float) atď.

'''Premenná''' je miesto odkiaľ alebo kam sa čísla, znaky, reťazce zapisujú alebo odkiaľ sa čítajú.
Funkcia '''scanf()''' načítava znaky z klávesnice ako formátovaný vstup a ukladá ich do premennej či už ako reťazec, číslo, znak.
Funkcia '''printf()''' vypíše na obrazovku formátovaný výstup premennej či už ako reťazec, číslo, znak, atď.

Príklad:
<source lang="c" >
#include <stdio.h>
int main( ) {
char str[100];
int i;

printf( "Zadajte text:");
scanf("%s %d", str, &i);

printf( "\nZadali ste: %s %d ", str, i);

return 0;
}
</source>
Výstup:
<source>
Zadajte text: sedem 7
Zadali ste: sedem 7
</source>

==Referencie==

Jazyk C - vstupno/výstupné operácie

2020-05-26T13:40:50Z

PatrikC: /* Funkcie scanf(), printf() */

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

{{Skripta_ZI}}
Keď povieme '''Vstup''' , znamená to, že niektoré údaje vložíme do programu. Vstup môže byť zadaný vo forme súboru alebo z príkazového riadku. Programovanie C poskytuje sadu vstavaných funkcií na čítanie daného vstupu a jeho posielanie do programu podľa potreby.

Keď povieme '''Výstup''' , znamená to zobraziť niektoré údaje na obrazovke, tlačiarni alebo v akomkoľvek súbore. Programovanie v jazyku C poskytuje sadu vstavaných funkcií na výstup údajov na obrazovke počítača a ich ukladanie do textových alebo binárnych súborov.

Pre prácu zo vstupom a výstupom je potrebné vložiť knižnicu <stdio.h><ref>https://www.tutorialspoint.com/c_standard_library/stdio_h.htm</ref> hlavičky definuje tri typy premenných, niekoľko makrá a rôzne funkcie pre vykonávanie vstupu a výstupu.

==Štandardné súbory <ref>https://www.tutorialspoint.com/cprogramming/c_input_output.htm</ref> ==
{| class="wikitable" style = "text-align: center;
|-
!scope="col" | Štandardný súbor
! Ukazovateľ súboru
! Zariadenie
|-
| Štandardný vstup || stdin || klávesnica
|-
| Štandardný výstup || stdout || obrazovka
|-
| Štandardná chyba || stderr|| Vaša obrazovka

|}

==Funkcie getchar(), putchar()==
'''Deklarácia:'''
<source lang="c" >
int getchar(void) // pre vstup znaku
int putchar(int) // pre výstup znaku
</source>

Funkcia '''getchar()''' dokáže načítať znak z klávesnice a vráti ho ako celé číslo. Táto funkcia dokáže načítať naraz iba jeden znak.

Funkcia '''putchar()''' dokáže vypísať jeden znak z klávesnice a vráti rovnaký znak.
Pre načítanie alebo vypísanie viacerých znakov je potrebné použiť cyklus.
Príklad:
<source lang="c" >
#include <stdio.h>
main( ) {
int c;

printf( "Vstup:");
c = getchar( );

printf( "\nVýstup: ");
putchar(c);
}
</source>
Po skompilovaní a spustení vyššie uvedeného kódu čaká na vloženie textu. Keď zadáte text a stlačíte Enter, program pokračuje a načíta iba jeden znak a zobrazí ho nasledovne -
<source >
Vstup: Toto je test.
Výstup: T
</source>
==Funkcie gets(), puts()<ref>https://www.javatpoint.com/c-gets-puts</ref>==

'''Deklarácia:'''
<source lang="c" >
char* gets(char[]);
int puts(char[])
</source>
Funkcia '''get()''' umožňuje užívateľovi zadať niektoré znaky, za ktorými nasleduje kláves Enter. Všetky zadané znaky sa uložia do poľa znakov.Na koniec poľa sa pridá nulový znak aby sa vytvoril retazec. Get() umožňuje užívateľovi zadať reťazce oddelené medzerami. Funkcia vracia string/retazec.
Priklad:
<source lang="c" >
#include<stdio.h>
void main () {
char s[30];

printf("Zadajte retazec: ");
gets(s);

printf("Zadaný retazec: %s",s);
}
</source>
Výstup:
<source >
Zadajte retazec: Toto je test.
Zadaný retazec: Toto je test.
</source>

Funkcia '''puts()''' je veľmi podobná funkcii printf(). Funkcia puts() sa používa na výpis reťazca na obrazovku, ktorý sa predtým čítal pomocou funkcie gets () alebo scanf (). Funkcia puts () vracia celočíselnú hodnotu predstavujúcu počet vypísaných znakov. Ak je úspešná, vráti sa nezáporná hodnota. Pri chybe funkcia vráti EOF.
Príklad:
<source lang="c" >
#include <stdio.h>
#include <string.h>
void main () {
znak char [50];

printf ( "Zadajte svoje meno:" );
gets (meno); // prečíta reťazec od používateľa

printf ( "Vaše meno je:" );
puts (názov); // zobrazuje reťazec
}
</source>
Výstup:
<source >
Zadajte svoje meno: Ferko Mrkvička
Vaše meno je: Ferko Mrkvička
</source>

==Funkcie [[printf (jazyk C)|printf]], [[scanf (jazyk C)|scanf]]==
Funkcie printf () a scanf () sa používajú na formátovaný vstup a výstup v jazyku C. Obe funkcie sú vstavané knižničné funkcie definované v stdio.h (súbor hlavičky).

'''Deklarácia:'''
<source lang="c" >
printf ( "formátovací reťazec" , premenná);
scanf ( "formátovací reťazec" , premenná);
</source>
'''Formátovací reťazec''' môže byť %d (celé číslo), %c (znak), %s (reťazec), %f (float) atď.

'''Premenná''' je miesto odkiaľ alebo kam sa čísla, znaky, reťazce zapisujú alebo odkiaľ sa čítajú.
Funkcia '''scanf()''' načítava znaky z klávesnice ako formátovaný vstup a ukladá ich do premennej či už ako reťazec, číslo, znak.
Funkcia '''printf()''' vypíše na obrazovku formátovaný výstup premennej či už ako reťazec, číslo, znak, atď.

Príklad:
<source lang="c" >
#include <stdio.h>
int main( ) {
char str[100];
int i;

printf( "Zadajte text:");
scanf("%s %d", str, &i);

printf( "\nZadali ste: %s %d ", str, i);

return 0;
}
</source>
Výstup:
<source>
Zadajte text: sedem 7
Zadali ste: sedem 7
</source>

==Referencie==

Jazyk C - operátory

2020-05-26T13:31:23Z

PatrikC: /* Priraďovací operátor */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

;Bitový posun vľavo <<: Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

;Poznámka: V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

;Bitový posun vpravo >>: Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

;Bitový súčin &: Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

;Bitový súčet |: Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

;Bitový exkluzívny súčet ^:Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

;Bitová negácia ~: Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

;Menšie ako <: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

;Väčšie ako >: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

;Menšie alebo rovné ako <=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

;Väčšie alebo rovné ako >=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

;Rovná sa ==: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

;Nerovná sa !=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

;Priradenie =: Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

;Poznámka: V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

;Operátor a následné priradenie: Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

;Veľkosť premennej sizeof(x): Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.

<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:31:07Z

PatrikC: /* Priraďovací operátor */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

;Bitový posun vľavo <<: Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

;Poznámka: V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

;Bitový posun vpravo >>: Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

;Bitový súčin &: Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

;Bitový súčet |: Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

;Bitový exkluzívny súčet ^:Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

;Bitová negácia ~: Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

;Menšie ako <: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

;Väčšie ako >: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

;Menšie alebo rovné ako <=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

;Väčšie alebo rovné ako >=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

;Rovná sa ==: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

;Nerovná sa !=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

;Priradenie =:

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

;Poznámka: V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

;Operátor a následné priradenie: Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

;Veľkosť premennej sizeof(x): Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.

<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:30:20Z

PatrikC: /* Miskuidné operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

;Bitový posun vľavo <<: Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

;Poznámka: V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

;Bitový posun vpravo >>: Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

;Bitový súčin &: Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

;Bitový súčet |: Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

;Bitový exkluzívny súčet ^:Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

;Bitová negácia ~: Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

;Menšie ako <: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

;Väčšie ako >: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

;Menšie alebo rovné ako <=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

;Väčšie alebo rovné ako >=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

;Rovná sa ==: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

;Nerovná sa !=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

;Veľkosť premennej sizeof(x): Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.

<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:29:55Z

PatrikC: /* Relačné operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

;Bitový posun vľavo <<: Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

;Poznámka: V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

;Bitový posun vpravo >>: Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

;Bitový súčin &: Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

;Bitový súčet |: Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

;Bitový exkluzívny súčet ^:Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

;Bitová negácia ~: Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

;Menšie ako <: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

;Väčšie ako >: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

;Menšie alebo rovné ako <=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

;Väčšie alebo rovné ako >=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

;Rovná sa ==: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

;Nerovná sa !=: Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

'''Veľkosť premennej sizeof(x)'''
Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.
<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:28:54Z

PatrikC: /* Bitové operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

;Bitový posun vľavo <<: Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

;Poznámka: V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

;Bitový posun vpravo >>: Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

;Bitový súčin &: Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

;Bitový súčet |: Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

;Bitový exkluzívny súčet ^:Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

;Bitová negácia ~: Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava.

Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

'''Menšie ako <'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

'''Väčšie ako >'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

'''Menšie alebo rovné ako <= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

'''Väčšie alebo rovné ako >= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

'''Rovná sa == '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

'''Nerovná sa != '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

'''Veľkosť premennej sizeof(x)'''
Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.
<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:26:55Z

PatrikC: /* Logické operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

;Logický súčin &&: Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

;Logický súčet ||: Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

;Negácia !: Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

;Poznámka: Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

'''Bitový posun vľavo <<'''

Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

'''Poznámka:''' V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

'''Bitový posun vpravo >>'''

Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

'''Bitový súčin &'''

Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

'''Bitový súčet |'''

Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

'''Bitový exkluzívny súčet ^'''

Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

'''Bitová negácia ~'''

Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

'''Menšie ako <'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

'''Väčšie ako >'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

'''Menšie alebo rovné ako <= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

'''Väčšie alebo rovné ako >= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

'''Rovná sa == '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

'''Nerovná sa != '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

'''Veľkosť premennej sizeof(x)'''
Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.
<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:26:22Z

PatrikC: /* Aritmetické operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++: Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --: Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

'''Logický súčin &&'''

Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

'''Logický súčet ||'''

Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

'''Negácia !'''

Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

'''Poznámka:''' Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

'''Bitový posun vľavo <<'''

Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

'''Poznámka:''' V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

'''Bitový posun vpravo >>'''

Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

'''Bitový súčin &'''

Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

'''Bitový súčet |'''

Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

'''Bitový exkluzívny súčet ^'''

Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

'''Bitová negácia ~'''

Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

'''Menšie ako <'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

'''Väčšie ako >'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

'''Menšie alebo rovné ako <= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

'''Väčšie alebo rovné ako >= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

'''Rovná sa == '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

'''Nerovná sa != '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

'''Veľkosť premennej sizeof(x)'''
Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.
<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - operátory

2020-05-26T13:26:08Z

PatrikC: /* Aritmetické operátory */

[[Kategória:Študijné materiály]]
[[Kategória:Informatika]]
__TOC__
Operátor je symbol, ktorý hovorí kompilátoru, aby vykonával konkrétne matematické alebo logické funkcie. <ref>https://www.tutorialspoint.com/cprogramming/c_operators.htm</ref> Jeho návratový typ určený podľa typu vstupných hodnôt.

Operátory sa dajú podľa počtu vstupov rozdeliť na unárne, binárne a ternárne.
{| class="wikitable"
! Unárne
| ++, --, -(zmena znamienka), !, ~, sizeof
|-
! Binárne
| <nowiki>+, -, *, /, %, &&, ||, <<, >>, &, |, ^, <, >, <=, >=, ==, !=, =</nowiki>
|-
! Ternárne
| ? :
|}

{{Skripta_ZI}}

==Aritmetické operátory==

;Sčítanie +: Tento operátor slúži na sčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčet daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A + B;</source>

;Rozdiel: Tento operátor slúži na odčítanie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je rozdiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A - B;</source>

;Súčin *: Tento operátor slúži na násobenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je súčin daných čísiel. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Podiel /: Tento operátor slúži na delenie dvoch celých alebo reálnych čísiel. Jeho návratová hodnota je podiel ľavého a pravého čísla. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A / B;</source>

;Zvyšok po delení %: Tento operátor slúži na vypočítanie celočíselného zvyšku po delení celých čísiel. Jeho návratová hodnota sa nazýva '''modulo'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A * B;</source>

;Zmena znamienka -: Tento operátor slúži na zmenu znamienka daného čísla. Jeho návratová hodnota je dané číslo krát -1.
<source lang="c">
x = -A;
y = A * (-1); //ekvivalent
</source>

;Inkrementácia ++:

Tento unárny operátor slúži na zväčšenie daného čísla o 1.
<source lang="c">
A++; //hodnota A sa zväčší o 1.
++A; //Hodnota A sa tiež zväčší o 1.

vypis(A++); //zväčší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(++A); //najprv zväčší hodnotu i o 1, potom toto číslo vypíše
</source>

;Dekrementácia --:

Tento unárny operátor slúži na zmenšenie daného čísla o 1.
<source lang="c">
A--; //hodnota A sa zmenší o 1.
--A; //Hodnota A sa tiež zmenší o 1.

vypis(A--); //zmenší hodnotu i o 1, ale vráti originálnu hodnotu, ktorú potom vypíše
vypis(--A); //najprv zmenší hodnotu i o 1, potom toto číslo vypíše
</source>

==Logické operátory==

'''Logický súčin &&'''

Tento operátor slúži na vypočítanie logického súčinu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A && B;</source>

'''Logický súčet ||'''

Tento operátor slúži na vypočítanie logického súčtu dvoch čísiel. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">x = A || B;</source>

'''Negácia !'''

Tento operátor slúži na vypočítanie negácie jedného čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''.
<source lang="c">x = !A;</source>

'''Poznámka:''' Vstupné hodnoty logických operátorov môžu byť len '''TRUE (1)''' alebo '''FALSE (0)''', avšak v jazyku C/C++ sú všetky hodnoty okrem 0 považované za '''TRUE'''.

==Bitové operátory==

'''Bitový posun vľavo <<'''

Tento operátor slúži na posunutie bitov jedného čísla vľavo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj násobením daného čísla násobkami 2 (napr. A << '''3''' = A * 2 * '''3'''). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A << 2;
//A = B11010100
</source>

'''Poznámka:''' V jazyku C/C++ poznáme viac foriem zápisu čísiel, buď napíšeme číslo v dekadickej sústave napr. 125, alebo v binárnej sústave napr. B01111101, alebo v hexadecimálnej sústave napr. 0x7D.

'''Bitový posun vpravo >>'''

Tento operátor slúži na posunutie bitov jedného čísla vpravo o zadaný počet (chýbajúce bity sa nahradia 0). Rovnaký výsledok sa dá dosiahnuť aj delením daného čísla násobkami 2 (napr. A >> '''3''' = A /( 2 * '''3''')). Vyhodnocuje sa zľava doprava.
<source lang="c">
//A = B00110101
x = A >> 2;
//A = B00001101
</source>

'''Bitový súčin &'''

Tento operátor vypočíta logický súčin každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
&10100110
---------
00100100
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A & B;
</source>

'''Bitový súčet |'''

Tento operátor vypočíta logický súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
|10100110
---------
10110111
</source> Využíva sa najmä ak chceme zmeniť alebo získať určitý bit v čísle.
<source lang="c">
x = A | B;
</source>

'''Bitový exkluzívny súčet ^'''

Tento operátor vypočíta exkluzívny súčet každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
^10100110
---------
10010011
</source> Využíva sa najmä pri šifrovaní.
<source lang="c">
x = A ^ B;
</source>

'''Bitová negácia ~'''

Tento operátor vypočíta logická negáciu každého jedného bitu v čísle. Vyhodnocuje sa zľava doprava. Napr.:<source lang="c">
00110101
~
---------
11001010
</source>
<source lang="c">
x = ~A;
</source>

==Relačné operátory==

'''Menšie ako <'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A < B;</source>

'''Väčšie ako >'''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A > B;</source>

'''Menšie alebo rovné ako <= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo menšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A <= B;</source>

'''Väčšie alebo rovné ako >= '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo väčšie alebo rovné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A >= B;</source>

'''Rovná sa == '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo rovnaké ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A == B;</source>

'''Nerovná sa != '''

Tento operátor porovnáva dve zadané čísla. Jeho návratová hodnota môže byť len '''TRUE''' alebo '''FALSE'''. Ak je ľavé číslo iné ako pravé, tak vráti '''TRUE''', inak '''FALSE'''. Vyhodnocuje sa zľava doprava.
<source lang="c">A != B;</source>

==Priraďovací operátor==

'''Priradenie = '''

Operátor priradenia slúži na priradenie hodnoty do premennej. Môže byť použitý na akýkoľvek datový typ s jedinou podmienkou, že prvý parameter (ľava strana), musí byť prijímač hodnoty, napríklad premenná. v závislosti na programovací jazyk môžu byť rozdielne podmienky pre priradenie hodnoty do premenných, napríklad na základe závislosti na type.<ref>http://ctp.mkprog.eu/sk/c/priradenie/</ref> Priradenie, rovnako ako ostatné operátory, má taktiež návratovú hodnotu a ňou je hodnota, ktorá bola priradená. Vyhodnocuje sa sprava doľava.
<source lang="c">A = B + 1</source>

'''Poznámka:''' V jazyku C/C++ sa pri používaní operátorov postupuje podľa priority operátorov, inak sa zväčša postupuje zľava doprava, napr.: A = A + 5 + B * 6 bude vypočítané ako x = B * 6; y = 5 + x; A = A + y.

'''Operátor a následné priradenie'''

Pre zjednodušenie programovania sa takmer všetky aritmetické a bitové operátory dajú nahradiť operátormi spojenými s priradením:
<source lang="c">
A = A + 2; //A += 2;
A = A - 2; //A -= 2;
A = A * 2; // A *= 2;
A = A / 2; //A /= 2;
A = A % 2; //A %= 2;

A = A << 2; //A <<= 2;
A = A >> 2; //A >>= 2;
A = A & 2; //A &= 2;
A = A | 2; //A |= 2;
A = A ^ 2; //A ^= 2;
</source>
Vyhodnocuje sa sprava doľava.

==Miskuidné operátory==

'''Veľkosť premennej sizeof(x)'''
Tento operátor vráti počet bajtov, ktoré daný dátový typ zaberá v pamäti RAM.
<source lang="c">
x = sizeof(int); //Zvyčajne vráti hodnotu 4 (závisí od architektúry procesora)
byte a;
x = sizeof(a); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
byte b[5];
x = sizeof(b); //Vráti hodnotu 5, pretože pole b zaberá 5 bajtov
x = sizeof(b[0]); //Vráti hodnotu 1, pretože byte zaberá iba jeden bajt
</source>

'''Podmienený operátor ? :'''
Tento operátor najprv zistí, či podmienka pred ? platí. Ak áno, tak vráti hodnotu medzi ? a :, inak vráti hodnotu za : .
<source lang="c">
x = (1 > 2)?5:6; //Vráti hodnotu 6
x = (1 < 2)?5:6; //Vráti hodnotu 5
</source>

'''Ostatné operátory'''
Poznáme ešte dva operátory: referenciu (&) a dereferenciu (*). Tieto operátory sú bližšie vysvetlené v sekii [[Jazyk C - smerník (pointer)]].

==Priorita operátorov==

Tabuľka nižšie zobrazuje prioritu operátorov a smer zápisu v jazyku C.
{| class="wikitable"
! Prednosť
! Operátor
! Popis
! Zápis
|-
| rowspan="5" | 1
| ''++ --''
| Inkrementácia a dekrementácia - prípona
| rowspan="5" | zľava doprava
|-
| ''()''
| Volanie funkcie
|-
| ''[]''
| Indexovanie poľa
|-
| ''.''
| Prístup do štruktúry alebo do union
|-
| ''->''
| Prístup do štruktúry alebo do union cez smerník
|-
| rowspan="7" | 2
| ''++ --''
| Inkrementácia a dekrementácia - predpona
| rowspan="7" | sprava doľava
|-
| ''+ -''
| Unárne plus a mínus
|-
| style="font-style:italic;" | ''! ~''
| logické alebo bitové NOT
|-
| style="font-style:italic;" | ''(type)''
| Konverzia dátového typu
|-
| ''*''
| Dereferencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''&''
| Referencia ([[Jazyk C - smerník (pointer)|smerník]])
|-
| ''sizeof''
| Veľkosť premennej
|-
| 3
| ''* / %''
| Násobenie, delenie a modulo
| rowspan="11" | zľava doprava
|-
| 4
| ''+ -''
| Súčet, rozdieľ
|-
| 5
| ''<< >>''
| Bitový posun vľavo a vpravo
|-
| rowspan="2" | 6
| ''< <=''
| Relačný operátor väčšie ako a väčšie alebo rovné ako
|-
| ''> >=''
| Relačný operátor menšie ako a menšie alebo rovné ako
|-
| 7
| ''== !=''
| Relačný operátor rovná sa a nerovná sa
|-
| 8
| ''&''
| Bitový súčin
|-
| 9
| ''<nowiki>^</nowiki>''
| Bitový exkluzívny súčet
|-
| 10
| ''<nowiki>|</nowiki>''
| Bitový súčet
|-
| 11
| ''&&''
| Logický súčin
|-
| 12
| ''<nowiki>||</nowiki>''
| Logický súčet
|-
| 13
| ''? :''
| Ternárna podmienka
| rowspan="6" | sprava doľava
|-
| rowspan="5" | 14
| ''=''
| Priradenie
|-
| ''+= -=''
| rowspan="4" | Operátor a následné priradenie
|-
| ''*= /= %=''
|-
| ''<<= >>=''
|-
| ''&= ^= <nowiki>|</nowiki>=''
|-
| 15
| '',''
| Čiarka
| zľava doprava
|}

==Referencie==

Jazyk C - dátové typy, premenné

2020-05-26T13:24:32Z

PatrikC: /* 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
<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-26T13:16:23Z

PatrikC: /* Parametrizované makrá */

[[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 || __DATE__ || 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/3*PI*(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.

Zápis makra ako je uvedené na nasledujúcom príklade je chybné, pretože pri dosadení parametrov môže nastať chybná interpretácia:
<source lang="c">
#define KOCKA(a) a*a*a
// pouzitie
cout<< KOCKA(5-4);
</source>
Makro KOCKA sa interpretuje ako:
<source lang="c">
5-4*5-4*5-4
</source>
A tento výraz má hodnotu: 5-20-20-4=-39, čo je chyba.

==Referencie==

Jazyk C - príkazy preprocesora

2020-05-26T13:12:22Z

PatrikC: /* Parametrizované makrá */

[[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 || __DATE__ || 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/3*PI*(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==

Jazyk C - príkazy preprocesora

2020-05-26T13:11:45Z

PatrikC: /* Parametrizované makrá */

[[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 || __DATE__ || 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/3*PI*(r)*(r)*(r))

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==

Jazyk C - príkazy preprocesora

2020-05-26T13:11:06Z

PatrikC: /* Parametrizované makrá */

[[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 || __DATE__ || 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))

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==

Jazyk C - príkazy preprocesora

2020-05-26T07:55:24Z

PatrikC: /* Preddefinované makrá */

[[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 || __DATE__ || 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==

Jazyk C - príkazy preprocesora

2020-05-26T07:55:00Z

PatrikC: /* Preddefinované makrá */

[[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 || __DATE__ || Aktuálny date 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==

Algoritmus

2020-05-26T07:52:16Z

PatrikC: /* Vlasnosti algoritmu */

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

==<big>Algoritmus</big>==
'''Algoritmus''' znamená proces alebo súbor pravidiel ktoré sa majú dodržiavať pri operáciach alebo riešení problémov. Algoritmus sa preto týka súboru pravidiel,pokynov ktoré postupne definujú, ako sa má práca vykonať, aby sa dosiahli očakávané výsledky.<ref>>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

Práca počítača je presne determinovaná. Počítač je absolútne neiniciatívny a všetko, čo chceme, aby urobil mu musíme nariadiť. Prácu počítaču nariaďujeme programom. K tomu aby sme mohli program zostaviť potrebujeme vytvoriť postupnosť krokov, ktorá v každom okamihu určuje ako postupovať ďalej, tzv. algoritmus. Jedna z definícií algoritmu hovorí, že algoritmus je presný popis definujúci výpočtový proces, vedúci od meniteľných vstupných údajov až k žiadaným výsledkom. Táto definícia síce presne vystihuje podstatu a účel algoritmu, je však úzko špecializovaná Obmedzuje sa len na výpočtový proces. Algoritmy však nepoužívame len pri počítačoch pri príprave programov, ale ich použitie je všeobecné. Pomocou algoritmu totiž môžeme presne definovať akýkoľvek determinovaný proces.

[[Súbor:Univerzalny algoritmus.png|none|240px|]]

Navrhnutý algoritmus je nezávislý od jazyka, tzn. že ide iba o jednoduché pokyny, ktoré je možné implementovať v akomkoľvek jazyku, a napriek tomu bude výstup rovnaký, ako sa očakávalo.

==<big>Vlasnosti algoritmu</big>==

;Jasný a jednoznačný: Každý z jeho krokov by mal byť jasný vo všetkých aspektoch a musí viesť iba k jednému významu.

;Dobre definované vstupy: Algoritmus zvyčajne pracuje s nejakými vstupmi, veličinami, ktoré sú mu odovzdané pred začatím jeho vykonávania, alebo v priebehu jeho činnosti. Vstupy majú definované množiny hodnôt, ktoré môžu nadobúdať.

;Efektivita: Všeobecne požadujeme, aby algoritmus bol efektívny, v tom zmysle, že požadujeme, aby každá operácia požadovaná algoritmom, bola dostatočne jednoduchá na to, aby mohla byť aspoň v princípe prevedená v konečnom čase iba s použitím ceruzky a papiera.

;Všeobecnosť: Algoritmus nerieši jeden konkrétny problém (napr. „ako vypočítať 3×7“), ale rieši všeobecnú triedu obdobných problémov (napr. „ako vypočítať súčin dvoch celých čísel“ <ref>https://spseke.sk/tutor/projekt/algoritmy.htm</ref>

==Riešenie problému pomocou algorimtu==
'''1.''' Problém, ktorý má tento algoritmus vyriešiť.

'''2.''' Obmedzenia problému, ktoré je potrebné zohľadniť pri jeho riešení.

'''3.''' Vstup, ktorý sa má prijať na vyriešenie problému.

'''4.''' Výstup, ktorý možno očakávať, keď sa problém vyrieši.

'''5.''' Riešenie tohto problému v daných obmedzeniach.<ref>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

==Značky vývojových diagramov==
[[Súbor:začiatok.png|100px|none]] Značka sa využíva na začatie alebo ukončenie vývojového diagramu

[[Súbor:Untitled Diagram.png|100px|none]] Výkonný blok na program

[[Súbor:Vstuo.png|100px|none]] Služi na zápis vstup a výstupov vývojoveého diagramu

[[Súbor:Untitled Diagram (3).png|160px|none]] Rozhodovací blok s jedným vstupom a viacerými výstupmi

[[Súbor:Spojka.png|none|30px]] Spojka

[[Súbor:Spojnica.png|none|160px]] Spojnica

==Príklady==
'''Príklady''' na tvorbu vývojových diagramov nájdete v sekcií:
[http://www.kiwiki.info/index.php/Jazyk_C_(príklady)_-_Algoritmy[Príklady algoritmus]]

=Referencie=
<references/>

Algoritmus

2020-05-26T07:52:03Z

PatrikC: /* Vlasnosti algoritmu */

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

==<big>Algoritmus</big>==
'''Algoritmus''' znamená proces alebo súbor pravidiel ktoré sa majú dodržiavať pri operáciach alebo riešení problémov. Algoritmus sa preto týka súboru pravidiel,pokynov ktoré postupne definujú, ako sa má práca vykonať, aby sa dosiahli očakávané výsledky.<ref>>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

Práca počítača je presne determinovaná. Počítač je absolútne neiniciatívny a všetko, čo chceme, aby urobil mu musíme nariadiť. Prácu počítaču nariaďujeme programom. K tomu aby sme mohli program zostaviť potrebujeme vytvoriť postupnosť krokov, ktorá v každom okamihu určuje ako postupovať ďalej, tzv. algoritmus. Jedna z definícií algoritmu hovorí, že algoritmus je presný popis definujúci výpočtový proces, vedúci od meniteľných vstupných údajov až k žiadaným výsledkom. Táto definícia síce presne vystihuje podstatu a účel algoritmu, je však úzko špecializovaná Obmedzuje sa len na výpočtový proces. Algoritmy však nepoužívame len pri počítačoch pri príprave programov, ale ich použitie je všeobecné. Pomocou algoritmu totiž môžeme presne definovať akýkoľvek determinovaný proces.

[[Súbor:Univerzalny algoritmus.png|none|240px|]]

Navrhnutý algoritmus je nezávislý od jazyka, tzn. že ide iba o jednoduché pokyny, ktoré je možné implementovať v akomkoľvek jazyku, a napriek tomu bude výstup rovnaký, ako sa očakávalo.

==<big>Vlasnosti algoritmu</big>==

;Jasný a jednoznačný: Každý z jeho krokov by mal byť jasný vo všetkých aspektoch a musí viesť iba k jednému významu.

;Dobre definované vstupy: Algoritmus zvyčajne pracuje s nejakými vstupmi, veličinami, ktoré sú mu odovzdané pred začatím jeho vykonávania, alebo v priebehu jeho činnosti.
Vstupy majú definované množiny hodnôt, ktoré môžu nadobúdať.

;Efektivita: Všeobecne požadujeme, aby algoritmus bol efektívny, v tom zmysle, že požadujeme, aby každá operácia požadovaná algoritmom,
bola dostatočne jednoduchá na to, aby mohla byť aspoň v princípe prevedená v konečnom čase iba s použitím ceruzky a papiera.

;Všeobecnosť: Algoritmus nerieši jeden konkrétny problém (napr. „ako vypočítať 3×7“), ale rieši všeobecnú triedu obdobných problémov (napr. „ako vypočítať súčin dvoch celých čísel“ <ref>https://spseke.sk/tutor/projekt/algoritmy.htm</ref>

==Riešenie problému pomocou algorimtu==
'''1.''' Problém, ktorý má tento algoritmus vyriešiť.

'''2.''' Obmedzenia problému, ktoré je potrebné zohľadniť pri jeho riešení.

'''3.''' Vstup, ktorý sa má prijať na vyriešenie problému.

'''4.''' Výstup, ktorý možno očakávať, keď sa problém vyrieši.

'''5.''' Riešenie tohto problému v daných obmedzeniach.<ref>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

==Značky vývojových diagramov==
[[Súbor:začiatok.png|100px|none]] Značka sa využíva na začatie alebo ukončenie vývojového diagramu

[[Súbor:Untitled Diagram.png|100px|none]] Výkonný blok na program

[[Súbor:Vstuo.png|100px|none]] Služi na zápis vstup a výstupov vývojoveého diagramu

[[Súbor:Untitled Diagram (3).png|160px|none]] Rozhodovací blok s jedným vstupom a viacerými výstupmi

[[Súbor:Spojka.png|none|30px]] Spojka

[[Súbor:Spojnica.png|none|160px]] Spojnica

==Príklady==
'''Príklady''' na tvorbu vývojových diagramov nájdete v sekcií:
[http://www.kiwiki.info/index.php/Jazyk_C_(príklady)_-_Algoritmy[Príklady algoritmus]]

=Referencie=
<references/>

Algoritmus

2020-05-26T07:51:48Z

PatrikC: /* Vlasnosti algoritmu */

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

==<big>Algoritmus</big>==
'''Algoritmus''' znamená proces alebo súbor pravidiel ktoré sa majú dodržiavať pri operáciach alebo riešení problémov. Algoritmus sa preto týka súboru pravidiel,pokynov ktoré postupne definujú, ako sa má práca vykonať, aby sa dosiahli očakávané výsledky.<ref>>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

Práca počítača je presne determinovaná. Počítač je absolútne neiniciatívny a všetko, čo chceme, aby urobil mu musíme nariadiť. Prácu počítaču nariaďujeme programom. K tomu aby sme mohli program zostaviť potrebujeme vytvoriť postupnosť krokov, ktorá v každom okamihu určuje ako postupovať ďalej, tzv. algoritmus. Jedna z definícií algoritmu hovorí, že algoritmus je presný popis definujúci výpočtový proces, vedúci od meniteľných vstupných údajov až k žiadaným výsledkom. Táto definícia síce presne vystihuje podstatu a účel algoritmu, je však úzko špecializovaná Obmedzuje sa len na výpočtový proces. Algoritmy však nepoužívame len pri počítačoch pri príprave programov, ale ich použitie je všeobecné. Pomocou algoritmu totiž môžeme presne definovať akýkoľvek determinovaný proces.

[[Súbor:Univerzalny algoritmus.png|none|240px|]]

Navrhnutý algoritmus je nezávislý od jazyka, tzn. že ide iba o jednoduché pokyny, ktoré je možné implementovať v akomkoľvek jazyku, a napriek tomu bude výstup rovnaký, ako sa očakávalo.

==<big>Vlasnosti algoritmu</big>==

;Jasný a jednoznačný: Každý z jeho krokov by mal byť jasný vo všetkých aspektoch a musí viesť iba k jednému významu.

;Dobre definované vstupy: Algoritmus zvyčajne pracuje s nejakými vstupmi, veličinami, ktoré sú mu odovzdané pred začatím jeho vykonávania, alebo v priebehu jeho činnosti.
Vstupy majú definované množiny hodnôt, ktoré môžu nadobúdať.

;Efektivita: Všeobecne požadujeme, aby algoritmus bol efektívny, v tom zmysle, že požadujeme, aby každá operácia požadovaná algoritmom,
bola dostatočne jednoduchá na to, aby mohla byť aspoň v princípe prevedená v konečnom čase iba s použitím ceruzky a papiera.

;Všeobecnosť: Algoritmus nerieši jeden konkrétny problém (napr. „ako vypočítať 3×7“), ale rieši všeobecnú triedu obdobných problémov (napr. „ako vypočítať súčin dvoch celých čísel“).
<ref>https://spseke.sk/tutor/projekt/algoritmy.htm</ref>

==Riešenie problému pomocou algorimtu==
'''1.''' Problém, ktorý má tento algoritmus vyriešiť.

'''2.''' Obmedzenia problému, ktoré je potrebné zohľadniť pri jeho riešení.

'''3.''' Vstup, ktorý sa má prijať na vyriešenie problému.

'''4.''' Výstup, ktorý možno očakávať, keď sa problém vyrieši.

'''5.''' Riešenie tohto problému v daných obmedzeniach.<ref>https://www.geeksforgeeks.org/introduction-to-algorithms/</ref>

==Značky vývojových diagramov==
[[Súbor:začiatok.png|100px|none]] Značka sa využíva na začatie alebo ukončenie vývojového diagramu

[[Súbor:Untitled Diagram.png|100px|none]] Výkonný blok na program

[[Súbor:Vstuo.png|100px|none]] Služi na zápis vstup a výstupov vývojoveého diagramu

[[Súbor:Untitled Diagram (3).png|160px|none]] Rozhodovací blok s jedným vstupom a viacerými výstupmi

[[Súbor:Spojka.png|none|30px]] Spojka

[[Súbor:Spojnica.png|none|160px]] Spojnica

==Príklady==
'''Príklady''' na tvorbu vývojových diagramov nájdete v sekcií:
[http://www.kiwiki.info/index.php/Jazyk_C_(príklady)_-_Algoritmy[Príklady algoritmus]]

=Referencie=
<references/>

Jazyk C (príklady) - Súbor

2020-05-26T07:47:51Z

PatrikC: /* fopen, fclose */

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

==Obsah==
V tejto časti bude ukázaná práca so súbormi v jazyku C. Pre prácu so súborom budeme používať funkcie pre prácu so štandardným vstupom/výstupom definovanými v knižninci stdio.h. Pre zvládnutie týchto príkladov sa predpokladá znalosť funkcií fopen, fclose, fprintf, fscanf, feof, putc, getc a práca s dátovým typom FILE*.

===FILE===
Dátový typ FILE sa používa na identifikovanie súboru, s ktorým budeme pracovať. Tento dátový typ sa nikdy neoužíva priamo (napr: FILE subor0;), ale vždy sa používa premenná typu ukazovateľ na súbor: FILE *subor;. S premennou subor sa potom robia všetky operácie so súborom (otvorenie, zápis, čítanie, zatvorenie).

===fopen, fclose===
;Otvorenie súboru: FILE *fopen("nazov_suboru",mod);
Funkcia fopen má 2 argumenty: prvý argument je názov súboru, ktorý chceme otvoriť. Názov súboru môže obsahovať relatívnu alebo absulútnu cestu k súboru. Druhý argument je (textový reťazec) mód otvorenia súboru: "r" – na čítanie, "w" – na zápis, "a" – pridávanie na koniec súboru. Funkcia vracia ukazateľ na premennú typu FILE. Premenná typu FILE obsahuje informácie o otváranom súbore ako sú: deskriptor súboru, stavové príznaky, veľkosť buffera, … Ak sa súbor podarilo otvoriť, fopen vráti ukazovateľ na otvorený súbor, v opačnom prípade vráti konštantu NULL.

;Zatvorenie súboru: int fclose(FILE *fp); Argument funkcie fclose je ukazovateľ na otvorený súbor. Ak sa súbor podarí zatvoriť, funkcia vráti 0, v opačnom prípade vráti konštantu EOF.

===Vstup/výstup znaku===
int getc(FILE *stream);
Funkcia getc vracia prečítaný znak zo súboru identifikovaným ukazovateľom stream.
int putc(int c,FILE *stream);
Funkcie putc zapíše znak c do súboru identifikovaným ukazovateľom na otvorený súbor stream.

===Formátovaný vstup/výstup===
Funkcie pre formátovaný vstup/výstup (fprintf, fscanf) majú rovnaké použitie ako funkcie printf a scanf. Jediný rozdiel v použití je pridanie prvého argumentu do funkcie (FILE *stream), ktorý nám určuje, s ktorým súborom budeme pracovať.
int fprintf(FILE *stream,char *format,arg1,arg2,...,argn);
int fscanf(FILE *stream,char *format, &arg1,&arg2,...,&argn);

==Programy==
===Čítanie po slovách===
;Zadanie: V textovom súbore data.txt je uložený nejaký text. Vytvorte program, ktorý tento text vypíše na monitor. Ak sa súbor nepodarí otvoriť, vypíšte chybové hlásenie a program ukončite.

;Analýza problému: Úloha je jednoduchá, stačí zo súboru postupne čítať slová a vypisovať ich na monitor. Zo súboru budeme čítať, pokiaľ nenarazíme na koniec súboru.

<source lang="c" line>
#include <stdio.h>
void main()
{

FILE *fp;
char c[20];
fp = fopen("data.txt","r"); // subor, z ktoreho budem citat
if(fp == NULL)
printf("Subor data.txt neexistuje\n");
else // ak subor existuje
{
do // v cykle
{
fscanf(fp,"%s",c); // citaj retazce po slovach
printf("%s ",c); // a vypis na monitor
} while (!feof(fp)); // pokial nenarazis na koniec suboru
fclose(fp); // nakoniec zatvor subor
}

}
</source>

===Počet viet v súbore===
;Zadanie: V textovom súbore data.txt je uložený nejaký text. Vytvorte program, ktorý zistí koľko je v súbore viet.

;Analýza problému: Ak budeme predpokladať, že za každou vetou je bodka, potom počet viet je zhodný s počtom bodiek. V tomto prípade sa čítanie po slovách neukazuje vhodné. Budeme čítať po znakoch a budeme počítať všetky výskyty bodiek.

<source lang="c" line>
#include <stdio.h>
void main()
{

FILE *fp;
int vety=0;
char c;
fp = fopen("data.txt","r");
if (fp == NULL) printf("Subor data.txt neexistuje\n");
else
{
do
{
c = getc(fp); //precita jeden znak zo suboru
if(c=='.')
vety++;
} while (c != EOF); // opakuj cyklus pokial sa nenarazi na koniec suboru
fclose(fp);
printf("V subore je %d viet",vety);
}

}
</source>

===Tlač súboru===
;Zadanie: V textovom súbore je uložený nejaký text. Vytvorte program, ktorý vytlačí tento súbor (odošle ho na tlačiareň). Program sa spýta na názov súboru. Po zadaní názvu súboru, tento vytlačí.

;Analýza problému: Zo súboru budeme čítať po znaku, pokiaľ nenarazíme na koniec súboru. Prečítaný znak ihneď odošleme na tlačiareň. Tlačiareň si možno predstaviť ako jednoduchý textový súbor, do ktorého budeme zapisovať. Jediná vec, čím sa líši od textového súboru je špeciálny názov tlačiarne. V prostredí Windows má tlačiareň názov $LPT. Tento súbor si otvoríme na zápis a budeme doňho zapisovať. To, čo tam zapíšeme, sa vytlačí.

<source lang="c" line>
#include <stdio.h>
void main(void)
{

FILE *fp,*printer;
char filename[25];
char c;
printf("Zadaj nazov suboru: ");
scanf("%s",filename);
fp = fopen(filename,"r");
printer=fopen("$LPT","w");
/* printer=fopen("PRN","w"); pre DOS */
if (fp == NULL) printf("Zadany subor (%s) neexistuje\n",filename);
else if (printer==NULL)printf("Tlaciaren neexistuje\n");
else
{

do
{
c = fgetc(fp); /* nacitaj 1 znak zo suboru */
if (c != EOF)
{
putchar(c);
putc(c,printer);
}
} while (c != EOF); /* opakuje az po koniec suboru */

}
fclose(fp);
fclose(printer);
}
</source>

===Kopírovanie súboru===
;Zadanie: Vytvorte program, ktorý skopíruje obsah jedného súboru do druhého súboru. Názvy súborov načítajte v programe z klávesnice. Pri kopírovaní zmeňte všetky malé písmená na veľké.

;Analýza problému: Zo súboru budeme čítať po slovách (mohli by sme aj po znakoch) a každé prečítané slovo skonvertujeme na slovo s veľkými písmenami. Na toto nám poslúži funkcia strupr definovaná v knižnici string.h, ktorá skonvertuje malé písmená na veľké. Funkcia strupr vracia ukazovateľ na char, preto si musíme definovať pomocnú premennú (char *slovo_upr;), v ktorej bude slovo skonvertované na veľké písmená.

<source lang="c" line>
#include <stdio.h>
#include <string.h>
void main()
{

FILE *f1,*f2;
int c;
char zdroj[20],ciel[20];
printf("\nZadaj nazov zdrojoveho suboru: ");
scanf("%s",zdroj);
printf("\nZadaj nazov cieloveho suboru: ");
scanf("%s",ciel);
f1 = fopen(zdroj,"r"); // subor z ktoreho budem citat
f2 = fopen(ciel,"w"); // subor zo ktoreho budem zapisovat
char slovo[50], *slovo_upr;
if(f1==NULL)
printf("Subor %s sa nepodarilo otvorit", zdroj);
else
{
do // v cykle
{
fscanf(f1,"%s",slovo); // citaj retazce po slovach
slovo_upr =strupr(slovo); //konvertuj na velke pismena
fprintf(f2,"%s ", slovo_upr); // a zapis do suboru
} while (!feof(f1)); // pokial nenarazis na koniec suboru
fclose(f1); // nakoniec zatvor subory
fclose(f2);
}

}
</source>

===Analýza dát===
;Zadanie: V súbore udaje.txt sa nachádzajú celé čísla oddelené od seba medzerou alebo znakom ‘\n’ (nový riadok). Tieto čísla by mali byť v rozsahu 0 až 100. Avšak môže sa stať, že sú tam aj väčšie čísla. Úlohou je skopírovať tieto čísla zo súboru udaje.txt do súboru upravene.txt. Avšak len tie, ktoré sú v dovolenom intervale – t.j. v rozsahu 0 až 100.

;Analýza problému: Keďže vieme, že v súbore sú len čísla, budeme zo súboru čítať len celé čísla (formát %d). Ak bude prečítané číslo v dovolenom intervale, tak ho zapíšeme do súboru upravene.txt.
<source lang="c" line>
#include <stdio.h>
void main()
{

FILE *fp,*upr;
int c;
fp =fopen("udaje.txt","r"); // subor, z ktoreho budem citat
if (fp == NULL) printf("Subor udaje.txt neexistuje\n");
else // ak subor existuje
{
upr =fopen("upravene.txt","w"); //subor, do ktoreho budem zapisovat
do // v cykle
{
fscanf(fp,"%d",&c); // citaj cisla
if( (c>0) && (c<101) ) // ak je cislo v danom intervale
fprintf(upr,"%d ",c); // a zapis do suboru
} while (!feof(fp)); // pokial nenarazis na koniec suboru
fclose(fp); // nakoniec zatvor subory
fclose(upr);
}

}
</source>

Jazyk C (príklady) - Cykly

2020-05-19T21:24:46Z

PatrikC: /* Test na prvočíslo */

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

==Obsah==
V tejto kapitole budú ukázané príklady s použitím cyklov. Na pochopenie týchto príkladov je nutné vedieť syntax a sémantiku príkazov while, do-while a for.

===Cyklus while===
Cyklus while je cyklus s podmienkou na začiatku. Pri každom opakovaní cyklu sa najskôr vyhodnotí podmienka a v prípade, že je pravdivá cyklus sa vykonáva (resp. vykonáva sa príkaz v cykle)

<source lang="c">
while(podmienka)
prikaz;
</source>

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku. (Toto platí aj pre do-while)

<source lang="c">
while(podmienka)
{
prikaz1;
prikaz2;
}
</source>

===Cyklus do while===
Cyklus do-while je cyklus s podmienkou na konci. Najskôr sa vykoná telo cyklu (teda prikaz) a na konci syklu sa vyhodnotí pravdivosť podmienky. V prípade ak je podmienka pravdivá, cyklus sa opäť vykoná

<source lang="c">
do
prikaz;
while(podmienka);
</source>

===Cyklus for===
Cyklus for sa používa najmä v prípadoch, ak dopredu poznáme počet opakovaní cyklu.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
prikaz;
</source>

Pred samotným spustením cyklu sa vykoná inicializácia. Toto sa vykoná len raz. Cyklus sa bude opakovať, pokiaľ je podmienka pravdivá. Ak je teda podmienka pravdivá, vykoná sa príkaz. Na konci cyklu sa vždy ešte vykoná vyraz. Všetky tri časti (inicializacia, podmienka, vyraz ) sú nepovinné, teda nemusia sa uvádzať.

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
{
prikaz1;
prikaz2;
}
</source>

==Príklady==
===Faktúra===
;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý zráta celkovú sumu položiek faktúry. Prvý údaj, ktorý načítate bude číselný údaj pocet, ktoré nám hovorí o počte položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcich cenu položky).

;Analýza problému: Keďže dopredu nikdy nevieme, koľko položiek je na faktúre, musíme použiť cyklus. Po načítaní hodnoty počet, vieme koľko položiek budeme načítavať – teda vieme, koľkokrát sa bude cyklus opakovať. V každom opakovaní cyklu načítame jednu hodnotu a zároveň ju pripočítame do celkovej sumy všetkých položiek. V príklade bude ukázané použitie troch základných typov cyklov.

<source lang="c" line>
#include<stdio.h>
void main(){
int suma=0,polozka,pocet;
printf(“Zadaj pocet nacitavanych poloziek”);
scanf(“%d”,&pocet);

/* cyklus pre nacitanie vsetkych poloziek */

printf(“Suma vsetkych poloziek=%d “,suma);
}
</source>

Nasledujúce časti kódov treba doplniť po jednom do programu vyššie.

<source lang="c" line>
/* cyklus while */
while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
{
scanf(“%d“,&polozka);
suma+=polozka;
pocet--; // v kazdom cykle znizime pocet o 1
}
</source>

<source lang="c" line>
/* cyklus do-while */
do{
scanf(“%d“,&polozka);
suma+=polozka;
pocet–-; // v kazdom cykle znizime pocet o 1
} while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
</source>

<source lang="c" line>
/* cyklus for */
// i je pomocna premenna, na zaciatku ma hodnotu 0, kazdy cyklus zvysi
for(int i=0 ; i<pocet ; i++){
// svoju hodnotu o 1, a cyklus opakujeme pokial je i mensie ako pocet
scanf(“%d“,&polozka);
suma+=polozka;
}
</source>

<source lang="c" line>
/* cyklus for (2) */
for( ; pocet>0 ; pocet –-) // pozri komentar k cyklu while
{
scanf(“%d“,&polozka);
suma+=polozka;
}
</source>

===Násobenie===
;Zadanie: Úlohou je vynásobiť 2 celé čísla x a y, ale bez použitia operátora *. Dovolené je použiť len operátor sčítania +.
;Analýza problému: Úloha nájdenia súčinu x*y len pomocou operátora sčítavania sa dá jednoducho naprogramovať, pretože súčin x*y=x+x+...+x, kde x sčítavame y krát. Teda stačí nám vytvoriť cyklus, ktorý sa bude opakovať y krát a v každom cykle sa hodnota x pripočíta do čiastočného výsledku.

<source lang="c" line>
#include<stdio.h>
void main(){
int vysledok=0,x,y,pom_y;
printf("Zadaj dve cisla");
scanf("%d %d",&x,&y);
pom_y=y;
while(y>0){
vysledok+=x;
y--;
}
printf("%d * %d = %d ",x,pom_y,vysledok);
}
</source>

Ako alternatívu môžeme (riadky 7-10) použiť cyklus for:
<source lang="c" line>
for( ; y>0 ; y--){
vysledok+=x;
}
</source>

===Umocňovanie===
;Zadanie:Navrhnite program, ktorý vypočíta mocninovú funkciu ab, pre a≥0, b≥0. Vstup do programu budú dve kladné nezáporné čísla a a b. Výstup bude hodnota ab. Príklad urobte pomocou príkazu while a for.

;Analýza problému: Tento príklad je veľmi podobný s predchádzajúcim, pretože ab=a*a*…*a, kde a budeme násobiť b krát.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=1,a,b,tmp_b;
printf("Zadaj dve cisla");
scanf("%d %d”,&a,&b);
tmp_b=b;
while(b>0)
{ vysledok*=a;
b–-;
}
printf("%d * %d = %d ",a,tmp_b,vysledok);

}

// pouzitie prikazu for
for(int i=0 ; i

===Najväčší spoločný deliteľ===
;Zadanie: Pri mnohých matematických operáciách je potrebné poznať najväčší spoločný deliteľ (NSD) dvoch čísel. Navrhnite algoritmus pre nájdenie NSD pomocou Euklidovho algoritmu. (Euklidov algoritmus pracuje na princípe opakovaného vzájomného odčítavania vstupných hodnôt a to vždy menší od väčšieho pokiaľ nie sú obe hodnoty rovnaké. Toto číslo je potom NSD.)

;Analýza problému: Na lepšiu predstavivosť funkcionality tohto algoritmu nám poslúži nasledujúci vývojový diagram. Prvý krok v algoritme (okrem načítania vstupných hodnôt) je urobiť cyklus, ktorý sa bude opakovať, pokiaľ je a a b rôzne. V tele cyklu bude podmienka, kde budeme zisťovať, ktoré z dvoch (a,b) čísel je väčšie. Potom od väčšieho odčítame menšie.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a,b;
int pa=a, pb=b; // pomocne premenne, nie su nutne
printf("Zadaj dve cisla");
scanf("%d %d",&a,&b);
while(a!=b){
if(a>b)
a=a-b;
else
b=b-a;
}
printf("nsd(%d, %d) = %d ",pa,pb,a);

}
</source>

===Test na prvočíslo===
;Zadanie: Navrhnite program, ktorý zistí či zadané číslo a je prvočíslo.

;Analýza problému: Číslo a budeme postupne celočíselne deliť číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok, povieme že číslo a je prvočíslo. Hodnotu čísla n určíme nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. Túto podmienku si dokážeme ľahko odvodiť. Majme napr. a=37. podiel=(37/2)=18. Teda pri zvyšovaní premennej del už nemusíme ísť za hranicu 18, lebo číslo 37 určite nie je deliteľné bezo zvyšku číslom väčším ako 18. Ďalej delíme podiel=(37/3)=10. Tento krok algoritmu nám teda povedal že horná hranica zvyšovania premennej del je 10, lebo neexistuje číslo väčšie ako 10, ktoré by delilo číslo 37 bezo zvyšku. Postupne sa dopracujeme k hranici 6. Na začiatku programu predpokladáme, že číslo a je prvočíslo (prvocislo=1) , čo sa snažíme v programe vyvrátiť (prvocislo=0). Výstup z algoritmu nám bude hovoriť, či a je prvočíslo. Ak áno, výstup bude 1, ak nie potom bude výstup 0. (Možná úprava: číslo n sa dá vypočítať jednoducho. n=celá časť z a1/2 ). Algoritmus naznačuje nasledujúci vývojový diagram.

;Ukážka:
*a=23
*a del podiel
*23 / 2 = 11 zv 1
*23 / 3 = 7 zv 2
*23 / 4 = 5 zv 3
*23 / 5 = 4 zv 3 del > podiel, koniec, a je prvočíslo
*23 je prvočíslo.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a;
printf(“Zadaj cislo, ktore chces testovat na prvocislo\n”);

scanf("%d",&a);
int del=2,prvocislo=1,podiel,zv;
do
{
podiel=a/del;
zv=a%del;
del++;
if(zv==0){
del=podiel+1;
prvocislo=0;
}

}while(podiel>del);
if(prvocislo==1)
printf("%d je prvocislo“,a);
else
printf("%d nie je prvocislo“,a);

}
</source>

===Výpočet čísla pí===
;Zadanie: Existuje nekonečný rad, ktorého súčtom je číslo PÍ. (vzťah PI.1). Ak budeme i zväčšovať až do nekonečna, dostaneme presnú hodnotu čísla PÍ. Vypočítajte číslo PI čo najpresnejšie. Presnosť výpočtu závisí od toho, pokiaľ budeme zväčšovať číslo i. Nájdite také n (i=0…n) , pri ktorom je výsledok presný na 15 desatinných miest.

;Analýza problému: Rozpísaním vzťahu PI.1 dostaneme vzťah PI.2. Úlohou je zvoliť vhodné n. Program urobíme tak, že na začiatku sa načíta číslo n a program vypočíta číslo PÍ s daným n. Číslo n musí byť dostatočne veľké, aby hodnota PÍ bola dostatočne presná. V samotnom výpočte sčítavame zlomky, ktorých menovatele sú iba nepárne čísla. To, aby boli čísla nepárne zabezpečíme tak, že menovateľ bude: 2*i+1. Ak dosadíme ľubovoľné i, dostaneme nepárne číslo. Druh[ vec, ktorú musíme vyriešiť je striedanie znamienok v súčte. Vytvoríme si premennú znamienko, ktorá bude mať hodnotu 1 alebo -1. V každom cykle budeme túto hodnotu meniť.

<source lang="c" line>
#include<stdio.h>
void main()
{
double pi=0;
int znamienko=1;
long int n;
scanf("%ld",&n);
for(int i=0;i<n ;i++)
{
pi+=znamienko*4.0/(2*i+1);
znamienko=-znamienko;
}
printf("PI=%.15f\n",pi);
}
</source>

Jazyk C (príklady) - Cykly

2020-05-19T21:19:10Z

PatrikC: /* Test na prvočíslo */

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

==Obsah==
V tejto kapitole budú ukázané príklady s použitím cyklov. Na pochopenie týchto príkladov je nutné vedieť syntax a sémantiku príkazov while, do-while a for.

===Cyklus while===
Cyklus while je cyklus s podmienkou na začiatku. Pri každom opakovaní cyklu sa najskôr vyhodnotí podmienka a v prípade, že je pravdivá cyklus sa vykonáva (resp. vykonáva sa príkaz v cykle)

<source lang="c">
while(podmienka)
prikaz;
</source>

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku. (Toto platí aj pre do-while)

<source lang="c">
while(podmienka)
{
prikaz1;
prikaz2;
}
</source>

===Cyklus do while===
Cyklus do-while je cyklus s podmienkou na konci. Najskôr sa vykoná telo cyklu (teda prikaz) a na konci syklu sa vyhodnotí pravdivosť podmienky. V prípade ak je podmienka pravdivá, cyklus sa opäť vykoná

<source lang="c">
do
prikaz;
while(podmienka);
</source>

===Cyklus for===
Cyklus for sa používa najmä v prípadoch, ak dopredu poznáme počet opakovaní cyklu.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
prikaz;
</source>

Pred samotným spustením cyklu sa vykoná inicializácia. Toto sa vykoná len raz. Cyklus sa bude opakovať, pokiaľ je podmienka pravdivá. Ak je teda podmienka pravdivá, vykoná sa príkaz. Na konci cyklu sa vždy ešte vykoná vyraz. Všetky tri časti (inicializacia, podmienka, vyraz ) sú nepovinné, teda nemusia sa uvádzať.

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
{
prikaz1;
prikaz2;
}
</source>

==Príklady==
===Faktúra===
;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý zráta celkovú sumu položiek faktúry. Prvý údaj, ktorý načítate bude číselný údaj pocet, ktoré nám hovorí o počte položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcich cenu položky).

;Analýza problému: Keďže dopredu nikdy nevieme, koľko položiek je na faktúre, musíme použiť cyklus. Po načítaní hodnoty počet, vieme koľko položiek budeme načítavať – teda vieme, koľkokrát sa bude cyklus opakovať. V každom opakovaní cyklu načítame jednu hodnotu a zároveň ju pripočítame do celkovej sumy všetkých položiek. V príklade bude ukázané použitie troch základných typov cyklov.

<source lang="c" line>
#include<stdio.h>
void main()
{

int suma=0,polozka,pocet;
printf(“Zadaj pocet nacitavanych poloziek”);
scanf(“%d”,&pocet);

/* cyklus pre nacitanie vsetkych poloziek */

printf(“Suma vsetkych poloziek=%d “,suma);

}

// nasledujuce casti kodov treba doplnit (po jednom) do programu

// cyklus while

while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
{
scanf(“%d“,&polozka);
suma+=polozka;
pocet--; // v kazdom cykle znizime pocet o 1
}

//cyklus do-while
do
{

scanf(“%d“,&polozka);
suma+=polozka;
pocet–-; // v kazdom cykle znizime pocet o 1

} while(pocet!=0)// cyklus sa opakuje pokial je hodnota pocet rozna od nuly

//cyklus for
for(int i=0 ; i<pocet ; i++) // i je pomocna premenna, na zaciatku ma hodnotu 0, kazdy cyklus zvysi
{ // svoju hodnotu o 1, a cyklus opakujeme pokial je i mensie ako pocet

scanf(“%d“,&polozka);
suma+=polozka;

}

//cyklus for (2)
for( ; pocet>0 ; pocet –-) // pozri komentar k cyklu while
{

scanf(“%d“,&polozka);
suma+=polozka;

}
</source>

===Násobenie===
;Zadanie: Úlohou je vynásobiť 2 celé čísla x a y, ale bez použitia operátora *. Dovolené je použiť len operátor sčítania +.
;Analýza problému: Úloha nájdenia súčinu x*y len pomocou operátora sčítavania sa dá jednoducho naprogramovať, pretože súčin x*y=x+x+...+x, kde x sčítavame y krát. Teda stačí nám vytvoriť cyklus, ktorý sa bude opakovať y krát a v každom cykle sa hodnota x pripočíta do čiastočného výsledku.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=0,x,y,pom_y;
printf("Zadaj dve cisla");
scanf("%d %d",&x,&y);
pom_y=y;
while(y>0)
{ vysledok+=x;
y–-;
}
printf("%d * %d = %d ",x,pom_y,vysledok);
}

// pouzitie prikazu for
for( ; y>0 ; y–-)
vysledok+=x;
</source>

===Umocňovanie===
;Zadanie:Navrhnite program, ktorý vypočíta mocninovú funkciu ab, pre a≥0, b≥0. Vstup do programu budú dve kladné nezáporné čísla a a b. Výstup bude hodnota ab. Príklad urobte pomocou príkazu while a for.

;Analýza problému: Tento príklad je veľmi podobný s predchádzajúcim, pretože ab=a*a*…*a, kde a budeme násobiť b krát.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=1,a,b,tmp_b;
printf("Zadaj dve cisla");
scanf("%d %d”,&a,&b);
tmp_b=b;
while(b>0)
{ vysledok*=a;
b–-;
}
printf("%d * %d = %d ",a,tmp_b,vysledok);

}

// pouzitie prikazu for
for(int i=0 ; i

===Najväčší spoločný deliteľ===
;Zadanie: Pri mnohých matematických operáciách je potrebné poznať najväčší spoločný deliteľ (NSD) dvoch čísel. Navrhnite algoritmus pre nájdenie NSD pomocou Euklidovho algoritmu. (Euklidov algoritmus pracuje na princípe opakovaného vzájomného odčítavania vstupných hodnôt a to vždy menší od väčšieho pokiaľ nie sú obe hodnoty rovnaké. Toto číslo je potom NSD.)

;Analýza problému: Na lepšiu predstavivosť funkcionality tohto algoritmu nám poslúži nasledujúci vývojový diagram. Prvý krok v algoritme (okrem načítania vstupných hodnôt) je urobiť cyklus, ktorý sa bude opakovať, pokiaľ je a a b rôzne. V tele cyklu bude podmienka, kde budeme zisťovať, ktoré z dvoch (a,b) čísel je väčšie. Potom od väčšieho odčítame menšie.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a,b;
int pa=a, pb=b; // pomocne premenne, nie su nutne
printf("Zadaj dve cisla");
scanf("%d %d",&a,&b);
while(a!=b){
if(a>b)
a=a-b;
else
b=b-a;
}
printf("nsd(%d, %d) = %d ",pa,pb,a);

}
</source>

===Test na prvočíslo===
;Zadanie: Navrhnite program, ktorý zistí či zadané číslo a je prvočíslo.

;Analýza problému: Číslo a budeme postupne celočíselne deliť číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok, povieme že číslo a je prvočíslo. Hodnotu čísla n určíme nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. Túto podmienku si dokážeme ľahko odvodiť. Majme napr. a=37. podiel=(37/2)=18. Teda pri zvyšovaní premennej del už nemusíme ísť za hranicu 18, lebo číslo 37 určite nie je deliteľné bezo zvyšku číslom väčším ako 18. Ďalej delíme podiel=(37/3)=10. Tento krok algoritmu nám teda povedal že horná hranica zvyšovania premennej del je 10, lebo neexistuje číslo väčšie ako 10, ktoré by delilo číslo 37 bezo zvyšku. Postupne sa dopracujeme k hranici 6. Na začiatku programu predpokladáme, že číslo a je prvočíslo (prvocislo=1) , čo sa snažíme v programe vyvrátiť (prvocislo=0). Výstup z algoritmu nám bude hovoriť, či a je prvočíslo. Ak áno, výstup bude 1, ak nie potom bude výstup 0. (Možná úprava: číslo n sa dá vypočítať jednoducho. n=celá časť z a1/2 ). Algoritmus naznačuje nasledujúci vývojový diagram.

;Ukážka:
*a=23
*a del podiel
*23 / 2 = 11 zv 1
*23 / 3 = 7 zv 2
*23 / 4 = 5 zv 3
*23 / 5 = 4 zv 3 del > podiel, koniec, a je prvočíslo
*23 je prvočíslo.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a;
printf(“Zadaj cislo, ktore chces testovat na prvocislo\n”);

scanf("%d",&a);
int del=2,prvocislo=1,podiel,zv;
do
{

podiel=a/del;
zv=a%del;
del++;
if(zv==0)
{
del=podiel+1;
prvocislo=0;
}

}while(podiel>del);
if(prvocislo==1)
printf("%d je prvocislo“,a);
else
printf("%d nie je prvocislo“,a);

}
</source>

===Výpočet čísla pí===
;Zadanie: Existuje nekonečný rad, ktorého súčtom je číslo PÍ. (vzťah PI.1). Ak budeme i zväčšovať až do nekonečna, dostaneme presnú hodnotu čísla PÍ. Vypočítajte číslo PI čo najpresnejšie. Presnosť výpočtu závisí od toho, pokiaľ budeme zväčšovať číslo i. Nájdite také n (i=0…n) , pri ktorom je výsledok presný na 15 desatinných miest.

;Analýza problému: Rozpísaním vzťahu PI.1 dostaneme vzťah PI.2. Úlohou je zvoliť vhodné n. Program urobíme tak, že na začiatku sa načíta číslo n a program vypočíta číslo PÍ s daným n. Číslo n musí byť dostatočne veľké, aby hodnota PÍ bola dostatočne presná. V samotnom výpočte sčítavame zlomky, ktorých menovatele sú iba nepárne čísla. To, aby boli čísla nepárne zabezpečíme tak, že menovateľ bude: 2*i+1. Ak dosadíme ľubovoľné i, dostaneme nepárne číslo. Druh[ vec, ktorú musíme vyriešiť je striedanie znamienok v súčte. Vytvoríme si premennú znamienko, ktorá bude mať hodnotu 1 alebo -1. V každom cykle budeme túto hodnotu meniť.

<source lang="c" line>
#include<stdio.h>
void main()
{
double pi=0;
int znamienko=1;
long int n;
scanf("%ld",&n);
for(int i=0;i<n ;i++)
{
pi+=znamienko*4.0/(2*i+1);
znamienko=-znamienko;
}
printf("PI=%.15f\n",pi);
}
</source>

Jazyk C (príklady) - Cykly

2020-05-19T21:18:26Z

PatrikC: /* Najväčší spoločný deliteľ */

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

==Obsah==
V tejto kapitole budú ukázané príklady s použitím cyklov. Na pochopenie týchto príkladov je nutné vedieť syntax a sémantiku príkazov while, do-while a for.

===Cyklus while===
Cyklus while je cyklus s podmienkou na začiatku. Pri každom opakovaní cyklu sa najskôr vyhodnotí podmienka a v prípade, že je pravdivá cyklus sa vykonáva (resp. vykonáva sa príkaz v cykle)

<source lang="c">
while(podmienka)
prikaz;
</source>

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku. (Toto platí aj pre do-while)

<source lang="c">
while(podmienka)
{
prikaz1;
prikaz2;
}
</source>

===Cyklus do while===
Cyklus do-while je cyklus s podmienkou na konci. Najskôr sa vykoná telo cyklu (teda prikaz) a na konci syklu sa vyhodnotí pravdivosť podmienky. V prípade ak je podmienka pravdivá, cyklus sa opäť vykoná

<source lang="c">
do
prikaz;
while(podmienka);
</source>

===Cyklus for===
Cyklus for sa používa najmä v prípadoch, ak dopredu poznáme počet opakovaní cyklu.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
prikaz;
</source>

Pred samotným spustením cyklu sa vykoná inicializácia. Toto sa vykoná len raz. Cyklus sa bude opakovať, pokiaľ je podmienka pravdivá. Ak je teda podmienka pravdivá, vykoná sa príkaz. Na konci cyklu sa vždy ešte vykoná vyraz. Všetky tri časti (inicializacia, podmienka, vyraz ) sú nepovinné, teda nemusia sa uvádzať.

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
{
prikaz1;
prikaz2;
}
</source>

==Príklady==
===Faktúra===
;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý zráta celkovú sumu položiek faktúry. Prvý údaj, ktorý načítate bude číselný údaj pocet, ktoré nám hovorí o počte položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcich cenu položky).

;Analýza problému: Keďže dopredu nikdy nevieme, koľko položiek je na faktúre, musíme použiť cyklus. Po načítaní hodnoty počet, vieme koľko položiek budeme načítavať – teda vieme, koľkokrát sa bude cyklus opakovať. V každom opakovaní cyklu načítame jednu hodnotu a zároveň ju pripočítame do celkovej sumy všetkých položiek. V príklade bude ukázané použitie troch základných typov cyklov.

<source lang="c" line>
#include<stdio.h>
void main()
{

int suma=0,polozka,pocet;
printf(“Zadaj pocet nacitavanych poloziek”);
scanf(“%d”,&pocet);

/* cyklus pre nacitanie vsetkych poloziek */

printf(“Suma vsetkych poloziek=%d “,suma);

}

// nasledujuce casti kodov treba doplnit (po jednom) do programu

// cyklus while

while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
{
scanf(“%d“,&polozka);
suma+=polozka;
pocet--; // v kazdom cykle znizime pocet o 1
}

//cyklus do-while
do
{

scanf(“%d“,&polozka);
suma+=polozka;
pocet–-; // v kazdom cykle znizime pocet o 1

} while(pocet!=0)// cyklus sa opakuje pokial je hodnota pocet rozna od nuly

//cyklus for
for(int i=0 ; i<pocet ; i++) // i je pomocna premenna, na zaciatku ma hodnotu 0, kazdy cyklus zvysi
{ // svoju hodnotu o 1, a cyklus opakujeme pokial je i mensie ako pocet

scanf(“%d“,&polozka);
suma+=polozka;

}

//cyklus for (2)
for( ; pocet>0 ; pocet –-) // pozri komentar k cyklu while
{

scanf(“%d“,&polozka);
suma+=polozka;

}
</source>

===Násobenie===
;Zadanie: Úlohou je vynásobiť 2 celé čísla x a y, ale bez použitia operátora *. Dovolené je použiť len operátor sčítania +.
;Analýza problému: Úloha nájdenia súčinu x*y len pomocou operátora sčítavania sa dá jednoducho naprogramovať, pretože súčin x*y=x+x+...+x, kde x sčítavame y krát. Teda stačí nám vytvoriť cyklus, ktorý sa bude opakovať y krát a v každom cykle sa hodnota x pripočíta do čiastočného výsledku.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=0,x,y,pom_y;
printf("Zadaj dve cisla");
scanf("%d %d",&x,&y);
pom_y=y;
while(y>0)
{ vysledok+=x;
y–-;
}
printf("%d * %d = %d ",x,pom_y,vysledok);
}

// pouzitie prikazu for
for( ; y>0 ; y–-)
vysledok+=x;
</source>

===Umocňovanie===
;Zadanie:Navrhnite program, ktorý vypočíta mocninovú funkciu ab, pre a≥0, b≥0. Vstup do programu budú dve kladné nezáporné čísla a a b. Výstup bude hodnota ab. Príklad urobte pomocou príkazu while a for.

;Analýza problému: Tento príklad je veľmi podobný s predchádzajúcim, pretože ab=a*a*…*a, kde a budeme násobiť b krát.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=1,a,b,tmp_b;
printf("Zadaj dve cisla");
scanf("%d %d”,&a,&b);
tmp_b=b;
while(b>0)
{ vysledok*=a;
b–-;
}
printf("%d * %d = %d ",a,tmp_b,vysledok);

}

// pouzitie prikazu for
for(int i=0 ; i

===Najväčší spoločný deliteľ===
;Zadanie: Pri mnohých matematických operáciách je potrebné poznať najväčší spoločný deliteľ (NSD) dvoch čísel. Navrhnite algoritmus pre nájdenie NSD pomocou Euklidovho algoritmu. (Euklidov algoritmus pracuje na princípe opakovaného vzájomného odčítavania vstupných hodnôt a to vždy menší od väčšieho pokiaľ nie sú obe hodnoty rovnaké. Toto číslo je potom NSD.)

;Analýza problému: Na lepšiu predstavivosť funkcionality tohto algoritmu nám poslúži nasledujúci vývojový diagram. Prvý krok v algoritme (okrem načítania vstupných hodnôt) je urobiť cyklus, ktorý sa bude opakovať, pokiaľ je a a b rôzne. V tele cyklu bude podmienka, kde budeme zisťovať, ktoré z dvoch (a,b) čísel je väčšie. Potom od väčšieho odčítame menšie.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a,b;
int pa=a, pb=b; // pomocne premenne, nie su nutne
printf("Zadaj dve cisla");
scanf("%d %d",&a,&b);
while(a!=b){
if(a>b)
a=a-b;
else
b=b-a;
}
printf("nsd(%d, %d) = %d ",pa,pb,a);

}
</source>

===Test na prvočíslo===
;Zadanie: Navrhnite program, ktorý zistí či zadané číslo a je prvočíslo.

;Analýza problému: Číslo a budeme postupne celočíselne deliť číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok, povieme že číslo a je prvočíslo. Hodnotu čísla n určíme nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. Túto podmienku si dokážeme ľahko odvodiť. Majme napr. a=37. podiel=(37/2)=18. Teda pri zvyšovaní premennej del už nemusíme ísť za hranicu 18, lebo číslo 37 určite nie je deliteľné bezo zvyšku číslom väčším ako 18. Ďalej delíme podiel=(37/3)=10. Tento krok algoritmu nám teda povedal že horná hranica zvyšovania premennej del je 10, lebo neexistuje číslo väčšie ako 10, ktoré by delilo číslo 37 bezo zvyšku. Postupne sa dopracujeme k hranici 6. Na začiatku programu predpokladáme, že číslo a je prvočíslo (prvocislo=1) , čo sa snažíme v programe vyvrátiť (prvocislo=0). Výstup z algoritmu nám bude hovoriť, či a je prvočíslo. Ak áno, výstup bude 1, ak nie potom bude výstup 0. (Možná úprava: číslo n sa dá vypočítať jednoducho. n=celá časť z a1/2 ). Algoritmus naznačuje nasledujúci vývojový diagram.

Ukážka: a=23
a del podiel
23 / 2 = 11 zv 1
23 / 3 = 7 zv 2
23 / 4 = 5 zv 3
23 / 5 = 4 zv 3 del > podiel, koniec, a je prvočíslo
23 je prvočíslo.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a;
printf(“Zadaj cislo, ktore chces testovat na prvocislo\n”);

scanf("%d",&a);
int del=2,prvocislo=1,podiel,zv;
do
{

podiel=a/del;
zv=a%del;
del++;
if(zv==0)
{
del=podiel+1;
prvocislo=0;
}

}while(podiel>del);
if(prvocislo==1)
printf("%d je prvocislo“,a);
else
printf("%d nie je prvocislo“,a);

}
</source>

===Výpočet čísla pí===
;Zadanie: Existuje nekonečný rad, ktorého súčtom je číslo PÍ. (vzťah PI.1). Ak budeme i zväčšovať až do nekonečna, dostaneme presnú hodnotu čísla PÍ. Vypočítajte číslo PI čo najpresnejšie. Presnosť výpočtu závisí od toho, pokiaľ budeme zväčšovať číslo i. Nájdite také n (i=0…n) , pri ktorom je výsledok presný na 15 desatinných miest.

;Analýza problému: Rozpísaním vzťahu PI.1 dostaneme vzťah PI.2. Úlohou je zvoliť vhodné n. Program urobíme tak, že na začiatku sa načíta číslo n a program vypočíta číslo PÍ s daným n. Číslo n musí byť dostatočne veľké, aby hodnota PÍ bola dostatočne presná. V samotnom výpočte sčítavame zlomky, ktorých menovatele sú iba nepárne čísla. To, aby boli čísla nepárne zabezpečíme tak, že menovateľ bude: 2*i+1. Ak dosadíme ľubovoľné i, dostaneme nepárne číslo. Druh[ vec, ktorú musíme vyriešiť je striedanie znamienok v súčte. Vytvoríme si premennú znamienko, ktorá bude mať hodnotu 1 alebo -1. V každom cykle budeme túto hodnotu meniť.

<source lang="c" line>
#include<stdio.h>
void main()
{
double pi=0;
int znamienko=1;
long int n;
scanf("%ld",&n);
for(int i=0;i<n ;i++)
{
pi+=znamienko*4.0/(2*i+1);
znamienko=-znamienko;
}
printf("PI=%.15f\n",pi);
}
</source>

Jazyk C (príklady) - Cykly

2020-05-19T21:17:52Z

PatrikC: /* Umocňovanie */

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

==Obsah==
V tejto kapitole budú ukázané príklady s použitím cyklov. Na pochopenie týchto príkladov je nutné vedieť syntax a sémantiku príkazov while, do-while a for.

===Cyklus while===
Cyklus while je cyklus s podmienkou na začiatku. Pri každom opakovaní cyklu sa najskôr vyhodnotí podmienka a v prípade, že je pravdivá cyklus sa vykonáva (resp. vykonáva sa príkaz v cykle)

<source lang="c">
while(podmienka)
prikaz;
</source>

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku. (Toto platí aj pre do-while)

<source lang="c">
while(podmienka)
{
prikaz1;
prikaz2;
}
</source>

===Cyklus do while===
Cyklus do-while je cyklus s podmienkou na konci. Najskôr sa vykoná telo cyklu (teda prikaz) a na konci syklu sa vyhodnotí pravdivosť podmienky. V prípade ak je podmienka pravdivá, cyklus sa opäť vykoná

<source lang="c">
do
prikaz;
while(podmienka);
</source>

===Cyklus for===
Cyklus for sa používa najmä v prípadoch, ak dopredu poznáme počet opakovaní cyklu.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
prikaz;
</source>

Pred samotným spustením cyklu sa vykoná inicializácia. Toto sa vykoná len raz. Cyklus sa bude opakovať, pokiaľ je podmienka pravdivá. Ak je teda podmienka pravdivá, vykoná sa príkaz. Na konci cyklu sa vždy ešte vykoná vyraz. Všetky tri časti (inicializacia, podmienka, vyraz ) sú nepovinné, teda nemusia sa uvádzať.

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
{
prikaz1;
prikaz2;
}
</source>

==Príklady==
===Faktúra===
;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý zráta celkovú sumu položiek faktúry. Prvý údaj, ktorý načítate bude číselný údaj pocet, ktoré nám hovorí o počte položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcich cenu položky).

;Analýza problému: Keďže dopredu nikdy nevieme, koľko položiek je na faktúre, musíme použiť cyklus. Po načítaní hodnoty počet, vieme koľko položiek budeme načítavať – teda vieme, koľkokrát sa bude cyklus opakovať. V každom opakovaní cyklu načítame jednu hodnotu a zároveň ju pripočítame do celkovej sumy všetkých položiek. V príklade bude ukázané použitie troch základných typov cyklov.

<source lang="c" line>
#include<stdio.h>
void main()
{

int suma=0,polozka,pocet;
printf(“Zadaj pocet nacitavanych poloziek”);
scanf(“%d”,&pocet);

/* cyklus pre nacitanie vsetkych poloziek */

printf(“Suma vsetkych poloziek=%d “,suma);

}

// nasledujuce casti kodov treba doplnit (po jednom) do programu

// cyklus while

while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
{
scanf(“%d“,&polozka);
suma+=polozka;
pocet--; // v kazdom cykle znizime pocet o 1
}

//cyklus do-while
do
{

scanf(“%d“,&polozka);
suma+=polozka;
pocet–-; // v kazdom cykle znizime pocet o 1

} while(pocet!=0)// cyklus sa opakuje pokial je hodnota pocet rozna od nuly

//cyklus for
for(int i=0 ; i<pocet ; i++) // i je pomocna premenna, na zaciatku ma hodnotu 0, kazdy cyklus zvysi
{ // svoju hodnotu o 1, a cyklus opakujeme pokial je i mensie ako pocet

scanf(“%d“,&polozka);
suma+=polozka;

}

//cyklus for (2)
for( ; pocet>0 ; pocet –-) // pozri komentar k cyklu while
{

scanf(“%d“,&polozka);
suma+=polozka;

}
</source>

===Násobenie===
;Zadanie: Úlohou je vynásobiť 2 celé čísla x a y, ale bez použitia operátora *. Dovolené je použiť len operátor sčítania +.
;Analýza problému: Úloha nájdenia súčinu x*y len pomocou operátora sčítavania sa dá jednoducho naprogramovať, pretože súčin x*y=x+x+...+x, kde x sčítavame y krát. Teda stačí nám vytvoriť cyklus, ktorý sa bude opakovať y krát a v každom cykle sa hodnota x pripočíta do čiastočného výsledku.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=0,x,y,pom_y;
printf("Zadaj dve cisla");
scanf("%d %d",&x,&y);
pom_y=y;
while(y>0)
{ vysledok+=x;
y–-;
}
printf("%d * %d = %d ",x,pom_y,vysledok);
}

// pouzitie prikazu for
for( ; y>0 ; y–-)
vysledok+=x;
</source>

===Umocňovanie===
;Zadanie:Navrhnite program, ktorý vypočíta mocninovú funkciu ab, pre a≥0, b≥0. Vstup do programu budú dve kladné nezáporné čísla a a b. Výstup bude hodnota ab. Príklad urobte pomocou príkazu while a for.

;Analýza problému: Tento príklad je veľmi podobný s predchádzajúcim, pretože ab=a*a*…*a, kde a budeme násobiť b krát.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=1,a,b,tmp_b;
printf("Zadaj dve cisla");
scanf("%d %d”,&a,&b);
tmp_b=b;
while(b>0)
{ vysledok*=a;
b–-;
}
printf("%d * %d = %d ",a,tmp_b,vysledok);

}

// pouzitie prikazu for
for(int i=0 ; i

===Najväčší spoločný deliteľ===
;Zadanie: Pri mnohých matematických operáciách je potrebné poznať najväčší spoločný deliteľ (NSD) dvoch čísel. Navrhnite algoritmus pre nájdenie NSD pomocou Euklidovho algoritmu. (Euklidov algoritmus pracuje na princípe opakovaného vzájomného odčítavania vstupných hodnôt a to vždy menší od väčšieho pokiaľ nie sú obe hodnoty rovnaké. Toto číslo je potom NSD.)

;Analýza problému: Na lepšiu predstavivosť funkcionality tohto algoritmu nám poslúži nasledujúci vývojový diagram. Prvý krok v algoritme (okrem načítania vstupných hodnôt) je urobiť cyklus, ktorý sa bude opakovať, pokiaľ je a a b rôzne. V tele cyklu bude podmienka, kde budeme zisťovať, ktoré z dvoch (a,b) čísel je väčšie. Potom od väčšieho odčítame menšie.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a,b;
int pa=a, pb=b; // pomocne premenne, nie su nutne
printf("Zadaj dve cisla");
scanf("%d %d",&a,&b);
while(a!=b)
{ if(a>b)
a=a-b;
else
b=b-a;
}
printf("nsd(%d, %d) = %d ",pa,pb,a);

}
</source>

===Test na prvočíslo===
;Zadanie: Navrhnite program, ktorý zistí či zadané číslo a je prvočíslo.

;Analýza problému: Číslo a budeme postupne celočíselne deliť číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok, povieme že číslo a je prvočíslo. Hodnotu čísla n určíme nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. Túto podmienku si dokážeme ľahko odvodiť. Majme napr. a=37. podiel=(37/2)=18. Teda pri zvyšovaní premennej del už nemusíme ísť za hranicu 18, lebo číslo 37 určite nie je deliteľné bezo zvyšku číslom väčším ako 18. Ďalej delíme podiel=(37/3)=10. Tento krok algoritmu nám teda povedal že horná hranica zvyšovania premennej del je 10, lebo neexistuje číslo väčšie ako 10, ktoré by delilo číslo 37 bezo zvyšku. Postupne sa dopracujeme k hranici 6. Na začiatku programu predpokladáme, že číslo a je prvočíslo (prvocislo=1) , čo sa snažíme v programe vyvrátiť (prvocislo=0). Výstup z algoritmu nám bude hovoriť, či a je prvočíslo. Ak áno, výstup bude 1, ak nie potom bude výstup 0. (Možná úprava: číslo n sa dá vypočítať jednoducho. n=celá časť z a1/2 ). Algoritmus naznačuje nasledujúci vývojový diagram.

Ukážka: a=23
a del podiel
23 / 2 = 11 zv 1
23 / 3 = 7 zv 2
23 / 4 = 5 zv 3
23 / 5 = 4 zv 3 del > podiel, koniec, a je prvočíslo
23 je prvočíslo.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a;
printf(“Zadaj cislo, ktore chces testovat na prvocislo\n”);

scanf("%d",&a);
int del=2,prvocislo=1,podiel,zv;
do
{

podiel=a/del;
zv=a%del;
del++;
if(zv==0)
{
del=podiel+1;
prvocislo=0;
}

}while(podiel>del);
if(prvocislo==1)
printf("%d je prvocislo“,a);
else
printf("%d nie je prvocislo“,a);

}
</source>

===Výpočet čísla pí===
;Zadanie: Existuje nekonečný rad, ktorého súčtom je číslo PÍ. (vzťah PI.1). Ak budeme i zväčšovať až do nekonečna, dostaneme presnú hodnotu čísla PÍ. Vypočítajte číslo PI čo najpresnejšie. Presnosť výpočtu závisí od toho, pokiaľ budeme zväčšovať číslo i. Nájdite také n (i=0…n) , pri ktorom je výsledok presný na 15 desatinných miest.

;Analýza problému: Rozpísaním vzťahu PI.1 dostaneme vzťah PI.2. Úlohou je zvoliť vhodné n. Program urobíme tak, že na začiatku sa načíta číslo n a program vypočíta číslo PÍ s daným n. Číslo n musí byť dostatočne veľké, aby hodnota PÍ bola dostatočne presná. V samotnom výpočte sčítavame zlomky, ktorých menovatele sú iba nepárne čísla. To, aby boli čísla nepárne zabezpečíme tak, že menovateľ bude: 2*i+1. Ak dosadíme ľubovoľné i, dostaneme nepárne číslo. Druh[ vec, ktorú musíme vyriešiť je striedanie znamienok v súčte. Vytvoríme si premennú znamienko, ktorá bude mať hodnotu 1 alebo -1. V každom cykle budeme túto hodnotu meniť.

<source lang="c" line>
#include<stdio.h>
void main()
{
double pi=0;
int znamienko=1;
long int n;
scanf("%ld",&n);
for(int i=0;i<n ;i++)
{
pi+=znamienko*4.0/(2*i+1);
znamienko=-znamienko;
}
printf("PI=%.15f\n",pi);
}
</source>

Jazyk C (príklady) - Cykly

2020-05-19T21:17:43Z

PatrikC: /* Umocňovanie */

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

==Obsah==
V tejto kapitole budú ukázané príklady s použitím cyklov. Na pochopenie týchto príkladov je nutné vedieť syntax a sémantiku príkazov while, do-while a for.

===Cyklus while===
Cyklus while je cyklus s podmienkou na začiatku. Pri každom opakovaní cyklu sa najskôr vyhodnotí podmienka a v prípade, že je pravdivá cyklus sa vykonáva (resp. vykonáva sa príkaz v cykle)

<source lang="c">
while(podmienka)
prikaz;
</source>

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku. (Toto platí aj pre do-while)

<source lang="c">
while(podmienka)
{
prikaz1;
prikaz2;
}
</source>

===Cyklus do while===
Cyklus do-while je cyklus s podmienkou na konci. Najskôr sa vykoná telo cyklu (teda prikaz) a na konci syklu sa vyhodnotí pravdivosť podmienky. V prípade ak je podmienka pravdivá, cyklus sa opäť vykoná

<source lang="c">
do
prikaz;
while(podmienka);
</source>

===Cyklus for===
Cyklus for sa používa najmä v prípadoch, ak dopredu poznáme počet opakovaní cyklu.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
prikaz;
</source>

Pred samotným spustením cyklu sa vykoná inicializácia. Toto sa vykoná len raz. Cyklus sa bude opakovať, pokiaľ je podmienka pravdivá. Ak je teda podmienka pravdivá, vykoná sa príkaz. Na konci cyklu sa vždy ešte vykoná vyraz. Všetky tri časti (inicializacia, podmienka, vyraz ) sú nepovinné, teda nemusia sa uvádzať.

Ak potrebujeme v rámci cyklu vykonať viacero príkazov, treba ich uzatvoriť do bloku.

<source lang="c">
for(inicializacia ; podmienka ; vyraz )
{
prikaz1;
prikaz2;
}
</source>

==Príklady==
===Faktúra===
;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý zráta celkovú sumu položiek faktúry. Prvý údaj, ktorý načítate bude číselný údaj pocet, ktoré nám hovorí o počte položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcich cenu položky).

;Analýza problému: Keďže dopredu nikdy nevieme, koľko položiek je na faktúre, musíme použiť cyklus. Po načítaní hodnoty počet, vieme koľko položiek budeme načítavať – teda vieme, koľkokrát sa bude cyklus opakovať. V každom opakovaní cyklu načítame jednu hodnotu a zároveň ju pripočítame do celkovej sumy všetkých položiek. V príklade bude ukázané použitie troch základných typov cyklov.

<source lang="c" line>
#include<stdio.h>
void main()
{

int suma=0,polozka,pocet;
printf(“Zadaj pocet nacitavanych poloziek”);
scanf(“%d”,&pocet);

/* cyklus pre nacitanie vsetkych poloziek */

printf(“Suma vsetkych poloziek=%d “,suma);

}

// nasledujuce casti kodov treba doplnit (po jednom) do programu

// cyklus while

while(pocet!=0) // cyklus sa opakuje pokial je hodnota pocet rozna od nuly
{
scanf(“%d“,&polozka);
suma+=polozka;
pocet--; // v kazdom cykle znizime pocet o 1
}

//cyklus do-while
do
{

scanf(“%d“,&polozka);
suma+=polozka;
pocet–-; // v kazdom cykle znizime pocet o 1

} while(pocet!=0)// cyklus sa opakuje pokial je hodnota pocet rozna od nuly

//cyklus for
for(int i=0 ; i<pocet ; i++) // i je pomocna premenna, na zaciatku ma hodnotu 0, kazdy cyklus zvysi
{ // svoju hodnotu o 1, a cyklus opakujeme pokial je i mensie ako pocet

scanf(“%d“,&polozka);
suma+=polozka;

}

//cyklus for (2)
for( ; pocet>0 ; pocet –-) // pozri komentar k cyklu while
{

scanf(“%d“,&polozka);
suma+=polozka;

}
</source>

===Násobenie===
;Zadanie: Úlohou je vynásobiť 2 celé čísla x a y, ale bez použitia operátora *. Dovolené je použiť len operátor sčítania +.
;Analýza problému: Úloha nájdenia súčinu x*y len pomocou operátora sčítavania sa dá jednoducho naprogramovať, pretože súčin x*y=x+x+...+x, kde x sčítavame y krát. Teda stačí nám vytvoriť cyklus, ktorý sa bude opakovať y krát a v každom cykle sa hodnota x pripočíta do čiastočného výsledku.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=0,x,y,pom_y;
printf("Zadaj dve cisla");
scanf("%d %d",&x,&y);
pom_y=y;
while(y>0)
{ vysledok+=x;
y–-;
}
printf("%d * %d = %d ",x,pom_y,vysledok);
}

// pouzitie prikazu for
for( ; y>0 ; y–-)
vysledok+=x;
</source>

===Umocňovanie===
;Zadanie:Navrhnite program, ktorý vypočíta mocninovú funkciu ab, pre a≥0, b≥0. Vstup do programu budú dve kladné nezáporné čísla a a b. Výstup bude hodnota ab. Príklad urobte pomocou príkazu while a for.

;Analýza problému: Tento príklad je veľmi podobný s predchádzajúcim, pretože ab=a*a*…*a, kde a budeme násobiť b krát.

<source lang="c" line>
#include<stdio.h>
void main()
{

int vysledok=1,a,b,tmp_b;
printf("Zadaj dve cisla");
scanf("%d %d”,&a,&b);
tmp_b=b;
while(b>0)
{ vysledok*=a;
b–-;
}
printf("%d * %d = %d ",a,tmp_b,vysledok);

}

// pouzitie prikazu for
for(int i=0 ; i

===Najväčší spoločný deliteľ===
;Zadanie: Pri mnohých matematických operáciách je potrebné poznať najväčší spoločný deliteľ (NSD) dvoch čísel. Navrhnite algoritmus pre nájdenie NSD pomocou Euklidovho algoritmu. (Euklidov algoritmus pracuje na princípe opakovaného vzájomného odčítavania vstupných hodnôt a to vždy menší od väčšieho pokiaľ nie sú obe hodnoty rovnaké. Toto číslo je potom NSD.)

;Analýza problému: Na lepšiu predstavivosť funkcionality tohto algoritmu nám poslúži nasledujúci vývojový diagram. Prvý krok v algoritme (okrem načítania vstupných hodnôt) je urobiť cyklus, ktorý sa bude opakovať, pokiaľ je a a b rôzne. V tele cyklu bude podmienka, kde budeme zisťovať, ktoré z dvoch (a,b) čísel je väčšie. Potom od väčšieho odčítame menšie.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a,b;
int pa=a, pb=b; // pomocne premenne, nie su nutne
printf("Zadaj dve cisla");
scanf("%d %d",&a,&b);
while(a!=b)
{ if(a>b)
a=a-b;
else
b=b-a;
}
printf("nsd(%d, %d) = %d ",pa,pb,a);

}
</source>

===Test na prvočíslo===
;Zadanie: Navrhnite program, ktorý zistí či zadané číslo a je prvočíslo.

;Analýza problému: Číslo a budeme postupne celočíselne deliť číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok, povieme že číslo a je prvočíslo. Hodnotu čísla n určíme nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. Túto podmienku si dokážeme ľahko odvodiť. Majme napr. a=37. podiel=(37/2)=18. Teda pri zvyšovaní premennej del už nemusíme ísť za hranicu 18, lebo číslo 37 určite nie je deliteľné bezo zvyšku číslom väčším ako 18. Ďalej delíme podiel=(37/3)=10. Tento krok algoritmu nám teda povedal že horná hranica zvyšovania premennej del je 10, lebo neexistuje číslo väčšie ako 10, ktoré by delilo číslo 37 bezo zvyšku. Postupne sa dopracujeme k hranici 6. Na začiatku programu predpokladáme, že číslo a je prvočíslo (prvocislo=1) , čo sa snažíme v programe vyvrátiť (prvocislo=0). Výstup z algoritmu nám bude hovoriť, či a je prvočíslo. Ak áno, výstup bude 1, ak nie potom bude výstup 0. (Možná úprava: číslo n sa dá vypočítať jednoducho. n=celá časť z a1/2 ). Algoritmus naznačuje nasledujúci vývojový diagram.

Ukážka: a=23
a del podiel
23 / 2 = 11 zv 1
23 / 3 = 7 zv 2
23 / 4 = 5 zv 3
23 / 5 = 4 zv 3 del > podiel, koniec, a je prvočíslo
23 je prvočíslo.

<source lang="c" line>
#include<stdio.h>
void main()
{

int a;
printf(“Zadaj cislo, ktore chces testovat na prvocislo\n”);

scanf("%d",&a);
int del=2,prvocislo=1,podiel,zv;
do
{

podiel=a/del;
zv=a%del;
del++;
if(zv==0)
{
del=podiel+1;
prvocislo=0;
}

}while(podiel>del);
if(prvocislo==1)
printf("%d je prvocislo“,a);
else
printf("%d nie je prvocislo“,a);

}
</source>

===Výpočet čísla pí===
;Zadanie: Existuje nekonečný rad, ktorého súčtom je číslo PÍ. (vzťah PI.1). Ak budeme i zväčšovať až do nekonečna, dostaneme presnú hodnotu čísla PÍ. Vypočítajte číslo PI čo najpresnejšie. Presnosť výpočtu závisí od toho, pokiaľ budeme zväčšovať číslo i. Nájdite také n (i=0…n) , pri ktorom je výsledok presný na 15 desatinných miest.

;Analýza problému: Rozpísaním vzťahu PI.1 dostaneme vzťah PI.2. Úlohou je zvoliť vhodné n. Program urobíme tak, že na začiatku sa načíta číslo n a program vypočíta číslo PÍ s daným n. Číslo n musí byť dostatočne veľké, aby hodnota PÍ bola dostatočne presná. V samotnom výpočte sčítavame zlomky, ktorých menovatele sú iba nepárne čísla. To, aby boli čísla nepárne zabezpečíme tak, že menovateľ bude: 2*i+1. Ak dosadíme ľubovoľné i, dostaneme nepárne číslo. Druh[ vec, ktorú musíme vyriešiť je striedanie znamienok v súčte. Vytvoríme si premennú znamienko, ktorá bude mať hodnotu 1 alebo -1. V každom cykle budeme túto hodnotu meniť.

<source lang="c" line>
#include<stdio.h>
void main()
{
double pi=0;
int znamienko=1;
long int n;
scanf("%ld",&n);
for(int i=0;i<n ;i++)
{
pi+=znamienko*4.0/(2*i+1);
znamienko=-znamienko;
}
printf("PI=%.15f\n",pi);
}
</source>

Jazyk C (príklady) - Podmienky

2020-05-19T21:15:30Z

PatrikC: /* Teória */

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

V tejto časti sú ukázané príklady s využitím podmieného príkazu. Na pochopenie týchto príkladov sa predpokladá zvládnutie syntaxe a sémantiky príkazov if a switch.

__TOC__
== Teória==
===if===
Príkaz if má 2 verzie.

;1. Skrátená verzia: má len jednu vetvu.
<source lang="c" line>
if(podmienka)
príkaz;
</source>
;Význam: ak je podmienka pravdivá, vykoná sa príkaz.

;2. Úplná verzia: má obe vetvy.
<source lang="c" line>

if(podmienka)
príkaz;
else
príkaz2;

</source>

;Význam: ak je podmienka pravdivá vykoná sa príkaz1, v opačnom prípade sa vykoná príkaz2.
;3. Rozšírená verzia: vo vetvách má viacero príkazov.
<source lang="c" line>
if(podmienka)
{
príkaz1;
príkaz2;
}
else
{
príkaz3;
príkaz4;
}
</source>
;Význam: Význam je rovnaký ako v druhom prípade, avšak teraz vykonávame viacero príkazov. V prípade ak cheme vykonať viacero príkazov, musíme tieto uzatvoriť do bloku {}.

===switch===
switch - viacnásobný výber.
<source lang="c" line>
switch(vyraz)
{
case hod_1: prikaz1; break;
case hod_2: prikaz2; break;

case hod_n: prikazn; break;
default: prikazD;
}
</source>
;Význam: vyraz môže nadobúdať celočíselné hodnoty hod_1, hod_2, ...,hod_n, alebo nejaké iné celočíselné hodnoty. V prípade že vyraz má hodnotu hod_1, vykoná sa príkaz1 a príkaz switch sa ukončí. V prípade že vyraz má hodnotu hod_2, vykoná sa príkaz2 a príkaz switch sa ukončí. Ak nadobudne vyraz nejakú inú hodnotu, vykoná sa príkazD. Ak by sa príkaz break neuviedol, vykonajú sa všetky vetvy príkazu switch postupne.

==Príklady==

===Delenie nulou 1===
;Zadanie: Vytvorte program, ktorý načíta 2 čísla a vypíše ich podiel. Ošetrite prípad, keď deliteľ je nulový (operácia delenie 0 nie je definovaná).

;Analýza problému: V prípade delenia nulou sa program ukončí chybovou hláškou „delenie nulou“. Tento prípad ošetríme vhodným použítím podmieňovacieho príkazu. Operáciu delenia budeme robiť iba v prípade, ak je deliteľ rôzny od nuly.

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

void main()
{

float x,y;
printf("Zadajte 2 reálne čísla. \n");
scanf("%f %f",&x,&y);
if(y!=0)
printf("podiel x/y=%.3f",x/y);

}
</source>

===Delenie nulou 2===
;Zadanie: Uvažujeme predchádzajúci príklad s tou zmenou, že ak má deliteľ hodnotu 0, program vypíše upozornenie „Nulou sa delit neda“. V opačnom prípade (teda, keď je všetko v poriadku) sa vypíše podiel.

;Analýza problému: V tomto prípade použijeme rozšírenú formu príkazu if: if-else.
<source lang="c" line>
#include<stdio.h>

void main()
{

float x,y;
printf("Zadajte 2 reálne čísla. \n");
scanf("%f %f",&x,&y);
if(y==0)
printf("Nulou sa delit neda");
else
printf("podiel x/y=%.3f",x/y);

}
</source>

===Absolútna hodnota===
;Zadanie: Vytvorte program, ktorý vypočíta absolútnu hodnotu zadaného čísla.

;Analýza problému: Absolútna hodnota je definovaná ako vzdialenosť čísla od nuly. Teda ak je číslo kladné, jeho absolútna hodnota je to isté číslo. Ak je číslo záporné, jeho absolútna hodnota je toto číslo, ale kladné.

abs(x)=

*x, ak je x>=0
*-1*x, ak je x<0

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

void main()
{

int x;
printf("Zadajte 1 celé číslo. \n");
scanf("%d",&x);
if(x<0)
x=-1*x;
printf("abs(x)=%d",x);

}
</source>

===Minimálna hodnota===
;Zadanie: Máme zistiť minimálnu hodnotu z dvoch zadaných čísel x a y.
;Analýza problému: Menšie z dvoch čísel zistíme jednoduchým porovnaním hondôt oboch premenných.

'''Príklad:'''
<source lang="c" line>
#include<stdio.h>
void main()
{

int x,y,min;
printf("Zadajte 2 celé čísla. \n");
scanf("%d %d",&x,&y);
if(x<y)
min=x;
else
min=y;
printf("min(%d,%d)=%d",x,y,min);

}
</source>

===Maximálna hodnota===
;Zadanie: Máme zistiť maximálnu hodnotu z troch zadaných čísel x, y, a z.
;Analýza problému: Keďže máme zistiť maximum len z troch čísel, najjednoduchším spôsobom bude porovnať každé číslo s každým. Týmto dostaneme 3 porovnania, po ktorých vieme jednoznačne určiť najväčšie číslo. Na lepšiu predstavivosť poslúži obrázok č.9.

'''Príklad:'''
<source lang="c" line>
#include<stdio.h>

int main()
{
int a, b, c, m;
scanf("%d %d %d",&a, &b, &c);
if(a>b)
{ if(a>c)
m=a;
else
m=c;
}
else
{ if(b>c)
m=b;
else
m=c;
}
printf("%d",m);
}
</source>

===Slovné hodnotenie===
;Zadanie: Vytvorte prgram, ktorý by po zadaní známky (číselná hodnota) túto hodnotu previedol na textové hodnotenie. Známky majú takéto slovné hodnotenia: 1-výborne, 2-veľmi dobre, 3-dobre, 4-dostatočne, 5-nedostatočne.

;Analýza problému: Na riešenie tohoto problému môžeme použiť príkaz if, avšak jeho použitie je v tomto prípade dosť neprehľadné. Použime teda príkaz switch.
'''Príklad:'''
<source lang="c" line>
#include<stdio.h>
void main()
{

int zn;
printf("Zadaj znamku (od 1 do 5)");
scanf("%d",&zn);
switch(zn)
{

case 1 : printf("vyborne");break;
case 2 : printf("velmi dobre");break;
case 3 : printf("dobre");break;
case 4 : printf("dostatocne");break;
case 5 : printf("nedostatocne");break;
default : printf("nepripustna znamka %d\n",zn);break;

}

}
</source>

Jazyk C (príklady) - Algoritmy

2020-05-19T21:14:12Z

PatrikC: /* Prvočíslo */

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

==Obsah==
V tejto kapitole budú ukázaná tvorba jednoduchých vývojových diagramov. Budú ukázané základné prvky algoritmizácie úloh, použitie rozhodovania, opakovania istého počtu operácií. K zvládnutiu tejto kapitoly sa predpokladá znalosť grafických značiek použitých pri tvorbe vývojových diagramov.

===Grafické značky vývojových diagramov===

Medzi základné stavebné bloky vývojových diagramov (VD) patria bloky, ktoré reprezentujú

*začiatok / koniec VD
*vykonávací blok
*rozhodovací blok
*spojka
*vstup / výstup dát
*orientované spojnice blokov
[http://www.kiwiki.info/index.php/Algoritmus[Vývojové stavebné bloky]]

==Príklady==

===Absolútna hodnota===
;Zadanie: Vieme, že absolútna hodnota je definovaná ako vzdialenosť čísla od začiatku súradnicového systému (resp. od nuly). Nakreslite vývojový diagram, ktorý by znázorňoval výpočet absolútnej hodnoty.

;Analýza problému: Pre absolútnu hodnotu reálnych čísel platí:
* abs(x) = x
* abs(-x) = x
Inak povedané, pre x>=0, je absolútna hodnota x rovná práve x, pre x<0 je absolútna hodnota x rovná -1*x.
Teda, stačí nám zistiť, či je x menšie ako nula.

[[Súbor:78 2 alg1.png|240px|none]]

===Kvadratická rovnica===
;Zadanie: Navrhnite algoritmus výpočtu koreňov kvadratickej rovnice ax2+bx+c=0. Vstupom do algoritmu budú koeficienty a, b, c, a výstupom budú korene kvadratickej rovnice x1,2.

;Analýza problému: Riešenie tejto rovnice je známe, úlohou je tento problém znázorniť v podobe vývojového diagramu. Vieme, že kvadratická rovnica má dva korene (x1 a x2). Tieto korene môžu byť rôzne, alebo riešením je jeden dvojnásobný koreň. Toto zistíme pomocou výpočtu diskriminantu kvadratickej rovnice. Diskriminant je definovaný ako D=b2-4ac
Rozoberme si jednotlivé prípady riešenia.
*D>0 : Rovnica má dva korene: x1=(-b+D1/2)/4ac, x2=(-b-D1/2)/4ac
*D=0 : Rovnica má jeden dvojnásobný koreň: x1,2=-b/4ac
*D<0 : Rovnica má riešenie na množine komplexných čísel:
Vieme, že i2=-1. (i je komplexná jednotka). Potom výpočet druhej odmocniny diskriminantu je (D)1/2=(i2 * (-D))1/2=i*(-D) ½ (poznámka: D<0). Teda korene kvadratickej rovnice budú x1=(-b+iD1/2)/4ac, x2=(-b-iD1/2)/4ac

[[Súbor:80 2 alg2.png|480px|none]]

===Maximum z 3 hodnôt===
;Zadanie: V predajni skrípt majú 3 skriptá, o ktoré máme záujem. Cena skrípt je a, b, c Sk. Navrhnite algoritmus, ktorý nájde najdrahšie skriptá; teda skriptá s maximálnou cenou.

;Analýza problému: V prípade, ak máme zistiť maximálnu (alebo minimálnu) hodnotu z troch čísel, musíme každé číslo porovnať s každým iným číslom. Teda, spolu budeme robiť 3 porovnania (a<->b, a<->c, b<->c). Nemá zmysel porovnávať ab a ba, lebo toto sú totožné porovnania. Ak teda máme zistiť najväčšie číslo z a, b, c, môžeme postupovať napríklad nasledovne: Najskôr porovnáme : a>b. Ak toto platí, potom porovnáme a>c. V prípade ak aj toto platí, tak maximum je a. Keby platilo že: a>b a c>a, potom vieme, že maximum je c. Takto by sme mohli pokračovať ďalej.

[[Súbor:82 2 alg3.png|360px|none]]

===Opakované načítanie===

;Zadanie: Na faktúre je údaj o počte položiek a samotné položky (položka obsahuje o.i. aj cenu v Sk). Ak viete koľko je na faktúre položiek, navrhnite algoritmus, ktorý vypočíta celkovú sumu položiek faktúry. Prvý vstupný údaj bude číslo pocet, ktoré nám hovorí o počte nasledujúcich položiek. Následne sa načíta pocet položiek ( – celých čísel symbolizujúcim cenu položky). Navrhnite algoritmus, ktorý vypočíta výslednú sumu ceny všetkých položiek.

;Analýza problému: V tomto prípade nikdy popredu nevieme, koľko budeme načítavať položiek. Tento údaj sa dozvieme až v momente, keď načítame prvý údaj. Úlohou bude teda navrhnúť algoritmus, ktorý by načítal požadovaný počet položiek (počet položiek môže byť od 0 až po ľubovoľne veľké konečné číslo). Na riešenie tohto problému využijeme cyklus. Tento cyklus sa bude opakovať toľkokrát, koľko položiek máme načítať. Pri každom opakovaní cyklu načítame jednu položku (položku označme ako premennú a) a jej hodnotu pripočítame k výslednej sume. Ďalším algoritmickým problémom je zabezpečiť, aby sa tento cyklus vykonával presne pocet krát. Tu využijeme prvý vstupný údaj pocet. Pri každej iterácii (opakovaní) cyklu sa hodnota premennej pocet zníži o 1. Cyklus budeme opakovať dovtedy, pokiaľ bude premenná pocet rôzna od nuly. Na výpočet súčtu všetkých položiek využijeme premennú suma, ktorú na začiatku vynulujeme (priradíme jej hodnotu 0).

[[Súbor:84 2 alg4.png|360px|none]]

===Násobenie===

;Zadanie: V počítačoch (na hardvérovej úrovni) sa operácia násobenia vykoná pomocou opakovaného sčítavania dvoch hodnôt. Vytvorte algoritmus, ktorý by násobil dve celé čísla pomocou opakovaného sčítavania.

;Analýza problému: Na riešenie problému nemôžeme použiť operáciu násobenia (*), musíme použiť operáciu sčítavania (+). Zoberme si príklad: x=5*3. Tu budeme 3 krát pripočítame hodnotu 5 do premennej x, ktorú musíme najskôr vynulovať. Teda x=5+5+5=15. Vo všeobecnosti máme x=a*b=a+a+...+a : sčítavanie robíme b krát. Z uvedeného vyplýva, že nemôžeme pevne napísať, koľkokrát sa a pripočíta do premennej x. Tu bude vhodné využiť nejaký cyklus. V každom cykle sa do premennej x pripočíta hodnota a. Počet opakovaní cyklu je b. V každej iterácii cyklu hodnotu premennej b znížime o 1. Cyklus ukončíme, ak sa b=0.

[[Súbor:86 2 alg5.png|300px|none]]

===Prvočíslo===
;Zadanie: Navrhnite algoritmus, ktorý zistí, či zadané číslo a je prvočíslo.

;Analýza problému: Prvočíslo je číslo, ktoré je delitelné iba číslom 1 a sebou samým. Pri testovaní čísla a na prvočíselnosť postupne celočíselne deliť číslo a číslami del=2, 3, ...n. Ak pri všetkých deleniach bude nejaký zvyšok (a sa nedá deliť číslom del), povieme že číslo a je prvočíslo. Ak v priebehu delenia zistíme, že a je delitené číslom del bezo zvyšku, algoritmus ukončíme, a povieme že a nie je prvočíslo. Ďalší problém je určiť, dokedy má zmysel zväčšovať deliteľ del. V predchádzajúcom texte sme del zvyšovali po hodnotu n. Úlohou je odhadnúť vhodné n. Pokúsme sa postupovať nasledovne: ako prvý deliteľ je del=2. Teda delíme a číslom del=2. Výsledok po tomto delení označme podiel. Ak budeme premennú del zvyšovať, nebude mať zmysel zväčšovať ju nad hodnotu podiel=a/2, pretože číslo a nemôže deliť žiadne číslo, ktoré je väčšie ako a/2. Ďalej, nech del=3. Ak číslo del (del=3) nedelí číslo a, hranica delenia – n sa zníži na hodnotu a/3, pretože žiadne číslo väčšie ako a/3 nemôže deliť a bezo zvyšku. Z uvedeného nám vyplýva, že hranicu n môžeme určiť nasledovne: Pri každom delení si zapamätáme podiel. Ďalšie delenie robíme iba ak podiel>del. V algoritme použijeme ešte jednu premennú prvocislo. Táto premenná nám bude hovoriť, či je číslo prvočíslo alebo nie je. Na začiatku má hodnotu 1 – teda predpokladáme, že číslo je prvočíslo. V prípade, ak počas delenia zistíme, že nejaké číslo del delí a bezo zvyšku, premennej prvocislo priradíme hodnotu 0. Vyhlásime, že a nie je prvočíslo.

; Ukážka:
*a=23
*a del podiel
*23 / 2 = 11 zv 1
*23 / 3 = 7 zv 2
*23 / 4 = 5 zv 3
*23 / 5 = 4 zv 3 del > podiel; koniec; a je prvočíslo, pretože ani jeden zvyšok po delení nebol 0
*23 je prvočíslo.

[[Súbor:88 2 alg6.png|480px|none]]

Strncat (jazyk C)

2020-05-19T20:57:43Z

PatrikC: /* Parametre */

{{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-19T20:56:06Z

PatrikC: /* 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==

Strncat (jazyk C)

2020-05-19T20:55:49Z

PatrikC: /* 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==

Strncat (jazyk C)

2020-05-19T20:55:07Z

PatrikC: /* Podrobný popis funkcie */

{{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, 14);

printf("Finálny retazec : |%s|", dest);
return(0);
}
</source>

Výstup:
Finálny retazec: |Toto je zdrojToto je ciel|

==Referencie==

Strncat (jazyk C)

2020-05-19T20:54:45Z

PatrikC: Vytvorená stránka „{{Funkcie jazyka c}} __NOTOC__ ==Funkcia strcat== <properties> knižnica=string.h popis=Pripoji retazec na koniec 2 retazca. </properties> Úplný funkčný prototyp<re…“

{{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, 14);

printf("Finálny retazec : |%s|", dest);
return(0);
}
</source>

Výstup:
Finálny retazec: |Toto je zdrojToto je ciel|

==Referencie==

Strcat (jazyk C)

2020-05-19T20:51:26Z

PatrikC: /* Funkcia strcat */

{{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 zdrojToto je ciel|

==Referencie==

Strcat (jazyk C)

2020-05-19T20:51:03Z

PatrikC: /* Funkcia strcat */

{{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);
char *strncat(char *dest, const char *src, size_t n)
</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 zdrojToto je ciel|

==Referencie==

Strcat (jazyk C)

2020-05-19T20:49:36Z

PatrikC: /* Parametre */

{{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 zdrojToto je ciel|

==Referencie==

Strcat (jazyk C)

2020-05-19T20:45:18Z

PatrikC: /* Parametre */

{{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ť. To by nemalo prekrývať cieľ.

==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 zdrojToto je ciel|

==Referencie==

Strcat (jazyk C)

2020-05-19T20:44:57Z

PatrikC: /* Podrobný popis funkcie */

{{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ť. To by nemalo prekrývať cieľ.

==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 zdrojToto je ciel|

==Referencie==

Strstr (jazyk C)

2020-05-19T20:43:51Z

PatrikC: /* Podrobný popis funkcie */

{{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==

Strstr (jazyk C)

2020-05-19T20:43:24Z

PatrikC: /* Podrobný popis funkcie */

{{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. Koncové 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==

Strstr (jazyk C)

2020-05-19T20:43:09Z

PatrikC: /* Návratová hodnota */

{{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 . Koncové 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-19T20:41:42Z

PatrikC: /* Podrobný popis funkcie */

{{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==

Strcpy (jazyk C)

2020-05-19T20:41:14Z

PatrikC: /* Podrobný popis funkcie */

{{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==

Atof (jazyk C)

2020-05-19T20:19:18Z

PatrikC: /* Parametre */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atof==
<properties>
knižnica=stdlib.h
popis=analýza stringu
</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-19T20:19:05Z

PatrikC: /* Parametre */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atol==
<properties>
knižnica=stdlib.h
popis=analýza stringu
</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-19T20:18:50Z

PatrikC: /* Parametre */

{{Funkcie jazyka c}}
__NOTOC__
==Funkcia atoi==
<properties>
knižnica=stdlib.h
popis=analýza stringu
</properties>

Úplný funkčný prototyp:
<source lang="c">
int atoi(const char *str)
</source>

==Podrobný popis funkcie==
Analyzuje string a jeho obsah interpretuje 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==

Malloc (jazyk C)

2020-05-19T20:03:37Z

PatrikC: /* 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==