8. Zßklady OOP VIII

1. Obdobn∞ jako binßrnφ operßtory m∙╛eme p°et∞╛ovat i unßrnφ operßtory (! ~ + -). Pamatujme si pouze, ╛e pokud chceme definovat homonyma t∞chto operßtor∙ jako °adovΘ funkce, musφme je definovat jako funkce s jednφm parametrem (musφ b²t objektovΘho nebo v²ΦtovΘho typu). Pokud je definujeme jako metody, pak budou bez parametr∙ (operand bude instancφ, pro kterou tuto metodu volßme). Definujte ve t°φd∞ retezce homonyma unßrnφch operßtor∙ + a -, kterß budou p°evßd∞t °et∞zce na velkß resp. malß pφsmena.
2. V nßsledujφcφ ukßzce je uvedeno p°etφ╛enφ operßtor∙ inkrementace a dekrementace (++ a --). Uv∞domte si, ╛e tyto operßtory existujφ jako prefixovΘ a postfixovΘ. Prostudujte si p°et∞╛ovßnφ t∞chto operßtor∙.

class ID {
  int i;
  double d;
public:
  ID() {i = 1; d = 1.1; }
  ID& operator++(){i++; return *this;}
  ID operator++(int){ID id = *this; d+=0.1; return id;}
  friend ID& operator--(ID& x){x.i--; return x;}
  friend ID operator-- (ID& x, int){ID id = x; x.d-=0.1; return id;}
  friend ostream& operator<< (ostream& o, ID x){
    o << "[" << x.i << "; " << x.d << " ]" ;
    return o;
  }
};
int main(int argc, char **argv)
{
  ID a;
  cout << "PoΦßtek: " << a << endl;
  cout << "Preinkrement: " << ++a;
  cout << " - V²sledek " << a << endl;
  cout << "Postinkrement: " << a++;
  cout << " - V²sledek " << a << endl;
  cout << "Predekrement: " << --a;
  cout << " - V²sledek " << a << endl;
  cout << "Postdekrement: " << a--;
  cout << " - V²sledek " << a << endl;
  return 0;
}
Chceme-li p°etφ╛it prefixov² operßtor ++ nebo --, musφme jej definovat bu∩ jako metodu bez parametr∙, nebo jako b∞╛nou funkci s jednφm parametrem objektovΘho nebo v²ΦtovΘho typu. Chceme p°etφ╛it postfixov² operßtor musφme jej deklarovat bu∩ jako metodu s jednφm parametrem typu int, nebo jako b∞╛nou funkci se dv∞ma parametry, z nich╛ prvnφ je objektovΘho nebo v²ΦtovΘho typu a druh² je typu int.
Pov╣imn∞te si op∞t pou╛itφ anonymnφch parametr∙ (celoΦφseln² parametr v postfixov²ch operßtorech). Dßle si pov╣imn∞te jak donutφme operßtor, aby se choval postfixov∞ (p∙vodnφ hodnotu nejprve odlo╛φme, provedeme Φinnost operßtoru a nakonec odlo╛enou hodnotu vrßtφme. V souvislosti s prefixov²m a postfixov²m chovßnφm homonym musφme myslet i na typ vrßcenΘ hodnoty. U prefixov²ch operßtor∙ je v podstat∞ jedno, zda budeme vracet hodnotu, odkaz Φi ukazatel. Pokud operßtor p°ebφrß parametr odkazem vφ, ╛e dan² parametr existoval ji╛ p°ed volßnφm operßtoru, a m∙╛e proto vrßtit odkaz na n∞j. PostfixovΘ operßtory nemajφ na vybranou, musφ v²sledek vrßtit hodnotou.
3. V dal╣φm p°φkladu si ukß╛eme p°ekrytφ operßtoru indexovßnφ ([]). Jednou z nejΦast∞j╣φch v²hrad proti jazyku C je jeho neschopnost kontrolovat p°ekroΦenφ mezφ p°i prßci s poli. C++ p°inß╣φ prost°edky, kter²mi je mo╛no podobnΘ problΘmy °e╣it pom∞rn∞ elegantn∞ (viz nßsledujφcφ p°φklad):

#define LADENI 1                          //po odlad∞nφ zm∞nφme 1 na 0
class pole {
  const int n;                                  //poΦet prvk∙ pole
  int *const p;                                 //ukazatel na zaΦßtek pole
public:
  pole(int Mez) : n(Mez), p(new int[Mez]){};         //konstruktor vytvo°φ pole
  ~pole() {delete [] p;}
  int& operator[] (int);                                           //homonymum operßtoru indexace
  int prvku() {return n;}                                         //dotaz na poΦet prvk∙ pole
};
#if LADENI                                      //v∞tec aktivovanß pro fßzi lad∞nφ
int& pole::operator[] (int i) {
  assert((i>=0) && (i < n));
  return p[i];
}
#else                                               //v∞tev aktivovanß po odlad∞nφ
int& pole::operator[] (int i) {
  return p[i];
}
#endif
int main(int argc, char **argv)
{
  pole P(2);
  for (int s=0, i=0; i <= P.prvku(); i++){              //p°i poslednφm pr∙chodu je p°ekroΦena mez pole
    P[i] = i;
    s += P[i];
  }
  return 0;
}
V tomto p°φklad∞ je pou╛ito makro assert (je v hlaviΦkovΘm souboru assert.h), jeho╛ ·kolem je otestovat podmφnku, kterou mu p°edßme jako parametr. V p°φpad∞, ╛e tato podmφnka nenφ spln∞na, ukonΦφ se b∞h programu a do standardnφho chybovΘho v²stupu se zapφ╣e zprßva o chyb∞. Tato zprßva bude obsahovat jmΘno souboru a Φφslo °ßdku, na n∞m╛ se makro nachßzφ a testovanou podmφnku. Okno konzolovΘ aplikace je uzav°eno a my ╛ßdnou informaci nevidφme. Po odlad∞nφ programu zm∞nφme prvnφ °ßdek programu a dφky podmφn∞nΘmu p°ekladu bude makro z programu vypu╣t∞no.
P°i p°et∞╛ovßnφ operßtoru indexovßnφ nesmφme zapomenout, ╛e tento operßtor smφme p°etφ╛it pouze jako nestatickou metodu objektovΘho typu s jednφm parametrem. Mo╛nost p°et∞╛ovat tento operßtor p°ed nßmi otevφrß netu╣enΘ perspektivy, nap°.
• Mo╛nost indexovat strukturovan²mi datov²mi typy (nap°. textov²mi °et∞zci)
• Mo╛nost definovat pole, kterß se dynamicky zv∞t╣ujφ tak, aby se do nich ve╣ly v╣echny pot°ebnΘ polo╛ky.
• Mo╛nost definovat rozsßhlß pole, kterß se nevejdou do pam∞ti (Φßsti pole mohou b²t na disku).
• Mo╛nost elegantnφ a efektivnφ prßce s °φdk²mi maticemi a vφcerozm∞rn²mi poli.
Pokuste se pochopit prßci p°edchozφho programu.
4. Pokusφme se vy°e╣it problΘm ulo╛enφ symetrickΘ matice v pam∞ti, tj. ulo╛enφ pouze poloviny takovΘto matice. ProblΘm vy°e╣φme pomocφ p°etφ╛enφ operßtoru volßnφ funkce. Tento operßtor nßm umo╛≥uje pou╛φvat instanci danΘho objektovΘho typu jako funkci. Operßtory volßnφ funkce majφ oproti ostatnφm operßtor∙m jednu zvlß╣tnost: nemajφ p°esn∞ definovan² poΦet operand∙, tak╛e si jejich homonyma m∙╛eme zcela p°izp∙sobit sv²m pot°ebßm. V nßsledujφcφ ukßzce definujeme t°φdu symetrick²ch matic smat. V nφ p°etφ╛φme operßtor funkΦnφho volßnφ s dv∞ma celoΦφseln²mi parametry. Tento operßtor bude zastupovat maticov² operßtor indexovßnφ. Pro zjednodu╣enφ ukßzky (abychom nemuseli definovat dal╣φ metody) jsou zde v╣echny slo╛ky t°φdy deklarovßny jako ve°ejnΘ.

class smat {
public:
  int N;
  int NN;
  int *P;
  smat(int n);
  ~smat(){delete [] P;}
  int& operator()(int i, int j);
};
smat::smat(int n): N(n), NN(n*(n+1)/2), P(new int[NN]){
  int i, j;
  for (i=0; i<N; i++)
  for (j=0; j<N; j++)
  (*this)(i,j) = i*10+j;
}
int& smat::operator()(int i, int j){
  if (i<j) {int p=i; i=j; j=p;}
  return (this->P[(i*(i+1))/2+j]);
}
int main(int argc, char **argv)
{
  smat M(4);
  int i;
  for (i=0; i<4; i++) M(i,i) += 100 * M(i, i);
  for (i=0; i<M.NN; i++) cout << M.P[i] << ", ";
  return 0;
}
Pokuste se urΦit, jak tento p°φklad pracuje.
5. Jazyk C++ umo╛≥uje definovat jako metodu objektovΘho typu funkci, kterß bude provßd∞t p°etypovßnφ. JmΘno tΘto metody je tvo°eno klφΦov²m slovem operator, za kter²m uvedeme identifikßtor cφlovΘho typu. Operßtor p°etypovßnφ nemß parametry a v jeho deklaraci neuvßdφme typ vrßcenΘ hodnoty, nebo╗ ten je urΦen ji╛ jmΘnem tΘto funkce. Nap°.

operator int(); nebo operator void *();
Podφvejte se na nßsledujφcφ program:
class zlomek{
  long Cit, Jm;
public:
  zlomek(long C=0, long J=1) {Cit = C; Jm = J;}
  operator double() {return (double(Cit) / Jm);}
  zlomek operator * (zlomek& Z) {return zlomek(Cit*Z.Cit, Jm*Z.Jm);}
  friend ostream& operator<< (ostream &o, zlomek &z);
};
ostream& operator<< (ostream &o, zlomek &z){
  o << z.Cit << "/" << z.Jm;
  return o;
}
int main(int argc, char **argv)
{
  zlomek Z2(1,2);
  zlomek Z3 = 3;
  cout << "Z2 = " << Z2 << endl;
  cout << "Z3 = " << Z3 << endl;
  cout << "Z2 * Z3 = " << Z2 * Z3 << endl;
  cout << "Z2 * Z3 = " << double(Z2 * Z3) << endl;
  return 0;
}
V tomto programu pracujeme se t°φdou zlomek. V tΘto t°φd∞ je definovßn operßtor p°etypovßnφ na typ double (je pou╛it v poslednφm p°φkazu pro p°evod zlomku na reßlnΘ Φφslo). Vyzkou╣ejte, co se stane, kdy╛ v tomto programu nebude pou╛ito p°etφ╛enφ operßtoru <<. Zd∙vodn∞te dosa╛en² v²sledek.
6. V nov²ch verzφch C++ je mo╛no v definici t°φdy definovat nejen datovΘ slo╛ky a metody, ale i novΘ vno°enΘ (a tedy lokßlnφ) datovΘ typy. Vno°ovat p°itom m∙╛eme jak typy neobjektovΘ, tak i typy objektovΘ. S vno°enφm neobjektov²ch datov²ch typ∙ se m∙╛eme setkat nap°. v definici datov²ch proud∙, kterΘ jsou souΦßstφ standardnφ knihovny. Vno°enφ datov²ch typ∙ pou╛φvßme p°edev╣φm proto, abychom p°edem zamezili p°φpadnΘ mo╛nΘ zßm∞n∞ s dal╣φmi identifikßtory, resp. abychom neblokovali n∞kterΘ identifikßtory pro pozd∞j╣φ pou╛itφ. V takovΘm p°φpad∞ definujeme vno°en² datov² typ jako ve°ejn². Pokud chceme definovat datov² typ urΦen² pouze pro danou t°φdu a jejφ p°ßtele, definujeme jej jako soukrom². Pokud se budeme chtφt na datov² typ odvolßvat, musφme tak provΘst plnou kvalifikacφ (identifikßtor t°φdy, dv∞ dvojteΦky a jmΘno typu). V souboru IOSTREAM.H v definici t°φdy ios najdeme nap°. nßsledujφcφ vno°enΘ datovΘ typy:

class ios {
public:                        // stavovΘ bity proud∙
  enum io_state   {
       goodbit  = 0x00,        // v╣e OK
       eofbit   = 0x01,        // byl nalezen konec souboru
       failbit  = 0x02,        // poslednφ operace byla ne·sp∞╣nß
       badbit   = 0x04,        // pokus o nedovolenou operaci
       hardfail = 0x80         // blφ╛e nespecifikovanß chyba
  };
  enum open_mode  {       // re╛im proud∙ - p°i otevφrßnφ
       in   = 0x01,       // otev°φt pro Φtenφ
       out  = 0x02,       // otev°φt pro zßpis
       ate  = 0x04,       // po otev°enφ p°esun na konec souboru
       app  = 0x08,       // p°idßvej pouze na konec souboru
       trunc    = 0x10,   // existuje-li soubor, vyΦisti jej
       nocreate = 0x20,   // nesmφ se vytvo°it nov² soubor
       noreplace= 0x40,   // nesmφ se p°epsat existujφcφ soubor
       binary   = 0x80    // binßrnφ soubor
  };
  enum seek_dir { beg=0, cur=1, end=2 }; // referenΦnφ bod pro p°esuny
  enum    {                     // formßtovacφ p°φznaky
        skipws    = 0x0001,     // p°eskakuj na vstupu bφlΘ znaky
        left      = 0x0002,     // zarovnßvej v²stup vlevo
        right     = 0x0004,     // zarovnßvej v²stup vpravo
        internal  = 0x0008,     // zarovnßvej oboustran∞
        dec   = 0x0010,         // desφtkovß soustava
        oct   = 0x0020,         // osmiΦkovß soustava
        hex   = 0x0040,         // ╣estnßctkovß soustava
        showbase  = 0x0080,     // oznaΦ soustavu vystupujφcφch Φφsel
        showpoint = 0x0100,     // zobrazuj desetinnou teΦku
        uppercase = 0x0200,     // ╣estnßctkovΘ Φφslice velk²mi pφsmeny
        showpos   = 0x0400,     // zobraz + u kladn²ch Φφsel
        scientific= 0x0800,     // semilogaritmick² tvar
        fixed     = 0x1000,     // b∞╛n² tvar reßln²ch Φφsel
        unitbuf   = 0x2000,     // po zßpisu splßchni v╣echny proudy
        stdio     = 0x4000      // po zßpisu splßchni stdout a stderr
  };
 .....
Poslednφ z vno°en²ch v²Φtov²ch datov²ch typ∙ nemß dokonce ani jmΘno, tak╛e nem∙╛eme definovat ╛ßdnΘ jeho instance. Slou╛φ pouze k pojmenovßnφ formßtovacφch p°φznak∙.
V tΘto kapitole si zopakujeme a roz╣φ°φme informace o datov²ch proudech. DatovΘ proudy C++ jsou zalo╛eny na dvou hierarchiφch objektov²ch typ∙. Jednodu╣╣φ z nich je odvozena od t°φdy strembuf a obsahuje objekty, kterΘ tvo°φ vyrovnßvacφ pam∞ti pro datovΘ proudy. Potomci t°φdy streambuf obsahujφ metody specifickΘ pro proudy orientovanΘ na soubory, °et∞zce a konzolu. Programßtor obvykle o t∞chto t°φdßch nepot°ebuje v∞d∞t vφce, ne╛ ╛e existujφ. Pracujφ s nimi metody t°φdy ios a jejich potomk∙, kterΘ programßtor opravdu vyu╛φvß. Hierarchie odvozenß od ios je podstatn∞ rozv∞tven∞j╣φ.
T°φda ios je virtußlnφm p°edkem dal╣φch t°φd a je definovßna v iostream.h. Polo╛ky ios jsou chrßn∞nΘ a jsou tedy p°φstupnΘ i v odvozen²ch t°φdßch. T°φda ios obsahuje ukazatel na sdru╛en² objekt typu strembuf, tedy na p°idru╛enou vyrovnßvacφ pam∞╗. ios dßle obsahuje polo╛ku state typu int, kterß obsahuje p°φznaky mo╛n²ch chybov²ch stav∙ proudu (tedy vlastn∞ p°φznaky toho, zda se poslednφ vstupnφ nebo v²stupnφ operace s tφmto proudem poda°ila nebo k jakΘ chyb∞ do╣lo). Tyto p°φznaky popisuje ve°ejn∞ p°φstupn² v²Φtov² typ ios::io_state (viz v²╣e). Polo╛ka x_flags je typu long. Obsahuje formßtovacφ p°φznaky. Ty jsou popsßny pomocφ nepojmenovanΘho ve°ejn∞ p°φstupnΘho v²ΦtovΘho typu deklarovanΘho taktΘ╛ ve t°φd∞ ios. Dal╣φ t°i polo╛ky x_precision, x_width a x_fill jsou typu int a obsahujφ p°esnost (poΦet zobrazovan²ch desetinn²ch mφst), ╣φ°ku v²stupnφho pole a v²pl≥ov² znak. Implicitnφ hodnota prvnφch dvou je 0, u poslednφho je to mezera. V∞t╣ina metod t°φdy ios nastavuje nebo vracφ hodnoty polo╛ek (a tak zji╣╗uje stav proudu nebo urΦuje formßtovßnφ). Hodnoty jednotliv²ch stavov²ch bit∙ v polo╛ce state lze zji╣╗ovat pomocφ metod bad, eof, fail a good, kterΘ vracejφ hodnoty typu int. Nap°. p°φkaz
if (cout.bad()) Konec();
zp∙sobφ volßnφ funkce Konec, jestli╛e v proudu cout do╣lo k zßva╛nΘ chyb∞ (je nastaven p°φznak badbit v io_state). Volßnφm metody ios::clear lze nastavit nebo vynulovat p°φznaky chyb (krom∞ p°φznaku hardfail). Metoda ios::rdstate vracφ slovo obsahujφcφ v╣echny chybovΘ p°φznaky danΘho proudu (tedy polo╛ku state). Metoda long ios::flags vrßtφ hodnotu formßtovacφch p°φznak∙, ulo╛en²ch v polo╛ce x_flags. Metoda long ios::flags(long priznaky) vrßtφ p∙vodnφ hodnotu p°φznak∙ a nastavφ novΘ, danΘ jednotliv²mi bity parametru priznaky. Metody int ios::precision() a int ios::precision(int P) vracejφ p°esnost; druhß z nich takΘ nastavuje novou hodnotu p°esnosti. Metody int ios::width() a int ios::width(int s) vracejφ nastavenou ╣φ°ku vstupnφho nebo v²stupnφho pole; druhß z nich tuto ╣φ°ku takΘ nastavuje. Metoda long ios::setf(long priznaky) vratφ p°edchozφ nastavenφ formßtovacφch p°φznak∙ a nastavφ novou hodnotu, danou parametrem. Metoda char ios::fill(char vypln) vrßtφ p°edchozφ vypl≥ovacφ znak a nastavφ nov², dan² parametrem, zatφmco char ios::fill() vrßtφ pouze p∙vodnφ vypl≥ovacφ znak. Pro testovßnφ stavu datov²ch proud∙ se Φasto vyu╛φvajφ p°etφ╛enΘ operßtory ! a (void*). Operßtor ! vracφ 1, jestli╛e se poslednφ vstupnφ nebo v²stupnφ operace s proudem nepoda°ila. Operßtor (void*) vracφ nulu, pokud se poslednφ operace nepoda°ila a ukazatel na proud, jestli╛e prob∞hla v po°ßdku. Vrßcen² ukazatel nelze dereferencovat.
Od t°φdy ios jsou odvozeny t°φdy istream a ostream, kterΘ p°edstavujφ zßklad vstupnφch a v²stupnφch datov²ch proud∙, t°φda fstreambase, kterß je zßkladem proud∙, orientovan²ch na soubory a t°φda strstreambase, kterß je zßkladem pam∞╗ov²ch proud∙. TakΘ tyto t°φdy se v programech p°φmo nepou╛φvajφ. Od nich jsou pak odvozeny t°φdy fstream, strstream, istream_withassign, ostream_withassign a n∞kterΘ dal╣φ, kterΘ ji╛ opravdu slou╛φ ke vstupnφm a v²stupnφm operacφm. Pokud v²slovn∞ neuvedeme n∞co jinΘho, jsou tyto t°φdy deklarovßny v iostream.h.
T°φda istream je zßkladem vstupnφch proud∙. V tΘto t°φd∞ je pro ·Φely formßtovanΘho vstupu p°etφ╛en operßtor >>. Deklarace tohoto operßtoru pro typ int mß tvar
istream& istream::operator>> (int&);
Tento operßtor vracφ odkaz na datov² proud, pro kter² jej zavolßme. To znamenß, ╛e nap°. v²raz
cin >> i;
p°edstavuje odkaz na proud cin. Dφky tomu m∙╛eme p°etφ╛enΘ operßtory z°et∞zovat. Jestli╛e napφ╣eme
cin >> i >> j;
vyhodnotφ to p°ekladaΦ jako
(cin >> i) >> j;
nebo╗ operßtor se vyhodnocuje v po°adφ zleva doprava. To znamenß, ╛e se p°eΦte hodnota do prom∞nnΘ i a jako v²sledek se vrßtφ odkaz na proud cin. Takto vrßcen² odkaz na proud pak slou╛φ jako lev² operand p°i nßsledujφcφm Φtenφ do prom∞nnΘ j. Jestli╛e se p°i Φtenφ do prom∞nnΘ i n∞jak²m zp∙sobem zm∞nil stav proudu cin, bude nßsledujφcφ operace probφhat ji╛ se zm∞n∞n²m proudem. Ve t°φd∞ istream jsou mimo jinΘ definovßny metody istream::tellg a iostream::seekg. Prvnφ z nich umo╛≥uje zjistit aktußlnφ pozici v souboru, druhß umo╛≥uje tuto pozici zm∞nit.
T°φda ostream je zßkladem v²stupnφch datov²ch proud∙. Je v nφ p°etφ╛en operßtor <<, kter² slou╛φ k formßtovanΘmu v²stupu. Definice tohoto operßtoru p°i int mß tvar:
inline ostream& ostream::operator<< (int _i) {
  return *this << (long) _i;
}
Tento operßtor konvertuje lev² operand na hodnotu typu long a pou╛ije operßtor << pro tento typ; pak vrßtφ odkaz na proud, pro kter² jsme jej zavolali. To op∞t umo╛≥uje z°et∞zenφ n∞kolika v²stupnφch operßtor∙ v jednom v²razu. V tΘto t°φd∞ jsou takΘ definovßny metody ostream::tellp a ostream::seekp. Prvnφ z nich zjistφ aktußlnφ pozici v proudu, druhß z nich umo╛≥uje aktußlnφ pozici zm∞nit.
T°φda iostream je spoleΦn²m potomkem t°φd istream a ostream. Spojuje jejich vlastnosti, obsahuje tedy prost°edky pro vstup i pro v²stup. Ke zd∞d∞n²m vlastnostem nep°idßvß nic novΘho.
T°φda ostream_withassign je potomkem t°φdy ostream. Navφc je v nφ definovßn p°i°azovacφ operßtor, kter² umo╛≥uje sdru╛it objekt tΘto t°φdy s objektem typu streambuf. Tφm, ╛e se zm∞nφ vyrovnßvacφ pam∞╗, se proud p°esm∞ruje. V hlaviΦkovΘm souboru iostream.h jsou definovßny standardnφ instance
extern ostream_withassign cout;
extern ostream_withassign cerr;
extern ostream_withassign clog;
Proud cout slou╛φ k formßtovanΘmu v²stupu do stdout, proudy cerr a clog p°edstavujφ standardnφ chybov² v²stup. Proud cerr nenφ vybaven vyrovnßvacφ pam∞tφ, proud clog je.
T°φda istream_withassign je potomkem t°φdy istream. Je v nφ takΘ definovßn p°i°azovacφ operßtor, kter² umo╛≥uje sdru╛it instanci tΘto t°φdy s objektem typu streambuf a tak jej p°esm∞rovat. V hlaviΦkovΘm souboru iostream.h je definovßna standardnφ instance
extern istream_withassign cin;
kterß slou╛φ k formßtovanΘmu vstupu z stdin.
Existuje je╣t∞ n∞kolik dal╣φch t°φd datov²ch proud∙. Nebudeme se jini ji╛ zab²vat. T°φdy souborov²ch proud∙ byly ji╛ popsßny.
Podφvejme se nynφ na prost°edky pro formßtovßnφ vstup∙ a v²stup∙. Pou╛φvajφ se k tomu p°edev╣φm manipulßtory, co╛ jsou objekty, kterΘ lze vklßdat do proud∙ a tφm n∞jak ovlivnit stav proudu (nap°. zm∞nit formßtovacφ p°φznaky). Seznam manipulßtor∙ je uveden v nßsledujφcφ tabulce.

Manipulßtor	V²znam
dec, hex, oct	Nßsledujφcφ vstupy nebo v²stupy v tomto proudu budou probφhat v desφtkovΘ, resp. ╣estnßctkovΘ, resp. osmiΦkovΘ soustav∞.
setbase(n)	P°edepisuje Φφselnou soustavu (p°i n=8,10 nebo 16) nebo implicitnφ stav (p°i n=0).
endl	Vlo╛φ do proudu znak od°ßdkovßnφ a splßchne vyrovnßvacφ pam∞╗.
ends	Vlo╛φ na konec °et∞zce znak '\0'.
flush	Splßchne proud.
resetiosflags(n)	Vynuluje formßtovacφ p°φznaky (ulo╛enΘ v x_flags) urΦenΘ parametrem n.
setiosflags(n)	Nastavφ formßtovacφ p°φznaky (ulo╛enΘ v x_flags) urΦenΘ parametrem n.
setfill(n)	Definuje vypl≥ovacφ znak.
setprecision(n)	Nastavφ p°esnost reßln²ch Φφsel.
setw(n)	Nastavφ ╣φ°ku v²stupnφho pole; t²kß se pouze nßsledujφcφ v²stupnφ operace.
ws	P°eskoΦφ na vstupu bφlΘ znaky.

K nastavovßnφ nebo nulovßnφ formßtovacφch p°φznak∙ pou╛φvßme manipulßtory setiosflags a resetiosflags. Tyto manipulßtory pracujφ s p°φznaky, jejich╛ bity jsou v parametru n rovny 1. Hodnotu prametru poklßdßme za bitov² souΦet hodnot jednotliv²ch formßtovacφch p°φznak∙. Nap°.
cout << setiosflags(ios::showpoint | ios::showpos);
nastavφ p°φznak zobrazovßnφ desetinnΘ teΦky (zp∙sobuje takΘ, ╛e se vypisujφ koncovΘ nuly) a p°φznak v²pisu znamΘnka.

8. Zßklady OOP VIII