












                         C++ Pruka programtora
 
































































                                   - 2 - 







                                   vod


   Pehled o cel sad dokumentace  systmu Turbo C++ vm poskytne Pruka
uivatele  {User's Guide}. V vodu a v Kapitole  2.  tto  knihy  naleznete
informace, jak pruek Turbo C++ co nejinnji vyut.

   Tato  pruka  obsahuje  materily  uren   pokroilm  programtorm.
Umte-li ji dobe programovat (a u v jazyku C i  v  njakm jinm), pak
je to pruka pro vs. Poskytne vm reference o jazyku, kov  odkazy na
knihovnu  innho  programu  a   programtorsk   informace   o  streamech,
pam؟ovch  modelech, pohybliv  dov  tece,  pekryvech,  zobrazovacch
funkcch, propojovn  s jazykem symbolickch adres a o chybovch hlench
z bاcho programu i kompiltoru jazyka C++.

   Jestlie

   1.  Jste nikdy v dnm jazyku neprogramovali.

   2.  Jste  sice programovali, avak nikoli v jazyku C  nebo  C++  a  rdi
       byste si peetli vod do jednoho i obou tchto jazyk.

   3.  Hledte informace ohledn instalace systmu Turbo C++.

   4.  Poadujete  obecn informace o integrovanm prosted systmu  Turbo
       C++ (vetn  editoru), jako i informace o pouit sprvce projekt,
       kompiltoru  s  pkazovm dkem a tak o  MAKE  a  TLINK,  dvou  z
       obslunch program dodvanch s Turbo C++.

   pette si Pruku uivatele.

   V  Pruce  uivatele  rovnا naleznete popis tvar psma, kterch se v
tchto knihch pouv.



---------------------------------------------------------------------------
Obsah tto pruky
---------------------------------------------------------------------------


   Kapitoly 1 a 4:  Lexikln  pravidla,  Pravidla  struktury frz, C++ a
Preprocesor  popisuj  jazyk  Turbo C++. Jsou zde uvedeny vechny doplky k
norm  ANSI  C.  Tyto kapitoly pinej formln definice jazyka, odkaz a
syntaxe Turbo C++ a to jak z pohledu jazyka C, tak i C++. Nkolik celkovch
informac z  kapitol  1  a  4  je  zahrnuto do nsledujcho oddlu tohoto
vodu.

   Kapitola  6:  Pouit  stream  v  C++ vm ekne, jak pouvat  knihovny
stream C++.

   Kapitola 7: Sprva pamti pojednv o pam؟ovch  modelech, programovn
se smenmi modely a o pekryvech.



                                   - 3 - 


   Kapitola 8:  Matematika  pojednv  o  matematice  s  pohyblivou dovou
tekou a BCD.

   Kapitola 9: Zobrazovac funkce je vnovna manipulaci s texty a grafikou
v Turbo C++.

   Kapitola 10: Chybov  hlen  uvd a vysvtluje vechny zvan chyby,
ostatn chyby a upozornn z bاcho programu i z  kompiltoru  a  zrove
navrhuje jejich mon een.

   Dodatek A: Implementan specifick normy  ANSI  popisuje  ty  aspekty z
normy ANSI C, je byly v ANSI definovny voln i nedefinovny  vbec. Tyto
pstupy se mn podle jednotlivch  implementac. V dodatku se dovte, jak
Turbo C++ pracuje s ohledem na jednotliv okruhy tchto otzek.

   Dodatek B: Pehled knihovny innho programu poskytuje  urit informace
o zdrojovch textech knihovny  innho  programu,  uvd a popisuje soubory
zhlav a poskytuje kov odkazy na knihovnu innho programu, uspodan
podle nzv. Chcete-li  si  napklad vyhledat funkce, tkajc se grafiky,
podvte se v tto kapitole na heslo "Grafika".



---------------------------------------------------------------------------
vod k formlnm definicm
---------------------------------------------------------------------------


   Kapitoly  1 a 4 pedstavuj formln popis jazyk C a C++, tak jak byly
implementovny v Turbo C++. Uspodali jsme je tmto zpsobem:

    o  Kapitola 1, "Lexikln pravidla", je lexikln gramatikou Turbo C++.
       Kapitola  2,  "Pravidla  struktury  frz",  poskytuje  informace  o
       struktue frz v Turbo C++.

       Lexikln pravidla se  zabvaj rznmi kategoriemi slovm podobnch
       jednotek, nazvanch lexikln prvky {token}, kter jazyk rozeznv.
       Pravidla struktury  frz  rozebr  ppustn  zpsoby,  jimi  lze
       lexikln prvky seskupovat, aby  vytvoily  vrazy,  pkazy  a jin
       jednotky uritho vznamu.

    o  Kapitola 3,  "C++", pojednv o tch otzkch, kter jsou specifick
       pro C++

    o  Kapitola  4,  "Preprocesor",  pojednv  o   preprocesoru,  vkldn
       makroinstrukc a direktiv pragma, jako i o ad jinch jednoduchch
       a pesto uitench prvcch.

   Spolen tyto kapitoly  popisuj  jazyk  Turbo  C++;  poskytuj formln
jazykov definice i syntax jazyka Turbo  C++  s  ohledem na jazyky C a C++.
Tyto kapitoly vak nenahrazuj  uebnici  jazyka.  K vyznaen syntaxe jsme
uili  upravenho  Backusova  a Naurova zpisu a podle poteby jsme pidali
strun vysvtlen a ukzky program.

   Turbo C++ pedstavuje  plnou  implementaci jazyka C++ firmy AT&T, verze
2.0.  Jde  o  objektov orientovanou nadmnoinu jazyka  C,  kterou  vyvinul
Bjarne Stroustrup od firmy AT&T Bell Laboratories. Mimo to, e  nabz adu
novch  vlastnost  a  monost,  se  jazyk  C++  vce i mn od jazyka  C
odchyluje. V rmci tchto  kapitol  na  takov odchylky upozornme. Veker



                                   - 4 - 


vlastnosti  jazyka  Turbo  C++,  odvozen  od C++, probereme  podrobnji  v
Kapitole 3.

   Jazyk Turbo C++ rovnا zcela  implementuje normu ANSI C. Implementace m
urit rozen, kter  jsou  v  textu  vyznaena.  Nastavenm pslunch
alternativ v kompiltoru lze zskat upozornn, jakmile se takov rozen
vyskytne.  Kompiltor lze rovnا nastavit tak,  aby  zachzel  s  klovmi
slovy, odpovdajcmi rozen Turbo C++, jako s normlnmi identifiktory
(viz Pruku uivatele, Kapitolu 11., "Kompiltor s pkazovm dkem").

   Existuj rovnا "pizpsobujc" rozen, poskytovan  prostednictvm
direktiv #pragma, je ANSI C navrhuje k oeten nestandardnch vlastnost,
zvislch na implementaci.


Syntax a terminologie
---------------------------------------------------------------------------

   Syntaktick  definice  pozstvaj  z  nzvu  novho  pojmu,   kter  se
definuje, za nm  nsleduje  dvojteka (:). Alternativy se obvykle uvdj
na samostatnch dcch, ale pi pouit frze "jeden (jedna) z"  lze uvst
alternativy i na jedinm dku. Napklad

   definice extern veliiny:
         definice funkce
         deklarace

   oktalov slice: jedna z
         0 1 2 3 4 5 6 7

   Prvky,  kter  nejsou  v  dan  konstrukci povinn, uvdme  v  lomench
zvorkch:

   pedpona celho sla:
         pedpona unsigned <pedpona long>

   V  rmci  tchto  kapitol uvme slova "argument"  ve  smyslu  skuten
hodnoty, pedvan pi voln  do  njak  funkce. Slovem "parametr" mnme
promnnou,  kter je definovna v zhlav funkce  a  m  obsahovat  njakou
hodnotu.






















                                   - 5 - 
































































                                   - 6 - 








                            K a p i t o l a   1

                            Lexikln pravidla


   Kapitola  poskytuje  formln  definici  lexiklnch pravidel Turbo C++.
Lexikln pravidla  pojednvaj  o  rznch  kategorich  slovm  podobnch
jednotek, zvanch lexikln prvky {token}, kter jazyk  rozeznv. Pravidla
struktury frz (probran  v  Kapitole 2.) naproti tomu rozebr ppustn
zpsoby,  jimi  lze  lexikln prvky navzjem seskupovat  a  vytvet  tak
vrazy, pkazy a jin platn jednotky.

   Lexikln prvky jazyka  Turbo  C++  jsou  odvozeny z ady operac, je s
programy vykonv kompiltor a jeho preprocesor.

   Program v jazyku Turbo C++ m na potku tvar posloupnosti znak  v kdu
ASCII, pedstavujc zdrojov text.  Ten  se  vytvo klvesami pi pouit
vhodnho  textovho editoru (jakm je teba  editor  Turbo  C++).  Zkladn
programovou  jednotkou   v  Turbo  C++  je  soubor.  Ten  obvykle  odpovd
pojmenovanmu souboru podle konvence DOS, umstnmu v pamti  RAM  nebo na
disku a opatenmu pponou .C nebo .CPP.

   Preprocesor  nejprve  program  prohldne  a  vyhled  v   nm  speciln
direktivy  preprocesoru  (viz strnku 139).  Napklad  direktiva  #include
<inc_file> pid (neboli vlo {include})  jet  ped  kompilan  fz do
programu  obsah  souboru  inc_file.   Preprocesor   tak   rozvine  vechny
makroinstrukce nalezen v programu i ve vkldacch souborech.



---------------------------------------------------------------------------
Przdn msto
---------------------------------------------------------------------------


   V lexikln fzi  kompilace  se zdrojov text syntakticky analyzuje (tj.
rozlen se) na lexikln prvky a przdn msta {whitespace}. Przdn msto
je souhrnnm nzvem pro mezery, horizontln i vertikln tabultory, znaky
novho dku a komente.  Przdn  msto slou k indikaci zatku a konce
lexiklnho prvku, ale vechna przdn  msta,  kter  jsou  pebyten, se
zru. Napklad nsledujc dv posloupnosti

   int i; float f;

   a

   int  i ;
   float   f;

   jsou lexikln ekvivalentn a  analyzuj  se  toton, m vznikne est
lexiklnch prvk:

   1.  int



                                   - 7 - 


   2.  in

   3.  ;

   4.  float

   5.  f

   6.  ;

   Znaky  z  kdu  ASCII, pedstavujc przdn msta,  lze  uvdt  uvnit
literlovch  etzc.   V  takovm  ppad  se  na  n  nevztahuje  bاn
syntaktick analza. Jinmi slovy, zstanou soust etzce:

   char nazev[] = "Borland International";

   se  analyzuje  jako  sedm lexiklnch prvk, mezi nا pat i samostatn
lexikln prvek, tvoen literlovm etzcem "Borland International".


Spojovn dk uitm \
---------------------------------------------------------------------------

   Zvltn ppad  nastane pi vskytu znaku novho dku, jemu pedchz
zptn  lomtko (\). Jak zptn lomtko, tak i znak novho dku se zru a
tm se umon,  aby  se  s  dvma  fyzickmi dky zachzelo jako s jedinm
celkem.

   "Borland \
   International"

   se analyzuje jako "Borland International" (dal informace  naleznete na
strnce 20 pod nzvem etzcov literly).


Komente
---------------------------------------------------------------------------

   Komente  jsou  seky   textu,  pedstavujcho  poznmky  o  programu.
Komente slou vlun pro poteby programtor. Ped analzou se z textu
vylou.

   Komente lze vymezit dvma zpsoby: metodou jazyka C  a  metodou jazyka
C++.  Turbo  C++  je  podporuje  oba spolu s dalm nepovinnm  rozenm,
umoujcm  vnoovn  koment  do sebe. V programech v jazyku C i v C++
lze vechny druhy koment vzjemn mchat a srovnvat.


Komente v jazyku C

   Komentem  v  jazyku  C je libovoln posloupnost  znak  umstnch  po
dvojici  symbol  /*.  Takov koment kon prvnm  vskytem  dvojice  */,
nsledujc za poten dvojic  */.  Po  rozvinut makroinstrukce se cel
takov posloupnost,  vetn  ty  symbol  oddlova  komente,  nahrad
jedinou mezerou.  Pamatujte si, e nkter implementace jazyka C odstrauj
komente bez jejich nhrady mezerou.

   Jazyk Turbo C++ nepodporuje nepenosnou strategii zabudovn lexiklnch
prvk {token pasting}, uvajc /**/. Zabudovn lexiklnch prvk v Turbo
C++ umouje dvojice ##, uren v ANSI:


                                   - 8 - 


   Popis zabudovn lexiklnch prvk naleznete na strnce 146.

   #define VAR(i,j)                 (i/**/j)          /* nebude fungovat */
   #define VAR(i,j)  (i##j)                  /* v Turbo C++ je v podku */
   #define VAR(i,j)  (i ## j)                        /* rovnا v podku */

   V Turbo C++ se

   int /* deklarace */ i /* ta */

   analyzuje jako

   int i ;

   a vzniknou ti lexikln prvky: int i ;


Vnoen komente

   Norma  ANSI  C  vnoen  komente  nepipout.  Pokus   o  komentovn
pedchozho dku vrazem

   /* int /* deklarace */ i /* ta */; */

   bude nespn, jeliko obor prvnho /* kon u prvnho */. Tm vznikne

   i ; */

   m se generuje syntaktick chyba.

   Turbo C++ implicitn vnoen komente  nepipout,  je  to  vak mono
pedefinovat   alternativami   kompiltoru.  Vnoen   komente   umonte
alternativou -C (pro kompiltor s pkazovm dkem),  nebo prostednictvm
menu O|C|Source Options v integrovanm prosted.


Komente v jazyku C++

   K vytvoen koment ve zdrojovm textu v jazyku C  lze  rovnا  pout
//. Jde o zleitost specifickou pro Turbo C++.

   Jazyk C++ pipout jednodkov komente  s  vyuitm  dvou spaench
lomtek (//). Takov koment sm zanat v libovolnm mst a pokrauje a
po nsledujc znak novho dku:

   class X { // zde je koment
   ... };


Oddlovae koment a przdn msto

   Vzcn se me stt, e  prv prdn msto ped /* a //, jako i po */,
by syntakticky nepovinn, vs  me  uchrnit  ped problmy s penosnost
programu. Tak napklad tento zdrojov text v C++

   int i = j//* dlen slem k*/k;
   +m;

   se analyzuje jako int i = j +m; a nikoli jako



                                   - 9 - 


   int i = j/k;
   +m;

   jak bychom podle konvence jazyka C ekali. Uitm itelnj formy

   int i = j/ /* dlen slem k*/ k;
   +m

   se tomuto problmu vyhnete.



---------------------------------------------------------------------------
Lexikln prvky
---------------------------------------------------------------------------


   Jazyk Turbo C++ rozeznv est td lexiklnch prvk. Formln definice
lexiklnho prvku vypad nsledovn:

   lexikln prvek:
      klov slovo
      identifiktor
      konstanta
      etzcov literl
      opertor
      interpunkn znak

   Interpunknm znakm se k tak oddlovae.

   Pi syntaktick analze zdrojovho textu  se  lexikln  prvky zskvaj
tak, e z posloupnosti znak se vybr vdy nejdel mon lexikln prvek.
Napklad  slovo  external  se   syntakticky   analyzuje   jako  samostatn
identifiktor  a  nikoli  jako  klov  slovo  extern,  za nm  nsleduje
identifiktor al.


Klov slova
---------------------------------------------------------------------------

   Klov slova {keyword} jsou slova  vyhraen pro zvltn ely a nesm
se jich  pouvat pro nzvy normlnch identifiktor. Klov slova jazyka
Turbo  C++  uvdme  v  nsledujcch  dvou  tabulkch.  Uitm  alternativ
kompiltoru  s pkazovm dkem (nebo alternativ integrovanho  prosted)
je mono zvolit  pouze  klov  slova  z normy ANSI, klov slova systmu
UNIX atd. Informace o tchto alternativch naleznete v Pruce uivatele v
Kapitole  8.,  "Zklady  integrovanho  prosted  IDE" a v  Kapitole  11.,
"Kompiltor s pkazovm dkem".














                                  - 10 - 


             Tab. 1.1: Vechna klov slova jazyka Turbo C++

---------------------------------------------------------------------------
asm                 _ds                 interrupt           short
auto                else                _loadds             signed
break               enum                long                sizeof
case                _es                 _near               _ss
catch               _export             near                static
_cdecl              extern              new                 struct
cdecl               _far                operator            switch
char                far                 _pascal             template
class               float               pascal              this
const               for                 private             typedef
continue            friend              protected           union
_cs                 goto                public              unsigned
default             huge                register            virtual
delete              if                  return              void
do                  inline              _saveregs           volatile
double              int                 _seg                while
---------------------------------------------------------------------------


             Tab. 1.2: Rozen jazyka Turbo C++ vi ANSI C

---------------------------------------------------------------------------
_cdecl              _es                 interrupt           pascal
cdecl               _export             _loadds             _saveregs
_cs                 _far                _near               _seg
_ds                 far                 near                _ss
                    huge                _pascal
---------------------------------------------------------------------------


                Tab. 1.3: Klov slova specifick pro C++

---------------------------------------------------------------------------
catch               friend              operator            public
class               inline              private             template
delete              new                 protected           this
                                                            virtual
---------------------------------------------------------------------------


           Tab. 1.4: Registrov pseudopromnn jazyka Turbo C++

---------------------------------------------------------------------------
_AH                 _BP                 _CX                 _DX
_AL                 _BX                 _DH                 _ES
_AX                 _CH                 _DI                 _FLAGS
_BH                 _CL                 _DL                 _SI
_BL                 _CS                 _DS                 _SP
                                                            _SS
---------------------------------------------------------------------------

Identifiktory
---------------------------------------------------------------------------

   Formln definice identifiktoru vypad nsledovn:

   identifiktor:


                                  - 11 - 


      ne-slice
      identifiktor ne-slice
      identifiktor slice

   ne-slice: jedno z
      a b c d e f g h i j k l m n o p q r s t u v w x y z_
      A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

   slice: jedna z
      0 1 2 3 4 5 6 7 8 9


Omezen pro nzvy a dlky

   Identifiktory jsou libovoln nzvy jakkoli dlky  pro  tdy, objekty,
funkce, promnn, uivatelem definovan typy  dat  atd.  Identifiktory sm
obsahovat psmena A a Z a a a z, znak podtren (_) a  slovky  0  a 9.
Existuj zde pouze dv omezen:

   1.  Prvnm znakem mus bt psmeno nebo podtren.

   2.  Jazyk Turbo  C++ rozeznv implicitn jako platnch jenom prvnch 32
       znak.  Poet  platnch  znak  lze  alternativami  v  menu  nebo  v
       pkazovm  dku  snit,  nikoli   vak   zvit.   Pouijte  tedy
       alternativy -in kompiltoru TCC (kde 1 <= n <= 32)  nebo alternativy
       z menu O|C|S|Identifier Length v integrovanm prosted.

   Pamatujte si, e identifiktory v programech v jazyku C++ jsou  platn v
jakkoli dlce.


Rozliovn velkch a malch psmen v identifiktorech

   V identifiktorech jazyka Turbo C++ se rozliuj mal  a  velk psmena,
take Sum, sum a suM jsou rozdlnmi identifiktory.

   Globln identifiktory, pevzat  z  jinch  modul,  se  d stejnmi
pravidly pro pojmenovn i  platnost  znak  jako  identifiktory normln.
Jazyk Turbo C++ vak nabz  alternativu,  umoujc  rozlien  velkch a
malch psmen potlait. Tm se  zsk kompatibilita pro spojovn s jazyky,
kter velk a mal psmena  nerozliuj.  Oznaenm  rmeku  pro spojovn
{Link box} Options|Linker|Case-Sensitive v dialogovm rmeku Linker, resp.
uitm pepnae /c pkazovho dku s programem TLINK  lze  zajistit, aby
globln identifiktory  velk  a  mal  psmena  nerozliovaly.  V takovm
reimu se budou globln identifiktory Sum a sum  povaovat  za identick,
co me bhem spojovn vystit upozornnm "Duplicate symbol" {duplicitn
symbol}.

   Vjimkou z tohoto pravidla jsou identifiktory typu pascal,  je  se pro
ely spojovn vdy pevedou na velk psmena.


Jednoznanost a obor platnosti

   I kdy jsou nzvy identifiktor voliteln (v rmci uvedench pravidel),
dojde k chyb, pouijete-li stejnho  nzvu pro vce identifiktor v rmci
stejnho oboru platnosti  {scope},  je  sdlej  tent  prostor platnosti
nzvu  {name  space}.  Duplicitn  nzvy  jsou  vdy  ppustn  v  rznch
prostorech platnosti nzvu bez  ohledu  na  obor  platnosti identifiktor.



                                  - 12 - 


Tato pravidla probereme v diskusi  o oboru platnosti, zanajc na strnce
32.


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

   Konstantami  nazvme lexikln prvky, pedstavujc pevn seln  nebo
znakov hodnoty. Jazyk Turbo C++ podporuje tyi tdy konstant: pohyblivou
dovou teku {floating point}, cel slo {integer}, vet {enumeration} a
znak {character}.

   Datov typ konstanty kompiltor odvod  z  takovch  informac,  jako je
seln  hodnota  a  formt, uit ve zdrojovm  textu.  Formln  definici
konstanty ukazuje Tabulka 1.5.















































                                  - 13 - 


                      Tab. 1.5: Formln definice konstant

--------------------------------------------------------------------------------
konstanta:                                   0 X hexadecimln slice
     konstanta-floating                      hexad.-konst. hexad.-slice
     konstanta-integer
     konstanta-enumeration              nenulov-slice: jedna z
     konstanta-character                     1 2 3 4 5 6 7 8 9

konstanta-floating:                     oktalov-slice: jedna z
     zlomkov-konstanta <exponentov-        0 1 2 3 4 5 6 7
-st><ppona-floating>
     posl.-slic exponentov-st      hexadecimln-slice: jedna z
<ppona-floating>                           0 1 2 3 4 5 6 7 8 9
                                             a b c d e f
     zlomkov-konstanta:                     A B C D E F
     <posl. slic> . posl.-slic
     posl.-slic .                     ppona-integer:
                                             ppona-unsigned <ppona-long>
exponentov-st:                            ppona-long <ppona-unsigned>
     e <znamnko> posl.-slic
     E <znamnko> posl.-slic          ppona-unsigned: jedno z
                                             u U
znamnko: jeden z
     + -                                ppona-long: jedno z
                                             l L
posloupnost slic:
     slice                            konstanta-enumeration:
     posl.-slic slice                    identifiktor

pedpona-floating: jedno z              konstanta-character:
     f l F L                                 posl.-znak-c

konstanta-integer:                      posloupnost-znak-c:
     dekad.-konstanta <pp.-integer>        znak-c
     oktal.-konstanta <pp.-integer>        posl.-znak-c znak-c
     hexad.-konstanta <pp.-integer>
                                        znak-c:
dekadick-konstanta:                         Libovoln znak z prvotn mnoiny
     nenulov-slice                        znak krom zmnov posloupnosti
     dekad.-konstanta slice                apostrof ('), zptn lomtko (\)
                                             nebo znak novho dku
oktalov konstanta:
     0                                  zmnov-posloupnost: jedna z
     oktal.-konstanta okt. slice           \"   \'   \?   \\
                                             \a   \b   \f   \n
hexadecimln-konstanta:                     \o   \oo  \ooo \r
     0 x hexad.-slice                      \t   \v   \Xh... \xh...
--------------------------------------------------------------------------------

Celoseln konstanty

     Celoseln {integer} konstanty mohou bt  dekadick  (o  zkladu 10),
oktalov (o zkladu 8) nebo  hexadecimln (o zkladu 16). Nen-li ptomna
dn ppona pro pedefinovn, datov typ celoseln konstanty se odvod
z jej hodnoty, jak ukazujeme v Tabulce 1.6. Nezapomete,  e  pravidla  se
pro dekadick a nedekadick konstanty li.


     Dekadick konstanty


                                  - 14 - 


     Dekadick  konstanty   jsou   ppustn   v   rozmez   hodnot   0  a
4 294 967 295. Konstanty,  kter  by  tyto  meze  peshly,  zpsob chybu.
Dekadick konstanty  nesm  zanat  nulou.  Celoseln  konstanta,  kter
zan nulou, se interpretuje jako konstanta oktalov. Proto

     int i = 10;                   /* dekadicky 10 */
     int i = 010;   /* dekadicky 8 */
     int i = 0;     /* dekadick 0 = oktalov 0 */


     Oktalov konstanty

     Veker konstanty zanajc nulou se povauj za  oktalov. Obsahuje-
li  oktalov  konstanta  neppustn slice 8  nebo  9,  hls  se  chyba.
Oktalov konstanty pesahujc 037777777777 zpsob chybu.


     Hexadecimln konstanty

     Vechny  konstanty   zanajc   0x   (nebo   0X)   se   povauj  za
hexadecimln.  Hexadecimln  konstanty  pesahujc  0xFFFFFFFF   zpsob
chybu.


     Ppony long a unsigned

     Pipojenm ppony L (nebo  l)  k  libovoln  konstant se nad jej
vnitn  zobrazen  typem  long {dlouh}. Analogicky se pponou U (nebo u)
nad, e konstanta bude typu  unsigned  {bez  znamnka}.  Bude-li hodnota
sla samotnho vt ne 65535, bez ohledu na pouit seln  zklad bude
konstanta  typu  unsigned  long.  Obou  ppon  L  i U lze pout na  tut
konstantu v libovolnm poad nebo velikosti: ul, lu, UL atd.






























                                  - 15 - 


      Tab. 1.6: Celoseln konstanty v Turbo C++ bez ppon L nebo U

---------------------------------------------------------------------------
     Dekadick konstanty

                 0 a 32 767                 int
            32 768 a 2 147 483 647          long
     2 147 483 648 a 4 294 967 295          unsigned long

                    > 4294967295             Generuje chybu

     Oktalov konstanty

                00 a 077777                 int
           0100000 a 0177777                unsigned int
          02000000 a 017777777777           long
      020000000000 a 037777777777           unsigned longs

                    > 037777777777           Generuje chybu

     Hexadecimln konstanty

            0x0000 a 0x7FFF                 int
            0x8000 a 0xFFFF                 unsigned int
           0x10000 a 0x7FFFFFFF             long
         0x8000000 a 0xFFFFFFFF             unsigned long

                    > 0xFFFFFFFF             Generuje chybu
---------------------------------------------------------------------------

     Datovm typem konstanty za neptomnosti  jakkoli  ppony  (U,  u, L
nebo l) bude prvn z nsledujcch typ, do nj se vmst jej hodnota:

---------------------------------------------------------------------------
     dekadick      int, long int, unsigned long int

     oktalov       int, unsigned int, long int, unsigned long int

     hexadecimln  int, unsigned int, long int, unsigned long int
---------------------------------------------------------------------------

     M-li konstanta pponu  U  nebo  u,  jejm datovm typem bude prvn z
typ unsigned int, unsigned long int, do nj se vmst jej hodnota.

     M-li konstanta pponu  L  nebo  l,  jejm datovm typem bude prvn z
typ unsigned int, unsigned long int, do nj se vmst jej hodnota.

     M-li konstanta ob ppony u i l (ul,  lu,  Ul,  lU,  uL, Lu, LU nebo
UL), jejm datovm typem bude unsigned long int.

     Vnitn zobrazen  celoselnch  konstant  o  vech  tech  zkladech
shrnuje Tabulka 1.6.  Stanoven  datov typy pedpokldaj, e se nepouilo
dn pedefinujc ppony L nebo U.


Znakov konstanty

     Znakovou konstantou {character}  je  jeden  i  vce  znak uzavench
apostrofy, jako teba 'A', '=', '\n'.  V  jazyku C jsou konstanty o jedinm
znaku datovho typu int; intern je pedstavuje 16 bit, piem vy byte


                                  - 16 - 


je  nulov  nebo  znamnkov  rozen.  V  jazyku  C++ jsou  jednoznakov
konstanty typu char. Vceznakov konstanty maj v jazyku C i C++ datov typ
int.


     Zmnov posloupnosti
     K zaveden zmnov posloupnosti se pouv znaku zptnho lomtka (\).
Zmnovou posloupnost  se  umon  vizuln  podn  uritch  negrafickch
znak. Tak napklad samotn znak novho dku se vyjaduje konstantou \n.

     Zptnho lomtka s oktalovmi  nebo  hexadecimlnmi  sly lze ut k
vyjden symbol z kdu ASCII nebo dcho kdu pslunho dan hodnot;
napklad  '\03'  zna  Ctrl-C  nebo  '\x3F'  zna  otaznk.  Ve  zmnov
posloupnosti  lze  pout  libovolnho  etzce  a  t   oktalovch  nebo
libovolnho potu hexadecimlnch sel, je-li  ovem  pslun  hodnota v
oboru ppustnm pro datov typ char (v ppad Turbo C++ je to 0 a 0xff).
Vt sla  zpsob kompilan chybu "Numeric constant too large" {seln
konstanta  je pli velk}. Napklad oktalov slo  \777  je  vt  ne
nejvy  ppustn  hodnota  \377 a zpsob tm chybu. Prvn neoktalov i
nehexadecimln  slo,  kter  se  v  oktalov  i  hexadecimln  zmnov
posloupnosti vyskytne, zna konec takov posloupnosti.

     Jazyk Turbo C pvodn pipoutl v hexadecimln  zmnov posloupnosti
jenom ti slice.  Nov pravidla ANSI C, pejat do Turbo C verze 2.0 a do
Turbo C++, proto mohou zpsobit  pote v ppad starho zdrojovho textu,
kter pedpokld, e se  pevdj  pouze  prvn  ti znaky. Napklad pi
pouit Turbo C  1.x  k  definovn  etzce  se zvonkem (ASCII 7), za nm
nsleduj seln znaky, by programtor mohl zapsat:

     printf("\x0072.1A Simple Operating System");

     Mn se tm \x007  a  "2.1A Simple Operating System". Systm Turbo C++
(a Turbo C verze 2.0) to vak zkompiluje jako hexadecimln slo  \x0072 a
literlov etzec "1.A Simple Operating System".

     Abyste se takovm potm vyhnuli, pepite svj zdrojov text takto:

     printf("\x007" "2.1A Simple Operating System");

     K   nejednoznanosti  me  dojt,  jestlie  za  oktalovou   zmnovou
posloupnost  nsleduje neoktalov slice. Tak napklad  protoe  8  a  9
nejsou   ppustnmi   oktalovmi   slicemi,   konstanta   \258   by   se
interpretovala jako dvouznakov konstanta tvoen znaky \25 a 8.

     Dostupn zmnov posloupnosti ukazuje nsledujc tabulka.

















                                  - 17 - 


                 Tab. 1.7: Zmnov posloupnosti Turbo C++

---------------------------------------------------------------------------
     Posloupnost    Hodnota   Znak      eho se doshne
---------------------------------------------------------------------------
     \a             0x07      BEL       Slyiteln zvonek
     \b             0x08      BS        Zptn vymazn
     \f             0x0C      FF        Nov strnka
     \n             0x0A      LF        Nov dek
     \r             0x0D      CR        Nvrat vozku
     \t             0x09      HT        Tabultor (horizontln)
     \v             0x0B      VT        Vertikln tabultor
     \\             0x5c      \         Zptn lomtko
     \'             0x27      '         Jednoduch uvozovka (apostrof)
     \"             0x22      "         Dvojit uvozovka
     \?             0x3F      ?         Otaznk
     \O                       libovol.  O = etzec a 3 oktalovch slic
     \xH                      libovol.  H = etzec hexadecimlnch slic
     \XH                      libovol.  H = etzec hexadecimlnch slic
---------------------------------------------------------------------------

     K  vyjden skutenho zptnho lomtka podle  kdu  ASCII,  jak  se
pouv v cestch k souborm v DOS, je nutn ut \\.


     Speciln dvouznakov konstanty v Turbo C++

     Turbo  C++  podporuje rovnا dvouznakov  konstanty  (napklad  'An',
'\n\t' a '\007\007'). Tyto konstanty se zobrazuj jako 16-ti bitov hodnoty
int  s prvnm znakem umstnm v nim bytu a druhm znakem v bytu vym.
Tyto znaky nejsou penosn do jinch kompiltor jazyka C.


     Znak se znamnkem a bez znamnka

     V jazyku C se jednoznakov konstanty, jako teba 'A', '\t' nebo '\007'
rovnا zobrazuj jako 16-ti bitov hodnoty int. V takovm ppad  se ni
byte znamnkov roz {sign  extended}  do  bytu  vyho. Znamen to, e
je-li hodnota  vt  ne  127  (o zkladu 10), nastav se vy byte na -1
(=0xFF).  Toto  lze  zablokovat  deklarovnm,  e typ char  je  implicitn
unsigned {bez znamnka} (pouijte k  tomu  alternativy  -K  kompiltoru TCC
nebo  zvolte  v  menu Options |  Compiler  |  Code  Generation  alternativu
Unsigned Characters). Tm se nad, e vy byte bude nulovm  bez ohledu
na hodnotu bytu niho.


     irok znakov konstanty (jenom v jazyku C)

     Znakov konstanta, kter pedchz L, je  irokou  znakovou konstantou
datovho typu wchar_t (vestavn typ definovan v stddef.h). Napklad

     x = L 'AB';


Konstanty s pohyblivou dovou tekou

     Konstanta s pohyblivou dovou tekou m est st:

    o  dekadick cel slo



                                  - 18 - 


    o  desetinnou teku

    o  desetinn zlomek

    o  e nebo E a celoseln (nepovinn) exponent se znamnkem

    o  typovou pponu: f nebo F, resp. l nebo L (nepovinn)

     Dekadick cel slo  nebo  desetinn zlomek lze vynechat (nikoli vak
oboj).  Lze  vynechat  bu  desetinnou  teku  nebo  psmeno  e  (i E)  a
celoseln  exponent  se  znamnkem  (nikoli  vak  oboj).  Tato pravidla
pipoutj bاn nebo semilogaritmick (exponenciln) tvary sel.

     Zporn konstanty s pohyblivou  dovou  tekou  se povauj za kladn
konstanty, jim pedchz unrn opertor minus (-).

     Pklady:

---------------------------------------------------------------------------
     Konstanta           Hodnota
---------------------------------------------------------------------------
                                   6
     23.45e6             23.45 x 10
     .0                  0
     0.                  0
                                 0
     1.                  1.0 x 10  = 1.0
     -1.23               -1.23
                                 -5
     2e-5                2.0 x 10
                                 10
     3E+10               3.0 x 10
                                  34
     .09E34              0.09 x 10
---------------------------------------------------------------------------


     Konstanty s pohyblivou dovou tekou - datov typy

     Chyb-li jakkoli ppona, jsou konstanty s pohyblivou  dovou tekou
typu double {dvojit pesnost}. Pidte-li vak ke konstant pponu f nebo
F,  pinutte  ji,  aby byla typu  float.  Analogicky  pponou  l  nebo  L
nadte,  aby  konstanta  byla datovho typu long  double.  V  nsledujc
tabulce uvdme pro float, double a long double jejich ppustn rozsahy.


  Tab. 1.8: Velikosti a rozsahy konstant s pohyblivou tekou v Turbo C++

---------------------------------------------------------------------------
     Typ            Velikost (bity)          Rozsah
---------------------------------------------------------------------------
                                                     -38            38
     float               32                  3.4 x 10    a 3.4 x 10
                                                     -308            308
     double              64                  1.7 x 10     a 1.7 x 10
                                                     -4932            4932
     long double         80                  3.4 x 10      a 1.1 x 10
---------------------------------------------------------------------------




                                  - 19 - 


     Vtov konstanty
     Vtov  {enumeration}  konstanty  jsou  identifiktory  definovan  v
deklaracch  typu  enum.  Takov  identifiktory  se   obvykle   pro  vt
srozumitelnost  vol  mnemotechnicky.  Vtov konstanty jsou celoselnmi
datovmi  typy.  Lze  jich ut v  jakmkoli  vrazu,  kde  jsou  ppustn
celoseln konstanty. Pouit identifiktory mus  bt  v  oboru deklarace
enum jednoznan.

     Podrobn pehled deklarac enum naleznete na strnce 77.

     Hodnoty, je vtov konstanty shromauj, zvis na  formtu vtov
deklarace a na ptomnosti volitelnch inicializtor. V ppad

     enum team ( giants, cubs, dodgers );

     pedstavuj giants, cubs a  dodgers  vtov  konstanty typu team, je
lze dosazovat do jakkoli promnn typu team i do libovoln  jin promnn
celoselnho  typu.  Hodnoty shromdn vtovmi  konstantami  jsou  pi
absenci explicitnch inicializtor tyto:

     giants = 0, cubs = 1, dodgers = 2

     V nsledujcm pklad

     enum team (giants, cubs=3, dodgers = giants + 1 );

     jsou konstanty nastaveny takto:

     giants = 0, cubs = 3, dodgers = 1

     Hodnoty konstant nemus bt jednoznan:

     enum team ( giants, cubs = 1, dodgers = cubs - 1 );

     Pipout se i zporn inicializtory.


etzcov literly

     etzcov literly, znm t pod  nzvem  etzcov  konstanty, tvo
zvltn  kategorii  konstant,  jich  se  pouv k manipulaci  s  pevnmi
posloupnostmi znak. etzcov literly jsou  datovho typu array of char a
pam؟ov tdy  static.  Zapisuj  se  jako  posloupnost  libovolnho potu
znak, obklopen dvojitmi uvozovkami:

     "Toto je nazorny retezec!"

     Przdn (null) etzec se zapisuje jako "".

     Znaky  mezi  dvojitmi  uvozovkami  sm obsahovat zmnov posloupnosti
(viz strnku 17). Napklad tento zdrojov text

     "\t\t\"Jmeno\"\\\tAdresa\n\n"

     zpsob vpis:

     "Jmeno"\                 Adresa





                                  - 20 - 


     Ped  "Jmeno"  jsou  uvedeny  dva  tabultory; ped Adresa  je  jedin
tabultor. Za dkem nsleduj dva  nov dky. Znak \" pedstavuje vnitn
dvojit uvozovky.

     Literlov etzec se  vnitn  ulo jako dan posloupnost znak plus
koncov przdn znak ('\0'). Przdn etzec se ulo jako pouh znak '\0'.

     Sousedn etzcov literly, oddlen pouze przdnm mstem,  se bhem
syntaktick analzy slou. Uveme pklad:

     #include <stdio.h>

     main()
     {
               *
          char  p;

          p =  "Jde o ukazku, jak Turbo C++"
               " automaticky\nza vas slouci"
               " velmi dlouhe retezce,\ncoz vede"
               " k lepe vyhlizejicim programum.";
          printf(p);
     }

     Vstup z takovho programu vypad nsledovn:

     Jde o ukazku, jak Turbo C++ automaticky
     za vas slouci velmi dlouhe retezce,
     coz vede k lepe vyhlizejicim programum.

     Chcete-li rozit etzcovou konstantu za hranice dku,  mete jako
znaku pro pokraovn ut tak zptnho lomtka (\):

     puts("Toto je ve skutecnosti \
     jednoradkovy retezec");


Vnitn zobrazen konstant

     Norma ANSI C potvrzuje, e velikosti a seln rozsahy zkladnch typ
dat (a jejich  rznch  permutac)  zvis  na  implementaci  a  obvykle se
odvozuj z  architektury hostitelskho potae. Protoe jazyk Turbo C++ je
uren  pedevm  pro  rodinu  pota  IBM PC (a s nimi  kompatibilnch),
uruje vbr zobrazen rznch typ dat  architektura  mikroprocesor Intel
8088 a 80x86.  Velikosti  a  vsledn  rozsahy  typ dat v jazyku Turbo C++
uvdme v nsledujc tabulce. Dal  informace  o  tchto  datovch typech
naleznete na strnce 46. Vnitn zobrazen tchto typ ukazuje obrzek 1.1.















                                  - 21 - 


              Tab. 1.9: Typy dat, jejich velikosti a rozsahy

---------------------------------------------------------------------------
               Velikost
  Typ          (bity)     Rozsah                  Pkladn pouit
--------------------------------------------------------------------------------
  unsigned char   8    0 a 255                   Mal sla a cel mnoina
                                                  znak PC

  char            8    -128 a 127                Velmi mal sla a znaku z
                                                  kdu ASCII

  enum           16    -32768 a 32767            Uspodan mnoiny hodnot

  unsigned int   16    0 a 65535                 Velk sla a cykly

  short int      16    -32768 a 32767            Natn, mal sla, ovldn
                                                  cykl

  int            16    -32768 a 32767            Natn, mal sla, ovldn
                                                  cykl

  unsigned long  32    0 a 4294967295            Astronomick vzdlenosti

  long           32    -2147483648 a 2147483647  Velk sla, populace
                             -38          38
  float          32    3.4x10    a 3.4x10        Semilogaritmick tvar
                                                  (pesnost na 7 mst)
                             -308          308
  double         64    1.7x10     a 1.7x10       Semilogaritmick tvar
                                                  (pesnost na 15 mst)
                             -4932          4932
  long double    80    3.4x10      a 1.1x10      Finann tvar (pesnost na 19
                                                  mst)

  near pointer   16    Nelze aplikovat            Manipulace s adresami pamti

  far pointer    32    Nelze aplikovat            Manipulace s adresami vn
                                                  aktulnho segmentu

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





















                                  - 22 - 


              Ŀ
         int  s   mantisa    
              
              15               0
              Ŀ
    long int  s         mantisa         
              
              31                          0
                         i 1
              Ŀ
       float  sexponent    znamnko    
              
              31          22              0

                         i 1
              Ŀ
      double  sexponent            znamnko            
              
              63          51                              0

                             i
              Ŀ
 long double  s exponent 1              znamnko                
              
              79          64 63                                     0

              s = znamnkov bit (0=pozitivn,1=negativn)
              i = pozice implicit.binrnho bodu
              1 = bit znamnka celho sla
                               uloen v long double
                               implicitn (vdy 1) v float, double

              Exponent (normalizovan hodnoty):
                       float:         127 (7FH)
                       double:        1023 (3FFH)
                       long double:   16,383 (3FFFH)

                 Obr. 1.1: Vnitn zobrazen datovch typ


Konstantn vrazy

     Konstantnm vrazem  rozumme  vraz,  kter  se  vdy  vyhodnot jako
konstanta  (a  mus  se  vyhodnotit   na  konstantu,  kter  je  v  rozsahu
zobrazitelnch hodnot svho typu). Konstantn vrazy  se  vyhodnocuj pln
stejn jako normln vrazy. Konstantnho vrazu lze pout  vude,  kde se
pipout njak konstanta. Syntax konstantnho vrazu je

     konstantn-vraz:
          Podmnn-vraz

     Konstantn  vraz  nesm obsahovat dn  z  nsledujcch  opertor,
ledae by tyto opertory byly obsaeny uvnit operandu opertoru sizeof:

    o  dosazen

    o  dekrementace

    o  voln funkce



                                  - 24 - 


    o  rka



---------------------------------------------------------------------------
Popisy opertor
---------------------------------------------------------------------------


     Opertory jsou lexikln prvky, kter  pi aplikaci na promnn a jin
objekty ve vrazech spust urit vpoty. Jazyk Turbo C++ je  na opertory
obzvlt bohat. Nabz nejen bاn aritmetick a logick opertory, nbr
i mnoh  uren  k  manipulacm  na  bitov  rovni, pro pstup ke slokm
struktur a union,  jako  i  k  operacm s ukazateli (odkazovn a nepm
odkazovn).

     Rozen jazyka C++ nabzej dal  opertory  pro  pstup  do len
uritch td a jejich objekt, jako i mechanismus pro pepsn opertor.
Aplikuje-li se pepsn {overloading}  na  objekty  urit  tdy, umouje
znovu definovat innost kadho standardnho opertoru. V tomto oddlu svou
diskusi omezme na standardn opertory  Turbo C++. O pepsn pojednme od
strnky 130.

     Po  definicch  standardnch opertor prodiskutujeme  datov  typy  a
deklarace a vysvtlme, jak se jimi innost kadho opertoru ovlivn. Dle
je mono pistoupit k syntaxi pro vytven vraz z opertor, interpunkce
a objekt.

     Opertory se v jazyku Turbo C++ definuj nsledovn:
     opertor: jeden z
          []        ()        .         ->        ++        --
                    *
          &                   +         -         ~         !
          sizeof    /         %         <<        >>        <
          >         <=        >=        ==        !=        ^
                                                            *
          |         &&        ||        ?:        =          =
          /=        %=        +=        -=        <<=       >>=
          &=        ^=        |=        ,         #         ##

     Opertory # a ## se pouvaj jenom v preprocesoru (viz stranu 139).

     Nsledujc opertory jsou pak specifick pro C++:
                     *          *
          ::        .         ->

     S vjimkou  [],  ()  a  ?,  jimi  se zvorkuj vrazy, se vceznakov
opertor povauje za samostatn  lexikln  prvek.  Jeden a t opertorov
lexikln prvek lze interpretovat  vce  zpsoby  v zvislosti na kontextu.
Napklad
       *
     A   B                                   Nsoben
     *
      ptr                                    Nepm odkaz

     A & B                                   Bitov AND
     &A                                      Adresov operace
     int &                                   Modifiktor odkazu (C++)

     nvt:                                Nvt pkazu


                                  - 25 - 


     a ? x : y                               Podmnn pkaz

     void func(int n);                       Deklarace funkce
              *
     a = (b+c) d;                            Uzvorkovan vraz

     a, b, c;                                Vraz s rkami
     func(a, b, c);                          Voln funkce

     a =-b;                                  Bitov negace (doplnk k jednice)
     -func() {delete a;}                     Destruktor (C++)


Unrn opertory
--------------------------------------------------------------------------------

          &            Adresov opertor
          *
                       Opertor nepmho adresovn
          +            Unrn plus
          -            Unrn minus
          ~            Bitov doplnk (doplnk k jednice)
          !            Logick negace
          ++           Pedpona: pedbاn zven; Ppona: dodaten zven
          --           Pedpona: pedbاn snen; Ppona: dodaten snen


Binrn opertory
--------------------------------------------------------------------------------

Aditivn opertory

          +            Binrn plus (stn)
          -            Binrn minus (odtn)


Multiplikativn opertory

          *            Nsoben
          /            Dlen
          %            Zbytek


Opertory posunu

          <<           Posun vlevo
          >>           Posun vpravo


Bitov opertory

          &            Bitov AND
          ^            Bitov XOR (vyluovac OR)
          |            Bitov inkluzivn OR


Logick opertory

          &&           Logick AND
          ||           Logick OR


                                  - 26 - 


Opertory dosazen

          =            Dosazen
          *
           =           Dosazen souinu
          /=           Dosazen podlu
          %=           Dosazen zbytku (modulus)
          +=           Dosazen soutu
          -=           Dosazen rozdlu
          <<=          Dosazen posunu vlevo
          >>=          Dosazen posunu vpravo
          &=           Dosazen bitovho AND
          ^=           Dosazen bitovho XOR
          |=           Dosazen bitovho OR


Relan opertory

          <            Men ne
          >            Vt ne
          <=           Men nebo rovno
          >=           Vt nebo rovno


Opertory rovnosti

          ==           Rovn se
          !=           Nerovn se


Opertory pro vbr sloky

          .            Pm selektor sloky
          ->           Nepm selektor sloky


Opertory pro leny td

          ::           Pstup/rozlien oboru
           *
          .            Nepm odkaz ukazatelem na len tdy
            *
          ->           Nepm odkaz ukazatelem na len tdy


Podmnn opertor

          a ? x : y    "jestlie a, potom x; jinak y"


Opertor rka

          ,            Vyhodnocen; nap. a, b, c; zleva doprava

     Funkce opertor, stejn jako jejich  syntaxi,  priority  i sdruovn
probereme ponaje strnkou 79.






                                  - 27 - 


Interpunkn znaky
---------------------------------------------------------------------------

     Interpunkn znaky (nazvan  t  separtory) se v Turbo C++ definuj
takto:

     interpunkn-znak: jeden z
          [ ] ( ) { } , ; : ... * = #


Hranat zvorky

     []  (poten   a   koncov   hranat   zvorka)   vyznauj   indexy
jednorozmrnch a vcerozmrnch pol:

     char ch, str[] = "Stan";
     int mat[3][4];                                      /* matice 3 x 4 */
     ch = str[3];                                            /* 4. prvek */
     ...


Kulat zvorky

     () (poten a  koncov  kulat  zvorka)  seskupuj  vrazy, izoluj
podmnn vrazy a oznauj voln funkc a parametry funkc:
           *
     d = c   (a + b);                 /* pedefinovn normln priority */

     if (d == z) ++x;                     /* bاn pro podmnn pkazy */

     func();                              /* voln funkce bez argument */
          *
     int ( fptr)();                     /* deklarace ukazatele na funkci */
     fptr = func;            /* neptomnost () zna ukazatel na funkci */
     void func2(int n);                  /* deklarace funkce s argumenty */

     Kulatch  zvorek  doporuujeme  pouvat v definicch makroinstrukc,
aby se bhem rozvoje pedelo potencilnm problmm s prioritou:
                             *     *
     #define KRYCHLE(x) ((x)   (x)   (x))

     Uit kulatch zvorek ke zmn normln priority opertor a pravidel
sdruovn probrme na strnce 82.


Sloen zvorky

     {} (poten a koncov sloen  zvorka)  vyznauj  zatek  a konec
sloenho pkazu, take po } se s vjimkou deklarace struktury  nebo tdy
nevyaduje ; (stednk). Stednk bv asto neppustn, jako napklad v

     if (pkaz)
          {};                                    /* neppustn stednk */
     else


rka

     rka (,) oddluje prvky seznamu argument funkce:



                                  - 28 - 


     void func(int n, float f, char ch);

     rky  se rovnا uv jako opertoru ve  vrazech  s  rkami  {comma
expression}. Oboj uit rky  lze  smovat,  avak  k jejich odlien je
nutno pout zvorek:

     func(i, j);                     /* voln funkce se dvma argumenty */
     func((exp1, exp2), (exp3, exp4, exp5));     /* rovnا voln funkce se
                                                  dvma argumenty! */


Stednk

     Stednkem (;) se ukonuj pkazy. Kad ppustn vraz  jazyka  C i
C++ (vetn vrazu przdnho),  za  nm  nsleduje  ; se interpretuje jako
pkaz, ktermu se  k  vrazov  pkaz  {expression  statement}. Takov
vraz  se  vyhodnot  a jeho hodnota  se  zru.  Nem-li  vrazov  pkaz
vedlejch efekt, Turbo C++ jej me ignorovat.

     a + b;                   /* me mt hodnotu a + b, ale ta se zru */
     ++a;               /* vedlej efekt na a, ale hodnota ++a se zru */
     ;                                 /* przdn vraz = przdn pkaz */

     Stednk se asto pouv k vytven przdnch pkaz:

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


Dvojteka

     Dvojteky (:) se pouv pi oznaen pkazu nvtm:

     start: x=0;
     ...
     goto start;
     ...
     switch (a) {
          case 1: puts("Jeden");
                  break;
          case 2: puts("Dva");
                  break;
     ...
     default:     puts("Zadny z uvedenych!");
                  break;
     }

     Nvt probrme na strnce 99.


Vpustka

     Vpustka  (...)  jsou  ti teky za  sebou.  dn  przdn  msto  se
nevkld. Vpustky  se uv v seznamech formlnch argument v prototypech
funkc  k  oznaen  promnnho potu argument nebo k oznaen argument s
promnnmi typy:

     void func(int n, char ch,...);


                                  - 29 - 


     Tato deklarace zna, e se func definuje tak, e jej voln mus mt
alespo  dva  argumenty,  toti jeden typu int a jeden typu char, me vak
mt libovoln poet argument dalch.

     V C++ lze rku ped vpustkou vynechat.


Hvzdika (deklarace ukazatele)
               *
     Hvzdika   v  deklaraci  promnn zna vytvoen ukazatele na njak
typ:
          *
     char  char_ptr;                /* deklaruje se ukazatel na typ char */

     Uvedenm patinho potu hvzdiek lze  deklarovat  ukazatele  s vce
rovnmi nepmho adresovn:
         **
     int   int_ptr;                /* ukazatel na ukazatel na cel slo */
            ***
     double    double_ptr;   /* ukazatel na ukazatel na ukazatel na slo s
                                   dvojitou pesnost */

     Hvzdiky lze tak pout  bu  jako  opertoru pro nepm odkazovn
nebo jako opertoru nsoben:
         *
     i =  int_ptr;
           *
     a = b   3.14;


Znamnko rovnosti (inicializtor)

     Znamnko rovnosti (=) oddluje deklarace promnnch od inicializanch
seznam:

     char array[5] = ( 1, 2, 3, 4, 5 );
     int x = 5;

     V  jazyku  C++  se mohou deklarace libovolnch typ objevit (s jistmi
omezenmi) kdekoli uvnit zdrojovho kdu. Ve funkcch v jazyku C nesm bt
dn zdrojov kd umstn ped deklarac promnnch.

     V seznamu argument funkce v  jazyku  C++  oznauje  znamnko rovnosti
implicitn hodnotu parametru:

     int f(int i = 0) { ... }                   /* parametr i m implicitn
                                                  nulovou hodnotu */

     Znamnka rovnosti se t pouv jako opertoru dosazen ve vrazech:

     a = b + c;
                                  *
     ptr = farmalloc(sizeof(float) 100);









                                  - 30 - 


Znaka libry (direktiva preprocesoru)

     Znaka  libry (#) oznauje, je-li uvedena jako  prvn  znak  na  dku
rzn od przdnho msta,  direktivu  preprocesoru.  Zna  njakou innost
kompiltoru, kter nemus bt  nutn  spojena s generovnm kdu. Vce se o
direktivch preprocesoru dovte na strnce 139.

     Znaky # a ## (dvojit znaka libry) se pouv  tak  jako  opertor
pro  pemstn  a  setdn  lexiklnch  prvk  bhem   prohlec  fze
preprocesoru.



---------------------------------------------------------------------------
Deklarace
---------------------------------------------------------------------------


     V tomto oddlu strun  zopakujeme  pojmy  souvisejc  s deklaracemi:
objekty, typy, pam؟ov tdy, obor, viditelnost, trvn a spojovn. Dve
ne se pustme do pln deklaran syntaxe, muste zskat o  tchto pojmech
veobecn vdomosti.

     Oborem,  viditelnost,  trvnm  a  spojovnm  se  uruj   ty  sti
programu, kde  se lze ppustn odkazovat na njak identifiktory, abychom
doshli  jejich  objekt.  Obor  diskutujeme  od  strnky  32.  Viditelnost
probereme  ponaje stranou 33, trvn pak od strnky  34  a  spojovn  od
strnky 35.


Objekty
---------------------------------------------------------------------------

     Objektem se  rozum identifikovateln oblast pamti, v n lze umstit
njakou pevnou i promnnou  hodnotu  (nebo  mnoinu hodnot). (Toto pouit
slova objekt nezamujte s obecnjm  pojmem, kter se pouv v objektov
orientovanch jazycch - viz  Kapitolu  5,  "Zatenk  v C++", v Pruce
uivatele.)  Kad hodnot pslu nzev a typ  (tak  zvan  datov  typ).
Nzvu   se  uv  k  dosaen  objektu.   Nzvem   me   bt   jednoduch
identifiktor,  nebo jm me bt njak sloit  vraz,  kter  na  objekt
jednoznan "ukazuje". Typ se pouv

    o  k uren sprvnho pidlen pamti, kter se vuaduje na potku,

    o  k interpretaci  bitovch vzork, kter se v objektu bhem nslednch
       pstup naleznou

    o  a v mnohch situacch, kdy se kontroluje typ  kvli  zajitn toho,
       aby se zachytila neppustn dosazen

     Jazyk  Turbo  C++ podporuje mnoho  standardnch  (peddefinovanch)  i
uivatelsky  definovanch datovch typ. Pat sem  cel  sla  v  rznch
velikostech se znamnkem  i  bez  nj,  sla s pohyblivou dovou tekou s
rznmi pesnostmi, struktury, uniony,  pole  a  tdy. Navc lze ustanovit
ukazatele  na  vtinu  tchto  objekt  a  manipulovat  s nimi  v  rznch
pam؟ovch modelech.

     Jak standardn knihovny Turbo  C++,  tak  i  vlastn program a soubory
zhlav mus poskytovat identifiktory (nebo z nich odvozen vrazy) a typy
jednoznan. Jen tak  me  Turbo C++ trvale zpstupovat, interpretovat a


                                  - 31 - 


(podle monosti) mnit v  pamti  bitov  vzorky odpovdajc vem aktivnm
objektm v programu.

     Deklaracemi  se  ustav potebn vzjemn  zobrazen  (mapovn)  mezi
identifiktory a objekty. Kadou deklarac se sdru njak identifiktor s
njakm  datovm  typem.  Ve vtin deklarac, kterm  se  k  definin
deklarace, se tak stanov  vytvoen  (kde  a  kdy) objekt, tj. pidlen
fyzick pamti  a  jej  ppadn  inicializace.  V  ostatnch deklaracch,
kterm se  k deklarace referenn, se pouze patin identifiktory daj
potai  na  vdom.  Pro  jeden  a t identifiktor me existovat  ada
referennch deklarac, a to zejmna ve vcesouborovm programu. Pro takov
identifiktor se vak pipout pouze jedin deklarace definin.

     Obecn lze ci, e nelze pout identifiktoru v  programu  ped jeho
deklaranm bodem ve zdrojovm textu. Ppustnou vjimku z tohoto pravidla,
zvanou dopedn odkazy, pedstavuj nvt, struktury,  oznaen  union a
voln nedeklarovanch funkc.


L-hodnoty
---------------------------------------------------------------------------

     L-hodnota  {lvalue} pedstavuje lokaliztor objektu: Vraz  oznaujc
                                                  *
njak  objekt. Pkladem l-hodnotovho vrazu je  P,  kde  P  je  jakkoli
vraz,    jen   se   vyhodnot   jako   neprzdn   {nonnull}    ukazatel.
Modifikovatelnou  l-hodnotou nazvme identifiktor nebo vraz,  vztahujc
se  k  objektu, kterho lze v pamti  doshnout  a  ppustn  jej  zmnit.
Ukazatel  const na njakou konstantu napklad modifikovatelnou  l-hodnotou
nen.  Ukazatel  na  konstantu lze zmnit (avak hodnotu, na kterou nepmo
odkazuje, nikoli).

     Historicky vzato, psmeno l znamen "vlevo" {left},  protoe l-hodnota
se me ppustn nachzet na lev stran (do n se dosazuje) dosazovacho
pkazu.  Na lev stran dosazovacho pkazu  jsou  nyn  ppustn  pouze
modifikovateln l-hodnoty.  Tak  napklad  jsou-li  a  a  b identifiktory
nekonstantnch celch sel se  sprvn  pidlenmmi  msty v pamti, jsou
oba modifikovatelnmi l-hodnotami a dosazen jako a= 1  i  a  =  a + b jsou
ppustn.


R-hodnoty

     Vraz  a + b nen l-hodnotou: a + b = a nen ppustn, jeliko  vraz
vlevo se nevztahuje  k  dnmu  objektu.  Takovm vrazm se asto k r-
hodnoty (zkratka pro prav hodnoty {prav = right}).


Typy a pam؟ov tdy
---------------------------------------------------------------------------

     Sdruovn identifiktor s  objekty vyaduje, aby kad identifiktor
ml alespo dva atributy:  pam؟ovou  tdu {storage class} a typ (nkdy se
mu  k  datov  typ).  Kompiltor  Turbo  C++  tyto atributy  odvozuje  z
implicitnch nebo explicitnch deklarac ve zdrojovm textu.

     Pam؟ovou tdou se stanov umstn (datov segment, registr, heap i
zsobnk)  objektu  a  jeho trvn ili  doba  ivotnosti  (po  celou  dobu
innosti programu, resp.  po  dobu innosti uritch blok kdu). Pam؟ovou



                                  - 32 - 


tdu lze stanovit syntax  deklarace,  jejm  umstnm ve zdrojovm textu
nebo obma tmito faktory.

     Jak ji bylo eeno, typem se ur, kolik pamti se objektu  piad a
jak bude program vyhodnocovat bitov  vzorky, kter v mst uloen objektu
nalezne. Urit datov typ lze chpat jako mnoinu  hodnot  (asto zvislou
na implementaci), kter se  v  identifiktoru  tohoto typu mohou vyskytnout
spolu s  mnoinou operac, pro tyto hodnoty ppustnch. Speciln opertor
sizeof,  uren  jen  pro kompilaci, umouje stanovit  velikost  v  bytech
kterhokoli  standardnho  nebo  uivatelsky  definovanho  typu.  O  tomto
opertoru se dovte vce na strnce 87.


Obor
---------------------------------------------------------------------------

     Oborem  {scope}   identifiktoru  je  ta  st  programu,  v  n  lze
identifiktoru pout  k  dosaen  jeho  objektu.  Existuje  pt kategori
obor:  blok  (neboli  lokln), funkce, prototyp funkce,  soubor  a  tda
(jenom v C++). Jsou zvisl od toho, jak a kde se identifiktory deklaruj.


Obor blok

     Obor identifiktoru  s blokovm (neboli loklnm) oborem zan v bod
deklarace a kon na konci  bloku,  obsahujcho  tuto  deklaraci (takovmu
bloku  se  k  blok  ohraniujc  {enclosing}).  Deklarace  parametr  v
definici funkce maj rovnا obor bloku, vymezen oborem toho bloku,  v nm
se funkce definuje.


Obor funkce

     Jedinmi identifiktory, kter maj obor funkce, jsou nvt pkaz.
Nzv  nvt lze pout v pkazech goto kdekoli ve funkci, v n se toto
nvt deklaruje. Nvt  se deklaruj implicitn zpisem nzev-nvt:,
za  nm nsleduje njak pkaz. V rmci funkce  mus  bt  nzvy  nvt
jednoznan.


Obor prototyp funkce

     Obor funkce maj  identifiktory, deklarovan uvnit seznamu deklarac
parametr v prototypu njak funkce  (co  nen  soust  definice funkce).
Tento obor kon na konci prototypu funkce.


Obor soubor

     Identifiktory s oborem soubor, kterm  se  rovnا  k  globln, se
deklaruj vn vekerch blok a td; jejich obor sah od bodu deklarace po
konec zdrojovho souboru.


Obor tda (C++)

     Prozatm povaujte tdu za pojmenovanou kolekci len, do n pat i
datov struktury a funkce, kter na  nich  psob. Obor tda se s uritmi
vjimkami  tk nzv len konkrtn tdy. Pro  tdy  a  jejich  objekty



                                  - 33 - 


existuje  mnoho  specilnch  pravidel pro pstup a  vymezen  oboru,  viz
strnky 109 a 120.


Obor a prostory pro nzvy

     Prostorem  pro nzev je obor, v jeho  rmci  mus  bt  identifiktor
jednoznanm. V jazyku C existuj tyi odlin tdy identifiktor:

   1.  Nzvy  nvt v pkazech goto. Ty mus  bt  jednoznan  v  rmci
       funkce, kde jsou deklarovny.

   2.  Oznaen struktur, union a vt. Ta mus bt  jednoznan  v rmci
       bloku, kde jsou definovna. Oznaen  deklarovan  vn  vech funkc
       mus bt jednoznan v rmci vech extern definovanch oznaen.

       V  jazyku  C++  jsou  struktury,  tdy a vty umstny ve  stejnm
       prostoru pro nzev.

   3.  Nzvy  len  struktur  a  union.  Ty mus bt jednoznan v  rmci
       struktury nebo unionu, kde jsou definovny. Ohledn typu nebo ofsetu
       len rznch struktur, kter maj stejn lensk  nzev, neexistuje
       dn omezen.

   4.  Promnn,  definice   typ  typedef  a  leny  vt.  Ty  mus  bt
       jednoznan v rmci oboru, kde jsou definovny.  Extern deklarovan
       identifiktory mus bt  jednoznan vzhledem k extern deklarovanm
       promnnm.


Viditelnost
---------------------------------------------------------------------------

     Viditelnost njakho identifiktoru se rozum oblast zdrojovho textu
programu, z n je dovolen pstup k objektu, kter  je  s  identifiktorem
sdruen.

     Obor a viditelnost obvykle splvaj, akoli existuj okolnosti, kdy se
njak objekt  doasn  stane  zakrytm  {hidden}  vskytem  identifiktoru
duplicitnho:  Takov  objekt  existuje i nadle, ale k jeho dosaen nelze
pout   pvodnho  identifiktoru,  dokud  neskon  obor   identifiktoru
duplicitnho.

     Viditelnost neme pesahovat pes obor,  avak  obor  me pesahovat
viditelnost.

     ...
     {
          int i; char ch;                         // implicitn automatick
          i = 3;         // v oboru a viditeln jsou cel slo i a znak ch
     ...
          {
          double i;
          i = 3.0e3;       // v oboru a viditeln je i s dvojitou pesnost
                        // celoseln i = 3 je v oboru, ale je neviditeln
          ch = 'A';                    // znak ch je v oboru a je viditeln
          }
                                     // i s dvojitou pesnost je mimo obor
          i += 1;                        // cel slo i je viditeln a = 4
     ...                      // znak ch je jet v oboru & viditeln = 'A'


                                  - 34 - 


     }
     ...                           // cel slo i a znak ch jsou mimo obor


     Pro  zakryt  nzvy  td  a  nzvy  len  td opt  plat  zvltn
pravidla: V C++ existuj speciln  opertory,  je  za  uritch okolnost
umouj doshnout zakrytch identifiktor (viz strnku 110).


Trvn
---------------------------------------------------------------------------

     Trvnm {duration}, je se zce ve na pam؟ovou  tdu,  se definuje
obdob, po  kter  jsou  deklarovanm  identifiktorm  pidleny  v pamti
reln  fyzick  objekty.  Rozliujeme  tak  mezi  objekty  kompilanmi a
objekty innho programu. Napklad promnn maj na rozdl od definic typ
typedef pidlenu  relnou pam؟ po dobu innosti programu. Existuje trvn
trojho druhu: statick, lokln a dynamick.


Statick trvn

     Objektm se  statickm trvnm se pidl pam؟, jakmile zane program
svou innost; toto pidlen pamti trv a do  ukonen  programu. Objekty
se  statickm  trvnm  obvykle sdl v pevnch datovch segmentech, kam se
pidluj v souladu  se  stanovenm pam؟ovm modelem. Objekty se statickm
trvnm jsou vechny funkce,  a  jsou  definovny kdekoli. Statick trvn
maj  rovnا  vechny  promnn  s  oborem soubor. Ostatnm  promnnm  lze
statick trvn zadat uitm explicitnch specifiktor tdy pamti static
nebo extern.

     V neptomnosti jakhokoli  explicitnho  inicializtoru,  a  v  C++ i
konstruktoru, se objekty se statickm trvnm inicializuj na nulu (nebo na
przdn ukazatel).

     Statick trvn si  neplete  s oborem soubor neboli globlnm. Objekt
me toti mt statick trvn a pitom lokln obor.


Lokln trvn

     Objekty s loklnm trvnm,  kterm  se  t k objekty automatick,
maj svou existenci mn jistou. Vytvej se v zsobnku (nebo v registru)
pi vstupu do bloku nebo funkce, ktermi jsou ohranieny. Jakmile program z
takovho bloku nebo funkce vystoup, objekty se z pamti uvoln.  Objekty s
loklnm trvnm je nutno  inicializovat  explicitn,  v opanm ppad by
jejich obsah byl nepedvdateln. Objekty  s loklnm trvnm mus mt vdy
obor lokln nebo obor funkce.  Pi deklaraci promnnch s loklnm trvnm
lze pout specifiktoru tdy pamti  auto,  ale  obvykle  je nadbytenm,
nebo auto je pro promnn deklarovan v rmci njakho bloku implicitnm.

     Objekt s loklnm  trvnm  m  tak  lokln  obor,  nebo  vn svho
ohraniujcho bloku neexistuje. Opak  neplat:  Objekt  s  loklnm oborem
me mt statick trvn.

     Pi deklaraci promnnch (napklad int, char, float) ze specifiktoru
pam؟ov tdy register vyplv tak auto, avak kompiltoru se ped vzva
(nebo nvrh), aby se takov objekt, je-li to mon,  umstil  do  registru.
Turbo C++ lze nastavit  tak,  aby  se  lokln celoseln nebo ukazatelov
promnn pidlil njak registr, pokud  je  voln.  Nen-li  dn registr


                                  - 35 - 


voln,  takov promnn se pidl pam؟ jako  auto,  tedy  jako  loklnmu
objektu. Nevyd se pi tom dn upozornn ani nevznikne chyba.


Dynamick trvn

     Objekty s dynamickm  trvnm  se vytvej i likviduj bhem programu
vyvolnm specifickch  funkc. Pam؟ se jim pidluje ze zvltn pam؟ov
rezervy, kter se k heap  {hromada}.  Uv  se  k  tomu  bu  funkc ze
standardn knihovny, nap. malloc,  nebo  se  v  C++ pouv opertoru new.
Odpovdajc uvolnn pamti se vykon uitm free nebo delete.


Pekladov unity
---------------------------------------------------------------------------

     Pojem pekladov  unit {translation unit} se tk souboru se zdrojovm
textem spolen se vemi obsaenmi  soubory,  avak  zmenench  o vechny
dky  se  zdrojovm  textem,  kter  se vynechaly v  dsledku  podmnnch
direktiv  preprocesoru.  Syntakticky   se  pekladov  unit  definuje  jako
posloupnost externch deklarac:

     pekladov-unit:
          extern-deklarace
          pekladov-unit extern-deklarace

     extern-deklarace:
          definice-funkce
          deklarace

     Slovo extern {external} m v jazyku C nkolik vznam;  zde  se  tk
deklarac,  uinnch vn jakkoli funkce, kter  tedy  maj  obor  soubor.
(Nco jinho znamen extern spojovn; viz nsledujc oddl "Spojovn".)
Kad  deklaraci, kter vyhrad objektu nebo funkci  tak  pam؟,  se  k
definice (neboli definin deklarace). Vce  informac  naleznete  v oddlu
"Extern deklarace a definice" na strnce 41.


Spojovn
---------------------------------------------------------------------------

     Vykonateln program se obvykle  vytvo  tak,  e se kompiluje nkolik
nezvislch pekladovch unit a potom se vsledn clov  soubory  spoj s
pedem existujcmi knihovnami. Kdy se  stejn  identifiktor  deklaruje v
rznch  oborech  (napklad  v rznch souborech), nebo  se  deklaruje  ve
stejnm oboru vcekrt, nastanou pote. Proces, kter umon, aby se kad
instance identifiktoru sprvn sdruila s konkrtnm objektem nebo funkc,
nazvme spojovn {linkage}.  Vechny  identifiktory  maj  jeden  ze t
spojovacch  atribut,  je  se  zce  vztahuj  k  jejich  oboru:  extern
spojovn, intern spojovn, nebo dn  spojovn.  Tyto  atributy urte
umstnm a formtem  svch  deklarac spolen s explicitnm (nebo pvodn
implicitnm) uitm specifiktoru tdy pamti static nebo extern.

     Kad  instance  konkrtnho  identifiktoru  s   externm  spojovnm
pedstavuje v cel mnoin soubor a knihoven, z  nich  program pozstv,
jeden a t objekt.  Kad  instance  konkrtnho identifiktoru s internm
spojovnm  pedstavuje  jeden  a t objekt  nebo  funkci  pouze  v  rmci
jedinho  souboru.  Identifiktory  bez  spojovn   pedstavuj  jedinen
entity.



                                  - 36 - 


     Pravidla pro extern a intern spojovn jsou tato:

   1.  Kad identifiktor objektu nebo  souboru  s  oborem soubor bude mt
       intern spojovn,  jestlie  jeho  deklarace  obsahuje specifiktor
       pam؟ov tdy static.

       V jazyku C++ plat, e pokud se tent identifiktor objev  v tme
       souboru jak s internm, tak i externm spojovnm,  bude  mt takov
       identifiktor spojovn  extern.  V  jazyku  C  bude  mt spojovn
       intern.

   2.  Obsahuje-li  deklarace  njakho  identifiktoru objektu nebo funkce
       specifiktor   pam؟ov   tdy   extern,  m  takov  identifiktor
       spojovn    stejn   jako   kad   viditeln   deklarace    tohoto
       identifiktoru  s  oborem  soubor.  Pokud takov viditeln deklarace
       neexistuje, m identifiktor spojovn extern.

   3.  Jestlie se  njak  funkce  deklaruje  bez  specifiktoru  pam؟ov
       tdy, stanov se jej spojovn jako kdyby se pouilo specifiktoru
       pam؟ov tdy extern.

   4.  jestlie se njak identifiktor objektu s  oborem  soubor deklaruje
       bez specifiktoru pam؟ov  tdy, m takov identifiktor spojovn
       extern.

     dn spojovac atributy nemaj tyto nsledujc identifiktory:

   1.  kad  identifiktor,  deklarovan jinak neli  objekt  nebo  funkce
       (napklad identifiktor typedef)

   2.  parametry funkc

   3.  identifiktory s oborem blok, tkajc se objekt  deklarovanch bez
       specifiktoru pam؟ov tdy extern


Uhlazovn nzv

     Pi kompilaci modul v C++ generuje kompiltor nzvy  funkc,  kter v
sob obsahuj zakdovan typy argument  funkce.  k  se  tomu uhlazovn
{mangling} nzv. Umon  se  tm pepisovn funkc a spojovacmu programu
to pomh zachycovat chyby ve volnch funkc v jinch modulech.  Jsou vak
situace, kdy je uhlazovn  nzv  nedouc.  Pi  kompilaci modulu v C++,
kter  se  m  spojit  s  modulem,  jen  nem  uhlazen  nzvy,  je  teba
kompiltoru  C++ sdlit, aby nzvy funkc  z  druhho  modulu  neuhlazoval.
Takov situace je typick  pi  spojovn  s  knihovnami nebo soubory .OBJ,
kter jsou kompilovny kompiltorem jazyka C.

     Abyste kompiltoru  C++ sdlili, e nzvy funkc nem uhlazovat, sta
deklarovat dan funkce jako extern "C", takto:

     extern "C" void Cfunc( int );

     Takovou deklarac se kompiltoru sdl, e se odkazy  na  funkci Cfunc
nemaj uhlazovat.

     Deklaraci extern "C" lze rovnا pout na njak blok nzv:

     extern "C" {
          void Cfunc1( int );


                                  - 37 - 


          void Cfunc2( int );
          void Cfunc3( int );
     };

     Stejn  jako  pi  deklaraci  jedin  funkce   sdl   tato  deklarace
kompiltoru,  e  se  odkazy  na  funkce  Cfunc1,  Cfunc2 a  Cfunc3  nemaj
uhlazovat. Tohoto tvaru blokov deklarace mete pout tak tehdy, kdy je
blok nzv funkc obsaen v souboru zhlav:

     extern "C" {
          #include "locallib.h"
     };



---------------------------------------------------------------------------
Deklaran syntax
---------------------------------------------------------------------------


     Vech est  atribut (pam؟ov tda, typ, obor, viditelnost, trvn a
spojovn), kter  spolu  vnitn  souvis,  se  uruje  rozdlnmi zpsoby
deklaracemi.

     Deklarace rozliujeme  na deklarace definin (k se jim tak prost
definice) a deklarace referenn (nkdy se jim k nedefinin deklarace).
Definin  deklarace,  jak  sm  nzev  napovd,  vykonv   jak  potebn
deklarovn, tak i definovn; nedefinin deklarace naopak  vyaduj nkam
do programu pidat jet definici.  Referenn  deklarace  pouze  zavd do
programu nzvy jednoho i nkolika  identifiktor.  Definice  pak njakmu
objektu skuten piad pam؟ a sdru s tmto objektem identifiktor.


Pokusn definice
---------------------------------------------------------------------------

     Norma  ANSI  C  zavd nov pojem, a sice pokusnou definici {tentative
definition}. Za pokusnou definici  se  povauje  kad  deklarace externch
dat,  kter  neobsahuje  dn   specifiktor   pam؟ov   tdy   a  dn
inicializtor. Pokud se deklarovan identifiktor objev v  njak pozdj
definici, s pokusnou definic se zachz, jako kdyby byl zadn specifiktor
pam؟ov  tdy  extern.  Jinak eeno, pokusn definice  se  stane  pouhou
referenn deklarac.

     Doshne-li se konce pekladovho unitu  a  pro  dan  identifiktor se
dn  definice  s  inicializtorem  neobjev,  pokusn  definice  se stane
definic  opravdovou  a  definovan  objekt  pro  sebe   dostane  vyhraen
neinicializovan (tj. nulami vyplnn) prostor. Napklad

     int x;
     int x;                       /* ppustn, vyhrad se jedna kopie x */

     int y;
     int y = 4;                     /* ppustn, y se inicializuje na 4 */

     int z = 5;
     int z = 6;  /* neppustn, nebo v obou ppadech jde o inic. def. */





                                  - 38 - 


Mon deklarace
---------------------------------------------------------------------------

     Do rozsahu objekt, kter lze deklarovat, pat

    o  promnn

    o  funkce

    o  tdy a leny td (C++)

    o  typy

    o  oznaen struktur, union a vt

    o  leny struktury

    o  leny unionu

    o  pole jinch typ

    o  vtov konstanty

    o  nvt pkaz

    o  makroinstrukce preprocesoru

     V nsledujcch tabulkch uvdme plnou syntaxi deklarac. Rekurzivn
povaha syntaxe  deklartoru  pipout  i  sloit  deklartory.  Pro lep
itelnost doporuujeme uvat klauzule typedef.
































                                  - 39 - 


                  Tab. 1.10: Syntax deklarac v Turbo C++

---------------------------------------------------------------------------
deklarace:                                   short
     <dekl-specifiktory><sezn.-dekl.>       int
     deklarace-asm                           long
     deklarace-funkce                        signed
     specifikace-spojen                     unsigned
                                             float
dekl-specifiktor:                           double
     specifiktor-pam؟ov-tdy             void
     specifiktor-typu
     specifiktor-funk                  propracovan-specifiktor-typu:
     friend (specifick pro C++)             kl-tdy identifiktor
     typedef                                 kl-tdy nzev-tdy
                                             enum nzev-vtu

dekl-specifiktory:
     <dekl-specif> dekl-specif.         kl-tdy: (specifick pro C++)
                                             class
specifiktor-pam؟ov-tdy:                 struct
     auto                                    union
     register
     static                             vtov-specifiktor:
     extern                                  e         n        u         m
<identifiktor>{<vtov-seznam>}

specifiktor-funk: (specifick pro C++) vtov-seznam:
     inline                                  itatel
     virtual                                 seznam-itatel, itatel

specifiktor-typu:                      itatel:
     nzev-jednoduchho-typu:                identifiktor
     specifiktor-tdy                      identifiktor = konst-vraz
     vtov-specifiktor
     propracovan-specifiktor-typu     konstantn-vraz:
     const                                   podmnn-vraz
     volatile
                                        specifikace-spojen: (spec.pro C++)
nzev-jednoduchho-typu:                     extern etzec{<sezn-dekl>}
     nzev-tdy                             extern etzec deklarace
     typedef-nzev
     char                               seznam-deklarac:
                                             deklarace
                                             seznam-deklarac ; deklarace
---------------------------------------------------------------------------

     U nsledujc tabulky si pamatujte, e pro poet a poad modifiktor
a kvalifiktor neexistuj dn omezen. Rovnا  upozorujeme,  e uveden
modifiktory pedstavuj jedin rozen syntaxe deklartor, kter nen v
ANSI C nebo v C++.  Zmnn  modifiktory  probereme  jednotliv podrobnji
ponaje stranou 52.










                                  - 40 - 


                 Tab. 1.11: Syntax deklartor v Turbo C++

---------------------------------------------------------------------------
seznam-deklartor:
     inic-deklartor
     seznam-deklartor , inic-deklartor

inic-deklartor:
     deklartor <inicializtor>

deklartor:
     dnzev
     seznam-modifiktor
     ukaz-opertor deklartor
     deklartor (deklar.-seznam-parametr) <seznam-kvalifiktor-cv>
     (<seznam-kvalifiktor-cv> se tk jen C++.)
     deklartor [<konstantn-vraz>]
     (deklartor)

seznam-modifiktor:
     modifiktor
     seznam-modifiktor modifiktor

modifiktor:
     cdecl
     pascal
     interrupt
     near
     far
     huge

ukaz-opertor:
     *
      <seznam-kvalifiktor-cv>
     &<seznam-kvalifiktor-cv> (specifick pro C++)
                   *
     nzev-tdy::  <seznam-kvalifiktor-cv> (specifick pro C++)

seznam-kvalifiktor-cv:
     kvalifiktor-cv <seznam-kvalifiktor-cv>

kvalifiktor-cv:
     constant
     volatile

dnzev:
     nzev
     nzev-tdy (specifick pro C++)
     ~ nzev-tdy (specifick pro C++)
     typedef-nzev

nzev-typu:
     specifiktor-typu <abstraktn-deklartor>

abstraktn-deklartor:
     ukaz-opertor <abstraktn-deklartor>
     <abstraktn-deklartor>                      (sezn.-deklar.-argument)
<seznam-kvalifiktor-cv>
     <abstraktn-deklartor> [<konstantn-vraz>]
     (abstraktn-deklartor)


                                  - 41 - 


seznam-deklarac-argument:
     <seznam-deklarac-arg>
     seznam-deklarac-arg ,...
     <seznam-deklarac-arg>... (specifick pro C++)

seznam-deklarac-arg:
     deklarace-argumentu
     seznam-deklarac-arg, deklarace-argumentu

deklarace-argumentu:
     dekl-specifiktory deklartor
     dekl-specifiktory deklartor = vraz (specifick pro C++)
     dekl-specifiktory <abstraktn-deklartor>
     dekl-specifiktory <abstraktn-deklartor> = vraz (specif. pro C++)

definice-funk:
     <dekl-specifiktory> deklartor <inicializtor-ctor> tlo-funk

tlo-funkce:
     sloen-pkaz

inicializtor:
     = vraz
     = { seznam inicializtor }
     (seznam-vraz) (specifick pro C++)

seznam inicializtor:
     vraz
     seznam-inicializtor, vraz
     { seznam inicializtor <,> }
---------------------------------------------------------------------------


Extern deklarace a definice
---------------------------------------------------------------------------

     V extern  deklaraci se nesm uvdt specifiktory pam؟ov tdy auto
a   register  (viz  "Pekladov  unity"  na   strnce   36).   Ke   kadmu
identifiktoru v pekladovm unitu,  deklarovanmu  s  internm spojovnm,
me existovat nejve jedna extern definice.

     Extern definice je  extern  deklarac, kter tak njak objekt nebo
funkci definuje; pidluje tedy i pam؟. Uijete-li v njakm vrazu (jinm
neli  je  st  operandu  v  sizeof) identifiktor deklarovan  s  vnjm
spojovnm,  mus  nkde  v  rmci  celho programu existovat  prv  jedna
extern definice tohoto identifiktoru.

     Jazyk Turbo C++ pipout pozdj optovn deklarace  externch nzv
jako jsou pole, struktury  a  uniony, aby lo pidat informace k deklaracm
pedchozm. Napklad

     int a[];                                              // nem velikost
     struct mojestrukt;            // jen oznaen, nejde o deklaraci len
     ...
     int a[3] = [1, 2, 3];                // zadat velikost a inicializovat
     struct mojestrukt {
          int i, j;
     };                                         // pidat deklartory len




                                  - 42 - 


     Nsledujc tabulka podv  syntax  deklarace  tdy.  Na  strnce 105
naleznete podrobnosti o referennch typech  v  C++  (zce  souvisejcch s
ukazatelovmi typy).



























































                                  - 43 - 


            Tab. 1.12: Deklarace tdy v Turbo C++ (jen v C++)

     ----------------------------------------------------------------------
     specifiktor-tdy:
          zhlav-tdy {<seznam-len>}

     zhlav tdy:
          kl-tdy <identifiktor> <spec-bze>
          kl-tdy nzev-tdy <spec-bze>

     seznam-len:
          deklarace-lenu <seznam-len>
          specifiktor-pstupu : <seznam-len>

     deklarace-lenu:
          <dekl-specifiktory> <seznam-deklartor-len>;
          definice-funkce <;>
          kvalifikovan-nzev;

     seznam-deklartor-len:
          deklartor-lenu
          seznam-deklartor-len, deklartor-lenu

     deklartor-lenu:
          deklartor <ist-specifiktor>
          <identifiktor> : konstantn-vraz

     ist-specifiktor:
          = 0

     spec-bze:
          : bzov-seznam

     bzov-seznam:
          bzov-specifiktor
          bzov-seznam, bzov-specifiktor

     bzov-specifiktor:
          nzev-tdy
          virtual <specifiktor-pstupu> nzev-tdy
          specifiktor-pstupu <virtual> <nzev-tdy>

     specifiktor-pstupu:
          private
          protected
          public

     nzev-pevodn-funkce:
          operator nzev-typu-pevodu

     nzev-typu-pevodu:
          specifiktory-typu <ukaz-opertor>

     inicializtor-ctor:
          : seznam-pam-inicializtor

     seznam-pam-inicializtor:
          pam-inicializtor
          pam-inicializtor, seznam-pam-inicializtor

     pam-inicializtor:

                                  - 44 - 


          nzev-tdy (<seznam-argument>)
          identifiktor (<seznam-argument>)

     nzev-opertorov-funkce:
          operator opertor

     opertor: jeden z
          new  delete    sizeof
          +    -    *    /    %    ^
          &    |    ~    !    =    <>
                    *
          +=   -=    =   /=   %=   ^=
          &=   |=   <<   >>   >>=  <<=
          ==   !=   <=   >=   &&   ||
                           *
          ++   --   ,    ->   ->   ()
                *
          []   .
     ----------------------------------------------------------------------


Specifiktory typu
---------------------------------------------------------------------------

   Specifiktor typu spolu s  jednm  i  vce nepovinnmi modifiktory se
uv ke stanoven typu deklarovanho identifiktoru:

   int i;                     // deklarace i jako celho sla se znamnkem
   unsigned char ch1, ch2;             // deklarace dvou znak bez znamnek

   V souladu se  zavedenou  tradic se pi vynechn typovho specifiktoru
implicitn pedpokld typ signed int (nebo ekvivalentn int). V jazyku C++
vak existuj situace,  kdy  chybjc specifiktor typu vede k syntaktick
nejednoznanosti. Proto je  v  C++ praktick vechny specifiktory typu int
zadvat explicitn.


Rozdlen typ
---------------------------------------------------------------------------

   Existuj tyi zkladn kategorie typ:  void  {przdn  znakov msto},
scalar {skalrn}, function a aggregate {agregovan}. Skalrn a agregovan
typy lze jet dle dlit:

    o  Skalrn: aritmetick, vtov, ukazatel a  v  C++  jet referenn
       typ

    o  Agregovan: pole, struktura, union a v C++ jet typ tda.

   Typy lze  rovnا dlit na fundamentln a odvozen. Fundamentlnmi typy
jsou void, char, int, float a double. Pat k nim jet short, long, signed
a unsigned, kter pedstavuj varianty nkterch z ve  uvedench  typ. K
odvozenm typm pat ukazatele a odkazy na jin typy,  pole  jinch  typ,
typy funkc, typy td, struktury a uniony.

   Objekt tda me napklad obsahovat urit poet objekt rznch typ,
jako i funkce pro manipulaci s tmito objekty plus njak  mechanismus pro
kontrolu pstupu a ddinosti z ostatnch td.




                                  - 45 - 


   Vyjdeme-li  z  njakho  typu  typ,  kter  nen  void, lze  s  uritmi
omezenmi nsledovn deklarovat jeho odvozen typy:


                        Tab. 1.13: Deklarovn typ

---------------------------------------------------------------------------
typ t;                             Objekt typu typ

typ pole[10];                      Deset typ; pole[0] - pole[9]
    *
typ  ukaz;                         ukaz je ukazatelem na typ

typ &ref = t;                      ref je odkazem na typ (C++)

typ func(void);                    Funkce func poskytne hodnotu typu typ

void func1(typ t);                 Funkce func1 pevezme parametr typu typ

struct st (typ t1; typ t2);        Struktura st obsahuje dva typy
---------------------------------------------------------------------------

   Uvdomte  si,  e  typ& prom, typ &prom  i  typ  &  prom  jsou  navzjem
ekvivalentn.

   A nyn si ukame, jak lze deklarovat odvozen typy v njak td:

   class ct {                     // tda ct obsahuje ukazatel na typ plus
                                  // funkci pebrajc parametr type (C++)
           *
      type  ptr;
      public;
                    *
      void func(type );


Typ void

   void je specilnm specifiktorem typu, kterm se  oznauje neptomnost
jakchkoli hodnot. Pouv se v nsledujcch situacch:

   V  jazyku  C++  se s funkc  func()  zachz  specilnm  zpsobem.  Viz
"Deklarace a prototypy" na strnce 66 a ukzky zdrojovho textu  na strnce
68.

    o  Przdn seznam parametr v deklaraci funkce:

       int func(void);                  // funkce nepebr dn argumenty

    o  Kdy deklarovan funkce neposkytne dnou hodnotu:

       void func(int n);                                 // zskan hodnota

    o  Jako generick ukazatel: Ukazatel na void  je  generickm ukazatelem
       na cokoli:
            *
       void  ptr;                // ptr lze pozdji nastavit k ukazovn na
                         libovoln objekt

    o  V petypovacch vrazech:


                                  - 46 - 


       extern int errfunc();                          // poskytne kd chyby
       ...
       (void) errfunc();                         // zruit zskanou hodnotu


Fundamentln typy
---------------------------------------------------------------------------

   Specifiktory  fundamentlnch  typ  jsou  sestaveny   z  nsledujcch
klovch slov:

          char           int            signed
          double         long           unsigned
          float          short

   Slova  signed  a  unsigned  jsou  modifiktory, kterch lze  pout  pro
celoseln typy.

   Z  tchto  klovch  slov lze sestavovat  celoseln  typy  a  typy  s
pohyblivou  dovou  tekou,  kterm  se  spolen  k  typy aritmetick.
Definice  rozsah  hodnot  vech  fundamentlnch  typ  jsou  obsaeny  ve
vkldacm {include} souboru limits.h.


Celoseln typy

   Za celoseln datov typy se povauj char, short, int a long,  jako i
jejich   varianty   bez   znamnka   {unsigned}.    Uvdme   specifiktory
celoselnch  typ,  piem  na jednom dku jsou  vdy  uvedena  vechna
synonyma:


                        Tab. 1.14: Celoseln typy

--------------------------------------------------------------------------------
char, signed char        Synonyma, je-li implicitn char nastaven na signed
unsigned char
char, unsigned char      Synonyma, je-li implicitn char nastaven na unsigned
signed char
int, signed int
unsigned, unsigned int
short, short int, signed short int
unsigned short, unsigned short int
long, long int, signed long int
unsigned long, unsigned long int
--------------------------------------------------------------------------------

   Spolen se slovem char, short, int nebo long lze navc ut  jednoho ze
slov signed nebo unsigned. Pouije-li  se klovch slov signed i unsigned
samotnch, znamenaj signed int, resp. unsigned int.

   Nen-li  udno  unsigned,  obvykle   se   pedpokld   signed.  Vjimku
pedstavuje slovo char. Jazyk  Turbo  C++  umouje  pro char nastavit jako
implicitn  slovo  signed  nebo unsigned. (Pokud je  nenastavte  sami,  je
implicitnm slovem signed.) Je-li jako implicitn  nastaveno  unsigned, pak
deklarac char ch se  ch  deklaruje  jako  unsigned. K pedefinovn takov
implicitn  deklarace  by  bylo  nutno  ut  signed  char ch.  Analogicky,
nastavte-li  pro  char  jako  implicitn  signed,  bylo  by k  deklarovn
unsigned char nutn explicitn deklarovat unsigned char ch.



                                  - 47 - 


   Se  slovem  int  lze navc pout  jednoho  ze  slov  long  nebo  short.
Pouije-li se klovch slov long  nebo short samotnch, znamenaj long int
i short int.

   Norma ANSI C  nenaizuje  pro  tyto  typy  dn  velikosti  ani vnitn
zobrazen.  Vyaduje  pouze,  aby  short,  int a long  tvoily  neklesajc
posloupnost, v n  "short<=int<=long".  Je ppustn, aby vechny tyto ti
typy byly stejn. To je  dleit, chcete-li napsat penosn program, kter
by se pouval na jinch pracovitch.

   V  jazyku  Turbo C++ jsou typy int a short ekvivalentn a  oba  maj  16
bit.  Typ long m 32 bit. Jejich alternativy  se  znamnkem  se  ukldaj
vesms ve formtu dvojkovho  doplku.  Jako  znamnkovho bitu uvaj MSB
('most  significant  bit'  =  bit  s nejvy hodnotou): 0 znamen  kladnou
hodnotu, 1 znamen hodnotu zpornou (m se vysvtluj  rozsahy  uveden v
Tabulce 1.9 na strnce 21). Ve verzch bez znamnka se pouv vech bit a
                     n
vznikne rozsah 0 - (2  - 1), kde n je 8, 16 nebo 32.


Typy s pohyblivou dovou tekou

   Zobrazen  a  mnoiny  hodnot v ppad typ s pohyblivou dovou tekou
zvis na implementaci. Znamen to, e kad implementace jazyka C  je me
voln definovat. Jazyk Turbo C++ uv pro pohyblivou dovou teku formt
IEEE (Institute of Electrical and Electronics Engineers).  (O implementan
specifickch polokch vm pov vce Dodatek  A,  "Implementan specifick
normy ANSI").

   Typy float a double jsou 32-, resp. 64- bitovmi typy. Spolen s double
lze ut long a deklarovat tak identifiktor s  pohyblivou  dovou tekou,
kter m pesnost 80 bit: napklad long double test_pripad.

   Pidlovn pamti pro typy s pohyblivou dovou tekou uvd na strnce
21.


Standardn pevody

   Kdy pouijete  njak  aritmetick  vraz,  jako teba a + b, kde a a b
jsou  rznch  aritmetickch  typ,  vykon  Turbo  C++  ped  vyhodnocenm
takovho vrazu jist vnitn pevody. Mezi tyto standardn pevody pat v
zjmu pesnosti a shody i poven "nich" typ na typy "vy".

   Uvedeme  jednotliv   kroky,  jich  Turbo  C++  k  pevodu  operand  v
aritmetickch vrazech pouv:

   1.  Vechny mal celoseln typy  se  pevdj  podle Tabulky 1.15. Po
       takovm  pevodu  jsou  jakkoli  dv  hodnoty,  patc  k njakmu
       opertoru, ob int (vetn  modifiktor  long  a  unsigned, double,
       float i long double).

   2.  Je-li  alespo  jeden  operand typu long double,  pevede  se  druh
       operand na long double.

   3.  Nen-li tomu tak a alespo jeden operand je typu double,  pevede se
       druh operand na double.

   4.  Nen-li tomu tak a  alespo  jeden operand je typu float, pevede se
       druh operand na float.


                                  - 48 - 


   5.  Nen-li  tomu tak a alespo jeden operand  je  typu  unsigned  long,
       pevede se druh operand na unsigned long.

   6.  Nen-li tomu tak a alespo jeden operand je typu  long,  pevede  se
       druh operand na long.

   7.  Nen-li tomu tak a alespo jeden operand je  typu  unsigned, pevede
       se druh operand na unsigned.

   8.  V opanm ppad jsou oba operandy typu int.

   Vsledek vrazu je stejnho typu jako operandy.

           Tab. 1.15: Metody standardnch aritmetickch pevod

---------------------------------------------------------------------------
     Typ                 Pevede se na       Metoda
---------------------------------------------------------------------------
     char                int                 Rozen o nulu nebo o
                                             znamnko (podle implicitnho
                                             typu char)
     unsigned char       int                 Nulami vyplnn nejvy byte
                                             (vdy)
     signed char         int                 Rozen o znamnko (vdy)
     short               int                 Stejn hodnota
     unsigned short      unsigned int        Stejn hodnota
     enum                int                 Stejn hodnota
---------------------------------------------------------------------------


Speciln pevody typ char, int a enum

   Dosazen objektu znakovho typu  se  znamnkem  (napklad  promnn) do
objektu celoselnho vede k automatickmu  rozen  o  znamnko. Objekty
typu  signed  char  vdy  pouvaj  znamnkovho  rozen.  Objekty typu
unsigned char vdy pi svm pevodu na int nastav nejvy byte na nulu.

   Pevody probran v tomto oddlu jsou specifick pro Turbo C++.

   Pevodem delho celoselnho typu na krat typ se  bity  vyho du
vypust  a  bity  du  niho  zstanou  beze  zmny.  Pevodem  kratho
celoselnho typu na typ del se pidan bity nov hodnoty bu znamnkov
roz  nebo  vypln  nulami. Zle na tom, zda krat typ je signed nebo
unsigned.


Inicializace
---------------------------------------------------------------------------

   Pouitm inicializtor  se nastav poten hodnoty, kter se ulo do
objekt (promnn, pole,  struktury  atd.).  Pokud  njak  objekt nebudete
inicializovat sami a tento objekt m statick trvn, bude se inicializovat
implicitn nsledujcm zpsobem:

    o  na nulu, je-li aritmetickho typu

    o  na przdn {null} ukazatel, je-li typu ukazatel

   M-li automatick trvn v pamti, zstane jeho hodnota neurena.



                                  - 49 - 


   Inicializtory maj tuto syntaxi:

   inicializtor
      = vraz
      = {seznam-inicializtor} <,>}
      (seznam vraz)

   seznam-inicializtor
      vraz
      seznam-inicializtor, vraz
      {seznam-inicializtor} <,>}

   Inicializtory se d tmito pravidly:

   1.  Poet inicializtor v seznamu inicializtor nesm bt  vt neli
       poet objekt, kter se maj inicializovat.

   2.  Poloka, kter se m inicializovat, mus bt typu  objekt  nebo pole
       neznm velikosti.

   3.  Veker vrazy mus bt konstantn, uvd-li se na  jednom  z tchto
       mst:

       a. v inicializtoru njakho objektu, kter m statick trvn (v
          C++ se to nevyaduje)

       b. v seznamu inicializtor pole, struktury nebo unionu (pipout
          se rovnا vrazy uvajc sizeof)

   4.  M-li deklarace identifiktoru obor blok a  een  identifiktor m
       extern nebo intern spojovn, neme mt takov deklarace pro dan
       identifiktor dn inicializtor.

   5.  Pokud  je  v  seznamu,  uvedenm   ve   sloench   zvorkch,  mn
       inicializtor  neli  je len njak  struktury,  inicializuje  se
       zbytek tto struktury implicitn stejnm zpsobem,  jako  objekty se
       statickm trvnm.

   Skalrn typy  se  inicializuj  jedinm  vrazem,  kter  lze nepovinn
uzavt do sloench zvorek. Poten  hodnotou  objektu  je  pak hodnota
vrazu;  plat  stejn  omezen  ohledn  typ a pevod jako pro  normln
dosazen.

   V  ppad  union   inicializtor,  uzaven  ve  sloench  zvorkch,
inicializuje len, kter se objev jako prvn v  seznamu  deklarac unionu.
Jde-li  o  struktury  nebo  uniony  s  automatickm  trvnm  pamti,  mus
inicializtor bt jednm z nsledujcch:

    o  seznamem inicializtor, popsanm v ptm oddlu

    o  jednoduchm vrazem typu kompatibilnho s unionem nebo strukturou. V
       takovm ppad je poten hodnotou objektu hodnota tohoto vrazu.


Pole, struktury a uniony

   Pole  a  struktury  se  inicializuj  (napklad   v   mst  deklarace)
prostednictvm seznamu inicializtor, uzavenho ve  sloench zvorkch,
pslunho  lenm  nebo  prvkm  patinho  objektu.  Inicializtory  se
zadvaj  ve  vzestupnm  poad   index   nebo   len  pole.  Uniony  se


                                  - 50 - 


inicializuj inicializtorem ve sloench zvorkch, patcm prvnmu lenu
unionu. Lze napklad deklarovat pole dny, kter m  slouit  ke spotn,
kolikrt se kad den tdne objev v njakm msci (za pedpokladu,  e se
kad den objev aspo jedenkrt). Deklarace je:

   int dny[7] = { 1, 1, 1, 1, 1, 1, 1 }

   K  inicializaci  znakovch   pol   a  pol  se  irokmi  znaky  uijte
nsledujcch pravidel:

   1.  Pole znakovho typu  lze inicializovat njakm literlovm etzcem,
       nepovinn uzavenm do sloench zvorek. Kad znak tohoto etzce,
       vetn  nulovho  termintoru,  inicializuje nsledujc prvek pole.
       Mete napklad deklarovat

       char nazev[] = { "Neznamy" }

       m se nastav pole  8  prvk, jeho prvky jsou 'N' (pro nazev[0]),
       'e' (pro nazev[1]) atd. (vetn nulovho termintoru).

   2.  Pole  se  irokmi  znaky  (kter  je  kompatibiln  s  wchar_t)  se
       inicializuje  pouitm  irokho  etzcovho  literlu,   nepovinn
       uzavenho do sloench zvorek. Analogicky jako v ppad znakovch
       pol kdy irokho znakovho literlu inicializuj  za  sebou jdouc
       prvky pole.

   Uvdme ukzku inicializace struktury:

   struct mojestrukt {
      int i;
      char str[21];
      double d;
   } s = { 20, "Borland", 3.141 };

   Sloit  leny  njak  struktury,  jimi  jsou   napklad   pole  nebo
struktury,  lze  inicializovat  vhodnmi  vrazy uvnit vnoench sloench
zvorek. Zvorky lze  vynechat,  je  vak  pi  tom  nutn  dodrovat jist
pravidla a z praktickho hlediska vm to nedoporuujeme.


Jednoduch deklarace
---------------------------------------------------------------------------

   Jednoduch deklarace identifiktor promnnch maj nsledujc tvar:

   datov-typ prom1 <=inic1>, prom2 <=inic2>, ...;

   kde prom1, prom2,... je njak posloupnost  oddlench  identifiktor s
nepovinnmi inicializtory. Vechny promnn se deklaruj jako  typ datov-
typ. Napklad

   int x = 1, y = 2;

   vytvo dv celoseln promnn s nzvy x a  y  (a  inicializuje  je na
hodnoty 1, resp. 2).

   Jde  vesms  o  definin  deklarace;  pidluje se pam؟ a aplikuj  se
vechny nepovinn inicializtory.




                                  - 51 - 


   Inicializtorem  automatickho  objektu  me  bt  libovoln  ppustn
vraz,  kter se vyhodnot na hodnotu kompatibiln  ve  smyslu  dosazen  s
typem dan promnn. Inicializtory statickch objekt  mus  bt konstanty
nebo konstantn vrazy.

   V jazyku C++ me bt inicializtorem statickho objektu jakkoli vraz,
obsahujc konstanty a dve deklarovan promnn a funkce.


Specifiktory pam؟ov tdy
---------------------------------------------------------------------------

   V   deklaraci   mus   bt   ptomen   specifiktor   pam؟ov   tdy.
Specifiktorem pam؟ov tdy  me  bt  jedno  z  nsledujcch klovch
slov:

          auto                register            typedef
          extern              static


Pouit specifiktoru pam؟ov tdy auto

   Specifiktoru  pam؟ov  tdy  auto  se  pouv  jenom  v  deklaracch
promnnch s loklnm  oborem.  Zavd se jm lokln (automatick) trvn,
ale protoe je pro vechny  promnn s loklnm oborem implicitnm, pouv
se zdka.


Pouit specifiktoru pam؟ov tdy extern

   Specifiktoru pam؟ov tdy extern  lze  pout  v deklaracch s oborem
funkce a rznch soubor, jako i v deklaracch s loklnm oborem,  kdy jde
o  vyznaen  externho  spojovn. V ppad promnnch s oborem soubor je
extern implicitnm specifiktorem pam؟ov tdy. Pi  pouit  s promnnou
extern zna, e promnn m  statick trvn. (Nezapomete, e funkce maj
statick  trvn vdy.) Na strnce 37 naleznete informace  o  tom,  jak  se
pouv extern k zabrnn uhlazovn nzv pi kombinacch kd v jazyku C
a C++.


Pouit specifiktoru pam؟ov tdy register

   Pouit  specifiktoru  pam؟ov  tdy  register  je  ppustn  jen  v
deklaracch loklnch promnnch a  parametr  funkc.  Je  ekvivalentn se
specifiktorem  auto a na okolnost, e kompiltor  obdr  vzvu,  aby  se
promnn  v ppad monosti pidlil registr.  Pidlenm  registru  se  v
mnoha  situacch  me  vrazn snit velikost a  zvit  vkon  programu.
Jeliko jazyk Turbo C++  asto  umsuje  promnn  do registr, je pouit
klovho slova register jen zdka nutn.

   Turbo  C++  umouje  vybrat  alternativy  pro  registrov   promnn  z
dialogovho  rmeku  Options  |   Compiler   |   Optimization.  Zvolte-li
Automatic,  Turbo  C++  se  pokus   o  pidlen  registr,  i  kdy  jste
specifiktor pam؟ov tdy register nepouili.








                                  - 52 - 


Pouit specifiktoru pam؟ov tdy static

   Specifiktoru pam؟ov tdy static  lze  pout  v deklaracch s oborem
funkce a rznch  soubor,  jako  i  loklnho  oboru,  m-li  se vyznait
intern  spojovn.  static  t  zna,  e promnn m  statick  trvn.
Nejsou-li  ptomny  dn  konstruktory  nebo  explicitn  inicializtory,
inicializuj se statick promnn nulou nebo jako przdn ukazatel.

   V C++ plat, e statick datov len njak tdy m ve vech instancch
tdy  tut  hodnotu.  Statick  funkn  len  njak  tdy lze  vyvolat
nezvisle na vech instancch tdy.


Pouit specifiktoru pam؟ov tdy typedef

   Klovm slovem typedef se ozna, e msto deklarovn njakho objektu
se  definuje  specifiktor  novho  typu  dat.  typedef  se  zahrnuje  mezi
specifiktory pam؟ov tdy spe pro  svou  podobnost  syntaktickou neli
funkn.

   static               long  int   biggy;
   typedef  long  int   BIGGY;

   Prvn deklarac se vytvo 32-  bitov objekt se statickm trvnm, typu
long int a s  nzvem  biggy.  Druh  deklarace ustanov identifiktor BIGGY
coby  nov specifiktor typu, avak nevytvo se  dn  objekt  pro  inn
program. Specifiktoru BIGGY lze pout v libovoln nsledn deklaraci, kde
by byl ppustn specifiktor typu. Napklad

   extern BIGGY plat;

   psob stejn jako

   extern long int plat;

   I  kdy bychom tohoto jednoduchho pkladu  doshli  i  pomoc  #define
BIGGY  long int, sloitjm pouitm aplikac  typedef  lze  dokzat  vce
neli pouhmi nhradami textu.

Dleit!
   typedef nevytv nov typy dat; vytv  pouze  uiten mnemotechnick
synonyma neboli alias typ existujcch.  Jeho uit se vyplc zejmna pi
zjednoduovn sloitch deklarac:
                   *
   typedef double ( PFD)();
   PFD pole_pfd[10];
   /* pole_pfd je polem 10 ukazatel na funkce, poskytujc double */

   Identifiktor  typedef  nelze pout s  jinmi  specifiktory  datovch
typ:

   unsigned BIGGY platba;                                 /* NEPPUSTN */










                                  - 53 - 


Modifiktory
---------------------------------------------------------------------------

   Krom klovch  slov pro specifiktory pam؟ov tdy lze v deklaracch
pout uritch modifiktor, ktermi se mn nkter vlastnosti vzjemnho
zobrazen mezi identifiktorem a objektem.  Modifiktory  dostupn  v Turbo
C++ jsme shrnuli do tabulky 1.16.


Modifiktor const

   Modifiktor const zabrn jakmukoli dosazovn do objektu  i vedlejm
efektm,  jakmi  jsou  teba   zven   i   snen   hodnoty.  Ukazatel
specifikovan  jako  const  nelze  modifikovat,  pestoe  objekt,  na nj
ukazuje, modifikovat lze. Promyslete si nsledujc pklady:

   Pouit modifiktoru const samotnho je ekvivalentn s const int.

     const     float     pi        = 3.1415926;
     const               maxint    = 32767;
               *
     char       const    str       = "Hello, world"; // Konstantn ukazatel
                         *
     char      const      str2     = "Hello, world";         /* Ukazatel na
                                             konstantn typ char */

   Za tchto okolnost jsou neppustn nsledujc pkazy:

   pi = 3.0;                               /* Dosazuje hodnotu konstant */
   i  = maxint++;                           /* Zvyuje hodnotu konstanty */
   str   = "Nazdar !";                 /* str m ukazovat na nco jinho */

   Uvdomte si vak, e je ppustn voln strcopy(str, "Nazdar !"), nebo
znak po znaku kopruje etzcov literl "Nazdar !" do msta v  pamti, kam
ukazuje str.

   V  C++  modifiktor  const  rovnا  zakryje objekt typu const a  zabrn
externmu spojovn. Muste pak ut  extern const. Ukazatel na const nelze
dosadit do ukazatele na ne-const (v opanm ppad by se mohlo  do hodnoty
const pouitm nekonstantnho ukazatele dosazovat). Napklad
        *
   char  str3 = str2                                    /* nen dovoleno */




















                                  - 54 - 


                    Tab. 1.16: Modifiktory v Turbo C++

--------------------------------------------------------------------------------
Modifiktor    Uv se pro        Pouit
--------------------------------------------------------------------------------

const          Jen promnn        Zabrn zmnm objektu.

volatile       Jen promnn        Zabrn pidlen registru a urit
                                   optimalizaci. Upozorn kompiltor, e objekt
                                   me bhem vyhodnocovn podlhat zmnm
                                   zven.

V C++ se const a volatile roziuj i na tdy a lensk funkce

Rozen v Turbo C++

cdecl          Funkce              Nad pedvn argument podle konvence
                                   jazyka C.

cdecl          Promnn            Nad rozliovn velkch a malch psmen v
                                   globlnch identifiktorech a zaten znaky
                                   podtren.

pascal         Funkce              Nad pedvn argument podle konvence
                                   jazyka Pascal.

pascal         Promnn            Nad rozliovn velkch a malch psmen v
                                   globlnch identifiktorech bez zatench
                                   znak podtren.

interrupt      Funkce              Funkce se kompiluje s pdavnm kdem pro
                                   drbu registr, kterho je teba pi zpisu
                                   oeten pro peruen.

near,          Ukazatelov prom.   Pedefinuje implicitn typ ukazatele, dan
far,                               aktulnm pam؟ovm modelem.
huge

_cs            Ukazatelov prom.   Segmentov ukazatele;
_ds,                               viz stranu 201.
_es,
_seg
_ss

near           Funkce              Pedefinuje implicitn typ funkce, dan
far,                               aktulnm pam؟ovm modelem.
huge

near,          Promnn            d umstn objektu v pamti.
far

_export        Funkce              Jen pro OS/2. Turbo C++ jej ignoruje.

_loadds        Funkce              Nastav DS, aby ukazoval na aktuln datov
                                   segment.

_saveregs      Funkce              Bhem vykonvn funkce zachov vechny
                                   hodnoty registr (s vjimkou zskanch



                                  - 55 - 


                                   hodnot)
--------------------------------------------------------------------------------


Modifiktor funkce peruen

   Modifiktor interrupt je specifick pro Turbo C++. Funkce interrupt jsou
ureny k pouit na vektorech  peruen v procesorech 8086/8088. Turbo C++
zkompiluje funkci  interrupt se zvltn vstupn hodnotou i vstupnm kdem
funkce,  m se uchrn registry AX, BX, CX, DX, SI, DI, ES a DS.  Ostatn
registry  (BP,  SP,  SS, CS a IP) se zachovaj jako  soust  sekvence  pro
voln  v  jazyku  C nebo jako soust samotnho oeten peruen. Funkce
pouije  k nvratu instrukce iret, take tto funkce  lze  ut  k  obsluze
technickch  i  programovch  peruen.  Pinme ukzku typick definice
interrupt:

   void interrupt mojeosetr()
   {
   ...
   }

   Funkce pro peruen deklarujte  jako  typ  void. Peruovac funkce lze
deklarovat v libovolnm pam؟ovm modelu. Registr DS se ve vech pam؟ovch
modelech  s  vjimkou  rozshlch  {huge}  nastav  na  datov  segment.  V
rozshlm modelu se DS nastav na datov segment modulu.


Modifiktor volatile

   Modifiktor volatile {nestl} zna, e  objekt  je  mono modifikovat.
Nemuste  tak uinit sami, pvodce me bt i  vn  programu,  napklad  v
peruovac rutin nebo  ve vstupnm/vstupnm portu. Deklarujete-li njak
objekt jako  volatile,  kompiltor  obdr  upozornn,  aby  neinil dn
pedpoklady ohledn hodnoty objektu  pi  vyhodnocovn  vraz,  kter jej
obsahuj.  Tato  hodnota  se  me  zmnit  (teoreticky)  kadm okamikem.
Kompiltoru se rovnا zabrn, aby z promnn uinil registrovou promnnou.

   V jazyku C++ m volatile speciln vznam pro lensk funkce td. Pokud
deklarujete  njak  objekt  jako  volatile,  mete  pouvat  jenom  jeho
lenskch funkc volatile.

   volatile int tiky;
   interrupt timer()
   {
      tiky++;
   }

   wait(int interval)
   {
      tiky = 0;
      while (tiky < interval);                               // Nedlat nic
   }

   Takovmi  rutinami  (za  pedpokladu,  e  se  timer  sprvn sdruil  s
peruenm  technickmi  hodinami)  se  implementuje ekn asov vymezen
potem tik, zadanm v argumentu  interval. Kompiltor snac se o vysokou
optimalizaci nemus hodnotu tiky do testu pro smyku  while  zavdt, nebo
tato smyka hodnotu tiky nemn.




                                  - 56 - 


Modifiktory cdecl a pascal

   Jazyk  Turbo  C++  umouje programm snadn voln  rutin  zapsanch  v
jinch jazycch a naopak. Pi takovm smovn jazyk mte co do inn se
dvma dleitmi okolnostmi: pedvnm identifiktor a parametr.

   V Turbo C++ se vechny globln identifiktory ulo s pvodnmi psmeny
(velkmi, malmi  i obojmi). Ped identifiktor se pipoj znak podtren
(_), ledae  byste  zvolili  alternativu  -u-  (Generate  Underbars...Off v
dialogovm rmeku Options | Compiler | Code Generation).

   Na strnce 36 jsme si povdli, jak se pouv extern, m  je umonno
odkazovn na nzvy z jazyka C v programech v C++.


   pascal

   V  jazyku  Pascal  se  globln  identifiktory  neukldaj   s  pvodn
velikost psmen, ani se  ped  n  nepipojuje  podtren. Jazyk Turbo C++
dovoluje deklarovat vechny identifiktory v typu pascal; identifiktory se
pevedou na velk psmena a dn podtren se ped  n  nepipoj.  (Je-li
identifiktor funkc, ovlivn to pouitou sekvenci pro pedvn parametr;
vce podrobnost o tom  naleznete  v  oddlu  "Modifiktory typu funkce" na
strnce 57.)

   Alternativa kompiltoru  -p  (Calling  Convention...Pascal  v dialogovm
rmeku Options | Compiler | Code Generation) zpsob, e se vemi funkcemi
(a ukazateli na tyto funkce) se zachz, jako kdyby byly typu pascal.

   Modifiktor pascal je specifick  pro  Turbo C++; je uren pro funkce (a
ukazatele na funkce),  je  uvaj sekvenc pro pedvn parametr jazyka
Pascal. Funkce  deklarovan  jako  typ  pascal  lze  rovnا volat z rutin v
jazyku C, nebo standardn podprogramy v jazyku C vid, e takov funkce je
typu pascal.

   pascal putnums(int i, int j, int k)
   {
      printf("Odpovedi jsou: %d, %d a %d\n", i, j, k);

   Funkce  typu  pascal  nemohou,  na  rozdl od funkc jako teba  printf,
pebrat  promnliv  poet  argument. Z tohoto dvodu  nelze  v  definici
funkce pascal pout vpustky (...).


   cdecl

   Lze  zajistit, aby si po dokonen kompilace  s  alternativou  -p  jist
identifiktory  uchovaly  sv  velk i mal  psmena  a  mly  ped  sebou
podtren. Zvlt to plat pro identifiktory v jazyku C z njakho jinho
souboru. Uin se to deklarovnm  tchto identifiktor jako cdecl. (M to
rovnا vliv na pedvn parametr funkc).

   Funkce  main se mus deklarovat jako cdecl.  Spoutc  kd  programu  v
jazyku C se toti vdy pokou  volat  main podle konvence pro voln podle
jazyka C.

   Stejn jako pascal, i  modifiktor  cdecl  je  specifick pro Turbo C++.
Uv  se  pro   funkce   a  ukazatele  na  funkce.  Pedefinuje  direktivu
kompiltoru -p  a  umon  funkce  volat  jako  normln funkce v jazyku C.
Kdybyste  napklad  chtli   pedchoz  program  kompilovat  s  nastavenou


                                  - 57 - 


alternativou  -p,  ale  chtli  byste  pout  printf,  mete uinit  nco
takovho:

   extern cdecl printf();
   putnums(int i, int j, int k);

   cdecl main()
   {
      putnums(1, 4, 9);
   }

   putnums(int i, int j, int k);
   {
      printf("Odpovedi jsou: %d, %d a %d\n", i, j, k);
   }

   Budete-li program kompilovat s alternativou -p, vechny pouit funkce z
knihovny innho programu je nutno deklarovat jako cdecl. Podvte-li se na
soubory  se zhlavm (teba stdio.h), uvidte, e  vechny  funkce  to  ji
oekvaj a jsou explicitn definovny jako cdecl.


Modifiktory ukazatel

   Turbo  C++  obsahuje  osm  modifiktor ovlivujcch opertor nepmho
            *
adresovn ( ), upravuj tedy ukazatele na njak data. Jsou to  near, far,
huge, _cs, _ds, _es, _seg a _es.

   V jazyku C lze  kompilovat  s  uitm  sedmi pam؟ovch model. Modelem,
jen  pouijete,  se   krom   jinho  ur  i  vnitn  formt  ukazatel.
Pouijete-li napklad mal datov model (drobn,  mal,  stedn), vechny
ukazatele  na  data  obsahuj 16- bitov ofset z registru datovho segmentu
(DS). Pouijete-li velk datov model  (kompaktn,  velk,  rozshl), jsou
vechny  ukazatele na data dlouh 32 bit a  poskytuj  adresu  segmentu  i
ofset.

   Nkdy pi  pouit datovho modelu s jedinou velikost chcete deklarovat
ukazatel  tak,  aby  byl  jin  velikosti  nebo  formtu, ne  je  aktuln
implicitn nastaven. Uin se to uitm modifiktor ukazatel.

   Hlub vysvtlen ukazatel near, far a huge naleznete na strnce  193 v
Kapitole 7. a  popis  normalizovanch  ukazatel  na strnce 195. Vce se o
_cs, _ds, _es, _seg a _ss v diskusi zanajc na strnce 201.


Modifiktory typu funkce

   Modifiktor near, far a huge lze rovnا pout  jako  modifiktor typu
funkce,  tj.  lze jimi upravovat funkce a  ukazatele  na  funkce,  jako  i
ukazatele na data. K prav funkc lze navc pout i modifiktor _export,
_loadds a _saveregs.

   Funkn modifiktory near,  far  a  huge  lze  kombinovat  s  cdecl nebo
pascal, nikoli vak s interrupt.

   Funkce  typu  huge  jsou  uiten  pi  propojovn  s kdem  v  jazyku
symbolickch adres, kter nepouv stejnho msta v pamti jako Turbo C++.




                                  - 58 - 


   Funkci, kter nen interrupt, lze deklarovat jako near,  far  nebo huge,
m se pedefinuj implicitn nastaven v aktulnm pam؟ovm modelu.

   Funkce near pov voln near; funkce far nebo  huge  pouv instrukc
pro voln far.

   V   drobnch,   malch    a   kompaktnch   pam؟ovch   modelech   jsou
nekvalifikovan  funkce  implicitn  typu  near.  Ve  stednch  a  velkch
modelech jsou  nekvalifikovan  funkce  implicitn  typu  far.  V rozshlm
pam؟ovm modelu jde o typ huge.

   Funkce huge je toton s funkc far.  Rozdl  je  pouze  v  tom,  e pi
vstupu do funkce  huge  se  registr  DS nastav na adresu datovho segmentu
zdrojovho modulu, zatmco v ppad funkce far zstane nenastaven.

   Modifiktor  _export  se  sice  syntakticky  analyzuje,  ale   jinak  se
ignoruje. Zajiuje kompatibilitu se zdrojovm  textem  napsanm  pro OS/2.
Pro  programy pod operanm systmem DOS  nem  modifiktor  _export  dn
vznam.

   Modifiktor _loadds zna, e funkce m nastavit registr DS, jak to in
funkce  rozshl {huge}, neimplikuje vak voln near  ani  far.  Proto  je
_loadds far ekvivalentn s huge.

   Modifiktor _saveregs zpsob, e funkce vechny hodnoty  registr ulo
a ped nvratem je obnov  (s vjimkou explicitnch zskanch hodnot, kter
se pedvaj v registrech jako teba AX nebo DX).

   Modifiktory _loadds a _saveregs jsou  uiten  pro  zpis standardnch
propojovacch podprogram na nzk rovni, nap. rutin pro podporu myi.


Sloit deklarace a deklartory
---------------------------------------------------------------------------

   V jednoduchch  deklaracch  se  udv  seznam  identifiktor  vzjemn
oddlench rkami, kter se uvd  za  nepovinnmi  specifiktory pam؟ov
tdy, specifiktory typu a jinmi modifiktory.

   Syntax deklartor naleznete v Tabulce 1.10 na strnce  39.  Definice se
tk deklarac identifiktor i funkc.

   Sloit  deklarace  pouv  seznamu  deklartor,  vzjemn  oddlench
rkami, kter nsleduje  za  rznmi specifiktory a modifiktory. V rmci
kadho  deklartoru existuje prv jeden identifiktor  -  ten,  kter  se
deklaruje. Kad z deklartor v seznamu pslu k vedoucmu specifiktoru
pam؟ov tdy a typu.

   Formt  deklartoru  zna,   jak   se   m   deklarovan   daj  dnazev
interpretovat  pi  pouit  ve  vrazu.  Uvaujme njak typ typ a  njak
specifiktor pam؟ov tdy specifikator tridy pameti. Nech D1  a  D2 jsou
njak dva deklartory. Potom deklarace

   specifikator tridy pameti typ D1, D2;

   zna, e kad vskyt D1 a  D2  v  njakm vrazu se oet jako objekt
typu  typ  a  pam؟ov tdy specifikator tridy pameti. Typem daje dnazev,
zabudovanho v  deklartoru, bude njak frze obsahujc typ, teba "typ",
"ukazatel  na  typ",  "pole typu", "funkce poskytujc typ" i "ukazatel na
funkci poskytujc typ" atd.


                                  - 59 - 


   Napklad v deklaracch
                         *        *
   int n, nao[], naf[3],  apn[], ( pan)[], &nr=n;
                *            *
   int f(void),  fnp(void), ( pfn)(void);

   by  bylo  mono  kad  deklartor  pout jako r-hodnotu  (v  nkterch
ppadech mon i jako l-hodnotu) ve vrazech, kam by patil  jedin objekt
int. Typy zabudovanch  identifiktor  se  ze  svch  deklartor odvozuj
takto:


                      Tab. 1.17: Sloit deklartory

-------------------------------------------------------------------------------------------
Syntax
deklartoru      Implikovan typ pro nzev                  Pklad
-------------------------------------------------------------------------------------------
typ nzev;       typ                                        int count;

typ nzev[];     (oteven) pole typu                       int count[];

typ nzev[3];    Pevn pole ze t prvk, vechny typu      int count[];
                 typ (nzev[0], nzev[1] a nzev[2])
    *                                                           *
typ  nzev       Ukazatel na typ                            int  count[];
    *                                                           *
typ  nzev[];    (oteven) pole ukazatel na typ           int  count[];
    *                                                           *
typ  (nzev[]);  Jako ve                                  int  (count[]);
     *                                                           *
typ ( nzev)[];  Ukazatel na (oteven) pole typu           int ( count)[];

typ &nzev[];    Odkaz na typ (jen v C++)                   int &count[];

typ nzev();     Funkce poskytujc typ                     int count();
    *                                                           *
typ  nzev();    Funkce poskytujc ukazatel na typ         int  count();
    *                                                           *
typ  (nzev());  Jako ve                                  int  (count());
     *                                                           *
typ ( nzev)();  Ukazatel na funkci poskytujc typ         int ( count)();
-------------------------------------------------------------------------------------------
                                *               *
   Nezapomete  na  zvorky  v ( nzev)[] a v  ( nzev)(),  nebo  priorita
deklartoru  pole  []  i deklartoru funkce  ()  je  vy  neli  priorita
                      *            *
deklartoru ukazatele  . Zvorky v  (nzev[]) povinn nejsou.



---------------------------------------------------------------------------
Ukazatele
---------------------------------------------------------------------------


   Diskusi odkazovn a nepmho odkazovn naleznete na strnce 85.





                                  - 60 - 


   Ukazatele  dlme do dvou hlavnch kategori:  ukazatele  na  objekty  a
ukazatele na funkce.  Oba  typy ukazatel pedstavuj speciln objekty, do
nich se ukldaj adresy pam؟ovch mst.

   Tyto  dv  tdy  ukazatel maj odlin vlastnosti, el a pravidla pro
manipulaci, pestoe nkter operace v Turbo C++ jsou pro n shodn. Obecn
se  d ci, e ukazatel na funkce se pouv pro pstup do funkc a  pro
pedvn funkc coby argument  do  jinch  funkc.  S ukazateli na funkce
nelze dlat dn aritmetick  kony.  Na druh stran se vak ukazatele na
objekty  pi prohlen pol i sloitjch  datovch  struktur  v  pamti
normln zvyuj nebo sniuj.

   Akoli ukazatele  obsahuj  sla  velmi  pipomnajc  cel  sla bez
znamnka, maj sv vlastn pravidla a omezen ohledn dosazovn, pevod a
aritmetiky. Tato pravidla a  omezen  ilustrujeme  na pkladech v nkolika
nsledujcch oddlech.


Ukazatele na objekty
---------------------------------------------------------------------------

   Ukazatel typu  "ukazatel na objekt typu" obsahuje adresu (neboli ukazuje
na...)  objektu  danho  typu. Jeliko i ukazatele jsou objekty, mete mt
ukazatel  na  njak  ukazatel (atd.). Mezi  objekty,  na  nا  se  obvykle
ukazuje, pat pole, struktury, uniony a tdy.

   Velikost ukazatel na objekty zvis na pam؟ovm modelu  a  velikosti a
monostech   datovch   segment,   je   lze  asto  ovlivnit  nepovinnmi
modifiktory ukazatel (diskutovanmi od strnky 58).


Ukazatele na funkce
---------------------------------------------------------------------------

   Ukazatel na funkci je nejlpe si pedstavit jako njakou adresu, obvykle
v kdovm segmentu, na n je  uloen  vkonn kd dan funkce, tj. adresu,
na ni se pi  vyvoln  funkce ped zen. Velikost a dispozice kdovho
segmentu je dna pouitm pam؟ovm modelem a z nich  zase  naopak  vyplv
velikost ukazatel na funkce, jich je k vyvoln funkc zapoteb.

   Ukazatel na funkci je typu "ukazatel na funkci poskytujc typ", kde typ
je typem zskan hodnoty z funkce.

   V rmci jazyka  C++,  kter  m  psnj kontrolu typ, m ukazatel na
funkci typ "ukazatel na funkci pebrajc argumenty typu typ a poskytujc
typ."  V  jazyku  C bude skuten  mt  njak  funkce  definovan  s  typy
argument tak tento u typ. Napklad
         *
   void ( func)();

   V  jazyku C jde o ukazatel na funkci, kter nic neposkytne. V jazyku C++
jde o ukazatel na funkci, kter nepebr dn argumenty a nic neposkytne.
V tomto pkladu ale
         *
   void ( func)(int);
      *
   je  func  ukazatelem na funkci, pebrajc argument int a neposkytujc
nic.




                                  - 61 - 


Deklarace ukazatel
---------------------------------------------------------------------------

   Podrobnosti o void naleznete na strnce 46.

   Ukazatel se mus deklarovat tak, aby ukazoval na njak konkrtn typ, i
kdyby tm typem byl void (co vlastn znamen ukazatel  na  cokoli).  Je-li
ji deklarovn, lze obvykle  do  ukazatele  znovu  dosadit, aby ukazoval na
njak  objekt jinho typu. Turbo C++ umouje  do  ukazatele  takto  znovu
dosadit  bez  petypovn,  ale  kompiltor  vs na to upozorn, ledae  by
ukazatel byl pvodn deklarovn jako ukazatel na void. A v jazyku C, nikoli
                             *                                      *
vak v C++, lze ukazatel void  dosadit do ukazatele, kter nen void .

   Je-li typ njakm peddefinovanm  nebo  uivatelsky  definovanm typem,
vetn void, deklarac
       *
   typ  ukaz;                       /* Pozor - neinicializovan ukazatel */

   se  deklaruje  ukaz  jako  typ  "ukazatel na typ." Na takto  deklarovan
objekt ukaz se vztahuj vechna pravidla prohlen, trvn a viditelnosti.

   Pozor ! Ped pouitm ukazatele je nutno jej inicializovat.

   Hodnotou przdnho {null} ukazatele je adresa, kter je zaruen odlin
od jakhokoli platnho pouvanho ukazatele v programu.  Hodnota przdnho
ukazatele se zsk dosazenm celoseln konstanty 0 do ukazatele.

   Pro  vt  srozumitelnost lze pouvat  mnemotechnick  konstanty  NULL
(definovan ve standardnch knihovnch souborech zhlav, jako je stdio.h).
Vechny ukazatele lze spn ovovat, zda se rovnaj i nerovnaj NULL.

   S przdnm ukazatelem nezamujte ukazatelov  typ  "ukazatel  na void".
Deklarac
        *
   void  vptr;

   se deklaruje, e vptr je generickm ukazatelem, do nj lze bez problmu
dosadit jakoukoli hodnotu "ukazatel na  typ",  vetn  przdnho ukazatele.
Dosazen mezi "ukazatelem na  typ1"  a "ukazatelem na typ2", jsou-li typ1 a
typ2 odlin, bez jejich  vhodnho  uren  me  vyvolat upozornn nebo i
chybu  kompiltoru. Je-li typ1 funkc a typ2  nikoli  (nebo  naopak),  jsou
vzjemn dosazen ukazatel neppustn.  Je-li  typ1  ukazatelem  na void,
dnho uren neteba. Je-li  v  jazyku C typ2 ukazatelem na void, dnho
uren nen zapoteb.

   Dosazovac omezen plat i pro ukazatele rozdlnch velikost (near, far
a  huge).  Men ukazatel lze dosadit do  vtho  bez  chyby,  nelze  vak
dosadit vt  ukazatel do menho, pokud se nepouije explicitnho uren.
Napklad
             *
   char near  ncp;
            *
   char far  fcp;
             *
   char huge  hcp;

   fcp = ncp;                                                  // ppustn
   hcp = fcp;                                                  // ppustn
   fcp = hcp;                                                // neppustn


                                  - 62 - 


   ncp = fcp;                                                // neppustn
                   *
   ncp = (char near )fcp;                             // nyn ji ppustn


Ukazatele a konstanty
---------------------------------------------------------------------------

   Ukazatelov objekt nebo objekt,  na  nj  se  ukazuje, lze deklarovat s
modifiktorem const. Potom do nj ale nelze dosadit nic, co  je deklarovno
jako const. Je rovnا neppustn  vytvoit  ukazatel,  kter  by nemonost
dosazovn do konstantnho objektu naruil. Zvate nsledujc pklady:

     int i;                        // i je celm slem
         *
     int   pi;                     // pi je (neinicializovanm) ukazatelem
                                   // na int
         *
     int   const cp = &i;          // cp je konstantnm ukazatelem na cel
                                   // slo

     const int ci = 7;             // ci je konstantnm celm slem
               *
     const int   pci;              // pci je ukazatelem na konstantn cel
                                   // slo
               *
     const int   const cpc = &ci;  // cpc je konstantnm ukazatelem na
                                   // konstantn cel slo

     Nsledujc dosazen jsou ppustn:

     i = ci;                       // Dosadit do celho sla celoselnou-
                                   // -konstantu
     *
      cp = ci;                     // Dosadit celoselnou-konstantu do
                                   // objektu-na-nj-ukazuje-konstantn-
                                   // -ukazatel

     ++pci;                        // Zvit o 1 ukazatel-na-konstantu

     pci = cpc;                    // Dosadit konstantn-ukazatel-na-
                                   // -konstantu do ukazatele-na-
                                   // -konstantu

     Nsledujc dosazen jsou neppustn:

     ci = 0;                       // NElze dosazovat do celoseln-
                                   // -konstanty

     ci--;                         // NElze zmnit celoselnou-konstantu
     *
      pci = 3;                     // NElze dosazovat do objektu, na nj
                                   // ukazuje ukazatel-na-konstantu

     cp = &ci;                     // NElze dosazovat do konstantnho-
                                   // -ukazatele, ani kdy se hodnota
                                   // nezmn

     cpc++;                        // NElze zmnit konstantn-ukazatel



                                  - 63 - 


     pi = pci;                     // NE - kdyby takov dosazen bylo
                                   // ppustn, mohli byste dosazovat do
                                      *
                                   //  pci (konstantn hodnoty) dosazenm
                                         *
                                   // do  pi.

     Podobn pravidla plat pro modifiktor volatile. Uvdomte si, e const
i   volatile   se   spolen   mohou   objevit   jako   modifiktory  tho
identifiktoru.


Aritmetika s ukazateli
---------------------------------------------------------------------------

   Pouit intern aritmetika pro  ukazatele  zvis  na  zadanm pam؟ovm
modelu a na ptomnosti modifiktor, kter ukazatel pedefinuj.

   Aritmetika  s ukazateli je omezena na  stn,  odtn  a  porovnn.
Aritmetick  operace  s  objekty  ukazatel  typu "ukazatel na  typ"  berou
automaticky v vahu velikost  typu;  tj.  poet  byt, potebnch k uloen
objektu typ.

   Rozdl  mezi dvma ukazateli m smysl jen  tehdy,  ukazuj-li  oba  tyto
ukazatele do stejnho pole.

   Pi vykonvn aritmetickch operac s ukazateli se pedpokld, e dan
ukazatel ukazuje na njak  pole  objekt.  Proto je-li ukazatel deklarovn
tak, e ukazuje na typ, pitenm celoseln hodnoty k tomuto ukazateli se
ukazatel  pemst  dle  o tento poet  objekt  danho  typu.  M-li  typ
velikost 10 byt, pak pitenm celho sla 5 k njakmu ukazateli  na typ
se  tento  ukazatel  pemst v pamti o 50 byt. Hodnotou rozdlu je poet
prvk pole, oddlujcch dan dv hodnoty  ukazatele.  Ukazuje-li napklad
ukaz1  na  tet  prvek  njakho  pole  a  ukaz2  ukazuje na prvek dest,
vsledkem ukaz2 - ukaz1 bude 7.

   Jestlie se k ukazateli "ukazatel na typ" pite nebo od nj odete cel
slo, je vsledek opt typu "ukazatel na typ". Nen-li typ  objektem pole,
s ukazatelovm operandem se  zachz  jakoby to byl ukazatel na prvn prvek
"pole typu" dlky sizeof (typ).

   Samozejm  e  neexistuje  dn  prvek  "ukazatel  na  prvek tsn  za
poslednm  prvkem",  avak   ukazatel  sm  takovou  hodnotu  pedpokldat.
Ukazuje-li  P  na  posledn  prvek  pole,  je  P+1  ppustn, ale P+2 nen
definovno. Ukazuje-li P na prvek tsn za poslednm prvkem  pole,  je  P-1
ppustn  a  pemst  ukazatel  na  posledn  prvek.  Aplikace  opertoru
                     *
nepmho adresovn   na  "ukazatel  na  prvek  tsn za poslednm prvkem"
vak vede k nedefinovanmu chovn.

   Neformln lze P+1 chpat jako  pemstn ukazatele o (n * sizeof(typ))
byt, dokud ukazatel  zstv  uvnit ppustnho rozsahu (od prvnho prvku
a po prvek tsn za poslednm prvkem).

   Odetenm  dvou  ukazatel  na  prvky  stejnho  objektu  pole se  zsk
celoseln hodnota  typu ptrdiff_t, definovan v stddef.h (signed long pro
rozshl  a  vzdlen  ukazatele,  signed  int  pro  vechny  ostatn).  Za
pedpokladu, e je v rozsahu  ptrdiff_t,  pedstavuje  tato  hodnota rozdl
mezi  indexy  danch dvou prvk pole. Ve vrazu P1 - P2, kde P1 a  P2  jsou
typu ukazatel na typ (nebo ukazatel na kvalifikovan  typ),  mus  P1  i P2


                                  - 64 - 


ukazovat  na  existujc  prvky  nebo  na prvek tsn za prvkem  poslednm.
Ukazuje-li P1 na i- t prvek a P2 ukazuje  na  prvek  j-  t,  m  P1  - P2
hodnotu (i - j).


Pevody ukazatel
---------------------------------------------------------------------------

   Typy ukazatel lze pevdt na  jin  typy  ukazatel  uitm mechanismu
petypovn:
        *
   char  str;
       *
   int  ip;
               *
   str = (char  )ip;
                                *
   eeno obecnji, urenm (typ ) se  ukazatel pevede na typ "ukazatel na
typ."


Odkazov deklarace v C++
---------------------------------------------------------------------------

   Referenn typy v C++  zce  souvis  s  typy ukazatel. Referenn typy
{reference  type}  vytvej  nhradn  nzvy  {alias}  objekt  a umouj
pedvat argumenty do funkc odkazovnm. V tradinm jazyku C se argumenty
pedvaj pouze hodnotou. V jazyku C++ lze argumenty pedvat hodnotou nebo
odkazem.  Vechny  podrobnosti   naleznete   na   strnce   105   v  oddlu
"Odkazovn".
































                                  - 65 - 
































































                                  - 66 - 








                            K a p i t o l a   2

                         Pravidla struktury frz


   Tato kapitola poskytuje formln  definici  pravidel  struktury  frz v
Turbo C++.  Pravidla  struktury  frz  podrobn  uruj  ppustn zpsoby
seskupovn lexiklnch  prvk za elem sestaven vraz, pkaz a jinch
platnch  jednotek.  Na  rozdl  od  toho se lexikln pravidla (popsan  v
Kapitole  1.)  zabvaj  rznmi  kategoriemi  slovm  podobnch  jednotek,
nazvanch lexikln prvky, kter dan jazyk rozeznv.



---------------------------------------------------------------------------
Pole
---------------------------------------------------------------------------


   Deklarac

   typ deklartor [<konstantn-vraz>]

   se deklaruje pole sloen z prvk danho typu. Pole pozstv ze spojit
oblasti  pamti, kter je pesn tak velk, aby se do n vely vechny jeho
prvky.

   Je-li v deklartoru pole  zadn  njak  vraz,  mus se vyhodnotit jako
kladn  konstantn cel slo. Jeho hodnota znamen  poet  prvk  v  poli.
Vechny prvky pole se sluj od 0 do potu prvk minus jedna.

   Vcerozmrn  pole  se  konstruuj  deklarovnm  pol   z   typ  pole.
Dvourozmrn pole z pti dk  a  sedmi  sloupc  s  nzvem  alfa  se tedy
deklaruje takto:

   typ alfa [5] [7];

   Za  jistch   okolnost  nemus  mt  prvn  deklartor  pole  z  njak
posloupnosti v lomench zvorkch dn  vraz.  Takov  pole  m neurenou
velikost. Je to ppustn za okolnost, kdy nen zapoteb velikosti pole k
vyhraen prostoru. Tak napklad deklarace  extern  njakho  objektu typu
pole  nepotebuje  ani  pesn rozmr pole, ani funkn parametr pole. Jako
speciln rozen normy  ANSI  C  pipout  jazyk  Turbo  C++  tak pole
neuren dlky coby posledn  len  njak  struktury. Takov pole nezvt
velikost struktury, ledae by  se  pidala  vpl kvli zajitn sprvnho
zarovnn takovho pole. Tchto struktur  se  normln  uv  v dynamickm
pidlovn pamti. K velikosti struktury  se  pak  mus  explicitn pidat
potebn velikost skutenho pole, aby se prostor vyhradil sprvn.

   S vjimkou, kdy jde o operand k opertoru sizeof nebo  &,  se vraz typu
pole pevd na konstantn ukazatel na prvn prvek pole.





                                  - 67 - 


---------------------------------------------------------------------------
Funkce
---------------------------------------------------------------------------


   Tاit  programovn  v  jazyku C i C++ pedstavuj funkce. Jazyky jako
teba Pascal rozliuj mezi procedurou a funkc. Funkce v  Turbo  C++  vak
zvldne role obou.


Deklarace a definice
---------------------------------------------------------------------------

   V kadm programu mus bt jedna extern funkce s nzvem  main {hlavn},
oznaujc  msto  vstupu  do programu. Funkce se  obvykle  deklaruj  jako
prototypy ve standardnch  nebo uivatelsky definovanch souborech zhlav,
resp. uvnit programovch soubor. Funkce jsou implicitn external {vnj}
a normln jsou dostupn ze vech soubor v programu. Lze je  omezit uitm
specifiktoru pam؟ov tdy static (viz strnku 36).

   Funkce  se  definuj  ve  zdrojovch  souborech  nebo   se  zpstupuj
pipojenm pedem kompilovanch knihoven.

   V  C++ se mus vdy pout prototyp  funkc.  Doporuujeme  vm  jejich
pouvn i v jazyku C.

   Uritou funkci lze v njakm  programu  deklarovat  i  nkolikrt, pokud
jsou takov deklarace kompatibiln. Nedefininmi deklaracemi funkc, kter
uvaj formtu prototypu  funkce,  se poskytnou systmu Turbo C++ podrobn
informace  o  parametrech.  Tm  se  umon  lep  zen  kontroly  potu
argument i typu, jako i pevod typ.

   Aby v C++  nedolo  k  pepsn  funkce, pipout se pro kadou uritou
funkci jen jedin  definice.  Deklarace, pokud existuj, mus tto definici
rovnا vyhovovat. (Zkladn rozdl mezi definic a deklarac spov v tom,
e definice obsahuje tlo funkce.)


Deklarace a prototypy
---------------------------------------------------------------------------

   V  pvodnm  stylu  deklarace podle Kernighana a  Ritchieho  bylo  mono
funkci  deklarovat  implicitn  jejm vskytem ve voln  funkce,  nebo  ji
deklarovat explicitn takto:

   <typ> func()

   V C++ takov deklarace znamen <typ> func(void).

   typ pedstavuje nepovinn zadvan  typ  vsledku,  kter  je implicitn
int.  Funkci  lze  deklarovat, aby poskytovala jakkoli typ s vjimkou typu
pole nebo funkce. Takov pstup kompiltoru nedovoluje kontrolovat, jestli
typ nebo poet uitch argument ve funkci souhlas s deklarac.

   V integrovanm prosted IDE nebo  v kompiltoru s pkazovm dkem lze
zadit upozornn: "Function called without a prototype" = "Vol se funkce
bez prototypu".

   Problm   se  zjednoduil  zavedenm  prototyp  funkc  s   nsledujc
deklaran syntax:


                                  - 68 - 


   <typ> func(seznam-parametr-a-deklartor);

   Deklartory specifikuj typy vech  parametr  funkce.  Tchto informac
vyuv kompiltor ke kontrole  sprvnosti  pi  voln  funkc. Kompiltor
tak doke argumenty do sprvnho tvaru nadit. Uvaujme nsledujc sek
zdrojovho textu:

   long lmax(long v1, long v2);                              /* prototyp */

   main()
   {
      int limit = 32;
      char ch = 'A';

      long mval;

      mval = lmax(limit, ch);                           /* voln funkce */
   }

   Jeliko   existuje   prototyp   funkce   lmax,  pevede  program  uitm
standardnch  pravidel  pro  dosazovn  promnn  limit a ch na typ  long.
Teprve potom je  umst  do  zsobnku  pro  voln  lmax.  Nebt prototypu
funkce,  umstily  by se limit a ch do zsobnku jako cel  slo  a  znak.
Potom by ale zsobnk, pedan do lmax, nesouhlasil velikost i  obsahem s
tm, co funkce lmax oekv  a  vedlo  by  to  k  problmm.  Klasick styl
deklarac dnou  kontrolu  typu  nebo  potu  parametr  nedovoluje, take
pouvn prototyp funkc vznamn pispv k nalezen chyb v programu.

   Prototypy funkc rovnا pomhaj  dokumentovat  zdrojov  text programu.
Napklad funkce strcopy  pejm  dva parametry: zdrojov etzec a clov
etzec. Otzkou ale je, kter je kter ? Prototyp funkce
        *             *          *
   char  strcopy(char  cil, char  zdroj);

   to vyjasn. Obsahuje-li soubor zhlav prototypy funkc, pak vytisknutm
takovho  souboru  zskte  velkou  st  informac  potebnch  k  napsn
program,  v  nich  se  tyto  funkce  volaj.  Zahrne-li se  do  parametru
prototypu njak identifiktor,  vyuije  se  jen  v  ppadnch pozdjch
hlench o chybch, tkajcch se tohoto parametru. Jin inek nem.

   Deklartor funkce se zvorkami obsahujcmi jedin  slovo  void oznauje
funkci, kter nepejm vbec dn argumenty:

   func(void);

[C++]
   V  C++  se  funkce nepejmajc vbec dn  argumenty  deklaruje  tak
tvarem func().

   V stdarg.h  jsou obsaeny makroinstrukce, jich lze vyut v uivatelsky
definovanch funkcch s promnnmi poty parametr.

   Prototypem funkce se normln deklaruje njak funkce, pejmajc pevn
poet parametr. V ppad funkc  pejmajcch  promnn  poet parametr
(jako  teba  printf),  me  prototyp  funkce   konit   vpustkou  (...).
Napklad:
         *
   f(int  pocet, long soucet, ...)




                                  - 69 - 


   Jde-li o  takov prototyp, kontroluj se bhem kompilace pevn parametry
a promnn parametry se pedvaj bez kontroly typu.

   Pinme nkolik ukzek deklarac a prototyp funkc:
   int f();                    /* V C jde o funkci, poskytujc cel slo,
                  kter nem dn informace o parametrech. Je
                  to "klasick styl" podle K&R. */

   int f();                          /* V C++ jde o funkci bez argument */

   int f(void);      /* Funkce poskytujc cel slo a nepejmajc dn
               parametry */

   int p(int, long);     /* Funkce poskytujc cel slo a pejmajc dva
               parametry: prvn je celoseln, druh je dlouh
               */

   int pascal q(void);   /* Funkce v jazyku Pascal, poskytujc cel slo,
               nepejm vbec dn argumenty */
            *       *
   char far  s(char  zdroj, int druh);       /* Funkce poskytujc vzdlen
            ukazatel na znak a pejmajc dva parametry: prvnm je
            ukazatel na znak, druhm je cel slo. */
                   *
   int printf(char  format,...);         /* Funkce poskytujc cel slo a
                        pejmajc jako pevn parametr
                        ukazatel na cel slo, jako i
                        libovoln poet dalch parametr
                        neznmch typ */
        *
   int ( fp)(int);       /* Ukazatel na funkci, kter poskytne cel slo a
               pejm jedin celoseln parametr. */


Definice
---------------------------------------------------------------------------

   Nsledujc tabulka pin obecnou syntaxi definic externch funkc:


                    Tab. 2.1: Definice externch funkc

--------------------------------------------------------------------------------
soubor
     extern-definice
     soubor extern-definice

     extern-definice:
     definice-funkce
     deklarace
     pkaz-asm

definice-funkce:
     <deklaran-specifiktory> deklartor <seznam-deklarac> sloen-pkaz
--------------------------------------------------------------------------------

   Definice funkce obecn pozstv z  nsledujcch  oddl  (je pravidla
pipout ve sloitjch ppadech):

   Prvky z 1. a 2. lze vzjemn smovat.


                                  - 70 - 


   1.  Nepovinn   specifiktory   pam؟ov   tdy:  extern  nebo  static.
       Implicitnm je extern.

   2.  Typ vsledku, ppadn void. Implicitnm je int.

   3.  Nepovinn  modifiktory: pascal, cdecl, interrupt, near, far,  huge.
       Implicitn daje zvis na pam؟ovm modelu a  nastaven alternativy
       kompiltoru.

   4.  Nzev funkce

   5.  Seznam deklarac parametr, kter me  bt  i  przdn,  uzaven v
       zvorkch.  V  jazyku  C  se  ke zdraznn przdnho  seznamu  dv
       pednost tvaru func(void). Star styl  func() je v C sice ppustn,
       ale je zastaral a nemus bt bezpen. V jazyku C++  byste obdreli
       upozornn.

   6.  Tlo  funkce, pedstavujc kd, kter se  m  pi  vyvoln  funkce
       vykonat.


Deklarace formlnch parametr
---------------------------------------------------------------------------

   Seznam deklarac formlnch  parametr  se  d  podobnou  syntax jako
deklartory, kter se vyskytuj  v  deklaracch  normlnch identifiktor.
Pinme nkolik ukzek:

   int func(void) {                                        // bez argument

[C++]
   int func(T1 t1, T2 t2, T3 t3=1) {                      // ti jednoduch
                              // parametry, jeden s
                           // implicitnm argumentem

[C++]
              *
   int func(T1  ptrl, T2& tref) {                 // ukazatelov a odkazov
                              // argument

   int func(register int i) {             // vydn registru pro argument
                 *
   int func(char  str,...) {        /* jeden etzcov argument s promnnm
         potem argument dalch nebo s pevnm potem argument s
         promnnmi typy */

   V  jazyku  C++  lze  zadat,  jak jsme pedvedli,  implicitn  argumenty.
Parametry s  implicitnmi hodnotami mus bt poslednmi argumenty v seznamu
parametr. Typy tchto argument mohou  bt  skalry,  struktury,  uniony a
vty. Dle jimi mohou bt ukazatele i odkazy na struktury a uniony, resp.
ukazatele na funkce nebo tdy.

   Vpustka (...) zna, e funkce se bude volat pi rznch pleitostech
s  rznmi  mnoinami  argument. Vpustku lze uvdt  za  dlm  seznamem
deklarac znmch argument. Takovm tvarem prototypu se ale sniuje rozsah
kontroly, kterou me kompiltor vykonat.

   Deklarovan  parametry obdr automatick obor a  trvn  po  dobu  dan
funkce. Jedinm ppustnm specifiktorem pam؟ov tdy je register.



                                  - 71 - 


   S deklartory  formlnch  argument  lze  pout  modifiktor  const a
volatile.


Voln funkc a pevody argument
---------------------------------------------------------------------------

   Funkce se volaj se skutenmi argumenty, kter se  vkldaj  ve stejnm
poad jako jim  odpovdajc  argumenty  formln.  Skuten  argumenty se
pevdj jako v ppad inicializace formlnch  argument  na deklarovan
typy.

   Uvdme souhrn pravidel, podle nich Turbo C++ zachz pi voln funkc
s jazykovmi modifiktory a formlnmi parametry, a u  s  prototypy, nebo
bez nich:

   1.  Pi vech volnch funkce mus  jazykov  modifiktory  pro definici
       funkce odpovdat modifiktorm, pouitm v deklaraci funkce.

   2.  Funkce sm  upravit hodnoty svch formlnch parametr, nem to vak
       dn  vliv  na  skuten  argumenty  ve  volajc  rutin.  Vjimku
       pedstavuj odkazov argumenty v C++

   Pokud  nebyl  prototyp  funkce  deklarovn  pedem,  pevede  Turbo  C++
celoseln argumenty pro voln funkce podle  pravidel  roziovn celch
sel.  Popsali  jsme  je  v  oddlu "Standardn pevody",  zanajcm  na
strnce 48. Kdy se prototyp funkce nachz v danm  oboru,  pevede  Turbo
C++ zadan argumenty na typy deklarovanch argument jako pi dosazovn.

   Kdy prototyp  funkce obsahuje vpustku (...), pevede Turbo C++ vechny
zadan argumenty funkce jako  v  kadm  jinm  prototypu (a po vpustku).
Kompiltor vechny argumenty uveden  za  pevnmi  parametry  roz podle
normlnch pravidel pro argumenty funkc bez prototyp.

   Je-li k dispozici prototyp, mus  poet argument souhlasit (ledae by v
prototypu byla vpustka). Typy mus bt kompatibiln jen v takovm rozsahu,
aby se pi dosazovn daly ppustn pevdt. K pevodu njakho argumentu
na typ pijateln pro prototyp funkce lze kdykoli ut explicitnho uren.

Dleit!
   Neodpovd-li prototyp funkce skuten  definici  funkce,  Turbo  C++ to
zjist  prv tehdy, nachz-li se tato  definice  ve  stejnm  kompilanm
unitu jako prototyp. Pokud vytvote  knihovnu  standardnch  podprogram s
odpovdajcm  souborem  zhlav  prototyp,  zvate vloen tohoto souboru
zhlav pi kompilaci  knihovny.  Odhal se tm jakkoli nesrovnalosti mezi
prototypy  a  skutenmi  definicemi.   C++   disponuje   zase  spojovnm,
zachovvajcm typy, take rozdly mezi oekvanmi a  skutenmi parametry
zachyt spojovac program.



---------------------------------------------------------------------------
Struktury
---------------------------------------------------------------------------


   Inicializaci struktur jsme diskutovali na strnce 49.





                                  - 72 - 


   Struktura je odvozenm typem, obvykle pedstavujcm njakou uivatelsky
definovanou kolekci vyjmenovanch len (neboli sloek).  Jej  leny mohou
bt  jakhokoli typu, a ji fundamentlnho  nebo  odvozenho  (s  jistmi
omezenmi, o nich  se  zmnme  pozdji)  a mohou bt v libovolnm poad.
len  struktury  navc  me bt typu  bitov  poloky,  kter  jinde  nen
ppustn.  Typ  struktura  v  jazyku  Turbo  C++  umouje manipulovat  se
sloitmi  datovmi  strukturami  tm  tak  snadno,  jako  s jednoduchmi
promnnmi.

   V  jazyku C++ se s typem struktura zachz jako s typem tda (s jistmi
rozdly: Implicitn pstup  je  veejn  {public}  a  implicitn nastaven
bzov  tdy  je  rovnا  veejn).  Umouje  se  tm dmyslnj  zen
pstupu do  len  struktury  uitm  specifiktor  pstupu  jazyka C++:
public   (implicitn),  private  a  protected.  Krom  tchto   volitelnch
pstupovch mechanism a podmnek, na nا jsme upozornili, se na syntaxi a
pouit struktur vztahuje nsledujc diskuse.  Tk se struktur v jazyku C
stejn jako v C++.

   Struktury se deklaruj uitm klovho slova struct. Napklad

   struct mojestrukt { ... };               // mojestrukt je oznaenm dan
                           // struktury
   ...
                        *
   struct mojestrukt s,  ps, arrs[10];
   /*  s je typu struktura mojestrukt; ps je  typu  ukazatel  na  strukturu
mojestrukt; arrs je polem struktury mojestrukt. */


Neoznaen struktury a definice typ typedef
---------------------------------------------------------------------------

   Vynechte-li oznaen  struktury,  mete  zskat  strukturu neoznaenou
{untagged}. Neoznaench struktur lze pout k  deklaraci  identifiktor v
seznamu   seznam-strukt-id,  oddlench  rkami,  aby  byly  danho   typu
struktury  (nebo  od  nj odvozenho). Dal objekty tohoto typu vak nelze
deklarovat kdekoli:

   leny neoznaench struktur a union se bhem inicializace ignoruj.
                     *
   struct { ... } s,  ps, arrs[10];                 // neoznaen struktura
   Pi deklarovn struktury, a  ji  s  oznaenm  nebo bez, lze vytvoit
typedef:

   typedef struct mojestrukt { ... } MOJESTRUKT;
                 *
   MOJESTRUKT s,  ps, arrs[10];       // tot jako struktura mojestrukt s,
                     // atd.
   typedef struct { ... } TVSTRUKT;                         // bez oznaen
               *
   TVSTRUKT y,  yp, arry[20];

   Obvykle  nen  zapoteb  oznaen  i  typedef  souasn:   V  deklaraci
struktury pouvejte jednoho z nich.








                                  - 73 - 


Deklarace len struktury
---------------------------------------------------------------------------

   Typy a  nzvy len struktury se deklaruj seznamem seznam-dekl-len ve
sloench zvorkch. Uv se pi tom syntaxe deklartor z Tabulky 1.11 na
strnce 40.

   len struktury me bt jakhokoli typu. Existuj ale dv vjimky:

   1.  Typ  lenu  nesm  bt shodn s  typem  struct,  kter  se  aktuln
       deklaruje:

       struct mojestrukt { mojestrukt s } s1, s2;                  // nelze

       V C++ lze klov slovo struct vynechat.

       Jak  ukeme v nsledujcm pkladu, lenem  sm  bt  ukazatel  na
       strukturu, kter se deklaruje:
                                      *
       struct mojestrukt { mojestrukt  ps }s1, s2;                    // OK

       Dle,  pi  deklaraci  njak  instance  deklarovan  struktury  sm
       struktura obsahovat dve definovan typy struktur.

   2.  S vjimkou  jazyka C++ neme bt len typu "funkce poskytujc...".
       Typ "ukazatel na funkci poskytujc..." se ale pipout. V C++ me
       mt struct lensk funkce.


Struktury a funkce
---------------------------------------------------------------------------

   Funkce me poskytnout typ struktura nebo ukazatel na typ struktura:

   mojestrukt func1(void);                    // func1() poskytne strukturu
              *
   mojestrukt  func2(void);       // func2() poskytne ukazatel na strukturu

   Strukturu lze jako argument pedat do funkce nsledujcm zpsobem:

   void func1(mojestrukt s);                                       // pmo
                         *
   void func2(mojestrukt  sptr);               // prostednictvm ukazatele
   void func3(mojestrukt &sref);                  // jako odkaz (jen v C++)


Pstup do len struktury
---------------------------------------------------------------------------

   leny struktur  a union se zpstupuj pouitm vbrovch opertor .
a ->. Dejme tomu,  e  objekt  s  je  strukturnho  typu  S  a  e  sptr je
ukazatelem na S. Je-li  potom  m identifiktor lenu typu M deklarovanho v
S, jsou vrazy  s.m i sptr->m typu M. Oba pedstavuj lensk objekt m v s.
                                         *
Vraz s->sptr je vhodnm synonymem pro ( sptr).m.

   Opertor  .  se nazv pm selektor lenu  a  opertor  ->  se  nazv
nepm (nebo t ukazatelov) selektor lenu. Napklad

   struct mojestrukt {


                                  - 74 - 


      int i;
      char str[21];
      double d;
        *
   } s,  sptr=&s;
   ...
   s.i = 3;                   // dosazen do lenu i struktury mojestrukt s
   sptr->d = 1.23;            // dosazen do lenu d struktury mojestrukt s

   Za pedpokladu, e s nen l-hodnotou  a  m  nen typu pole, je vraz s.m
l-hodnotou. Vraz sptr->m je l-hodnotou, pokud m je typem pole.

   Jestlie struktura B obsahuje pole, jeho typ je strukturou A, lze leny
A zpstupnit dvojm pouitm selektor len:

   struct A {
      int j;
      double x;
   }

   struct B {
      int i;
      struct A a;
      double d;
        *
   } s,  sptr;
   ...
   s.i = 3;                              // dosadit do i, kter je lenem B
   s.a.j = 2;                            // dosadit do j, kter je lenem A
   sptr->d = 1.23;                       // dosadit do d, kter je lenem B
   (sptr->a).x = 3.14                    // dosadit do x, kter je lenem A

   Kadou deklarac struktury se zavd jednoznan typ struktura, take ve

   struct A {
      int i, j;
      double d;
   } a, a1;

   struct B {
      int i, j;
      double d;
   } b;

   jsou objekty a i a1 oba typu struktura A, ale objekty a a b jsou rznch
typ struktura.  Do  struktur  lze  dosazovat  pouze  kdy zdroj i cl jsou
stejnho typu:

   a = a1;                      // OK: stejn typ, tedy dosazen po lenech
   a = b;                                              // NELZE: rzn typy
   a.i = b.i; a.j = b.j; a.d = b.d   /* lze vak dosazovat len po lenu */


Zarovnn slov ve strukturch
---------------------------------------------------------------------------

   Strukturm  se  pidluje  pam؟ len po lenu, zleva doprava, smrem od
nich k vym pam؟ovm adresm. V ukzce

   struct mojestrukt {


                                  - 75 - 


      int i;
      char str[21];

      double d;
   } s;

   zabr objekt s pam؟ dostatenou k tomu, aby se do  n  velo 2- bytov
cel  slo, 21- bytov etzec a 8- bytov  slo  s  dvojitou  pesnost.
Formt tohoto objektu v pamti se ur alternativou zarovnn slov  v Turbo
C++.  Je-li   tato  alternativa  vypnuta  (implicitn),  pidl  se  s  31
souvislch  byt. Zapnete-li alternativou kompiltoru -a (resp.  dialogovm
rmekem Options | Compiler |  Code  Generation)  zarovnvn  slov, napln
Turbo  C++  byty  do  struktury  tak,  aby  se zajistilo  jej  nsledujc
zarovnn:

   1.  Struktura bude zanat na hranici slova (sud adresa).

   2.  Vechny leny, kter nejsou  char,  budou mt ofset na sudm bytu od
       zatku struktury.

   3.  Je-li teba, na konec  se  pid  zvren  byte pro zajitn, aby
       cel struktura obsahovala sud poet byt.

   Pi  zapnutm  zarovnvn  slov by nae struktura tedy mla ped double
dodaten byte a vznikl by objekt o 32 bytech.


Prostory pro nzvy struktur
---------------------------------------------------------------------------

   Nzvy oznaen struktur  sdlej  stejn prostor pro nzvy jako oznaen
union a oznaen  vt  (v  C++  jsou  vak vty enum, kter jsou uvnit
struktur, v jinm prostoru pro nzvy). Znamen to, e takov  oznaen mus
bt v  tme  oboru  jednoznan.  Nzvy  oznaen  se vak nemus liit od
identifiktor  v jinch tech prostorech pro  nzvy:  prostoru  pro  nzvy
nvt,  prostoru(ech) pro nzvy len a  prostoru  pro  jednoduch  nzvy
(pozstvajc z promnnch, funkc, nzv typedef a vt).

   Nzvy  len uvnit dan struktury nebo  unionu  mus  bt  jednoznan,
mohou  se  vak krt s nzvy len  v  jinch  strukturch  nebo  unionech.
Napklad

   goto s;
   ...
   s;
   struct s {                // OK: prostory nzvu oznaen a nvt rzn
      int s;          // OK: prostory nzvu nvt, oznaen a lenu rzn
      float s;                              // NELZE: duplicita nzvu lenu
   } s;      // OK: prostor nzvu promnn rzn. V C++ lze toto uinit jen
         // tehdy, m-li s njak konstruktor

   union s {                      // NELZE: duplicita prostoru pro oznaen
      int s;                                   // OK: nov prostor pro len
      float f;
   } f;                                       // OK: prostor nzvu promnn

   struct t {
      int s;                                  // OK: rzn prostor pro len
   ...
   } s;                                  // NELZE: duplicita nzvu promnn


                                  - 76 - 


Nepln deklarace
---------------------------------------------------------------------------

   Je  ppustn,  aby se ukazatel na njak  typ  struktury  A  objevil  v
deklaraci jin struktury B jet ped deklarac struktury A:

   struct A;                                                     // nepln
                       *
   struct B { struct A  pa };
                       *
   struct A { struct B  pb };

   O prvnm vskytu A ekneme, e je nepln,  nebo  v  tomto  mst chyb
jej definice. V takovch situacch se nepln deklarace pipout, protoe
definice B nepotebuje znt velikost A.


Bitov poloky
---------------------------------------------------------------------------

   Struktura  sm  obsahovat  jakoukoli  sms  typ  bitovch  a nebitovch
poloek.

   Celoseln leny signed  i  unsigned lze deklarovat jako bitov poloky
irok od 1 do 16 bit. Bitov poloka se uruje volitelnm identifiktorem
takto:

   specifiktor-typu <id-bitpol> : ka;

   kde specifiktor-typu je char, unsigned  char,  int  nebo  unsigned int.
Bitov poloky se pidluj uvnit slova smrem od nich k  vym bitm.
Vraz ka se mus zadvat a mus se vyhodnotit jako konstantn cel slo
v rozsahu 0 a 16.

   Vynechte-li identifiktor bitov poloky, pidl se poet  bit uren
v ce, avak poloka nebude  pstupn. Tm se umon srovnvn bitovch
vzork teba s fyzickmi  registry,  v  nich  jsou nkter bity nevyuit.
Napklad struktura

   struct mojestrukt {
      int      i : 2;
      unsigned j : 5;
      int        : 4;
      int      k : 1;
      unsigned m : 4;
   } a, b, c;

   vytvo nsledujc pravu:

    Ŀ
     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
    Ĵ
      x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x
    Ĵ
    <><><- - - - - - -><><>
    Ĵ
           m        k   (nevyuito)           j            i   
    




                                  - 77 - 


   Celoseln poloky se ukldaj ve  tvaru  dvojkovho  doplku,  kdy bit
zcela  vlevo  je  MSB ('most significant bit' = bit s nejvy hodnotou). V
ppad bitovch poloek int  (napklad  signed)  se MSB interpretuje jako
bit  znamnkov. Bitov poloka ky 2, v n je binrn 11, se tud bude
interpretovat  v  ppad  unsigned  jako  3,  ale  v  ppad int jako -1.
Vrtme-li  se  k pedchozmu pkladu, platn dosazen  a.i  =  6  by  bez
upozornn zanechalo  v  a.i  binrn  hodnotu 10 = -2. Poloka k o ce 1
typu int se znamnkem me obsahovat  pouze  hodnoty -1 a 0, jeliko bitov
vzorek 1 se interpretuje jako -1.

Pamatujte!
   Bitov poloky  lze deklarovat jenom ve strukturch, unionech a tdch.
Zpstupuj se stejnmi selektory len (. a ->), jak  se  pouvaj  pro
leny,  je  bitovmi  polokami  nejsou.  Pi  psan  penosnch  program
vyvolvaj bitov poloky urit problmy, nebo organizace bit v bytech a
byt ve slovech zvis na jednotlivch potach.

   Je-li   x   identifiktor  bitov  poloky,   je   vraz   &mojestrukt.x
neppustn. Nen zde toti zruka, e mojestrukt.x le na adrese bytu.



---------------------------------------------------------------------------
Uniony
---------------------------------------------------------------------------


   Uniony odpovdaj typm zznam  s  promnnou  dlkou  v jazyku Pascal a
Modula-2.

   Typ  union  je  odvozenm typem, kter sdl mnoh syntaktick i funkn
vlastnosti typu struktura. Klov rozdl  spov v tom, e union dovoluje
vdy jen jednomu  ze  svch  len,  aby byl "aktivn". Velikost unionu je
velikost jeho nejvtho lenu. Uloit lze vdy jen hodnotu jedinho z jeho
len. V nsledujcm jednoduchm ppad

   union mujunion {                        /* oznaen unionu = mujunion */
      int i;
      double d;
      char ch;
         *
   } mu,  muptr=&mu;

   lze ut identifiktor mu, kter je typu union mujunion,  k  uloen  2-
bytovho  int,  8-  bytovho double nebo jednobytovho char, avak vdy jen
jednoho z nich.

   Jak  sizeof(union mujunion), tak i sizeof(mu) poskytne  8.  Je-li  v  mu
uloen objekt int, je ale 6 byt nevyuito (vyplnno). Obsahuje-li mu char,
je nevyuito 7 byt. leny union se zpstupuj selektory len struktury
(. a ->), je vak zapoteb opatrnosti:

   mu.d = 4.016;
   printf("mu.d = &f\n", mu.d);                 // OK: zobraz mu.d = 4.016
   printf("mu.i = &d\n", mu.i);                      // specifick vsledek
   mu.ch = 'A';
   printf("mu.ch = &c\n", mu.ch);                  // OK: zobraz mu.ch = A
   printf("mu.d = &f\n", mu.d);                      // specifick vsledek
   muptr->i = 3;
   printf("mu.i = &d\n", mu.i);                     // OK: zobraz mu.i = 3


                                  - 78 - 


   Druh pouit printf je ppustn,  nebo  mu.i  je  celoselnm typem.
Bitov  vzorek  v  mu.i  vak  zsti odpovd pedtm dosazenmu double  a
obvykle neposkytne uitenou interpretaci celho sla.

   Pevede-li se sprvn, ukazatel na union ukazuje na kad z jeho len a
naopak.


Deklarace unionu
---------------------------------------------------------------------------

   Obecn  deklaran  syntax  pro  uniony  je tm pln stejn jako  pro
struktury. Rozdly jsou:

   1.  Uniony  mohou  obsahovat  bitov poloky, ale jen  jedin  me  bt
       aktivn. Vechny zanaj na zatku unionu.

   2.  Na  rozdl  od struktur v C++ typy  union  v  C++  nemohou  pouvat
       specifiktor pstupu do td: public, private a protected. Vechny
       poloky union jsou veejn.

   3.  Uniony  lze inicializovat jenom prostednictvm jejich lenu,  kter
       byl deklarovn jako prvn:

       union local187 {
          int i;
          double d;
       } a = { 20 };

   4.  Union se neme podlet na hierarchii td. Nelze jej ze dn tdy
       odvodit, ani neme bt bzovou tdou. Union me mt konstruktor.

   5.  Anonymn uniony nemohou mt lensk funkce.



---------------------------------------------------------------------------
Vty
---------------------------------------------------------------------------


   Vtov  typ  dat poskytuje mnemotechnick  identifiktory  pro  njakou
mnoinu celoselnch hodnot. Tak napklad nsledujc deklarace

   enum dny { pon, ute, str, ctv, pat, sob, ned } den;

   ustanov jednoznan celoseln typ enum dny, promnnou den tohoto typu
a mnoinu itatel (pon, ute,...) s konstantnmi celoselnmi hodnotami.

   Turbo C++ m povoleno uloit itatele do jedinho bytu, pokud je pznak
-b vypnut (implicitn je zapnut, co znamen, e vty enum jsou  vdy cel
sla  int)  a  dovol-li to rozsah hodnot. Pi pouit ve vrazu se takov
hodnota  ale  vdy  pevede na int. Identifiktory uit v seznamu itatel
jsou implicitn typu  unsigned  char  nebo  int,  co  zvis  na hodnotch
itatel. Lze-li vechny hodnoty intern zobrazit jako unsigned char, stane
se typem kadho itatele.

   V jazyku C lze do promnn vtovho typu dosadit jakoukoli hodnotu typu
int - dn dal kontrola  typu  se  nepoaduje.  V  C++  lze  do promnn
vtovho typu dosadit jenom jeden z jejch itatel. Take


                                  - 79 - 


   den = pon;                                                         // OK
   den = 0;                                     // nelze, pestoe pon == 0

   Identifiktor  dny  je  nepovinn  oznaen  vtu, jeho lze  vyut  v
nslednch deklaracch vtovch promnnch typu enum dny:

   enum dny vyplata, svatek;                   // deklarace dvou promnnch

   V C++ lze klov slovo enum  vynechat,  pokud dny nen ve stejnm oboru
nzvem n؟eho jinho.

   Jako  v deklaracch struct a union, lze i  u  vtu  vynechat  oznaen,
nevyaduj-li se dn dal promnn tohoto typu enum:

   enum { pon, ute, str, ctv, pat, sob, ned } den;
   /* anonymn vtov typ */

   itatelm  uvedenm  ve  sloench  zvorkch  se   tak   k  vtov
konstanty. Kad se dosad pevn celoseln hodnota. Nejsou-li udny dn
explicitn inicializtory, nastav se prvn itatel (pon) na  nulu  a kad
dal itatel se nastav na hodnotu o jednu vy, ne jeho pedchdce (ute
= 1, str = 2 atd.).

   O vtovch konstantch se dotete vce na strnce 20.

   Pouitm explicitnch inicializtor lze nastavit jeden i vce itatel
na konkrtn hodnoty.  Vechny  nsledn nzvy bez inicializtor pak budou
narstat vdy o jedniku. Napklad v takov deklaraci

   /* inicializan vraz sm obsahovat itatele deklarovan
   dve */
   enum mince { pence = 1, dvojpence, niklak = pence +  4,  desetnik  = 10,
                 *
ctvrtak = niklak   niklak } drobne;

   dvojpence zsk hodnotu 2, niklak hodnotu 5 a ctvrtak hodnotu 25.

   Inicializtorem  me  bt  libovoln  vraz  poskytujc  kladnou  nebo
zpornou celoselnou hodnotu (po ppadnch celoselnch pevodech). Tyto
hodnoty jsou obvykle jednoznan, ale pipout se i duplicita.

   Typy enum se mohou vyskytovat vude, kde jsou dovoleny typy int.

   enum dny { pon, ute, str, ctv, pat, sob, ned } den;
   enum dny vyplata;
   typedef enum dny DNY;
       *
   DNY  dnyptr;
   int i = ute;
   den = pon;                                                         // OK
   *
    dnyptr = den;                                                     // OK
   pon = ute;                                    // NELZE: pon je konstanta

   Oznaen vt sdlej stejn prostor pro nzvy jako oznaen struktur a
union. itatele sdlej stejn prostor pro nzvy jako bاn identifiktory
promnnch:

   int pon = 11;
   {


                                  - 80 - 


      enum dny { pon, ute, str, ctv, pat, sob, ned } den;
      /* itatel pon zakryje vnj deklaraci celoselnho pon */
      struct dny { int i, j;};            // NELZE: duplicitn oznaen dny
      double ned;                          // NELZE: opakovan definice ned
   }
   pon = 12;                              // zpt v oboru celoselnho pon

   V C++ plat, e itatele deklarovan uvnit njak tdy  jsou  v  oboru
tto tdy.



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


   Jak se identifiktory  a  opertory  kombinuj  do  gramaticky sprvnch
'frz' ukazuje Tabulka 1.19.

   Vraz je posloupnost opertor, operand a interpunknch znak, j se
uruje potebn vpoet.  Formln  syntax, uveden v Tabulce 2.2, ukazuje,
e  vrazy  se  definuj rekurzivn: Bez formlnho  omezen  lze  vnoovat
vrazy dl.  (Jestli vak kompiltor nedoke zkompilovat vraz, kter je
pli sloit, ohls chybu nedostatku pamti.)

   Standardn pevody jsou uvedeny podrobn v Tabulce 1.15 na strnce 49.

   Vrazy se vyhodnocuj podle uritch pravidel pro  pevody, seskupovn,
sdruovn a prioritu.  Ta  zvis  na  pouitch  opertorech, ptomnosti
zvorek a datovch  typech  operand. Zpsob seskupovn operand a dlch
vraz  jet  nemus  urovat  skuten   poad,  v  nm  je  Turbo  C++
vyhodnocuje (viz "Poad vyhodnocovn" na strnce 82).

   Z vraz mohou vznikat l-hodnoty,  r-hodnoty  nebo  tak  dn hodnoty.
Vrazy mohou vyvolat i vedlej efekty, a ji vytvej hodnoty nebo ne.

   Prioritu  i  asociativitu  operand  pln  definuj  pravidla  uveden v
Tabulce 2.2  na  strnce  79.  Tyto  informace  jsme shrnuli v Tabulce 2.3.
Existuje  16  kategori  priority,  z  nich nkter obsahuj  jenom  jeden
opertor. Opertory ve stejn kategorii maj prioritu stejnou.  Pokud  se v
tabulce  opertory  opakuj,  prvn  vskyt  zna unrn a  druh  binrn
opertor. Kad  kategorie m njak asociativn pravidlo: zleva doprava i
zprava  doleva.  Nejsou-li  udny  zvorky,  e se seskupovn  vraz  s
opertory stejn priority podle tchto pravidel.

















                                  - 81 - 


                       Tab. 2.2: Vrazy v Turbo C++

---------------------------------------------------------------------------------------------------------
primrn-vraz:                                   urovac-vraz:
     literl                                           unrn-vraz
     pseudo-promnn                                   (nzev-typu) urovac-vraz
     (vraz)
     this (jen C++)                               pm-vraz:
     :: identifiktor (jen C++)                        urovac-vraz
                                                                *
     :: nzev-funkce-opertoru (jen C++)               pm-vraz. urovac-vraz (jen C++)
     nzev                                             pm-vraz.->urovac-vraz (jen C++)

literl:                                          multipl-vraz:
     celoseln-konstanta                             pm-vraz
                                                                     *
     znakov-konstanta                                 multipl-vraz   pm-vraz
     pohyb-te-konstanta                               multipl-vraz / pm-vraz
     etzec                                           multipl-vraz % pm-vraz

nzev:                                            adit-vraz:
     identifiktor                                     multipl-vraz
     nzev-funkce-opertoru (jen C++)                  adit-vraz + multipl-vraz
     nzev-pevod-funkce (jen C++)                     adit-vraz - multipl-vraz
     kvalif-nzev (jen C++)
                                                  posun-vraz:
kvalif-nzev: (jen C++)                                adit-vraz
     nzev-tdy :: identifiktor                      posun-vraz << adit-vraz
     nzev-tdy :: nzev-funkce-opertoru             posun-vraz >> adit-vraz
     nzev-tdy :: nzev-pevod-funkce
     nzev-tdy :: nzev-tdy                   relan-vraz:
     nzev-tdy :: ~nzev-tdy                       posun-vraz
                                                       relan-vraz < posun-vraz
postfix-vraz:                                         relan-vraz > posun-vraz
     primrn-vraz                                    relan-vraz <= posun-vraz
     postfix-vraz [vraz]
     postfix-vraz (<seznam-vraz>)              rov-vraz:
     nz-jedn-typu (<seznam-vraz>) (jen C++)         relan-vraz
     postfix-vraz.nzev                               rov-vraz == relan-vraz
     postfix-vraz -> nzev                            rov-vraz != relan-vraz
     postfix-vraz ++
     postfix-vraz --                             AND-vraz:
                                                       rov-vraz
seznam-vraz:                                         AND-vraz & rov-vraz
     dosaz-vraz
     seznam-vraz, dosaz-vraz                   excl-OR-vraz:
                                                       AND-vraz
unrn-vraz:                                          excl-OR-vraz ^ AND-vraz
     postfix-vraz
     ++unrn-vraz                               incl-OR-vraz:
     --unrn-vraz                                    excl-OR-vraz
     unrn-opertor urovac-vraz                    incl-OR-vraz | excl-OR-vraz
     sizeof unrn-vraz
     sizeof (nzev-typu)                          log-AND-vraz:
     pidl-vraz (jen C++)                            incl-OR-vraz
     uvol-vraz (jen C++)                              log-AND-vraz && incl-OR-vraz

unrn-opertor: jeden z                          log-OR-vraz:
       *
     &   + - !                                         log-AND-vraz


                                  - 82 - 


                                                       log-OR-vraz || log-AND-vraz
pidl-vraz: (jen C++)
     <::> new <umst> nz-omez-typu <inic>        podm-vraz:
     <::> new <umst> (nz-typu) <inic>                log-OR-vraz
                                                       log-OR-vraz ? vraz : podm-vraz
umst: (jen C++)
     (seznam-vraz)                              dosaz-vraz:
                                                       podm-vraz
nz-omez-typu: (jen C++)                               unrn-vraz dosaz-opertor dosaz-vraz
     typ-specifiktory <omez-deklartor>
                                                  dosaz-opertor: jeden z
                                                           *
omez-deklartor: (jen C++)                             =    =  /=  %=  +=  -=
     ukaz-opertor <omez-deklartor>                   <<= >>= &=  ^=  |=
     omez-deklartor [<vraz>]
                                                  vraz:
uvol-vraz: (jen C++)                                  dosaz-vraz
     <::> delete urovac-vraz                        vraz,dosaz-vraz
     <::> delete [vraz] urovac-vraz
                                                  konstant-vraz:
                                                       podm-vraz
---------------------------------------------------------------------------------------------------------

          Tab. 2.3: Asociativita a priorita opertor v Turbo C++


   Priorita jednotlivch kategori je dna poadm v tabulce. Prvn kategorie (prvn dek) m nejvy prioritu.

---------------------------------------------------------------------------
Opertory                                              Asociativita
---------------------------------------------------------------------------
() [] -> :: .                                          Zleva doprava
                *
! ~ + - ++ -- &   (petypovn) sizeof new delete      Zprava doleva
 *   *
.  ->                                                  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
---------------------------------------------------------------------------


Vrazy a C++
---------------------------------------------------------------------------

   Jazyk C++ umouje urit  standardn  opertory  z jazyka C pepisovat,
co vysvtlujeme od strnky 131. Pepsan opertor se definuje tak,  aby se
choval pi pouit ve vrazech  typu  tda  zvltnm  zpsobem. Napklad


                                  - 83 - 


relan opertor == je  mono  definovat tak, aby ovoval ve td complex
rovnost  dvou komplexnch sel a pitom nemnil  sv  normln  pouit  s
datovmi typy jinmi ne tda.  Pepsan  opertory  se  implementuj jako
funkce;  takov   funkce   uruje   typ   operandu,   l-hodnotu   i  poad
vyhodnocovn, je maj pi uit pepsanho opertoru platit. Pepsnm se
vak  ned  zmnit  priorita  opertoru.  Jazyk  C++  podobn  pipout  i
uivatelsky definovan pevody mezi objekty  td  a  fundamentlnmi typy.
Mjte ale na zeteli, e nkter pravidla pro opertory a pevody, je jsme
v tomto oddlu probrali, se na vrazy v C++ nemus vztahovat.


Poad vyhodnocovn
---------------------------------------------------------------------------

   Poad  vyhodnocovn  operand  ve vrazech nen v  Turbo  C++  ureno.
Vjimkou jsou ppady, kdy to opertor specificky vyaduje. Aby se zlepila
kvalita generovanho kdu, pokou se  kompiltor  vrazy  uspodat znovu.
Pi je nutno vnovat zejmna tm vrazm, v nich se hodnoty upravuj vce
ne  jedenkrt. Obecn doporuujeme vyhnout se psan  vraz,  v  nich  se
hodnoty tho objektu upravuj i pouvaj. Uvaujme vraz

   i = v[i++];                                         // i nen definovno

   Hodnota i zvis na tom, zda se i inkrementuje ped nebo a po dosazen.
Podobn

   int total = 0;
   sum = (total = 3) + (++total);                // sum = 3 nebo sum = 7 ??

   je nejednoznan pro sum i total. eenm je pepracovat takov  vraz s
pouitm doasn promnn:

   int temp, total = 0;
   temp = ++total;
   sum = (total = 3) + temp;

   Kde  je   poad  vyhodnocovn  dno  syntax,  tam  je  bezpen  ut
vcensobnho vyhodnocen:

   sum = (i = 3, i++, i++);                            //OK: sum = 4, i = 5

   Vechny dl vrazy ve vrazu s rkami se vyhodnot  zleva  doprava  a
cel vraz zsk hodnotu nejvce vpravo.

   Turbo C++ vrazy  peskupuje.  Bez  ohledu  na  zvorky  se  mn poad
asociativnch a  komutativnch opertor, aby vznikl vraz, kter se inn
zkompiluje. Zmnou uspodn se v dnm ppad neovlivn hodnota vrazu.

   Poad vyhodnocovn ve vrazech se d nadit pouitm zvorek. Mte-li
napklad promnn a, b, c a f, pak vraz f = a +  (b  +  c) nad, aby se
nejprve vyhodnotilo (b + c) a vsledek se pietl k a.


Chyby a peplnn
---------------------------------------------------------------------------

   Pi vyhodnocovn  vraz me Turbo C++ narazit na adu problematickch
situac,  jako nap. na dlen nulou i na  hodnoty  s  pohyblivou  dovou
tekou, kter jsou  mimo  definin obor. Celoseln peplnn se ignoruj



                                  - 84 - 


                                                             n
(jazyk C pouv v n- bitovch registrech aritmetiku modulo 2 ),  ale chyby
zachycen ve  funkcch z matematick knihovny se oetuj standardnmi nebo
uivatelsky definovanmi  rutinami.  Viz  matherr  nebo  signal  v soustav
spaen npovdy.



---------------------------------------------------------------------------
Smantika opertor
---------------------------------------------------------------------------


   Zde popisovan opertory Turbo  C++  jsou  standardnmi  opertory podle
ANSI C.

   Pokud nejsou opertory pepsny, jsou nsledujc  informace  platn pro
jazyk C i C++. V jazyku C++ lze vechny tyto opertory pepisovat. Vjimkou
je . (opertor lenu) a ? (podmnn opertor). (V C++ nelze rovnا pepsat
                *
opertory :: a . ).

   Je-li  opertor  pepsan,  uvdn  diskuse  ji pro nj  vbec  nemus
platit. Syntax vech opertor i vraz s opertory se  nachz  v  Tabulce
2.2 na strnce 81.


Pponov a pedponov opertory
---------------------------------------------------------------------------

   Pouv se esti pponovch {postfix} opertor [] ()  .  ->  ++  a --.
Vytv  se  jimi  pponov {postfix} vrazy, kter jsou uvedeny v syntaxi
vraz (Tabulka 2.2). Opertory pro inkrement a dekrement (++  a  --)  jsou
rovnا pedponovmi {prefix} a unrnmi opertory. Diskutujeme  je ponaje
stranou 85.


Opertor indexovn pole []

   Ve vrazu

   postfix-vraz [vraz]

   V jazyku C, ale ji ne nutn v C++, se vraz vr1[vr2] definuje jako
   *
     ((vr1) + (vr2))

   kde bu vr1 je ukazatel a vr2 je cel slo, nebo vr1 je cel slo a
                                    *
vr2 je ukazatel. (Interpunkci [],     a  +  je  mono  v  C++ individuln
pepsat.)


Opertory voln funkc ()

   Vraz

   postfix-vraz(<seznam-arg-vraz>)




                                  - 85 - 


   pedstavuje  voln  funkce  dan  pponovm {postfix} vrazem. seznam-
arg-vraz  je  seznamem  vraz  jakchkoli typ, pedstavujcch skuten
(neboli reln) argumenty funkce. V seznamu jsou vzjemn oddleny rkami.
Hodnota vrazu pro voln funkce,  pokud existuje, se ur pkazem nvratu
{return} v definici funkce. Vce se o voln funkc dovte v oddlu "Voln
funkc a pevody argument" na strnce 72.


Opertor lenu struktury/unionu .(teka)

   Ve vrazu

   postfix-vraz . identifiktor

   mus bt pponov vraz  typu  struktura  nebo union. Identifiktor pak
mus bt typu nzvu  lenu  tto struktury nebo unionu. Vraz oznauje len
objektu struktura nebo union. Hodnotou vrazu je hodnota vybranho lenu. O
l-hodnotu pjde prv tehdy,  je-li  pponov  vraz  l-hodnotou. Podrobn
ukzky uit . a -> pro struktury jsou na strnce 74.

   l-hodnoty jsou definovny na strnce 32.


Opertor ukazatele na strukturu/union ->

   Ve vrazu

   postfix-vraz -> identifiktor

   mus bt pponov vraz  typu  ukazatel  na  strukturu nebo ukazatel na
union.  Identifiktor pak mus bt typu nzvu  lenu  tto  struktury  nebo
unionu. Vraz oznauje  len  objektu struktura nebo union. Hodnotou vrazu
je hodnota vybranho lenu. O  l-hodnotu pjde prv tehdy, je-li pponov
vraz l-hodnotou.


Pponov opertor inkrementace ++

   Ve vrazu

   postfix-vraz ++

   je pponov vraz operandem. Mus bt skalrnho typu (aritmetick nebo
ukazatelov   typ)   a   mus    bt    modifikovatelnou    l-hodnotou   (o
modifikovatelnch l-hodnotch se dotete vce na strnce 32). Ppon ++ se
k t postinkrementan  opertor.  Hodnotou  celho  vrazu  je hodnota
pponovho vrazu ped  vykonnm inkrementace. Po vyhodnocen pponovho
vrazu se operand inkrementuje, neboli zv o 1.

   Zven hodnota  odpovd  typu  operandu.  Ukazatelov  typy  podlhaj
pravidlm aritmetiky s ukazateli.


Pponov opertor dekrementace --

   Pponov dekrement, ktermu se t k postdekrementan  opertor, se
d stejnmi pravidly jako pponov inkrement a na to, e po vyhodnocen
operandu se od nj odete 1.




                                  - 86 - 


Opertory inkrementace a dekrementace
---------------------------------------------------------------------------

   Prvnmi dvma unrnmi opertory jsou ++  a  --. Jeliko se jedn tak o
pponov  i  pedponov  opertory,  diskutujeme   je   na   tomto  mst.
Zbvajcch est unrnch opertor probereme po tto diskusi.


Pedponov opertor inkrementace

   Ve vrazu

   ++ unrn-vraz

   je  unrn  vraz  operandem.  Mus  bt  skalrnho  typu  a  mus  bt
modifikovatelnou  l-hodnotou.  Pedponovmu  opertoru inkrementace se tak
k  preinkrementan  opertor.  Operand   se   zv   o  1  jet  ped
vyhodnocenm vrazu. Hodnotou celho vrazu je  pak  inkrementovan hodnota
operandu.  1  pouit  pro  inkrementaci  je  typu  odpovdajcho  k  typu
operandu. Ukazatelov typy podlhaj pravidlm aritmetiky s ukazateli.


Pedponov opertor dekrementace

   Pedponov   opertor  dekrementace,  zvan  t  predekrementan,   m
nsledujc syntax:

   -- unrn-vraz

   d se stejnmi pravidly  jako  pedponov  opertor inkrementace a na
to,  e ped vyhodnocenm celho vrazu  se  operand  dekrementuje,  neboli
sn o 1.


Unrn opertory
---------------------------------------------------------------------------
                                                                  *
   Mme est unrnch  opertor  (mimo ++ a --), ktermi jsou: &   + - ~ a
!. Syntax m tvar

   unrn-opertor urovac-vraz

   urovac-vraz:
      unrn-vraz
      (nzev-typu) urovac-vraz


Opertor adresovn &

   V jazyku C++ se symbolu &  pouv  tak k urovn odkazovch typ. Viz
strnku 105.
                                               *             *
   Opertor  &  spolupracuje   s   opertorem     (opertor     popeme  v
nsledujcm oddlu) coby opertory odkazovn a  nepmho  odkazovn. Ve
vrazu

   & urovac-vraz





                                  - 87 - 


   mus bt operand urovac-vraz bu oznaovaem  funkce  nebo l-hodnotou
oznaujc  objekt,  jen  nen  bitovou  polokou  a  nen  deklarovn  se
specifiktorem pam؟ov tdy register.  Je-li  tento  operand typu typ, je
vsledek typu ukazatel na typ.

   Pamatujte,  e  nkter  identifiktory,  kter nejsou l-hodnotou, nap.
nzvy funkc a nzvy pol, se za uritch okolnost automaticky pevedou na
typy "ukazatel na X". Opertoru & lze pout i s takovmi objekty, ale jeho
uit je nadbyten a proto je nedoporuujeme.

   Zvate nsledujc ukzku:

   type t1 = 1, t2 = 2;
        *
   type  ptr = &t1;                              // inicializovan ukazatel
   *
    ptr = t2;                                 // stejn inek jako t1 = t2
                        *
   Uvdomte si, e type  ptr = &t1 se zpracuje jako
     *
   T  ptr;
   ptr = &t1;
                                        *
   take se dosazuje do ptr a nikoli do  ptr. Jakmile je ptr inicializovna
adresou &t1, lze  se  pes  ni  klidn nepmo odkazovat a zskat l-hodnotu
*
 ptr.


                              *
Opertor nepmho adresovn

   Ve vrazu
   *
     urovac-vraz

   mus  bt operand urovac-vraz typu "ukazatel  na  typ",  piem  typ
pedstavuje njak libovoln typ.  Vsledek  nepmho  adresovn  je typu
typ.  Je-li  operand  typu  "ukazatel  na funkci", vsledkem  je  oznaova
funkce. Je-li operand typu "ukazatel  na  objekt",  vsledkem  je l-hodnota
oznaujc tento objekt. V situacch,  kter  nyn  uvedeme,  nen vsledek
nepmho adresovn definovn:

   1.  urovac-vraz je przdnm ukazatelem.

   2.  urovac-vraz  je  adresou automatick promnn  a  innost  jejho
       bloku skonila.


Opertor unrn plus +

   Ve vrazu

   + urovac-vraz

   mus bt operand urovac-vraz aritmetickho typu. Vsledkem je hodnota
tohoto operandu po vech potebnch celoselnch pevodech.





                                  - 88 - 


Opertor unrn minus -

   Ve vrazu

   - urovac-vraz

   mus bt operand urovac-vraz aritmetickho typu. Vsledkem je zporn
hodnota tohoto operandu po vech potebnch celoselnch pevodech.


Opertor bitovho doplku ~

   Ve vrazu

   ~ urovac-vraz

   mus bt operand urovac-vraz celoselnho typu. Vsledkem  je bitov
doplnk  tohoto  operandu  po  vech  potebnch  celoselnch  pevodech.
Vechny  bity  v operandu, kter jsou 0, se nastav na 1.  Vechny  bity  v
operandu, kter jsou 1, se nastav na 0.


Opertor logick negace !

   Ve vrazu

   ! urovac-vraz

   mus bt operand urovac-vraz skalrnho  typu. Vsledek je typu int a
je logickou negac danho operandu: Je 0, je-li operand nenulov,  resp. 1,
je-li operand nulov. Vraz !E je ekvivalentem vrazu (0 == E).


Opertor sizeof
---------------------------------------------------------------------------

   Opertoru sizeof {velikost} se pouv dvma rozdlnmi zpsoby:

   sizeof unrn-vraz
   sizeof (nzev-typu)

   Velikost prostoru, kter se pro kad typ v pamti rezervuje,  zvis na
konkrtnm potai.

   Vsledkem  je  v  obou ppadech celoseln konstanta,  kter  udv  v
bytech  velikost  prostoru,  zabranho  operandem  (urenho,  s  nkolika
vjimkami,  jeho  typem).  V  prvnm  pouit se stanov  typ  operandovho
vrazu, ani by se vraz vyhodnotil (a tedy i bez vedlejch  efekt). Kdy
je  operand typu char (signed i unsigned),  poskytne  sizeof  vsledek  1.
Nen-li operand parametrem a je typu pole, je vsledkem celkov  poet byt
v takovm poli  (jinmi  slovy:  nzev  pole se nepevd na typ ukazatel).
Poet prvk pole se rovn sizeof pole / sizeof pole[0].

   Je-li operand parametrem deklarovanm jako  typ  pole  nebo  typ funkce,
udv sizeof velikost ukazatele. Pi  pouit na strukturu nebo union udv
sizeof celkov poet byt, vetn veker vpln.

   Opertoru sizeof nelze  pout  ve vrazech typu funkce, neplnch typ,
uzvorkovanch nzv takovch typ nebo s l-hodnotou, kter oznauje objekt
s bitovmi polokami.


                                  - 89 - 


   Celoselnm typem vsledku opertoru  sizeof  je  size_t,  definovan v
stddef.h jako unsigned int.

   Opertoru sizeof lze pout v direktivch preprocesoru; jde o specifikum
jazyka Turbo C++.

   V  C++ poskytne sizeof(typ-tda), kde typ-tda  je  odvozen  z  njak
bzov tdy, velikost bzov tdy.


Multiplikativn opertory
---------------------------------------------------------------------------

   Existuj ti multiplikativn opertory: * / a %

   multiplikativn-vraz:
      urovac-vraz
                            *
      multiplikativn-vraz   urovac-vraz
      multiplikativn-vraz / urovac-vraz
      multiplikativn-vraz % urovac-vraz

   Operandy  pro * (nsoben) a / (dlen)  mus  bt  aritmetickho  typu.
Operand pro %  (modulus  neboli  zbytek)  mus  bt  typu  celoselnho. S
operandy se vykonvaj bاn aritmetick pevody (viz strnku 48).

   Vsledkem (op1 * op2) je souin tchto dvou operand.  Vsledky  (op1  /
op2) a (op1 % op2) jsou podl a zbytek, kdy  op1  se  dl  op2,  ovem  za
pedpokladu,  e  op2  je nenulov. Pi pouit / nebo % s druhm operandem
nulovm vznikne chyba.

   Kdy jsou op1 a op2 cel  sla  a podl nen celoseln, jsou vsledky
nsledujc:

   1.  Maj-li  op1 i op2 stejn znamnka, je op1  /  op2  nejvtm  celm
       slem menm ne skuten podl. op1 % op2 m znamnko  stejn jako
       op1.

   2.  Maj-li  op1 i op2 znamnka opan, je op1  /  op2  nejmenm  celm
       slem vtm ne skuten podl. op1 % op2 m znamnko  stejn jako
       op1.

   Zaokrouhluje se vdy smrem k nule.


Aditivn opertory
---------------------------------------------------------------------------

   Aditivn opertory jsou dva: + a -. Pslun syntax vypad takto:

   aditivn-vraz:
      multiplikativn-vraz
      aditivn-vraz + multiplikativn-vraz
      aditivn-vraz - multiplikativn-vraz


Opertor stn +

   Ppustnmi typy operand pro op1 + op2 jsou



                                  - 90 - 


   1.  op1 i op2 jsou oba aritmetickho typu.

   2.  op1 je typu celoselnho a op2 je ukazatelem na typ objektu.

   3.  op2 je typu celoselnho a op1 je ukazatelem na typ objektu.

   V  1.  ppad  operandy  podlhaj  normlnm  aritmetickm  pevodm a
vsledkem je aritmetick souet operand. V pipad 2. a 3.  plat pravidla
aritmetiky s ukazateli. (Aritmetiku s ukazateli popisujeme na strnce 64.)


Opertor odtn -

   Ppustnmi typy operand pro op1 - op2 jsou

   1.  op1 i op2 jsou oba aritmetickho typu.

   2.  op1 i  op2 jsou ukazatele na kompatibiln typy objekt. (Upozornn:
       Nekvalifikovan   typ   typ    se   povauje   za   kompatibiln   s
       kvalifikovanmi typy const typ, volatile typ a const volatile typ.)

   3.  op1 je ukazatelem na typ objektu a op2 je typu celoselnho.

   V  1.  ppad  operandy  podlhaj  normlnm  aritmetickm  pevodm a
vsledkem je aritmetick rozdl operand. V pipad 2. a 3.  plat pravidla
aritmetiky s ukazateli.


Opertory bitovch posun
---------------------------------------------------------------------------

   Opertory bitovch posun jsou dva: << a >>. Pslun syntax je

   posun-vraz:
      aditivn-vraz
      posun-vraz << aditivn-vraz
      posun-vraz >> aditivn-vraz


Opertory bitovch posun (<< a >>)

   Ve  vrazu  E1  << E2 a E1 >> E2 mus bt operandy E1 i E2 celoselnho
typu. S E1 i E2 se  vykonaj  normln celoseln pevody a typem vsledku
je typ pevedenho E1. Je-li E2  zporn,  resp. je-li roven nebo vt ne
ka v bitech E1, nen takov operace definovna.

   Konstanty ULONG_MAX a UINT_MAX jsou definovny v limits.h.

   Vsledkem  E1 << E2 je hodnota E1 posunut vlevo o E2 bitovch mst. Je-
li teba, zprava se dopln nulami. Posun vlevo sla E1 typu  unsigned long
                                         E2
je ekvivalentn s vynsobenm E1 slem 2  , zmenenm  modulo  ULONG_MAX +
                                                                        E2
1; lev posun sla unsigned int je ekvivalentn s vynsobenm  slem 2  ,
zmenenm modulo UINT_MAX + 1. Je-li E1 celm slem se znamnkem,  mus se
vsledek interpretovat opatrn, nebo znamnkov bit se me mnit.

   Vsledkem E1 >> E2 je hodnota E1 posunut  vpravo  o  E2  bitovch mst.
Je-li  E1  typu  unsigned, v ppad poteby se zleva dopln nuly. Je-li E1
typu signed, vyplnn  zleva  pouije  znamnkov  bit (0 pro kladn, 1 pro


                                  - 91 - 


zporn E1). Rozen znamnkovm bitem zajist, e znamnko E1 >> E2 bude
toton  se znamnkem E1. S vjimkou typ se znamnkem je hodnotou E1 >> E2
                     E2
cel st podlu E1/2  .


Relan opertory
---------------------------------------------------------------------------

   Existuj tyi relan opertory:  <  > <= a >=. Syntax tchto opertor
je:

   relan-vraz:
      posun-vraz
      relan-vraz < posun-vraz
      relan-vraz > posun-vraz
      relan-vraz <= posun-vraz
      relan-vraz >= posun-vraz


Opertor men ne <

   Ve vrazu E1 <  E2  mus operandy vyhovovat jedn z nsledujcch mnoin
podmnek:

   1.  E1 i E2 jsou oba aritmetickho typu.

   2.  E1 i E2 jsou oba ukazatele na kvalifikovan i nekvalifikovan verze
       kompatibilnch typ objekt.

   3.  E1 i E2 jsou oba ukazatele na kvalifikovan i nekvalifikovan verze
       kompatibilnch neplnch typ.

   Kvalifikovan nzvy definujeme na strnce 115.

   V 1. ppad se vykonaj obvykl aritmetick pevody. Vsledek vrazu E1
< E2 je typu int. Je-li hodnota E1  men  ne  hodnota  E2, je vsledkem 1
(true). V opanm ppad je vsledkem 0 (false).

   V ppadech 2. a 3., kde  E1  i  E2 jsou ukazatele na kompatibiln typy,
zvis  vsledek  E1  < E2 na  relativnm  umstn  (adresch)  tch  dvou
objekt, na nا se  ukazuje.  Pi  porovnvn  len struktury uvnit te
struktury, zna "vy" ukazatel  pozdj  deklaraci.  Uvnit  pol zna
"vy" ukazatel vt hodnotu indexu.  Vechny  ukazatele  na  leny tho
objektu union se porovnaj jako stejn.

   Porovnn ukazatel na objekty rznch struktur, pol nebo union, resp.
porovnn  ukazatel  mimo  rozsah  njakho  objektu  pole  normln  dv
nedefinovan vsledky. Vjimkou je  ovem  situace  v ppad "ukazatele za
poslednm prvkem", kterou  jsme  probrali v oddlu "Aritmetika s ukazateli"
na strnce  64.  Ukazuje-li  P  na njak prvek objektu pole a Q ukazuje na
posledn prvek, vraz P <  Q + 1 je ppustn a vyhodnot se jako 1 (true),
i kdy vlastn Q + 1 na dn prvek objektu pole neukazuje.









                                  - 92 - 


Opertor vt ne >

   Vraz E1 > E2 dv 1 (true), je-li hodnota E1 vt  ne  hodnota  E2. V
opanm  ppad  je  vsledkem  0  (false). Uv se  stejn  interpretace
aritmetickch  a  ukazatelovch   porovnn,  kterou  jsme  definovali  pro
opertor men ne. Plat tak stejn pravidla a omezen pro operandy.


Opertor men nebo rovno <=

   Analogicky vraz E1 <= E2 dv 1 (true),  je-li  hodnota  E1  men nebo
rovna hodnot E2. V opanm ppad je vsledkem 0 (false). Uv se stejn
interpretace  aritmetickch   a   ukazatelovch   porovnn,   kterou  jsme
definovali pro opertor men ne. Plat tak stejn pravidla a omezen pro
operandy.


Opertor vt nebo rovno >=

   Vraz  E1 >= E2 dv 1 (true), je-li hodnota E1 vt nebo rovna hodnot
E2. V opanm ppad je vsledkem 0 (false). Uv se  stejn interpretace
aritmetickch  a  ukazatelovch   porovnn,  kterou  jsme  definovali  pro
opertor men ne. Plat tak stejn pravidla a omezen pro operandy.


Opertory rovnosti
---------------------------------------------------------------------------

   Opertory  rovnosti  jsou  dva: == a  !=.  Ovuje  se  jimi  rovnost  a
nerovnost dvou aritmetickch hodnot nebo dvou  hodnot  ukazatel. Postupuje
se podle pravidel velmi podobnch pravidlm pro relan opertory. Uvdomte
si ale, e == a != maj prioritu ni ne relan opertory <, >, <= a >=.
Pomoc == a != lze porovnvat rovnost a nerovnost uritch  typ ukazatel,
u nich se relan opertory nepipoutj.

   Syntax je

   rovnost-vraz:
      relan-vraz
      rovnost-vraz == relan-vraz
      rovnost-vraz != relan-vraz


Opertor rovn se ==

   Ve  vrazu  E1  ==  E2  mus  operandy  vyhovovat  podmnkm  z jedn  z
nsledujcch mnoin:

   1.  E1 i E2 jsou oba aritmetickho typu.

   2.  E1 i E2 jsou oba ukazatele na kvalifikovan i nekvalifikovan verze
       kompatibilnch typ.

   3.  Jeden z E1 a E2 je ukazatel na njak objektov  nebo  nepln typ a
       druh je ukazatel na kvalifikovanou i  nekvalifikovanou  verzi typu
       void.

   4.  Jeden z E1 a E2 je ukazatel a  druh  je  konstantou  przdn {null}
       ukazatel.



                                  - 93 - 


   Jsou-li E1 a E2 takovch typ, je jsou platnmi typy pro njak relan
opertor, plat  stejn pravidla porovnvn, jak jsme je podrobn probrali
pro E1 < E2, E1 <= E2 atd.

   Napklad  v  ppad  1.  se  vykonaj  obvykl  aritmetick pevody  a
vsledek E1 ==  E2  je  typu  int.  Je-li  hodnota  E1 rovna hodnot E2, je
vsledkem 1 (true). V opanm ppad je vsledkem 0 (false).

   V ppad  2.  dv  E1  ==  E2  hodnotu 1 (true), ukazuj-li E1 i E2 na
stejn objekt, nebo oba ukazuj na "prvek tsn za poslednm  prvkem" tho
objektu pole, resp. kdy jsou oba przdnmi ukazateli.

   Jsou-li E1 i  E2  ukazatele  na  typy  funkce,  dv  E1 == E2 hodnotu 1
(true), jsou-li oba przdn nebo ukazuj-li oba na stejnou funkci.
Naopak, dv-li  E1  ==  E2  hodnotu  1  (true), pak E1 i E2 ukazuj oba na
stejnou funkci, resp. jsou oba przdn.


Opertor nerovnosti !=

   Vraz  E1 != E2 se d stejnmi pravidly jako E1 == E2  a  na  to,  e
vsledek  je  1  (true), kdy se operandy nerovnaj a 0  (false),  kdy  se
operandy rovnaj.


Opertor bitov AND &
---------------------------------------------------------------------------

   Pslun syntax m tvar

   AND-vraz:
      rovnost-vraz
      AND-vraz & rovnost-vraz

   Ve  vrazu E1 & E2 mus bt oba operandy celoselnho typu. S vrazy E1
a E2 se vykonaj obvykl aritmetick pevody a vsledkem je bitov AND z E1
a E2. Jak se ur jednotliv bity ve vsledku ukazuje Tabulka 2.4.


             Tab. 2.4: Pravdivostn tabulka bitovch opertor

---------------------------------------------------------------------------
     Bitov hodnota Bitov hodnota
     v E1           v E2           E1 & E2        E1 ^ E2        E1 | E2
---------------------------------------------------------------------------
       0              0               0              0              0
       1              0               0              1              1
       0              1               0              1              1
       1              1               1              0              1


Opertor bitov exklusivn OR ^
---------------------------------------------------------------------------

   Syntax je tvaru

   excl-OR-vraz:
      AND-vraz
      excl-OR-vraz ^ AND-vraz



                                  - 94 - 


   Ve  vrazu E1 ^ E2 mus bt oba operandy celoselnho typu. S vrazy E1
a  E2  se  vykonaj  obvykl  aritmetick  pevody  a vsledkem  je  bitov
exklusivn OR z E1 a E2.  Jak  se  ur jednotliv bity ve vsledku ukazuje
Tabulka 2.4.


Opertor bitov inklusivn OR |
---------------------------------------------------------------------------

   Syntax je tvaru

   incl-OR-vraz:
      excl-OR-vraz
      incl-OR-vraz | excl-OR-vraz

   Ve  vrazu E1 | E2 mus bt oba operandy celoselnho typu. S vrazy E1
a  E2  se  vykonaj  obvykl  aritmetick  pevody  a vsledkem  je  bitov
inklusivn OR z E1 a E2.  Jak  se  ur jednotliv bity ve vsledku ukazuje
Tabulka 2.4.


Opertor logick AND &&
---------------------------------------------------------------------------

   Syntax je tvaru

   log-AND-vraz:
      incl-OR-vraz
      log-AND- vraz && incl-OR-vraz

   Ve  vrazu  E1  && E2 mus bt oba operandy skalrnho typu. Vsledek je
typu int  a  je  roven  1  (true),  jsou-li hodnoty E1 i E2 ob nenulov. V
opanm ppad je vsledkem 0 (false).

   Na rozdl od opertoru bitov & zaruuje && vyhodnocovn zleva doprava.
Nejprve se vyhodnot E1; je-li E1 roven nule, poskytne E1  &&  E2 hodnotu 0
(false) a E2 se ji nevyhodnocuje.


Opertor logick OR ||
---------------------------------------------------------------------------

   Syntax je tvaru

   log-OR-vraz:
      log-AND-vraz
      log-OR-vraz || log-AND- vraz

   Ve  vrazu  E1  || E2 mus bt oba operandy skalrnho typu. Vsledek je
typu int a je roven  1 (true), je-li aspo jedna z hodnot E1 a E2 nenulov.
V opanm ppad je vsledkem 0 (false).

   Na rozdl od opertoru bitov | zaruuje || vyhodnocovn zleva doprava.
Nejprve se vyhodnot E1; je-li E1 nenulov, poskytne  E1  ||  E2  hodnotu 1
(true) a E2 se ji nevyhodnocuje.







                                  - 95 - 


Podmnn opertor ?:
---------------------------------------------------------------------------

   Syntax m tvar

   podmnn-vraz:
      log-OR-vraz
      log-OR-vraz ? vraz : podmnn-vraz

   Ve vrazu E1  ? E2 : E3 mus bt operand E1 skalrnho typu. Operandy E2
a E3 se mus dit pravidly z jedn z nsledujcch mnoin:

   1.  Oba jsou aritmetickho typu

   2.  Oba jsou kompatibilnho typu struktura nebo union

   3.  Oba jsou typu void

   4.  Oba jsou typu ukazatel na kvalifikovanou  i  nekvalifikovanou verzi
       kompatibilnho typu

   5.  Jeden operand je typu ukazatel, druh je konstantou przdn ukazatel

   6.  Jeden operand je typu ukazatel na njak objektov nebo nepln typ,
       druh je typu ukazatel na kvalifikovanou  i  nekvalifikovanou verzi
       typu void.

   Nejprve se vyhodnot  E1.  Je-li jeho hodnota nenulov (true), vyhodnot
se E2 a E3 se ignoruje.  Vyhodnot-li  se E1 jako nulov (false), vyhodnot
se E3 a E2 se ignoruje. Vsledkem E1 ? E2 : E3 bude hodnota  toho  z vraz
E2 a E3, kter se bude vyhodnocovat.

   V ppad  1.  prodlaj  E2  a  E3  obvykl aritmetick pevody a typem
vsledku je spolen typ, kter z tchto pevod vyplyne.

   V ppad 2. je typem vsledku typ struktury nebo unionu E2 a E3

   V ppad 3. je vsledek typu void.

   V  ppadech 4. a 5. je typem vsledku  ukazatel  na  typ  kvalifikovan
vemi kvalifiktory typu, na nj ukazuj oba operandy.

   V ppad 6. je typem vsledku typ toho operandu, kter nen ukazatel na
void.


Opertory dosazovn
---------------------------------------------------------------------------

   Opertor  pro  dosazovn  je  jedenct.  Opertor  =   je  jednoduchm
opertorem dosazen, ostatnm deseti se k sloen opertory dosazen.

   Syntax je tvaru

   dosaz-vraz:
      podmnn-vraz
      unrn-vraz dosaz-opertor dosaz-vraz

   dosaz-opertor: jeden z



                                  - 96 - 


         *
      =   = /= %= += -=
      <<=   >>=   &= ^= |=


Jednoduch opertor dosazen =

   Ve vrazu E1 = E2 mus bt E1 modifikovatelnou l-hodnotou. Hodnota E2 se
po  pevodu  na  typ E1 ulo  v  objektu  oznaenm  vrazem  E1  (nahrad
pedchoz hodnotu  E1). Hodnotou takovho dosazovacho vrazu je hodnota E1
po dosazen. Dosazovac vraz sm l-hodnotou nen.

   V C++ je vsledek l-hodnotou.

   Operandy E1 a E2 se mus dit pravidly z jedn z nsledujcch mnoin:

   1.  E1 je kvalifikovanho i nekvalifikovanho aritmetickho  typu  a E2
       je aritmetickho typu.

   2.  E1  m  kvalifikovanou   i  nekvalifikovanou  verzi  njakho  typu
       struktury nebo unionu kompatibilnho s typem E2.

   3.  E1 i E2  jsou  ukazatele na kvalifikovanou i nekvalifikovanou verzi
       kompatibilnch typ a typ, na nj ukazuje vraz  vlevo,  m vechny
       kvalifiktory typu, na nj ukazuje vraz vpravo.

   4.  Jeden z E1 a E2 je ukazatel na njak objektov  nebo  nepln typ a
       druh je ukazatel na kvalifikovanou i nekvalifikovanou  verzi void.
       Typ, na nj ukazuje vraz vlevo m vechny  kvalifiktory  typu, na
       nj ukazuje vraz vpravo.

   5.  E1 je ukazatel a E2 je konstantou przdn ukazatel.


Sloen opertory dosazen

   Sloen dosazen op=,  kde  op  me  bt libovoln z deseti symbol pro
         *
opertor   / % + - << >> & ^ |, se interpretuj nsledovn:

   E1 op= E2

   psob stejn jako

   E1 = E1 op E2

   a na to, e  se  l-hodnota E1 vyhodnocuje pouze jedenkrt. Napklad E1
+= E2 je tot jako E1 = E1 + E2.

   Pravidla sloenho dosazovn jsme  tak  vlastn  probrali  v pedchozm
oddlu (u jednoduchho opertoru dosazen =).


Opertor rka
---------------------------------------------------------------------------

   Syntax je tvaru

   vraz:
      dosaz-vraz


                                  - 97 - 


      vraz , dosaz-vraz

   Ve vrazu s rkou

   E1 , E2

   se  lev operand E1 vyhodnot jako vraz void a potom se vyhodnot E2, z
nj se zsk vsledek a typ vrazu s rkou. Vraz

   E1 , E2 , ..., En

   rekurzivn vede k vyhodnocen vech  Ei zleva doprava, piem hodnotu a
typ vsledku celho  vrazu  poskytne En. Aby se zabrnilo nejednoznanosti
rek pouitch v  argumentech  funkc a seznamech inicializtor, je nutno
pout zvorek. Napklad vrazem

   func(i, (j = 1, j + 4), k);

   se vyvol func se  temi  argumenty a nikoli tymi. Tyto argumenty jsou
i, 5 a k.


Opertory specifick pro C++
---------------------------------------------------------------------------
                                             *   *
   Opertory  specifick  pro  C++  jsou::  .  ->  . Informace o  opertoru
pstupu v oboru (::) naleznete na strnce 107.
                     *     *
   Syntax opertor .  a ->  je tato:

   pm-vraz
      ur-vraz
                *
      pm-vraz .  ur-vraz
                 *
      pm-vraz ->  ur-vraz
               *
   Opertorem .  se nepmo adresuj  ukazatele na leny td. Svazuje ur-
vraz, kter mus  bt  typu  "ukazatel  na  len tdy typ", s vrazem pm-
vraz, kter mus bt tdy typ  nebo  tdy veejn odvozen od tdy typ.
Vsledkem je objekt typu urenho vrazem ur-vraz.
               *
   Opertor  ->   nepmo  odkazuje ukazatele na ukazatele  na  leny  td
(nikoli,  nejde   o  chybu;  skuten  nepmo  odkazuje  na  ukazatele  na
ukazatele). Svazuje ur-vraz, kter mus  bt typu "ukazatel na len tdy
typ", s  vrazem  pm-vraz,  kter  mus  bt  tdy typ nebo tdy veejn
odvozen od tdy typ. Vsledkem je objekt typu urenho vrazem ur-vraz.

   Je-li  vsledkem  kterhokoli  z  tchto  opertor  njak  funkce, pak
takovho vsledku lze pout jenom jako operandu pro opertor voln funkce
(). Napklad
                *
   (ptr2object-> ptr2clenfunc) (10);

   vol lenskou  funkci, oznaenou jako ptr2clenfunc, pro objekt, na kter
se ukazuje jako na ptr2object.






                                  - 98 - 


---------------------------------------------------------------------------
Pkazy
---------------------------------------------------------------------------


   Pkazy se pi vkonu programu  uruje prbh zen. Pokud nejsou udny
specifick pkazy skoku a vbru,  vykonvaj se pkazy postupn v poad
svho uveden ve zdrojovm  textu  programu.  Syntax  pkaz je vyloena v
nsledujc tabulce:





















































                                  - 99 - 


                        Tab. 2.5: Pkazy Turbo C++

---------------------------------------------------------------------------
pkaz:
     pkaz-s-nvtm
     sloen-pkaz
     vrazov-pkaz
     vbrov-pkaz
     iteran-pkaz
     pkaz-skoku
     asm-pkaz
     deklarace (specifick pro C++)

asm-pkaz:
     asm lexikln-prvky nov-dek
     asm lexikln-prvky;
     asm {lexikln-prvky; <lexikln-prvky;> =
          <lexikln-prvky>
          }

pkaz-s-nvtm:
     identifiktor : pkaz
     case konstantn-vraz : pkaz
     default : pkaz

sloen-pkaz:
     { <seznam-deklarac> <seznam-pkaz> }

seznam-deklarac:
     deklarace
     seznam-deklarac deklarace

seznam-pkaz:
     pkaz
     seznam-pkaz pkaz

vrazov-pkaz:
     <vraz>;

vbrov-pkaz:
     if (vraz) pkaz
     if (vraz) pkaz else pkaz
     switch (vraz) pkaz

iteran-pkaz:
     while (vraz) pkaz
     do pkaz while (vraz);
     for (pkaz-inic-for <vraz> ; <vraz>) pkaz

pkaz-inic-for:
     vrazov-pkaz
     deklarace (specifick pro C++)

pkaz-skoku:
     goto identifiktor ;
     continue ;
     break ;
     return <vraz> ;
---------------------------------------------------------------------------



                                  - 100 - 





---------------------------------------------------------------------------
Bloky
---------------------------------------------------------------------------


   Sloen pkaz  neboli blok je seznamem (i przdnm) pkaz, uzavench
do vzjemn  si odpovdajcch sloench zvorek ({}). Syntakticky lze blok
povaovat  za  jedin  pkaz,  hraje  vak  svou  roli  i v urovn oboru
identifiktor. Identifiktor deklarovan uvnit njakho bloku m  obor od
msta deklarace po koncovou sloenou zvorku. Bloky lze do libovoln rovn
vnoovat.


Pkazy s nvtm
---------------------------------------------------------------------------

   Pkaz lze opatit nvtm nsledujcmi zpsoby:

   1.  identifiktor-nvt : pkaz

       Identifiktor nvt slou jako  cl  nepodmnnho  pkazu skoku
       goto. Identifiktory nvt  maj  svj vlastn prostor pro nzvy a
       vyuvaj  obor funkce. Pamatujte si, e v  C++  je  mono  nvtm
       oznait jak deklaran, tak i nedeklaran pkazy.

   2.  case konstantn-vraz : pkaz
       default : pkaz

       Pkaz 'case'  {ppad}  a  'default'  {implicitn}  se  s nvtm
       pouv jenom v souvislosti s pkazy 'switch' {pepna}.


Vrazov pkazy
---------------------------------------------------------------------------

   Vrazov pkaz vznikne z kadho vrazu, za nm nsleduje stednk:

   <vraz>;

   Turbo C++ vrazov pkaz vykon  tm, e tento vraz vyhodnot. Vechny
vedlej efekty  se uskuten jet ped vykonnm dalho pkazu. Vtinu
vrazovch pkaz tvo dosazovac pkazy nebo voln funkc.

   Zvltnm ppadem je pkaz przdn  {null},  tvoen  pouze stednkem
(;). Przdn pkaz nevykon nic.  Pesto je uiten v takovch situacch,
kdy syntax jazyka Turbo C++ njak pkaz oekv, ale vy ve  svm programu
dn nepotebujete.


Vbrov pkazy
---------------------------------------------------------------------------

   Vbrovch pkaz neboli pkaz pro zen prbhu se pouv k vbru
alternativnch smr innosti programu.  Tmto  pkazy  se  ovuj urit
hodnoty. Existuj dva typy vbrovch pkaz: pkaz if...else a switch.




                                  - 101 - 


Pkazy if

   Zkladn pkaz if m nsledujc formu:

   if (podmnkov-vraz) pk-t <else pk-f>

   Zvorky okolo podmnkovho vrazu jsou velmi dleit.
   podmnkov-vraz mus bt skalrnho  typu.  Tento  vraz  se vyhodnot.
Je-li jeho hodnotou  nula  (nebo przdn ukazatel), ekneme, e podmnkov-
vraz je nepravdiv (false). V opanm ppad je pravdiv (true).

   Nen-li udna klauzule else  a  podmnkov-vraz  je pravdiv, vykon se
pk-t; v opanm ppad se pk-t ignoruje.

   Je-li zadna  nepovinn st else pk-f a podmnkov-vraz je pravdiv,
vykon se pk-t. V opanm ppad se pk-t ignoruje a vykon se pk-f.

Pamatujte!
   Na rozdl od jinch jazyk, jako je napklad Pascal, neexistuje v Turbo
C++ specifick typ logickch  (booleovskch)  dat.  Pi  testovn podmnek
msto logickho typu slou vraz  celoselnho  nebo  ukazatelovho typu.
Relan  vraz (a > b) (pokud je ppustn) se vyhodnot jako int 1 (true),
kdy je skuten (a > b) a jako int 0 (false), kdy je  (a  <=  b). Pevody
ukazatel umouj, aby se ukazatel  vdy  sprvn  porovnal  s konstantnm
vrazem,  vyhodnocenm  jako  0.  Lze  tedy  zadvat  testy  vi  przdnm
ukazatelm if (!ptr)... nebo if (ptr == 0)....

   Pkazy pk-t a pk-f mohou bt  samy  dle pkazy if, m se umon
vytvoen  cel  posloupnosti  podmnnch  test  vnoench  do  libovoln
hloubky.  U  vnoench  konstrukc  if...else  je   teba   opatrnosti  pi
zajiovn, aby se vybraly ty  sprvn  pkazy.  Neexistuje  dn pkaz
endif: Vechny nejednoznanosti "else" se e piazenm else k poslednmu
nalezenmu if, kter je bez else a je na rovni stejnho bloku. Napklad

   if (x == 1)
      if (y == 1) puts("x=1 a y=1");
   else puts("x != 1");

   vede k nesprvnm zvrm ! Navzdory odsazen pat else ke  druhmu if.
Sprvn zvr je, e x = 1 a y = 1. Uvdomte si efekt sloench zvorek:

   if (x == 1)
   {
      if (y == 1) puts("x=1 a y=1");
   }
   else puts("x != 1");                                    // sprvn zvr


Pkazy switch

   Pkaz switch {pepna} pouv nsledujcho zkladnho formtu:

   switch (pep-vraz) case-pk

   Pkaz  switch  umon  pedat  zen  na  jeden  z  nkolika  pkaz,
oznaench nvtm podle  jednotlivch  ppad,  v  zvislosti  na vrazu
pep-vraz. Ten mus bt celoselnho typu ( v C++ sm  bt  typu tda za
pedpokladu,  e  je  k   dispozici   njak   jednoznan  pevod  na  typ
celoseln). Vechny pkazy v case-pk  (vetn  pkaz  przdnch) lze
opatit jednm i vce nvtmi ppad:


                                  - 102 - 


   case konst-vraz-i : case-pk-i

   kde kad konstanta ppadu {case} konst-vraz-i je  konstantnm vrazem
s  celoselnou  hodnotou  (pevedenou na typ dcho  vrazu),  kter  je
uvnit svho pkazu switch jednoznan.

   Nen dovoleno pouvat ve stejnm pkazu  switch  duplicitnch konstant
case.

   Rovnا lze uvst nejve jedno nvt default:

   default : default-pk

   Po  vyhodnocen vrazu pep-vraz se hled shoda  s  nkterm  z  vraz
konst-vraz-i.  Nalezne-li  se,  pejde  zen  na  pkaz  case-pk-i  s
odpovdajcm nvtm ppadu.

   Pokud se dn shoda nenalezne a je udno nvt default, pejde zen
na default-pk. Pokud se  dn  shoda  nenalezne  a nvt default udno
nen, nevykon se dn z  pkaz case-pk-i. Pi prchodu nvtmi case
a default se innost programu nijak neovlivn. zen se prost  ped pes
nvt na nsledujc pkaz nebo pepna. Chcete-li z uritho dvodu na
konci njak skupiny pkaz program zastavit, uijte pkazu break.


Iteran pkazy
---------------------------------------------------------------------------

   Iteran pkazy umouj vykonvat uritou mnoinu pkaz  cyklicky. V
Turbo C++ existuj ti tvary iterac: cykly while, do a for.


Pkazy while

   Obecn formt tohoto pkazu je

   while (podmnkov-vraz) pk-t

   Zvorky jsou velmi dleit.

   Pkaz cyklu pk-t se  bude  opakovan  vykonvat  tak dlouho, dokud se
podmnkov-vraz nevyhodnot jako nulov (false).

   Nejprve se  vyhodnot a testuje podmnkov-vraz (jak uvdme na strnce
102).  Je-li jeho hodnota nenulov (true), vykon  se  pkaz-t.  Pokud  se
nenaraz na pkaz skoku z  cyklu ven, znovu se vyhodnot podmnkov-vraz.
Tento cyklus se opakuje, dokud nen podmnkov-vraz roven nule.

   Stejn jako u pkaz if lze vrazy typu ukazatel porovnvat  s przdnm
ukazatelem, take while (ptr) je ekvivalentn s

   while (ptr != NULL)...

   Cyklus while nabz spornou metodu prohlen etzc a jinch datovch
struktur s nulovmi termintory:

   char str[10] = "Borland";
        *
   char  ptr = &str[0];
   int count = 0;


                                  - 103 - 


   //...
          *
   while ( ptr++)                             // cyklus a po konec etzce
      count++;

   Nejsou-li ptomny pkazy skoku, mus pk-t  njak  ovlivovat hodnotu
podmnkovho-vrazu, nebo sm  podmnkov-vraz se mus bhem vyhodnocovn
mnit. Jinak by dochzelo k nedoucm nekonenm cyklm.


Pkazy do while

   Obecn formt pkaz je

   do pk-do while (podmnkov-vraz)

   Pkaz pk-do se vykonv  opakovan  tak  dlouho, dokud se podmnkov-
vraz nevyhodnot jako nula (false).  Zsadn  rozdl  proti  pkazu while
spov v tom, e podmnkov-vraz se neovuje ped, ale teprve  po kadm
vykonn pkazu cyklu. Tm je  zajitno  alespo  jedno  vykonn pkazu
pk-do. Pro typ podmnkovho-vrazu plat stejn omezen (skalrn typ).


Pkazy for

   V jazyku C m pkaz for tento formt

   for (<po-vraz>; <test-vraz>; <inkrement-vraz>) pkaz

   V C++ me bt <po-vraz> vrazem nebo deklarac.

   Udlosti probhaj nsledovn:

   1.  Je-li zadn poten vraz po-vraz,  vykon se. Jak ji sm nzev
       napovd, inicializuje  se tm obvykle jeden nebo vce ta cyklu.
       Syntax vak pipout vraz  libovolnho  stupn  sloitosti (vetn
       deklarac v C++). Odtud tak vyplv poadavek, aby se kad program
       v  jazyku  C  dal  zapsat  jako  jedin  cyklus  for.  (Sami to  ale
       nezkouejte. Podobn kousky penechte zkuenm profesionlm.)

   2.  Vyhodnot se test-vraz podle pravidel cyklu while. Je-li test-vraz
       nenulov (true), vykon se pkaz  cyklu. Przdn pkaz se zde bere
       jako while(1), tedy vdy pravdiv. Je-li  hodnota  vrazu test-vraz
       nulov (false), cyklus for se ukon.

   3.  Jeden i vce ta se zv o vraz inkrement-vraz.

   4.  Vyhodnot se vraz pkaz (kter me bt przdn) a zen se vrt
       do 2. kroku.

   Pokud  zstane  nkter  z  volitelnch  prvk przdn, vyaduj  se  na
pslunch mstech stednky:

   for (; ;) {                                     // tot jako for (; 1;)
      // v؟n cyklus
   }

   V jazyku C++ plat pro pkaz for pravidla jazyka C. Vrazem po-vraz v
jazyku C++ vak me bt  i  deklarace.  Obor  deklarovanho identifiktoru
dosahuje a po konec ovldanho pkazu, nikoli za nj. Napklad


                                  - 104 - 


   for (int i = 1; i < j; ++i)
   {
      if (i ...) ...                         // zde je odkaz na i v podku
   }
   if (i...)                       // neppustn; i je nyn mimo svj obor


Pkazy skoku
---------------------------------------------------------------------------

   Vykonnm njakho pkazu skoku se  zen  nepodmnn  ped  na jin
msto v programu.  Takov  pkazy  jsou  tyi:  break,  continue,  goto a
return.


Pkazy break

   Syntax pkazu je

   break;

   Pkazu  break  se  sm pout jen uvnit  njakho  iteranho  pkazu
(cykl while, do a for) nebo pkazu switch. Iteran  pkaz  nebo  pkaz
switch se jm ukon. Protoe iteran pkazy a pkaz switch lze vzjemn
smchat a vnoovat do libovoln hloubky, bute opatrn a zajistte,  aby se
pkazem break konilo ve sprvnm cyklu nebo pepnai. Plat pravidlo, e
pkazem break se ukon nejbli ohraniujc iteran pkaz nebo pkaz
switch.


Pkazy continue

   Syntax pkazu je

   continue;

   Pkazu continue se  sm  pout jen uvnit njakho iteranho pkazu;
pedv  toti  zen  na ovovac podmnku pro cyklus while a  do  a  na
inkrementan vraz v cyklu for.

   Pi pouit  ve vnoench iteranch cyklech se pkaz continue povauje
za pslun k nejbli ohraniujc iteraci.


Pkazy goto

   Syntax pkazu je

   goto nvt;

   Pkazem goto se zen ped na pkaz oznaen  nvtm  nvt (viz
oddl "Pkazy  s  nvtm"  na  strnce  101),  kter se mus nachzet ve
stejn funkci.

   V  jazyku   C++  je  neppustn  obejt  njakou  deklaraci,  kter  m
explicitn nebo implicitn  inicializtor,  ledae by tato deklarace byla v
njakm vnitnm bloku, kter se rovnا obejde.





                                  - 105 - 


Pkazy return

   S vjimkou ppadu, kdy je vsledn hodnota funkce typu void,  mus tlo
funkce obsahovat alespo jeden  pkaz  return  {nvrat}.  Je nsledujcho
formtu:

   return nvrat-vraz;

   kde nvrat-vraz mus bt typu typ  nebo  typu, kter lze na typ pevst
dosazenm. Hodnota vrazu nvrat-vraz je hodnotou, kterou funkce poskytne.
Vrazem, kterm  se funkce vol, jako teba func(sezn-skut-par), nen dn
l-hodnota, ale njak r-hodnota typu typ:

   t = func(arg);                                                     // OK
   func(arg) = t;             // V jazyku C nelze; v C++ jen jestli hodnota
                  // poskytovan funkc je njakm odkazem
   (func(arg))++;                    /* V C nelze; v C++ jen jestli hodnota
                  // poskytovan funkc je njakm odkazem

   Dojde-li  se  k  pkazu  return,  innost  vyvoln  funkce se  ukon.
Jestlie se na dn pkaz return nenaraz, innost "se propadne" a skon
na koncov sloen zvorce tla funkce.

   Pokud je zskan hodnota typu void, lze pkaz return zapsat jako

   {
      ...
      return;
   }

   bez nvratovho vrazu. Alternativou je vyputn pkazu return.































                                  - 106 - 








                            K a p i t o l a   3

                                    C++


   Jazyk  C++  je  v podstat nadmnoinou jazyka C. Znamen to, e - eeno
obecn - program zapsan v jazyku C lze kompilovat pod  C++,  ale program v
jazyku C++ pod  C  kompilovat  nelze,  pokud  takov  program  uv njak
konstrukce specifick pro C++. Nkterm situacch je teba vnovat zvltn
pi.  Napklad  tat  funkce func, deklarovan  v  jazyku  C  dvakrt  s
rozdlnmi typy argument, vyvol chybu kvli duplicit nzvu. V jazyku C++
se vak func bude interpretovat jako funkce pepsan  {overloaded}.  Zda je
to ppustn i nikoli, to bude zviset na jinch okolnostech.

   Akoli  C++  zavd  nov klov slova a operace kvli oetovn td,
pro  nkter  vlastnosti  C++  lze  najt aplikace i mimo jakkoli  kontext
tdy.  Podme nejprve pehled o tch aspektech  C++,  kterch  lze  vyut
nezvisle na tdch. Potom se pustme do problematiky specifick pro tdy
a mechanismus td.


Odkazovn

   Odkazovn a nepm odkazovn prostednictvm ukazatel diskutujeme na
strnce 87.

   Zatmco v jazyku  C  se  argumenty  pedvaj hodnotou, v jazyku C++ lze
argumenty pedvat bodnotou nebo  odkazem.  Odkazov  typy  v C++, je zce
souvis s typy ukazatel, vytvej pro objekty nhradn nzvy neboli alias
a umouj pedvn argument funkcm prostednictvm odkaz.


Jednoduch odkazy
---------------------------------------------------------------------------

   Odkazovho (referennho) deklartoru lze pout k deklaraci  odkaz vn
funkc:

   Uvdomte  si,  e  typ& prom, typ &prom  i  typ  &  prom  jsou  navzjem
ekvivalentn.

   int i = 0;
   int &ir = i;                                        // ir je alias pro i
   ir = 2;                                              // tot jako i = 2

   Za pedpokladu, e inicializtor  je  stejnho  typu  jako odkaz, se tm
vytvo l-hodnota ir coby  alias  pro i. Vechny opertory aplikovan na ir
maj naprosto stejn efekt jako opertory na i. Napklad ir  =  2 dosad 2
do i a &ir poskytne adresu i.







                                  - 107 - 


Argumenty v odkazech
---------------------------------------------------------------------------

   Odkazovho deklartoru lze tak pout k deklaraci  parametr odkazovho
typu uvnit funkce:

   void func1 (int i);
                                                             *            *
   void func2 (int &ir);                       // ir je typu  odkaz na int
   ...
   int sum=3;
   func1(sum);                                     // sum se ped hodnotou
   func2(sum);                                      // sum se ped odkazem

   Argument sum pedvan odkazem lze zmnit pmo funkc  func2.  Na druh
stran  vak  funkce  func1 zsk pouze kopii  argumentu  sum  (pedvanho
hodnotou) a neme tedy samotn sum zmnit.

   Kdy  se  njak  skuten   argument   x   pedv   hodnotou,  dostane
odpovdajc  formln  argument  ve funkci kopii x. dn zmny tto kopie
uvnit  tla  funkce  se  neodraz  v  hodnot  samotnho  x.  Funkce  me
samozejm poskytnout hodnotu, kter lze  pozdji pout ke zmn x. Funkce
vak neme parametr pedvan hodnotou zmnit pmo.

   Metoda  jazyka C pro zmnu x nepouv  samotnho  x,  nbr  skutenho
argumentu  &x, kter je adresou x. I kdy se &x pedv hodnotou, funkce je
schopna  zpstupnit x prostednictvm kopie &x,  kterou  dostane.  I  kdy
funkce nemus x mnit, je pesto uiten (zejmna kvli monm nebezpenm
vedlejm  efektm)   pedvat  j  &x,  zejmna  je-li  x  velkou  datovou
strukturou.  Pedvn  x  pmo  hodnotou  by toti sebou  neslo  zbyten
koprovn tto datov struktury.

   Porovnejte tyto ti implementace funkce treble:

Implementace 1

   int treble_1(n)
   {
              *
      return 3 n;
   }
   ...
   int x, i = 4;
   x = treble_1(i);                                   // nyn x = 12, i = 4
   ...

Implementace 2
                    *
   void treble_2(int  np)
   {
      *      *    *
       np = ( np)  3;
   }
   ...
   treble_2(int &i);                                      // nyn je i = 12

Implementace 3

   void treble_3(int& n)                                 // n je typu odkaz
   {


                                  - 108 - 


           *
      n = 3 n;
   }
   ...
   treble_3(i);                                           // nyn je i = 36

   Deklarac  formlnho argumentu typ& t (nebo  ekvivalentn  typ  &t)  se
ustav t, kter je typu "odkaz na typ". Proto se  pi  vyvoln treble_3 se
skutenm  argumentem  i  pouije  tohoto  i   k   inicializaci  formlnho
                                                                         *
odkazovho argumentu n. Tm se tedy n chov jako alias pro i a tak n = 3 n
                       *
piad do i hodnotu 3   i.

   Je-li inicializtor konstantou nebo objektem  jinho  typu  ne odkazov
typ, vytvo Turbo  C++  doasn  objekt,  pro nj tento odkaz psob jako
alias:

   int& ir = 6;               /* vytvoen doasn celos. objekt, pro nj
                  je ir alias a jen zsk hodnotu 6 */
   float f;
   int& ir2 = f;      /* vytvo doasn celos. objekt, pro nj je alias
               ir2; f se ped dosazenm pevede */
   ir2 = 2.0                 // nyn je ir2 = 2, ale hodnota f se nezmnila

   Automatick  vytven doasnch  objekt  dovoluje  pevody  odkazovch
typ,  kdy   formln  a  skuten  parametry  jsou  typ  rznch  (avak
kompatibilnch v dosazovn). Pi pedvn argument hodnotou  je problm
samozejm m, protoe kopii  skutenho  argumentu  lze ped dosazenm do
formlnho argumentu zmnit fyzicky.



---------------------------------------------------------------------------
Opertor pstupu v oboru
---------------------------------------------------------------------------


   Opertor pstupu v  oboru  (neboli rozlien) :: (dv dvojteky) umon
pstup k nzvu globlnmu (nebo s trvnm v souboru) dokonce i  tehdy, je-
li  zakryt njakou optovnou lokln deklarac tohoto  nzvu  (vce  se  o
oboru dovte na strnce 33).

   Tento zdrojov text funguje i tehdy, kdy je 'global' statick na rovni
souboru.

   int i;                                                     // globln i
   ...
   void func(void);
      {
         int i=0;                           // lokln i zakryje globln i
         i = 3;                                        // toto i je lokln
         ::i = 4;                                     // toto i je globln
         printf ("%d", i);                                    // vytiskne 3

   Opertor :: m dal pouit pro  typy  tda, co probereme dle v tto
kapitole.





                                  - 109 - 


---------------------------------------------------------------------------
Opertory new a delete
---------------------------------------------------------------------------


   Opertory new  a delete umouj dynamicky pidlovat a uvolovat pam؟.
Jejich innost je obdobou standardnch  knihovnch funkc z rodiny malloc a
free (viz Pruka knihovny), ale jsou jim nadazeny.

   Zjednoduen syntax m tvar

   ukazatel-na-nzev = new nzev <inicializtor-nzvu>;
   delete ukazatel-na-nzev

   nzev  me  bt  jakhokoli  typu  s  vjimkou  "funkce poskytujc..."
(pipoutj se vak ukazatele na funkce).

   new se pokus o vytvoen objektu  typu  nzev tm, e pidl (je-li to
mon)  sizeof(nzev)  byt  z  volnho  skladu  (ktermu  se k  heap  =
hromada).  Trvn  novho  objektu  v  pamti  je  vymezeno okamikem  jeho
vytvoen a okamikem, kdy jej opertor delete uvolnnm pamti zlikviduje,
resp. okamikem ukonen programu.

   V  ppad  spchu  poskytne new ukazatel na tento nov objekt. Przdn
ukazatel znamen  nespch  (teba  nedostatek  nebo  fragmentaci  pamti v
heapu). Stejn jako v ppad funkce malloc je i zde poteba ped pokusem o
pstup  do  novho  objektu  ovit,  zda ukazatel nen przdn. Avak  na
rozdl od malloc opertor new vypot velikost nzvu,  ani  by poteboval
explicitn opertor sizeof. Dle, poskytnut ukazatel je ji sprvnho typu
"ukazatel na nzev" a nepotebuje dn explicitn urovn.

   Protoe new je klovm slovem, nepotebuje dn prototyp.
         *
   nazev  nazevptr;                // nazev je libovolnho nefunknho typu
   ...
   if (!(nazevptr = new nazev)) {
      errmsg("Nedostatek pameti pro nazev");
      exit (1);
   }
                                                   *
   // k inicializaci novho objektu nazev se uije  nazevptr
   ...
   delete nazevptr;        // likvidace nazev a uvolnn sizeof(nazev) byt


Oetovn chyb
---------------------------------------------------------------------------

   Lze  definovat  funkci,  kter  se  vyvol  po  nespchu  oprtoru  new
(poskytne-li 0). Existence nov  oetujc  funkce  se opertoru new sdl
volnm set_new_handler a zadnm ukazatele na toto nov oeten. Prototyp
pro set_new_handler (z new.h) vypad nsledovn:
         *                       *
   void ( set_new_handler( void ( ) () )) ();

   set_new_handler  poskytne  starou   oetujc  funkci  a  zmn  funkci
_new_handler, kter nadle bude ukazovat na vmi definovan nov oeten.





                                  - 110 - 


Pole a opertor new
---------------------------------------------------------------------------

   Je-li objekt nzev polem, ukazatel zskan z funkce new ukazuje na prvn
prvek  tohoto  pole.  Pi vytven vcerozmrnch pol funkc new je teba
zadat vechny rozmry pole:

   mat_ptr = new int[3] [10] [12];                                    // OK
   mat_ptr = new int[3] [] [12];                                   // nelze
   mat_ptr = new int[] [10] [12];                                  // nelze


::operator new
---------------------------------------------------------------------------

   Pi pouit na objekty,  kter  nepat do dn tdy, funguje new tak,
e vyvol standardn knihovn rutinu,  kterou je globln ::operator new. V
ppad  objekt  z  tdy, kter jsou typu nzev, lze definovat specifick
opertor s nzvem nzev::operator new. Kdy se new aplikuje  na  objekty  z
tdy  nzev,  vyvol  vhodnou  rutinu  nzev::operator  new,  pokud  je  k
dispozici. V opanm ppad se pouije standardn ::operator new.


Inicializtory s opertorem new
---------------------------------------------------------------------------

   Dal  vhodou  funkce   new   ped   malloc   je   pouit  nepovinnho
inicializtoru  (i  kdy  pidlen  msta  v pamti lze  vynulovat  funkc
calloc).  Nen-li  dn inicializtor explicitn  udn,  obsahuje  objekt,
vytvoen funkc new, nepedvdateln  hodnoty.  Objekty,  jim  funkce new
pidl  msto  v  pamti  a  kter nejsou pole, lze inicializovat  vhodnm
vrazem v zvorkch:

   init_ptr = new int(3);

   Pole td s konstruktory se inicializuj  potenm  konstruktorem (viz
strnku 122). Uivatelsky definovan opertor new  se  zkaznicky upravenou
inicializac  hraje  v  jazyku C++ klovou roli u konstruktor pro objekty
typu tda.



---------------------------------------------------------------------------
Tdy
---------------------------------------------------------------------------


   Tdy v  C++ znamenaj rozen peddefinovan soustavy typ. Kad typ
tda pedstavuje jednoznanou  mnoinu  objekt, jako i operac (metod) a
pevod,  kter  jsou  k dispozici pro vytven,  manipulace  a  likvidace
tchto  objekt.  Lze  deklarovat odvozen tdy, kter dd leny jedn i
vce bzovch (neboli rodiovskch) td.

   V C++  se  struktury  a  uniony  povauj  za tdy s jistm implicitnm
pstupem.

   Zjednoduen, "pibliujc" syntax deklarac tdy vypad takto

   kl-tdy nzev-tdy <: bzov-seznam> {<seznam-len>}



                                  - 111 - 


   kl-tdy je jeden z class, struct nebo union.

   Nepovinn bzov-seznam uvd bzovou  tdu  nebo  tdy, z nich tda
nzev-tdy odvod (neboli zdd) sv  objekty  a  metody.  Pi specifikaci
njakch bzovch td se td  nzev-tdy k odvozen tda (viz oddl
"Pstup do bzovch a odvozench  td" na strnce 116). V bzovm-seznamu
jsou implicitn a  voliteln  specifiktory  pstupu,  kter  jsou schopny
pedefinovnm upravit pstupov prva odvozench td ke  lenm bzovch
td (viz "zen pstupu do len" na strnce 119).

   Nepovinn seznam-len deklaruje leny tdy (data a funkce) nzev-tdy
s implicitnmi a volitelnmi specifiktory pro pedefinovn pstupu. Tmi
lze ovlivnit, kter funkce maj pstup ke kterm lenm.


Nzvy td
---------------------------------------------------------------------------

   nzev-tdy me bt libovoln identifiktor,  kter  je  ve  svm oboru
jednoznan. V ppad struktur, td  a  union  lze  nzev-tdy vynechat
(viz "Neoznaen struktury a definice typ typedef" na strnce 73.)


Typy td
---------------------------------------------------------------------------

   Deklarac se  vytvo  jednoznan  typ  tda  nzev-tdy.  Ten umon
deklarovat dal objekty tdy (neboli instance) tohoto typu  a  objekty od
tohoto typu odvozen (jako jsou ukazatele, odkazy, pole nzev-tdy atd.):

   class X { ... };
             *
   X x, &xr,  xptr, xpole[10];
   /* tyi objekty: typ X, odkaz na X, ukazatel na X a pole z X */

   struct Y { ... };
             *
   Y y, &yr,  yptr, ypole[10];
   // C bude mt
                          *
   // strukturu Y y, &yr,  yptr, ypole[10];

   union Z { ... };
             *
   Z z, &zr,  zptr, zpole[10];
   // C bude mt
                      *
   // union Z z, &zr,  zptr, zpole[10];

   Uvdomte si rozdl mezi deklaracemi struktury a unionu v jazyku C a C++.
V jazyku C jsou klov slova  struct  a  union podstatn, zatmco v C++ je
jich  zapoteb  pouze  tehdy,  kdy  jsou  nzvy  td Y a Z zakryt  (viz
nsledujc oddl).









                                  - 112 - 


Obor nzvu tdy
---------------------------------------------------------------------------

   Obor  nzvu tdy je lokln s  uritmi  vlastnostmi  specifickmi  pro
tdy. Obor nzvu tdy zan v mst deklarace a kon s uzavenm bloku.
Ve svm oboru nzev tdy zakryje vechny tdy, objekty, vty nebo funkce
se  stejnm  nzvem.  Je-li  nzev  tdy  deklarovn  v oboru  obsahujcm
deklaraci njakho objektu, funkce i vtu tho nzvu, pak se lze na tuto
tdu odkazovat jenom uitm propracovanho specifiktoru typu. Znamen to,
e  s  nzvem tdy je nutno ut i kle tdy, tedy  class,  struct  nebo
uinion. Napklad

   struct S { ... };
                  *
   int S(struct S  Sptr);

   void func(void)
   {
      S t;                       // NEPPUSTN deklarace: chyb kl tdy
                     // a funkce S v oboru
      struct S s;                          // OK: propracovno klem tdy
      S(&s);                                     // OK: jde o voln funkce
   }

   C++ pipout tak neplnou deklaraci tdy:

   class X;                                            // zatm bez len !
   struct Y;
   union Z;

   Nepln deklarace dovoluj urit odkazy na nzvy td X, Y a Z (obvykle
odkazy na ukazatele na objekty td) jet ped plnou definic tchto td
(viz  "Deklarace  len  struktury" na strnce 73). Ne mete deklarovat a
pouvat objekty tdy,  muste  samozejm  udlat  plnou  deklaraci tto
tdy i s jejmi leny.


Objekty td
---------------------------------------------------------------------------

   Do objekt td lze dosazovat  (ledae by koprovn bylo zakzno), lze
je pedvat jako argumenty do funkce, lze je zskvat jako  vsledek funkce
(s jistmi vjimkami) atd. Uivatelsky lze definovat mnoh  jin  operace s
objekty a leny td, vetn lenskch a sptelench funkc. Pi pouit s
objekty urit tdy je mono standardn funkce a  operace  definovat nov.
Pedefinovanm funkcm a operacm se  k  pepsan.  Opertory  a funkce,
kter jsou omezeny na objekty urit tdy (nebo  spznn  skupiny td),
se nazvaj lensk funkce pro  takovou tdu. C++ nabz mechanismus, jm
lze volat tent nzev funkce nebo opertoru pro vykonn rozdlnch loh v
zvislosti na typu nebo potu argument i operand.


Seznam len tdy
---------------------------------------------------------------------------

   Nepovinn  seznam-len je posloupnost deklarac dat (jakhokoli  typu,
vetn vt, bitovch poloek a jinch td), jako i deklarac  a definic
td.  Vechny  mohou  mt  nepovinn   specifiktory   pam؟ov   tdy  a
modifiktory pstupu.  Takto  definovanm  objektm  se  k  leny td.



                                  - 113 - 


Nejsou dovoleny specifiktory pam؟ov tdy auto, extern a register. leny
lze deklarovat se specifiktory pam؟ov tdy static.


lensk funkce
---------------------------------------------------------------------------

   Funkci deklarovan  bez specifiktoru friend se k lensk funkce dan
tdy.  Funkcm  deklarovanm  s  modifiktorem  friend   se   k  funkce
sptelen.

   Jednoho  a tho nzvu lze pout k oznaen  vce  ne  jedin  funkce,
pokud se tyto li v typu argument nebo v potu argument.


Klov slovo this
---------------------------------------------------------------------------

   Nestatick lensk funkce psob na objektech typu tda,  s  nimi jsou
vyvolny. Je-li napklad  x  objektem  tdy  X  a f je lenskou funkc X,
psob vyvoln funkce x.f() ma x. Podobn je-li xptr ukazatelem  na objekt
                                       *
X, psob vyvoln funkce xptr->f() na  xptr. Jak se vak f dov, na kterm
x  m psobit ? Jazyk C++ vybav funkci f ukazatelem na x, ktermu se  k
this.  Takov  ukazatel  this   {tento}   se   pedv  ve  vech  volnch
nestatickch lenskch funkc jako neviditeln argument.

   Klov slovo this  je  lokln  promnnou,  kter je k dispozici v tle
kad nestatick lensk funkce. this nen teba deklarovat a jen zdka se
na n  v  definici  funkce  odkazuje.  Uvnit  funkce se j vak implicitn
pouv k odkazm na leny. Napklad pi vyvoln x.f(y), kde y je len X,
se this nastav na &x a y se nastav na this->y, co je ekvivalentn s x.y.


Funkce inline
---------------------------------------------------------------------------

   lenskou  funkci je mono deklarovat uvnit sv  tdy  a  definovat  ji
kdekoli jinde.  Ppadn lze njakou lenskou funkci deklarovat i definovat
uvnit sv tdy a pak se j k funkce inline {vestavn, vnitn}.

   Jazyk  Turbo  C++  doke nkdy omezit ztا  normlnho  voln  funkce
nahrazenm tohoto voln  funkce  pmo  zkompilovanm  kdem  tla funkce.
Tento  proces,  ktermu  se k vnitn rozvoj tla funkce, neovlivn obor
nzvu funkce ani  jej  argumenty.  Vnitn  rozvoj  nen  vdy  mon nebo
ppustn.   Specifiktor  inline  pedstavuje  dost  (nebo  nvrh)   pro
kompiltor, e byste  uvtali  vnitn rozvoj. Jako v ppad specifiktoru
pam؟ov tdy register kompiltor me, ale nemus nvrh pijmout !

   Explicitn i implicitn dosti inline  je  nejlpe  vyhradit  pro mal,
asto  pouvan funkce, jakmi jsou teba  opertorov  funkce,  jimi  se
implementuj pepsan opertory. Napklad nsledujc deklarace tdy:

   int i;                                            // globln cel slo

   class X {
   public:
          *
      char  func(void) { return i; }                   // implicitn inline



                                  - 114 - 


          *
      char  i;
   };

   je ekvivalentn s:
              *
   inline char  X::func(void) { return i; }

   func  se definuje "vn" tdy s  explicitnm  specifiktorem  inline.  i
                        *
zskan z func  je  char  i z tdy X - viz oddl o oboru len, zanajc
na strnce 114.


Statick leny
---------------------------------------------------------------------------

   V deklaracch td datovch a  funknch  len  lze  ut specifiktoru
pam؟ov tdy static. Takovm  lenm  se potom k statick leny a maj
valstnosti odlin od  len  nestatickch.  V  ppad  nestatickch len
"existuje" ke kadmu objektu v jeho td zeteln kopie. V  ppad len
statickch  existuje jen jedna kopie a tu lze  zpstupnit  bez  odkazu  na
jakkoli konkrtn objekt v jeho td. Je-li x statick len tdy  X, lze
se na nj odkzat jako na X::x (dokonce i kdy objekty tdy X nebyly dosud
vytvoeny).  Stle  je  mon  doshnout  x uitm opertor  pro  normln
pstup ke lenm.  Napklad y.x a yptr->x, kde y je objekt tdy X a yptr
je ukazatel na objekt tdy X,  akoli  vrazy y a yptr nejsou vyhodnoceny.
Konkrtn  lze  vyvolat  statickou  lenskou  funkci  se  speciln syntax
lensk funkce nebo i bez n:

   class X {
      int clen_int;
   public:
                               *
      static void func(int i, X  ptr);
   };

   void g(void);
   {
      X obj;
      func(1, &obj);            // chyba, pokud neexistuje nkde definovan
                           // globln func()
      X::func(1, &obj);                    // vyvol se statick func() v X
                        // OK jen pro statick funkce
      obj.func(1, &obj);      // stejn i zde (OK pro statick i nestatick
                  // funkce)
   }

   Protoe  statickou lenskou funkci lze volat,  ani  bychom  mysleli  na
njak konkrtn  objekt, nem takov funkce dn ukazatel this. Dsledkem
toho je, e  statick  lensk funkce nemohou zpstupnit nestatick leny,
ani by objekt byl expilcitn specifikovn pomoc . nebo ->.  Napklad pi
deklaracch z minul ukzky by bylo mono func definovat nsledovn:









                                  - 115 - 


                        *






   void X::func(int i, X  ptr)
   {
      clen_int = i;            // Chyba: Kterho objektu se tk clen_int ?
      ptr->clen_int = i;                                 // OK: u se to v

   Nehled na funkce  inline,  statick lensk funkce globlnch td maj
vnj spojovn. Statick lensk funkce nemohou bt funkcemi virtulnmi.
Existence statickch i nestatickch lenskch funkc se stejnmi typy nzvu
a argument nen dovolena.

   Deklarace  statickho  datovho  lenu  v  deklaraci  jeho   tdy  nen
definic. Proto se nkde mus vyskytovat definice, aby se vyhradila pam؟ a
vykonala inicializace.

   Statick leny  njak tdy deklarovan jako lokln pro uritou funkci
nemaj dn spojovn a  nelze  je  inicializovat. Statick leny globln
tdy lze inicializovat jako normln globln objekty, ale  jenom  v oboru
soubor. Statick leny podlhaj  obvyklm  pravidlm  pro pstup do lenu
tdy a na to, e je lze inicializovat.

   class X {
      ...
      static int x;
      ...
   };

   int X::x = 1;

   Hlavn vyuit statickch len spov  ve  sledovn  dat,  kter jsou
spolen  pro  vechny   objekty   dan  tdy.  Jsou  to  napklad  poty
vytvoench objekt  nebo naposledy pouit zdroj z oblasti, kterou vechny
takov objekty sdlej. Statickch len se pouv tak ke

    o  snen potu viditelnch globlnch nzv

    o  vytvoen pehledu, kter statick objekty  logicky  pat  ke kter
       td

    o  povolen zen pstupu k jejich nzvm


Obor len
---------------------------------------------------------------------------

   Ve vrazu X::func() v ukzce na strnce 115 se pouv  nzvu  tdy X s
modifiktorem pstupu v oboru.  Tm  se vyzna, e funkce func, akoli je
definovna "vn" dan tdy, je opravdu lenskou funkc X a existuje uvnit
oboru X. Vliv X:: se roz do tla definice. Tm je vysvtleno, pro func
poskytne i, kter se nevztahuje ke globlnmu int i, ale  k  X::i, kter je
    *
char_ i z X. Nebt modifiktoru X::, funkce func by pedstavovala obyejnou
funkci, nepatc do dn tdy a poskytla by globln int i.



                                  - 116 - 


   Vechny  lensk  funkce tedy pat do oboru  sv  tdy,  i  kdy  jsou
definovny vn tto tdy.

   Na datov leny tdy X se lze odkazovat pouitm vbrovch opertor .
a  -> (jako v ppad struktur v jazyku C). lensk funkce lze rovnا volat
uitm vbrovch opertor (viz  t  "Klov  slovo this", strnka 114).
Napklad

   class X {

   public:
      int i;
      char nazev[20];
        *
      X  ptr1;
        *
      X  ptr2;
                     *       *        *
      void Xfunc(char data, X  leve, X  prave);// nkde jsou definovny
   };
   void f(void);
   {
                *
      X x1, x2,  ptr=&x1;
      x1.i = 0;
      x2.i = x1.i;
      xptr->i = 1;
      x1.Xfunc("stan", &x2, xptr);
   }
   Je-li m len nebo bzov len tdy X, k se vrazu X::m kvalifikovan
nzev.  M  stejn  typ  jako  m  a je l-hodnotou pouze tehdy, je-li  m  l-
hodnotou. Dleit je, e i kdy je nzev tdy X zakryt njakm netypovm
nzvem, kvalifikovanm  nzvem X::m se doshne sprvnho lenu tdy, toti
m.

   leny tdy nelze  ke  td  pidvat  v jinm oddlu programu. Tda X
neme obsahovat objekty tdy X,  ale me obsahovat ukazatele nebo odkazy
na objekty tdy X (uvdomte si podobnost s typy struktur a union v jazyku
C).


zen pstupu do len

   leny  njak  tdy  zskvaj  atributy  pstupu  bu  implicitn  (v
zvislosti na kli tdy a umstn deklarace), nebo uitm jednoho ze t
specifiktor pstupu: public, private  a  protected.  Tyto  atributy maj
nsledujc vznam:

public            len se me pouvat v libovoln funkci.

private           len  se  me  pouvat  jenom  v  lenskch  funkcch a
                  sptelench funkcch t tdy, v n je deklarovn.

protected         Tot jako private, ale len  se  me  navc  pouvat v
                  lenskch  funkcch a sptelench funkcch odvozench  z
                  deklarovan tdy,  avak  jenom  v  objektech odvozenho
                  typu. (Odvozen tdy vysvtlme v ptm oddlu.)

   Deklarace  sptelench  funkc  nejsou specifiktory pstupu ovlivnny
(viz "Sptelen funkce td", strnka 119).


                                  - 117 - 


   leny tdy jsou implicitn private, take k  pedefinovn implicitnho
nastaven  je  zapoteb explicitnch specifiktor  pstupu  public  nebo
protected.

   leny  njak  stuktury  struct  jsou  implicitn public, co  lze  vak
pedefinovat specifiktorem pstupu private nebo protected.

   leny unionu union jsou implicitn  public. Toto nelze zmnit. Pro leny
union jsou vechny ti specifiktory pstupu nedovolen.

   Implicitn nebo pedefinovan modifiktor pstupu zstv v  innosti i
pro vechny nsledn deklarace len tak dlouho, dokud se nevyskytne njak
odlin modifiktor pstupu. Napklad

class X {
      int i;                                  // X::i je implicitn private
      char ch;                                        // rovnا tak i X::ch
   public:
      int j;                                       // dal dva jsou public
      int k;
   protected:
      int l;                                           // X::l je protected
   };

   struct Y {
      int i;                                   // Y::i je implicitn public
   private:
      int j;                                             // Y::j je private
   public:
      int k;                                              // Y::k je public
   };

   union Z {
      int i;                       // implicitn public; nen jin monosti
      double d;
   };

   Specifiktory pstupu lze uvdt a seskupovat podle poteby v libovoln
posloupnosti.  Uette  si napklad trochu  psan,  budete-li  deklarovat
vechny leny private spolen atd.


Pstup do bzovch a odvozench td
---------------------------------------------------------------------------

   Pi deklaraci odvozen tdy D se uvd seznam bzovch td B1, B2... v
bzovm-seznamu, kde jsou navzjem oddleny rkami:

   kl-tdy D: bzov-seznam {<seznam-len>}

   Tda  D  zdd  vechny  leny   tchto  bzovch  td.  (Zdd  se  i
pedefinovan  leny  bzov  tdy  a  pokud je teba, lze jich  doshnout
uitm  pedefinovanch  obor.)  D me pouvat jenom  tch  len  svch
bzovch  td, kter jsou public a protected.  Jak  vak  budou  atributy
pstupu tchto zddnch  len  z  pohledu  D  ? Tda D me pout len
public  z  bzov  tdy, ale pokud jde o vnj funkce,  me  jej  uinit
private. eenm je pouit specifiktor pstupu v bzovm-seznamu.





                                  - 118 - 


   Jeliko  bzov  tda  me sama bt tdou  odvozenou,  je  zleitost
atributu  pstupu rekurzivn: postupuje se stle  zpt,  a  doshneme  t
nejzkladnj ze vech bzovch td, kter ji nic nedd.

   Pi deklaraci  D lze v bzovm-seznamu pout ped tdami specifiktor
pstupu public nebo private:

   class D : public B1, private B2, ... {
   ...
   }

   V bzovm seznamu nelze ut  protected. Uniony nemohou mt bzov tdy
a ani jako bzovch td nelze union pout.

   Tmito modifiktory se nezmn atributy  pstupu  do  bzovch  len z
pohledu bzov tdy, akoli atributy  pstupu  bzovch  len  z pohledu
odvozen tdy se zmnit mohou.

   Je-li  D  deklarac  class,  implicitn  se  nastav  private.  Je-li  D
deklarac struct, nastav se implicitn public.

   Odvozen  tda  dd  atributy  pstupu  z  bzov  tdy nsledujcm
zpsobem:

bzov tda public:     leny public z bzov tdy se stanou leny public
                         z  tdy odvozen. leny protected z bzov  tdy
                         se stanou leny  protected z tdy odvozen. leny
                         private  z  bzov  tdy  zstanou   private  pro
                         bzovou tdu.

bzov tda private:    leny public i protected z bzov tdy  se stanou
                         leny  private tdy  odvozen.  leny  private  z
                         bzov tdy zstanou private pro bzovou tdu.

   V obou ppadech si  dobe  zapamatujte, e leny private z bzov tdy
jsou a zstanou pro lensk funkce odvozen tdy  nedostupnmi,  ledae by
se explicitn deklarovaly v bzov td deklarace friend, kter by pstup
umonily. Napklad

   class X : A {                 // implicitn nastaven tdy je private A
   ...
   }
   /* tda X je odvozena z tdy A */

   class Y : B, public C {           // pedefinovat implicitn nastaven C
   ...
   }
   /* tda Y je odvozen (vcensobn ddn) z B a C
      B je implicitn private B */

   struct S : D {                       // struktura je implicitn public D
   ...                                    /* struktura S je odvozena z D */
   }
   struct T : private D, E {         // pedefinovat implicitn nastaven D
                                                  // E je implicitn public
   ...
   }
   /* struktura T je odvozen (vcensobn ddn) z D a E
      E je implicitn public E */



                                  - 119 - 


   Efekt specifiktor  pstupu  v  bzovm  seznamu  lze  nastavit uitm
kvalifikovanho-nzvu v deklaracch public nebo protected v odvozen td.
Napklad

   class B {
      int a;                                          // implicitn private
   public:
      int b, c;
      int Bfunc(void);
   };

   class X : private B {            // a, b, c, Bfunc jsou nyn private v X
      int d;                      // implicitn private, UPOZORNN: a nen
                     v X dostupn
   public:
      B::c;                               // C bylo private, nyn je public
      int e;
      int Xfunc(void);
   };

   int Efunc(X& x);                                    // extern pro B i X

   Funkce Efunc me pouvat jenom nzv c, e a Xfunc, kter jsou public.

   Funkce Xfunc je v X, kter je odvozena z private B. M proto pstup k

    o  c, kter je "nastaven-na-public"

    o  lenm z B:b a Bfunc, kter jsou "private-vi-X"

    o  lenm d, e a Xfunc, kter jsou z X a jsou private a public

   Xfunc vak neme doshnout a, kter je len "private-vi-B".



---------------------------------------------------------------------------
Virtuln bzov tdy
---------------------------------------------------------------------------


   V ppad  vcensobnho  ddn  nelze  v  odvozen  td specifikovat
bzovou tdu vce ne jednou:

   class B { ... };
   class D : B, B { ... };                                         // nelze

   Bzovou tdu lze vak do tdy odvozen pedat vcekrt nepmo:

   class X : public B { ... }
   class Y : public B { ... }

   class Z : public X, public Y { ... }                               // OK

   V takovm ppad bude mt kad objekt tdy Z dva dl  objekty tdy
B. Pokud by tm vznikly pote, lze ke specifiktoru  bzov  tdy  pidat
klov slovo virtual. Napklad

   class X : virtual public B { ... }
   class Y : virtual public B { ... }


                                  - 120 - 


   class Z : public X, public Y { ... }

   B je nyn virtuln {zdnlivou} bzovou tdou a tda Z m  jenom jeden
dl objekt tdy B.



---------------------------------------------------------------------------
Sptelen funkce td
---------------------------------------------------------------------------


   friend  F tdy X je funkc nebo tdou, kter i kdy nen lenem X,  m
pln prvo pstupu ke lenm X,  kter  jsou private a protected. Po vech
jinch  strnkch  je F normln funkc s  ohledem  na  obor,  deklarace  i
definice.

   Protoe  F nen lenem X, nen ani v oboru X a nelze ji volat  vbrovm
opertorem x.F i  xptr->F  (x je objekt z X a xptr je ukazatel na objekt z
X).

   Pouije-li  se  v   deklaraci   nebo  definici  funkce  uvnit  tdy  X
specifiktoru friend, stane se takov funkce sptelenou s X.

   Sptelen funkce  definovan  uvnit  njak  tdy  podlhaj  stejnm
pravidlm 'inline'  jako funkce lensk (viz "Funkce inline", strnka 114).
Na  sptelen  funkce  nem  vliv  jejich umstn uvnit tdy ani  dn
specifiktory pstupu. Napklad

   class X {
      int i;                                              // private vi X
                               *
      friend void friend_func(X , int);
   /* friend_func nen private, pestoe je deklar. v oddlu private */
   public:
      void clen_func(int);
   };

   /* definice; pamatujte, e ob funkce maj pstup k int i, kter je
      private */
                     *
   void friend_func(X  xptr, int a) { xptr->i = a; }
   void X::clen_func(int a) { i = a; }

   X xobj;

   /* uvdomte si rozdl ve voln funkc */
   friend_func(&xobj, 6);
   xobj.clen_func(6);

   Vechny  funkce tdy Y lze uinit sptelenmi  vi  td  X  jedinou
deklarac:

   class Y;                                            // nepln deklarace
   class X {
      friend Y;
      int i;
      void clen_funcX();
   };



                                  - 121 - 


   class Y; {                                        // dokonen deklarace
      void friend_X1(X&);
      void friend_X2(X&);
      ...
   };

   Funkce  deklarovan  v  Y jsou sptelen  s  X,  i  kdy  nemaj  dn
specifiktory friend. Maj pstup  do  len  X,  kter jsou private, jako
jsou i a clen_funcX.

   Je rovnا mon,  aby  se  individuln  lensk  funkce  tdy  X stala
sptelenou s tdou Y:

   class X {
      ...
      void clen_funcX();
   }

   class Y {
      int i;
      friend void X::clen_funcX();
      ...
   };

   Ptelstv s tdou nen tranzitivn: kdy  X  je  sptelen s Y a Y je
sptelen  se Z, neznamen to, e tak X je sptelen se Z. Ptelstv se
vak dd.



---------------------------------------------------------------------------
Konstruktory a destruktory
---------------------------------------------------------------------------


   Existuje nkolik specilnch  lenskch  funkc,  kter  uruj,  jak se
tvo,   inicializuj,   kopruj  a  likviduj   objekty   njak   tdy.
Nejdleitj  z  nich  jsou  konstruktory  a   destruktory.   Maj  mnoh
charakteristiky normlnch  lenskch  funkc  -  deklaruj  a  definuj se
uvnit tdy, nebo se deklaruj uvnit tdy a definuj se vn - ale maj i
nkter jedinen vlastnosti.

   1.  Nemaj deklarace vsledn hodnoty (dokonce ani ne void).

   2.  Nelze je  zddit, pestoe odvozen tdy mohou volat konstruktory i
       destruktory tdy bzov.

   3.  Konstruktory,  stejn jako vtina funkc v  jazyku  C++,  me  mt
       implicitn argumenty nebo pouvat seznam inicializac len.

   4.  Destruktory mohou bt virtuln, avak konstruktory nikoli.

   5.  Nelze zskat jejich adresy.

       main()
       {
          ...
               *
          void  ptr = baze::baze;                                  // nelze
          ...


                                  - 122 - 


       }

   6.  Konstruktory  a  destruktory  lze  v  jazyku  Turbo  C++  generovat,
       jestlie nebyly definovny explicitn; pi mnoha pleitostech se v
       programu   spust   tak   i   bez  explicitnho  vyvoln.  Vechny
       konstruktory i destruktory generovan kompiltorem budou public.

   7.  Konstruktory nelze volat zpsobem, jakm se volaj  normln funkce.
       Destruktory  lze volat,  pouijete-li  jejich  pln  kvalifikovanch
       nzv.

       {
       ...
            *
          X  p;
       ...
          p->X::~X();                       // ppustn voln destruktoru
          X::X()                         // neppustn voln konstruktoru
       ...
       }

   8.  Kompiltor  automaticky   vol   konstruktory   a   destruktory  pi
       definovn a likvidaci objekt.

   9.  Jestlie se  pro  njak  objekt  vyaduje  pidlen  pamti, mohou
       konstruktory a destruktory implicitn volat opertor new  a opertor
       delete.

  10.  Objektu s  konstruktorem  a  destruktorem  nelze  pout  jako lenu
       dnho unionu.

   M-li tda X jeden i vce konstruktor, pi kadm definovn njakho
objektu x  tdy  X  se  jeden z nich vyvol. Tento konstruktor vytvo x a
inicializuje ho. Destruktory postupuj zase  obrcen  a  likviduj objekty
td, vytvoen konstruktory.

   Konstruktory se rovnا volaj  pi  vytven  loklnch  nebo doasnch
objekt njak tdy. Destruktory  se  volaj,  kdy tyto objekty opoutj
obor.



---------------------------------------------------------------------------
Konstruktory
---------------------------------------------------------------------------


   Konstruktory  se  li  od vech ostatnch lenskch funkc tm, e maj
stejn nzev jako tda, k n pat. Kdy se vytv nebo  kopruje njak
objekt tto tdy, implicitn se vol potebn konstruktor.

   Konstruktory globlnch promnnch se volaj ped vyvolnm funkce main.
Kdy  se  pouije  spoutc direktiva pragma, aby  se  instalovala  njak
funkce ped main,  volaj  se konstruktory globlnch promnnch jet ped
spoutcmi funkcemi.

   Lokln  objekty  se  vytvej,  jakmile  se obor dan  promnn  stane
aktivnm. Konstruktor se vol tak  pi  vytven  doasnho  objektu dan
tdy.



                                  - 123 - 


   class X
   {
   public:
      X();                                           // konstruktor tdy X
   };

   Konstruktor tdy X neme pejmat X jako svj argument:

   class X {
   ...
   public:
      X(X);                                                        // nelze
   }

   Parametry konstruktoru  mohou  bt  jakhokoli  typu  s  vjimkou tdy,
jejm je lenem. Konstruktor  me  pejmat  jako  parametr odkaz na svou
vlastn  tdu.   Je-li  tomu  tak,  k  se  mu  koprovac  konstruktor.
Konstruktor,   kter   nepejm   dn   parametr,  se  nazv  poten
konstruktor.   Poten   konstruktor   probereme   te,   zatmco   popis
koprovacho konstruktoru zan na strnce 127.


Poten konstruktor
---------------------------------------------------------------------------

   Potenm konstruktorem pro tdu  X  je  takov, kter nepejm dn
argumenty:  X::X().  Neexistuj-li  pro  tdu dn uivatelsky definovan
konstruktory, jazyk Turbo C++ generuje poten konstruktor. Pi deklaraci
jako nap. X x vytvo poten konstruktor objekt x.

Dleit!
   Jako vechny funkce,  i  konstruktory  mohou  mt  implicitn argumenty.
Napklad konstruktor

   X::X(int, int = 0)

   me pejmat jeden i dva argumenty. Pi uveden  s  jedinm argumentem
se  chybjc druh argument povauje za nulov  cel  slo  int.  Podobn
konstruktor

   X::X(int = 5, int = 6)

   by mohl mt dva,  jeden  nebo  dn  argument s potebnmi implicitnmi
hodnotami. Poten konstruktor X::X() vak  nepejm  dn  argumenty a
nesmte jej zamovat napklad  s  X::X(int = 0), kter pejm jeden nebo
dn argument.

   Dejte    pozor,    abyste    se    pi   voln   konstruktor   vyhnuli
nejednoznanostem.  V  nsledujcm  ppad  by  mohlo   dojt   k  zmn
potenho konstruktoru a konstruktoru, pejmajcho cel slo:

   class X
   {
   public:
      X()
      X(int i = 0);
   };

   main()
   {


                                  - 124 - 


      X jedna(10);                                 // OK; pouv X::X(int)
      X dva;      // nelze; nen jasno, zda volat X::X() nebo X::X(int = 0)
   ...
   return 0;


Koprovac konstruktor
---------------------------------------------------------------------------

   Koprovacm konstruktorem pro  tdu  X je takov konstruktor, kter lze
volat s jedinm argumentem typu X: X::X(const X&) nebo X::X(const X&, int =
0). V koprovacm konstruktoru jsou dovoleny  rovnا  implicitn argumenty.
Koprovac konstruktory se vyvolaj pi koprovn  objektu  tdy, zejmna
pi deklaraci s inicializac objektem jin tdy X x =  y.  Jazyk Turbo C++
pro tdu X koprovac konstruktor generuje, je-li njak zapoteb a dn
nen v td X definovn.


Pepisovn konstruktor
---------------------------------------------------------------------------

   Konstruktory  lze  pepisovat,  m  se  umon  vytvoen   objekt  v
zvislosti na hodnotch pouitch k inicializaci.

   class X
   {
      int cela_cast;
      double dvoj_cast;
   public:
      X(int i)    { cela_cast = i; }
      X(double d) { dvoj_cast = d; }
   };

   main()
   {
      X jedna(10);         // vyvol se X::X(int) a nastav cela_cast na 10
      X jedna(3.14);          // vyvol se X::X(double) a nastav dvoj_cast
   ...
      return 0;
   }


Poad voln konstruktor
---------------------------------------------------------------------------

   V  ppad,  kdy  njak  tda  m  jednu  i  vce  td bzovch,  se
konstruktory bzov  tdy  vyvolaj  ped  konstruktorem  tdy  odvozen.
Konstruktory bzov tdy se volaj v poad sv deklarace.

   V tomto nastaven, napklad,

   class Y { ... }
   class X : public Y { ... }
   X jedna;

   se konstruktory volaj v nsledujcm poad:

   Y();                                         // konstruktor bzov tdy
   X();                                       // konstruktor odvozen tdy



                                  - 125 - 


   V ppad vce bzovch td:

   class X : public Y, public Z
   X jedna;

   se konstruktory volaj v poad deklarace:

   Y();                               // nejprve konstruktory bzovch td
   Z();
   X();

   Konstruktory  pro  virtuln  bzov  tdy  se  vyvolvaj  ped  vemi
nevirtulnmi   bzovmi   tdami.  Obsahuje-li   hierarchie   vcensobn
virtuln bzov tdy, vyvolvaj se konstruktory virtuln bzov tdy v
poad sv deklarace. Vechny nevirtuln bze se pak konstruuj jet ped
vyvolnm konstruktoru tdy odvozen.

   Je-li njak virtuln tda  odvozena  z  nevirtuln bze, pijde tato
nevirtuln bze na adu prvn, aby se mohla virtuln bzov tda sprvn
zkonstruovat. Zdrojov text

   class X : public Y, virtual public Z
   X jedna;

   vede k tomuto poad:

   Z();                              // inicializace virtuln bzov tdy
   Y();                                         // nevirtuln bzov tda
   X();                                                   // odvozen tda

   Nebo ve sloitjm pkladu:

   class baze;
   class baze2;
   class uroven1 : public baze2, virtual public baze;
   class uroven2 : public baze2, virtual public baze;
   class vrchuroven : public uroven1, virtual public uroven2;
   vrchuroven viditel_objekt;

   Konstrukn poad objektu viditel_objekt bude nsledujc:

   baze();                  // virtuln bzov tda nejvy v hierarchii
                  // bze se konstruuje pouze jednou
   baze2();                  // nevirtuln bze pro virtuln bzi rovn2
                  // mus se volat kvli konstrukci rovn2
   uroven2();                                     // virtuln bzov tda
   baze2();                                     // nevirtuln bze rovn1
   uroven1();                                     // dal nevirtuln bze
   vrchuroven();

   V ppad, kdy tdn hierarchie  obsahuje  vcensobn  instance njak
virtuln  bzov  tdy,  se tato bzov tda  konstruuje  pouze  jednou.
Jestlie vak  existuj  virtuln  i  nevirtuln  instance  bzov tdy,
konstruktor  dan  tdy  se vyvol jednou pro vechny virtuln instance a
pak vdy jednou pro kad nevirtuln vskyt bzov tdy.

   Konstruktory  pro prvky njakho pole se  volaj  ve  vzestupnm  poad
index.




                                  - 126 - 


Inicializace tdy
---------------------------------------------------------------------------

   Objekt njak tdy  pouze  se  leny  public  a  bez  konstruktor nebo
bzovch    td    (obvykle    struktura)   lze   inicializovat   seznamem
inicializtor. M-li tda njak  konstruktor,  mus  se jej objekty bu
inicializovat,  nebo  mus  mt  njak  poten  konstruktor.  V ppad
objekt, kter se neinicializuj explicitn, se pouv druh monosti.

   Objekty  td  s  konstruktory  lze  inicializovat  seznamem   vraz  v
zvorkch.  Tohoto  seznamu  se   pouije   jako   seznamu   argument  pro
konstruktor.  Alternativn lze pout znamnka rovnosti  a  za  nm  jedin
hodnoty. Tato jedin hodnota me bt typu prvnho argumentu, kter pejm
konstruktor dan tdy. V  takovm  ppad  bu  ji dn dal argumenty
neexistuj, nebo  zbvajc  argumenty  maj  implicitn  hodnoty.  Me se
jednat  tak  o  objekt  danho  typu  tdy.  V  prvm  ppad   se  vol
odpovdajc konstruktor k vytvoen objektu.  Ve  druhm  ppad  se vol
koprovac konstruktor k inicializaci objektu.

   class X
   {
      int i;
   public:
   X();                // kvli lep srozumitelnosti vynechna tla funkc
   X(int x);
   X(const X&);
   };

   main()
   {
      X jedna;                             // vyvoln poten konstruktor
      X dva(1);                         // pouv se konstruktor X::X(int)
      X tri = 1;                                          // vol X::X(int)
      X ctyri = jedna;                 // vyvol X::X(const X&) kvli kopii
      X pet(dva);                                    // vol X::X(const X&)
   }

   Konstruktor me do svch  len  dosazovat  hodnoty dvma zpsoby. Me
pijmout  tyto  hodnoty  za parametry a uinit dosazen do promnnch len
uvnit funknho tla konstruktoru:

   class X
   {
      int a, b;
   public:
      X(int i, int j) { a = i; b = j }
   };

   Nebo me jet ped tlem funkce pout seznam inicializtor:

   class X
   {
      int a, b;
   public:
      X(int i, int j) : a(i), b(j) {}
   };

   V obou ppadech se inicializac X x(1, 2) dosad do x::a hodnota 1 a do
x::b  hodnota  2.  Druh  metoda,  toti  seznam  inicializtor, poskytuje
mechanismus k pedvn hodnot smrem do konstruktor bzov tdy.


                                  - 127 - 


   Aby se daly volat  z  odvozen tdy, mus bt konstruktory bzov tdy
deklarovny bu jako public nebo jako protected.

   class baze1
   {
      int x;
   public:
      baze1(int i) { x = i; }
   };

   class baze2
   {
      int x;
   public:
      baze2(int i) : x(i) {}
   };

   class vrch : public baze1, public baze2
   {
      int a, b;
   public:
                                 *
      top(int i, int j) : baze1(i 5, baze2(j+i), a(i) { b = j }
   };

   Pi  tto  tdn  hierarchii by deklarace  vrch  jedna(1,  2)  vedla  k
inicializaci baze1 s hodnotou  5  a baze2 s hodnotou 3. Metody inicializace
lze vzjemn mchat.

   Jak jsme popsali dve, bzov tdy se inicializuj v poad deklarace.
Potom  se   inicializuj  leny,  t  v  poad  deklarace,  nezvisle  na
inicializanm seznamu.

   class X
   {
      int a, b;
   public:
      X(int i, j) : a(i), b(a+j) {}

   Pro takovou tdu  vede  deklarace X x(1, 1) k dosazen 1 do x::a a 2 do
x::b.

   Konstruktory bzov tdy  se  volaj ped konstrukc jakhokoli z len
td  odvozench.  Hodnoty  odvozen  tdy  nelze  zmnit  a ovlivnit  tm
vytvoen tdy bzov.

   class baze
   {
      int x;
   public:
      baze(int i) : x(i) {}
   };

   class odvoz : baze
   {
      int a;
   public:
                        *
      odvoz(int i) : a(i 10), baze(a) { }     // Pozor ! Do baze se pedv
                              // neinicializovan a.


                                  - 128 - 


   };

   Pi takovm nastaven tdy nepovede voln odvozen d(1)  k  hodnot 10
lenu x bzov tdy. Hodnota pedan do konstruktoru  bzov  tdy nebude
definovna.

   Pokud  chcete  v  konstruktoru,   kter   nen   'inline',   mt  seznam
inicializtor, nedvejte tento seznam  do  definice  tdy. Msto toho jej
vlote do msta, kde se definuje tato funkce.

   odvoz::odvoz(int i) : a(i)
   {
   ...
   }



---------------------------------------------------------------------------
Destruktory
---------------------------------------------------------------------------


   Destruktor  urit  tdy  se  vol  proto, aby ped  vlastn  likvidac
njakho objektu  uvolnil  leny  tohoto  objektu.  Destruktor  je lenskou
funkc,  kter  m  nzev stejn jako tda, ale ped nm  se  uvd  jet
vlnovka  (~).  Destruktor  neme  pejmat  dn   parametry,   ani  nem
deklarovan dn typ vsledku nebo jeho hodnotu.

   class X
   {
   public:
      ~X();                                       // destruktor pro tdu X
   };

   Nen-li  pro njakou tdu destruktor definovan explicitn,  kompiltor
jej generuje sm.


Kdy se vyvolvaj destruktory
---------------------------------------------------------------------------

   Destruktor se vol  implicitn,  kdy njak promnn vystupuje ze svho
deklarovanho oboru. Destruktory pro lokln promnn se volaj, kdy blok,
v nm jsou  deklarovny,  pestv  bt  aktivnm.  Pokud  jde  o globln
promnn, volaj se destruktory jako soust vstupn procedury po main.

   Kdy z oboru vystupuj  ukazatele  na  objekty, destruktor se implicitn
nevol. To znamen, e k likvidaci takovho objektu se mus  volat opertor
delete.

   Destruktory  se  volaj  v poad pesn  opanm,  ne  se  volaly  jim
odpovdajc konstruktory (viz strnku 125).










                                  - 129 - 


Funkce atexit, #pragma exit a destruktory
---------------------------------------------------------------------------

   Vechny  globln  objekty  jsou aktivn, dokud se nevykon kd ve vech
vstupnch procedurch. Lokln promnn, vetn tch, je jsou deklarovny
ve funkci main, se likviduj pi svm vstupu z oboru. Z tohoto hlediska je
poad innost na konci njakho programu v jazyku Turbo C++ nsledujc:

    o  Vykonaj se funkce atexit v poad, v nm byly vloeny.

    o  Vykonaj se vstupn funkce #pragma v poad svch kd priority.

    o  Volaj se destruktory pro globln promnn.


Funkce exit a destruktory
---------------------------------------------------------------------------

   Pi  voln  exit  zevnit programu se  pro  dn  lokln  promnn  v
aktulnm oboru destruktory nevolaj.  Globln  promnn  se  likviduj ve
svm normlnm poad.


Funkce abort a destruktory
---------------------------------------------------------------------------

   Jestlie  kdekoli  v  programu  vyvolte   abort,   nevolaj   se  dn
destruktory, dokonce ani pro promnn s globlnm oborem.

   Destruktor  se  d  rovnا vyvolat explicitn jednm  ze  dvou  zpsob:
nepmo  -  prostednictvm  voln   delete,   i   pmo  -  uitm  pln
kvalifikovanho nzvu destruktoru. Funkce  delete  lze  pout  k likvidaci
objekt, jim byla  pam؟  pidlena uitm funkce new. Explicitnch voln
destruktor je nutn pout  jenom  pro  objekty, jim byly prostednictvm
voln new pidleny specifick adresy.

   class X {
   ...
      ~X();
   ...
   };
       *                                *
   void  operator new(size_t size, void  ptr)
   {
      return ptr;
   }

   char buffer[sizeof(X)];

   main()
   {
       *

      X  ukaz = new X;
       *
      X  pres_ukaz;

      pres_ukaz = new(&buffer) X;      // ukazatel inicializovan na adresu
                        // vyrovnvac pamti buffer



                                  - 130 - 


   ...

      delete ukaz;                  // pouito delete k likvidaci ukazatele
      pres_ukaz->X::~X();          // pouit pmho voln kvli uvolnn
   }


Virtuln destruktory
---------------------------------------------------------------------------

   Destruktor je mono deklarovat jako virtuln. To umouje, aby ukazatel
na objekt bzov  tdy  volal  sprvn  destruktor  v  ppad,  kdy tento
ukazatel ve skutenosti odkazuje na objekt tdy odvozen. Destruktor tdy
odvozen z tdy s virtulnm destruktorem je i sm virtuln.

   class barva
   {
   public:
      virtual ~barva();                   // virtuln destruktor pro barvu
   };

   class cervena : public barva
   {
   public:
      ~cervena();            // destruktor pro ervenou je rovnا virtuln
   };

   class svetlecervena : public cervena
   {
   public:
      ~svetlecervena();       // destruktor svtl erven je t virtuln
   };

   Prv uveden tdy a nsledujc deklarace
         *
   barva  palette[3];

   palette[0] = new cervena;
   palette[1] = new svetlecervena;
   palette[2] = new barva;

   povedou k tmto vsledkm

   delete palette[0];
   // Vol se destruktor pro ervenou a za nm destruktor pro barvu.

   delete palette[1];
   // Vol se destruktor pro svtlou ervenou a za nm ~cervena a ~barva.

   delete palett[2];
   // Vyvol se destruktor pro barvu.

   Kdyby vak dn destruktory nebyly deklarovny  jako  virtuln, volaly
by delete palette[0],  delete  palette[1] a delete palette[2] vechny jenom
destruktor pro tdu barva. Ten by nesprvn zlikvidoval  prvn  dva prvky,
kter byly ve skutenosti typu cervena a svetlecervena.






                                  - 131 - 


---------------------------------------------------------------------------
Pepsan opertory
---------------------------------------------------------------------------


   Jazyk  C++  umouje  innost  vtiny  opertor  definovat  znovu, aby
vykonvaly pi pouit s  objekty  njak  konkrtn tdy urit innosti.
Stejn  jako  v  obecnm ppad pepsanch funkc v C++ rozli kompiltor
rzn  funkce  tak,  e  zjist  souvislosti takovho voln: poet a  typy
argument i operand.

   Vechny opertory ze strnky 25 lze pepsat s vjimkou
          *
      .  .  :: ?:

   Rovnا nelze pepsat symboly pro pedzpracovn # a ##.

   Klov slovo operator, za  nm  nsleduje  symbol opertoru, se nazv
nzev opertorov funkce. Pi definovn  nov  (pepsan)  innosti danho
opertoru se jej pouv jako nzvu normln funkce.

   Kdy  se funkn opertor vyvol s argumenty,  chov  se  jako  opertor
pracujc se svmi operandy v  njakm  vrazu.  Opertorov  funkce neme
mnit poet argument nebo  prioritn  i  asociativn pravidla (na strnce
83),  kter se vztahuj na pouit  normlnch  opertor.  Uvaujme  tdu
komplex:

   Tuto  tdu  zavdme  jen pro ilustrativn ely. Nen toton s tdou
complex v knihovn innho programu.

   class komplex {
      double real, imag;                              // implicitn private
   public:
      ...
      komplex() { real = imag = 0; }                // konstruktor 'inline'
      komplex(double r, double i = 0) {                            // dal
         real = r; imag = i;
      }
   ...
   }

   Snadno bychom si poradili s funkc pro stn komplexnch sel, teba

   komplex AddKomplex(komplex c1, komplex c2);

   ale pirozenj by bylo, kdybychom mohli pst

   komplex c1(0, 1), c2(1, 0), c3
   c3 = c1 + c2;

   ne

   c3 = AddKomplex(c1, c2);

   Vloenm  nsledujc  deklarace  do  tdy  komplex  opertor  + snadno
pepeme:

   friend komplex operator +(komplex c1, komplex c2);

   a definujeme jej (pokud mono 'inline') jako:


                                  - 132 - 


   komplex operator +(komplex c1, komplex c2)
   {
      return komplex(c1.real + c2.real, c1.imag + c2.imag);
   }



---------------------------------------------------------------------------
Opertorov funkce
---------------------------------------------------------------------------


   Opertorov funkce je  mon  volat  pmo,  i  kdy  se  obvykle volaj
nepmo uitm opertoru pepisu:

   c3 = c1.operator + (c2);                      // tot jako c3 = c1 + c2

   Ponechme-li  stranou  funkce  new  a  delete,  kter  maj sv  vlastn
pravidla  (viz  nsledujc  oddly),  mus  bt  opertorov   funkce  bu
nestatickou  lenskou funkc, nebo mus mt  alespo  jeden  argument  typu
tdy. Opertorov funkce =, (), [] a -> mus  bt  nestatickmi  lenskmi
funkcemi.


Pepsan opertory a ddinost
---------------------------------------------------------------------------

   S   vjimkou  funknho  opertoru  dosazovn  =()  (viz   "Pepisovn
opertoru dosazovn =" na strnce  133)  se  vechny  pepsan opertorov
funkce  pro  tdu  X dd do td odvozench z X, piem plat standardn
rozliovac pravidla pro pepsan funice. Je-li X bzovou tdou vi Y, je
mon opertorov funkce pepsan pro X dle pepisovat pro Y.


Pepisovn new a delete
---------------------------------------------------------------------------

   Opertory new a delete lze pepsat a zskat tm alternativn  rutiny pro
sprvu voln  pamti  (heapu).  Uivatelsky  definovan  opertor  new mus
               *
poskytovat void  a jako svj prvn argument mus mt size_t. Typ  size_t je
definovn  v  stdlib.h.  Uivatelsky   definovan   opertor   delete  mus
                                                                  *
poskytovat  typ  void a jako svj prvn  argument  mus  mt  void ;  druh
argument typu size_t je nepovinn. Napklad

   #include <stdlib.h>

   class X {
      ...
   public:
          *
      void  operator new(size_t size) { return newalloc(size);}
                               *
      void operator delete(void  p) { newfree(p); }
      X() { /* zde inicializovat */ }
      X(char ch) { /* zde tak */ }

      ~X() { /* zde uklidit */ }
      ...


                                  - 133 - 


   };

   Argument size udv velikost objektu, kter se m  vytvoit.  newalloc a
newfree  jsou  funkcemi  pro  pidlen  a  uvolnn  pamti, kter  zadv
uivatel.  Volnm konstruktor a destruktor pro  objekty  tdy  X  (nebo
objekty td odvozench od  X,  je nemaj vlastn pepsan opertory new a
delete) se vyvolaj odpovdajc uivatelsky definovan X::operator new() a
X::operator delete().

   Opertorov  funkce  X::operator   new()  a  X::operator  delete()  jsou
statickmi leny X, a ji jsou explicitn deklarovny jako static nebo ne,
take nemohou bt virtulnmi funkcemi.

   Uvnit oboru X lze pi vytven a likvidaci objekt, je nejsou tdy X
nebo tdy  odvozen  z  X,  stle  pouvat  standardnch peddefinovanch
(globlnch)  opertor  new  a  delete,  a to bu explicitn s  opertorem
globlnho oboru (::operator new  a  ::operator  delete),  nebo implicitn.
Mete napklad pout standardnch new a delete pi definovn pepsanch
verz:
       *
   void  X::operator new(size_t s)
   {
          *
      void  ptr = new char[s];                   // voln standardnho new
      ...
      return ptr;
   }
                               *
   void X::operator delete(void  ptr)
   {
      ...
                  *
      delete (void ) ptr;                     // voln standardnho delete
   }

   Smysl argumentu  size  spov  v  tom,  aby  tdy odvozen z X zddily
X::operator  new.  Velikost  objektu odvozen tdy se me znan liit od
velikosti objektu tdy bzov.


Pepisovn unrnch opertor
---------------------------------------------------------------------------

   Pedponov nebo  pponov  unrn  opertor  lze  pepsat  deklarovnm
njak nestatick lensk funkce, kter  nepejm  dn  argumenty, resp.
deklarovnm njak nelensk  funkce pebrajc jedin argument. Jestlie
@ pedstavuje njak  unrn  opertor,  @x  a x@ lze oba interpretovat bu
jako  x.operator@()  nebo   jako  operator@(x),  podle  uinn  deklarace.
Jestlie  byly  deklarovny  oba  tvary,  aplikuje se k  vyeen  jakkoli
nejednoznanosti standardn porovnn argument.

   Opatrnosti je poteba pi  pepisu  ++  a  --, nebo zevnit pepisujc
funkce nelze rozliit pedponov pouit od pponovho. Napklad

   class X {
      ...
      X operator ++() { /* zde jde o inkrement rutiny X */ }
   }
   ...
   X x, y;


                                  - 134 - 


   y = ++x;                                             // tot jako x++ !


Pepisovn binrnch opertor
---------------------------------------------------------------------------

   Pedponov  nebo  pponov binrn opertor  lze  pepsat  deklarovnm
njak  nestatick  lensk   funkce  pejmajc  jedin  argument,  resp.
deklarovnm njak  nelensk  funkce  (obvykle  friend)  pebrajc  dva
argumenty.  Jestlie  @  pedstavuje  njak  binrn  opertor,   x@y  lze
interpretovat bu jako  x.operator@(y)  nebo  jako  operator@(x,  y), podle
uinn  deklarace.  Jestlie  byly deklarovny oba tvary,  aplikuje  se  k
vyeen jakkoli nejednoznanosti standardn porovnn argument.


Pepisovn dosazovacho opertoru =
---------------------------------------------------------------------------

   Dosazovac   opertor  =  lze  pepisovat  jedin  deklarovnm   njak
nestatick lensk funkce. Napklad

   class Retezec {
      ...
      Retezec& operator = (Retezec& str);
      ...
      Retezec (Retezec&);
      ~Retezec();
   }

   Tento zdrojov text spolen s vhodnmi definicemi Retezec::operator =()
umouje dosazovn  etzc  ret1  =  ret2,  stejn  jako je tomu v jinch
jazycch.  Na  rozdl  od  jinch  opertorovch  funkc  nelze  dosazovac
opertorovou funkci zddit  do  odvozench  td.  Pokud  v  dn  td X
neexistuje dn  uivatelsky definovan opertor =, definuje se opertor =
implicitn jako postupn dosazovn len tdy X:

   X& X::operator = (const X& zdroj)
   {
      // dosazovn po lenech
   }


Pepisovn opertoru voln funkce ()
---------------------------------------------------------------------------

   Voln funkce

   primrn-vraz (<seznam-vraz>)

   se  povauje za binrn opertor s  operandy  primrn-vraz  a  seznam-
vraz  (me  bt  i  przdn).   Odpovdajc   opertorovou   funkc  je
operator().  Tuto  funkci  lze uivatelsky definovat pro tdu X (a vechny
odvozen  tdy)  pouze  prostednictvm  njak nestatick lensk funkce.
Voln x(arg1,  arg2),  kde  x  je  objektem  tdy X, se interpretuje jako
x.operator()(arg1, arg2).







                                  - 135 - 


Pepisovn indexovacho opertoru []
---------------------------------------------------------------------------

   Indexovac opertor

   primrn-vraz [vraz]

   se analogicky povauje  za  binrn opertor s operandy primrn-vraz a
vraz. Odpovdajc opertorovou funkc je operator[].  Tu  lze uivatelsky
definovat  pro tdu X (a vechny  odvozen  tdy)  pouze  prostednictvm
njak nestatick lensk funkce. Vraz x[y], kde x je objektem tdy X, se
interpretuje jako x.operator[](y).


Pepisovn opertoru pstupu ke lenm tdy ->
---------------------------------------------------------------------------

   Pstup ke lenm tdy, pouvajc

   primrn-vraz ->vraz

   se povauje za  unrn  opertor. Funkce operator-> mus bt nestatickou
lenskou funkc. Vraz  x->m,  kde  x  je objektem tdy X, se interpretuje
jako  (x.operator->())->m,  take  funkce  operator->() mus poskytovat bu
ukazatel na objekt  tdy,  nebo  mus  poskytnout objekt tdy, pro ni je
operator-> definovn.



---------------------------------------------------------------------------
Virtuln funkce
---------------------------------------------------------------------------


   Virtulnmi funkcemi mohou bt jen funkce lensk.

   Virtuln funkce umouj, aby odvozen tdy poskytovaly  odlin verze
funkc td bzovch. Je mon njakou virtuln funkci deklarovat v bzov
td a potom ji definovat odlin v kad td odvozen,  by  by poet a
typ  argument  zstal   stejn.   Je  tak  mon  deklarovat  funkce  int
Baze::Fun(int) a int  Odvoz::Fun(int),  dokonce  i  kdy  nejsou virtuln.
Verze z bzov tdy je k dispozici objektm tdy odvozen prostednictvm
pedefinovn  oboru.  Jsou-li  virtuln,  je  k  dispozici  jenom  funkce
sdruen se skutenm typem objektu.

   V ppad virtulnch funkc nesta zmnit jenom typ  funkce.  Proto je
neppustn definovat njakou virtuln funkci  znovu tm, e se li pouze
typem zskan hodnoty. Maj-li  dv  funkce  tho nzvu odlin argumenty,
jazyk  C++  je  povauje  za  rozdln a mechanismus virtulnch funkc  se
ignoruje.

   Nech bzov tda B obsahuje virtuln funkci vf a tda D,  odvozen z
B,  obsahuje funkci vf tho typu. Kdy se potom vf vol pro objekt d  nebo
D, realizuje se voln  D::vf,  dokonce  i  kdy pstup je prostednictvm
ukazatele nebo odkazu na B. Napklad

   struct B {
      virtual void vf1();
      virtual void vf2();
      virtual void vf2();


                                  - 136 - 


      void f();
   };
   class D : public B {
      virtual void vf1();         // specifiktor virtual je ppustn, ale
                     // nadbyten
      void vf2(int);          // nen virtuln, nebo uv odlin seznam
                  // argument
      char vf3();        //Nelze: jde pouze o zmnu typu poskytnut hodnoty
      void f();
   };

   void extf()
   {
      D d;                                           // deklarace objektu D
       *                                                            *     *
      B  bp = &d;                           // standardn pevod z D  na B
      bp->vf1();                                          // vol se D::vf1
      bp->vf2();         // vol se B::vf2, nebo vf2 z D m jin argumenty
      bp->f();                             // vol se B::f (nen virtuln)
   }

   Pedefinujc  funkce  vf1  v D je automaticky  virtuln.  V  deklaraci
pedefinujc funkce v odvozen td lze pout specifiktoru virtual, ale
jeho uit je nadbyten.

   Interpretace voln virtuln funkce zvis na typu objektu, pro nj se
vol. V ppad voln nevirtuln funkce zvis interpretace jenom na typu
ukazatele nebo odkazu oznaujcho objekt, pro nj se vol.

Pamatujte!
   Virtuln  funkce mus bt leny njak tdy,  ale  nemohou  bt  leny
statickmi. Virtuln funkce me bt sptelena (friend) s jinou tdou.

   Virtuln  funkce v bzov td, stejn  jako  vechny  lensk  funkce
bzov tdy, se mus definovat, ppadn deklarovat, jako ist:

   class B {
   virtual void vf(int) = 0;                         // = 0 znamen 'ist'

   Ve td  odvozen  z  takov  bzov  tdy  se mus kad ist funkce
definovat  nebo  znovu  deklarovat  jako  ist   (viz   nsledujc  oddl
"Abstraktn tdy").

   Je-li virtuln  funkce definovna v bzi, nen nezbytn nutn definovat
ji v odvozen td znovu. Tda bude prost volat funkci bzovou.

   Virtuln  funkce  vak  za  svou  univerzlnost plat: Kad  objekt  v
odvozen  td  mus  sebou nst ukazatel na tabulku funkc, aby se v dob
innosti programu vybrala ta sprvn (pozdn vazba).



---------------------------------------------------------------------------
Abstraktn tdy
---------------------------------------------------------------------------


   Abstraktn  tdou se rozum tda s  alespo  jednou  istou  virtuln
funkc. Virtuln funkce se ur jako ist uitm specifiktoru istoty.



                                  - 137 - 


   Abstraktn  tdy lze pout jenom jako bzov  tdy  pro  tdy  jin.
dn objekty  abstraktn  tdy  vytvet  nelze.  Abstraktn  tdy nelze
pout jako typu argumentu nebo jako typu zskan hodnoty z funkce.  Je ale
mono deklarovat  ukazatele na abstraktn tdu. Odkazy na abstraktn tdu
jsou  dovoleny za pedpokladu, e v  inicializaci  nen  zapoteb  dnho
doasnho objektu. Napklad

   class obrys {                                        // abstraktn tda
      bod stred;
      ...
   public:
      kde() { return stred; }
      presun(bod p) { stred = p; kresli(); }
      virtual void rotace(int) = 0;               // ist virtuln funkce
      virtual void kresli() = 0;                  // ist virtuln funkce
      virtual void zvyrazni() = 0;                // ist virtuln funkce
      ...
   }

   obrys x;            // CHYBA: pokus o vytvoen objektu abstraktn tdy
           *
      obrys  sptr;                    // ukazatel na abstraktn tdu je OK
      obrys f();        // CHYBA: abstraktn tda neme bt typem zskan
               // hodnoty
   int g(obrys s);    // CHYBA: abstraktn tda neme bt typem argumentu
               // funkce
   obrys& h(obrys&);     // odkaz na abstraktn tdu jako zskanou hodnotu
               // nebo argument funkce je OK

   Dejme tomu, e D je  odvozenou  tdou  a  abstraktn  tda  B  je jej
bezprostedn bzovou  tdou. Potom pro kadou istou virtuln funkci pvf
v B  mus  D  bu  poskytnout definici pvf, nebo D mus deklarovat pvf jako
istou.

   Pouijeme-li napklad tdy obrys, nartnut ve,

   class kruh : public obrys {                // kruh odvozen z abstraktn
                           // tdy
      int radius;                                                // private

   public:
      void rotace(int) {}                   // definovna virtuln funkce:
                        // dn innost pro rotaci kruhu
      void kresli();                // nkde se mus definovat kruh::kresli
      void zvyrazni() = 0;                 // znovu se deklaruje jako ist
   }

   lensk funkce lze volat z  konstruktoru  abstraktn  tdy,  ale voln
ist virtuln funkce pmo i nepmo z takovho  konstruktoru  zpsob v
innosti programu chybu.












                                  - 138 - 


---------------------------------------------------------------------------
Obor C++
---------------------------------------------------------------------------


   Lexikln pravidla  pro  obor  v  jazyku  C++  se, mimo oboru td, d
obecnmi pravidly jazyka C s tou vhradou, e  C++  dovoluje  na  rozdl od
jazyka  C,  aby  se deklarace dat i funkc vyskytovaly vude,  kde  se  sm
vyskytnout  njak  pkaz.  Tato   pizpsobivost   ale   znamen  potebu
opatrnosti pi interpretaci takovch frz  jako  "ohraniujc  obor" nebo
"deklaran msto".


Obor tdy
---------------------------------------------------------------------------

   Nzev M njakho lenu tdy X m obor tdy "lokln vzhledem k X". Lze
jej pout jenom v nsledujcch situacch:

    o  Ve lenskch funkcch tdy X

    o  Ve vrazech jako x.M, kde x je objektem tdy X

    o  Ve vrazech jako xptr->M, kde xptr je ukazatel na objekt tdy X.

    o  Ve vrazech jako X::M nebo D::M, kde D je odvozenou tdou z X

    o  V dopednch odkazech uvnit tdy, jejm je lenem.

   Tdy, vty nebo nzvy typedef  deklarovan uvnit tdy X, resp. nzvy
funkc  deklarovanch jako sptelen s X, leny  tdy  X  nejsou.  Jejich
nzvy maj jenom ohraniujc obor.


Zakrvn
---------------------------------------------------------------------------

   Nzev se d  zakrt  explicitn deklarac stejnho nzvu v ohraniujcm
bloku nebo ve td. Zakryt  len tdy zstv nadle dostupnm, uije-li
se s nzvem tdy modifiktor oboru X::M. Na zakryt nzev s  oborem soubor
(globlnm) se lze odkazovat  unrnm  opertorem  ::, napklad ::g. Nzev
tdy lze  zakrt nzvem objektu, funkce nebo itatele deklarovanch uvnit
oboru tdy X bez ohledu na poad deklarace tchto  nzv.  Nzev  zakryt
tdy  vak  lze  zpstupnit, uvedete-li ped X  patin  klov  slovo:
class, struct nebo union.


Souhrn pravidel pro obor v C++
---------------------------------------------------------------------------

   Uvdn pravidla plat pro vechny nzvy, vetn nzv  typedef  a nzv
td,  pokud  C++  takov  nzvy  v  konkrtnch  probranch souvislostech
pipout:

   1.  Samotn nzev se testuje ohledn sv jednoznanosti. Pokud se v jeho
       oboru  nezjist   dn   nejednoznanost,   spust   se  pstupov
       posloupnost.

   2.  Neobjev-li  se  dn  chyby pi zen pstupu,  testuje  se  typ
       objektu, funkce, tdy, typedef atd.


                                  - 139 - 


   3.  Pouv-li se tohoto nzvu vn  njak funkce nebo tdy, nebo je-li
       opaten  unrnm opertorem pstupu do oboru  ::  a  nen-li  nzev
       kvalifikovn binrnm opertorem :: nebo opertory pro vbr len .
       i  ->,  mus  bt  tento  nzev  globlnm  objektem,  funkc  nebo
       itatelem.

   4.  Pokud se  nzev  n  objev  v ktermkoli z tvar X::n, x.n (kde x je
       objektem tdy X nebo odkazem na X), i ptr->n (kde ptr  je ukazatel
       na  X), pak je n nzvem lenu X nebo lenu tdy, z n je  odvozena
       X.

   5.  Jakkoli nzev, dosud nepopsan, jen se pouv ve statick lensk
       funkci, mus bt deklarovn v tom bloku, v nm se objevuje,  nebo v
       bloku  ohraniujcm,  resp. mus bt  nzvem  globlnm.  Deklarac
       loklnho nzvu n  se  zakryj deklarace n v ohraniujcch blocch,
       jako  i  globln  deklarace  n.  Nzvy  v  rozdlnch  oborech  se
       nepepisuj.

   6.  Jakkoli  nzev,  dosud  nepopsan,  jen  se  pouv  v nestatick
       lensk  funkci  tdy  X, se mus deklarovat v tom bloku, v nm se
       objevuje, nebo v bloku ohraniujcm, mus bt lenem  tdy  X nebo
       tdy  bzov  k  X,  resp.  mus  bt  nzvem globlnm.  Deklarac
       loklnho nzvu n se zakryj deklarace n v ohraniujcch blocch, v
       lenech tdy dan  funkce,  jako i globln deklarace n. Deklarac
       nzvu lenu se zakryj deklarace tho nzvu v bzovch tdch.

   7.  Nzev argumentu funkce v definici njak funkce se  nachz  v oboru
       nejvyho bloku tto funkce. Nzev argumentu  funkce  v nedefinin
       deklaraci funkce nem vbec dn obor. Obor  implicitnho argumentu
       se stanov  podle  msta  deklarace  jejho  argumentu,  neme vak
       zpstupnit lokln promnn  nebo nestatick leny td. Implicitn
       argumenty se vyhodnocuj v kadm mst voln.

   8.  Inicializtor   konstruktoru   (viz   inicializtor-ctor  v  syntaxi
       deklartor tdy,  na strnce 43) se vyhodnocuje v oboru nejvyho
       bloku svho konstruktoru, take me  odkazovat  na  nzvy argument
       tohoto konstruktoru.

























                                  - 140 - 








                            K a p i t o l a   4

                                Preprocesor


   Akoli  jazyk  Turbo  C++  pouv  ve  svch  verzch  pro  integrovan
prosted  IDE  i  pro  kompiltor  s pkazovm dkem kompilaci s  jednm
prchodem,  je vhodn dret se terminologie, kter  se  ve  na  dvj
vceprchodov kompiltory.

   Ve  vceprchodovch  kompiltorech se pi  prvnm  prchodu  zdrojovho
textu zavedou dovnit  vechny  dl soubory, zjist se ppadn direktivy
podmnn kompilace, rozvinou se vechny makroinstrukce a vznikne pechodn
soubor pro dal prchody kompiltorem. Protoe v Turbo C++ jak  verze IDE,
tak  i   kompiltor  s  pkazovm  dkem  vykonvaj  prvn  prchod  bez
jakhokoli   pechodnho   vstupu,   disponuje   Turbo    C++   nezvislm
preprocesorem CPP.EXE, kter takov vstupn soubor pod. CPP je uiten
jako  prostedek  pro  ladn,  nebo  umouje  zhldnout  ist  vsledek
direktiv pro vkldn {include}, direktiv pro podmnnou kompilaci, jako i
pln rozvinut makroinstrukce.

   Nezvisl preprocesor dokumentujeme dle.

   Nsledujc  diskuse  o   direktivch  preprocesoru,  jejich  syntaxi  a
smantice se vztahuje jak  na  preprocesor CPP, tak i na funkn vlastnosti
preprocesoru, zabudovan do kompiltor Turbo C++.

   Preprocesor zjiuje v  textu  direktivy uren pro preprocesor (k se
jim t dic,  resp.  kontroln  dky)  a pedv lexikln prvky v nich
obsaen.

   Preprocesor jazyka Turbo  C++ obsahuje dmysln procesor makroinstrukc,
jen prohldne zdrojov text  jet  ped  zahjenm  innosti kompiltoru.
Tento  preprocesor  vm  nabz  velkou   vkonnost   a   pizpsobivost  v
nsledujcch oblastech:

    o  Pi   definovn   makroinstrukc,  jimi  se   sn   nmaha   pi
       programovn  a zv se srozumitelnost zdrojovho textu.  Nktermi
       makroinstrukcemi se d omezit pemra voln funkc.

    o  Pi vkldn textu z jinch soubor, jakmi jsou soubory zhlav. Ty
       obsahuj  prototypy   standardnch   knihovnch   funkc   i  funkc
       definovanch uivatelsky, jako i zadan konstanty.

    o  Pi  nastavovn podmnnch kompilac kvli zlepen penosnosti  a
       pro poteby ladn.

   Direktivy preprocesoru se obvykle umsuj na zatek  zdrojovho textu,
ale jsou ppustn kdekoli v programu.

   Za direktivu preprocesoru  se  povauje kad dek zanajc znakem #,
pokud  tento  znak  # nen uvnit njakho etzcovho literlu, ve znakov
konstant, nebo nen vlenn do komente. Znak # me bt obklopen zepedu
i zezadu przdnm mstem (s vjimkou novch dk).


                                  - 141 - 


   plnou syntaxi  direktiv  preprocesoru  Turbo  C++  pin  nsledujc
tabulka.




























































                                  - 142 - 


          Tab. 4.1: Syntax direktiv pro pedzpracovn Turbo C++

---------------------------------------------------------------------------
soubor-pro-pedzpracovn:
   skupina

skupina:
   st-skupiny
   skupina st-skupiny

st-skupiny:
   <pp-lex-prvky> nov-dek
   sekce-if
   dic-dek

sekce-if:
   skupina-if <skupiny-elif> <skupina-else> dek-endif

skupina-if:
   #if konstantn-vraz nov-dek <skupina>
   #ifdef identifiktor nov-dek <skupina>
   #ifndef identifiktor nov-dek <skupina>

skupiny-elif:
   skupina-elif
   skupiny-elif skupina-elif

skupina-elif:
   #elif konstantn-vraz nov-dek <skupina>

skupina-else:
   #else nov-dek <skupina>

dek-endif:
   #endif nov-dek

dic-dek:
   #include pp-lex-prvky nov-dek
   #define  identifiktor seznam-nhrad nov-dek
   #define  identifiktor lzv <seznam-ident> seznam-nhrad nov-dek
   #undef   identifiktor nov-dek
   #line pp-lex-prvky nov-dek
   #error   <pp-lex-prvky> nov-dek
   #pragma  <pp-lex-prvky> nov-dek
   #pragma warn   innost zkratka nov-dek
   #pragma inline nov-dek
   #     nov-dek

innost: jeden z
   +  -  .

zkratka:
   amb   amp   apt   aus   big   cln   cpt
   def   dup   eff   mod   par   pia   pro
   rch   ret   rng   rpt   rvl   sig   str
   stu   stv   sus   ucp   use   voi   zst

lzv:
   znak lev zvorky, ped nm nen przdn msto



                                  - 143 - 


seznam-nhrad:
   <pp-lex-prvky>

pp-lex-prvky:
   lex-prvek-pro-pedzpracovn
   pp-lex-prvky lex-prvek-pro-pedzpracovn

lex-prvek-pro-pedzpracovn:
   nzev-zhlav (jen v direktiv #include)
   identifiktor (bez rozlien klovch slov)
   konstanta
   etzcov-literl
   opertor
   interpunkn-znak
   jakkoli znak neuveden ve, kter nen przdnm mstem

nzev-zhlav:
   <posloup-znak-z>

posloup-znak-z:
   znak-z
   posloup-znak-z znak-z

znak-z:
   libovoln znak z pvodn mnoiny s vjimkou novho dku (\n) nebo
   znaku vt ne (>)

nov-dek:
   znak novho dku
---------------------------------------------------------------------------



---------------------------------------------------------------------------
Przdn direktiva #
---------------------------------------------------------------------------


   Przdn direktiva pozstv  z  dku obsahujcho jedin znak #. Takov
direktiva se vdy ignoruje.



---------------------------------------------------------------------------
Direktivy #define a #undef
---------------------------------------------------------------------------


   Direktivou #define se definuj makroinstrukce.  Makroinstrukce poskytuj
mechanismus nhrady lexiklnch prvk s vyuitm (nebo i  bez  nj) mnoiny
formlnch parametr, podobn jako ve funkcch.


Jednoduch makroinstrukce #define
---------------------------------------------------------------------------

   V jednoduchm ppad bez parametr je syntax nsledovn:

   #define identifiktor_makro <posloupnost_lex_prvk>



                                  - 144 - 


   Kad  vskyt  identifiktoru_makro ve zdrojovm  kdu,  nsledujc  za
tmto  dicm  dkem,  se na svm  mst  nahrad  pokud  mono  przdnou
posloupnost_lex_prvk  (existuje  nkolik  vjimek,  o  nich  se  zmnme
pozdji).  Takovm  nhradm   se  k  rozvoj  makroinstrukc.  Pslun
posloupnost lexiklnch prvk se nazv tlem makroinstrukce.

   Identifiktory  makroinstrukc,  kter se ve  zdrojovm  kdu  vyskytnou
uvnit   literlovch  etzc,  znakovch  konstant  nebo  koment,   se
nerozvinou.

   Vsledkem przdn posloupnosti lexiklnch prvk je efektivn odstrann
vech dotynch identifiktor makroinstrukc ze zdrojovho kdu:

   #define HI "Preji dobry den !"
   #define prazdno
   #define NIL ""
   ...
   puts(HI);                  /* rozvine se na puts("Preji dobry den !") */
   puts(NIL);                                  /* rozvine se na puts("") */
   puts("prazdno");             /* pro prazdno NEexistuje dn rozvoj ! */
   /* neexistuje ani rozvoj pro prazdno uvnit koment ! */

   Po kadm rozvoji jednotliv makroinstrukce se prohldne  nov rozvinut
text. Tm je dna monost  vnoench  makroinstrukc:  Rozvinut  text me
toti   obsahovat  dal  identifiktory  makroinstrukc,  kter  se   dle
rozvinou. Jestli se vak makroinstrukce  rozvine  do  podoby  direktivy pro
pedzpracovn, preprocesor takovou direktivu ji nerozezn:

   #define GETSTD #include <stdio.h>
   ...
   GETSTD                                            /* kompilan chyba */

   GETSTD  se  rozvine  do #include <stdio.h>. Preprocesor  sm  vak  tto
zdnliv ppustn  direktivy  neuposlechne,  nbr  ji  doslovn  ped do
kompiltoru.  Kompiltor  pak  #include  <stdio.h> odmtne jako neppustn
vstup. Makroinstrukce se  bhem  svho vlastnho rozvoje ji dl nerozvj.
Proto se #define A A nebude rozvjet donekonena.


Direktiva #undef
---------------------------------------------------------------------------

   Definici makroinstrukce lze zruit direktivou #undef:

   #undef identifiktor_makro

   Tento dek odpoj od  identifiktoru  makroinstrukce  vechny pedchoz
posloupnosti lexiklnch  prvk.  Definice  makroinstrukce  se  zapomene  a
identifiktor makroinstrukce nen dle definovn.

   Uvnit dk #undef se nevyskytuje dn rozvoj makroinstrukc.

   Ukazuje  se,  e  stav  bt  i nebt definovn je dleitou  vlastnost
identifiktor bez ohledu na  jejich  skutenou  definici. K ovovn, zda
njak  identifiktor  je  aktuln  definovn  nebo  ne,  slou podmnn
direktivy #ifdef a #ifndef. Ty  poskytuj prun mechanismus k zen mnoha
variant kompilace.





                                  - 145 - 


   Po  zruen  definice identifiktoru makroinstrukce  jej  lze  definovat
znovu prostednictvm #define s vyuitm stejn  nebo  odlin posloupnosti
lexiklnch prvk.

   #define BLOK_VEL 512
   ...
                  *                                                   *
   buff = BLOK_VEL blks;                        /* rozvine se jako 512 blks
   ...
   #undef BLOK_VEL
   /* pouit BLOK_VEL by nyn bylo neppustnm "neznmm" identifiktorem
*/
   ...
   #define BLOK_VEL 128                                    /* redefinice */
   ...
                  *                                                   *
   buff = BLOK_VEL blks;                        /* rozvine se jako 128 blks
   ...

   Pokus  o znovudefinovn ji definovanho identifiktoru  makroinstrukce
skon upozornnm, ledae by nov definice byla pesn  toton,  prvek za
prvkem, s definic existujc. Pro ppad, e by definice mohly existovat v
jinm souboru zhlav, doporuujeme tuto strategii:

   #ifndef BLOK_VEL
      #define BLOK_VEL 512
   #endif

   Pokud je  BLOK_VEL aktuln definovn, prostedn dek se obejde. Nen-
li  BLOK_VEL  aktuln  definovn,  prostedn  dek se vyvol a bude  jej
definovat.

   Uvdomte si, e k ukonen  direktivy  preprocesoru  nen  teba dnho
stednku (;). Vechny znaky, kter se nachzej v posloupnosti lexiklnch
prvk, vetn stednk, se objev  v  rozvoji  makroinstrukce. Posloupnost
lexiklnch  prvk  se  ukon na prvnm novm dku nalezenm bez zptnho
lomtka.   Vechny   posloupnosti   przdnch   mst,  vetn  koment  v
posloupnosti lexiklnch prvk, se nahrad jedinm znakem mezery.

   Programtoi v  jazyku  symbolickch  adres  mus  odolat  pokuen, aby
nepsali:

   #define BLOK_VEL = 512    /* ?? posloupnost lexiklnch prvk obsahuje i
                                                                  znak = */


Alternativy -D a -U
---------------------------------------------------------------------------

   Identifiktory  je  mono  definovat  a  jejich  definice  ruit  uitm
alternativ  -D a -U v kompiltoru s pkazovm  dkem  (viz  Kapitolu  11.
"Kompiltor s pkazovm dkem" v Pruce uivatele).  Identifiktory lze
definovat,  nikoli vak jejich definice explicitn  ruit,  rovnا  v  menu
Options | Compiler | Defines v IDE.

   Pkazov dek

   tcc -Ddebug=1; paradox=0; X -Umysym myprog.c

   znamen tot, jako kdy umstte do programu


                                  - 146 - 


   #define  debug 1
   #define  paradox 0
   #define  X
   #undef   mysym


Klov a chrnn slova
---------------------------------------------------------------------------

   Pouit  klovch   slov   jazyka   Turbo   C++   jako   identifiktor
makroinstrukc je sice ppustn, ale nerozumn:

   #define int long                    /* ppustn, ale mon i zkzonosn
   #define INT long                            /* ppustn a mon vhodn

   Peddefinovan  globln identifiktory, uvdn dle, se nesm  objevit
bezprostedn za direktivou #define i #undef:

   __STDC__                            __DATE__
   __FILE__                            __TIME__
   __LINE__

   Nezapomete na dvoj podtren vpedu a vzadu.


Makroinstrukce s parametry
---------------------------------------------------------------------------

   K definovn makroinstrukc s parametry se pouv nsledujc syntaxe:

   #define identifiktor_makro(<seznam_arg>) posloupnost_lex_prvk

   Vechny rky uvnit zvorek v  seznamu argument se povauj za soust
argumentu a nikoli za jeho oddlova.

   Vimnte  si,  e  mezi  identifiktorem  makrointrukce a (  neme  bt
przdn  msto.  Nepovinn  seznam_argument je posloupnost identifiktor
oddlench rkami, ne nepodobn seznamu  argument ve funkcch v jazyku C.
Kad rkou oddlen identifiktor  m  roli  formlnho  argumentu neboli
obsazen msta.

   Takov makroinstrukce se volaj zpisem

   identifiktor_makro<przdn_msto>(<seznam_skut_arg>)

   do pslunho zdrojovho  textu.  Syntax je identick s volnm funkc,
ostatn mnoh standardn  knihovn  "funkce" v jazyku C jsou implementovny
jako makroinstrukce. Existuj vak nkter  dleit  smantick  rozdly a
potenciln nstrahy (viz strnku 147).

   Nepovinn  seznam_skut_arg  mus  obsahovat  tolik   rkami  oddlench
posloupnost lexiklnch prvk, zvanch skuten parametry,  kolik  se jich
nachz ve formlnm seznamu_arg v  dku  #define:  Ke  kadmu formlnmu
argumentu zde mus existovat argument skuten. Pokud by se poty argument
v tchto dvou seznamech liily, ohls se chyba.

   Voln makroinstrukce vede ke dvoj  nhrad.  Nejprve  se identifiktor
makroinstrukce  a argumenty  ohranien  zvorkami  nahrazuj  posloupnost
lexiklnch  prvk.   V  dalm  kroku  se  vechny  formln  argumenty  v



                                  - 147 - 


posloupnosti lexiklnch prvk nahrad odpovdajcmi  argumenty skutenmi
ze seznamu_skut_arg. Napklad
                          *   *
   #define KRYCHLE(x) ((x) (x) (x))
   ...
   int n, y;
   n = KRYCHLE(y);

   vede k nsledujc nhrad:

   n = ((y) * (y) * (y));

   Podobn posledn dek v

   #define SUM ((a) + (b))
   ...
   int i, j, sum;
   sum = SUM(i, j);

   se  rozvine do sum = ((i) + (j)). Dvod k oividnmu nadbytku zvorek se
ozejm, zvte-li voln

   n = KRYCHLE(y+1);

   Bez vnitnch zvorek  v  definici  by  dolo k rozvoji n = y+1*y+1*y+1,
kter se syntakticky analyzuje jako
             *       *
   n = y + (1 y) + (1 y) + 1;                   // != (y+1) na tet, krom
                           // ppad y=0 a y=-3 !

   Stejn jako  u  definic  jednoduchch  makroinstrukc,  i  zde nsleduje
prohldka  za elem zjitn vlennch identifiktor makroinstrukc  pro
pedpokldan rozvoj.

   Pi   pouvn  makroinstrukc  se  seznamy  argument  si   promyslete
nsledujc:

   1.  Vnoen  zvorky  a  rky:  V  seznamu_skut_arg  mohou  bt vnoen
       zvorky za pedpokladu,  e  jsou  vzjemn  vyveny.  Rovnا rky
       uvdn v uvozovkch nebo  v  zvorkch  se nepovauj za oddlovae
       argument:

       #define ERRMSG(x, str) ukazchybu("Chyba", x, str)
       #define SUM(x, y) ((x) + (y))
       ...
       ERRMSG(2, "Stiskni Enter, potom Esc");
       /* rozvine se  v  ukazchybu("Chyba", 2, "Stiskni Enter, potom Esc");
       */
       return SUM(f(i, j), g(k, l));
       /* rozvine se v return ((f(i, j)) + (g(k, l))); */

   2.  Zabudovn  lexiklnch prvk s ##: Dva  lexikln  prvky  je  mono
       zabudovat  (neboli  slouit)  do  sebe,  kdy je oddlte  ##  (plus
       nepovinnmi przdnmi msty na  kad  stran).  Preprocesor przdn
       msta i ## odstran a slo oddlen lexikln prvky v  jedin prvek
       nov. Toho lze vyut ke konstrukci identifiktor;  mjme napklad
       definici

       #define VAR(i, j) (i##j)



                                  - 148 - 


       pak  se voln VAR(x, 6) rozvine do (x6).  Tm  se  nahrazuje  star
                                        **
       (nepenosn) metoda uvajc (i/  /j).


   3.  Pevod  na  etzce  s  #:  Symbol  #  je  mono umstit ped njak
       formln argument  makroinstrukce,  m  se  skuten  argument  po
       nhrad pevede na etzec. Take mme-li definici makroinstrukce:

       #define TRACE(flag) printf(#flag "=%d\n", flag)

       ze zdrojovho textu

       int highval = 1024;
       TRACE(highval);

       se stane

       int highval = 1024;
       printf("highval" "= %d\n", highval);

       se kterm se dle zachz jako s

       int highval = 1024;
       printf("highval=%d\n", highval);

   4.  Zptn  lomtko  pro   pokraovn  dku:  S  dlouhou  posloupnost
       lexiklnch prvk je mono i peshnout dek, pouijete-li zptnho
       lomtka  (\).  Zptn  lomtko i nsledujc znak  novho  dku  se
       odstran a zsk se skuten posloupnost prvk, kter  se  pouije v
       rozvoji:

       #define UPOZOR "Jde opravdu o jedno\
       radkove upozorneni"
       ...
       puts(UPOZOR);
       /* na obrazovce se uke: Jde opravdu o jednoradkove upozorneni */
       Vedlej efekty a  jin  nebezpe: Podobnosti mezi volnm funkc a
       makroinstrukc  asto  zamluj  jejich  odlinost.   Makroinstrukce
       nemaj dnou  zabudovanou  kontrolu  typ.  Proto  nesrovnalosti  v
       datovch  typech  formlnch a skutench  argument  mohou  vyvolat
       podivn, tاko rozlutiteln  vsledky,  ani  by  dolo  k njakmu
       okamitmu upozornn. Z voln  makroinstrukc  mohou  vyvstat tak
       nechtn   vedlej  efekty,  zvlt  kdy  se  skuten   argument
       vyhodnocuje  vcekrt.  Srovnejte KRYCHLE a  krychle  v  nsledujc
       ukzce:

       int krychle(int x) {
                  * *
          return x x x;
       }
                               *     *
       #define KRYCHLE(x) ((x)   (x)   (x))
       ...
       int b = 0, a = 3;
       b = krychle(a++);
       /* krychle() dostane aktuln arg = 3; tedy b = 27; nyn a = 4 */
       a = 3;
       b = KRYCHLE(a++);



                                  - 149 - 


                             *     *
       /* rozvine se v ((a++) (a++) (a++)); nyn a = 6 */

   Vsledn  hodnota  b  zvis  na  tom, co kompiltor uin s  rozvinutm
vrazem.



---------------------------------------------------------------------------
Vkldn soubor prostednictvm #include
---------------------------------------------------------------------------


   Direktivou #include se do  zdrojovho  textu  zavedou  dal vyjmenovan
soubory, kterm se  k  vkldac {include} soubory, soubory zhlav, nebo
prost jen zhlav {header}. Potebn syntax m troj tvar:

   #include <nzev_zhlav>
   #include "nzev_zhlav"
   #include identifiktor_makro

   Lomen  zvorky  jsou  opravdovmi  lexiklnmi  prvky.  Nejde  o  dn
metasymboly k oznaen, e nzev_zhlav je nepovinn.

   Ve tet variant  se  pedpokld,  e  jako  prvn  neprzdn  znak za
#include  se  neobjev ani <, ani ".  Dle  se  tam  pedpokld  existence
definice  makroinstrukce, kterou se identifiktor makroinstrukce rozvine  v
platn  a  oddlen  nzev   zhlav   ve   formtu   <nzev_zhlav>  nebo
"nzev_zhlav".

   Z prvn  a  druh  varianty  plyne,  e  se nepikro k dnmu rozvoji
makroinstrukc.  Jinmi slovy: v nzvu_zhlav se nehledaj  identifiktory
makroinstrukc.  nzev_zhlav  mus   bt  platnm  nzvem  souboru  podle
pravidel operanho systmu DOS. M pponu (tradin .h  jako  'header') a
nepovinn nzev cesty i s oddlovai.

   Preprocesor ve zdrojovm textu dek  #include  odstran  a systematicky
jej  v  danm  mst nahrad celm textem souboru zhlav. Samotn zdrojov
text zstane  beze zmny, ale kompiltor "spat" text rozen. Umstnm
#include  se  proto  me  ovlivnit  obor i trvn vech identifiktor  ve
vkldacm souboru.

   Umstte-li  do  nzvu_zhlav   njakou  explicitn  cestu  k  souboru,
prohled se jenom tento adres.

   Rozdl mezi formty <nzev_zhlav> a "nzev_zhlav" spov v aplikaci
algoritmu pro pokus o vyhledn vkldacho souboru. Tyto algoritmy popeme
v nsledujcch dvou oddlech.


Vyhledn souboru zhlav uitm <nzev_zhlav>
---------------------------------------------------------------------------

   Variantou   <nzev_zhlav>   se   uruje  standardn  vkldac  soubor.
Vyhledvn  probh postupn ve vech adresch  pro  vkldn  v  poad
jejich  definic.  Pokud  se hledan soubor v dnm z implicitnch adres
nezjist, vyd se chybov hlen.





                                  - 150 - 


Vyhledn souboru zhlav uitm "nzev_zhlav"
---------------------------------------------------------------------------

   Variantou  "nzev_zhlav" se uruje uivatelem zadan vkldac  soubor.
Tento  soubor se hled nejprve v aktulnm adresi  (obvykle  se  jedn  o
adres obsahujc zdrojov text,  kter  se  m  kompilovat). Pokud se tam
soubor  nenalezne,  pokrauje  hledn  v  adresch pro vkldn  jako  v
situaci s <nzev_zhlav>.

   Uveden rozdly vysvtl nsledujc ukzka:

   #include <stdio.h>
   /* zhlav ze standardnho adrese pro vkldn */

   #define mujvklad "c:\Turboproduct\INCLUDE\mystuff.h"
   /* Upozornn: Jednotliv zptn lomtka jsou zde OK; v pkazu jazyka
   C byste potebovali "c:\\Turboproduct\\INCLUDE\\mystuff.h" */

   #include mujvklad
   /* rozvoj makroinstrukce */

   #include "mujvklad.h"
   /* dn rozvoj makroinstrukce */

   Po  rozvinut druh pkaz #include pimje  preprocesor  ke  hledn  v
C:\Turboproduct\INCLUDE\mystuff.h  a  u nikde jinde.  Tet  #include  jej
pimje  ke  hledn  mujvklad.h  v  aktulnm adresi a potom v  adresi
implicitnm.



---------------------------------------------------------------------------
Podmnn kompilace
---------------------------------------------------------------------------


   Turbo C++  podporuje podmnnou kompilaci tm, e nahrad patin dky
zdrojovho textu dkem przdnm. Takto se ignoruj dky zanajc znakem
# (s vjimkou direktiv #if, #ifdef, #ifndef, #else, #elif a #endif), stejn
jako i dky,  kter  se  v  dsledku  tchto  direktiv  nemaj kompilovat.
Vechny direktivy podmnn kompilace se  mus ukonit v tom zdrojovm nebo
vkldacm souboru, kde zanaj.


Podmnn direktivy #if, #elif, #else a #endif
---------------------------------------------------------------------------

   Podmnn direktivy #if, #elif,  #else,  a  #endif funguj jako normln
podmnn opertory jazyka C. Uvaj se nsledovn:

   #if konstant-vraz-1
   <sekce-1>
   <#elif konstant-vraz-2 nov-dek sekce-2>
      ...
   <#elif konstant-vraz-n nov-dek sekce-n>

   <#else posled-sekce>
   #endif
   ...



                                  - 151 - 


   Jestlie  se  konstant-vraz-1   (podlhajc   rozvoji  makroinstrukce)
vyhodnot jako nenulov (true), pedzpracuj  se  dky  textu  (nemus bt
dn) oznaen jako sekce-1, a u jde o pkazov dky preprocesoru nebo
o normln dky, a ppadn se pedaj do kompiltoru Turbo C++. V opanm
ppad, vyhodnot-li se konstant-vraz-1  jako  nula  (false),  sekce-1 se
ignoruje (dn rozvoj makroinstrukc a dn kompilace).

   V ppad true po pedzpracovn sekce-1 se zen ped na odpovdajc
#endif (kterm tato podmnn  st  kon)  a  pokrauje se dal-sekc. V
ppad false se zen ped  na nsledujc dek #elif (pokud existuje),
kde se vyhodnot konstant-vraz-2.  Je-li  pravdiv,  zpracuje  se sekce-2,
nae  se zen ped na odpovdajc #endif.  V  opanm  ppad,  je-li
konstant-vraz-2 nepravdiv, ped se  zen  na  nsledujc  #elif atd.,
dokud se nedoshne #else  nebo  #endif.  Nepovinnho  #else se pouv jako
alternativn podmnky, pro ni vechny pedchoz testy  dopadly nepravdiv.
Podmnnou posloupnost kon #endif.

   Zpracovan sekce me obsahovat  dal  podmnn  klauzule,  vnoen do
libovoln hloubky. Kad klauzule #if se mus peliv vyrovnat odpovdajc
klauzul #endif.

   Vsledek uvedenho postupu spov  v  tom,  e  k dalmu zpracovn se
ped jenom jedin sekce (teba  przdn). Obchzen sekce se uplatn pouze
pi sledovn vnoench  podmnnch  klauzul,  aby  se  k  #if  dalo vdy
piadit odpovdajc #endif.

   Konstantn  vrazy,  je  se  maj  testovat,  se  mus vyhodnotit  jako
konstantn celoseln hodnoty.


Opertor defined

   Opertor   defined  nabz  alternativn,  pizpsobivj  metodu   pro
testovn, zda kombinace identifiktor  jsou  nebo  nejsou  definovny. Je
ppustn pouze ve vrazech #if a #endif.

   Vraz defined(identifiktor) nebo defined identifiktor  (zvorky nejsou
povinn) se vyhodnot jako 1 (true), jestlie dan symbol byl ji definovn
(uitm #define) a jeho definice  nebyla mezitm zruena (uitm #undef). V
opanm ppad se vyhodnot jako 0 (false). Proto direktiva

   #if defined(mujsym)

   znamen tot jako

   #ifdef mujsym

   Vhodn  je,  e  defined  se  d  pouvat  ve  sloitch  vrazech  za
direktivou #if opakovan, teba

   #if defined(mujsym) && !defined(tvujsym)


Podmnn direktivy #ifdef a #ifndef
---------------------------------------------------------------------------

   Podmnn  direktivy  #ifdef  a  #ifndef  umouj  ovit,  zda  urit
identifiktor  aktuln  je  i  nen  definovan,  tj.  zda  se  pro  dan
identifiktor vykonal pkaz #define a zda jet plat. dek



                                  - 152 - 


   #ifdef identifiktor

   m pesn tent inek jako

   #if 1

   pokud je identifiktor aktuln definovan a stejn inek jako

   #if 0

   pokud identifiktor aktuln nen definovan.

   #ifndef se vyhodnot pravdiv  (true)  pro  podmnku  "nen definovan",
take dek

   #ifndef identifiktor

   m pesn tent inek jako

   #if 0

   pokud je identifiktor aktuln definovan a stejn inek jako

   #if 1

   pokud identifiktor aktuln definovan nen.

   Potebn syntax je stejn jako v ppad #if, #elif, #else a #endif, co
jsme popsali v pedchozm oddlu.

   Identifiktor definovan jako NULL se povauje za definovan.



---------------------------------------------------------------------------
Direktiva pro ovldn dk #line
---------------------------------------------------------------------------


   Pkazu #line se d pout k doplnn programu o sla dk pro hlen
kovch odkaz a chyb. Pozstv-li program z sek odvozench z njakho
jinho programovho  souboru, je asto vhodn oznait takov seky namsto
normlnch  postupnch  sel  dk  ze  sloenho  programu  sly  dk
programu pvodnho. Syntax je

   #line celos_konstanta <"nzev_souboru">

   a znamen, e nsledujc dek zdrojovho textu pvodn pochz z sla
dku  celos_konstanta v souboru nzev_souboru. Jakmile se  nzev_souboru
zaregistruje, me se v  nslednch  pkazech  #line, tkajcch se tohoto
souboru, explicitn argument nzev_souboru vypustit. Napklad

   /* TEMP.C: Ukzka direktivy #line */

   #include <stdio.h>

   #line 4 "junk.c"
   void main()
   {
      printf(" v radku %d z %s",__LINE__,__FILE__);


                                  - 153 - 


   #line 12 "temp.c"
      print("\n");
      printf(" v radku %d z %s",__LINE__,__FILE__);
   #line 8
      printf("\n");
      printf(" v radku %d z %s",__LINE__,__FILE__);
   }

   Vloen stdio.h znamen, e vstup z preprocesoru se ponkud zvt.

   Zpracujete-li TEMP.C v  CPP  (cpp temp), zskte vstupn soubor TEMP.I,
kter by ml vypadat takto:

   temp.c 1:
   C:\BORLAND\Turboproduct\CPP\INCLUDE\stdio.h 1:
   C:\BORLAND\Turboproduct\CPP\INCLUDE\stdio.h 2:
   C:\BORLAND\Turboproduct\CPP\INCLUDE\stdio.h 3:
   ...
   C:\BORLAND\Turboproduct\CPP\INCLUDE\stdio.h 212:
   C:\BORLAND\Turboproduct\CPP\INCLUDE\stdio.h 213:
   temp.c 2:
   temp.c 3:
   junk.c 4: void main()
   junk.c 5: {
   junk.c 6: printf(" v radku %d z %s",6,"junk.c");
   junk.c 7:
   temp.c 12: printf("\n");
   temp.c 13: printf(" v radku %d z %s",13,"temp.c");
   temp.c 14:
   temp.c 8: printf("\n");
   temp.c 9: printf(" v radku %d z %s",9,"temp.c");
   temp.c 10: }
   temp.c 11:

   Kdy potom TEMP.C zkompilujete, zskte takov vstup

    v radku 6 z junk.c
    v radku 13 z temp.c
    v radku 9 z temp.c

   Makroinstrukce v argumentech  #line  se rozvinou stejn jako v direktiv
#include.

   Direktivy #line se vyuv  pedevm  v  obslunch  podprogramech, je
produkuj jako svj  vstup  kd  jazyka  C  a nikoli v textech, kter p
lid.



---------------------------------------------------------------------------
Direktiva #error
---------------------------------------------------------------------------


   Direktiva #error m nsledujc syntax:

   #error errormsg

   Tm se generuje hlen:



                                  - 154 - 


   Error: nzev-souboru dek# : Error directive: errmsg

   Tato direktiva bv obvykle zabudovna  v  preprocesoru  do podmnkovch
vraz, ktermi se ovuj nkter  nedouc situace, je mohou nastat pi
kompilaci. V  normlnm  ppad  bude  tato  podmnka  nepravdiv (false).
Stane-li  se  podmnka  pravdivou  (true),  d se od  kompiltoru  podn
chybovho hlen a zastaven  kompilace.  Uin  se tak vloenm direktivy
#define do podmnkovho vrazu, kter je pro poadovan ppad pravdivm.

   Pedpokldejme napklad, e definujete #define MOJEHOD, kter  mus bt
0 nebo 1.  Do  svho  zdrojovho  textu pak mete vloit podmnkov vraz,
kterm se sprvnost hodnoty MOJEHOD ov:

   #if (MOJEHOD != 0 && MOJEHOD != 1)
   #error MOJEHOD musi byt definovana bud jako 0 nebo jako 1
   #endif



---------------------------------------------------------------------------
Direktiva #pragma
---------------------------------------------------------------------------


   Direktiva #pragma dovoluje implementan specifick direktivy tvaru:

   #pragma nzev-direktivy

   S  direktivou  #pragma  me  jazyk   Turbo   C++   definovat  jakoukoli
poadovanou  direktivu,  ani  by   se   dostala   do  konfliktu  s  jinmi
kompiltory, je  direktivu  #pragma  podporuj.  Pokud  takov  kompiltor
nzev-direktivy nezn, jednodue direktivu  #pragma  ignoruje  bez jakkoli
chyby nebo vstranho hlen.

   Turbo C++ podporuje nsledujc direktivy #pragma:

    o  #pragma argsused

    o  #pragma exit

    o  #pragma inline

    o  #pragma option

    o  #pragma saveregs

    o  #pragma startup

    o  #pragma warn


#pragma argsused
---------------------------------------------------------------------------

   Pragma argsused je dovolena jenom mezi definicemi funkc a ovlivn jenom
funkci nsledujc. Zablokuje vstran hlen:

   "Parameter nzev is never used in function nzev-funkce"
   {"Ve funkci nzev_funkce se parametru nzev nikdy nepouv"



                                  - 155 - 


#pragma exit a #pragma startup
---------------------------------------------------------------------------

   Tyto dv direktivy pragma dovoluj,  aby se v programu urila(y) funkce,
kter()  se  m  volat ped sputnm programu (ped volnm funkce main),
nebo  ped  vstupem  z  programu  (bezprostedn  ped  ukonenm programu
prostednictvm _exit).

   Syntax vypad nsledovn:

   #pragma exit nzev_funkce <priorita>
   #pragma startup nzev_funkce <priorita>

   Zadan  nzev_funkce mus pedstavovat dve deklarovanou funkci,  kter
nepejm  dn   argumenty  a  poskytuje  void;  jinmi  slovy,  mus  se
deklarovat jako

   void func(void);

   Nepovinn parametr priorita mus bt celm slem v rozsahu 64 a 255.

   Priorit  od  0  do 63 vyuvaj knihovny jazyka C a uivatel je pouvat
nesm.

   Nejvy  prioritu m 0. Funkce s vymi  prioritami  se  pi  sputn
volaj prvn a pi vstupu jako posledn. Pokud  dnou  prioritu neurte,
bude implicitn 100. Napklad

   #include <stdio.h>

   void startFunc(void)
   {
      printf("Spousteci funkce.\");
   }

   #pragma startup startFunc 64
   /* priorita 64 --> pi sputn se vol jako prvn */

   void exitFunc(void)
   {
      printf("Program bali svou cinnost.\");
   }

   #pragma exit exitFunc
   /* implicitn priorita je 100 */

   void main(void)
   {
      printf("Toto je hlavni funkce.\n");
   }

   Pamatujte, e nzev funkce pouit  v  direktivch  pragma  startup nebo
exit  mus bt definovn (nebo deklarovn) jet  ped  dosaenm  dku  s
direktivou pragma.








                                  - 156 - 


#pragma inline
---------------------------------------------------------------------------

   Tato direktiva je ekvivalentem alternativy -B z kompiltoru s pkazovm
dkem nebo  z integrovanho prosted. Sdluje kompiltoru, e do programu
je zabudovn kd v jazyku symbolickch adres. Syntax je

   #pragma inline

   Nejlpe je tuto direktivu umstit na vrchol souboru, nebo kompiltor se
pi nalezen #pragma inline spout znovu s alternativou -B. Ve skutenosti
lze  vynechat  jak  alternativu  -B,  tak  i  direktivu  #pragma  inline  a
kompiltor se sm  znovu  spust,  jakmile  naraz  na  pkaz  asm. elem
uveden alternativy i direktivy je etit kompilan as.


#pragma option
---------------------------------------------------------------------------

   Direktivy #pragma option se pouv ke vkldn alternativ z pkazovho
dku do textu programu. Jej syntax je

   #pragma option [alternativy...]

   Alternativy kompiltoru s pkazovm dkem jsou  definovny  v Kapitole
11. v Pruce uivatele.

   Alternativami  mohou  bt  jakkoli  alternativy  pkazovho  dku  (s
vjimkou tch, kter uvdme  v  nsledujcm  odstavci). V jedn direktiv
lze  uvst  libovoln  poet alternativ. Stejn jako v pkazovm dku lze
zapnout i vypnout kteroukoli z  pepnacch alternativ (jako teba -a nebo
-K).  V ppad tchto pepnacch alternativ  lze  rovnا  za  alternativu
umstit rku, aby se alternativa vrtila do nastaven z pkazovho dku,
konfiguranho souboru nebo z menu pro alternativy. Tm se umouje njakou
alternativu doasn zmnit a  pak  ji vrtit do vchoz hodnoty, ani byste
si museli pamatovat (nebo dokonce znt), jak vlastn  jej  pesn vchoz
nastaven bylo.

   Mezi alternativy, kter nelze uvdt v direktiv #pragma option, pat:

-B                            _Inzev souboru               -Q
-c                            _Lnzev souboru               -S
-dnzev                       _Ixset                        -T
-Dnzev = etzec             _M                            -V
-enzev souboru               _o                            -X
-E                            _P                            -Y

     #pragma, #include, #define a nkterch #if lze pout ped

   1.  Pouitm   nzvu  libovoln   makroinstrukce,   je   zan   dvma
       podtrenmi  (a  je tud ppadnou  zabudovanou  makroinstrukc)  v
       direktiv #if, #ifdef, #ifndef nebo #elif.

   2.  Vskytem  prvnho  skutenho  lexiklnho  prvku (prvn deklarace v
       jazyku C nebo C++).

     Urit  alternativy  z  pkazovho dku se sm  vyskytnout  jenom  v
pkazu #pragma option ped takovmi udlostmi. Tmito alternativami jsou
                                *
-Enzev souboru               -m                            -u


                                  - 157 - 


  *                                                           *
-f                            -ncesta                       -z
-i#                           -onzev souboru

   Ostatn  alternativy lze  mnit  kdekoli.  Nsledujcmi  alternativami,
jestlie  se  zmn  mezi deklaracemi funkc nebo objekt, se ovlivn pouze
kompiltor:

-1                            -k                            -rd
-2                            -N                            -v
-a                            -O                            -y
-ff                           -P                            -Z
-G                            -r

   Nsledujc alternativy lze zmnit kdykoli a psob okamit:

-A                            -gn                           -zE
-b                            -jn                           -zF
-C                            -K                            -zH
-d                            -wxxx

   O  pouvn  #pragma  option se vzdlenmi objekty  naleznete  vce  na
strnce 203.

   Navc lze za nimi uvdt teku (.), m se alternativa znovu nastav do
stavu z pkazovho dku.


#pragma saveregs
---------------------------------------------------------------------------

   Direktivou pragma  saveregs se zaru, e funkce huge {rozshl} nezmn
obsah dnho registru,  kdy  do  nj  vstoup.  Tto  direktivy  je nkdy
zapoteb pi propojovn  s  kdem jazyka symbolickch adres. Direktivu je
teba umstit pmo  ped  definici  funkce.  Vztahuje se pak pouze na tuto
funkci.


#pragma warn
---------------------------------------------------------------------------

   Direktiva  warn  umon  pedefinovat specifick alternativy pkazovho
dku  -wxxx  (nebo  zkontrolovat  Display  Warnings  v  dialogovm rmeku
Options | Compiler | Messages).

   Obsahuje-li zdrojov text napklad direktivy

   #pragma warn +xxx
   #pragma warn -yyy
   #pragma warn .zzz

   zapne se upozornn xxx (i  kdyby  bylo  v  menu  Options  |  Compiler |
Messages  pepnuto na Off), vypne se upozornn yyy  a  upozornn  zzz  se
nastav na hodnotu, kterou mlo pi zahjen kompilace souboru.

   pln seznam tpsmenovch zkratek a upozornn, ke kterm se vztahuj,
naleznete  v  Kapitole  11.  "Kompiltor  s pkazovm dkem"  v  Pruce
uivatele.




                                  - 158 - 


---------------------------------------------------------------------------
Peddefinovan makroinstrukce
---------------------------------------------------------------------------


   Jazyk Turbo C++ peddefinuje  urit  globln  identifiktory,  z nich
kad v tomto oddlu probereme. S vjimkou __cplusplus kad z  nich zan
i kon dvma znaky  podtren  (__).  Tmto  makrointrukcm se rovnا k
zadan {manifest} konstanty.


__CDECL__
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy  Borland.  Signalizuje,   e   se   nepouil   pznak   -p  (Calling
Convention...C): Nedolo-li k  pouit  -p,  je  nastavena  na celoselnou
konstantu 1. V opanm ppad nen definovna.

   Podle pam؟ovho modelu, kter byl  zvolen  pro  kompilaci,  se definuje
nsledujcch est symbol:

          __COMPAKT__                   __MEDIUM__
          __HUGE_-                      __SMALL__
          _-LARGE_-                     __TINY__

   Pro danou kompilaci je definovn jenom jedin z nich. Ostatn jsou podle
definice nedefinovny. Kompilujete-li napklad  s  malm  {small} modelem,
definuje se makroinstrukce __SMALL__  a  ostatn  definovny  nejsou. Proto
tak direktiva

   #if defined(__SMALL__)

   bude pravdiv (true), zatmco

   #if defined(__HUGE__)

   (nebo kterkoli  jin) bude nepravdiv (false). Skuten hodnota kad z
tchto definovanch makroinstrukc je 1.


__cplusplus
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy  Borland.  Jedn-li  se o reim C++, definuje se jako  1;  v  opanm
ppad  nen  definovna.  Umouje  zpis  modulu,  kter  se nkdy  bude
kompilovat jako jazyk C a nkdy zase jako jazyk C++. Kter z st C, resp.
C++, se vlo je mono ovldat uitm podmnn kompilace.


__DATE__
---------------------------------------------------------------------------

   Tato makroinstrukce poskytne datum,  kdy  preprocesor  zaal zpracovvat
aktuln zdrojov soubor (jako etzcov literl).






                                  - 159 - 


   Kad zaazen __DATE__ do danho  souboru  obsahuje  tut  hodnotu bez
ohledu na dobu zpracovn. Datum bude  mt  formt  mmm dd rrrr, kde mmm je
msc  (Jan,  Feb atd.), dd je den (1 a 31, piem prvn znak v  dd  bude
mezera, pokud je hodnota men ne 10) a rrrr je rok (1990, 1991 atd.).


__FILE__
---------------------------------------------------------------------------

   Tato makroinstrukce poskytne  nzev aktulnho zdrojovho souboru, kter
se zpracovv  (jako  etzcov  literl).  Tato  makroinstrukce  se zmn,
kdykoli kompiltor zpracuje direktivu #include nebo  direktivu  #line, nebo
kdy se vkldac soubor dokon.


__LINE__
---------------------------------------------------------------------------

   Makroinstrukce poskytne slo dku v aktulnm zdrojovm souboru, kter
se zpracovv (jako dekadickou konstantu). Normln se definuje prvn dek
zdrojovho  souboru  jako  1,  co  lze  ovem  ovlivnit direktivou  #line.
Informace o direktiv #line naleznete na strnce 153.


__MSDOS__
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy Borland. Pro vechny kompilace poskytne celoselnou konstantu 1.


__OVERLAY__
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy Borland. Pokud kompilujete njak modul s alternativou -Y (umoujc
podporu  pekryv),  je  makroinstrukce  peddefinovna  jako  1.  Jestlie
podporu pekryv neumonte, je tato makroinstrukce nedefinovna.


__PASCAL__
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy  Borland.  Signalizuje  pouvn  pznaku  -p. Uv-li se  -p,  je
makroinstrukce nastavena na celoselnou  konstantu  1.  V  opanm ppad
zstv nedefinovna.


__STDC__
---------------------------------------------------------------------------

   Makroinstrukce   se   definuje   jako   1,  kompilujete-li  s  pznakem
kompatibility  s  normou  ANSI (-A nebo ANSI Keywords Only...On). V opanm
ppad nen makroinstrukce definovna.







                                  - 160 - 


__TIME__
---------------------------------------------------------------------------

   Makroinstrukce  sleduje  as,  kdy  preprocesor  zaal  aktuln  soubor
zpracovvat (jako etzcov literl).

   Jako v ppad __DATE__ i kad zaazen __TIME__ obsahuje tut hodnotu
bez ohledu na to, jak dlouho zpracovn trv. M formt hh:mm:ss, kde hh je
hodina (00 a 23), mm jsou minuty (00 a 59) a ss jsou sekundy (00 a 59).


__TURBOC__
---------------------------------------------------------------------------

   Tato makroinstrukce je specifick pro  rodinu kompiltor jazyk C a C++
firmy Borland. Je definovna jako hexadecimln konstanta 0x0297. V dalch
verzch se tato seln hodnota bude zvyovat.













































                                  - 161 - 
































































                                  - 162 - 








                            K a p i t o l a   5

                                Funkce main


   V kadm programu v jazyku C nebo C++  mus  bt  funkce  main {hlavn};
jej umstn je  libovoln.  Nkte programtoi umsuj main na zatek
souboru, jin zase  na  konec.  Bez  ohledu  na umstn vak pro main vdy
plat nsledujc body.



---------------------------------------------------------------------------
Argumenty pro main
---------------------------------------------------------------------------


   Zavdc  rutina systmu Turbo C++ pedv  funkci  main  ti  parametry
(argumenty): argc, argv a env.

    -  argc je cel  slo,  udvajc poet argument z pkazovho dku,
       pedvanch do main.
                                                *
    -  argv je polem ukazatel na etzce (char  []).

           o  Pouvte-li  operan  systm  DOS   verze   3.x   a  vy,
              pedstavuje argv[0] pln nzev cesty  k  programu,  kter se
              vykonv.

           o  V ppad  operanho systmu DOS verze ni ne 3.0 ukazuje
              argv[0] na przdn etzec ("").

           o  argv[1] ukazuje na prvn etzec zapsan  v  pkazovm dku
              operanho systmu DOS za nzvem programu.

           o  argv[2] ukazuje na druh etzec zapsan za nzvem programu.

           o  argv[argc-1] ukazuje na posledn argument pedan do main.

           o  argv[argc] obsahuje przdn znak.

    -  env je rovnا polem  ukazatel  na  etzce.  Kad prvek pole env[]
       obsahuje etzec tvaru ENVVAR=hodnota.

           o  ENVVAR  je  nzev  promnn  popisujc prosted, jako teba
              PATH nebo 87.

           o  hodnota je hodnotou,  na  ni se ENVVAR nastavuje, jako teba
              C:\DOS;C:\TOOLS (v ppad PATH) nebo YES (v ppad 87).

   Pokud  nkter  z  tchto  parametr  opravdu  deklarujete,   muste  je
deklarovat pesn v urenm poad: argc, argv, env.  Tak  napklad vesms
platnmi deklaracemi argument funkce main jsou:



                                  - 163 - 


main()
main(int argc)                   /* ppustn, ale velmi nepravdpodobn */
                    *
main(int argc, char   argv[])
                    *              *
main(int argc, char   argv[], char   env[])]


   Deklarace   main(int   argc)   je   sice   ppustn,   ale   je   velmi
nepravdpodobn,  e  byste  ve  svm  programu  pouili  argc, ani  byste
souasn pouili prvk pole argv.

   Argument  env  lze   rovnا  zskat  prostednictvm  globln  promnn
environ. Dal informace naleznete u poloky environ v kapitole  2.  a  pod
vyhledvacmi polokami putenv a getenv v tto kapitole.

   argc a argv  lze  rovnا  zskat  prostednictvm  globlnch promnnch
_argc a _argv.


Ukzkov program
---------------------------------------------------------------------------

   Pinme  ukzkov  program ARGS.EXE, kter  vm  pedvede  jednoduchou
metodu pouit argument, pedanch do main.

/* Program ARGS.C */

#include <stdio.h>
#include <stdlib.h>
                        *             *
int main(int argc, char  argv[], char  env[])
{
   int i;

   printf("Hodnota argc je %d \n\n", argc);
   printf("Toto  jsou  argumenty  z  prikazoveho   radku   %d   predane  do
main:\n\n", argc);

   for (i = 0; i < argc; i++)
      printf("   argv(%d): %s\n", i, argv[i]);

   printf("\nRetezce prostredi tohoto systemu jsou:\n\n");

   for (i = 0; env[i] != NULL; i++)
      printf("   env[%d]; %s\n", i, env[i]);
   return 0;
}


   Pedpokldejme, e program ARGS.EXE spustte na vzvu operanho systmu
DOS nsledujc pkazovm dkem:

C:> args prvni_arg "arg s mezerami" 3 4 "predposledni" stop!


   Vimnte si, e lze pedvat argumenty obsahujc mezery, uzavete-li je
dvojitmi  uvozovkami,  jak  je  vidt  u  "arg  s mezerami"  na  ukzkovm
pkazovm dku.



                                  - 164 - 


   Vstupy z ARGS.EXE (za  pedpokladu,  e  promnn  popisujc prosted
jsou nastaveny jako v ukzce) pak budou vypadat takto:

Hodnota argc je 7

Toto jsou argumenty z prikazoveho radku 7 predane do main:

   argv[0]: C:\TC\TESTARGS.EXE
   argv[1]: prvni_arg
   argv[2]: arg s mezerami
   argv[3]: 3
   argv[4]: 4
   argv[5]: predposledni
   argv[6]: stop!

Retezce prostredi tohoto systemu jsou:

   env[0]: COMSPEC=C:\COMMAND.COM
   env[1]: PROMPT=$p $g
   env[2]: PATH=C:\SPRINT;C:\DOS;C:\TC


   Celkov maximln dlka argument z  pkazovho  dku,  pedvanch do
main (vetn mezer  mezi  sousednmi argumenty a nzvu programu samotnho),
je 128 znak; jde o mez operanho systmu DOS.


Pseudoznaky jako argumenty
---------------------------------------------------------------------------

   Na  vechny  porovnvan  nzvy  soubor   lze   rozit   argumenty  z
pkazovho dku, obsahujc pseudoznaky.  Je  to  tm stejn, jako kdy
operan systm  DOS roziuje pseudoznaky, pouit v pkazech, jako nap.
COPY. K rozen pseudoznak je pouze teba, abyste svj program spojili s
clovm souborem WILDARGS.OBJ, kter je obsaen v systmu Turbo C++.

   Mte-li s kdem svho programu  soubor  WILDARGS.OBJ  spojen,  mete do
funkce  main  odeslat  pseudoznaky typu *.*. Takov argument se roz (v
poli argv) na vechny soubory, odpovdajc pseudoznakov  masce. Maximln
velikost pole argv se mn v zvislosti na  velikosti  pamti,  kter  je k
dispozici v heapu.

   Nenaleznou-li  se  dn  odpovdajc   soubory,   argument   se  ped
nezmnn. (To znamen, e do main se ped atzec, tvoen pseudoznakovou
maskou.)

   Argumenty uzaven v uvozovkch ("...") se neroziuj.


Ukzkov program

   Nsledujcmi pkazy se zkompiluje soubor ARGS.C a spoj  se  s modulem
pro  roziovn  pseudoznak  WILDARGS.OBJ.  Potom se vsledn vykonateln
soubor ARGS.EXE spust:

   tcc args wildargs.obj
   args C:\TC\INCLUDE\*.H "*.C"





                                  - 165 - 


   Kdy ARGS.EXE spustte, prvn argument  se  roz  na  nzvy vekerch
soubor  *.H v adresi INCLUDE v Turbo C++.  Pamatujte  si,  e  rozen
argumentov etzce obsahuj  celou  cestu.  Argument  *.C  se neroziuje,
nebo je uzaven v uvozovkch.

   V integrovanm prosted sta urit projektov  soubor  (z projektovho
menu), kter obsahuje nsledujc dky:

   ARGS
   WILDARGS.OBJ

   Potom k nastaven parametr pkazovho dku pouijte alternativu Run |
Arguments.

Upozornn!
   Pokud  byste  dali  pednost  tomu,  aby  roziovn  pseudoznak  bylo
implicitnm, upravte sv standardn knihovn  soubory  C?.LIB  tak,  aby se
WILDARGS.OBJ pipojil  automaticky.  Za  tm  elem  odstrate  z knihoven
SETARGV a pidejte tam WILDARGS.  Nsledujcmi  pkazy  se  vyvol Turbo-
knihovnk (TLIB), kter  vechny  standardn  knihovn  soubory  uprav (za
pedpokladu,  e  standardn  knihovny jazyka C i C++ a soubor WILDARGS.OBJ
jsou obsaeny v aktulnm adresi):

   Vce se o TLIB dovte ve spaenm dokumentu s nzvem UTIL.DOC.

tlib     cs -setargv +wildargs
tlib     cc -setargv +wildargs
tlib     cm -setargv +wildargs
tlib     cl -setargv +wildargs
tlib     cn -setargv +wildargs




---------------------------------------------------------------------------
Uit -p (konvence voln jazyka Pascal)
---------------------------------------------------------------------------


   Kompilujete-li svj program s vyuitm  konvenc  voln  jazyka Pascal,
nesmte zapomenout explicitn deklarovat funkci main jako typ  C.  Uin se
to klovm slovem cdecl takto:
                          *              *
cdecl main(int argc, char   argv[], char   envp[])




---------------------------------------------------------------------------
Hodnota, kterou poskytuje main
---------------------------------------------------------------------------


   Hodnotou,  kterou  main  poskytuje,  je  kd stavu programu:  typu  int.
Jestlie  vak  program  pouv  k  ukonen rutinu exit (nebo _exit),  je
hodnotou  zskanou z main argument, pedan pro voln  do  exit  (nebo  do
_exit).

   Obsahuje-li program napklad voln



                                  - 166 - 


   exit[1]

   stav se rovn 1.

   Pouvte-li ke spoutn svho programu integrovanho prosted IDE (na
rozdl od kompiltoru s pkazovm  dkem), mete hodnotu zskanou z main
zobrazit volbou File | Get Info.























































                                  - 167 - 
































































                                  - 168 - 








                            K a p i t o l a   6

                           Pouit stream v C++


   Kapitola je rozdlena do  dvou  oddl:  strunho  praktickho pehledu
pouvn streamovch vstup/vstup  (V/V)  v  C++  a  referennho oddlu
vybranch td z knihovny streanovch td v C++.

   Dal ukzky naleznete v Kapitole 6. v Pruce uivatele.

   Streamovch vstup/vstup (funkn podobnch knihovn stdio v jazyku C)
se v  C++  pouv  k  pevodu objekt s piazenmi typy na iteln text a
naopak. Umouje se tm definovat  vstupn/vstupn  funkce,  jich  se pak
automaticky  pouv  pro   odpovdajc  typy,  definovan  uivatelem.  K
hlubmu studiu naleznete nkolik  titul  v  seznamu literatury v Pruce
uivatele.


Co je stream ?
---------------------------------------------------------------------------

   Stream  {proud} je abstraktn pojem, pedstavujc  njak  tok  dat  ze
zdroje (neboli vrobce) do jmky (neboli spotebitele). Mluvme-li o pjmu
znak ze zdroje, pouvme  tak  vraz  vyjmut,  zskn a vyvoln. Pi
vstupu znak do  jmky  mluvme  o  vloen, poloen nebo uloen. Jsou k
dispozici  tdy,  je  podporuj  vyrovnvac pamti (iostream.h), soubory
(fstream.h)  a  etzce  (strstream.h),  a  u jako zdroje i jmky  (nebo
oboj).


Knihovna iostream
---------------------------------------------------------------------------

   Knihovna iostream (definovan  v  iostream.h)  m  dv  paraleln rodiny
td: ty, je jsou odvozeny ze streambuf a ty, je jsou odvozeny z ios. Ob
jsou tdy nzk rovn a kad pln jinou mnoinu kol. Vechny streamov
tdy maj jednu z tchto td za tdu bzovou.


Tda streambuf

   Tda streambuf poskytuje obecn metody k prci s vyrovnvac pamt a k
oetovn  stream  v  ppadech, kdy se  vyaduje  jen  mlo  nebo  dn
formtovn. Tda streambuf je uiten  jako  bzov  tda,  pouvan v
jinch  stech  knihovny  iostream. Mte ji  vak  tak  k  dispozici  pro
odvozovn  svch  vlastnch  funkc  a  knihoven. Z tdy  streambuf  jsou
odvozeny tdy strstreambuf a filebuf.








                                  - 169 - 


                  Ŀ
                    streambuf  
                  
                          
                     Ŀ
                                    
            Ŀ      Ŀ
             filebuf         strstreambuf  
                  

              Obr. 6.1: Tda streambuf a jej odvozen tdy


Tda ios

   Tda ios (a tm i vechny tdy z  n  odvozen)  obsahuje  ukazatel na
streambuf. Vykonv formtovan V/V s kontrolou chyb pouitm streambuf.

   Na  obrzku  6.2  naleznete diagram ddinosti cel rodiny td ios. Tak
napklad tda ifstream je odvozena ze td istream a fstreambase, istream
je  odvozena z istream a strstreambase.  Vzhledem  ke  generickmu  vyuit
vcensobn  ddinosti nepedstavuje tento diagram pouhou hierarchii.  Pi
vcensobn  ddinosti  me  jedin  tda  ddit z vce ne jedn  tdy
bzov. Znamen to napklad, e vechny leny (data i funkce)  z iostream,
istream, ostream, fstreambase a  ios  jsou  soust objekt tdy fstream.
Vechny tdy v sti ios pouvaj jako svho zdroje a/nebo jmky streambuf
(nebo filebuf nebo strstreambuf, co jsou speciln ppady streambuf).

   Programy v C++ zanaj tymi peddefinovanmi  otevenmi  streamy. Ty
se definuj jako objekty td withassign nsledovn:

   extern istream_withassign cin;                         // Odpovd stdin
   extern ostream_withassign cout;                       // Odpovd stdout
   extern ostream_withassign cerr;                       // Odpovd stderr
   extern ostream_withassign clog;             // cerr s vyrovnvac pamt



























                                  - 170 - 


                                Ŀ
                                   ios     
                                
                   Ŀ
         Ŀ         Ŀ  Ŀ
       >istream     fstreambase    strstreambase  ostream<
                    
            Ŀ         ſ    
           Ŀ        Ŀ  ٳ Ŀ
             Ŀ  Ŀ  Ŀ  Ŀ  
             ifstream  istrstream  ofstream  ostrstream  
                   ٳ  
                                                                 
       Ŀ                            
Ŀ  Ŀ          Ŀ Ŀ
istream_withassign  fstream          strstream ostream_withassign
ٳ             
                                                   
                          Ŀ              
                                                   
                               v      v              
                                           
                    ĳiostream
                               
                                   ^
                          Ŀ
                          iostream_withassign
                          
                 Obr. 6.2: Tda ios a jej odvozen tdy

   Podle zaveden praxe m ipky z odvozench td do td bzovch.


Vstupy
---------------------------------------------------------------------------

   Streamov vstupy se realizuj opertorem vloen  (nebo  t piloen)
<<. Standardn opertor posunu vlevo, kterm je <<, se  toti  pepe  pro
vstupn operace. Jeho levm operandem je objekt typu tdy ostream. Pravm
operandem  je  jakkoli  typ, pro kter byl definovn streamov vstup (tj.
zabudovan  typy  nebo  jakkoli typy, kter jsou  pro  to  pedefinovan).
Napklad

   cout << "Hello!\n";

   zape do cout (standardnho vstupnho streamu,  obvykle  na obrazovku)
etzec "Hello!", za kterm nsleduje nov dek.

   Opertor << je asociativn  zleva  doprava  a  poskytuje odkaz na objekt
typu ostream, pro kter je vyvoln. To dovoluje seadit nkolik  vloen za
sebe:

   void display(int i, double d)
   {
      cout << "i = " << i << ", d = " << d << "\n";
   }

   Tm se do standardnho vstupu vype napklad

   i = 8, d = 2.34


                                  - 171 - 


Zabudovan typy
                                                                          *
   Typy vkladatel podporovan pmo  jsou:  char,  short, int, long, char
                                                                         *
(zachz se s nm jako s etzcem), float,  double,  long  double  a void .
Celoseln  typy  se  pevdj  podle  implicitnch  pravidel  pro printf
(ledae byste  tato  pravidla  zmnili  nastavenm  rznch  pznak ios).
Napklad dva nsledujc vstupn pkazy dvaj stejn vsledek:

   int i;
   long l;
   cout << i << " " << l;
   printf("%d %ld", i, l);
                                                     *
   K zobrazen ukazatel se pouv ukazatelov (void ) vkladatel:

   int i;
   cout << &i;                           // hexadecimln zobrazit ukazatel

   Dal vstupn funkce naleznete v popisu tdy ostream (strnka 184).


Formtovn vstup

   Formtovn  vstup i vstup je dno  rznmi  pznaky  stavu  formtu
obsaenmi ve td ios. Tyto stavy se uruj podle bit v njakm long int
takto:

public:
enum {
     skipws      = 0x0001,             // peskoit przdn msto ve vstupu
     left        = 0x0002,                        // vstup zarovnan vlevo
     right       = 0x0004,                       // vstup zarovnan vpravo
     internal    = 0x0008, // doplnit za znamnkem nebo indiktorem zkladu
     dec         = 0x0010,                              // dekadick pevod
     oct         = 0x0020,                               // oktalov pevod
     hex         = 0x0020,                              // dekadick pevod
     showbase    = 0x0080,              // na vstupu ukzat indiktor bze
     showpoint   = 0x0100,        // ukzat deset. teku (vstup poh. te.)
     uppercase   = 0x0200,                  // velk psmena v hex. vstupu
     showpos     = 0x0400,                // kladn cel sla uvdt s '+'
     scientific  = 0x0800,            // ut zpisu poh. te. 1.2345E2 a E
     fixed       = 0x1000,                            // ut zpisu 123.45
     unitbuf     = 0x2000,         // po vloen vechny streamy vyprzdnit
     stdio       = 0x4000,         // po vloen vyprzdnit stdout a stderr
};

   Tyto pznaky se tou  a  nastavuj  lenskmi  funkcemi rdstate a clear
(popsanmi ve td ios ponaje strnkou 179).


Manipultory

   Formtov  promnn  lze  snadno  zmnit  pouitm  specilnho,  funkci
podobnho opertoru, ktermu se  k  manipultor.  Manipultory pejmaj
jako svj argument odkaz na stream  a  poskytnou odkaz na tent stream. To
znamen, e manipultory lze  zabudovat  do  etzu vloen (nebo vyjmut).
Tm se daj stavy streamu mnit jako vedlej  efekt,  ani  by  skuten k
njakmu vloen (nebo vyjmut) dolo. Napklad



                                  - 172 - 


   cout << setw(4) << i << setw(6) << j;

   je ekvivalentem slovn bohatho

   cout.width(4);
   cout << i;
   cout.width(6);
   cout << j;

   setw  je  parametrizovan  manipultor  deklarovan  v  iomanip.h.  Jin
parametrizovan manipultory setbase, setfill, setprecision,  setiosflags a
resetiosflags pracuj stejnm zpsobem. Aby se daly vyut, je teba  mt v
programu vloen soubor iomanip.h.  Lze  napsat  i sv vlastn manipultory
bez parametr:

   ostream& dingy( ostream& os)
   {
      return os << "\a\a";
   }
   ...
   cout << i << dingy << j;

   Neparametrizovan manipultory dec, hex a oct (deklarovan v iostream.h)
nepejmaj  dn  argumenty  a  pouze  mn zklad pevod (a nechaj  ho
zmnn):

   int i = 36;
   cout << dec << i << " "
      << hex << i << " "
      << oct << i << endl;
   // zobraz 36 24 44


                     Tab. 6.1: Streamov manipultory

---------------------------------------------------------------------------
Manipultor              innost
---------------------------------------------------------------------------
dec                      Nastaven formtovho pznaku na zklad pro
                         dekadick pevody.
hex                      Nastaven formtovho pznaku na zklad pro
                         hexadecimln pevody.
oct                      Nastaven formtovho pznaku na zklad pro
                         oktalov pevody.
ws                       Vyjmout znaky przdnch mst.
endl                     Vloit nov dek a vyprzdnit stream.
ends                     Vloit do etzce nulov termintor.
flush                    Vyprzdnit ostream.
setbase(int)             Nastavit formt zkladu pevod na zklad n (0, 8,
                         10 nebo 16). 0 znamen implicitn nastaven:
                         dekadick na vstupu, pravidla jazyka C pro
                         literlov cel sla na vstupu.
resetiosflags(long)      Smazat uren formtov bity v ins nebo v outs.
setiosflags(long)        Nastavit uren formtov bity v ins nebo v outs.
setfill(int)             Nastavit vplov znak na n.
setprecision(int)        Nastavit pesnost v pohybliv tece na n slic.
setw(int)                Nastavit ku poloky na n.
---------------------------------------------------------------------------




                                  - 173 - 


   Manipultor  endl vlo znak novho dku  a  vyprzdn  stream.  Stream
ostream lze rovnا kdykoli vyprzdnit takto:

   ostream << flush;


Vyplovn a doplovn

   Vplov znak a smr doplovn zvis na nastaven znaku  pro  vpl  a
pznak left, right a internal.

   Implicitnm znakem pro vpl je  mezera. Mete jej vak zmnit pouitm
funkce fill:

   int i = 123;
   cout.fill('*');
   cout.width(6);
   cout << i;                                          // zobraz se ***123

   Implicitn smr doplovn je dn zarovnnm doprava  (doplovn smrem
vlevo). Tyto implicitn hodnoty  lze  pozmnit  (i jin formtov pznaky)
funkcemi setf a unsetf:

   int i = 56;
   ...
   cout.width(6);
   cout.fill('#');
   cout.setf(ios::left, ios::adjustfield);
   cout << i;                                          // zobraz se 56####

   Druh argument, kterm je  ios::adjustfield,  sdl  funkci  setf, kter
bity m nastavit. Prvn argument, toti ios::left, sdl  funkci  setf, jak
m tyto bity nastavit. Alternativn je mon ke zmn  vplovho  znaku  a
reimu doplovn pout manipultor setfill, setiosflags a resetiosflags.


Uivatelsky definovan vkladatele

   Pro  vstup  vlastnch  datovch  typ  je  mon  si napsat  vkladatele
pepisem opertoru <<. Dejme tomu, e mte typ

   struct info {
           *
      char  nazev;
      double hodnota;
           *
      char  jednotky;
   };

   Opertor << lze nsledovn pepsat:

   ostream& operator << (ostream& s, info& m)
   {
      s << m.nazev << " " << m.hodnota << " " << m.jednotky;
   }

   Pkazy

   info x;
   ...


                                  - 174 - 


   // zde je inicializace x
   ...
   cout << x;

   by vznikl vstup jako nap. "kapacita 1.25 litru".


Vstupy
---------------------------------------------------------------------------

   Streamov   vstupy  se  podobaj  vstupm,  pouvaj  ale   pepsanho
opertoru posunu vpravo >>,  ktermu  se  k opertor extrakce (vyjmut),
neboli  extraktor. Levm operandem pro >> je  objekt  typu  tdy  istream.
Stejn jako u vstup, prav operand me bt jakhokoli typu, pro nj byl
definovn streamov vstup.

   Implicitn pesko >> przdn msto (co se definuje  funkc  isspace v
souboru ctype.h) a  potom  nat  znaky  v  souladu  s  typem vstupujcho
objektu. Peskakovn przdnch mst  se  ovld  pznakem  ios::skipws ve
vtu stavu formtu. Pznak  skipws  je  normln nastaven na peskakovn
przdnch  mst.  Smaznm  tohoto  pznaku  (napklad  funkc  setf)  se
peskakovn  przdnch  mst  vypne.  Existuje  tak  speciln  "jmkov"
manipultor ws, kter umouje przdn msto vymazat.

   Zvate nsledujc pklad:

   int i;
   double d;
   cin >> i >> d;

   Posledn dek zpsob peskoen  przdnho  msta.  slice,  kter se
petou  ze  standardnho  vstupu  (implicitn  je  to  klvesnice) se  pak
pevedou do vnitnho binrnho tvaru a ulo se do promnn i. Pesko se
dal przdn msto a nakonec se pete slo s pohyblivou  tekou, pevede
a ulo se do promnn d.

   U  typu  char  (se znamnkem nebo bez nj) je inek  opertoru  >>  dn
peskoenm przdnho msta a  uloenm  dalho  znaku (jinho ne przdn
msto). Pokud chcete st nsledujc znak, a u jde o przdn  msto nebo
ne, mete pout jedn z lenskch funkc get (viz odkazy na strnkch pro
tdu istream v tto kapitole).
              *
   U typu char  (se kterm se zachz jako s etzcem) je  inek opertoru
>>  dn  peskoenm  przdnho msta a ukldnm dalch znak (jinch ne
przdn  msta),  dokud  se nenalezne dal przdn msto. Potom se pipoj
zvren nulov (0) znak. Je teba  dbt  na to, aby nedolo k "peplnn"
etzce. Implicitn nulovou ku (znamenajc  dn  omezen)  lze zmnit
pouitm setw:

   char pole[VELIKOST];
   ...
   // inicializace pole
   ...
   cin.width(sizeof(pole));
   cin >> pole;                                        // zabrn peplnn

   Pro  vechny vstupy zabudovanch typ plat,  e  vyskytne-li  se  konec
vstupu jet ped nalezenm njakho znaku rznho od  przdnho  msta, do
clovho  pole  buf  se  neulo  nic  a  stav  istreamu  se  nastav  jako



                                  - 175 - 


"nespch".    Pokud   by   cl   nebyl   inicializovn,   zstane    stle
neinicializovanm.


Uivatelsky definovan typy pro vstupy

   Extraktory pro vlastn definovan  typy  lze  vytvoit  stejnm zpsobem
jako vkladatele. Vyjdeme-li ze struktury  informac  definovan  na strnce
174, lze opertor >> pepsat nsledovn:

   istream& operator >> (istream& s, info& m);
   {
      s >> m.nazev >> m.hodnota >> m.jednotky;
      return s;
   }

   (Ve  skuten  aplikaci  by  se  ovem  jet  pidal kd  pro  kontrolu
vstupnch  chyb.)  K  peten vstupnho dku jako  teba  "kapacita  1.25
litru" by se pouilo dku s textem

   cin >> m;


Jednoduch vstupy/vstupy soubor
---------------------------------------------------------------------------

   Pamatujte, e v Turbo C++ fstream.h vlo automaticky iostream.h

   Tda  ofstream  dd  operace  pro  vkldn z tdy  ostream,  zatmco
ifstream  dd  operace  extrakc  z   tdy   istream.   Poskytuj  rovnا
konstruktory  a lensk funkce k vytven soubor  a  oetovn  V/V  pro
soubory.  Do vech program, kter tchto td  uvaj,  je  teba  vloit
soubor fstream.h. Promyslete si nsledujc pklad,  jen  kopruje soubor
SOUBOR.IN do souboru SOUBOR.OUT:

   #include fstream.h
   ...
   char ch;
   ifstream f1("soubor.in");
   if (!f1)
      errmsg("'soubor.in' nelze otevrit pro vstup");
   ofstream f2("soubor.out");
   if (!f2)
      errmsg("'soubor.out' nelze otevrit pro vystup");
   while ( f2 && f1.get(ch) )
      f2.put(ch);

   Pamatujte si, e  pokud  konstruktory  ifstream  nebo  ofstream nedok
poadovan soubor otevt, nastav se patin chybov stav streamu.

   Konstruktory umouj deklarovat  souborov  stream,  ani  by  se uril
konkrtn  soubor.   Poslze  je  pak  mon  souborov  stream  sdruit  s
konkrtnm souborem:

   ofstream ofile;                     // vytv stream vstupnho souboru
   ...
   ofile.open("vyp_list");            // stream ofile se sdru se souborem
                        // "vyp_list"

   // njak innost s vplatami


                                  - 176 - 


   ofile.close();                                   // "vyp_list" se uzave
   ofile.open("zamest");                          // ofile lze pout znovu

   Implicitn se soubory otvraj  v  textovm  reimu.  Znamen to, e pi
vstupu se posloupnosti nvrat vozku/nov dek pevdj na znak '\n'. Pi
vstupu se znak '\n' pevd  na posloupnost nvrat vozku/nov dek. Tyto
peklady  se  v  binrnm  reimu  nedlaj.  Reim  souboru  se  nastavuje
nepovinnm tetm parametrem funkce open,  kter  se  vybr  z nsledujc
tabulky:


                         Tab. 6.2: Reimy souboru

---------------------------------------------------------------------------
Reimov bit        innost
---------------------------------------------------------------------------
ios::app            Pipojit data - zapisovat vdy na konec souboru.
ios::ate            Po pvodnm oteven prohledat do konce souboru.
ios::in             Otevt pro vstup (plat i pro ifstreamy).
ios::out            Otevt pro vstup (plat i pro ofstreamy).
ios::trunc          Vymazat obsah, pokud soubor existuje (plat kdy je
                    uren ios::out a nen uren ios::atei ani ios::app).
ios::nocreate       Jestli soubor neexistuje, open sele.
ios::noreplace      Kdy soubor existuje, open pro vstup sele, pokud nen
                    nastaven ate nebo app.
---------------------------------------------------------------------------


Zpracovn etzcovch stream
---------------------------------------------------------------------------

   Funkce definovan v strstream.h podporuj formtovn  v  pamti podobn
jako sscanf a sprintf, ale  mnohem pizpsobivji. Vechny funkce z istream
jsou k dispozici  pro  tdu istrstream ("input string stream"); analogicky
pro vstup: ostrstream dd z ostream.

   Nsledujc ukzkov program te textov soubor s nsledujcm formtem:

   101   191   Cedrova skrin
   102   1999.99  Obyvaci souprava

   Kad  dek  se  syntakticky  analyzuje  na  ti   sloky:  celoseln
identifiktor ID, cenu s pohyblivou tekou a njak popis. Vznikne vstup:

   1: 101   191   Cedrova skrin
   2: 102   1999.99  Obyvaci souprava

   Nsleduje program:

   #include <fstream.h>
   #include <strstream.h>
   #include <iomanip.h>
   #include <string.h>
                            **
   void main(int argc, char   argv)
   {
      int id;
      float mnozstvi;
      char popis[41];
      ifstream inf(argv[1], ios::in);


                                  - 177 - 


      if (inf)
      {
         char inbuf[81];
         int cisrad = 0;

         // Chceme tisk pohyb. teky jako pevn teky
         cout.setf(ios::fixed, ios::floatfield);

         // Chceme aby pohyb. teka mla vdy deset. msta
         cout.setf(ios::showpoint);

         while (inf.getline(inbuf, 81))
         {
            // 'ins' je etzcov stream;
            istrstream ins(inbuf, strlen(inbuf));

            ++cisrad;
            ins >> id >> mnozstvi >> ws;
            ins.getline(popis, 41);                    // Stle nov dek!
            cout << cisrad << ": "
               << id << '\t'
               << setprecision(2) << mnozstvi << '\t'
               << popis;
         }
      }
   }

   V  pedchoz  ukzce  si  uvdomte   pouit   formtovch   pznak  a
manipultor. Volnm setf spojenm se setprecision umonte tisknout sla
s pohyblivou dovou  tekou  v penاnm formtu. Manipultor ws peskakuje
przdn msta ped tenm etzce popisu.



---------------------------------------------------------------------------
Pehled streamovch td
---------------------------------------------------------------------------


   Knihovna  streamovch  td  v  C++  obsahuje nkolik set td. V  tomto
pehledu probereme podrobn nkter z nejpouvanjch td. Jsou seazeny
abecedn. Kter tdy pat  do  kterch  soubor  zhlav zjistte v tomto
kovm seznamu:
iostream.h:         ios, iostream, iostream_withassign, istream,
                    istream_withassign, ostream, ostream_withassign,
                    streambuf.

fstream.h:          filebuf, fstream, fstreambase, ifstream, ofstream.

strstream.h:        istrstream, ostrstream, strstream, strstreambase,
                    strstreambuf.



---------------------------------------------------------------------------
filebuf                                                         <fstream.h>
---------------------------------------------------------------------------


Odvozena z     streambuf


                                  - 178 - 


Bze pro       dnou

Popis          Specializuje streambuf pro oetovn soubor.

Konstruktory   filebuf() Sestav filebuf, kter nen
                    pipojena k souboru.

               filebuf(int fd) Sestav filebuf pipojenou k
                    souboru prostednictvm popisovae souboru.
                                    *
               filebuf(int fd, char  , int n) Sestav
                    filebuf pipojenou k souboru a pouije urenou
                    n-znakovou vyrovnvac pam؟.
                      *
lensk        filebuf  attach(int) Pipoj tuto uzavenou
funkce              filebuf k popisovai otevenho souboru.
                      *
               filebuf  close() Vyprzdn a uzave soubor.
                    V ppad chyby poskytne 0.

               int fd() Poskytne popisova souboru nebo
                    EOF.

               int is_open() Je-li soubor oteven, poskytne
                    nenulovou hodnotu.
                      *                *
               filebuf  open(const char , int mode, int prot =
                    filebuf::openprot) Oteve zadan soubor a pipoj
                    se k nmu.

               virtual long seekoff(long seek_dir, int)
                    Pemst ukazatel souboru vi aktuln pozici.
                                *            *
               virtual streambuf  setbuf(char , int)
                    Uruje vyrovnvac pam؟ pro tuto filebuf.



---------------------------------------------------------------------------
fstream                                                         <fstream.h>
---------------------------------------------------------------------------


Odvozena z     fstreambase, iostream

Bze pro       dnou

Popis          Slou k simultnnm vstupm a vstupm na filebuf.

Konstruktory   fstream() Sestav fstream, kter nen
                    pipojena k souboru.
                                 *
               fstream(const char , int, int =
                    filebuf::openprot) Sestav fstream, oteve soubor a
                    pipoj se k nmu.

               fstream(int) Sestav fstream, pipoj se k
                    popisovai otevenho souboru.
                                   *
               fstream(int _f, char , int) Sestav fstream


                                  - 179 - 


                    pipojenou k otevenmu souboru a pouije urenou
                    vyrovnvac pam؟.
                                   *
lensk        void open(const char , int, int =
funkce         filebuf::openprot) Oteve soubor pro
                    fstream.
                      *
               filebuf  rdbuf() Poskytne pouitou
                    vyrovnvac pam؟.



---------------------------------------------------------------------------
fstreambase                                                     <fstream.h>
---------------------------------------------------------------------------


Odvozena z     ios

Bze pro       fstream, ifstream, ofstream

Popis          Slou k operacm, kter jsou spolen pro streamy pracujc
               se soubory.

Konstruktory   fstreambase() Sestav fstreambase, kter
                    nen pipojena k souboru.
                                     *
               fstreambase(const char , int, int = filebuf::openprot)
                    Sestav fstreambase, oteve soubor a pipoj se k nmu.

               fstreambase(int) Sestav fstreambase,
                    pipoj se k popisovai otevenho souboru.
                                       *
               fstreambase(int _f, char , int) Sestav
                    fstreambase pipojenou k otevenmu souboru a pouije
                    urenou vyrovnvac pam؟.

lensk        void attach(int) Pipoj se k popisovai
funkce              otevenho souboru.

               void close() Uzave sdruenou filebuf i
                    soubor.
                                   *
               void open(const char , int, int =
                    filebuf::openprot) Oteve soubor pro fstreambase.
                      *
               filebuf  rdbuf() Poskytne pouitou
                    vyrovnvac pam؟.
                               *
               void setbuf(char , int) Pouije urenou
                    vyrovnvac pam؟.



---------------------------------------------------------------------------
ifstream                                                        <fstream.h>
---------------------------------------------------------------------------


Odvozena z     fstreambase, istream


                                  - 180 - 


Bze pro       dnou

Popis          Slou ke vstupnm operacm na filebuf.

Konstruktory   ifstream() Sestav ifstream, kter nen
                    pipojena k souboru.
                                  *
               ifstream(const char , int, int = filebuf::openprot)
                    Sestav ifstream, oteve soubor a pipoj se k nmu.

               ifstream(int) Sestav ifstream, pipoj se k
                    popisovai otevenho souboru.
                                    *
               ifstream(int fd, char , int) Sestav
                    ifstream pipojenou k otevenmu souboru a pouije
                    urenou vyrovnvac pam؟.
                                   *
lensk        void open(const char , int, int =
funkce         filebuf::openprot) Oteve soubor pro
                    ifstream.
                      *
               filebuf  rdbuf() Poskytne pouitou
                    vyrovnvac pam؟.



---------------------------------------------------------------------------
ios                                                            <iostream.h>
---------------------------------------------------------------------------


Odvozena z     dn

Bze pro       istream, ostream, fstreambase, strstreambase

Popis          Tda ios poskytuje operace spolen jak pro vstupy, tak i
               pro vstupy. Jej odvozen tdy (istream, ostream,
               iostream) specializuj V/V prostednictvm formtovacch
               operac vysok rovn.

Konstruktory   ios(streambuf)cc Sdru zadanou streambuf se
               streamem.

lensk        int bad() Dojde-li k chyb, poskytne
funkce              nenulovou hodnotu.

               void clear(int = 0) Nastav stav streamu na
                    zadanou hodnotu.

               int eof() Pi nalezen konce souboru
                    poskytne nenulovou hodnotu.

               int fail() Pi selhn operace poskytne
                    nenulovou hodnotu.

               char fill() Poskytne aktuln vplov znak.

               char fill(char) Znovu nastav vplov znak;
                    poskytne znak pedchoz.



                                  - 181 - 


               long flags() Poskytne aktuln formtov
                    pznaky.

               long flags(long) Nastav formtov pznaky,
                    aby byly identick se zadanm long; poskytne pznaky
                    pedchoz.

               int good() Je nenulov, nejsou-li nastaveny
                    dn stavov bity (tj. nedolo k dnm chybm).

               int precision(int) Nastav pesnost
                    v pohybliv tece; poskytne pedchoz nastaven.

               int precision() Poskytne aktuln pesnost
                    v pohybliv tece.
                        *
               streambuf  rdbuf() Poskytne ukazatel na
                    piazenou streambuf tohoto streamu.

               int rdstate() Poskytne stav streamu.

               long setf(long _setbits, long _field) Bity
                    odpovdajc tm, kter jsou oznaeny ve _field, se
                    vyist a pak nastav shodn s tmi, kter jsou
                    oznaeny v _setbits.

               long setf(long) Nastav pznaky
                    odpovdajc tm, kter jsou oznaeny v zadanm long;
                    poskytne pedchoz nastaven.
                      *n
               ostream   tie() Poskytne svzan {tied}
                    stream, ppadn 0, pokud takov neexistuje. Svzan
                    streamy jsou ty, je jsou pipojeny takovm zpsobem,
                    e pi pouit jednoho se njak ovlivn i druh.
                    Napklad cin a cout jsou svzan; pi pouit cin se
                    nejprve vyprzdn cout.
                      *n            *
               ostream   tie(ostream ) Sve s tmto
                    streamem njak jin a poskytne pedchoz svzan
                    stream. Kdy m vstupn stream znaky, je se maj
                    spotebovat, nebo kdy vstupn stream potebuje vce
                    znak, nejprve se automaticky vyprzdn svzan stream.
                    Implicitn jsou cin, cerr a clog svzan s cout.

               long unsetf(long) Vyist bity odpovdajc
                    tm, je jsou oznaeny v zadanm long; poskytne
                    pedchoz nastaven.

               int width() Poskytne aktuln nastaven
                    ky.

               int width(int) Nastav ku podle
                    zadn; poskytne ku pedchoz.









                                  - 182 - 


---------------------------------------------------------------------------
iostream                                                       <iostream.h>
---------------------------------------------------------------------------


Odvozena z     istream, ostream

Bze pro       fstream, strstream

Popis          Tato tda je pouhou sms svch bzovch td, umoujc
               na streamu jak vstup, tak i vstup.
                                  *
Konstruktory   iostream(streambuf  ) Sdru zadanou
                    streambuf se streamem.

lensk        dn
funkce



---------------------------------------------------------------------------
iostream_withassign                                            <iostream.h>
---------------------------------------------------------------------------


Odvozena z     iostream

Bze pro       dnou

Popis          Tato tda je iostream s pidanm opertorem dosazen.

Konstruktory   iostream_withassign() Przdn konstruktor
                    (vol konstruktor tdy iostream).

lensk        dn (akoli opertor = je pepsn).
funkce



---------------------------------------------------------------------------
istream                                                        <iostream.h>
---------------------------------------------------------------------------


Odvozena z     ios

Bze pro       ifstream, iostream, istrstream, istream_withassign

Popis          Tato tda poskytuje formtovan i neformtovan vstupy ze
               streambuf. Opertor >> je pro vechny vestavn skalrn
               typy pepsn. Vysvtlili jsme to ve vkladu na zatku tto
               kapitoly a zde to dle nepopisujeme.
                                 *
Konstruktory   istream(streambuf  ) Sdru zadanou
                    streambuf se streamem.

lensk        int gcount() Poskytne poet naposled
funkce              vyjmutch znak.

               int get() Vyjme nsledujc znak nebo EOF.


                                  - 183 - 


                                       *
               istream& get(signed char , int len, char = '\n')
                                         *
               istream& get(unsigned char , int len, char = '\n')
                                                 *
                    Vyjm znaky do zadanho char  a po vskyt oddlovae
                    (tet parametr) nebo konce souboru, resp. a do
                    peten (len - 1) byt. Do vstupnho etzce se vdy
                    umst nulov termintor. Nikdy se tam neumst
                    oddlova. Je nespn jen kdy nebyly vyjmuty dn
                    znaky.

               istream& get(unsigned char&)
               istream& get(signed char&) Vyjme jedin znak
                    do zadanho znakovho odkazu.

               istream& get(streambuf&, char = '\n') Vyjm
                    znaky do zadan streambuf a do vskytu oddlovae.
                                           *
               istream& getline(signed char , int, char = '\n')
                                             *
               istream& getline(unsigned char , int, char = '\n') Tot
                    jako get a na to, e se vyjme i oddlova.

               istream& ignore(int = 1, int delim = EOF)
                    Zpsob peskoen n znak ve vstupnm streamu; zastav
                    se pi vskytu delim.

               int peek() Poskytne nsledujc znak bez
                    jeho vyjmut.

               istream& putback(char) Vtla znak zpt do
                    streamu.
                                        *
               istream& read(signed char , int)
                                          *
               istream& read(unsigned char , int) Vyjme
                    zadan poet znak do pole. Dojde-li k chyb, pouijte
                    pro poet skuten vyjmutch znak gcount().

               istream& seekg(long) Pemst se na njakou
                    absolutn pozici (kter se zsk z tellg).

               istream& seekg(long, seek_dir) Pemst se
                    na njakou pozici vzhledem k pozici aktuln podle
                    definice: enum seek_dir {beg, cur, end};

               long tellg() Poskytne aktuln pozici ve
                    streamu.



---------------------------------------------------------------------------
istream_withassign                                             <iostream.h>
---------------------------------------------------------------------------


Odvozena z     istream

Bze pro       dnou


                                  - 184 - 


Popis          Tato tda je istream s pidanm opertorem dosazen.

Konstruktory   istream_withassign() Przdn konstruktor
                    (vol konstruktor tdy istream).

lensk        dn (akoli opertor = je pepsn).
funkce



---------------------------------------------------------------------------
istrstream                                                    <strstream.h>
---------------------------------------------------------------------------


Odvozena z     strstreambase, istream

Bze pro       dnou

Popis          Poskytuje vstupn operace na strstreambuf.
                                    *
Konstruktory   istrstream(const char ) Sestav istrstream
                    s urenm etzcem (nulov znak se nikdy nevyjme).
                                     *
               istrstream(const char  , int n) Sestav
                    istrstream pouitm n byt urenho etzce>

lensk        dn
funkce



---------------------------------------------------------------------------
ofstream                                                        <fstream.h>
---------------------------------------------------------------------------


Odvozena z     fstreambase, ostream

Bze pro       dnou

Popis          Slou k vstupnm operacm na filebuf.

Konstruktory   ofstream() Sestav ofstream, kter nen
                    pipojena k souboru.
                                  *
               ofstream(const char , int, int = filebuf::openprot)
                    Sestav ofstream, oteve soubor a pipoj se k nmu.

               ofstream(int) Sestav ofstream, pipoj se k
                    popisovai otevenho souboru.
                                    *
               ofstream(int fd, char , int) Sestav
                    ofstream pipojenou k otevenmu souboru a pouije
                    urenou vyrovnvac pam؟.
                                   *
lensk        void open(const char , int, int =
funkce         filebuf::openprot) Oteve soubor pro
                    ofstream.



                                  - 185 - 


                      *
               filebuf  rdbuf() Poskytne pouitou
                    vyrovnvac pam؟.



---------------------------------------------------------------------------
ostream                                                        <iostream.h>
---------------------------------------------------------------------------


Odvozena z     ios

Bze pro       iostream, ofstream, ostrstream, ostream_withassign

Popis          Tato tda poskytuje formtovan i neformtovan vstupy do
               streambuf. Opertor << je pro vechny vestavn skalrn
               typy pepsn, co jsme vysvtlili na strnce 171.
                                 *
Konstruktory   ostream(streambuf  ) Sdru zadanou
                    streambuf se streamem.

lensk        ostream& flush() Vyprzdn stream
funkce
               ostream& seekp(long) Pemst se na
                    absolutn pozici (kterou zskte z tellp).

               ostream& seekp(long, seek_dir) Pemst se
                    na njakou pozici vzhledem k pozici aktuln podle
                    definice: enum seek_dir {beg, cur, end};

               ostream& put(char) Vlo znak.

               long tellp() Poskytne aktuln pozici ve
                    streamu.
                                               *
               ostream& write(const signed char , int n)
                                                 *
               ostream& write(const unsigned char , int n)
                    Vlo n znak (vetn nulovch).



---------------------------------------------------------------------------
ostream_withassign                                             <iostream.h>
---------------------------------------------------------------------------


Odvozena z     ostream

Bze pro       dnou

Popis          Tato tda je ostream s pidanm opertorem dosazen.

Konstruktory   ostream_withassign() Przdn konstruktor
                    (vol konstruktor tdy ostream).

lensk        dn (akoli opertor = je pepsn).
funkce



                                  - 186 - 


---------------------------------------------------------------------------
ostrstream                                                    <strstream.h>
---------------------------------------------------------------------------


Odvozena z     strstreambase, ostream

Bze pro       dnou

Popis          Slou k vstupnm operacm na strstreambuf.

Konstruktory   ostrstream() Sestav dynamickou ostrstream.
                              *
               ostrstream(char , int, int) Sestav
                    ostrstream s urenou n-bytovou vyrovnvac pamt.
                    Je-li mode roven ios::app nebo ios::ate, umst se
                    ukazatel pro zskn\vloen v etzci na nulov znak.
                    *
lensk        char  pcount() Poskytne poet byt aktuln
funkce              uloench ve vyrovnvac pamti.
                    *
               char  str() Poskytne a zmraz vyrovnvac
                    pam؟. Byla-li dynamick, muste ji uvolnit.



---------------------------------------------------------------------------
streambuf                                                      <iostream.h>
---------------------------------------------------------------------------


Odvozena z     dn

Bze pro       filebuf, strstreambuf

Popis          Je to tda pro oetovn vyrovnvac pamti. Normln
               pro aplikace nepouvte pmo ji, ale jej odvozen tdy.

Konstruktory   streambuf() Vytvo przdn objekt
                    vyrovnvac pamti.
                              *
               streambuf(char  , int) Pouv jako
                    vyrovnvac pamti zadan pole a jeho velikost.

lensk        int in_avail() Poskytne zbvajc poet
funkce              znak ve vstupn vyrovnvac pamti.

               int out_waiting() Poskytne zbvajc poet
                    znak ve vstupn vyrovnvac pamti.

               int abumpc() Poskytne aktuln znak ze
                    vstupn vyrovnvac pamti, pak postoup.
               virtual long seekoff(long, seek_dir, int = (ios::in |
               ios::out) Pemst ukazatel pro zskvn a/nebo pro
                    vkldn (tetm argumentem se stanov kter, i zda
                    oba) vi aktuln pozici.

               virtual long seekpos(long, int = (ios::in |
               ios::out) Pemst ukazatel pro zskvn a/nebo pro
                    vkldn ma mjakou absolutn pozici.


                                  - 187 - 


               int sgetc() Ukazuje na dal znak ve vstupn
                    vyrovnvac pamti.
                          *
               sgetn(char  , int n) Zsk dalch n znak
                    ze vstupn vyrovnvac pamti.
                                *                   *
               virtual streambuf  setbuf(signed char , int)
                    Pipoj se k zadan vyrovnvac pamti.

               int snextc() Postoup a poskytne nsledujc
                    znak ze vstupn vyrovnvac pamti.

               int sputback(char) Poskytne znak pro vstup.

               int sputc(int) Vlo jeden znak do vstupn
                    vyrovnvac pamti.
                                    *
               int sputn(const char  , int n) Vlo n znak
                    do vstupn vyrovnvac pamti.

               void stossc() Postoup na dal znak ve
                    vstupn vyrovnvac pamti.



---------------------------------------------------------------------------
strstreambase                                                 <strstream.h>
---------------------------------------------------------------------------


Odvozena z     ios

Bze pro       strstream, istrstream, ostrstream

Popis          Specializuje ios na etzcov streamy.

Konstruktory   strstreambase() Sestav przdnou
                    strstreambase.
                                        *
               strstreambase(const char  , int, char
               *
                start) Sestav strstreambase s urenou vyrovnvac
                    pamt a poten pozic.

lensk        dn (pouv ios).
funkce



---------------------------------------------------------------------------
strstreambuf                                                  <strstream.h>
---------------------------------------------------------------------------


Odvozena z     streambuf

Bze pro       dnou

Popis          Specializuje streambuf pro formtovn v pamti.



                                  - 188 - 


Konstruktory   strstreambuf() Sestav dynamickou
                    strstreambuf. Pam؟ se bude dynamicky pidlovat podle
                    poteby.
                                 *  *              *  *       *
               strstreambuf(void   ( )(long), void   ( )(void  ))
                    Sestav dynamickou vyrovnvac pam؟ s urenmi
                    funkcemi pro pidlovn a uvolovn.

               strstreambuf(int n) Sestav dynamickou
                    strstreambuf a na potku pidl vyrovnvac pamti
                    nejmn n byt.
                                 *            *
               strstreambuf(char  , int, char  end) Sestav
                    statickou strstreambuf s urenou vyrovnvac pamt.
                    Nen-li end nulov znak, oddluje tuto vyrovnvac
                    pam؟.

lensk        void freeze(int = 1) Je-li vstupn parametr
funkce              nenulov, zablokuje ukldn jakchkoli znak do
                    vyrovnvac pamti. Lze odmrazit pednm nuly.
                    *
               char  str() Poskytne ukazatel na vyrovnvac
                    pam؟ a zmraz ji.
                                *            *
               virtual streambuf  setbuf(char , int)
                    Specifikuje pam؟, kter se m pouvat.

               virual long seekoff(long, seek_dir, int)
                    Pemst ukazatel vi aktuln pozici.



---------------------------------------------------------------------------
strstream                                                     <strstream.h>
---------------------------------------------------------------------------


Odvozena z     strstreambase, iostream

Bze pro       dnou

Popis          Poskytuje simultnn vstupy a vstupy na strstreambuf.

Konstruktory   strstream() Sestav dynamickou strstream.
                             *
               strstream(char , int n, int mode) Sestav
                    strstream s urenou n-bytovou vyrovnvac pamt. Je-li
                    mode roven ios::app nebo ios::ate, umst se ukazatel
                    pro zskn\vloen v etzci na nulov znak.
                    *
lensk        char  str() Poskytne a zmraz vyrovnvac
funkce         pam؟. Byla-li dynamick, mus ji uvolnit uivatel.










                                  - 189 - 
































































                                  - 190 - 








                            K a p i t o l a   7

                               Sprva pamti


   V kapitole probrme:

    o  Chyby z nedostatku pamti. Co dlat, kdy se njak vyskytne.

    o  Pam؟ov modely, od drobnch po rozshl. ekneme vm o co  jde, jak
       si  z  nich  vybrat  a  pro  konkrtn  pam؟ov model  pout  (i
       nepout).

    o  Pekryvy. Jak funguj a jak jich pouvat.



---------------------------------------------------------------------------
Vyerpn pamti
---------------------------------------------------------------------------


   Turbo  C++  pi  kompilaci  negeneruje  dn  asov  pechodn  datov
struktury na disk (Turbo C++ zapisuje na disk jenom  soubory  .OBJ).  Msto
toho uv pro  doasn  datov struktury mezi jednotlivmi prchody pamti
RAM. Proto se pi nedostatku  pamti pro kompiltor me vyskytnout hlen
"Out of memory..." {Nedostatek pamti}.

   een  tohoto  problmu  spov ve zmenen funkc  nebo  v  rozdlen
souboru, kter takov velk  funkce  m.  Rovnا  je vhodn zruit vechny
programy instalovan jako rezidentn v RAM a uvolnit tm  vce  pamti  pro
vyuit v Turbo C++.



---------------------------------------------------------------------------
Pam؟ov modely
---------------------------------------------------------------------------


   Souhrn vech pam؟ovch model se nachz na strnce 195.

   Jazyk Turbo C++ nabz  est  pam؟ovch model, z nich kad je vhodn
pro jinou velikost programu  a  kdu.  Kad  pam؟ov model vyuv pamti
jinm zpsobem. Co teba znt,  abyste  mohli  pam؟ovch  model pouvat?
Abychom na tuto otzku odpovdli, musme se podvat na systm potae, na
kterm pracujete. Jeho  zkladn  jednotkou (CPU) je mikroprocesor z rodiny
Intel iAPx86; pravdpodobn 8088 nebo 80286, ale spe  8086,  80186, 80386
nebo 80486. Pro nae ely se na nj budeme odkazovat pouze jako na 8086.







                                  - 191 - 


Registry procesoru 8086
---------------------------------------------------------------------------

   Tyto  registry  se  nachzej  v  procesoru 8086. Existuje  jet  jeden
registr - IP (instruction  pointer  = ukazatel instrukc) - ale jazyk Turbo
C++ jej neme doshnout pmo a proto jej zde neuvdme.


        Registry pro obecn ely
   Ŀ
AX        AH                AL        akumultor (matematick operace)
   Ĵ
BX        BH                BL        bze (indexovn)
   Ĵ
CX        CH                CL        potn (indexovn)
   Ĵ
DX        DH                DL        data (obsahuje data)
   


        Registry adres segment
   Ŀ
CS                                     ukazatel kdovho segmentu
   Ĵ
DS                                     ukazatel datovho segmentu
   Ĵ
SS                                     ukazatel zsobnkovho segmentu
   Ĵ
ES                                     ukazatel extra segmentu
   


       Registry pro speciln ely
   Ŀ
CS                                     ukazatel zsobnku
   Ĵ
DS                                     ukazatel bze
   Ĵ
SS                                     index zdroje
   Ĵ
ES                                     index msta uren
   

                     Obr. 7.1: Registry procesoru 8086


Registry pro obecn ely

   Registr  pro  obecn  ely se pouv  nejastji  k  uchovn  dat  a
manipulaci s nimi. Kad z nich m speciln funkci, kterou  me vykonvat
pouze on sm. Napklad

    o  Nkter matematick operace lze vykonat pouze uitm registru AX.

    o  Registru BX lze pout jako registru indexovho.

    o  Registru CX pouvaj instrukce LOOP a nkter etzcov instrukce.

    o  K nkterm matematickm operacm se implicitn pouv registru DX.



                                  - 192 - 


   Existuje  vak  mnoho  operac,  kter  mohou vykonat vechny  z  tchto
registr. V mnoha ppadech je mon klidn zamnit jeden za druh.


Segmentov registry

   V tchto registrech  jsou  uloeny poten adresy vech ty segment.
Jak vysvtlme v dalm  oddlu,  pro zskn skuten 20- ti bitov adresy
danho segmentu se 16- ti bitov hodnota v segmentovm registru posune  o 4
bity doleva (vynsob se 16).


Registry pro speciln ely

   Procesor 8086 m tak nkolik registr pro speciln ely:

    o  Regitry SI a DI mohou vykonat  mnoh  z toho, co dlaj registry pro
       obecn ely.  Navc se jich pouv jako registr indexovch. Jazyk
       Turbo C++ jich tak vyuv pro registrov promnn.

    o  Registr  SP ukazuje na aktuln vrchol zsobnku  a  je  ofsetem  do
       zsobnkovho segmentu.

    o  Registr  BP  je  sekundrnm  ukazatelem  zsobnku.  Obvykle  se ho
       pouv  k  indexovn  do  zsobnku  pro  zskn  argument  nebo
       automatickch promnnch.

   Funkce  v  Turbo  C++ pouvaj registru ukazatele bze (BP) jako bzov
adresy argument a automatickch promnnch. Parametry  maj  kladn ofsety
od BP, kter se mn v zvislosti na pam؟ovm modelu.  BP  vdy ukazuje na
pedchoz uloenou hodnotu BP. Funkce bez argument nebudou BP pouvat ani
ukldat, je-li alternativa Standard Stack Frame vypnuta (Off).

   Automatickm promnnm se pidluj  zporn  ofsety  od BP. Tyto ofsety
zvis na tom, kolik prostoru ji bylo promnnm piazeno.


Registr pznak

   Tento 16- ti bitov registr obsahuje vechny podstatn informace o stavu
mikroprocesoru 8086 a o vsledcch momentlnch instrukc.

   Kdybyste napklad chtli  vdt,  jestli  vsledkem  odtn  je nula,
zkontrolujete ihned po  tto  instrukci  pznak  nuly  (bit  Z  v registru
pznak).  Kdy  bude  nastaven, budete vdt, e vsledek je nulov. Jin
pznaky,  jako  teba  penos  {carry}  a  peplnn  {overflow},  podobn
ohlauj vsledky aritmetickch a logickch operac.















                                  - 193 - 


                               Virtuln reim 8086
                                Obnova
                                   Vnoen loha
                                     rove ochrany V/V
                                       Peplnn
                                        Smr
                                         Peruen mon
                                          Zdr
                                           Znamnko
                                            Nula
                                               Pomocn penos
                                                  Parita
                                                     Penos
                                                     
31                              15         7          0
Ŀ
               VR NIOPODITSZ A P C

 \/\/\/
                                                   
             Pouze 80386            80286    Vechny procesory 80x86
                                    80386
              Obr. 7.2: Registr pznak mikroprocesoru 8086

   Ostatn pznaky ovldaj reim innosti  procesoru  8086.  Pznak smr
{direction}   ovld  smr  pemsovn  etzcovch  instrukc.   Pznak
peruen {interrupt} rozhoduje, zda  vnj  technick  prostedky, jakmi
jsou teba klvesnice nebo modem,  sm aktuln kd doasn pozastavit, aby
bylo mon obslouit  urgentn  poteby.  Pznaku  zdr  {trap} vyuvaj
jenom programy, ktermi se lad jin programy.

   Registr pznak se obvykle neupravuje ani nete pmo. Registr pznak
se  ovld  zejmna  prostednictvm  specilnch instrukc asembleru (jako
CLD,  STI a CMC) a prostednictvm  aritmetickch  a  logickch  instrukc,
jimi se upravuj urit pznaky. Analogicky se zase obsahem uritch bit
v  registru  pznak  ovlivuje  innost  instrukc jako JZ, RCR a  MOVSB.
Registru  pznak  se  vlastn  nepouv  jako  pam؟ovho  msta,  nbr
obsahuje pedevm daje o stavu a zen mikroprocesoru 8086.


Segmentace pamti
---------------------------------------------------------------------------

   Mikroprocesor  Intel  8086 m segmentovanou  architekturu  pamti.  Jeho
celkov adresovan prostor je 1Mb, je vak sestrojen tak, e  me souasn
pmo adresovat jenom  64K  pamti.  Takov  sek pamti o velikosti 64K se
nazv segment; odtud pochz frze "segmentovan architektura pamti".

    o  Procesor 8086 stle eviduje tyi  rzn  segmenty:  kdov, datov,
       zsobnkov  a  extra.  Kdov  segment  je  ten,  kde se  nachzej
       strojov  instrukce; v datovm segmentu jsou informace;  zsobnkov
       segment je samozejm zsobnkem  a  extra  segmentu se tak pouv
       pro extra data.

    o  Procesor 8086 m tyi 16-  ti bitov segmentov registry (pro kad
       segment  jeden)  nazvan CS, DS, SS a  ES;  ty  ukazuj  na  kdov,
       datov, zsobnkov a extra segment.





                                  - 194 - 


    o  Segment me bt umstn kdekoli v pamti -  pesnji  eeno, tm
       kdekoli.  Z  dvod,  kter se ozejm dle, mus segment zanat na
       adrese, kter je sudm nsobkem sla 16 (dekadicky).


Vpoet adresy

   pln adresa v  procesoru  8086  se  skld ze dvou 16- bitovch hodnot:
adresy segmentu a ofsetu. Dejme tomu, e adresa datovho segmentu - hodnota
v registru DS - je 2F84 (zklad 16)  a  chcete  vypotat  skutenou adresu
njakho  daje,  kter  m ofset 0532  (zklad  16)  od  zatku  datovho
segmentu. Jak se to udl?

   Vpoet  adresy  probh nsledovn: Hodnota  segmentovho  registru  se
posune  o 4 bity vlevo (je to ekvivalentn  posunu  o  jednu  hexadecimln
slici). Potom se pite ofset.

   Vsledn  20-  ti  bitov hodnota je pak skutenou adresou danho daje,
co si hned ukeme:
   Registr DS (posunut):  0010  1111  1000  0100  0000     =  2F840
   Ofset:               0000  0101  0011  0010     =  00532
        
   Adresa:           0010  1111  1101  0111  0010     =  2FD72

   sek  o 16 bytech se nazv paragraf, take se d ci, e segmenty vdy
zanaj na hranici njakho paragrafu.

   Poten adresa segmentu je  vdy  slem  o  20 bitech, ale segmentov
registr pojme jenom 16 bit - proto  se  spodn  4  bity  vdy  povauj za
nulov. To znamen - jak jsme ji  uvedli  -  e  segmenty  mohou  v pamti
zanat vdy po  kadch  16  bytech,  na  adrese, kter m posledn 4 bity
(neboli  posledn hexadecimln slici) nulov. Take obsahuje-li  registr
DS hodnotu 2F84, datov segment ve skutenosti zan na adrese 2F840.

   Standardn zpis  adresy  m  tvar  segment:ofset;  pedchoz  adresa se
napklad zape jako 2F84:0532. Uvdomte si, e ofsety mohou pesahovat do
jinho segmentu a proto  urit  dvojice  segment:ofset  nen jednoznanou.
Vechny nsledujc adresy se nap. tkaj stejnho msta pamti:
   0000:0123
   0002:0103
   0008:00A3
   0010:0023
   0012:0003

   Segmenty  se  mohou  (ale  nemus)  vzjemn  pesahovat.  Tak napklad
vechny tyi segmenty mohou zanat na stejn adrese, co znamen, e cel
program nezabere vce ne 64K - to je vak veker prostor,  kter obdrte
pro svj kd, sv data i zsobnk.


Ukazatele
---------------------------------------------------------------------------

   Akoli je mon  deklarovat,  aby ukazatel nebo funkce byly specifickho
typu  bez  ohledu  na pouvan model, typem zvolenho pam؟ovho modelu se
ur  implicitn  typ  ukazatel,  pouitch  pro kd i data. Ukazatele  se
vyskytuj ve tyech odstnech: blzk {near} (16 bit), vzdlen {far} (32
bit), rozshl {huge} (rovnا 32 bit) a segmentov {segment} (16 bit).




                                  - 195 - 


Blzk ukazatele

   16-  bitov  (blzk,  near)  ukazatel  se s dokonenm  vpotu  adresy
spolh na jeden ze segmentovch  registr.  Napklad  ukazatel  na funkci
pite  svou  16-  bitovou hodnotu k obsahu registru kdovho segmentu (CS)
posunutho  vlevo.  Podobn  i  blzk  datov  ukazatel  obsahuje ofset  k
registru datovho  segmentu (DS). S blzkmi registry se snadno manipuluje,
nebo vekerou aritmetiku (teba stn)  lze  vykonvat  bez  starost se
segmentem.


Vzdlen ukazatele

   Vzdlen  {far}  (32-  bitov)  ukazatel  obsahuje  nejen  ofset  uvnit
segmentu, ale tak (jako dal 16- bitovou hodnotu) adresu segmentu.  Ta se
potom posune vlevo a  pite  se k ofsetu. Pi pouit vzdlench ukazatel
lze mt vce kdovch segment. To zase naopak umouje mt  programy vt
ne 64K. Lze tak adresovat vce ne 64K dat.

   Pi pouit  vzdlench  ukazatel  na  njak  data  je teba mt se na
pozoru  ped  monmi  problmy  pi  manipulacch s ukazatelem.  Jak  jsme
vysvtlili v oddlu o vpotu adresy, me existovat  mnoho  rznch dvojic
segment:ofset, kter odkazuj na tut adresu. Napklad vzdlen ukazatele
0000:0120, 0010:0020 a 0012:0000 vechny vyst v tut 20- bitovou adresu.
Kdybyste  vak mli ti rzn promnn typu vzdlen ukazatel - a, b a c  -
obsahujc  uveden ti hodnoty, pak by  byly  vechny  nsledujc  vrazy
nepravdiv (false):
   if (a == b)...
   if (b == c)...
   if (a == c)...

   Obdobn problm nastane, kdy chcete porovnat vzdlen  ukazatele uitm
opertor >, >=, < a <=. V takovm ppad se  pouije  pro ely porovnn
jenom  ofset  (jako unsigned). Vyjdeme-li z toho, e a, b a  c  stle  maj
pedchoz hodnoty, budou nsledujc vrazy vechny pravdiv (true):
   if (a > b)...
   if (b > c)...
   if (a > c)...

   Opertor rovnost (==) i opertor  nerovnost  (!=)  pouvaj  tchto 32-
bitovch hodnot  jako unsigned long (nikoli jako plnch pam؟ovch adres).
Porovnvac opertory (<=, >=, < a >) pouvaj jenom ofset.

   Opertory  ==  a  !=  potebuj  vech  32  bit  a  proto pota  me
porovnvat  s  przdnm  (NULL)  ukazatelem,  kter  m  hodnotu 0000:0000.
Kdybyste  pro  kontrolu  rovnosti vyuvali jenom ofset, rovnal by se kad
ukazatel s ofsetem 0000 ukazateli przdnmu (NULL).

Dleit!
   Pitete-li ke vzdlenmu  ukazateli  njakou  hodnotu,  zmn  se jenom
ofset. Pitete-li tak velkou hodnotu,  e zpsob pesaen hodnoty FFFF v
ofsetu (co je nejvy  mon  hodnota),  ukazatel  se pemst zase jenom
dokola  na  zatek  segmentu. Pitete-li napklad 1  k  5031:FFFF,  bude
vsledkem  5031:0000  (nikoli  6031:0000).  Stejn  tak  odetete-li  1  od
5031:0000, zskte 5031:FFFF (a nikoli 5030:000F).

   Pokud   chcete  porovnvat  ukazatele,  je  nejbezpenj  pout   bu
ukazatel blzkch -  kter  vechny pouvaj stejnou segmentovou adresu -
nebo ukazatel rozshlch {huge}, kter popeme nyn.



                                  - 196 - 


Rozshl ukazatele

   Rozshl  {huge}  ukazatele  jsou  rovnا  dlouh 32 bit.  Stejn  jako
ukazatele vzdlen, obsahuj tak  adresu  segmentu  i  ofset. Na rozdl od
vzdlench ukazatel jsou vak normalizovny,  aby  se  pedelo problmm,
tkajcm se vzdlench ukazatel.

   Co je to normalizovan ukazatel? Je  to  32- bitov ukazatel, kter m v
adrese segmentu co nejvy  monou  hodnotu.  Jeliko segment me zanat
vdy po 16  bytech  (10  v  hexadecimlnm vyjden), znamen to, e ofset
bude mt jenom hodnoty od 0 do 15 (0 a F hexadecimln).
   Ukazatel se normalizuje tak, e se pevede na svou 20-ti bitovou adresu,
potom se pravch 4 bit pouije  pro  konkrtn  ofset a 16 levch bit pro
konkrtn adresu segmentu. Mme-li napklad ukazatel 2F84:0532, pevede se
na absolutn adresu 2FD72, kter se potom normalizuje na 2FD7:0002. Uvdme
nkolik dalch ukazatel i s jejich normalizovanmi ekvivalenty:
   0000:0123      0012:0003
   0040:0056      0045:0006
   500D:9407      594D:0007
   7418:D03F      811B:000F

   K tomu, aby rozshl  ukazatele  byly  stle normalizovan, existuj ti
dleit dvody:

   1.  K  jakkoli  pam؟ov  adrese  bude  existovat  pouze  jedin  mon
       rozshl {huge} adresa - dvojice segment:ofset. Z toho plyne, e pro
       jakkoli rozshl ukazatele  poskytnou  opertory  ==  a  != sprvn
       vsledek.

   2.  Navc  se  vech opertor >, >=, <  a  <=  pro  rozshl  ukazatele
       pouv na cel 32- bitov  hodnoty.  Normalizace  pak  zaruuje, e
       vsledky budou tak sprvn.

   3.  A konen v dsledku normalizace se ofset v  rozshlm  ukazateli po
       kadch  16  hodnotch  automaticky  peto,  ale  -  na rozdl  od
       vzdlench ukazatel  -  se  dolad  i  segment.  Kdybyste napklad
       inkrementovali 811B:000F,  byl  by  vsledek  811C:0000. Analogicky,
       kdybyste dekrementovali 811C:0000, zskte 811B:000F. Prv pro tuto
       vlastnost   rozshlch  ukazatel   lze   manipulovat   s   datovmi
       strukturami  o velikostech vtch ne 64K.  Tm  ja  zajitno,  e
       mte-li napklad njak rozshl  pole  struktur  struct,  kter je
       vt  ne 64K, bude indexovn do takovho  pole  i  vbr  poloek
       struct vdy fungovat, a jsou struktury jakkoli velk.

   Za pouit rozshlch ukazatel se na druh stran vak plat zpomalenm
innosti programu. Aritmetika se u  rozshlch  ukazatel  vykonv volnm
specilnch procedur. Proto je aritmetika u  rozshlch  ukazatel znateln
pomalej ne u ukazatel vzdlench i blzkch.


est pam؟ovch model
---------------------------------------------------------------------------

   Jazyk Turbo C++ nm nabz est pam؟ovch model:  drobn  {tiny}, mal
{small}, stedn {medium}, kompaktn {compakt},  velk  {large}  a rozshl
{huge}. Kter  si vyberete zvis na poadavcch programu. Pinme jejich
strun pehled:





                                  - 197 - 


Drobn            Jak se d  oekvat,  jde o nejmen z pam؟ovch model.
                  Vechny tyi segmentov registry (CS, DS,  SS,  ES) jsou
                  nastaveny  na tut adresu, take na  cel  kd,  data  a
                  zsobnk  pipad 64K pamti. Programy s drobnm  modelem
                  lze  pevdt  na  formt   .COM   jejich   spojovnm  s
                  alternativou /t.

                  Tohoto  modelu  pouijte, pokud jde  pedevm  o  sporu
                  pamti.

Mal              Kdov  a  datov  segment   se   li   a   vzjemn  se
                  nepesahuj.  Proto  je  k dispozici 64K kdu a 64K dat a
                  zsobnku. Vdy se pouv blzkch ukazatel.

                  Toto je vhodn velikost pro prmrn aplikace.

Stedn           Pro kd se pouv vzdlench ukazatel, nikoli  vak pro
                  data. Vsledkem je, e data plus zsobnk jsou omezena na
                  64K, zatmco kd me zabrat a 1Mb.

                  Nejvhodnj pro velk programy,  kter  v  pamti nedr
                  velk mnostv dat.

Kompaktn         Opak stednho: Pro data se pouv vzdlench ukazatel,
                  nikoli vak pro kd. Proto  je kd omezen na 64K, zatmco
                  data maj rozsah 1Mb.

                  Nejvhodnj pro ppad, kdy je kd mal, ale je zapoteb
                  adresovat velk mnostv dat.

Velk             Pro kd i  data  se  pouv  vzdlench  ukazatel, m
                  jejich rozsahy jsou 1Mb.

                  Velkch a rozshlch model je  zapoteb  jen  pro velmi
                  rozshl aplikace.

Rozshl          Pro kd i data se pouv vzdlench ukazatel. Turbo C++
                  normln omezuje velikost vech  statickch  dat  na 64K;
                  rozshl  pam؟ov  model   stoj  mimo  toto  omezen  a
                  dovoluje, aby data zabrala vce ne 64K.

   Pam؟ov model se zvol tak, e bu pouijete  v  integrovanm prosted
vbru  z  menu,  nebo mete zadat potebn alternativy pi vyvoln verze
kompiltoru Turbo C++ s pkazovm dkem.

   Jak se v procesoru 8086 rozdluje pam؟ pro est pam؟ovch model Turbo
C++ ukazuj obrzky 7.3 a 7.8.















                                  - 198 - 


 Segmentov registry:         ni adresa       Velikost segmentu:
 CS, DS, SS    >Ŀ
                         _TEXT tda 'CODE'     
                               kd              
                      Ĵ
                         _DATA tda 'DATA'     
                         inicializovan data    
                      Ĵ
        DGROUP           _BSS tda 'BSS'           do 64K
                         inicializovan data    
                      Ĵ
                               HEAP             
                      ñ
                            voln prostor       
  SP (TOS)     >ñ
                             ZSOBNK           
  zatek SP   >
                              vy adresa


         Obr. 7.3: Segmentace pamti podle drobnho modelu (Tiny)


 Segmentov registry:         ni adresa       Velikost segmentu:
         CS    >Ŀ
                         _TEXT tda 'CODE'     
                               kd               *
         DS, SS >Ĵ
                         _DATA tda 'DATA'     
                    *    inicializovan data     *
                      Ĵ
      * DGROUP           _BSS tda 'BSS'           do 64K *
                    *    inicializovan data     *
                      Ĵ
                               HEAP             
                      ñ
                            voln prostor       
  SP (TOS)     >ñ
                    *        ZSOBNK            *
  zatek SP   >Ĵ
                              FAR HEAP          
                      ñ   do ve instal.pamti
                             voln prostor      
                      
                              vy adresa

          Obr. 7.4: Segmentace pamti podle malho modelu (Small)















                                  - 199 - 


            Vcensobn sfiles:
           Ŀ
            sfile A          
           Ĵ
            ...              
           Ĵ
     CS > sfile Z          
           
                           
 Segmentov registry:        ni adresa       Velikost segmentu:
                      Ŀ
                        sfile_TEXT tda 'CODE' 
                               kd                kad sfile do 64K
         DS, SS >Ĵ
                         _DATA tda 'DATA'     
                    *    inicializovan data     *
                      Ĵ
      * DGROUP           _BSS tda 'BSS'           do 64K *
                    *    inicializovan data     *
                      Ĵ
                               HEAP             
                      ñ
                            voln prostor       
  SP (TOS)     >ñ
                    *        ZSOBNK            *
  zatek SP   >Ĵ
                              FAR HEAP          
                      ñ   do ve instal.pamti
                             voln prostor      
                      
                              vy adresa

        Obr. 7.5: Segmentace pamti podle stednho modelu (Medium)

   CS ukazuje vdy jenom na jedin soubor sfile.

 Segmentov registry:         ni adresa       Velikost segmentu:
         CS    >Ŀ
                         _TEXT tda 'CODE'     
                               kd               *
         DS    >Ĵ
                         _DATA tda 'DATA'     
                    *    inicializovan data     *
                      Ĵ
      * DGROUP           _BSS tda 'BSS'           do 64K *
                    *    inicializovan data     *
         SS    >Ĵ
                               HEAP             
                      ñ
                            voln prostor       
  SP (TOS)     >ñ
                             ZSOBNK            *
  zatek SP   >Ĵ
                              FAR HEAP          
                      ñ   do ve instal.pamti
                             voln prostor      
                      
                              vy adresa

      Obr. 7.6: Segmentace pamti podle kompaktnho modelu (Compact)


                                  - 200 - 


            Vcensobn sfiles:
           Ŀ
            sfile A          
           Ĵ
            ...              
           Ĵ
     CS > sfile Z          
           
                           
 Segmentov registry:        ni adresa       Velikost segmentu:
                      Ŀ
                        sfile_TEXT tda 'CODE' 
                               kd                kad sfile do 64K
         DS     >Ĵ
                         _DATA tda 'DATA'     
                    *    inicializovan data     *
                      Ĵ
      * DGROUP           _BSS tda 'BSS'           do 64K *
                    *    inicializovan data     *
         SS     >Ĵ
                               HEAP             
                      ñ
                            voln prostor       
  SP (TOS)     >ñ
                             ZSOBNK            *
  zatek SP   >Ĵ
                              FAR HEAP          
                      ñ   do ve instal.pamti
                             voln prostor      
                      
                              vy adresa

         Obr. 7.7: Segmentace pamti podle velkho modelu (Large)

   CS ukazuje vdy jenom na jedin soubor sfile.



























                                  - 201 - 


            Vcensobn sfiles:
           Ŀ
            sfile A          
           Ĵ
            ...              
           Ĵ
     CS > sfile Z          
           
                           
 Segmentov registry:        ni adresa       Velikost segmentu:
                      Ŀ
    Ŀ    sfile_TEXT tda 'CODE' 
     sfile A                 kd                 kad sfile do 64K
    Ĵ  Ĵ
DS-> sfile B      >sfile_DATA tda 'DATA' 
    Ĵ     inicializovan data       kad sfile do 64K
     ...            Ĵ
               HEAP             
          SS   >ñ
                            voln prostor       
  SP (TOS)     >ñ
                             ZSOBNK              do 64K
  zatek SP   >Ĵ
                              FAR HEAP          
                      ñ   do ve instal.pamti
                             voln prostor      
                      
                              vy adresa

        Obr. 7.8: Segmentace pamti podle rozshlho modelu (Huge)

   CS ukazuje vdy jenom na jedin soubor sfile.

   V  Tabulce  7.1  naleznete  souhrn  rznch  model  a  jejich  vzjemn
srovnn. Modely se asto seskupuj podle toho, zda jsou jejich modely kdu
nebo  dat mal (64K) nebo velk (1Mb). Tyto  skupiny  odpovdaj  dkm  a
sloupcm tabulky 7.1.

























                                  - 202 - 


                         Tab. 7.1: Pam؟ov modely

---------------------------------------------------------------------------
                                        Velikost kdu
     Velikost dat        
                              64K                              1 Mb
---------------------------------------------------------------------------

                         Drobn (data a kd
                         se pesahuj;
                         celk. vel.= 64K)
        64K

                         Mal (bez pesah;       Stedn (mal data,
                         celk. vel. = 128K        velk kd)
---------------------------------------------------------------------------

                         Kompaktn (velk data,   Velk (velk data i kd)
                         mal kd)

        1 Mb

                                                  Rozshl (jako velk,
                                                  ale statick data > 64K)
---------------------------------------------------------------------------

   Modely drobn, mal a kompaktn se nazvaj modely s malm  kdem proto,
e kdov ukazatele jsou implicitn blzk. Stejn tak  kompaktn,  velk a
rozshl  modely  se  nazvaj  modely  s  velkmi  daty proto,  e  datov
ukazatele jsou implicitn vzdlen.

Dleit!
   Kdy kompilujete njak modul (urit zdrojov soubor, kter  m  v sob
urit poet rutin), neme  bt  vsledn kd tohoto modulu vt ne 64K,
nebo se toto ve mus vejt do jednoho kdovho segmentu. To plat dokonce
i tehdy, pouvte-li nkter z model s vtm kdem (stedn,  velk nebo
rozshl). Mte-li svj  modul  pli  velk,  ne aby se veel do jednoho
(64K) kdovho segmentu,  muste  jej rozlenit do nkolika rznch soubor
zdrojovho textu, zkompilovat kad soubor  samostatn  a  potom  je spojit
dohromady. Podobn, i kdy  rozshl  model  dovoluje statick data celkov
vt ne 64K, mus bt tato v kadm modulu vdy men ne 64K.



---------------------------------------------------------------------------
Programovn se smenmi modely: Modifiktory adresovn
---------------------------------------------------------------------------


   Jazyk  Turbo C++ zavd osm novch klovch  slov,  kter  nenajdete  v
norm ANSI C  (near, far, huge, _cs, _ds, _es, _ss a _seg). Lze jich pout
jako  modifiktor  pro  ukazatele  (a  v jistch ppadech i pro  funkce),
piem plat urit omezen a upozornn.

   V jazyku Turbo C++  je  mon  deklarace  funkc a ukazatel modifikovat
klovmi slovy near, far  nebo  huge. Datov ukazatele near, far nebo huge
jsme vysvtlili v  tto  kapitole  ji  dve.  Funkce  near  se vyvolvaj
blzkm volnm a vystupuje se z nich blzkm nvratem.  Podobn  i  funkce
far se  volaj  vzdlen  a  maj  vzdlen  nvraty. Funkce huge jsou jako



                                  - 203 - 


funkce far a na to, e  funkce  huge  nastav DS na novou hodnotu, zatmco
funkce far nikoli.

   Existuj tak tyi speciln  datov  ukazatele  near:  _cs, _ds, _es a
_ss. Jde o 16-ti bitov ukazatele, kter se  tkaj  zvlt odpovdajcho
segmentovho  registru. Kdybyste napklad chtli deklarovat ukazatel,  aby
byl
            *
   char _ss  p;

   pak p by obsahoval 16-ti bitov ofset do zsobnkovho segmentu.

   Funkce a ukazatele v danm programu jsou implicitn blzk nebo vzdlen
v  zvislosti  na  zvolenm pam؟ovm modelu. Je-li  funkce  nebo  ukazatel
blzk, pidl se automaticky k registru CS nebo DS.

   Nsledujc tabulka ukazuje,  jak  to konkrtn probh. Uvdomte si, e
velikost ukazatele odpovd tomu, zda funguje v rmci omezen na 64K pamti
(blzk,  uvnit  segmentu)  nebo  uvnit  hlavnho  prostoru  pamti 1  Mb
(vzdlen, m adresu svho vlastnho segmentu).


                       Tab. 7.2: Vsledky ukazatel

---------------------------------------------------------------------------
     Pam؟ov model           Funkn ukazatele        Datov ukazatele
---------------------------------------------------------------------------

      Drobn                    blzk, _cs              blzk, _ds
      Mal                      blzk, _cs              blzk, _ds
      Stedn                   vzdlen                 blzk, _ds
      Kompaktn                 blzk, _cs              vzdlen
      Velk                     vzdlen, _cs            vzdlen
      Rozshl                  vzdlen, _cs            vzdlen
---------------------------------------------------------------------------


Segmentov ukazatele
---------------------------------------------------------------------------

   V deklartorech typu segmentovho ukazatele  se  pouv  _seg. Vsledn
ukazatele jsou 16-ti bitov segmentov ukazatele. Syntax pro _seg je:
                   *
   datov typ _seg  identifiktor;

   Napklad
            *
   int _seg  nazev;

   Kad nepm adresovn prostednictvm identifiktoru m pedpokldan
ofset 0. V aritmetice pro segmentov ukazatele plat nsledujc pravidla:

   1.  Pro segmentov ukazatele nelze  pouvat  opertor  ++, --, += nebo
       -=.

   2.  Nelze odest jeden segmentov ukazatel od druhho.

   3.  Pitenm  blzkho  ukazatele  k  segmentovmu   ukazateli  vznikne
       ukazatel vzdlen. Ten se zformuje pouitm segmentu ze segmentovho
       ukazatele  a  ofsetu  z  ukazatele  blzkho.  Proto  mus tyto  dva


                                  - 204 - 


       ukazatele bu ukazovat na stejn typ, nebo jeden mus bt ukazatelem
       na void. Bez ohledu na typ, na kter se  ukazuje,  neexistuje  dn
       nsoben ofsetu.

   4.  Kdy pouijete segmentovho ukazatele v  njakm  vrazu  s nepmm
       adresovnm, tak se implicitn pevede na vzdlen ukazatel.

   5.  Pitenm  nebo  odetenm  celoselnho  operandu  k  segmentovmu
       ukazateli   vznikne   ukazatel   vzdlen.   Segment   pevezme   ze
       segmentovho   ukazatele  a  ofset  nalezne  vynsobenm   velikosti
       objektu, na nj  se  ukazuje,  danm  celoselnm  operandem. Tato
       aritmetika se vykonv tak, jako  kdyby  se  pietlo  nebo odeetlo
       cel slo ke vzdlenmu ukazateli.

   6.  Do segmentovch  ukazatel  lze  dosazovat,  lze  je  inicializovat,
       pedvat  je  a  pebrat  z  funkc,  porovnvat  atd.  (Segmentov
       ukazatele se  porovnvaj, jako kdyby jejich hodnoty byla cel sla
       unsigned.) eeno  jinmi slovy, na rozdl od ve uvedench omezen
       se s nimi zachz pesn jako se vemi ostatnmi ukazateli.


Deklarovn vzdlench objekt
---------------------------------------------------------------------------

   V Turbo C++ lze deklarovat vzdlen objekty. Napklad

   int far x = 5;
   int far z;
   extern int far y = 4;
   static long j;

   Pro  kad vzdlen objekt vytvo Turbo  C++  oddlen  segment.  Nzev
segmentu, jeho tda a skupina  se  ovlivuje  alternativami  kompiltoru s
pkazovm dkem -zE, -zF a -zH (kter lze tak  nastavit  uitm  #pragma
option). Mnte-li je pomoc  #pragma  option,  mete  je zmnit kdykoli a
vztahuj  se  na  vechny nsledn deklarace vzdlench  objekt.  Proto  k
vytvoen vzdlenho objektu v uritm segmentu  mete  pout nsledujc
posloupnosti:

   #pragma option -zEmujsegment -zHmojeskupina -zFmojetrida
   int far x;
                     *    *    *
   #pragma option -zE  -zH  -zF

   Tm  se  x  vlo   do   segmentu   MUJSEGMENT  'MOJETRIDA'  ve  skupin
'MOJESKUPINA'  a  pak  se  vechny  prvky  vzdlench  objekt  nastav  na
implicitn  hodnoty.  Pamatujte,  e  pouitm  tchto  alternativ  lze  do
jedinho segmentu soustedit nkolik vzdlench objekt:

   #pragma option -zEkombinace -zFmojetrida
   int far x;
   double far y;
                     *    *
   #pragma option -zE  -zF

   Jak x, tak i y se objev v segmentu KOMBINACE 'MOJETRIDA' bez skupiny.






                                  - 205 - 


Deklarovn funkc jako blzkch nebo vzdlench
---------------------------------------------------------------------------

   Pleitostn  mete  (nebo potebujete) implicitn  typ  funkce  svho
pam؟ovho modelu, uvedenho v Tabulce 7.1 (strnka 202), pedefinovat.

   Pedpokldejme napklad, e pouvte velk pam؟ov model, ale mte ve
svm programu njakou rekurzivn (sebe volajc) funkci, jako teba:

   double mocnina(double x, int exp)
   {
      if (exp <= 0)
         return(1);
      else
                  *
         return(x   mocnina(x, exp-1));
   }

   Kdykoli  mocnina  vol  sama sebe, mus uinit  vzdlen  voln,  kter
potebuje vce prostoru  v  zsobnku a vce hodinovch cykl. Deklarovnm
funkce mocnina jako  near  se  nkter  z tchto komplikac omez, nebo se
nad, e vechna voln tto funkce budou blzk:

   double near mocnina(double x, int exp)

   Tm se zaru, e funkci mocnina lze volat jenom  uvnit  toho  kdovho
segmentu, ve kterm se kompilovala a e vachna voln  tto  funkce  budou
blzk.

   Znamen to, e pokud  pouvte  modelu  s  velkm kdem (stedn, velk
nebo rozshl), mete funkci mocnina volat jenom uvnit  toho  modulu, kde
je  definovna. Ostatn moduly maj sv vlastn  kdov  segmenty  a  tud
nemohou volat funkce near z jinch modul. Dle plat, e blzk  funkce se
mus bu definovat nebo deklarovat jet pedtm, ne se j poprv pouije.
Jinak by kompiltor nevdl, e m generovat blzk voln.

   Naopak deklarovn njak  funkce  jako vzdlen znamen, e se generuje
vzdlen  nvrat.  V  modelech  s  malm  kdem  se  mus  vzdlen  funkce
deklarovat nebo definovat ped svm prvnm pouitm. Tm se zajist,  e se
vyvolaj se vzdlenm volnm.

   Podvejme  se  zpt  na  ukzku  mocnina. Je rozumn  deklarovat  funkci
mocnina tak jako statickou, nebo se bude volat  jenom  zevnit aktulnho
modulu. Bude-li statickou, nebude jej  nzev  k  dispozici  dnm funkcm
mimo tento modul.


Deklarovn ukazatel jako blzkch, vzdlench nebo rozshlch
---------------------------------------------------------------------------

   ekli jsme si, pro je vhodn deklarovat funkce tak,  aby  byly  jinho
modelu  ne  zbytek  programu.  Pro  dlat tot s ukazateli? Ze  stejnch
dvod, kter jsme  uvedli  v  pedchozm  oddlu:  bu  proto,  abychom se
vyhnuli zbytenmu zpomalen (deklarovnm  near  kdy  implicitn  by bylo
far),  nebo  pro   monost   odkazovn   se   vn   implicitnho  segmentu
(deklarovnm far nebo huge kdy implicitn by bylo near).

   Je samozejm, e  deklarovnm  funkc a ukazatel na neimplicitn typy
vznikaj i potenciln nstrahy.  eknme  napklad,  e  mte nsledujc
program s malm modelem:


                                  - 206 - 


   void mujputs(s)
        *
   char  ;
   {
      int i;
      for (i=0; s[i] != 0; i++) putc(s[i]);
   }

   main()
   {
                *
      char near  mujret;

      mujret = "Nazdar\n";

      mujputs(mujret);
   }

   Tento  program  funguje  hezky a deklarace  near  u  mujret  je  vlastn
nadbyten, nebo vechny ukazatele, jak kdov tak i datov, budou blzk.

   Co  kdy ale tento program zkompilujete  znovu  s  pouitm  kompaktnho
(nebo velkho i rozshlho) pam؟ovho modelu? Ukazatel mujret v main bude
stle blzk (bude  stle  16-ti  bitovm  ukazatelem).  Ale  ukazatel  s v
mujputs bude nyn vzdlenm, nebo  jde o implicitn nastaven. Znamen to,
e mujputs ve snaze o vytvoen vzdlenho ukazatele  vythne  ze zsobnku
dv slova a adresa, ke kter se dopracuje, zajist nebude adresou mujret.

   Jak se tomuto problmu vyhnout?  eenm je definovat mujputs v modernm
stylu jazyka C takhle:
                     *
   void mujputs(char  s)
   {
      /* tlo funkce mujputs */
   }

   Zamlte-li  deklarovat  ukazatele   explicitn  jako  far  nebo  near,
nezapomete  pout  pro  vechny  funkce,  kter  by  jich  mohly  vyut,
prototyp funkc.

   Kdy nyn Turbo C++ takov  program zkompiluje, zjist e funkce mujputs
oekv ukazatel na char a jeliko kompilujete pod  velkm  modelem, zjist
e  tento ukazatel mus bt far. Proto Turbo  C++  vlo  registr  datovho
segmentu  (DS)  do  zsobnku  spolen  s 16-ti bitovou hodnotou mujret  a
zformuje vzdlen ukazatel.

   Co by se stalo v opanm ppad: Argumenty pro mujputs deklarovan jako
far a kompilace s malm datovm modelem? Bez prototypu  funkce  byste  opt
mli pote, nebo main vlo do zsobnku jak ofsetovou, tak i segmentovou
adresu,  zatmco  mujputs  bude  oekvat  jenom  ofset.  Pi definovn  s
prototypem funkce vlo vak main do zsobnku jenom ofset.


Ukazovn na danou adresu segment:ofset

   Jak  pimt  vzdlen  ukazatel,  aby  ukazoval na dan  pam؟ov  msto
(konkrtn adresu segment:ofset)? Mete  pout  zabudovan  rutiny MK_FP,
kter pevezme segment a ofset a poskytne vzdlen ukazatel. Napklad

   MK_FP(segment_hodnota, ofset_hodnota)


                                  - 207 - 


   Pro dan ukazatel fp, kter je far, lze zskat segmentovou sloku pomoc
FP_SEG(fp) a ofsetovou  sloku  pomoc FP_OFF(fp). Dal informace o tchto
tech knihovnch rutinch Turbo C++ naleznete ve spaen npovd.


Pouvn knihovnch soubor
---------------------------------------------------------------------------

   Jazyk  Turbo  C++  nabz pro kad ze esti pam؟ovch model patinou
verzi standardnch knihovnch rutin. Turbo C++ je  dostaten inteligentn,
aby pipojil patin knihovny ve  sprvnm poad v zvislosti na vybranm
modelu. Pouvte-li  vak spojovacho programu Turbo C++ TLINK pmo (jako
samostatnho spojovacho programu), muste urit,  kter  knihovny  se maj
pout.  Podrobnosti  o  tom, jak se to m dlat, si  pette  v  Pruce
uivatele v Kapitole 13.


Spojovn smench modul
---------------------------------------------------------------------------

   Co  by se stalo, kdybyste zkompilovali jeden  modul  s  malm  pam؟ovm
modelem  a  jin  modul  s  pouitm  velkho  modelu  a  chtli je  spojit
dohromady?

   Soubory by se spojily hezky, ale problmy, kter by ped  vmi vyvstaly,
by byly podobn tm,  kter  jsme  popsali  v dvjm oddlu "Deklarovn
funkc jako blzkch a  vzdlench".  Kdyby  funkce  z malho modulu volala
njakou  funkci v modulu velkm, uinila by tak  blzkm  volnm,  co  by
pravdpodobn  vedlo  ke  katastrof.  Dle  byste se mohli  ocitnout  ped
problmy s ukazateli, popsanmi v dvjm  oddlu  "Deklarovn ukazatel
jako blzkch, vzdlench nebo rozshlch",  nebo funkce v malm modulu by
oekvala pedvn a pijmn ukazatel  near,  zatmco  funkce  v modulu
velkm by oekvala ukazatele far.

   eenm je znovu pouit prototyp  funkc.  Pedpokldejme,  e vlote
mujputs  do  jejho  vlastnho modulu a zkompilujete jej s velkm pam؟ovm
modelem. Pak vytvote soubor zhlav s nzvem mujputs.h (nebo njakm jinm
nzvem s pponou .h), kter by ml v sob nsledujc prototyp funkce:
                             *
   void far mujputs(char far  s);

   kdy  nyn  vlote  funkci  main  do jejho vlastnho modulu (s  nzvem
MUJMAIN.C) sestavte ve nsledovn:

   #include <stdio.h>
   #include "mujputs.h"

   main()
   {
                *
      char near  mujret;
      mujret = "Nazdar"\n";
      mujputs(mujret);
   }

   Kdy budete takov program kompilovat, Turbo C++ nate prototyp funkce z
MUJPUTS.H a zjist, e jde o funkci far, kter oekv ukazatel  far. Proto
se bude  generovat  sprvn  kd  voln,  dokonce  i pi kompilaci s malm
pam؟ovm modelem.



                                  - 208 - 


   Co  kdy  jet  ke vemu navc potebujete  pipojit  knihovn  rutiny?
Nejlp udlte, kdy pouijete  nkterou  z knihoven s velkmi modely a ve
deklarujete  jako  far.  Abyste tak uinili, poite si kopie vech soubor
zhlav,  kter  byste  normln vkldali (jako teba stdio.h) a tyto kopie
vhodn pejmenujte (teba na fstdio.h).

   Potom vechny prototypy funkc v  kopii  editujte,  aby  byly explicitn
far, teba takto:
                                 *
   int far cdecl printf(char far   format, ...);

   Tmto zpsobem se doshne, e nejen voln rutin  budou  far,  ale  e i
pedvan ukazatele budou  far.  Upravte  svj  program  tak,  aby  do sebe
vkldal tento nov soubor:

   #include <fstdio.h>

   main()
   {
                *
      char near  mujret;
      mujret = "Nazdar"\n";
      printf(mujret);
   }

   Zkompilujte svj program kompiltorem TCC,  potom  jej  spojte programem
TLINK s urenm njak knihovny s velkm modelem,  teba  CL.LIB. Smovn
model vyaduje uritch trik, ale  je  uskuteniteln.  Potejte  vak s
obtnmi chybami v ppad, neudlte-li ve sprvn.



---------------------------------------------------------------------------
Pekryvy (VROOMM)
---------------------------------------------------------------------------


   Pamatujte, e nelze smovat aplikace VROOMM a obsluhy soubor v sti.

   Pekryvy jsou sti  programovho  kdu,  kter  sdlej  stejnou oblast
pamti. V uritou  chvli  se  v  pamti vyskytuj jenom ty sti programu,
kter se vyaduj pro danou funkci.

   Uitm pekryv lze vznan snit  celkov  poadavky  na  pam؟ bhem
innosti  programu.  S  pekryvy lze vykonvat programy mnohem vt ne je
celkov pam؟, nebo v pamti se vdy souasn vyskytuj jenom urit sti
programu.


Jak pracuj pekryvy
---------------------------------------------------------------------------

   Sprvce  pekryv v jazyku Turbo C++ (s  nzvem  VROOMM  neboli  Virtual
Runtime  Object-Oriented Memory Manager = 'Virtuln objektov  orientovan
sprvce  pekryv innho programu') je velmi  dmysln  a  vykon  vtinu
prce za  vs.  V  bاnm  systmu  pekryv  se moduly seskup dohromady a
vytvo bzi a mnoinu pekryvovch unit. Rutiny v danm pekryvovm unitu
mohou volat jin rutiny v tme unitu i rutiny v bzi, nikoli vak rutiny z
unit jinch. Pekryvov unity se navzjem pekrvaj; tj. v pamti sm bt
vdy jen jedin pekryvov unit  a vechny zabraj stejnou fyzickou pam؟.


                                  - 209 - 


Celkov mnostv pamti, kter  program  potebuje,  je dno velikost bze
plus velikost nejvtho pekryvu.

   Takov konvenn schma je zcela neprun. Vyaduje plnou znalost vech
monch zvislost tkajcch se voln v programu a d  od  vs,  abyste
mli  pekryvy  patin   seskupeny.  Nedokete-li  program  rozloit  na
oddliteln sousti z hlediska voln,  me se stt rozdlen programu do
pekryv zcela nemonm.

   Schma, pouvan ve VROOMM, je zcela odlin. Poskytuje toti dynamick
vmny segment. Zkladn jednotkou pro  vmny  je  segment.  Segment me
pozstvat z jednoho i vce modul. Co je vak dleitj,  kad segment
me volat libovoln jin segment.

   Pam؟ se rozdl  na  oblast  pro  bzi  plus oblast pro vmny. Kdy se
zavol njak funkce v segmentu, kter nen ani v bzi,  ani  v oblasti pro
vmny, pivede se segment  obsahujc  tuto funkci do oblasti pro vmny a
ppadn  se  z  n  odstran  segmenty  jin.  Jde  o velmi inn pstup
pipomnajc programovou virtuln pam؟.  Nen  ji  zapoteb rozdlovat
kd do statickch,  vzjemn  disjunktnch  pekryvovch  unit.  Sta ve
pouze spustit!

   Co se stane, kdy je teba penst njak segment do oblasti pro vmny?
Je-li pro  takov segment dostatek msta, innost klidn pokrauje. Nen-li
msto, je poteba jeden i vce segment z oblasti  pro  vmny  odstranit,
aby se  prostor vytvoil. Jak rozhodnout, kter segment odstranit? Skuten
algoritmus  je  velmi  dmysln,  proto  uvedeme  jen  zjednoduen vklad:
Existuje-li njak neaktivnm segment,  zvol  se  k  odstrann. Neaktivn
segmenty jsou ty,  kter  nemaj  dn  funkce inn. V opanm ppad se
vezme  njak  aktivn  segment  a  odhod  se.  V odhazovn  segment  se
pokrauje, dokud nen k  dispozici  dostatek  msta.  Tto innosti se k
dynamick vmna.

   m  vce  pamti  se  pro   oblast  vmny  poskytne,  tm  je  program
vkonnj. Tato oblast pro vmny  psob  jako  rychl  vyrovnvac pam؟
{cache}; m je rychl vyrovnvac  pam؟ vt, tm rychleji program bا.
Nejlpe  je  nastavit  velikost  oblasti  pro vmny na  velikost  pracovn
mnoiny danho programu.

   Jakmile se njak pekryv  zavede  do  pamti,  umst se do vyrovnvac
pamti pekryv. Ta je umstna  mezi  zsobnkovm  segmentem  a vzdlenm
heapem.  Implicitn  se  velikost  vyrovnvac  pamti  pekryv  odhadne a
nastav  pi  zahjen  innosti,  ale  je mon ji zmnit uitm  globln
promnn _ovrbuffer (viz strnku 212). Nen-li k dispozici dostatek pamti,
zobraz se chybov hlen operanho systmu DOS ("Program too big  to fit
in memory" = 'Program je  pli  velk  a  nevejde  se  do  pamti'), nebo
zahajovacho  kdu  jazyka  C  ("Not   enough  memory  to  run  program"  =
'Nedostatek pamti pro innost programu').

   Velmi dleitou monost ve sprvci pekryv je schopnost pevodu modul
- pi jejich odstraovn z vyrovnvac pamti pekryv - do rozen nebo
pdavn pamti. Kdy  je  opt njakho modulu zapoteb, sprvce pekryv
jej me pekoprovat z msta jeho pevodu a nemus st  pslun soubor.
Tm se vechno zrychl.

   Pi pouvn pekryv se pam؟ vyuv podle nsledujcho obrzku.






                                  - 210 - 


         MODEL MEDIUM             MODEL LARGE             MODEL HUGE
      Ŀ------Ŀ-----Ŀ
        tda CODE            tda CODE            tda CODE    
      Ĵ      Ĵ     Ĵ
        tda OVRINFO         tda OVRINFO         tda OVRINFO 
      Ĵ      Ĵ     Ĵ
        tda STUBSEG         tda STUBSEG         tda STUBSEG 
      Ĵ------Ĵ-----Ĵ
               _DATA                 _DATA       Ĵ
          tda DATA            tda DATA       Ĵ*
                                                 Ĵ
           NEAR HEAP        Ĵ     Ĵ
        ^                      ^            **      ^             **
              STACK                STACK               STACK   
      Ĵ------Ĵ-----Ĵ
      pekryvn buffer      pekryvn buffer     pekryvn buffer 
        (alokovn              (alokovn            (alokovn     
         pi startu)            pi startu)          pi startu)  
      Ĵ------Ĵ-----Ĵ
           FAR HEAP              FAR HEAP             FAR HEAP 
        v                      v                    v             
                 

- Segmenty OVRINFO a STUBSEG jsou automaticky vygenerovny spojovacm programem (linkerem).
- Segment CODE je rezidentn.
- STUBSEG je koenov segment pro kad overlay
* vcensobn datov segmenty
** oddlen segment zsobnku
                     Obr. 7.9: Pam؟ov mapy pekryv


Jak vytاit z pekryv v Turbo C++ co nejvce

   Z pekryv v Turbo C++ se zsk nejvce pi dodren tchto zsad:

    o  Minimalizovat  pam؟ov  rezidentn  kd   (nejlpe   je   zat  od
       rezidentn knihovny innho  programu, oeten peruen a dicch
       program zazen).

    o  Nastavit velikost oblasti pro pekryvy, aby se z  n  stala pohodln
       pracovn mnoina (zante  se  128K  a  dolate  je  nahoru  i dol
       sledovnm pomru rychlost/velikost).

    o  Myslete na vestrannost a promnlivost: Vyuijte soustavy pekryv k
       vytvoen  podpory  pro  speciln  ppady, interaktivn npovdu a
       jin pnosy koncovm uivatelm, co jste si dve nemohli dovolit.


Poadavky
---------------------------------------------------------------------------

   K vytvoen pekryv je zapoteb  zapamatovat  si  nkolik jednoduchch
pravidel.

    o  Nejmen st programu, z n lze uinit pekryv, je segment.

    o  Pekrvan  aplikace mus uvat stednch, velkch nebo  rozshlch
       programovacch  model.  Drobn,  mal  a  kompaktn  modely  nejsou
       podporovny.



                                  - 211 - 


    o  Pekrvan   segmenty   podlhaj   pravidlm  normlnho  sluovn
       segment. Znamen  to, e k tmu pekrvanmu segmentu me nleet
       nkolik modul .OBJ.

   Generovn pekryv pi  spojovn  je zcela oddleno od sprvy pekryv
innho  programu.  Spojovac  program  nevkld  kd  pro  sprvu pekryv
automaticky. Z  hlediska spojovn je sprvce pekryv vlastn jenom dalm
kusem kdu,  kter  se  pipojuje.  Jedinm  pedpokladem,  kter spojovac
program uin, je to, e sprvce pekryv pebr vektor peruen (obvykle
INT 3FH),  jeho prostednictvm se d vechna dynamick zavdn. Takov
rove srozumitelnosti velmi usnaduje implementaci  zkaznicky sestavench
sprvc pekryv, kter vyhovuj konkrtnm potebm danch aplikac.


Vyuvn pekryv
---------------------------------------------------------------------------

   K pekrvn programu je teba, aby se vechny jeho moduly kompilovaly s
aktivovanou alternativou kompiltoru -Y. Aby se uinil z konkrtnho modulu
pekryv, mus se kompilovat s  alternativou -Yo (-Yo automaticky aktivuje -
Y.)

   Alternativa -Yo se vztahuje na vechny moduly a knihovny,  kter  za  n
uvedete v pkazovm dku kompiltoru TCC. Lze ji zablokovat zadnm -Yo-.
Jde o jedin alternativy pkazovho dku, kter se sm  uvdt  za  nzvy
soubor.  Napklad  k  pekryt   modulu   OVL.C,   ale  ne  ji  knihovny
GRAPHICS.LIB, je  mon  pout  kterhokoli  z  nsledujcch  pkazovch
dk:

   TCC -ml -Yo ovl.c -Yo- graphics.lib

   nebo

   TCC -ml graphics.lib -Yo ovl.c

   Vyvolte-li  pro  pipojen  souboru .EXE explicitn TLINK,  mus  se  v
pkazovm  dku  spojovacho   programu  nebo  odezvovho  souboru  urit
pipojovac alternativa  /o. Ohledn pouvn alternativy /o si pette v
Pruce uivatele oddl o TLINK v Kapitole 13., "TLINK".


Ukzka pekryv

   Dejme tomu, e chcete pekrvat program, kter se skld ze  t modul:
MAIN.C, O1.C a O2.C. Pekryvy maj vzniknout jenom z program O1.C  a O2.C.
(MAIN.C obsahuje asov kritck rutiny a oeten peruen a proto  by ml
zstat  rezidentnm.)  Pedpokldejme,   e  tento  program  pouv  velk
pam؟ov model.

   kol se vykon nsledujcm pkazem:

   TCC -ml -Y main.c -Yo o1.c o2.c

   Vsledkem bude vykonateln soubor MAIN.EXE obsahujc dva pekryvy.


Vytven pekryv v integrovanm prosted IDE

   K vytvoen pekryv v IDE je nutno uinit tyto kroky:



                                  - 212 - 


   1.  Pejt  do  dialogu  Options | Compiler | Code Generation a nastavit
       kontroln rmeek Overlays On.

   2.  Pejt do Options | Linker a nastavit kontroln  rmeek  Overlay na
       On.

   3.  Ve  sprvci  projekt  pout  projektovho  prvku  Options  a urit
       vechny moduly, z nich se maj stt pekryvy.

   Prvn krok pedstavuje ekvivalent  alternativy  pkazovho  dku  -Y v
integrovanm prosted. Nebude-li  tento kontroln rmeek aktivovn, nelze
ji pout dalch dvou alternativ. Ve druhm kroku se  rozhoduje,  zda  se
informac o pekryvech pouije ve  spojovacm  procesu  IDE.  Vypnutm tto
alternativy  lze  globln  pekryvy  vypnout,  ani  by  bylo teba  znovu
kompilovat   nebo   ve   sprvci   projekt  zmnit  nastaven  kterhokoli
jednotlivho modulu. Tetm kontrolnm rmekem  se  rozhoduje,  ze kterch
modul  se  stanou  pekryvy a kter zstanou  nezmnn.  Tento  kontroln
rmeek siln pipomn pepna -Yo kompiltoru s pkazovm dkem.

Pozor!
   Sestavujete-li  njak  soubor  .EXE  obsahujc   pekryvy,  kompilujte
vechny  moduly  s  pepnaem  Code  Generation  |  Overlays v  poloze  On
(ujistte se, zda jste nejprve zvolili Options | Full Menus On).

Pozor!
   dn modul, z nho se m stt pekryv, by neml nikdy mnit implicitn
nzev kdov tdy {Code Class}. Integrovan prosted IDE umouje mnoinu
modul  usdlench  v  pekryvech mnit, ani  byste  se  starali  o  novou
kompilaci.  To  lze  vak  zajistit  jen tehdy (aktulnmi  informacemi  ze
souboru .OBJ), ponechaj-li si pekryvy implicitn nzvy kdov tdy.


Pekrvan programy
---------------------------------------------------------------------------

   V tomto oddlu probereme nkolik  otzek, kter jsou pro dobe fungujc
pekrvan aplikace ivotn dleit.


Poadavek vzdlenho voln

   Kdy chcete kompilovat pekryvov modul, uijte njakho modelu s velkm
kdem (stednm,  velkm  nebo  rozshlm).  Pi  kadm  voln pekrvan
funkce  v  jinm  modulu muste zaruit, e vechny aktuln aktivn funkce
jsou vzdlen.

   Vechny pekrvan moduly muste  kompilovat  s  alternativou  -Y, kter
zpsob, e kompiltor zajist monost pekrvn generovanho kdu.

Dleit!
   Nepozornost pi  plnn  poadavk  na  vzdlen  voln  v pekrvanm
programu zpsobte nepedvdateln a  mon  i  katastrofln  vsledky pi
vykonvn programu.


Velikost vyrovnvac pamti

   Implicitn   velikost   vyrovnvac   pamti  pekryv  je  dvojnsobkem
velikosti nejvtho pekryvu. Pro  nkter  aplikace  je to pimen. Ale
pedstavte  si  situaci,  kdy   nkterou   konkrtn   funkci   z  programu


                                  - 213 - 


implementujete  do  mnoha  modul, z nich kad je pekrvan. Jestlie je
celkov  velikost  tchto  modul vt ne vyrovnvac  pam؟  pekryv  a
jestlie se tyto moduly asto  vzjemn volaj, dojde k podstatnmu nrstu
vmn.
   eenm je zejm zvten velikosti  vyrovnvac  pamti  pekryv, aby
byl kdykoli dostatek pamti  pro  vechny  pekryvy,  kter se asto volaj
navzjem.  Lze  tak  uinit  nastavenm  globln  promnn  _ovrbuffer  na
poadovanou  velikost  vyjdenou v paragrafech.  Napklad  pro  nastaven
vyrovnvac pamti  pekryv na 128K vlote do zdrojovho textu nsledujc
pkaz:

   unsigned _ovrbuffer = 0x2000;

   Pro  stanoven ideln velikosti vyrovnvac pamti pekryv  neexistuje
dn  obecn formule. Vhodnou hodnotu me  pomoci  nalzt  program  Turbo
Profiler od firmy Borland.


Kdy se pekrvn vyhnout

   Nepekrvejte moduly obsahujc oeten peruen  nebo  mal  a asov
kritick rutiny. V dsledku toho, e operan systm  DOS  nen vcensobn
pstupn, by se nemly pekrvat moduly, kter by se mohly volat  z funkc
peruen.

   Sprvce pekryv  v  Turbo  C++  pln  podporuje  pedvn pekrvanch
funkc  jako argument, dosazovn a inicializaci ukazatelovch  promnnch
ve funkcch adresami pekrvanch funkc, jako i voln pekrvanch rutin
prostednictvm ukazatel funkc.


Ladn pekryv

   Vtina ladicch program m  velmi  omezen  monosti  ladn pekryv,
pokud vbec njak maj. Nikoli vak integrovan ladic program Turbo C++ a
samostatn  ladic  program  Turbo  Debugger.  Oba tyto ladic  programy  v
pekryvech pln podporuj krokovn i  body  peruen  zcela srozumitelnm
zpsobem.  Pi pouit pekryv lze snadno  konstruovat  i  ladit  rozshl
aplikace - to ve uvnit integrovanho prosted IDE nebo pouitm programu
Turbo Debugger.


Extern rutiny v pekryvech

   Jako  normln  funkce  v  jazyku  C,  mus  i  rutiny external v jazyku
symbolickch  adres  dodret  jist  pravidla,  aby  sprvn  fungovaly  se
sprvcem pekryv.

   Jestlie  njak  rutina  v  jazyku  symbolickch  adres  vol jakoukoli
pekrvanou  funkci,  mus  bt  tato  rutina v jazyku  symbolickch  adres
deklarovna  FAR  a  mus  nastavovat  rm  zsobnku  uitm registru  BP.
Pedpokldejme napklad,  e JinaFunc je pekrvanou funkc v jinm modulu
a  e  ji  vol  rutina  ExternFunc  v  jazyku  symbolickch  adres.  Potom
ExternFunc mus bt FAR a nastavit rm zsobnku, co nyn pedvedeme:
   ExternFunc  PROC     FAR

      push     bp       ; Uloit BP
      mov      bp, sp      ; Nastavit rm zsobnku
      sub      sp, LocalVel   ; Pidlit pam؟ loklnm promnnm
      ...


                                  - 214 - 


      call     JinaFunc    ; Voln jinho pekrvanho modulu
      ...
      mov      sp, bp      ; Uvolnit lokln promnn
      pop      bp       ; Obnovit BP
      RET               ; Nvrat

   ExternFunc  ENDP

   kde LocalVel je velikost loklnch  promnnch.  Je-li  LocalVel nulov,
mete dva dky pro  pidlen  a  uvolnn loklnch promnnch vypustit.
Nastaven  rmu  zsobnku  BP  vak  vypustit nesmte, dokonce ani kdy  v
zsobnku dn argumenty nebo promnn nejsou.

   Stejn  poadavky  plat  i tehdy, in-li JinaFunc  nepm  odkazy  na
pekrvan funkce. Jestlie napklad JinaFunc vol pekrvan  funkce, ale
sama pekrvan nen, mus bt ExternFunc FAR a rovnا  mus  nastavit  rm
zsobnku.

   V ppad, e rutina v jazyku symbolickch adres dn pm ani nepm
odkazy na pekrvan funkce nedl, dn  speciln  poadavky neexistuj.
Pak  takov  rutina  v jazyku symbolickch adres me bt deklarovna NEAR.
Nemus ani nastavit rm zsobnku.

   Pekrvan rutiny v  jazyku  symbolickch  adres  nemaj  vytvet dn
promnn v kdovm segmentu,  jeliko  vechny  zmny uinn v pekrvanm
kdovm  segmentu  se  pi  uvolnn  pekryvu  ztrc.  Podobn nelze  ani
oekvat, e ukazatele  na  objekty zaloen v pekrvanm kdovm segmentu
zstanou  v  platnosti  i po voln jinch pekryv. Sprvce pekryv toti
pekrvan kdov segmenty voln pemsuje i uvoluje.


Vmny
---------------------------------------------------------------------------

   Mte-li k  dispozici  rozenou  nebo  pdavnou  pam؟,  mete sdlit
sprvci pekryv, aby j vyuil k vmnm. Uinte-li to, sprvce pekryv,
kdy  m  odstranit  njak modul z vyrovnvac pamti pekryv (protoe m
zavst do vyrovnvac pamti  modul  nov a vyrovnvac pam؟ je ji pln),
me  odstrann  modul  uloit prv do takov  pamti.  Vechna  pozdj
zavdn danho modulu se pak omez na vnitropam؟ov  pesuny,  kter jsou
znan rychlej ne ten z diskovho souboru.

   V  obou  ppadech  existuj  dv  monosti: Sprvce pekryv  me  bu
ptomnost  rozen  nebo  pdavn pamti zjistit a me ji sm pevzt,
nebo me  vyut ji zjitn a pidlen sti rozen/pdavn pamti.
V ppad pamti pdavn nebv  detekce pouit tto pamti vdy spn.
Je  to  zpsobeno  mnostvm  rznch  program  v  rychlch  vyrovnvacch
pamtech  a  disku  RAM,  kter  si  sti  pdavn pamti  odebraj  bez
jakhokoli oznmen. Abyste  se  tomuto  problmu  vyhnuli,  mete sprvci
pekryv sdlit poten adresu pdavn pamti i kolik  j  me bezpen
vyuvat.


Rozen pam؟

   Vmny s rozenou  pamt  se  inicializuj  funkc  _OvrInitEms. Jej
prototyp vypad nsledovn:

   extern int far _OvrInitEms
   {


                                  - 215 - 


      unsigned emsHandle,
      unsigned emsFirst,
      unsigned emsPages
   };

   Funkce _OvrInitEms a _OvrInitExt jsou definovny v dos.h.

   Je-li parametr emsHandle  nulov, kontroluje sprvce pekryv ptomnost
rozen  pamti a pidl j (me-li) takov mnostv,  aby  se  do  nj
vely  vechny  pekryvy  minus  velikost  vyrovnvac  pamti  pekryv. V
opanm ppad  bude emsHandle ppustnm oetenm EMS, emsFirst je prvn
pouitelnou strnkou EMS a emsPages  je potem strnek tto pamti, kterch
sm sprvce pekryv vyut.  Je-li  rozen  pam؟ k dispozici, poskytne
tato funkce hodnotu 0.


Pdavn pam؟

   Vmny s  pdavnou  pamt  se  inicializuj  funkc  _OvrInitExt. Jej
prototyp vypad nsledovn:

   extern int far _OvrInitExt
   {
      unsigned long extStart,
      unsigned long extLength
   };

   Je-li  parametr extStart nulov, kontroluje sprvce pekryv  ptomnost
rozen pamti. Me-li, sprvce pekryv pouije takovho mnostv voln
pamti, do kterho se  vejdou  vechny  pekryvy minus velikost vyrovnvac
pamti  pekryv.  V  opanm  ppad  bude  extStart  potkem vyuiteln
pdavn pamti, piem sprvce pekryv z n bude  moci  pout extLength
byt.  Je-li  extStart  nulov,  bude  sprvce  pekryv  pouvat  veker
dostupn pdavn pamti nad  extStart.  Funkce  poskytne 0, je-li pdavn
pam؟ k dispozici. Funkce _OvrInitExt je definovna v dos.h.

Dleit!
   Pouvn pdavn pamti nen normalizovno.  I  kdy  sprvce pekryv
zkou vechny znm metody ke  zjitn mnostv pdavn pamti, kter se
u pouv, uvejte tto funkce  obezetn.  Mte-li  napklad instalovn
njak program  o  velikosti  2  Mb  na  pevnm disku s rychlou vyrovnvac
pamt (jen vyuv pdavn pamti), mete pout  nsledujcho voln,
kterm sprvci pekryv umonte pout zbvajc pdavnou pam؟:
                       *
if (_OvrInitExt (1024L   (2048 + 1024), 0L)
   puts ("Pro vymeny prekryvu neni k dispozici zadna pridavna pamet");
















                                  - 216 - 








                            K a p i t o l a   8

                                Matematika


   V  kapitole  se  zabvme  alternativami   pohybliv   dov   teky  a
vysvtlujeme pouvn matematiky v oboru komplexnch sel.



---------------------------------------------------------------------------
Alternativy pohybliv dov teky
---------------------------------------------------------------------------


   V jazyku C se pracuje se dvma typy sel: s  celmi  sly (int, short,
long atd.) a  s  sly  s  pohyblivou  dovou tekou (float, double a long
double). Procesor v potai je sestaven tak, e celoseln hodnoty oet
snadno, ale oeten hodnot  v  pohybliv dov tece vyaduje vce asu i
nmahy.

   K  rodin   procesor   iAPx86   vak   existuje   odpovdajc   rodina
matematickch  koprocesor   8087,  80287  a  80387.  O  cel  tto  rodin
matematickch koprocesor se dle budeme zmiovat jako o 80x87 nebo  jako o
"koprocesoru".

   Mte-li procesor 80486, je v nm numerick kopropcesor ji vestavn.

   Koprocesor 80x87 je specilnm technickm procesorem, kter si mete do
svho PC piinstalovat. Vykonv instrukce v pohybliv tece velice rychle.
Uvte-li  pohyblivou  teku  velmi  asto,  pravdpodobn  si  koprocesor
podte.  CPU  vaeho  potae se technicky propoj  s  80x87  specilnm
vedenm.


Emulace koprocesoru 80x87
---------------------------------------------------------------------------

   Implicitn  alternativou  pro  generovn  kdu  Turbo  C++  je  emulace
(alternativa -f  kompiltoru  s  pkazovm  dkem).  Tato  alternativa je
urena programm, kter mohou i nemus mt pohyblivou  teku  a potam,
kter mohou i nemus mt matematick koprocesor 80x87.

   S emulan alternativou bude kompiltor  generovat  kd  jako  kdyby byl
80x87 instalovn, ale  pipoj  rovnا emulan knihovnu (EMU.LIB). Kdy se
program spust,  pouije  koprocesoru  80x87,  pokud  je  tento instalovn.
Nen-li  dn  koprocesor  v dob innosti k  dispozici,  vyuije  program
specilnch programovch prostedk, kter koprocesor 80x87 emuluj.








                                  - 217 - 


Pouit kdu 80x87
---------------------------------------------------------------------------

   Pokud se v program bude vykonvat jenom na  potach  s matematickm
koprocesorem 80x87, mete vyputnm autodetekce 80x87  a  emulan logiky
uetit  asi 10K velikosti svho souboru  .EXE.  Sta  zvolit  alternativu
generovn kdu  pohybliv teky pro koprocesor 80x87 (alternativu -f87 pro
kompiltor  s pkazovm dkem). Turbo C++ pak  programy  spoj  nikoli  s
emulan knihovnou EMU.LIB, ale s knihovnou FP87.LIB.


Kd bez pohybliv teky
---------------------------------------------------------------------------

   Pokud  v  programu  dn kd s pohyblivou tekou nemte, mete uetit
trochu asu pi spojovn, zvolte-li alternativu generovn kdu pohybliv
teky None (alternativu -f- kompiltoru  s  pkazovm  dkem).  Turbo C++
potom nepipoj ani EMU.LIB, ani FP87.LIB i MATHx.LIB.


Rychl alternativa pohybliv teky
---------------------------------------------------------------------------

   Turbo C++ m i rychlou alternativu pro pohyblivou teku (alternativu -ff
kompiltoru s pkazovm dkem). Lze  ji v pkazovm dku vypnout pomoc
-ff-.  Jejm  elem  je umonit uritou optimalizaci, kter je technicky v
rozporu se sprvnou smantikou jazyka C. Napklad

   double x;
                   *
   x = (float) (3.5 x)

   M-li se toto sprvn vykonat, x se vynsob 3.5, m se  zsk hodnota
double,  kter  se  vyputnm koncovch slic pevede na pesnost float a
potom  se  jako  double ulo do x. V rychl alternativ pohybliv teky se
souin long double pevede pmo na double. Protoe jen velmi mlo program
utrp  ztrtou pesnosti pi pevodu do uho  typu  pohybliv  teky,  je
rychl alternativa pohybliv teky alternativou implicitn.


Promnn prosted 87
---------------------------------------------------------------------------

   Sestavte-li svj program s emulac  80x87,  kter  je  implicitn, bude
program automaticky kontrolovat, zda je koprocesor 80x87 k dispozici. Pokud
ano, pouije se.

   Existuj situace,  kdy  je  lpe  toto  implicitn  autodetekn chovn
pedefinovat. Napklad kdy v vlastn provozn  systm  koprocesor 80x87
sice  m,  ale  potebujete  si  ovit,  e  program  bude  fungovat i  na
potach bez koprocesoru,  pro  nا  je  uren.  Nebo  kdy  program bude
zapoteb provozovat v njakm  systmu  kompatibilnm  s PC, ale konkrtn
systm poskytuje autodetekn logice  nesprvnou  informaci  (teba e je k
dispozici neexistujc koprocesor 80x87 nebo opan).

   Turbo  C++  poskytuje  alternativu  k pedefinovn spoutc implicitn
autodetekn   logiky.  Touto  alternativou  je  promnn  87,   popisujc
prosted.




                                  - 218 - 


   Promnn  prosted  87  se  nastav  na  vzvu  operanho systmu  DOS
pkazem SET takto:

   C> SET 87=N

   nebo takto:

   C> SET 87=Y

   Okolo = neuvdjte dn mezery. Nastavenm promnn prosted  87  na N
(jako No = 'Ne') se spoutcmu kdu sdl, e  nechcete  koprocesor  80x87
pout, ani kdyby byl v systmu instalovn.

   Nastaven  promnn  prosted 87 na Y (jako  Yes  =  'Ano')  zna,  e
koprocesor  je  k dispozici a vy si  pejete,  aby  jej  program  pouval.
Programtor mus  vak bt opatrn! Nastavte-li 87=Y kdy dn koprocesor
80x87 v systmu k dispozici nen, program uvzne.

   Pokud promnn prosted 87 byla  definovna  (jakkoli),  ale  vy chcete
jej definici zruit, uvete na vzvu DOS toto:

   C> SET 87=

   Ihned po zadn znamnka rovnosti udejte Enter.


Registry a koprocesor 80x87
---------------------------------------------------------------------------

   Pi pouvn pohybliv  teky  byste se mli vyvarovat nkolika situac
tkajcch se registr.

   1.  V reimu emulace  80x87  se nepodporuje cyklick pechod registr na
       nulu ani nkter dal zvltnosti koprocesoru 80x87.

   2.  Pi smovn pohybliv teky  a  vestavnho  asembleru  bude mon
       zapoteb vnovat pouvn  registr  zvltn  pi.  Je  to kvli
       tomu,  e  ped  volnm njak funkce systm Turbo C++ vdy mnoinu
       registr 80x87  vyprzdn. Bude mon nutn ped volnm funkc, je
       uvaj  koprocesoru, registry koprocesoru vdy vythnout a  uloit,
       ledae byste mli jistotu, e existuje dostatek registr volnch.


Zablokovn vjimench situac pohybliv teky
---------------------------------------------------------------------------

   Implicitn  se  programy  v  Turbo  C++  pedasn  ukon,  dojde-li  k
peplnn  pohybliv  teky  nebo k dlen nulou.  Tyto  vjimen  situace
pohybliv teky je mono zamaskovat volnm _control87 ve funkci main jet
pedtm, ne se njak operace s pohyblivou tekou vykon. Napklad

   #include <float.h>
   main() {
      _control87(MCW_EM, MCW_EM);
      ..
   }

   Jestli dolo k njak vjimen situaci v pohybliv tece, lze po takov
skutenosti zjistit volnm _status87 nebo _clear87. Podrobn  popis tchto
funkc viz v soustav spaen npovdy.


                                  - 219 - 


   V knihovnch funkcch me tak  dojt  k  uritm  matematickm chybm,
napklad pi pokusu o odmocninu ze zpornho sla.  Implicitn  reakc na
n  je  podn  chybovho hlen na obrazovce a poskytnut NAN ('neslo',
nedefinovan hodnota podle IEEE, Institute  of  Electrical  and Electronics
Engineers). Pouit  NAN  pozdji  podobn  zpsob,  nen-li  zamaskovno,
vjimen stav  pohybliv teky, m se program pedasn ukon. Jestlie
si  nepejete  zobrazovn  takovch  hlen,  vlote  do  svho  programu
nsledujc verzi funkce matherr.

   #include <math.h>
                                      *
   int cdecl matherr(struct exception  e)
   {
      return 1;                                     /* chyba je oetena */
   }

   Jakkoli jin pouit funkce matherr k vyhledvn matematickch chyb se
nedoporuuje, nebo ji povaujeme za zastaralou a v budoucch verzch Turbo
C++ ji nemus bt podporovna.



---------------------------------------------------------------------------
Pouvn matematiky v oboru komplexnch sel
---------------------------------------------------------------------------


   Komplexn sla maj tvar x + yi, kde x a y jsou  reln  sla  a  i je
druhou odmocninou z -1. V Turbo C++ byl vdy k dispozici typ

   struct complex
   {
      double x, y;
   };

   definovan v math.h. Tento  typ  je vhodn pro komplexn sla, nebo ty
lze  povaovat  za  dvojice relnch sel.  Omezen  jazyka  C  vak  in
aritmetiku  s  komplexnmi  sly  ponkud  nemotornou.  Pidnm   C++  se
matematika komplexnch sel stala mnohem jednodu.

   Ve co pro  pouit  komplexnch  sel  v C++ muste udlat, spov ve
vloen souboru complex.h.  V  complex.h  bylo  kvli  oeten komplexnch
sel pepsno nsledujc:

    o  vechny obvykl matematick opertory

    o  streamov opertory >> a <<

    o  obvykl matematick funkce, jako jsou sqrt a long

   Dal informace naleznete v popisu tdy complex ve spaen npovd.

   Komplexn knihovna se vyvolv jenom tehdy, je-li argument typu complex.
Proto chcete-li zskat druhou odmocninu z -1, pouijte

   sqrt (complex(-1))

   a nikoli

   sqrt (-1)


                                  - 220 - 


   Jako ukzku  pouit  komplexnch  sel  uvdme  funkci,  kter pot
Fourierovu transformaci v komplexnm oboru.

   #include <complex.h>
   // vpoet diskrtn Fourierovy transformace a[0], ..., a[n-1].
   void Fourier(int n, complex a[], complex b[]
   {
      int j, k;
      complex i(0, 1);                              // druh odmocnina z -1
      for (j = 0; j < n; ++j)
      {
      b[j] = 0;
      for (k = 0; k < n; ++k)
                      *      *    * * *
         b[j] += a[k]   exp(2 M_PI j k i/n);
      b[j] /= sqrt(n);
      }
   }


Uit matematiky BCD
---------------------------------------------------------------------------

   Turbo  C++ stejn jako tm vechny  potae  a  kompiltory  vykonv
aritmetick operace na binrnch slech (tj. o zkladu 2). Pro lidi zvykl
na  vyjdovn  sel v dekadickm tvaru (o  zkladu  10)  to  nkdy  bv
matouc.  Mnoho  sel,  kter lze v dekadickm tvaru vyjdit pesn, jako
teba 0,01, lze pi zkladu 2 vyjdit jenom piblin.

   Ve  vtin  aplikac  se dv pednost slm binrnm, ale v nkterch
situacch jsou zaokrouhlovac chyby, spojen s pevodem mezi  zkladem  2 a
zkladem 10, nenosn. Nejastjm  takovm  ppadem  jsou  finann nebo
kalkulan aplikace, kde se pot i s hali.  Uvate  nsledujc program
pro piten 100 hal a odeten jedn koruny:

   #include <stdio.h>
   int i;
   float x = 0.0;
   for (i = 0; i < 100; ++i)
      x += 0.01;
   x -= 1.0;
              *
   printf("100 .01 - 1 = %d\n", x);

   Sprvn odpov؃ zn 0.0, ale vypotanou odpovd je  njak  mal slo
blzko 0.0. Vpotem  se  toti zvtuje drobn zaokrouhlovac chyba, kter
vznik  pevodem 0.01 na zklad 2. Zmnou typu x na double nebo long double
se tato chyba zmen, ale neodstran se.

   Pro een takovho problmu  nabz  Turbo  C++  typ bcd, deklarovan v
bcd.h. Pouitm bcd se slo 0.01 zobraz pesn a promnn x typu bcd bude
udvat pesn poet hal.

   #include <bcd.h>
   int i;
   bcd x = 0.0;
   for (i = 0; i < 100; ++i)
      x += 0.01;
   x -= 1.0;



                                  - 221 - 


               *
   cout << "100 .01 - 1 = " << x << "\n";

   Uveme nkolik daj o bcd, kter je dobr si pamatovat.

    o  Typ  bcd  neodstrauje vechny zaokrouhlovac  chyby:  Vpoet  jako
       nap. 1.0/3.0 bude mt zaokrouhlovac chybu stle.

    o  Obvykl matematick funkce, jako jsou  sqrt a log, byly pepsny pro
       argumenty bcd.

    o  sla BCD maj pesnost asi na  17  desetinnch mst a rozsah asi od
             -125          125
       1 x 10     do 1 x 10   .


Pevod sel BCD

   Typ bcd je definovanm  typem  rznm od float, double nebo long double;
dekadick aritmetika se vykon jen  tehdy, je-li alespo jeden operand typu
bcd.

Dleit!
   Pro  pevod  sla  bcd zpt na jeden z obvyklch formt  o  zkladu  2
(float, double  nebo  long  double)  je  k  dispozici funkce real, kter je
lenskou  funkc  bcd.  Pevod se vak nevykon  automaticky.  Funkce  real
vykon potebn pevod na long double, kter pak lze pevdt na  jin typy
pouitm obvyklch pevod v jazyku C. Napklad

   bcd a = 12.1;

   je mono vytisknout uitm kterhokoli z nsledujcch  dk zdrojovho
textu:

   double x = a; printf("a = %g", x);
   printf("a = %Lg", real(a));
   printf("a = %g", (double) real(a));
   cout << "a = " << a);

   Pamatujte,  e  printf  nekontroluje  argumenty  a  proto  pedv-li se
hodnota real(a) typu  long  double, mus mt formtov specifiktor uvedeno
L.


Poet desetinnch mst

   Poet  desetinnch  mst,  kter  se  maj pi pevodu z binrnho  typu
penst do  typu  bcd,  lze  urit.  Tento  poet mst je nepovinnm druhm
argumentem  v  konstruktoru  bcd.  Napklad  pro pevod 1000.00/7  Ks  na
promnnou bcd zaokrouhlen na nejbli cel hal se pouije

   bcd a = bcd(1000.00/7, 2)

   kde 2 zna dv slice za desetinnou tekou. Potom
   1000.00/7            =  142.85714...
   bcd(1000.00/7, 2)    =  142.860
   bcd(1000.00/7, 1)    =  142.900
   bcd(1000.00/7, 0)    =  143.000
   bcd(1000.00/7, -1)      =  140.000
   bcd(1000.00/7, -2)      =  100.000


                                  - 222 - 


   sla se zaokrouhluj pouitm bankovn  zaokrouhlovac  metody,  co je
zaokrouhlovn  na  nejbli  cel  slo  a  ppadn  zlomkov  st  se
zaokrouhl na sud poet mst.
   bcd(12.335, 2)       =  12.34
   bcd(12.345, 2)       =  12.35
   bcd(12.355, 2)       =  12.36

   Tuto zaokrouhlovac metodu  uruje  IEEE  (Institute  of  Electrical and
Electronics Engineers).





















































                                  - 223 - 
































































                                  - 224 - 








                            K a p i t o l a   9

                            Zobrazovac funkce


   Jazyk Turbo  C++ pichz s kompletn knihovnou grafickch funkc, kter
umouj na obrazovce vytvet schmata a diagramy. V tto kapitole nejprve
strun  probereme  zobrazovac  reimy a okna. Potom  vysvtlme,  jak  se
programuje v textovm reimu a v reimu grafickm.

   Zobrazovac  funkce  v  Turbo C++ se podobaj  odpovdajcm  rutinm  v
jazyku Turbo Pascal. Nejste-li jet obeznmeni  s  ovldnm obrazovkovch
reim svho PC nebo s tvorbou a sprvou oken a vez, udlejte si chvilku
asu a pette si o tchto otzkch nsledujc text.



---------------------------------------------------------------------------
Nkolik slov o zobrazovacch reimech
---------------------------------------------------------------------------


   V osobn pota je vybaven njakm adaptrem pro zobrazovn. Me to
bt Monochrome  Display  Adapter  (MDA)  vlun  pro  zkladn zobrazovn
text, nebo me jt o adaptr schopn grafickho  zobrazovn,  jako teba
Hercules   Monochrome  Graghics  Adapter,  Color/Graphics  Adapter   (CGA),
Enhanced Graphics Adapter (EGA)  nebo  Video  Graphics Array Adapter (VGA).
Kad adaptr me pracovat v cel ad reim. Zadnm reimu se ur, zda
se na obrazovce  zobrazuje  80  nebo  40 sloupc (jenom v textovm reimu),
rozliovac  schopnost  zobrazovn  (jenom  v  grafickm  reimu)   a  typ
obrazovky (barevn nebo ernobl).

   Pracovn reim obrazovky se definuje  v okamiku, kdy program vol jednu
z funkc pro definovn reimu (textmode, initgraph nebo setgraphmode).

    o  V textovm reimu se  obrazovka  osobnho  potae rozdl na buky
       (80 nebo 40 sloupc na ku  krt  25,  43 nebo 50 dk na vku).
       Kad buce pslu urit atribut a njak znak.  Tmto  znakem je
       zobrazen  znak z kdu ASCII, zatmco atribut  uruje  jak  se  znak
       zobraz (jeho barvu, intenzitu atd.).  Turbo  C++  poskytuje irokou
       klu rutin pro manipulaci  s  textovou  obrazovkou, pro psan textu
       pmo na obrazovku i pro ovldn atribut bunk.

    o  V  grafickm  reimu  se  obrazovka  osobnho  potae  rozdl  na
       obrazov  body {pixel}; kad z nich  zobrazuje  jedin  bod.  Poet
       obrazovch   bod   (rozliitelnost)   je  dn  typem  zobrazovacho
       adaptru, kter mte k  systmu  pipojen a reimem, v nm se tento
       adaptr nachz. K vytven obrazovkov grafiky lze vyut funkc z
       grafick knihovny Turbo C++: Mete kreslit ry a obrysy, vyplovat
       uzaven oblasti vzorky a ovldat barvu vech obrazovch bod.






                                  - 225 - 


   V textovch reimech m lev horn roh obrazovky pozici (1,  1), piem
souadnice  x  roste  zleva  doprava  a  souadnice  y  roste shora dol. V
grafickch  reimech m lev horn roh obrazovky  pozici  (0,  0),  piem
souadnice x i y jsou orientovny stejnm zpsobem.



---------------------------------------------------------------------------
Nkolik slov o oknech a vezech
---------------------------------------------------------------------------


   Jazyk Turbo C++  disponuje  funkcemi  pro  tvorbu a manipulaci s okny na
obrazovce v textovm reimu (a s vezy v reimu  grafickm).  Nejste-li  s
okny a vezy obeznmeni, pette si tento strun  pehled.  Funkce Turbo
C++ pro sprvu oken a vez vysvtlme v oddlech "Programovn v textovm
reimu"  a  "Programovn  v  grafickm  reimu",  zaazench  dle v  tto
kapitole.


Co je okno ?
---------------------------------------------------------------------------

   Oknem  rozumme  obdlnkovou  oblast  definovanou na obrazovce osobnho
potae v textovm reimu.  Kdy  program  zapisuje  na obrazovku, je jeho
vstup  omezen  na  aktivn  okno.  Zbytek  obrazovky  (vn  okna)  zstane
nezmnn.

   Implicitnm oknem je  textov  okno  pedstavovan  celou  obrazovkou. V
programu lze toto implicitn celoobrazovkov textov okno zmnit na textov
okno  men ne cel obrazovka (volnm funkce  window).  Touto  funkc  se
uruje pozice okna souadnicemi na obrazovce.


Co je vez ?
---------------------------------------------------------------------------

   Obdlnkovou oblast lze na obrazovce  definovat  i  v  reimu grafickm;
potom se jedn o vez. Kdy ve svm grafickm programu vyrbte  obrzky a
pod., vezy pedstavuj obrazovku. Zbytek obrazovky  (vn  vezu) zstv
nezmnn.  Vez se definuje souadnicemi na  obrazovce  ve  voln  funkce
setviewport.


Souadnice
---------------------------------------------------------------------------

   S  vjimkou  tchto  funkc pro definovn  oken  a  vez  se  vechny
souadnice  ve  funkcch  pro  textov  nebo grafick reim  zadvaj  jako
vztaen  na  dan  okno  i  vez  a  nikoli v  absolutnch  souadnicch
obrazovky. Potkem souadnic je v textovm reimu horn lev roh  okna, na
nj  se  odkazujeme  jako  na  (1,  1).  V  grafickch reimech je potek
souadnic vezu v pozici (0, 0).









                                  - 226 - 


---------------------------------------------------------------------------
Programovn v textovm reimu
---------------------------------------------------------------------------


   V tomto oddlu  podme  strun  souhrn  funkc,  kter  se  pouvaj v
textovm  reimu.  Kad  z  tchto  funkc je podrobn popsna v  soustav
spaen npovdy.

   S Turbo C++  se  dodv  balen  pmch V/V pro ovldac pult (cprintf,
cputs atd.), poskytujc vysoce vkonn  vstupy,  sprvu  oken, umsovn
kurzoru a funkce pro ovldn atribut. Vechny tyto  funkce  jsou soust
standardnch knihoven Turbo  C++.  Jejich prototypy jsou umstny v souboru
zhlav conio.h.


Funkce pro V/V z ovldacho pultu
---------------------------------------------------------------------------

   Funkce  pro textov reim v Turbo C++ funguj  ve  vech  esti  monch
textovch zobrazovacch reimech. Reimy dostupn ve  vaem  systmu zvis
na typu zobrazovacho adaptru a  na monitoru, kter mte. Aktuln textov
reim se  ur volnm textmode. Pouvn takov funkce vysvtlme pozdji
v  tto  kapitole.  Jej podrobnj popis naleznete  v  soustav  spaen
npovdy.

   Tyto funkce pro textov reim se dl do pti samostatnch skupin:

    o  textov vstupy a manipulace s nimi

    o  ovldn oken a reim

    o  ovldn atribut

    o  zjiovn stavu

    o  podoba kurzoru

   Tchto pt skupin funkc pro  textov  reim  probereme  v nsledujcch
oddlech.


Textov vstupy a manipulace s nimi

   Uvdme krtk shrnut funkc pro textov vstupy a manipulace s nimi:

   Zpis a ten text:

cprintf           Odesl na obrazovku formtovan vstupy.

cputs             Odesl na obrazovku etzec.

getche            Pete znak a jeho odezvu zobraz na obrazovce.

putch             Odesl na obrazovku jedin znak.

   Manipulace s textem (a s kurzorem) na obrazovce:

clreol            Vymae ve od kurzoru po konec dku.



                                  - 227 - 


clrscr            Vymae textov okno.

delline           Vymae dek, na nm se nachz kurzor.

gotoxy            Umst kurzor.

insline           Kopruje text z jedn oblasti obrazovky do jin.

   Pemsovn textovch blok do- a z pamti.

gettext           Kopruje text z njak oblasti na obrazovce do pamti.

puttext           Kopruje text z pamti do njak oblasti na obrazovce.

   Programy pro vstup na obrazovku  maj  implicitn  nastaveno  okno jako
celou  obrazovku, proto lze texty ihned zapisovat,  st  a  manipulovat  s
nimi,  ani  by  bylo  nutn  pedem  nastavovat  njak  reim. Text se na
obrazovku zapisuje funkcemi pro  pm  vstup  z ovldacho pultu cprintf,
cputs a putch. Odezva vstupu se zsk funkc getche. Pesuny textu  na nov
dek se ovldaj globln promnnou _wscroll. Je-li _wscroll rovna 1, text
se po dosaen konce dku pemst na zatek dku novho a podle poteby
dojde k posunu cel strnky vzhru. Je-li _wscroll rovna  0,  pesunuje  se
text  na  zatek  tho  dku  a  k  dnmu  posunu  strnky  nedochz.
Implicitn je _wscroll rovna 1.

   Jakmile je text na  obrazovce,  lze  aktivn  okno smazat funkc clrscr,
st dku lze  smazat  funkc  clreol,  smazat cel dek funkc delline a
vloit  przdn  dek  lze  funkc  insline. Posledn ti  uveden  funkce
pracuj podle pozice kurzoru.  Ten  se  umst  do poadovan pozice funkc
gotoxy.  Je  tak  mon koprovat cel blok textu z njakho obdlnkovho
msta v okn do jinho uitm funkce movetext.

   Obdlnk s textem na  obrazovce  lze zachytit do pamti funkc gettext a
vloit takov text zptky na obrazovku (kamkoli chcete) lze funkc puttext.


Ovldn oken a reim

   Funkce pro ovldn oken a reim jsou dv:

textmode          Nastavuje obrazovku do textovho reimu.

window            Definuje okno v textovm reimu,

   Funkc  textmode  lze  nastavit  obrazovku  do  kterhokoli  z  nkolika
textovch  zobrazovacch reim (omezen je dno  pouze  typem  monitoru  a
adaptru ve vaem  systmu).  Inicializuje obrazovku jako textov okno pes
celou  obrazovku  v  uritm konkrtnm reimu a  smae  vechny  zbvajc
obrzky nebo texty.

   Mte-li obrazovku v textovm  reimu,  mete  vstupy odeslat na celou
obrazovku, nebo mete vyhradit jej st  -  okno, do n vstupy ze svho
programu  zavedete. K vytvoen textovho okna se vol  window  a  ur  se
oblast na obrazovce, kterou bude zabrat.


Ovldn atribut

   Existuj tyto funkce pro ovldn atribut textovho reimu:



                                  - 228 - 


   Nastavovn poped a pozad:

textattr          Nastavuje souasn barvy (atributy) poped i pozad.

textbackground    Nastavuje barvu (atribut) pozad.

textcolor         Nastavuje barvu (atribut) poped.

   prava intenzity:

highvideo         Nastavuje text na vy intenzitu.

lowvideo          Nastavuje text na ni intenzitu.

normvideo         Nastavuje text na pvodn intenzitu.

   Funkce pro  ovldn  atribut  nastavuj  aktuln  atributy,  kter se
vnitn zobrazuj jako 8-mi bitov hodnoty: tyi nejni bity pedstavuj
barvu poped, dal ti bity udvaj barvu pozad a nejvy bit  je bitem
"zapnutho blikn".

   Nsledn text  se zobrazuje s aktulnm atributem. Funkcemi pro ovldn
atribut lze nastavovat  barvy  pozad a poped (znak) oddlen (funkcemi
textbackground a textcolor),  nebo  slouit uren barev do jedinho voln
funkce textattr. Je tak mono stanovit, aby znak (poped) blikal. Vtina
barevnch monitor v barevnch reimech  zobrazuje  barvy  vrn. Nebarevn
monitory  mohou  nkter   nebo   vechny   atributy   pevdt   na  rzn
monochromatick odstny nebo jin vizuln efekty, jakmi jsou tun psmo,
podtren, inverzn zobrazen atd.

   Je mon usmrnit systm tak, aby se barvy poped  s  vy  intenzitou
pevedly na barvy s  nzkou  intenzitou,  co  uin funkce lowvideo (kter
vypne  bit  pro  vysokou intenzitu znak). Nebo lze funkc highvideo (kter
zapne bit pro vysokou intenzitu znak) pevst barvy s nzkou intenzitou na
barvy s intenzitou vysokou.  Kdy  prci  s  intenzitou znak skonte, lze
vrtit nastaven na pvodn hodnoty funkc normvideo.


Zjiovn stavu

   Zde je strun pehled funkc pro zjiovn stavu:

gettextinfo       Napln  strukturu  text_info   informacemi   o  aktulnm
                  textovm okn.

wherex            Poskytne souadnici x buky obsahujc kurzor.

wherey            Poskytne souadnici y buky obsahujc kurzor.

   Funkce Turbo C++  pro  V/V  z  ovldacho pultu obsahuj i takov, kter
jsou ureny  pro  zjiovn  stavu.  Prostednictvm  takovch  funkc lze
zskat  informace o oknech v textovm reimu, jako  i  o  aktuln  pozici
kurzoru v okn.

   Funkce gettextinfo napln strukturu  text_info  (definovanou  v conio.h)
nkolika podrobnostmi o textovm okn, vetn:

    o  aktulnho reimu zobrazovn

    o  pozice okna v absolutnch souadnicch na obrazovce


                                  - 229 - 


    o  rozmr okna

    o  aktulnch barev poped i pozad

    o  aktuln pozice kurzoru

   Nkdy je zapoteb jen nkterch z tchto daj. Namsto zskvn vech
informac o textovm okn lze funkcemi wherex a wherey zjistit jenom pozici
kurzoru (vzhledem k danmu oknu).


Podoba kurzoru

   Vzhled   kurzoru   lze   mnit   pouitm  nov  funkce  _setcursortype.
Pslunmi  hodnotami  jsou  _NOCURSOR,  kterou  se  kurzor   vypne,  dle
_SOLIDCURSOR, poskytujc  kurzor  ve  tvaru  plnho  obdlnku  (velk) a
konen _NORMALCURSOR, kterou se udv normln kurzor ve tvaru podtren.


Textov okna
---------------------------------------------------------------------------

   Implicitnm textovm oknem je  cel  obrazovka.  Lze  je zmnit na men
textov  okno volnm funkce window. Textov okna  mohou  obsahovat  a  50
dk a a 40 nebo 80 sloupc.

   Potkem souadnic (bodem, odkud  se  zan  slovat) textovho okna v
Turbo C++ je lev horn roh  okna.  Souadnice hornho levho rohu jsou (1,
1); souadnice dolnho pravho  rohu  textovho okna na cel obrazovce s 80
sloupci a 25 dky jsou (80, 25).


Ukzka

   Pedpokldejme, e mte  100%  kompatibiln systm PC v 80-ti sloupcovm
textovm  reimu  a  chcete vytvoit okno.  Horn  lev  roh  okna  bude  v
souadnicch  na  obrazovce  (10,  8)  a  doln  prav  roh  okna   bude  v
souadnicch na obrazovce (50, 21). Uin se tak volnm funkce window:

   window(10, 8, 50, 21);

   Kdy  jste  nyn  v textovm reimu vytvoili okno, pemstte kurzor na
pozici  v okn (5, 8) a napite na n njak text. Pouijete k tomu  funkc
gotoxy a cputs.

   gotoxy(5, 8);
   cputs("Hodne stesti, doktore Petrosi");

   Uvdn mylenky ilustruje nsledujc obrzek.













                                  - 230 - 


                 1.sloupec obrazovky
                  
                 ͻ
                 
                 
   1.dek    Ŀ
     okna                             
                  Dobr den.          
                                      
                                      
   14.dek   ٱ
      okna       25.dek
                 Ѽ     obrazovky
                                                     
                    1.sloupec okna    41.sloupec okna  80.sloupec obrazovky

                  Obr. 9.1: Okno v textovm reimu 80x25


Typ text_modes
---------------------------------------------------------------------------

   Svj monitor mete uvst do jednoho ze sedmi textovch  reim  pro  PC
volnm funkce textmode.  Vtov  typ  text_modes,  definovan  v conio.h,
umouje pro argument  mode  {reim} ve funkci textmode pout symbolickch
nzv  msto  "pvodnch"  sel  reim.  Pouvte-li  vak  symbolickch
konstant, muste do svho zdrojovho textu vloit

   #include <conio.h>

   seln a symbolick hodnoty definovan v text_modes jsou tyto:


---------------------------------------------------------------------------
     Symbolick     seln
     konstanta      hodnota   Textov reim zobrazovn
---------------------------------------------------------------------------

     LASTMODE      -1         Aktivace pedchozho textovho reimu
     BW40           0         ernobl, 40 sloupc
     C40            1         16 barev, 40 sloupc
     BW80           2         ernobl, 80 sloupc
     C80            3         16 barev, 80 sloupc
     MONO           7         Monochromatick, 80 sloupc
     C4350          64        EGA, 80x43; VGA, 80x50 dk
---------------------------------------------------------------------------

     Nsledujc  voln textmode uvedou monitor do vyznaenho  pracovnho
reimu:

     textmode(0)                        ernobl, 40 sloupc
     textmode(BW80)                     ernobl, 80 sloupc
     textmode(C40)                      16 barev, 40 sloupc
     textmode(3)                        16 barev, 80 sloupc
     textmode(7)                        Monochromatick, 80 sloupc
     textmode(C4350)                    EGA, 80x43; VGA, 80x50 dk

     Po voln textmode  v  reimu  C4350  se ur poet dk na obrazovce
funkc settextinfo.



                                  - 231 - 


Barvy textu
---------------------------------------------------------------------------

     Podrobn popis  pravy atribut bunk naleznete pod heslem textattr ve
spaen npovd.

     Kdy  njak znak zabr uritou buku, k  se  barv  tohoto  znaku
poped; barv zbytku  plochy  v  buce  se k pozad. Barevn monitory s
barevnmi zobrazovacmi adaptry mohou  zobrazovat  a  16 rznch barev. V
monochromatickch   monitorech  se  barvy  nahrazuj  vizulnmi   atributy
(zvraznn, podtren, inverzn zobrazen atd.).

     Ve  vkldacm  souboru  conio.h  jsou  pro   rzn   barvy  definovny
symbolick  nzvy. Jestlie tchto symbolickch konstant pouvte,  muste
do svho zdrojovho textu vloit soubor conio.h.

     Symbolick   konstanty  a  jim  odpovdajc  seln  hodnoty   uvd
nsledujc  tabulka. Pamatujte, e pro poped i  pozad  je  k  dispozici
pouze prvnch osm barev; dalch osm barev (barvy 8 a  15)  je k dispozici
jenom pro poped (pro samotn znaky).


---------------------------------------------------------------------------
     Symbolick                              seln        Poped nebo
     konstanta                               hodnota        pozad
---------------------------------------------------------------------------

     BLACK          {= ern}                0              Oboj
     BLUE           {= modr}                1              Oboj
     GREEN          {= zelen}               2              Oboj
     CYAN           {= azurov}              3              Oboj
     RED            {= erven}              4              Oboj
     MAGENTA        {= purpurov}            5              Oboj
     BROWN          {= hnd}                6              Oboj
     LIGHTGRAY      {= svtl ed}          7              Oboj
     DARKGRAY       {= tmav ed}           8              Jenom poped
     LIGHTBLUE      {= svtl modr}         9              Jenom poped
     LIGHTGREEN     {= svtl zelen}       10              Jenom poped
     LIGHTCYAN      {= svtl azurov}      11              Jenom poped
     LIGHTRED       {= svtl erven}      12              Jenom poped
     LIGHTMAGENTA   {= svtl purpurov}    13              Jenom poped
     YELLOW         {= lut}               14              Jenom poped
     WHITE          {= svtl modr}        15              Jenom poped
     BLINK          {= blikn}            128              Jenom poped
---------------------------------------------------------------------------

   Chcete-li,  aby urit znak blikal, pitte  k  argumentu  pro  poped
symbolickou konstantu BLINK (seln hodnota 128).


Vstup s vysokou vkonnost: Promnn directvideo

   Balk  V/V pro ovldac pult v Turbo C++  obsahuje  promnnou  s  nzvem
directvideo. Tato promnn rozhoduje, zda programov  vstupy  z ovldacho
pultu  jdou  pmo  do pamti RAM pro zobrazovn (directvideo = 1) nebo se
vykonvaj prostednictvm voln BIOS (directvideo = 0).

   Implicitn hodnotou je directvideo =  1 (vstupy z ovldacho pultu jdou
pmo do  pamti  RAM  pro  zobrazovn).  Pechod  pmo do pamti RAM pro
zobrazovn obecn  umouje  velkou  vkonnost  (rychlej  vstupy),  ale


                                  - 232 - 


vyaduje, aby pota byl 100%  kompatibiln s IBM PC: Technick prostedky
pro zobrazovn mus bt identick se zobrazovacmi adaptry IBM. Nastaven
directvideo = 0 bude fungovat na kadm potai kompatibilnm s  IBM BIOS,
ale vstupy z ovldacho pultu budou pomalej.



---------------------------------------------------------------------------
Programovn v grafickm reimu
---------------------------------------------------------------------------


   V  tomto  oddlu  podme krtk souhrn  funkc,  kterch  se  pouv  v
grafickm reimu. Ohledn podrobnjch  informac  o  tchto  funkcch vs
odkazujeme na jejich popis ve spaen npovd.

   S Turbo C++ se dodv samostatn knihovna vce ne 70  grafickch funkc
v rozsahu od  vysokorovovch  voln (jako setviewport, bar3d a drawpoly)
a  po  funkce  bitov  orientovan  (jako getimage a  putimage).  Grafick
knihovna podporuje etn styly vpln a ar a poskytuje nkolik typ psma,
pro nا lze stanovit  velikost,  zarovnat  je  a orientovat horizontln i
vertikln.

   Tyto  funkce  se  nachz  v  knihovnm  souboru  GRAPHICS.LIB a  jejich
prototypy  jsou uvedeny v souboru zhlav  graphics.h.  Krom  tchto  dvou
soubor obsahuje balk grafiky dic programy grafickch zazen (soubory
*.BGI) a vektorov typy  psma  (soubory  *.CHR).  Tyto soubory probereme v
nsledujcch oddlech.

   Abyste mohli grafick funkce pouvat:

    o  Pouvte-li integrovan prosted, pepnte Full Menus do polohy On
       a potom zvolte Options | Linker | Graphics Library. A  svj program
       sestavte,   spojovac  program   grafickou   knihovnu   Turbo   C++
       automaticky pipoj.

    o  Pouvte-li TCC.EXE, muste  uvst GRAPHICS.LIB v pkazovm dku.
       Pouv-li  se  grafiky napklad v  programu  MUJPROG.C,  pkazov
       dek TCC bude

       tcc mujprog graphics.lib

Dleit!
   Jeliko grafick funkce pouvaj ukazatel far, nepodporuje  se grafika
v drobnm pam؟ovm modelu.

   Grafick  knihovna je pouze jedna a  neexistuj  dn  jej  samostatn
verze pro jednotliv pam؟ov  modely  (na  rozdl od standardnch knihoven
CS.LIB, CC.LIB, CM.LIB atd.,  kter  jsou  specifick pro jednotliv modely
pamti). Kad funkce v GRAPHICS.LIB je funkc far a  ty  grafick  funkce,
je pejmaj ukazatele, pejmaj ukazatele far. Aby takov funkce sprvn
fungovaly,  je  dleit  zahrnout  pomoc  #include  soubor  graphics.h do
kadho modulu, kter pouv grafiku.


Funkce z grafick knihovny
---------------------------------------------------------------------------

   Funkce z grafick knihovny Turbo C++ se dl do sedmi kategori:



                                  - 233 - 


    o  ovldn systmu grafiky

    o  kreslen a vyplovn

    o  manipulace s obrazovkou a s vezy

    o  textov vstupy

    o  ovldn barev

    o  oetovn chyb

    o  zjiovn stavu


Ovldn systmu grafiky

   Strun pehled ovldn systmu grafiky:

closegraph        Uzavr systm grafiky.

detectgraph       Kontroluje technick prostedky a rozhodne,  kter dic
                  program grafiky pout; doporu reim.

graphdefaults     Nastav  vechny  promnn  systmu  grafiky   na  jejich
                  implicitn hodnoty.

_graphfreemem     Uvoln grafickou pam؟; nstroj pro  definovn vlastnch
                  rutin.

_graphgetmem      Pidluje   grafickou   pam؟;   nstroj  pro  definovn
                  vlastnch rutin.

getgraphmode      Poskytne daj o aktulnm grafickm reimu.

getmoderange      Poskytne  nejni  a  nejvy  platn reimy pro uren
                  dic program.

initgraph         Inicializuje grafick systm a uvd technick prostedky
                  do grafickho reimu.

installuserdriver Instaluje  do  tabulky  dicch  program  zazen  BGI
                  dic program pro njak pikoupen zazen.

installuserfont   Zavd do tabulky soubor se znaky BGI  njak pikoupen
                  soubor s vektorovmi typy psma.

registerbgidriver Registruje  njak  pipojen nebo  uivatelsky  zaveden
                  soubor dicho programu pro vloen pi spojovn.

restorecrtmode    Obnov pvodn (ped- grafick) reim obrazovky.

setgraphbufsize   Uruje velikost vnitn grafick vyrovnvac pamti.

setgraphmode      Vybr  uren grafick reim, mae obrazovku a  obnovuje
                  vechny implicitn hodnoty.

   S  balkem  grafiky  Turbo  C++  se dodvaj grafick dic programy  k
nsledujcm grafickm adaptrm (a k adaptrm s nimi kompatibilnm):



                                  - 234 - 


    o  Color/Graphics Adapter (CGA)

    o  Multi-Color Graphics Array (MCGA)

    o  Enhanced Graphics Adapter (EGA)

    o  Video Graphics Array (VGA)

    o  Hercules Graphic Adapter

    o  AT&T 400-dkov Graphics Adapter

    o  3270 PC Graphics Adapter

    o  IBM 8514 Graphics Adapter

   Ke sputn grafickho systmu se nejdve vol funkce initgraph. Funkce
initgraph  zavede  dic  program  grafiky  a uvede systm  do  grafickho
reimu.

   Funkci initgraph je mono  sdlit,  aby  pouila njak konkrtn dic
program i reim grafiky,  nebo  aby  sama  bhem innosti programu zjistila
pipojen zobrazovac adaptr a vybrala k nmu odpovdajc dic program.
Vyzvete-li funkci initgraph k autodetekci, vyvol funkci detectgraph, kter
zvol  dic  program  i  reim  grafiky.  Vyzvete-li  initgraph  k  uit
konkrtnho dicho programu a reimu grafiky, muste mt jistotu, e dan
technick  prostedky  jsou  k   dispozici.   Donutte-li   initgraph  ut
technickch   prostedk,   kter   k   dispozici  nejsou,  budou  vsledky
nepedvdateln.

   Jakmile  se  dic  program  grafiky  zavede,  mete  pouitm  funkce
getdrivername zjistit  nzev tohoto dicho programu a poet reim, kter
tento  dic   program   podporuje,   zjistte   funkcemi   getmaxmode   a
getgraphmode. Ty vm eknou, v  jakm reimu grafiky se skuten nachzte.
Jakmile  znte  slo  reimu, mete zjistit nzev  tohoto  reimu  funkc
getmodename.  Grafick  reimy  lze  mnit  funkc  setgraphmode   a  reim
zobrazovn lze  vrtit  do  pvodnho  stavu  (ped  inicializac grafiky)
funkc  restorecrtmode. Funkce restorecrtmode vrt obrazovku do  textovho
reimu, ale systm grafiky  neuzave  (typy  psma  i dic programy budou
stle v pamti).

   Funkce  graphdefaults  nastav  stav  grafiky (velikost vezu, kreslic
barvu, vplovou barvu a vzorek atd.) na implicitn hodnoty.

   Funkce installuserdriver a installuserfont umouj pidat  do  BGI nov
dic programy zazen a typy psma.

   A nakonec, kdy  s  pouitm grafiky konte, vyvolte closegraph, kter
systm grafiky uzave. Funkce closegraph uvoln dic program  z  pamti a
obnov pvodn reim zobrazovn (prostednictvm funkce restorecrtmode).


Podrobnj diskuse

   Pedchoz diskuse poskytla pehled o tom, jak funguje funce initgraph. V
nsledujcch odstavcch popeme  chovn funkc initgraph, _graphgetmem a
_graphfreemem ponkud podrobnji.





                                  - 235 - 


   Normln zavd  rutina initgraph dic program grafiky tm, e pidl
pro  tento  program pam؟ a potom zavede  z  disku  patin  soubor  .BGI.
Alternativn k takovmu dynamickmu  zavdcmu  schmatu  je  mon soubor
dicho programu grafiky (nebo nkolik takovch soubor)  do vykonatelnho
programovho souboru pipojit pmo. Uin  se to tak, e nejprve pevedete
soubor  .BGI  na  soubor  .OBJ  (pouitm obslunho programu BGIOBJ -  viz
UTIL.DOC, dodvan s distribunmi disketami),  potom  do  svho zdrojovho
textu   (jet   ped   voln    initgraph)    umstte    voln   funkce
registerbgidriver, kter dic  program(y) grafiky zaregistruje. Kdy svj
program sestavte, je teba do nj pipojit soubory  .OBJ  pro registrovan
dic programy.

   Po   uren,   kterch   dicch   program   grafiky   se   m  pout
(prostednictvm   detectgraph),   funkce   initgraph  kontroluje,  zda  je
poadovan dic program ji registrovn. Jestlie ano,  pouije initgraph
pmo registrovan dic program z  pamti.  V  opanm  ppad initgraph
pidl takovmu dicmu programu pam؟ a zavede soubor .BGI z disku.

Pozor!
   Pouvn   funkce  registerbgidriver  pat  ji  k  vym   technikm
programovn  a  nedoporuujeme je programtorm  zatenkm.  Funkce  je
popsna podrobnji ve spaen npovd.

   V dob innosti me systm grafiky potebovat pidlit pam؟ pro dic
programy, typy psma i vnitn vyrovnvac pamti. Je-li to nutn,  vol se
pro  pidlen  pamti  funkce  _graphgetmem  a  pro  jej uvolnn  funkce
_graphfreemem. Tyto rutiny pak  v  implicitnm  ppad volaj pouze funkce
malloc, resp. free.

   Takov   implicitn  chovn   lze   pedefinovat   vlastnmi   funkcemi
_graphgetmem  a  _graphfreemem.  Kdy  tak  uinte,  mete  sami  ovldat
pidlovn grafick pamti. Muste vak pro sv vlastn verze tchto rutin
k pidlovn pamti  uvat  stejnch  nzv:  Implicitn  funkce stejnch
nzv, kter jsou ve standardnch knihovnch jazyka C, se pedefinuj.

   Dodte-li si vlastn funkce _graphgetmem a _graphfreemem, obdrte mon
vstran hlen "duplicate symbols". Toto hlen prost ignorujte.


Kreslen a vyplovn

   Pinme krtk pehled funkc pro kreslen a vyplovn:

   Kreslen:

arc               Nakresl kruhov oblouk.

circle            Nakresl krunici.

drawpoly          Nakresl obrys mnohohelnku.

ellipse           Nakresl eliptick oblouk.

getarccoords      Poskytne souadnice z poslednho voln arc nebo ellipse.

getaspectratio    Poskytne initel podlnosti aktulnho grafickho reimu.

getlinesettings   Poskytne aktuln styl ry, jej vzorek a tlouku.

line              Nakresl ru z (x0, y0) do (x1, y1).


                                  - 236 - 


linerel           Nakresl ru do  bodu,  kter m od aktuln pozice (CP)
                  uritou relativn vzdlenost.

lineto            Nakresl ru z aktuln pozice (CP) do (x, y).

moveto            Pemst aktuln pozici (CP) do (x, y).

moverel           Pemst aktuln pozici (CP) o relativn vzdlenost.

rectangle         Nakresl obdlnk.

setaspectratio    Mn implicitn opravn faktor initele podlnosti.

setlinestyle      Nastav aktuln ku a styl ry.

   Vyplovn:

bar               Nakresl a vypln ps.

bar3d             Nakresl a vypln 3-rozmrn ps.

fillellipse       Nakresl a vypln elipsu.

fillpoly          Nakresl a vypln mnohohelnk.

floodfill         Zapln ohranienou oblast.

getfillpattern    Poskytne uivatelem definovan vzorek vpln.

getfillsettings   Poskytne informace o aktulnm vzorku a barv vpln.

pieslice          Nakresl a vypln kruhov diagram.

sector            Nakresl a vypln eliptick kruhov diagram.

setfillpattern    Vybere uivatelem definovan vzorek vpln.

setfillstyle      Nastav vzorek a barvu vpln.

   Pomoc funkc pro kreslen a malovn mete v Turbo C++ kreslit barevn
ry, oblouky,  krunice,  elipsy,  obdlnky,  kruhov  diagramy,  dvou- a
trojrozmrn psy, mnohohelnky, jako i pravideln i nepravideln tvary,
zaloen na kombinaci pedchozch. Jakkoli ohranien  tvar  (i jakoukoli
oblast,  kter  takov  tvar   obklopuje)   mete   vyplnit  jednm  z  11
peddefinovanch vzork nebo svm vlastnm uivatelsky definovanm vzorkem.
Mete  rovnا  ovldat  tlouku  a  styl kreslen ry, jako i  umstn
aktuln pozice (CP).

   ry  a  nevyplnn  tvary  se  kresl funkcemi arc,  circle,  drawpoly,
ellipse,  line,  linerel,  lineto a rectangle. Tyto  tvary  mete  vyplnit
funkc floodfill, nebo mete kreslen a vyplovn zkombinovat do jedinho
kroku funkcemi bar, bar3d, fillellipse, fillpoly, pieslice a sector. Funkce
setlinestyle  se pouv k uren, zda kreslen ra  (i  hranin  ra  u
vyplovanch tvar) bude tlust nebo tenk a zda jej  styl  bude  spojit,
tekovan atd., i zda jm bude njak vzorek, kter  si  sami  definujete.
Mete   zvolit  peddefinovan  vplov  vzorek  funkc  setfillstyle   i
definovat  svj  vlastn  vplov  vzorek  funkc  setfillpattern.  CP  se
pemst  do  definovan  polohy funkc moveto  a  o  urenou  odchylku  se
pemst funkc moverel.



                                  - 237 - 


   Ke  zjitn  aktulnho  stylu  a   tlouky   ry   se   vol  funkce
getlinesettings.  Pro  informace  o aktulnm vzorku a barv vpln se vol
getfillsettings.   Uivatelem  definovan  vzorek  vpln  zskte   funkc
getfillpattern.

   initel podlnosti  (faktor  mtka,  kter  grafick  reim  pouv k
zajitn kulatosti krunic) lze zskat funkc getaspectratio  a souadnice
naposledy  kreslenho  oblouku  nebo  elipsy zjistte volnm getarccoords.
Nemte-li krunice dokonale kulat, napravte je funkc setaspectratio.


Manipulace s obrazovkou a vezy

   Pinme strun pehled funkc pro  manipulace  s  obrazovkou, vezy,
obrazy a obrazovmi body:

   Manipulace s obrazovkou:

cleardevice       Smae obrazovku (aktivn strnku).

setactivepage     Nastav aktivn strnku grafickch vstup.

setvisualpage     Nastav slo viditeln grafick strnky.

   Manipulace s vezy:

clearviewport     Smae aktuln vez.

getviewsettings   Poskytne informace o aktulnm vezu.

setviewport       Nastav aktuln vstupn vez pro grafick vstupy.

   Manipulace s obrazy:

getimage          Ulo do pamti bitov obraz uren oblasti.

imagesize         Poskytne  poet   byt   potebnch   k   uloen  njak
                  obdlnkov oblasti z obrazovky.

putimage          Pivede na obrazovku njak dve uloen bitov obraz.

   Manipulace s obrazovmi body:

getpixel          Zsk barvu obrazovho bodu v (x, y).

putpixel          Vykresl v (x, y) obrazov bod.

   Mimo  kreslen  a  malovn nabz grafick knihovna  nkolik  funkc  k
manipulacm s obrazovkou, vezy, obrazy a obrazovmi body. Celou obrazovku
lze smazat jednm mahem volnm  cleardevice.  Tato  rutina  vyist celou
obrazovku a umst CP do vezu, ale vechna  ostatn  nastaven grafickho
systmu  ponech  beze  zmny (styl ry, vpln i textu; paletu, nastaven
vezu atd.).

   V  zvislosti  na grafickm adaptru m v  systm  od  jedn  do  ty
vyrovnvacch pamt pro strnky obrazovky. Jde o oblasti v pamti,  kam se
bod  po  bodu  ukldaj  jednotliv  obrazy o velikosti cel obrazovky.  Ke
stanoven, kter strnka  obrazovky  je aktivn (kam grafick funkce umst
sv vstupy) a kter strnka  je viditeln (zobrazen na obrazovce), slou
funkce setactivpage a setvisualpage.


                                  - 238 - 


   Jakmile mte obrazovku v grafickm  reimu, mete na n definovat vez
(obdlnkovou "zdnlivou obrazovku")  volnm setviewport. Pozice vezu se
stanovuje v absolutnch souadnicch obrazovky  a zrove se tak ur, zda
bude zapnuto (aktivn) odezvn  obrazu  nebo  ne.  Vez se smae funkc
clearviewport. Pro zjitn  aktulnch absolutnch souadnic obrazovky pro
dan vez i stav odezvn volejte getviewsettings.

   st obrazu  z obrazovky lze zachytit funkc getimage. Volnm imagesize
se vypot poet byt potebnch  k uloen takovho zachycenho obrazu do
pamti. K piveden takovho  uloenho  obrazu  zpt na obrazovku (kamkoli
chcete) slou putimage.

   Souadnice pro vechny vstupn funkce (kreslen, vyplovn, text atd.)
se vztahuj na dan vez.

   Lze rovnا manipulovat s  barvami  jednotlivch  obrazovch  bod uitm
funkc getpixel (kter poskytne  barvu  danho  obrazovho bodu) a putpixel
(kter uren bod v dan barv vykresl).


Textov vstupy v grafickm reimu

   Podvme strun pehled funkc pro vstup textu v grafickm reimu:

gettextsettings   Poskytne  aktuln  typ  psma,  jeho  smr,  velikost  a
                  zarovnn.

outtext           Odele  na  obrazovku  do  aktuln  pozice  (CP)  njak
                  etzec.

outtextxy         Odele na obrazovku do uren pozice njak etzec.

registerbgifont   Zaregistruje  njak  pipojen  nebo uivatelem zaveden
                  typ psma.

settextjustify    Nastav  hodnoty  zarovnn   textu,   kterch  pouvaj
                  outtext a outtextxy.

settextstyle      Nastav aktuln typ psma, jeho styl a zvtovac faktor
                  znak.

setusercharsize   Nastav pomr ky a vky vektorovch typ psma.

textheight        Poskytne vku etzce udanou v obrazovch bodech.

textwidth         Poskytne ku etzce udanou v obrazovch bodech.

   Grafick knihovna obsahuje pro vstupy v grafickm reimu jeden typ 8x8-
bitov zobrazovanho psma a nkolik vektorovch typ psma.

    o  V bitov zobrazovanm typu psma  se kad znak definuje jako matice
       obrazovch bod.

    o  Ve vektorovm typu psma  je  kad  znak definovn jako posloupnost
       vektor, kter grafickmu systmu sdl, jak dan znak vykreslit.

   Pednosti pouit  vektorovho  typu  se  projev  pi  kreslen velkch
znak. Jeliko vektorov typ se definuje  prostednictvm  vektor, zachov
si stle dobrou rozliitelnost a  kvalitu i navzdory svmu zvtovn. Kdy
vak  zvtte  bitov  zobrazovan typ psma, nsob  se  matice  faktorem


                                  - 239 - 


mtka a m vce se faktor mtka zvtuje, tm je  rozliitelnost znak
hor. Pro mal  znaky  bude  bitov  zobrazovan typ psma stait, ale pro
vt texty radji volte typ vektorov.

   Vstupy textu v grafice se  realizuj bu volnm outtext nebo outtextxy
a zarovnn vstupnho textu (vi CP) se ovld funkc settextjustify. Typ
psma, jeho smr (horizontln nebo  vertikln)  i  velikost  (mtko) se
vol funkc settextstyle.  Aktuln  nastaven  textu  lze  zjistit volnm
gettextsettings,  kter  poskytne   aktuln  typ  psma,  jeho  zarovnn,
zvten i  smr  ve  struktue  textsettings.  Funkce  setusercharsize vm
umon upravit ku i vku znak vektorovho typu psma.

   Je-li aktivovno (on) odezvn {clipping}, veker  vstupy  etzc z
funkc  outtext  a  outtextxy se na hranicch vezu budou odezvat. Je-li
odezvn vypnuto (off),  pak  v  ppad,  kdy  by  vstupy  etzc mly
peshnout okraj vezu, uveden funkce vstupy  bitov  zobrazovanho typu
psma  zcela  zru;  vstupy vektorovch typ psma se na okraji obrazovky
odseknou.

   Ke stanoven velikosti danho textovho  etzce  na  obrazovce  se vol
textheight (kter uruje vku etzce v potu obrazovch bod) a textwidth
(kter uruje ku etzce v potu obrazovch bod).

   Implicitn  8x8-  bitov  zobrazovan typ psma je  zabudovn  v  balku
grafiky, take je v dob  innosti  programu  stle  dosaiteln. Vektorov
typy  jsou  vak  uloeny  v  samostatnch  souborech  .CHR;  lze je v dob
innosti programu zavst do pamti, nebo pevst na soubory .OBJ (obslunm
programem BGIOBJ) a pipojit je do souboru .EXE.

   Normln se soubor  typu  psma zavede funkc settextstyle, kter tomuto
typu psma  pidl  pam؟  a  potom  z  disku zavede patin soubor .CHR.
Alternativn k takovmu dynamickmu  zavdcmu  schmatu  je  mon soubor
typu psma (nebo nkolik takovch  soubor)  do  vykonatelnho programovho
souboru pipojit pmo. Uin  se  to tak, e nejprve pevedete soubor .CHR
na  soubor  .OBJ  (pouitm obslunho programu BGIOBJ - dotete se o tom v
UTIL.DOC, co je spaen dokumentace, dodvan s distribunmi disketami),
potom do svho  zdrojovho  textu (jet ped voln settextstyle) umstte
voln funkce registerbgifont, kter typ(y) psma  zaregistruje.  Kdy svj
program sestavte, je teba do nj pipojit soubory  .OBJ  pro registrovan
vektorov typy psma.

Pozor!
   Pouvn   funkce   registerbgifont   pat   ji  k  vym  technikm
programovn  a  nedoporuujeme je programtorm  zatenkm.  Funkce  je
popsna podrobnji v UTIL.DOC, obsaenm na distribunch disketch.


Ovldn barvy

   Nsleduje strun pehled funkc pro ovldn barvy:

   Zskn informac o barv:

getbkcolor        Poskytne aktuln barvu pozad.

getcolor          Poskytne aktuln kreslic barvu.

getdefaultpalette Poskytne definin strukturu palety.




                                  - 240 - 


getmaxcolor       Poskytne  nejvy  hodnotu  barvy pouiteln v aktulnm
                  grafickm reimu.

getpalette        Poskytne aktuln paletu a jej velikost.

getpalettesize    Poskytne velikost nhledov tabulky palety.

   Nastaven jedn i nkolika barev:

setallpalette     Zmn vechny barvy palety podle uren.

setbkcolor        Nastav aktuln barvu pozad.

setcolor          Nastav aktuln kreslic barvu.

setpalette        Zmn jednu barvu z palety podle uren argumenty funkce.

   Dve  ne  o  tchto funkcch pro ovldn  barvy  pojednme  souhrnn,
podme  zkladn popis toho, jak se vlastn  barvy  na  grafick  obrazovce
vyrbj.


Obrazov body a palety

   Grafick obrazovka  pozstv z pole obrazovch bod; kad obrazov bod
vyrb  na obrazovce jeden (barevn) bod.  Hodnotou  obrazovho  bodu  nen
urena pmo pesn barva; jde jen o index vztahujc se na  tabulku barev,
kter se k  paleta.  Teprve vstupn hodnota palety, odpovdajc hodnot
danho  obrazovho  bodu,  obsahuje  pesnou  informaci o barv  pro  tento
obrazov bod.

   Toto  schma nepmho adresovn m adu  dsledk.  I  kdy  technick
prostedky  um zobrazit mnoh barvy, v danou chvli  lze  z  tchto  barev
zobrazit  jenom  njakou  podmnoinu. Poet barev, kter  lze  v  konkrtn
okamik  zobrazit,  se  rovn  potu  vstupnch  hodnot  palety  (velikosti
palety). Napklad s grafickm adaptrem  EGA  dok  technick prostedky
zobrazit 64 rznch barev, ale jenom 16 z nich souasn; velikost palety je
16.

   Velikost palety je uren rozsah hodnot, kter se daj u obrazovho bodu
pedpokldat,  tedy  od  0 do (velikost  -  1).  Nejvy  platnou  hodnotu
obrazovho  bodu (velikost - 1) pro dan dic  program  a  reim  grafiky
poskytuje funkce getmaxcolor.

   Pi probrn grafickch  funkc  Turbo C++ pouvme asto pojmu barva,
jako napklad aktuln kreslic barva,  barva  vpln  a  barva obrazovho
bodu. Ve skutenosti je tato barva hodnotou obrazovho bodu: je to  index z
palety. Jenom paleta rozhoduje o skuten barv na obrazovce. Manipulovnm
s  paletou lze skuten barvy, zobrazen na obrazovce,  mnit,  i  kdy  se
hodnoty obrazovch bod (kreslic barva, vplov barva atd.) nezmn.


Barva pozad a kreslic barva

   Barva pozad vdy odpovd  hodnot  obrazovho  bodu  0. Kdy se njak
oblast  ist  barvou  pozad, obrazov body takov  oblasti  se  jednodue
nastav na 0.





                                  - 241 - 


   Kreslic  barvou  je  hodnota,  na  kterou se obrazov body nastav  pi
kreslen ar. Kreslic barva se zvol pkazem setcolor(n), kde n je platn
hodnota obrazovho bodu vzhledem k aktuln palet.


Ovldn barev s adaptrem CGA

   Vzhledem k rozdlm v technickch  grafickch  prostedcch  se skuten
ovldn  barev  s  adaptry  CGA  a  EGA  ponkud li a proto je  uvdme
oddlen. Ovldn barev u dicho programu AT&T i s ni  rozliivost u
dicho programu MCGA se podob ovldn barev u CGA.

   S  adaptrem  CGA   si   mete  vybrat  zobrazovn  grafiky  s  nzkou
rozliivost (320x200), kter umouje pouvn ty barev, nebo s vysokou
rozliivost (640x200), kdy mete pouvat dvou barev.


   CGA s nzkou rozliivost

   V reimech  nzk  rozliivosti  lze  vybrat  ze  ty peddefinovanch
tybarevnch palet. V  kad  z  tchto  palet  lze  nastavit  pouze prvn
vstupn hodnotu palety; vstupn hodnoty 1, 2, a 3 jsou pevn. Prvn vstupn
hodnota palety (barva  0)  je  barvou  pozad. Touto barvou pozad me bt
kterkoli ze 16 dostupnch barev (viz tabulku barev pozad v  CGA, uvedenou
dle).

   Poadovanou  paletu si zvolte prostednictvm vybranho reimu  (CGAC0,
CGAC1,  CGAC2, CGAC3); v tchto reimech se uv palety 0 a palety 3, jak
je podrobn uvedeno v  nsledujc  tabulce.  Kreslic barvy a ekvivalentn
konstanty pro CGA jsou definovny v graphics.h.


---------------------------------------------------------------------------
               Konstanta piazen slu barvy (hodnot obrazovho bodu)
slo     
palety              1                   2                   3
---------------------------------------------------------------------------

  0            CGA_LIGHTGREEN      CGA_LIGHTRED        CGA_YELLOW
  1            CGA_LIGHTCYAN       CGA_LIGHTMAGENTA    CGA_WHITE
  2            CGA_GREEN           CGA_RED             CGA_BROWN
  3            CGA_CYAN            CGA_MAGENTA         CGA_LIGHTGRAY
---------------------------------------------------------------------------

   K dosazen jedn z tchto barev za kreslic barvu v CGA se vol setcolor
bu s slem barvy, nebo s nzvem odpovdajc  konstanty  jako argumentem.
Napklad chcete-li pi pouit palety 3 zvolit za kreslic barvu azurovou:

   setcolor(1);

   nebo

   setcolor(CGA_CYAN);

   V nsledujc  tabulce uvdme dostupn barvy pozad pro CGA, definovan
v graphics.h.






                                  - 242 - 


---------------------------------------------------------------------------
     seln        Symbolick          seln        Symbolick
     hodnota        nzev               hodnota        nzev
---------------------------------------------------------------------------
       0            BLACK                 8            DARKGRAY
       1            BLUE                  9            LIGHTBLUE
       2            GREEN                10            LIGHTGREEN
       3            CYAN                 11            LIGHTCYAN
       4            RED                  12            LIGHTRED
       5            MAGENTA              13            LIGHTMAGENTA
       6            BROWN                14            YELLOW
       7            LIGHTGRAY            15            WHITE
---------------------------------------------------------------------------

   Barvy poped v CGA jsou stejn jako barvy uveden v tto tabulce.

   K  dosazen  jedn  z  tchto  barev  za  barvu pozad  v  CGA  se  vol
setbkcolor(barva),  kde barva je jednou ze  vstupnch  hodnot  z  pedchoz
tabulky. Pamatujte si, e v ppad CGA nen tato barva hodnotou obrazovho
bodu  (indexem  palety);  uruje pmo skutenou barvu, kter se vezme jako
prvn vstupn hodnota palety.


   CGA s vysokou rozliivost

   V reimu  vysok rozliivosti (640x200) zobrazuje adaptr CGA dv barvy:
ern pozad a barevn poped. Obrazov body mohou nabvat hodnoty  0 nebo
1. Vzhledem ke konstrukci samotnho  CGA se barva poped konstruuje pesn
tak,  jak  technick  prostedky  chpou  barvu pozad. Nastavuje  se  tedy
rutinou setbkcolor. (Podivn, ale je tomu tak.)

   Barvami, kter jsou pro barevn  poped k dispozici, jsou barvy uveden
v pedchoz tabulce. Adaptr CGA pouije tchto barev  k  zobrazovn vech
obrazovch bod, jejich hodnota se rovn 1.

   Mezi reimy, kter se chovaj  tmto  zpsobem,  pat:  CGAHI, MCGAMED,
MCGAHI, ATT400MED a ATT400HI.


   Rutiny pro prci s paletou v CGA

   Protoe  paleta  je  v  CGA  peddefinovna,  nemete  s adaptrem  CGA
pouvat rutinu  setallpalette.  Nemete  rovnا  pout setpalette(index,
skut_barva), s vjimkou ppadu  index  = 0. (Je to alternativn zpsob pro
nastaven barvy pozad v CGA na barvu skut_barva.)


Ovldn barev s adaptry EGA a VGA

   S adaptrem EGA obsahuje paleta 16 vstupnch hodnot z celkovho potu 64
monch barev a  kadou  vstupn hodnotu lze nastavit uivatelsky. Aktuln
paleta  se  vyhled  funkc  getpalette,  kter  vypln  uritou  strukturu
velikost palety (16) a  polem  skutench  vstupnch hodnot palety ("sel
barev pro technick prostedky", uloench  v  palet).  Vstupn  hodnoty v
palet lze mnit jednotliv funkc setpalette, nebo vechny najednou funkc
setallpalette.

   Implicitn  paleta  EGA  odpovd 16 barvm CGA,  uvedenm  v  pedchoz
tabulce barev: ern je ve vstupn  hodnot  0, modr ve vstupn hodnot 1,
...,  bl  ve  vstupn  hodnot  15. V souboru graphics.h jsou  definovny


                                  - 243 - 


konstanty,  obsahujc  pslun  hodnoty  barev pro technick prostedky:
jsou  to  EGA_BLACK,  EGA_WHITE atd. Tyto hodnoty mete zskat tak funkc
getpalette.

   Rutina  setbkcolor(barva) se s adaptrem EGA chov  odlin  od  CGA.  V
ppad EGA setbkcolor pekopruje  skutenou  hodnotu  barvy,  uloenou ve
vstupn hodnot barva#, do vstupn hodnoty #0.

   Pokud  jde o barvy, dic program adaptru VGA  se  chov  jako  dic
program EGA; m jenom vy rozliivost (a men obrazov body).


Oetovn chyb v grafickm reimu

   Uvdme strun pehled funkc pro oetovn chyb v grafickm reimu:

grapherrormsg     Poskytne  pro  uren  chybov  kd  etzec  s  chybovm
                  hlenm.

graphresult       Poskytne chybov kd z posledn grafick  operace,  v n
                  nastaly pote.

   Nastane-li pi voln funkce z  grafick  knihovny  njak  chyba (teba
kdy se nenalezne typ  psma,  vyadovan  funkc settextstyle), nastav se
vnitn chybov kd. Chybov kd z posledn grafick operace, kter hlsila
chybu, se zsk volnm graphresult.  Definovny  jsou  nsledujc chybov
kdy:



































                                  - 244 - 


---------------------------------------------------------------------------
Chybov   Konstanta                Odpovdajc
kd       graphics_errors          etzec chybovho hlen
---------------------------------------------------------------------------

    0     grOk                     No error = Bez chyby
    -1    grNoInitGraph            (BGI) graphics not installed (use
                                   initgraph) = Grafika (BGI) nen
                                   instalovna (uijte initgraph)
    -2    grNotDetected            Graphics harware not detected =
                                   Technick prostedky pro grafiku
                                   nezjitny
    -3    grFileNotFound           Device driver file not found = dic
                                   program zazen nenalezen
    -4    grInvalidDriver          Invalid device driver file = Nesprvn
                                   soubor dicho programu zazen
    -5    grNoLoadMem              Not enough memory to load driver =
                                   Nedostatek pamti pro zaveden dicho
                                   programu
    -6    grNoScanMem              Out of memory in scan fill = Nedostatek
                                   pamti pi prohlen vpln
    -7    grNoFloodMem             Out of memory in flood fill = Nedostatek
                                   pamti pi zaplovn
    -8    grFontNotFound           Font file not found = Soubor typu psma
                                   nenalezen
    -9    grNoFontMem              Not enough memory to load font =
                                   Nedostatek pamti pro zaveden typu
                                   psma
    -10   grInvalidMode            Invalid graphics mode for selected
                                   driver = Nesprvn grafick reim pro
                                   zvolen dic program
    -11   grError                  Graphics error = Grafick chyba
    -12   grIOerror                Graphics I/O error = V/V grafick chyba
    -13   grInvalidFont            Invalid font file = Nesprvn soubor
                                   typu psma
    -14   grInvalidFontNum         Invalid font number = Nesprvn slo
                                   typu psma
    -15   grInvalidDeviceNum       Invalid device number = Nesprvn slo
                                   zazen
    -18   grInvalidVersion         Invalid version of file = Nesprvn
                                   verze souboru
    -----------------------------------------------------------------------

   Chybov  etzce   uveden   v   pedchoz   tabulce   zskte   volnm
grapherrormsg(graphresult()).

   Poskytovan  chybov kd se std a zmn se  jen  tehdy,  kdy  njak
grafick funkce hls chybu. Na 0 se poskytovan chybov kd  nastav jenom
kdy spn probhne initgraph anebo kdy zavolte  graphresult. Chcete-li
tud vdt, kter grafick  funkce  poskytla  kterou chybu, ulote hodnotu
graphresult do njak doasn promnn a potom ji ovte.


Zjiovn stavu

   Podvme strun pehled funkc pro zjiovn stavu grafickho reimu:

getarccoords      Poskytne informace o souadnicch z poslednho voln arc
                  nebo ellipse.



                                  - 245 - 


getaspectratio    Poskytne initel podlnosti grafick obrazovky.

getbkcolor        Poskytne aktuln barvu pozad.

getcolor          Poskytne aktuln kreslic barvu.

getdrivername     Poskytne nzev aktulnho dicho programu grafiky.

getfillpattern    Poskytne uivatelem definovan vzorek vpln.

getfillsettings   Poskytne informace o aktulnm vzorku a barv vpln.

getgraphmode      Poskytne aktuln grafick reim.

getlinesettings   Poskytne aktuln styl ry, vzorek ry a jej tlouku.

getmaxcolor       Poskytne nejvy aktuln ppustnou hodnotu  obrazovho
                  bodu.

getmaxmode        Poskytne  nejvy  slo  reimu  pro   aktuln  dic
                  program.

getmaxx           Poskytne aktuln rozliivost ve smru osy x.

getmaxy           Poskytne aktuln rozliivost ve smru osy y.

getmodename       Poskytne nzev reimu danho dicho programu.

getmoderange      Poskytne rozsah reim danho dicho programu.

getpalette        Poskytne aktuln paletu a jej velikost.

getpixel          Poskytne barvu obrazovho bodu v (x, y).

gettextsettings   Poskytne  aktuln  typ  psma,  jeho  smr,  velikost  a
                  zarovnn.

getviewsettings   Poskytne informace o aktulnm vezu.

getx              Poskytne souadnici x aktuln pozice (CP).

gety              Poskytne souadnici y aktuln pozice (CP).

   V kad kategorii grafickch funkc v Turbo C++  existuje  alespo jedna
funkce pro zjiovn  stavu.  O  tchto  funkcch se zmiujeme jak v rmci
jejich kategori, tak i zde. Kad z funkc pro zjiovn stavu  grafiky v
Turbo C++ se nazv  getnco  (s  vjimkou  kategorie pro oetovn chyb).
Nkter z nich nepejmaj dn  argumenty  a  poskytuj  jedinou hodnotu,
kter pedstavuje poadovanou informaci. Jin  zase  pejmaj  ukazatel na
njakou  strukturu  definovanou  v   graphics.h,   vypln   tuto  strukturu
patinmi informacemi a dnou hodnotu neposkytnou.

   Funkcemi pro  zjiovn stavu v kategorii ovldn systmu grafiky jsou
getgraphmode, getmaxmode a  getmoderange.  Prvn z nich poskytne cel slo
pedstavujc aktuln dic program a reim grafiky, druh poskytne slo
nejvyho  reimu  pro  dan dic program a tet poskytne rozsah reim
podporovanch danm dicm programem grafiky. getmaxx a  getmaxy poskytnou
nejvy souadnice x a y na obrazovce pro aktuln grafick reim.




                                  - 246 - 


   Funkcemi pro zjiovn stavu kreslen a  vyplovn  jsou getarccoords,
getaspectratio, getfillpattern, getfillsettings  a  getlinesettings. Funkce
getarccoords vypln uritou strukturu souadnicemi z poslednho  voln arc
nebo ellipse; funkce getaspectratio vm sdl initel podlnosti aktulnho
reimu, kter se pouv  v  systmu grafiky k tomu, aby krunice vychzely
kulat.  Funkce  getfillpattern  poskytne  aktuln  uivatelem  definovan
vzorek vpln. Funkce getfillsettings  vypln  uritou  strukturu aktulnm
vzorkem a barvou vpln. Funkce  getlinesettings  vypln  uritou strukturu
aktulnm stylem ry (spojit, peruovan  atd.),  kou  ry (normln
nebo tlust) a vzorkem ry.

   V  kategorii  pro  manipulace  s  obrazovkou a vezy jsou funkcemi  pro
zjiovn stavu getviewsettings, getx, gety a getpixel. Mte-li definovan
njak  vez,  mete  jeho  absolutn  souadnice na obrazovce,  jako  i
aktivaci  odezvn, zjistit volnm funkce getviewsettings, kter  vypln
informacemi uritou strukturu. Funkce getx  a  gety  poskytnou  (vzhledem k
vezu) souadnice x a  y  aktuln  pozice  (CP). Funkce getpixel poskytne
barvu urenho obrazovho bodu.

   Kategorie funkc pro vstup  text  v  grafickm reimu obsahuje jedinou
funkci pro zjiovn  stavu,  kter  zahrnuje  ve:  gettextsettings. Tato
funkce vypln uritou strukturu informacemi o aktulnm typu psma, o smru
zobrazovn textu (horizontln nebo vertikln  zdola  nahoru),  o faktoru
zvten znak a o zarovnn textovch etzc (jak  horizontlnch,  tak i
vertiklnch).

   Kategorie funkc pro ovldn barev v Turbo C++ zahrnuje ti  funkce pro
zjiovn stavu: getbkcolor  poskytne  aktuln  barvu  pozad  a getcolor
poskytne   aktuln  kreslic  barvu.  Funkce  getpalette  vypln   uritou
strukturu velikost aktuln palety pro  kreslen  a  obsahem  tto palety.
Funkce getmaxcolor poskytne nejvy platnou  hodnotu  obrazovho  bodu pro
aktuln dic program a reim grafiky (velikost palety - 1).

   A konen getmodename  a  getdrivername  poskytnou  nzev  reimu danho
dicho programu, resp. nzev aktulnho dicho programu grafiky.



























                                  - 247 - 
































































                                  - 248 - 








                           K a p i t o l a   10

                              Chybov hlen


   V Turbo C++ existuj  dv  kategorie chyb: chyby pi innosti programu a
chyby kompilan. Chybov  hlen  z  innho  programu  uvdme nejdve.
Chybov  hlen  kompilan  se dl do t td: zvan chyby, nezvan
chyby a upozornn. Vysvtlme a probereme je podrobn od strnky 250.

   Nsleduje  nkolik  generickch  nzv  a  hodnot,  je  se  objevuj  v
chybovch hlench uvdnch v souasn kapitole (nkter  vysvtluj samy
sebe). V obdrenm chybovm  hlen  jsou  nahrazeny patinm nzvem nebo
hodnotou.


---------------------------------------------------------------------------
     Co spatte         Co spatte
     v pruce          na obrazovce
---------------------------------------------------------------------------
     alternativa         Alternativa z pkazovho dku i jin
     argument            Argument z pkazovho dku nebo jin
     len                Nzev datovho lenu nebo lensk funkce
     hlen             etzec hlen
     identifiktor       Identifiktor (nzev promnn i jin)
     jazyk               Nzev programovacho jazyka
     modul               Nzev modulu
     nzev souboru       Nzev souboru (s- nebo bez ppony)
     parametr            Nzev parametru
     poet               Skuten poet
     poloka             Odkaz na poloku
     segment             Nzev segmentu
     skupina             Nzev skupiny
     specifiktor        Specifiktor typu
     symbol              Nzev njakho symbolu
     tda               Nzev tdy
     XXXXh               tycifern hexadecimln slo konc psmenem h
---------------------------------------------------------------------------

   Chybov hlen uvdme v abecednm  poad  podle  kdu  ASCII; hlen
zanajc  njakmi symboly (znaky rovnosti, rkami, sloenmi  zvorkami
atd.) obvykle maj pednost.  Protoe  hlen  zanajc nkterou z prv
uvedench  promnnch  nelze  abecedn  uspodat  podle  toho,  co opravdu
spatte  pi  obdren  hlen,  umstili  jsme  je  ve  vech  seznamech
chybovch hlen na zatek.

   Mte-li  napklad  v  jazyku  C  njakou   funkci   jdiproto,  obdrte
nsledujc skuten hlen:

   jdiproto must be declared with no arguments
   {jdiproto se mus deklarovat bez argument}

   Abyste si mohli toto chybov hlen vyhledat, muste najt



                                  - 249 - 


   function must be declared with no arguments

   pobl zatku seznamu chybovch hlen.

   Vyskytuje-li se  promnn  dle  v  textu  chybovho  hlen (napklad
"Incorrect   command-line  argument"  =  'Nesprvn  argument   pkazovho
dku'), naleznete takov hlen ve  sprvnm  abecednm  poad,  v tomto
ppad pod psmenem I.



---------------------------------------------------------------------------
Chybov hlen innho programu
---------------------------------------------------------------------------


   V Turbo C++ existuje  mlo  chybovch  hlen  z innho programu. Tyto
chyby se vyskytuj po spn  kompilaci  programu  bhem  jeho vykonvn.
Takov chyby uvdme a vysvtlujeme v tomto oddlu v abecednm poad.

Abnormal program termination = Nenormln ukonen programu
     Takov chybov  hlen se me generovat, nen-li dostatek pamti pro
     vykonn programu. Toto chybov hlen probrme podrobnji  na konci
     oddlu  o  chybch  v pohybliv tece. Volnm funkce abort se hlen
     tak aktivuje.

     Tato chyba me bt dsledkem pepsn pamti.

Divide error = Chyba pi dlen
     Takov  hlen  znamen,  e jste se pokusili dlit cel slo nulou,
     jako teba

          int n = 0;
          n = 2 / n;

     Tuto chybu lze zachytit signln funkc. V opanm  ppad  Turbo C++
     vol abort a program se ukon.

Floating point error: Divide by 0 = Chyba v pohybliv tece: Dlen nulou
Floating point error: Domain = Chyba v pohybliv tece: Definin obor
Floating point error: Overflow = Chyba v pohybliv tece: Peplnn
     Tato zvan (fatln)  chyba  je dsledkem operace v pohybliv tece,
     kdy vsledek nen konen.

         o  "Dlen nulou" znamen,  e  vsledek je pesn +INF nebo -INF,
            jako teba 1.0 / 0.0

         o  "Definin  obor"  znamen,  e vsledek je NAN (not a number =
            'neslo', nedefinovan), jako teba 0.0 / 0.0.

         o  "Peplnn" znamen, e vsledek je +INF  (nekoneno),  resp. -
            INF s naprostou  ztrtou  pesnosti,  jako  teba  pi dosazen
                 *
            1e200 1e200 do double.

Floating point error: Partial loss of precision = Chyba v  pohybliv tece:
sten ztrta pesnosti
Floating point error: Underflow = Chyba v pohybliv tece: Nenaplnn




                                  - 250 - 


     Tyto vjimen  stavy jsou implicitn zamaskovny a chybov hlen se
     neobjev.  Nenaplnn  se  pevd  na  nulu  a  ztrta  pesnosti  se
     ignoruje. Odmaskovat je lze volnm _control87.

Floating point error:  Stack  fault  =  Chyba  v  pohybliv  tece: Porucha
zsobnku
     Takov  hlen  zna,  e  v  pohybliv  tece  dolo  k  pekroen
     zsobnku. Chyba se normln nevyskytuje  a me bt zpsobena tm, e
     kd v asembleru  pouv  pli mnoha registr nebo patnou deklarac
     funkce v pohybliv tece.

     Takovm chybm v pohybliv tece  lze  pedejt  zamaskovnm vjimky,
     aby  nenastala,  nebo zachycenm vjimky  funkc  signal.  Podrobnosti
     naleznete u funkc _control87 a signal (v soustav spaen npovdy).

     V kadm z uvedench ppad vyd program chybov hlen a potom vol
     abort, kter zobraz

          Abnormal program termination

     a vol _exit(3). Dal podrobnosti naleznete u abort a _exit.

Null pointer assignment = Dosazen do przdnho ukazatele
     Pi  vstupu z programu s malm nebo  stednm  pam؟ovm  modelem  se
     zjiuje, zda se zmnil obsah nkolika prvnch byt v datovm segmentu
     tohoto  programu. Tyto byty by inn  program  nikdy  nezmnil.  Pokud
     dolo k jejich zmn,  zobraz  se  hlen "Null pointer assignment",
     kter  vs  informuje  o  tom,  e (nejspe) dolo k dosazen  njak
     hodnoty do neinicializovanho ukazatele. Me bt, e program ze vech
     ostatnch hledisek  funguje sprvn; jde vak o zvanou zvadu, kter
     je ihned zapoteb  vnovat pozornost. Nepoda-li se neinicializovan
     ukazatel opravit, me to  vst  k  nepedvdatelnmu  chovn (vetn
     ppad, kdy ve velkch, kompaktnch a rozshlch  pam؟ovch modelech
     dojde k "uzamen" potae). K  prozkoumn  przdnch  ukazatel lze
     vyut integrovanho ladicho programu.

Stack overflow = Peplnn zsobnku
     Implicitn velikost zsobnku v programech Turbo C++ je 4096 byt. Pro
     vtinu  program  je  to  dostaten,  ale  tam,  kde  se  vykonvaj
     rekurzivn funkce nebo se  ukld  velk  mnostv loklnch dat, me
     dojt k  peplnn zsobnku. Toto hlen obdrte jenom tehdy, mte-
     li aktivovnu kontrolu zsobnku. Pokud opravdu toto hlen obdrte,
     mete se pokusit pejt na  vt  pam؟ov  model,  zvtit velikost
     zsobnku nebo zmenit zvislost svho programu na zsobnku. Velikost
     zsobnku  se  d  zmnit pravou globln promnn _stklen; vce se o
     tom dovte ve spaen npovd. Ohledn  zmenen  mnostv loklnch
     dat  pouvanch  ve  funkcch  pinme nsledujc ukzku. Promnn
     buffer byla deklarovna jako  statick  a  nepotebuje dn prostor v
     zsobnku, jako tomu je u promnn list.

          void libfunction( void )
               {
               static int buffer[ 2000 ];    /* sdl v datovm segmentu */
               int list[ 2000 ];                    /* sdl v zsobnku */
               }

     Deklarovn loklnch promnnch jako statickch m dv nevhody:





                                  - 251 - 


        1.  Zabraj  nyn trvale prostor globlnm promnnm a  zsobnku.
            (Co  pidte  na  jedn  stran,  chyb na stran  druh.)  Jde
            obvykle jenom o men nevhodu.

        2.  Funkce ji nesm bt  vcensobn  pstupnou.  Znamen  to, e
            pokud se funkce vol rekurzivn nebo asynchronn a je dleit,
            aby kad voln tto  funkce  mlo  svou  vlastn jednoznanou
            kopii dan promnn, nemete ji uinit statickou. To proto, e
            pi kadm  voln funkce by se msto pidlen novho prostoru
            v pamti pouilo pro promnnou prostoru pesn  stejnho. Mohlo
            by  dojt  k  problmm  se  sdlenm pamti, kdyby  se  funkce
            pokouela vykonat uvnit sebe sama (rekurzivn) nebo ve stejnou
            dobu jako sama (asynchronn). Pro vtinu program  v operanm
            systmu  DOS  se  o  dn  problm  nejedn.   Pokud  nepete
            rekurzivn funkce nebo  se  nepokoute  o  vykonn  vce loh
            najednou, nedlejte si dn  starosti.  Pokud  ano, m pro vs
            pedchoz vklad svj vznam.



---------------------------------------------------------------------------
Chybov hlen z kompiltoru
---------------------------------------------------------------------------


   Diagnostick hlen z  kompiltoru  Turbo  C++  se  dl  do  t td:
zvan (fatln) chyby, chyby a upozornn.

Zvan  chyby   jsou  vzcn.  Nkter  z  nich  znamenaj  vnitn  chybu
kompiltoru. Dojde-li  k  zvan  chyb,  kompilace  se  okamit zastav.
Muste pak pijmout potebn opaten a potom kompiltor znovu spustit.

Chyby znamenaj syntaktick chyby v programu, chyby v pstupu na disk nebo
do pamti, jako i chyby  pkazovho  dku.  Kompiltor  dokon aktuln
kompilan  fzi a potom se zastav. Kompiltor  se  pokou  nalzt  tolik
skutench  chyb  ve   zdrojovm   programu,  kolik  je  bhem  kad  fze
(pedzpracovn,  syntaktick  analza,  optimalizace  a  generovn  kdu)
mon.

Upozornn nebrn  dokonen  kompilace.  Indikuj  podmnky,  kter  jsou
podezel,  ale  kter  jsou  legitimn  coby  soust  jazyka.  Kompiltor
poskytuje  upozornn i tehdy, kdy ve  zdrojovm  souboru  nalezne  njak
konstrukce, je zvis na danm potai.

   Kompiltor podv hlen tak, e  nejprve  uvede  tdu  hlen, potom
nzev zdrojovho souboru a slo dku, kde zjistil danou podmnku. Nakonec
nsleduje text samotnho hlen.

   V nsledujcch seznamech uvdme hlen uspodan abecedn.  S kadm
hlenm se udv i pravdpodobn pina a nprava.

   V  chybovch  hlench  muste dt pozor na jednu malikost tkajc se
sel dk: kompiltor  generuje  hlen tak, jak odhaluje chyby. Jeliko
jazyk C nenaizuje dn omezen pro umsovn pkaz do textovch dk,
me se skuten pina chyby  nachzet nkolik dk ped uvedenm slem
dku. V nsledujcm seznamu jsme  vyznaili ta hlen, kter se objevuj
asto (z pohledu kompiltoru) na dcch a za skutenou pinou chyby.

constructor is not a base class of class = konstruktor nen  bzovou tdou
pro danou tdu


                                  - 252 - 


     Konstruktor tda pro tdy v  C++ se pokou volat konstruktor bzov
     tdy  konstruktor,  nebo  se  pokoute  zmnit  pstupov  prva  k
     tda::konstruktor.   konstruktor   nen   bzovou  tdou  od  tdy.
     Zkontrolujte si deklarace.

function1 cannot be distinguished from function2 = funkce1 nen k rozlien
od funkce2
     Seznamy typ  parametr v deklaracch tchto dvou funkc se dostaten
     neli,  aby  se  daly  prohlsit  za rzn. Zkuste v jedn  deklaraci
     zmnit poad parametr nebo typ nkterho parametru.

Upozornn
function1 hides virtual  function  function2  =  funkce1  zakryje virtuln
funkci funkce2
     Virtuln  funkce  v  bzov  td  se  obvykle  pedefinuje  njakou
     deklarac ve td odvozen. V tomto ppad in deklarace se stejnm
     nzvem  ale  s  odlinmi typy argument virtuln  funkce  pro  dal
     odvozen tdy nepstupnmi.

function cannot return a value = funkce neme poskytnout dnou hodnotu
     K  takovmu  hlen  v C++ dojde, obsahuje-li funkce s typem vsledku
     void pkaz return, kter poskytuje njakou hodnotu, napklad int.

function must be declared with no arguments = funkce se mus deklarovat bez
argument
     Tuto opertorovou funkci jste v  jazyku  C++  nesprvn  deklarovali s
     argumenty.

function must be declared with one  argument  = funkce se mus deklarovat s
jedinm argumentem
     Tuto opertorovou funkci jste v  jazyku  C++  nesprvn  deklarovali s
     vce ne jednm argumentem.

function must be declared with two arguments = funkce se mus deklarovat se
dvma argumenty
     Tuto opertorovou funkci jste v jazyku C++ nesprvn deklarovali jinak
     ne s dvma argumenty.

function was previously  declared  without static = funkce byla deklarovna
pedtm jako nestatick
     Tuto  funkci  zde  deklarujete  jako  statickou,   ale   pedtm  byla
     deklarovna jako extern (nebo globln). Norma ANSI C takov smovn
     deklarac nepipout.

function was previously declared with the language language  =  funkce byla
pedtm deklarovna v jazyku jazyk
     Pro funkci lze udat  pouze  jeden  jazykov modifiktor (cdecl, pascal
     nebo  interrupt).  Tato  funkce  byla  deklarovna na dvou  mstech  s
     odlinmi jazykovmi modifiktory.

identifier cannot be declared in an anonymous union  =  identifiktor nelze
deklarovat v anonymnm unionu
     Kompiltor nalezl deklaraci lensk  funkce  nebo  statickho  lenu v
     anonymnm (bezejmennm) unionu. Takov  uniony  mohou  obsahovat jenom
     datov leny.

identifier cannot be used in a static member function = identifiktor nelze
pouvat ve statick lensk funkci




                                  - 253 - 


     Statick lensk funkce  sm  pouvat jenom statick leny sv tdy,
     akoli  m pln pstupov prva. Tato chyba  je  vsledkem  pokusu  o
     uit lenu, kter vyaduje ukazatel this.

Upozornn
identifier declared but never used = identifiktor je deklarovn, ale nebyl
vbec pouit
     Ve zdrojovm souboru byla deklarovna  uveden  promnn  jako soust
     prv  koncho  bloku,  ale tto promnn nebylo  vbec  pouito.  K
     takovmu  upozornn dojde, naraz-li kompiltor na koncovou  sloenou
     zvorku  njakho sloenho pkazu nebo funkce. Deklarace  promnnch
     se vyskytuj na zatku sloench pkaz a funkc.

Upozornn
identifier is both a structure tag and a name, now obsolete = identifiktor
je souasn oznaenm struktury i nzvem, co je nyn ji zastaral
     V jazyku C je naprosto  sprvn  pout  identifiktoru  souasn jako
     oznaen njak struktury i jako promnn i nzvu typedef, jako teba

          struct s { int i, j; } s;

          nebo

          typedef struct s { int i, j; } s;

     V C++ to nen vhodn.

Upozornn
identifier  is  assigned  a  value  that  is  never used  =  Identifiktoru
identifiktor je dosazena hodnota, kter se nikdy nepouije
     Tato promnn se sice objevuje v dosazen, ale nikde ve  funkci, kter
     prv kon, se j nepouv. K upozornn dojde jenom kdy kompiltor
     naraz na koncovou sloenou zvorku.

Upozornn
identifier  is  declared  as  both  external and static = identifiktor  je
deklarovn souasn jako extern i statick
     Tento identifiktor  se objevil v deklaraci, kter jej implicitn nebo
     explicitn oznaila jako globln  nebo  extern  a rovnا v deklaraci
     statick. Takov identifiktor se  povauje  za  statick. Prohldnte
     vechny deklarace tohoto identifiktoru.

identifier  is  inaccessible  because  also  in  class  = identifiktor  je
nepstupn, jeliko je tak ve td
     Nen  dovoleno pouvat tdu jako pmou  i  nepmou  bzovou  tdu
     souasn, nebo poloky jsou automaticky nejednoznan. Zkuste  v obou
     mstech uinit bzovou tdu virtuln.

identifier  is  not  a  data  member  and  can't  be  initialized   here  =
identifiktor nen datovm lenem a nelze jej zde inicializovat
     V inicializtorech konstruktor  lze inicializovat jenom datov leny.
     Takov  hlen  znamen,  e  seznam  obsahuje  njak  statick nebo
     funkn len.

identifier is not a member of struct = identifiktor nen lenem struktury
     Pokoute se odkzat na identifiktor  jako na len struktury, ale ten
     lenem nen. Zkontrolujte si deklarace.

identifier is not a parameter = identifiktor nen dnm parametrem



                                  - 254 - 


     V sekci deklarac parametr njak  definice funkce ve starm stylu je
     identifiktor deklarovn, ale nen uveden jako parametr. Bu deklaraci
     odstrate nebo doplte identifiktor jako parametr.

identifier is not legal here = identifiktor zde nen ppustn
     Typov specifiktor  identifiktor  zde  nen  ppustn,  protoe  se
     popr nebo  duplikuje jin typov specifiktor v tto deklaraci, nebo
     proto, e se identifiktor uv jako nzev v typedef,  kdy  v  tomto
     oboru nen nzvem v typedef.

identifier  must be a member function =  identifiktor  mus  bt  lenskou
funkc
     Vtina opertorovch funkc v C++  sm bt leny td nebo normlnmi
     nelenskmi  funkcemi,  ale  po uritch z nich se pmo vyaduje, aby
     byly leny td. Jsou to operator =, operator ->, operator() a pevody
     typ. Tato opertorov funkce nen lenskou funkc, avak m j bt.

identifier must be a member function  or  have  an argument of class type =
identifiktor mus bt lenskou funkc nebo mt argument typu tda
     Vtina opertorovch funkc v C++ mus mt implicitn nebo explicitn
     argument typu tda.  Tato  opertorov  funkce  byla  deklarovna vn
     tdy a nem explicitn argument typu tda.

identifier must be a  previously  defined  class  or struct = identifiktor
mus bt pedem definovanou tdou nebo strukturou
     Pokoute se  deklarovat identifiktor jako bzovou tdu, ale ten bu
     nen  tdou  nebo  dosud nebyl zcela definovn.  Opravte  nzev  nebo
     pozmte deklarace.

identifier must be a previously  defined  enumeration  tag  = identifiktor
mus bt pedem definovanm oznaenm vtu
     Tato deklarace se pokou  odkzat  na  identifiktor jako na oznaen
     njakho typu enum, ale ten nebyl takto deklarovn. Opravte nzev nebo
     pozmte deklarace.

identifier must be a previously  defined structure tag = identifiktor mus
bt pedem definovanm oznaenm struktury
     Tato deklarace se pokou  odkzat  na  identifiktor jako na oznaen
     njakho typu struct, ale  ten  nebyl  takto deklarovn. Opravte nzev
     nebo pozmte deklarace.

identifier specifies multiple or duplicate  access  =  identifiktor uruje
vcensobn nebo duplicitn pstup
     Bzovou tdu lze deklarovat jako  public  nebo  private,  nikoli vak
     oboj. Tento  specifiktor pstupu se nesm pro bzovou tdu objevit
     vckrt ne jednou.

member is not accessible = len nen pstupn
     Pokoute  se  odkzat  na len len njak tdy v C++,  ale  ten  je
     private nebo protected a nelze se na nj z tto funkce  odkzat. Nkdy
     se  to stv pi pokusu o voln  urit  pstupn  pepsan  lensk
     funkce   (nebo  konstruktoru),   ale   argumenty   odpovdaj   njak
     nepstupn  funkci.  Ped  kontrolou  pstupnosti  vdy  dochz  ke
     kontrole  rozliitelnosti  pepsn.   Jde-li  prv  o  toto,  zkuste
     explicitn jeden i vce  parametr  urit,  aby se vybrala poadovan
     pstupn funkce.

specifier has already been included = specifiktor ji byl zahrnut
     Tento specifiktor typu se v deklaraci objevuje vce ne jednou. Jeden
     z jeho vskyt zrute nebo zmte.


                                  - 255 - 


= expected = oekv se =
     Pro inicializaci promnn byl oekvn opertor dosazen (piazen).

, expected = oekv se ,
     V seznamu deklarac, inicializac nebo parametr byla oekvna rka.

{ expected = oekv se {
     Na  potku  bloku  nebo  inicializace  byla  oekvna  lev  sloen
     zvorka.

( expected = oekv se (
     Ped seznamem parametr byla oekvna lev zvorka.

} expected = oekv se }
     Na konci bloku nebo inicializace byla oekvna prav sloen zvorka.

) expected = oekv se )
     Na konci seznamu parametr byla oekvna prav zvorka.

: expected after  private/protected/public = po private/protected/public se
oekv :
     Pi pouit na zatku sekce private/protected/public v njak td v
     C++ mus za tmito vyhraenmi slovy nsledovat dvojteka.

:: requires a preceding identifier in this context = v tomto kontextu se na
zatku vyaduje njak identifiktor
     V deklaraci byla zahrnuta  dvojit  dvojteka,  ani by j pedchzela
     kvalifikace  nzvu  tdy. Nekvalifikovan dvojit  dvojteka  se  sm
     pout  jedin  ve  vrazech  k  oznaen globlnho oboru a nikoli  v
     deklaracch.
 *                                   *
.  operands do not match = operandy .  si neodpovdaj
                                                                  *
     Nedeklarovali jste pravou stranu opertoru teka-hvzdika (. )  v C++
     jako ukazatel na len tdy uren na lev stran opertoru.

# operator not followed by macro argument name = po opertoru # nensleduje
nzev argumentu makroinstrukce
     V definici makroinstrukce se sm pout # k oznaen pevodu argumentu
     makroinstrukce  na  etzec.  Za  #  mus bt uveden  nzev  argumentu
     makroinstrukce.

Access can only  be  changed  to  public  or protected = Pstup lze zmnit
pouze na public nebo protected
     Odvozen tda v C++ sm pozmnit pstupov prva lenu bzov tdy,
     avak jenom na public nebo protected. len bzov  tdy  nelze uinit
     private.

Access  declarations cannot grant or reduce  access  =  Deklarac  pstupu
nelze pstup udlit nebo omezit
     Odvozen tda me v C++ upravit pstupov prva lenu bzov tdy,
     avak pouze jejich obnovou na  prva v td bzov. Neme pstupov
     prva udlit ani omezit.

Access specifier specifier found in a union = V unionu nalezen specifiktor
pstupu specifiktor
     Specifiktor pstupu (public, private nebo protected) se v C++ nesm
     pout v unionech.




                                  - 256 - 


Ambiguity between function1 a  function2  =  Nejednoznanost  mezi funkcemi
funkce1 a funkce2
     Na zadan parametry me bt pouito obou uvedench pepsanch funkc.
     Takov nejednoznanost nen dovolena.

Ambiguous conversion functions: type1 and  type2  =  Nejednoznan pevodn
funkce: typ1 a typ2
     Kompiltor  nalezl  vce  ne jeden zpsob pro pevod zadanho typu na
     typ poadovan. Takov nejednoznanost nen dovolena.

Upozornn
Ambiguous operators need parentheses  =  Nejednoznan  opertory potebuj
zvorky
     Toto upozornn se zobraz, kdykoli se spolen pouije dvou opertor
     posunu, relanch i bitov logickch  opertor  bez  zvorek. Rovnا
     opertorem  stn  nebo  odtn,  jen  se  objev  bez zvorek  s
     opertorem posunu, se takov  hlen  vyvol.  Programtoi  si asto
     prioritu tchto opertor ml, jeliko jim piazen priorita ponkud
     odporuje intuici.

Array bounds missing ] = Hranice pole postrdaj ]
     Ve zdrojovm souboru je deklarovno pole, v nm  hranice  pole nebyly
     ukoneny pravou hranatou zvorkou.

Array must have at least one element = Pole mus mt alespo jeden prvek
     ANSI C  i  C++  vyaduj,  aby  pole  bylo definovno alespo s jednm
     prvkem   (objekty  nulovch   velikost   nejsou   dovoleny).   Starm
     programovacm  trikem  se  deklaruje  prvek  pole  njak  struktury s
     nulovou  velikost a potom se mu  pidl  skuten  potebn  prostor
     funkc  malloc.  Tohoto  triku  lze  stle pouvat, ale  muste  pole
     deklarovat (alespo) s jednm prvkem. Deklarace (na rozdl od definic)
     pol neznm velikosti jsou samozejm dovoleny.

     Napklad

     char ray[];                   /* definice neznm velikosti - nelze */
     char ray[0];                        /* definice velikosti 0 - nelze */
     extern char ray[];              /* deklarace neznm velikosti - ok */

Array of references is not allowed = Pole odkaz nen dovoleno
     Je  neppustn  mt  pole odkaz, nebo ukazatele  na  odkazy  nejsou
     ppustn a nzvy pol jsou vzny na ukazatele.

Array size too large = Pole je pli velk
     Deklarovan pole je vt ne 64K.

Assembler statement too long = Pkaz asembleru je pli dlouh
     Pkaz s vestavnm pekladem nesm bt del ne 480 byt.

Upozornn
Assigning type to enumeration = Piazovn typu typ k vtu vet
     Dosazovn celoseln hodnoty do typu enum. Jde sice o chybu,  ale je
     omezena  na  pouh  upozornn,   aby   existujc   programy  dostaly
     pleitost k innosti.

Upozornn
Assignment to this is obsolete, use X::operator new instead = Dosazovn do
this je zastaral, pouijte msto nj X::operator new




                                  - 257 - 


     Ve  dvjch  verzch  C++  existoval  jedin  zpsob,  jak  ovldat
     pidlovn pamti  td objekt, toti dosazenm do parametru this v
     konstruktoru. Tuto praxi nyn nedoporuujeme, nebo lpe, bezpenji a
     obecnji to uinte definovnm lensk funkce operator new.

Attempting  to  return  a  reference  to  local  name  identifier = Pokus o
poskytnut odkazu na lokln nzev identifiktor
     Tato funkce v C++ poskytuje typ  odkaz  a vy se pokoute zskat odkaz
     na lokln (auto) promnnou. To je neppustn, nebo promnn, na ni
     se  odkazuje,  pi  ukonen  funkce  zmiz.  Mete  zskat odkaz  na
     libovolnou  statickou  nebo globln promnnou,  resp.  mete  funkci
     zmnit, aby msto toho poskytovala hodnotu.

Attempting to return a reference to a temporary object = Pokus o poskytnut
odkazu na doasn objekt
     Ve funkci poskytujc referenn typ  jste  se  pokusili  o poskytnut
     odkazu na njak  doasn  objekt (mon na vsledek konstruktoru nebo
     voln funkce). Jeliko tento objekt  pi nvratu z funkce zmiz, bude
     takov odkaz neppustn.

Zvan chyba
Bad call of inline function = patn voln funkce inline
     Pouili  jste   funkce   inline,   kterou   jste   vzali   z  definice
     makroinstrukce, ale volte ji nesprvn. Funkc inline v  jazyku  C je
     takov funkce, kter zan i kon dvojitm podtrenm (__).

Bad file name format in include directive =  V  direktiv  pro  vkldn je
chybn formt nzvu souboru
     Nzvy vkldacch soubor  mus bt uzaveny uvozovkami ("nazevsoub.h")
     nebo  lomenmi  zvorkami   (<nazevsoub.h>).  V  nzvu  souboru  chyb
     poten   uvozovka   nebo  lomen  zvorka.   Pokud   jste   pouili
     makroinstrukci, je chybn vsledn rozvinut  text,  tj.  nen uzaven
     uvozovkami.

Bad ifdef directive syntax = Chybn syntax direktivy ifdef
     Direktiva   #ifdef   mus  obsahovat  jako   tlo   direktivy   jedin
     identifiktor (a nic jinho).

Bad ifndef directive syntax = Chybn syntax direktivy ifndef
     Direktiva   #ifndef   mus   obsahovat   jako  tlo  direktivy  jedin
     identifiktor (a nic jinho).

Bad return type  for  a  type  conversion  operator = patn typ vsledku v
opertoru pro pevod typ
     lensk funkce pro pevod typu v C++ uruje typ  vsledku  odlin  od
     svho typu. Deklarac pevodn funkce  operator  T  se  nesm stanovit
     dn typ vsledku.

Bad  syntax for pure function definition =  Chybn  syntax  definice  ist
funkce
     ist virtuln  funkce se uruj pipojenm "=0" k deklaraci. Napsali
     jste nco podobnho, ale ne pesn tot.

Bad undef directive syntax = Chybn syntax direktivy undef
     Direktiva   #undef   mus  obsahovat  jako   tlo   direktivy   jedin
     identifiktor (a nic jinho).

Base  class  class  is  included  more  then  once = Bzov tda tda  je
obsaena vce ne jedenkrt



                                  - 258 - 


     Tdu v C++ lze  odvodit  z libovolnho potu td bzovch, ale pmo
     se sm odvodit z dan tdy jenom jednou.

Base class class  is  initialized  more  then  once = Bzov tda tda je
inicializovna vce ne jedenkrt
     V konstruktoru tdy  v  C++  je  v  seznamu  inicializac  po zhlav
     konstruktoru obsaena bzov tda tda vce ne jednou.

Base  class  cannot  be declared protected = Bzovou tdu nelze deklarovat
jako protected
     Bzov tda v C++ sm bt public nebo private, nikoli vak protected.

Upozornn
Base initialization without a  class  name  is  now obsolete = Inicializace
bze bez nzvu tdy je nyn ji zastaral
     Dvj verze jazyka C++ umoovaly inicializovat bzovou  tdu tak,
     e  se  po  zhlav   konstruktoru   uvedl   jenom   seznam  parametr
     konstruktoru bzov tdy.  Nyn  se  doporuuje  udvat  nzev bzov
     tdy.

          Zdrojov text se tm stane mnohem  srozumitelnjm  a doporuuje
     se to zejmna pi existenci vcensobnch bzovch td.

          Star zpsob:

          odvoz::odvoz(int i) : (i, 10) { ... }

          Nov zpsob:

          odvoz::odvoz(int i) : baze(i, 10) { ... }

Bit field cannot be static = Bitov poloka neme bt statickou
     Jako  static  lze  deklrarovat  jenom  dn datov leny td v  C++,
     nikoli bitov poloky.

Bit  fields must be signed or unsigned int = Bitov poloky mus bt celmi
sly se znamnkem nebo bez nj
     Bitov poloka se mus  deklarovat  jako  celoseln typ se znamnkem
     nebo bez znamnka. V ANSI  C  sm  bt  bitov  poloky  jenom  int se
     znamnkem nebo bez nj (nikoli nap. char nebo long).

Bit  fields  must  contain at least one bit = Bitov poloky mus obsahovat
alespo jeden bit
     Nen mono deklarovat nazvanou bitovou poloku tak, aby  mla  0 (nebo
     mn ne 0) bit. Nenazvanou  bitovou poloku lze deklarovat, aby mla
     0  bit, co je konvence, kterou  se  nad  zarovnn  nsledujcch
     bitovch poloek k okraji bytu (i okraji slova,  je-li  pro zarovnn
     zvolena alternativa -a).

Bit field too large = Bitov poloka je pli velk
     Takov chyba nastv, zadte-li bitovou poloku s vce ne 16 bity.

Body  already  defined  for this function  =  Tlo  tto  funkce  ji  bylo
definovno
     Funkci tohoto nzvu a typu ji bylo tlo zadno. Tlo funkce lze zadat
     pouze jednou.

Upozornn
Both  return and return with a value used = Pouito jak pkazu return, tak
i return s hodnotou


                                  - 259 - 


     Aktuln funkce m pkazy return s hodnotami i bez hodnot. V jazyku C
     je to ppustn, ale tm vdy to vede k chyb. Je mon, e na konci
     funkce byl mjak pkaz return vynechn.

Call of non-function = Nejde o voln funkce
     Volan nzev nen deklarovn  jako  funkce.  Obvykle to bv zpsobeno
     nesprvn deklarovanou funkc nebo zkomolenm nzvem funkce.

Upozornn
Call to function with no prototype = Voln funkce bez prototypu
     Takov hlen se vyd, jestlie je aktivovno  upozornn "Prototypes
     required" = 'Vyaduj se prototypy' a vy volte  njakou  funkci, ani
     byste nejprve pro tuto fumkci zadali prototyp.

Upozornn
Call  to function function with no prototype =  Voln  funkce  funkce  bez
prototypu
     Takov hlen se vyd, jestlie je aktivovno  upozornn "Prototypes
     required"  =  'Vyaduj  se prototypy' a vy volte funkci funkce, ani
     byste nejprve pro tuto fumkci njak prototyp zadali.

Upozornn
Code has no effect = Kd nem dn inek
     Takov upozornn se vyd,  nalezne-li  kompiltor  pkaz  s njakmi
     opertory, kter nemaj dn inek. Napklad pkaz

          a + b;

          nam dn vliv na dnou promnnou. Takov operace je nepotebn
     a pravdpodobn znamen, e jde o njak nedopaten.

Cannot assign  identifier1 to identifier2 = Nelze dosadit identifiktor1 do
identifiktoru identifiktor2
     Ob  strany  dosazovacho  (=)  opertoru (nebo sloenho dosazovacho
     opertoru, jako teba +=)  mus  bt kompatibiln a nesm to bt pole.
     Prav  strana  takovho  dosazen je typu identifiktor1  a  nelze  ji
     dosadit do objektu vlevo, kter je typu identifiktor2.

Cannot call 'main' from  within  the program = Zevnit programu nelze volat
funkci main
     Jazyk C++ nepipout rekurzivn voln main.

Cannot  cast  from  identifier1  to  identifier2 = Nelze petypovat z  typu
identifiktor1 na typ identifiktor2
     Petypovn  z  typu  identifiktor1   na   typ   identifiktor2  nen
     ppustn. V jazyku C  lze  ukazatel  urit  jako celoseln typ nebo
     jako  jin  ukazatel.  Celoseln  typ  lze  petypovat  na libovoln
     celoseln typ, na typ s pohyblivou tekou nebo na typ  ukazatel. Typ
     s pohyblivou tekou lze petypovat na celoseln typ nebo  na  typ  s
     pohyblivou tekou. Struktury a pole  nelze  petypovat.  Obvykle nelze
     mnit typ void.

          V  jazyku  C++  se  hledaj  uivatelsky  definovan   pevody  a
     konstruktory a nelze-li  dn  nalzt,  plat  pedchoz  pravidla (s
     vjimkou ukazatel na leny td). Pokud jde o  celoseln  typy, lze
     na ukazatel lenu petypovat jenom konstantn nulu. Ukazatel lenu lze
     petypovat  na  celoseln  typ  nebo  na  ukazatel  podobnho lenu.
     Ukazatel podobnho lenu ukazuje na datov len, in-li tak originl,
     nebo na funkn  len,  in-li tak originl. Kvalifikan tda typu,
     na nj se m pejt, mus bt toton nebo bzov k originlu.


                                  - 260 - 


Cannot  create  a  variable  for  abstract  class  class =  Nelze  vytvoit
promnnou pro abstraktn tdu tda
     Abstraktn tdy - s istmi  virtulnmi  funkcemi  -  nelze pouvat
     pmo, jenom jako odvozeniny.

Cannot define  a  pointer  or  reference  to  a reference = Nelze definovat
ukazatel nebo odkazovat se na odkaz
     Nelze mt ukazatel na odkaz nebo odkaz na odkaz.

Cannot  find  class::class(class  &)  to  copy  a  vector  =  Nelze  nalzt
tda::tda(tda &) pro koprovn vektoru
     Kdy v C++ tda  tda1  obsahuje vektor (pole) tdy tda2 a chcete
     konstruovat objekt typu tda1 z jinho objektu typu tda1, je k tomu
     teba  konstruktoru tda2::tda2(tda2&), aby bylo mono  sestrojit
     prvky vektoru. Takov konstruktor pebr pouze jedin parametr (kter
     je odkazem na svou tdu) a nazv se odkazov konstruktor.

          Kompiltor obvykle dosad odkazov konstruktor automaticky. Pokud
     jste vak definovali  konstruktor  pro tdu tda2, kter m parametr
     tda2&  a  dodaten   parametry  s  implicitnmi  hodnotami,  neme
     odkazov konstruktor existovat a kompiltor jej  neme  vytvoit. (Je
     to  proto, e tda2::tda2(tda2&) a tda2::tda2(tda2&, int  =
     1) nelze  rozliit).  Tento  konstruktor  je  teba  pedefinovat, aby
     vechny  parametry  mly  implicitn  hodnoty.  Pak  mete  definovat
     odkazov konstruktor nebo jej nechat vytvoit kompiltorem.

Cannot find  identifier::identifier() to initialize a vector = Nelze nalzt
identifiktor::identifiktor() pro inicializaci vektoru
     Kdy v C++ tda  tda1  obsahuje vektor (pole) tdy tda2 a chcete
     konstruovat objekt typu tda1 z jinho objektu typu tda1, je k tomu
     teba konstruktoru tda2::tda2(), aby  bylo  mono  sestrojit prvky
     vektoru.  Takovmu  konstruktoru  bez  parametr  se  k  implicitn
     konstruktor.  Kompiltor  automaticky dosad  implicitn  konstruktor,
     ledae byste pro tdu tda2 njak konstruktor definovali. V takovm
     pdad  kompiltor  automaticky  implicitn  konstruktor  nedosad  -
     muste jej dosadit sami.

Cannot  find  class::class()  to  initialize  base  class  =  Nelze  nalzt
tda::tda() pro inicializaci bzov tdy
     Kdykoli se konstruuje v  C++  odvozen  tda  tda2, mus se nejprve
     konstruovat kad bzov tda tda1. Jestlie konstruktor  pro tdu
     tda2 neuruje konstruktor pro tdu1 (jako soust  zhlav tdy2),
     mus pro bzovou  tdu existovat konstruktor tda1::tda1(). Takov
     konstruktor bez parametr se nazv implicitn konstruktor. Kompiltor
     automaticky  dosad  implicitn konstruktor, ledae  byste  pro  tdu
     tda1  njak  konstruktor  definovali.  V takovm pdad kompiltor
     automaticky implicitn konstruktor nedosad - muste jej dosadit sami.

Cannot find class::class() to  initialize  field  identifier = Nelze nalzt
tda::tda() pro inicializaci identifiktoru poloky
     Kdy v C++ tda tda1 obsahuje njak len tdy tda2 a pejete si
     zkonstruovat objekt typu tda1, nikoli  vak  z  jinho  objektu typu
     tda1, mus existovat konstruktor  tda2::tda2(),  aby  bylo mono
     takov len zkonstruovat. Takovmu konstruktoru bez parametr  se k
     poten   konstruktor.   Kompiltor   automaticky  dosad  poten
     konstruktor,   ledae  byste  pro  tdu  tda2  njak   konstruktor
     definovali.   V  takovm  pdad  kompiltor  automaticky   poten
     konstruktor nedosad - muste jej dosadit sami.




                                  - 261 - 


Cannot  find  class::operator=(class&)  to  copy  a vector =  Nelze  nalzt
tda::opertor=(tda&) pro koprovn vektoru
     Kdy v C++ tda tda1 obsahuje njak len tdy tda2 a pejete si
     koprovat  tdu  typu  tda1   mus   existovat   opertor  dosazen
     tda2::opertor=(tda2&),  aby  bylo  mono koprovat prvky vektoru.
     Kompiltor obvykle dosad takov opertor automaticky. Pokud jste vak
     pro tdu  tda2 definovali opertor=, avak ne takov, kter pebr
     parametr typu tda2&, kompiltor jej  automaticky  nedosad  - muste
     tak uinit sami.

Cannot  have a near member in a far class = Nemete mt ve vzdlen  td
blzk len
     Vechny leny tdy far v C++ mus bt vzdlen. Tento len je tdou,
     kter byla deklarovna (nebo je implicitn urena) jako near.

Cannot initialize a field = Nemete inicializovat poloku
     Jednotliv  poloky  struktur,  union   a   td   v  C++  nesm  mt
     inicializtory.  Strukturu  nebo union lze  inicializovat  jako  celek
     uitm  inicializtor  ve  sloench  zvorkch.  Tdu  v   C++  lze
     inicializovat pouze uitm konstruktoru.

Cannot initialize type1 with type2 = Nelze inicializovat typ1 typem typ2
     Pokoute se inicializovat objekt  typu  typ1  hodnotou typu typ2, co
     nen dovoleno. Pravidla  pro  inicializaci jsou v podstat stejn jako
     pravidla pro dosazovn.

Cannot modify a const object = Nelze modifikovat konstantn objekt
     jde o indikaci neppustn operace na objektu deklarovanm jako const,
     nap dosazovn do takovho objektu.

Cannot overload 'main' = Nelze pepsat funkci main
     main je jedinou funkc, kterou nelze pepsat.

Cannot specify base classes  except  when defining the class = Bzov tdy
nelze specifikovat s vjimkou definovn takov tdy
     Kdy se v  C++  specifikuje  njak  tda, bzovou tdu, od n byla
     dan  tda odvozena, lze specifikovat pouze  v  mst  definice  tto
     tdy. Kdy deklarujete jenom oznaen  tdy,  jako  teba  class c;,
     nemete bzov tdy specifikovat.
Case constant is out of range of the selector = Konstanta  v  case  je mimo
rozsah selektoru
     Konstanta  u  nvt  case  nen  v  rozsahu  monch  hodnot  vrazu
     pepnae a proto  se  nvt tohoto ppadu nikdy nezvol. Napklad
     kdy je vraz switch typu int, ale nvt ppadu  m  hodnotu  vt
     ne nejvt hodnota int.

Case outside of switch = Ppad je mimo pepna
     Kompiltor narazil na pkaz case,  kter je mimo pkaz switch. asto
     je to zpsobeno tm, e sloen zvorky nejsou v prech.

Case statement missing : = Pkaz case postrd :
     V pkazu case mus bt konstantn vraz, za nm nsleduje dvojteka.
     Ve vrazu v pkazu case bu chybla dvojteka,  nebo  ped dvojtekou
     byl njak symbol navc.

Character constant too long = Znakov konstanta je pli dlouh
     Znakov konstanty mohou bt jenom jeden nebo dva znaky dlouh.

Class  cannot  be  initialized  with  {}  =  Tdu nelze  inicializovat  se
sloenmi zvorkami {}


                                  - 262 - 


     Normln struktury jazyka C lze inicializovat  mnoinou  hodnot uvnit
     sloench zvorek. Tdy v C++ lze  inicializovat  pouze konstruktory,
     pokud  je tda m, leny private,  funkcemi  nebo  bzovmi  tdami,
     kter jsou virtuln.

Class  member  member  declared  outside  its  class  =  len tdy len je
deklarovn mimo svou tdu
     lensk funkce td v C++ lze deklarovat jenom uvnit deklarace tdy.
     Na rozdl od funkc, kter nejsou leny, je nelze deklarovat vcekrt,
     ani na jinch mstech.

Compound statement missing } = Sloen pkaz postrd }
     Kompiltor doshl konce zdrojovho souboru a nenalezl  dnou koncovou
     sloenou zvorku. Nejastji to bv zpsobeno tm, e sloen zvorky
     nejsou v prech.

Conflicting type modifiers = Modifiktory typu se navzjem popraj
     Dochz  k  tomu,  kdy je udna deklarace  obsahujc  napklad  pro
     tent  ukazatel klov slova near i far.  Pro  jedin  ukazatel  lze
     zadat  pouze  jeden  adresov modifiktor a pro funkci lze zadat pouze
     jeden modifiktor jazykov (cdecl, pascal nebo interrupt).

Constant expression required = Vyaduje se konstantn vraz
     Pole  se  mus  deklarovat  s  konstantn velikost. Tato  chyba  bv
     obvykle zpsobena zkomolenm konstanty #define.

Upozornn
Constant is too long = Konstanta je pli dlouh
     Kompiltor narazil bu na dekadickou konstantu vt neli 32767, nebo
     na oktalovou (i hexadecimln) konstantu vt neli 65535, za kterou
     chyb psmeno l nebo L. S takovou konstantou se zachz jako s long.

Upozornn
Constant  member  member  is  not  initialized = Konstantn len len  nen
inicializovn
     Tda  v  C++  obsahuje  len  len, kter nem  dnou  inicializaci.
     Pamatujte si, e  konstantn  leny lze jenom inicializovat, nikoli do
     nich dosazovat.

Upozornn
Constant out  of  range  in  comparison  =  Konstanta je pi porovnn mimo
rozsah
     Zdrojov soubor obsahuje  porovnn zahrnujc konstantn dl vraz,
     jen  byl  mimo  rozsah  ppustn  pro  typ  jinho  dlho  vrazu.
     Napklad porovnn  jakhokoli daje unsigned s -1 nem smysl. Abyste
     zskali konstantu unsigned vt  ne  32767  (dekadicky),  muste bu
     tuto  konstantu urit jako unsigned [napklad (unsigned)65535],  nebo
     ke konstant pipojit psmeno u i U (napklad 65535u).

          Kdykoli   k  takovmu  hlen  dojde,  kompiltor  pesto   bude
     generovat  kd  pro  porovnn.  Kon-li  tento   kd   vdy  stejnm
     vsledkem, jako teba pi porovnn vrazu char a 4000, kd tento test
     bude vykonvat.

Constructor cannot have a  return  type  specification = Konstruktor neme
mt specifikovn typ vsledku
     Konstruktory  v  C++  maj  implicitn  typ  vsledku,  kter  pouv
     kompiltor,  ale  vy  nemete  typ  vsledku  deklarovat  ani njakou
     hodnotu zskat.



                                  - 263 - 


Upozornn
Conversion may lose significant  digits  = Pi pevodu me dojt ke ztrt
platnch slic
     Zdrojov text vyaduje v opertoru dosazen nebo v njak jin situaci
     pevod z typu long nebo usigned long na  typ  int  nebo  unsigned int.
     Jeliko  promnn  typu  int a typu long nemaj stejnou velikost, me
     tento druh pevodu zmnit chovn programu.

Conversion of near pointer  not  allowed  =  Pevod blzkho ukazatele nen
dovolen
     V rmeku pro vyhodnocen vraz  nelze  blzk  ukazatel  pevdt na
     ukazatel vzdlen, pokud program prv  nebا. To proto, e k pevodu
     je zapoteb aktuln hodnoty  registru  DS  v  uivatelskm programu,
     kter neexistuje.

Could not  find  a  match  for  argument(s)  = K argumentu(m) nebylo mon
nalzt odpovdajc funkce
     Nebylo  mon   nalzt  dn  funkce  v  C++,  jejich  parametry  by
     odpovdaly zadanm argumentm.

Could not find file filename = Nebylo mon nalzt soubor nzev souboru
     Kompiltor nen schopen nalzt soubor zadan v pkazovm dku.

Declaration  does  not  specify  a  tag  or  an   identifier   =  Deklarace
nespecifikuje oznaen ani identifiktor
     Touto deklarac se nic nedeklaruje. V deklaraci me jt o struct nebo
     union bez oznaen nebo bez promnn. Jazyk C++ vyaduje, aby  se nco
     deklarovalo.

Declaration is not allowed here = Zde nen deklarace dovolen
     Deklarace nelze pout  jako  dicho pkazu v pkazech while, for,
     do, if nebo switch.

Declaration missing ; = Deklarace postrd ;
     Zdrojov soubor obsahoval  deklaraci  poloky  struct  nebo  union, za
     kterou nebyl uveden stednk.

Declaration syntax error = Chyba v syntaxi deklarace
     Ve zdrojovm  souboru  byla  obsaena  deklarace  postrdajc  njak
     symbol, resp. s njakm symbolem navc.

Declaration terminated incorrectly = Deklarace nesprvn ukonena
     Deklarace m njak  symbol  navc, resp. m nesprvn koncov symbol,
     jako teba stednk za tlem funkce. lensk funkce v  C++,  kter  je
     deklarovna  v  njak  td  se  stednkem  mezi  zhlavm a  levou
     poten sloenou zvorkou tuto chybu generuje tak.

Declaration was expected = Oekvala se deklarace
     Zde  se  oekvala  deklarace, ale nebyla nalezena.  Obvykle  to  bv
     zpsobeno chybjcm  oddlovaem,  jako  je  rka,  stednk,  prav
     zvorka i prav sloen zvorka.

Upozornn
Declare function prior to use in prototype = Deklarujte funkci  funce jet
ped jejm pouitm v prototypu
     Kdy se prototyp funkce odkazuje na njak typ  struktury,  jen nebyl
     pedem  deklarovn,  nebude   deklarace  uvnit  prototypu  toton  s
     deklarac vn prototypu. Napklad:
                            *
          int func(struct s  ps);


                                  - 264 - 


          struct s { /* ... */ };

     Jeliko v oboru  prototypu  func  dn  struktura  s  nen,  je typem
     parametru ps ukazatel na nedefinovanou  strukturu  s.  Nen  toton s
     pozdji deklarovanou strukturou s. Vsledkem budou pozdj upozornn
     a chybov hlen ohledn nekompatibilnch typ. Ta by byla bez tohoto
     vstranho hlen velmi zhadn. Vechno lze zajistit, pemstte-li
     deklaraci struktury s ped veker prototypy, kter se na ni odkazuj,
     resp.  pidte-li  ped  kad  prototyp,  kter  se  na  strukturu  s
     odkazuje, neplnou deklaraci typu  struct  s;.  Je-li  parametr funkce
     struct a ne ukazatel na struct, nepln deklarace nesta.; pak muste
     ped prototyp umstit deklaraci struktury.
                             *            *
Declare operator delete (void )  or  (void ,  size_t) = Deklarujte opertor
              *              *
delete s (void ) nebo s (void , size_t)
                                                            *
     Deklarujte opertor delete s  jedinm  parametrem  void  nebo s druhm
     parametrem typu size_t. Pouijete-li druh verze, uije  se pednostn
     ped verz prvn. Globln opertor  delete je ji deklarovn se dvma
     parametry,   proto  bute   opatrn,   zamlte-li   tuto   deklaraci
     pedefinovat.

Default outside of switch = Pkaz default je mimo pepna
     Kompiltor narazil na pkaz default vn pkazu switch. Nejastji to
     bv zpsobeno tm, e sloen zvorky nejsou v prech.

Default value missing = Chyb implicitn hodnota
     Kdy  njak  funkce  v  C++  deklaruje urit parametr  s  implicitn
     hodnotou, vechny parametry nsledujc  mus  mt  implicitn hodnoty
     tak. V tto  deklaraci  za parametrem s implicitn hodnotou nsleduje
     parametr bez implicitn hodnoty.

Define  directive  needs  an  identifier   =   Direktiva   define  vyaduje
identifiktor
     Prvnm  znakem  za  #define,  kter  nen  przdnm  mstem, mus  bt
     identifiktor. Kompiltor zde nalezl njak jin znak.

Destructor cannot have a return  type specification = Destruktor neme mt
specifikaci typu vsledku
     Destruktory v  C++ nikdy dnou hodnotu neposkytuj a nelze deklarovat
     typ vsledku ani zskat njakou hodnotu.

Destructor for class is not accessible = Destruktor pro  tdu  tda  nen
pstupn
     Destruktor pro tdu v C++ je  protected  nebo private a nelze jej zde
     pro likvidaci tdy doshnout. Je-li destruktor  tdy  private, nelze
     takovou tdu  zlikvidovat a proto jej nelze nikdy pout. Destruktoru
     protected lze doshnout pouze z odvozench td. Je to uiten zpsob
     jak zajistit, aby se z  bzov tdy nikdy nevytvoila dn instance,
     nbr jenom tdy z n odvozen.

Destructor  name  must  match  the  class  name  = Nzev  destruktoru  mus
odpovdat nzvu tdy
     Ve td v C++ zan  deklarace destruktoru tdy znakem vlnovky (~).
     Nzev destruktoru mus bt stejn jako nzev tdy. Ve vaem zdrojovm
     souboru je ~ uvedena ped njakm jinm nzvem.

Division by zero = Dlen nulou



                                  - 265 - 


     Ve vaem  zdrojovm souboru bylo v njakm konstantnm vrazu obsaeno
     dlen nebo zbytek s nulovm dlitelem.

Upozornn
Division by zero = Dlen nulou
     Ve vrazu pro dlen nebo zbytek byla dlitelem literlov nula.

do statement must have while = V pkazu do mus bt while
     Zdrojov soubor obsahoval pkaz  do,  v  nm chyblo koncov klov
     slovo while.

do-while statement missing ( = V pkazu do-while chyb (
     V pkazu do kompiltor nenalezl  po klovm slov while dnou levou
     zvorku.

do-while statement missing ) = V pkazu do-while chyb )
     V pkazu do kompiltor  nenalezl  po  testovacm vrazu dnou pravou
     zvorku.

do-while statement missing ; = V pkazu do-while chyb ;
     V testovacm vrazu pkazu  do  nenalezl  kompiltor po prav zvorce
     dn stednk.

Duplicate case = Duplicita v pkazu case
     Kad pkaz case z  pkazu  switch  mus mt jednoznanou konstantn
     hodnotu vrazu.

Enum syntax error = Chyba syntaxe vtu
     Deklarace enum neobsahovala seznam identifiktor ve sprvnm tvaru.

Error directive: message = Direktiva error: hlen
     Takov hlen se vyd  pi  zpracovn  direktivy #error ve zdrojovm
     souboru. V tomto hlen se zobraz text direktivy.

Error writing output file = Chyba pi zpisu vstupnho souboru
     Chyba operanho systmu  DOS,  kter znemon Turbo C++ zapsat njak
     soubor .OBJ, .EXE nebo  doasn  soubor.  Zkontrolujte -n nebo adres
     Options  |  Directories | Output a ujistte  se,  zda  je  to  adres
     sprvn. Zkontrolujte tak, zda je na disku dostatek msta.

Expression expected = Oekv se vraz
     Zde  se oekval vraz, ale aktulnm  symbolem  dn  vraz  zanat
     neme.  Takov hlen se me objevit tam,  kde  se  oekv  dic
     vraz  klauzule  if  nebo  while,  resp.  kde  se inicializuje  njak
     promnn. Pinou asto  bv  njak  nhodn  vloen  nebo zruen
     symbol ve zdrojovm textu.

Expression is too complicated = Vraz je pli komplikovan
     Kompiltor doke oetit velmi sloit vrazy,  avak  nkter vrazy
     se stovkami len se mohou projevit jako pli komplikovan. Rozdlte
     takov vraz do dvou i vce pkaz.

Expression of arithmetic type expected  =  Oekv  se  vraz aritmetickho
typu
     Opertory unrn plus (+) a  minus  (-)  vyaduj  vraz aritmetickho
     typu - povoleny jsou  jenom  typy char, short, int, long, enum, float,
     double a long double.

Expression of integral type expected = Oekv se vraz celoselnho typu



                                  - 266 - 


     Opertor doplku (~) vyaduje vraz celoselnho typu - povoleny jsou
     pouze typy char, short, int, long nebo enum.

Expression of scalar type expected = Oekv se vraz skalrnho typu
     Opertory  not (!), inkrement (++) a  dekrement  (--)  vyaduj  vraz
     skalrnho typu - povoleny  jsou  pouze  typy  char, short, int, long,
     enum, float, double, long double a typy ukazatelov.

Expression syntax = Syntax vrazu
     Jde   o  univerzln  chybov  hlen,  kdy  kompiltor   syntakticky
     analyzuje vraz a naraz na vnou chybu. Obvykle bv zpsobeno dvma
     za   sebou   nsledujcmi   opertory,  neprovmi  nebo  chybjcmi
     zvorkami nebo chybjcm stednkem u pedchozho pkazu.

Expression  type  does  not match the return type = Typ vrazu nesouhlas s
typem vsledku
     Typ vrazu return nelze pevst na typ vsledku funkce.

extern  variable  cannot  be   initialized   =   Extern   promnnou  nelze
inicializovat
     Aplikuje-li se na njakou promnnou pam؟ov tda extern, znamen to,
     e se zde tato promnn deklaruje, ale nedefinuje -  nepidl  se  j
     dn pam؟. Proto  ani  nelze promnnou, kter je soust deklarace,
     inicializovat.

Extra parameter in call = Ve voln je pebyten parametr
     Voln funkce prostednictvm ukazatele definovanho s prototypem mlo
     zadno pli mnoho parametr.

Extra  parameter  in call to function =  Ve  voln  funkce  je  pebyten
parametr
     Voln uveden funkce (definovan s  prototypem)  mlo  v  sob pli
     mnoho argument.

Field field cannot be used without an object = Poloky poloka nelze pout
bez objektu
     Znamen to, e uivatel zapsal tda::poloka, kde poloka je normln
     (nestatick) len a neexistuje  dn  tda,  kterou  by bylo mono s
     touto    polokou    sdruit.    Napklad    je     ppustn    pst
     obj.tda::poloka, ale nelze pst tda::poloka.

Field field is  ambigous  in  class  =  Poloka poloka nen ve td tda
jednoznan
     Odkaz na  poloku je nutno kvalifikovat patinm nzvem bzov tdy.
     Ve td tda  v  C++  lze  poloku  poloka nalzt ve vce ne jedn
     bzov  td  a  nebyla kvalifikovna tak, aby bylo jasn, kam pat.
     Plat to pouze pi vcensobn ddinosti, kdy nzev  poloky  v dn
     bzov td nen zakryt stejnm nzvem poloky ve  td  odvozen po
     stejn cest. Pravidla jazyka C++ vyaduj, aby se vykonal test takov
     nejednoznanosti  jet ped  kontrolou  pstupovch  prv  (private,
     protected, public). Je tud mon toto hlen zskat  i  tehdy, kdy
     lze doshnout jenom jedn (nebo dn) z poloek.

Field identifier expected = Oekv se identifiktor poloky
     Zde se oekval nzev struktury nebo poloky tdy v  C++,  ale  nebyl
     nalezen. Prav strana opertoru  teka  (.)  nebo  ipka (->) mus bt
     nzvem poloky ve struktue nebo td z lev strany opertoru.

File must contain at least one external declaration = Soubor mus obsahovat
alespo jednu extern deklaraci


                                  - 267 - 


     Tento kompilan unit byl  logicky  przdn,  nebo  neobsahoval dn
     deklarace. ANSI C i C++ vyaduj, aby v kompilanm  unitu  bylo  nco
     deklarovno.

File name too long = Nzev souboru je pli dlouh
     Nzev souboru udan v direktiv #include byl pli dlouh na  to, aby
     jej kompiltor dokzal zpracovat. Nzvy  souboru  v  operanm systmu
     DOS nesm bt del ne 79 znak.

For statement missing ( = V pkazu for chyb (
     V pkazu for nenalezl kompiltor po klovm slov  for  dnou levou
     zvorku.

For statement missing ) = V pkazu for chyb )
     V  pkazu for nenalezl kompiltor po  dicm  vrazu  dnou  pravou
     zvorku.

For statement missing ; = V pkazu for chyb ;
     V pkazu for nenalezl kompiltor po nkterm z vraz dn stednk.

Found : instead of :: = Msto :: nalezana :
     Msto dvojit dvojteky (::) jste k oddlen kvalifiktoru tdy v C++
     od jej poloky v deklaraci nebo vrazu pouili jenom dvojteku.

Friend declarations need a function signature = K  deklaraci  ptelstv je
teba uren funkce
     Deklarujete-li  sptelenou  funkci,  muste  rovnا  poskytnout  typy
     parametr, aby bylo mon nalzt ve sboru pepsanch funkc tu pravou.

Friends must be  functions  or  classes,  not fields = Sptelen mohou bt
funkce nebo tdy, nikoli poloky
     Se tdou v C++ me bt sprtelena jen njak funkce nebo jin tda;
     poloka neme bt friend.

Function call missing ) = Ve voln funkce chyb )
     V seznamu  argument  voln  funkce  se  vyskytla  njak syntaktick
     chyba, jako teba chybjc nebo neprov prav zvorka.

Function calls not supported = Voln funkc nejsou podporovna
     Pi vyhodnocovn vraz v  integrovanm  ladicm  programu  se voln
     funkc   (vetn   implicitnch   pevodnch   funkc,   konstruktor,
     destruktor, pepsanch opertor a funkc inline) nepodporuje.

Function defined  inline  after  use  as  extern  = Funkce se definuje jako
inline, ale byla ji pouita jako extern.
     Funkce  se nemohou stt inline pot, co  ji  byly  pouity.  Definici
     inline bu pemstte v souboru dopedu, nebo ji zcela odstrate.

Function definition cannot be  a  typedef'ed  declaration = Definice funkce
neme bt deklarac typedef
     Deklarace  ukazatel  na   funkce  se  zpehledn  pouitm  deklarac
     typedef.  Ale v jazyku C++ se takovch  typedef  k  definovn  funkc
     pout nesm.

          Napklad zde je typ F funkc bez parametr, poskytujc int:

          typedef int F(void);

          Zde je definovn g jako takov funkce neppustn:



                                  - 268 - 


          F g { /* ... */ }

          Ale je dovoleno mt g jako funkci poskytujc ukazatel na typ F.
            *
          F  g(...) { /* ... */ }

Function function cannot be static = Funkce funkce neme bt statickou
     Jako statick lze deklarovat jenom normln lensk funkce a opertory
     new a  delete. Konstruktory, destruktory a jin opertory statick bt
     nesm.

Function function should have a prototype = Funkce funkce m mt prototyp
     Dolo k voln funkce bez prototypu v oboru.

     V  jazyku  C  nen int foo(); prototypem, ale int foo(int); prototypem
     je, stejn jako int foo(void). V C++ je int foo()  prototypem  a je to
     tot  jako  int  foo(void);.  V  jazyku C jsou prototypy pro  vechny
     funkce doporuen. V C++ se  prototypy pro vechny funkce vyaduj. Ve
     vech ppadech  slou definice funkce (zhlav funkce s jejm tlem)
     jako prototyp, objev-li se ped jakoukoli zmnkou o tto funkci.

Functions cannot return arrays or  functions  =  Funkce  nemohou poskytovat
pole nebo funkce
     Tato  funkce  byla  deklarovna  aby  msto  ukazatele  na  funkci  i
     ukazatele na prvek pole poskytla pmo funkci nebo pole.

Upozornn
Functions  containing  reserved  word  are  not  expanded  inline =  Funkce
obsahujc vyhraen slovo nelze rozvinout jako inline
     Funkce obsahujc vyhraen slova do, for, while, goto, switch, break,
     continue a case nelze rozvinout jako inline, i kdyby byly  jako inline
     ureny. Takov funkce zstane nadle zcela ppustnou, ale  bude  se s
     n zachzet jako s  obyejnou  statickou  (nikoli globln) funkc. Ve
     vech kompilanch unitech, kde se vol, se objev kopie tto funkce.

Function should return a value = Funkce m poskytnout hodnotu
     Tato funkce byla deklarovna (mon implicitn)  aby  poskytla njakou
     hodnotu. Byl nalezen pkaz nvratu  bez  zskan  hodnoty,  resp. byl
     dosaen  konec  funkce,  ani  by  se pkaz nvratu  nalezl.  Upravte
     funkci,  aby   poskytla  njakou  hodnotu  nebo  ji  zmte  tak,  aby
     poskytovala void.

Upozornn
Function should return a value = Funkce m poskytnout hodnotu
     Ve  zdrojovm  souboru  jste  deklarovali  aktuln  funkci  tak,  aby
     poskytla njak typ rzn od int i void, ale  kompiltor  narazil  na
     nvrat  bez   hodnoty.  Obvykle  jde  o  njak  druh  chyby.  Vjimku
     pedstavuj funkce  int, nebo ve starch verzch jazyka C neexistoval
     typ void, kter oznauje funkce, je neposkytuj nic.

Functions  may  not  be  part  of  a struct or union = Funkce  nesmj  bt
soust struktury ani unionu
     Tato  poloka  ve  struct nebo v union byla v C deklarovna msto jako
     ukazatel  na  funkci  pmo  jako  typ funkce. Funkce se jako  poloky
     pipout jenom v C++.

Global anonymous union not static = Globln anonymn union nen statick
     V C++ globln anonymn union na rovni souboru mus bt statick.

Goto statement missing label = Pkaz goto postrd nvt


                                  - 269 - 


     Za klovm slovem goto mus nsledovat njak identifiktor.

Group overflowed maximum size: name = Skupina peplnila maximln velikost:
nzev
     Celkov  velikost  segment  ve  skupin (napklad DGROUP) pekroila
     64K.

Upozornn
Hexadecimal  value  contains  more than 3 digits  =  Hexadecimln  hodnota
obsahuje vce ne 3 slice
     Ve   starch   verzch  jazyka  C   nemohly   hexadecimln   zmnov
     posloupnosti  obsahovat  vce  neli  ti  slice.  Nov  norma  ANSI
     pipout vskyt libovolnho  potu  slic, dokud se hodnota vejde do
     bytu. K  tomoto  upozornn  dojde,  kdy  mte  njakou hexadecimln
     zmnovou posloupnost s adou potench nul  (jako  teba "\x00045").
     Star verze jazyka C budou takov etzec interpretovat odlin.

Identifier  identifier  cannot  have  a  type  qualifier   =  Identifiktor
identifiktor neme mt kvalifiktor typu
     Nen zde mono aplikovat kvalifiktor tda::identifiktor jazyka C++.
     Kvalifiktory se nepipout u  nzv  typedef,  u deklarac funkc (s
     vjimkou definic  na  rovni  souboru),  u  loklnch  promnnch nebo
     parametr funkc nebo  u  len  td  s vjimkou ppad, kdy se jako
     kvalifiktoru pouije  jejich  vlastn  tdy  (co  je  zbyten, ale
     ppustn).

Identifier expected = Zde se oekv identifiktor
     Zde se oekval identifiktor, ale nebyl nalezen. V jazyku  C  k  tomu
     dochz  v  seznamu  parametr  v  zhlav funkce ve starm stylu,  po
     vyhraench slovech struct a union kdy chyb sloen zvorky, jako i
     u nzv poloek ve struktue  nebo unionu (s vjimkou bitovch poloek
     ky  0).  V  jazyku C++ se  identifiktor  oekv  tak  v  seznamu
     bzovch  td,  z  nj se odvozuje dal tda, po dvojit dvojtece
     (::) a po vyhraenm slov operator kdy chyb symbol opertoru.

If statement missing ( = V pkazu if chyb (
     V pkazu if nenalezl  kompiltor  po  klovm  slov if dnou levou
     zvorku.

If statement missing ) = V pkazu if chyb )
     V pkazu if nenalezl  kompiltor  po  testovacm vrazu dnou pravou
     zvorku.

Illegal character character (0xvalue) = Neppustn znak znak (0xhodnota)
     Kompiltor  narazil  ve  vstupnm  souboru  na  njak  neplatn znak.
     Zobraz se hexadecimln hodnota  tohoto  chybnho  znaku. Me k tomu
     dojt  i  pi  pedn  nadbytench  parametr   do   njak  funkn
     makroinstrukce.

Illegal initialization = Neppustn inicializace
     Inicializace mus bt bu  konstantnmi  vrazy,  nebo  adresou njak
     globln promnn extern i static plus nebo minus njak konstanta.

Illegal octal digit = Neppustn oktalov slice
     Kompiltor nalezl oktalovou konstantu obsahujc  njakou ne-oktalovou
     slici (8 nebo 9).

Illegal pointer subtraction = Neppustn odtn ukazatele
     Je to zpsobeno pokusem o odeten ukazatele od ne-ukazatele.



                                  - 270 - 


Illegal structure operation = Neppustn operace se strukturou
     Struktury  lze  pouvat  jenom s opertory teka (.), adresa (&) nebo
     dosazen (=), resp.  je  lze  pedvat  nebo  pebrat  z  funkc jako
     parametry. Kompiltor  narazil  na  strukturu,  kter  bylo  pouito s
     njakm jinm opertorem.

Illegal to take address of bit field = Je neppustn brt si adresu bitov
poloky
     Je neppustn brt si adresu bitov poloky, akoli  lze  brt adresy
     poloek jinho druhu.

Illegal use of floating point = Neppustn pouit pohybliv teky
     V opertorech  posunu,  bitov  logiky,  podmnnch  (?:),  nepmho
                *
     adresovn( )  a  nkterch  jinch  nejsou  ppustn  operandy  typu
     pohybliv teky.  Kompiltor  nalezl  operand  s  pohyblivou  tekou s
     jednm ze zakzanch opertor.

Illegal use of pointer = Neppustn pouit ukazatele
     Ukazatel  lze  pouvat  jenom  pi  stn,  odtn,  dosazovn,
                                     *
     porovnn, nepmm adresovn ( ) nebo ipce (->). Ve zdrojovm textu
     jste pouili ukazatele s nkterm jinm opertorem.

Upozornn
Ill-formed pragma = patn sestaven direktiva pragma
     Pragma neodpovd dnmu tvaru, kter kompiltor Turbo C++ oekv.

Improper use of typedef identifier = Nevhodn pouit typedef identifiktor
     Ve zdrojovm souboru jste  pouili  symbolu typedef v mst, kde se ve
     vrazu mla objevit njak promnn. Pekontrolujte deklaraci takovho
     symbolu a ppadn zkomolen.

Improper use of a typedef symbol = Nevhodn pouit symbolu typedef
     Ve zdrojovm souboru jste  pouili  symbolu typedef v mst, kde se ve
     vrazu mla objevit njak promnn. Pekontrolujte deklaraci takovho
     symbolu a ppadn zkomolen.

Incompatible type conversion = Nekompatibiln pevod typ
     Poadovan uren nen mon.

Incorrect  command-line option: option = Nesprvn alternativa  pkazovho
dku: alternativa
     Kompiltor nerozeznal parametr pkazovho dku jako ppustn.

Incorrect  configuration  file   option:  option  =  Nesprvn  alternativa
konfiguranho souboru: alternativa
     Kompiltor nerozeznal parametr konfiguranho souboru  jako ppustn;
     zkontrolujte poten pomlku (-).

Incorrect number format = Nesprvn formt sla
     Kompiltor narazil v hexadecimlnm sle na desetinnou teku.

Incorrect use of default = Nesprvn pouit default
     Kompiltor po klovm slov default nenalezl dnou dvojteku.

Upozornn
Initialization is only partially bracketed = Inicializace je jenom sten
uzvorkovna



                                  - 271 - 


     Pi  inicializaci  struktur  lze   pout   k   oznaen  inicializace
     jednotlivch len struktury sloench zvorek. Je-li  sm  len polem
     nebo strukturou, lze pout vnoench dvojic sloench zvorek. Tm se
     zajist, aby vae pedstava o tom, jak hodnota  pat  ktermu lenu,
     byla shodn s pedstavou, kterou m kompiltor. Vynechte-li nkter z
     nepovinnch sloench zvorek, kompiltor vyd toto upozornn.

Upozornn
Initializing   identifier   with   type   =   Inicializace   identifiktoru
identifiktor typem typ
     Pokoute se inicializovat promnnou enum na odlin typ. Jde o chybu,
     ale je omezena na upozornn, aby ml existujc program pleitost k
     innosti. Napklad

     enum pocet { nula, jeden, dva } x = 2;

          povede k tomuto upozornn,  protoe  2 je typu int a nikoli enum
     pocet. Je prakticky vhodnj pi dosazovn  nebo  inicializaci typ
     enum pouvat namsto celoselnch literl identifiktor enum.

Inline assembly not allowed in an  inline  function = Ve funkci inline nen
ppustn vestavn peklad
     Kompiltor nedoke  oetit vestavn peklad ve funkci inline v C++.
     Mete z n uinit makroinstrukci, odstranit  pam؟ovou  tdu inline,
     resp. odstranit kd vestavnho asembleru.

Invalid indirection = Nepm adresovn je neplatn
                                      *
     Opertor  nepmho  adresovn ( ) vyaduje  jako  operand  ukazatel,
     kter nen void.

Invalid   macro   argument  separator  =   Neplatn   oddlova   argument
makroinstrukce
     V  definici  makroinstrukce   se  mus  argumenty  oddlovat  rkami.
     Kompiltor narazil po njakm nzvu argumentu na jin znak.

Invalid pointer addition = Neplatn stn ukazatel
     Ve zdrojovm souboru se pokoute sest dva ukazatele.

Invalid use of dot = Neplatn pouit teky
     Za opertorem teka (.) mus ihned nsledovat identifiktor.

Zvan chyba
Irreducible expression tree = Neeiteln vrazov struktura
     Jedn se o pznak  njak  formy  chyby  kompiltoru. Njak vraz na
     oznaenm dku zdrojovho souboru zpsobil,  e  genertor  kdu nen
     schopen  kd  generovat.  A se jedn o jakkoli vraz, je teba se mu
     vyhnout. Pokud  kompiltor takovou chybu nalezne, uvdomte o tom firmu
     Borland.

Items of type type need constructors and can't be passed  with  ... = Prvky
typu typ potebuj konstruktory a nelze je pedvat s ...
     Je  neppustn  pedvat  objekt  typu  vyadujcho  konstruktor  do
     promnnho seznamu argument (urenho ...).

Left side must be a structure = Lev strana mus bt strukturou
     Lev strana opertoru teka (.) (nebo v C++ opertoru teka-hvzdika)
     se mus vyhodnotit  jako  typ  struktura.  V  tomto  ppad  tomu tak
     nebylo.



                                  - 272 - 


Linkage specification not allowed = Specifikace pipojovn nen dovolena
     Specifikace pipojovn, jako teba extern "C", jsou dovoleny jenom na
     rovni souboru. Pemstte tuto deklaraci funkce na rove souboru.

Lvalue required = Vyaduje se l-hodnota
     Lev strana opertoru dosazen mus bt adresovatelnm  vrazem. Pat
     sem seln nebo ukazatelov promnn, odkazy na poloky struktur nebo
     nepm  adresovn prostednictvm ukazatele, resp. indexovan  prvek
     pole.

Macro argument syntax error = Syntaktick chyba argumentu makroinstrukce
     Argument  v   definici   makroinstrukce   mus   bt  identifiktorem.
     Kompiltor narazil v mst, kde se oekv argument,  na  njak znak,
     jen identifiktorem nen.

Macro expansion too long = Rozvoj makroinstrukce je pli dlouh
     Makroinstrukce se neme rozvinout na vce ne 4096 znak.

May compile only one file when an output file name is  given  =  Pi zadn
nzvu vstupnho souboru lze kompilovat jenom jeden soubor
     Zadali jste alternativu pkazovho  dku  -o,  kter  povoluje jenom
     jedin nzev vstupnho souboru. Prvn soubor  se  zkompiluje, zatmco
     ostatn se ignoruj.

Member member is initialized more than once = len  len  je  inicializovn
vce ne jednou
     V konstruktoru tdy v  C++  obsahuje  seznam inicializac za zhlavm
     konstruktoru vcekrt stejnou poloku.

Member functions can only have static storage class = lensk  funkce mohou
mt jenom statickou pam؟ovou tdu
     Jedinou pam؟ovou tdou, kter je  dovolena  pro  lensk  funkce, je
     pam؟ov tda statick.

Misplaced break = patn umstn pkaz break
     Kompiltor narazil  na  pkaz  break  mimo  pepna  nebo konstrukci
     cyklu.

Misplaced continue = patn umstn pkaz continue
     Kompiltor narazil na pkaz continue mimo konstrukci cyklu.

Misplaced decimal point = patn umstn desetinn teka
     Kompiltor narazil v konstant s pohyblivou tekou na desetinnou teku
     jako soust exponentu.

Misplaced elif directive = patn umstn direktiva elif
     Kompiltor narazil na direktivu  #elif,  ke  kter  chyb odpovdajc
     direktiva #if, #ifdef nebo #ifndef.

Misplaced else = patn umstn pkaz else
     Kompiltor narazil  na  pkaz  else  bez  odpovdajcho  pkazu if.
     Takov hlen by mohl zpsobit i njak pebyten pkaz else  , ale
     me je zpsobit  i  nadbyten stednk, chybjc sloen zvorky i
     njak syntaktick chyba v pedchozm pkazu if.

Misplaced else directive = patn umstn direktiva else
     Kompiltor narazil na direktivu #else bez odpovdajc  direktivy #if,
     #ifdef nebo #ifndef.

Misplaced endif directive = patn umstn direktiva endif


                                  - 273 - 


     Kompiltor narazil na direktivu #endif bez odpovdajc direktivy #if,
     #ifdef nebo #ifndef.

Upozornn
Mixing  pointers  to  signed and unsigned char = Smovn ukazatel signed
char a unsigned char
     Pevedli jste ukazatel  char  na ukazatel unsigned char, resp. naopak,
     ani  byste  pouili  explicitn  uren  typu.  (Psn  vzato je  to
     nesprvn, ale u procesoru 8086 jde asto o nekodnou vc.)

Multiple base classes require explicit  class  names  =  Vcensobn bzov
tdy vyaduj explicitn nzvy td
     Pokud  existuje  vce  ne jedna bezprostedn bzov  tda,  mus  v
     konstruktoru  tdy v C++ kad voln  konstruktoru  bzov  tdy  v
     zhlav konstruktoru obsahovat nzev bzov tdy.

Multiple declaration  for  identifier  =  Identifiktor  identifiktor  byl
deklarovn vcekrt
     Tento identifiktor byl nesprvn deklarovn vce ne jednou. Mohly to
     zpsobit vzjemn si odporujc  deklarace,  jako  teba int a; double
     a;, funkce deklarovan dvma  rznmi  zpsoby  i opakovan nvt v
     te funkci, resp. njak opakovan deklarace jin neli funkce extern
     i jednoduch promnn.

Multiple scope qualifiers = Vcensobn kvalifiktory oboru
     Tento  identifiktor v C++ byl kvalifikovn  vce  ne  jednm  nzvem
     tdy; identifiktor sm kvalifikovat nejve jedna tda.

Must take address of a memory location = Mus obdret adresu njakho msta
v pamti
     Zdrojov soubor uv adresovho opertoru  (&)  s  vrazem,  kter se
     takto pout nesm; napklad s registrovou promnnou.

Need an identifier to declare = K deklaraci je zapoteb identifiktoru
     Zde se pro  ukonen  deklarace oekval njak identifiktor. Me to
     bt  typedef  bez  nzvu,  i  njak  nadbyten  stednk na  rovni
     souboru. V C++ me jt o nesprvn pouit nzev tdy coby jin druh
     identifiktoru.

'new' and 'delete' not supported = new a delete nejsou podporovny
     Pi  vyhodnocovn  vrazu  v  integrovanm  ladicm  programu  nejsou
     opertory new a delete podporovny.

No : following the ? = Za ? chyb :
     V tomto vrazu si neodpovdaj  opertory otaznk (?) a dvojteka (:).
     Me  jt  o  chybjc  dvojteku  nebo zvorky mohou  bt  nesprvn
     vnoeny i chybt.

No base class to initialize = K inicializaci chyb bzov tda
     Tento konstruktor  tdy v C++ se pokou implicitn volat konstruktor
     bzov tdy, avak  takov  tda byla deklarovna bez td bzovch.
     Zkontrolujte si deklarace.

No  body  defined  for this inline function = Pro tuto funkci inline nebylo
definovno dn tlo
     Tato funkce v C++ je deklarovna jako inline, ale  neexistuje  pro  ni
     dn  viditeln  tlo.  Tlo  funkce  inline se obvykle  umsuje  do
     stejnho souboru zhlav jako deklarace  funkce, a ji jde o lenskou
     funkci nebo o obyejnou funkci inline.



                                  - 274 - 


No constructor parameters allowed for array  of  class = V poli td nejsou
ppustn dn parametry konstruktoru
     Kdy deklarujete njak pole td v C++, nelze  do  konstruktoru tdy
     pedat dn parametry.  Ke  konstrukci kadho prvku takovho pole je
     nutno pout konstruktor,  kter dn parametry nepebr (implicitn
     konstruktor).

Upozornn
No declaration for function function = Chyb deklarace funkce funkce
     Toto  hlen  se  poskytne v ppad, kdy volte njakou funkci, ani
     byste  ji  pedem  deklarovali. V jazyku C lze funkci deklarovat, ani
     byste uvedli jej prototyp,  jako  teba "int func(),". V C++ je kad
     deklarace   funkce   rovnا   jejm   prototypem;  een  pklad  je
     ekvivalentem  "int  func(void),".  Deklarace  me  bt  jak  ve stylu
     klasickm, tak i ve stylu modernm (prototyp).

No file name ending = Chyb zakonen nzvu souboru
     Nzev souboru v pkazu #include postrdal sprvnou  koncovou uvozovku
     nebo lomenou zvorku.

No file names given = Nejsou udny dn nzvy soubor
     V pkazovm dku v kompiltoru s pkazovm dkem  Turbo  C++ (TCC)
     nebyly obsaeny dn  nzvy  soubor. Je teba urit nzev zdrojovho
     souboru.

No matching ) = Chyb odpovdajc )
     K   lev  zvorce  chyb  odpovdajc  zvorka  prav.   Zkontrolujte
     vyvenost zvorek v tomto vrazu.

Upozornn
Non-const function function called for const object = Pro konstantn objekt
se vol nekonstantn funkce funkce
     lensk funkce, kter nen const, se vol na objekt,  jen  je  const.
     Jde o chybu, ale je omezena na upozornn, aby ml  existujc program
     pleitost k innosti.

Upozornn
Nonportable pointer comparison = Nepenosn porovnn ukazatele
     Ve zdrojovm souboru porovnvte ukazatel  s  ne-ukazatelem  rznm od
     konstantn nuly. Je-li  takov  porovnn  na  mst,  pouijte uren
     typu, m toto upozornn potlate.

Nonportable pointer conversion = Nepenosn pevod ukazatel
     Vyaduje se implicitn pevod mezi  ukazatelem  a  celoselnm typem,
     ale  tyto  typy   nemaj   stejnou  velikost.  Nelze  tak  uinit  bez
     explicitnho  uren.  Je  mon , e takov pevod nem dn vznam,
     proto se ujistte, zdali se jedn o to, co opravdu zamlte.

Upozornn
Nonportable pointer conversion = Nepenosn pevod ukazatele
     Pouit nenulov  celoseln hodnoty na mst, kde je teba ukazatele
     i   njak  celoseln  hodnoty.  Velikosti  celoselnho  typu   i
     ukazatele jsou shodn. Jde-li o skuten zmr, pouijte uren typu.

Non-virtual function  function declared pure = Nevirtuln funkce funkce je
deklarovna jako ist
     Jako ist lze deklarovat jenom funkce virtuln, nebo odvozen tdy
     je mus bt schopny pedefinovat.

Not an allowed type = Nejde o ppustn typ


                                  - 275 - 


     Ve zdrojovm souboru jste deklarovali njak  zakzan  typ; napklad
     funkci poskytujc funkci nebo pole.

Not a valid expression format type = Nejde o platn typ formtu vrazu
     Ve vyhodnocovacm  nebo sledovacm okn byl za vrazem uveden neplatn
     specifiktor  formtu. Platnm formtovm specifiktorem je  nepovinn
     hodnota opakovn, za n nsleduje znak formtu (c, d, f[n], h, x, m,
     p, r, nebo s).

No type information = Chyb informace o typu
     Pro tuto promnnou nem ladic  program dnou informaci o typu. Mon
     dolo  ke  kompilaci  modulu  bez  zapnutho  pepnae  ladn,  nebo
     kompilaci vykonal jin kompiltor nebo asembler.

Numeric constant too large = seln konstanta je pli velk
     Nelze generovat etzcov nebo znakov zmnov posloupnosti  vt ne
     \xFF hexadecimln, resp.  \377 oktalov. Dvoubytov znakov konstanty
     lze specifikovat pouitm druhho zptnho lomtka. Napklad \x0D\x0A
     pedstavuje  dvoubytovou konstantu.  seln  literl  nsledujc  po
     zmnov posloupnosti je vhodn rozloit takto:

          printf("\x0D" "12345");

          Vype se tm nvrat vozku a po nm 12345.

Object must be initialized = Objekt je teba inicializovat
     Tento objekt v C++ je  deklarovn jako const, nen vak inicializovn.
     Jeliko do nj nelze dnou  hodnotu dosadit, mus bt inicializovn v
     okamiku deklarace.

Upozornn
Obsolete syntax; use :: instead = Zastaral syntax; pouijte radji ::
     V dvjch verzch C++ se  v deklaracch nebo definicch pouvalo k
     oddlen nzvu lenu od nzvu jeho tdy teky (.) nebo dvojteky (:).
     To je ji zastaral a je nutno pouvat dvojitou dvojteku (::).

          Star zpsob:

          void mojetrida.func(int i) { /* ... */ }

          Nov zpsob:

          void mojetrida::func(int i) { /* ... */ }

Only  one of a set of overloaded functions can be function = Jenom jedna  z
mnoiny pepsanch funkc sm bt funkce
     Funkce  v C++ se implicitn pepisuj  a  kompiltor  piazuje  kad
     funkci nov nzev. Pejete-li si piazovn novho nzvu kompiltorem
     pedefinovat deklarac funkce  funkce,  mete  tak  uinit  jenom pro
     jedinou  z mnoiny funkc se stejnm nzvem.  (V  opanm  ppad  by
     spojovac program  nalezl  vce  ne  jednu  globln  funkci stejnho
     nzvu.)

Operand expected = Oekv se operand
     Pi  vyhodnocovn  aktulnho  vrazu  kompiltor   vyerpal  vechny
     operandy, ani by pouil vech opertor. Podvejte se, zda neexistuj
                                               *
     njak nadbyten symboly opertor  (+,   ,  /  atd.), i zda nechyb
     nzvy promnnch.



                                  - 276 - 


Operands  are  of  differing or incompatible type = Operandy jsou odlinho
nebo nekompatibilnho typu
     Levou a pravou stranu binrnho opertoru (+, /, == atd.)  nelze tmto
     zpsobem kombinovat.

Operator [] missing ] = V opertorov funkci operator[] chyb ]
     Opertorov funkce v C++ operator[] byla  deklarovna  jako operator[.
     Muste pidat chybjc ] nebo tuto deklaraci zajistit jinak.

operator  ->  must return a pointer or a class = Funkce  operator  ->  mus
poskytnout ukazatel nebo tdu
     Funkce v C++ operator -> mus bt deklarovna tak,  aby  bu  poskytla
     tdu nebo ukazatel na class (nebo struct i union). V  kadm ppad
     mus jt o nco, na co lze aplikovat opertor ->.

Operator  cannot  be  applied  to  these  operand  types =  Opertor  nelze
aplikovat na takov typy operand
     Lev nebo prav  strana  binrnho  opertoru  (+,  -,  ==  atd.) nen
     platnm typem  pro tento opertor; mon napklad zkoute sest dv
     pole.

operator delete must return void = Opertor operator delete mus poskytnout
void
     Tento pepsan operator delete v C++ byl deklarovn njak jinak.

operator new must have an initial  parameter  of type size_t = Opertor new
mus mt njak poten parametr typu size_t
     Opertor new lze  deklarovat  s libovolnm potem parametr. Vdy mus
     vak mt alespo jeden, kter  pedstavuje rozsah prostoru, jen se m
     piadit.
                                                   *
operator new must return an  object  of  type  void   =  Opertor  new mus
                           *
poskytnout objekt typu void
     Tento pepsan operator new v C++ byl deklarovn njak jinak.

Other  objects cannot be declared in a function  definition  =  V  definici
funkce nelze deklarovat dn jin objekty
     Za  tlem funkce neme nsledovat rka, aby  se  k  seznamu  pidaly
     dal deklarace.

          Napklad

          int f(), j;   /* deklarace f, rka OK, j deklarovno jako int */
          int f() { return 0;}, j; /* zde je f definovna, rka nepp. */

Upozornn
overload  is  now  unnecessary  and  obsolete  =  Slova overload  te  nen
zapoteb a je ji zastaral
     V  dvjch  verzch  C++  se  k  oznaen  mzv pepsanch  funkc
     vyadovalo vyhraen slovo  overload.  Jazyk  C++  nyn  pracuje podle
     schmatu "spojovn  se  zabezpeenm  typ",  kde  se  vechny funkce
     povauj za pepsan, nejsou-li  oznaeny  jinak.  Slova  overload ji
     nepouvejte.

Zvan chyba
Out of memory = Nedostatek pamti
     Dolo  k  vyerpn  celkov  pracovn  pamti.  Kompilujte  soubor na
     potai  s vt pamt. Mte-li ji  640K,  muste  zdrojov  soubor
     zjednoduit.


                                  - 277 - 


Overlays only supported in  medium,  large an huge memory models = Pekryvy
jsou  podporovny  pouze  ve  stednch,  velkch  a  rozshlch pam؟ovch
modelech
     Jak  jsme  vysvtlili  v  Kapitole  7., lze pekrvat  jenom  programy
     pouvajc stednch, velkch nebo rozshlch pam؟ovch model.

Overloadable operator expected = Oekv se pepsateln opertor
     Tm vechny  opertory v C++ lze pepisovat. Jedinmi, kter pepsat
                                                                *
     nelze, jsou teka pro vbr poloky (.), teka-hvzdika (. ), dvojit
     dvojteka (::) a podmnn vraz (?:). Opertory preprocesoru (# a ##)
     nejsou  opertory  z  jazyka C ani C++ a proto je pepsat nelze. Nelze
     samozejm  pepsat  ani  jin  neopertorov interpunkn znaky, jako
     teba stednk (;).

Overloaded function resolution not supported = Rozlien  pepsanch funkc
se nepodporuje
     Pi   vyhodnocovn   vraz   v   integrovanm  ladicm  programu  se
     nepodporuje rozlien pepsanch funkc  nebo  opertor,  dokonce ani
     pro pevzet adresy.

Upozornn
Parameter parameter is not used = Parametru parametr se nepouv
     Uvedenho parametru, kter je  deklarovn  ve  funkci,  se v tle tto
     funkce vbec nepouv. Me, ale nemus jt o chybu a  pinou asto
     bv  zkomolen  tohoto  parametru.  Toto  upozornn  se  rovnا me
     objevit,  jestlie  se  uveden  identifiktor  v  tle  funkce  znovu
     deklaruje  jako  automatick   (lokln)  promnn.  Parametr  se  pak
     zamaskuje automatickou promnnou a zstane nepouit.

Parameter parameter missing name = Parametr parametr postrd nzev
     V  zhlav  definice  funkce  pozstval  tento   parametr   jenom  ze
     specifiktoru typu bez nzvu parametru.  V jazyku C to nen ppustn.
     (V jazyku C++ je to dovoleno,  ale  ve  funkci nen mono se na takov
     parametr odkazovat.)

Parameter names are used only with a function  body  =  Nzvy  parametr se
pouvaj jenom s tlem funkce
     Pi deklaraci funkce (nikoli pi jejm definovn s  tlem  funkce) je
     nutno pout bu  przdnch  zvorek  nebo  prototypu  funkce. Samotn
     seznam nzv parametr nen dovolen.

          K ukzkovm deklaracm pat:

          int func();                    /* deklarace bez prototypu - OK */
          int func(int, int);             /* deklarace s prototypem - OK */
          int func(int i, int j);    /* nzvy parametr v prototypu - OK */
          int func(i, j);               /* pouze nzvy parametr - nelze */

Pointer  required  on  left  side  of  -> = Na lev stran ->  se  vyaduje
ukazatel
     Na lev stran ipky (->) se vyaduje vhradn ukazatel.

Upozornn
Possible  use  of  identifier   before   definition   =   Ppadn  pouit
identifiktoru identifiktor ped jeho definic
     Ve  zdrojovm souboru se pouv uveden  promnn  v  njakm  vrazu
     jet dve, nا j byla piazena hodnota. Ke zjitn takov situace
     vykonv kompiltor jenom jednoduchou prohldku  programu. Vyskytne-li
     se pouit njak promnn fyzicky ped vekermi  dosazenmi, vznikne


                                  - 278 - 


     toto upozornn. Pi skutenm prbhu programu se  samozejm hodnota
     me dosadit jet pedtm, ne j program pouije.

Upozornn
Possibly incorrect assignment = Pravdpodobn nesprvn dosazen
     K   tomuto   upozornn   dojde,   naraz-li  kompiltor  na  opertor
     dosazovn,  kter je hlavnm opertorem njakho podmnnho  pkazu
     (tj. st pkau if, while nebo do-while). Vtinou se toti  jedn o
     typografickou  chybu opertoru  rovnosti.  Chcete-li  toto  upozornn
     potlait, uzavete dosazovn do zvorek a porovnejte  explicitn cel
     vraz s nulou. Tedy

          if (a = b) ...

          pepite jako

          if ((a = b) != 0) ...

Previously  specified  default  argument value cannot be  changed  =  Nelze
zmnit pedchoz urenou implicitn hodnotu argumentu
     Kdy je njak parametr funkce v C++ deklarovn s implicitn hodnotou,
     nelze  v  dn  jin  deklaraci  te funkce tuto hodnotu zmnit  ani
     vynechat.

Upozornn
Program flow can skip  this  initialization; try using {} = Prbh programu
me tuto inicializaci peskoit; zkuste pout {}
     Inicializace tto promnn je  ovldna  pkazem  if  a tud se me
     peskoit. Pro zen  oboru  tto promnn je mon zapoteb uzavt
     blok do sloench zvorek.

Pure function function not overriden in  class  = Ve td tda nen ist
funkce funkce pedefinovna
     V odvozench tdch  se  mus ist virtuln funkce bu pedefinovat
     (udnm nov deklarace), nebo znovu deklarovat jako ist.

Upozornn
Redefinition of macro  is  not identical = Optovn definice makroinstrukce
nen identick
     Ve zdrojovm souboru jste uvedenou makroinstrukci  definovali  znovu s
     pouitm  textu,  kter  nebyl pesn toton s  prvn  definic  tto
     makroinstrukce. Star text se nahrad novm.

Reference  member member is not initialized =  Referenn  len  len  nen
inicializovn
     Odkazy je vdy nutno inicializovat. lenu tdy typu  odkaz  muste ve
     vech konstrukcch tto tdy poskytnout njak inicializtor. Znamen
     to, e se nemete spolehnout na kompiltor, aby generoval pro takovou
     tdu konstruktory. Ten toti nem monost se dovdt, jak tento odkaz
     inicializovat.

Reference member member  needs  a temporary for initialization = Referenn
len len potebuje pro inicializaci njak doasn objekt
     Uivatel poskytl pro referenn typ njakou  poten  hodnotu, kter
     nebyla l-hodnotou zmnnho typu. To vyaduje, aby kompiltor vytvoil
     pro inicializaci doasn objekt. Jeliko  k  uloen  tohoto doasnho
     objektu nen zejm msto, je tato inicializace neppustn.

Zvan chyba
Register allocation failure = Chyba v pidlovn pamti registru


                                  - 279 - 


     Jedn  se  o  pznak njak formy chyby kompiltoru. Nkter vraz na
     oznaenm dku zdrojovho  souboru  je tak sloit, e genertor kdu
     pro nj nedoke kd generovat. Zjednodute takov vraz. Pokud se tm
     problm nevye, vyhnte se tomuto vrazu.  Pokud  kompiltor takovou
     chybu nalezne, uvdomte o tom firmu Borland.

register  is  the  only storage class allowed = Jedinou povolenou pam؟ovou
tdou je register
     Jedinou pam؟ovou tdou, povolenou pro parametry funkce, je register.

Repeat count needs an lvalue = ta opakovn potebuje l-hodnotu
     V  okn Watch nebo Evaluate mus bt vraz  ped  rkou  (,)  njakou
     manipulovatelnou  oblast pamti.  Nejsou  napklad  dovoleny  vrazy
     jako:

          i++, 10d
          x = y, 10m

Upozornn
Restarting compile using assembly = Kompiluje se znovu s pouitm pekladu
     Kompiltor narazil  na asm bez doprovodn alternativy -B z pkazovho
     dku nebo pkazu #pragma  inline.  Kompilace  zane znovu s vyuitm
     monost jazyka symbolickch adres.
                *                                         *
Right side of  .  is not a member pointer = Prav strana .  nen ukazatelem
na len
                                              *
     Prav strana opertoru teka-hvzdika (. ) v C++ mus bt deklarovna
     jako ukazatel na len tdy uren levou stranou  tohoto  opertoru. V
     danm ppad nen prav strana ukazatelem na len.

Side effects are not allowed = Vedlej efekty nejsou dovoleny
     V okn Watch  nejsou  dovoleny vedlej efekty, jako teba dosazovn,
     ++ nebo --. astou chybou je  pouvn  x = y (neppustn) namsto x
     == y pi ovovn rovnosti x a y.

Size  of  identifier  is   unknown   or   zero  =  Velikost  identifiktoru
identifiktor je neznm nebo nulov
     Tohoto identifiktoru bylo  pouito  v kontextu, kde je zapoteb jeho
     velikosti. Bez udn velikosti lze  deklarovat  jenom  oznaen struct
     (piem struct jet nen definovna),  nebo  pole  extern.  Potom je
     neppustn  se  na  takov  prvek  odkazovat  (jako  sizeof).  Zmte
     deklaraci tak, aby byla k dispozici velikost identifiktoru.

sizeof  may  not  be  applied  to  a bit field = Na bitovou  poloku  nelze
aplikovat sizeof
     sizeof poskytne velikost datovho objektu  v bytech, co se ale netk
     poloek bitovch.

sizeof may not be applied to a function = Na funkci nelze aplikovat sizeof
     sizeof lze aplikovat jenom na  datov  objekty,  nikoli  funkce. Mon
     vyadujete velikost ukazatele na funkci.

Size of the type is unknown or zero = Velikost typu je neznm nebo nulov
     Tohoto  typu   bylo  pouito  v  kontextu,  kde  bylo  zapoteb  jeho
     velikosti.  Pouze  deklarovat  lze  napklad oznaen struct (piem
     struct jet nen definovna). Potom je neppustn se na takov prvek
     odkazovat (jako sizeof) nebo se nepmo odkazovat na ukazatel na tento
     typ. Zmte deklaraci tak, aby byla k dispozici velikost tohoto typu.



                                  - 280 - 


Size of this  expression  is  unknown  or  zero = Velikost tohoto vrazu je
neznm nebo nulov
     Tento vraz obsahoval typ nebo  promnnou, jeho velikost nen znma a
     pitom jej bylo pouito v kontextu, kde bylo zapoteb jeho velikosti.
     Bez udn velikosti  lze  deklarovat  jenom  oznaen  struct (piem
     struct jet  nen definovna), nebo pole extern. Potom je neppustn
     se na takov prvek odkazovat (jako sizeof) nebo  se  nepmo odkazovat
     na ukazatel na tento  typ.  Zmte deklaraci tak, aby byla k dispozici
     velikost tohoto typu.

Statement is required here = Zde se vyaduje pkaz
     Urit sti program v C nebo C++ vyaduj njak pkaz (teba jenom
     stednk); umsuje se mezi nvt a konec bloku, v nm se objev, a
     to po klauzuli if, do, while nebo for.

Statement missing ; = V pkazu chyb ;
     Kompiltor narazil na vrazov pkaz, za kterm chyb stednk.

Storage class storage  class  not  allowed  for  a field = Pro poloku nen
ppustn pam؟ov tda pam؟ov tda
     V jazyku C nen pi deklaraci poloky povolena dn pam؟ov tda. V
     C++ me bt poloka typedef, datov poloka me bt static a funkn
     poloka me bt inline. Nic jinho dovoleno nen.

Storage  class  storage  class not allowed for a function = Pro funkci nen
ppustn pam؟ov tda pam؟ov tda
     V jazyku C  i  v C++ sm bt funkce extern nebo static. V C++ me bt
     funkce inline. Nic jinho dovoleno nen a ptomna sm bt jenom jedna
     pam؟ov tda.

Storage class storage class  is  not allowed here = Pam؟ov tda pam؟ov
tda zde nen ppustn
     Udan pam؟ov tda zde nen ppustn. Pravdpodobn byly ureny dv
     pam؟ov tdy, zatmco lze zadat jenom jednu.

Upozornn
Structure passed by value = Struktura se pedv hodnotou
     Nen-li  upozornn "Structure passed by value" zablokovno,  generuje
     se  vdy, kdy se njak struktura  pedv  jako  argument  hodnotou.
     Programtoi  se  toti  asto  dopoutj  chyby,  e  pi  pedvn
     struktury jako  argumentu vynechaj opertor adresy (&) na ni. Jeliko
     struktury hodnotou pedvat lze, je takov opomenut ppustn. een
     upozornn pedstavuje pro kompiltor monost,  jak  vs  varovat ped
     zmnnou chybou.

Structure size too large = Pli velk struktura
     Ve zdrojovm souboru byla deklarovna struktura vt ne 64K.

Upozornn
Style of function definition is now obsolete = Styl definice funkce  je ji
zastaral
     V C++ je tento star styl definice funkce v jazyku C neppustn:

          int func(p1, p2) int p1, p2; { /* ... */ }

          Tento zpsob nemus  bt  ppustn  ani  v  jinch kompiltorech
     jazyka C++.

Subscripting missing ] = V indexovn chyb ]



                                  - 281 - 


     Kompiltor narazil na indexov vraz,  v  nm  chybla  prav hranat
     zvorka. Mohlo to bt zpsobeno chybjcm nebo nadbytenm opertorem
     nebo neprovmi zvorkami.

Upozornn
Superfluous & with function = U funkce je & nadbyten
     Opertoru adresy (&) nen u  nzvu  funkce  zapoteb;  vechny takov
     opertory se zru.

Upozornn
Suspicious pointer conversion = Podezel pevod ukazatele
     Kompiltor narazil na pevod  ukazatele,  kterm  se zpsob, e tento
     ukazatel bude ukazovat na jin typ. Je-li takov pevod na mst, toto
     upozornn potlate pouitm uren typu.

Switch selection expression  must  be  of  integral type = Vbrov vraz v
pepnai mus bt celoselnho typu
     Vbrov  vraz  v  zvorkch v pkazu switch se mus vyhodnotit jako
     celoseln typ (char, short, int, long, enum). Takovmu poadavku lze
     mon vyhovt explicitnm urenm typu.

Switch statement missing ( = V pkazu switch chyb (
     V pkazu switch  nenalezl  kompiltor po klovm slov switch dnou
     levou zvorku.

Switch statement missing ) = V pkazu switch chyb )
     V pkazu  switch  nenalezl  kompiltor  po  testovacm  vrazu dnou
     pravou zvorku.

Upozornn
Temporary used to initialize  identifier  =  K  inicializaci identifiktoru
identifiktor se pouilo doasnho objektu
Temporary used  for  parameter  number  in  call  to identifier = Ve voln
funkce identifiktor se pro parametr slo pouilo doasnho objektu
Temporary used for parameter parameter in call to identifier  =  Ve  voln
funkce identifiktor se pro parametr parametr pouilo doasnho objektu
Temporary  used  for  parameter number =  Pro  parametr  slo  se  pouilo
doasnho objektu
Temporary used for parameter parameter = Pro parametr  parametr  se pouilo
doasnho objektu
     V C++ plat, e  do  promnn nebo parametru referennho typu se mus
     dosazovat odkaz  na objekt tho typu. Pokud typy vzjemn nesouhlas,
     dosad se skuten hodnota  do  njakho  doasnho  objektu sprvnho
     typu a do referenn promnn nebo parametru se  dosad  adresa tohoto
     doasnho objektu. Upozornn pak znamen, e  referenn  promnn i
     parametr neodkazuje tam,  kam  jste oekvali, ale na njakou doasnou
     promnnou, kter se jinak nepouv.

          Napklad nyn vyaduje funkce f odkaz na int a c je char:

          f(int&);
          char c;
          f(c);

          Namsto  voln  f  s adresou c generuje kompiltor kd, kter je
     ekvivalentn zdrojovmu textu v C++:

          int X = c, f(X);




                                  - 282 - 


The constructor constructor  is  not allowed here = Konstruktor konstruktor
zde nen dovolen
     Konstruktory  tvaru X::(X) nejsou dovoleny. Koprovac konstruktor  se
     sprvn zape jako X::(const X&).

'this' can only be used within  a  member  function = Slova this lze pout
jenom ve lensk funkci
     V jazyku C++ je this vyhraenm slovem, kterho lze  pout  jenom  ve
     lenskch funkcch td.

Too few parameters in call to  function  =  Ve voln funkce je pli mlo
parametr
     Voln uveden funkce (deklarovan uitm prototypu) mlo  pli mlo
     parametr.

Too many decimal points = Pli mnoho desetinnch teek
     Kompiltor narazil na konstantu v pohybliv tece, kter mla vce ne
     jedinou desetinnou teku.

Too many default cases = Pli mnoho ppad default
     Kompiltor  nalezl  v  jedinm pkazu switch vce  ne  jeden  pkaz
     default.

Too  many  error  or  warning   messages  =  Pli  mnoho  chybovch  nebo
vstranch hlen
     Po 255 chybovch nebo vstranch hlench se kompiltor zastav.

Too many eexponents = Pli mnoho exponent
     Kompiltor  nalezl v konstant s pohyblivou  tekou  vce  ne  jedin
     exponent.

Too many initializers = Pli mnoho inicializtor
     Kompiltor nalezl  vce  inicializtor,  ne  bylo  v  inicializovan
     deklaraci dovoleno.

Too many  storage  classes  in  declaration  =  V deklaraci je pli mnoho
pam؟ovch td
     V deklaraci nesm bt nikdy vce ne jedin pam؟ov tda.

Too many types in declaration = V deklaraci je pli mnoho typ
     V deklaraci nesm bt nikdy vce ne jedin ze zkladnch  typ: char,
     int, float, double, struct, union, enum nebo typedef-nzev.

Too much global data defined in file = V souboru je definovno pli mnoho
globlnch dat
     Souet deklarac globlnch dat  pevyuje  64K  byt.  Zkontrolujte v
     deklaracch, jestli tam nen njak pole pli velk. Je-li zapoteb
     vech  deklarac,  zvate  tak  reorganizaci  programu  nebo  pouit
     promnnch far.

Trying to derive a far  class from a near base = Pokus o odvozen tdy far
z bze near
     Je-li bze deklarovna (nebo implicitn stanovena) jako near, mus bt
     vechny odvozen tdy rovnا near.

Trying to derive a near class from a far base = Pokus o odvozen tdy near
z bze far
     Je-li bze  deklarovna (nebo implicitn stanovena) jako far, mus bt
     vechny odvozen tdy rovnا far.



                                  - 283 - 


Two consecutive dots = Dv teky za sebou
     Jeliko  vpustka  obsahuje  ti teky (...) a  desetinn  teka  nebo
     opertor pro vbr lenu pouv teky jedin, neexistuje v programu v
     jazyku  C  dn  monost povolenho vskytu dvou  za  sebou  jdoucch
     teek.

Two  operands  must evaluate to the same type = Oba dva  operandy  se  mus
vyhodnotit na stejn typ
     Typy vraz  na obou stranch dvojteky v opertoru podmnnho vrazu
     (?:) mus bt stejn. Vjimkou jsou obvykl pevody, jako char  na int
                                          *
     nebo  float  na  double,  resp.  void  na konkrtn ukazatel. V  tomto
     vrazu  se   ob  strany  vyhodnocuj  jako  odlin  typy,  kter  se
     automaticky nepevd. Teba jde o chybu anebo bude stait jenom urit
     typ jedn strany jako typ strany druh.

Type mismatch in parameter number = Nesoulad v typu parametru slo
     Funkce volan prostednictvm ukazatele na funkci  byla  deklarovna s
     prototypem.  Parametr udanho sla (pot se  od  1  zleva  doprava)
     nebylo mono pevst na deklarovan typ parametru.

Type mismatch in parameter number in call to  function  =  Nesoulad  v typu
parametru slo ve voln funkce
     Ve zdrojovm souboru byla  deklarovna  uveden  funkce s prototypem a
     parametr udanho sla (pot  se  od  1  zleva doprava) nebylo mono
     pevst na deklarovan typ parametru.

Type mismatch in parameter parameter = Nesoulad v typu parametru parametr
     Ve zdrojovm souboru byla  deklarovna  funkce  volan prostednictvm
     ukazatele  na  funkci  s prototypem a uveden  parametr  nebylo  mono
     pevst na deklarovan typ parametru.

Type mismatch in parameter parameter in call to function = Nesoulad  v typu
parametru parametr ve voln funkce
     Ve zdrojovm souboru byla  deklarovna  uveden  funkce s prototypem a
     uveden parametr nebylo mono pevst na deklarovan typ parametru.

Type  mismatch  in  redeclaration of identifier = Nesoulad typu v opakovan
deklaraci identifiktoru
     Ve  zdrojovm  souboru  byla  optovn  deklarovna  promnn  s typem
     odlinm, ne jak byl pro tuto promnnou deklarovn  pvodn.  Me k
     tomu  dojt,  volte-li  funkci  a  nsledn  ji  deklarujete  takovm
     zpsobem, aby poskytla nco jinho neli cel slo.  Je-li  tomu tak,
     muste funkci deklarovat jet ped jejm prvnm volnm.

Type name expected = Oekv se nzev typu
     Nastala jedna z tchto chyb:

         o  V deklaraci promnn na rovni soubor nebo poloky struct nebyl
            udn ani nzev, ani pam؟ov tda.

         o  V deklaraci typedef nebyl udn pro nzev dn typ.

         o  V deklaraci destruktoru pro tdu v C++ nebyl nzev destruktoru
            shodn s nzvem typu (mus bt stejnho nzvu jako jeho tda).

         o  V zadn nzvu bzov  tdy  v C++ nebyl nzev shodn s nzvem
            tdy.




                                  - 284 - 


Type qualifier identifier  must  be  a  struct or class name = Kvalifiktor
typu identifiktor mus bt nzvem struktury nebo tdy
     Kvalifiktor v konstrukci kval::identifiktor v C++ nen nzvem struct
     nebo class.

Unable  to create output file filename =  Nelze  vytvoit  vstupn  soubor
nzev souboru
     K tto chyb dochz,  je-li  pracovn  disk  pln nebo chrnn proti
     zpisu.  Je-li disk pln, zkuste nepotebn  soubory  zruit  a  znovu
     spuste  kompilaci.  Je-li  disk  chrnn  proti  zpisu,  pemstte
     zdrojov soubory na  disk,  na  nj  lze  zapisovat  a  znovu spuste
     kompilaci. Tato chyba rovnا nastv, neexistuje-li vstupn adres.

Unable to create turboc.$ln = Nelze vytvoit soubor turboc.$ln
     Kompiltor  neme  vytvoit  doasn  soubor TURBOC.$LN, protoe nem
     pstup na disk, anebo je disk pln.

Unable to execute command command = Nelze vykonat pkaz pkaz
     Nen mon nalzt TLINK nebo TASM, nebo me jt o patn disk.

Unable to open include file filename = Nelze otevt vkldac  soubor nzev
souboru
     Kompiltor  uveden soubor nenalezl. Mohlo by  k  tomu  rovnا  dojt,
     pokud  by soubor #include vkldal sm sebe  anebo  kdybyste  nemli  v
     zkladnm  adresi  v  souboru  CONFIG.SYS  nastaveno  FILES  (zkuste
     FILES=20). Zkontrolujte, zda uveden soubor vbec existuje.

Unable to open  input  file  filename  = Nelze otevt vstupn soubor nzev
souboru
     K tto chyb dochz, nelze-li  nalzt  zdrojov  soubor. Zkontrolujte
     znn  jeho  nzvu  i zda je tento soubor na sprvnm  disku  nebo  ve
     sprvnm adresi.

Undefined label identifier = Nedefinovan nvt identifiktor
     Uveden nvt sice pat k pkazu goto, avak chyb jeho definice.

Undefined structure structure = Nedefinovan struktura struktura
     Ve zdrojovm  souboru bylo uveden struktury pouito na nkterm dku
     ped mstem zjitn chyby (pravdpodobn v  ukazateli  na strukturu),
     ale chybla  definice tto struktury. Mon je to zpsobeno zkomolenm
     nzvu struktury nebo chybjc deklarac.

Upozornn
Undefined structure structure = Nedefinovan struktura struktura
     Ve zdrojovm souboru se  pouilo  uveden  struktury,  pravdpodobn v
     ukazateli  na  tuto  strukturu,  ale  nen  tam  dn jej  definice.
     Pravdpodobn  to  bude  zpsobeno  zkomolenm  nzvu  struktury  nebo
     chybjc deklarac.

Undefined symbol identifier = Nedefinovan symbol identifiktor
     K uvedenmu identifiktoru  chyb  deklarace.  Me  to  bt zpsobeno
     zkomolenm v tomto mst nebo v deklaraci. Pinou by vak mohla tak
     bt ppadn chyba v deklaraci identifiktoru.

Unexpected } = Neoekvan }
     Byla nalezena pebyten prav sloen  zvorka  v  mst,  kde nebyla
     oekvna. Zkontrolujte, zda nechyb {.

Unexpected  )  -  check  for  matching  parenthesis  =   Neoekvan   )  -
zkontrolujte pry zvorek


                                  - 285 - 


     Byla nalezena  pebyten prav zvorka v mst, kde nebyla oekvna.
     Zkontrolujte, zda nechyb (.

Unexpected : found = Nalezena neoekvan :
     Byla nalezena nadbyten  dvojteka  v  mst,  kde  nebyla oekvna.
     Zkontrolujte, zda nechyb ?, nebo zda nen patn umstn.

Unexpected  end of file in comment started on  line  number  =  Neoekvan
konec souboru v komenti, kter zaal na slo dku
     Zdrojov  soubor  skonil  uprosted  komente. Obvykle bv pinou
     chybjc ukonen komente (*/).

Unexpected end of file in conditional started on line number  = Neoekvan
konec souboru v podmnnm vrazu, kter zaal na slo dku
     Zdrojov soubor skonil dve,  ne  kompiltor  nalezl  #endif. Slovo
     #endif bu chyb, nebo je zkomolen.

union cannot have a base type = union neme mt bzov typ
     Obecn  me  bt  tda v C++ typu union, ale takov tda neme bt
     odvozena z dn tdy jin.

Union members cannot require initialization = leny unionu nemoho vyadovat
inicializaci
     Protoe ivotnost lenu unionu je neurit, nen  ppustn deklarovat
     takov, jen vyaduje njak druh inicializace.

Upozornn
Unknown assembler instruction = Neznm instrukce asembleru
     Kompiltor  narazil  na  pkaz   vestavnho   asembleru,   kter  m
     neppustn  operan kd. Zkontrolujte si pravopis tohoto  operanho
     kdu (viz tabulku operanch kd ve spaen npovd). Implicitn je
     toto upozornn vypnuto.

Unknown language, must be C or C++ = Neznm jazyk, mus jt o jazyk C nebo
C++
     V konstrukci jazyka C++

          extern nzev typ func(/* ... */);

          Mus bt udn v uvozovkch nzev C nebo C++; jin nzvy jazyk se
     nerozeznaj. Mete deklarovat extern  funkci  podle  konvence jazyka
     Pascal, kterou kompiltor nepejmenuje:

          extern "C" int pascal func(/* ... */);

          Funkci v C++ (ppadn pepsanou) lze  deklarovat  podle konvence
     jazyka Pascal  a dovolit kompiltoru jej obvykl pejmenovn (aby se
     umonilo pepsn):

          extern int pascal func(/* ... */);

Unknown   preprocessor   directive:   identifier   =    Neznm   direktiva
preprocesoru: identifiktor
     Kompiltor  narazil  na  zatku  dku  na #, ale  nsledujc  nzev
     direktivy nebyl  define, undef, line, if, ifdef, ifndef, include, else
     ani endif.

Upozornn
Unreachable code = Nedosaiteln kd



                                  - 286 - 


     Za pkazem break, continue, goto nebo return chyb nvt nebo konec
     cyklu  i   funkce.  Kompiltor  kontroluje  cykly  while,  do  a  for
     konstantn ovovac podmnkou  a  pokou se rozliit cykly, kter ji
     nespluj.

Unterminated string  or  character  konstant  =  Neukonen  etzcov nebo
znakov konstanta
     Kompiltor nenalezl po zatku etzcov nebo znakov konstanty dnou
     koncovou uvozovku.

Upozornn
Untyped bit field assumed signed int = Bitov poloka s neurenm  typem se
povauje za signed int
     Tato bitov poloka postrd specifikaci typu a povauje se za  int se
     znamnkem.  Nkter  kompiltory  berou  int implicitn jako unsigned.
     Zadvejte deklaraci bu jako int, nebo unsigned int.

Use . or -> to call function = K voln funkce uijte . nebo ->
     Pokusili jste se volat lenskou  funkci,  ani  byste  poskytli njak
     objekt.

Use :: to  take the address of a member function = K zskn adresy lensk
funkce pouijte ::
     Je-li  f  lenskou  funkc tdy c, zskte jej adresu syntax &c::f.
     Nezapomete, e se pouv nzvu typu tdy, nikoli nzvu objektu  a k
     oddlen nzvu tdy od nzvu funkce se uv ::. (Ukazatele  na leny
     td nejsou  skutenmi typy ukazatel a neodkazuj na dnou konkrtn
     instanci tdy.)

Use ; to determine declaration = K ukonen deklarace pouijte ;
     Tato deklarace nebyla ukonena rkou ani stednkem.

User break = Peruen zadan uivatelem
     Bhem kompilace nebo spojovn v  integrovanm  prosted  jste zadali
     Ctrl-Break. (Nejde o chybu, je to jen potvrzen.)

Value of type void is not allowed = Nen dovolena hodnota typu void
     Hodnota typu void  vlastn  dnou  hodnotou  nen a proto se v dnm
     ppad nesm objevit tam, kde se poaduje hodnota skuten. K takovm
     ppadm pat prav  strana  pi dosazovn, argument funkce a dic
     vraz z pkazu if, for nebo while.

Variable  identifier  is  initialized  twice  =  Promnn  identifiktor je
inicializovna dvakrt
     Tato promnn  m vce ne jednu inicializaci. Je ppustn deklarovat
     promnnou na rovni souboru vce ne jednou, ale inicializaci me mt
     jen jedinou (i kdyby byly dv stejn).

Variable name expected = Oekv se nzev promnn
     Pi pouit adresovho opertoru (&)  nebo  pi  poskytnut  odkazu na
     objekt v C++ je teba zadat skuten objekt. Bv  to  pevn  nzev
     promnn.  V tomto ppad se od  kompiltoru  vyaduje,  aby  pevzal
     adresu n؟eho nevhodnho.

Vectors of classes  must  use  the  default constructor = Vektory td mus
pouvat implicitn konstruktor
     Pi   inicializaci   njakho   vektoru   (pole)  td  muste  pout
     konstruktor,  kter  nem  dn  argumenty.  k  se   mu  poten
     konstruktor, co znamen, e pi inicializaci takovho vektoru nesmte
     argumenty konstruktoru zadvat.


                                  - 287 - 


Virtual function function1  conflicts  with  function2  =  Virtuln funkce
funkce1 je v rozporu s funkc funkce2
     Virtuln funkce m stejn typy  argument jako funkce v bzov td,
     ale je jinho typu vsledku. To je neppustn.

virtual specified more than once = Klauzule virtual urena vcekrt
     Vyhraen slovo virtual v C++ se sm v deklaraci jedin lensk funkce
     objevit jen jednou.

void & is not a valid type = void & nen ppustnm typem
     Jde o explicitn hlen  ohledn  omezen,  kter  je zejm. Dve k
     nmu dochzelo  pi  pokusech  o  inicializaci  nebo  pouit njakho
     referennho typu. Nyn je to jasnj.

Upozornn
Void functions may not return a value = Funkce void nesm  poskytovat dn
hodnoty
     Ve zdrojovm  souboru jste mli deklarovnu aktuln funkci jako void,
     zatmco kompiltor  narazil na pkaz nvratu s njakou hodnotou. Tato
     hodnota z pkazu nvratu se bude ignorovat.

While statement missing ( = V pkazu while chyb (
     V pkazu while nenalezl kompiltor  po  klovm  slov  while dnou
     levou zvorku.

While statement missing ) = V pkazu while chyb )
     V pkazu while nenalezl kompiltor po testovacm vrazu dnou pravou
     zvorku.

Wrong  number  of  arguments in call of macro = Ve voln makroinstrukce je
patn poet argument
     Ve zdrojovm  souboru  se  uveden  makroinstrukce  vol  s nesprvnm
     potem argument.





























                                  - 288 - 








                                 Dodatek A

               Dodatek A Implementan specifick normy ANSI


   Jist otzky z normy ANSI C se v  norm  ANSI  nedefinuj  pesn. Msto
toho se jednotlivm realiztorm kompiltoru  jazyka  C  ponechv volnost,
aby  definovali  tyto  otzky individuln. V tto kapitole se dovte, jak
varianty  definic  tchto implementan specifickch  norem  zvolila  firma
Borland.  sla oddl se vztahuj na normu ANSI  Standard  z  nora  1990.
Nezapomete, e mezi C a C++ jsou rozdly; tento dodatek se  vztahuje pouze
na jazyk C.

    *  Jak se pozn diagnostika.

       Kdy kompiltor  bا  se  sprvnou  kombinac  alternativ,  vechna
       hlen, je vydv a je zanaj slovy Fatal,  Error  nebo Warning
       jsou diagnostikou  ve smyslu ANSI. Alternativy, jich je k zajitn
       takov interpretace zapoteb, jsou:

                 Tab. A.1: Identifikace diagnostiky v C++

---------------------------------------------------------------------------
Alternativa         innost
---------------------------------------------------------------------------
-A                  Umonit jenom klov slova z ANSI.
-C-                 Nejsou dovoleny vnoen komente.
-p-                 Pouvat konvenc pro voln z jazyka C.
-i32                Nejmn 32 platnch znak v identifiktorech.
-w-                 Vypnout vechna upozornn s vjimkou nsledujcho.
-wbei               Zapnout upozornn o nesprvnch inicializtorech.
-wdcl               Zapnout upozornn o deklaracch bez typu nebo pam؟ov
                    tdy.
-wcpt               Zapnout upozornn o nepenosnch porovnnch
                    ukazatele.
-wdup               Zapnout upozornn o duplicit neidentickch definic
                    makroinstrukc.
-wsus               Zapnout upozornn o podezelch pevodech ukazatele.
-wrpt               Zapnout upozornn o nepenosnm pevodu ukazatele.
-wvrt               Zapnout upozornn o funkcch void poskytujcch
                    hodnotu.
-wbig               Zapnout upozornn o pli velkch konstantch.
-wucp               Zapnout upozornn o smovn ukazatel signed char a
                    unsigned char.
-wstu               Zapnout upozornn o nedefinovanch strukturch.
-wext               Zapnout upozornn o promnnch deklarovanch jako
                    extern i statick.
-wfdt               Zapnout upozornn o definicch funkc uvajcch
                    typedef.
---------------------------------------------------------------------------

       Nelze pout dn z nsledujcch alternativ:

       -ms!     Pro mal datov modely mus bt SS stejn jako DS.


                                  - 289 - 


       -mm!     Pro mal datov modely mus bt SS stejn jako DS.
       -mt!     Pro mal datov modely mus bt SS stejn jako DS.
       -zGxx Nzev skupiny BSS se nesm mnit.
       -zSxx Nzev datov skupiny se nesm mnit.

       Ostatn zde  konkrtn  neuveden  alternativy  lze  nastavit  podle
       vlastnho pn.


    *  Smantika argument funkce main.

       Pokud program bا v operanm systmu DOS verze ni neli 3.0, je
       hodnotou argv[0] ukazatel na byte s adresou nula. V DOS verze  3.0 a
       pozdjch ukazuje argv[0] na nzev programu.

       Zbvajc  etzce  argv  ukazuj   na   vechny   sloky  argument
       pkazovho  dku  DOS.   Przdn  msta  oddlujc  argumenty  se
       odstran a s kadou posloupnost za sebou jdoucch znak, je nejsou
       przdnmi msty, se zachz jako se samostatnm  argumentem. etzce
       v uvozovkch se oetuj sprvn (tj. jako jedin etzec obsahujc
       mezery).


    *  Co se povauje za interaktivn zazen.

       Za interaktivn zazen se povauje kad zazen, je vypad jako
       ovldac pult {console}.


    *  Porovnvac posloupnost zpracovvan mnoiny znak.

       Porovnvac  posloupnost zpracovvan mnoiny znak pouv  hodnoty
       znaku v kdu ASCII se znamnkem.


    *  leny zdrojovch a zpracovvanch mnoin znak.

       Zdrojovou i zpracovvanou mnoinou znak je rozen  mnoina ASCII
       podporovan  potai  IBM  PC.  V etzcovch literlech, znakovch
       konstantch nebo  komentch se sm objevit kterkoli znak rzn od
       ^Z (Control-Z).


    *  Vcebytov znaky.

       V Turbo C++ nejsou dn vcebytov znaky podporovny.


    *  Smr tisku.

       Tiskne se zleva doprava, ve smru normlnm pro PC.


    *  Poet bit ve znaku ze zpracovvan mnoiny znak.

       Ve zpracovvan mnoin znak m kad znak 8 bit.


    *  Poet platnch potench znak v identifiktorech.



                                  - 290 - 


       Platnch je prvnch 32 znak,  akoli  lze  pout  alternativy (-i)
       pkazovho  dku  a  tento  poet   zmnit.   Vnitn   i  extern
       identifiktory  pouvaj stejnho  potu  platnch  slic.  (Poet
       platnch znak v identifiktorech jazyka C++ je neomezen.)


    *  Zda se v externch identifiktorech rozliuj velk a mal psmena.

       Kompiltor  normln  naizuje  spojovacmu programu, aby rozlioval
       mezi  velkmi  a  malmi  psmeny.  Lze  pout  alternativy  (-i-c)
       pkazovho dku a toto rozlien potlait.


    *  Vnitn zobrazen a mnoiny hodnot rznch typ celch sel.

---------------------------------------------------------------------------
     Typ                 Nejmen hodnota         Nejvt hodnota
---------------------------------------------------------------------------
     signed char                     -128                     127
     unsigned char                      0                     255
     signed short                  -32 768                 32 767
     unsigned short                     0                  65 535
     signed int                   -32 768                  32 767
     unsigned int                       0                  65 535
     signed long           -2 147 483 648           2 147 483 647
     unsigned long                      0           4 294 967 295
---------------------------------------------------------------------------

       Vechny typy char pouvaj v pamti jeden 8-mi bitov byte.

       Vechny typy short a int pouvaj 2 byty.

       Vechny typy long pouvaj 4 byty.

       Vyaduje-li se zarovnn (-a),  vechny  objekty  celoselnho typu
       rznho od char se zarovnvaj  na hranice sudch byt. Znakov typy
       se nikdy nezarovnvaj.


    *  Vnitn zobrazen a  mnoiny  hodnot rznch typ sel s pohyblivou
       dovou tekou.

       V Turbo C++ se  ve  vech typech s pohyblivou dovou tekou pouv
       formt pohybliv dov teky podle IEEE  (Institute  of Electrical
       and  Electronics  Engineers),  jak  jich pouvaj koprocesory Intel
       8087.  Typ float uv 32- bitovho  formtu  relnch  sel  podle
       IEEE. Typ double uv 64-  bitovho  formtu  relnch  sel podle
       IEEE.  Typ  long  double  uv  80-  bitovho  rozenho  formtu
       relnch sel podle IEEE.


    *  Vzjemn  zobrazen  mezi  zdrojovou  mnoinou znak a zpracovvanou
       mnoinou znak.

       Vechny znaky v etzcovch  literlech  nebo  znakovch konstantch
       zstanou v  innm  programu  nezmnny.  Zdrojov  mnoina  znak a
       zpracovvan mnoina znak jsou toton.





                                  - 291 - 


    *  Hodnota celoseln znakov  konstanty obsahujc znak nebo zmnovou
       posloupnost, kter se nenalz v zkladn zpracovvan mnoin znak
       ani v rozen mnoin znak pro irok znakov konstanty.

       irok znaky nejsou podporovny. Zachz se s nimi jako s normlnmi
       znaky.  Vechny  ppustn  zmnov  posloupnosti  se  zobrazuj  do
       jednoho i druhho znaku. Pouije-li se hexadecimln  nebo oktalov
       zmnov  posloupnosti,  je  pesahuje  rozsah  znaku,  vyd  o  tom
       kompiltor hlen.


    *  Aktuln daje pro danou zemi {locale}, jich se  pouv  k pevodu
       vcebytovch znak na odpovdajc irok znaky pro irokou znakovou
       konstantu.

       Konstanty se irokmi znaky se sice rozeznaj, ale zachz se s nimi
       po vech  strnkch jako s normlnmi znakovmi konstantami. V tomto
       smyslu se pod pojmem 'locale'  rozum konvence tchto pojm z jazyka
       C.


    *  Hodnota celoseln konstanty obsahujc vce ne  jeden  znak, nebo
       konstanty se irokmi znaky  obsahujc  vce  ne  jeden vcebytov
       znak.

       Znakov konstanty mohou  obsahovat  jeden  nebo  dva  znaky. Jsou-li
       obsaeny  znaky  dva,  prvn  z  nich zabr byte niho du  dan
       konstanty a druh pak byte vyho du.


    *  Vsledek pevodu celho sla na  krat  cel  slo  se znamnkem,
       nebo  vsledek  pevodu  celho  sla  bez  znamnka  na  slo  se
       znamnkem stejn dlky, nelze-li hodnotu vnitn zobrazit.

       Takov pevody se vykonaj prostm odznutm bit  nejvych d.
       Cel sla se znamnkem se ukldaj jako dvojkov  doplky,  take i
       vsledn  sla  se  interpretuj  jako  takov  hodnoty.  Je-li bit
       nejvyho du  menho  celho  sla  nenulov,  interpretuje  se
       takov hodnota jako hodnota zporn; v opanm ppad je kladn.


    *  Smr  odznut  pi  pevodu  celho  sla na slo  s  pohyblivou
       dovou tekou, je neme pvodn hodnotu zobrazit pesn.

       Celoseln   hodnota  se  zaokrouhl  na  nejbli   zobrazitelnou
                                                      31
       hodnotu. Proto se  napklad  hodnota  long  (2    -  1)  pevede na
                        31
       hodnotu  float  2  .  Zlomkov  msta  se  odznou  podle  pravidel
       normalizovan aritmetiky IEEE.


    *  Smr odznut nebo  zaokrouhlen  pi  pevodu  sla  s pohyblivou
       dovou tekou na u slo s pohyblivou dovou tekou.

       Hodnota  se zaokrouhl na nejbli zobrazitelnou hodnotu.  Zlomkov
       msta se odznou podle pravidel normalizovan aritmetiky IEEE.


    *  Vsledky bitovch operac s celmi sly se znamnkem.


                                  - 292 - 


       Bitov  opertory se na cel sla  se  znamnkem  aplikuj  stejn,
       jakoby lo o odpovdajc typy bez znamnka. Se znamnkovm bitem se
       zachz  stejn  jako  s normlnm datovm bitem.  Vsledek  se  pak
       interpretuje jako normln cel slo se  znamnkem,  vyjden jako
       dvojkov doplnk.


    *  Co  se  stane  pi zpstupnn lenu objektu union za pouit lenu
       odlinho typu.

       Takov pstup je dovolen a zpstupn se jenom bity zde  uloen. K
       pochopen pstupu do len njakho  typu  s  pohyblivou  tekou za
       pouit odlinho lenu je zapoteb podrobn  znt  bitov kdovn
       hodnot s  pohyblivou dovou tekou. Je-li uloen len krat neli
       len pouit  ke  zpstupnn  hodnoty,  zstanou  v  pebvajcch
       bitech ty hodnoty, kterou tam byly ped uloenm krtkho lenu.


    *  Celoseln typ poadovan pro uloen maximln velikosti pole.

       V ppad normlnho pole je to unsigned int a pro pole rozshl jde
       o typ signed long.


    *  Vsledek petypovn ukazatele na cel slo nebo opan.

       Pi  pevodech mezi celmi sly a  ukazateli  stejn  velikosti  se
       dn bity nemn.  Pi  pevodu  delho  typu  na  krat  se bity
       vyho du odznou. Pi pevodu  kratho  celoselnho  typu na
       del  typ  ukazatelov  se  nejprve  celoseln  typ   roz  na
       celoseln typ stejn velikosti jako typ ukazatelov. Proto se cel
       sla  se znamnkem ve znamnku roz,  aby  vyplnila  nov  byty.
       Podobn i men ukazatelov typy pevdn na vt typy celoseln
       se  nejprve  roz  na  ukazatelov  typ  stejn  irok jako  typ
       celoseln.


    *  Znamnko zbytku pi celoselnm dlen.

       Znamnko zbytku je zporn,  je-li  prv  jeden z operand zporn.
       Nen-li dn, nebo jsou-li oba zporn, je zbytek kladn.


    *  Poadovan celoseln typ pro uloen rozdlu mezi  dvma ukazateli
       na prvky tho pole ptrdiff_t.

       Tmto typem je signed  int,  jsou-li  ukazatele blzk, resp. signed
       long, jsou-li ukazatele vzdlen nebo rozshl.  Typ  pole ptrdiff_t
       zvis  na  pouitm  pam؟ovm modelu. Pro mal datov modely je to
       typ int. Ve velkch datovch modelech se jedn o typ long.


    *  Vsledek posunu vpravo zpornho celoselnho typu se znamnkem.

       Zporn  hodnota  se  znamnkem  se  pi  posunu  vpravo  znamnkov
       roz.


    *  Oblast, kam lze skuten uloit  objekty  v  registrech  pi pouit
       specifiktoru pam؟ov tdy register.


                                  - 293 - 


       Objekty   deklarovan   vemi   dvoubytovmi   celoselnmi    nebo
       ukazatelovmi typy lze  ukldat  do  registr.  Kompiltor  se sna
       umstit do registr vechny mal automatick  objekty,  ale pednost
       maj objekty explicitn deklarovan jako register. K  dispozici jsou
       nejmn dva a a  est  registr.  Poet skuten pouitch registr
       zvis  na  tom,  jakch registr je pro doasn hodnoty ve funkcch
       zapoteb.


    *  Zda  se  s  neifrovanou bitovou polokou int zachz jako se signed
       int nebo jako s unsigned int.

       S neifrovanmi biovmi polokami int  se  zachz  jako  s bitovmi
       polokami signed int.


    *  Poad pidlovn bitovch poloek uvnit celho sla.

       Bitov poloky se pidluj od bitovho msta nejniho du po d
       nejvy.


    *  Doplovn a zarovnvn len struktur.

       Implicitn se ve  strukturch dnho doplovn nepouv. Uijete-
       li alternativy pro zarovnvn  (-a),  struktury  se dopln na sudou
       velikost  a vechny leny, kter nejsou  znakovho  typu  nebo  typu
       znakovho pole, se zarovnaj na sud ofset.


    *  Zda mohou bitov poloky pesahovat hranici jednotky pamti.

       Nen-li  vydno zarovnvn (-a), mohou bitov poloky  pesahovat
       hranice slov, ale nikdy se neulo do vce ne dvou sousednch byt.


    *  Celoseln typ zvolen pro uvdn hodnot vtovho typu.

       Pokud vechny  itatele odpovdaj typu unsigned char, bude to tento
       typ. V opanm ppad je tmto typem signed int.


    *  Jak se utv pstup do objektu, kter je typu kvalifikovanho jako
       volatile.

       Kadm  odkazem  na  nestl  {volatile}  objekt  se   tento  objekt
       zpstupn.   Zdali  se  zpstupnnm  sousednch  mst  v   pamti
       zpstupn tak njak objekt zvis na technick konstrukci pamti.
       V ppad pamti specilnch zazen, jako  je  pam؟ zobrazovacho
       displeje,  to  zvis  na  konstrukci  tohoto  zazen.  V  ppad
       normln pamti osobnch pota se nestlch objekt pouv jenom
       v pamti,  kter  lze  doshnout  v  asynchronnch  peruench. Pak
       zpstupnn sousednch objekt nem dn vznam.


    *  Nejvy poet deklarac, jimi lze modifikovat aritmetick typ, typ
       struktury nebo unionu.





                                  - 294 - 


       Pro  poet  deklarac   neexistuje  dn  zvltn  omezen.  Poet
       povolench deklarac je hodn  velk,  ale  pi hlubokm vnoovn v
       mnoin blok ve funkci se  poet deklarac sn. Poet povolen na
       rovni souboru je nejmn 50.


    *  Nejvy poet hodnot ppad v pkazu pepnae.

       Pro poet ppad v  pepnai  neexistuje  dn  zvltn omezen.
       Pokud bude dostaovat pam؟ pro  ukldn  informac  o jednotlivch
       ppadech, kompiltor je pijme.


    *  Zda hodnota  znakov konstanty o jedinm znaku v konstantnm vrazu,
       kterm se ovld podmnn zalenn, odpovd hodnot  te znakov
       konstanty   ve  zpracovvan  mnoin  znak.  Zda  takov   znakov
       konstanta me mt zpornou hodnotu.

       Vechny  znakov  konstanty,   dokonce  i  konstanty  v  podmnnch
       direktivch, pouvaj stejn mnoiny znak  (zpracovvan). Znakov
       konstanty o  jedinm znaku budou zporn, m-li znakov typ znamnko
       (implicitn a pi nezadan alternativ -K).


    *  Metoda vyhledn zdrojovch soubor pro vkldn.

       Zadte-li nzvy vkldacch {include} soubor v lomench  zvorkch a
       v  pkazovm dku jsou udny adrese  pro  vkldn,  hledaj  se
       takov  soubory  v  kadm  z  adres pro vkldn.  Adrese  pro
       vkldn se prohledaj v tomto  poad:  Nejprve  adrese  zadan v
       pkazovm dku, potom  adrese uren v souboru TURBOPRODUCT.CFG.
       Nejsou-li dn adrese  pro  vkldn  ureny,  prohled  se jenom
       aktuln adres.


    *  Podpora nzv v uvozovkch pro vkldac zdrojov soubory.

       V ppad nzvu v  uvozovkch  se  soubor  nejprve hled v aktulnm
       adresi. Jestlie se  nenalezne,  hled Turbo C++ tento soubor tak,
       jako kdyby byl v lomench zvorkch.


    *  Zobrazovn posloupnost znak nzvu zdrojovho souboru.

       Se zptnmi lomtky v nzvech vkldacch soubor se  zachz  jako s
       oddlovacmi  znaky a nikoli jako se  znaky  zmnovmi.  Psmena  se
       nerozliuj na mal a velk.


    *  Definice __DATE__ a __TIME__, kdy nejsou k dispozici.

       Datum a as jsou k dispozici vdy a pouvaj data a asu operanho
       systmu DOS.


    *  Znak desetinn teky.

       Znakem desetinn teky je teka (.).




                                  - 295 - 


    *  Typ opertoru sizeof, tj. size_t.

       Typem size_t je unsigned int.


    *  Konstanta  przdnho  ukazatele, do n  se  rozvine  makroinstrukce
       NULL.

       Je to celoseln nebo dlouh 0 v zvislosti na pam؟ovm modelu.


    *  Zobrazovan diagnostika a ukonovac chovn funkce assert.

       Zobrazovan diagnostick hlen zn "Assertion  failed: expression,
       file filename, line nn" =  'Vrok se nepotvrdil: vraz, soubor nzev
       souboru, dek nn', kde vraz  je  zformulovanm  vrazem,  kter se
       nepotvrdil,  nzev  souboru  je nzvem zdrojovho souboru  a  nn  je
       slem dku, kde k vroku dolo.

       Ihned po zobrazen hlen o vroku se vol funkce abort.


    *  Implementan   definovan   otzky   testovn   znak   a   funkc
       zobrazujcch velk a mal psmena.

       dn, jinak ne se uvd v 4.3.1.


    *  Mnoiny  znak  ovovanch  funkcemi  isalnum,   isalpha,  iscntrl,
       islower, isprint a isupper.

       Prvnch 128 znak kdu ASCII.


    *  Hodnoty zskan z matematickch funkc pi chyb defininho oboru.

       Hodnota NAN (not a number = 'ne-slo') podle IEEE.


    *  Zda matematick funkce nastav celoseln  vraz  errno  na hodnotu
       makroinstrukce ERANGE pi chybch nenaplnn rozsahu.

       Nikoli,   pouze   pi  ostatnch  chybch   -   defininho   oboru,
       singularity, peplnn a celkov ztrty pesnosti.


    *  Zda  dojde  k  chyb  defininho  oboru nebo se poskytne nula  kdy
       funkce fmod m druh argument nulov.

       Nikoli, fmod(x, 0) poskytne 0.


    *  Mnoina signl pro funkci signal.

       SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM.


    *  Smantika vech signl, kter funkce signal rozeznv.

       Viz popis funkce signal ve spaen npovd.


                                  - 296 - 


    *  Implicitn oeten  a  oeten  pi  sputn  programu  vekerch
       signl, kter funkce signal rozeznv.

       Viz popis funkce signal ve spaen npovd.


    *  Jestli se ped volnm oeten signlu  nevykon  ekvivalent funkce
       signal(sig, SIG_DFL), blokovn uskutennho signlu.

       Ekvivalent signal(sig, SIG_DFL) se vykon vdy.


    *  Zda v ppad, kdy oeten uren pro signln funkci obdr signl
       SIGILL, se nastav oeten implicitn.

       Nikoli.


    *  Zda se na poslednm dku textovho streamu vyaduje ukonovac znak
       novho dku.

       Nikoli, nic se nevyaduje.


    *  Zda se  znaky mezer, zapsan do textovho streamu bezprostedn ped
       znakem novho dku, objev pi natn.

       Ano, objev se.


    *  Poet nulovch znak, je lze pipojit k datm zapsanm do binrnho
       streamu.

       dn.


    *  Zda indiktor pozice v souboru njakho streamu v reimu pipojovn
       se na potku umst na zatek i konec souboru.

       Indiktor pozice  v souboru njakho streamu v reimu pipojovn se
       na potku umst na zatek souboru. Ped kadm zpisem se nastav
       na konec souboru.


    *  Zda se zpisem do textovho  streamu zpsob, e se pslun soubor
       od tohoto msta odzne.

       Zpisem 0 byt se me i nemus soubor odznout podle toho,  jak je
       soubor  pam؟ov vyrovnvn. Nejbezpenj je klasifikovat zpis  s
       nulovou dlkou jako zpsobujc neuren chovn.


    *  Charakteristika vyrovnvac pamti souboru.

       Soubory lze  pln  pam؟ov  vyrovnvat,  vyrovnvat  je  dkov i
       nevyrovnvat vbec. Je-li soubor vyrovnvn, vytvo se  po oteven
       souboru vyrovnvac pam؟ 512 byt.


    *  Zda soubor nulov dlky skuten existuje.


                                  - 297 - 


       Ano, existuje.


    *  Zda lze tent soubor vcekrt otevt.

       Ano, lze.


    *  Psoben funkce remove na oteven soubor.

       Nevykonv se dn zvltn  kontrola,  zda  je soubor ji oteven;
       zodpovdnost je ponechna na programtorech.


    *  Vliv existence souboru s novm nzvem ped volnm funkce rename.

       rename poskytne -1 a errno se nastav na EEXIST.


    *  Vstup pi konverzi %p ve funkci fprintf.

       V blzkch datovch modelech to  budou  tyi  hexadecimln slice
       (XXXX).  Ve  vzdlench datovch modelech  pak  tyi  hexadecimln
       slice, dvojteka, tyi hexadecimln slice (XXXX:XXXX).


    *  Vstup pi konverzi %p ve funkci fscanf.

       Viz 4.9.6.1.


    *  Interpretace znaku -  (pomlka),  kter  nen  prvnm  ani poslednm
       znakem v seznamu prohlen pi konverzi %[ ve funkci fscanf.

       Viz popis funkce scanf ve spaen npovd.


    *  Hodnota, na ni funkce fgetpos  nebo ftell nastav v ppad selhn
       makroinstrukci errno

       EBADF patn slo souboru.


    *  Hlen generovan funkc perror.


















                                  - 298 - 


---------------------------------------------------------------------------
          Error 0 = Chyba 0
          Invalid function number = Neplatn slo funkce
          No such file or directory = Takov soubor nebo adres neexistuje
          Path not found = Cesta k souboru nebyla nalezena
          Too many open files = Pli mnoho otevench soubor
          Permission denied = Povolen odmtnuto
          Bad file number = patn slo souboru
          Memory arena trashed = Pam؟ov oblast byla oklestna
          Not enough memory = Nedostatek pamti
          Invalid memory block address = Nesprvn adresa bloku pamti
          Invalid environment = Nesprvn prosted
          Invalid format = Nesprvn formt
          Invalid access code = Nesprvn pstupov kd
          Invalid data = Nesprvn data
          No such device = Takov zazen neexistuje
          Attempted  to  remove  current  directory  =  Pokus  o odstrann
          aktulnho adrese
          Not same device = Nejde o stejn zazen
          No more files = Dal soubory neexistuj
          Invalid argument = Nesprvn argument
          Arg list too big = Seznam argument je pli velk
          Exec format error = Chyba formtu funkce exec
          Cross-device link = Vazba mezi zazenmi
          Math argument = Matematick argument
          Result too large = Vsledek je pli velk
          File already exists = Soubor ji existuje
---------------------------------------------------------------------------

       Podrobnosti naleznete v popisu funkce perror ve spaen npovd.


    *  Chovn calloc,  malloc  nebo  realloc,  je-li  poadovan  velikost
       nulov.

       Funkce calloc i malloc  takov  poadavek  ignoruj.  Funkce realloc
       uvoln blok.


    *  Chovn funkce abort s ohledem na oteven a doasn soubory.

       Vyrovnvac pamti soubor se nevyprzdn a soubory se neuzavou.


    *  Stav, kter poskytne funkce exit, je-li hodnota  argumentu nenulov,
       EXIT_SUCCESS nebo EXIT_FAILURE.

       Nic zvltnho. Stav se poskytne pesn tak, jak se pedv. Stav se
       zobrazuje jako signed char.


    *  Mnoina nzv  promnnch pro uren prosted a metoda zmn seznamu
       promnnch pro prosted pouvan ve funkci getenv.

       etzce prosted {environment} se definuj v operanm  systmu DOS
       pkazem SET. Pro  zmnu  tchto etzc po dobu innosti aktulnho
       programu  lze  pout  funkce  putenv,  ale k trval  zmn  etzc
       prosted je nutno ut pkazu SET z DOS.




                                  - 299 - 


    *  Obsah a reim zpracovn etzce funkc system.

       etzec se interpretuje jako pkaz operanho  systmu  DOS. Vykon
       se  soubor  COMMAND.COM  a etzec argument se ped jako pkaz ke
       zpracovn. Lze vykonat jakkoli vestavn pkaz operanho systmu
       DOS, stejn jako dvkov soubory i vykonateln programy.


    *  Obsah etzc chybovch hlen zskanch z funkce strerror.

       Viz 4.9.10.4.


    *  Mstn asov psmo a letn as.

       Jsou definovny jako mstn as a datum v osobnm potai.


    *  asov interval hodin.

       Uvd se jako poet hodinovch  tik s potkem totonm se zatkem
       vykonvn programu.


    *  Formty data a asu.

       Jazyk Turbo C++ implementuje formty ANSI.



































                                  - 300 - 








                                 Dodatek B

                Dodatek B Pehled knihovny innho programu


     V tomto dodatku podvme pehled knihovnch standardnch podprogram a
vkldacch soubor jazyka Turbo C++.

     V dodatku

    o  vysvtlme pro  je vhodn zskat zdrojov text pro knihovnu innho
       programu jazyka Turbo C++

    o  uvedeme a popeme soubory zhlav

    o  shrneme rzn kategorie loh, kter vykonvaj knihovn rutiny

     Turbo C++ se dodv vybaven  vce ne 450 funkcemi a makroinstrukcemi.
Kdy se vyvolaj z njakho programu  v  jazyku C nebo C++, vykonvaj adu
loh  vetn  vstup/vstup  nzk i vysok rovn, manipulac s etzci i
soubory,  pidlovn pamti, ovldn procesu, pevod dat,  matematickch
vpot a mnoha  jinch.  Tyto  funkce  a  makroinstrukce,  kterm  se k
knihovn rutiny, jsou podrobn popsny ve spaen npovd.

     Rutiny  Turbo  C++  jsou  obsaeny  v  knihovnch  souborech  (Cx.LIB,
CPx.LIB,  MATHx.LIB  a  GRAPHICS.LIB).  Protoe  Turbo  C++  podporuje est
rozdlnch pam؟ovch model, m kad  model  s  vjimkou  drobnho {tiny}
svj vlastn knihovn soubor a matematick soubor. Jsou v nich  verze rutin
zapsanch pro  konkrtn modely. (Drobn model sdl knihovn i matematick
soubor modelu malho {small}.)

     Turbo  C++  implementuje  normu  ANSI  C, kter, krom  mnoha  jinho,
umouje (a drazn doporuuje)  uvdt  pro rutiny v programech v jazyku C
prototypy funkc.  Vechny knihovn rutiny Turbo C++ jsou deklarovny svmi
prototypy v jednom i nkolika souborech zhlav.

     V  jazyku  C++  se  prototyp  mus  ut  vdycky. Vce  informac  o
prototypech funkc naleznete na strnce 68.



---------------------------------------------------------------------------
Dvody k pstupu do zdrojovch text knihovny innho programu
---------------------------------------------------------------------------


     K zskn  zdrojovho textu rutin z knihovny innho programu existuje
nkolik dobrch dvod:

    o  Mon zjistte, e urit funkce,  kterou chcete v Turbo C++ zapsat,
       je velmi podobn, i kdy ne zcela stejn, nkter funkci v knihovn.
       Mte-li pstup ke zdrojovm textm knihovny  innho  programu, lze
       takovou knihovn funkci  upravit  podle vlastn poteby a nen nutn
       zvlt pst funkci vlastn.


                                  - 301 - 


    o  Nkdy,  zejmna  pi  ladn programu, je dobr vdt ponkud vce o
       vnitnch stech funkce z knihovny.  V  takov  situaci pedstavuje
       dostupnost zdrojovch  text  z  knihovny  innho  programu  velkou
       pomoc.

    o  Neda-li  se  vm  zjistit, co m vlastn  urit  knihovn  funkce
       dlat, bv uiten  mt  monost  nahldnout  do  zdrojovho textu
       takov funkce.

    o  Chcete-li vylouit ze symbol jazyka C zaten  podtren, pstup
       do zdrojovch text knihovny innho programu vm to umon.

    o  Studiem   zdrojovch   text   z   knihovny,   napsanch   hutn   a
       profesionln, se lze mnohmu piuit.

     Toto  ve  a jet i jin jsou dvody, pro je dobr  mt  pstup  ke
zdrojovm textm knihovny innho programu Turbo C++. Protoe firma Borland
pln dvuje koncepci  "oteven architektury", zpstupnili jsme zdrojov
texty knihovny innho programu Turbo C++ na zklad licenc. Sta vyplnit
formul objednvky,  dodvan v kadm balen Turbo C++, piloit patin
poplatek a my vm ji zdrojov texty knihovny innho  programu  Turbo  C++
dodme.



---------------------------------------------------------------------------
Soubory zhlav v Turbo C++
---------------------------------------------------------------------------


     Soubory zhlav v C++  i  soubory zhlav definovan podle ANSI C jsou
oznaeny komentem na okraji.

     Soubory zhlav, nazvan t  vkldac  soubory,  poskytuj deklarace
prototyp  funkc  z  knihovny. V nich  se  definuj  tak  datov  typy  a
symbolick konstanty, kterch knihovn funkce pouvaj,  jako  i globln
promnn definovan v Turbo C++ a ve funkcch z  knihovny.  Knihovna  Turbo
C++ dodruje pro nzvy soubor zhlav a jejich obsah normu ANSI C.

          alloc.h        Deklaruje funkce pro sprvu pamti (pidlovn,
                         uvolovn atd.).

ANSI C    assert.h       Definuje ladic makroinstrukci assert.

[C++]     bcd.h          Deklaruje v C++ tdu bcd a pepsan opertory pro
                         funkce z bcd i matematick funkce z bcd.

          bios.h         Deklaruje rzn funkce pouvan ve volajcch
                         rutinch IBM-PC ROM BIOS.

[C++]     complex.h      Deklaruje matematick funkce C++ v oboru
                         komplexnch sel.

          conio.h        Deklaruje rzn funkce pouvan ve voln
                         vstupnch/vstupnch rutin operanho systmu DOS.

ANSI C    ctype.h        Obsahuje informace, kterch vyuvaj
                         makroinstrukce pro klasifikaci a pevody znak
                         (jako jsou isalpha a toascii).



                                  - 302 - 


          dir.h          Obsahuje struktury, makroinstrukce a funkce pro
                         prci s adresi a nzvy cesty.

          dos.h          Definuje rzn konstanty a udv deklarace
                         potebn pro DOS a k volnm specifickm pro 8086.

ANSI C    errno.h        Definuje mnemotechnick konstanty k chybovm
                         kdm.

          fcntl.h        Definuje symbolick konstanty pouvan ve spojen
                         s knihovn rutinou open.

ANSI C    float.h        Obsahuje parametry pro rutiny v pohybliv dov
                         tece.

[C++]     fstream.h      Deklaruje tdy stream v C++, je podporuj
                         vstupy a vstupy ze soubor.

[C++]     generic.h      Obsahuje makroinstrukce pro deklarace generickch
                         td.

          graphics.h     Deklaruje prototypy grafickch funkc.

          io.h           Obsahuje struktury a deklarace pro
                         vstupn/vstupn rutiny nzk rovn.

[C++]     iomanip.h      Deklaruje manipultory pro vstupy/vstupy stream
                         v C++ a obsahuje makroinstrukce pro vytven
                         parametrizovanch manipultor.

[C++]     iostream.h     Deklaruje zkladn rutiny pro streamy
                         (vstup/vstup) v C++ (verze 2.0).

ANSI C    limits.h       Obsahuje parametry prosted, informace o
                         omezen kompilan innosti a rozsahy
                         celoselnch veliin.

ANSI C    locale.h       Deklaruje funkce poskytujc informace specifick
                         pro danou zemi a jazyk.

ANSI C    math.h         Deklaruje prototypy matematickch funkc. Definuje
                         tak makroinstrukci HUGE_VAL a deklaruje strukturu
                         vjimek pouvanou v rutin matherr.

          mem.h          Deklaruje funkce pro manipulace s pamt. (Mnoh z
                         nich jsou definovny tak ve string.h.)

          process.h      Obsahuje struktury a deklarace pro funkce spawn...
                         a exec....

ANSI C    setjmp.h       Definuje typ jmp_buf, kter pouvaj funkce
                         longjmp a setjmp a deklaruje rutiny longjmp a
                         setjmp.

          share.h        Definuje parametry, jich pouvaj funkce
                         vyuvajc sdlen soubor.

ANSI C    signal.h       Definuje konstanty a deklarace pro pouit ve
                         funkcch signal a raise.



                                  - 303 - 


ANSI C    stdarg.h       Definuje makroinstrukce pouvan pro ten
                         seznamu argument ve funkcch deklarovanch pro
                         pebrn promnnho potu argument (jako jsou
                         vprintf, vscanf atd.)

ANSI C    stdef.h        Definuje nkolik spolench datovch typ a
                         makroinstrukc.

ANSI C    stdio.h        Definuje typy a makroinstrukce potebn pro
                         Standard I/O Package podle definic Kernighana a
                         Ritchieho a rozen pod systmem UNIX System V.
                         Definuje peddefinovan streamy pro standardn
                         vstupy/vstupy stdin, stdout, stdprn a stderr a
                         deklaruje vstupn/vstupn rutiny na rovni
                         stream.

[C++]     stdiostr.h     Deklaruje tdy stream v C++ pro pouit ve
                         strukturch stdio FILE. .

ANSI C    stdlib.h       Deklaruje nkolik spolen pouvanch rutin:
                         pevodn rutiny, rutiny pro vyhledn/tdn a
                         rzn jin.

[C++]     stream.h       Deklaruje rutiny pro streamy (vstup/vstup) v C++
                         (verze 1.2).

ANSI C    string.h       Deklaruje nkolik rutin pro manipulaci s etzci a
                         s pamt.

[C++]     strstrea.h     Deklaruje tdy stream v C++ pro pouit v
                         bytovch polch v pamti.

          sys\stat.h     Definuje symbolick konstanty pouvan k otvrn
                         a vytven soubor.

          sys\timeb.h    Deklaruje funkci ftime a strukturu timeb, kterou
                         poskytuje ftime.

          sys\types.h    Deklaruje typ time_t pouvan ve funkcch pro
                         zpracovn asu.

ANSI C    time.h         Definuje strukturu vyplnnou rutinami pro pevod
                         asu asctime, localtime a gmtime, jako i typ
                         pouvan v rutinch ctime, difftime, gmtime,
                         localtime a stime. Poskytuje rovnا prototypy
                         tchto rutin.

          values.h       Definuje dleit konstanty vetn tch, kter
                         upravuj zvislost na konkrtnm potai. Slou
                         k zajitn kompatibility se systmem UNIX System
                         V.











                                  - 304 - 


---------------------------------------------------------------------------
Knihovn rutiny podle kategori
---------------------------------------------------------------------------


   Rutiny z knihovny Turbo C++ vykonvaj adu kol. V tomto oddlu rutiny
uvedeme spolen s  vkldacmi  soubory, v nich jsou deklarovny. Seadili
jsme  je  do  nkolika hlavnch kategori podle  vykonvanch  loh.  pln
informace o vech uvdnch funkcch naleznete ve spaen npovd.


Klasifikan rutiny
---------------------------------------------------------------------------

   Temito rutinami se znaky z kdu ASCII klasifikuj  jako  psmena, dic
znaky, interpunkce, horn poloha atd.

isalnum      (ctype.h)    isdigit      (ctype.h)    ispunct      (ctype.h)
isalpha      (ctype.h)    isgraph      (ctype.h)    isspace      (ctype.h)
isascii      (ctype.h)    islower      (ctype.h)    isupper      (ctype.h)
iscntrl      (ctype.h)    isprint      (ctype.h)    isxdigit     (ctype.h)


Pevodn rutiny
---------------------------------------------------------------------------

   Tyto  rutiny  pevdj  znaky a etzce  na  sla  s  rznm  vnitnm
zobrazenm (pohybliv teka, cel sla, dlouh sla) a opan, jako  i z
velkch psmen na mal a naopak.

atof         (stdlib.h)   itoa         (stdlib.h)   _tolower     (ctype.h)
atoi         (stdlib.h)   ltoa         (stdlib.h)   tolower      (ctype.h)
atol         (stdlib.h)   strtod       (stdlib.h)   _toupper     (ctype.h)
ecvt         (stdlib.h)   strtol       (stdlib.h)   toupper      (ctype.h)
fcvt         (stdlib.h)   strtoul      (stdlib.h)   ultoa        (stdlib.h)
gcvt         (stdlib.h)   toascii      (ctype.h)


Rutiny pro ovldn adres
---------------------------------------------------------------------------

   Tyto rutiny manipuluj s adresi a s nzvy cesty k souboru.

chdir        (dir.h)      fnsplit      (dir.h)      mkdir        (dir.h)
findfirst    (dir.h)      getcurdir    (dir.h)      mktemp       (dir.h)
findnext     (dir.h)      getcwd       (dir.h)      rmdir        (dir.h)
fnmerge      (dir.h)      getdisk      (dir.h)      searchpath   (dir.h)
                                                    setdisk      (dir.h)

Diagnostick rutiny
---------------------------------------------------------------------------

   Rutiny poskytuj vestavn prostedky pro odstraovn poruch.

assert       (assert.h)
matherr      (math.h)
perror       (errno.h)





                                  - 305 - 


Grafick rutiny
---------------------------------------------------------------------------

     Tyto rutiny umouj vytvet na obrazovce grafiku s textem.

arc                 (graphics.h)        _graphresult        (graphics.h)
bar                 (graphics.h)        imagesize           (graphics.h)
bar3d               (graphics.h)        initgraph           (graphics.h)
circle              (graphics.h)        installuserdriver   (graphics.h)
cleardevice         (graphics.h)        installuserfont     (graphics.h)
clearviewport       (graphics.h)        line                (graphics.h)
closegraph          (graphics.h)        linerel             (graphics.h)
detectgraph         (graphics.h)        lineto              (graphics.h)
drawpoly            (graphics.h)        moverel             (graphics.h)
ellipse             (graphics.h)        moveto              (graphics.h)
fillellipse         (graphics.h)        outtext             (graphics.h)
fillpoly            (graphics.h)        outtextxy           (graphics.h)
floodfill           (graphics.h)        pieslice            (graphics.h)
getarccoords        (graphics.h)        putimage            (graphics.h)
getaspectratio      (graphics.h)        putpixel            (graphics.h)
getbkcolor          (graphics.h)        rectangle           (graphics.h)
getcolor            (graphics.h)        registerbgidriver   (graphics.h)
getdefaultpalette   (graphics.h)        registerbgifont     (graphics.h)
getdrivername       (graphics.h)        restorecrtmode      (graphics.h)
getfillpattern      (graphics.h)        sector              (graphics.h)
getfillsettings     (graphics.h)        setactivepage       (graphics.h)
getgraphmode        (graphics.h)        setallpalette       (graphics.h)
getimage            (graphics.h)        setaspectratio      (graphics.h)
getlinesettings     (graphics.h)        setbkcolor          (graphics.h)
getmaxcolor         (graphics.h)        setcolor            (graphics.h)
getmaxmode          (graphics.h)        setcursortype       (graphics.h)
getmaxx             (graphics.h)        setfillpattern      (graphics.h)
getmaxy             (graphics.h)        setfillstyle        (graphics.h)
getmodename         (graphics.h)        setgraphbufsize     (graphics.h)
getmoderange        (graphics.h)        setgraphmode        (graphics.h)
getpalette          (graphics.h)        setlinestyle        (graphics.h)
getpalettesize      (graphics.h)        setpalette          (graphics.h)
getpixel            (graphics.h)        setrgbpalette       (graphics.h)
gettextsettings     (graphics.h)        settextjustify      (graphics.h)
getviewsettings     (graphics.h)        settextstyle        (graphics.h)
getx                (graphics.h)        setusercharsize     (graphics.h)
gety                (graphics.h)        setviewport         (graphics.h)
graphdefaults       (graphics.h)        setvisualpage       (graphics.h)
grapherrosmsg       (graphics.h)        setwritemode        (graphics.h)
_graphfreemem       (graphics.h)        textheight          (graphics.h)
_graphgetmem        (graphics.h)        textwidth           (graphics.h)

Rutiny pro vstupy/vstupy
---------------------------------------------------------------------------

     Tyto rutiny poskytuj  monosti  vstup/vstup na rovni stream i na
rovni operanho systmu DOS.

acces               (io.h)              getftime            (io.h)
cgets               (conio.h)           getpass             (conio.h)
_chmod              (io.h)              gets                (stdio.h)
chmod               (io.h)              getw                (stdio.h)
chsize              (io.h)              ioctl               (io.h)
clearerr            (stdio.h)           isatty              (io.h)
_close              (io.h)              kbhit               (conio.h)


                                  - 306 - 


close               (io.h)              lock                (io.h)
cprintf             (conio.h)           lseek               (io.h)
cputs               (conio.h)           _open               (io.h)
_creat              (io.h)              open                (io.h)
creat               (io.h)              perror              (stdio.h)
creatnew            (io.h)              printf              (stdio.h)
creattemp           (io.h)              putc                (stdio.h)
cscanf              (conio.h)           putch               (conio.h)
dup                 (io.h)              putchar             (stdio.h)
dup2                (io.h)              puts                (stdio.h)
eof                 (io.h)              putw                (stdio.h)
fclose              (stdio.h)           _read               (io.h)
fcloseall           (stdio.h)           read                (io.h)
fdopen              (stdio.h)           remove              (stdio.h)
feof                (stdio.h)           rename              (stdio.h)
ferror              (stdio.h)           rewind              (stdio.h)
fflush              (stdio.h)           scanf               (stdio.h)
fgetc               (stdio.h)           setbuf              (stdio.h)
fgetchar            (stdio.h)           setcursortype       (conio.h)
fgetpos             (stdio.h)           setftime            (io.h)
fgets               (stdio.h)           setmode             (io.h)
filelength          (io.h)              setvbuf             (stdio.h)
fileno              (stdio.h)           sopen               (io.h)
flushall            (stdio.h)           sprintf             (stdio.h)
fopen               (stdio.h)           sscanf              (stdio.h)
fprintf             (stdio.h)           stat                (sys\stat.h)
fputc               (stdio.h)           _strerror           (string.h,stdio.h)
fputchar            (stdio.h)           strerror            (stdio.h)
fputs               (stdio.h)           tell                (io.h)
fread               (stdio.h)           tmpfile             (stdio.h)
freopen             (stdio.h)           tmpnam              (stdio.h)
fscanf              (stdio.h)           ungetc              (stdio.h)
fseek               (stdio.h)           ungetch             (conio.h)
fsetpos             (stdio.h)           unlock              (io.h)
fstat               (sys\stat.h)        vfprintf            (stdio.h)
ftell               (stdio.h)           vfscanf             (stdio.h)
fwrite              (stdio.h)           vprintf             (stdio.h)
getc                (stdio.h)           vscanf              (stdio.h)
getch               (conio.h)           vsprintf            (stdio.h)
getchar             (stdio.h)           vsscanf             (io.h)
getche              (conio.h)           _write              (io.h)


Propojovac rutiny (DOS, 8086, BIOS)
---------------------------------------------------------------------------

     Tyto rutiny  poskytuj nkter monosti operanho systmu DOS, BIOS i
monosti podle konkrtnch pota.

absread      (dos.h)      geninterrupt (dos.h)      keep         (dos.h)
abswrite     (dos.h)      getcbrk      (dos.h)      MP_FP        (dos.h)
bdos         (dos.h)      getdfree     (dos.h)      outport      (dos.h)
bdosptr      (dos.h)      getdta       (dos.h)      outportb     (dos.h)
bioscom      (bios.h)     getfat       (dos.h)      parsfnm      (dos.h)
biosdisk     (bios.h)     getfatd      (dos.h)      peek         (dos.h)
biosequip    (bios.h)     getpsp       (dos.h)      peekb        (dos.h)
bioskey      (bios.h)     getvect      (dos.h)      poke         (dos.h)
biosmemory   (bios.h)     getverify    (dos.h)      pokeb        (dos.h)
biosprint    (bios.h)     harderr      (dos.h)      randbrd      (dos.h)
biostime     (bios.h)     hardresume   (dos.h)      randbwr      (dos.h)


                                  - 307 - 


country      (dos.h)      hardretn     (dos.h)      segread      (dos.h)
ctrlbrk      (dos.h)      inport       (dos.h)      setcbrk      (dos.h)
disable      (dos.h)      inportb      (dos.h)      setdta       (dos.h)
dosexterr    (dos.h)      int86        (dos.h)      setvect      (dos.h)
enable       (dos.h)      int86x       (dos.h)      setverify    (dos.h)
FP_OFF       (dos.h)      intdos       (dos.h)      sleep        (dos.h)
FP_SEG       (dos.h)      intdosx      (dos.h)      unlink       (dos.h)
freemem      (dos.h)      intr         (dos.h)


Manipulan rutiny
---------------------------------------------------------------------------

   Tmito  rutinami  se  oetuj  etzce  a  bloky  pamti:  koprovnm,
porovnvnm, pevody a vyhledvnm.

memccpy             (mem.h, string.h)   stricmp             (string.h)
memchr              (mem.h, string.h)   stricmpi            (string.h)
memcmp              (mem.h, string.h)   strlen              (string.h)
memcpy              (mem.h, string.h)   striwr              (string.h)
memicmp             (mem.h, string.h)   strncat             (string.h)
memmove             (mem.h, string.h)   strncmp             (string.h)
memset              (mem.h, string.h)   strncmpi            (string.h)
movedata            (mem.h, string.h)   strncpy             (string.h)
movmem              (mem.h, string.h)   strnicmp            (string.h)
setmem              (mem.h)             strnset             (string.h)
stpcpy              (string.h)          strpbrk             (string.h)
strcat              (string.h)          strrchr             (string.h)
strchr              (string.h)          strrev              (string.h)
strcmp              (string.h)          strset              (string.h)
strcoll             (string.h)          strspn              (string.h)
strcpy              (string.h)          strstr              (string.h)
strcspn             (string.h)          strtok              (string.h)
strdup              (string.h)          strupr              (string.h)
strerror            (string.h)          strxfrm             (string.h)


Matematick rutiny
---------------------------------------------------------------------------

     Tyto rutiny vykonvaj matematick vpoty a pevody.

abs            (complex.h, stdlib.h)       ldexp       (math.h)
acos           (complex.h, stdlib.h)       ldiv        (math.h)
arg            (complex.h)                 log         (complex.h, math.h)
asin           (complex.h, stdlib.h)       log10       (complex.h, math.h)
atan           (complex.h, stdlib.h)       _lrotl      (stdlib.h)
atan2          (complex.h, stdlib.h)       _lrotr      (stdlib.h)
atof           (stdlib.h, math.h)          ltoa        (stdlib.h)
atoi           (stdlib.h)                  _matherr    (math.h)
atol           (stdlib.h)                  matherr     (math.h)
bcd            (bcd.h)                     modf        (math.h)
cabs           (math.h)                    norm        (complex.h)
ceil           (math.h)                    polar       (complex.h)
_clear87       (float.h)                   poly        (math.h)
complex        (complex.h)                 pow         (complex.h, math.h)
conj           (complex.h)                 pow10       (math.h)
_control87     (math.h)                    rand        (stdlib.h)
cos            (complex.h, math.h)         random      (stdlib.h)
cosh           (complex.h, math.h)         randomize   (stdlib.h)


                                  - 308 - 


div            (math.h)                    real        (complex.h)
ecvt           (stdlib.h)                  _rotl       (stdlib.h)
exp            (math.h)                    _rotr       (stdlib.h)
fabs           (math.h)                    sin         (complex.h, math.h)
fcvt           (stdlib.h)                  sinh        (complex.h, math.h)
floor          (math.h)                    sqrt        (complex.h, math.h)
fmod           (math.h)                    srand       (stdlib.h)
_fpreset       (float.h)                   _status87   (float.h)
frexp          (math.h)                    strtod      (stdlib.h)
gcvt           (stdlib.h)                  strtol      (stdlib.h)
hypot          (math.h)                    strtoul     (stdlib.h)
imag           (complex.h)                 tan         (complex.h, math.h)
itoa           (stdlib.h)                  tanh        (complex.h, math.h)
labs           (stdlib.h)                  ultoa       (stdlib.h)


Rutiny pro prci s pamt
---------------------------------------------------------------------------

     Tyto rutiny  zajiuj dynamick pidlovn pamti v malch a velkch
datovch modelech.

allocmem          (dos.h)               farmalloc      (alloc.h)
brk               (alloc.h)             farrealloc     (alloc.h)
calloc            (alloc.h)             free           (alloc.h, stdlib.h)
coreleft          (alloc.h, stdlib.h)   heapcheck      (alloc.h)
farcalloc         (alloc.h)             heapchecknode  (alloc.h)
farcoreleft       (alloc.h)             heapwalk       (alloc.h)
farfree           (alloc.h)             malloc         (alloc.h, stdlib.h)
farheapcheck      (alloc.h)             realloc        (alloc.h, stdlib.h)
farheapcheckfree  (alloc.h)             farrealloc     (alloc.h)
farheapchecknode  (alloc.h)             sbrk           (alloc.h)
farheapfillfree   (alloc.h)             setblock       (dos.h)
farheapwalk       (alloc.h)

Rzn rutiny
---------------------------------------------------------------------------

     Tyto rutiny zajiuj monosti neloklnch skok,  zvukovch  efekt a
informac specifickch pro danou zemi {locale}.

delay       (dos.h)                     setjmp      (setjmp.h)
localeconv  (locale.h)                  setlocale   (locale.h)
longjmp     (setjmp.h)                  sound       (dos.h)
nosound     (dos.h)


Rutiny pro ovldn procesu
---------------------------------------------------------------------------

     Tmito rutinami lze z procesu vyvolvat a ukonovat procesy jin.

abort     (process.h)     execvp   (process.h)      spawnl   (process.h)
execl     (process.h)     execvpe  (process.h)      spawnle  (process.h)
execle    (process.h)     _exit    (process.h)      spawnlp  (process.h)
execlp    (process.h)     exit     (process.h)      spawnlpe (process.h)
execlpe   (process.h)     getpid   (process.h)      spawnv   (process.h)
execv     (process.h)     raise    (signal.h)       spawnve  (process.h)
execve    (process.h)     signal   (signal.h)       spawnvp  (process.h)
                                                    spawnvpe (process.h)


                                  - 309 - 


Standardn rutiny
---------------------------------------------------------------------------

     Jde o rutiny odpovdajc norm.

abort     (stdlib.h)      exit     (stdlib.h)       malloc   (stdlib.h)
abs       (stdlib.h)      fcvt     (stdlib.h)       putenv   (stdlib.h)
atexit    (stdlib.h)      free     (stdlib.h)       qsort    (stdlib.h)
atof      (stdlib.h)      gcvt     (stdlib.h)       rand     (stdlib.h)
atoi      (stdlib.h)      getenv   (stdlib.h)       realloc  (stdlib.h)
atol      (stdlib.h)      itoa     (stdlib.h)       srand    (stdlib.h)
bsearch   (stdlib.h)      labs     (stdlib.h)       strtod   (stdlib.h)
calloc    (stdlib.h)      lfind    (stdlib.h)       strtol   (stdlib.h)
ecvt      (stdlib.h)      lsearch  (stdlib.h)       swab     (stdlib.h)
_exit     (stdlib.h)      ltoa     (stdlib.h)       system   (stdlib.h)


Rutiny pro zobrazovn textovch oken
---------------------------------------------------------------------------

     Tyto rutiny umon vstup textu na obrazovku.

clreol         (conio.h)                normvideo        (conio.h)
clrscr         (conio.h)                puttext          (conio.h)
delline        (conio.h)                setcursortype    (conio.h)
gettext        (conio.h)                textattr         (conio.h)
gettextinfo    (conio.h)                textbackground   (conio.h)
gotoxy         (conio.h)                textcolor        (conio.h)
highvideo      (conio.h)                textmode         (conio.h)
insline        (conio.h)                wherex           (conio.h)
lowvideo       (conio.h)                wherey           (conio.h)
movetext       (conio.h)                window           (conio.h)


Rutiny pro datum a as
---------------------------------------------------------------------------

     Jde o rutiny pro pevody a manipulaci asovch daj.

asctime        (time.h)                 mktime           (time.h)
ctime          (time.h)                 setdate          (dos.h)
difftime       (time.h)                 settime          (dos.h)
dostounix      (dos.h)                  stime            (time.h)
ftime          (sys\timeb.h)            strftime         (time.h)
getdate        (dos.h)                  time             (time.h)
gettime        (dos.h)                  tzset            (time.h)
gmtime         (time.h)                 unixtodos        (dos.h)
localtime      (time.h)


Rutiny pro promnn seznam argument
---------------------------------------------------------------------------

   Tchto rutin se pouv k pstupu do promnnch seznam argument (jako
teba pro vprintf atd.).

   va_arg   (stdarg.h)
   va_end   (stdarg.h)
   va_start (stdarg.h)



                                  - 310 - 
      738136
