












                              Z A   N  M E
 
































































                                   - 2 - 








                                   vod


   C++ je objektov orientovan programovac (OOP) jazyk. Je dalm stupnm
v pirozenm vvoji C jazyka. Je penositeln, take je lehce mon penst
aplikan programy napsan v  C++  z jednoho systmu na druh. Konen, C++
je vhodnm jazykem tak pro vtinu programovacch loh.

   Turbo C++ je vytvoen pro programtory v C++ a C, kte potebuj rychl
a efektivn kompiltor, dle  pro  programtory  v  Turbo Pascalu, kte se
chtj nauit C++ nebo C se vemi vhodami "Turba" a v neposledn ad tak
pro kadho, kdo potebuje jak C++ verze 2.0 od AT&T, tak ANSI C.

   Turbo C je vysoce kompatibiln s kdem Turbo C.



---------------------------------------------------------------------------
Co obsahuje Turbo C++
---------------------------------------------------------------------------


   Turbo  C++  m  mnoho vlastnost, kter  jsou  v  posledn  dob  dny
uivateli:

   V kapitole 1 je popsna instalace Turbo C++. Kapitola 2 obsahuje  vce o
zmnnch vlastnostech.

       Turbo C++  vm nabz pln vyuit programovacch schopnost C++ (je
       implementovno C++ verze 2.0  od  AT&T).  K usnadnn zatku slou
       zabudovan knihovna C++. Tak k usnadnn pechodu od  verze  1.2 je
       vytvoena podpora.

       ANSI C: Turbo  C  vm poskytuje aktuln implementaci standardu ANSI
       C.   Borlandovsk   nov   programtorsk  zkladna.  Tato  zkladna
       pedstavuje  novou generaci  uivatelskho  rozhran;  pedchz  mu
       star integrovan prosted, kter umouje pln vyuit  program a
       prostedk danho potae. Zahrnuje:

           -  podporu myi

           -  mnostnv pekryvnch oken

           -  editaci vce soubor najednou (multi-file editor)

           -  podporu assembleru a dal.

    o  VROOMM (Virtual  Run-time  Object-Oriented  Memory  Manager): VROOMM
       umouje jednodue prci s pekryvy (overlay). Vyberete  segment pro
       overlay a VROOMM  se  postar  o  zbytek,  dl ve, co je poteba k
       umstn kdu do pamti 640 KB.

    o  Program, kter vs provede novou programtorskou zkladnou.



                                   - 3 - 


    o  Spaen  help  s koprovatelnmi pklady  program  prakticky  pro
       vechny funkce

    o  Mnostv nepostradatelnch knihovnch funkc vetn  funkc kontroly
       heapu  a  kompletn  sady  komplexnch  funkc   a   funkc  binrn
       aritmetiky.

   Dal rysy:

    o  Rozen  -S  volby:  Ke  zdrojovmu  kdu C jazyka je pidn  jako
       poznmka k vslednmu kdu v assembleru.

    o  Dalek (far) objekty a rozshl (huge) pole.

    o  Nkter nov vztahy (pragmas)  a  varovn  (warnings)  mezi etzci
       jazyka s danou smantikou  a  jejich  elem pro uivatele: varovn
       pi patn formulovanm pragmatu, argumenty uvan pragmaty a start
       pragmatu.

    o  Zmna .CFG soubor. Je mono nco vytvoit a vyut toho, kdy  se to
       bude hodit.

    o  "Odezvov" (response) soubory pro dkov kompiltor.



---------------------------------------------------------------------------
Poadavky na hardware a software
---------------------------------------------------------------------------


   Turbo C++ funguje na potach kompatibilnch s IBM PC, vetn XT, AT a
PS/2. Turbo C ++ poaduje DOS verze 2.0 nebo vy a nejmn 640 KB pamti.
Je teba jakkoliv  80-ti  sloupcov monitor. K minimlnm poadavkm pat
dle hard disk a jedna jednotka prunch disk.
Turbo C++ obsahuje rutiny, kter umouj prci s matematickm koprocesorem
80x87. Pokud nen  k  dispozici,  Turbo  C++ jej emuluje. Akoliv nepat k
nezbytnmu vybaven, koprocesor 80x87 znateln urychl bh vaich program.

   Turbo  C++  tak  podporuje  prci  s  my.  Ta  tak nepat k nutnmu
vybaven, ale pokud ji chcete pout, muste mt jednu my  z nsledujcho
vtu, nebo jinou s nimi pln kompatibiln:

    o  Microsoft Mouse verze 6.1 nebo vy verzi, ppadn jinou my  s n
       kompatibiln

    o  Logitech mouse verze 3.4 nebo vy

    o  Mouse System's PC mouse verze 6.22 nebo vy

    o  IMSI mouse verze 6.11 nebo vy











                                   - 4 - 


---------------------------------------------------------------------------
Implementace Turbo C++
---------------------------------------------------------------------------


   V Turbo C++ je implementovna pln C++ verze 2.0 od AT&T. Obsahuje tak
standart American National  Standards  Institute  (ANSI)  a  pln podporuje
definici Kernighana a Ritchieho. Navc jsou zabudovna samozejm rozen
pro  kombinovan jazyk (mixed language) a  programovn  s  rznmi  modely
(mixed model programming) kter pln  vyuv  schopnost  PC.  pln popis
Turbo C++ najdete v  Programtorsk  pruce,  kapitola 1, "Standart Turbo
C++".



---------------------------------------------------------------------------
Balk Turbo C
---------------------------------------------------------------------------


   Balk turbo C++ obsahuje nkolik distribunch disket a tyi manuly:

    o  Turbo C++ - Zanme (tato kniha)

    o  Turbo C++ - Uivatelsk pruka

    o  Turbo C++ - Programtorsk pruka

    o  Turbo C++ - Knihovna

   Zanme  a  Uivatelsk  pruka  dvaj   nvod,   jak   vyut  C++,
Programtorsk pruka a Knihovna se zamuj na programovn v C.

   K tmto  tyem manulm je piloena pruka Rychl nvod. Distribun
diskety obsahuj vechny programy,soubory  a  knihovny,  kter jsou teba k
vytvoen,  kompilaci,  linkovn  a sputn program v  Turbo  C++;  dle
obsahuj  pklady  program, nkolik standartnch  utilit,  spaen  help
soubor,  integrovan ladic program (debugger) a  dal  dokumentaci  k  C,
kter nen poopsna v tchto prukch.


Zanme
---------------------------------------------------------------------------

   Tato pruka  uvd  do  Turbo  C++  a  ukazuje, jak vytvoit a spustit
programy  v  C  i  v  C++.  Obsahuje  informace, kter je teba k  rychlmu
zatku: instalaci, konzultace, zklady a  dle  provd  dokumentac Turbo
C++. Manul obsahuje tyto kapitoly:

   Kapitola 1: Instalace Turbo C++ obsahuje nvod k instalaci Turbo C++.

   Kapitola  2:  Orientace  v  manulech  Turbo  C++  uvd  nejzajmavj
vlastnosti  Turbo  C++  a nvod k jejich osvojen, obsahuje i odkazy, kde o
nich najt vce informac.

   Mete vyzkouet provdc program TCTOUR.






                                   - 5 - 


   Kapitola 3: Nov IDE - provd integrovanm prostedm  a  popisuje nov
editor, podporu myi a dal nov nebo zmnn  vlastnosti.  Obsahuje letm
pehled systmu Turbo C++. Hlub informace  je  mono najt v kapitole 1 "
IDE" v Uivatelsk pruce.

   Kapitola 4: vod do C je pehledem jazyka C. Tato kapitola uvd zklady
programovn v C, data a datov typy, opertory, funkce, pole,  struktury a
jin rysy jazyka C.

   Kapitoly 5 a 6 pat k sob, jedna obsahuje teorii, druh praxi.

   Kapitola 5: Zklady C++ je  vodem  do  systmu  objektov orientovanho
programovn v C++.

   Kapitola 6: Pruka C++ je rychlm vodem do C++.

   Kapitola 7: Ladn v novm IDE popisuje integrovan ladic program Turbo
C++  a   provd  nkolika  chybnmi  programy  na  kterch  ukazuje  rzn
vlastnosti tohoto programu.

   Knihovna obsahuje seznam knih, ze  kterch byly erpny podnty k tvorb
C, C++ a obzvlt Turbo C++.


Uivatelsk pruka
---------------------------------------------------------------------------

   Uivatelsk pruka obsahuje  kapitoly popisujc vlastnosti Turbo C++:
Borlandovsk  nov  integrovan prosted obsahujc  jak  velmi  rozen
editor a projektovho sprvce (Project Manager), tak podrobnosti k utilitm
Turbo C++, dkov kompiltor a program pro styk s uivatelem.

   Kapitola 1: Popis IDE - podv kompletn informace o IDE.

   Kapitola 2: zen  vcesouborovch  projekt (multi - file projects) je
vnovna  vyuit  Sprvce  projekt  v  programovch  projektech   o  vce
souborech.

   Kapitola 3: Editor od A do Z obsahuje pln popis editoru.

   Kapitola 4: dkov kompiltor uvd, jak vyut  dkovho kompiltoru.
Dle vysvtluje konfiguran soubory.

   Kapitola 5: Utility popisuje nkter z utilit obsaen v Turbo C++.

   Kapitola  6:  Uivatelsk  prosted  Turbo  C++ dv nvod  k  programu
TCINST, kter nastavuje uivatelsk prosted. Je  mono  pizpsobit barvy
obrazovky, implicitn hodnoty editoru, kompiltoru, linkeru a mnoho dalch
aspekt Turbo C++.

   Dodatek A : Makra Turbo editoru popisuje makrojazyk Turbo editoru, kter
je mocnm nstrojem k rozen nebo pozmnn editoru Turbo C++.










                                   - 6 - 


Programtorsk pruka
---------------------------------------------------------------------------

   Programtorsk pruka obsahuje uiten materil pro zkuen uivatele
jazyka C: kompletn popis  jazyka  C a C++, pam؟ov modely, programovn s
rznmi  modely,  videofunkce,  informace  o  pohybliv  rce,  pekryvech
(overlay) a chybovch zprvch.


   Kapitola 1: Standard jazyka Turbo C++ popisuje Turbo C++. Jsou  zde tak
rozen standardu ANSI C. Tato  kapitola je zkladnm popisem jak aspekt
C, tak Turbo C++.

   Kapitola  2:  Kov  reference  run-time  knihovny  poskytuje  nkter
informace  o  zdrojovm  kdu run-time knihovny, obsahuje  seznam  a  popis
hlavikovch  soubor  a  podv  kov  reference  o  setdn run-time
knihovn. Napklad pokud by jste chtli najt, kter funkce se vztahuj ke
grafice, je mon se podvat pod nadpisem "Grafika".

   Kapitola 3: C++ streamy dv nvod, jak uvat knihovnu  stream  v  C++
verze 2.0. Dokumentace se tak tk nich verz.

   Kapitola 4: Modely pamti, pohybliv  rka  a  overlay  popisuje modely
pamti,  programovn  s  rznmi  modely,  operace s pohyblivou  rkou  a
overlay.

   Kapitola 5: Video funkce je vnovna textm a grafice v Turbo C++.

   Kapitola  6: Assembler k, jak pst programy v  assembleru  a  jak  je
spoutt z program Turbo C++.

   Kapitola  7:  Chybov  zprvy  obsahuje  seznam  a  popis vech  chyb  a
varovn,  kter  vznikaj  pi  bhu  programu  a  pi kompilaci.  Zrove
navrhuje jejich mon odstrann.

   Dodatek A:  Implementovan ANSI standard popisuje ty aspekty, kter jsou
ve  standardu  ANSI  C nedefinovny. Tyto  aspekty  se  mohou  mnit  podle
implementace. Dodatek k, jak Turbo C++ jednotliv aspekty aplikuje.


Knihovna
---------------------------------------------------------------------------

   Popis knihovny obsahuje detailn vpis  a vysvtlen k vnj knihovn a
globlnm promnnm v Turbo C++.

   Kapitola 1: Run-time knihovna  je  abecedn  setdnm seznamem ke vem
knihovnm  funkcm  Turbo  C++. U kad funkce je syntaxe, include soubory,
operativn popis, hodnoty, je funkce  vrac,  informace  o penositelnosti
(portability) a referenn seznam relanch opertor.

   Kapitola 2: Globln promnn definuje  a  vysvtluje  globln promnn
Turbo C++. Pi jejich  vhodnm  pouit  (  datum, chybov zprvy, velikost
zsobnku apod.) uette mnoho programtorskho asu.








                                   - 7 - 
































































                                   - 8 - 








                            K a p i t o l a   1

                            Instalace Turbo C++


   Balk Turbo C++ sestv ze dvou rznch st kompiltoru Turbo C++:
sti  s  integrovanm  prodtedm a st s pekladaem. K instalaci Turbo
C++ muste pout program  INSTALL,  kter  automaticky zkopruje soubory z
distribunho disku na  hard  disk. Proti koprovn nen zavedena ochrana.
Pro plnost obsahuje soubor README seznam distribuovanch soubor.

   Pokud neznte pkazy DOS,pak se  pedtm, ne zanete s instalac Turbo
C++, podvejte do referennho manulu DOSu.

   Pedpokldme,  e  jste  seznmani s pkazy DOSu.  K  vytvoen  kopi
distribunch  disket  je  potebn  pkaz  DISKCOPY.  Udlejte  si  je  a
originln diskety uschovejte na vhodn msto.
   Pokud nejste seznmeni s Borlandovskou  No  Nonsence  License Statement,
pette si dokument obsaen  v  balku Turbo C++. Potou nm polete zpt
vyplnnou  registran kartu, co vm zaruuje,  e  budete  mezi  prvnmi,
kte budou mt nejerstvj informace o nejnovjch verzch Turbo C++.

   Tato kapitola obsahuje nsledujc informace:

    o  instalace Turbo C++

    o  soubor README

    o  soubor HELPME!

    o  odkaz na informace o TurboCalc

   Pokud mte instalovno  Turbo  C++,  je  mono jej zat zkouet. Je ale
nutno vdt alespo nco o nkterch kapitolch a manulech, kter obsahuj
informace nezbytn k programovn. Kapitola 2, "Orientace v manulech Turbo
C++", poskytuje zkladn informace o tom, kde najt vce daj o Turbo C++.



---------------------------------------------------------------------------
Instalace Turbo C++
---------------------------------------------------------------------------


   Turbo  C++ m automatick instalan program  -  INSTALL,  kter  muste
pout. Tento program zjiuje, jak hardware mte k dispozici a podle toho
pimen stanovuje konfiguraci Turbo C++. Dle vytv potebn adrese a
pen  soubory  z  distribun  diskety  na  hard  disk. Jeho  akce  jsou
samovysvtlujc;  nsledujc  text  obsahuje  ve,  co je teba  vdt  k
instalaci Turbo C++:

1. Vlote instalan disk do achty A. Napite nsledujc  pkaz  a  pot
stisknte Enter.
2. A:INSTALL


                                   - 9 - 


3. V instalan obrazovce zmknte Enter.
4. Dle konejte dle pkaz.

Dleit!
   Kdy je instalace skonena, program INSTALL vm pipomene,  aby  jste si
peetli nejnovj informace o Turbo  C++ v souboru README, kter obsahuje
dleit nejnovj  informace  o  systmu  Turbo  C++.  Soubor HELPME!.DOC
odpovd na mnoho otzek tkajcch se technick podpory.
   Nyn je Turbo C++ instalovn a mte monost vyzkouet TCTOUR.  TCTOUR je
prvodcem po dleitch prvcch integrovanho prosted  novho  Turbo C++.
TCTOUR se nachz v podadresi TOUR, mimo adres Turbo C++.

   Pro ukonen prce s Turbo C++ stisknte Alt-X.

   Po instalaci Turbo C++ a vyzkouen TCTOUR jste mon dychtiv jt dle.
Pak se pepnte  do  adrese  Turbo  C++  a napite TC. Zmknte Enter. V
opanm  ppad  pokraujte  ve ten tto  kapitoly.  Pot,  co  jste  si
vyzkoueli integrovan  prosted Turbo C++, chtli byste mon nco zmnit
v  uivatelskm  nastaven.  To  umouje  program  TCINST.  Instrukce jsou
obsaeny v kapitole 6  "Nastaven  uivatelskho  prosted"  v Uivatelsk
pruce.


Systmy laptop
---------------------------------------------------------------------------

   Pokud vlastnte pota  laptop  (s  plasmatickm  nebo  LCD displejem),
potebujete  jet  navc  ped  sputnm  Turbo  C++  nastavit obrazovku.
Integrovan  prosted  Turbo  C++  pracuje  nejlpe po zadn MODE BW80  z
operanho systmu DOS jet ped sputnm Turbo C++.

   Akoliv je mono vytvoit  dvkov  soubor, kter se o tuto vc postar,
ernoblou obrazovku mete instalovat i pomoc programu  TCINST. Instrukce
je  mono   najt  v  kapitole  6  "Nastaven  uivatelskho  prosted"  v
Uivatelsk pruce. V TCINST zvolte nabdku "Black and White" z menu
Screen Modes.



---------------------------------------------------------------------------
Soubor README
---------------------------------------------------------------------------


   Soubor  README  obsahuje   nejerstvj  informace,  kter  nemus  bt
zahrnuty v manulu. Obsahuje tak  seznam  vech  soubor  na distribunch
disketch spolu s krtkm popisem kadho z nich.

   Sputn souboru README :

1.  Jestlie nemte instalovn Turbo C++, vlote disketu  s  Turbo  C++  do
mechaniky  A.  Jestlie  mte Turbo C++ instalovn, pokraujte bodem 3 nebo
nsledujcm odstavcem.

2. Napite A: a stisknte Enter.

3. Napite README a stisknte Enter. Nyn se nachzte v souboru README a k
jeho prohlen je mono ut ipky nahoru a dol.

4. Ze souboru se dostanete stiskem Esc.


                                  - 10 - 


   Vce  detail  o  vyuit novho integrovanho prosted  se  nachz  v
kapitole 3 "Nov IDE" v tto pruce a v kapitole 1 "Popis IDE" v Pruce
uivatele.
   Pokud  je  Turbo  C++  ji   instalovn,  je  mono  zkusit  otevt  do
editovacho okna soubor README pomoc tchto bod:

1. K odstartovn Turbo C++ napie na pkazov dek TC. Stisknte Enter.
2.  Stisknte  F10.  Vyberte volbu File|Open. Napite  README  a  stisknte
Enter. Turbo C++ oteve do editovacho okna soubor README.

3. Pokud jste skonili  prci  se  souborem  README, zvolte File|Quit (nebo
pokraujte ve zkouen novho IDE).



---------------------------------------------------------------------------
Soubor HELPME!.DOC
---------------------------------------------------------------------------


   Instalan disketa obsahuje soubor nazvan HELPME!.DOC,  ve  kterm jsou
obsaeny  odpovdi na problmy, je obvykle  mvaj  uivatel.  Pokud  vm
vyvstanou problmy, podvejte se do  nj. K prohldce mete vyut program
README. Napite nsledujc pkazy:

README HELPME!.DOC



---------------------------------------------------------------------------
Turbo Calc
---------------------------------------------------------------------------


   Balk Turbo C++  obsahuje  zdrojov kd tabulkovho programu Turbo Calc.
Ped jeho kompilac je nutno si pest dokumentaci v souboru TCALC.DOC.


























                                  - 11 - 
































































                                  - 12 - 








                            K a p i t o l a   2

                      Orientace v manulech Turbo C++


   Tato kapitola slou:

    o  ke strunmu seznmen s nejzajmavjmi  vlastnostmi  Turbo  C++ -
       jak jsou, pedchoz koncepce, jejich pouit.

    o  k tomu, aby  poskytla  informace,  kde  je mono najt vce o novch
       vlastnostech a aspektech Turbo C++.

   Pokud jste si na pedchozch  stranch  peetli,  jak  instalovat Turbo
C++, je vm  tak  jasn,  jak  ho  odstartovat a jak ukonit jeho innost.
Pokud ne a jestlie chcete zat pmo programovat, podvejte se dle.



---------------------------------------------------------------------------
Vlastnosti
---------------------------------------------------------------------------


   Turbo  C++  m  mnoho uitench vlastnost, je jsou popsny na prvnch
stranch. Tato st obsahuje o nco vce a k, kde najt dal informace.



C++
---------------------------------------------------------------------------

   S Turbo C++ dostvte dva kompiltory v jednom. Jsou k dispozici vechny
schopnosti ANSI C  plus  vechny  vlastnosti  C++. Kapitoly 5 a 6, "Zklady
C++" a "Pruka C++" obsahuj konzultace a teorii o programovn v C++.

   Navc jsou k  okamitmu  pouit pipraveny knihovny C++. Tyto knihovny
obsahuj  velk  mnostv  funkc.  Dal  vhody  C++  jsou roziitelnost
(extensibility) a opakovan pstup (reusability).


VROOMM (OVERLAY)
---------------------------------------------------------------------------

   Hlub  informace  o  pekryvech  podv  kapitola  4  " Modely  pamti,
pohybliv rka a overlay " v Programtorsk pruce.
   Turbo  C++ dv k dispozici VROOMM  (Virtual  Run-time  Object  Oriented
Memory Manager), inteligentn overlay. Pokud znte pekryvy   z  jinch ne
borlandovskch produkt, budete  pjemn  pekvapeni. Za prv - VROOMM um
urit, jak a kdy overlay provst,  co  vs  tto lohy zbavuje. Za druh -
akoliv je  VROOMM zaloen na rafinovanch algoritmech, je mnohem rychlej
a efektivnj ne jin schmata pekryv.




                                  - 13 - 


Borlandovsk nov integrovan prosted
---------------------------------------------------------------------------

   Pestoe borlandovsk integrovan prosted  u  bylo  podrobn popsno,
doporuujeme vm nechat se jm provst programem TCTOUR;  dokonce  i tehdy,
jestlie jej dvrn znte z jinch produkt firmy Borland. Pepnte  se do
podadrese TOUR v adresi TC. Pak napite TCTOUR a stisknte Enter.

   Vce informac lze najt v kapitole 3 "Nov IDE". Tato kapitola umouje
zskat  zkuenosti  s  mnostvm  novch  vlastnost  v  novm integrovanm
prosted vetn podpory myi, systmu npovdy, oezvn,  novch zpsob
operac s okny, editace vce soubor, penosu do jinch program (i zpt do
Turbo C++), atd. V kapitole 1 "IDE" v Uivatelsk  pruce  jsou  obsaeny
vechny vlastnosti novho integrovanho prosted.



---------------------------------------------------------------------------
Jak pouvat manuly
---------------------------------------------------------------------------


   Manuly jsou napsny tak, aby jste  okamit  a pesn mohli v knihch a
kapitolch  najt  to,  co  potebujete.  Zanme  a  Uivatelsk pruka
poskytuj  informace,  jak  vyut  Turbo  C++;  Programtorsk  pruka a
Knihovna obsahuje materil o programovn v C a C++.

   Nsledujcch  pt kapitol tto pruky je  vnovno  vodu  do  tchto
zleitost:

    o  Kapitola 3, "Nov IDE"

    o  Kapitola 4, "vod do C"

    o  Kapitola 5, "Zklady C++"

    o  Kapitola 6, "Pruka C++"

    o  Kapitola 7, "Ladn v novm IDE"

   Jak u bylo eeno  dve,  integrovan prosted je z vt sti nov,
take doporuujeme projt prvn kapitolu tohoto seznamu i tehdy, kdy znte
Turbo C nebo Turbo Pascal.

   Jako referenn pruky k  Turbo  C++  slou tyto kapitoly Uivatelsk
pruky:

Prostudujte tyto kapitoly, a budete mt zvldnuty zklady.

    o  Kapitola 1, "IDE"

    o  Kapitola 2, "zen vcesouborovch (multi-file) projekt"

    o  Kapitola 3, "Editorem od A do Z"

    o  Kapitola 4, "Kompiltor z pkazovho dku"

    o  Kapitola 5, "Utility"

    o  Kapitola 6, "Uivatelsk prosted Turbo C++"


                                  - 14 - 


    o  Dodatek A, "Makra Turbo editoru"



---------------------------------------------------------------------------
Zatenci a programtoi, kte se u C jazyku
---------------------------------------------------------------------------


   Pokud se ute  C jazyk, zante kapitolami 3 a 4, "Nov IDE" a "vod do
C".  V  tchto  kapitolch je obsaen vod do integrovanho prosted Turbo
C++ a dvaj pehled o programovn v C. Kapitoly 5 a  6,  "Zklady  C++" a
"Pruka C++" obsahuj strun informace o programovn v C++. Po peten
kapitoly 4 je mono skoit pmo do tchto kapitol v zvislosti na tom, jak
jste vyspl v programovn vbec a jak zvldte programovn v C. Kapitola
7, "Ladn v novm IDE", provd integrovanm debuggerem Turbo C++. Pozdji
je mono vyut kapitol 1 a 6 v Uivatelsk pruce.

   Dalm  vam  krokem  bude zat programovat v C jazyku. Nejvce budete
vyuvat pruku Knihovna. Je mono  vyut  i  spaenou  npovdu, kter
obsahuje stejn mnostv informac jako  Knihovna a navc pro tm vechny
funkce pipojuje pklady, kter je mono koprovat do vaich program.



---------------------------------------------------------------------------
Zkuen programtoi v C
---------------------------------------------------------------------------


   Pokud jste zkuenmi programtory  v  C  jazyku  a mte instalovn Turbo
C++,  budete  asi  chtt zat pracovat pmo s Programtorskou prukou a
Knihovnou.  Jestlie  se  vak chcete dozvdt vce  o  novm  integrovanm
prosted  vetn  integrovanho  ladicho  programu,  pette  si  v tto
pruce kapitoly 3 a 7 ("Nov IDE" a "Ladn v novm IDE").

   Pokud  vs  zajm  C++,  pette  si  kapitoly  5  a 6, "Zklady C++"a
"Pruka C++".

   V  Programtorsk  pruce  lze  nalzt nkter uiten programtorsk
informace, jako nap.  C++  streams,  rozhran  assembleru,  modely pamti,
videofunkce,  pekryvy,  dalek  (far)  a  velk  (huge)  ukazatele.  Navc
obsahuje  Programtorsk  pruka  kov  reference  ke  Knihovn  podle
funknosti (kapitola 2,  "Kov  reference  Run-time  knihovny  "). Take
napklad  pokud  chcete  vdt,  kter  funkce  v  C pracuj  s  grafikou,
vyhledte patinou kapitolu a v n najdete nzev "Grafika".
















                                  - 15 - 
































































                                  - 16 - 








                            K a p i t o l a   3

                                 Nov IDE


   Ne  se  zatete  do  tto  kapitoly,  je  nutno  instalovat Turbo C++ s
odpovdajcmi podadresi. Podrobnosti v kapitole 1.
   Tato  kapitola  je  vnovna  nov  verzi  borlandovskho  integrovanho
prosted (Borland integrated development environment)  -  IDE.  I  kdy u
dvrn znte jin produkty firmy Borland, doporuujeme vm prost si tuto
kapitolu. D vm pehled o  nejdleitjch  novch  vlastnostech  IDE. Je
rozlenna do t lekc:

    o  Lekce 1 ukazuje sputn  Turbo  C++,  nahrvn, editaci a ukldn
       soubor.

    o  Lekce 2 popisuje kompilaci a sputn programu z IDE.

    o  Lekce 3 podv nvod k ukonen prce s Turbo C++.

   Jestlie  vs  svrb  prsty  a  chcete  prv  te  spustit  Turbo  C++,
nalistujte prvn kapitolu. V opanm ppad tte dle a  ute  se  novmu
IDE. Zabere vm to asi 30 minut.

   Pokud potebujete najt hlub  informace  o  nkterch polokch v menu
nebo o dialogovch oknech,  jsou  obsahem  kapitoly  1, "IDE" v Uivatelsk
pruce.   Jestlie  vm  vce  vyhovuje  interaktivn  pstup,   spuste
TCTOUR.EXE (napite v DOSu podadresi TOUR jmno TCTOUR).

   Kapitola 7 " Ladn v novm IDE" poskytuje del nvod k ladn.



---------------------------------------------------------------------------
IDE
---------------------------------------------------------------------------


   Turbo  C++   IDE  sestv  z  oken,  menu  (roletovch  a  pekryvnch),
dialogovch oken a stavovch dk. Nsleduje diagram typickch sloek IDE:
















                                  - 17 - 


    poloka menu
    aktivn oknoͻ neaktivn oknoĿ
                        Pkaz  >                                 
  roletov menu-------->   Ŀ                             
                           Pkaz...                             
                             ͻ 
                              Vstupn rmeek                     
                       ĳ     
       pekryvn menu----->                                        
                           ĺ [ ] K.r.v.                          
                                [X] K.r.z.      >[aktiv.tlatko]<  
      [X] K.r.z.                          
    neaktivn okno  [ ] K.r.v.       [neakt.tlatko]   
                                                                    
                                ( ) R.t.v.                          
        dialogov-------------> ( ) R.t.z.       [neakt.tlatko]   
        rmeek                 (.) R.t.v.                          
                               ͼ 
                                                                      
    
    Stavov dek

Pozn.:K.r.v. - Kontroln rmeek vypnut
      K.r.z. - Kontroln rmeek zapnut
      R.t.z. - Rdiov tlatko zapnuto
      R.t.v. - Rdiov tlatko vypnuto

                           Obr. 3.1: Sloky IDE

 Ŀ
 F10
 
   K aktivaci systmu menu IDE stisknte F10 a nsledn klvesu s psmenem,
kter odpovd zvraznnmu psmenu  v  libovolnm  dku  menu. ( je mono
stisknout i Alt spolu se svraznnm psmenem - nap.  Alt-F  otevr  File
menu stejn jako F10 F.

 Ŀ
 Esc
 
   Ke zruen menu stisknte Esc dokud vechna nepotebn menu nezmiz a vy
se neocitnete zptky v jednom z oken.

   K vypsn voleb uv Turbo C++ dialogov okno ( dialog box ). Dialogov
okno obsahuje jednu nebo  vce  poloek,  je  jsou zobrazeny v nsledujc
tabulce. (Pokud prv te chcete vyzkouet Turbo C++,  pett  si prvnch
nkolik odstavc z instalace Turbo C++.)















                                  - 18 - 


             Tab. 3.1: Co lze vechno udlat v dialogovm okn

---------------------------------------------------------------------------
Poloka             Jak vypad a co um
---------------------------------------------------------------------------
Akn tlatka      Akn tlatka (action buttons) jsou "vystnovanm"
                    textem. Pokud si vyberete tlatko (stiskem Enter nebo
                    kliknutm my), Turbo C++ okamit vykon poadovan.

Kontroln rmeek   Kontroln rmeek (check box) je bu zapnut nebo vypnut
                    (on nebo off). Ke zmn volby stisknte mezernk nebo
                    kliknte my. Jestlie je kontroln rmeek zapnut
                    (on), objev se x v hranatch zvorkch: [x].

Rdiov tlatka    Rdiov tlatka (Radio buttons) jsou volby, kter se
(Radio buttons)     vyskytuj ve dvou nebo vce dcch. Souasn me bt
                    aktivn pouze jedna volba. Jej nastaven se provede na
                    klvesnici ipkami. K oputn mnoiny voleb stisknte
                    Tab. S my je mono udlat klik na libovoln dek
                    rdiovho tlatka. Pokud je rdiov tlatko aktivn,
                    objev se v kulatch zvorkch kulika.

Vstupn okno        Vstupn okno (Input box) poaduje vstup etzce
(Input box)         (napklad jmno souboru ).

Seznamov okno      Seznamov okno (List box) pedstavuje seznam poloek,
(List box)          ze kterch je mono vybrat ( napklad seznam soubor,
                    je je mono otevt ).
---------------------------------------------------------------------------

   Dialogov  okna  se  objev,  jestlie  zvolte  poloku   menu,  kterou
doprovz ikona dialogovho  okna  (...),  tak  jak  je  znzornno  v menu
File|Open na obrzku 3.3.


Full Menus On/Off
---------------------------------------------------------------------------

   V Turbo C++ si mete vybrat ze dvou systm menu:  pln  menu zapnuto a
pln  menu vypnuto (Full menus on a Full menus off). Full menus off zobraz
zhutn  pehledn  menu  s minimln mnoinou pkaz, kter jsou teba k
vytven a ladn program Turbo C++. Full menus on poskytne vt mnoinu
pkaz  pro  rozshlej  programov   lohy.   V   tomto   nvodu  budeme
pedpokldat volbu Full menus off.

   Obrzek 3.2 porovnv dva stavy menu - jak vypad napklad menu Compile
ve Full menus on a Full menus off.















                                  - 19 - 


 ͻ                  ͻ
  Full Menus Off                   Full Menus On
 ͼ                  ͼ
  Compile                  Compile
 Ŀ                Ŀ
   Make EXE file                   Compile to OBJ  
   Build All                       Make EXE file   
                  Link EXE file   
                                     Build All       
                                    Ĵ
                                     Remove messages 
                                    

                      Obr. 3.2: Full menus : on a off


My, hork klvesy a spaen help
---------------------------------------------------------------------------

   Ne skote pmo do IDE, mli  byste  znt  zklad o tom, jak Turbo C++
podporuje my, dle nco o horkch klvesch a spaenm helpu.

   Pokud  jste jet nepracovali s my, podvejte  se  do  manulu,  kter
pslu k dan myi.
   IDE  Turbo  C++  podporuje my. Lev tlatko na myi je ureno pro IDE.
Turbo  C++ umouje tlatka myi pedefinovat:  detaily  viz  kapitola  1,
"IDE" v Uivatelsk pruce. Akce s my popisuj tyto pojmy:

                            Tab. 3.2: e myi

---------------------------------------------------------------------------
Akce                popis
---------------------------------------------------------------------------
Klik                Zmknout a uvolnit tlatko na myi.
Dvojit klik        Dvakrt kliknout za sebou.
Pesun (drag)       Zmknout tltko na myi, pesunout my a uvolnit
                    tlatko.
Klik-pesun         Zmknout a uvolnit tlatko na myi, znova zmknout,
(Click-drag)        pesunout a uvolnit.
Vbr (Choose)      Kliknout poloku menu, stejn jako selektor v
                    pkazovm nebo dialogovm okn.
---------------------------------------------------------------------------


Hork klvesy.

   Mnoho  poloek v menu a dialogovch  oknech  koresponduje  s  uivatelem
pomoc  horkch  klves,  co  jsou  jedno  nebo  dvoutlatkov zkracovac
klvesy aktivujc pkaz nebo dialogov okno. ( V  dialogovm  okn, pokud
nejste  ve  vstupnm  dku, sta ke zmn  pkazu  stisknout  zvraznn
psmeno.) Nsledujc tabulka  obsahuje  nejvce  uvan  hork  klvesy v
Turbo C++. Obshlej  vet  lze  najt  v kapitole 1, "IDE" v Uivatelsk
pruce.









                                  - 20 - 


                     Tab. 3.3: Hork klvesy Turbo C++

---------------------------------------------------------------------------
Klvesa  poloka menu         funkce
---------------------------------------------------------------------------
F1      Help                  Otevr spaen obrazovkov help

F2      File|Save             Ukld soubor, je je aktivn v editanm
                              okn.

F3      File|Open             Aktivuje dialogov okno, ze kterho je mono
                              otevt soubor.

F4      Run|Go to Cursor      Startuje program a k dku, kde je nastaven
                              kursor.

F5      Window|Zoom           Zvtuje a zmenuje aktivn okno.

F6      Window|Next           Cykluje vemi otevenmi okny.

F7      Run|Trace Into        Sput program v ladicm mdu a trasuje
                              pitom funkce.

F8      Run|Step Over         Spout program v ladicm mdu bez trasvn
                              funkc.

F9      Compile|Make Exe      Pekld odpovdajc zdrojov kd do EXE
                              souboru.

F10     (neexistuje)          Nvrat do slouce menu.
---------------------------------------------------------------------------

 Ŀ
 MY
 
   Stavov dek na spodu obrazovky  obsahuje hork klvesy, kter je mono
v  tom kterm okn ut. Jestlie mte my,  mete  msto  stisku  klvesy
kliknout my.


Spaen npovda.

   Turbo C++ stejn jako  jin  produkty  firmy Borland obsahuje kontextov
citlivou spaenou npovdu,  kter  se aktivuje stiskem hork klvesy nebo
kliknutm my. Npovda existuje ke kad poloce v Turbo C++ IDE  plus ke
ke  kadmu  rezervovanmu  slovu  nebo  knihovn  funkci.  Navc je  mono
koprovat pklady program z okna npovdy do vaeho programu.

Pouit helpu je obsahem lekce 2.
   Turbo C++ obsahuje tak systm  "mini" npovdy, kter slou k zbاnmu
nahldnut. Stavov dek na spodu  obrazovky  IDE  vypisuje  hork klvesy
nebo pkazy pouiteln v pslunm okn menu nebo v  dialogovm  dku  a
strun popisuje, co dan menu nebo dialogov kontroln poloka provd.









                                  - 21 - 


---------------------------------------------------------------------------
Lekce 1: Spoutn, nahrvn a editace
---------------------------------------------------------------------------


   Tato lekce vm zabere 20 minut asu.
   V  IDE  Turbo  C++ je zabudovn vlastn editor. Z prosted Turbo C++ je
mono otevt soubor, editovat,  kompilovat,  spoutt,  ladit a ukldat na
disk - to ve lze z IDE lehce provst. Tato lekce obsahuje:

    o  sputn Turbo C++ z DOSu

    o  oteven souboru v editanm okn

    o  koprovn souboru do jinho editanho okna

    o  pouit editoru ke zmn v koprovanm souboru

    o  uloen modifikovanho souboru na disk

   Pepnte se  do  podadrese  EXAMPLES  ( je v adresi TC ) a napite v
DOSu ..\TC . K  nahrn  programu BARCHART.C do IDE zvolte pkaz File|Open
nebo stisknte F3. Ob volby zobraz dialogov okno Load a File, je vypad
takto:

        [*]Load a fileͻ
                                                                   
        >Name              
          *.C   >[Open   ]< 
                                                                   
          Files                                         [Replace]  
          >CPASDEMO.C  <                                           
           HELLOWORLD.C                                            
           HIDD.C                                                  
           STEP01.C                                                
           STEP02.C                                     [Cancel ]  
                                                                   
                                                        [Help   ]  
           <..>                  
                                                                   
        C:\tc\DEMOS\*.C 
        CPASDEMO.C3206Jan 13,19893:00am 
        ͼ

               Obr. 3.3: Dialogov okno k nahrvn soubor

   V  tomto dialogovm okn je implicitn  nastaveno  Open.  Pokud  zvolte
Replace msto Open, pvodn  soubor  se pemae msto toho, aby byl umstn
do novho okna. Pro tuto lekci ponechte volbu Open.

   Oteven souboru z dialogovho okna me probhat dvma zpsoby:

    o  Je mono vypsat jmno souboru v Name input box.

    o  Je mono vybrat soubor ze seznamu soubor.

   Pokud mte my, provete v seznamu soubor dvojit klik u jmna souboru.

   Nyn vyuijeme seznam soubor.



                                  - 22 - 


1. Stisknte Tab k aktivaci seznamu soubor.

2. Bاn se k zvraznn vybranho souboru uv ipek. V tomto  ppad je
BARCHART.C u zvraznn, protoe je prvnm souborem v seznamu.

3. Stisknte Enter.

   Brzy po volb souboru (stisku Enter) se BARCHART.C  objev  v editovacm
okn. V pravm hornm rohu editanho okna si vimnte sla okna,  toto je
okno slo 1. slo dku a sloupce je zobrazeno v lev dolnm rohu.



---------------------------------------------------------------------------
Tvorba novho souboru
---------------------------------------------------------------------------


   Jednm  z  rys  Turbo C++ IDE je multiwindowing - souasn je mon mt
oteveno vce  ne  jedno  editovac  okno.  V  rznch oknech tak me bt
oteven stejn nebo jin  soubor,  mezi okny je mono penet, koprovat a
pipojovat.

   Nyn,  kdy  je  v editan okn oteven soubor BARCHART.C, mete zat
editovat. Protoe ale nechcete zmnit  pvodn  program,  otevete  si nov
editan okno pomoc File|New.

   Nov  editan  okno  se  nazv  NONAME00.C  (okno  2),  kter  pozdji
pojmenujeme MYCHART.C.  Dvojit linka kolem novho editanho okna k, e
okno je aktivn.

   K pepnut do jinho editanho okna stsknte Alt  a  odpovdajc slo
okna.
   Nyn se pepnte do prvnho  editanho  okna  (kliknte  nebo stisknte
Alt-1). Chceme zkoprovat ve z BARCHART.C do NONAME00.C. (Jestlie nevte,
jak se pohybovat v editan okn, podvejte se na nsledujc  tabulku nebo
stisknte v editoru F-1.  pln  seznam povel editoru lze najt v kapitole
3, "Editor od A do Z" v Uivatelsk pruce.

                    Tab. 3.4: Pesuny v editanm okn

------------------------------------------------------------------------
Co pesunout        Klvesnice          My
------------------------------------------------------------------------
Znak nebo dek     ipky               Kliknte ipkou na druh konec
v libovolnm smru                      posuvnho psu

Kurzor na zatek   Home nebo End       Kliknte na zatek nebo konec
nebo konec dku                        dku.

Obrazovku nahoru    PgUp nebo PgDn      Kliknte a drte ipku na jednom
nebo dol                               nebo druhm konci posuvnho psu

Kurzor na zatek   Ctrl-PgUp nebo      Udlejte klik - pesun palcovou
nebo konec souboru  Ctrl-PgDn           tabulkou (tvercov ikona) na jeden
                                        nebo druh konec posuvnho psu;
                                        pesute na vrchol nebo konec psu;
                                        uvolnte tlatko na myi.
------------------------------------------------------------------------



                                  - 23 - 


Vbr bloku

 Edit
Ŀ
  Restore line         Alt-Bksp  
Ĵ
  Cut                  Shift-Del 
  Copy                  Ctrl-Ins 
  Paste                Shift-Ins 
  Copy Example                   
Ĵ
  Clear                 Ctrl-Del 


   Blok je mono oznait pomoc klvasnice nebo pomoc myi:

    o  Z klvesnice: umstte kurzor na  prvn  nebo  posledn  znak bloku,
       stisknte Shift a k vbru bloku nkterou ze ipek (nebo  Home, End,
       PgDn,  PgUp).  (Pi  uvn  ipkovch  klves  je  teba stisknout
       Shift.)

    o  Pomoc myi: kliknte na  prvn  znak bloku a pot pesute na konec
       bloku. Zruen vbru se doshne optovnm kliknutm.

   Vybran blok textu  se  zobraz reverzn (zvraznn). Zkuste si oznait
cel zdrojov kd souboru BARCHART.C.


Koprovn a pidvn

   Po  vbru textu v okn BARCHART.C,  zvolte  Edit|Copy  (nebo  stisknte
Ctrl-Ins). Tato volba kopruje  text  do  speciln vyhraen sti pamti,
kter se nazv Clipboard. Jestlie se text nachz v Clipboardu,  je mono
jej pemstit do jinho nebo do tho okna.

   Nvrat do NONAME00.C: Stisknte Alt a patin slo  okna  (nebo zvolte
editan okno  my).(Jestlie jste zapomnli slo okna, do kterho chcete
provst pesun, zvolte Window|List.)

   Z  Clipboard  do  textovho okna se text pesune volbou Edit|Paste (nebo
stiskem  Shift-Ins).  Nyn  zrute  oznaen  bloku - kliknte  jinam  nebo
stisknte Ctrl-K H.

   Nyn u umte  provdt  zmny  v  textu,  uloit  a  pejmenovat soubor
NONAME00.C.


Zmny v novm souboru
---------------------------------------------------------------------------

   BARCHART.C je program, kter vypot deset vsledk v rozmez 0  a 50,
spot procenta a ve sloupcovm diagramu zobraz vsledky i procenta.

   V tto sti udlme v BARCHART.C nkter improvizace:

    o  zmnme verzi  BARCHART.C  (NONAME00.C)  tak,  e  bude  potat pt
       vsledk v rozmez 0 a 35

    o  zmnme nzev  promnn a k tomu vyuijeme volbu editoru search-and-
       replace


                                  - 24 - 


    o  zkoprujeme a pesuneme text z Help okna


   Vimnte si sla dku na spodu editanho okna.

   Zaneme tm, e zmnme v souboru poet vsledk vetn rozsahu.  Zde je
nvod:

1. Pesute kurzor ipkami na konec dku 7.

2. Smate pomoc Backspace slo 50 a msto nj napite 35.

3. Na nsledujcm dku zmte slo 10 na 5.


Vbr a nahrazen

   Jmno promnn i nen identifiktorem,  kter by toho mnoho kal, proto
jej  zmnme  na  index,  protoe  k  tomu  elu  je promnn uita. Zmna
jednopsmennho identifiktoru  je  malm  trikem,  kter  se  naume jako
prvn. Chceme  zmnit kad vskyt promnn i, jestlie jedinou zapomeneme,
program se nezkompiluje, protoe obsahuje nedefinovanou promnnou.

   Natst  menu  Search  obsahuje  volbu  pro operace vbr  a  nahrazen
(search-and-replace). Nsleduje replace dialog, kter vypad takto:

    [.]Replaceͻ
                                                           
     > Text to Find    
                                                           
           New Text    
                                                           
       Options                       Direction             
        [X] Case senzitive            (.) Forward          
        [ ] Whole words only          ( ) Backward         
        [ ] Regular expression                             
        [X] Prompt on replace                              
                                                           
       Scope                         Origin                
        (.) Global                    (.) From cursor      
        ( ) Selected text             ( ) Entire scope     
                                                           
      >[   Ok  ]<     [Change All]    [Cancel]    [ Help]  
    ͼ

                         Obr. 3.4: Dialog replace


   Dialogov okno pro nahrazovn  obsahuje  dv  vstupn okna, ti skupiny
radio tlatka, skupinu kontrolnch  oken  a  tyi tlatka. Chceme zmnit
vechny vskyty promnn i v souboru NONAME00.C na index,  take  je  nutno
jt na zatek souboru (stisknte Ctrl-Up  nebo pouijte my).

1. K oteven dialogovho okna Replace uijte volby Search|Replace. Kdy se
dialogov okno oteve poprv, je aktivn vstupn okno.

2. Napite i,  co  je  jmno  promnn, kter chceme najt. Pot stisknte
Tab, m se aktivuje vstupn okno New Text.




                                  - 25 - 


3.  Urete index - jmno promnn, kterm chceme  nahradi  promnnou  i.  K
pesunu do okna Options check stisknte Tab.

   K volb Whole  Words  Only  se  dostanete  ipkou  dol.  Pot stisknte
mezernk. Je mono i kliknout my.

   Case Sensitive a  Prompt  to  replace  jsou u implicitn zvoleny. To je
pesn  to, co potebujeme. Jet je ale teba  vybrat  Whole  Words  Only,
jinak  se  vbr  nezastav na kadm  vskytu  i  v  programu.  Kdy  jste
aktivovali tuto volbu, nechte tuto skupinu tak, jak je a stisknte Tab nebo
kliknte my a pepnte se do Direction Radio Buttons.

4. Chceme vybrat smrem dopedu, take je mono stisknout Tab  a pesunout
se tak do Scope.

5. Ve Scope je pedvoleno Global, co znamen, e se bude  prohledvat cel
dokument. Stisknte Tab a ocitnete se v Origin.

6.V  Origin  stisknte  ipku dol a se dostanete k Entire Scope (nebo tam
kliknte).

7. Pesute se pomoc Tab na klvesu Change All a stisknte Enter ke startu
operace vyhledvn a nahrazen (nebo kliknte na klvesu my).

   Pi kadm vskytu i jste dotzni jestli se m dan ppad  nahradit. Y
(Yes) pi kadm vskytu promnn i, v opanm ppad stisknte N (No).


Pevzet z okna Help

   Pedpokldejme, e chcete pidat ke sloupcovmu grafu tento titulek:

   Percentages, Exam 1A

   Funkce,  kter  pe  text na obrazovku  v  grafickm  mdu  se  jmenuje
outtextxy; obrazovky npovdy popisujc tuto funkci obsahuj zdrojov kd,
kter je mono zkoprovat do oblasti Clipboard a pot penst do NONAME00.
Nvod, jak zkoprovat pklad z help okna outtextxy je zde:

1. V Help menu zvolte Index.

2. Napite slovo outtextxy. Pomocnou obrazovku dostanete stiskem Enter.

3.  Pklad  je  u  pedem  oznaen  jako  blok,  take sta pmo vybrat
Edit|Copy Example ke koprovn do Clipboardu.

4. Stisknte Esc, m se uzave okno npovdy.

5. Nastavte kurzor na konec souboru na zatek poslednho dku.

6. Vyberte Edit|Paste k penesen bloku programu do souboru.


   Nen mon nechat  blok  tak,  jak  je. Nkter sti mohou zstat, jin
mus bt pozmnny a nkter jsou nepouiteln.

   Nyn, po zkoprovn pkladu  z  help okna do programu, lze jist dky
pozmnit a jin vyadit. Napklad:




                                  - 26 - 


1. Pouijeme dek  int  midx,  midy;  Oznate  jej ( nzorn pklad je na
konci  programu  )  a  potom  ho  peneste  do makegraph,  sekce  deklarac
promnnch ( dek 35).

2. Nsledujc dva dky  peneste  do makegraph hned za zvorky smyky for
(dek 49)

   midx = getmaxx()/2;
   midy = getmaxy()/2;

3. Zmte je takto:
   midx = (getmaxx()/2) - (textwidth("Percentages, Exam 1A")/2);
   midy = getmaxy() - 10;

4. Peneste tento dek do makegraph hned za pkaz midy:

   outtextxy(midx, midy, "This is a test.")

5. Modifikujte jej:

   outtextxy(midx, midy, "Percentages, Exam 1A");

   Na  konci  souboru  je  teba  se zbavit nepotebnch zbytk z  programu
outtextxy.  Natst  obsahuje  menu Edit pkaz pro  zruen  bloku  textu
pomoc dvojice klves.

1.  Vyberte blok, kter chcete zruit: zatek je  tam,  kde  jste  napsali
outtextxy a konec na konci souboru.

2. Vyberte volbu Edit|Clear (nebo stisknte Ctrl-Del).


Uloen provedench zmn

   A je to. V programu jsou provedeny nkter  zmny,  take  je  mono jej
uloit na disk.  Zvolte  File|Save  (nebo  stisknte  F2),  pot  se objev
dialogov  okno Save Editor File. Do vstupnho  okna  napite  MYCHART.C  a
stisknte Enter.



---------------------------------------------------------------------------
Lekce 2 : Kompilace a spoutn
---------------------------------------------------------------------------


   Tato lekce zabere pt minut.
   V tto lekci

    o  zkompilujeme MYCHART.C pkazem Compile|Make EXE

    o  spustme MYCHART.EXE pkazem Run|Run (pot je vidt vsledek)

Compile
Ŀ
Make EXE file C:DEMO.EXE      
Build All                     





                                  - 27 - 


   Ke kompilaci programu se uv menu Compile. (Protoe  volba  Full Menus
je nastavena na Off, menu Compile obsahuje pouze dv poloky. Podrobnosti k
menu Compile lze najt v kapitole 1 "IDE" v Uivatelsk pruce.)

   Pokud se objev chybov zprva, kter k, e Turbo  C++  neme  najt
v soubor, pravdpodobn nejsou instalovny odpovdajc podadrese Turbo
C++. Podrobnost viz kapitola 1.

1. Ke generovn MYCHART.EXE zvolte  Compile|Make  EXE  nebo  stisknte F9.
Objev se kompilan  okno;  pokud  se  v  programu  vyskytnou  chyby, jsou
vypsny prv sem ( jestlie se tak stane, opravte je a kompilujte znova ).
Kdy je program spn zkompilovn a zlinkovn, objev se v okn blikajc
zprva:

   Success: Press any key

2. Stisknte cokoliv k nvratu do programu.

Run
Ŀ
Run                  Ctrl-F9 
Program reset        Ctrl-F2 
Go to cursor              F4 
Trace into                F7 
Step over                 F8 
Arguments...                 


   Ke sputn MYCHART, zvolte  Run|Run  nebo  stisknte  Ctrl-F9. (Ostatn
pkazy v menu Run jsou pro ladn.) Turbo C++ pepn z IDE do uivatelsk
obrazovky, protoe MYCHART po vs poaduje vstup.

   Pokad  kdy  MYCHART  pod  o  vstup (stane se tak celkem  ptkrt),
zadejte slo mezi 0 a 35. Brzy po zadn poslednho sla  zobraz MYCHART
vech pt hodnot a jejich procenta.

   Uivatelsk obrazovka slou jak pro textov, tak pro grafick vstup.

   Stisknte Enter. MYCHART zobraz procenta  ve  form  sloupcovho grafu.
Vimnte si, jak je npis nad sloupcovm grafem pkn vycentrovn. Jestlie
jste zvdav, jakm zpsobem je toto dosaeno, podvejte se na tento dek:

   midx = (getmax()/2 - (textwidth("Percentages, Exam 1A")/2);

   K  helpu  o  funkci textwidth  se dostanete stiskem Ctrl-F1  (  nebo  se
podvejte do kapitoly 1, "Run-time knihovna" v Knihovn ).

   K nvratu do IDE stisknte Enter.


Uzaven editanho okna
---------------------------------------------------------------------------

   Skonili jsme prci se  souborem  MYCHART.C.  K uzaven jeho editanho
okna  zvolte  Window|Close  (  nebo  stisknte  Alt-F3  ). Uzavete  soubor
BARCHART.C.

Ŀ
 MY  



                                  - 28 - 


   Pokud mte my, je mono kliknout na uzavrac okno (close box)  ([.]) v
levm hornm rohu a uzavt tak editan okno.



---------------------------------------------------------------------------
Lekce 3 : Konec prce s Turbo C++
---------------------------------------------------------------------------


   Kdy jste skonili prci se souborem, zbvaj u jen dv vci:

    o  uloit zmny do souboru na disk

    o  ukonit prci s Turbo C++ a vrtit se do DOSu

Soubor  je na disku u uloen, proto je teba u jen ukonit prci s  Turbo
C++ a vrtit se do DOSu.

    o  Vyberte File|Quit nebo stisknte Alt-X.



---------------------------------------------------------------------------
Kde lze najt vce informac
---------------------------------------------------------------------------


   Tato kapitola byla pouze rychlm  vodem  do  nejuvanjch  st IDE
Turbo C++. Mnoha vlastnost jsme se dotkli jen letmo a nkterch  vbec ne.
Hlub informace  o  kad  sti  IDE  mete  nalzt v kapitole 1,"IDE" v
Uivatelsk pruce.






























                                  - 29 - 
































































                                  - 30 - 








                            K a p i t o l a   4

                                 vod do C


   Jestlie jste jet nikdy  neprogramovali  v C ( nebo pokud nemte velk
zkuenosti ), pak  jste  na  sprvn  adrese, tato kapitola je urena prv
vm. Zan  jednoduchmi  pklady,  pozdji  pechz  ke  komplexnjm,
piem  zrove ukazuje, jak je zabudovat do  program.  Naute  se,  jak
eit rzn problmy tkajc se sel, slov a grafiky. Seznmte se tak s
nktermi  dleitmi  zsadami   vzhledu  a  strukturalizace  programu.  V
podadresi EXAMPLES  najdete  zdrojov  kd  nkolika  obecnch  program.
Zaadili  jsme  proto,  jeliko  je  mono je snadno nahrt, zkompilovat  a
spustit, co se jev jako nejlep zpsob, jak se nauit jazyku C.



---------------------------------------------------------------------------
Strun historie
---------------------------------------------------------------------------


   C byl pvodn vytvoen v roce  1970  pro operan systm UNIX a zdnliv
se  vyvjel s nm. Kdy se na trhu  objevily  mikropotae  s  dostatenm
vkonem,  byly na nich implementovny kompiltory jazyka  C.  V  roce  1978
zformulovali W. Kernighan a Dennis M. Ritchie klasickou definici C v prvnm
vydn sv  knihy  The  C  Programming  Language.  O pt rok pozdji zaal
American National Standard Institute (ANSI) vyvjet nov standard C jazyka.
Tento standard  odstranil  dvojznanosti  v  klasic  definici  a definoval
nkter nov vlastnosti,  vetn  lep kontroly voln funkc. Druh edice
knihy Kernighana a Ritchieho rozebrala do  detail  implementaci standardu
ANSI. V Turbo  C++  je  implementovna  posledn verze standardu ANSI C. Je
tak  plnou  implementac  verze  2.0  od  firmy  AT&T, je  je  objektov
orientovna a nazv se C++. Objektov orientovan rysy C++ jsou  popsny v
kapitolch 5 a 6, "Zklady C++" a "Pruka C++".



---------------------------------------------------------------------------
Zkladn programov operace
---------------------------------------------------------------------------


   Je mono nechat se vst pklady popsanmi v tto kapitole tm zpsobem,
e postupn nahrajete a spustte oznaen programy.

   Programy pro potae se od sebe vzjemn velmi li  elem,  stylem  a
sloitost. Tm vechny programy prochzej temi fzemi:

    o  popis, shromaovn a ukldn informac (dat)

    o  zpracovn dat k dosaen poadovanho vsledku

    o  zobrazen a/nebo uloen vsledk


                                  - 31 - 


   Jakkoliv data uvan v programu mus bt popsna, a proto si  je Turbo
C++  um  zapamatovat  a zptn vybavit. Pam؟ mus bt pipravena pijmout
mnostv  dat. Program mus ukldat data do pamti,  co  se  obvykle  dje
natnm  znak  z  klvesnice, penosem dat ze souboru na disku, penosem
dat  po  telefonn  lince  nebo  uitm  nkterho  jinho druhu  vstupnho
zazen.

   Kdy jsou data uloena  do  numerickch  promnnch,  znakovch etzc,
pol  nebo  komplikovanjch   datovch  struktur,  mus  bt  zpracovna.
Zpracovn se dje  pomoc  rznch program - napklad tabulkov procesor
me aplikovat vzorec na mnoinu dat a vypotat tak njak  vsledek, nebo
slovn procesor me uspodat dky textu zarovnnm do jinch okraj.

   Po zpracovn  dat  mus  bt  njakm  zpsobem  uivateli prezentovny
vsledky.  dky textu mohou bt vypsny na  obrazovce  nebo  na  tiskrn,
buky tabulkovho procesoru mohou bt  pepsny  novmi  hodnotami. Vtina
dat se ukld na disk pro pozdj vyuit.

   Vimnte  si, jak jsou v nsledujcm  krtkm  programu  uspodny  za
sebou sti programu:

   Pokud si chcete tento program  vyzkouet,  nahrejte  a  spuste INTRO1.C
(FILE|OPEN|INTRO1).  Nezapomete,  e   vechny  pklady  se  nachzej  v
podadresi EXAMPLES.


   */* INTRO1.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int   bushels;
   float dollars, rate;
   char  inbuf [130];
   printf("How many dollars did you get? ");
   gets(inbuf);
   sscanf(inbuf, "%f", &dollars);
   printf("For how many bushels? ");
   gets(inbuf);
   sscanf(inbuf, "%d", &bushels);
   rate = dollars / bushels;
   printf("You got %f dollars for each bushel\n", rate);

   return 0;
}

   Prvn dek programu, main(), definuje funkci nebo  skupinu programovch
instrukc. Funkce jsou stavebnmi kameny  program v jazyce C, podobn jako
odstavce  v povdce. Kad program v C m  funkci  nazvanou  main.  Vtina
program m nkolik  dalch  funkc nazvanch vhodnmi jmny. Lev sloen
zvorka ({)  indikuje  posloupnost  programovch  instrukc,  nebo  v tomto
ppad pkaz,  kter definuj chovn potae po proveden funkce main.
Kad posloupnost pkaz je ukonena pravou sloenou zvorkou (}).

   Jestlie funkce jsou jako odstavce, pkazy  pedstavuj  vty. Vimnte
si, e kad  pkaz  kon  stednkem  (;). Akoliv C dovoluje uit vce
pkaz na dek, nedoporuujeme to, programy jsou pak nepehledn.

Popis


                                  - 32 - 


   Prvn ti pkazy jsou tyto:

   int bushels;
   float dollars, rate;
   char inbuf [130];

   Vzpomete  si,  e  prvnm   krokem   pi   psan  programu  je  "popis,
shromaovn a ukldn informac". V C se mus  deklarovat  kad poloka
dat jet  pedtm,  ne  se  s n cokoliv dl. K deklaraci poloky dat je
teba vdt, jakho typu je a nsledn ji pojmenovat. V tomto  ppad mme
jednu poloku  typu  int  (integer  nebo  tak  cel slo), jej jmno je
bushels. Mme  jet  druhou  a  tet  poloku,  kter jsou ob typu float
(slo s pohyblivou adovou rkou) a jsou pojmenovny dollars a rate. Tyto
datov poloky se nazvaj promnnmi, protoe jejich hodnota se me mnit
v  zvislosti na okolnostech. Jako posledn  mme  znakovou  poloku  pole,
kter nat a uchovv vstup (pole jsou probrna pozdji).

   Shromaovn a ukldn.

   Nsledujcch est pkaz zskv a  uchovv  data,  kter  jsme prv
popsali. Pkaz printf vypisuje poet bushel (dut mra, asi  36  litr  -
pozn. pekl.) a poet dolar  odpovdajcch tmto bushelm. Pkazy gets a
sscanf  nataj  a  uchovvaj hodnoty v promnnch. Tاit prce v Turbo
C++ je soustedno do  voln  funkc obsaench v knihovn spojen s Turbo
C++.  Funkce  se  vol vypsn jejho jmna, ostatn informace nezbytn pro
prci funkce jsou uzaveny v zvorkch. printf, gets a sscanf jsou knihovn
funkce. Nejsou pmou soust jazyka C. Parametry %d a %f ve funkci sscanf
kaj, e datov poloky  jsou  uchovvny  jako celoseln, respektive v
pohybliv  adov rce. Nazvaj se specifikace  formtu  a  jsou  popsny
dle.

   Zpracovn

   Nsledujc  pkaz, rate = dollars/bushels pedstavuje  zpracovatelskou
st  programu, dlen potu bushel potem  dolar.  Dostaneme  tak  poet
dolar na jeden bushel.

   Zobrazen

   Poslednm  pkazem  je  opt  funkce  printf,  kter  vypisuje vsledek
vpotu.  Vimnte  si,  e  pkaz  printf  zde  obsahuje  urit  etzec
(zprvu), nsleduje rka a  jmno  promnn  rate.  %f uruje, e promnn
bude formtovna jako hodnota v pohybliv adov rce.

   Po sputn programu bude vsledek vypadat takto:

   How many dollars did you get? 32
   For how many bushels? 24
   You got 1.333333 dollars for each bushel



---------------------------------------------------------------------------
Zkladn struktura programu v C
---------------------------------------------------------------------------


   Nsledujc   pklad  demonstruje   funkce,   komente   a   direktivy
preprocesoru #include a #define.



                                  - 33 - 


   Nahrejte a spuste program SALESTAG.C.

/* SALESTAG.C--Example from Chapter 4 of Getting Started.
   SALESTAG.C calculates a sales slip. */

#include <stdio.h>
#define RATE 0.065                         /* Sales Tax Rate */

float tax (float amount);
float purchase, tax_amt, total;

int main()
{
   char inbuf [130];
   printf("Amount of purchase: ");
   gets(inbuf);
   sscanf(inbuf, "%f", &purchase);

   tax_amt = tax(purchase);
   total = purchase + tax_amt;

   printf("\nPurchase is:  %f", purchase);
   printf("\n        Tax:  %f", tax_amt);
   printf("\n      Total:  %f", total);

   return 0;
}

float tax (float amount)
{
   return(amount * RATE);
}

   Prvn dek programu zan symbolem /*, co zna  koment.  Symbol */
koment ukonuje. Turbo C++  ignoruje  vechny  znaky uzaven mezi tmito
symboly. Komente se pouvaj k popisu programu, funkc a pkaz. Vhodn
komente  in  popsan  objekt  srozumitelnjm,  kaj,  co  dan st
programu dl a pomhaj jinm programtorm vyznat se ve vaem programu.

   dky, kter zanaj slem nebo kkem (#) nejsou  pkazy  C jazyka,
ale instrukcemi pro Turbo  C++.  Nazvaj  se direktivami kompiltoru (nebo
direktivami  preprocesoru)  protoe  d  operace  kompiltoru.  Direktiva
#include <stdio.h> k Turbo C++, aby naetl a  zkompiloval  obsah souboru
stdio.h, kter je jednm z ady hlavikovch soubor (header files), je se
tak nazvaj include soubory (include files), kter Turbo C++ obsahuje pro
uivatele.  Tyto  soubory  obsahuj  popisy  knihovnch  funkc  (jako nap
printf,  gets), stejn jako jin sti  standardn  knihovny.  Tyto  popisy
uv kompiltor  pi kompilaci programu pro knihovn funkce, je pipojuje
k vslednmu kdu. Dal informace o hlavikovch souborech jsou v kapitole
2, "Kov reference run-time knihovny" v Programtorsk pruce.

   Jinm  zpsobem,  jak  definovat  hodnoty,  kter  se  nemn, je  uit
klovho slova const - je popsno pozdji.

   Nsledujc  dek,  #define  RATE  0.065 definuje makrosubstituci. k
Turbo  C++, e kdykoliv se v programu vyskytne  slovo  RATE,  je  nahrazeno
slem 0.065. V delm  programu  se  da  (tax) me vypotvat vcekrt.
Jestlie se da zmn, sta  pouze zmnit definici a rekompilovat program.
Vechny odkazy budou automaticky zmnny. Zabere to nejmn asu  a  je  to
mnohem lep, ne hledat vechny odkazy run.


                                  - 34 - 


   Nsledujc  odstavec popisuje funkci tax definovanou uivatelem.  Popis
(nazvan prototype - viz pozdji) k, e do tto funkce vstupuje slo s
pohyblivou adovou rkou (float)  a  vsledkem  je  opt slo v pohybliv
adov rce. Tmto popisem pomh Turbo C++ ujistit se, e  program neme
pedat funkci patn typ dat. Pkaz

   float purchase, tax_amt, total;

popisuje ti promnn v pohybliv adov rce.

   Pkazy printf, gets a sscanf obstarvaj vstupn st. Nyn pistoupme
k vpotu:

   tax_amt = tax(purchase);

   vol funkci tax definovanou uivatelem. Vstupn hodnota (v zvorkch) je
pedna  funkci.  K  tomu, aby jste vidli, co funkce dl, podvejte se na
tuto definici:

   float tax (float amount)
   {
   return(amount * RATE);
   }

   Ta k, e  funkce  tax  pijm  hodnotu  promnn  amount,  nsob ji
definovanou konstantou RATE a vrac vsledek. Proto kdy se provede dek

   tax_amt = tax(purchase);,

je vypotna da z stky nkup,  vrcena  funkc tax a uloena v promnn
tax_amt pro pozdj pouit. V  nsledujcm dku je tato stka pitena
k celkovmu soutu total.
   Mon se  zd zbyten definovat hned pro jednoduch vpoet samostatnou
funkci,  jako  je  v  tomto  programu. V komplikovanjch situacch se  to
naopak hod, nap. pi vpotu nkolika dan podle  msta  nkupu. Vsledek
mon ovlivn  vae rozhodnut. V tomto ppad oddlen mechanismu vpotu
in hlavn st pehlednj. Pokud to bude nutn, je mono pozdji zmnit
vpoet dan bez zsahu do ostatnch st programu.

   Vsledn  hodnota  nkupu  neodpovd vstupu - problm  je  v  pohybliv
adov rce - viz pozdji.

   Posledn  ti  dky  hlavnho programu tisknou nkupn  stku,  da  a
celkov souet. Vstup z programu vypad takto:

   Amount of purchase: 24.95

   Purchase is: 24.950001
   Tax: 1.621570
   Total: 26.571751

   Vce  pozornosti  by  si zaslouila prava vstupnho  textu,  stka  v
dolarech m mt poze dv desetinn msta a  mla  by  bt  zaokrouhlena. Je
teba vykat, a se naute vce o formtovn a o funkci printf. (Jestlie
se  zajmte o tyto zlomky penny, hlub informace o td bcd lze zskat v
kapitole 4,"Modely pamti,  pohybliv  rka  a  overlay"  v Programtorsk
pruce.)





                                  - 35 - 


---------------------------------------------------------------------------
Prce s sly
---------------------------------------------------------------------------


   sla jsou zkladn data  se  ktermi  pracuje  pota. Jak mon vte,
skuten obsah pamti potae sestv z binrnch sel.  Ta  jsou obvykle
organizovna do skupin  po  osmi  bitech  (1 byte) nebo estncti bitech (2
byty nebo 1 slovo).  Dokonce  i  takov  potaov operace, kter zahrnuj
bاn slova nebo grafiku jsou v podstat adou sel uloench v pamti.


Numerick typy dat
---------------------------------------------------------------------------

   Stejn st pamti me obsahovat rzn druhy sel, co zvis  na tom,
kolik byt je sdrueno dohromady.  Jmno  promnn,  jako  napklad total,
pmo vypovd o obsahu jednoho nebo  vce  byt uloench na dan adrese v
pamti - tato adresa je pidlena Turbo C++ v okamiku  definice (piazen
hodnoty) promnn. Avak vy i pota mus respektovat, jak druh  sla je
danou promnnou repezentovn a tedy kolik byt pamti je vyhrazeno  na dan
adrese. Tato skutenost se uruje  datovm  typem  pi  deklaraci promnn.
Napkad:

   int total, count, step;
   float cost, profit;

adresy
                      Ŀ
                        char        1000  
                     int    Ĵ
                                    1001  
                 float       Ĵv
                                     1002  
                               Ĵ
                                     1003  
                             Ĵ
         double                       1004  
                                Ĵ
                                      1005  
                                Ĵ
                                      1006  
                                Ĵ
                                      1007  
                              

Obr. 4.1: Obrzek 4.1 : Velikost pamti pidlen slm (1 stupe = 1 byte)

   Kad typ dat pedstavuje jin druh  sel.  Pro dan druh sla je vdy
nutno vybrat odpovdajc typ. V tto deklaraci promnnch:

    o  Promnn  total  je  typu int (celoseln -  integer).  Jestlie  v
       programu pouijete  pkaz s promnnou total, zabere 2 byty ponaje
       adresou promnn total.

    o  Promnn  cost  je  typu float (pohybliv adov  rka  -  floating
       point). Jestlie program uije promnnou  cost,  zabere  tm  4 byty
       ponaje adresou promnn cost. (To  je proto, e slo s pohyblivou
       adovou rkou potebuje  dva  zvltn byty k reprezentaci sla se
       znamnkem a dvoumstnm exponentem.)


                                  - 36 - 


       Tabulka  4.1  ukazuje  zkladn typy dat Turbo C++ a jejicj variace.
       Vimnte si rozsahu  sel,  kter  mohou  bt  reprezentovna. Tato
       kapitola ukazuje, jak nkter z tchto typ vyut.

             Tab. 4.1: Tabulka 4.1 : Typy dat, dlka a rozsah

------------------------------------------------------------------------
Typ            dlka     rozsah              jednoduch aplikace
------------------------------------------------------------------------
znakov bez    8         0-255               mal sla a cel mnoina
znamnka                                     znak PC
(unsigned char)

znakov        8         -128 a 127         velmi mal sla a znaky ASCII
(char)

enumerick     16        -32768 a 32767     uspodan mnoina hodnot
(enum)

celoseln    16        0-65535             vt sla a smyky
bez znamnka
(unsigned int)

celoseln    16        -32768 a 32767     mal sla, smyky, vpoty
krtk
(short int)

celoseln    16        -32768 a 32767     mal sla, smyky, vpoty
(int)

dlouh bez     32        0-4,294,967,295     astronomick vzdlenosti
znamnka
(unsigned long)

dlouh         32        -2,147,483,648 a   velk sla, poty obyvatel
(long)                   2,147,483,647
                               -38
pohybliv      32        3.4*10    a        vdeck vpoty (pesnost
                               38
(float)                  3.4*10              na 7 mst)
                               308
dvojit        64        1.7*10    a        vdeck vpoty (pesnost na
                               -308
(double)                 1.7*10              15 mst)
                               -4932
dlouh dvojit 80        3.4*10      a      finann vpoty (pesnost
                               4932
(long double)            1.1*10              na 19 mst)

blzk         16        nespecifikovateln  manipulace s adresami pamti
ukazatel
(near pointer)

dalek         32        nespecifikovateln  manipulace s adresami mimo
ukazatel                                     aktuln segment
(far pointer)
------------------------------------------------------------------------





                                  - 37 - 


Cel sla

   Zkladnm typem celch sel  je  typ int, jen me vyjdit jak kladn
tak zporn sla v intervalu (-32768 - 32767).

   Zde je pklad, kter pedvd nkter operace s celmi sly:

   #include <stdio.h>

   main()

   {
      int bags, pounds;
      int total;
      pounds = 50;
      bags = 1000;
      total = bags * pouds;
      printf(There are %d lbs. in 1000 bags of beans\n", total);
      return 0;
   }
   Vstup z programu vs asi trochu pekvap:

   There are -15536 lbs. in 1000 bags of beans

   Kompiltor nevype varovn, pokud chcete uloit promnnou,  kter nen
vhodn pro dan typ dat.

   Souin bags * pounds, 50000 je pro obyejn  int  pli  velk  (jak se
mete pesvdit v tabulce 4.1). Jestlie se program  pokus  uloit 50000
do  typu,  kter  me  maximln  obshnout 32767, vsledek  petee.  Jak
vyeit tento problm? Pouitm long int.

   Dlouh varianta

   long int, kter  je  obvykle  zkracovn  na long, dv k dispozici vt
rosah celch sel. Problm zpornch bob je mono vyeit deklarac:

   long total;

   Je poteba tak zmnit %d v pkaze printf na %d. Vysvtlen viz dle.
   Tato deklarace dv prostor pro vce liber bob, protoe long,  kter je
uloen  ve  32 bitech msto 16 uitch  v  obyejnm  int,  me  obsahovat
hodnotu z intervalu (-2,147,483,648  a  2,147,483,647).  Ale co s librami?
Tato promnn je typu int,  protoe je nepravdpodobn, e hmotnost jednoho
pytle  pekro 32,767 liber. Tak promnn  bags  mon  peshne  32,767,
take ji tak pedefinujte jako long. Pro se pokad  neuv  msto  typu
int  typ  long?  long zabr 4 byty pamti, zatmco int pouze dva. Jestlie
pouvte mnoho promnnch, uspote tak pam؟.

   int pounds;
   long bags, total;


Promnn se znamnkem a bez znamnka

   Vechny typy dat z tabulky 4.1 jsou se znamnkem -  jeden  bit z uloen
promnn je uit k indikaci  kladnho nebo zpornho sla. Nkter hodnoty
v praxi mohou bt jak kladn, tak zporn  -  nap.  teplota  nebo bankovn
operace. Mnoho jinch hodnot nen nikdy zpornch - napklad obchod neme
nikdy zamstnvat zporn poet zamstnanc.


                                  - 38 - 


K tomu, abyste se rozhodli, jak typ dat  pout,  uvaujte  vdy  o monm
vsledku.

Pidnm slova unsigned  ke  ktermukoliv datovmu typu omezte jeho rozsah
na  kladn  sla.  Protoe u nen teba znamnkovho bitu, zdvojnsob se
maximln hodnota uloiteln  v  tomto typu dat. Napklad zatmco obyejn
int se znamnkem mus obsahovat hodnotu z intervalu (-32768;32767), int bez
znamnka  me nabvat hodnoty od 0 do 65535. (Unsigned long m rozsah od 0
do  4,294,967,295).  Pedchoz  program  bude  pracovat  sprvn,  jestlie
deklarujete

   unsigned int total;,

akoliv se jen stا vejdete do limitu pro typ unsigned int.

   Protoe  vechna  nastaven  pro  numerick  typ  dat   jsou  implicitn
znamnkov, nemuste deklarovat signed int, signed long.


sla s pohyblivou adovou rkou

   Mnoho sel obsahuje za desetinnou  rkou  jet  nkolik  slic, jako
nap. ceny v  dolarech  a  centech.  Tato sla nazvme sly s pohyblivou
adovou rkou (floating-point  numbers)  (asto  se  uv  nzvu reln).
Nejnzornj pklad desetinn sti  :  jestlie  kupujete  v elezstv
rouby, eknete  prodavai rozmr patrn ve zlomcch metru. Takovou situaci
e typ dat float. Dal pklad:

   Vyzkouejte si tento program - nahrejte a spuste INTRO2.C.

*/* INTRO2.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char  inbuf[130];
   float num, denom;     /* numerator and denominator of fraction */
   float value;          /* value of fraction as decimal */

   printf("Convert a fraction to a decimal\n");
   printf("Numerator: ");
   gets(inbuf);
   sscanf(inbuf, "%f", &num);
   printf("Denominator: ");
   gets(inbuf);
   sscanf(inbuf, "%f", &denom);

   value = num / denom;  /* convert fraction to decimal */

   printf("\n %f / %f  = %f", num, denom, value);

   return 0;
}


   Program oekv vstup itatele a jmenovatele zlomku, pot jej pevede na
desetinn slo a vype vsledek. Nap.:

   Convert a fraction to a decimal


                                  - 39 - 


   Numerator: 7
   Denominator: 8

   7.000000 / 8.000000 = 0.875000

   Promnn value  mus  bt  typu  float,  stejn  jako num a denom, pokud
chcete,  aby  vsledek  podlu  num/denom  byl  sprvn.  Vyzkouejte tento
pklad:

   Jestlie dlte cel slo celm  slem, vsledek je ped piazenm do
promnn typu float zaokrouhlen dol k nejblimu celmu slu

   #include<stdio.h>

   int main()

   {
      int num = 3, denom = 4;
      float value;
      value = num / denom;
      printf("\n%f",value);
      return );
   }

   Vsledkem je velk nula, pesnji 0.000000 - ne tedy 0.75 jak jste jist
oekvali.

   Typ double a long double

   Typy double a  long  double  jsou  stejn jako float, pouze jsou schopny
vyjdit velk sla s vt pesnost. Pesnost je dleit ve vd  a pi
finannch operacch. Mon chcete  svj  systm  pouvat  k psan ek na
velk sumy, nap. 125,375,750.75 $.

   #include<stdio.h>

   int main()

   {include<stdio.h
      float amount = 125375750.75;
      printf("\nPay the sum of %f dollars\n", amount);
      return 0;
   }

   ek je vypsn takto:

   Pay the sum of 125375752.000000

   Vsledek  je peplacen o 1.25 $. To nen mnoho, ale od pota se ek,
e budou pracovat se 100% pesnost, naproti tomu penze jsou zaokrouhleny.
Tato chyba vznikla proto, e typ  float  je omezen pesnost na sedm slic
zatmco  hodnota piazena do promnn amount  m  jedenct  slic,  deset
nenulovch.  Zmte  amount  na double a spuste program znovu, uvidte, e
stka bude sprvn.








                                  - 40 - 


---------------------------------------------------------------------------
Promnn
---------------------------------------------------------------------------


   Jak  jste  se  u  nauili,   kad  promnn  mus  bt  ped  pouitm
deklarovna. Deklarace sestv z  datovho  typu  za kterm nsleduje jedno
nebo vce jmen promnnch. Deklarace k Turbo C++, e mte v  myslu ut
zvltn promnnou, kter bude uchovvat patin typ dat.

   int hours;
float total_pay, pay_rate;
long id_number;

Inicializace promnnch
---------------------------------------------------------------------------

   Promnnou je teba inicializovat, co  znamen  nastavit  ji  na uritou
hodnotu, napklad na nulu. Co myslte, e vype nsledujc program?

   #include<stdio.h>

   int main()
   {
      int something;
      printf("%d", something);
      return 0;
   }


   Vsledek bude rzn - na naem  potai  byl -32417. Vimli jste si, e
program promnn ped jejm vypsnm nic  nepiazuje?  Definic globlnch
nebo statickch promnnch (viz dle)  nemaj promnn v C piazenu dnou
hodnotu. (Nkter jazyky,  jako  nap.  Basic  napluj  numerick promnn
hodnotou 0.) Hodnota something je proto jakkoliv slo  nachzejc  se na
adrese, kterou piadil Turbo C++ promnn.

   Tato hodnota je nepedvdateln. Kdy  jste  kompilovali  program, mon
jste si vimli varovn v okn Message: "Possible use of 'something' before
definition in  function  main"  (Mon  pouit  promnn  'something' ped
definic ve  funkci main.) Kdy dostanete toto varovn, zkontrolujte jmno
promnn, abyste se ujistili, e jste ji ped pouitm deklarovali.


Piazovac pkazy
---------------------------------------------------------------------------

   Hodnotu  lze  promnn  piadit  pomoc  pkazu  piazen.  Piazen
sestva z jmna promnn, za nm nsleduje rovntko a hodnota, je  m bt
piazena. Zde je nkolik pklad:

   count = 0;
   total = purchase + tax_amt;
   tax_amt = tax(purchase);

   V  prvnm  pklad  skuten  slo  (neboli  numerick  konstanta)  je
piazeno promnn count.  Ve  druhm pkaze je vraz piazujc promnn
total  souet purchase + tax_amt. Vraz je  jakkoliv  kombinace  hodnot  a
opertor (nap. + nebo *), kter dv jedinou hodnotu. Z toho  vyplv, e
v C je mono ut  k  piazen  vraz,  zatmco  v  jinch  jazycch pouze


                                  - 41 - 


jedinou numerickou hodnotu. Vraz je mono piadit promnn, pedat funkci
ke zpracovn nebo vytisknout pomoc printf.

   Tet pkaz je trochu sloitj. Vyvol funkci tax a ulo  hodnotu do
promnn purchase. Tuto hodnotu  a  jet  jin  informace pouv funkce k
vypotn dan. Vrac hodnotu do pkazu, kter ji vyvolal, jinmi slovy -
funkn voln tax(purchase) je nahrazeno skutenou  hodnotou,  nap. 1.14.
Piazovac pkaz potom piad hodnotu promnn tax_amt. V C je piazen
pomoc funknch voln velmi ast.


Kombinace piazen
---------------------------------------------------------------------------

   V  C  je  mono  kombinovat  dv  nebo  vce  odlinch operac v jednom
pkaze. Sm se deklarovat promnn, kter zrove piadme hodnotu. Msto

   float total_expenses;
   total_expenses = 0;

pe vtina programtor v C

   float total_expenses = 0;

   Lze  tak  piadit  jednu  hodnotu  nkolika  promnnm.  Nap.  slovn
procesor zane zpracovn textu nastavenm

   page = line = column = 1;

   To je mon proto,  e  piazovac pkaz penese tak hodnotu z jinch
st pkazu. To znamen, e column = 1 piad 1 do column a dv hodnotu
1  k  dispozici.  Vzato zprava doleva dostaneme line = 1.  Podobn  i  toto
piazen poskytne hodnotu 1, take poslednm piazenm je page  =  1.  To
jet nen ve. Je obvykle lep deklarovat a piazovat v jednom pkazu a
pipojit zrove koment, je danou promnnou popisuje :

   int lines = 0;             /*dky textu konc znakem pro nov dek*/
   int words 0;               /*Slova jsou skupiny znak konc mezerou,
                              /*tabultorem nebo znakem pro nov dek*/
   int chars 0;               /*Pot se kad znak*/


   as  vnovan popisu se vrt v  podob  pedchzen  rznm  problmm.
Nap. je opravdu vhodn pojmenovat chars promnnou typu int ?


Pojmenovvn
---------------------------------------------------------------------------

   Nyn se rozhodneme, jak jmna dme promnnm v C. V  tomto  ohledu je C
zcela prun. Uivatelsk jmna ( zvan identifiktory ) mus splovat tato
pravidla:

    o  Vechny identifiktory mus zanat psmenem (a a z nebo  A  a  Z)
       nebo podtrhntkem (_).

    o  Zbytek  identifiktoru  me  obsahovat  psmena,  podtrhntka  nebo
       slice (0 a 9). Jin  znaky, jako nap. interpunkn znamnka nebo
       kontroln znaky, nesm bt pouity.



                                  - 42 - 


       Identifiktory v C++ mohou mt jakoukoliv dlku.

    o  Prvnch 32 znak identifiktoru je vznamnch. To znamen, e
       The_total_amount_of_money_in_my_checking_account
       a
       The_total_amount_of_money_in_my_charge_account
       budou  v  Turbo  C++  chpny  jako jedna promnn.  Samozejm,  e
       pouvat takto dlouh jmna je nevhodn.

    o  Identifiktory rozliuj velk a mal psmena  (case  sensitive). To
       znamen, e amount a Amount jsou pln odlin promnn.

   Podle tchto  pravidel  jsou  deduction,  tax_status,  amt_1099  legln
promnn, zatmco 1989_tax  nebo  stop!  nejsou  sprvn.  (1989_tax zan
slem msto psmenem nebo podtrhntkam  a  stop!  obsahuje  vykink, co
nen ani psmeno, ani podtrhntko ani slice.)

   Krom  respektovn  pravidel  je  dleit  dt  jmnm  njak  smysl.
Navrhujeme vm:

    o  Jmno by mlo popisovat, co promnn obsahuje. z nek nic,  zda u
       je lep a zdanitelna_polozka je nejlep a zcela urujc.

    o  K oddlen slov v dlouhm  identifiktoru  pouvejte  velk psmena
       nebo  podtrhntka.   PricePer100   nebo   price_per_100   je  mnohem
       srozumitelnj ne priceper100.

    o  K popisu skutenost a elu pouvejte komente.


Formtovn vstupn hodnoty : sscanf
---------------------------------------------------------------------------

   Vidli jste pkady, kter k zskvn dat z  klvesnice  uvaly funkc
gets a sscanf . Vte, e sscanf ukld data do urench promnnch a vidli
jste tak jej pouit s rznmi typy dat (int a float). Protoe rzn typy
dat  jsou  v  pamti uloeny odlin, je nutn ci funkci sscanf, jak typ
dat  chcete uloit. Podvejme se ble na  stavbu  funkce  sscanf.  Syntaxe
voln sscanf je tato:

   sscanf(buffer,"format string",[address,address,...])

Srovnejte s konkrtnm ppadem sscanf:

   sscanf(inbuf, "%f", &num);

   buffer  je  vstupn  pole,  kde  jsou data doasn uloena funkc  gets.
format string obsahuje jednu nebo vce  formtovch  specifikac. Formtov
specifikace  sestv  ze  znamnka procent (%) za  nm  nsleduje  psmeno
indikujc  typ  dat,  kter maj bt  uloena.  Skupina  jedn  nebo  vce
formtovch specifikac se nachz  v  uvozovkch.  Nap. %d uruje hodnotu
int,  %f  z  pedchozho  pkladu  float  a  %s  indukuj  etzec  znak.
Formtovac  etzec  %c%d se uv pro jedin  znak  i  pro  hodnotu  int.
Nejvce pouvan formty jsou obsaeny v tabulce 4.2.








                                  - 43 - 


   Tab. 4.2: Tabulka 4.2 : Formtov specifikace funkc sscanf a printf

------------------------------------------------------------------------
Funkce                                            sscanf       printf
------------------------------------------------------------------------

Velikost hodnoty (mn typ dat):
 specifikace short integer                        %hd
 specifikace long integer                         %ld          %ld
 specifikace double                               %lf          %lf
 uit float k indikaci long double               %Lf          %Lf

Typ dat, kter budou natna nebo vypsna:
 jedin znak                                      %c           %c
 signed integer                                   %d           %d
 signed double nebo float v exponencilnm
 formtu                                          %e           %e
 signed double nebo float v dekadickm
 formtu                                          %f           %f
 etzec znak (character string)                 %s           %s
 dekadick unsigned integer                       %u           %u
------------------------------------------------------------------------

   Tato tabulka tak ukazuje specifikace formtu  printf  probranho dle.
Vimnte si, e formt je shodn pro vtinu formtovch specifikac.

   Dal  nedlnou  soust  sscanf je adresa, na kter jsou data uloena.
Kad promnn  m  v  C  pidlenu  adresu.  Vtinou se o adresy nemuste
starat, k zskn hodnoty sta jmno promnn. Napklad count  +  1  dv
skutenou  hodnotu   promnn  count  plus  jedna.  V  naem  ppad  vak
nepotebujeme hodnotu promnn, potebujeme jej adresu.  K  zskn adresy
se uv  adresov  opertor  &  (ampersand).  Nsledujc  program ukazuje
rozdl mezi adresou promnn a hodnotou uloenou v n:

   Abyste mohli vyzkouet nsledujc program, nahrejte a spuste INTRO3.C.

*/* INTRO3.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   int  number = 10;
   printf("Address of variable number = %ld\n", &number);
   printf("Value stored at variable number = %d\n", number);
   printf("Enter a new value for the variable: ");
   gets(inbuf);
   sscanf(inbuf, "%d", &number);
   printf("New value stored at variable number = %d\n", number);

   return 0;
}

   Vsledek vypad takto :

   Adresses of variable number = 65498
   Value stored at variable number = 10
   Enter a new value for the variable: 33
   New value stored at variable number = 33


                                  - 44 - 


   Nsledujc program ilustruje dal monosti sscanf:

   Nahrejte  a spuste INTRO4.C. Vimnte si.  jak  uvdme  funkci  sscanf
pomoc funkc printf nebo puts, kter popisuj oekvanou hodnotu.

/* INTRO4.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   long transaction_number;
   int cashier_number;
   char transaction_code;
   float purchase_amount;

   printf("Enter transaction number: ");
   gets(inbuf);
   sscanf(inbuf, "%8ld", &transaction_number);

   printf("\nEnter your cashier number: ");
   gets(inbuf);
   sscanf(inbuf, "%2d", &cashier_number);

   printf("\nEnter transaction type code: ");
   gets(inbuf);
   sscanf(inbuf, "%c", &transaction_code);

   printf("\nEnter amount of purchase: ");
   gets(inbuf);
   sscanf(inbuf, "%f", &purchase_amount);

   return 0;
}


   Prvn  pkaz  sscanf  nate long (long int) s maximln osmi slicemi,
zatmco  druh  sscanf  nate  int  s maximln dvmi slicemi. (Je  mono
udlat jet dal chybovou kontrolu. Jestlie napete vce slic, ne je
dno, sscanf je zane jednodue  ukldat do nsledujc promnn nebo pokud
nensleduj u dn promnn, ignoruje je jako v tomto ppad.)

   V jednom voln sscanf je mono nast vce ne jednu promnnou:

gets(inbuf);
sscanf(inbuf, "%81d %2d", &transaction_number, &cashier_number);

   Program kombinuje prvn dv  voln  z  pedchozho pkladu. Protoe je
uito jednoho voln gets, je ten jen jeden vstupn dek.

   Pi nenaplnn sscanf pedpokld, e uivatel oddl  numerick hodnoty
mezerami. Do formtovacho etzce je  mon uloit i jin oddlovac znak;
v tomto ppad je nutno napsat kadou hodnotu tak, jak je pedepsna:

   #include <stdio.h>

   int main()
   {
      char inbuf(130);


                                  - 45 - 


      int hours, minutes, seconds;
      printf("Enter new time in hh:mm:ss ");
      gets(inbuf);
      sscanf(inbuf, "%d:%d:%d", &hours, &minutes, &seconds);
      return 0;
   }


Vypsn hodnoty promnn
---------------------------------------------------------------------------

   Opakem ke sscanf, kter ukld hodnotu pro promnnou,  je  printf, kter
vypisuje promnnou na obrazovku. Voln printf vypad takto:

   printf("format string",item,item,...)

   format string me obsahovat libovoln text, kter bude vypsn. Jestlie
vypisujete hodnotu jedn nebo vce promnnch, je pro kadou nutno stanovit
konverzn  specifikaci.  Tyto konverzn specifikace  jsou  analogick  jako
formtovac specifikace ve funkci sscanf, je byla popsna  ve,  ale maj
pro formtovn vstupu nkter dal  vlastnosti.  Specifikace  sestv ze
znaku % nsledovanho symbolem pro typ vkldanch dat.

   Funkci  printf jsme dve pouvali k vypsn  nkupn  stky,  dan  a
celkovho soutu:

   printf("\nPurchase is: %f", purchase);
printf("\n           Tax: %f", tax_amt);
printf("\n         Total: %f", total);

   Vsledky se zobrazovaly takto :

   Purchase is: 24.950001
           Tax: 1.621750
         Total: 26.571751

   Poet slic zahrnuje i desetinnou  teku. Nap. %6.2 vype pt slic,
ze kterch jsou dv za desetinnou tekou vpravo.

   Jak je mono nastavit specifikaci  konverze, aby Turbo C++ zobrazil tyto
hodnoty  sprvn  vyrovnny  s pouze dvma desetinnmi  msty  (kter  jsou
vhodn pro  stku  v  dolarech)?  een  je  nasnad: za znakem % napite
slo,  jen  je  soutem vech slic (i s des. tekou),  kter  je  teba
vypsat, dle desetinnou teku a za n poet desetinnch mst.

   printf("\nPurchase is: $%6.2f", purchase);
   printf("\n           Tax: $%6.2f", tax_amt);
   printf("\n         Total: $%6.2f", total);

   Zobraz tyto hodnoty:

   Purchase is: $ 24.95
           Tax: $  1.62
         Total: $ 26.57

   Nsledujc pklad ukazuje, jak je funkce printf schopna vypsat nkolik
typ sel v rznch formtech:

   Nahrejte a spuste program INTRO5.C.



                                  - 46 - 


/* INTRO5.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int   int_num = 999;
   float float_num = 99.99895;
   long  double big_num = 1250500750.75;

   printf("12345678901234567890\n");
   printf("%d\n", int_num);
   printf("%6d\n", int_num);
   printf("%f\n", float_num);
   printf("%6.3f\n", float_num);
   printf("%e\n", big_num);
   printf("%Le\n", big_num);

   return 0;
}

   Vsledky :

   12345678901234567890
   999
      999
   99.998947
   99.999
   -3.55361e-207
   1.25050e+09

   Prvn pkaz printf vype 20  slic  jako  mtko  seazen ostatnch
sel. Ukazuje zrove, e  printf  nemus  vypisovat pouze obsah promnn,
me pst i  text  dle  vaeho  pn.  Nsledujc  pkaz  vypisuje obsah
promnn int_num  (999) takov, jak je. Tet pkaz specifikuje 6-seln
pole, take  vsledek  je  zarovnn  vpravo,  slo  999 je vypsno s temi
mezerami  zleva.  (Jestlie  urte  pli  malou  dlku  pole pro  slo,
specifikace bude pekroena a bude vypsn  pln  poet slic. Je to z toho
dvodu, e 999 neme bt vypsno jako 99.)

   Nsledujc dva pkazy vypisuj hodnotu  promnn  float_num.  V prvnm
pkaze nen hodnota pln pesn,  je vypsno 99.998947 msto 99.99895. To
je tm, e typ float deklarovan pro float_num zaruuje  pesnost  na  sedm
mst, ale printf vypisuje vce sel, ne je dno vlevo od  desetinn teky
a jet 6 sel  vpravo  od desetinn teky, take nkolik poslednch sel
je  nesprvnch.  Pro  mnoho aplikac tento  mal  rozdl  nevad,  ale  je
dleit  si  pedchoz skutenost uvdomit,  protoe  jestlie  pekrote
pesnost danou pro  urit  typ  dat,  printf vype vce sel, kter jsou
nepesn, co me zmst uivatele.

   Vpis klamnch slic lze potlait  specifikac  pesnosti,  kter ur,
kolik sel za desetinnou tekou  potebujete.  V  nsledujcm  pkaze je
%6.3f, co zna maximln dlku  6  mst  a  3  desetinn  msta.  Kdy je
pesnost men ne poet  slic,  posledn  slice je zaokrouhlena nahoru
nebo dol dle okolnost.







                                  - 47 - 


Konverze typ v printf

   printf  s  konverznmi  specifikacemi se uv ke  konverzi  hodnoty  na
jakkoliv typ dat, jen je specifikovn, nehled na  aktuln  typ hodnoty.
Napklad  jestlie  mme  promnnou  dollars   typu   float   a  pouijeme
specifikaci  %d, hodnota 24.95 bude konit  nulou  nebo  nkterm  nhodnm
slem, protoe printf nate 2, ne 4 byty  (jako  int),  kter  zanaj na
adrese promnn dollars.  Na  druh stran, kdy deklarujete promnnou jako
int,  pokusem  o  vypsn pomoc %f tak dostanete chybn vsledek, protoe
printf bude st 4 byty do 2 bytov promnn.

   printf je komplikovan funkce s  dlouhm  zdrojovm  kdem,  aby obshla
rzn  formty. Turbo C++ pilinkuje k vaemu  programu  st  kdu,  kter
obsahuje hodnoty pohybliv rky  jen  tehdy,  pouijete-li  hodnoty tohoto
typu ve svm  programu.  Jestlie  v  programu nen pouit typ s pohyblivou
rkou a uijete specifikaci  %f  s hodnotou int, vype se chybov zprva,
kter  oznamuje,  e  formty  typu  pohybliv  rky  nejsou pilinkovny.
Kompaktnj a pehlednj alternativa  k  printf  a  sscanf je obsaena v
knihovn stream C++, popsan v kapitole 5.

   Pedchoz pklad uval k vpisu  big_num  specifikace  %e,  kter byla
deklarovna jako  long  double.  Nanetst  specifikace  zkou  promnnou
vypsat jako obyejn double,  co  dv  znovu  nesmyslnou hodnotu s velkm
zpornm exponentem. Posledn pkaz uv specifikaci  %Lf,  kter sprvn
specifikuje long double.


Formtovn s posloupnostmi escape\

   Existuje  mnoho  znak,  kter d vpis textu na obrazovce. Nap. znak
tab pesunuje kurzor na nsledujc pozici tabultoru, znak pro dal dak
pesunuje  kurzor  na  nsledujc  dek,  znak  pro  odstrnkovn vymae
obrazovku pro psan dalho textu. printf me mt v textu, kter vypisuje,
zalenn jakkoliv z tchto znak tak,  e  ped symbolem znaku se nape \
(zptn lomtko - backslash). Zptn lomtko se nazv escape, protoe k
Turbo C++, e nsledujc znak nem chpat jako literl, ale jako symbol se
specilnm vznamem.

   U  bylo  uvedeno  mnoho pklad, kter v pkaze printf ve vypisovanm
etzci obsahovaly \n.  Zatmco  pkaz  print  v  jazycch  jako  je Basic
automaticky posunuje kurzor na nsledujc dek, v C jazyku tomu tak nen.
To dv vce monost, protoe je mono k vypsn textu na jeden dek ut
oddlen pkazy printf. Na dalm dku meme pokraovat  tehdy,  kdy to
bude teba. Nsledujc tabulka vypisuje escape posloupnosti Turbo C++.


















                                  - 48 - 


            Tab. 4.3: Tabulka 4.3 : Znakov escape posloupnosti

------------------------------------------------------------------------
posloupnost jmno                       vznam
------------------------------------------------------------------------
\a          alert (vstraha)            tn
\b          backspace                   vrac o jeden znak
\f          formfeed (odstrnkovn)    nov obrazovka
\n          newline (nov dek)        pesun na zatek dalho dku
\r          carriage return             pesun na zatek dku
            (nvrat vozku)
\t          horizontln tabultor      pesun na dal pozici tabultoru
\v          vertikln tabultor        pesun dol o danou hodnotu
\\          obrcen lomtko            vype aktuln backlash
\'          apostrof                    vype aktuln apostrof
\"          uvozovky                    vype aktuln uvozovky
\?          otaznk                     vype aktuln otaznk
\OOO                                    vypisuje znak, jeho hodnota ASCII
                                        je v oktln soustav (jedna a
                                        ti slice)
\xHHH                                   vypisuje znak, jeho hodnota ASCII
                                        je v estnctkov soustav (jedna
                                        nebo vce slic)


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

    o  "newline" (nov dek) je  v  MS-DOS  systmu  ekvivalentn carriage
       return (nvrat vozku) plus linefeed (oddkovn) (CR+LF). V jinch
       systmech to neodpovd.

    o  zptn lomtko ped apostrofem nebo  uvozovkami  je  nezbytn tehdy,
       kdy by peklada Turbo C++ mohl znaky interpretovat  jinak,  ne je
       myleno. Nap  "  normln  ohraniuj  etzec.  Vypsn  etzce v
       uvozovkch se docl pomoc "\"etzec v uvozovkch\"".

    o  oktln   nebo  hexadecimln  hodnoty  je  vtinou  uvno   jako
       grafickch znak nebo znak pro zen tisku. Nap. printf("xDB") na
       IBM PC vype tvereek.

Krom \n  je  nejvce  pouvna  sekvence  \t,  tj. znak pro tabultor. Je
uiten pro vpis tabulek sel. Nap. tento program :

   Nahrejte a spuste program INTRO6.C.
/* INTRO6.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int i = 101, j = 59, k = 0;
   int m = 70,  n = 85, p = 5;
   int q = 39, r = 110, s = 11;

   printf("\tWon\tLost\tTied\n\n");
   printf("Eagles\t%3d\t%3d\t%3d\n", i, j, k);
   printf("Lions\t%3d\t%3d\t%3d\n", m, n, p);
   printf("Wombats\t%3d\t%3d\t%3d\n",  q, r, s);

   return 0;


                                  - 49 - 


}

   zpracovv nsledujc pravn naformtovanou tabulku:
             Mon    Lost   Tied

   Eagles    101    59     0
   Loins     70     85     5
   Wombats   39     110    11


Aritmetick opertory
---------------------------------------------------------------------------

   Nyn,  kdy   vte,  jak  natat  a  vypisovat  hodnoty  rznch  druh
promnnch, podvejme se ble na opertory Turbo C++. Nkter z  nich jste
u vidli: opertor piazen  (=)  a  tyi aritmetick opertory (+,-,*,/
pro stn, odtn, nsoben a dlen).

   Tyto  opertory vtinou pracuj tak, jak je  obecn  znmo  -  existuje
pouze nkolik odlinost : nap. dlenm dvou hodnot int dostanete vsledek
int  bez  mst  za desetinnou tekou.  Dle  pro  tyto  opertory  existuje
speciln uspodn nazvan priorita.  Operace  s  nsoben a dlenm maj
pednost  ped stnm a odtnm. Zkuste  uhodnout  tyi  sla,  kter
vype nsledujc program (nahrejte a spuste program INTRO7.C):


/* INTRO7.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   float result;
   result = 1.0 + 2.0 * 3.0 / 4.0;
   printf("%f\n", result);
   result = 1.0 / 2.0 + 3.0;
   printf("%f\n", result);
   result = (1.0 + 2.0) / 3.0;
   printf("%f\n", result);
   result = (1.0 + 2.0 / 3.0) + 4.0;
   printf("%f\n", result);

   return 0;
}

Zde jsou vsledky. Hdali jste dobe ?

   2.500000
   3.500000
   1.000000
   5.666667

   V prvnm vrazu je nsoben 2.0*3.0 provedeno jako prvn, vsledek je 6.
Dle,  6/4.0  dv  1.5, tato hodnota se  pite  k  1.0,  co  je  konen
vsledek:  2.5.  Vimnte  si, e kdy  jsou  opertory  rovnocenn  co  do
pednosti (* a / maj stejnou prioritu,  stejn  tak  +  a  -),  operace se
provdj zleva doprava.

   Ve druhm vrazu  se  jako  prvn  provd  dlen,  pak  stn, take
vsledek je 0.5+3 = 3.5.


                                  - 50 - 


   Ve  tetm  vraze je souet (1.0+2.0) v  zvorkch,  je  mu  tedy  dna
pednost. Vsledek je 3.0/3 = 1.

   Konen  v  poslednm  vraze  je  1.0+2.0/3.0 bez zvorek.  Proto  jsou
uplatnny nsledujc priority:  2  je  dleno  3 a piteno k 1. Vsledek,
1.666667 je piten k 4 a dostaneme 5.666667.

   modulo (%)

   Opertor  modulo  (%)  dl  dv  sla  a  uchovv zbytek  po  dlen.
Napklad vraz 5%2 dv 1, zatmco 18%3 dv 0, protoe 18 je dlitelno 3.


Aritmetick a typov konverze
---------------------------------------------------------------------------

   Co se stane, jestlie pitete  int k float? Pravdpodobn budete chtt,
aby  vsledek  byl  typu float a desetinn st byla zachovna. Takov je i
skutenost. Turbo C povyuje  ni  typy  na  vy podle skupiny pravidel
(viz nsledujc tabulka). Z tabulky je mono vyst, e kdy  jsou seteny
typy int a float, int je poveno na float. Dv sla se setou a vsledek
je typu float.


                  Tab. 4.4: Povyovn aritmetickch typ

------------------------------------------------------------------------
typ                                konvertovn na
------------------------------------------------------------------------

Tyto typy jsou konvertovny automaticky :

char                               int
unsigned char                      int
signed char                        int
                                      1
short                              int
                                               1
unsigned short                     unsigned int
enum                               int
float                              double

Nsledujc  pravidla  jsou  aplikovna  do  t doby ne jsou oba  operandy
stejnho typu :

Kdy jeden operand je:             Druh je konvertovn na:

long double                        long double
double                             double
float                              float
unsigned long                      unsigned long
long                               long
unsigned                           unsigned
------------------------------------------------------------------------

1
  Toto je poadavek ANSI. Akoliv  short  a  int maj stejnou dlku u vech
kompiltor C jazyka, konverze se neprovd.




                                  - 51 - 


Petypovn

   Nkdy je uiten nebo nezbytn explicitn zmnit datov poloky na jin
typ. Napklad pokud mme :


#include <stdio.h>

int main()
{
   int a=5, b=2;
   printf("%d", a/b);
   return 0;
},

dostaneme vsledek 2, protoe celoseln dlen  nedv  dnou desetinnou
st. Jestlie to vak zkuste takto :


#include <stdio.h>

int main()
{
   int a=5, b=2;
   printf("%f",(float) a / (float) b);
   return 0;
},

hodnoty a a  b  budou  konvertovny  jet  ped dlenm na typy obsaen v
zvorkch (v tomto ppad  float),  take  vsledek  bude 2.5. Tato nucen
konverze se nazv petypovn (type cast nebo pouze cast).


Kombinace aritmetiky a piazen
---------------------------------------------------------------------------

   Bاnou  operac  v  programovn  je  pitn stle stejn  hodnoty  k
promnn (jej inkrementace). Nap. kdy program st nalezen slova, dl
nco  jako  :  total_words = total_words + 1. Pozdji uvidte, jak se tvo
smyky pitnm nebo odtnm sla o jist velikosti k dan promnn.

   Nejkrat cestou jak to  provst,  je  spojit  aritmetiku a piazen do
jednoho  kroku.  S  piazenm  je  mono  kombinovat  binrn  aritmetick
opertor. Pedchoz pkaz by mohl bt napsn jako total_words +=  1. tte
to jako : "Piti 1 k obsahu promnn total_words a novou hodnotu ulo zpt
do total_words." Jednodue - program na bilanci ek by mohl provst pkaz
jako balance -= check_amt (odeti stku na eku z hodnoty balance  a novou
hodnotu pia do balance). Stejn se tvo kombinace *= a /=.


Inkrementace a dekrementace
---------------------------------------------------------------------------

   Pitn a odtn jedniky je operac dvou specilnch opertor (++)
a (--). Tedy ++total_words provd  pesn tot jako total_words +=1. Jin
program  me odtat count-- do t doby, ne  je  hodnota  promnn  count
rovna 0.





                                  - 52 - 


   Opertory  pitn nebo odtn mohou bt  ped  nebo  za  pslunou
promnnou. Pokud opertor stoj ped  promnnou,  je  aplikovn  nejprve na
tuto promnnou a a potom je  vsledek  pouit jako vraz. Kdy je opertor
za  promnnou,  bere se nejprve hodnota promnn  a  a  pak  je  aplikovn
opertor.

   #include <stdio.h>

   int main()
   {
      int val = 1;

      printf("val is %d and then post-incremented\n",val++);
      printf("val is now %d\n", val);
      printf("val is pre-incremented to %d\n", ++val);
      return 0;
   }

co dv vsledky :

   val is 1 and then post-incremented
   val is now 2
   val is pre-incremented to 3

   V prvnm pkaze printf je promnn val rovna 1 a  tak  je tak vypsna.
Pot je zvtena o 1, jak je  vidt  z  druhho  pkazu  printf.  V tetm
pkaze je nejprve inkrementovna val a hodnota 3 je vypsna funkc printf.


Prce s bity
---------------------------------------------------------------------------

   Nkdy je poteba  manipulovat  s  bity  kterhokoliv  byte  v  pamti. C
obsahuje  mnoinu  bitovch  opertor,  je  jsou  vypsny  v  nsledujc
tabulce:


                 Tab. 4.5: Tabulka 4.5 : Bitov opertory

------------------------------------------------------------------------
opertor       vznam
------------------------------------------------------------------------
opertory se dvma operandy:
&              AND;jestlie oba bity jsou 1, vsledek je 1
|              OR - jestlie libovoln bit je 1, vsledek je 1
^              exkluzvn OR, jestlie alespo 1 bit je 1, vsledek je 1
>>             pro signed int (celos. se znamnkem) posunuje bity vpravo
               tolikrt, kolik je hodnota sla za nm, zleva zapisuje 1,
               jestlie je slo zporn a 0 jestlie je kladn. Pro
               unsigned int (cel slo bez znamnka) se zleva zapisuj
               nuly.
<<             posunuje bity vlevo tolikrt, kolik je hodnota sla za nm,
               zprava zapisuje nuly.

Opertory s jednm operandem :
~              doplnk, pevrac vechny hodnoty bit
------------------------------------------------------------------------


   Nsledujc program ilustruje uit tchto opertor :


                                  - 53 - 


   #include <stdio.h>

   int main()
   {
      printf("1 & 1 is %d\n, 1 & 1);
      printf("1 | 1 is %d\n, 1 | 1);
      printf("1 ^ 1 is %d\n, 1 ^ 1);
      printf("255 << 2 is %d\n, 255 << 2);
      printf("255 >> 2 is %d\n, 255 >> 2);
      printf("255 is %u\n", -255);
      return 0;
   }
   slo 1 je uloeno ve dvou bytech jako 00000000 00000001, slo 255 jako
00000000 11111111. Zde je vsledek:

   1 & 1 is 1
   1 | 1 is 1
   1 ^ 1 is 0
   255 << 2 is 1020
   255 >> 2 is 63
   -255 is 65280

   Vimnte si, e opertor & dv hodnotu 1, jestlie oba porovnvan bity
jsou rovny 1. To je uiten pro demaskovn vybranch bit pomoc bitovho
vzoru, kter m nulu v tch pozicch, je chcete zmnit. Opertor | nastav
bit na  hodnotu  1,  jestlie  jedna nebo ob hodnoty maj 1 v te pozici.
Jestlie chcete zajistit, aby byl jist bit nastaven, pouijte k  nmu "OR"
s hodnotou, kter m v tomto mst urit 1.

   tvrt pkaz posouv dvakrt doleva hodnotu 255 (z 00000000 11111111 se
stane  00000011  11111100).  Protoe kad msto v  binrn  aritmetice  je
dvojnsobek  pedchozho,  vsledek  je  ekvivalentn souinu 255*2*2, ili
1020.  V  nsledujcm  pikaze  je  255 posunuta dvakrt doprava, take  z
00000000 11111111 se  stane  00000000 00111111, neboli 63. Konen posledn
pkaz  mn  00000000  11111111 na 11111111 00000000.  Je  to  evivalentn
65535-255, ili 65280.



---------------------------------------------------------------------------
Vrazy
---------------------------------------------------------------------------


   Mli  jste  monost  vidt mnostv pkaz, ve  kterch  byly  obsaeny
pkazy. Nyn je tedy nejvy as si ci, jak vypad vraz  obecn. Vraz
je  jakkoliv  kombinace  promnnch,  definovanch konstant nebo selnch
literl, kter spolu s  jednm  nebo vce opertory dv jedinou hodnotu a
me zpsobit jeden nebo vce vedlejch efekt. Tedy :

   purchase * TAX_RATE
   dollars / bushels
   count++
   STATUS & SWITCH_ON

jsou  vechno  pklady  vraz. Vraz me bt  piazen  promnn  pomoc
opertoru piazen (=). Me bt zobrazen funkc printf stejn jako jedin
promnn. Pedchoz program uval vrazy jako:

printf("255 << 2 is %d\n", 255 << 2);


                                  - 54 - 


Vyslen vraz
---------------------------------------------------------------------------

   Turbo  C++  vysluje  vrazy  aplikovnm  opertor  v   poad  danm
prioritou ponaje jakoukoliv st vrazu uzavenou  v  zvorkch. Tabulka
4.6  vypisuje  vechny  opertory  C  jazyka  v  poad jejich  priority  a
asociativity.   Asociativita  je  smr,  ve  kterm  kompiltor   vysluje
opertory a operandy. Napklad rzn  piazovac  opertory  (=,  +=, *=,
atd.) maj  asociaci zprava doleva (piazuj vraz vpravo promnn vlevo),
zatmco  aritmetick  opertory (*, /, +, -  a  %)  jsou  asociovny  zleva
doprava.  Priorita  je  poad  ve  kterm  probh  vyslovn. Napklad
nsoben m pednost ped stnm, take pkaz

   count = 5 + 3 * 4

dv vsledek 17, ne 32.

   Nejlepm zpsobem jak  se  seznmit  s  tmito pravidly, je napsat si v
pkaze printf njak vraz, abyste  mli monost zjistit vsledek, a potom
se podvat do tabulky, jak byl vsledek vypotn. (Jako alternativa slou
kapitola  7,  "Ladn  v  novm  IDE", kter ukazuje, jak vyut  vestavn
ladic program Turbo C++ k vyslen rznch druh vraz.)

   Pravidla priority a asociativity jsou nsledujc:

    o  Unrn opertory  (opertory s jednm operandem, jako nap. ++) maj
       vy prioriu ne binrn opertory (nap. /).

    o  Arimetick opertory maj vy prioritu ne porovnvac opertory.

    o  Vt ne a men ne maj vy prioritu ne rovn se a je rzn.

    o  Porovnvac opertory maj vy prioritu ne  bitov  (krom posunu
       vpravo a vlevo).

    o  Bitov opertory maj pednost ped logickmi.

    o  Logick AND (&&) m pednost ped logickm OR (||).

    o  Vechno  ostatn  krom  opertoru  rka  m  vy   prioritu  ne
       piazen.





















                                  - 55 - 


         Tab. 4.6: Tabulka 4.6 : Priorita a asociativita opertor

------------------------------------------------------------------------
opertory                                         asociativita
------------------------------------------------------------------------
() [] ipka vpravo :: .                           zleva doprava
! vlnovka + - ++ -- & * (petypovn) sizeof new
delete                                            zprava doleva
.* ipka vpravo *                                 zleva doprava
* / %                                             zleva doprava
+ -                                               zleva doprava
<< >>                                             zleva doprava
< <= > >=                                         zleva doprava
== !=                                             zleva doprava
&                                                 zleva doprava
^                                                 zleva doprava
|                                                 zleva doprava
&&                                                zleva doprava
||                                                zleva doprava
?: (podmnn vraz)                              zprava doleva
= *= /= %= += -= &= ^= |= <<= >>=                 zprava doleva
,                                                 zleva doprava
------------------------------------------------------------------------


   Opertory, priorita a asociativita  jsou  pln  vysvtleny v kapitole 1,
"Jazykov standard Turbo C++" v Pruce programtora.


Piazen hodnoty ve vrazu
---------------------------------------------------------------------------

   U  byly uvedeny pklady pkaz, ve kterch  bylo  uito  piazen  a
inicilizace promnn (total = 0). Z piazovacho  pkazu total=count=line
=  0  vyplv,  e kad piazovac pkaz je tak vrazem. Co myslte, e
zobraz nsledujc program ?

   #include <stdio.h>

   int main()
   {
      int val
      printf("%d\n", val = 7);
      return 0;
   }

   Jestlie jste hdali 7, hdali jste dobe. Hodnota piazovacho pkazu
jako vrazu je to, co se piazuje.

   U  bylo  uvedeno,  e  voln  funkce,  kter  vrac hodnotu,  je  samo
hodnotou. Nap. total+= tax (total) je evivalentn

   tax_amt = tax(total;
   total - total 1 tax?amt;

   Prvn varianta vynechv extra promnnou za cenu malho znepehlednn.






                                  - 56 - 


---------------------------------------------------------------------------
Znaky a etzce
---------------------------------------------------------------------------


   Mimo sel existuje  jet  nco  jinho  - znaky a znakov etzce. Jak
mon vte, znak (velk  nebo  mal  psmeno, slo, interpunkn znamnko,
nvrat  vozku  nebo Ctrl-C) je uloen jako  jedin  byte  (8  bit).  Tyto
hodnoty jsou znakm piazovny kdem ASCII  (American  Standards Committee
for Information Interchange). Prvnch 128  hodnot  je  stejnch  jako vude
jinde, ale druhch 128 hodnot vyuvaj potae kompatibiln s IBM  PC pro
speciln grafick znaky a znaky na kreslen ar. V C jazyku  budeme uvat
typ  char  (co  je tot jako signed char) k dosaen hodnot od 0 do 127 s
rezervou zpornch hodnot pro  speciln  ely  (jako teba indikace chyby
nebo  konce souboru). Pokud poadujete pstup k  pln  mnoin  znak  PC,
pouijte typ unsignad char.


Vstup a vstup jedinho znaku
---------------------------------------------------------------------------

   Ukeme  vm  zpsob,  jak  nast  znak  z  klvesnice  a uloit jej do
promnn (nahrejte a spuste INTRO8.C):

/* INTRO8.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   char one_char;
   printf("Enter a character: ");
   gets(inbuf);
   sscanf(inbuf, "%c", &one_char);
   printf("The character you entered was %c\n", one_char);
   printf("Its ASCII value is %d\n", one_char);

   return 0;
}

   Vsledky vypadaj takto:

   Enter a character: A
   The character you entered was A
   Its ASCII value is 65

   Nezapomete,  e  potebujeme  adresu  one_char,  take  je  nutno  ped
one_char napsat opertor & (adresa).

   one_char je promnn typu char. Pkaz sscanf uv  k  indikaci jednoho
znaku  specifikaci %c a ukld vstupn  hodnotu  do  one_char.  Nsledujc
pkaz vypisuje hodnotu  one_char  (vimnte  si  konverzn  specifikace %c
funkce printf).  Nsledujc  pkaz  printf  zobrazuje  ASCII  kd vstupn
hodnoty. Doshne toho konverzn specifikac %d. Ta konvertuje znak na ASCII
hodnotu.  Znak  je  cel  slo,  ale  dky  jistm  vlastnostem  C  (nap.
specifikace %c) se vypisuje jako znak lpe ne jako cel slo.





                                  - 57 - 


   Alternativou  k  tomuto  postupu natn znaku z  klvesnice  je  uit
knihovnch funkc getch nebo getche.  Pedchoz  program  me  bt pepsn
takto:

   Tento program se jmenuje INTRO9.C. Nahrejte jej, spuste a podvejte se,
jak pracuje.

/* INTRO9.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>
#include <conio.h>

int main()
{
   int one_char;
   printf("Enter a character: ");
   one_char = getch();
   printf("\nThe character you entered was %c\n", one_char);
   printf("Its ASCII value is %d\n", one_char);

   return 0;
}


   V tto verzi programu nebude  znak vypsn na obrazovku. Jestlie chcete,
aby byl znak zobrazen, nahrate getch funkc getche. gets nat cel dek
textu  a pak teprve pokrauje v innosti, zatmco  getch  a  getche  natou
jeden znak a hned pokrauj dle.


Zobrazen znaku
---------------------------------------------------------------------------

   Pedchoz pklad ukzal jeden  zpsob  jak  zobrazit znak na obrazovku.
Konverzn specifikace %c se uv s funkc printf k vypsn jedinho znaku.
Jinak  lze  zobrazit  jedin  znak  pomoc knihovn funkce putch, kter  je
definovna v hlavice souboru conio.h. Nap.  putch('>')  zobrazuje literl
>. Jestlie one_char je promnn typu char (nebo v nkterch ppadech typu
int), putch(c) vype hodnotu one_char jako znak.


Zobrazen znakovch etzc
---------------------------------------------------------------------------

   etzec (string)  je posloupnost znak. etzce byly pouity v pkazech
s printf. Napklad :

   printf("Enter a character: ");

vol printf a k, aby vypsala  etzec  znak ponaje E a kone mezerou.
Uvozovky kaj Turbo C++, aby bral skupinu znak jako etzec.  Kad znak
je  uchovvn v za sebou jdoucch bytech pamti  a  printf  dostv  adresu
prvnho znaku. Jak ale printf v, kde je konec etzce? Turbo C++ pipojuje
na  konec  neviditeln  znak zvan null. Tento znak m ASCII  hodnotu  0  a
sybolicky je reprezentovn jako \0.  Nsledujc  obrzek  ukazuje, uloen
etzce v pamti.






                                  - 58 - 


                    Obr. 4.2: Uloen etzce v pamti


   po.adresa etzce    nulov znakĿ
  Ŀ
  Toto je hodnota str\n \0             
  
  0 1 2 3 4 5 6 7 8 9 10   ....                                        30
                    pozice
  char str[30];
  strcpy(str,"Toto je hodnota str\n";

   Pozor !

   message je skuten ukazatel na umstn etzce. Proto pkaz

   message = "this is the value of msg\n";

vytv bod message, kter oznauje etzec. Nekopruje etzec literl do
pam؟ovho  msta  promnn  message.  K  tomu by bylo nutno pout  funkci
strcpy.

   Kvli  komfortu  obsahuje  Turbo C++ i knihovn funkci puts. Tato funkce
pe etzec na  standardn  vstupn zazen, obvykle na obrazovku. Proto
puts("Enter a character: ") pracuje stejn jako ve popsan pkaz printf,
pouze s jednm rozdlem  :  puts zapisuje automaticky na konec etzce znak
pro  nov  dek  (\n), kter zpsob pechod kurzoru na nsledujc dek.
Jestlie program vmi  vytvoen nepotebuje formtovac schopnosti printf,
je mono uetit msto a k vypsn etzce pout jednodu funkci puts .

   Pi specifikaci etzc a  znak  je  dleit  rozdl mezi apostrofem a
uvozovkami.

    o  "a"  je  etzec,  kter sestv z jednoho psmena a a neviditelnho
       nulovho znaku (null character)

    o  'a' je pouze znak a.

   Protoe etzce  a znaky jsou odlin datov typy, etzcov specifikace
nebo  etzcov funkce se znaky nepracuj a obrcen  -  znakov  funkce  a
specifikace nepracuj s etzci. Ke zobrazen "a" se v printf uv %s nebo
puts; pro 'a' se uv printf s %c nebo putch.



---------------------------------------------------------------------------
Testovac podmnky a tvorba vbr
---------------------------------------------------------------------------


   U  jste se nauili hodn ze zklad jazyka C, ale jet to nen zdaleka
ve. Budeme pokraovat dle.  Vechny  programy bا pmo od zatku a do
konce. asto se vak  mus  rozhodnout  na  zklad jist hodnoty. Uvaujme
tuto st programu :

   if (bill > credit_limit)
      puts("Consult with the manager");

   Jestlie hodnota tu  je  vt  ne  stka  kreditnho limitu,program
vype zprvu o konzultaci s manaerem.


                                  - 59 - 


Pouit relanch opertor
---------------------------------------------------------------------------

   Opertor > (vt ne) z pedchozho pkazu se nazv relan opertor.
Vyjaduje vztah mezi dvma hodnotami - v tomto ppad jestli bill je vt
ne   credit_limit.  Potae  uvaj  jednoduchou  dvoustavovou   logiku:
Jestlie je vraz pravdiv, m hodnotu  1,  pokud ne, m hodnotu 0. Pehled
relanch opertor obsahuje nsledujc tabulka.

                 Tab. 4.7: Tabulka 4.7 : Relan opertory

------------------------------------------------------------------------
opertor       vznam              pklad
------------------------------------------------------------------------
>              vt ne           5 > 4
>=             vt nebo rovno    5 >= x
<              men ne           4 < 5
<<=            men nebo rovno    x <= 5
==             rovno               5 == 5
!=             nerovno             5 != 4
------------------------------------------------------------------------


   Nsledujc  jednoduch   program   ukazuje   mon   pouit  relanch
opertor:

   Nahrejte a spuste INTRO10.C.

/* INTRO10.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   int first, second;
   printf("Input two numbers\n");
   gets(inbuf);
   sscanf(inbuf, "%d %d", &first, &second);
   printf("first > second has the value %d\n", first > second);
   printf("first < second has the value %d\n", first < second);
   printf("first == second has the value %d\n", first == second);

   return 0;
}


Jeden  z  monch  prbh s hodnotami 3 a 5 (nezapomete mezi sly napsat
mezeru) vypad takto :

Input two numbers:
first > second has the value 0
first < second has the value 1
first == second has the value 0

   Vimnte si, e relan test je vraz, protoe dv hodnotu.  Proto me
bt  vypsn  pomoc printf a je ho  mono  piadit  promnn  teba  tmto
pkazem  :  hot  =  (temperature  > 90). Nezamujte == (relan  opertor
rovnosti)  s  =  (piazovac opertor). Zkuste zmnit  posledn  pkaz  v
pkladu takto :


                                  - 60 - 


   printf("first == second has the value %d\n", first = second)

   Vraz first = second piazuje hodnotu second, v pkladu hodnotu 5. if,
for a jin  pkazy,  kter testuj podmnky, povauj jakoukoliv nenulovou
podmnku za pravdivou. Je  jasn,  e pouit = msto == zpsob nepatin
chovn programu (napklad zacyklovn v nekonen smyce).


Pouit logickch opertor
---------------------------------------------------------------------------

   V testu je mono kombinovat vce ne jednu  podmnku.  Realizace probh
pomoc jednoho ze tech opertor z nsledujc tabulky :


                        Tab. 4.8: Logick opertory

------------------------------------------------------------------------
opertor                 vznam
------------------------------------------------------------------------

&&                       AND (ob podmnky mus bt pravdiv)
||                       OR (alespo jedna podmnka mus bt pravdiv)
!                        NOT (obrac pravdivostn hodnotu podmnky)
------------------------------------------------------------------------


   Napklad podmnkov vraz

   (employee_type == temporary) && (wage > 6.00)

je pravdiv pouze tehdy, kdy je zamstnanec pijat pouze  doasn  a  jeho
(nebo jej) mzda pekrauje  6.00$  za  hodinu. Pi vyhodnocovn opertor
postupuje  C  takto  : pokud prvn podmnka (employee_type == temporary) je
nepravdiv,  druh  u  nen  testovna,   protoe  cel  vraz  s  AND  je
nepravdiv, pokud je nepravdiv alespo jedna z podmnek.

   Vraz

   (employee_type == temporary) || (employeee_type == hourly)
je pravdiv, kdy  je  splnna  kterkoliv  z  podmnek.  Protoe  prvn je
pravdiv, nen u druh testovna.


Vtven pomoc if a if...else
---------------------------------------------------------------------------

   Nyn, kdy mte pehled o relanch a logickch  opertorech,  je naase
jich vyut. Jednoduch prkaz if m tuto syntaxi :

   if(podmnkov vraz)
      pkaz nebo skupina pkaz;

   Podmnkou me  bt jedin relan vraz nebo kombinace vraz spojench
logickmi opertory. Mus bt uzaven(y)  v  zvorkch.  Pkaz  if piad
podmnkovmu  vrazu  hodnotu  true nebo false. Pokud  je  vraz  pravdiv,
provd se pkaz  nebo  skupina  pkaz  za if. Jestlie chcete, aby byla
provedena  cel skupina pkaz, je nutno uzavt  vechny  do  zvorek.  V
nsledujcm programu jsou obsaeny  dva  pkazy  if, kter rozhoduj, zda
slo, kter zadte je lich nebo sud.


                                  - 61 - 


   Nahrejte a spuste INTRO11.C.

/* INTRO11.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char  inbuf[130];
   int   your_number;
   printf("Enter a whole number: ");
   gets(inbuf);
   sscanf(inbuf, "%d", &your_number);

   if (your_number % 2 == 0)
      printf("Your number is even\n");

   if (your_number % 2 != 0) {
      printf("Your number is odd.\n");
      printf("Are you odd, too?\n");
   }
   printf("That's all, folks!\n");

   return 0;
}


   Po vypsn npovdy a uloen  sla  do  your_number  rozhoduje program
pomoc if a opertoru modulo (%), jestli je slo  sud.  (Protoe  vechna
sud sla jsou dliteln dvma, kad  sud  slo v operaci modulo 2 dv
vsledek 0.) Pokud  je  slo  sud,  provede se prvn pkaz printf. Druh
pkaz if testuje, zda your_number je lich, to jest,  jestli  m  nenulov
zbytek po dlen dvma. Pokud je slo lich, vype se :

   Your number is odd.
   Are you odd, too ?

   Provedeny  jsou  oba  pkazy  printf,  protoe  jsou  spojeny dohromady
zvorkami. Nakonec je vypsna zprva "That's all, folks!". Ta nen soust
pkazu if, proto je zobrazena  vdy nezvisle na tom,jestli je your_number
lich nebo sud slo.


Vcensobn vbr pomoc if...else
---------------------------------------------------------------------------

   Pedchoz pklad se vm mon zdl ponkud nemotorn. Jestlie je slo
sud, u neme bt lich, take pro dva oddlen testy? Tento  pklad je
mono napsat mnohem kompaktnji pidnm  else vtve k if. Pkaz if...else
m tuto syntaxi:

   if(podmnkov vraz)
      pkaz nebo skupina pkaz;
   else
      alternativn pkaz nebo skupina pkaz;

   Aplikac tohoto na pedchoz pklad dostanete :

   Nahrejte a spuste program INTRO12.C.



                                  - 62 - 


/* INTRO12.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   int  your_number;
   printf("Enter a whole number: ");
   gets(inbuf);
   sscanf(inbuf, "%d", &your_number);

   if (your_number % 2 == 0)
      printf("Your number is even\n");
   else {
      printf("Your number is odd.\n");
      printf("Are you odd, too?\n");
   }
   printf("That's all, folks!\n");

   return 0;
}


   Pkazy  if a else je mono vnoovat do  libovoln  rovn,  akoliv  po
nkolika  vnoench pkazech if kompiltor pepln pam؟.  Pedpokldejme,
e mte napsat program, kter  rozdluje  potae  pracovnkm  za splnn
nsledujcch podmnek :

    o  Jestlie zamstnanec je programtor a pracuje u firmy  vce  jak dva
       roky, pidl se mu PC 80386.

    o  Jestlie zamstnanec je programtor a pracuje u firmy  mn  ne dva
       roky, pidl se mu PC 80286.

    o  Jestlie zamstnanec pracuje u  firmy  vce  jak  dva roky, ale nen
       programtor, pidl se mu PC 8088.

    o  Konen, pokud zamstnanec  nespluje  ani jednu z podmnek, bude mu
       pidlen Macintosh.

   Zkuste se zamyslet,  jak  byste realizovali tyto podmnky pomoc pkaz
if a else. Zde je een :

   if (employee_type ==PROGRAMMER) {
      if (years_worked >=2)
         give_employee(PC386);
      else
         give_employee(PC286);
}
else if (years_worked >= 2)
   give_employee(PC88);
else
   give_employee(Mac);

   Vimnte  si,  e  k zdraznn zvislosti podmnek na sob jsme pouili
odsazen. V  prvnm pkaze se zjiuje, jestli zamstnanec je programtor.
Pokud  ano,  nsleduje  kontrola  potu  odpracovanch  rok   a  pidlen
odpovdajcho  potae. Jestlie  zamstnanec  nen  programtor,  vnj



                                  - 63 - 


pkaz  if...else  vyhodnot  poet  odpracovanch  let  a   pidl  stroj
neprogramtorm podle zsluh.


Vcensobn vbr : switch
---------------------------------------------------------------------------

   Dlouh posloupnost pkaz if, else if je pi tvorb navn,  spletit a
nchyln k chybm. Podvejte se na nsledujc program, jen m rozhodnout,
jak zobrazit mnoinu dat v zvislosti na psmenu, kter stiskne  uivatel v
menu. Zde je :

   Nahrejte a psuste program INTRO13.C.

/* INTRO13.C--Example from Chapter 4 of Getting Started */

#include <conio.h>
#include <stdio.h>
#include <ctype.h>

int main()
{
   char cmd;

   printf("Chart desired: Pie  Bar  Scatter  Line  Three-D");
   printf("\nPress first letter of the chart you want: ");
   cmd = toupper(getch());
   printf("\n");

   if (cmd == 'P')
      printf("Doing pie chart\n");
   else if (cmd == 'B')
      printf("Doing bar chart\n");
   else if (cmd == 'S')
      printf("Doing scatter chart\n");
   else if (cmd == 'L')
      printf("Doing line chart\n");
   else if (cmd == 'T')
      printf("Doing 3-D chart\n");
   else printf("Invalid choice.\n");

   return 0;
}


   Program zobrazuje dek menu a nate pomoc funkce getch hodnotu do cmd.
Pi tom prochz vstupn hodnota funkc toupper. Znamen to, e  se pracuje
pouze s velkmi psmeny. Posloupnost vtven if a else  if  testuje  kadou
hodnotu a  vyvolv  odpovdajc  funkci.  Posledn  else  oetuje ppad
nesprvnho znaku.

   Jednodu zpis pedchozho programu se  d  realizovat  pomoc pkazu
switch. M tuto syntaxi :

   switch(hodnota)
   {
      case hodnota : pkaz nebo skupina pkaz
      ...
      default : pkaz nebo skupina pkaz
   }


                                  - 64 - 


   Hodnota za pkazem switch je porovnna s hodnotou  prvnho  case. Pokud
odpovdaj, je proveden pkaz nebo skupina pkaz za  prvnm  case, dokud
nen nalezen konec pkazu switch  nebo  speciln  pkaz  break. Jestlie
neodpovdaj, je testovna hodnota nsledujcho case, atd. Kdy neodpovd
dn z hodnot, provd se pkaz nebo skupina pkaz za  default. default
je voliteln. Pokud jej nepotebujete a nen nalezena dn podmnka switch
se neprovd.

   Nsledujc pklad je pepisem pedelho programu pomoc switch.

   Nahrejte a spuste INTRO14.C.

*/* INTRO14.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>
#include <conio.h>
#include <ctype.h>

int main()
{
   char cmd;

   printf("Chart desired: Pie  Bar  Scatter  Line  Three-D");
   printf("\nPress first letter of the chart you want: ");
   cmd = toupper(getch());
   printf("\n");

   switch (cmd)
   {
      case 'P': printf("Doing pie chart\n"); break;
      case 'B': printf("Doing bar chart\n"); break;
      case 'S': printf("Doing scatter chart\n"); break;
      case 'L': printf("Doing line chart\n"); break;
      case 'T': printf("Doing 3-D chart\n"); break;
      default : printf("Invalid choice.\n");
   }

   return 0;
}


   Pkaz break na konci kadho case je velmi dleit. Zpsobuje  skok na
konec pkazu switch.

   Urit chcete vdt, co se stane, kdy se odstran z jednoho case pkaz
break. Zkuste vymazat break z konce volby case 'L' a znovu spuste program.
Pokud vyberete L, vype se :

   Doing line chart
   Doing 3-D chart

   Jsou  provedeny pkazy jak pro L, tak pro  T.  Jinmi  slovy,  jestlie
odstrante break, provd  se  pkazy  a  do  nalezen  break  nebo konce
pkazu switch.

   Nkdy  je  takov  chovn  uiten.  Pedpokldejme,  e  chcete,  aby
uivatel vaeho programu  pouval  jak  D  (ruen),  tak  E  (mazn) pro
zruen jistho souboru. Toto je mono napsat takto :

   switch (cmd)


                                  - 65 - 


   {
      case 'I': insert_file(); break;
      case 'F': format_file(current_file); break
      case 'D':
      case 'E': erase_file(current_file);
   }

   Protoe pro case 'D'  nen  uito break, pro mazn souboru bude pouito
erase_file, stejn jako v case 'E'.



---------------------------------------------------------------------------
Opakovan provdn pomoc smyek
---------------------------------------------------------------------------


   Jednm z vznamnch  rys  if,  else  a  switch je to, e test provdj
pouze jednou. Avak mnoh programy obsahuj  opakovn,  zahrnuj instrukce
jako  "opakuj  stejn  proces pro kadou poloku souboru dokud nen nalezen
konec souboru" nebo "opakuj stejn  proces pro kadou poloku mnoiny dat".
Pro tento druh  loh  je  vhodn  pout smyku. Smyka opakuje pkaz nebo
skupinu pkaz a zrove pracuje se speciln podmnku, aby vdla, kdy m
skonit innost. C jazyk obsahuje ti druhy smyek : while, do, a for.


Smyka while
---------------------------------------------------------------------------

   Smyka while provd jeden nebo vce pkaz do t doby, ne  je splnna
podmnka. Syntaxe je tato :

   while(podmnka)
      pkaz nebo skupina pkaz;

   Nsledujc program poaduje vstup sel z  klvesnice.  Provd celkov
souet. Kdy vlote nulu, vype souet a prmr vloench sel.

   Nahrejte a spuste INTRO15.C.

*/* INTRO15.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char inbuf[130];
   int  number;            /* Number entered by user */
   int  total = 0;         /* Total of numbers entered so far */
   int  count = 1;         /* Count of numbers entered */

   printf("Enter 0 to quit\n");
   /* Priming statement puts a value into number */
   gets(inbuf);
   sscanf(inbuf, "%d", &number);

   while (number != 0)
   {
      total += number;
      gets(inbuf);


                                  - 66 - 


      sscanf(inbuf, "%d", &number);
      if(number == 0)
         printf("Thank you. Ending routine.\n");
      else count++;
   }
   printf("Total is %d\n", total);
   printf("Average is %d\n", total / count);

   return 0;
}


   Kdy je nateno slo,  je  testovno pkazem while. Do doby, ne slo
je 0, se provdj ti kony :

    o  slo, kter se prv naetlo, je piteno do total.

    o  Nov slo se nate funkc sscanf.

    o  Toto slo je testovno.  Pokud  je  rzn  od nuly, poet vloench
       sel se zvt o jedniku.


Smyka do while
---------------------------------------------------------------------------

   Smyka do while je velmi podobn smyce while. M tuto syntaxi :

   do pkaz nebo skupina pkaz
   while (podmnka je splnna)

   Pozor !

   Jak je rozdl mezi smykami do while a while ?

    o  Smyka while nejprve  provd  test,  pkazy  jsou  realizovny jen
       tehdy, kdy je podmnka splnna.

    o  Smyka do while  nejprve  provede  pkazy  a  a  pot  testuje. To
       znamen, e pkazy se provedou vdy, i kdy je podmnka nepravdiv.

   Vhodnou situac pro pouit smyky  do while je realizace menu. Dvj
menu  mly  ten  nedostatek, e se  provedly  pouze  jednou,  pot  program
nekompromisn skonil. Jinm zpsobem, jak eit problm menu je tento :

   Nahrejte a spuste INTRO16.C.

*/* INTRO16.C--Example from Chapter 4 of Getting Started */

#include <conio.h>
#include <ctype.h>
#include <stdio.h>

int main()
{
   char cmd;

   do {
      printf("Chart desired: Pie  Bar  Scatter  Line  Three-D  Exit");
      printf("\nPress first letter of the chart you want: ");


                                  - 67 - 


      cmd = toupper(getch());
      printf("\n");

      switch (cmd)
      {
         case 'P': printf("Doing pie chart\n"); break;
         case 'B': printf("Doing bar chart\n"); break;
         case 'S': printf("Doing scatter chart\n"); break;
         case 'L': printf("Doing line chart\n"); break;
         case 'T': printf("Doing 3-D chart\n"); break;
         case 'E': break;
         default : printf("Invalid choice. Try again\n");
      }
   } while (cmd != 'E');

   return 0;
}


   Co se zmnilo? Aktivn st programu vetn pkaz, kter vypisuj menu
a  nataj  znak  a dle pkaz switch, je uzavena do  smyky  do  while.
Pidan volba E umouje uivateli ukoit bh programu. Tento case obsahuje
pouze  break.  Pokud  je  naten  jin znak (vetn nesprvnho), je  znovu
zobrazeno  menu. Jestlie je ale nateno E (nebo e), podmnka cmd != 'E' je
nepravdiv a vysko se ze smyky. Program ukon innost.


Smyka for
---------------------------------------------------------------------------

   Smyka for prochz sekvenc  hodnot  a pro kadou z nich provd urit
kon. Syntaxe je tato :

   for(poten hodnoty; podmnka; zmny)
   {
      pkaz nebo skupina pkaz;
   }

   Nsledujc smyka for vypisuje viditeln znaky z mnoiny znak PC.

   Nahrejte a spuste INTRO17.C.

*/* INTRO17.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int ascii_val;

   for (ascii_val = 32; ascii_val < 256; ascii_val++)
   {
      printf("\t%c", ascii_val);
      if (ascii_val % 9 == 0)
         printf("\n");
   }

   return 0;
}



                                  - 68 - 


   Promnn ascii_val je dc promnnou smyky for. Inicializace promnn
je ascii_val = 32. Podmnka ascii_val < 256 je limitem smyky. Zmna dc
promnn  je  realizovna  jako  ascii_val++  (jinmi  slovy  - pi  kadm
prchodu smykou je inkremetovna).

   Pkazy printf  a  if  jsou  uzaveny  v  zvorkch a tvo tlo smyky.
Pkaz printf zobrazuje znak, kter odpovd obsahu ascii_val  a  k vypsn
mezer pouv tabultor  (\t).  Pkaz  if  zajiuje  tisk  na  nov dek
pokad,  kdy ascii_val je dliteln 9 -  jinmi  slovy  zabezpeuje,  aby
kad dek ml devt znak.

   Tma smyka for je dost obshl, existuje mnoho obmn. Tlo  smyky me
obsahovat pouze jedin pkaz  -  v  tomto  ppad jsou zvorky nepovinn,
pouze jsou doporueny kvli pehlednosti.  Smyka for tak nemus mt dn
tlo, pak je tاit prce  soustedno pouze ve zmn kontrolnho pkazu.
Napklad  tato  smyka  st  sla  od  1  do  10.  (Nahrejte a  spuste
INTRO18.C.)

*/* INTRO18.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int number, total;
   for (number = 1, total = 0; number < 11; total += number,
   number++);
   printf("Total of numbers from 1 to 10 is %d\n", total);

   return 0;
}


   Tento  pklad  tak  ukazuje,  e  st potench hodnot a st  zmn
specifikace smyky me obsahovat vce  vraz  oddlench  rkami. Smyka
inicializuje dv promnn, number a total a pak zvtuje number.

   Nkte  programtoi  p  stednk  na  zvltn  dek,  take stoj
samostatn.

   Stednk za uzavrac zvorkou pedstavuje przdn tlo smyky. Pokud je
vynechn, smyka vezme pkaz printf a provd jej opakovan -  povauje ho
za tlo. Smykou for  me  bt  nahrazena  smyka while. Pedchoz pklad
me bt pepsn takto :

   Nahrejte a spuste INTRO19.C.

*/* INTRO19.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int number = 1, total = 0;
   while (number < 11) {
      total += number;
      number++;
   }
   printf("Total of numbers from 1 to 10 is %d\n", total);



                                  - 69 - 


   return 0;
}


   Smyka  while  vykonv  inicializaci  pedtm,  ne  smyka   zan  a
aktualizuje dc promnnou za tlem. Smyka for je  kompaktnj,  ale je
tاko iteln, kdy se uije mezi zvorkami pli mnoho pkaz.


Break a continue
---------------------------------------------------------------------------

   Nkdy  je nezbytn opustit smyku, i kdy  je  podmnka  jet  splnna.
Pkaz break m dvoj vznam: skoit na konec pkazu switch v  ppad, e
byl  proveden  jeden  z case, a okamit vyskoit ze smyek while, do while
nebo  for  bez  toho, e by se  provdl  zbytek  pkaz  v  tle  smyky.
Napklad  pedpokldejme, e nechcete odstartovat raketopln, pokud  svt
kterkoliv varovn svtlo :

   Nahrejte a spuste program INTRO20.C.

*/* INTRO20.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

#define WARNING -1

int get_status(void)
{
   return WARNING;
}

int main()
{
   int count = 10;
   while (count-- > 1)
   {
      if (get_status() == WARNING)
         break;
      printf("%d\n", count);
   }
   if (count == 0)
      printf("Shuttle launched\n");
   else
   {
      printf("Warning received\n");
      printf("Count down held at t - %d", count);
   }

   return 0;
}


   Smyka while  spout  odpotvn,  neustle  kontroluje,  zda  funkce
get_status nevrac -1  (co  je definovno jako WARNING). Pedpokldme, e
tato funkce te varovn  systmu  v  relnm  ase. Pokud get_status vrt
hodnotu -1 kdykoliv bhem odpotvn, pkaz break  odpotvn zastav.
Dal pkaz if kontroluje,  zda  count  nenabyla  hodnoty nula. Pokud ano,
varovn se nevype. Jestlie  count  je  vt  ne nula, odpotvn je
zastaveno a raketopln neodstartuje.


                                  - 70 - 


   Pkaz continue peskakuje stejn jako break  vechny  zbvajc pkazy
ve smyce. Avak zatmco break vyskakuje ze smyky, continue sko  na test
podmnky smyky.

INTRO21.C vypisuje sud sla do deseti :

   Nahrejte a spuste INTRO21.C.
/* INTRO21.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int num = 0;
   while (num++ <= 10)
   {
      if (num % 2 != 0)
         continue;
      printf("%d\n", num);
   }

   return 0;
}


   Pokud slo je lich, pkaz continue peskakuje printf.

   continue se pouv velmi asto. Je tady ovem jeden problm -  je nutno
zvit,  kdy je vhodn pkaz continue a kdy  break.  Pouit  continue  ve
smyce while programu  pro  raketopln nen vhodn, protoe odpotvn by
nebylo vypisovno (pkaz printf je  peskoen), ale promnn count se bude
dle  zmenovat  a  k  nule,  protoe  dekrementace  je soust  podmnky
(count--> 1). Raketopln tedy odstartuje, pestoe je varovn vypsno.


Pkaz goto
---------------------------------------------------------------------------

   Ti, kte um BASIC nebo FORTRAN, znaj dvrn pkaz goto. C jazyk jej
obsahuje tak. Syntaxe :

   goto label,

kde label je identifiktor, kter je svzn s nkterm  pkazem.  Kdy  je
goto  proveden, je pedno zen na oznaen  pkaz.  V  prvnch  verzch
BASICu  byl  pkaz  goto nezbytn, protoe neexistovala  jin  cesta,  jak
vytvoit smyku. V C, kde jsou ti druhy smyek, break  a  use k peskoen
st smyek,  poteba pkazu goto tm odpad. Modern programovn goto
zcela odmt, protoe in program nepehlednm a obtn modifikovatelnm.
Je  toti  velmi  snadn  zapomenout,  pro  se  skkalo  zrovna na tu st
programu. Mimo to toho dn jazyk neobsahuje pkaz wherefrom.


Vnoen smyky
---------------------------------------------------------------------------

   Jeden z pkaz uvnit tla smyky  me  bt jin smyka - tato situace
se nazv vnoen. V nsledujcm ppad smyka while nate etzce, kter
jste zadali a smyka for podtrhne etzec pomlkami.



                                  - 71 - 


   Nahrejte a spuste INTRO22.C.

*/* INTRO22.C--Example from Chapter 4 of Getting Started */

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

int main()
{
   int pos;
   char text [40];

   printf("Type 'end' to quit\n");

   while (strcmp (gets(text), "end") != 0) {
      for (pos = 1; pos <= strlen(text); pos++)
         putch('-');
      printf("\n");
   }

   return 0;
}


   Toto je pklad napsan v kompaktnm stylu zkuench  programtor  v C.
Abyste  vidli, jak pracuje smyka while,  tte  zevnit  ven.  gets(text)
nat vstupn etzec  a  ukld  jej  do textovho pole text. Tato funkce
tak vrac etzec do pkazu, kter ji vyvolv, take me bt porovnn s
"end" pomoc  funkce strcmp, kter porovnv dva etzce. Pokud porovnvn
dv hodnotu 0, etzce jsou idnetick, uivatel napsal end a smyka kon.
V opanm ppad pokrauje smyka while v innosti.  Prvnm  pkazem tla
je dal smyka  for,  kter  vypisuje  poet pomlek, kter je roven dlce
etzce, jen byl pvodn  naten.  Pitom  ke  zjiovn dlky se vyuv
funkce  strlen  .  Pkaz printf, kter je na konci tla smyky umsuje na
dal dek kurzor kvli vstupu .


Vbr vhodn smyky
---------------------------------------------------------------------------

   Seznmili  jste  se se temi druhy smyek.  (while,  do  while  a  for).
Pouijte tu, kter nejlpe vystihuje podstatu programu a  zrove  mjte na
pamti tato pravidla :

    o  Pokud  chcete,  aby  se  tlo  smyky  nikdy  neprovdlo, pokud  je
       podmnka nepravdiv, pouijte smyku while.

    o  Pokud  chcete,  aby  se tlo smyky provedlo  vdy  alespo  jednou,
       pouijte do while.

    o  Jestlie poet prchod smykou je uren promnnou  nebo konstantou,
       je nejlep for.

    o  Pokud  je smyka provdna a do  splnn  nkter  vnj  podmnky
       (nap.  do  t  doby,  dokud  jsou  v  souboru   njak   data),  je
       nejvhodnj while.





                                  - 72 - 


---------------------------------------------------------------------------
Tvorba programu pomoc funkc a maker
---------------------------------------------------------------------------


   Nyn,  kdy  vte,  jak  dit  chod  programu,  je as napsat v C  nco
uitenho.  Povzbudme  vs vytvoenm a  modifikac  nkterch  pklad.
Nkolik malch a jednoduchch  program  u  bylo  popsno, ty ovem pli
strukturalizace  neukzaly.  Pokud  vae  programy  budou   velk   a  vce
veobecn, vyvstane poteba rozdlit  je  na  men,  snze kontrolovateln
logick celky nebo funkce.


Definice uivatelskch funkc
---------------------------------------------------------------------------

   Programy, kter jste  vidli,  jsou njak rozdleny. Kdy zavolte gets,
puts nebo strcmp, nemuste se o prci tchto funkc starat. Tyto  a dalch
400  funkc je definovno a zkompilovno v knihovn  Turbo  C++.  K  jejich
vyuit je  nutno pouze zalenit odpovdajc hlavikov soubor do programu
a  zkontrolovat  pomoc  spaen  npovdy  nebo  v  kapitole 1  "Run-time
knihovna"  v Uivatelsk pruce, zda dan funkce  opravdu  vrac  to,  co
potebujete.

   Je ovem mono  pst  tak  sv  vlastn  funkce. K tomu je teba uloit
program  do  oddlench  sekc (funkc), je kad  provd  jednoduchou  a
pochopitelnou funkci ve vaem programu. Kdy u jste  jednou  deklarovali a
definovali svou funkci, je mono ji z programu volat jako kteroukoliv jinou
funkci z knihovny Turbo C++.


Funkn prototyp

   Funkn prototypy jsou klovm rysem novho standardu ANSI pro C jazyk.
Funkn prototyp je deklarace s touto syntax :

   nvratov_typ jmno_funkce (typ_parametru jmno_parametru...);

   Zde je nkolik pklad :

   Vimnte  si,  e  main, funkce jako takov, mus tak splovat pedpisy
ANSI, e vechny funkce jsou prototypy.

   int main(void)
   float tax(float purchase);
   char get_employee_type(int employee_num);
   char get_choice(void);
   int getch(void);
   void show_menu(void);

   Pi  prvnm  pohledu  na prototyp mete pesn ci, jak typ informace
funkce oekv a jak typ vrac

   Podvejme se na tax. Kdy je volna, je nutno j pedat slo v plovouc
adov rce. Vsledek bude  stejnho  typu. O tom vem informuje Turbo C++
prototyp.

   Jednm z dalch dve pouitch prototyp je void. void znamen przdn
nebo dn. Pokud  se  slovo  void  vyskytne  v  zvorkch  namsto seznamu
parametr,  znamen  to,  e  funkce  nem dn parametry. Proto, kdy  se


                                  - 73 - 


pokuste pout pkaz show_menu(10), jste informovni,  e  show_menu nem
dn parametry. Pokud se  void  vyskytne v nvratovm typu, znamen to, e
funkce nevrac dnou hodnotu - take nen mono piadit hodnotu  z voln
funkce promnn.


Funkn deklarace podle Kernighana a Ritchieho.

   Doporuujeme vm, abyste prototypy ve svm programu pouvali.

   Ve star  definici Kernighana a Ritchieho existoval nvratov typ funkce
jen  tehdy,  kdy  nebyl int. Jednodue - parametry funkc byly deklarovny
uvnit tla definice funkce v seznamu  parametr.  Funkce get_employee_type
by v tomto starm stylu byla deklarovna takto:

   char get_employee_type();

   Definice funkce vypadala takto :

   char get_employee_type(employee_num)
   int employee_num;
   {
      /* tlo funkce */
   }

   Funkce napsan starm zpsobem  Turbo  C++  kompiluje tak. Obsahuj ale
mn informac o  funknch  parametrech, take chyby vznikl chybnm typem
parametru pi voln funkce nemohou bt detekovny automaticky. Je to jeden
z mnoha dvod, pro byl star zpsob nahrazen ANSI standardem.


Definice funkce

   V definici funkce je  obsaeno  jdro  toho,  co funkce provd. Syntaxe
hlaviky  funkce  je  pesn  stejn  jako  deklarace  funkce, jen  nekon
stednkem.  Za  n  nsleduj  deklarace  loklnch promnnch a  dky  s
vlastnmi realizanmi pkazy uzavenmi v zvorkch.

   float tax(float purchase)
   {
      float tax_rate = 0.065;
      return(purchase * tax_rate);
   }

Kd uvnit funkce

   Funkce bere  sv parametry jako deklarovan promnn danch typ. Funkce
tax m tedy pstup ke dvma  promnnm:  k parametru purchase typu float a
ke sv vlastn promnn  tax_rate,  jen je tak typu float. Pokud napete
tax(amount),  je  to  kopie hodnoty amount, kterou funkce tax obdr pomoc
parametru purchase. S touto hodnotou operuje funkce pod  jmnem  purchase a
me tak mnit pouze jej hodnotu.  To  ale nem vliv na pvodn promnnou
amount.  Pozdji  vm  ukeme,  jak  je  mono  mnit  hodnoty  takovchto
promnnch pomoc ukazatel.








                                  - 74 - 


Hodnota, kterou funkce vrac

   Pokud  funkce  nevrac  dnou  hodnotu,  mli  byste   deklarovat  jej
nvratov  typ jako void. K nvratu na msto  odkud  byla  volna,  pouv
funkce pkaz return (jako nap. ve funkci tax, kde  nvratov  hodnota  je
purchase  * tax_rate). Nsledujc obrzek shrnuje tok  informac  do  a  z
funkce tax.

                                     Ŀ
                                      /"deklarace funkce"/          
Hodnota promnn amount je            float tax(float purchase)     
piazena odpovdajcmu              ...                           
parametru purchase.                   /"pkaz voln"/             
                                      tax_amt =  tax(amount);       
                                     
                                     Ŀ
Nyn je hodnota pouiteln            return(purchase * tax_rate);  
ve funkci tax pod jmnem purchase.   

Pkaz return vrac zpt vypotanou   Ŀ
hodnotu do volajcho pkazu, kde se   tax_amt = tax(amount);      
j nahrad voln funkce tax(amount).  

Ve volajcm pkazu je hodnota,     Ŀ
kter se vrtila, piazena           tax_amt = (vrcen hodnota)   
promnn tax_amt.                    

                 Obr. 4.3: Tok informac do a z funkce tax


Pouit hodnoty, kterou funkce vrac.

   Hodnota,  kterou  funkce  vrac, me bt pouita  jako  jakkoliv  jin
hodnota ve vrazu. Je mono ji  kombinovat  ve vrazu s jinmi promnnmi a
aritmetickmi opertory. Me bt st podmnky pkazu if nebo smyky, je
mono ji piadit promnn atd. Zde je uvedeno nkolik pklad pouit:

   tax_amt = tax(purchase);
   if (get_status() == WARNING)
   while (strcmp(gets(text), "end") != 0)

   V  prvnm  pklad  je hodnota vracen funkc  tax  piazena  promnn
tax_amt.  Ve  druhm  ppad  hodnota  vrcen  po  voln  get_status  je
porovnna  s  definovanou hodnotou WARNING;  vsledek  uruje  pravdivostn
hodnotu pkazu if. V  poslednm  ppad  je  hodnota vrcen gets pedna
funkci strcmp (spolu s etzcem "end") a vsledek voln strcmp je porovnn
s nulou. Toto ve pedstavuje podmnku smyky while.


Programy s vce funkcemi
---------------------------------------------------------------------------

Nsledujc  program  kresl  st  slunen  soustavy.  Ilustruje  pouit
nkterch  funkc  definovanch uivatelem a  nkter  vlastnosti  grafick
knihovny  Turbo C++. (Informace o pouit grafiky v  Turbo  C++  najdete  v
kapitole 5, "Video funkce" v Programtorsk pruce.)

   Ujistte se, e v argumentu initgraph je nastavena cesta do podadrese,
kde jsou umstny soubory .BGI.



                                  - 75 - 


   Jak u bylo eeno, program poaduje ptomnost karty EGA nebo  VGA, ale
sten toleruje i verze CGA s men rozliovac schopnost, pokud zmnte
nkter konstanty barev.

   Vpis programu zahrnuje  funkn prototypy, globln deklarace, definici
main a definice  rznch  jinch  funkc.  Tento program je na disku uloen
jako PLANETS.C.

   Po  peten  komente  k  tomuto  programu  jej   zkuste  modifikovat.
Podvejte  se   do  grafick  knihovny.  Vyzkouejte  jin  barvy  a  styly
vyplovn. Experimentujte s promnnmi pro vzdlenosti a polomry krunic.


*/* PLANETS.C--Example from chapters 4 and 7 of Getting Started */

#include <graphics.h>           /* For graphics library functions */
#include <stdlib.h>             /* For exit() */
#include <stdio.h>
#include <conio.h>

int set_graph(void);            /* Initialize graphics */
void calc_coords(void);         /* Scale distances onscreen */
void draw_planets(void);        /* Draw and fill planet circles */

/* Draw one planet circle */
void draw_planet(float x_pos, float radius,
                 int color, int fill_style);
void get_key(void);         /* Display text on graphics screen, */
                            /* wait for key */

/* Global variables -- set by calc_coords() */
int max_x, max_y;           /* Maximum x- and y-coordinates */
int y_org;                  /* Y-coordinate for all drawings */
int au1;                    /* One astronomical unit in pixels
                               (inner planets) */
int au2;                    /* One astronomical unit in pixels
                               (outer planets) */
int erad;                   /* One earth radius in pixels */

int main()
{
   /* Exit if not EGA or VGA */
   /* Find out if they have what it takes */
   if (set_graph() != 1) {
      printf("This program requires EGA or VGA graphics\n");
      exit(0);
   }
   calc_coords();       /* Scale to graphics resolution in use */
   draw_planets();      /* Sun through Uranus (no room for others) */
   get_key();           /* Display message and wait for key press */
   closegraph();        /* Close graphics system */

   return 0;
}

int set_graph(void)
{
   int graphdriver = DETECT, graphmode, error_code;

   /* Initialize graphics system; must be EGA or VGA */


                                  - 76 - 


   initgraph(&graphdriver, &graphmode, "..\\bgi");
   error_code = graphresult();
   if (error_code != grOk)
      return(-1);               /* No graphics hardware found */
   if ((graphdriver != EGA) && (graphdriver != VGA))
   {
      closegraph();
      return 0;
   }
   return(1);                   /* Graphics OK, so return "true" */
}

void calc_coords(void)
{
   /* Set global variables for drawing */
   max_x = getmaxx();           /* Returns maximum x-coordinate */
   max_y = getmaxy();           /* Returns maximum y-coordinate */
   y_org = max_y / 2;           /* Set Y coord for all objects */
   erad = max_x  / 200;         /* One earth radius in pixels */
   au1 = erad * 20;             /* Scale for inner planets */
   au2 = erad * 10;             /* scale for outer planets */
}

void draw_planets()
{
   /* Each call specifies x-coordinate in au, radius, and color */
   /* arc of Sun */
   draw_planet(-90, 100, EGA_YELLOW, EMPTY_FILL);
   /* Mercury */
   draw_planet(0.4 * au1, 0.4 * erad, EGA_BROWN, LTBKSLASH_FILL);
   /* Venus */
   draw_planet(0.7 * au1, 1.0 * erad, EGA_WHITE, SOLID_FILL);
   /* Earth */
   draw_planet(1.0 * au1, 1.0 * erad, EGA_LIGHTBLUE, SOLID_FILL);
   /* Mars */
   draw_planet(1.5 * au1, 0.4 * erad, EGA_LIGHTRED, CLOSE_DOT_FILL);
   /* Jupiter */
   draw_planet(5.2 * au2, 11.2 * erad, EGA_WHITE, LINE_FILL);
   /* Saturn */
   draw_planet(9.5 * au2, 9.4 * erad, EGA_LIGHTGREEN, LINE_FILL);
   /* Uranus */
   draw_planet(19.2 * au2, 4.2 * erad, EGA_GREEN, LINE_FILL);
}

void draw_planet(float x_pos, float radius, int color, int fill_style)
{
   setcolor (color);                /* This becomes drawing color */
   circle(x_pos, y_org, radius);    /* Draw the circle */
   setfillstyle(fill_style, color); /* Set pattern to fill interior */
   floodfill(x_pos, y_org, color);  /* Fill the circle */
}

void get_key(void)
{
   outtextxy(50, max_y - 20, "Press any key to exit");
   getch();
}





                                  - 77 - 


Funkn prototypy a globln deklarace

   Tento  program  vol   pt  funkc  definovanch  programtorem.  Jejich
deklarace  jsou  hned  za pkazem #include. Deklarace mohou bt kdekoliv v
programu,  ale  pak  nen pehled o pouitch prototypech. Je jednodu je
zaadit hned na zatek.  Prototypy  funkc void a non-int mus bt uvedeny
jet ped prvnm volnm tchto funkc.

   Globln  promnn  obsahuj  informace,  je  jsou  teba  k vykreslen
planet.  jejich  hodnoty  jsou  potny  funkc calc_coords a  vyuv  je
draw_planets.  Tm,  e  jsou  globln  (lep, ne je  deklarovat  uvnit
funkce), jsou dostupn vem funkcm , kter je  potebuj.  Pozdji uvedeme
jet jin zpsob, jak se sdlej promnn mezi dvma funkcemi.


Nastaven grafick obrazovky

   Funkce main jako prvn zavol set_graph, kter obsahuje mnostv operac
z grafick  knihovny Turbo C++. set_graph vyuv knihovn funkce initgraph
s mdem DETECT, kter automaticky uruje, jak typ  grafickho  hardware je
pouit. Vinmte si  vce  pkaz  return  - funkce me mt tolik pkaz
return,  kolik  je  teba. Prvn pkaz  if  zjiuje,  jestli  byla  bhem
inicializace grafickho systmu nalezena  njak  chyba  (jestlie hodnota,
kter  se  vrac  je rzn od grOk ("graphics OK"), funkce ukon innost s
chybou). Druh test  vrac  chybovou  zprvu,  jestlie dn z EGA ani VGA
karet nen k  dispozici.  Druhm  testem  se prochz jen tehdy, kdy prvn
dopadl spn. Vcensobn  pouit  pkazu return umouje obejt se bez
else.

   Identifiktory DETECT a  grOk  nejsou nikde v programu deklarovny. Jsou
to definovan  konstanty  z  hlavikovho  souboru  graphics.h.  Hlavikov
soubory obsahuj spolu s funknmi  prototypy  nejvce  pouvan definice,
kter se daj  vyut  v uivatelskch programech. Doporuujeme vm, abyste
nahldli do graphics.h a  jinch  asto  pouvanch hlavikovch soubor a
seznmili se s jejich obsahem. V graphics.h jsou definovny vechnu barvy a
monosti  vyplovn.  Kadmu  identifiktoru  je   piazena  celoseln
hodnota, ale pouit symbolickho jmna je vhodnj. (BLACK je vstinj
ne 0.)

   main kontroluje hodnotu,  kterou  vrac set_graph. Pokud je vrcena jin
hodnota ne 1, program vype chybu a skon innost.


Vpoet grafickch souadnic

   Pokud  je  ve   v   podku,  zavol  se  finkce  calc_coords.  Vtina
zanajcch  programtor  si  mysl,  e  rozmry  grafick  obrazovky ve
smrech x a y, tak, jak  je  definuje  jejich grafick adaptr (nap. 640 x
350 pro EGA), jsou nemnn. Svd to k pevnmu zabudovn tchto rozmr do
vlastnho programu. Pi sputn programu  na  potai  s  jinou grafickou
kartou  a jinou paletou barev pak vzniknou pote.  V  kapitole  5,  "Video
funkce"  v  Programtorsk  pruce  je  popsno, jak je  pomoc  grafick
knihovny mono pouvat vmi napsan programy na irokm spektru grafickch
adaptr.

   K  tomuto  vemu  napomhaj grafick funkce getmaxx  a  getmaxy,  kter
vracej nejvt x-ovou a y-ovou  souadnici  nastavenho  grafickho mdu.
(Je nastavovn initgraph.) Zbyl pkazy :




                                  - 78 - 


    o  uruj sted planetrnho systmu tm,  e  maximln  hodnota  y se
       vydl dvma.

    o  potaj planetrn polomr  Zem  (co dl unit, kter vysluje i
       polomr pro jin  planety)  jako  1/200  ky  obrazovky (maximln
       hodnoty x).

    o  uruj dv  vzdlenosti sted krunic na ose x. Protoe vzdlenosti
       ve slunenm systmu za planetou Mars prudce rostou, je pouito jin
       mtko  pro  vnitn  a vnj planety. Dsledek je ten, e obrzek
       nen  v  mtku,  i kdy ukazuje relativn velikosti planet. (Je to
       zpsobeno velikost obrazovky, nen  mon  mt  oboje  najednou.) Z
       toho samho dvodu jsou vynechny Neptun a Pluto.

Kreslen planet

   Funkce  draw_planets  nkolikrt  vol  funkci  draw_planet,  v  n  je
soustedno tاit innosti. draw_planet potebuje tyi parametry: x_pos,
radius, color a fill_style.

    o  x_pos je x-ov souadnice stedu planetrn krunice.  Je vypotna
       vynsobenm  jednotkou  vzdlenosti  (au1  nebo  au2),  a  vyjaduje
       vzdlenost planetrn drhy od  Slunce  vyjdenou  v astronomickch
       jednotkch.  (Astronomick  jednotka  je  vzdlenost Zem od Slunce,
       piblin 93 milin mil - co je asi 149 mil. km - pozn. pekl.)

    o  radius je  polomr  planety.  Je  vypotn  vynsobenm  skutenho
       polomru planety v jednotkch polomru Zem (kolem 4000  mil  = 6378
       km - pozn. pekl.) promnnou erad, v kter je uloen polomr  Zem v
       bodech obrazovky (pixel).

    o  color je konstanta z graphic.h, kter uruje barvu krunice (i barvu
       vuplovn) z odpovdajc palety EGA (pracuje i pro VGA).

    o  fill_style je  konstanta z graphics.h, kter uruje vzor, jakm bude
       krunice vyplnna.

   draw_planet pevezme tyto parametry a  vyvol  rutiny  grafick knihovny
Turbo C++, kter nakresl a vypln krunici. Vimnte si. e  souadnice y,
kterou potebuje circle a floodfill  nemus bt dna jako parametr. Protoe
je pevn, je pouito hodnoty y-org vypotan pedem calc_coords.

   get_key pouv k vpisu zprvy  funkce  knihovn  funkce  outtext. Pot
zavol  getch, kter ek na stisk jakkoliv  klvesy,  aby  mohla  ukonit
program.


Hlavikov soubory, funkce a knihovny
---------------------------------------------------------------------------

   V malch programech se  obvykle  definuj a deklaruj funkce v tom samm
souboru i s funkc main, kter shrnuje ve dohromady. Takovto struktura je
ukzna v nsledujcm obrzku.









                                  - 79 - 


                         Ŀ
                          include                
                          define                 
/*funkn deklarace*/   
popis vlastnch funkc    void menu(void);        
 ...                     
                          /*Globln data*/       
                          ...                     
main ()                 
               funkn    {                       
               voln      /*hlavn program vetnس
  voln funkc*/       
                          }                       
 /*definice funkce(kd)*/
                          void menu(void)         
      definice vlastnho                          
         tla funkce       /*kd funkce menu*/    
      (toho, co m funkce                         
           vykonvat)      *Definice dalch fc*/
 ...                     
                         

         Obr. 4.4: Jednoduch programov struktura (ve v jednom)

   Hlavikov soubory obsahuj obvykle  pouze  deklarace  funkc,  take je
mono je vyut ve vce zdrojovch souborech nebo modulech.

   m je program vt, tm je vhodnj mt  skupinu  'pbuznch' funkc
uloenu v oddlenm souboru. Napklad funkce mnc  uivatelsk prosted
je mono uloit do jednoho souboru, funkce zpracovvajc data do  jinho a
funkce pracujc s  grafikou  do  tetho.  Turbo C++ um peloit a spojit
vechny ti soubory do jednoho  konenho programu. Tento druh struktury je
znzornn v nsledujcm obrzku.





























                                  - 80 - 


Hlavn program
                            Ŀ
                             include             
                             define              
                             ...                  
                             int main(void)       
                             {                    
                             /*hlavn program*/   
                             ...                  
                             }                    
                            

                                  Podprogramy
                           (soubory kompilovan zvl)
                   Ŀ
                                                             
  Menu - modul 1             Grafika - modul 2         Kalkulace - modul 3
 Ŀ    Ŀ    Ŀ
 /*menu.c*/              /*graf.c*/               /*kalk.c*/         
 /*deklarace funkc*/    /*deklarace funkc*/     /*deklarace fc  */
 void menu(void);        void bar_graph(int_);    float rate_of_ret_;
 ...                     ...                      ...                
 /*funkn definice*/    /*deklarace funkc*/     /*deklarace fc  */
 void menu(void);        void bar_graph(int_);    float rate_of_ret; 
 { ...                   { ....                   {...               
   }                      }                        }                 
         

              Obr. 4.5: Program vytvoen z nkolika soubor

   #include "header.h" je mono nahradit deklaracemi funkc.
   Kdy  u  jsou  sti  programu  hotov a nemnn, je mono  zkompilovat
skupiny funkc do knihoven.  Deklarace  funkc  v  kad knihovn mohou bt
uvedeny v hlavikovm souboru, take je mono je pout jako knihoven Turbo
C++. Hlavn program pak nate  hlavikov soubory a vlo funkn deklarace
do textu programu. Po  kompilaci  spojovac  program pilinkuje knihovny do
vslednho kdu. Tento proces je znzornn v nsledujcm obrzku.

























                                  - 81 - 


 Hlavik.soubor               Hlavn program
Ŀ             Ŀ
menu.h       Ŀ       include ....          Ŀ
/*deklarace*/             include ....    > Kompiltor 
      > include menu.h        
Ŀ            include graf.h              
 graf.c        > include kalk.h              
 /*deklarace*/             ...                  vĿ
     > int main(void)        peloen kd  
Ŀ           {                     funkce main    
 kalk.c                ....               
 /*deklarace*/             }               
           

 pedkompilovan knihovny
  Ŀ
    menu.lib  Ŀ
                
        Ŀ         >Ŀ
          graf.lib >  Linker  
                   >
  Ŀ                                               Ŀ
   kalk.lib                > .EXE  
                                                   

           Obr. 4.6: Program, kter pouv uivatelsk knihovny

Rozsah platnosti a doba trvn promnnch
---------------------------------------------------------------------------

   Jak se program komplikuje, vyvstv otzka pstupu k promnnm v jinch
stech programu. Kad promnn m dv charakteristiky: rozsah platnosti a
dobu  trvn   (scope  a  duration).  Rozsah  platnosti  (nkdy  se  nazv
viditelnost - visibility) definuje,  kter  sti  programu maj k promnn
pstup. Doba trvn uruje, jak dlouho zstv promnn pstupn.


Rozsah platnosti

   Rozsah platnosti je uren tm,  kde  je  promnn  deklarovna. Promnn
definovan uvnit funkce  je  lokln  -  je pstupn pouze v dan funkci.
Pklad je uveden v tomto programu:

Nahrejte a spuste INTRO23.C.

*/* INTRO23.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

void showval(void);

int main()
{
   int mainvar = 100;
   showval();
   printf("%d\n", funcvar);

   return 0;
}



                                  - 82 - 


void showval(void)
{
   int funcvar = 10;
   printf("%d\n", funcvar);
   printf("%d\n", mainvar);
}


   Funkce  showval uv k vypsn hodnoty funcvar  pkaz  printf  .To  je
sprvn, protoe funcvar je deklarovna a definovna uvnit funkce showval.
Nsledujc pkaz, kter  se  pokou vypsat hodnotu mainvar zpsob chybu
pi kompilaci (vype se chybov zprva) - mainvar  je  nedefinovna. Stalo
se tak proto, e mainvar je definovna uvnit  jin  funkce,  je  m jmno
main. Nen z showval pstupn.

   Po  oeten  tohoto  ppadu  a  nvratu z funkce showval, zkou  main
vypsat hodnotu funcvar. Tak toto zpsob zobrazen chybov zprvy, protoe
funcvar je definovna v showval.

   K tomu, aby promnn byla pstupn z jakkoliv funkce v  danm souboru,
je teba ji definovat  mimo  definici  kterkoliv  funkce. Bude viditeln z
pozice  zdrojovho souboru, kde je deklarovna.  Vhodn  msto  k  definici
globlnch  promnnch  je  ped  zatkem  definice  main.  Kdyby  zatek
pedchozho pkladu vypadal takto:

   void showval(void);
   int mainvar, funcvar;,

a deklarace int by byla:

   int mainvar = 100
   a int funcvar = 10,

chyba  by  nenastala.  Nezapomete  vak,  e  promnn,  kter je  odevad
pstupn  je  tak   odevad   zmniteln,   co   me   zavlci  obtn
vyhledvateln chyby. Zmny promnn  zpsobuj  v  tomto  ppad vedlej
efekty.

   Jak bylo eeno, globln promnn jsou pstupn z jakhokoliv souboru.
(Bez  reference extern v jinch souborech  m  globln  promnn  platnost
pouze  v  jednom  souboru - v tom, ve kterm je  deklarovna.)  Pokud  mte
program,  kter  m  vce ne jeden  zdrojov  soubor  a  potebujete,  aby
promnn  byla  dostupn  v  jinm  souboru,  deklarujte  ji v  nm  pomoc
klovho  slova  extern  ("external").  Tedy  pokud  hlavn  soubor main.c
definuje  int  xscale,  je  mono  tuto promnnou "vidt" z jinho  souboru
(nap. stars.c) deklarac

   extern int xscale;.

   Kdy je promnn definovna, je  j pidlena adresa v pamti. Deklarace
extern  pouze  informuje  kompiltor,  e  se  na  extern  promnnou  bude
odkazovat.


Doba trvn

   Bylo by neefektivn, kdyby  se  ve  velkm programu neustle rezervovala
pam؟ pro vechny promnn.  Celkem  vzato  me  bt nkter funkce volna
pouze jednou. Proto promnn deklarovan v definici funkce  jsou  typu auto
(automatic).  Pam؟ je jim vyhrazena tehdy, kdy  je  funkce  vyvolna.  Po


                                  - 83 - 


nvratu  na  msto,  odkud  se  funkce  vol,  je  pam؟ uvolnna pro dal
promnn.

   Obas  je  poteba  tuto vlastnost obejt a vytvoit promnnou, kter je
uloena neustle, i tehdy, kdy funkce, ve kter byla promnn deklarovna,
nen prv provdna. Tuto situaci e klov slovo  static.  Nap. jedna
funkce me potat, kolikrt byla volna.

   Nahrejte a spuste INTRO24.C.

/* INTRO24.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>
#include <conio.h>

void tally(void);

int main()
{
   while ( getch() != 'q')
      tally();

   return 0;
}

void tally(void)
{
   static int called = 0;
   called++;
   printf("Function tally called %d times\n", called);
}

   Pokad,  kdy  smyka  while v main nate pomoc getch jin znak ne q,
zavol  se  tally.  tally zvtuje pi kadm  voln  statickou  promnnou
called. Statick numerick promnn inicializuje C jazyk hodnotou 0.

   Dal  klov  slovo  pouvan  k  deklaraci  je  register.  Pokud  se
vyskytuje u deklarace promnn, pod  kompiltor,  aby  pouil  k uloen
promnn jeden z vnitnch rychlch registr mikroprocesoru msto pomalej
RAM. register je mono vyut pro krtk datov typy, jako jsou car a int.

   Akoliv  modern  kompiltory,  mezi  nا  se  ad  i  Turbo  C++,  um
optimalizovat, take efektivn vyuvaj monosti potae, um tuto vhodu
vyut pouze zkuen programtoi. Nevhodn pouit zpsob zpomalen chodu
programu.  Obvykle je nejlep nechat kompiltor, aby  sm  uril,  kdy  je
teba pout pro  promnnou  registr  procesoru.  Navc  aplikace klovho
slova register nezaruuje, e promnn  bude  v  registru  opravdu uloena.
register pouze navrhuje kompiltoru, aby tak uinil.


Konstanty
---------------------------------------------------------------------------

   Konstanta  je  pevn  hodnota,  kter  se bhem programu  neme  mnit.
Konstanty  se  mohou  definovat  dvma  zpsoby:  klovm  slovem const  a
direktivou #define.

1. Prvn zpsob, jak deklarovat konstanty, je pout v deklaraci klov
   slovo const. Napklad pokud deklarujete



                                  - 84 - 


      const float cm_per_inch = 2.54,

   eknete tm kompiltoru, e tato hodnota se nikdy nezmn. Pokud se
   pokuste piadit j kdekoliv v programu novou hodnotu (vetn
   inkrementace nebo dekrementace pomoc ++ nebo --), vype se chybov
   zprva. Pouit tohoto klovho slova pomh Turbo C++ vyhledat chyby v
   programu.

2. Jin zpsob zalenn konstant do programu je pouit direktivy
   #define. Nkter pklady u byly uvedeny:

      #define RATE 0.065.
   Toto nen deklarace, nbr instrukce pro preprocesor, st Turbo C++,
   kter provd zmny ve zdrojovm kdu jet ped kompilac. V tomto
   ppad je zmna rovna pouit slovnho procesoru k tomu, aby nael
   vechny vskyty promnn RATE a nahradil je znaky 0.065.

      Existuj ppady, kdy pouit const nebo #define je velmi vhodn. V
   obou ppadech je mono jednodue zmnit hodnotu promnn a znovu
   program zkompilovat. const m tu dleitou vhodu, e Turbo C++ v,
   jakho datovho typu promnn je (nap const int). Na druh stran
   #define se me vyskytnout bez problm v nkolika modulech, kdeto
   const float ne.

      Vhoda pouit konstant je ta, e pokud se zmn hodnota promnn, je
   nutno pepsat jen jeden pkaz. Nemus se hledat kad vskyt danho
   sla - tento proces krom toho, e je navn, je monm zdrojem chyb.


Pouit maker k ukryt podrobnost
---------------------------------------------------------------------------

   #define um daleko vce  ne  jednoduchou  substituci. Je mono vytvet
makra, kter stejn jako funkce maj parametry, a vyut je k prav textu.
Napklad :

   Nahrejte a spuste INTRO25.C.

   Programtoi obvykle pro makra uvaj vraz ? :

*/* INTRO25.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

#define EVEN(value) (((value) % 2 == 0) ? (value) : ((value) + 1))

int main()
{
   char inbuf[130];
   int  num;
   printf("Enter a number: ");
   gets(inbuf);
   sscanf(inbuf, "%d", &num);
   printf("\n%d", EVEN(num));

   return 0;
}


   Zvorky navc v definici makra jsou pro vrazy povoleny.


                                  - 85 - 


   V pkaze printf("\n%d", EVEN(num)) bude EVEN(num) nahrazen nsledujcm
textem: ((num) % 2 == 0) ? (num) : ((num) + 1).  Jinmi  slovy,  kdy  se v
zvorkch za EVEN vyskytne  njak  term, nahrad jmno value ve vech jeho
vskytech v ablon. Vsledn vraz vypisuje num tehdy,  kdy  je dlitelno
dvma. ((num) % 2 == 0);, v opanm ppad je lich a je nahrazeno (num) +
1, stane se tak sudm.

   Makro EVEN je mono napsat jako funkci :

   int even (int num)
   {
      return (num % 2 == 0 ? (num) : (num+1));
   }

   Rozdl mezi funkcemi a makry spov v rychlosti a v mst.  Funkce jsou
obvykle men, ale pomalej ne makra.

   Zatmco  makra  a  funkce jsou vyvolvny stejn, zpsob jejich prce je
naprosto odlin. U makra ablona  s vloenou hodnotou nahrad voln makra
ve zdrojovm kdu jet ped kompilac. U funkce je kd funkce zkompilovn,
voln  funkce  je  zaazeno  do  programu,  patin  hodnoty  uloeny  do
zsobnku a teprve pot se funkce zane provdt. Funkce se kompiluje pouze
jednou, nezvisle na potu voln funkce.  Nov  zdrojov kd u maker je do
souboru zaazen vdy, kdy se makro vol.

   Pokud pouijete makro, ujistte se, e nahrazovan hodnota je patinho
typu.

   Makra  pomhaj  uinit  zdrojov  kd  itelnjm,  protoe  nahrazuj
komplikovan  vraz  jednoduchm   nzvem.  Mnostv  "funkc"  v  run-time
knihovn  jsou  makra,  nap.  rutina  pro  urovn  znak isalpha,  kter
kontroluje, jestli  znak  je  prvek  z  abecedy  nebo jestli je to slice,
interpunkn znamnko apod. Doporuujeme  ji  ke  studiu, stejm jako dal
makra obsaen  v hlavikovm souboru ctype.h.



---------------------------------------------------------------------------
Budovn datov struktury
---------------------------------------------------------------------------


   Data se obvykle vyskytuj ve  vtm potu. Napklad je teba sledovat,
kolik hodin tdn odpracuje zamstnanec v letonm roce.  Zde  se vyskytuje
mnoina pbuznch dat stejnho typu (poet hodin bude asi typu  float, aby
zahrnul i zlomky hodiny). C jazyk umouje deklarovat  pole  (array), kter
uchovv  mnoinu homogennch dat. K vaim  obchodnm  zjmm  jet  pat
sledovat mnosv jinch dat o  kadm zamstnanci, jako je napklad jmno,
poet odpracovanch let, plat, oddlen,  atd. Tyto poloky obvykle pat k
sob (vechny vypovdaj o zamstnanci),  ale  jsou  odlinch  typ. Jmna
jsou znakov etzce (pole znak), odpracovan roky mohou bt typu int nebo
float v zvislosti  na  tom,  jestli  je poadovna desetinn st, plat je
pravdpodobn typu  double  (kvli  velmi  dobe  placenm  zamstnancm) a
oddlen me bt etzec nebo seln kd.








                                  - 86 - 


                   Ŀ                   Ŀ
                   ^                   float hours[52];
        array                                         
                        Ŀ
                    0 1 2 3 4  ...    51
                        
                   0  4  8  12 16    ...       208
                     relativn adresy pamti
                                                       Ŀ
                                                       typedef struct {  
        structure                                         char nazev[40];
                                                          int dept_no;   
                                                          float rate;    
                                                          float hours;   
                                                        } employee;      
                     nazev[40]                         
                  ¿
                  
                  0 ....                        ... 39 42  46  49
                        relativn adresy pamti

               Obr. 4.7: Dva zpsoby sdruovn mnoiny dat

   Rzn sti struktury mohou bt uloeny v rznch stech pamti, nemus
pedstavovat vdy jeden celek.

   K dobr organizaci dat tak pat snadn pstup k jakkoliv  poloce se
kterou chcete pracovat. Protoe  vechna  tato  data  jsou uloena v jednom
adresovm bloku pamti (jako teba adresa domu v ulici), je  mono pracovat
s daty pomoc adres. V tto sti se naume pouvat  pro  pstup k datm
ukazatele.



---------------------------------------------------------------------------
Deklarace a inicializace pole
---------------------------------------------------------------------------


   Pole je st pamti, kter umouje uchovat skupinu  dat  stejnho typu.
Napklad  pole  typu int uchov dan poet  celch  sel  v  jedn  sti
pamti.  Pole se specifikuje urenm typu ukldanch  dat,  jmnem  pole  a
potem uloench poloek; tento poet je uzaven v hranatch zvorkch:

   type jmno[velikost];

   Nsleduje je pklad  deklarace  pole,  kter  umouje  uchovat celkov
poet hodin za jeden tden pro cel rok:

   float hours[52];,

co se te jako "hours, pole 52 hodnot typu float".

   Pole zanaj  indexem  0  a  kon na mst o 1 menm ne je piazen
velikost.

   Na jednu poloku pole je mono se odkzat jmnem pole za  nm nsleduje
pozice  poloky v zvorkch. Prvn poloka je uloena  na  adrese,  je  je
uloena v samotnm jmnu pole. To me bt povaovno za pozici 0. Proto je



                                  - 87 - 


mono se na celkov souet pro prvn tden odkzat hours[0]. Celkov souet
pro dest tden je v poloce hours[9] a pro 52. tden v poloce hours[51].

   Nsledujc  program  inicializuje  pole  hours  hodnotou  0,  piazuje
hodnoty prvnm tyem polokm, pak je vypisuje a zrove ukazuje pstup k
nim.

   Nahrejte a spuste INTRO26.C.

/* INTRO26.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   float hours[52];
   int week;

   /* Initialize the array */
   for (week = 0; week < 52; week++)
      hours[week] = 0;

   /* Store four values in array */
   hours[0] = 32.5;
   hours[1] = 44.0;
   hours[2] = 40.5;
   hours[3] = 38.0;

   /* Retrieve values and show their addresses */
   printf("Elements\t\tValue\tAddress\n");
   for (week = 0; week < 4; week++)
      printf("hours[%d]\t\t%3.1f\t%p\n", week, hours[week],
             &hours[week]);

   return 0;
}

vsledky vypadaj takto :

poloka             hodnota   adresa
hours[0]            32.5      FF0E
hours[1]            44.0      FF12
hours[2]            40.5      FF16
hours[3]            38.0      FF1A

   Adresy jsou zvisl na potai a li se ppad od ppadu.

   Vimnte  si,  e  poloky jsou uloeny v po sob jdoucch adresch ve 4
oddlench bytech (co je koneckonc dlka single float). Adresov opertor
& vrac adresu dan poloky. Specifikace %p funkce printf vypisuje adresu v
hexadecimlnm tvaru. Pkaz for je konvenn smyka pro prochzen poloek
pole.

   Pole je mono  v  okamiku jeho deklarace inicializovat. Inicializace se
provd tak,  e  se  hodnoty,  je  se  maj piadit, umst do sloench
zvorek a oddl se rkami. Nap. :

   int quarters[4] - {3, 10, 7, 14};




                                  - 88 - 


me  obsahovat  body  dosaen  mustvem  za  jednu  tvrtinu  hrac  doby
americkho  fotbalu. (Je jasn, e takovto data  jsou  obvykle  natena  z
klvesnice nebo ze souboru.  Toto  explicitn  piazen  je ale vhodn pro
testovn programu.)

   Pokud se piazuj znakov konstanty, kad se vkld do apostrof:

   char grades[5] = { 'A', 'B', 'C', 'D', 'F'};

   Pokud  vlote  mn  dat  ne  je  dlka  pole a pole je globln  nebo
statick, Turbo C++ napln zbytek  poloek nulami (pokud je pole numerick)
nebo  przdnmi  znaky  (v ppad znakovho pole). Pokud vlote vce dat,
ne  je  stanoven  dlka  pole,  vype  se  chybov   zprva   "Too  many
initializers" (Pli mnoho inicializanch hodnot).

   Pole maj  jet  dal  monosti,  ne  je  uvedeno zde (nap. je mono
vynechat velikost pole nebo  inicializovat  znakov  pole  pomoc etzce).
Tyto schopnosti ale vybouj z rmce tto kapitoly.


Vcerozmrn pole
---------------------------------------------------------------------------

   Nkdy je vhodn mt  mnoinu  mnoin  dat  - napklad kdy potebujete
uchovat  hodiny  odpracovan  12  zamstnanci  bhem  52  tdn,  je  mono
deklarovat

   float hours[12][52];.

   tte to jako  "pole  obsahujc  12  pol,  z nich kad m 52 hodnot,
vechny typu float". Mete si to pedstavit jako tabulku o 12  sloupcch a
52 dcch.

   Nsledujc hra  generuje  fiktivn  basebalov  skre  s  pouitm pole
scoreboard[2][9] pedstavujc dva tmy a jejich skre pro devt ppad.

   Nahrejte a spuste GAME.C.

*/* GAME.C--Example from Chapter 4 of Getting Started */

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

#define DODGERS 0
#define GIANTS 1

void main(void)
{
   int scoreboard [2][9];    /* An array two rows by nine columns */
   int team, inning;
   int score, total;

   randomize();              /* Initialize random number generator */

   /* Generate the scores */
   for (team = DODGERS; team <= GIANTS; team++) {
      for (inning = 0; inning < 9; inning++) {
         score = random(3);


                                  - 89 - 


         if (score == 2)     /* 1/3 chance to score at least a run */
            score = random(3) + 1;   /* 1 to 3 runs */
         if (score == 3)
            score = random(7) + 1;   /* Simulates chance of a big
                                        inning of 1 to 7 runs */
         scoreboard[team][inning] = score;
      }
   }

   /* Print the scores */
   printf("\nInning\t1   2   3   4   5   6   7   8   9   Total\n");
   printf("Dodgers\t");
   total = 0;
   for (inning = 0; inning <= 8; inning++) {
      score = scoreboard[DODGERS][inning];
      total += score;
      printf("%d   ", score);
   }
   printf("   %d", total);

   printf("\nGiants\t");
   total = 0;
   for (inning = 0; inning < 9; inning++) {
      score = scoreboard[GIANTS][inning];
      total += score;
      printf("%d   ", score);
   }
   printf("   %d\n", total);
}


   Jestlie je deklarovno dvourozmrn  pole,  pouvaj  se k pstupu ke
kad poloce dv smyky  for  vloen do sebe. Vnin smyka, jej dc
promnn se  jmenuje inning, prochz devt poloek, zatmco vnj pepn
z tmu 0 (Dodgers) na tm 1 (Giants).

   Funkce random (definovan v hlavikovm souboru stlib.h) generuje v tle
smyky  skre.  Poprv,  kdy se vol  (  RANDOM(3)),  je  33%  nadje,  e
dostaneme hodnotu 2 (random vrac hodnotu  z  rozsahu  0 a slo o 1 ni
ne je parametr). Jestlie score m hodnotu 2, je potna nhodn veliina
mezi 1 a  3.  Nakonec je score 3 a posledn skre je generovno z rozsahu 1
a 7. Posloupnost pkaz if se pokou simulovat ppadn velk odpal.

   Dv smyky for vypisuj a zrove staj skre. Kad z  nich zobrazuje
skre tm zpsobem, e pouv jmno tmu jako konstantu pro  prvn dimenzi
a promnnou inning jako druhou dimenzi. Zde jsou vsledky :

   Inning  1  2  3  4  5  6  7  8  9  Total
   Dodgers 0  1  0  1  0  1  1  2  0      6
   Giants  1  1  0  2  0  0  4  1  0      9


Pole a etzce
---------------------------------------------------------------------------

   etzce a pole si jsou velmi podobn. etzec je de facto pole typu char
se  znakem  null  na  konci.  Nsledujc  program  deklaruje znakov  pole
(etzec),   pak   do   nj  ukld  hodnotu  a  vybr  z  celho  etzce
"podetzec". (Nahrejte a spuste INTRO27.C.)



                                  - 90 - 


   Nezpomete, e etzcov pole potebuj jedno zvltn msto pro koncov
znak null.

*/* INTRO27.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char string[80];              /* Has 79 usable elements */
   char number[10];
   int pos, num_chars;

   printf("Enter a string for the character array: ");
   gets(string);
   printf("How many characters do you want to extract? ");
   gets(number);
   sscanf(number, "%d", &num_chars);

   for (pos = 0; pos < num_chars; pos++)
      printf("%c", string[pos]);
   printf("\n");

   return 0;
}


Pklad vsledk:

   Enter a value for the character array: The quick brown fox
   How many characters do you want to extract ? 9
   The quick


   Je  zvykem  pro  manipulaci s etzci uvat knihovn rutiny (jako nap.
strcat nebo strtok), protoe se automaticky staraj o znak  null  na  konci
etzce. Pokud vytvote etzec pomoc  deklarace pole, je nutno znak null
n؟m nahradit. (Pole  mus  bt  tak  velk. aby obshlo etzec plus znak
null, kter mus bt umstn na konec etzce. )


Definice etzcov promnn
---------------------------------------------------------------------------

   Je  mono definovat promnnou typu char tak,  aby  obshla  pouze  jeden
znak. Je mono definovat promnnou typu string tak, aby uchovale  etzec ?
Ne, protoe C nepracuje s etzci jako oddlenmi datovmi typy. etzec je
definovn  jako  posloupnost  znak.  Jeden  ze   zpsob,   jak  definovat
etzcovou promnnou, je deklarovat pole znak. Pklad :

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

   int main()
   {
      char message[30];
      strcpy(message, "This is the value of msg\n");
      puts(message);
      return 0;
   }


                                  - 91 - 


   dek char message[30]; deklaruje pole znak (etzec), kter obshne 30
znak. Pout je mono ovem jen 29, protoe mus zbt 1 msto na konci pro
znak null. Tchto 30 byt m  njakou  poten adresu, kter je uloena v
message. Pi voln strcpy je etzec literl

   This is the value of msg\n

nejprve zkompilovn a  uloen,  pot  je  na konec pidn znak null. strcpy
pracuje tak, e  po  jednom  zkopruje  znaky z etzce do pamti, ponaje
adresou message.

   Knihovna Turbo C++ obsahuje  mnostv  uitench  etzcovch  funkc -
ble  je  o  nich pojednno v  kapitole  2,  "Kov  reference  run-time
knihovny" v  Programtorsk pruce. Jako pklad je uvedena strcat, kter
kombinuje (spojuje) etzce :

   Nahrejte a spuste INTRO28.C.

*/* INTRO28.C--Example from Chapter 4 of Getting Started */

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

int main()
{
   char name[60];
   strcpy(name, "Bilbo ");
   strcat(name, "Baggins");
   puts(name);

   return 0;
}


   Zde  je  deklarovno  znakov  pole  velk  natolik,  e uchov  zvolen
etzce. Funkce strcpy ulo prvn etzec, pot funkce strcat za nj pid
(pipoj) dal. (vimnte si, e prvn etzec ("Bilbo  ")  kon mezerou,
take ob jmna budou oddlena.)


Pejmenovn typ
---------------------------------------------------------------------------

   Pokud vytvte sloitj datovou strukturu,  je  uiten  piadit j
vhodn jmno. Je mono ut klovho slova typedef.  typedef  um piadit
jmno  nkterm  kombinacm  standardnch typ dat  v  C.  Zde  je  nkolik
pklad :

   #include <stdio.h>

   int main()
   {
      typedef unsigned char uchar;
      uchar greek_alpha = 224, greek_beta = 225;
      printf("%c %c", greek_alpha, greek_beta);
      return 0;
   }





                                  - 92 - 


   Deklarace typedef pidluje nov jmno  uchar typu unsigned char. (To je
znakov typ, kter  me  uchovat  vech  256  znak  rozen  PC mnoiny
znak.) Druh pkaz deklaruje greek_alpha, a greek_beta jako promnn typu
uchar, printf pak vype jejich hodnoty.

   typedef  nevytv nov typ dat. Pouze  jej  in  srozumitelnjm  pro
dal pouit v programu. Jak uvidte dle, je  uiten  pojmenovat obecn
typy dat, jako nap. vtov typ nebo strukturu.


Vtov typy
---------------------------------------------------------------------------

   Data  se  obvykle  vyskytuj  v  uspodanm  sledu,  kde jedna  poloka
pedchz druhou -  napklad  dny  v  tdnu. K prochzen se obvykle uv
smyky.

   for (day = mon; day <= fri; day++)
      /* add hours worked that day to total for week */

   Protoe  smyka  prochz   numerickmi  hodnotami,  je  teba  piadit
celoselnou hodnotu promnn mon,  dal  tues,  atd.  To je mono provst
pkazy #define :

   #define mon 0
   #define tues 1
   #define wed 2
   #define thurs 3
   #define fri 4

   Typ enum (vtov) umouje  provst  stejnou  vc  mnohem kompaktnjm
zpsobem - tak, jak je popsno v nsledujcm pklad :
(Nahrejte a spuste INTRO29.C.)

*/* INTRO29.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   enum workday {mon, tues, wed, thurs, fri};
   int day;

   for (day = mon; day <= fri; day++)
      printf("%d\n", day);

   return 0;
}


   Prvn  deklarace automaticky piazuje 0 do mon, 1  do  wed,  atd.  Tyto
jmna mohou bt nyn pouita jako poten a konen hodnota smyky for.

   Vimnte  si, e sla uvan ve vtu nemus  nsledovat  za  sebou  -
poad je mono pozmnit nsledujcm zpsobem:

   enum  scores  {touchdown  = 6, field_goal = 3, safety = 2, point_after =
1];

Pkaz


                                  - 93 - 


   printf("_d\n", touchdown + point_after + field_goal)

vype vsledek 10.


Kombinace dat do struktur
---------------------------------------------------------------------------

   Pole a vtov typy  pedstavuj  dva mocn nstroje k manipulaci s daty
stejnho  typu. Struktura naproti tomu sdruuje  data  rznch  typ  (nebo
hodnoty, kter maj  rzn  vznam). Napklad informace o zamstnanci me
mt nsledujc strukturu:

   struct employee {
      char last_name[30];
      char first_name[20];
      char initial;
      double employee_no;
      double SS_no;
      char dept_code (3);
      float annual_salary;
   } ;


   Nyn jste definovali nov datov  typ  employee  a  specifikovali seznam
datovch  poloek  (len),  kter  typ  employee obsahuje. Jak je vidt  z
pedchozho pkladu, je  mono  pout  rzn  typy  dat  -  znakov pole,
samostatn znaky, promnn dvojnsobn dlky, typu float apod.


Pouit st struktury
---------------------------------------------------------------------------

   Nsledujc   pklad   sdruuje   informace   o  zobrazovn  planet  z
pedchozho  programu  PLANETS.C.  To   pozdji   vyuijeme   k  znzornn
inicializace  a  pstupu  ke  struktue.  Zde jsou zobrazeny  (Nahrejte  a
spuste INTRO30.C ) :

   K   jednotlivm   polokm   struktury   se  pstupuje  napsnm  jmna
struktury,za nm nsleduje  teka  a jmno lenu. mars.distance je poloka
obsahujc vzdlenost planety Mars od Slunce v astronomickch jednotkch.

   */* INTRO30.C--Example from Chapter 4 of Getting Started */

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

typedef struct {
   char name[10];
   float distance;
   float radius;
} planet;

planet mars;

int main()
{
   strcpy(mars.name,"Mars");
   mars.distance = 1.5;
   mars.radius = 0.4;


                                  - 94 - 


   printf("Planetary statistics:\n");
   printf("Name: %s\n", mars.name);
   printf("Distance from Sun in AU: %4.2f\n", mars.distance);
   printf("Radius in Earth radii: %4.2f\n", mars.radius);

   return 0;
}


   Klov slovo keyword  pidluje  jmno  planet  ke  struct (struktue),
kter sestv z  t  pol:  jmno  planety  (znakov  pole),  vzdlenost a
polomr  (sla v pohybliv adov rce).  Deklarace  struct  planet  mars
vytvo  promnnou  mars,  kter je typu planet (jinmi slovy provd kopii
struktury vyskytujc se dve). V main jsou tmto ve uvedenm tem polm
piazeny hodnoty.

   Jak zde bylo ukzno, pro  koprovn etzce do poloky, kter obsahuje
pole  znak,  je  vhodn  knihovn  funkce strcpy. Numerick  hodnoty  jsou
piazeny obvyklm zpsobem.

   Pkaz  printf na konci programu pouv  k  vypsn  oznaench  hodnot
pedpis jmno.poloka.



---------------------------------------------------------------------------
Tvorba sprvnch deklarac
---------------------------------------------------------------------------


   Deklartor  se  v  C jazyku pouv k  deklarovn  funkc,  promnnch,
ukazatel  a  datovch  typ. C umouje vytvet velmi obecn deklarace. V
tto podkapitole vm  ukeme  nkolik pklad deklarac, abyste zskali s
jejich tvorbou (a tak tenm) zkladn zkuenosti; je uvedeno tak nkolik
chybnch ppad.

   V tradinm programovn v C je nutno vytvoit deklartor pmo na mst
vetn  definic.  Tento   postup   in  program  tاko  itelnm  a  he
sestavitelnm.

   Uvaujme  napklad deklartory z nsledujc tabulky a  pedpokldejme,
e mte k dispozici malou pam؟ ke kompilaci (mal kd, mal data).




















                                  - 95 - 


                   Tab. 4.9: Deklarace bez definic typ

------------------------------------------------------------------------
int f1();                          Funkce vracejc int
int *p1;                           Ukazatel na int
int *f2();                         Funkce vracejc ukazatel na int
int far *p2;                       Dalek (far) ukazatel na int
int far *f3();                     Blzk (near) funkce vracejc dalek
                                   (far) ukazatel na int
int * far f4();                    Dalek (far) funkce vracejc blzk
                                   (near) ukazatel na int
int (*fp1)(int);                   Ukazatel na funkci vracejc int a
                                   obsahujc parametr int
int (*fp2)(int *ip);               Ukazatel na funkci vracejc int a
                                   obsahujc ukazatel na int
int (far *fp3)(int far *ip)        Dalek (far) ukazatel na funkci
                                   vracejc int a obsahujc dalek (far)
                                   ukazatel na int
int (far *list[5])(int far *ip);   Pole pti dalekch (far) ukazatel na
                                   funkce vracejc int a obsahujc dalek
                                   (far) ukazatele na int
int (far *gopher(int(far * fp[5])\ Blzk (near) funkce obsahujc pole
(int far *ip)))(int far *ip);      pti dalekch (far) ukazatel na funkce
                                   vracejc int a obsahujc dalek
                                   ukazatele na int; dle vrac nco jako
                                   ukazatel (zptn lomtko je znak pro
                                   pokraovn dku)
------------------------------------------------------------------------

   Tyto deklarace  jsou  vechny  sprvn,  jen  jsou  patn pochopiteln.
Vhodnm pouitm typedef je mono jejich itelnost zlepit.

   Nsleduj stejn deklarace, pepsan pomoc pkaz typedef :





























                                  - 96 - 


                      Tab. 4.10: Deklarace s typedef

------------------------------------------------------------------------
int f1();                          Funkce vracejc int
typedef int intptr;                Ukazatel na int
intptr p1;
intptr f2();                       Funkce vracejc ukazatel na int
typedef int far *farptr;
farptr p2;                         Dalek (far) ukazatel na int
farptr f3();                       Blzk (near) funkce vracejc dalek
                                   (far) ukazatelna int
intptr far f4();                   Dalek (far) funkce vracejc blzk
                                   (near) ukazatel na int
typedef int (*fncptr1)(int);
fncptr fp1;                        Ukazatel na funkci vracejc int a
                                   obsahujc parametr int
typedef int (fncptr2)(intptr);
fncptr2 fp2;                       Ukazatel na funkci vracejc int a
                                   obsahujc ukazatel na int
typedef int (far *ffptr)(farptr);
ffptr fp3;                         Dalek (far) ukazatel na funkci
                                   vracejc int a obsahujc dalek (far)
                                   ukazatel na int
typedef ffptr ffplist [5];
ffplist list;                      Pole pti dalekch (far) ukazatel na
                                   funkce vracejc int a obsahujc dalek
                                   (far) ukazatele na int

ffptr gopher(ffplist);             Blzk (near) funkce obsahujc pole
                                   pti dalekch (far) ukazatel na funkce
                                   vracejc int a obsahujc dalek
                                   ukazatele na int; dle vrac nco jako
                                   ukazatel.
------------------------------------------------------------------------


   Jak je vidt, je velk rozdl mezi itelnost  a  prhlednost deklarace
gopher pomoc typedef a pedchozm ppadem. Jestlie budete hodn pouvat
pkazy  typedef  a  funkn  prototypy,  shledte, e vae  programy  jsou
itelnj, snze se lad a udruj.



---------------------------------------------------------------------------
Ukazatele
---------------------------------------------------------------------------


   Kad  promnn  m  svou  jedinenou  adresu v pamti,  kter  oznauje
zatek sti  pamti  vyhrazen  pro  promnnou.  Velikost  zabran pamti
zvis na typu dat. V ppad int in 2 byty, zatmco float zabr 4 byty.
Pro pole  je  velikost  zabran  pamti  rovna  potu prvk krt poet byt
jednoho prvku. U struktury se  rovn  soutu  velikost  jednotlivch len
plus pam؟ nutn pro volbu -a.  Protoe  vechna data jsou uloena v pedem
uren  uspodan  posloupnosti,  je  mono  pistupovat  k  datm  pomoc
promnn   obsahujc  odpovdajc  adresu.  Takov  promnn  se   nazv
ukazatel.





                                  - 97 - 


   Kdy jsou ukazatele uiten?  Pedevm  tehdy,  kdy je teba jednodue
manipulovat se strukturovanmi  daty  bez  toho,  e  by  se  pesunovala v
pamti. Napklad  kdy je ukazatel nastaven na adresu odpovdajcho prvku
pole, me bt pouit k jeho inicializaci nebo k uloen hodnoty do nj.

   Ukazatele tak umouj pijmat a mnit hodnotu promnn ve funkci. Tm
se d obejt poteba deklarace globlnch promnnch.

   Vyhrazen  pamti je popsno v kapitole  4,  "Modely  pamti,  pohybliv
adov rka a overlay" v Programtorsk pruce.

   Ukazatele jsou tak teba  pro  vyhrazen pamti v dob bhu programu. V
praxi je mono nap. zjiovat velikost voln pamti  (viz  funkce malloc),
zpt dostanete ukazatel na prvn volnou adresu.


Deklarace a pouit ukazatele
---------------------------------------------------------------------------

   Deklarace ukazatele m tuto syntaxi :

   typ *jmno,

kde typ je jakkoliv typ dat. Zde je uvedeno nkolik pklad delarac :

   Vtina programtor pouv  jmno,  kter  ve  zkratce  obsahuje slovo
pointer (ukazatel), nap. intptr.

   int *intptr;         /*ukazuje na integer*/
   float *fltptr;       /*ukazuje na hodnotu v pohybliv adov rce*/
   char *string;        /*ukazuje na znakovou hodnotu*/

   Ukazatel je mono deklarovat na  jakkoliv objekt v pamti, vetn pol,
struktur, funkc a dokonce i jinch ukazatel.

   Pstup k promnn pomoc ukazatele se  dje  prostednictvm hvzdiky,
za  n  nsleduje  jmno  ukazatele.  Nap. *intptr dv hodnotu z  adresy
uloen v ukazateli intptr. Protoe je k tto promnn pistupovno nepmo
(na rozdl od "opravdov" promnn, kde je hodnota uloena pmo  na adrese
promnn), nazv se tento proces nepmm (indirect).

   Nsledujc program  deklaruje  ukazatel  a  pouv  jej  k zpstunn
promnn :

   Nahrejte a spuste INTRO31.C.

/* INTRO31.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   int intvar = 10;
   int *intptr;
   intptr = &intvar;

   printf("Location of intvar: %p\n", &intvar);
   printf("Contents of intvar: %d\n", intvar);
   printf("Location of intptr: %p\n", &intptr);
   printf("Contents of intptr: %p\n", intptr);


                                  - 98 - 


   printf("The value that intptr points to: %d\n", *intptr);

   return 0;
}


   Vsledky :

   Location of intvar: FFDC
   Contents of intvar: 10
   Location of intptr: FFDE
   Contents of intptr: FFDC
   The value thet intptr points to : 10

   Adresy se mohou mnit.

   Na zatku je deklarovna promnn intvar a je j piazena  hodnota 10.
Nsledujc deklarace  deklaruje  promnnou  int*  nazvanou  intptr.  (Tuto
deklaraci tte jako  "intptr,  ukazatel na hodnotu integer".) Dal pkaz
piazuje  do intptr adresu promnn intvar (vimnte si  znaku  &,  je  to
adresov opertor). Do ukazatele mus  bt vdy piazena adresa objektu na
kter m ukazovat.  Pokud  to opomenete, ukazatel bude obsahovat nesprvnou
adresu. Jestlie se pokuste nco  uloit  na  adresu  ukazatele, riskujete
znien sti programu, dat nebo dokonce zablokovn systmu.

   Jak  je  mono vidt z vstupu pkaz  printf,  intvar  a  intptr  jsou
uloeny na rznch adresch. (Protoe  jsou deklarovny za sebou, je mon,
e  jejich adresy budou blzko sebe, ale to  nijak  nesouvis  s  podstatou
prce ukazatel.) Intptr obsahuje adresu  intvar (byla piazena v jednom z
pedelch pkaz). Posledn pkaz printf vypisuje hodnotu, na ni intptr
ukazuje; jinmi slovy  obsah  adresy  uloen  v intptr. Protoe se jedn o
adresu intvar, ukazatel ukazuje na obsah intvar. Konkrtn pedstavu vm d
nsledujc obrzek.

Adresy   Obsah      Kd
         Ŀ
           
         Ĵ
   FFDC  10       int intvar=10;  /*deklarace a inicializace intvar*/
         Ĵ
           
         ĴĿ
         DC      int *intptr;   /*deklarace ukazatele,umstn v pamti
         Ĵ  
         FF      intptr=&intvar;/*adresa intvar piazena ukazateli */
         Ĵ
           
         Ĵ
           
         

                 Obr. 4.8: Jak (a na co) ukazuj ukazatele


Ukazatele a etzce
---------------------------------------------------------------------------

   V pedelm byl popsn pstup  k  jednotlivm  znakm  njakho etzce
pomoc indexace. Napklad kdy deklarujete etzec char name[20] a ulote
do nj poslopnost znak "Madonna",  hodnota name[2] je znak d (nezapomete,


                                  - 99 - 


e indexace zan na hodnot 0: name[0] je M). Jin zpsobe  je deklarovat
ukazatel a pouvat jej k manipulaci s etzci.

   Tento pklad vychz z jednoho  z pedchozch pklad, kter operuje s
etzcem jako s polem znak; je pepsn s pouitm  ukazatel.  Nahrejte  a
spuste INTRO32.C.

/* INTRO32.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

int main()
{
   char name[40];
   char number[10];
   char *str_ptr = name;
   int pos, num_chars;

   printf("Enter a string for the character array: ");
   gets(name);
   printf("How many characters do you want to extract? ");
   gets(number);
   sscanf(number, "%d", &num_chars);

   for (pos = 0; pos < num_chars; pos++)
      printf("%c", *str_ptr++);
   printf("\n");

   return 0;
}

   Vimnte si, e str_ptr je deklarovn jako ukazatel na znak, nsledn je
mu piazena adresa pole znak name. To me bt napsno ve dvou oddlench
pkazech :

   char *str_ptr;
   strptr = name;,

   Programtoi v C jazyku ale zdka pouvaj dva  pkazy,  kdy stejmou
funkci spln i pkaz jeden. Vimnte si dle, e piazen adresa je name,
ne  &name.  Odkazem  na  jmno  pole (nebo struktury)  dostanete  poten
adresu, kde jsou uloeny hodnoty  pole. To je ekvivalentn &name[0] (adresa
prvnho prvku pole name).

   Zbytek  programu  pracuje  stejn jako pvodn program a do smyky for,
kter vybr zadan podetzec. V pvodn verzi byl vybran znak pi kadm
prchodu smykou indexovn  vrazem  name[pos]. Naproti tomu je zde pouito
ukazatele, take  odkaz na hodnotu je realizovn jako *str%ptr++. (Ukazatel
je zvten pokad, kdy m ukazovat na nsledujc hodnotu.)


Aritmetika ukazatel
---------------------------------------------------------------------------

   S  neznakovmi  poli   pracuj   ukazatele  stejn  jako  s  etzci.  K
zpstupnn nsledujc (pedchoz) poloky se ukazatel zvt  (zmen) o
1. Je samozejm nutno  zabezpeit,  aby  ukazatele nevyboily z patinho
rozsahu pole. To se zpravidla dl stanovenm vhodnho limitu pro smyku.




                                  - 100 - 


   Je dleit si pamatovat, e kdy se zvt ukazatel ptr o jedna, nemus
ukazovat na  nsledujc adresu (obvykle tomu tak opravdu nen). Vzdlenost
mezi adresami, na kter se ukazuje, je rovna dlce pouitho datovho typu.
Ukazatel na  int  sko  po  zvten o 1 o dv adresy dopedu, ukazatel na
double sko o osm adres dopedu. Tento kon provd C automaticky.


Ukazatele, struktury a seznamy
---------------------------------------------------------------------------

   Mon si  pamatujete, e hodnotu lenu struktury dostanete pomoc zpisu
jmno_struktury.jmno_lenu,  take  poloka  plat ve struktue zamstnanec
pojmenovan jim je pstupn  zpisem  jim.plat.  Jak je ekvivalent tohoto
postupu pomoc  ukazatel? Uke to nsledujc pklad (nahrejte a spuste
SOLAR.C).

   Prci programu znzoruje obrzek 4.9 .

   */* SOLAR.C--Example from Chapter 4 of Getting Started */

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

typedef struct {
   char name[10];
   float distance;
   float radius;
   int color;
   int fill_type;
} planet;

planet solar_system[9];
planet *planet_ptr;
int    planet_num;

int main()
{
   strcpy(solar_system[0].name,"Mercury");
   solar_system[0].distance = 0.4;
   solar_system[0].radius = 0.4;
   solar_system[0].color = EGA_YELLOW;
   solar_system[0].fill_type = EMPTY_FILL;

   planet_ptr = solar_system;
   planet_ptr++;             /* Point to second planet structure */
    strcpy (planet_ptr->name,"Venus");

Notace -> je vysvtlena dle.

   planet_ptr->distance = 0.7;
   planet_ptr->radius = 1.0;
   planet_ptr->color = EGA_BROWN;
   planet_ptr->fill_type = SOLID_FILL;

   planet_ptr = solar_system;         /* Reset to first element */
   for (planet_num = 0; planet_num < 2; planet_num++, planet_ptr++) {
      printf("\nPlanetary statistics:\n");
      printf("Name: %s\n", planet_ptr->name);
      printf("Distance from Sun in AU: %4.2f\n",


                                  - 101 - 


              planet_ptr->distance);
      printf("Radius in Earth radii: %4.2f\n", planet_ptr->radius);
      printf("Color constant value %d\n", planet_ptr->color);
      printf("Fill pattern constant value %d\n",
             planet_ptr->fill_type);
   }

   return 0;
}

   Nsledujc obrzek ilustruje, jak pracuje pedchoz  program  v prvnch
nkolika krocch smyky for:

    name   distance  radius  color fill_type
   Ŀ
   ^
     
     
   Ŀ
    0 1 2 3 4 5 6 7 8
   ^^^
         optn inkr.
inkrem. optn
planet_ptr  inkrementace

         Obr. 4.9: Pouit ukazatel ke zpstupnn pole struktur

   Struktura  planet  je  rozen verze te struktury  uveden  dve  o
poloky pro barvu a typ vpln. Deklarace

   planet solar_system[9];
   planet *planet_ptr;

   specifikuje pole solar system,  jeho  devt  len jsou kopie struktury
planet a ukazatel planet_ptr ukazuje na strukturu planet.

   Prvn  skupina  pkaz  v  main  inicializuje  leny  prvn  planetrn
struktury pomoc pole a  popisu  struktury. Odkaz na leny struktury v poli
struktur provd takto:

   jmeno_pole[index].jmeno_clenu

   Vzdlenost    tvrt     planety     v     solar_system     tedy    bude
solar_system[3].distance.

   Protoe planet_ptr byl deklarovn jako ukazatel na typ planet, vestavn
ukazatelov  aritmetika zabezpe pechod na nsledujc poloku  struktury
skokem o pslun poet byt.

   Druh blok pkaz inicializuje strukturu planet pomoc  ukazatel. Ped
pouitm ukazatel je  nutno  piadit sprvnou adresu. Pkaz planet_ptr =
solar_system nastavuje planet_ptr  na  prvn prvek pole solar_system. To je
prvek, kter po inicializaci  obsahuje  informace  o planet Merkur. Pkaz
planet_ptr++ zpsob pechod na dal prvek.

   Pomoc sprvn ukazujcho  ukazatele  je  piazena  informace  o druh
planet  (Venue)  do  druhho  prvku  solar_system.  Zde  je  mono  vidt
(srovnejte indexovou notaci)  pouit  ukazatele  planet_ptr  k  pstupu k
polokm struktury planet . Syntaxe je nsledujc :



                                  - 102 - 


   jmeno_ukazatele->jmeno_polozky.

Take napklad poloka distance  ve  struktue  planet je pstupn takto:
planet_ptr->distance.

   Zbytek  programu  obsahuje  dv  planetrn  struktury,  kter  maj bt
inicializovny. planet_ptr  je  nastaven  zpt  na  prvn  prvek piazenm
adresy solar_system. Smyka for zvtuje planet_ptr a pistupuje k polokm
struktury   ve    popsanm    zpsobem.    Vimnte    si,    e    popis
planet_ptr->distance je o nco jednodu ne

   solar_system[index].distance,

kde index je slo odpovdajcho prvku.

   Ve skutenosti index prvku pole je ukazatel na adresu pole  plus hodnota
indexu, co vnitn aritmetika ukazatel konvertuje na adresu pole plus

   index * sizeof(type),

kde type je deklarovan typ pole a sizeof je opertor C jazyka, kter vrac
poet byt vyhrazench pro dan typ promnn.


Pouit ukazatel k nvratu hodnoty z funkc
---------------------------------------------------------------------------

   Ukazatel umouj i zmnit skutenou hodnotu  promnn  nebo promnnch
pouitch ve voln funkce.  Funkce  mohou  bt  volny s pouitm konstant
nebo jmen promnnch jako argument. Kdy zavolte draw(x_cor, y_cor, size,
color),  zadali jste funkci draw hodnoty  uritch  promnnch.  Funkce  ve
skutenosti  udl  kopie  tchto  hodnot  a  um  se  na  n  odkazovat  a
manipulovat s nimi, jene  to  nem dn vliv na skuten promnn pouit
ve voln.

   Nkdy  je  uiten  zavolat funkci se jmny promnnch a poadovat, aby
skuten zmnila hodnoty samotnch promnnch. Pklad:

   void swap(int *a, int *b)

   swap zamuje hodnoty dvou promnnch, kter jsou uvedeny v zvorkch za
funkc.  Avak  aby  funkce  mla  k dispozici samotn promnn, nesm  mt
jejich hodnoty, ale  jejich  adresy,  aby  mohla pst nov hodnoty pmo do
pamti. Proto jsou parametry  ukazatele  na  promnn, ne promnn samotn.
Protoe ukazatele obsahuj adresy, je  mono tuto funkci zavolat i pkazem
swap(&x,&y).

   Definice  funkce  swap  vetn  funkce  main,  kter  ji testuje,  je  v
nsledujcm programu (nahrejte a spuste INTRO33.C).

*/* INTRO33.C--Example from Chapter 4 of Getting Started */

#include <stdio.h>

void swap(int *, int *);   /* This is swap's prototype */

int main()
{
   int x = 5, y = 7;
   swap(&x, &y);


                                  - 103 - 


   printf("x is now %d and y is now %d\n", x, y);

   return 0;
}

void swap(int *a, int *b)    /* swap is actually defined here */
{
   int temp;
   temp = *a;
   *a = *b;
   *b = temp;
}


   Vimte si, e funkce swap pouv (zpis *) k hodnotm v promnnch x a
y nepm pstup. Hodnota x je nejprve uloena v pomocn promnn,  pak je
hodnota y pepsna do x. Nakonec  je  pvodn hodnota x pevedena z pomocn
promnn do y.

Ŀ
    inicializ.promnn               0
   Ŀ              Ĵ
   int x = 5, y = 7   >   7y
                 Ĵ
                                     0
                                    Ĵ
    voln funkce                    5x
   Ŀ                 
   swap(&x, &y); 
   


    vsledky                        Ŀ
  Ŀ       0
   void swap(int *a, int *b)      Ĵ
   {                               5y
    int temp;               >Ĵ
    temp = *a; *a = *b;            0
    *b = temp;                    Ĵ
   }                               7x
        

                  Obr. 4.10: Pouit ukazatel ve funkci

   Pi  pouit ukazatel nen funkce omezena tm,  e  vrac  pouze  jednu
hodnotu  pomoc  pkazu  return.  Funkce  me  mnit  hodnotu  kterkoliv
promnn, ke  kter  m  pstup.  To  me  bt dosaeno (v tomto ppad)
pomoc globlnch promnnch a a b (jejich deklarac mimo definici funkce),
ovem  ty  jsou  nchyln k snadnm zmnm odevad. Ukazatele provedou tuto
transakci zcela privtn.












                                  - 104 - 


---------------------------------------------------------------------------
Vyuit systmovch zdroj
---------------------------------------------------------------------------


   Je jasn, e  pklady  program  nepracuj  ve  vakuu.  Nkter  z nich
nataj  data z klvesnice a kad program  vypisuje  nco  na  obrazovku.
dn data nejsou  uloena  stle,  pokud  s nimi chcete operovat, je nutno
znovu spustit program. Ve skutench aplikacch se nat obvykle z mnoiny
dat  na disku, z komunikanho portu nebo jinho  zdroje.  Kdy  jsou  data
zpracovna,  vytisknou  se  na  tiskrn  nebo zap na disk pro  pozdj
pouit. To plat nap. pro slovn a tabulkov procesory, databze apod.

   Tato podkapitola ukazuje, jak se v Turbo C++ nataj a zapisuj  data z
a do diskovho  souboru.  Turbo  C++  m  k pesunu dat k dispozici stream.
Existuj jet jin, ni (low-level)  rovn pstupu k souborm MS-DOS a
knihovnm  funkcm   spojenm  s  nimi,  ale  obecn  se  doporuuje  kvli
penositelnosti stream (=proud, tok) . Umouje pouvat soubory bez ohledu
na operan systm.

   Stream pedstavuje soubor na disku  nebo jin zazen, ze kterho mohou
bt data natena, nebo kam mohou bt poslna. (Mnoho zazen  je pouvno
jen pro vstup nebo vstup, ale ne pro oboje zrove - nen nap. mono st
data  z  tiskrny  nebo  poslat  je  na  klvesnici.)  V naem programu se
nemanipuluje pmo se streamy. Msto toho je v knihovn definovna promnn
FILE typu struct  (ve  stdio.h). Protoe tato struktura vytv vyrovnvac
pam؟,  je  mono  deklarovat ukazatel na  patin  soubor  a  pak  s  nm
normlnm zpsobem pracovat.

   K  oteven  streamu  se  pouv  funkce  (obvykle  fopen)  z  run-time
knihovny.  Je  nutno  urit, jestli budete ze streamu natat, zapisovat do
nj nebo oboje. Dle je teba specifikovat, jestli pjde o text nebo data v
binrnm tvaru.

   Pro normln soubory DOS  se  pouv  textov stream. Standardn stream
I/O pedpokld, e text sestv z dk zakonench znakem pro konec dku
(ASCII znak linefeed). Avak DOS ukld soubory se znakem pro nvrat vozku
(carriage return) a  se  znakem  pro  nov dek (newline) na konci kadho
dku. Kdy deklarujete textov stream, Turbo C++ zmn  CR/LF  na linefeed
pi vstupu a linefeed  na  CR/LF na vstupu, m zachovv kompatibilitu s
DOSem.


Pouit soubor a stream
---------------------------------------------------------------------------

   Zkladn  kroky  nezbytn  k  pouvn  diskovch soubor z  Turbo  C++
program jsou tyto:

1. K zaveden nezbytnch deklarac pro soubory pouijte #include<stdio.h>.

2. Deklarujte ukazatel na typ FILE (je definovn v stdio.h).

3. Deklarujte datov objekt (objekty), kter budou pijmat informace ze
   souboru. Napklad znakov pole pro dek textu, pole nkterho z
   numerickch typ nebo pole struktur.

4. Otevete soubor pomoc fopen, zadejte jmno souboru a zpsob pstupu,
   kter je teba (pouze ke ten, zpisu, pidvn vt, atd. - vce viz
   kapitola 2, "Kov reference run-time knihovny" v Programtorsk


                                  - 105 - 


   pruce).

5. Ujistte se pomoc hodnoty vracen fopen, e soubor byl opravdu oteven.

6. Pouijte vhodnou knihovn funkci (funkce) ke ten nebo zpisu dat. Pro
   text jsou vhodn fprintf a fscanf pln stejn jako jejich obrazovkov
   orientovan dvojnci printf a sscanf. fputs a fgets pracuj s jedinm
   znakem. Pro ten strukturovanch blok dat znm dlky jsou
   nejvhodnj fwrite a fread.

7. Po skonen prce je nutno soubor uzavt pomoc fclose.


Nsledujc program otevr soubor, ukld do nj ti dky textu a  pak je
znovu nate:

   Nahrejte a spuste INTRO34.C.

/* INTRO34.C--Example from Chapter 4 of Getting Started */

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

FILE *textfile;        /* Pointer to file being used */
char line[81];         /* Char array to hold lines read from file */

int main()
{
   /* Open file, testing for success */
   if ((textfile = fopen("intro34.txt", "w")) == NULL) {
      printf("Error opening text file for writing\n");
      exit(0);
   }

   /* Write some text to the file */
   fprintf(textfile, "%s\n", "one");
   fprintf(textfile, "%s\n", "two");
   fprintf(textfile, "%s\n", "three");

   /* Close the file */
   fclose(textfile);

   /* Open file again */
   if ((textfile = fopen("intro34.txt", "r")) == NULL) {
      printf("Error opening text file for reading\n");
      exit(0);
   }

   /* Read file contents */
   while ((fscanf(textfile, "%s", line) != EOF))
      printf("%s\n", line);

   /* Close file */
   fclose(textfile);

   return 0;
}





                                  - 106 - 


Oteven streamu

   Se soubory urit pracovat budete. Pro usnadnn m kad  program  v  C
automaticky pstup k pti streamm uvedenm v nsledujc tabulce.


          Tab. 4.11: Peddefinovan oteven streamy v Turbo C++

------------------------------------------------------------------------
jmno          funkce                   pipojen na
------------------------------------------------------------------------
stdin          standardn vstup         klvesnici
stdout         standardn vstup        obrazovku
stderr         standardn chybov       obrazovku
stdaux         standardn pomocn       sriov port
stdprn         standardn tiskov       port tiskrny
------------------------------------------------------------------------

   Prvn dva definovan streamy mohou  bt  pesmrovny.  V  zvislosti na
jejich  definovanm  pipojen  oekvaj  programy  v  Turbo  C++ vstup  z
klvesnice a vstup se  posl  na  obrazovku.  Kdy otevete soubor pomoc
ukazatele na typ FILE (soubor), oteve se dal stream.

   V pkladu programu je  deklarovn  ukazatel  na stream textfile. Pkaz
fopen  spoj  ukazatel  s  diskovm  souborem  text,  kter  je  oteven  v
pstupovm  mdu  w  (zpis).  Pkaz  if kontroluje hodnotu NULL, co  je
peddefinovan ukazatel indikujc chybu pi oteven souboru


Zpis do souboru

   fprintf pe do souboru  ti  dky  textu.  fprintf pracuje stejn jako
podobn funkce printf a na to,  e  obsahuje jako prvn jmno ukazatele na
stream,  dle  specifikaci  formtu  a  pot data, kter maj bt  zapsna.
Vimnte  si, e k oddlen dk textu mus bt pouit znak pro nov dek
(\n),  aby  mohl  pozdji  bt  naten  pomoc  fscanf.  Pot, co jsou data
zapsna, je soubor uzaven pomoc fclose.


Natn ze souboru

   K  naten  textu  ze souboru je  soubor  znovu  oteven  pomoc  fopen,
tentokrt v mdu  pro  ten.  fscanf  nat kad dek do znakovho pole
line. Pkaz printf  dek  vype  na  obrazovku. To ve probh ve smyce
loop, kter ek, a fscanf vrt EOF (end of file).

















                                  - 107 - 
































































                                  - 108 - 








                            K a p i t o l a   5

                                Zklady C++


   Tato kapitola obsahuje  zkladn  rysy C++; nkolika pklady program v
C++ strun provd kapitola 6, "Pruka C++".

   V tto kapitole dostanete chu na C++. Odstranme  nkter  nejasnosti a
zkombinujeme trochu teorie s jednoduchmi nzornmi programy.  Zdrojov kd
tchto pklad je uloen  na  distribunch  disketch,  take je mono je
studovat, editovat, kompilovat  a  spoutt.  (Grafick  pklady  je mono
samozejm spoutt jen tehdy, jestlie vlastnte grafick adaptr a vhodn
monitor. Spolupracovat bude kad karta CGA, VGA, EGA nebo Hercules.)

   Turbo  C++  zahrnuje  vechny rysy C jazyka firmy AT&T verze 2.0. C++ je
rozenm   populrnho   jazyka  C  o   zvltn   vlastnosti   objektov
orientovanho programovn (OOP).

   OOP je  metoda programovn, kter napodobuje zpsob, jakm si vytvme
modely  svta kolem ns. K pochopen  komplexnosti  ivota  mme  vyvinutou
velkou  schopnost  zeveobecovn, klasifikace a  abstrakce.  Tm  kad
podstatn jmno v  naem  slovnku  pedstavuje  tdu  objekt sdlejcch
mnoinu  atribut  a  zpsob chovn. Ze  svta  plnho  rznch  ras  ps
odvozujeme  abstraktn  tdu  nazvanou  pes.  To  nm  umouje zkoumat  a
pracovat se psy bez toho, e  bychom  se zabvali detaily nkterho ze ps.
Rozen C++ o OOP vyuv tto pirozen tendence, kterou klasifikujeme a
abstrahujeme vci - C++ byl de facto pvodn nazvn "C  s  tdami" (C with
Classes).

   Hlavnmi charakteristickmi rysy OOP jsou:

    o  Ohranienost (encapsulation) : Kombinuje  struktury  dat  s funkcemi
       (akcemi  nebo  metodami),  kter  s  daty  pracuj.  Ohranienost se
       dosahuje  pomoc nov struktury a mechanismu  zpisu  dat  -  tdou
       (class).

    o  Ddinost (inheritance) : Buduj se nov, odvozen tdy, kter dd
       data  a funkce od jedn nebo  vce  pedchozch,  definovanch  jako
       zkladn (base) tdy, a znovudefinuj nebo pidvaj nov data nebo
       akce. To tvo hierarchii td.

    o  Mnohotvrnost    (polymorphism):  Pidluje  akci jmno nebo symbol,
       kter je sdlen smrem nahoru nebo dol v  tdn  hierarchii; kad
       tda v hierarchii si pizpsob akci tak, jak j to vyhovuje.

   C++ od firmy Borland poskytuje  vechnu  vhody  objektov orientovanho
programovn:

    o  lep kontrolu struktury a modularity program

    o  schopnost vytvet nov typy dat se specializovanmi opertory

    o  prostedky, kter pomhaj pst obecnj programy


                                  - 109 - 


   Vsledkem  vech  tchto  vlastnost   je   lpe   strukturovan,  snze
roziiteln  a  srozumitelnj  program, ne ten, kter je mono napsat v
neobjektov orientovanch jazycch.

   K vyuit tchto dleitch vhod  C++ je nutno zmnit zabhnut mylen
v programovn, kter roky pedstavovalo  standard. Pokud se vm to poda,
stane se C++ jednodum,  pmjm  a  lepm  nstrojem pro een mnoha
problm, je jsou tradinmi prodtedky tاko eiteln.

   Vyberte si odstavec, kter se k vm nejlpe hod:

   V C a C++ jste  novky.  Mon  nejprve  budete  mt  s  novou koncepc
probranou  v  tto  kapitole  trochu  pote,  ale  urit  si pi prci a
experimentovn  s  pklady  brzy na hlavn rysy  zvyknete.  Ne  zanete,
zopakujte  si  zklady  jazyka  C  (pette  si  teba kapitolu  4).  Jako
zatenci   mte   jednu   velkou   vhodu:   nejste   zateni   starmi
programtorskmi nvyky.

   V  C  jste  zkuenmi  programtory.  C++ buduje na stvajc syntaxi  a
schopnostech C. To in uen mnohem leh, ne kdyby  jste  mli  poznvat
pln  nov  jazyk.  Existujc  programy  v  C  je mono pepsat do C++  s
minimlnmi zmnami ve  zdrojovm  kdu. Neztratte ani slu ani efektivitu
C, navc dostanete k dispozici monosti td a vt bezpenost  v pstupu
k datm.

   Programujete v Turbo Pascalu 5.5.  Turbo  Pascal  5.5  obsahuje mnostv
stejnch objektov orientovanch rys jako C++. Jakmile peklenete zkladn
rozdly v syntaxi  obou  jazyk,  shledte,  e objekty Turbo Pascalu 5.5 a
tdy Turbo  C++  jsou  si  podobn.  lensk  funkce (member function) v C
odpovdaj metodm (methods) z  Turbo  Pascalu  5.5  a existuje jet mnoho
dalch  podobnost.  Hlavn  rozdl, kterho si urit vimnete je ten, e
C++ m psnj kontrolu pstupu k datm.

   Mte  zkuenosti  s  jinm objektov orientovanm jazykem. C++ se od nj
trochu li:

    o  Za  prv  -  syntaxe  C++  je stejn jako v tradinm  procedurlnm
       jazyku.

    o  Za druh - zpsob, jakm pracuje C++ a Smalltalk  bhem  pekladu  s
       objekty,  je odlin. Vazby v Smalltalk se  vytvej  a  pi  bhu
       programu (jde o tzv. pozdj vazbu - late binding), C++ vyuv jak
       as pi kompilaci, tak pozdj vazby.

   V tto  kapitole zaneme s podrobnjm popisem t klovch vlastnost
OOP: ohranienost, ddinost a vcetvarost.  Prvn  vpisy  obsahuj pro
lep  ilustraci  pouze  fragmenty  program.  Pozdji  jsou  uvedeny pln
kompilovateln programy. Hlavn pklad  aplikuje  vhody  OOP na grafiku a
jeho vedlej  vtve  navc  ukazuj,  jak  C++  pracuje s etzci a jinmi
datovmi strukturami.












                                  - 110 - 


---------------------------------------------------------------------------
Ohranienost
---------------------------------------------------------------------------


   Jak mn C++ obvyklou prci s programem a  daty?  Jednm  ze  zpsob je
ohranienost: sdruuje dohromady program a  data v jedin objekt typu tda
(class-type object). Napklad mte vytvoit datovou strukturu, teba pole,
kter obsahuje informaci potebnou k  vypisovn fontu znak na obrazovku a
dle   napsat   program  (funkce)  pro   zobrazen,   zvtovn,   rotaci,
zvrazovn a vybarvovn znak fontu.

   V klasickm C by bylo mono tuto lohu eit tak, e se datov struktury
a  s  nimi  spojen funkce ulo do  jednoho  samostatn  zkompilovatelnho
souboru,  co  je pokus o sdruen dat  a  programovho  kdu  do  jedinho
modulu.  To  je  krok  sprvnm  smrem,  ale  nen  tak  docela  korektn.
Neexistuje  vnj  vazba mezi daty a programovm  kdem  a  vy  nebo  jin
programtor me  pistupovat k datm pmo bez pouit vytvoench funkc.
To vede k problmm. Napklad  pedpokldejme,  e  se  rozhodnete vymnit
pole  znak  za  spojen seznam. Jin programtorka  pracujc  na  stejnm
projektu se me rozhodnout, e vymyslela lep zpsob,  jak  pistupovat k
datm a nape vlastn  funkci,  kter manipuluje pmo s polem. Problm je
ten, e pole u neexistuje!

   C++  sdruuje  monosti klovch slov struct a  union  z  C  jazyku  do
klovho  slova,  kter  se  v  C nevyskytuje: tda (class). Vechna  t
klov slova se v C++ pouvaj k definici td (classes).

   V tchto manulech budeme rozliovat  klov  slovo  tda  od obecnho
"tda".

   V  C++  jedna  entita tdy (definovan pomoc struct, union nebo class)
kombinuje  funkce  (nazvan  lensk  funkce  (member  functions))  a data
(nazvan datov leny (data members)).  Td  se  obvykle  piad vhodn
jmno,  nap. Font. Toto jmno se tak  stv  novm  identifiktorem  typu,
kter  je  mono  pout k deklaraci instance (ppadu) nebo objektu tohoto
typu tdy:

      class Font {
   // zde se deklarovaly leny : data i funkce;
   // zatm si nelamte hlavu tm, jak.
   };
   Font Tiffany;     //deklaruje Tiffany jako typ tda (class)
                     //Font.

   Vimnte si, e v Turbo C++ je mono k okomentovn jednoho dku pout
dv lomtka (//). Mete pout i  znaky  /* */, pokud jim dvte pednost,
ty se vak obvykle pouvaj pro dlouh komente.

   Pozor!

   Pkazy // nejsou  obvykle  penositeln  na  jin  C  jazyky.  Jsou ale
penositeln na jin kompiltory C++.

   Promnn  Tiffany   je   instance   (nkdy   je   nazvna   ppadnost
(instantion)) tdy Font. Jmno tdy Font budete pouvat velmi asto jako
normln  datov typ z C. Napklad je mono  deklarovat  takovto  pole  a
ukazatele:

   Font Times[10];   // deklarace pole 10 font


                                  - 111 - 


   Font* font_ptr;   // deklarace ukazatele na Font

   Velk  rozdl  mezi tdami C++ a stukturami  C  spov  v  pstupu  k
polokm. Poloky struktury v C  jsou  voln  pstupn  jakmukoliv vrazu
nebo funkci v jejich rozsahu. V C++ je mono dit pstup ke lenm struct
a class  (kd  i  data)  deklarac  danch  len jako public, private nebo
protected. (C++ union  je  vtinou  stejn  jako  union v C se vemi leny
public). V dalm vysvtlme tyto ti rovn pstupu podrobnji.

   C++ struktury a uniony nejsou zcela toton se strukturami a uniony v C.

   Struktury  a  uniony  v C++ umj obvykle vce ne jejich protjky v C:
mohou obsahovat deklarace funkc a  definice, stejn jako datov poloky. V
C++  mohou  bt  vechna  klov  slova  struct,  union  a class pouita k
definici td.

    o  Tda definovan pomoc struct je  tdou,  kde  vechny  leny jsou
       public (tuto rove pstupu je mono zmnit, pokud bude teba).
       Tda definovan pomoc  union  m vechny leny public (tuto rove
       pstupu mnit nelze).

    o  Ve td  definovan pomoc class jsou leny definovny jako private
       (tuto rove pstupu je tak mono mnit).

   Jestlie tedy v C++mluvme o tdch, rozum se tm struktury,  uniony a
typy definovan klovm slovem class.

   Typickm ppadem je omezen pstupu len - data  ke  lenskm funkcm:
obvykle se lensk data definuj jako private a lensk funkce jako public.

   Vrame se k  problmu  font.  Jak  je v tomto ppad uiten koncepce
td z C++?

   Po vytvoen vhodn tdy Font se mete ujistit, e s datovm fontem je
mono pracovat a pistupovat k nmu jen pomoc funkc  public  lenu  Font,
kter byly vytvoeny k tomuto elu. Nyn je mono kdykoliv  zmnit datovou
strukturu fontu z pole na spojen seznam nebo  na  nco  jinho.  Bude tak
samozejm nutno pepsat lensk funkce  tak, aby pracovaly s novou datovou
strukturou,  ale pokud se nezmn jmna funkc  a  argumenty,  programy  (a
programtorky) v jinch stech tho systmu budou zmnami nedoteni !

   Nsledujc obrzek porovnv zpsoby pstupu k fontu C a C++.

      STRUKTURA C A KD                        TDA C++
   Ŀ  Ŀ Ŀ
   struct data                       Ŀ     
   {                                 tda                data
   ... }                             {                   
       ....                
   Ŀ        
   /*kd manipulujc s daty*/        /*lenske funkce*/ 
   {                                                      Ŀ
    init(...);                        constructor(...);    
    get(...);                         get(...);            
    sort(...);                        sort(...);            funkce
    print(...);                       print(...);          
    ...}                              }                   
     

                 Obr. 5.1: Klasick C versus rozen C++


                                  - 112 - 


   Technika  ohranienosti ve tdch m velk  pnos  i  pro  modularitu,
stejn, jak je mono nalzt v jazycch jako je Ada a Modula-2. Tda v C++
je dobe definovanm rozhranm, kter napomh tvorb, implementaci, drb
a pouvn programu. Tak ladn v programech napsanch v  C++  je  mnohem
jednodu, protoe chyby mohou bt v tdch rychle lokalizovny.

   Koncepce td vede k  mylence  datov  abstrakce. Nae datov struktura
fontu  se  nikterak  neve k fyzick implementaci, je definovan v termech
operac  (lenskch  funkc),  kter jsou s n  spojeny.  Zrove  klasick
pojet C  ,  kter  vid  program jako sbrku funkc a data jako dal st
celku, je  tak  poznamenno  zmnou.  Tda  C++  chpe data a funkce jako
rovnocenn a na sob zvisl partnery.



---------------------------------------------------------------------------
Ddinost
---------------------------------------------------------------------------


   Popisn  odvtv  vdy  (pouvan  ped  tm,  ne  mohou bt  uiten
vysvtlujc  a  pedpovdajc  sti  vdy)  spotebuj  pi  klasifikaci
pedmtu  mnoho  asu  k vystien uritch rys.  Klasifikace  se  obvykle
vyjaduje ve form stromu, kde  koen  pedstavuje  nejobecnj kategorii,
kter se dle len na podkategorie a ty se zase vtv, atd.

   Napklad entomologov  klasifikuj hmyz zpsobem z obrzku 5.2. V td
hmyz jsou dv  podtdy:  kdlat  a  bezkdl. Kdlat se dl na mnoho
kategori: moli, motli, atd.


Ŀ
                             Hmyz  
                          
              Ŀ
                                              
       Ŀ                   Ŀ
         kdlat                       bezkdl  
                          
  Ŀ
 moli                vky  
             
         Ŀ
          motli 
         

                      Obr. 5.2: st taxonomie hmyzu

   Tento klasifikan postup  se  nazv taxonomie. Je dobrou metaforou pro
vysvtlen mechanismu ddinosti v OOP.

   Otzky, kter si klademe pi  klasifikaci  novho  zvete  nebo objektu
jsou nsledujc: m se podob jinm ve stejn obecn td? m  se li?
Kad  tda m jistou mnoinu vlastnost a  chovn,  kter  ji  definuje.
Zanme u koene  stromu  a  pedchoz  dv otzky si klademe celou cestu.
Nejvy  rovn  jsou nejveobecnj, take  otzky  jsou  nejjednodu:
Kdlat nebo bezkdl? Kad nsledujc rove je vce specifick a mn
obecn ne pedchoz.




                                  - 113 - 


   Pokud je jednou definovna njak charakteristika, vechny kategorie pod
n  ji  obsahuj.  Kdy  identifikujete  hmyz jako len  du  dvoukdlch
(diptera),  nen  nutno  uvdt zvl, e lt pomoc jednoho pru kdel.
Znak lt se dd z pedchozho.

   OOP je proces tvorby hierarchie td. Jednm z dleitch pnos C++ do
C  je  mechanismus,  pomoc  kterho  typy td mohou zddit vlastnosti  od
jednoduch obecnjch  typ.  Tento  mechanismus  se  nazv  ddinost.
Ddinost poskytuje jedn funkci obecnost,  zatmco  nsledujc  mohou bt
tak specializovan,  jak  je  poteba.  Jestlie  tda  D dd po td B,
kme, e D je odvozen (derivovan) tda a B je zkladn (base) tda.

   Nae loha je  samozejm  triviln, ale pesto obsahuje ideln tdn
hierarchii pro danou aplikaci. Taxonomie  hmyzu se vyvjela stalet a jet
v souasnosti je pedmtem  zmn  a debat. Ped tm, ne napete jakkoliv
dek  v C++, je nutno si dobe promyslet, kter tdy jsou na kter rovni
potebn. Jak se aplikace vyvj, shledte mon, e nov tdy budou muset
bt nadazeny cel hierarchii. K tomuto tmatu se poj  mnoho  publikac  z
na knihovny. Vzrst tak poet prodvanch knihoven  td kompatibilnch
s Turbo C++.

   Pleitostn je mono tak vytvoit  tdu,  kter  zahrnuje vlastnosti
vce  td  ne  jedn pedchoz. C++ verze 2.0 obsahuje mechanismus (kter
nen v  pedchozch verzch C++) znm jako vcensobn ddinost (multiple
inheritance), pomoc nho  me  bt  tda  odvozena  ze  dvou  nebo vce
zkladnch td. Pozdji uvidte,  jak  je  tento  rys odvozen jako logick
rozen jednoduchho mechanismu ddinosti.



---------------------------------------------------------------------------
Vcetvarost
---------------------------------------------------------------------------


   Slovo polymorfismus  (vcetvarost) pochz z etiny a znamen nco jako
"mt vce tvar (podob)". Polymorfismus v C++ pedstavuj virtuln funkce.
Virtuln  funkce umouj pouvat vce verz  te  funkce  v  hierarchii
td,  piem  aktuln  verze se tvo a pi bhu programu (tomu se k
pozdj vazba - late binding).



---------------------------------------------------------------------------
Pekrvn
---------------------------------------------------------------------------


   V C je mono mt  pouze  jedno  jmno  k  dan  funkci.  Napklad pokud
deklarujete a definujete funkci

   int cube (int number);,

mte cube deklarovanou jako integer. Ale co kdy chcete mt cube float nebo
double?  Samozejm  je  mono deklarovat podobn funkce, ale ty u nemohou
mt jmno cube:

   float fcube (float float_number);
   double dcube (double double_number);



                                  - 114 - 


   V C++ je mono funkce pekrvat. To znamen,  e  je  mono  mt nkolik
funkc  se  stejnm  jmnem, kter pracuj s jinm typem dat. Je mono tedy
deklarovat:

   int cube (int number);,
   float cube (float float_number);
   double cube (double double_number);

   Protoe seznamy argument jsou  odlin,  pebr  C++ starost o sprvn
voln funkce s  patinm  argumentem. Pokud zavolte cube(10), je pouita
verze int, kdy napete cube(2.5), vyvol se verze  double.  Kdy zavolte
cube(2.5F), kde pouijete  za  slem literl pro pohyblivou adovou rku,
aplikuje  se  verze  float. Pekryt a  pedefinovn  me  bt  tak  kad
opertor, jako teba +, take me operovat nejenom  s  sly,  ale  tak s
grafickmi objekty, etzci nebo se strukturami dan tdy.



---------------------------------------------------------------------------
Modelovn reality pomoc td
---------------------------------------------------------------------------


   Tda  v  C++  umouje  pirozenou  cestou  vytvet  potaov modely
reality - pomoc tohoto nstroje  vytvoil  Bjarne  Stroustrup  v Bellovch
laboratoch firmy AT&T jazyk modelu velkho telefonnho systmu.

   Mnoho aplikac C++ se vyskytuje v tak automobilovm prmyslu. Napklad
kdy se tvo modely  automobil,  mete se zajmat o fyzick popis (poet
pneumatik,  vkon  motoru,  hmotnost,  atd.)  nebo  o   ostatn  vlastnosti
(zrychlen, brzdy, zen, spoteba  paliva).  Tda  Car  umouje uzavt
fyzikln parametry (data) a chovn  (funkce)  do  jednoho  velmi obecnho
celku. Pomoc ddinosti je mono odvodit  specializovan  tdy Sports_car
nebo  Station_wagon  s  novmi datovmi typy a  funkcemi  nebo  modifikovat
(pepsat) funkce zkladn tdy.  Pitom  je  vyuita  vtina programovho
kdu zkladn tdy nebo zkladnch td.


Tvorba td, grafick pklad
---------------------------------------------------------------------------

   Nejvhodnjm pkladem v grafickm prosted  bude  pro  zatek tda,
kter modeluje fyzick  body  na obrazovce pomoc abstraktnch bod rovinn
geometrie. Mjme tdu struct, kter vol Point, jen obsahuje souadnice X
a Y:

   struct Point { //definuje struct tdu nazvanou Point
      int X;    //data lenu struktury jsou publc
      int Y;
   };

   Kdy se definuje tda, pidvaj se ke stvajcm typm dat v C++ nov.
Jazyk je aplikuje stejnm zpsobem jako zabudovan datov typy.

   Nyn je mono deklarovat nkolik promnnch typu struct  Point  (dle se
na takov promnn budeme strun odkazovat jako na promnn typu Point). V
C je mono deklarovat teba:

   struct Point Origin, Center, Cur_Pos, AnyPoint;,



                                  - 115 - 


v C++ lze zkrtit na:

   Point Origin, Center, Cur_Pos, AnyPoint;

   Termy object a class se v C++ nemn.

   Promnn typu Point (nap. Origin) je jedna z mnoha instanc typu Point.
Vimnte si, e hodnoty (zde souadnice) se piazuj instanci tdy Point,
ne  Point sammu. Zatenci obvykle typ Point  a  jeho  instance  spojuj
dohromady. Je mono napsat Center = Origin (piazen souadnic z Origin do
Center), ale Point = Origin ne.

   Pokud potebujete souadnice X a Y zvl, mete je brt jako nezvisl
leny  (pole)   struktury.  Jinmi  slovy  -  pokud  si  chcete  pedstavit
souadnice  X  a  Y jako bod na obrazovce, mete je  brt  dohromady  jako
Point.

   Stoj ped nmi kol zobrazit bod v danch souadnicch.  Dle  mme  ke
lenm X a Y pidat dal,  kter  indikuje,  jesti dan bod svt nebo ne.
Nov typ struct u tyto ti leny obsahuje:

   Typ Boolean je programtorm v Turbo Pascalu dvrn znm.

   enum Boolean {false, true};    //false=0, true=1
   struct Point {
      int X;
      int Y;
      Boolean Visible;
   };

   Tento fragment pouv  vtov  typ (enum) k vytvoen testu true/false
(pravdiv/nepravdiv).  Protoe  hodnoty  vtovho  typu zanaj od nuly,
Boolean  me  obsahovat  pouze dv hodnoty:  0  nebo  1  (nepravdiv  nebo
pravdiv).


Deklarace objekt
---------------------------------------------------------------------------

   Jako v jinch datovch typech je  mono  pouvat i ukazatele na tdy a
pole td:

   Point Origin;    //deklarace objektu Origin typu Point
   Point Row[80];      //deklarace pole 80 objekt typo Point
   Point *point_ptr;   //deklarace ukazatele na typ Point
   point_ptr = &Origin;  //ukazuje na objekt Origin
   point_ptr = Row;      //te ukazuje na Row[0]


lensk funkce
---------------------------------------------------------------------------

   Jak bylo uvedeno dve, tdy C++ mohou obsahovat funkce i datov leny.
lensk  funkce  je  funkce deklarovan uvnit definice tdy a je striktn
uzavena  v   typu  tdy.  (lensk  funkce  jsou  v  ostatnch  objektov
orientovanch   jazycch  (Turbo  Pascal,  Smalltalk)  znmy  jako   metody
(methods)).

   Datov leny jsou to, co tda zn, lensk  funkce  jsou  to,  co tda
dl.


                                  - 116 - 


   Ke td Point te pidme jednoduchou lenskou funkci GetX.  D  se  to
provst dvma zpsoby :

    o  Definovat funkci uvnit tdy

    o  Deklarovat ji uvnit tdy a definovat mimo

   Tyto dva zpsoby maj jinou syntaxi a jin provdc techniky.

   Prvn zpsob vypad takto :

   struct Point {
      int X,Y;
      Boolean Visible;
      int GetX() { return X; }   ///definice lensk funkce "inline"
   };

   "Inline" funkce jsou detailnji popsny dle.

   Tento zpsob definuje funkce jako  spaen  (inline).  Ve  strunosti -
spaen  funkce  jsou  povaovny za "mal", a proto se kompiluj dovnit,
stejn jako makro, tm se li od normlnho voln funkce.

   Vimnte si, e definice spaen  funkce je stejn jako obvykl syntaxe
v C  pro  definici  funkce  : funkce GetX vrac int a nem dn argumenty.
Tlo  funkce,  uzaven  do  sloench  zvorek   ({}),   obsahuje  pkazy
popisujc prci funkce - v tomto ppad je to jedin pkaz, return X;.

   Pi druhm zpsobu  se  jednodue lensk funkce deklaruje uvnit struct
Point (obvyklou syntax  deklarace  funkce  v  C),  potom  se  nape pln
definice (vetn pkaz tla) kdekoliv mimo tlo definice tdy.

struct Point {
      int X,Y;
      Boolean Visible;
      int GetX() { return X; }   ///deklarace lensk funkce
   };
      int Point:: GetX()   {//definice lensk funkce
      return X;             //mimo tdu
   }


   :: je chpn jako opertor vymezujc pslunost, k kompiltoru, kam
funkce pat.

   lensk  funkce definovan vn definice tdy  mohou  bt  pemnny  na
spaen  (pokud  jsou  splnny jist podmnky), ale je nutno to explicitn
oznmit klovm slovem inline.

   Pozorn si vimnte pouit  vymezujcho  opertoru  v  definici funkce
Point::GetX. Jmno tdy  Point  je  teba  k tomu, aby kompiltor vdl do
kter tdy GetX pat. (V jinch tdch mohou  bt  i  jin  verze GetX.)
Uvnit  definice  nen  Point poteba, vechny identifiktory  se  k  Point
automaticky vztahuj.

   Vymezujc  opertor  popisuje detailnji kapitola  1  "Standard  jazyka
Turbo C++" z Programtorsk pruky.





                                  - 117 - 


   Point:: ped GetX m jet jin vznam. Jeho vliv se vztahuje k definici
funkce,  take  X  v return X; se bere jako odkaz na len X ve td Point.
Vimnte si tak, e tlo Point::GetX  je  v psobnosti Point bez ohledu na
fyzick umstn.

   A  u  jsme pouili jakoukoliv metodu, dleit  je,  e  nyn  mme  k
dispozici lenskou funkci GetX, kter se vztahuje ke  td  Point. Protoe
je to lensk funkce, m pstup  ke  vem datovm promnnm, kter pat k
Point. V naem jednoduchm ppad GetX vrac hodnotu X.


Voln lensk funkce
---------------------------------------------------------------------------

   lensk funkce  pedstavuj operace s objekty pslun tdy. Kdy nyn
zavolme  GetX,  musme  njak  oznait,  se kterm objektem Point se  bude
pracovat.  Pokud  by  GetX  byla  normln funkce C jazyka (nebo  nelensk
funkce C++), tento problm  by  nevyvstal - jednodue by se zavolala funkce
vrazem  GetX().  U  lensk  funkce  je nutno vymezit jmno objektu.  Jej
syntaxe je pirozenm  rozenm  t,  kter  se  pouv v C k odkazm na
leny struktury. Stejn jako  se  odkazuje na Origin.X, na X sloku objektu
Origin nebo Endpoint.Y na Y sloku objektu Endpoint, je mono  vymezit GetX
pomoc Origin.GetX() nebo Endpoint.GetX(). Opertor "." vymezuje komponentu
tdy jak pro data, tak pro funkce. Obecn syntaxe voln je:

   jmno_objektu_tdy.jmno_lensk_funkce(seznam_argument)

   Stejnm zpsobem je mono vybrat pomoc opertoru pro ukazatele "->" :
Point_pointer->GetX().

   V pkladech tto kapitoly je uvedeno mnostv pklad voln funkc.

Konstruktory a destruktory
---------------------------------------------------------------------------

   Existuj  dva  speciln  typy  lenskch   funkc   -   konstruktory  a
destruktory (constructors  a destructors), kter hraj v C++ klovou roli.
K zdraznn jejich  dleitosti  je  teba  krtkho  vysvtlen. Spolen
problm klasickch jazyk  je  inicializace:  ped  pouitm  njak datov
struktury mus  bt  vyhrazena  pam؟  a  provedena  inicializace. Uvaujme
inicializaci struktury, kter byla definovna v pedelm textu:

struct Point {
      int X;
      int Y;
      Boolean ;
};

   Nezkuen programtoi budou piazovat inicializan  hodnoty promnnm
X, Y a Visible tmto zpsobem :

   Point ThisPoint;
ThisPoint.X = 17;
ThisPoint.Y = 42;
ThisPoint.Visible = false;

Tento  zpsob je sprvn, jene zahrnuje  pouze  jeden  specifick  objekt,
ThisPoint. Pokud je nutno inicializovat vce ne jeden  objekt  Point, bude
teba  k  proveden  tho  vce  piazovacch  pkaz.  Proto je  dalm
pirozenm  krokem   vytvoen   inicializan   funkce,   kter  zobecuje


                                  - 118 - 


piazovac  pkazy  tak,  aby se hodily ke  ktermukoliv  objektu  Point,
zadanmu jako argument.

void InitPoint(Point *Target, Int NewX, Int NewY)
{
   Target>X = NewX;
   Target>Y = NewY;
   Target>Visible = false;
}

   Tato funkce vytv ukazatel na objekt Point a pouv  ho  k  piazen
danch hodnot  k  jeho  lenm  (vimnte  si  znovu opertoru ->, kter se
pouv u ukazatel k  odkazu  na leny tdy). Funkce InitPoint je napsna
korektn a je speciln zamena na strukturu Point. Pro  potom  je  nutno
urit typ tdy a patin objekt? Protoe InitPoint  nen  lensk funkce.
Ve, co nm jet chyb k objektov orientaci je lensk funkce, kter bude
inicializovat jakkoliv objekt Point. To je jeden z kol konstruktoru.

   C++ m k vytvoen uivatelsky definovanch typ dat jako zabudovanch
(a snadno pouitelnch) integrlnch soust  jazyka.  Proto  C++ obsahuje
speciln typ lensk funkce  zvan  konstruktor.  Konstruktor  uruje, jak
bude vytvoen nov objekt typu tda, co vymez a inicializuje pam؟. Jeho
definice me obsahovat pkazy pro  vymezen  pamti,  piazen  hodnot k
lenm,  konverze z jednoho typu na druh a cokoliv jinho, co by mohlo bt
uiten. Konstruktory mohou bt definovny uivatelem nebo si C++ me sm
konstruktory definovat.  Konstruktory  mohou  bt  volny  explicitn  nebo
implicitn. Kompiltor C++ automaticky vyvol patin konstruktor kdykoliv
definujete nov  objekt  nebo  tdu.  To  se  me stt pi deklaraci dat,
koprovn objekt nebo  pi  dynamickm vyhrazovn pamti pro nov objekt
pomoc opertoru new.

   Destruktor, jak jmno  napovd,  ni  objekty  td  pedtm vytvoen
konstruktorem  tm,   e  vymae  promnn  a  uvoln  pam؟.  Stejn  jako
konstruktory,  i  destruktory  mohou  bt  volny  explicitn  (pomoc  C++
opertoru  delete)  nebo  implicitn  (napklad  kdy  objekt  vybouje  z
rozsahu). Pokud nedefinujete destruktor  pro  danou  tdu,  C++ vygeneruje
standardn  destruktor.  Syntaxi destruktoru uvedeme  pozdji.  Nejprve  se
podvejme, jak se vytvej konstruktory.

   V nsledujc verzi Point je pidn konstruktor :

struct Point {
   int X;
   int Y;
   Boolean Visible;
   int GetX() {return X;}
   Point (int NewX, int NewY); //deklarace konstruktoru
};
Point::Point(int NewX, int NewY)  //definice konstruktoru
{
   X = NewX;
   Y = NewY;
   Visible = false;
};

   Point::Point zna, e je definovn konstruktor pro tdu Point.

   Definice konstruktoru je zde uvedena mimo  definici  tdy. Konstruktory
mohou  bt  definovny  i  uvnit  tdy jako spaen funkce, ppadn  se
definuj mimo definici tdy a spojuj se pomoc klovho slova inline. Je


                                  - 119 - 


vak nutno jet nco dodat : velikost kdu  generovan  konstruktorem nen
vdy stejn jako viditeln st v jeho definici.

   Vimnte  si,  e  jmno  konstruktoru  se shoduje se jmnem tdy.  Tm
kompiltor pozn, e pat k sob. Vimnte si tak,  e  konstruktor  me
obsahovat argumenty, stejn jako jakkoliv jin funkce. Zde jsou dva : NewX
a NewY. Tlo  konstruktoru  je  stejn  jako  tlo  jakkoliv  jin lensk
funkce, take konstruktor me volat jakoukoliv lenskou funkci, jej tdu
nebo me mt pstup k lenskm datm. Naproti tomu nikdy nevrac hodnotu,
dokonce ani void.

   Nyn je mono deklarovat nov objekt Point :

   Point Origin(1,1);

   Tato deklarace se odvolv na  ve  definovan  konstruktor  Point. Jak
uvidte pozdji, je mono mt pro jednu tdu vce ne jeden  konstruktor a
jako jin pekryvn funkce v C++, me bt vhodn verze automaticky spojena
s patinm  seznamem  argument.  Pokud  nen  konstruktor  definovn, C++
vygeneruje standardn konstruktor bez argument.

   Jinm uitenm trikem v C++ je to, e je mono mt v argumentech funkc
implicitn hodnoty:

   Point::Point(int NewX=0, int NewY=0) //pozmnn definice konstruktoru
   {
   // jako v pedelm
   }

   Deklarace

   Point Origin(5);

piazuje 5 do X a implicitn 0 do Y.


Program a data jako jeden celek
---------------------------------------------------------------------------

   Jednou   z   nejdleitjch    vlastnost    objektov   orientovanho
programovn je, e programtor me pi tvorb brt program  i  data  jako
jeden celek. Ani program, ani data nemohou existovat ve  vakuu.  Data  d
chod programu a program mn tvar a hodnoty dat.

   Pokud jsou data a program oddleny od sebe, vdy existuje  nebezpe, e
se zavol sprvn  funkce  s  nesprvnmi  daty  nebo  nesprvn  funkce se
sprvnmi daty. To je programtorsk zleitost  a  v ANSI C, stejn jako v
klasickm C existuje dobr typov kontrola, kter nejlpe odhal chybu.

   Spojenm  programu  a  dat  do   jednoho  celku  pomhaj  tdy  z  C++
zesynchronizovat tyto  sloky  dohromady.  Napklad  -  zskn  hodnoty z
jednoho z len tdy se provede zavolnm lensk funkce  patc  k  dan
td, kter vrt hodnotu odpovdajcho  lenu. K uloen hodnoty do pole
se zavol lensk funkce, kter piad prvkm pole novou hodnotu.








                                  - 120 - 


zen pstupu k lenm : private, public a protected
---------------------------------------------------------------------------

   I kdy rozen pkaz struct v C++ spojuje dohromady  data  a  funkce,
nen  jet tak ohranien a modulrn, jak by mohl bt. Jak bylo uvedeno v
pedelm,  pstup  ke  vem datovm lenm struct  je  implicitn  public
(veejn, veobecn) - to  znamen,  e jakkoliv pkaz v danm rozsahu je
schopen  st  nebo  mnit vnitn data tdy struct. To me vst k vnm
problmm. Dobr program  v  C++  prosazuje  ukryt  dat  a  informac, co
znamen  uchovvat  data  jako chrnn, zce spojen s nkterm objektem a
vytvet pro pstup k nim  speciln rozhran. Obecnm pravidlem je uinit
vechna  data  privtn,  co  by  znamenalo, e mohou bt pstupn  pouze
pomoc "veobecnch" (public) lenskch funkc. Existuje pouze nkolik mlo
situac, kdy je vhodnj  mt  data  s  veobecnm pstupem (public) ne
data privtn nebo chrnn. Tak nkter lensk funkce obsahujc vnitn
operace by radji mly bt privtn a chrnn ne veobecn pstupn.

   K zen pstupu ke  strukturm  nebo  lenm  tdy slou ti klov
slova. Vhodn klov slovo (s dvojtekou) je umstno ped danou deklarac
lenu :

private:       K lenm za tmto klovm slovem je mono pistupovat pouze
               pomoc lenskch funkc deklarovanch uvnit stejn tdy.

protected:     K lenm za tmto klovm slovem je mono pistupovat pouze
               pomoc lenskch funkc uvnit stejn tdy a pomoc
               lenskch funkc td, kter jsou s touto tdou spojeny
               (viz dle).

public:        K lenm za tmto klovm slovem je mono pistupovat
               odkudkoliv z rozsahu definice tdy.

   Zde je pklad, kter ukazuje, jak pedefinovat strukturu Point tak, aby
data byla privtn a lensk funkce mly veobecn pstup :

struct Point {
private:
   int X;
   int Y;

public:
   int GetX();
   Point(int NewX, int NewY);
};


Tda je implicitn privtn
---------------------------------------------------------------------------

   Tda  struct je implicitn s veobecn pstupn,  take  k  tomu,  aby
nkter  st  byla  privtn,  je   nutno  pout  private  a  nsledn  k
zeveobecnn public. Akoliv je implicitn zprivtnn a  pozdj opatrn
urovn  toho,  co  m  bt  veejn  pstupn  dobrm  cvienm  v  C++,
programtoi v C++ radji  pouvaj  class ne  struct. Jedin rozdl mezi
class a struct je v implicitnm pstupu.

   Point pedefinovan jako tda vypad takto :

class Point {
   int X;   // implicitn privtn


                                  - 121 - 


   int Y;

public:     // potebn k pepisu private
   int GetX();
   Point(int NewX, int NewY);
};

   Pro  data nen pkaz private potebn -  ta  jsou  private  implicitn.
Avak lensk funkce, pokud maj bt pouity mimo tdu  k  inicializaci  a
pepisovn hodnot, mus bt deklarovny jako public.

   Specifikace zen pstupu je mono mnit podle poteby :

enum Boolean (false, true);

class Employee{
   double salary;
   Boolean permanent;
   Boolean professional;

public:
   char name[50];
   char dept_code[3];

private:
   int Error_check(void);

public:
   Employee(double salary, Boolean permanent, Boolean professional, char
            *name, char *dept_code);
};


   Datov  leny  jsou  obvykle  private,  zatmco  lensk  funkce public.
Pstup public pouvejte pouze tam, kde je to opravdu nutn.

   Data salary, permanent a   professional  jsou  implicitn  private, data
name a dept_code  jsou  deklarovny jako public, lensk funkce Error_check
je deklarovna jako private a konstruktor Employee je public.


Sputn programu v C++
---------------------------------------------------------------------------

   Nyn nastal as, abyste ve, co jste se nauili, vloili  do kompletnho
kompilovatelnho  programu.  Ke   kompilaci  C++  programu  v  integrovanm
prosted  je  nutno  obvyklm  zpsobem  run vloit nebo nahrt text  do
editoru.  Z  IDE  je mono program spustit dvma zpsoby. Prvn, implicitn
zpsob je tem, e kompilovn me bt jakkoliv soubor s pponou  .CPP (se
syntax C++) a  .C (se syntax C). Za druh - k pekladu zdrojovch text v
C++ bez uveden ppony je mono vybrat tlatko C++  Always  v  dialogovm
okn Source Options.

   Pro kompilaci C++ programu pomoc  kompiltoru  z  pkazovho  dku je
nutno souboru piadit pponu  .CPP.  Je mono tak pout volbu -P, kter
zpsob,  e  Turbo  C++ piad souboru pponu .CPP automaticky. Pokud m
soubor jinou pponu, muste ji za jmnem souboru  uvst.  Nejsnadnj pro
vs  (i pro druh) bude, kdy vem programm v C++ piadte pponu .CPP a
vem programm v C pponu .C.



                                  - 122 - 


   Program POINT.CPP definuje tdu Point a manipuluje s jejmi daty :

   Tento program je mono nahrt a spustit, jmenuje se POINT.CPP.

*/* POINT.CPP illustrates a simple Point class */

#include <iostream.h>   // needed for C++ I/O

class Point {     // define Point class
   int X;               // X and Y are private by default
   int Y;
public:
   Point(int InitX, int InitY) {X = InitX; Y = InitY;}
   int GetX() {return X;}  // public member functions
   int GetY() {return Y;}
};

int main()
{
   int YourX, YourY;

   cout << "Set X coordinate: ";  // screen prompt
   cin >> YourX;                  // keyboard input to YourX

   cout << "Set Y coordinate: ";  // another prompt
   cin >> YourY;                  // key value for YourY

   Point YourPoint(YourX, YourY);  // declaration calls constructor

   cout << "X is " << YourPoint.GetX(); // call member function
   cout << '\n';                        // newline
   cout << "Y is " << YourPoint.GetY(); // call member function
   cout << '\n';
   return 0;
}


   Tda  Point nyn obsahuje novou lenskou funkci  -  GetY.  Tato  funkce
pracuje stejn  jako  GetX,  je  byla  definovna  dve, jen m pstup k
privtnm  datm  Y.  Ob funkce jsou "krtk" (short) a dobe  se  hod  k
definici tla funkce.

   Stejn  jako  pi  pouit  #define  direktivy u makra, je kd  spaen
funkce  vloen pmo do souboru pokad, kdy  je  funkce  zavolna,  take
voln funkce m vliv  na  velikost vslednho kdu. To je klasick problm
"prostor  kontra  as",  kter  se  vyskytuje v mnoha  programech.  Obecnm
pravidlem  je,  e  spaen  definice  se  pouvaj  pro "krtk"  funkce
obsahujc  jeden  a ti pkazy. Vimnte si,  e  stejn  jako  makro  i
spaen funkce m typovou kontrolu, kter pomh odhalit  chybu  ve voln
funkce. Poet argument ve funkci zvis na vaem  rozhodnut,  stejn jako
to,  jestli m bt funkce spaen nebo ne.  Nejlep  dvod  pro  spaen
funkce vyvstane tehdy, kdy  tlo  funkce je men ne voln funkce, kter
spaen nen.  Ped rozhodnutm, kter zpsob pouijete je mono vyzkouet
oba a podle vsledku si vybrat ten lep.

   Rozhodnut o spaen konstruktoru me zviset na tom, na jak  bzi je
konstruktor zaloen. Konstruktor odvozen tdy, zvlt t, kter obsahuje
virtuln funkce (viz dle) me generovat velk "ukryt" kd.




                                  - 123 - 


   V pedchozm pklad byl konstruktor  Point  definovn  na  konci tdy
jako  nespaen.  Pokud  chcete definovat v jinm poad (nebo jej zaadit
kamkoliv jinam do souboru), co m smysl v mench programech zvci jednoho
souboru, umstte tyto nespaen  definice  hned  za  definici tdy v tom
poad, v jakm byly deklarovny.

   Pokud bude v program  del,  umstte  deklarace td do hlavikovch
soubor  a  definice  funkc  td  v  oddlen   kompilovanch  zdrojovch
souborech  C++. Spaen definice funkc by mly  vdy  bt  v  hlavikovm
souboru.

   Tento  program  pouv  knihovnu  C++  iostreams  (viz  pkaz #include
<iostream.h> na zatku programu).

   cout pedstavuje standardn vstupn stream (implicitn  je  smrovn na
obrazovku). Data (nap. promnn nabo  etzce) jsou do nj poslna pomoc
opertoru <<.

   cin je standatdn vstupn  stream  (obvykle  klvesnice). Znaky psan na
klvesnice  jsou  ukldny  do  promnnch  pomoc  opertoru  >>.  Pouit
opertor >> a << pro I/O stream je typickm pkladem pro C++.

   Knihovna iostream je podrobnji rozebrna dle v tto pruce a  tak v
kapitole 3, "Streamy C++" v Programtorsk pruce.

   Stream funkce jsou vhodn  tam,  kde  se nechcete zabvat formtovacmi
detaily printf a scanf;  pouvaj  se  tak  k pizpsoben vstup nkter
td.

   Kdy jsou hodnoty X a Y nateny z klvesnice, je deklarovn Point objekt
YourPoint s  odpovdajcmi  hodnotami  argument.  Vzpomete  si,  e tato
deklarace automaticky vyvol  konstruktor  pro tdu Point, kter vytvo a
inicializuje YourPoint.

   Zkuste program spustit. Vsledek vypad takto :

   Set X coordinate: 50
   Set Y coordinate: 100
   X is 50
   Y is 100



---------------------------------------------------------------------------
Ddinost (inheritance)
---------------------------------------------------------------------------


   Tdy nemohou existovat ve vakuu.  Program  obvykle  pracuje  s nkolika
rznmi,  ale  spojenmi  datovmi  strukturami.  Napklad  je  mono  mt
jednoduchou  vyrovnvac pam؟, do kter chceme  ukldat  a  vybrat  data.
Pozdji mon budeme potebovat  vytvoit  vce  specializovan vyrovnvac
pamti  -  souborovou  vyrovnvac  pam؟,  kter obsahuje data,  je  jsou
pesunovna do a ven ze souboru a snad i vyrovnvac  pam؟  pro tiskrnu a
jet jednu pro modem.  Tyto  specializovan  vyrovnvac pam؟i maj mnoho
spolench znak, ale  kad  m  sv  specifika  vyplvajc  z  faktu, e
diskov soubory, tiskrny a modemy pracuj odlin.





                                  - 124 - 


   een tto "jednoduch, ale odlin" situace v C++  je  umonit tdm,
aby zddily charakteristiky a chovn z jedn nebo  vce  zkladnch (base)
td. To k intuice. Ddinost je  snad  nejvtm rozdlem mezi C++ a C.
Tdy, kter dd po zkladnch  tdch  se  nazvaj  odvozen (derived).
Odvozen tda me zase sama bt zkladn pro odvozovn dalch td (viz
strom taxonomie hmyzu).


Nov pohled na tdu Point
---------------------------------------------------------------------------

   Zkladem grafiky je  jeden  bod  na  obrazovce  (jeden  pixel).  U bylo
navrhnuto nkolik variant tdy Point,  kter  definovala  bod  pomoc jeho
umstn X a Y,  dle  konstruktor,  kter  vytv a inicializuje umstn
bodu  a  dal  lensk  funkce,  kter  jsou  schopny vrtit  odpovdajc
souadnice X a Y. Jet pedtm, ne nco zanete kreslit, muste se nauit
rozliovat mezi body, kter jsou "on" (zapnuty, svt v  nkter  barv)  a
tmi, kter jsou "off" (vypnuty,  svt v barv pozad). Pozdji samozejm
budete  moci  definovat  barvu, kterou dan bod bude mt a i jin argumenty
(jako teba blikn).  Ze  veho  nejdve  dokoneme  komplikovanou tdu,
kter m mnoho datovch len.

   Zopakujme  si  nai  strategii. Jak jsou dva zkladn druhy informac o
bodu? Jeden druh informac popisuje, kde bod je (umstn) a druh jak bod
je (stav byt bodu - jestli jej vidte v njak barv  nebo  ne).  Z tchto
dvou vlastnost je umstn podstatnj, bez nj by dn bod neexistoval.

   Protoe vechny body mus mt njak umstn, je  mono  vytvoit tdu
Point, co je odvozen  tda  ze  zkladn  tdy Location, kter obsahuje
informace o souadnicch  X  a  Y.  Point  dd ve, co obsahuje Location a
pidv k tomu nco novho - to, co dl Point Pointem.

   Tyto dv spojen tdy mohou bt definovny takto :

   Program je spustiteln pod nzvem point.h.

*/* point.h--Example from Chapter 5 of Getting Started */

// point.h contains two classes:
// class Location describes screen locations in X and Y coordinates
// class Point describes whether a point is hidden or visible

enum Boolean {false, true};

class Location {
protected:          // allows derived class to access private data
   int X;
   int Y;

public:             // these functions can be accessed from outside
   Location(int InitX, int InitY);
   int GetX();
   int GetY();
};
class Point : public Location {      // derived from class Location
// public derivation means that X and Y are protected within Point

   protected:
   Boolean Visible;  // classes derived from Point will need access



                                  - 125 - 


public:
   Point(int InitX, int InitY);      // constructor
   void Show();
   void Hide();
   Boolean IsVisible();
   void MoveTo(int NewX, int NewY);
};


Zkladn tdou je zde Location, Point je odvozen.  Proces  me pokraovat
dle : z Location je mono dle definovat jin tdy, z Point tak, ze td
odvozench od Point dal, atd. Je dokonce mono mt tdu odvozenou z vce
ne  jedn zkladn tdy. To se  nazv  vcensobn  ddinost  (multiple
inheritance) a bude probrna dle.  Velk st prce pi vytven program
v C++ spov v budovn tto tdn hierarchie a ve vyjden  stromu td
pro danou aplikaci.


Ddinost a zen pstupu

   Pedtm ne probereme  lensk  funkce  point.h,  zopakujme  ddinost a
pstupov mechanismus v C++.

   Data ve td Location jsou deklarovna jako protected  -  vzpomete si,
e to znamen, e lensk funkce ve td Location a v odvozen td Point
k nim pistupovat mohou, ale funkce s veobecnm pstupem ne.

   Odvozen tda se deklaruje takto :

   class D : access_modifier B { //implicitn privtn
...
}
nebo

   struct D : access_modifier B { // implicitn public

   D je jmno odvozen tdy, access_modifier je voliteln (bu public nebo
private), B je jmno zkladn tdy.

   S class je access_modifier implicitn  privtn,  se  struct  je public.
(Vimnte si, e uniony nemohou bt bz ani odvozenou tdou.)

   access_modifier se pouv ke zmn pstupu zddnch len tak, jak je
ukzno v nsledujc tabulce :

                        Tab. 5.1: Pstup k tdm

------------------------------------------------------------------------
pstup v zkladn  mni pstupu      zddn pstup
td
------------------------------------------------------------------------
public              public              public
private             public              nen pstup
protected           public              protected

public              private             private
private             private             nen pstup
protected           private             private
------------------------------------------------------------------------



                                  - 126 - 


   Pstup  v odvozen td me bt vce omezen  ne  v  zkladn  td,
nikdy vak ne mn.

   Kdy  budete  vytvet  nov tdy, kter jsou  spojeny  s  existujcmi
tdami, ujistte se, e jste  pochopili vztah mezi zkladnmi a odvozenmi
tdami. Nejdleitj st  je porozumt rovnm pstupu pedstavovanm
specifikacemi  private,  protected  a  public.  Pstupov  prva  mus bt
sprvn zabezpeena (nebo odepena) smrem od rodi k dtem a  vnukm. C++
vyaduje, aby data vdy k n؟emu patila. rove pstupu v  zkladn td
nemus  bt stejn jako v odvozench tdch z n. Jinmi slovy - kdy jsou
leny zddny, mte vdy kontrolu nad tm, jakou maj rove pstupu.

   Vce technickch detail najdete  v  kapitole  1, "Standard jazyka Turbo
C++" v Programtorsk pruce.

   Ze  zkladn  tdy  mus  bt  dal  tda  odvozena privtn  nebo  s
veobecnm pstupem. Privtn odvozen (implicitn  pro  typ  tdy class)
konvertuje leny public a  protected  ze zkladn tdy na leny private ve
td  odvozen;  leny  private zstanou private. (Akoliv  je  pro  tdy
definovno private odvozen, nen  to  nejobvyklej  metoda odvozen - zde
vznikla zvltn situace, kdy implicitn nen obvykl.)

   Odvozen public ponechv rove pstupu nezmnnu.

   Odvozen tda zdd vechny leny zkladn tdy, ale ze zkladn tdy
me pouvat pouze leny protected a public. Privtn leny zkladn tdy
nejsou z odvozench td pstupny.

   Definice  Location  a  Point  uveden  zde pozdji poslou  k  odvozen
dalch td z Point pro obecnj grafick aplikace.

   leny ze zkladn tdy, kter  chcete  pouvat  ve  tdch odvozench
mus bt bu protected nebo public. K lenm private  nen  pstup  mon,
dje se tak jen pomoc vlastnch lenskch funkc nebo friend funkc.

   Pokud  pouijete  odvozen  public,  leny  protected  v  zkladn td
zstanou protected i v  odvozen  td,  a  proto nejsou pstupny zven,
pouze z jinch  veejn  pstupnch  odvozench  a  "ptelskch" (friend)
td. Je vhodn vdy public nebo private uvst, protoe implicitn definice
me vst k omylm. Dobr komente navc zlep itelnost vmi vytvoenho
zdrojovho programu.


Balen td do modul
---------------------------------------------------------------------------

   Tdy  jako  Location  a  Point  mohou  bt  pro dal  pouit  uloeny
spolen.  Spolu s daty, lenskmi funkcemi a  zenm  pstupu  je  tda
vlastn modulem. Pi vvoji programu  je vdy dobr umstit deklarace kad
tdy  nebo  skupiny  td do zvltnho hlavikovho  souboru  a  definice
nespaench lenskch funkc do  zvltnho  zdrojovho  souboru. (Detaily
pouit  sprvce  projekt  pro   sprvu   program   obsahujcch  nkolik
zdrojovch soubor viz  kapitola  2,  "Sprva  vcesouborovch  projekt" v
Uivatelsk pruce.)

   Nkolik  td je tak mono pomoc TLIB  umstit  do  knihovny.  (Tvorba
knihoven viz Uivatelsk pruka, kapitola 5, "Utility".)





                                  - 127 - 


   Umstn td do modul  m  nkolik vhod. Vae tdy je mono pedvat
ve form objekt jinm programtorm. Ti mohou vytvet nov odvozen tdy
bez poteby pstupu k vaim zdrojovm programm. Akoliv C++ verze  2.0 je
zcela  nov, u se objevila na trhu tet generace knihoven td a je mono
oekvat, e programtoi v C++ vytvo dal uiten nstroje k usnadnn
tvorby programovch projekt.

   Nyn vytvome zvl  kompilovateln "moduly" obsahujc tdy Location
a Point. V prvnm  kroku  jsou deklarace tchto dvou td (vetn lenskch
funkc)  tak,  jak  jsou naposledy uvedeny, umstny do souboru point.h (na
vaich distribunch disketch).

   Vimnte si, jak je tda Point odvozena ze tdy Location :

   class Point : public Location { ...

   Klov slovo public ped Location  se  pouv  k  zabezpeen pstupu
lenskch funkc odvozen tdy Point  k  chrnnm  lenm  zkladn tdy
Location. Navc Point krom umstn X a Y dd po Location  lensk funkce
GetX a GetY. V Point je navc chrnn datov len Visible  (vtovho typu
Boolean)  a  pt  funkc  se  veobecnm   pstupem   vetn  konstruktoru
Point::Point. Znovu si vimnte, e je kvli odvozen dalch td z Locate
a Point v nsledujcch pkladech pouito protected namsto private.

   Soubor POINT2.CPP obsahuje definice vech lenskch  funkc  tchto dvou
td :

   Tento program se d spustit pod jmnem POINT2.CPP.

/* POINT2.CPP--Example from Chapter 5 of Getting Started */

// POINT2.CPP contains the definitions for the Point and Location
// classes that are declared in the file point.h

#include "point.h"
#include <graphics.h>

// member functions for the Location class
Location::Location(int InitX, int InitY) {
   X = InitX;
   Y = InitY;
};

int Location::GetX(void) {
   return X;
};

int Location::GetY(void) {
   return Y;
};

// member functions for the Point class: These assume
// the main program has initialized the graphics system

Point::Point(int InitX, int InitY) : Location(InitX,InitY) {
   Visible = false;                  // make invisible by default
};

void Point::Show(void) {
   Visible = true;


                                  - 128 - 


   putpixel(X, Y, getcolor());       // uses default color
};

void Point::Hide(void) {
   Visible = false;
   putpixel(X, Y, getbkcolor()); // uses background color to erase
};

Boolean Point::IsVisible(void) {
   return Visible;
};

void Point::MoveTo(int NewX, int NewY) {
   Hide();         // make current point invisible
   X = NewX;       // change X and Y coordinates to new location
   Y = NewY;
   Show();         // show point at new location
};


   Zkladn konstruktor se vol ped tlem konstruktoru odvozen tdy.

   V tomto pklad je zahrnuta dleit  koncepce  konstruktor zkladnch
td.  Kdy  je definovn objekt Point, je  mono  vyut  faktu,  e  jeho
zkladn tda, Location, u m vlastn konstruktor.  Definice konstruktoru
Point::Point   zan   dvojtekou   a   odkazem  na  zkladn  konstruktor
Location(InitX,InitY).  To  znamen, e konstruktor  Point  nejprve  zavol
konstruktor Location s argumenty InitX a InitY a vytvo a inicializuje tak
datov leny X a Y. Pak se provede tlo konstruktoru Point, kter vytvo a
inicializuje   datov  len   Visible.   Explicitnm   urenm   zkladnho
konstruktoru  si uetme prci (ve vtch  programech  je  to  samozejm
markantnj).

   Ve skutenosti konstruktor odvozen tdy vdy nejprve  vol konstruktor
zkladn  tdy  aby  se ujistil, e  zddn  datov  leny  jsou  sprvn
vytvoeny a inicializovny. Pokud i  zkladn  tda  je  odvozenou tdou,
proces  pokrauje  smrem  dol. Pokud pro nkterou  tdu  X  nedefinujete
konstruktor, C++ vytvo implicitn konstruktor  sm  ve  tvaru  X::X(), to
znamen konstruktor bez argument.

   Pokud konstruktor odvozen tdy nevol explicitn jeden  z konstruktor
jeho  zkladn  tdy,  zavol  se  implicitn  zkladn  konstruktor  (bez
argument).  (Vce  o  konstruktorech   zkladnch   td   je   uvedeno  v
Programtorsk pruce v kapitole 1, "Standard jazyka Turbo C++.)

   Vimnte    si,    e    odkaz    na    konstruktor    zkladn    tdy
Location(InitX,InitY)  se  objevuje  v  definici, ne deklaraci konstruktoru
odvozen tdy.

   Nsleduje hlavn program (spout  se  z  distribun diskety pod jmnem
PIXEL.CPP), kter demonstruje schopnosti td Point a Location.

   Pomoc  souboru  PIXEL.PRJ,  projektu  z  distribun  diskety  je nutno
zkompilovat  a  zlinkovat  POINT2.CPP,  PIXEL.CPP a GRAPHICS.LIB. (Jestlie
neumte pracovat s projektovmi  soubory,  pette  si kapitolu 2, "zen
vcesouborovch projekt" v Uivatelsk pruce.)


/* PIXEL.CPP--Example from Chapter 5 of Getting Started */



                                  - 129 - 


// PIXEL.CPP demonstrates the Point and Location classes
// compile with POINT2.CPP and link with GRAPHICS.LIB

#include <graphics.h>   // declarations for graphics library
#include <conio.h>      // for getch() function
#include "point.h"      // declarations for Point and Location classes

int main()
{
   // initialize the graphics system
   int graphdriver = DETECT, graphmode;
   initgraph(&graphdriver, &graphmode, "..\\bgi");

   // move a point across the screen
   Point APoint(100, 50);   // Initial X, Y at 100, 50
   APoint.Show();           // APoint turns itself on
   getch();                 // Wait for keypress
   APoint.MoveTo(300, 150); // APoint moves to 300,150
   getch();                 // Wait for keypress
   APoint.Hide();           // APoint turns itself off
   getch();                 // Wait for keypress
   closegraph();            // Restore original screen
   return 0;
}


Rozen tdy
---------------------------------------------------------------------------

   Jedna  z  nejlepch  vlastnost  td  je,  e  nov objekty  se  mohou
pizpsobovat  a  bt  tak  schopny  dalch  vhodnch  funkc. Nsledujc
pklad z dve definovanch funkc  Location a Point odvozuje novou tdu,
Circle,  kter  obsahuje  funkce   pro   kreslen,   vymazn,  zvtovn,
zmenovn a pesunovn krunic.

   Tento program se na disku jmenuje CIRCLE.CPP.

*/* CIRCLE.CPP--Example from Chapter 5 of Getting Started */

// CIRCLE.CPP   A Circle class derived from Point

#include <graphics.h>    // graphics library declarations
#include "point.h"       // Location and Point class declarations
#include <conio.h>       // for getch() function

// link with point2.obj and graphics.lib

class Circle : Point {   // derived privately from class Point
          // and ultimately from class Location
   int Radius;           // private by default

public:
   Circle(int InitX, int InitY, int InitRadius);
   void Show(void);
   void Hide(void);
   void Expand(int ExpandBy);
   void MoveTo(int NewX, int NewY);
   void Contract(int ContractBy);
};



                                  - 130 - 


Circle::Circle(int InitX, int InitY, int InitRadius) : Point(InitX,InitY)
{
   Radius = InitRadius;
};

void Circle::Show(void)
{
   Visible = true;
   circle(X, Y, Radius);      // draw the circle
}

void Circle::Hide(void)
{
   unsigned int TempColor;    // to save current color
   TempColor = getcolor();    // set to current color
   setcolor(getbkcolor());    // set drawing color to background
   Visible = false;
   circle(X, Y, Radius);      // draw in background color to erase
   setcolor(TempColor);       // set color back to current color
};

void Circle::Expand(int ExpandBy)
{
   Hide();                       // erase old circle
   Radius += ExpandBy;           // expand radius
   if (Radius < 0)               // avoid negative radius
      Radius = 0;
   Show();                       // draw new circle
};

void Circle::Contract(int ContractBy)
{
   Expand(-ContractBy);       // redraws with (Radius - ContractBy)
};

void Circle::MoveTo(int NewX, int NewY)
{
   Hide();                    // erase old circle
   X = NewX;                  // set new location
   Y = NewY;
   Show();                    // draw in new location
};

main()                        // test the functions
{
   // initialize the graphics system
   int graphdriver = DETECT, graphmode;
   initgraph(&graphdriver, &graphmode, "..\\bgi");

   Circle MyCircle(100, 200, 50);   // declare a circle object
   MyCircle.Show();                 // show it
   getch();                         // wait for keypress
   MyCircle.MoveTo(200, 250);       // move the circle (tests hide
                                    // and show also)
   getch();
   MyCircle.Expand(50);             // make it bigger
   getch();
   MyCircle.Contract(75);           // make it smaller
   getch();
   closegraph();


                                  - 131 - 


   return 0;
}


   Abyste poznali,  jak  pracuje  tda  Circle,  muste  vyzkouet lensk
funkce  z  vpisu CIRCLE.CPP a osvاit si  znalosti  o  deklaraci  tdy  v
point.h

   Nejprve si vimnte, e lensk funkce Circle, potebuj  mt  pstup k
rznm datovm lenm ve tdch Circle, Point a Location.

   Vezmme  Circle::Expand.  Potebuje  mt  pstup  k  int   Radius.  Bez
problm. Radius je definovn jako  private  (implicitn)  v  Circle. Take
Radius je v Circle::Expand pstupn  - je pstupn pouze lenskm funkcm
Circle. (Pozdji uvedeme, e leny  private jsou pstupny i funkcm, kter
jsou definovny jako friend (ptelsk) k dan td.)

   Nyn se  podvejme na lenskou funkci Circle::Hide. Ta potebuje pstup
k  Boolean  promnn  Visible ze zkladn  tdy  Point.  Nyn  je  Visible
chrnna v Point, v Circle je odvozena z Point  implicitn  jako  privtn.
Take podle pravidel uvedench dve  je Visible uvnit Circle typu private
a pstupn stejn  jako  Radius.  Vimnte  si, e jestlie Visible byla v
Point  definovna jako private, nemus bt  pstupna  lenskm  funkcm  v
Circle. To bude pro vs mon popudem udlat  Visible  public.  To  je vak
nesprvn : Visible by se tak stala pstupnou nelenskm funkcm. Je mono
ci, e protected  je  private  s  pvlastkem public pro odvozen tdy :
lensk  funkce odvozen tdy mohou mt pstup  k  protected  lenm  bez
veobecnho zpstupnn danho lenu.

   Nakonec  uvaujme  Circle::Show.  Circle::Show  potebuje mt pstup ke
lenm X a  Y  tdy  Location,  aby  mohla vykreslit krunici. Jak se toho
doshne?  Circle nen pmo odvozena z  Location,  take  pstupov  prva
nejsou okamit nasnad. Circle je odvozena z Point, kter je zase odvozena
z Location. Podvejme se krok po kroku na deklarace pstupu :


1. leny X a Y jsou v Location deklarovny jako protected.

2. Point uruje odvozen public z Location, take Point tak dd leny X a
Y jako protected.

3. Circle je odvozena z Point pomoc implicitnho odvozen private.

4. Proto Circle dd X a Y jako private. Circle::Show  m  tak  k  X  a  Y
pstup. Vimnte si, e X a Y jsou uvnit Location protected.

   Po projt tmto etzcem  pravidel  budete  mon uvaovat situaci, kdy
bude  teba  odvodit z Circle teba PieChart  nebo  Arc.  Je  mono  zmnit
odvozen Circle od Point na public a Radius se stane protected.

   Nyn je u snadn porozumt tomu,  co  se dje v CIRCLE.CPP. Krunice je
ve  skutenosti  tlust  bod, m ve, co  m  bod  (umstn  X,Y,  a  stav
viditeln/neviditeln), plus polomr. Tda  Circle  m  pouze  jedin len
Radius, ale nezapomnejme, e Circle je odvozen od Point. Circle m tedy i
X, Y a Visible, i kdy v definici Circle nejsou vidt.

   Zkompilujte a zlinkujte CIRCLE.CPP,  POINT2.CPP  a  GRAPHICS.LIB. Pome
vm  s tm projektov soubor CIRCLE.PRJ  z  distribun  diskety.  Jestlie
stisknete  jakoukoliv  klvesu,   vykresl  se  krunice.  Znovu  stisknte



                                  - 132 - 


tlatko a  krunice  se  pesune.  Po  dalm  stisku se krunice zvt a
posledn stisk zpsob zmenen.


Vcensobn ddinost
---------------------------------------------------------------------------

   Jak bylo uvedeno ve, tda me ddit z vce ne jedn zkladn tdy.
Mechanismus  vcensobn  ddinosti  je jednm z hlavnch  rys  C++  2.0.
Praktick pklad je uveden v  nsledujcm programu - vpisuje text dovnit
krunic.

   Prvn vc, kter vs  napadne  pi zamylen se nad vypisovnm textu do
krunice bude asi jednoduch  pidn  etzcovho  datovho lenu do tdy
Circle a potom pipsn nkolika dk do Circle::Show tak, aby  se dovnit
krunice vypisoval text. Ale text a krunice jsou zcela odlin  vci: Kdy
pemlte o textu, mte na mysli psmo, velikost znak a mon  jet jin
atributy, z kterch vak dn neum kreslit krunici. Mete si samozejm
odvodit novou tdu pmo z Circle a dt j monost pst text. Ne pracovat
s mnoha jednoduchmi funkcemi je asto lep vytvoit novou "fundamentln"
zkladn  tdu  a  z  n  odvozovat  specializovan  tdy, kter  vhodnm
zpsobem  kombinuj nkter vlastnosti. Tento postup ilustruje  nsledujc
vpis MCIRCLE.CPP

   Definujme novou tdu nazvanou  GMessage,  kter  vypisuje  na obrazovku
etzec na pozice X a Y. Tato tda bude jednm  z  rodi MCircle. MCircle
zdd GMessage::Show a pouije ji k psan textu. Vztahy mezi tmito tdami
jsou znzornny v nsledujcm obrzku :

Ŀ
                           class Location:{     
                           int X;               
                           int Y;               
                           ...                  
                           }                    
                          
                Ŀ
  vĿ         vĿ
   class Point: Location {               Class GMessage: Location { 
   int Visible;                          char *msg;                 
   ...                                   int Font,Field;            
   }                                     }                          
           
                                                        
  vĿ                        
   class Circle: Point {                               
   int Radius;                                         
   ...                                                 
   }                                                   
                          
                
                                    
                  vĿ
                   class MCircle: Circle,GMessage { 
                   ...                              
                   }                                
                  

                      Obr. 5.3: Vcensobn ddinost



                                  - 133 - 


   Tento program je  uloen  na  disku  pod jmnem MCIRCLE.CPP. Je mono ho
spustit pomoc MCIRCLE.PRJ.

*/* MCIRCLE.CPP--Example for Chapter 5 of Getting Started */

// MCIRCLE.CPP        Illustrates multiple inheritance

#include <graphics.h> // Graphics library declarations
#include "point.h"    // Location and Point class declarations
#include <string.h>   // for string functions
#include <conio.h>    // for console I/O

// link with point2.obj and graphics.lib

// The class hierarchy:
// Location->Point->Circle
// (Circle and CMessage)->MCircle

class Circle : public Point {  // Derived from class Point and ultimately
                // from class Location
protected:
   int Radius;
public:
   Circle(int InitX, int InitY, int InitRadius);
   void Show(void);
};


class GMessage : public Location {
// display a message on graphics screen
   char *msg;               // message to be displayed
   int Font;                // BGI font to use
   int Field;               // size of field for text scaling

public:
   // Initialize message
   GMessage(int msgX, int msgY, int MsgFont, int FieldSize,
            char *text);
   void Show(void);         // show message
};


class MCircle : Circle, GMessage {  // inherits from both classes
public:
   MCircle(int mcircX, int mcircY, int mcircRadius, int Font,
           char *msg);
   void Show(void);                 // show circle with message
};


// Member functions for Circle class

//Circle constructor
Circle::Circle(int InitX, int InitY, int InitRadius) :
   Point (InitX, InitY)        // initialize inherited members
//also invokes Location constructor
{
   Radius = InitRadius;
};



                                  - 134 - 


void Circle::Show(void)
{
   Visible = true;
   circle(X, Y, Radius); // draw the circle
}

// Member functions for GMessage class

//GMessage constructor
GMessage::GMessage(int msgX, int msgY, int MsgFont,
         int FieldSize, char *text) :
         Location(msgX, msgY)
//X and Y coordinates for centering message
{
   Font = MsgFont;    // standard fonts defined in graph.h
   Field = FieldSize; // width of area in which to fit text
   msg = text;        // point at message
};

void GMessage::Show(void)
{
   int size = Field / (8 * strlen(msg));     // 8 pixels per char.
   settextjustify(CENTER_TEXT, CENTER_TEXT); // centers in circle
   settextstyle(Font, HORIZ_DIR, size);      // if size > 1, magnifies
   outtextxy(X, Y, msg);                     // display the text
}

//Member functions for MCircle class

//MCircle constructor
MCircle::MCircle(int mcircX, int mcircY, int mcircRadius, int Font,
       char *msg) : Circle (mcircX, mcircY, mcircRadius),
       GMessage(mcircX,mcircY,Font,2*mcircRadius,msg)
{
}

void MCircle::Show(void)
{
   Circle::Show();
   GMessage::Show();
}

main()      //draws some circles with text
{
   int graphdriver = DETECT, graphmode;
   initgraph(&graphdriver, &graphmode, "..\\bgi");
   MCircle Small(250, 100, 25, SANS_SERIF_FONT, "You");
   Small.Show();
   MCircle Medium(250, 150, 100, TRIPLEX_FONT, "World");
   Medium.Show();
   MCircle Large(250, 250, 225, GOTHIC_FONT, "Universe");
   Large.Show();
   getch();
   closegraph();
   return 0;
}






                                  - 135 - 


   Pi ten vpisu se zamte na deklaraci td a vimnte si, jak datov
leny  a  lensk  funkce m dan tda zddny. Mon se podvte znovu na
point.h, protoe tam jsou definovny tdy Location a  Point.  Vimnte si,
e jak MCircle, tak  GMessage  maj  jako  zkladn tdu Location, MCircle
pes Point a Circle a GMessage pmo.

   Opertor :: se pouv k specifikaci funkce z jinho rozsahu astji ne
(implicitn) pouit funkce z danho rozsahu.

   V  tle  definice  MCircle::Show  jsou  zahrnuta   dv   voln  funkc:
Circle::Show(); a Message::Show();. Tato syntaxe znzoruje jin pouit ::
(opertor vymezujc rozsah). Pokud chcete  zavolat  zddnou  funkci, jako
nap. Show, kompiltor potebuje trochu vypomoci: jakou Show mte na mysli?
Bez  vymezen  rozsahu  "override" se Show() obrt na Show() do aktulnho
rozsahu, konkrtn MCircle::Show().  K  vyvoln  Show()  z  jinho rozsahu
(samozejm za pedpokladu, e mte k tomu oprvnn) je nutno napsat jmno
patin  tdy, za nj :: a dle jmno funkce (i s argumenty, pokud njak
existuj). Co ale s  ppadem,  kdy  potebujete zavolat nelenskou funkci
Show? Nape se ::Show() bez uveden jmna tdy.

   Vce detail a  informac  o  rozsahu  v C++ je uvedeno v Programtorsk
pruce, kapitola 1, "Jazykov standard Turbo C++".

   lensk funkce danho jmna  v  odvozen  td pepisuj lensk funkce
stejnho jmna v zkladn td, ale je mono se do zkladn  tdy odvolat
pomoc ::. Pravidla o rozsahu se v C++ a C od sebe nepatrn li.

   Ne skonme s probrnm MCIRCLE.CPP, strun se zmnme o konstruktoru
MCircle. V pedchozm  bylo  uvedeno, jak konstruktor Point explicitn vol
svj zkladn konstruktor v  Location.  Protoe MCircle dd po Circle i po
GMessage, konstruktor Mcircle me bt inicializovn jako obvykle zavolnm
obou zkladnch konstruktor:

   MCircle::MCircle
      (int mcircX, int mcircY, int mcircRadius, int font, char *msg) :
      Circle(mcircX, mcircY, mcircRadius),
      GMessage(mcircX, mcircY, 2*mcircRadius,msg){
   }

   Tlo konstruktoru je zde przdn, protoe vechno potebn je v lenskm
inicializanm seznamu (member  inicialization list) (po dvojtece napete
seznam inicializanch vraz oddlench rkami. S jednoduchou  verz tto
syntaxe  jste  se  setkali  v  konstruktorech zkladnch td  pouitch  v
definicch Point a Circle). Po  zavoln  konstruktoru  Mcircle  (nap. pi
deklaraci objektu MCircle) se vtina innosti odehrv na pozad.

   Detaily volac posloupnosti  konstruktor jsou v Programtorsk pruce
v kapitole 1, "Jazykov standard Turbo C++".

   Nejprve se zavol konstruktor Circle.  Tento  konstruktor  nsledn vol
konstruktor Point, kter zase  vol  konstruktor  Location. Nakonec se vol
konstruktor  GMessage,  kter  vyvolv  konstruktor Location kvli vlastn
kopii  X  a  Y  vlastn  zkladn tdy. Argumenty obsaen v  konstruktoru
MCircle inicializuj vhodn datov leny zkladnch td.

   Pi pouit  destruktor (nap. kdy je objekt mimo rozsah), posloupnost
dealokace je obrcen proti  poslopnosti  v  konstruktoru.  (Konstruktory a
destruktory virtulnch zkladnch td vybouj z rmce tto kapitoly.)




                                  - 136 - 


   Pokud nenapete sv  vlastn  konstruktory  nebo  destruktory,  C++ sm
vygeneruje a vyvol implicitn verze.



---------------------------------------------------------------------------
Virtuln funkce
---------------------------------------------------------------------------


   Kad typ tdy z  grafick  posloupnosti  pedstavuje jin typ obrazce:
bod a krunice. Poadovat zobrazen krunice nebo bodu m samozejm smysl.
Pozdji, jestlie definujete tdy, kter  pedstavuj  jin  obrazce, jako
nap.  pmky,  tverce,  sti  krunic,  atd., mete pro  kadou  napsat
lenskou funkci, kter m za kol je zobrazovat.  Ovlivnni  novm mylenm
OOP mete ci,  e  vechny  tyto  grafick obrazce se mohou na obrazovce
vykreslovat samy.

   Objekty se od sebe li zpsobem zobrazen. Bod se kresl pomoc rutiny,
kter potebuje pouze umstn X,Y a ppadn barvu.  Krunice  potebuje k
vykreslen obecnj grafickou rutinu,  kter  mus  mt  k dispozici X,Y a
tak polomr. st krunice sestv ze zatku a konce hlu a  k nakreslen
je teba odlin algoritmus. Stejn situace nastv pi mazn, pesunovn
a dalch operacch.

   Obyejn  lensk  funkce,  kter  jste  mli  monost   vidt  umouj
samozejm definovat funkci Show  pro  kadou  tdu.  Tyto Show ale nemaj
vlastnosti, kter ns zajmaj.  Grafick  moduly  zaloen  na stvajcch
tdch a  lenskch funkcch potebuj rekompilaci a zmny zdrojovho kdu
pokad, kdy se pidv nov tda s vlastn lenskou funkc Show. Dvodem
je mechanismus C++, kter  e  otzku: "Kter Show m bt pouita?" pouze
temi zpsoby:

1. Existuj rozdly mezi argumenty - Show(int,char) nen stejnou funkc
   jako Show(char*, float).

2. Pouv se opertor rozsahu, Circle::Show se li od Point::Show a
   ::Show.

3. Existuje rozdl mezi objekty td : ACircle.Show vol Circle::Show,
   zatmco APoint.Show vol Point::Show. Jednodueji pomoc ukazatel na
   objekty : APoint_pointer->Show  vol Point::Show.

   Vechna tato rozlien  se  provdj pi kompilaci - mechanismus, kter
to provd, se jmenuje statick (static).

   Typick  grafick  balk  pomcek  (toolbox),  kter   je   k  dispozici
uivateli,  je  uloen  v  souboru  .H  spolu  se zkompilovanmi  lenskmi
funkcemi v .OBJ nebo .LIB. S  omezenmi,  kter s sebou pin asn vazba
(early binding) neme snadno uivatel pidvat nov tdy a i  dal vvoj
balku  in  obte.   C++   obsahuje  k  een  tchto  problm  prun
mechanismus  :  pozdj  (dynamickou)   vazbu   (late,   dynamic  binding)
reprezantovanou specilnmi lenskmi funkcemi zvanmi virtuln.

   Zkladem je, e  voln  virtulnch  funkc  je eeno a pi bhu (co
vyjaduje nzev pozdn vazba). Prakticky to znamen, e  rozhodnut  o tom,
kter z  funkc  Show  bude  zavolna  je  znmo a pi provdn programu.
Virtuln funkce Show, kter je "ukryta" v td B ve zkompilovan knihovn
balku  pomcek, nen vzna k objektu B  stejnm  zpsobem  jako  obyejn
lensk  funkce B. Z B je mono odvodit tdu D pro v oblben obrazec  a


                                  - 137 - 


pipsat  vhodn  funkce   (uloen   v  Show).  Pak  mete  zkompilovat  a
pilinkovat k balku pomcek vlastn soubor .OBJ nebo .LIB. Voln Show, a
u z existujcch lenskch funkc z B nebo  z  novch  funkc,  kter jste
napsali, bude automaticky nasmrovno  na  sprvnou  Show.  Toto rozhodnut
zvis pln na typu  objektu  uvedenm ve voln. Podvejme se na virtuln
funkce "v akci". Potencionlnho kandidta mme v CIRCLE.CPP.


Virtuln funkce v praxi
---------------------------------------------------------------------------

   Uvaujme v CIRCLE.CPP lenskou funkci Circle::MoveTo:

   void Circle::MoveTo(int NewX, int NewY)
{
Boolean vis = Visible;
if (vis) Hide();              //sma pokud je viditeln
X = NewX; Y = NewY;           //nastaven novho umstn
if (vis) Show();              //pokud byl viditeln, pemsti na nov msto
}


   Vimnte si, jak je tato definice jednoduch oproti Point::MoveTo, kter
je  v  zkladn  td  Point  tdy Circle. Ve skutenosti jsou  nvratov
hodnoty,  jmno funkce, poet a typy  formlnch  argument  (znmch  jako
signatura funkce) a dokonce i tlo funkce stejn! Jestlie  C++  naraz  na
dv voln funkc se  stejnm  jmnem, ale s odlinou signaturou, e tyto
potenciln dvojsmyslnosti chyte pomoc funkce overloading. (Vzpomete si,
e v C, stejn jako v  C++  jsou  poadovna jedinen jmna funkc.) V C++
jsou lensk funkce s odlinou signaturou rzn, i kdy maj stejn jmno.

   Ale nae dv  MoveTo  nemaj  na  prvn  pohled  vi  kompiltoru dn
rozdly.  Jak tedy pozn, kter se m volat?  Odpov؃  zn,  e  kompiltor
uruje clovou funkci z typu tdy objektu, odkud se vol funkce.

   Pro Circle nedd MoveTo z Point, zatmco GetX a  GetY  (viz  Location)
ano? Dvod je ten, e Hide  a  Show  volan z Circle::MoveTo se neshoduj s
Hide a Show volanmi v Point::MoveTo. Stejn jsou pouze jmna  a signatury.
Zddn MoveTo z Point by vedlo k voln nesprvnch Hide a Show pi pokusu
o kreslen krunice. Pro?  Protoe  verze Point tchto dvou funkc by byly
omezeny pi kompilaci na MoveTo v  Point  (a  tak v Circle). Jak vs mon
napadlo u dve, eenm je deklarovat Hide a Show jako  virtuln funkce.
To vytvo takovou vazbu, e pi pesunu bodu nebo  krunice  (nebo  n؟eho
jinho) budou zavolny odpovdajc verze Hide a Show.

   Vimnte  si  tak,  e  pokud  chceme  pekompilovat  definici tdy  a
lenskch funkc pro  Location,  Point  a  Circle  do  hledn  knihovny (s
utajenm zdrojovm kdem), nememe samozejm pedem vdt, e objekt jako
MoveTo provd pesun. Tuto technickou otzku zabezpeuj virtuln funkce,
kter jsou jednou z koncepnch vhod OOP. Mete se tak lpe soustedit na
vvoj vcensobn pouitelnch td a metod s menmi obavami o kolizi jmen
td.

   Akoliv pdavn roziiteln knihovny jsou vhodn pro  vtinu jazyk,
pouit  virtulnch  funkc  a  mnohonsobn  ddinosti  v  C++  umouje
doshnout jet vtho pirozenho rozen. Zddte vechno, co obsahuj
zkladn tdy a navc je mono k nov vytvoenm tdm pidat jet dal
vlastnosti, kter umocn jejich schopnosti. Vmi definovan virtuln tdy
se stvaj  rozenm v pirozen hierarchii monost. Protoe jsou jednou
z dleitch st jazyka, neexistuje v pedpokladech mnoho omezen.


                                  - 138 - 


   Po  seznmen  s  vhodami  virtulnch  funkc se podvejme  na  jejich
implementaci a na pravidla, kter je nutno respektovat.


Definice virtulnch funkc
---------------------------------------------------------------------------

   Syntaxe je jednoduch  -  v  prvn  deklaraci  lensk  funkce  se pid
kvalifiktor virtual :

   virtual void Show();
   virtual void Hide();


   Pozor! Jako virtuln  mohou  bt deklarovny pouze lensk funkce! Kdy
je  funkce  jednou  deklarovna  jako  virtuln, nemus bt  v  kterkoliv
odvozen  td  znovu  deklarovna   se   stejnou   signaturou  formlnch
argument,  ale  i  s  odlinm  typem  nvratov  hodnoty. Jestlie  znovu
deklarujete Show se stejnou  signaturou  formlnch  argument a se stejnou
nvratovou hodnotou, nov  Show  je automaticky virtuln nezvisle na tom,
jestli  je pouit kvalifiktor virtual. Tato  nov  virtuln  funkce  Show
pepe Show ze zkladn tdy.

   Je  mono  deklarovat  Show  s  jinou  signaturou  formlnch  argument
(nezvisle  na zmn typu nvratov hodnoty), ale pak  se  stane  pro  tyto
verze Show virtuln mechanismus nefunknm.

   Zatenci by nemli bt  ukvapen  -  jsou  situace, kdy funkce, kter
nejsou virtuln mohou pod sebou skrvat virtuln funkce.

   Voln aktuln verze Show zvis pouze na td objektu  pro  kter  je
Show pouvna, dokonce  i  tehdy,  kdy  se  vol  pomoc  ukazatele (nebo
odkazem) na zkladn tdu. Napklad :

   Circle ACircle;
   Point* APoint_pointer = &ACircle;    //ukazatel na Circle spojen s
                                        //ukazatelem na zkladn tdu,
      APoint_pointer->Show();           //Point vol Circle::Show!

   vpoint.h  a  VCIRC.CPP  (z distribunch disket) jsou  verze  point.h  a
CIRCLE.CPP  s virtulnmi funkcemi Show a  Hide.  Zkompilujte  VCIRC.CPP  a
POINT2.CPP pomoc VCIRC.PRJ. PObا pln stejn jako CIRCLE.CPP. Neuvdme
vpis virtuln verze, protoe  rozdly  se  daj  shrnout do nkolika mlo
bod :

    o  V vpoint.h jsou Show a Hide z Point deklarovny  s  klovm  slovem
       virtual. Show a Hide v odvozen td Circle ve  VCIRC  maj  stejn
       argumenty a vracej stejnou hodnotu jako v zkladn  verzi  v Point.
       To znamen, e jsou tak virtuln, i kdy nen  v  jejich  definici
       uvedeno klov slovo virtual.

    o  Ve VCIRC.CPP nem Circle vlastn lenskou funkci MoveTo.

    o  Circle  se odvod z Point jako veejn pstupn  a  umon  se  tak
       pstup k MoveTo.

   Zopakujme si vznam tchto zmn:





                                  - 139 - 


   Objekty Circle mohou nyn bezpen volat MoveTo, kter se dd po Point.
Show a Hide volan z MoveTo jsou pi bhu programu spojeny se Show a Hide z
Circle.  Jakkoliv objekty Point, kter volaj  MoveTo,  dostanou  verze  z
Point.


Vvoj kompletnho grafickho modulu
---------------------------------------------------------------------------

   Jako nejplnj a nejrealistitj pklad virtulnch funkc vytvome
modul, kter definuje tdy nkterch grafickch objekt a obecnou funkci k
jejich posouvn po obrazovce. Tento  modul,  figures.h  a  FIGURES.CPP (na
distribunch  disketch) je  jednoduchou  implementac  grafickho  balku
pomcek, o kterm bylo pojednno dve.

   Hlavnm kolem pi tvorb modulu FIGURES je umonit uivateli roziovat
tdy definoven v modulu a  zpstupnit  jim  vechny  dleit vlastnosti
modulu. Vytvoit funkci, kter umouje posunovat  podle  uivatelova pn
jakmkoliv objektem po obrazovce, je urit zajmav kole.

   Nejprve  uvaujme  funkci,  kter pijme objekt jako argument a pot jej
posunuje po obrazovce :

   void Drag(Point& AnyFigure int DragBy)
   {
      int DelteX,DeltaY~
      int FigureX,FigureY~
      AnyFigure.Show();                 //kresl obrazec, kter je
      //pesunovn
      FigureX = AnyFigure.GetX();       //inicializace X,Y obrazce
      FigureY = AnyFigure.GetY();
      {
         //Aplikace delta na figure X,Y
         FigureX = FigureX + (deltaX * DragBy);
         FigureY = FigureY + (deltaY * DragBy);
         //a pesun obrazce pomoc AnyFigure.MoveTo(FigureY = FigureY);
      };
   };

Typy odkaz

   Vimnte si, e AnyFigure je typu Point&. To znamen  "odkaz  na  objekt
typu Point" a  je  dal  z  vlastnost  C++. Jak vte, C pedv argumenty
hodnotou,  ne  odkazem.  Pokud  chcete  mt  v  C pm pstup z funkce  k
promnn,  muste mt definovan ukazatel na promnnou,  co  me  vst  k
nemotorn  syntaxi,  protoe  si muste pamatovat odkaz  na  ukazatel.  C++
umouje mt k dispozici promnnou pomoc odkazu. Odkaz se deklaruje pouhm
pipsnm ampersandu (&) za datov typ pi deklaraci promnn.

   Drag vol pomocnou funkci GetDelta, kter zde nen  uvedena.  Ta pebr
od uivatele zmnu  v  X  a  Y,  co  se  dje pomoc klvesnice, myi nebo
joysticku. (Pro jednoduchost obsahuje n pklad vstup z klvesnice.)

   Dleit bod, kter stoj za  zmnku  u  Drag  je  ten,  e  v argumentu
AnyFigure  me  bt  jakkoliv  objekt  typu  Point  nebo objekt  z  Point
odvozen.  Objekty  typu  Point,  Circle  nebo   jakhokoliv   jinho  typu
definovanho pozdji, kter dd  z  Point nebo Circle se bez problm hod
do AnyFigure.




                                  - 140 - 


   Pi pidvn nov lensk funkce  k existujc hierarchii td je teba
trochu  pemlet.   Jak  vysoko  v  hierarchii  m  bt  funkce  umstna?
Zapemlejte o loze, kterou  m  funkce plnit a rozhodnte se, jak irok
m  pouit. Posun obrazce zahrnuje zmnu jeho  umstn  v  zvislosti  na
volb uivatele. V termnech  ddinosti  to znamen, e by funkce mla bt
hned  vedle  MoveTo  -  u  jakkoliv objektu, kter potebuje MoveTo,  bude
vhodn, kdy zdd tak Drag. Proto by Drag ml bt  lenem  Point, aby jej
sdlely vechny typy odvozen od Point.

   Po  uren  zaazen  Drag do hierarchie se ble podvejme na definici.
Jako lensk funkce zkladn  tdy  Point  nepotebuje explicitn odkaz na
argument Point&AnyFigure. Meme znovu napsat Drag,  protoe  funkce, kter
vol  (GetX,  Show,  MoveTo  a  Hide)  se  um  odkazovat  na sprvn  typy
posunovanch objekt. Jak bylo  uvedeno  dve,  funkce  Show a Hide, kter
provdj  speciln  operace,  mohou  bt  virtuln.   Proto   je  meme
pedefinovat bez toho,  e  by  naruili  modul FIGURES. Je teba oetit i
MoveTo, aby volala sprvn verze Show a Hide (vzpomete si, e to byla nae
hlavn motivace ke  zmn  Show  a  Hide  na virtuln funkce). GetX a GetY
nein problmy, jako obyejn lensk funkce dd po Point alias Location,
jednodue vrac datov leny X a Y volanho objektu  z  jakkoliv  odvozen
tdy  definovan  pozdji.  Nezapomete,  e  X  a  Y   jsou   v  Location
chrnny,take je nutno ut odvozen public tak, jak je ukzno.

   Dalm rozhodnutm je, zda uinit Drag virtuln. Testem  jestli  m bt
funkce virtuln je to, jestli bude  jejch  slueb poteba i smrem dol v
hierarchii. Zde neexistuje njak  pravidlo,  ale  pozdji  budeme probrat
rzn nhledy na  vc,  jako teba roziitelnost versus rychlost provdn
(virtuln funkce potebuj o nco mlo vce pamti  a  je  o  trochu del
pstupov doba do pamti). Podvejme se na problm z  hlu  CAD  (Computer
Aided Design -  konstruovn  pomoc potae), kdy nkter tda vytvoen
pozdji bude mon potebovat speciln operace pesunu.  (Napklad pesun
v izometrickm zobrazen.) Proto v nov definici tdy  Point  ve figures.h
udlme Drag virtuln.

   Nezapomete pekompilovat ve, co souvis s tmto hlavikovm souborem.

   class Point : public Location {
   protected:
      boolean Visible;
   public:
      Point(int InitX, int InitY);
      virtual void Show();              //Show a Hide jsou virtuln
      virtual void Hide();
      Boolean IsVisible() {return Visible;}
      void MoveTo(int NewX, int NewY);
      virtual void Drag(int DragBy);
   };


   Nsleduje  hlavikov  soubor  figures.h,  kter obsahuje deklarace td
modulu FIGURES. To je  jedin  st balku, kter mus bt distribuovna ve
zdrojovm kdu.

   Tento program je uloen pod jmnem figures.h.

*// figures.h contains three classes.
//
//  Class Location describes screen locations in X and Y
//  coordinates.
//


                                  - 141 - 


//  Class Point describes whether a point is hidden or visible.
//
//  Class Circle describes the radius of a circle around a point.
//
// To use this module, put #include <figures.h> in your main
// source file and compile the source file FIGURES.CPP together
// with your main source file.

enum Boolean {false, true};

class Location {
protected:
   int X;
   int Y;
public:
   Location(int InitX, int InitY) {X = InitX; Y = InitY;}
   int GetX() {return X;}
   int GetY() {return Y;}
};

class Point : public Location {
protected:
   Boolean Visible;
public:
   Point(int InitX, int InitY);
   virtual void Show();       // Show and Hide are virtual
   virtual void Hide();
   virtual void Drag(int DragBy); // new virtual drag function
   Boolean IsVisible() {return Visible;}
   void MoveTo(int NewX, int NewY);
};

class Circle : public Point {  // Derived from class Point and
                               // ultimately from class Location
protected:
   int Radius;
public:
   Circle(int InitX, int InitY, int InitRadius);
   void Show();
   void Hide();
   void Expand(int ExpandBy);
   void Contract(int ContractBy);
};

// prototype of general-purpose, non-member function
// defined in FIGURES.CPP

Boolean GetDelta(int& DeltaX, int& DeltaY);


   Nsleduje soubor FIGURES.CPP,  kter obsahuje definice lenskch funkc.
Tento me bt en  v  objektu nebo knihovn pro komern ely. Vimnte
si, e konstruktor Circle je definovn vn tdy, protoe obsahuje zkladn
konstruktory. Mon s nm budete  chtt  experimentovat  jako  se spaenou
funkc (viz tedy pojednn o nkolik stran dle). Nelensk funkce umouje
zatenkm nastudovat nebo zopakovat  zklad  C.  Vimnte  si odkazovch
argument, jsou st C++; zbytek programovho kdu je klasickho typu.





                                  - 142 - 


   Tento program je umstn na disketch pod jmnem  FIGURES.CPP.  Je mono
jej  zkompilovat  a  pilinkovat  ke  grafick  knihovn  GRAPHICS.LIB jako
FIGURES.OBJ. Doporuujeme vm to, protoe FIGURES.OBJ  budete  potebovat k
nsledujcmu cvien.

// FIGURES.CPP: This file contains the definitions for the Point
// class (declared in figures.h). Member functions for the
// Location class appear as inline functions in figures.h.

#include "figures.h"
#include <graphics.h>
#include <conio.h>

// member functions for the Point class

//constructor
Point::Point(int InitX, int InitY) : Location (InitX, InitY)
{
   Visible = false;    // make invisible by default
}

void Point::Show()
{
   Visible = true;
   putpixel(X, Y, getcolor()); // uses default color
}

void Point::Hide()
{
   Visible = false;
   putpixel(X, Y, getbkcolor()); // uses background color to erase
}

void Point::MoveTo(int NewX, int NewY)
{
   Hide();          // make current point invisible
   X = NewX;        // change X and Y coordinates to new location
   Y = NewY;
   Show();          // show point at new location
}

// a general-purpose function for getting keyboard
// cursor movement keys (not a member function)

Boolean GetDelta(int& DeltaX, int& DeltaY)
{
   char KeyChar;
   Boolean Quit;
   DeltaX = 0;
   DeltaY = 0;

   do
{
      KeyChar = getch();     // read the keystroke
      if (KeyChar == 13)     // carriage return
         return(false);
      if (KeyChar == 0)      // an extended keycode
         {
          Quit = true;       // assume it is usable
          KeyChar = getch(); // get rest of keycode


                                  - 143 - 


              switch (KeyChar) {
                 case 72: DeltaY = -1; break; // down arrow
                 case 80: DeltaY =  1; break; // up arrow
                 case 75: DeltaX = -1; break; // left arrow
                 case 77: DeltaX =  1; break; // right arrow
                 default: Quit = false; // bad key
                 };
         };
   } while (!Quit);
   return(true);
}

void Point::Drag(int DragBy)
{
   int DeltaX, DeltaY;
   int FigureX, FigureY;

   Show(); // display figure to be dragged
     FigureX = GetX(); // get initial position of figure
   FigureY = GetY();

   // This is the drag loop
   while (GetDelta(DeltaX, DeltaY))
{
      // Apply delta to figure at X, Y
      FigureX += (DeltaX * DragBy);
      FigureY += (DeltaY * DragBy);
      MoveTo(FigureX, FigureY); // tell figure to move
      };
}
// Member functions for the Circle class

//constructor
Circle::Circle(int InitX, int InitY, int InitRadius) : Point (InitX, InitY)
{
   Radius = InitRadius;
}

void Circle::Show()
{
   Visible = true;
   circle(X, Y, Radius);     // draw the circle
}

void Circle::Hide()
{
   unsigned int TempColor;   // to save current color
   TempColor = getcolor();   // set to current color
   setcolor(getbkcolor());   // set drawing color to background
   Visible = false;
   circle(X, Y, Radius);     // draw in background color to
   setcolor(TempColor);      // set color back to current color
}

void Circle::Expand(int ExpandBy)
{
   Hide();                       // erase old circle
   Radius += ExpandBy;           // expand radius
   if (Radius < 0)               // avoid negative radius
      Radius = 0;


                                  - 144 - 


   Show();                       // draw new circle
}

void Circle::Contract(int ContractBy)
{
   Expand(-ContractBy);      // redraws with (Radius-ContractBy)
}


   Nyn je mono vyzkouet FIGURES tak, e jej rozme o novou  tdu pro
obrazec zvanou Arc. Ta je definovna ve FIGDEMO. CPP.  Arc  je  (pirozen)
odvozen ze Circle. Vzpomete si, e Drag me pesouvat  i  obrazce,  kter
nikdy pedtm dve "nevidl"!

   Tento  program  je  umstn  na   disketch   pod   jmnem  FIGDEMO.CPP.
Zkompilujte a pilinkujte jej ke knihovn FIGURES.OBJ.

*// FIGDEMO.CPP -- Exercise for Chapter 5

// demonstrates the Figures toolbox by extending it with
// a new type Arc.

// Link with FIGURES.OBJ and GRAPHICS.LIB

#include "figures.h"
#include <graphics.h>
#include <conio.h>

class Arc : public Circle {
   int StartAngle;
   int EndAngle;
public:
// constructor
   Arc(int InitX, int InitY, int InitRadius, int InitStartAngle, int
       InitEndAngle) : Circle (InitX, InitY, InitRadius) {
       StartAngle = InitStartAngle; EndAngle = InitEndAngle;}
   void Show();  // these functions are virtual in Point
   void Hide();
};

// Member functions for Arc

void Arc::Show()
{
   Visible = true;
   arc(X, Y, StartAngle, EndAngle, Radius);
}

void Arc::Hide()
{
   int TempColor;
   TempColor = getcolor();
   setcolor (getbkcolor());
   Visible = false;
   // draw arc in background color to hide it
   arc(X, Y, StartAngle, EndAngle, Radius);
   setcolor(TempColor);
}

int main()   // test the new Arc class


                                  - 145 - 


{
   int graphdriver = DETECT, graphmode;
   initgraph(&graphdriver, &graphmode, "..\\bgi");
   Circle ACircle(151, 82, 50);
   Arc AnArc(151, 82, 25, 0, 190);

   // you first drag an arc using arrow keys (5 pixels per key)
   // press Enter when tired of this!
   // Now drag a circle (10 pixels per arrow key)
   // Press Enter to end FIGDEMO.

   AnArc.Drag(5);   // drag increment is 5 pixels
   AnArc.Hide();
   ACircle.Drag(10); // now each drag is 10 pixels
   closegraph();
   return 0;
}


Obyejnou nebo virtuln lenskou funkci?
---------------------------------------------------------------------------

   Obecn,  protoe  voln  nevirtulnch  lenskch  funkc  je   o  nco
rychlej ne voln virtulnch,  je  mono  doporuit  pouit obyejnch
lenskch funkc vude tam, kde se o roziovn neuvauje,  kde  se  pouze
pedpokld. Jinak pouvejte virtuln funkce.

   Zrekapitulujme si n postup. Deklarovali  jsme  tdu  Base,  uvnit n
lenskou  funkci  Action.  M  bt  Action obyejn nebo virtuln? Zde  je
nvod: Action bude virtuln tehdy, kdy existuje monost, e nkter tda
vytvoen pozdji z Base Action pepe a vy chcete, aby byl mon pozdj
pstup  k Base. Definujte Action jako obyejnou,  jestlie  je  jasn,  e
odvozen typy budou Action  pouvat  beze zmny (i kdy obsahuj odkazy na
jin,  virtuln  funkce)  nebo  jestlie  odvozen  typy   nebudou  Action
pouvat.



---------------------------------------------------------------------------
Dynamick objekty
---------------------------------------------------------------------------


   Ve vech pedchozch pkladech, krom alokace pole zprv v MCIRCLE.CPP,
mly normln deklarovan  statick  nebo  automatick  objekty  typu tda
vyhrazenu pam؟ bhem kompilace. V tto podkapitole se podvme na objekty,
kter jsou alokovny bhem programu pomoc systmu volnho uloen v pamti
(free memory store).

Tvorba dynamickch objekt je dleitou  technikou  pro  mnoho programovch
aplikac, kde nen ped sputnm programu znmo mnostv dat, kter  se m
uloit do pamti. Jako pklad  uvedeme  databzov  program,  kter ukld
kvli rychlmu pstupu vty o rzn dlce do pamti.

   C++ um pouvat funkce z C, kter alokuj (pidluj) dynamickou pam؟,
jako nap. malloc. Navc obsahuje C++ jet nkter dal vhodn rozen,
kter in dynamickou alokaci  a  dealokaci  spolehlivj. Dleit je, e
existuje jistota, e jsou volny konstruktory a destruktory. napklad :

   Circle *ACircle = new Circle(151,82,50);


                                  - 146 - 


   K alokaci objektu se deklaruje ukazatel na typ objektu a vsledek vrazu
new object type se piazuje do ukazatele. Nyn je mono pout k odkazu na
nov vytvoen objekt ukazatele.

   V tomto ppad je  ACircle  (ukazatel  na  typ Circle) piazena adresa
bloku  pamti o velikosti, kter pojme jeden  objekt  typu  Circle.  Jinmi
slovy ACircle nyn ukazuje na objekt typu Circle, kter je umstn ve voln
pamti.  Pak se vol konstruktor Circle,  aby  inicializoval  objekt  podle
argument.

   Pokud  chcete  vyhradit  pam؟  pro  pole, kter nem  standardn  dlku
datovch typ, pouijte volitelnou syntaxi

   new object [size]

   Napklad  pro  dynamick  vyhraen  pamti  pro pole 50  celch  sel
nazvan counts se pouv:

   counts = new int [50];

   Pokud  chcete  vytvoit  dynamick objekt Point typu  tda,  mete  to
udlat takto:

   Tento program je umstn na  disketch pod jmnem DYNPOINT.CPP. Je mono
tak pout DYNPOINT.PRJ.

*// DPOINT.CPP -- exercise in Chapter 5, Getting Started

#include <iostream.h>
#include <graphics.h>
#include <conio.h>
#include "figures.h"

int main()
{
// Assign pointer to dynamically allocated object; call constructor
Point *APoint = new Point(50, 100);

// initialize the graphics system
int graphdriver = DETECT, graphmode;
initgraph(&graphdriver, &graphmode, "..\\bgi");

// Demonstrate the new object
APoint->Show();
cout << "Note pixel at (50,100). Now, hit any key...";
getch();
delete APoint;
closegraph();
return(0);
}


Destruktory a mazn
---------------------------------------------------------------------------

   Stejn jako je definovn konstruktor, kter se vol vdy, kdy  se tvo
nov  objekt  tdy,  je  mono  definovat i destruktor, kter se  aktivuje
tehdy, kdy je nutno njak objekt zruit, co znamen smazat  jeho hodnotu
a dealokovat pam؟.



                                  - 147 - 


   Pam؟ov msto pro statick objekty vyhrazuje kompiltor; konstruktor se
vol  ped  main  a destruktor po main. V ppad objekt auto se dealokace
provd  po  skonen  deklaran  sti  (za  uzavrac  zvorkou  bloku).
Jakkoliv destruktor, kter je definovn,  se  vol  pi  mazn statickch
nebo  auto  objekt.  (Pokud  nen   destruktor   definovn,   C++  pouije
implicitn.)

   Pokud  ovem  vytvote  dynamick  objekt  pomoc  opertoru  new, jste
odpovdn za jeho uvolnn z pamti, protoe C++ "nev", kdy u nen objekt
potebn. K vymazn z  pamti  se pouv opertor delete. Kdy se provd
delete, je voln jakkoliv destruktor, kter jste definovali.

   O syntaxi destruktor se mete dozvdt vce v Programtorsk pruce,
kapitola 1, "Standard jazyka Turbo C++".

   Opertor delete m tuto syntaxi :

   delete ukazatel;,

kde ukazatel je ukazatel, kter se pouv za new k alokaci pamti.

   Vidli jste, e  konstruktor  tdy  X  m stejn jmno jako jeho tda:
X::X(). Jmno destruktoru tdy X je toto: X::~X().  Krom  uvolnn pamti
provd  destruktor  jet  jin  potebn  kony,  jako  nap.  zapisovn
lenskch datovch pol na disk, uzavrn soubor, apod.


Pklad alokace dynamickho objektu
---------------------------------------------------------------------------

   Nsledujc program je  praktickou ukzkou dynamicky alokovanch objekt
v pamti vetn jejich uvolnn pomoc destruktor. Program ukazuje, jak je
v pamti vytvoen spojen seznam  grafickch objekt, kter jsou po vyuit
opt vymazny.

   Vytvoen spojenho seznamu objekt znamen,  e  kad  objekt obsahuje
ukazatel  na  nsledujc  objekt  v  seznamu.  Typ  Point takov  ukazatel
neobsahuje. Jednoduchm zpsobem,  jak  to  napravit  je pidat ho k nmu a
ujistit se, e i vechny objekty od Point odvozen, ho zdd. Avak cokoliv
pidat k Point znamen, e muste  mt  k dispozici zdrojov kd Point, co
mae  jednu  z  vhod  C++  - schopnost rozen existujcch objekt  bez
nutnosti jejich rekompilace.  Take  v  tomto  pklad  pedpokldejme, e
nemme zdrojov kd Point k dispozici, co umouje ukzat,  jak  je  mono
jinm zpsobem rozit grafickou knihovnu.

   Podvejte se na deklaraci List a Node do nsledujcho vpisu.

   Jednm z mnoha  zpsob  een  bez  proveden zmn v Point je vytvoit
novou tdu, kter  nen  od  Point  odvozena. Typ List je velmi jednoduch
tda,  kter   je  hlavikou  pro  seznam  objekt  Point.  Protoe  Point
neobsahuje ukazatel  na nsledujc objekt v seznamu, provd to jednoduch
struktura Node. Node je jet jednodu ne List, nem  lensk  funkce  a
neobsahuje data krom ukazatele  na  typ  Point  a ukazatele na nsledujc
uzel v seznamu.

   List  m lenskou funkci, kter slou k  pidvn  novch  objekt  do
spojenho seznamu zznam Node na to msto, kam ukazuje ukazatel  jednoho z
uzl  seznamu.  lensk  funkce  Add  vrac ukazatel na objekt typu  Point.
Vzpomete  si,  e  pravidla  tdn  hierarchie  v  C++ povoluj  umstn
ukazatele na jakkoliv typ odvozen z Point do argumentu Item v List::Add.


                                  - 148 - 


   Program ListDemo deklaruje  statickou  promnnou AList typu List a tvo
spojen seznam se temi uzly. Kad uzel ukazuje na jin  grafick obrazec,
kter je bu typu Point nebo typu odvozenho od Point. Poet volnch byt v
pamti je vypisovn  ped  a po vytvoen kterhokoliv dynamickho objektu.
Nakonec je cel struktura vetn t zznam Node a t objekt  typu Point
vymazna a  uvolnna z pamti pomoc automatickho voln destruktoru tdy
List.

   Tento program je uloen na disku pod jmnem LISTDEMO.CPP.

/* LISTDEMO.CPP--Example from Chapter 5 of Getting Started */

// LISTDEMO.CPP           Demonstrates dynamic objects

// Link with FIGURES.OBJ and GRAPHICS.LIB

#include <conio.h>          // for getch()
#include <alloc.h>          // for coreleft()
#include <stdlib.h>         // for itoa()
#include <string.h>         // for strcpy()
#include <graphics.h>
#include "figures.h"

class Arc : public Circle {
   int StartAngle, EndAngle;
public:
   // constructor
   Arc(int InitX, int InitY, int InitRadius, int InitStartAngle,
       int InitEndAngle);
   // virtual functions
   void Show();
   void Hide();
};

struct Node {     // the list item
   Point *Item;   // can be Point or any class derived from Point
   Node  *Next;   // point to next Node object
};

class List {      // the list of objects pointed to by nodes
   Node *Nodes;   // points to a node
public:
   // constructor
   List();
   // destructor
   ~List();
   // add an item to list
   void Add(Point *NewItem);
   // list the items
   void Report();
};

// definitions for standalone functions

void OutTextLn(char *TheText)
{
   outtext(TheText);
   moveto(0, gety() + 12);   // move to equivalent of next line
}



                                  - 149 - 


void MemStatus(char *StatusMessage)
{
   unsigned long MemLeft;  // to match type returned by
            // coreleft()
   char CharString[12];    // temp string to send to outtext()
   outtext(StatusMessage);
   MemLeft = long (coreleft());

   // convert result to string with ltoa then copy into
   // temporary string
   ltoa(MemLeft, CharString, 10);
   OutTextLn(CharString);
}

// member functions for Arc class

Arc::Arc(int InitX, int InitY, int InitRadius, int InitStartAngle,
         int InitEndAngle) : Circle (InitX, InitY,InitRadius)
                              // calls Circle
                              // constructor
{
   StartAngle = InitStartAngle;
   EndAngle = InitEndAngle;
}

void Arc::Show()
{
   Visible = true;
   arc(X, Y, StartAngle, EndAngle, Radius);
}

void Arc::Hide()
{
   unsigned TempColor;
   TempColor = getcolor();
   setcolor(getbkcolor());
   Visible = false;
   arc(X, Y, StartAngle, EndAngle, Radius);
   setcolor(TempColor);
}

// member functions for List class

List::List () {
   Node *N;
   N = new Node;
   N->Item = NULL;
   N->Next = NULL;
   Nodes = NULL;             // sets node pointer to "empty"
                             // because nothing in list yet
}

List::~List()                // destructor
{
   while (Nodes != NULL) {   // until end of list
      Node *N = Nodes;       // get node pointed to
      delete(N->Item);       // delete item's memory
      Nodes = N->Next;       // point to next node
        delete N;            // delete pointer's memory
   };


                                  - 150 - 


}

void List::Add(Point *NewItem)
{
   Node *N;              // N is pointer to a node
   N = new Node;         // create a new node
   N->Item = NewItem;    // store pointer to object in node
   N->Next = Nodes;      // next item points to curent list pos
   Nodes = N;            // last item in list now points
                         // to this node
}

void List::Report()
{
   char TempString[12];
   Node *Current = Nodes;
   while (Current != NULL)
   {
      // get X value of item in current node and convert to string
      itoa(Current->Item->GetX(), TempString, 10);
      outtext("X = ");
      OutTextLn(TempString);
      // do the same thing for the Y value
      itoa(Current->Item->GetY(), TempString, 10);
      outtext("Y = ");
      OutTextLn(TempString);
      // point to the next node
      Current = Current->Next;
   };
}

void setlist(void);

// Main program
main()
{
   int graphdriver = DETECT, graphmode;
   initgraph(&graphdriver, &graphmode, "..\\bgi");

   MemStatus("Free memory before list is allocated: ");
   setlist();
   MemStatus("Free memory after List destructor: ");
   getch();
   closegraph();
}

void setlist() {

   // declare a list (calls List constructor)
   List AList;

   // create and add several figures to the list
   Arc *Arc1 = new Arc(151, 82, 25, 200, 330);
   AList.Add(Arc1);
   MemStatus("Free memory after adding arc1: ");
   Circle *Circle1 = new Circle(200, 80, 40);
   AList.Add(Circle1);
   MemStatus("Free memory after adding circle1: ");
   Circle *Circle2 = new Circle(305, 136, 35);
   AList.Add(Circle2);


                                  - 151 - 


   MemStatus("Free memory after adding circle2: ");
   // traverse list and display X, Y of the list's figures
   AList.Report();
   // The 3 Alist nodes and the Arc and Circle objects will be
   // deallocated automatically by their destructors when they
   // go out of scope in main(). Arc and Circle use implicit
   // destructors in contrast to the explicit ~List destructor.
   // However, you could delete explicitly here if you wish:
   // delete Arc1; delete Circle1; delete Circle2;
   getch();   // wait for a keypress
   return;
}

   Po  zvldnut  LISTDEMO.CPP jste schopni  zkoumat  uitenj  aplikace
zaloen na tto mylence: definovn nov tdy PointList pro vcensobnou
ddinost ze td Point a List.



---------------------------------------------------------------------------
Prunost C++
---------------------------------------------------------------------------


   Pestoe  vm  bude  chvli  trvat,  ne zvldnete obraty  novho  stylu
programovn,  naute  se  nyn  nkterm  prvkm  z  C++.  Ve  strunosti
pojednme  o  mnostv  rozench  vlastnost  tak,  aby  jste vdli  co
znamenaj a jak je pout.

   dn z tchto rys  nen  nezbytn k porozumn C++, ale jejich znalost
umocn vai prunost a schopnosti v programovn v tomto jazyce.

    o  Spaen funkce mimo definice td

    o  Implicitn argumenty funkc

    o  Pepisovn funkc a vcensobn konstruktory

    o  "Ptelsk" funkce = dal zpsob pstupu k tdm

    o  Pepisovn opertor za elem piazen novch vznam

    o  Dal informace o vstupech a vstupech v C++ a o knihovn stream.


Spaen funkce vn definice td
---------------------------------------------------------------------------

   Ve td  Point  jste  vidli,  e  do  deklarace tdy je mono vlenit
definici lensk funkce:

   class Point: {        //definice tdy Point
      int X;             //implicitn privtn
      int Y;
   public:               //veobecn pstupn lensk funkce
      Point(int InitX, int InitY) {X=InitX, y=InitY;}
      int GetX(void) {return X;}
      int GetY(void) {return Y;}
   };



                                  - 152 - 


   Vechny ti lensk funkce  tdy  Point  jsou definovny jako spaen,
take nen nutn zvltn definice. Pro funkce s jedinm dkem  to pin
kompaktn a iteln popis tdy.

   Nezapomete, e spaen kd je uzaven do zvorek.

   Tak funkce mohou bt deklarovny jako spaen. Jedin  rozdl  je ten,
e  funkn  deklarace  mus zanat klovm slovem  inline.  Napklad  v
LISTDEMO.CPP je operace, kter  posunuje  vstup  textu  v grafickm kdu o
jeden dek dol (pouito  ve  funkci OutTextLn). Pokud by tato funkce byla
pouita  na vce mstech v programu, bylo by  vhodn  deklarovat  ji  jako
zvltn spaenou funkci:

   inline void graphLn() { moveto(0, gety() + 12);}

   Pokud si pejete,  je  mono  napsat  spaenou definici tak, e se vce
podob definici "prav" funkce:

   inline void graphLn()
   {
      moveto(0, gety() + 12);
   }

   Dal vhoda pouit klovho  slova  inline je, e je mono se vyhnout
opisu implementace funkce z distribunch hlavikovch soubor.


Funkce s implicitnmi argumenty
---------------------------------------------------------------------------

   Je  mono  definovat  funkce, kter se volaj s menm potem argument,
ne je  definovno.  Vynechan  argumenty  se  nahrad  implicitnmi. Pokud
pedpokldte,  e  budete  hodn  pouvat  implicitnch  hodnot,  pak vm
"zkrcen" voln uet  psan.  Pitom prunost se neztrc, protoe kdy
chcete implicitn hodnoty pepsat, jednodue  uvedete  hodnoty,  kter jsou
potebn.

   Pokud chcete  ve funkci asto pouvat njak hodnoty, vyuijte monosti
implicitnch argument. Implicitn hodnoty  mus  bt  uvedeny  ped jmnem
funkce.

   Napklad  v  nsledujc  verzi konstruktoru tdy Circle  se  bere  za
implicitn krunice  o polomru 50 obrazovch bod umstn na souadnicch
X=200, Y=200. Vce penositeln  program  by  samozejm ml urit grafick
hardware schopn patin tyto hodnoty pizpsobit.

   Stejn  jako  ANSI C i C++ umouje,  aby  funkce  mly  promnn  poet
argument, jako nap. float average(int number, ...), kter  m  jeden nebo
vce celoselnch argument. Detaily  najdete  v  Programtorsk pruce,
kapitola 1, "Standard jazyka Turbo C++".

   class Circle : public Point {            //odvozeno od tdy Point
                                            //a Location
   protected:
      int Radius;
public:
      Circle(int InitX = 200, int InitY=200, int InitRadius = 50);
      void Show(void);
      void Hide(void);
      void Expand(int ExpandBy);


                                  - 153 - 


      void Contract(int ContractBy);
   };

   Deklarace

   Circle ACircle;

v  tomto  ppad  kresl krunici se stedem v (200,200) a s polomrem 50.
Deklarace

   Circle ACircle(50,100);

kresl krunici se stedem v (50,100) s implicitnm polomrem 50.

Deklarace

   Circle ACircle(300)

kresl krunici se stedem v (300,200) a polomrem 50.

   Implicitn argumenty mus bt v  seznamu  na  sprvnch  pozicch. Nap.
nen mono deklarovat

   void func(int a=10, int b=, int c),

protoe kompiltor neme vdt, kter hodnoty maj bt nahrazeny.


Pekryvn funkce - rozen
---------------------------------------------------------------------------

   Pekrvn  je  dleitm  a  astm  obratem v C++. Kdy je  definovno
nkolik  rznch  funkc  (lenskch  nebo  obyejnch)  stejnho  jmna se
stejnm rozsahem psobnosti, kme, e  se  pekrvaj.  S  tmto ppadem
jste se u setkali  pod  jmnem cube. (Dvj verze C++ doporuovaly, aby
takov deklarace byly uvozeny klovm slovem overload, ale temto zpsob je
u zastaral.)

   Zkladn mylenka je ta, e  voln  pekryvnch  funkc  jsou rozliena
porovnnm typ skutench  argument  a  signatur  formlnch  argument v
definicch  funkc. Skuten pravidla k odstrann dvojznanost  pesahuj
rozsah  zklad   C++  a  zatenci  je  potebuj  velmi  zdka.  Mon
komplikace mohou nastat u funkc s promnnm potem argument nebo u funkc
s implicitnmi argumenty, nebo  tehdy,  kdy  se  pouvaj C konverze typ
argument  spolen s typovmi konverzemi specifickmi  pro  C++.  Kdy  se
kompiltor  setk  s  funkc, je se  obtn  pekrv,  sna  se  zvolit
nejvhodnj variantu. Pokud neexistuje, peklad skon chybou.

   Jednm z nejobecnjch ppad  je  pekrvn  konstruktoru  za elem
vytven novch objekt tdy rznmi  zpsoby.  Pro  ilustraci definujeme
jednoduchou  tdu  String.  (Dal  etzcov  tdy jsou k  nahldnut  v
knihovn.)

   Z  IDE  je  mono nahrt a spustit STRING.CPP. Po skonen bhu je teba
nahldnout  do  obrazovky  uivatele  pomoc   Alt-F5   nebo   pomoc  menu
Window|User Screen.

*//STRING.CPP--Example from Chapter 5 of Getting Started */

#include <iostream.h>


                                  - 154 - 


#include <string.h>

class String {
   char *char_ptr;   // pointer to string contents
   int length;       // length of string in characters
public:
   // three different constructors
   String(char *text);           // constructor using existing string
   String(int size = 80);        // creates default empty string
   String(String& Other_String); // for assignment from another
                                 // object of this class
   ~String() {delete char_ptr;};
   int Get_len (void);
   void Show (void);
};

String::String (char *text)
{
   length = strlen(text);  // get length of text
   char_ptr = new char[length + 1];
   strcpy(char_ptr, text);
};

String::String (int size)
{
   length = size;
   char_ptr = new char[length+1];
   *char_ptr = '\0';
};

String::String (String& Other_String)
{
   length = Other_String.length;       // length of other string
   char_ptr = new char [length + 1];   // allocate the memory
   strcpy (char_ptr, Other_String.char_ptr); // copy the text
};

int String::Get_len(void)
{
   return (length);
};

void String::Show(void)
{
   cout << char_ptr << "\n";
};

main ()                                // test the functions
{
   String AString ("Allocated from a constant string.");
   AString.Show();

   String BString;             // uses default length
   cout << "\n" << BString.Get_len() << "\n" ; //display length
   BString = "This is BString";

   String CString(BString);    // invokes the third constructor
   CString.Show();             // note its contents
}



                                  - 155 - 


   Kdy  se vol konstruktor bez argument (nebo  kdy  se  maj  aplikovat
vechny implicitn argumenty),neuvdj se za jmnem objektu przdn kulat
zvorky. Napklad deklaruje se String BString;, ne String BString();.

   Tda String  m  ti  odlin  konstruktory.  Prvn  obsahuje obyejnou
etzcovou konstantu jako teba "This is a string" a inicializuje etzec s
tmto obsahem. Druh konstruktor uv implicitn dlku 80 a vymezuje pam؟
pro etzec bez uloen  znak  (tento zpsob se pouv k tvorb doasnch
vyrovnvacch  pamt).  Vimnte  si,  e  implicitn  hodnotu   je  mono
jednodue zmnit pomoc konstruktoru s jinou dlkou: msto deklarace String
AString je mono deklarovat napklad String AString(40).

   Tet konstruktor obsahuje  odkaz  na jin objekt typu String (vzpomete
si, e ampersand  za typem znamen odkaz na tento typ a pouv se k odkazu
na adresu msto  koprovn  jejho  obsahu  =  voln  hodnotou).  S tmto
konstruktorem nyn mete pst pkazy jako je tento:

   String AString("This is the first string");  //vytvoen a inicializace
String BString = AString;  //vytvoen a nsledn piazen AString do
                           //BString

   Vimnte  si,  e  konstruktory  jsou  zalenny do t  svzanch,  ale
zrove oddlench st prbhu innosti objekt : vytvoen, inicializace
a piazen. Pouit opertoru = pro piazen tdy ns pivd  k dalmu
tmatu - pekrvn opertor. Bez  definice  specilnho  opertoru  = pro
tdu obsahuje C++ piazen len ke lenu.


Nov vznamy pomoc pekrvn opertor
---------------------------------------------------------------------------

   C++ m zvltn vlastnost,  kterou  m  jen  nkolik mlo jinch jazyk:
existujc  opertory (nap. +) mohou dostat novou  funkci  tak,  aby  byly
schopny  pracovat  s  vlastnmi  tdami  objekt  dle  poteby  uivatele.
Opertory se pouvaj velmi jednodue.  Pokud je nemte k dispozici, vraz
jako  line  *  width + pos  me  bt  pepsn  teba  jako  add(mult(line,
width),pos).  Aritmetick opertory v C (i v C++)  um  pracovat  se  vemi
numerickmi datovmi typy. Stejn opertor +    pracuje s int jako s float,
naproti tomu je ale vsledn kd zcela odlin, protoe cel sla  a sla
s pohyblivou adovou rkou jsou v pamti uloena jinak. Jinmi slovy  - u
v  C se opertory jako teba +, pekrvaj.  C++  tuto  mylenku  jednodue
roziuje o uivatelsky definovan verze existujcch opertor.

   K  definici  opertoru  je teba definovat funkci,  jej  jmno  zan
klovm  slovem  operator,  za  nm  nsleduje  symbol  opertoru. (take
napklad operator+ je verze  opertoru  +).  Vechny funkce opertoru jsou
touto definic pekryty, pouv se sice stejn opertor, kter m v C svj
vznam,  ale  nyn  je pedefinovn pro pouit jinho datovho typu. Nap.
opertor + st dv hodnoty  standardnch  numerickch  typ  (int, float,
double, atd.).

   Nyn ke td  String  pidme  opertor  +.  Tento  opertor  spoj dva
etzcov  objekty  (jako  v BASICu) a vrac vsledek jako etzcov objekt
patin  dlky  a  obsahu. Protoe spojen je jako "seten dohromady", je
symbol  +  nejvhodnj.  Pznivci BASICu asto kritizuj C jazyk, e nem
tyto pirozen etzcov opertory. Proto je C++ obsahuje.

   Soubor XSTRING.CPP z  distribunch  disket je dodatkem k STRING.CPP, ke
ktermu pidv opertor +.



                                  - 156 - 


*//XSTRING.CPP--Example from Chapter 5 of Getting Started */
// version of STRING.CPP with overloaded operator +

#include <iostream.h>
#include <string.h>

class String {
   char *char_ptr;   // pointer to string contents
   int length;       // length of string in characters
public:
   // three different constructors
   String(char *text);           // constructor using existing string
   String(int size = 80);        // creates default empty string
   String(String& Other_String); // for assignment from another
                                 // object of this class
   ~String() {delete char_ptr;}; // inline destructor
   int Get_len (void);
   String operator+ (String& Arg);
   void Show (void);
};

String::String (char *text)
{
   length = strlen(text);  // get length of text
   char_ptr = new char[length + 1];
   strcpy(char_ptr, text);
};

String::String (int size)
{
   length = size;
   char_ptr = new char[length+1];
   *char_ptr = '\0';
};

String::String (String& Other_String)
{
   length = Other_String.length;       // length of other string
   char_ptr = new char [length + 1];   // allocate the memory
   strcpy (char_ptr, Other_String.char_ptr); // copy the text
};

String String::operator+ (String& Arg)
{
  String Temp( length + Arg.length );
  strcpy(Temp.char_ptr, char_ptr);
  strcat(Temp.char_ptr, Arg.char_ptr);
  return Temp;
}

int String::Get_len(void)
{
   return (length);
};

void String::Show(void)
{
   cout << char_ptr << "\n";
};



                                  - 157 - 


main ()                                // test the functions
{
   String AString ("The Quick Brown fox");
   AString.Show();

   String BString(" jumps over Bill");
   String CString;
   CString = AString + BString;
   CString.Show();
}


   Po sputn programu se  do  CString  piad  spojen etzce AString a
BString. CString.Show() pak vypisuje

   The Quick Brown Fox jumps over Bill

   Stisknte Alt F5 nebo vyberte Window|User.

   Pekryvn opertor + m  pouze  jeden  explicitn argument, take mete
bt pekvapeni, jak pracuje pi spojovn  etzc.  Kompiltor vyhodnocuje
vraz AString+BString takto:

   AString.(opertor+(BString)),

take opertor +  m  pstup  ke  dvma etzcm. Prvnm je objekt String,
kter je prv  aktuln.  Funkce  st  dlky obou etzc a pot vyuv
slueb knihovn funkce strcat ke  spojen obsahu obou etzc; tato hodnota
se vrac. Tento  zaznamennhodn  trik pouv "skryt" ukazatel znm pod
jmnem this. Co je to this?

   Detailnji je this probrn v Programtorsk pruce.

   Kad voln ze lensk funkce  nastavuje ukazatel na objekt, ze kterho
je voln provdno. Na tento ukazatel je mono se odkzat pomoc klovho
slova this (v  ei  argonu  OOP  je  tak znmo jako "ukazatel na sebe"),
kter umouje funkcm pstup  ke  skutenmu  objektu.  Nyn je this typu
"ukazatel na etzec", take nvratov  hodnota  mus  bt  *this, aktuln
skuten objekt. Vimnte si tak,  e na jednotliv leny objektu obsaen
ve funkci je mono se odkzat vrazem this->len. Dal dleitou poznmkou
je  to,  e  pomoc  this  je  mono se odkazovat pouze na lensk,  ne  na
ptelsk funkce.

   Omezen pi pouit pekrvn opertor:

    o  C++ neum rozliit pedponu a pponu ++ a --.

    o  Opertor, kter  chcete  definovat,  mus  v  jazyce  C++ existovat.
       Napklad nen mono definovat opertor #.

    o  Nen mono pekrvat tyto opertory:
       . .* :: ?:

    o  Pekryt opertory zachovvaj pvodn prioritu.

    o  Pi pouit @ s unrnm opertorem mohou bt vrazy @x a  x@ chpny
       bu   jako   x.opertor@()   nebo   jako  opertor@(x).  Pokud  jsou
       deklarovny oba  zpsoby,  kompiltor  se  tuto  dvojznanost  sna
       vyeit  porovnnm  argument. Jednodue eeno  -  pi  pekryvnm
       binrnm opertoru  @  me  x@y  znamenat  bu  x.opertor@(y) nebo


                                  - 158 - 


       opertor@(x,y)  a  kompiltor  bere  pro  rozlien  argumenty  obou
       zpsob.  V  etzcov  verzi + jste mli monost vidt pklad, kdy
       AString   +  BStrig   byl   interpretovn   jako   AString.(opertor
       +(BString)).


Sptelen funkce
---------------------------------------------------------------------------

   Pstup  k  privtnm  lenm dan tdy maj pouze jej lensk funkce.
Nkdy je ovem nezbytn poskytnout pstup k datm tdy i vnjm funkcm.
Deklarace  friend  uvnit  tdy  umouje  urit ty vnj funkce (nebo  i
vnj  tdy),  kterm  m bt umonn pstup  k  deklarovanm  privtnm
lenm dan tdy. Mon nkdy  uvidte  i  pekryvn  opertor deklarovan
jako  "sptelen", ale obecn je mono ci,  e  sptelen  funkce  jsou
pouvny jako kompromis -  pokud  jsou  ve  vaem programu nezbytn nutn,
znamen to, e je teba pebudovat hierarchii td.

   Pesto pedpokldejme, e je teba, aby  obrazovkov  orientovan funkce
Fancy_Print mla pstup k obsahu objektu tdy String. K seznamu deklarac
lenskch funkc se pid tento dek:

   class String{
   ...
   friend void Fancy_Print(String& AString);
   ...

   Na pozici deklarace nezle.

   V tomto  vykonstruovanm pklad m funkce Fancy_Print pstup k lenm
char_ptr  a  length  objektu tdy String. Take pokud AString je etzcov
objekt, Fancy_Print m pstup k AString.char_Ptr a k AString.length.

   Pokud  funkce  Fancy_Print  je  soust  jin  tdy  (napklad  tdy
Format), pouv se v deklaraci opertor vymezujc rozsah:

friend void Format::Fancy_Print(String& AString);

   Pomoc slova class v  deklaraci  je  mono  jako sptelenou definovat i
celou tdu:

   friend class Format;

   Nyn m jakkoliv lensk funkce tdy Format pstup k privtnm lenm
tdy String. Vimnte si, e  v  C++,  stejn  jako  v  ivot,  nen tato
situace  trazitivn: pokud X je ptelem Y a Y je ptelem Z, neznamen to,
e X je ptelem Z.

   Sptelen deklarace by se  mly  pouvat jen tehdy, kdy je to opravdu
nutn;  bez jejich existence by jste zase  museli  mt  dokonale  uzavenou
hierarchii td. Ve  sv  podstat sptelen deklarace ru ohranienost a
modularitu. Pokud budete chtt uinit  jednu  tdu  sptelenou  s druhou,
uvaujte, zda by msto tto monosti nepichzela v vahu spolen odvozen
tda s pstupem k potebnm lenm.








                                  - 159 - 


Knihovny stream v C++
---------------------------------------------------------------------------

   Tato  podkapitola  je urena pouze k "vylepen  chuti  do  prce"  a  k
natoen do sprvnho  smru.  Doporuujeme vm studovat a experimentovat s
pklady z Programtorsk pruky kapitola 3, "Streamy C++".

   Krom vstup/vstupnch funkc  z  knihovny stdio (nap. printf a scanf),
kter u umme pouvat,  poskytuje  C++ tak skupinu dalch td a funkc
pro  vstup  a  vstup sdruench v knihovn iostreams. K pstupu k n mus
v program obsahovat direktivu  #include<iostream.h>,  tak  jak ji bylo v
nkterch pkladech uvedeno.

   Pouit iostreams  m oproti stdio nkolik vhod. Syntaxe je jednodu,
elegantnj  a  vce  pochopiteln.  Mechanismus  C++   stream   je  tak
efektivnj  a  prunj.  Napklad  formtovn vstupu je zjednodueno
irokm  pouvnm  pekrvn.  Stejn  opertor  me bt pouit  jak  k
vstupu peddefinovanch, tak k vstupu uivatelem definovanch  dat vetn
vech vhod seznamu argument v printf.

   Stream je abstrakce modelu proudu dat z odeslatele (zdroje) k pjemci.
iostream obsahuje rozvtvenou hierarchii td pro prci se vstupy a vstupy
soubor a zazen pomoc vyrovnvac pamt i bez n.


   Turbo  C++  podporuje  i  star  (verze 1.x) knihovny stream C++,  aby
umonila programtorm pechod do nov  knihovny  iostream  C++  verze 2.0.
Pokud mte jin C++, kter pouv zastaral tdy stream, je mono  s nimi
pracovat  a  spoutt je i v Turbo C++. Muste je ovem  pi  psan  novho
programu  konvertovat  na  iostream  a  vyhnout  se  stream.  Rozdly  mezi
knihovnami  stream a iostream vysvtluje Programtorsk pruka,  kapitola
3,  "Streamy  C++".  Obsahuje  zrove  i  pokyny  ke  konverzi.  Viz  tak
distribun diskety, soubor OLDSTR.DOC.

   V  tto  podkapitole  se  budeme  zabvat pouze jednoduchmi  tdami  z
iostream. Detaily naleznete v Programtorsk pruce, kapitola 3, "Streamy
C++". Je tak mono podvat se na distribun diskety, kde je  definovno a
odvozeno mnostv td pomoc jednoduch a vcensobn ddinosti.


Standardn I/O (vstup/vstup)

   C++ obsahuje tyi peddefinovan objekty:

cin            standardn vstup, obvykle klvesnice, odpovd stdin v C

cout           standardn vstup, obvykle obrazovka, odpovd stout v C

cerr           standardn chyba vstupu, obvykle obrazovka, odpovd sterr      v
               C

clog           verze cerr s vyrovnvac pamt (v C neexistuje ekvivalent)

   Tyto standardn streamy je mono pesmrovat na jin zazen a soubory.
(V  C  je mono pesmrovat pouze stdin a stdout.) cin a  cout  maj  mnoho
spolenho, co uvidte na pkladech v tto kapitole.

   Zde  je  jednoduch  pohled   na   hierarchii   iostream   s  primitivn
specializac:
streambuf                  provd metody vyrovnvacch pamt


                                  - 160 - 


los                        uchovv stavov promnn a chyby stream

istream                    vybr  formtovan  a   neformtovan  konverze
                           znak ze streambuf

ostream                    ukld  formtovan  a   neformtovan  konverze
                           znak do streambuf

iostream                   kombinuje  istream  a  ostream  do  obousmrnch
                           operac v jedinm streamu

istream_withassign         uchovv  konstruktory  a  piazovac opertory
                           streamu cin

ostream_withassign         uchovv  konstruktory  a  piazovac opertory
                           stream cout, cerr a clog

   Pouit << spolu se streamem znamen uloen, >> vbr z opertoru.

   Tda istream obsahuje pekryvn definice pro opertor >> pro standardn
typy [int, long, double,  float,  char  a  char*(etzec)]. Pkaz cin>> x;
vol vhodnou funkci opertoru >> pro iostream cin, kter  je  definovna  v
iostream.h a pouv ji  k  nasmrovn  tohoto  vstupnho streamu do seku
pamti pedstavovanm promnnou x. Podobn tda ostream obsahuje pekryvn
definice pro opertor <<, kter umouje pkazu cout << x;  poslat hodnotu
x do ostream cout na vstup.

   Tyto funkce opertor vrac krom pesunu dat i odkaz  na  patin  typ
stream tdy (nap.  ostream&).  To  umouje  spojen  nkolika takovchto
opertor do vstupn nebo vstupn sekvence znak:

   int i=0, x=243; double d=0;
   cout << "The value of x is " << x <<'\n';
   cin >> i >> d; // vstup int, mezera, double

   Druh dek vypisuje "The  value  of  x  is 243", nsleduje oddkovn.
Dal pkaz nat a konvertuje znaky na slo integer a  ukld  je do i,
ignoruje nsledujc mezeru, nate  a  konvertuje  dal  znaky na double a
ulo je do d.

   Nsledujc program  pouze kopruje cin do cout. Bez pesmrovn nat
z klvesnice a vypisuje na obrazovku:

   // COPYKBD.CPP   kopruje z klvesnice na obrazovku
   #include <iosream.h>
   main()
   {
      char ch;
      while (cin >>cg)
         cout << ch;
   }

   Vimnte si, e je mono  testovat (cin >>ch) jako normln booleanovsk
vraz. Tento uiten trik je mon dky definicm ve  td  ios.  Strun
eeno, vraz jako (cout) nebo (cin >>ch) je chpn  jako  ukazatel,  jeho
hodnota zvis na nastaven chyby  ve streamu. Przdn ukazatel (vraz nen
pravdiv) indikuje ve  streamu  chybu, zatmco neprzdn ukazatel (vraz je
pravdiv) chybu nezpsob. Test je mono invertovat pomoc !, take (!cout)
je pravdiv, kdy je ve streamu cout indikovna chyba a nepravdiv, kdy je
cout v podku:


                                  - 161 - 


   if (!cout) errmsg("Chyba vstupu!");


Formtovan vstup

   Jednoduch I/O v C++ je vkonn proto, e se provd  minimln konverze
dat  podle  obsaench  datovch typ. Pro  cel  sla  se  provd  tat
konverze jako v printf. Pkazy

   int i=5; cout<<i;

a

   int i=5; printf("%d",i);

dvaj stejn vsledek.

   Formtovn  se provd podle mnoiny stavovch formtovacch  pepna
uvedench  v  ios.  Ty pro kad  aktivn  stream  uruj  zklad  konverze
(destkov, oktln  nebo  hexadecimln),  smr  vyplovn  (zprava  nebo
zleva),   formt   pohybliv   adov   rky   (vdeck   nebo   pevn)  a
vynechn/nevynechn mezery na vstupu.  Dal  parametry,  kter  je mono
zmnit jsou velikost pole (pro vstup) a znak uvan pro  vyplovn. Tyto
pepnae  mohou  bt  nastavovny,  testovny  a  mazny   pomoc  rznch
lenskch  funkc.  Nsledujc  fragment   ukazuje   jak   pracuj  funkce
ios::width a ios::fill:

   int previous_width, i=87;
   previous_width = count.width(7);     //nastaven velikosti pole na 7
                                        //a uchovn pedchoz velikosti
   cout.fill('*');                      //nastaven znaku vpln na *
   cout << i << '\n';                   //vypsn *****87 <newline>
   //po << je ka 0
   //pedchoz velikost me bt nastavena bez sekvence <<, take
   //je mono ji obnovit pomoc nsledujcho dku.
   cout.width(previous_width);

   Nastavenm width na nulu (implicitn)  znamen,  e  obrazovka  m tolik
pozic,  kolik je poteba. Pokud je dan  ka  pro  sprvnou  reprezentaci
mal, nastav se ka nula  (to znamen, e se nezaokrouhluje). Implicitn
se pro vechny typy zaokrouhluje vpravo (vyplovn zleva).

   setf   a   unsetf   jsou  dv  obecn  funkce  pro  nastaven  a  ruen
formtovacch pepna:

   cout.set(ios:left, ios::adjustfield);

   Tento pkaz nastavuje vyplovn zleva.  Prvn  argument  uv vtov
mnemoniky pro rzn  bitov  pozice  (kombinovateln  pomoc & a |) a druh
argument  je pole pro uloen formtu. unsetf pracuje  stejn,  jen  s  tm
rozdlem, e mae vybran bity.

   Manipultory

   Nejelegantnjm  zpsobem  jak  nastavit  pepnae  formtu  (a  dal
pomocn   pznaky  streamu),  je  pout  speciln  mechanismus   nazvan
manipultory. Stejn jako opertory << a >> mohou bt manipultory obsaeny
v operacch se streamy:

   cout << setw(7) << dec << i << setw(6) << oct << j;


                                  - 162 - 


   Bez pouit manipultor by tyto kony zabraly est dk.

   Manipultor   s  parametry  (parametrizovan)  setw  ukld   jednoduch
argument typu int do nastaven velikosti pole.

   Manipultory  bez  parametr,  jako  nap.  dec,  oct  a  hex  nastavuj
konverzn  zklad  na  decimln,  oktln  a  hexadecimln.  V pedchozm
pklad  int i vype decimln obsah pole o dlce 7, int j vype oktln
pole dlky 6.

   Jin  jednoduch parametrizovan  manipultory  jsou  setbase,  setfill,
setprecision,   setiosflags   a  resetiosflags.  K   tomu,   abyste   mohli
parametrizovan manipultory pout,  mus program obsahovat dva hlavikov
soubory:  iomanip.h a iostream.h. Neparametrizovan manipultory  iomanip.h
nepotebuj.

   Neparametrizovan manipultory jsou tyto:

ws (whitespace extractor):istream >> ws; vynechv v istream mezery.

endl (endline and flush): ostream << endl; vkld do ostream znak  pro nov
dek a pak ostream ***vyist***.

ends (end string with null): ostream << ends; pidv znak null do ostream.

flush (flush output stream): ostream << flush; ***vyist*** ostream.


   put, write a get

   Za  zmnku  stoj  dv obecn funkce pro vstup: put a write, kter jsou
deklarovny v ostream nsledujcm zpsobem:

   ostream& ostream::put(char ch);
   //posl ch do ostream

   ostream& ostream::write(const char* buff, int n);
   //posl n znak z buff do ostream; podvejte se na velikost n!

   put a write umouj vstup  naformtovanch  binrnch  dat  do ostream
objektu.  put  vysl  jeden znak, zatmco write um poslat jakkoliv poet
znak z  oznaenho  bufferu.  write  se  pouv  tam, kde je teba vyslat
"syrov" znaky, kter mohou  obsahovat  znak  null.  (Vimnte si, e zpis
binrnch dat pedpokld, e soubor  je oteven v binrnm mdu.) Normln
funkce pro vybrn z  etzce  fungovat  nebude,  protoe kon innost po
naten null.

   Vstupn alternativa put se jmenuje get:

   char ch;
   cin.get(ch);
   //bere nsledujc znak z cin nehled na mezery

   Dal verze  get  bere  libovoln  poet  znak  z istream a po zvolen
maximum a umsuje je do oznaenho  bufferu  (stejn jako u write mus bt
soubory oteveny v binrnm mdu):

   istream& istream::get(char *buf, int max, int term='\n');
   //nat z istream max znak a umsuje je v buf. Kon tehdy, kdy
   //naraz na ukonovac znak.


                                  - 163 - 


   term je mono nastavit na urit ukonovac znak (implicitn je  to znak
pro  nov  dek  newline) na kterm get zastav natn do buf jet ped
dosaenm hranice max.


Diskov I/O

   Knihovna iostream obsahuje  za  elem velkho vbru metod I/O mnostv
td, kter jsou odvozen od  streambuf, ostream a istream. Napklad tda
filebuf podporuje I/O pes deskriptory  soubor  s  lenskmi  funkcemi pro
otevrn, uzavrn a hledn. Je  alternativou  k  td  stdiobuf, kter
podporuje  I/O  pes  struktury stdio FILE a kter je sten kompatibiln
pi sluovn program v C a v C++.

   Nejuitenjmi   obecnmi   tdami   pro  zatenky  jsou  ifstream
(odvozena z istream), ofstream (odvozena z ostream) a  fstream  (odvozena z
iostream).  Vechny  podporuj   formtovan  I/O  soubor  pomoc  objekt
filebuf. Nsledujc pklad kopruje existujc diskov  soubor  do jinho
souboru:

   Tento program se jmanuje DCOPY.CPP.

*/* DCOPY.CPP -- Example from Chapter 5 of Getting Started */

/* DCOPY source-file destination-file                  *
 * copies existing source-file to destination-file     *
 * If latter exists, it is overwritten; if it does not *
 * exist, DCOPY will create it if possible             *
 */

#include <iostream.h>
#include <process.h>    // for exit()
#include <fstream.h>    // for ifstream, ofstream

main(int argc, char* argv[])  // access command-line arguments
{
   char ch;
   if (argc != 3)      // test number of arguments
   {
      cerr << "USAGE: dcopy file1 file2\n";
      exit(-1);
   }

   ifstream source;    // declare input and output streams
   ofstream dest;

   source.open(argv[1],ios::nocreate); // source file must be there
   if (!source)
   {
      cerr << "Cannot open source file " << argv[1] <<
          " for input\n";
      exit(-1);
   }
   dest.open(argv[2]);   // dest file will be created if not found
                                                                              //
or cleared/overwritten if found
   if (!dest)
   {
      cerr << "Cannot open destination file " << argv[2] <<
         " for output\n";


                                  - 164 - 


      exit(-1);
   }

   while (dest && source.get(ch)) dest.put(ch);

   cout << "DCOPY completed\n";

   source.close();        // close both streams
   dest.close();
}


   Nejprve si vimnte, e #include  <fstream> se vyskytuje i v iostream.h.
DCOPY pouv  standardn metody pstupu k argumentm pkazovho dku ke
kontrole  specifikace  obou  soubor  uivatelem.  Pokud  je  seznam tchto
argument pouit ve funkci main, pak argument argc obsahuje poet argument
pkazovho dku (vetn samotnho jmna  programu)  a  etzce  argv[1] a
argv[2] jmna soubor. Typick pkazov  dek  pro  tento  program vypad
takto:

   dcopy letter.spr letter.bak

   Jak DCOPY pracuje, poznte po vyzkouen nsledujcch dvou dk:

   ifstream source;                     //deklarace vstupnho streamu
                                        //(objekt ifstream)
   ...
   open.source(argv[1], ios::nocreate); //mus tam bt zdrojov soubor

   Deklarace   vol  konstruktor  ifstream  (tda  pro  stream   vstupnho
souboru), aby vytvoil stream objekt pod jmnem source. Jet ped pouitm
source je teba vytvoit vyrovnvac pam؟ a spojit ji spolu se streamem se
skutenm fyzickm souborem. Oba  kony  jsou  zabezpeeny  lenskou funkc
open  v  ifstream.  Funkce  open  potebuje  etzec  se jmnem  souboru  a
voliteln jeden nebo dva argumenty k uren mdu a pstupovch prv. Jmno
souboru je uloeno jako argv[1] a to ho zastupuje v pkazovm dku.

   Alternativa k pedchoz deklaraci je

   ifstream source (argv[1], ios::nocreate);  //zde mus bt zdrojov
                                              //soubor
   //vytv a otevr soubor

   Argument ios::nocreate k open,  e  nem  vytvet soubor, pokud nen
nalezen soubor danho jmna.  V  DCOPY se open pouv pro zjitn, jestli
soubor  danho  jmna je na disku nebo  ne.  Pozdji  budou  uvedeny  dal
varianty argument. Pokud  neme  bt soubor argv[1] oteven z jakhokoliv
dvodu (obvykle kdy nen  nalezen),  hodnota  source  je nastavena na nulu
(nepravda),  test  (!source)  m tedy pravdivostn hodnotu  1  a  dostaneme
chybovou zprvu. Program pak ukon innost.

   Ve skutenosti je mono  urit  pravdpodobn  dvod  neoteven souboru
testem  na  bity ve stream state. Rzn  chybov  bity  se  testuj  pomoc
lenskch  funkc  eof,  fall  a  bad,  kter  vrac  true, pokud jsou bity
nastaveny.  Alternativn  vrac  rdstate chybov stav  v  int  a  je  mono
testovat, kter bity jsou  nastaveny.  eof nen de facto chyba jako takov,
ale  mus  bt  testovn, protoe za koncovm znakem nen stream pstupn.
Dleit je, e jakmile  nastane  chyba (vetn eof), neprovd se u dn
I/O.  Funkce  clear  slou k vymazn nkterch nebo vech chybovch bit,
aby pi dalm pouit nedolo k fatln chybov situaci.


                                  - 165 - 


   Pokud je v  DCOPY  ve  se  vstupnm souborem v podku, zkusme otevt
druh  soubor pomoc objektu ofstream dest.  Obvykl  postup  u  vstupnch
soubor  je  ten,  e pokud soubor neexistuje, je vytvoen; pokud existuje,
smae  se  a  znovu  vytvo  jako  przdn.  Tento  postup je mono zmnit
pidnm druhho argumentu mode k deklaraci dest. Napklad:

   ofstream dest (argv[2], ios::app|ios::nocreate);

zkus otevt dest v mdu append a havaruje, jestlie dest nen  nalezen. V
append mdu jsou data ze zdrojovho souboru pidna na konec  dest, pvodn
data  zstanou  nezmmna.  Dal   funkce   ve   td  ios  (vimnte  si
vymezujcho  opertoru v ios::app) jsou: ate  (hled  konec  souboru),  in
(oteven pro vstup, pouv se s fstreams, protoe me bt oteven jak pro
vstup, tak i pro vstup),  out  (oteven  pro  vstup,  tak  se  pouv s
fstreams),   trunc  (odzne  obsah,  pokud  soubor  existuje),   noreplace
(chybov, pokud soubor existuje).

   Kdy jsou oteveny oba soubory, provd se skuten koprovn v typick
zhutn form jazyka  C.  Uvaujme  booleanovsk  vraz  testovan smykou
while:

   (dest && source.get(ch))

   Kdy  C  testuje  (x  &&  y)  a pokud je hodnota x false,  neprovd  se
testovn y. Protoe je pravdpodobn, e dest je mn "nchyln"  k false,
je mono uvaovat i o zmn operand.

   Vidme,  e  dest  bude  true,  dokud se neobjev chyba. Podobn  voln
source.get(ch) bude true dokud  se  nenaraz na chybu nebo dokud nen konec
souboru. Pokud se nevyskytnou  zvan  chyby,  smyka  get nat znaky ze
zdroje  a put je ukld do dest dokud nenastane konec souboru a source nen
false.

   V knihovn iostream jsou obsaeny  jet dal monosti I/O. iostream je
tak  k  dispozici  pi formtovn pamti, za pedpokladu, e streamy jsou
uloeny v RAM. Tuto  manipulaci  provdj  speciln  tdy, jako je nap.
strstreambuf.



---------------------------------------------------------------------------
Vstup a vstup pro typy dat definovan uivatelem
---------------------------------------------------------------------------


   Skutenou  pednost stream C++ je jednoduchost,  se  kterou  je  mono
pekrt >> a << za elem manipulace s vlastnmi  datovmi  typy.  Uvaujme
jednoduchou uivatelskou datovou strukturu:

   struct emp {
      char *name;
      int dept;
      long sales;
   };

   K pekryt << pro vstup objekt typu emp je nutn nsledujc definice:

   ostream& operator << (ostream& str, emp& e)
   {
   str << setw(25) << e.name << ": Department " << setw(6) << e.dept <<


                                  - 166 - 


   << tab << "Sales $" << e.sales << '\n';
   return str;
   }

   Vimnte  si,  e  opertor-funkce << mus vracet  ostream&,  adresu  na
ostream, take nov << je  mono spojit stejn jako peddefinovan vkldac
opertor. Nyn je mono odeslat objekty typu emp nsledujcm zpsobem:

   #include <iostream.h>
   #include <iomanip.h>   //nezapomete na to !
   ...
   emp jones = {"S. Jones", 24,1000};
   cout << jones;

   Vstup:

   S. Jones: Department 25   Sales $1000

   Vimli jste si  v  definici  <<  manipultoru  tab?  Nen  to standardn
manipultor, nbr je definovn uivatelem:

   ostream& tab(ostream& str) {
      return str << '\t';
   }

   To  je samozejm trivin, ale pece jen  dl  tato  definice  program
itelnjm.

   Vstupn rutina pro emp me bt vyeena s  pomoc  pekryt  >>.  To je
ponechno jako cvien pro tene.



---------------------------------------------------------------------------
Co te?
---------------------------------------------------------------------------


   Jako v prvn projekt v C++ doporuujeme rozit modul FIGURES uveden
dve  (je uloen i na disku). Body, krunice  a  oblouky  nejsou  vechno.
Vytvote objekty pro pmky,  trojhelnky  a  tverce. Pokud si troufnete,
vytvote objekt pro kruhov diagram pomoc  spojenho  seznamu jednotlivch
st kruhu.

   Jednm  z  mench  vzkumnch kol je implementovat tdy jako tdy s
relativnm umstnm. Relativn umstn je  ofset,  sted,  ze  kterho se
vychz  pi  urovn   znamnka   plus  nebo  mnus.  Bod  s  relativnmi
souadnicemi -17,42 je  umstn  17  bod  vlevo  a 42 bod dol od stedu.
Relativn pozice jsou nezbytn k  efektivn  kombinaci  obrazc  do vtch
celk,  protoe neme bt vytvoena kombinace  nkolika  obrazc  z  nich
kad m svj pevn bod.  K pevnm bod X a Y je nejlep pidefinovat RX a
RY a  konen  umstn  na  obrazovce  potat  jako souet pevnho bodu a
relativnch souadnic.

   Pokud jste s C++  seznmeni,  zalete  jej  do sv kadodenn innosti.
Vezmte nkolik z ji existujcch uitench rutin a pemlejte o  nich v
pojmech C++. Zkuste se podvat na knihovny funkc jako na tdy a pak je do
nich  pepite.  Shledte,  e  knihovny  td  se  v budoucch  projektech
pouvaj  mnohem  snadnji.  Bude promrhno velmi mlo  z  va  poten
investice do  programu. Zdka budete muset pepsat tdu kvli malikosti.


                                  - 167 - 


Obvykle se bude hodit tak, jak je. Pokud  nco  bude  chybt,  rozite ji.
Pokud pracuje dobe, nen dvod nco na n mnit.



---------------------------------------------------------------------------
Zvr
---------------------------------------------------------------------------


   C++  je pmou odezvou na obecnost  modernch  aplikac,  kter  obvykle
mnoho programtor uvd  do  zoufalstv. Ddinost a ohranienost jsou pro
prci  s  obecnmi  jevy velmi efektivn prostedky. C++ ukld software do
pirozen  struktury,  kter  stejn  jako  taxonomie  nem  omezen co  do
velikosti.

   K  tomu  vemu  pidejte   roziitelnost   a   opakovan   pouit  ji
existujcch program a nedostanete  jen  nstroj,  dostanete  prostedek k
tvorb novch prostedk!











































                                  - 168 - 








                            K a p i t o l a   6

                               Pruka C++


   Tato kapitola je strunou prukou C++.

   K tomu, abyste mli pehled a dokzali v C++  nco  vytvoit,  poskytuje
tato kapitola velk mnostv  koncepc  na  malm  prostoru. Je urena jako
pomcka  pi  prci s potaem; je mono  nahrt  a  spustit  jakkoliv  z
program  obsaench v n (jsou umstny v  podadresi  EXAMPLES  spolu  s
jinmi hlavikovmi a ostatnmi soubory,  kter  budete  potebovat). Pokud
chcete vce proniknout  do  hloubky C++, zejmna do objektov orientovanho
programovn, pette si kapitolu  5,  "Zklady  C++". Detailn syntaxi je
mono nalzt v  Programtorsk  pruce,  kapitola  1,  "Jazykov standard
Turbo C++".

   Pozor!
   V tto kapitole pedpokldme, e jste seznmeni s jazykem C a  e vte,
jak zkompilovat, zlinkovat a spustit  zdrojov program v Turbo C++. Zaneme
s jednoduchmi pklady, kter obecn ukazuj, jak vypad nov koncepce. Je
pochopiteln, e tyto  pklady  nejsou  pln  (jinmi  slovy nekontroluj
chyby pamti  apod.). Tato kapitola nepojednv o datovch strukturch nebo
profesionlnch programovacch technikch, msto toho  je  malm  vodem do
komplikovanho jazyka.

   Tato kapitola je rozdlena  do  dvou  podkapitol.  Prvn z nich popisuje
odchylky  C++  a  C.  Druh  je  rychlm  vodem  do  jdra C++:  objektov
orientovanho programovn pomoc td a ddinosti.



---------------------------------------------------------------------------
Pechod z obyejnho C do lepho C
---------------------------------------------------------------------------


   Pi odkazech na sla dk potme i przdn dky.

   Akoliv  je  znalost  C pi uen C++ obecn uiten, nkdy je spe na
obt a to zejmna v oblastech objektov orientovanho programovn, kdy je
nutno v C++ myslet jinak ne  v  C.  Z tohoto dvodu obsahuje tato kapitola
nvod,  jak napsat njakou aplikaci v C++, piem  hodn  typ  kon  lze
nalzt i v C: vypisovn textu na obrazovku, komente,  tvorba  a  pouit
konstant, prce se streamy vstupu a vstupu, spaen funkce, atd.


Program 1
---------------------------------------------------------------------------

   Zdrojov text:

// ex1.cpp:   A First Glance
// from Chapter 6 of Getting Started


                                  - 169 - 


#include <iostream.h>

main()
{
   cout << "Frankly, my dear...\n";
   cout << "C++ is a better C.\n";
}


   Vstup:

   Frankly, my dear...
   C++ is a better C

   Vimnte si nov syntaxe komente v prvnm du programu. Vechny znaky
od  prvnho  vskytu dvojitch lomtek za sebou  a  do  konce  dky  jsou
povaovna  za  koment,  i  kdy  je  mono  jako  alternativu  pout  i
klasickho stylu  /*...*/. Soubory, kter maj pponu .CPP jsou povaovny
za soubory C++ (druhou monost je pout v dkovm kompiltoru volbu -P).

   Tet dek vleuje standardn hlavikov soubor  iostream.h,  kter m
mnoho funkc stejnch jako stdio.h. cout je vstupn stream a pouv  se k
vstupu  znak  na standardn vstup (stejn jako  to  in  stdout  v  C).
Opertor << (tte jako "ulo do") posl data z prav strany do streamu na
stran lev. Kontextem se li  od  aritmetickho  opertoru  posunu vlevo,
kter m stejn symbol. (Toto vcensobn pouit opertor a funkc, hojn
se v C++ vyskytujc, se nazv pekrvn.)


Program 2
---------------------------------------------------------------------------

   Zdroj:

// ex2.cpp:   An interactive example
// from Chapter 6 of Getting Started
#include <iostream.h>

main()
{
   char name[16];
   int age;

   cout << "Enter your name: ";
   cin >> name;
   cout << "Enter your age: ";
   cin >> age;

   if (age < 21)
      cout << "You young whippersnapper, " << name << "!\n";
   else if (age < 40)
      cout << name << ", you're still in your prime!\n";
   else if (age < 60)
      cout << "You're over the hill, " << name << "!\n";
   else if (age < 80)
      cout << "I bow to your wisdom, " << name << "!\n";
   else
      cout << "Are you really " << age << ", " << name << "?\n";
}



                                  - 170 - 


   Pklad vstupu:

   Enter your name: Don
   Enter your age: 40
   You're over the hill, Don!

   cin je vstupn  stream  spojen se standardnm vstupem. Pracuje sprvn
se  vemi  standardnmi  datovmi typy. Mon jste si v C  vimli,  e  pi
okamitm vstupu bez znaku newline pomoc stdout se vol fflush(stdout). V
C++  se  cout   vyprazduje   automaticky  pi  kadm  pouit  cin  (toto
automatick vyprazdovn je mono vypnout, implicitn je on (zapnuto)).


Program 3
---------------------------------------------------------------------------

   Zdrojov text:
// ex3.cpp:   Inline Functions
// from Chapter 6 of Getting Started
#include <iostream.h>

const float Pi = 3.1415926;

inline float area(const float r) {return Pi * r * r;}

main()
{
   float radius;

   cout << "Enter the radius of a circle: ";
   cin >> radius;
   cout << "The area is " << area(radius) << "\n";
}


   Proti C je zde dleit rozdl  -  deklarace se mohou vyskytnout vude v
pkaze, kde je teba.

   Vstup:

   Enter the radius og a circle: 3
   The area is 28.274334

   Identifiktor konstanty  se  chov  stejn  jako  normln  promnn (to
znamen, e rozsah jeho platnosti je blok, ve kterm je  definovn  a e je
podrobovn kontrole typu) krom toho, e se nesm vyskytnout na lev stran
piazovacho  pkazu (nebo tam, kde by se do  nj  mohlo  nco  ukldat).
Pouit #define je v C++ zcela zastaral.

   Klov  slovo inline k kompiltoru, aby  vloil  na  zklad  voln
funkce st  programu  tam,  kde  je  to  poteba. Jinak se spaen funkce
(nap.  scope)  chov   stejn   jako  normln  funkce.  Jej  pouit  je
zabezpeeno  makry  #define  (pak  jste  samozejm   zvisl   na  tricch
preprocesoru s makrosubstitucemi). Tato vlastnost je vhodn  pro jednoduch
jednodkov funkce.







                                  - 171 - 


Program 4
---------------------------------------------------------------------------

   Zdrojov text:

// ex4.cpp:   Default arguments and Pass-by-reference
// from Chapter 6 of Getting Started
#include <iostream.h>
#include <ctype.h>

int get_word(char *, int &, int start = 0);

main()
{
   int word_len;
   char *s = "  These words will be printed one-per-line  ";

   int word_idx = get_word(s,word_len);           // line 13
   while (word_len > 0)
   {
      cout.write(s+word_idx, word_len);
                cout << "\n";
      //cout << form("%.*s\n",word_len,s+word_idx);
      word_idx = get_word(s,word_len,word_idx+word_len);
   }
}

int get_word(char *s, int& size, int start)
{
   // Skip initial whitespace
   for (int i = start; isspace(s[i]); ++i);
   int start_of_word = i;

   // Traverse word
   while (s[i] != '\0' && !isspace(s[i]))
      ++i;
   size = i - start_of_word;
   return start_of_word;
}


   Dobr programtor vynechv przdn tla smyek.

   Vstup:

   These
   words
   will
   be
   printed
   one-per-line

   Prototyp  funkce get_word na dku est  m  dv  speciln  vlastnosti.
Druh argument je deklarovn jako  parametr odkazem. To znamen, e hodnota
argumentu se ve volanm programu bude mnit (toto je ekvivalentn parametru
var  v Pascalu a v C je zabezpeeno pomoc ukazatel). V tomto smyslu je  v
main  aktualizovna promnn word_len a pomoc  funkce  get_word  je  mono
vrtit jinou uitenou hodnotu.

   Jednm z dleitch rys v C++ je implicitn argument.


                                  - 172 - 


   Tetm  argumentem je implicitn argument. To zna,  e  je  mon  jej
vynechat a automaticky se dosad hodnota 0 (viz dek 13). Vimnte  si, e
implicitn  hodnota me bt specifikovna jen  u  prvnho  voln  funkce.
Implicitn hodnoty mohou bt dosazeny jen do argument funkc.



---------------------------------------------------------------------------
Objektov podpora
---------------------------------------------------------------------------


   Svt se skld z vc, kter  maj  njak atributy (znaky) a kter jsou
charakteristick svm chovnm. Tento stav modeluje C++  strukturami, kter
obsahuj jak funkce, tak  data.  Zpsob  uren  objektu je vyjden pomoc
jedin jazykov konstrukce. Vznam objektov orientovan  podpory  je vt
ne pouh zaveden notace - je to zpsob mylen.


Program 5
---------------------------------------------------------------------------

   Pedpokldejme, e mme spaen slovnk. Slovnk  je  tvoen definicemi
slov. Nejprve vytvome definici:

   Je teba zkompilovat  DEF.CPP  do  souboru  .OBJ,  pak  jej  zlinkovat s
EX6.CPP  nebo  EX7.CPP  (nebo nahrt EX5.PRJ).  Je  mono  jej  spustit  se
zapnutou volbou Debug info, pak mete sledovat bh programu krok po kroku.

// ex5.cpp:   Using the Definition class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "def.h"

main()
{
   Definition d;          // Declare a Definition object
   char s[81];

   // Assign the meanings
   d.put_word("class");
   d.add_meaning("a body of students meeting together to \
study the same subject");
   d.add_meaning("a group sharing the same economic status");
   d.add_meaning("a group, set or kind sharing the same attributes");

   // Print them
   cout << d.get_word(s) << ":\n\n";
   for (int i = 0; d.get_meaning(i,s) != 0; ++i)
      cout << (i+1) << ": " << s << "\n";
}


   V klasickm C se  definice  ukldaj  do  souboru include. Klov slovo
class uvd popis objektu. Implicitn jsou leny tdy privtn (i  kdy je
mono ut explicitn i klov slovo private), take v tomto  ppad pole
na dcch 9 a 11 jsou pstupn pouze pro funkce tto  tdy.  (V  C++ se
funkce  tdy jmenuj lensk funkce.) Tyto funkce  je  mono  pout  jako
uivatelsk rozhran  pomoc klovho slova public. Vimnte si, e uvnit
definice tdy nen pouito klov slovo inline (dek 15).


                                  - 173 - 


   V jinch objektov  orientovanch  jazycch  se  tdy  nazvaj objects
(objekty) a lensk funkce methods (metody).

   Implementace se obvykle oddluje do zvltnho souboru:

// def.cpp:   Implementation of the Definition class
// from Chapter 6 of Getting Started
#include <string.h>
#include "def.h"

void Definition::put_word(char *s)
{
   word = new char[strlen(s)+1];
   strcpy(word,s);
   nmeanings = 0;
}

void Definition::add_meaning(char *s)
{
   if (nmeanings < Maxmeans)
   {
      meanings[nmeanings] = new char[strlen(s)+1];
      strcpy(meanings[nmeanings++],s);
   }
}

char * Definition::get_meaning(int level, char *s)
{
   if (0 <= level && level < nmeanings)
      return strcpy(s,meanings[level]);
   else
      return 0;                                // line 27
}


   Opertor vymezujc rozsah (scope  resolution  operator)  (::) informuje
kompiltor, e vytvme definice  lenskch  funkc  pro  tdu Definition
(dobrm cvienm pro vs je napsat prvn psmeno tdy  velkm  psmenem  a
pivodit tak konflikt s knihovn funkc).  Klov  slovo new na dku 8 je
pkazem  pro funkci malloc, kter vyhrazuje dynamickou  pam؟.  V  C++  je
konvenn pro ukazatele pouita nula msto NULL (dek 27). Akoliv to tady
nedlme, je uiten ovit, zda new vrac nenulovou hodnotu.

   Zdrojov text:

*// ex5.cpp:   Using the Definition class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "def.h"

main()
{
   Definition d;          // Declare a Definition object
   char s[81];

   // Assign the meanings
   d.put_word("class");
   d.add_meaning("a body of students meeting together to \
study the same subject");
   d.add_meaning("a group sharing the same economic status");


                                  - 174 - 


   d.add_meaning("a group, set or kind sharing the same attributes");

   // Print them
   cout << d.get_word(s) << ":\n\n";
   for (int i = 0; d.get_meaning(i,s) != 0; ++i)
      cout << (i+1) << ": " << s << "\n";
}


   vstup:

   class:

   1: a body of students meeting together  to study the same subject
   2: a group sharing the same economic status
   3: a group, set, or kind sharing the same attributes



---------------------------------------------------------------------------
Program 6
---------------------------------------------------------------------------


   Nyn je mono definovat slovnk jako shrnut definic.

   Z  DOSu  vytvote  DICTION.OBJ  a  DEF.OBJ  s  EX6.CPP. Z  IDE  Pouijte
projektov soubor EX6.PRJ.

// ex6.cpp:   Using the Dictionary class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "diction.h"

main()
{
   Dictionary d(5);
   char *word = "class";
   char *indef[4] =
     {"a body of students meeting together to study the same",
      "subject a group sharing the same economic status",
      "a group, set or kind sharing the same attributes",
      0};
   char *outdef[4];

   d.add_def(word,indef);
   cout << word << ":\n\n";
   int ndef = d.get_def(word,outdef);
   for (int i = 0; i < ndef; ++i)
      cout << (i+1) << ": " << outdef[i] << "\n";
}


   Funkce find_word na dku 12 slou pouze pro tdu Dictionary a zstv
stle privtn. Funkce stejnho jmna  jako m tda, se nazv konstruktor
(dek 16). Vol se pi deklaraci objektu. Pouv se pro inicializaci; zde
se  dynamicky  vymezuje  prostor pro pole definic. Destruktor (dek 17) se
pouv  pi ukonen prce s objektem (v  tomto  ppad  opertor  delete
uvoluje pam؟ alokovanou konstruktorem). V ppad pole  lenskch objekt



                                  - 175 - 


(dek 9) mus mt zalenn tda konstruktor bez argument nebo  mus bt
bez konstruktoru (tda Definition dn nem).

// diction.cpp:   Implementation of the Dictionary class
// from Chapter 6 of Getting Started
#include "diction.h"

int Dictionary::find_word(char *s)
{
   char word[81];
   for (int i = 0; i < nwords; ++i)
      if (stricmp(words[i].get_word(word),s) == 0)
         return i;

   return -1;
}

void Dictionary::add_def(char *word, char **def)
{
   if (nwords < Maxwords)
   {
      words[nwords].put_word(word);
      while (*def != 0)
         words[nwords].add_meaning(*def++);
      ++nwords;
   }
}

int Dictionary::get_def(char *word, char **def)
{
   char meaning[81];
   int nw = 0;
   int word_idx = find_word(word);
   if (word_idx >= 0)
   {
      while (words[word_idx].get_meaning(nw,meaning) != 0)
      {
         def[nw] = new char[strlen(meaning)+1];
         strcpy(def[nw++],meaning);
      }
      def[nw] = 0;
   }

   return nw;
}


   Nyn pouijeme tdu  Dictionary  bez odkazu na tdu Definition (vstup
je stejn jako v pedchozm ppad).

   Zdrojov text:

// ex6.cpp:   Using the Dictionary class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "diction.h"

main()
{
   Dictionary d(5);


                                  - 176 - 


   char *word = "class";
   char *indef[4] =
     {"a body of students meeting together to study the same",
      "subject a group sharing the same economic status",
      "a group, set or kind sharing the same attributes",
      0};
   char *outdef[4];

   d.add_def(word,indef);
   cout << word << ":\n\n";
   int ndef = d.get_def(word,outdef);
   for (int i = 0; i < ndef; ++i)
      cout << (i+1) << ": " << outdef[i] << "\n";
}


   V  implementaci  Dictionary  se volaj lensk funkce  z  Definition.  V
nkterch  ppadech je teba, aby urit funkce  nebo  urit  tdy  mly
pstup k privtnm lenm jin  tdy. Je mono definovat tdu Dictionary
jako sptelenou (friend) ke td Definition (dek 18):

   Vytvote LIST.OBJ s EX7.CPP.

// def2.h:   A word definition class
// from Chapter 6 of Getting Started
#include <string.h>

const int Maxmeans = 5;

class Definition
{
   char *word;                      // Word being defined
   char *meanings[Maxmeans];        // Various meanings of this word
   int nmeanings;

public:
   void put_word(char *);
   char *get_word(char *s) {return strcpy(s,word);};
   void add_meaning(char *);
   char *get_meaning(int, char *);
   friend class Dictionary;         // line 18
};


   Implementace find_word m pm pstup  ke lenm Definition (dek 5 v
nsledujcm programu):

   int Dictionary::find_word(char *s)
   {
      char word[81];
      for (int i = 0; i < nwords; ++i)
         if (stricmp(words[i].word),s == 0)
            return i;

      return -1;
   }






                                  - 177 - 


Program 7
---------------------------------------------------------------------------

   Jednou z klovch vlastnost  objektov  orientovanho  programovn je
ddinost  (inheritance).  Nov  tda  me  po  existujc  ("zkladn" -
"base") td zddit data i lensk funkce (nov tda se nazv odvozen -
derived  ze zkladn tdy). V tomto  programu  definujeme  List,  zkladn
tdu  pro  seznam  celch  sel  a  pot  se  odvozuje  Stack, tda  pro
manipulaci  se  zsobnkem  (co  je  speciln  ppad  seznamu).  Nejprve
vytvome hlavikov soubor:

   Vytvote LIST.OBJ s EX7.CPP nebo pouijte EX7.PRJ.

// list.h:   A Integer List Class
// from Chapter 6 of Getting Started
const int Max_elem = 10;

class List
{
   int *list;        // An array of integers
   int nmax;         // The dimension of the array
   int nelem;        // The number of elements

public:
   List(int n = Max_elem) {list = new int[n]; nmax = n; nelem = 0;};
   ~List() {delete list;};
   int put_elem(int, int);
   int get_elem(int&, int);
   void setn(int n) {nelem = n;};
   int getn() {return nelem;};
   void incn() {if (nelem < nmax) ++nelem;};
   int getmax() {return nmax;};
   void print();
};


   Pot vytvome zdrojov program:

// list.cpp:   Implementation of the List Class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "list.h"

int List::put_elem(int elem, int pos)
{
   if (0 <= pos && pos < nmax)
   {
      list[pos] = elem;    // Put an element into the list
      return 0;
   }
   else
      return -1;           // Non-zero means error
}

int List::get_elem(int& elem, int pos)
{
   if (0 <= pos && pos < nmax)
   {
      elem = list[pos];    // Retrieve a list element
      return 0;


                                  - 178 - 


   }
   else
      return -1;           // non-zero means error
}

void List::print()
{
   for (int i = 0; i < nelem; ++i)
      cout << list[i] << "\n";
}


   Nakonec pouijeme novou tdu:

// ex7.cpp:   Using the List class
// from Chapter 6 of Getting Started
#include "list.h"

main()
{
   List l(5);
   int i = 0;

   // Insert the numbers 1 through 5
   while (l.put_elem(i+1,i) == 0)
      ++i;
   l.setn(i);

   l.print();
}


   Vstup:

   1
   2
   3
   4
   5


Program 8
---------------------------------------------------------------------------

   Vytvote STACK.OBJ a LIST.OBJ sEX8.CPP nebo pouijte EX8.PRJ.


// stack2.h:   A Stack class derived from the List class
// from Chapter 6 of Getting Started
#include "list2.h"

class Stack : public List                  // line 5
{
   int top;

public:
   Stack() {top = 0;};
   Stack(int n) : List(n) {top = 0;};      // line 11
   int push(int elem);
   int pop(int& elem);


                                  - 179 - 


   void print();
};


   Pro definici odvozen tdy mus  bt pstupn zkladn tda, take na
dku 3 se zaleuje jej  hlavikov soubor. dek 5 informuje kompiltor,
e tda Stack je odvozena od tdy List.  Klov  slovo  public  k, e
obecn  pstupn  leny List jsou obecn pstupn  i  ve  Stack  (co  je
obvykle  poteba).  Protoe  tda  List  m   konstruktor   s  argumentem,
konstruktor Stack vol  pmo  konstruktor  List  (dek  11). Konstruktory
zkladn tdy se aktivuj ped konstruktory odvozen tdy.

// stack.cpp:   Implementation of the Stack class
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "stack.h"

int Stack::push(int elem)
{
   int m = getmax();
   if (top < m)
   {
      put_elem(elem,top++);
      return 0;
   }
   else
      return -1;
}

int Stack::pop(int& elem)
{
   if (top > 0)
   {
      get_elem(elem,--top);
      return 0;
   }
   else
      return -1;
}

void Stack::print()
{
   int elem;

   for (int i = top-1; i >= 0; --i)
   {  // Print in LIFO order
      get_elem(elem,i);
      cout << elem << "\n";
   }
}


   Vimnte si, e obecn  pstupn  funkce  tdy  List se mohou pouvat
pmo, protoe Stack je odvozeno od List. Naproti tomu  na  privtn  leny
List se ze Stack nen mono pmo odkazovat.

// ex8.cpp:   Using the Stack Class
// from Chapter 6 of Getting Started
#include "stack.h"



                                  - 180 - 


main()
{
   Stack s(5);
   int i = 0;

   // Insert the numbers 1 through 5
   while (s.push(i+1) == 0)
      ++i;

   s.print();
}


   Vstup:
   5
   4
   3
   2
   1


Program 9
---------------------------------------------------------------------------

   Nkdy  je poteba, aby odvozen tda mla  pm  pstup  k  privtnm
datm zkladn tdy. Takov data se nazvaj chrnn (protected).

   Vytvote EX9.CPP, LIST2.OBJ nebo pouijte EX9.PRJ.

// list2.h:   A Integer List Class
// from Chapter 6 of Getting Started
const int Max_elem = 10;

class List
{
protected:     // The protected keyword gives subclasses
               // direct access to inherited members
   int *list;        // An array of integers
   int nmax;         // The dimension of the array
   int nelem;        // The number of elements

public:
   List(int n = Max_elem) {list = new int[n]; nmax = n; nelem = 0;};
   ~List() {delete list;};
   int put_elem(int, int);
   int get_elem(int&, int);
   void setn(int n) {nelem = n;};
   int getn() {return nelem;};
   void incn() {if (nelem < nmax) ++nelem;};
   int getmax() {return nmax;};
   virtual void print();                   // line 22
};


   V implementaci Stack meme  nyn  nahradit  stvajc odkazy na lensk
funkce z List pmmi odkazy na data List.

// stack.cpp:   Implementation of the Stack class
// from Chapter 6 of Getting Started
#include <iostream.h>


                                  - 181 - 


#include "stack.h"

int Stack::push(int elem)
{
   int m = getmax();
   if (top < m)
   {
      put_elem(elem,top++);
      return 0;
   }
   else
      return -1;
}

int Stack::pop(int& elem)
{
   if (top > 0)
   {
      get_elem(elem,--top);
      return 0;
   }
   else
      return -1;
}

void Stack::print()
{
   int elem;

   for (int i = top-1; i >= 0; --i)
   {  // Print in LIFO order
      get_elem(elem,i);
      cout << elem << "\n";
   }
}


   Pak je mono to vyzkouet:

// ex9.cpp:   Using the print() virtual function
// from Chapter 6 of Getting Started
#include <iostream.h>
#include "stack2.h"

main()
{
   Stack s(5);
   List l, *lp;
   int i = 0;

   // Insert the numbers 1 through 5 into the stack
   while (s.push(i+1) == 0)
      ++i;

   // Put a couple of numbers into the list
   l.put_elem(1,0);
   l.put_elem(2,1);
   l.setn(2);

   cout << "Stack:\n";


                                  - 182 - 


   lp = &s;           // line 22
   lp->print();       // Invoke the Stack print() method; line 23

   cout << "\nList:\n";
   lp = &l;
   lp->print();       // Invoke the List print() method; line 27
}


   Vstup:
   Stack:
   5
   4
   3
   2
   1

   List:
   1
   2

   Pedchoz pklad ilustruje vcetvarost (polymorphism) (co  je  znmo i
jako "pozdn vazba" -  "late  binding",  nebo  "dynamick vazba" - "dynamic
binding", co se  v  C++  realizuje  jako virtuln funkce). To znamen, e
ped sputnm  programu nen objektov typ "znm". Definic lensk funkce
Print jako virtuln (dek  22  "list2.h") je mono volat pes ukazatel na
zkladn  tdu jinou lenskou funkci. Na dku 22  ukazuje  lp  na  objekt
Stack (Stack je List), odvoln na metody tisku ve Stack je na dku 23. Na
dku 27 se provd lensk funkce print z List.



---------------------------------------------------------------------------
Shrnut
---------------------------------------------------------------------------


   C++ obsahuje jet  mnoho  dalch vlastnost ne popisuje tato kapitola
(napklad vcensobnou ddinost - multiple inheritance). Jak bylo uvedeno
na zatku, je tato kapitola vnovna tomu, abyste zskali pehled o C++, o
rozdlech mezi C  a  C++  a  demonstruje  tak  pouit  vtiny zkladnch
vlastnost  C++. Vce informac o nich naleznete  v  kapitole  5,  "Zklady
C++",  a dle v Programtorsk pruce,  kapitola  1,  "Jazykov  standard
Turbo C++". Nezapomete se  podvat  tak  do  knihovny C++, obsahuje knihy
speciln pro Turbo C++.

















                                  - 183 - 
































































                                  - 184 - 








                            K a p i t o l a   7

                            Ladn v novm IDE


   V kapitole 4 jste se nauili vtinu prvk z C. Pomoc  rznch program
umte  tyto  prvky  eln  sdruovat,  pst  funkn  programy.  S  tmito
znalostmi jste u asi  napsali  nkolik  svch vlastnch krtkch program.
Pokud ne, je prv te as zat, protoe pi ovovn porozumn probran
ltky nen nad vlastn zkuenost.

   Je samozejm, e  psan  program  s  sebou  pin  i  chyby. Vtina
zkuench  programtor  se  domnv,  e  odstraovn  logickch  chyb (v
anglitin zvan bugs = tnice, brouci - pozn. pekl.) zabr vtinu asu
pi vvoji programu. Ladn  (debugging)  nebo  hledn a odstraovn chyb
obvykle trv dle ne psan samotnho programu.

   Turbo C++  obsahuje  integrovan  ladic  program  na  rovni zdrojovho
programu, kter um  mnoho  kon  ze  standardnch  postup  pi  ladn a
zrove poskytuje vechny vhody integrovanho prosted.

   rove zdrojovho programu znamen,  e  je  mono trasovat skuten kd
programu  vetn,  pokud  si to pejete, kad funkce, kterou program vol.
Umstnm bod  peruen (breakpoints) je mono dit bh programu. Pomoc
vypsn  jmna do vyhodnocovacho pole (Evaluate  field)  je  mono  vypsat
aktuln  hodnotu  promnn.  Lze  nastavit  okno,  kter   zobrazuje  vce
promnnch  vetn jejich zmn pi bhu programu. Toto  ve  je  mon  bez
toho, e byste museli pestat myslet v pojmech  C  (nebo  C++),  protoe se
pouvaj stejn promnn, vrazy a opertory jako v programu.

   Odstartujte  Turbo  C++  napsnm  TC  (pokud nen v provozu) a  vnujte
nkolik  minut  pozornosti  menu  Debug.  K vbru poloky je mono  pout
zvraznn psmeno, F1 slou pro aktuln npovdu. Tyto  volby  menu jsou
ladicmi nstoji, jejich pouit  se  naume  jet ped vvojem pkladu
programu v tto kapitole.





















                                  - 185 - 


 Debug
Ŀ  [.]Data Inspectͻ
 Inspect...   Inspect                              
                      
                                                          
                     [   Ok   ]    [Cancel]      [ Help ] 
                                                          
                    ͼ
                    [.]Evaluate and Modifyͻ
                     Expression                                        
                         >[Evaluate]< 
                                                                       
                     Result                                            
                          [ Modify ]  
                                                                       
                     New value                                         
 Evaluate... Ķ      [ Cancel ]  
                                                                       
 Call stack...                                             [  Help  ]  
                    ͼ
                   Ŀ
 Watches Ĵ Add watch        Ctrl-F7 
                    Delete watch             
 Toogle breakpoints  Edit watch               
                    Remove all watches       
                   
                   [.]Breakpointsͻ
 Breakpoints ĺ Breakpoint List       Line Condition        Pass  
                                                                     
                      
                      
                   >[ Ok ]<  [Edit]  [Delete]  [View]  [Cancel] [Help] 
 ͼ



---------------------------------------------------------------------------
Ladn a vvoj programu
---------------------------------------------------------------------------


   Zamysleme se nad starmi televizory. patn se opravuj, protoe vechny
jejich sti obsahuj velk mnostv  odpor,  kondenztr  apod.  Je tاk
nalzt, kter soustka v kter sti nepracuje. Kdy ji konen  najdete a
chcete ji vymnit, jde to tاko, protoe se nalz ve spleti drt.

   Po  nstupu  tranzistor  a  integrovanch  celk  se  zaaly televizory
konstruovat jinak. Kad celek  m  svj modul, kter je snadno pstupn a
dobe se vymuje. patn modul se prost vymn za nov.

   Ekvivalentem zsuvnch modul v C jsou funkce. Vytvote, implementujete
a otestujete pklad programu  z  tto  kapitoly  zpsobem "jedna funkce po
druh." Krtk programy vs asto budou svdt napsat je jako jeden celek a
a pot zat s ladnm. Stejn jako ve starm  televizoru  vyvolv  tento
zpsob problmy. Abyste vidli pro, uvaujme, e main vol funkci b, kter
zase vol c  a  d.  Pokud  po  napsn kadou funkci neotestujete, je tاk
ci,  kde je mon chyba, jestli v  d,  b  nebo  v  c.  Navc  se  obvykle
vyskytuje vce ne jedna chyba. Zatm zdnliv odpojen funkce a modifikuje
globln data, kter b zpracovv pro c. Vidte, e postupn vvoj programu
napsn a testovn jedn sti po druh vm uet spoustu asu a nmahy.


                                  - 186 - 


                       Ŀ
                        main()               Ŀ
                        {               <Ĵ nejvy rove(voln
                        get_temp;       <Ĵ  koenovch funkc)   
                        save_temp;           
                        }                    koenov definice
                            
             Ŀ
  ĿĿĿ
  get_temp()             read_temp()           graphics_view()     
  {                      {                     {                   
  printf("To je          printf("To je         printf("To je       
          get_temp");   }       read_temp");  }   graphics_view");}
  ٳٳ
    Ŀ  Ŀ
Funkce      save_temp()                  table_view()        
volan  {                            {                   
main()      printf("To je save_temp");    min_max;           
     }                             avg_max;     }     
               
                                                        reln kd
                           ĿĿ
             min_max()            avg_temp()         
          Funkce volan {                   {                   
           funkcemi       printf("To je min_  printf("To je avg_  
                     max");  }         temp");    }  
                           
                                           koenov definice
                    Obr. 7.1: Vvojov diagram programu



---------------------------------------------------------------------------
Tvorba pkladu: PLOTEMP.C
---------------------------------------------------------------------------


   Pklad programu v  tto  kapitole zahrnuje natn a vypisovn teplot
pomoc tabulky nebo grafiky. Ilustruje  nkolik monost z Turbo C++: vstup
a  vstup  na  obrazovku  a  do  souboru,  pedvn  pole funkci a nkter
grafick funkce. Pozdji, pokud budete mt zjem, mete PLOTEMP.C pozmnit
tak, aby pracoval s jinmi druhy dat, vypisoval jin zprvy a  kreslil jin
obrzky.

   Jednm z nejlepch zpsob  jak  zat  pst  program, je vymyslet jeho
komunikaci s uivatelem - jak bude podvat informace, reagovat na pkazy a
vypisovat zprvy. Pedtm, ne se dostaneme k samotnmu programu, podvejme
se, jak vypad z hlediska uivatele.

   Po sputn PLOTEMP.C se vype toto menu:

   Temperature Plotting Program Menu
      E - Enter temperatures for scratchpad
      S - Store scratchpad to disk
      R - Read disk file to scratchpad
      T - Table view of current data
      G - Graph view of current data
      X - Exit the program
   Press one of the above keys:



                                  - 187 - 


   Po stisku E se  ocitnete  v sti programu pro natn teploty. Program
oekv osm vstup, jejich poet je mono zmnit na dku

   #define READINGS 8

blzko zatku programu.

   Vstup dat me vypadat takto:

   Enter temperatures, one at time.
Enter reading # 1: 52
Enter reading # 2: 55
Enter reading # 3: 62
Enter reading # 4: 65
Enter reading # 5: 73
Enter reading # 6: 76
Enter reading # 7: 68
Enter reading # 8: 61

   Po tto innosti nebo po vbru jin volby (krom X pro  konec programu)
se znovu vype menu.

   Volba  S  ulo  data  do  diskovho  souboru  (jste dotzni  na  jmno
souboru). Volba R nate data z diskovho souboru do programu.

   Kdy  mte  data  natena (a u z disku nebo z  klvesnice),  je  mono
vypsat celkovou tabulku dat volbou T (tabulka):

   Reading             Temperature (F)
   1                        52
   2                        55
   3                        62
   4                        65
   5                        73
   6                        76
   7                        68
   8                        61
   Minimum temperature: 52
   Maximum temperature: 76
   Average temperature: 64.000000

   Jako alternativu je mono zvolit G - grafick pohled na aktuln data.
   Je zde jeden problm: Program, kter jste napsali, nebا tak, jak se od
nj oekv. K nalezen a odstrann chyb je nutno pout ladic program.



---------------------------------------------------------------------------
Tvorba prototypu programu
---------------------------------------------------------------------------


   Po zven veho, co m program dlat je mono urit, jak globln data
a jin definice budou teba a pot napsat funkci main:

   Tento program si  mete nahrt pomoc: File|Open|PLOTEMP1. Nezapomete,
e jsme do tohoto programu mysln vloili chyby.

/* PLOTEMP1.C--Example from Chapter 7 of Getting Started */



                                  - 188 - 


/* This program creates a table and a bar chart plot from a
   set of temperature readings */

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

/* Prototypes */

void get_temps(void);
void table_view(void);
void min_max(void);
void avg_temp(void);
void graph_view(void);
void save_temps(void);
void read_temps(void);

/* Global defines */

#define TRUE      1
#define READINGS  8

/* Global data structures */

int temps[READINGS];

int main(void)
{
   while (TRUE)
   {
      printf("\nTemperature Plotting Program Menu\n");
      printf("\tE - Enter temperatures for scratchpad\n");
      printf("\tS - Store scratchpad to disk\n");
      printf("\tR - Read disk file to scratchpad\n");
      printf("\tT - Table view of current data\n");
      printf("\tG - Graph view of current data\n");
      printf("\tX - Exit the program\n");
      printf("\nPress one of the above keys: ")

      switch   (toupper(getche()))
      {
         case 'E': get_temps();  break;
         case 'S': save_temps(); break;
         case 'R': read_temps(); break;
         case 'T': table_view(); break;
         case 'G': graph_view();
         case 'X': exit(0);
      }
   }
}

/* Function definitions */

void get_temps(void)
{
   printf("\nExecuting get_temps().\n");
}

void table_view(void)


                                  - 189 - 


{
   printf("\nExecuting table_view().\n");
}

void min_max(void)
{
   printf("\nExecuting min_max().\n");
}

void avg_temp(void)
{
   printf("\nExecuting avg_temp().\n");
}

void graph_view(void)
{
   printf("\nExecuting graph_view().\n");
}

void save_temps(void)
{
   printf("\nExecuting save_temps().\n");
}

void read_temps(void)
{
   printf("\nExecuting read_temps().\n");
}


   Povimnte si nsledujcch dleitch rys tohoto programu:

    o  #define a datov struktury jsou globln (pole temps).

    o  Menu obsahuje funkce main.

    o  Ostatn funkce jsou deklarovny tak, e nevrac nic  a  nemaj dn
       argument.

    o  Kad funkce obsahuje pouze  pkaz  printf,  kter ji pi provdn
       identifikuje.

    o  Program je pipraven ke sputn.

   Pro maj funkce deklaraci void? Po sputn programu  kontroluj  bh z
vy  rovn.  Pokud dte funkcm formt z  ANSI  i  s  argumenty  rznch
datovch typ, muste napsat definice  funkc  a  dky,  kter zabezpeuj
hodnoty  pro  funkce.  Jinak obdrte od kompiltoru  varovn,  e  nejsou
pouity parametry. Dobrm pravidlem pro  tvorbu  program  je  "napi jeden
krok,  testuj  jeden  krok".  V  tomto  bod  u snad tedy vte, e  hlavn
(nejvy) struktura je v programu nezbytn.











                                  - 190 - 


---------------------------------------------------------------------------
Pouit integrovanho ladicho programu
---------------------------------------------------------------------------


   Zkompilujte PLOTEMP.C pomoc Compile|Build All. Kompiltor se  zastav a
vype chybovou zprvu:

   Error C:\TC\EXAMPLES|PLOTEMP1.C 43:
      Statement missing ; in function main

   Turbo C++ nael  syntaktickou  chybu.  Ped  prvnm  skutenm sputnm
programu se zejm budete  pmo  brodit  v syntaktickch chybch. Natst
jsou syntaktick chyby  snadno  k  nalezen.  Stisknte  mezeru. Zvraznn
chybov ps oznauje prvn dek pkazu switch, kter vypisuje menu. Odkaz
na  chybjc stednk se obvykle vztahuje na  pedchoz  pkaz  (v  tomto
ppad na posledn z  pedchoz  skupiny  pkaz printf). Po zorientovn
stisknte F6  nebo  Enter  a  opravte  chybu.  Jestlie mte vce ne jednu
syntaktickou chybu, znovu  stisknte  F6  k  nvratu do okna Message a dle
pokraujte v pesunu na nsledujc  chybu pomoc Alt-F8 (nebo pomoc ipky
dol).

   Po  opraven  syntaktickch chyb znovu  program  zkompilujte.  Tentokrt
kompiltor  a linker pobا bez peruen, co  znamen,  e  program  nem
dn syntaktick chyby.

   Pro  sputn  PLOTEMP.EXE  zvolte  Run|Run.  Vype  se  menu programu.
Vyzkouejte postupn program stiskem vech klves v menu. Vyzkouejte velk
a  mal psmena. Stisknte i psmena, kter v nabdce nejsou. Co se v tomto
ppad stane? Pracuje ve tak, jak si pejete?

   Mon jste si vimli, e  pi  kadm  vbru  z  menu  se  objev dek
popisujc tuto funkci. (Vzpomnte si na pkazy printf  ve  vpisu?) Pot
se obvykle znovu objev menu. Pokus stisknete X (nebo  x),  program  skon
innost a nsleduje  nvrat  do  Turbo  C++.  Co se stane, kdy stisknete G
(nebo  g)?  Tak se vrtte do Turbo C++. To nen dobe - mlo by  se  opt
objevit menu. Nkde je chyba.



---------------------------------------------------------------------------
Trasovn programu
---------------------------------------------------------------------------


   Pouitm voleb v menu Run a sledovnm innho psu je  mono pozorovat,
jak se provdj programov pkazy a dit, jak detailn m trasovn bt.

   Zvolte  Run|Trace  Into  (nebo stisknte F7). Ladic  program  najede  v
editanm  okn na funkci main a zvrazn ji.  Toto  zvraznn  se  nazv
inn ps (run  bar)  a  oznauje  msto, kde se provdn programu doasn
zastavilo, pkaz, kter se m provst jako nsledujc.


Trasovn vy rovn
---------------------------------------------------------------------------

   Pro trasovn vy rovn vyberte Run|Step Over (nebo  stisknte  F8) a
provede  se  nsledujc  dek  obsahujc  kd  (dky  s  poznmkami  se
peskakuj). Kdy budete opakovan tisknout F8, budou se postupn vykonvat


                                  - 191 - 


pkazy printf, kter vypisuj menu. Obrazovka bude blikat. To je zpsobeno
ladicm programem - ten provede pkaz, kter vype zprvu na displej nebo
pkaz,  kter  se  na  okamik  pepne  do  uivatelsk obrazovky.  To  je
obrazovka, kterou generuje v program kdy jej nespoutte z integrovanho
prosted Turbo C++. Pepnut do n doshnete volbou Winow|User Screen nebo
stiskem Alt-F5. V zvislosti na tom, jak daleko jste  v  pkazech  printf,
objev  se  st  nebo  cel  menu  PLOTEMP.  Zpt  do ladicho programu se
dostanete stiskem kterkoliv klvesy.

   Tisknte  F8  dokud  se neobjev prvn dek pkazu switch. Tento dek
obsahuje voln  funkce getche, kter poaduje od uivatele vstup. Kdykoliv
se v programu objev poadavek na  vstup  uivatele, Turbo C++ se pepne do
uivatelsk  obrazovky.  Protoe  se  chcete  podvat, co se dje, kdy  se
vybere volba pro  graf (G), znovu stisknte F8 a pak G. Po zadn vstupu se
displej  pepne  zpt  do ladicho programu  a  inn  ps  se  pesune  na
nsledujc pkaz:

   case 'G': graph_view();

   m dle, tm lpe. Nsledujcm pkazem, kter se provede  je  exit  a
ocitnete se zpt v editoru. Stiskem F8 se pesvdte,  e  program  opravdu
skonil.  Nyn  vm  mon u dolo, e na nsledujcm dku m bt pkaz
break. Opravte dek, aby vypadal takto:

   case 'G': graph_view(); break;

   Nyn se podvejme, jestli oprava funguje. Mete spustit  program  a jt
krok  po  kroku - jene to je navn. Msto toho zvolte  Run|Go  to  Cursor
(nebo  stisknte  F4,  ujistte  se,  e  kurzor  je  na  sprvnm  dku).
Pebudujte  program  (potvrte  zprvu  "OK  to rebuild"); provede se a  k
dku, kde  se  oekv  vstup  od  uivatele.  Stisknte G v menu PLOTEMP,
provdn pokrauje na oznaen dek. Pokraujte v krokovn. Vimnte si,
e  tentokrt  se  provedl pkaz break a provdc pozice se vrt zpt na
zatek smyky while. Nyn se u sprvn objev menu PLOTEMP.


Trasovn ve volanch funkcch
---------------------------------------------------------------------------

   Po volb Run|Step Over se krokuje  pouze  ve vy rovni. Jak je vidt,
inn ps se zastavil uvnit funkce main, prochzelo se  pkazy  printf  a
rznmi  case uvnit pkazu switch. asto je  vak  nutno  trasovat  uvni
funkc  volanch  main  a uvnit funkc volanch z jinch funkc. Trasovn
uvnit funkc se zapn volbou Run|Trace Into nebo stiskem F7.

   Vyzkouejte  to: Trasujte programem a v menu  zvolte  E.  Tentokrt  jde
inn ps do patinho case v pkaze switch  a  pot  do  definice funkce
get_temps. Po projt  funkc  (je  v  n  pouze pkaz printf) se sko na
konec a  nsledn  na  zatek  velk smyky while v main a znovu se vype
menu.












                                  - 192 - 


---------------------------------------------------------------------------
Pokraovn ve vvoji programu
---------------------------------------------------------------------------


   Ve zbytku tto kapitoly  pidme  a  otestujeme  jednu funkci v PLOTEMP.
Msto toho, abyste museli ve  napsat z klvesnice, nahrajeme si rozenou
st z disku. Pokud  jste  ladili nkter ze svch program, provdli jste
pitom tyto kroky:


1. Pokud je to nutn, vymnil se prototyp funkce za kompletn nhradu.

2. Nhraky funkc se vymnily za skuten funkce provdjc zadanou
   lohu.

3. Otestovala se nov funkce sputnm programu a odpovdajc volbou v
   menu.

4. Opravily se chyby a testovalo se do t doby, ne byly vechny
   odstranny.

5. Obdobnm zpsobem se zalenily i nsledujc funkce dokud nebyl program
   odladn.


   Nejlep a nejrychlej vsledky  se  dostavuj  tehdy,  kdy vytvoen,
kompliaci,  sputn  a  odladn  provdme  pro  kadou  funkci oddlen.
Nezanejte  vyvjet  novou  funkci dokud nemte program  bez  chyb.  Tento
postup neodstrauje vechny  chyby,  mohou  se  vyskytnout  "skryt chyby",
kter  ekaj,  a  nastane  vhodn  kombinace okolnost. Alespo  se  vak
minimalizuje pravdpodobnost neoekvanch havri.

   Zanme funkc get_temps,  kter  z  klvesnice  nat  mnoinu vstup.
Protoe nam dn argumenty a nic pmo nevrac, deklarace prototypu

   void get_temps(void)

se nemus mnit. (V pln verzi tohoto programu vrac kad  funkce njakou
hodnotu, take se zde  mohou  vyskytnout  chyby.  V zjmu komplexnosti toto
vynechvme.)

   Vyhledejte existujc definici get_temps. Nyn je  torzem  funkce, kter
po  svm  vyvoln  pouze  vypisuje  zprvu.   Nahrate   existujc  dky
nsledujcmi:

   Program, kter zahrnuje tyto zmny se jmenuje PLOTEMP2.C. Nahrejte jej.


void get_temps(void)
{
   char inbuf[130];
   int  reading;

   printf("\nEnter temperatures, one at a time.\n");
   for (reading = 0; reading < READINGS; reading++)
   {
      printf("\nEnter reading # %d: ", reading + 1);
      gets(inbuf);
      sscanf(inbuf, "%d", temps[reading]);


                                  - 193 - 


      /* Show what was read */
      printf("\nRead temps[%d] = %d", reading, temps[reading]);
   }
}



---------------------------------------------------------------------------
Nastaven bod peruen
---------------------------------------------------------------------------


   Vzpomete si, e pole v C zanaj indexem 0, prvn  odkaz  jde na prvek
0, druh na prvek 1, atd.

   Pokud get_temps pracuje sprvn, smyka for vypisuje pi kadm natn
npovdu,  pot se nat etzec pomoc gets. Dle  se  pouv  sscanf  k
ukldn  etzce  do  pole  temps,  dal pkaz printf  vypisuje  hodnotu
uloenou v poli. Druh pkaz printf je jen vhodnm  prostedkem  z  nouze:
Ukazuje,  jak  se  ukldaj vstupy. Po  odladn  tto  funkce  jej  mete
odstranit.

   Spuste PLOTEMP2 a v jeho menu  zvolte  E, aby se get_temps provedla. Po
vstupu dat se objev nco jako:

   Enter reading # 1: 40

   Read temps[0] = 0
   Enter reading # 2: 50

   Read temps[1] = 0
   Enter reading # 3: 55

   Read temps[2] = 0
   Enter reading # 4: 57

   Read temps[3] = 0
   Enter reading # 5: 61

   Read temps[4] = 0
   Enter reading # 6: 64

   Read temps[5] = 0
   Enter reading # 7: 65

   Read temps[6] = 0
   Enter reading # 8: 60

   Read temps[7] = 0

   Co se zde stalo? Bez ohledu na to, jak data jste vkldali, odpovdajc
element pole temps zstal nastaven na 0.

   Bod  peruen je msto v programu, na kterm  se  program  po  sputn
zastav.

   Je jasn, e program potebuje uzavrac zkouku. K tomu, aby bاel a k
sti,  kter  ns  zajm,  nastavme  bod peruen. Pesute  kurzor  na
zatek smyky ve funkci get_temps:



                                  - 194 - 


   for (reading = 0; reading < READINGS; reading++)

   Nyn  vyberte  Debug|Toggle Breakpoint (nebo  stisknte  Ctrl-F8),  m
nastavte bod peruen na tento dek. dek s for je  zvraznn. Kdykoliv
se pi provdn programu  naraz  na dek, kde je nastaven bod peruen,
program se zastav a aktivuje se ladic program.

   Kdy umstte Toggle Breakpoint na dek, na kterm u bod  peruen je
nastaven zru se.

   Jak jste mohli vidt v pedchozm, umon vm  nastaven  bodu peruen
vyut  ladicch  pkaz  ke kontrole a zmn promnnch a jinch datovch
struktur. Jestlie je v programu  umstno nkolik bod peruen, je mono
se ve  volb Debug|Breakpoints vbrem View tlatka podvat na nsledujc
bod peruen.

   Body peruen zstvaj nastaveny do doby, ne:

    o  Opustte integrovan prosted.

    o  Zrute bod peruen pomoc Ctrl-F8.

    o  Zrute bod peruen volbou Debug|Breakpoints|Delete.

    o  Zrute  dek  (-ky),  na  kterm  (kterch)  je  (jsou)  bod  (-y)
       peruen nastaven (-y).

    o  Editujete  soubor  obsahujc  body  peruen  a  opustte  jej bez
       uloen.

   Kdykoliv opravte chybu nebo v  aktulnm  souboru  uinte  jin zmny,
ppadn  pouijete ladic pkaz, Turbo C++  se  zept  "Source  modified,
rebuild?"  (zdroj  modifikovn,  pebudovat?).  Obvykle  se  vol  Y, take
program respektuje zmny, kter jste provedli. Pokud stisknete N, potom jak
body peruen, tak inn ps  se vyskytuj na nesprvnch mstech, protoe
zdrojov text neodpovd programu, kter se provd.


Okamit zastaven pomoc Ctrl-Break
---------------------------------------------------------------------------

   Mon  vte,  e  stiskem  Ctrl-Break  se  vm  poda zastavit  vtinu
bاcch program. Stejn je tomu u Turbo C++ a  u  integrovanho  ladicho
programu. Avak ladic program nezastav vdy okamit chod programu. ek,
a  se  provede  strojov  kd,  kter  odpovd  jednomu dku  zdrojovho
programu. Pak zastav program na strojov instrukci, kter odpovd zatku
nsledujcho dku zdroje. Na nsledujcm dku se objev inn ps.

   Pokud  opravdu  potebujete  okamit  zastaven,  stisknte  Ctrl-Break
dvakrt.  Kdy je detekovn druh stisk,  ladic  program  okamit  ukon
provdn bez jakhokoliv vstupu a bez zavoln kterkoliv funkce slouc
k  ukonen. (Podobn jako uit funkce _exit.)  Tento  "double  break"  je
obvykle nedouc, protoe  obsah  datovch  soubor  je  nepedvdateln a
ladic program nev, kter dek m bt provdn dle.  Druh  stisk  Ctrl-
Break budete potebovat  snad  jen  tehdy,  kdy  program  "vis",  nebo se
zacykluje v nekonen smyce.

   Spuste program znovu, vype  se  menu. Stisknte E. Program bا a do
funkce get_temps, kde se  zastav  na bodu peruen. Krokujte pomoc F8 a
inn ps pejde  pkazy  v  tle  smyky  for  a  vrt se na prvn dek


                                  - 195 - 


smyky. Nyn se podvme na klov promnn, abychom se dovdli nco vce
o chyb.



---------------------------------------------------------------------------
Provrka dat
---------------------------------------------------------------------------


   Obecn programy obvykle pouvaj  mnostv  datovch  struktur  - pole,
struktury, uniony, seznamy, atd..  K  pochopen, co se dje v nkter sti
programu je asto  poteba  znt,  co  se ve skutenosti ukld do datovch
struktur.  Turbo C++ vm dv novou monost,  kter  se  nazv  inspektor.
Inspektory  vm   pomohou  podvat  se  "pod  pokliku"  sti  programu  a
vyzkouet, jak pracuje.


Inspektorsk okna
---------------------------------------------------------------------------

   Je mono provovat jakkoliv sprvn formulovan vraz C nebo C++ krom
tch, kter obsahuj voln funkc nebo symboly vytvoen pomoc #define.

   Oteven inspektorskho okna  doclte  pesunem  kurzoru  na  poloku v
editanm  okn a stiskem Alt-F4. (Je  mono  tak  zvolit  Debug|Inspect.)
Zkuste si proven promnn reading  z aktuln verze PLOTEMP2.C (kter by
mla   prv  bt  v  editanm  okn).   Vyberte   Run|Trace   Into,   pak
Debug|Inspect.

   Vechna inspektorsk okna zanaj jmnem poloky. U promnnch obsahuje
spodn dek adresu vyjdenou ve  form  segment::ofset.  (Promnn. kter
jsou deklarovny jako typ register nebo ty, kter Turbo C++  optimalizuje a
pot ulo do registr, adresu nemaj,  protoe  jsou uloeny v CPU, co je
lep  ne  v  RAM. Msto adresy uvidte slovo register.) Nsledujc dek
popisuje datov typ poloky (nap. unsigned int).

   Skuten  hodnota  poloky  se vypisuje napravo od  datovho  typu.  Pro
zobrazen promnn vol  Turbo  C++ automaticky vhodn datov formt. Msto
znak, kter nejdou vypsat, se zobraz obrcen lomtko (\) a hexadecimln
hodnota.  Na  druh   stran   me  promnn  int  obsahovat  destkov  i
hexadecimln hodnoty, ale ne znaky. S jinmi numerickmi typy je nakldno
obdobn.


Provovn pol a etzc
---------------------------------------------------------------------------

   U pole je pro kad prvek vylenn jeden dek. Pokud  se  prvky do okna
nevejdou, pouijte k prohldce  ipky.  U  etzce  se zobrazuje jeho pln
znakov reprezentace. Nsledujc obrzek ukazuje pole temps z PLOTEMP.C po
jeho naplnn pomoc funkce get_temps.










                                  - 196 - 


 [.]Inspecting temps2[^]ͻ
 8E8F:122C                                           ^
  [0]                                   55 (0x0037)  
  [1]                                   58 (0x003A)  
  [2]                                   61 (0x003D)  
  [3]                                   64 (0x0040)  
  [4]                                   69 (0x0045)  
  [5]                                   72 (0x0048)  
 <.>ı
  int [8]                                            v
 ͼ

                       Obr. 7.2: Provrka pole temps

   Vpis  etzc  se  podob vpisu pol (jsou to koneckonc stejn datov
struktury). U etzc se krom prvk vypisuje i znakov reprezentace.


Provovn struktur a union
---------------------------------------------------------------------------

   U struktur a  union  jsou vypisovny hodnoty individulnch len. Kdy
budete chtt vidt, jak  cel  vc funguje, nahrejte SOLAR.C (z kapitoly 4.
"vod do C") a  podvejte  se na pole solar_system. Protoe solar_system je
pole,  jeho  prvky  jsou  struktury  typu planet, je mono prohlet  data
uloen v kadm z len struktury planet.


Provovn ukazatel
---------------------------------------------------------------------------

   U ukazatel  je v inspektorskm okn zabrazena adresa ukazatele, adresa,
na  ni  ukazatel  ukazuje  a  data  uloen  na tto adrese (co me  mt
jednoduch  promnn,  pole,  struktura,  atd.).  Indexy  [0],   [1]  apod.
zjednoduuj uren pozice kad sti  dat.  Nsledujc  program definuje
znakov ukazatel ptr:

   main()
   {
      char * ptr - "This is a string\n";
   }


Provovn funkc
---------------------------------------------------------------------------

   V ppad funkce ukazuje  inspektorsk  okno  typ hodnoty, kterou vrac,
jej adresu a parametry.  Na  nsledujcm  obrzku je ukzno inspektorsk
okno pro funkci min_max z pln verze PLOTEMP.C.













                                  - 197 - 


 [.]Inspecting min max1[^]ͻ
  845B:03C8                                          ^
  int num_vals                                       
  int *vals                                          
  int *min_val                                       
  int *max_val                                       
 <.>ı
  void ()                                            v
 ͼ

                     Obr. 7.3: Provrka funkce min_max


   Provrku  funkce  je  mono  s  vhodou pout k zopakovn typu,  kter
funkce vrac a k zobrazen parametr bez nutnosti nvratu zpt do deklarace
funkce.


Kdy inspektory pouvat?
---------------------------------------------------------------------------

   Pouit  inspektor  by  se  mon  mohlo zdt zbyten,  protoe  volba
Debug|Evaluate (probrna dle) tak zobrazuje hodnoty promnnch. Skuten
vhoda  inspektor  se  projev  pi  vyetovn  komplexnjch  datovch
struktur  (struktury,  uniony  a pole tchto datovch  typ).  Obecn  jsou
inspektory uiten pi hloubkovm studiu  dat,  zatmco  Debug|Evaluate je
nejlep pro rychl pohled na jednoduch data.



---------------------------------------------------------------------------
Vyslovn a zmna promnnch
---------------------------------------------------------------------------


   Nahrejte PLOTEMP2.C,  zkompilujte jej a skote na posledn pkaz printf
ve  funkci  get_temps.  Zvolte E a vlote jednu hodnotu. Mla by se provst
jednou smyka for. Nate, zformtuje a ulo jednu hodnotu (viz funkce gets
a sscanf). Nyn  zvolte  Debug|Evaluate, kter vykresl okno obsahujc ti
pole:

    o  pole pro vrazy (Expression field),  kter  obsahuje  vraz,jen vs
       zajm

    o  pole vsledk  (Result field), kter zobrazuje hodnotu vrazu z pole
       pro vrazy

    o  pole  novch hodnot (New Value field), kam  je  mono  napsat  novou
       hodnotu pro zvolen vraz

   Implicitn  je "slovo" (promnn z C, voln  funkce,  atd)  vypsno  do
vyslovacho  pole.  Mme  zjem  o  dv promnn: reading, co je  dc
promnn smyky, a o pole temps, kter obsahuje vstupn data.

   Napite reading a stisknte Enter. V poli vsledk je  0.  Po  krokovn
pkaz ve smyce  a  po  dalm  vyslen reading shledte, e hodnota se
zmnila na 1.





                                  - 198 - 


   Je mono vyzkouet i hodnoty komplexnjch datovch struktur, jako jsou
pole, etzce a struktury. Nyn uvidte, co se stane s polem temps. Napite
temps do vyslovacho pole. Vype se nsledujc:

   [0,0,0,0,0,0,0,0]

   To ukazuje, jak celoseln hodnoty jsou uloeny v poli temps. Je mono
nechat  si  vypsat  pomoc indexu i jen jedinou hodnotu: napklad temps[0]
zobraz prvn prvek. Je mono samozejm otevt inspektorsk okno.

   Vimnte si, e se  odkazujeme  na  vrazy,  nikoliv na hodnoty samotn.
Vzpomete si, e vraz je kombinace promnnch, konstant a opertor, kter
dvaj  jedinou hodnotu, nap. vals1[index] +  vals2[index]  +1.  Je  mono
zobrazit hodnotu vrazu, kter

    o  nezahrnuje voln funkce (nap.  neme  bt  pouit vraz sqrt(a) +
       1),

    o  nepouv hodnotu #define, jako teba READINGS  v  prv aktivovanm
       programu.

   Jako cvien si vyslete hodnoty nsledujcch vraz:

   reading + 2
   temps [reading + 1]


Uren formtu zobrazen
---------------------------------------------------------------------------

   Nepovinn  je mono k zobrazovan hodnot  pidat  rku  a  specifikaci
formtu. Napklad pro  vpis  hodnoty  promnn  reading  v hexadecimlnm
tvaru  napite  reading,h  (nebo reading, x). Implicitn  jsou  cel  sla
zobrazovna v destkovm tvaru a znakov pole jako etzce.

   Specifikace m  je  uiten  pi  prci  s  poli: vypisuje pam؟ na dan
adrese. Napklad temps,m  zobraz  obsah  pamti  ponaje  zadanm mstem
(protoe  temps  je  pole, jeho jmno ukazuje na poten adresu uloench
dat):

   00 00 00 00 00 00 00

   To znamen, e vechny prvky pole temps jsou nastaveny  na  nulu.  Poet
vypsanch prvk zvis  na  dlce  pole.  m  je mono kombinovat i s jinmi
specifikacemi:

   temps,mh

zobrazuje vpis pamti v hexadecimlnm formtu.

   Dal uitenou specifikac je  p,  kter  zobrazuje  vybranou promnnou
jako ukazatel, kter podv informaci o sti pamti, kam se ukazuje (nap.
tabulka  vektor   peruen,  oblast  dat  BIOS  nebo  prefix  segmentu  s
uivatelskm programem [PSP]). Pokud  se  ukazuje na msto v pam؟i, kde je
uloen  program,  je  vypsno  (pokud  existuje) i jmno promnn. (Vce  o
rozdlen pamti  se mete se dozvdt v Programtorsk pruce, kapitola
4, "Modely pamti, pohybliv rka a overlay".)





                                  - 199 - 


Uren potu hodnot
---------------------------------------------------------------------------

   Kdy pracujete  s  polem,  je  nutno  urit,  kolik hodnot se m vypsat:
temps,5 uruje prvnch pt  len  pole temps. Tento zpsob vpisu je mono
kombinovat s jinmi specifikacemi.  Napklad  temps[2],3h  k,  e budou
vypsny ti prvky za tetm prvkem pole temps v hexadecimlnm formtu.

   Dal formtov specifikace a vce detail o pkazech ladicho programu
najdete v  Uivatelsk pruce, kapitola 1, "IDE" (kapitola o integrovanm
prosted).  Pot,   co  si  v  tto  kapitole  ladic  program  "osahte",
doporuujeme vm pest souvisejc sti tto kapitoly.


Koprovn od pozice kurzoru
---------------------------------------------------------------------------

   Jak  bylo  uvedeno  dve,  obsahuje  vyslovac okno slovo,  kter  se
nachz na pozici kurzoru pi  volb Debug|Evaluate. Tm si uette psan.
Napklad kdy pesunete kurzor na zatek vrazu

   temps[reading],

objev se ve vyslovacm okn temps. Do vyslovacho okna  je  pak  mon
zkoprovat cel vraz temps[reading], stiskem Enter se vype hodnota.


Specifikace promnnch v jinch funkcch
---------------------------------------------------------------------------

   Prv te se  dvte  na  promnn  reading a temps ve funkci get_temps.
Pomoc ladicho programu  je  mono zskat i hodnoty statickch promnnch,
protoe ty si dr svou hodnotu i tehdy,  kdy  funkce,  kter  je pouv,
nen prv v  innosti.  Je  mono  si prohldnout i promnn funkc, kter
vyvolvaj prv provdnou funkci.  Nelze  prohlet  obyejn automatick
promnn deklarovan v jinch funkcch,  protoe  si  po  skonen innosti
funkce  neuchovvaj svou hodnotu. Kontext na  jeho  zklad  jsou  funkce
vyslovny je dn okamitou pozic kurzoru v editanm okn.

   Specifikace promnn vn dan funkce se dje umstnm  kurzoru  do tla
funkce nebo urenm jmna funkce, periody a jmna promnn.

   Pokud se promnn, kterou chcete  vyslit  nalz  v  jinm programovm
modulu, je teba nejprve specifikovat jmno modulu - nap.:

   module2.getvals.count


Zmny hodnot
---------------------------------------------------------------------------

   Nyn vte, jak prohlet rzn druhy promnnch a vraz  a  jak  zskat
jejich hodnoty v rznch  formtech.  Jako cvien si projdte smyku for v
get_temps a prohldnte si hodnoty  reading a temps[reading]. Druh by mla
vdy bt nulov.

   Zkuste si  pi  prchodu  smykou  vyslit vraz temps[reading]. Ladic
program vype hodnotu nula bez ohledu na hodnotu reading.  Co  tedy  tento
vraz vyjaduje? Protoe specifikuje msto v pamti pro funkci sscanf, mus
bt  adresou. To znamen, e vechny vstupujc  hodnoty  jsou  uloeny  na


                                  - 200 - 


adrese 0! V tomto zjitn se meme utvrdit pouitm ukazatelovho formtu
temps[reading],p, shledme, e hodnota je stle nulov.

   K  tomu,  aby  se tento vraz odvolval na adresu pole  temps  je  nutno
pout  adresov  opertor &. Vyslete  &temps[reading],p.  Vsledek  bude
vypadat  asi takto: DS:1278 temps+1. Skuten  hodnota,  kter  se  vype,
zvis na na konfiguraci  vaeho  systmu a aktuln hodnot reading, ale i
tak  je  mono  vidt,  e  &temps[reading]  ukazuje  na adresu  v  datovm
segmentu, offset pak na promnnou temps.

   Zmte v pkaze sscanf vraz temps[reading]  na  &temps[reading]. Pokud
nyn znovu  krokujete program, jste dotzni na jeho pebudovn. Stisknte
Y. Kdy te znovu  prochzte  smykou  for  a vysluje se temps[reading],
vidte, e se vstupn hodnoty ukldaj do pole sprvn.

   Nyn nastala vhodn chvle, abyste si vyzkoueli zmnu promnnch pomoc
ladicho programu. Vyslete aktuln hodnotu temps[reading].

   Klvesou Tab se  pesute  na  ti  pole (pole vsledk, novch hodnot a
vyslovac pole). Kurzorem najete  do  pole  novch  hodnot, napite 66 a
stisknte Enter. Pokud nyn napete do vyslovacho  pole temps[reading],
v poli vsledk se objev nov hodnota 66.  Je  tedy  mono  zmnit hodnotu
jakhokoliv  vrazu,  kter  obsahuje  jedin  datov   element,   jako  je
jednoduch promnn, ukazatel nebo prvek pole.

   Interaktivn  zmna hodnot z ladicho programu  je  vhodn  pro  doasn
odstrann chyb  za  pinou  pokraovn  prchodu  programem  a hlednm
dalch chyb. Zde  je  napklad  mon  uloit nov hodnoty do temps[0] a
temps[7], nastavit reading na 8 a  vyskoit  tak ze smyky do hlavnho menu
programu. Je tak mono  pinutit  funkci,  aby  vrtila uritou hodnotu, se
kterou se pak vol dal funkce. Toto vechno vm umon testovat neobvykl
podmnky, kter mohou bt zdrojem chyb bez umstn doasnch piazovacch
pkaz do programu.

   Funkce  get_temps  u  bude  pracovat  sprvn. Nyn se  vnujme  funkci
table_view abychom si mohli prohldnout vstupn data. Nahrate torzo kdu v
table_view nsledujcm:

   Umstno v PLOTEMP3.C.

void table_view(void)
{
   int reading;

   clrscr();       /* clear the screen */
   printf("Reading\t\tTemperature(F)\n");

   for (reading = 0; reading <= READINGS; reading++)
      printf("%d\t\t\t%d\n", reading + 1, temps[reading]);

   min_max();
   printf("Minimum temperature: \n");
   printf("Maximum temperature: \n");
   avg_temp();
   printf("Average temperature: \n");
}






                                  - 201 - 


   Tato funkce vypisuje  hlaviky  tabulek  a  pot  pouv  smyku  for k
naten a zobrazen hodnot uloench v poli temps. Um ppadn vypisovat i
minimum, maximum  a prmr teplot. Tyto funkce nejsou jet implementovny,
zatm poze zobrazuj zprvu o tom, e jsou provdny.

   Vimnte si, e zalenn volanch funkc jet ped jejich implementac
umouje testovat chod programu a  sledovat  jeho  strukturu.  Tento zpsob
tvorby se nazv shora dol (top-down), protoe program se tvo nejprve od
nejvy rovn (funkce main). Nachzte se ve stavu tvorby funkc volanch
main, jako je teba table_view. A bude pracovat table_view, zanou se pst
funkce, kter table_view vol, jako min_max a avg_temp.

   Te  spuste  PLOTEMP3.C,   zvolte   E  a  vlote  testovac  data  (zde
10,20,30,40,50,60,70,80). Po  nvratu do menu vyberte T (tabulka) a uvidte
toto:
Reading                  Temperature (F)
   1                             10
   2                             20
   3                             30
   4                             40
   5                             50
   6                             60
   7                             70
   8                             80
   9                              0

   Executing min_max()
   Minimum temperature:
   Maximum temperature:

   Executing avg_temp().
   Average tamperature:



---------------------------------------------------------------------------
Sledovn programu nastavenm sledovn
---------------------------------------------------------------------------


   Vloili jste osm hodnot a dostali  devt!  Posledn m hodnotu 0. Asi ve
vs vzniklo podezen na smyku, kter se provede vcekrt ne m.

   Ureme msto chyby nastavenm bodu peruen na prvn dek smyky for v
table_view. Nastavte kurzor na tento dek a zvolte Debug|Toggle Breakpoint
(nebo stisknte Ctrl-F8).

   Nyn znovu spuste program, vlote testovac data a vyberte T (tabulka).
Program se zastav v table_view na bodu peruen. Podvejme se nyn, co se
dje ve smyce for.

   Hodnoty  promnnch  jste  provili   krokovnm   programu   a  volbou
Debug|Evaluate.  To  je  dobr k jednorzovmu pohledu  na  hodnoty,  jene
tehdy,  kdy prochzme smykou nebo opakovanm  volnm  funkce,  by  bylo
vhodn, kdybychom mohli  sledovat,  jak  se  hodnoty  mn.  Run  je tato
innost navn. Proto umouje  ladic  program  sledovat mnc se hodnoty
automaticky  nastavenm  sledovn (watching). Sledovn  je  vraz,  jeho
hodnota je aktualizovna vdy, kdy je pepotna v bاcm programu.




                                  - 202 - 


Vkldn sledovn
---------------------------------------------------------------------------

   V  tomto  ppad  ns zajmaj dv hodnoty: reading, kter je opakovan
zvtovna smykou for a temps[reading],  kter obsahuje hodnotu, je se ve
smyce vypisuje. Protoe je nablzku kurzor, nejlepm zpsobem k nastaven
sledovn je pesunout kurzor na jmno promnn, kterou  chcete  sledovat a
pak vybrat  Debug|Watches|Add  Watch  (nebo  stisknout  Ctrl-F7).  Pesute
kurzor na reading a  zkuste  to. Uvidte okno. Stejn jako v Debug|Evaluate
se  implicitn  vype  u  kurzoru  jmno. Stisknte Enter.  Stejn  postup
opakujte pro  temps[reading].  V  okn  se  uke  temps, ale stejn jako v
Debug|Evaluate mete zbytek vrazu umstit do okna pomoc  ipky  vpravo a
Enter.


Sledovn (watching)
---------------------------------------------------------------------------

   Nyn  mme  nastaveno  dvoj sledovn, jmno promnn a jej hodnota je
zobrazena v okn Watch:

   reading:177
   temps[reading]: 92
   Protoe smyka jet nebاela, vypsan hodnoty (zvisl na systmu) jsou
bezvznamn, jsou nhodnm obsahem pamti.

   Nyn krokujte smykou (pomoc F8). Vmejte si mncch  se  hodnot. Pi
prvnm prchodu jsou hodnoty tyto:

   reading:0
   temps[reading]: 10.

   Jsou piazovna testovac data ponaje  10, jak bylo popsno dve. Po
dalch krocch se vype

   reading:1
   temps[reading]: 20

   Pi poslednm prchodu jsou hodnoty takovto:

   reading:8
   temps[reading]: 0

   To znamen, e smyka kon  pot,  co  reading  m  hodnotu  8.  Kdy by
sprvn mla konit? Protoe je natno osm vstup a reading zan  na 0,
posledn hodnota by mla bt 7,  ne  8. Podvejme se na ukonovac podmnku
smyky:

   reading <= READINGS

   Kontrolou  v  #define  na zatku programu zjistme,  e  READINGS  maj
hodnotu  8.  Vidte  tu chybu? Aby smyka skonila tehdy, kdy reading je 7
(po  naten  osmi  vstup), mla by  podmnka  vypadat  takto:  reading  <
READINGS. Opravte to a znovu spuste program, abyste si ovili, e pracuje
sprvn.







                                  - 203 - 


zen oken ladicho programu
---------------------------------------------------------------------------

   Pokud nastavte vce oken, nen prostor na to, aby byly vidt vechny. V
okn Watch je mono se pohybovat pomoc klves PgUp a PgDn a ipek nahoru a
dol.

   Tento zpsob prce plat i pro okno Debug|Evaluate.

   Kdy se dan vraz nevejde do okna, je mono jej prohlet  pomoc Home,
End a ipek doprava a doleva.

   Jinm zpsobem je  zvten  okna. Nvod najdete v Uivatelsk pruce,
kapitola 1, "IDE".

   Vzpomete si, e do obrazovky programu se mete pepnout pomoc Alt-F5.
Zpt se dostanete stiskem kterhokoliv tlatka.

   Vyzkouejte si tyto vlastnosti prakticky.


Editace a ruen sledovn
---------------------------------------------------------------------------

   Pidvn, editace (zmna) a ruen  sledovn  je  snadnou zleitost.
Pokud je okno Watch aktivn, je zvraznn aktuln vraz. Pro  vbr jinho
vrazu se pouvaj ipky nahoru a dol, Home a End.

   Nen mono mnit hodnotu vrazu, pouze vraz samotn.  Ke  zmn hodnoty
se pouv Debug|Evaluate.

   K editaci (zmn) zvraznnho okna je  mono  zvolit Debug|Watches|Edit
Watch. Stisknte Enter. Ladic  program  oteve  pekryvn okno se zvolenm
vrazem, kter je mono editovat. Vyzkouejte to zmnou temps[reading] na
temps[reading+1].

   Jak se pidvaj vrazy do oken u vte. Existuje vak  jet jednodu
cesta ne bylo uvedeno: stisknte Ins. Objev se pekryvn okno. Napite do
nj vraz, pipite k nmu  pomoc ipky vpravo nebo akceptujte okoprovan
z pozice kurzoru.

   Ke  zruen  aktulnho  okna  zvolte  Debug|Watches|Delete  Watch  nebo
jednodue stisknte  Del. Vyzkouejte to zruenm okna pro reading. Vechna
sledovn je mono zruit volbou Debug|Watches|Remove All Watches.


Hledn definice funkce
---------------------------------------------------------------------------

   Nyn, kdy se PLOTEMP.C roziuje, he se hled  funkce,  kterou chcete
vyzkouet. Ladic program poskytuje  monost  prochzet  editanm  oknem k
dan definici funkce.  Vyberte  Search|Locate  Function,  Turbo  C++ oteve
dialogov dek.  Zkuste  napsat  get_temps  (neuvdjte  za  jmnem funkce
zvorky, ladic program by  funkci  nenael).  V  editanm okn se zobraz
definice get_temps. Tato monost je uiten pi opakovn definice funkce,
pi hledn bod peruen a pi sledovn.

   Vimnte si, e funkce  Search|Locate  Function  pracuje jen s funkcemi,
kter maj zdrojov kd  v  souboru, kter byl kompilovn s informacemi pro
ladn. Knihovn funkce, jako nap. printf,  volba  Search|Locate Functions


                                  - 204 - 


nenajde,  protoe  jejich  zdrojov  kd  nen  v   integrovanm  prosted
pstupn.


Nalezen co se odkud vol
---------------------------------------------------------------------------

   V  obecnm programu me existovat nkolik  rovn  funknch  voln  a
nkdy  je nron pamatovat si poad, v jakm se funkce volaj a k danmu
bodu peruen. I tady vm pome ladic program.  Nastavte  bod peruen,
kter zastav chod programu na  mst,  kde  potebujete  znt posloupnost.
Jako cvien nastavte bod peruen na printf v min_max.

   Spuste program  a  zvolte  T.  To  pinut  program zastavit se na bodu
peruen. Nyn zvolte  Debug|Call  Stack.  Pekryvn  okno  vype vechny
funkce, kter ekaj v tomto bod na dokonen. Zsobnk obsahuje nejbli
funkci  na  vrcholu,  v  tomto  ppad  je  to min_max.  Ta  je  volna  z
table_view, kter je zase volna z main.

   Ke zvraznn funkce v okn Call Stack se pouvaj ipky nahoru a dol.
Po stisku Enter se v editanm okn objev posledn dek, kter byl v dan
funkci proveden.

   Vdy je mono vrtit se zpt na pvodn msto, kde se  zastavil program.
Najete na prvn funkci v okn Call Stack - v tomto ppad min_max.

   Nyn

    o  poslednm provdnm  dkem v min_max je prvn dek jej definice,
       protoe prv tam je umstn bod peruen.

    o  poslednm provdnm dkem v  table_view  byl  ten,  kter obsahuje
       voln min_max.

    o  poslednm provdnm dkem v main je ten, kter spout table_view;
       pesnji case 'T':table_view; break.

   Jinmi slovy -  prv  se  provd  min_max, table_view a main ekaj na
dokonen.


Vce zdrojovch soubor
---------------------------------------------------------------------------

   Pokud pracujete s delmi programy,  poznte,  e  vlastnosti  o kterch
jsme mluvili v pedelm, jsou velmi uiten. Vtina velkch programovch
projekt sestv z nkolika zdrojovch soubor. Ladic  program automaticky
do  editanho  okna  nahrv  takov  soubor, aby splnil  vae  poadavky.
Napklad  jestlie  budete pomoc Search|Locate  Function  hledat  funkci,
kter  je deklarovna v jinm souboru, ne je  prv  oteven  v  editanm
okn, ladic program nahraje patin  soubor do editoru. Pokud v aktulnm
souboru udlte njak  zmny,  jste  dotzni  na to, jestli se maj zmny
uloit  na  disk.  Stejn proces probh, kdy si chcete prohldnout pomoc
Debug|Call Stack posledn provdn dek funkce, jej definice je v jinm
zdrojovm souboru.

   Pestoe  ladic  program  umouje  snadnou  prci  s  vce  zdrojovmi
soubory, je z praxe znmo, e nejlep je  ladit  jeden  nebo  dva zdrojov
soubory  narz.  Opravu  chyby  vdy  ihned vyzkouejte, protoe  jinak  se



                                  - 205 - 


vystavujete nebezpe, e oprava bu  nebude  fungovat  nebo  zpsob dal
chyby.



---------------------------------------------------------------------------
Prevence
---------------------------------------------------------------------------


   Brzy ukonme  vvoj  a  testovn  PLOTEMP.C.  Jako  pomoc k tomuto a k
dalmu budoucmu ladn se  podvejme  na  nkolik  zpsob, jak se chybm
vyhnout a ukame si nkolik chybovch situac.


Opatrn tvorba
---------------------------------------------------------------------------

   Stejn jako se mete opatrnm zenm auta vyvarovat nehod, je mono se
opatrnou  tvorbou  programu  vyhnout chybm. To jste  mohli  pozorovat  pi
tvorb PLOTEMP.C metodou programovn shora dol.

   Zkuste  vytvoit  program  z  funkc,  kter  jsou  jednoduch  a  dobe
definovan.  in  analzu  a  testovn  vsledk  jednodu.  Program je
itelnj a snze  modifikovateln.  Jestlie  se  v  PLOTEMP.C zkombinuje
tabulka a graf do jedn funkce, program se snadno stane tاkopdnm.

   Vyzkouejte u kad funkce minimalizovat data a snit poet prvk. Tak
to usnadn  testy a analzu vsledk jednotlivch ppad, zlep itelnost
a modifikovatelnost program. Omez se i ppadn nesprvn chovn funkc,
protoe  je  mono  spoutt  jednu  funkci  nkolikrt  pi jednom  ladn
programu.


ist prce
---------------------------------------------------------------------------

   Pite svoje programy jasn, s  jasnou nvaznost, vhodnmi komenti a s
popisnmi jmny promnnch.

   Pite  jednodue.  Vyjdete  sloitj  operace radji pomoc mnostv
jednoduchch pkaz ne v  jednom  obecnm.  Optimalizac,  kterou provd
Turbo  C++, doshne v program uiten  efektivity,  mnohem  snadnji  se
lad, te a modifikuje.

   Nezkouejte pi psan programu vymknout  z nj co nejvt vkon. Kdy
se  pokuste  jej  napsat co nejvkonnjm zpsobem,  bude  zejm  patn
iteln a bude obsahovat mnoho chyb. A kdy bude pli pomal, rozhodnte
se, kter sti  je  teba  zrychlit  a pemlejte, jak to nejlpe udlat.
(Pro tuto lohu se nejlpe hod Turbo Profiler.)

   Dvejte pozor na funkce, kter se v programu pouvaj nkolika zpsoby,
ppadn  se  uvaj  v  jinch  programech. Tvorba a ladn jedn  obecn
funkce je obvykle jednodu ne  tvorba  dvou  nebo  vce specializovanch
procedur.







                                  - 206 - 


---------------------------------------------------------------------------
Systematick testovn software
---------------------------------------------------------------------------


   Ped vzletem je kad letadlo systematicky kontrolovno  posdkou, kter
zkou,  zda  ve  dobe  funguje.  Pouit  specilnho  postupu  redukuje
nespolehlivost drav lidsk pamti na  minimum.  Stejn  mylenka  vede ke
standardnmu postupu pi testovn software: mme nkolik bod  o  nich ze
zkuenosti vme, e vedou ke spolehlivm programm.

   Jedin "prav" cesta k testovn programu neexistuje, seznam kontrolnch
bod  zvis  na  typu  programu,  kter  pete,  vaich  programtorskch
schopnostech a  osobnm stylu. Nsledujc seznam kontrolnch bod me bt
chpn jako startovac rampa, i kdy erp z velkch zkuenost.

    o  Zadejte   programu  jednoduch,  ale  ne  triviln  vstupn   data.
       Vyzkouejte i nemon - nap. zkusili jste v PLOTEMP napsat zpornou
       vstupn hodnotu? Trasujte program pomoc Debug|Evaluate a kontolujte
       data pomoc vraz. Opravujte vdy  jen jednu nebo nkolik mlo chyb
       najednou.

    o  Zadejte jin vstupn data ne v pedchozm bod, abyste otestovali i
       jin  sti  programu.  Pokud je to mon, pozvte nkoho, kdo nezn
       v  program,  a   jej   vyzkou.   Obecn   zkuenost   k,  e
       programtorm se tاko testuj vlastn programy, protoe vd, kter
       hodnoty jsou vhodn a kter ne. Jestlie je program ovldn popisn,
       vyzkouejte to.

    o  Testujte kad pkaz v programu.  Naleznete chyby tam, kde byste je
       neoekvali.

    o  Odlote   ladic  program  a  testujte  sprvn  chovn   vlastnho
       programu. Jestlie program pouvaj i  jin  lid,  kte oekvaj
       hladk prbh,  otestujte  vechny  chyby,  kter  by  mohly nastat.
       Program, kter um oetit vtinu chyb, se nazv robustn.


Modifikace test
---------------------------------------------------------------------------

   Jestlie pozmnte program, je  teba  znovu  otestovat  opraven sti.
Muste vyzkouet i  ty  sti,  kter  nejsou  modifikovny,  ale  kter se
zmnami souvis.

   Pokud  je  program  rozshlej,  zaznamenejte  si  testy,   kter  jste
provdli.  Pi ppadn zmn vm tento  zznam  pome  otestovat,  kter
vsledky  jsou  na  oprav  zvisl.  Jestlie  je  mono  testovat  pomoc
vstupnch soubor, nahrvejte si je.


Oblasti zasluhujc zvltn pozornost
---------------------------------------------------------------------------

   Jak se  postupn  budete  uit  C  a  vyvjet programy, budete tak znt
nkolik  obecnch  chyb  a jejich kd.  Zde  je  nkolik  pklad,  kter
postihuj mnoho programtor:

    o  chyby rozsahu



                                  - 207 - 


    o  zmna adres a hodnot na tchto adresch

    o  patn umstn opertor pro pitn nebo odtn

    o  nepln testovac pkazy

    o  pouit syntaxe Pascalu msto syntaxe C

   Kad z tchto bod je probrn dle.

   Zamte se na hranin podmnky - podmnky, kter  uruj  konec smyky,
naplnn  pole,  atd..  Chyby se nejvce projevuj  pi  patnm  nastaven
hraninch  podmnek.  Mli  jste monost vidt, jak  podmnka  reading  <=
READINGS vypisovala o jednu  hodnotu  vce. Jinm problmem je zatek od 1
msto od 0.

   Dejte si pozor  na  to,  jestli  specifikujete  adresu  nebo  hodnotu na
adrese. Nap. nezamte hodnotu temps[reading] za adresu &temps[reading].

   Bute opatrn pi  pouvn  opertor  ++  a  --.  Je  pouit hodnota
inkrementovna ped nebo po pouit?

   Bute opatrn u pkaz  nebo  vraz, kter mus bt testovny vce ne
jednou, jako nap.
   switch (strcmp(a,b) ) ...

strcmp  me  vracet ti hodnoty: 0 (a se rovn b), -1 (a je men  ne  b)
nebo +1 (a je vt ne b). To znamen, e je  nutno  testovat  ti ppady
vstupnch hodnot, jestli strcmp dl vechno tak, jak je teba.

   x = (x>0) ? func(x) : 0 ;

Tento pkaz obsahuje "implicitn if", kter me dvat dva rzn vsledky.



---------------------------------------------------------------------------
Ukonen PLOTEMP.C
---------------------------------------------------------------------------


   Instalovali  a  otestovali  jste   prototyp   PLOTEMP.C   a   dle  jste
implementovali,  vyzkoueli  a  odladili  funkce  get_temps  a  table_view.
Nauili jste se pouvat vechny vlastnosti  ladicho  programu. Kompletace
PLOTEMP.C je sri cvien, kde

    o  Pepete  torzo  kdu  funkce kdem z vpisu. Usnadnili jsme vm to
       napsnm programu,  kter tyto zmny obsahuje. Ve, co muste udlat
       je to, e nahrajete dal verzi.

    o  Zmnte prototyp funkce (pokud je to nutn).

    o  Vyzkoute  implementace funkce uitm vhodnch vlastnost  ladicho
       programu.

    o  Najdete a odstrante chyby.

    o  Pesunete se na dal funkci.




                                  - 208 - 


Ukonen table_view
---------------------------------------------------------------------------

   K uzaven tto funkce je teba implementovat nsledujc dv funkce:

   Nahrejte PLOTEMP4.C. Nezapomete, e jsme  do  program  PLOTEMP vloili
chyby, take si mete vyzkouet sv ladic schonosti.


void  min_max(int num_vals, int vals[], int *min_val, int *max_val)
{
   int reading;

   *min_val = *max_val = vals[0];

   for (reading = 1; reading < num_vals; reading++)
   {
      if (vals[reading] < *min_val)
    *min_val = (int)&vals[reading];
      else if (vals[reading] > *max_val)
    *max_val = (int)&vals[reading];
   }
}

float avg_temp(int num_vals, int vals[])
{
   int reading, total = 1;

   for (reading = 0; reading < num_vals; reading++)
      total += vals[reading];

   return (float) total/reading; /* reading equals total vals */
}


Protoe  tyto  funkce  maj  parametry  a  vracej  hodnoty, zmte  jejich
prototypy na

   Tyto zmny jsou zahrnuty v PLOTEMP4.C.


void  min_max(int num_vals, int vals[], int *min_val, int *max_val)

float avg_temp(int num_vals, int vals[])

   Nakonec zmnme  table_view tak, aby byly sprvn pouity hodnoty, kter
vracej funkce. Opraven table_view vypad takto:

   Tyto zmny jsou zahrnuty v PLOTEMP4.C.


void  table_view(void)
{
   int reading, min, max;

   clrscr();                                  /* clear the screen */
   printf("Reading\t\tTemperature(F)\n");

   for(reading = 0; reading < READINGS; reading++)
      printf("%d\t\t\t%d\n", reading + 1, temps[reading]);


                                  - 209 - 


   min_max(READINGS, temps, &min, &max);
   printf("Minimum temperature: %d\n", min);
   printf("Maximum temperature: %d\n", max);
   printf("Average temperature: %f\n", avg_temp(READINGS, temps));
}


   Nyn k vlastnmu ladn. Vyzkouejte obvykl operace:

    o  Pracuj sprvn smyky?

    o  Jsou sprvn aritmetick operace?

    o  Co porovnvaj porovnn?


Implementace graph_view
---------------------------------------------------------------------------

   Vzpomete  si na funkci graph_view, kter vytv  graf  (obr.  7.2).  K
implementaci tto funkce nahrate jej  definici tmto: (ujistte se, e na
zatku programu je #include <graphics.h>)

   nahrejte plotemp5.C.


void  graph_view(void)
{
   int  graphdriver = DETECT, graphmode;
   int  reading, value;
   int  maxx, maxy, left, top, right, bottom, width;
   int  base;                          /* zero x-axis for graph */
   int  vscale = 1.5;       /* value to scale vertical bar size */
   int  space = 10;                     /* spacing between bars */

   char fprint[20];               /* formatted text for sprintf */

   initgraph(&graphdriver, &graphmode, "..\\bgi");
   if (graphresult() < 0)           /* make sure initialized OK */
      return;

   maxx  = getmaxx();              /* farthest right you can go */
   width = maxx /(READINGS + 1); /* scale and allow for spacing */
   maxy  = getmaxy() - 100;              /* leave room for text */
   left  = 25;
   right = width;
   base  = maxy / 2;              /* allow for neg values below */

   for (reading = 0; reading <= READINGS; reading++)
   {
      value = temps[READINGS] * vscale;
      if (value > 0)
      {
         top = base - value;            /* toward top of screen */
         bottom = base;
         setfillstyle(HATCH_FILL, 1);
      }
      else
      {
         top = base;


                                  - 210 - 


         bottom = base - value;      /* toward bottom of screen */
         setfillstyle(WIDE_DOT_FILL, 2);
      }
      bar(left, top, right, bottom);
      left  +=(width + space);       /* space over for next bar */
      right +=(width + space);        /* right edge of next bar */
   }

   outtextxy(0, base, "0 -");
   outtextxy(10, maxy + 20, "Plot of Temperature Readings");
   for (reading = 0; reading < READINGS; reading++)
   {
      sprintf(fprint, "%d", temps[reading]);
      outtextxy((reading *(width + space)) + 25, maxy + 40, fprint);
   }

   outtextxy(50, maxy+80, "Press any key to continue");

   getch();                               /* Wait for a key press */

   closegraph();
}


save_temps a read_temps
---------------------------------------------------------------------------

   Funkce save_temps ukld  obsah  pole temps do diskovho souboru. Logiku
pstupu k jednotlivm lenm pole u znte.

   Nahrate torzo definice funkce save_temps nsledujcm:

   Nahrejte PLOTEMP5.C.


void  save_temps(void)
{
   FILE * outfile;
   char file_name[40];

   printf("\nSave to what filename? ");
   while (kbhit());     /* "eat" any char already in keyboard buffer */
   gets(file_name);
   if ((outfile = fopen(file_name,"wb")) == NULL)
   {
      perror("\nOpen failed! ");
      return;
   }
   fwrite(temps, sizeof(int), READINGS, outfile);
   fclose(outfile);
}


   Funkce read_temps  je  opakem  save_temps,  nat  z  diskovho souboru
hodnoty do pole temps. Zaate  read_temps  pepsnm  torza  jeho definice
nsledujcm:

   Tyto zmny jsou tak zahrnuty v PLOTEMP5.C.




                                  - 211 - 


void  read_temps(void)
{
   FILE * infile;
   char file_name[40] = "test";

   printf("\nRead from which file? ");
   while (kbhit());     /* "eat" any char already in keyboard buffer */
   gets(file_name);

   if((infile == fopen(file_name,"rb")) == NULL)
   {
      perror("\nOpen failed! ");
      return;
   }
   fread(temps, sizeof(int), READINGS, infile);
   fclose(infile);
}


   Po skonen prce s read_temps mme kompletn fungujc verzi PLOTEMP.C.
(PLOTEMP6.C je bezchybn verze tohoto programu.)



---------------------------------------------------------------------------
Odpovdi na cvien k ladn
---------------------------------------------------------------------------


   Zde jsou vypsny chyby vyskytujc se ve funkcch PLOTEMP5.C.


min_max a avg_temps
---------------------------------------------------------------------------

   V min_max piazuje pkaz  if  do  min  nebo max hodnotu &vals[reading]
(co je adresa) msto hodnoty  vals[reading]. V avg_temps by promnn total
mla bt 0.  Pokud obsahuje na zatku 1, pite 1 do potu hodnot, z nho
se pak pot patn prmr.

   Vimnte  si, e tato funkce pijm a  pedv  ukazatele,  ne  hodnoty
funkci Table_view, ze kter je volna. Vce informac najdete v kapitole 4.


graph_view
---------------------------------------------------------------------------

   V tto funkci se vyskytuj dv pliv chyby. Jsou ve smyce for:

   for (reading = 0; reading <=READINGS; reading++)
   {
      value = temps[READINGS] * vscale;

   Natanou hodnotou je temps[READINGS] - msto promnn reading se nat
konstanta READINGS. Vsledek je ten,  e jedinou hodnotou, kter se zobraz
v grafu, je neexistujc prvek temps[8]. Druh chyba  je  ta,  e  msto <=
READINGS m bt < READINGS, aby se naetl sprvn  poet  hodnot.  Vimnte
si, jak prvn chyba maskuje druhou  -  asto nen mon zjistit jednu chybu
ani bychom odstranili jinou, protoe prvn chyba zabrauje provdn sti
programu, kter obsahuje druhou chybu.


                                  - 212 - 


save_temps
---------------------------------------------------------------------------

   Zde se problm nevyskytuje v prvnm dku smyky  for,  ale  a  v jejm
tle:

   if ((outfile = fopen(file_name, "wb")) == NULL)
      perror("\nOpen failed! ");
      return;

   Zvorky jsou pouity tak,  e  jak pkaz perror, tak return spadaj pod
rozsah platnosti if. Proto zde funkce vdy skon svoji innost -  i tehdy,
kdy je soubor oteven sprvn.

   Upozornn   kompiltoru  "neprovediteln  kd  ve  funkci   save_temps"
("unreachable code in  function  save_temps") znamen, e dky za pkazem
return se nikdy  nebudou  provdt.  Vdy  se toti naraz na pkaz return
uvnit zvorek.


read_temps
---------------------------------------------------------------------------

   Kdy budete kompilovat tuto funkci, vype kompiltor  upozornn "Mon
pouit infile ped definic" ("Possible use of infile before definition".)
Podvejte se na nsledujc dky:

   if ((infile == fopen(file_name, "rb")) == NULL)

   Kdy se oteve soubor,  infile  obdr hodnotu od fopen, tato hodnota se
testuje,  jestli  nen  NULL, co zna nespn pokus o oteven souboru.
Pro nen infile  definovna  (piazenm hodnoty) pi svm prvnm pouit?
Protoe  za  infile  nsleduje msto =  opertor  ==.  Protoe  ==  znamen
porovnn, ne piazen, do infile nen piazena dn hodnota.




























                                  - 213 - 
      479066
