B-PROG2 Syntax jazyka C

Prehľad syntaxe jazyka C

Základný prázdny program

//hlavickove subory

//deklaracie funkcii, typov, ...

int main()
{
  //deklaracie premennych pre main

  //prikazy

  return 0;
}

//definicie (kod) dalsich funkcii

//hlavickove subory

//deklaracie funkcii, typov, ...

int main()

{

//deklaracie premennych pre main

//prikazy

return 0;

}

//definicie (kod) dalsich funkcii

Základná syntax funkcií

//nezabudajte na popis funkcie v komentari
TYP_NAVRATOVEJ_HODNOTY NAZOV_FUNKCIE( TYP1 PARAM1, TYP2 PARAM2, ... )
{
  //deklaracie lokalnych premennych pre funkciu
  TYP PREMENNA1, PREMENNA2, ... ;
  TYP PREMENNE_INEHO_TYPU;

  //prikazy

  return VYRAZ;
}

//nezabudajte na popis funkcie v komentari

TYP_NAVRATOVEJ_HODNOTY NAZOV_FUNKCIE( TYP1 PARAM1, TYP2 PARAM2, ... )

{

//deklaracie lokalnych premennych pre funkciu

TYP PREMENNA1, PREMENNA2, ... ;

TYP PREMENNE_INEHO_TYPU;

//prikazy

return VYRAZ;

}

Základné I/O

printf("Hello world\n");   //vypise zadany retazec: Hello world a koniec riadku
printf("%d", VYRAZ);      //vypise hodnotu vyrazu ako desiatkove cele cislo
scanf("%d", &PREMENNA);    //nacita desiatkove cislo zo vstupu a ulozi ho do premennej

printf("Hello world\n"); //vypise zadany retazec: Hello world a koniec riadku

printf("%d", VYRAZ); //vypise hodnotu vyrazu ako desiatkove cele cislo

scanf("%d", &PREMENNA); //nacita desiatkove cislo zo vstupu a ulozi ho do premennej

Viac info: https://en.wikipedia.org/wiki/Printf_format_string

Základné dátové typy

Typ	Popis	Konštanta	Formátovací reťazec
`int`	celé číslo: 32 bitové alebo 16 bitové, so znamienkom	189	`%d`
		0x189	`%x`
`unsigned`	kladné celé číslo bez znamienka	189	`%u`
`long long`	64-bitové číslo so znamienkom	189LL	`%lld`
`float`	desatinné číslo s malou presnosťou	1.89f	`%f`
`double`	desatinné číslo s väčšou presnosťou	1.89	`%lf`
		7.3e-4	`%.1le`
`char`	8-bitové číslo, jeden znak	‚a‘	`%c`

Konverzia dátových typov

Implicitná:

binárne operátory: A op B
- konvertuje na „väčší typ“
- int / double konvertuje na double / double, výsledok je double
- int + char konvertuje na int + int, výsledok je int
priradenie: A = B
- konvertuje na cieľový typ, môže nastať strata presnosti
- int = double konvertuje na int, stratí sa desatinná časť/hrozí pretečenie
- char = int konvertuje na char, stratia sa bity (zostane posledných 8 bitov, zvyšok po delení 256)
volanie funkcie: f(A)
- snaží sa skonvertovať A na typ deklarovaný v zozname parametrov funkcie
- void f(int): f(3.3) -> stratí presnosť, volá sa f s parametrom 3

Explicitná:

pomocou operátora (cielovy_typ)
pozor na združovanie (x,y sú double):
- (int) (x/y) -> delia sa double čísla, výsledok je orezaný na int
- (int) x/y -> x sa oreže na int, ale potom sa opäť skonvertuje na double a delenie je s double číslami (a teda aj výsledok)

Výrazy

Základná aritmetika:

c = a + b;
c = a - b;
c = a * b;
c = a / b;

c = a % b;   //zvysok po deleni, iba pre cele cisla

c = a + b;

c = a - b;

c = a * b;

c = a / b;

c = a % b; //zvysok po deleni, iba pre cele cisla

Priradenie spojené s operáciou:

//zjednodusenie pre: c = c + a
c += a;     
//detto: -= *= /= %=

//zjednodusenie pre: c = c + a

c += a;

//detto: -= *= /= %=

Zvýšenie hodnoty o 1:

//post-inkrement
c = a++;     
//to iste ako: c = a; a = a + 1;

//pre-inkrement
c = ++a;     
//to iste ako: a = a + 1; c = a;

//podobne pre/post-dekrement: operator --

//post-inkrement

c = a++;

//to iste ako: c = a; a = a + 1;

//pre-inkrement

c = ++a;

//to iste ako: a = a + 1; c = a;

//podobne pre/post-dekrement: operator --

Združovanie operátorov

Riadi sa (zväčša) štandardnými matematickými zápismi:

Unárne operátory majú najvyššiu priorit

a * -b  // a * (-b)

1	a * -b // a * (-b)

Násobenie/delenie má vyššiu prioritu ako sčítanie/odčítani

 a + b * c  // a + ( b * c )
 a || b && c  // a || ( b && c )

1 2	a + b * c // a + ( b * c ) a \|\| b && c // a \|\| ( b && c )

Rovnaká priorita sa zátvorkuje matematicky (zväčša zľava)

 a * b / c *d  // (((a * b) / c) * d )

1	a * b / c d // (((a b) / c) * d )

Priradenia sa zväčša zátvorkujú posledné a zprava doľava

 a = b = c + d  // (a = (b = (c+d)))

1	a = b = c + d // (a = (b = (c+d)))

Plná tabuľka a popis: http://en.cppreference.com/w/c/language/operator_precedence

Pri zápise je kvôli čitateľnosti vhodné zložité výrazy rozdeliť, a manuálne ozátvorkovať netriviálne časti.

Vetvenie

Podmienky a logické operátory

 //zakladne podmienky:
 a == b   //zhoda, ma a tu istu hodnotu ako b ?
 a != b   //nezhoda, ma a roznu hodnotu ako b ?
 a < b    //je a mensie ako b ?
 a <= b    //je a mensie alebo rovne ako b ?
 a > b    //je a vacsie ako b ?
 a >= b    //je a vacsie alebo rovne ako b ?

 //logicke operatory
 !P1        // nie P1
 P1 && P2   // P1 a zaroven P2
 P1 || P2   // P1 alebo P2

//zakladne podmienky:

a == b //zhoda, ma a tu istu hodnotu ako b ?

a != b //nezhoda, ma a roznu hodnotu ako b ?

a < b //je a mensie ako b ?

a <= b //je a mensie alebo rovne ako b ?

a > b //je a vacsie ako b ?

a >= b //je a vacsie alebo rovne ako b ?

//logicke operatory

!P1 // nie P1

P1 && P2 // P1 a zaroven P2

P1 || P2 // P1 alebo P2

Vetvenie if

  //vetvenie
  if ( PODMIENKA1 ) 
  {
      //kod vnutri sa vykonava, iba ak podmienka1 plati, t.j. prislusny vyraz ma nenulovu hodnotu
      PRIKAZY
  }
  else if ( PODMIENKA2 ) 
  {
      //kod vnutri sa vykonava, iba ak podmienka1 neplati (else) a podmienka2 plati (if)
      PRIKAZY
  }
  else
  {
      //kod vnutri sa vykonava, iba ak podmienka1 ani podmienka2 neplatia
      PRIKAZY
  }

//vetvenie

if ( PODMIENKA1 )

{

//kod vnutri sa vykonava, iba ak podmienka1 plati, t.j. prislusny vyraz ma nenulovu hodnotu

PRIKAZY

}

else if ( PODMIENKA2 )

{

//kod vnutri sa vykonava, iba ak podmienka1 neplati (else) a podmienka2 plati (if)

PRIKAZY

}

else

{

//kod vnutri sa vykonava, iba ak podmienka1 ani podmienka2 neplatia

PRIKAZY

}

Vetvenie switch

  //vetvenie podla konstanty
  switch( VYRAZ ) 
  {
  case NAVESTIE1:  
    //kod sa vykonava, ak VYRAZ ma hodnotu NAVESTIE1
    PRIKAZY
    break;   //ak sa break vynecha, pokracuje sa kodom v dalsom navesti
  case NAVESTIE2:  
    //kod sa vykonava, ak VYRAZ ma hodnotu NAVESTIE2
    PRIKAZY
    break;
  default:
    //kod sa vykonava, vo vsetkych ostatnych pripadoch
    break;
  }

//vetvenie podla konstanty

switch( VYRAZ )

{

case NAVESTIE1:

//kod sa vykonava, ak VYRAZ ma hodnotu NAVESTIE1

PRIKAZY

break; //ak sa break vynecha, pokracuje sa kodom v dalsom navesti

case NAVESTIE2:

//kod sa vykonava, ak VYRAZ ma hodnotu NAVESTIE2

PRIKAZY

break;

default:

//kod sa vykonava, vo vsetkych ostatnych pripadoch

break;

}

Cykly

 // ak PODMIENKA je pravdiva, vykona sa telo cyklu, a znova sa otestuje podmienka, 
 // ak PODMIENKA praviva nie je, pokracuje sa v programe za prikazom while
 while ( PODMIENKA )
 {
    PRIKAZY_V_TELE_CYKLU
 }

 // ak PODMIENKA je pravdiva, opatovne sa vykonava telo cyklu (minimalne raz), inak sa pokracuje v programe
 do
 {
    PRIKAZY_V_TELE_CYKLU
 } while ( PODMIENKA );

 // najprv sa vykona INIT
 // potom sa otestuje PODMIENKA, ak je pravdiva, vykona sa telo cyklu, inak sa pokracuje v programe za cyklom
 // ked skonci telo cyklu, vykona sa INKREMENT, a pokracuje sa testovanim podmienky
 for ( INIT ; PODMIENKA ; INKREMENT )
 {
    PRIKAZY_V_TELE_CYKLU
 }

// ak PODMIENKA je pravdiva, vykona sa telo cyklu, a znova sa otestuje podmienka,

// ak PODMIENKA praviva nie je, pokracuje sa v programe za prikazom while

while ( PODMIENKA )

{

PRIKAZY_V_TELE_CYKLU

}

// ak PODMIENKA je pravdiva, opatovne sa vykonava telo cyklu (minimalne raz), inak sa pokracuje v programe

{

PRIKAZY_V_TELE_CYKLU

} while ( PODMIENKA );

// najprv sa vykona INIT

// potom sa otestuje PODMIENKA, ak je pravdiva, vykona sa telo cyklu, inak sa pokracuje v programe za cyklom

// ked skonci telo cyklu, vykona sa INKREMENT, a pokracuje sa testovanim podmienky

for ( INIT ; PODMIENKA ; INKREMENT )

{

PRIKAZY_V_TELE_CYKLU

}

 //typicke pouzitie na opakovanie kodu n-krat 
 //v jazyku C musi byt i deklarovane ako premenna na zaciatku funkcie
 for ( i=0 ; i<n ; i++ )
 {
    PRIKAZY_CO_SA_MAJU_n_KRAT_OPAKOVAT
 }

//typicke pouzitie na opakovanie kodu n-krat

//v jazyku C musi byt i deklarovane ako premenna na zaciatku funkcie

for ( i=0 ; i<n ; i++ )

{

PRIKAZY_CO_SA_MAJU_n_KRAT_OPAKOVAT

}

 //specialne riadiace konstrukcie
    break;      // vyskoci z tela cyklu von
    continue;   // presunie sa riadenie na podmienku cyklu (vo for prikaze najprv na INKREMENT)

//specialne riadiace konstrukcie

break; // vyskoci z tela cyklu von

continue; // presunie sa riadenie na podmienku cyklu (vo for prikaze najprv na INKREMENT)

Polia

Polia predstavujú postupnosť za sebou v pamäti uložených údajov sprístupniteľných cez index.

//deklaracia pola, nedefinovany obsah, maximum KAPACITA prvkov
TYP NAZOV[KAPACITA];   

//deklaracia pola s vymenovanim prvkov, KAPACITA sa moze, ale nemusi vynechat
int prvocisla[] = {2,3,5,7,11,13,17};

//spristupnenie prvku - operator indexovania - indexy od nuly po KAPACITA-1
a = pole[0];  //precita sa prvy prvok a zapise do premennej a
pole[i] = a;  //obsah premennej a sa zapise do pola na index ulozeny v premennej i

//deklaracia pola, nedefinovany obsah, maximum KAPACITA prvkov

TYP NAZOV[KAPACITA];

//deklaracia pola s vymenovanim prvkov, KAPACITA sa moze, ale nemusi vynechat

int prvocisla[] = {2,3,5,7,11,13,17};

//spristupnenie prvku - operator indexovania - indexy od nuly po KAPACITA-1

a = pole[0]; //precita sa prvy prvok a zapise do premennej a

pole[i] = a; //obsah premennej a sa zapise do pola na index ulozeny v premennej i

Viac detailov k inicializácii: http://en.cppreference.com/w/c/language/array_initialization

Viacrozmerné polia

Štandardné polia, ktorých prvkami sú iné polia.

//pole troch poli, z ktorych kazde ma 5 prvkov typu int
int pole2D[3][5];   

//pole NS stranok po NR riadkoch po NC+1 znakoch kazdy riadok
char kniha[NS][NR][NC+1];

//pole troch poli, z ktorych kazde ma 5 prvkov typu int

int pole2D[3][5];

//pole NS stranok po NR riadkoch po NC+1 znakoch kazdy riadok

char kniha[NS][NR][NC+1];

Reťazce

Pole znakov, na ktorých konci je znak '\0'.

//pripravene miesto na retazec s 5 znakmi
char retazec[5+1];   

//inicializacia pola (retazec, ktory sa da citat aj menit)
char text[] = "lorem ipsum";

//pointer na konstantny retazec (da sa iba citat)
const char *str = "lorem ipsum";

//pripravene miesto na retazec s 5 znakmi

char retazec[5+1];

//inicializacia pola (retazec, ktory sa da citat aj menit)

char text[] = "lorem ipsum";

//pointer na konstantny retazec (da sa iba citat)

const char *str = "lorem ipsum";

S reťazcami sa dá robiť v jazyku C veľa vecí cez knižničné funkcie, viď príslušné cvičenie a literatúru.

Smerníky

Adresa premennej sa získa cez operátor &.

Smerník je premenná obsahujúca pamäťovú adresu:

beztypový: iba vieme uložiť a prečítať adresu ľubovoľného typu
typový: obsahuje adresu prvku nejakého typu, dá sa nepriamo získať hodnota cez operátor *, dá sa robiť smerníková aritmetika
na funkciu: obsahuje adresu funkcie, funkcia sa dá zavolať

 int i;       //premenna typu int
 void * ptr;  //beztypovy smernik
 int*   pi;   //typovy smernik

 ptr = &i;         //adresovy operator
 pi = (int*) ptr;  //pretypovanie smernikov
 *pi = 2;          //spristupnovaci operator, na adresu kam ukazuje pi (do i) sa zapise 2

int i; //premenna typu int

void * ptr; //beztypovy smernik

int* pi; //typovy smernik

ptr = &i; //adresovy operator

pi = (int*) ptr; //pretypovanie smernikov

*pi = 2; //spristupnovaci operator, na adresu kam ukazuje pi (do i) sa zapise 2

Smerníková aritmetika:

 int pole[100];  //pole 
 int*   pi;      //typovy smernik

 pi = &pole[10];   //adresa 11. prvku
 pi = pole+10;     //to iste co predosly riadok cez smernikovu aritmetiku

 *(pi+1) = pi[1];   //nic sa nestane, nalavo aj napravo je ten isty vyraz

 printf("%d\n", pi-pole);  //malo by vypisat 10 - o kolko intov dalej ukazuje pi od pole

int pole[100]; //pole

int* pi; //typovy smernik

pi = &pole[10]; //adresa 11. prvku

pi = pole+10; //to iste co predosly riadok cez smernikovu aritmetiku

*(pi+1) = pi[1]; //nic sa nestane, nalavo aj napravo je ten isty vyraz

printf("%d\n", pi-pole); //malo by vypisat 10 - o kolko intov dalej ukazuje pi od pole

Štruktúry

Štruktúry logicky združujú viacero údajov do 1 celku. Syntax deklarácie:

struct TAG {
  //deklaracie poloziek - ako keby sme deklarovali premenne
  //polozky mozu byt lubovolneho typu: zakladne typy, existujuce struktury, polia, smerniky
};

struct TAG {

//deklaracie poloziek - ako keby sme deklarovali premenne

//polozky mozu byt lubovolneho typu: zakladne typy, existujuce struktury, polia, smerniky

};

Často sa spája deklarácia s vytvorením nového typu:

typedef
    struct _datum {
        char  den;
        char  mesiac;
        short int rok;
    }
Datum;

typedef

struct _datum {

char den;

char mesiac;

short int rok;

}

Datum;

Operácie so štruktúrou:

//deklaracia premennej
    struct _datum d1;
//deklaracia s nastavenim hodnot
    Datum d2 = {22,4,1999};
//deklaracia smernika
    Datum *p1 = &d1;  

//kopirovanie hodnot
    d1 = d2;

//spristupnovaci operator pre strukturu
    d1.rok = 2000;

//spristupnovaci operator pre smernik
    p1->den = 15;

//deklaracia premennej

struct _datum d1;

//deklaracia s nastavenim hodnot

Datum d2 = {22,4,1999};

//deklaracia smernika

Datum *p1 = &d1;

//kopirovanie hodnot

d1 = d2;

//spristupnovaci operator pre strukturu

d1.rok = 2000;

//spristupnovaci operator pre smernik

p1->den = 15;

Enumerácie

Enumerácie združia pomenovanie konštánt do 1 typu. Namiesto:

#define JANUAR   1
#define FEBRUAR  2
#define MAREC    3
...

#define JANUAR 1

#define FEBRUAR 2

#define MAREC 3

...

vytvoríme typ

enum _mesiac {
  JANUAR=1, FEBRUAR, MAREC, ..., DECEMBER
};

enum _mesiac {

JANUAR=1, FEBRUAR, MAREC, ..., DECEMBER

};

Tento typ môžeme používať ďalej ľubovoľne v kóde. Hodnoty sa správajú ako int, ale ako konštanty môžem použiť pomenované názvy:

enum _mesiac m;

for (m = JANUAR; m <= DECEMBER; M++)
   printf("%d ", m);   //pozor: vypise cislo

enum _mesiac m;

for (m = JANUAR; m <= DECEMBER; M++)

printf("%d ", m); //pozor: vypise cislo

Dynamické polia (aj viacrozmerné)

Dynamické polia sa vytvárajú pomocou funkcií malloc (neinicializované pole, t.j. nie je definovaný obsah), alebo calloc (naplní pole nulami). Funkcia vráti adresu alokovanej pamäte, ktorú si uložíme do smerníkovej premennej.
Dynamické pole je možné zmenšiť alebo zväčšiť podľa potreby pomocou funkcie realloc.
Po skončení práce s dynamickým poľom musíme pamäť uvoľniť pomocou funkcie free. Po volaní free je vhodné smerník vynulovať, ak sa s ním nebude ďalej pracovať.

Viacrozmerné dynamické polia

Typicky ich reprezentujeme poľom smerníkov (dynamickým, alebo aj statickým), pričom každý smerník odkazuje na dynamicky alokované pole.