FUNKCE GETCHAR A FUNKCE PUTCHAR :                                16.10.                                                       
getchar - načte 1 znak klavesnice         getchar()
putchar - vytiskne 1 znak na obrazovku    putchar()
- musíme dat knihovnu #include <stdio.h>
- getch() neceka na zmacknuti klavesy



PR: chci dostat 10 * 20 = ... (vysledek)

#include <stdio.h>
#include <conio.h>
void miain(void)
{
  int i=10, j=20,
  clrscr();
  printf("%d x %d = %d",i,j,i*j);
  getch();
}

muzu si jeste dodat: printf(" Vysledek je : %d x %d = %d",i,j,i*j);



PR: #include <stdio.h>
    #include <conio.h>
    void miain(void)
    {
       int i;
       clrscr();
       scanf("%d",i);
       getchar();
    }

melo by se vytisknout na obrazovku 255

PR: #include <stdio.h>
    #include <conio.h>
    void miain(void)
    {


       int i,j;
       clrscr();
       scanf("%d %d",&i,&j); 
       putchar('\n')                odradkuje se 
       printf("vysledek %d",i*j);
       getch();
    }


ŘÍDÍCÍ STRUKTURY V JAZYCE C:

if(vyraz)
{ .
  .
  .
}
else 
{ .
  .
  .
}


pravdivy vyraz v jazyku C je vsechno co je ruzne od 0, 
nepravdivy je roven 0

kdyz je neco rovno, musime psat ==
= jen prirazuje
!= nerovnost
> < >= <= 
&& a zaroven
|| nebo
! negace

pozn: if(hodnota!=0) je stejne jako kdyz napisu if(hodnota)
      if(hodnota==0) je stejne jako kdyz napisu	if(!hodnota)


if(x!=0 && x/4==10){ ...
                    }

PR: #include <stdio.h>
    #include <conio.h>
    void main(void)
    {
      int znak;
      znak=getchar();
      if(znak=='a') {
         printf ("stiskli jste a");
         }
      else {
         printf ("stiskli jste neco jineho");
         }
     getch();
     }

PR: #include <stdio.h>
    #include <conio.h>
    void main(void)
    {
      int znak;
      if((znak=getchar())=='a') {
         printf ("stiskli jste a");
         }
      else {
         printf ("stiskli jste neco jineho");
         }
     getch();
     }



TERNARNI OPERATOR:

syntaxe: vyraz1 ? vyraz2 ! vyraz3
         jestlize je vyraz1 pravda proved vyraz2 a pokud je tomu 
         jinak proved vyraz3

PR: getchar()=='a' ? printf("stiskli jste a"):printf("stiskli jste 
    neco jineho");

PR: nacteme 2 hodnoty, porovname ktera je vetsi a ulozime ji do k

    #include <stdio.h>
    #include <conio.h>
    void main(void)
    {
      int i,j,k;
      scanf("%d %d",&i&j);
      k=(i>j) ?i:j;
   


PR: #include <stdio.h>
    #include <conio.h>
    void main(void)
    {
       int i=10,j=20;
       i++,j++

operator carky


CYKLY:
1) while - while(vyraz){} bude se vykonavat tak dlouho dokud bude 
           vyraz pravdivy

          #include <stdio.h>
          #include <conio.h>
          void main(void)
          {
            int i=0;
            while (i<10) 
            printf("%d/n",i++)

2) do while - do { ... 
               } while

            - provede se alespon 1 a provadi se dokud je pravdivy
          
          #include <stdio.h>
          #include <conio.h>
          void main(void)
          {
            int i=0;
            do {
            printf("%d/n",i++)
            } while (i<10) ;
           }

3) for - for(vyraz1; vyraz2; vyraz3){.....
          }
       - vyraz se většinou používá pro nastavení proměnných a provede se
         jeste pred tim nez se cyklus spusti, vyraz 2 se bude provadet 
         dokud bude pravdivy, vyraz3 se provede na konci kazdeho cyklu


          #include <stdio.h>
          #include <conio.h>
          void main(void)
          {
            int i;
            for(i=0;i<10; i++) {
              printf ("%d\n",i++)
            }

    - mužeme skratit:
          #include <stdio.h>
          #include <conio.h>
          void main(void)
          {
            int i;
            for( ; ; ) {
              printf ("%d\n",i++)
            }


          #include <stdio.h>
          #include <conio.h>
          void main(void)
          {
            int i;
            for(i=0,j=0,k=0; i<j && k<j; k+=3, j++, i-=10 ) {    -logicka blbost
              printf ("%d\n",i++)
            }

PŘÍKAZ SWITCH (obdoba case v pascalu):

switch(vyraz){
       case hodnota2:prikaz1;
                     . 
                     .
                     prikazn;
                     break;

       case hodnota2:prikaz1;
                     . 
                     .
                     prikazn;
                     break;
           . 
           .
       default:

             

PŘ: #include <stdio.h>                 
    #include <conio.h>
    void main(void)
    {
     switch(getch()) {
       case 'a': putchar('a');
                 break;
       case 'b': putchar('b');
                 break;
       case 'c': putchar('c');
                 break;
       default: printf("nic z toho");
        }
      getch();
    }  
              break;



=======================================================================
prikaz break: kdyz na nej program narazi, bezprostredne se ukonci 
              vnitrni cyklus

PR: 
     while(1) {
        if (getchar()=='a') {
          break }
    }

prikaz continue: pokracovat - neukoncuje se s nim cyklus, ale pouze 
se skace na konec cyklu, kde je continue

PR:
    hile(1) {
        if (getchar()=='a') {
          continue; }
    printf("Ahoj");
    }

- cyklus se stava nekonecnym (vytiskne se ahoj pokud zmacknu neco 
  jineho nez a)

prikaz return(param): ukoci bezprostredne a vraci parametry, az u
funkci

prikaz goto -

PR:

     while(1) {
      if (getchar()=='a') {
          goto chyba }
      printf("Ahoj");
    }
    chyba:
    printf("chyba");

   
PRACE SE SOUBORY:
musime #include <stdio.h>
- fopen("c:\\moje\\soubor.txt","r")- funkce pro otevreni souboru, 
pozor: v retezovych konstantach se lomitko zdvojuje
r - dany soubor otevre jen pro cteni, chyba pokud soubor neexistuje,
 ukazatel je na 1. znaku souboru

jine parametry (krome r):
w - jen pro zapis, pokud neexistuje tak se vytvori,
pokud ex. ukazatel na zacatku
a -pouziva se spise v kombinaci ra (nebo take wa), soubor je 
otevren pro cteni nebo zapis, ale kurzor je na konci

parametr se da pouzivat s + na konci - soubor se otevre pro 
cteni i zapis (ovsem z vlastnostmi daneho parametru, co se tyce 
existence)

rb - pro cteni binarnich (take wb+, atd.)
NULL - kontrola zda pri otvirani nedoslo k chybe

FILE - musi byt velkymi pismeny, ukazatel
FILE *soubor, *soubor1;
soubor = fopen("c:\\moje\\soubor.txt","r")


pro zavreni souboru:
fcloce(soubor);
EOF - pri chybe v zavirani souboru

int znak;
znak = getc(soubor) - k nacitani ze souboru

opakem ke getc() je: putc(znak, soubor) - znak uklada do souboru


PR: Skopiruje obsah text. souboru do druheho (znak po znaku)

    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
      FILE *puvodni, *kopie;
      int znak;
      if((puvodni=fopen("i:\\C++\\moje.txt","r"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      if((kopie=fopen("i:\\C++\\kopie.txt","w"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      while((znak=getc(puvodni))!=EOF){
         putc(znak, kopie);
         }
      fclose(puvodni);
      fclose(kopie);               pri teto funkci se malokdy stava chyba 
    }                              a proto se nekontroluje
   
  

fscanf
fprintf

    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
      FILE *puvodni, *kopie;
      int znak;
      if((puvodni=fopen("i:\\C++\\moje.txt","r"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      if((kopie=fopen("i:\\C++\\kopie.txt","w"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      while(fscanf(puvodni,"%c",&znak)!=EOF){
         fprintf(kopie,"%c",znak);
         }
      fclose(puvodni);
      fclose(kopie);   
    }     

PR:
    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
      FILE *puvodni, *kopie;
      int znak;
      if((puvodni=fopen("i:\\C++\\moje.txt","r"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      if((kopie=fopen("i:\\C++\\kopie.txt","w"))==NULL){
         printf("chyba!!!");
         exit(1);
         }
      while(fscanf(puvodni,"%d %d %d\n",&a, &b, &c)!=EOF){
         fprintf(kopie,"%d %d %d\n",a, b, c);
         }
      fclose(puvodni);
      fclose(kopie);   
    }  


PRACE S BINARNIMI SOUBORY:   
"\n" konec radku
- pouzivame na velka data
- funkce fread(char *kam, int velikost, int pocet, FILE *soubor) - k 
  nacitani nejakych n bajtu ze souboru do pameti
  parametry: kam se maji nacitat, jaka velikost v bajtech, kolik 
  polozek se ma nacist, ukazatel na soubor 


PR: #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
      int cislo;
      fread (&cislo, sizeof(int),1,soubor)

samozdrejme se musi jeste take fopen ...

=======================================================================


- funkce fwrite(char odkud, int velikost, int pocet, FILE *sobor)
- funkce fseek(FILE *sobor, long posun, int odkud) - umoznuje se 
  nejak pohybovat v binarnim souboru
  parametry- int odkud: SEEK_set nastavi se na zacatek, posne se o tolik 
                        bajtu, kolik specifikuje druhy parametr
                        SEEK_end nejdrive na konec a potom se posune 
                        (2. par. roven 0) 
                        SEEK_cur posune se 

- funkce ftell(FILE *soubor)- zjisti o kolik bajtu jsme posunuti 
  od zacatku


TYPOVA KONVERZE:
-implicitni konverze: predkladac se ridi podle 3 bobu:
                    -char, short int -> int
                    -char ->short ->int ->Long ->float ->double ->
                     ->Long double
                     napr: int a float bude typu float
                    -na leve str. int a prave float: 
                     int = float -> fload se prepise na int
                     


                     napr: int i
                           float f
                           char c
                           i=f*c

-explicitni typova konverze: int i;
                             float f;
                             f=(float)i;
                   

PRIKAZY PREPROCESORU:
-zacinaji vzdy #
napr: #include <stdio.h>
- #define -definuji se tak parametricke a bezparametricke makra

-bezparametricke   
PR:Nadefinujeme si PI 3.14
    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
     float f;
     f=PI*10;
    }
 
-do predkladece nejde ale PI, ale 3.14, vsechny symboli se nahradi
 jejich definici
-u makra se nakonci nepisou stredniky

-makra s parametry: nahrazuji funkce
-nayev_makra(arg1,...,argn) zdrij_kod_makra
PR: TISK_CHYBA printf("chyba!!!")  -bez stredniku
   
    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
     TISK_CHYBA;      do prekladace jde printf("chyba!!!");
    }

#define TISK_CHYBA(x) printf("chyba cislo: %d",x) vytiskne i 
                                                  cislo chyby

PR: #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
     TISK_CHYBA(5); =>printf("chyba cislo: %d",5);
    }

- #define se pise pod #include
PR: #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    #define DR_MOCNINA(x)  x*x  
    void main(void)             
    {
     int i=10;
     printf("%d",DR_MOCNINA(i))
    }

pokud napiseme do define x * x, tak to nevezme, musime dohromady
nebo zavorky (bere po 1.mezeru)
pozor - printf("d%",DR_MOCNINA(i+j))
        =>i+j*i+j
        musime tedy uzavorkovat (x)*(x) => (i+j)*(i+j)

PR: Zdali je znak velke nabo male pismeno (porovnaveme ASCI hodnotu)
    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    #define JE_VELKE(x) (x>='A'&& x<='Z') ? 1 : 0
    void main(void)
    {
     if(JE_VELKE(getchar())) {
     .
     .
     .
    } else ...

PR: #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    #define SPOJ(X,Y) X##Y
    void main(void)
    {  
     printf("%d",SPOJ(8,7))          => vystup 87
     ... }

-makra se nerozbaluji v retezcich
 tzn. #define A Ahoj
      printf("A")       bud vytiskne jen znak A, nebo zahlasi chybu   

podivat se na: ctype.h - ruzna makra
=================

#if konstantni_vyraz
#elseif
#elseif
.
.
.
#else
#endif

#indef SVGA 1
#if SVGA
 #include "svga.h"
#else
 #include"vga.h"
#endif

dalsi prikaz: 
#indef SVGA 0
#if SVGA
 #include "svga.h"
#else
 #include"vga.h"
#endif

samotny vyraz mohu take oddefinovat #undefine SVGA

#ifndef --STDIO_H
#define --STDIO_H
.
.
.
#endif   

s if se muze pouzit jen jedna podminka, kdyz jich chci vic,
pouziji:
#if define (SVGA) && defined(OWIO)
...


FNKCE:
-funkce main
 Hlavicka:
 plny funkcni prototyp - jsou jednotlive specifikovane typy
 funkcni prototyp - nejsou specifikovane

navratovy typ hodnoty nazev funkce(arg1,...,argn)    
 
void - nechci aby fnkce neco vracela
void tisku(void) - nechci nic predavat nebo vracet
{
printf("Ahoj")
}

funkci mohu volat i s jine funkce: ... tiskni();....

funkce, ktere predeavam a chci take vracet
int secti(int a, intb)
{
return(a+b)
} 

ve fci. tiskni mohu zavolat fci secti
voi tiskni (void)
{
printf("%d\n",secti(10,20));           nakonec se mi vytiskla 30
}

kdybych volal fci. secti(10.34,1.5) tak desetinna cisla se odriznou
a secte se jen 10 a 1

=======================================================================

hlavicku fce jsme definuvali: návratový typ jmeno funkce(arg1,...argn)
                              {...}

volali jsme je v jine fci: void tiskni(void)
                           { printf("chyba") 
                           } 
volali jsme ji nejakymi parametry: secti(5,10);


int secti(int a, int b);
{
return(a+b)
}

vyvolani fce muze byt napr:printf("10+20=%d",secti(10,20));                           

Rekurzivni volani: fce vola sama sebe 
napr: vypocet faktorialu 

    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
      int fact(int n)
      {
       return ((n<=1) ? 1 : n*fact(n-1))
      }
      
      printf("%d",fact(3));         -timto vyvolame   


PR:
int i=10;
f1() {                      f1-nejaka fce
     int a=20;
     }
int c=20;
f2() { ... }
main() { ... } 


PAMETOVE TRIDY:
- rika jak jsou promenne v pameti ulozene
1) auto

   {
   int i=10;              to same jako kdyz napisi: auto int i=10
   ... } 
   - jako lokalni promennou
2) static

   {
   static int i=10        promenna ma statickou dobu trveni
   ... }  
   -ma delsi dobu trvani (ne jen v bloku)
   PR:
   void nastav(void)
   {
   static int i=10;
   }
   void main(void)
   {
   printf("%d",i);
   }
   -je jak oglobalni promenna, ale neni.
___________________
CHYBI:
3) extern
4) registr
___________________

UKAZAELE:

PR: #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void main(void)
    {
    int i=10, *P_I;           promennou P_I muzem na stejny jako i
    P_I=&i;                   operator & dava adresu kam ulozit 
    printf("%d",*P_I);  
    }

    kdyz dam misto %d %p, vytiskne se mi adresa

PR: Vymeni 2 cisla: 
    #include <stdio.h>
    #include <conio.h>
    #include <process.h>
    void vymen(int *a, int *b)
    {
    int pom;
    pom=*a;
    *a=*b;
    *b=pom;
    }
    void main(void)
    {
     int i=10, j=20;
     vymen(&i,&j);
     printf("%d,%d",i,j);
     getch();
    }
                                                                
         

Konverze ikazatelu:
int i=10
float *P-f;
P-f=(float*)&I;    

---------------------------------

chybi jedna prednaska

---------------------------------

\0 nullovy znak
retezec v jednorozmaenem poli: 'a''h''o''j''\0'
musime ukoncit "\0"

retezec muzeme vytvorit staticky:
napr:
char ret[20]   o 20 znacich
ret[0]='a';
ret[1]='h';
ret[2]='o';
ret[3]='j';
ret[4]='\0';

nebo: char ret[]="Ahoj"   jenom v deklaraci, nemuzem vprosterd progr. 
      char ret[10]={'A','h','o','j','\0'}


dinamicky vytvareny retezec:
char *ret;
ret=(char*)malloc(10*sizeof(char))   malloc udava kolik se ma 
ret[0]='A'                           do pameti bajtu
c=ret[2];
free(ret);

pokud chci retezec vytisknout na obr: char ret[]='Ahoj';
                                      printf("%s",ret);

nacteni z klavesnice: char ret1[50];
                      scanf("%s",ret1);

fprintf(f,"%s",ret);
fscanf(f,"%s",ret1);

fprintf,print,fscanf,scanf - funguji jen po 1.bily znak

Funkce:include<string.h>
char *strcpy(char *S1, char *S2) 
-prekopiruje obsah 1. soub do 2. (ret1 prekopiruje do 2., jednotlive 
 znaky se prekopirovavaji)

char *strcat(char *S1, char *S2) 
-retezec S2 pripoji na konec retezce S1 (pozor na delku- aby se 
 tam S2 vesel)

char *strchr(char *S1, char c)
-nalezne 1.vyskyt daneho znaku v retezci
char *nalezt;
char S1[]='Ahoj';
char c='h';
nalezt                           -chybi kousek

int strcm(char *S1, char *S2)
-fce vraci: 0 kdyz jsou si retezce rovny
          : zaporne S1<S2
          : kladne S1>S2

char *strstr(char *S1, char *S2)

int atui(char *S1)
-prevede retezec do int, ret. muze obsahovat i carku

sprintf(S1,"%x",i)   - tiskne jakoby do retezce, vezme cislo z i
                       a podle %x ulozi do retezce S1
sscanf(S1,"%x",&i)   - nacita z formatu a uklada do promenne

puts(char *S1)       - je daleko rychlejsi nez sprintf, je 
                       jen pro retezce, odradkovava "\n"
                       pozor: ne pri praci se soubory
char gets(char *S1)  -nacte z klavesnice a necte do terezce, 
                      misto sscanf, nacte i bile znaky, jen pro retezce
                      samo si nacita "\0", 
                      pozor: ne pri praci se soubory

char *fgets(char *S1,int max, FILE *f)

PR:
FILE *f;
char S1[60];
f=fopen("c:\\moje.txt","r");
fgetsf(S1, 59, f);

chybi


VICEROZMERNA POLE:

int a[20];
int a[10][20][30];
a[?][?][?]=10;
c=a[9][29][19];

TROJROZMERNA POLE: staticky nebo dinamicky
int a[10][20][30];

a[0][0][0]=1;
c=a[1][2][3];

-pokud vztvarim staticky mohu hned pri deklaraci inicializovat
int a[][3]={{1,2,3}{4,5,6}{7,8,9}{10,11,12}}

int *a[3] ;           staticke jednoroznerne pole,sloupce vytvorime 
                      dynamicky (vznika dvourozmerne pole) 

chybi


BYTOVE POLE:
typedef struct {
  insigned int vaha: 7;
  unsignet int vek: 8;
  unsigned int pohlavi: 1;
}

#define MUZ 0
#define ZENA 1

VYCTOVY TYP:
typedef enum{false, true} BOOLEAN;
BOOLEAN X

if (X==true){
...
}

typedef enum{modra=13, bila=8, seda=10} BARVY;
BARVY x;

switch(x);
case seda: .
           .
           .
          break
case bila: ...
}
 
===================================================

ZASOBNIK

typedef struct clovek {
        int vaha
        int vyska
        int vek
        struct clovek *p_dalsi;   
               } CLOVEK, *P_CLOVEK;
P_CLOVEK p_akt;                               (p_akt vrchol zasobniku)
              
void init_zas(void);
{
p_akt = malloc (sizeof(CLOVEK));
     p_akt -> p_dalsi = NULL;
}                           

pridani prvku do zasobniku:
void pridej_zas(int vaha, int vyska, int vek)
{
P_CLOVEK p_pom;
p_pom = (P_CLOVEK) malloc (sizeof(CLOVEK));
p_pom -> vaha=vaha;
p_pom -> vyska=vyska;
p_pom -> vek=vek;
p_pom -> p_dalsi=p_akt;
p_akt = p_pom;
}             

odebrani prvku ze zasobniku:
void odeber_zas(void)
{
P_CLOVEK p_pom;
p_pom = p_akt -> p_dalsi;
free(p_akt);
p_akt = p_pom;
}             



typedef struct{
           int vek;
           int vaha;
           int vyska;
}CLOVEK;
CLOVEK X[100];
FILE *f;
f = fopen("c:\\moje.bin","wb");
fwrite(X, sizeof(CLOVEK), 100, F);
g= fopen("c:\\moje.bin");
fread(X, sizeof(CLOVEK), 100, g);