Základy jazyka C v příkladech 1

Pro psaní jednoduchých aplikací v C a C++ můžete použít nenáročný nástroj Dev-C++  jenž je zdarma, má zvýraznění syntaxe a vlastní kompilátor. Pokročilejší programátor s kompilátorem je Code::Blocks. Kompilace a spuštění proběhne klávesou F9. Při spouštění zkompilovaného programu doporučuji vypnout nebo pozastavit antivirové programy. Zejména Avast svým testem způsobí nestandardní chování programu.

Zde jsou uváděny příklady v C jenž běží jako Console Application. (Jazyk C++ je obsahově rozšířenější a objektově orientovaný.) V ukázkách se využívají nejčastěji základní knihovny <stdio.h> a <stdlib.h> pro výpis na obrazovku a čtení klávesnice.

Příklad 01: Hello World. Aplikace vypisující nápis Ahoj světe! Aby aplikace ihned neskončila, vyčká na stisk libovolné klávesy.

// Za dve lomitka piseme komentar na radek

/* Za lomitko a hvezdicku
   muzeme psat komentar na vice radku.
   Musime jej ukoncit hvezdickou a lomitkem */

#include <stdio.h>
#include <stdlib.h>

int main(){

    printf("Ahoj, svete!\n");  // Vypise text Ahoj svete!


  system("PAUSE");             // Vycka na stisk libovolne klavesy.
  return 0;
}

Proměnné a konstanty, základní datové typy:

short – Celé číslo (2B)

int – Celé číslo (4B) (-32767 až +32767)

float – Reálné číslo (4B)

double – Reálné číslo (8B)

long double – Reálné číslo (12B)

char – Znak uložený jako číslo (1B)

Textový řetězec a řídící sekvence (pro vstup i výstup):

“V uvozovkách se zapisuje textový řetězec“

%d – Vypíše proměnnou jako celé číslo

%f – Vypíše proměnnou jako reálné číslo

%lf – Vypíše proměnnou jako reálné číslo se zvýšenou přesností

%c – Vypíše proměnnou jako číslo konvertované na znak

%o – Vypíše proměnnou jako číslo v osmičkové soustavě

%x – Vypíše proměnnou jako číslo v šestnáctkové soustavě

%s – Vypíše textový řetězec

\a – Varovné pípnutí

\n – Začátek nového řádku

Výpis na obrazovku:

printf(“Textový řetězec a řídící sekvence“, proměnné)

Příklad 02: Konstanty, proměnné a výpis na obrazovku. Do paměti se uloží konstanty a jejich hodnoty. Program také vytvoří dvě proměnné bez hodnot. Konstanty se vypíší na obrazovku.

#include <stdio.h>
#include <stdlib.h>

// Vytvoreni konstant s hodnotou
char a = 'A';                     // znak nebo cislo 1-bytove (0-255)
int  b = 6325;                    // cele cislo 4-bytove
float c = 3.14;                   // realne cislo 4 bytove
double d = 15.1566;               // realne cislo 8 bytove s velkou presnosti

// Vytvoreni promennych bez hodnot
int  x;
int  y;

int main(){

    printf("Hodnota a: %c \n", a);    // vypise text, promennou a da novy radek
    printf("Hodnota b: %d \n", b);
    printf("Hodnota c: %f \n", c);
    printf("Hodnota d: %f \n", d);

  system("PAUSE");   // vycka na stisk libovolne klavesy
  return 0;
}

Příklad 03: Vstup z klávesnice. Program vytvoří proměnnou. Následně vyčká na vložení čísla uživatelem z klávesnice. Číslo se uloží do paměti a vypíše na nový řádek.

#include <stdio.h>
#include <stdlib.h>

int  x;

int main(){
    printf("Zadejte cislo: \n");         // vypise text a skoci na dalsi radek
    scanf("%d", &x);                     // ceka na vstup z klavesnice, ulozi x
    printf("Hodnota cisla: %d \n", x);   // vypise text a hodnotu x

  system("PAUSE");                       // vycka na stisk libovolne klavesy
  return 0;
}

Číselné konstanty:

Desítková soustava: 109   -15   19U   915L   6598UL

Osmičková soustava: 06   01341   02365

Šestnáctková soustava: 0x0   0xAF3   0xA3A

Základní operace, operátory, logické operátory:

Sčítání     +

Odčítání      –

Násobení      *

Dělení      /

Inkrementace      ++

Dekrementace      – –

Porovnávání      <     >      <=     >=

Rovná se při porovnávání      ==

Nerovná se při porovnávání     !=

And, a zároveň, konjunkce     &&

Or, nebo, disjunkce   ||

Not, negace     !

Příklad 04: Součet dvou čísel. Program sečte dvě čísla zadaná z klávesnice.

#include <stdio.h>
#include <stdlib.h>

int  a;
int  b;
int  c;

int main(){
    printf("Zadejte prvni cislo: \n");
    scanf("%d", &a);
    printf("Zadejte druhe cislo: \n");
    scanf("%d", &b);
    c = a + b;
    printf("Soucet cisel je: %d \n", c);

  system("PAUSE");
  return 0;
}

Příklad 05: Násobení. Program ze dvou čísel vypočítá obsah obdélníku.

#include <stdio.h>
#include <stdlib.h>

int  a;
int  b;
int  obsah;

int main(){
    printf("Obsah obdelniku \n");
    printf("---------------------------------------------------------\n");
    printf("Zadejte delku strany a: ");
    scanf("%d", &a);
    printf("\n");
    printf("Zadejte delku strany b: ");
    scanf("%d", &b);
    printf("\n");
    obsah = a * b;
    printf("Obsah je: %d \n", obsah);
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Podmínky uvnitř výrazu:

podmínka ? podminka_splnena : podminka_nesplnena

(a > b) ? (vysledek = A) : ( vysledek = B)

Příklad 06: Porovnání dvou čísel.

#include <stdio.h>
#include <stdlib.h>
             
int  a;
int  b;
int vysledek;


int main(){
    printf("Porovnani dvou cisel \n");
    printf("---------------------------------------------------------\n");     
    printf("Zadejte prvni cislo: ");       
    scanf("%d", &a);
    printf("\n");                      
    printf("Zadejte druhe cislo: ");
    scanf("%d", &b);   
    printf("\n"); 
    (a > b) ? (vysledek = a) : (vysledek = b);          
    printf("Vetsi cislo je: %d \n", vysledek);  
    printf("---------------------------------------------------------\n");      
  
  system("PAUSE");                      
  return 0;
}

Příklad 07: Sestrojitelnost trojúhelníku. Program ověří zda-li lze sestrojit trojúhelník. Zadat můžete i dvě desetinná čísla. Nejdříve se ověří sestrojitelnost a zapíše jako logická 1 nebo 0 do proměnné výsledku. Následně se porovná výsledek a vypíše textový řetězec „lze“ nebo „nelze“.

#include <stdio.h>
#include <stdlib.h>
             
double  a;
double  b;
double c;
int vysledek;


int main(){
    printf("Sestrojitelnost trojuhelniku \n");
    printf("---------------------------------------------------------\n");  
    printf("Dodrzujte stejne jednotky. Pouzivejte desetinnou tecku \n");
    printf("---------------------------------------------------------\n");
         
    printf("Zadejte delku strany a: ");       
    scanf("%lf", &a);
    printf("\n");   
    
    printf("Zadejte delku strany b: ");       
    scanf("%lf", &b);
    printf("\n"); 
    
    printf("Zadejte delku strany c: ");       
    scanf("%lf", &c);
    printf("\n");                    

    ((a + b > c) && (a + c > b) && (c + b > a)) ? (vysledek = 1) : (vysledek = 0);              
    printf("Trojuhelnik sestavit: %s", (vysledek == 1) ? "lze" : "nelze");  
    printf("\n");     
    printf("---------------------------------------------------------\n");      
  
  system("PAUSE");                      
  return 0;
}

 Podmínky pomocí if a else (když a jinak):

if (podmínky)

{následek splněné podmínky}

else

{následek nesplněné podmínky}

Příklad 08: Test dospělosti. Po zadání věku program vypíše zda-li jste dle zákonů ČR dospělý/á.

#include <stdio.h>
#include <stdlib.h>

int  roky;

int main(){
    printf("Test dospelosti \n");
    printf("---------------------------------------------------------\n");

    printf("Kolik je Vam let?: ");
    scanf("%d", &roky);
    printf("\n");

    if (roky >= 18)
       { printf("Jsi dospely/a");}
     else
       { printf("Nejsi dospely/a");}
    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Přepínací podmínka pomocí switch:

switch (výraz)

{

case hodnota_1:

{následek splněné podmínky při hodnotě 1}

break;

case hodnota_2:

{následek splněné podmínky při hodnotě 2}

break;

default:

{následek splněné podmínky při ostatních hodnotách}

break;

} 

Příklad 09: Automatické pozdravy. Dle zadaného času program pozdraví. Pokud k danému času nezná pozdrav, napíše univerzální pozdrav „Dobrý den!“.

#include <stdio.h>
#include <stdlib.h>

int  hodiny;

int main(){
    printf("Automaticke pozdravy \n");
    printf("---------------------------------------------------------\n");

    printf("Kolik je hodin? ");
    scanf("%d", &hodiny);
    printf("\n");

    switch (hodiny)
        {
          case 6:
          case 7:
          case 8:
               { printf("Dobre rano!");}
               break;
          case 12:
               { printf("Dobre poledne!");}
               break;
          case 13:
          case 14:
               { printf("Dobre odpoledne!");}
               break;
          case 18:
          case 19:
               { printf("Dobry vecer!");}
               break;
          default:
               { printf("Dobry den!");}
               break;
        }

    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Cyklus podmínek while:

while (podmínka)

{následek splněné podmínky, úprava podmínky}

Příklad 10: Opakovač. Program zopakuje nápis „Nemám zlobit“ dle zadaného čísla.

#include <stdio.h>
#include <stdlib.h>

int  opakuj;

int main(){
    printf("Opakovac Nemam zlobit \n");
    printf("---------------------------------------------------------\n");

    printf("Kolikrat mam opakovat? ");
    scanf("%d", &opakuj);
    printf("\n");

    while (opakuj > 0 )
        {
          printf("Nemam zlobit! \n");
          opakuj = opakuj - 1;
        }

    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Cyklus podmínek for:

for (vnitřní proměnná , inicializace; podmínka; iterace)

{následek splněné podmínky}

U některých kompilátorů nelze definovat vnitřní proměnnou (C99 mode). Tu je třeba definovat externě (globálně) jako všechny ostatní proměnné a pak až ji použít uvnitř for.

Postup pro úpravu kompilátoru v CODE::BLOCK pro chyby C99 mode.

Příklad 11: Počítání od do (bez C99 mode).  Program napočítá od zadaného čísla min do zadaného čísla max. Každý krok se uloží do proměnné i jenž je zapsána jako globální proměnná mino for.

#include <stdio.h>
#include <stdlib.h>

int  min;
int  max;
int i;

int main(){
    printf("Pocitej do... \n");
    printf("---------------------------------------------------------\n");

    printf("Od kolika mam pocitat? ");
    scanf("%d", &min);
    printf("\n");

    printf("Do kolika mam napocitat? ");
    scanf("%d", &max);
    printf("\n");

    for (i = min; i <= max; i++)
        {
          printf("Cislo! %d \n" , i);
        }

    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Příklad 12: Počítání od do (C99 mode).  Program napočítá od zadaného čísla min do zadaného čísla max. Každý krok se uloží do proměnné i jenž je zapsána jako lokální proměnná uvnitř for.

#include <stdio.h>
#include <stdlib.h>

int  min;
int  max;

int main(){
    printf("Pocitej do... \n");
    printf("---------------------------------------------------------\n");

    printf("Od kolika mam pocitat? ");
    scanf("%d", &min);
    printf("\n");

    printf("Do kolika mam napocitat? ");
    scanf("%d", &max);
    printf("\n");

    for (int i = min; i <= max; i++)
        {
          printf("Cislo! %d \n" , i);
        }

    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Cyklus podmínek do-while:

do

{příkazy vykonané před testem podmínky}

while (podmínka pro další opakování příkazů)

Příklad 13: Násobek čísla. Program zjistí kolikrát se vejde násobek čísla x do čísla y.

#include <stdio.h>
#include <stdlib.h>

int  x;
int  y;
int nasobek = 1;
int vypocteno;

int main(){
    printf("Kolikrat se vejde cely nasobek cisla x do cisla y? \n");
    printf("---------------------------------------------------------\n");

    printf("Zadejte cislo x: ");
    scanf("%d", &x);
    printf("\n");

    printf("Zadejte cislo y: ");
    scanf("%d", &y);
    printf("\n");

    do
        {
          vypocteno = x * nasobek;
          vypocteno = y / vypocteno;
          printf("Cislo: %d" , x*nasobek);
          printf(" se vejde do cisla: %d" , y);
          printf(" ........ ");
          printf("%dx \n" , vypocteno);
          nasobek++;
        }
      while ((x*nasobek)<=y);

    printf("\n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Přerušení cyklu:

continue – přeruší aktuální cyklus a začne nový.

break – přeruší aktuální cyklus a vyskočí z něj.

Příklad 14: Vynechání sudého násobku čísla pomocí continue.

#include <stdio.h>
#include <stdlib.h>

int x;
int nasobitel = 0;
int vysledek;


int main(){
    printf("---------------------------------------------------------\n");

    printf("Zadejte cislo jehoz nasobek chcete pocitat: ");
    scanf("%d", &x);
    printf("\n");
    printf("Vypisi se jen nasobky jenz jsou licha cisla! ");
    printf("\n");
    printf("---------------------------------------------------------\n");
    do
     {
        vysledek = x * nasobitel;
        nasobitel = nasobitel + 1;

        if (vysledek % 2 == 0) continue;
        printf("Lichy nasobek %d: " , vysledek);
        printf("\n");
     }
     while (nasobitel <= 10);

    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Příklad 15: Násobek čísla. Počítání bude ukončeno pomocí break při násobku rovnajícímu se 36.

#include <stdio.h>
#include <stdlib.h>

int x;
int nasobitel = 1;
int vysledek;


int main(){
    printf("---------------------------------------------------------\n");

    printf("Zadejte cislo jehoz nasobek chcete pocitat: ");
    scanf("%d", &x);
    printf("\n");
    printf("Vypisi se nasobky cisla. Pokud je nasobek 36, pocitani se ukonci! ");
    printf("\n");
    printf("---------------------------------------------------------\n");
    do
     {
        vysledek = x * nasobitel;
        nasobitel = nasobitel + 1;

        if (vysledek  == 36) break;
        printf("Nasobek %d: " , vysledek);
        printf("\n");
     }
     while (nasobitel <= 10);

    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Pole:

typ nazev_pole [velikost];

int cisla [10];

int suda [5] = {2, 4, 6, 8, 10};

Prvky se indexují od 0 do max. velikosti pole.

Příklad 16: Výpis každé druhé pozice pole.

#include <stdio.h>
#include <stdlib.h>

int i = 0;
int pole [10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};


int main(){
    printf("---------------------------------------------------------\n");

    do
     {
        printf("%i" , pole[i]);
        printf(" - ");
        i = i + 2;
     }
     while (i <= 9);
    printf(" \n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Příklad 17: Textový řetězec ze znaků  v poli.

#include <stdio.h>
#include <stdlib.h>

    char retezecA[] = "Testovaci text...";
    char retezecB[] = {'T' , 'E' , 'S' , 'T' , '\0'};

    char znakA;
    int iA = 0;

    char znakB;
    int iB = 0;


int main(){

    while( znakA = retezecA [iA]){
            printf("%c ", znakA);
            iA++;}

    printf("\n");

    while( znakB = retezecB [iB]){
            printf("%c ", znakB);
            iB++;}

    printf("\n");
    printf("\n");

  system("PAUSE");
  return 0;
}

Příklad 18: Práce s poli. Vytvoření dvourozměrného pole (2 x 3). Uložení data narození do pole a následné vyčítání a zpracování hodnot.

#include <stdio.h>
#include <stdlib.h>

int datum [2] [3] =  {{0, 0, 0},
                       {0, 0, 0}};

int rozdil;

int main(){

    datum[1][1] = 2;
    datum[1][2] = 12;
    datum[1][3] = 1984;

    datum[2][1] = 26;
    datum[2][2] = 7;
    datum[2][3] = 1979;

    printf ("Dana se narodila: %d.%d.%d\n" , datum[1][1] , datum[1][2] , datum[1][3]);
    printf ("Tomas se narodil: %d.%d.%d\n" , datum[2][1] , datum[2][2] , datum[2][3]);
    printf ("\n");

    rozdil = datum[1][3] - datum[2][3];

    printf ("Rozdil je: %d let \n" , rozdil);

    printf ("\n");

    system("PAUSE");
    return 0;
}

Příklad 19: Práce s poli. Textové řetězce a čísla.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int i = 0;
int poleA [10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
int poleB [10] = {100, 100, 100, 100, 100, 100, 100, 100, 100, 100};
char poleT1 [] = {"Zprava v lahvi: "};
char poleT2 [] = {"...jsem na pustem ostrove! A dochazi zasoby!"};
int delkaT1;
int delkaT2;
int soucetAB;

int main(){
    printf("---------------------------------------------------------\n");

    delkaT1 = strlen(poleT1);            // zjisteni delky pole pomoci strlen
    delkaT2 = strlen(poleT2);            // zjisteni delky pole pomoci strlen

    printf("Delka pole T1 je: %d \n" , delkaT1);
    printf("Delka pole T2 je: %d \n" , delkaT2);
    printf(" \n");

    printf("Text: %s \n" , strcat(poleT1, poleT2));  //spojení dvou poli - strncat

    printf(" \n");
    printf("---------------------------------------------------------\n");

    printf("Soucet pole A+B: ");
    do
     {
        soucetAB =  poleA[i] + poleB[i];    //vyhleda v poli na pozici i a scita
        printf("%d" , soucetAB);
        printf(", ");
        i = i + 1;                          //prida k i 1, posune hledanou pozici
     }
     while (i <= 9);
    printf(" \n");
    printf("---------------------------------------------------------\n");

  system("PAUSE");
  return 0;
}

Příklad 20: Vytvoření vlastní funkce pro opakované volání.

#include <stdio.h>
#include <stdlib.h>

void hlaseni (){
    printf ("Toto je prvni zprava \n");
    return;
}

int main(){
    hlaseni ();
    printf ("Toto je druha zprava \n");
    system("PAUSE");
    return 0;
}

Příklad 21: Vlastní funkce s návratovou hodnotou po výpočtu.

#include <stdio.h>
#include <stdlib.h>

int sDPH (int x){
    int celkem;
    celkem = x * 1.21;
    return celkem;
}

int main(){
    int cena;
    printf("Zadejte cenu bez DPH: ");
    scanf("%d", &cena);
    printf("\n");

    cena = sDPH (cena);
    printf ("S DPH je cena: %d \n \n" , cena);

    system("PAUSE");
    return 0;
}

Příklad 22: Vlastní funkce. Nejdříve jsou funkce deklarovány. Následně je vytvořena hlavní funkce. Podmíněné funkce jsou upřesněny až v dalším kódu. Některé proměnné jsou dostupné jen uvnitř bloku aby nedocházelo k jejich kolizím a také se tím šetřila paměť u složitějších programů.

#include <stdio.h>
#include <stdlib.h>

int ctverec (int a);       // priprava funkce
int trojuhelnik (int a);   // priprava funkce
int sestiuhelnik(int a);   // priprava funkce

int main(){
    int volba;          // vytvoreni promenne
    int strana;         // vytvoreni promenne
    static int obvod;   // staticka promenna zanika po ukonceni funkce - bloku

    printf("Vypocet: \n 1-ctverec \n 2-prav. trojuhelnik \n 3-prav. sestiuhelnik \n  ");
    scanf("%d", &volba);
    printf("\n");

    printf("Strana: ");
    scanf("%d", &strana);
    printf("\n");

    switch (volba){
                    case 1: {
                        obvod = ctverec (strana);
                        printf ("Obvod je: %d \n", obvod);
                        return;}

                    case 2: {
                        obvod = trojuhelnik (strana);
                        printf ("Obvod je: %d \n", obvod);
                        return;}

                    case 3: {
                        obvod = sestiuhelnik (strana);
                        printf ("Obvod je: %d \n", obvod);
                        return;}
                  }

    system("PAUSE");
    return 0;
}

int ctverec (int a){
 static int obvod; // staticka promenna zanika po ukonceni funkce - bloku
 obvod = 4* a;
 return obvod;}

int trojuhelnik (int a){
 static int obvod; // staticka promenna zanika po ukonceni funkce - bloku
 obvod = 3* a;
 return obvod;}

int sestiuhelnik (int a){
 static int obvod; // staticka promenna zanika po ukonceni funkce - bloku
 obvod = 6* a;
 return obvod;}

Příklad 23: Vlastní matematické funkce. 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int aI;
int bI;
int c;

int main()
    {
    printf("%i \n" , secti("950", "10003"));
    printf("%i \n" , odecti("1000", "3"));
    printf("%i \n" , vynasob("111", "7"));
    printf("%i \n" , secti("3a2 1", "100"));

    printf("\n");
    system("PAUSE");
    return 0;
}

int secti(char a[], char b[])
    {
    sscanf(a, "%i", &aI);   //sscanf naskenuje cisla z textoveho pole a do cisla aI
    sscanf(b, "%i", &bI);   //sscanf naskenuje cisla z textoveho pole b do cisla bI
    c = aI + bI;
    return c;
}

int odecti(char a[], char b[])
    {
    sscanf(a, "%i", &aI);
    sscanf(b, "%i", &bI);
    c = aI - bI;
    return c;
}

int vynasob (char a[], char b[])
    {
    sscanf(a, "%i", &aI);
    sscanf(b, "%i", &bI);
    c = aI * bI;
    return c;
}

Příklad 24: Vlastní datový typ.

#include <stdio.h>
#include <stdlib.h>

typedef int cislo; 
cislo x = 10;        // Promennou x nemusime tvorit jako int ale jiz jako cislo

int main(){
    x = x * x;
    printf ("Cislo je %d \n" , x );

    system("PAUSE");
    return 0;
}

Příklad 25: Vlastní datová struktura.

#include <stdio.h>
#include <stdlib.h>

typedef struct hraci{             // struktura hraci
    int cislo;
    char barva [10];
    int score;
    } HRACI;                      // datovy typ HRACI

int main(){

    HRACI Petr = {1, "zelena", 937} ;
    HRACI Lukas = {2, "modra", 941};
    HRACI Otakar = {3, "cervena", 899};

    printf ("%d %s %d \n" , Petr.cislo, Petr.barva, Petr.score );
    printf ("%d %s %d \n" , Lukas.cislo, Lukas.barva, Lukas.score );
    printf ("%d %s %d \n" , Otakar.cislo, Otakar.barva, Otakar.score );
    printf ("\n");



    system("PAUSE");
    return 0;
}

Příklad 26: Ukazatel na místo v paměti (pointer).

#include <stdio.h>
#include <stdlib.h>

int  x = 107;           // promenna x
int  *adresa_x = &x;    // adresa x v pameti

char znak = 'T';
char *adresa_znaku = &znak;

int main(){
    printf("Cislo x je ulozeno v pameti na adrese: %i" , &x);
    printf("\n");
    printf("Na adrese: %i" , &x);
    printf(" je ulozeno cislo: %i" , *adresa_x);
    printf("\n \n \n");

    printf("Znak je ulozen v pameti na adrese: %i" , &znak);
    printf("\n");
    printf("Na adrese: %i" , &znak);
    printf(" je ulozen znak: %c" , *adresa_znaku);
    printf("\n \n \n");

  system("PAUSE");
  return 0;
}