Programovací jazyk C++ Jiří Vogel

edničku. Dále sestavme spřátelenou funkci, která bude schopna tento privátní údaj vytisknout.
Řeąení:
Program je jednoduchý a snad i jasný. Zajímavé je na něm jen umístění prototypu spřátelené funkce. Je lhostejné, je-li umístěn v části private nebo public. Funkce pracuje s formálním parametrem typu zvec, který voláme odkazem pro uąetření místa. Je samozřejmé, ľe lze pouľít i standardní volání hodnotou, které je opět rychlejąí.
#include
class zvec
{
private:
int hodn;
// Prototyp spratelene funkce
friend void print(zvec &);
public:
// Vnitrni funkce tridy (vcetne konstruktoru)
zvec(int n=0){hodn=n;}
void pricti(){hodn++;}
};
// Definice spřátelené funkce
void print(zvec &i){printf("hodnota = %d\n",i.hodn);}
#include"friendf.h"
main()
{ zvec z(10000); z.pricti();
/* Nasleduje pouziti spratelene funkce: */print(z);
z.pricti();/* a opet spratelena funkce: */print(z);
}
Příklad 6.5. Sestavme stejný program jako v příkladu 6.2 s tím rozdílem, ľe jednotlivé celočíselné hodnoty se budou číst z klávesnice, při čemľ nejprve udáme, kolik jich budeme číst. Navíc budeme definovat spřátelenou třídu, která zařadí nový objekt na správné místo seznamu, budeme-li předpokládat, ľe prvky seznamu tvoří klesající posloupnost.
Řeąení:
Opět je třeba zdůraznit, ľe i spřátelenou třídu je moľno uvést v oblasti public i private. Pro zjednoduąení algoritmu se v programu předpokládá klesající posloupnost zařazených hodnot seznamu. Objekty seznamu se tvoří öd zadu", tj. první udaný objekt z klávesnice je v seznamu umístěn jako poslední.
// Soubor friendc.h - hlavickovy soubor
#include
#include
class objekt //Tato trida vlastne nahrazuje strukture
{
private:
objekt *dalsi;
int hodnota;
friend class seznam;
friend class zarad_objekt;
};
class seznam // Spratelena trida seznam
{
private:
objekt *zac_sez;
objekt *pom_prv;
friend class zarad_objekt;
public:
seznam()
{
zac_sez=NULL;
}
void vytvor_seznam(int);
void tiskni_seznam();
void cisteni_pameti();
~seznam(){cisteni_pameti();}
};
class zarad_objekt /* Spratelena trida zarad_objekt k objektu
i seznamu */
{
private:
objekt *novy_objekt;
objekt *predchozi_objekt;
public:
zarad_objekt(){novy_objekt=new objekt[1];}
void zarad(seznam &);
};
// Soubor friendc.cpp - implementace metod
#include"friendc.h"
void seznam:: cisteni_pameti()
{
objekt *pred=zac_sez;
if(pred==NULL)return;
do
{objekt *predpred=pred;
pred=pred->dalsi;
delete predpred;
}while(pred!=0);
}
void seznam::vytvor_seznam(int pocet=10)
{
printf("\nCti %d prvku \n",pocet);
zac_sez=NULL;pom_prv=new objekt;
for (int i=pocet;i>=1;i--)
{
scanf("%d",&pom_prv->hodnota);
pom_prv->dalsi=zac_sez;
zac_sez=pom_prv;
pom_prv=new objekt;
}
}
void seznam::tiskni_seznam()
{
pom_prv=zac_sez;
int i = 0;
while(pom_prv!=0)
{
i++;
printf("adresa %d. objektu = %p a jeho hodnota = %d\n",i,
pom_prv,pom_prv->hodnota);
pom_prv=pom_prv->dalsi;
}
}
void zarad_objekt::zarad(seznam &s)
{
printf("\nCti hodnotu noveho objektu\n");
scanf("%d",&novy_objekt->hodnota);
predchozi_objekt=s.pom_prv=s.zac_sez;
while(s.pom_prv!=NULL)
{
if(s.pom_prv->hodnotahodnota)
if(s.pom_prv==s.zac_sez)
{novy_objekt->dalsi=s.pom_prv;
s.zac_sez=novy_objekt;break;
}
else
{
novy_objekt->dalsi=s.pom_prv;
predchozi_objekt->dalsi=novy_objekt;break;
}
else
if(s.pom_prv->dalsi==NULL)
{
novy_objekt->dalsi=NULL;s.pom_prv->dalsi=novy_objekt;
break;
}
{
predchozi_objekt=s.pom_prv;s.pom_prv=s.pom_prv->dalsi;
}
}
}
// Soubor frhlac.cpp - hlavni program
#include "friendc.cpp"
main()
{
seznam sez;zarad_objekt a;
printf("\nCti pocet clenu seznamu\n");
int n;
scanf("%d",&n);
sez.vytvor_seznam(n);
sez.tiskni_seznam();
a.zarad(sez);
sez.tiskni_seznam();
}

4.  Přetíľené operátory
V odstavci jsme mluvili o přetíľených funkcích. Nyní se jeątě stručně zmíníme o přetíľených operátorech. Máme-li moľnost definovat objekty nových typů, musíme mít také moľnost definovat nové operátory, kterými realizujeme operace nad těmito objekty. Můľeme si vymýąlet názvy nových operátorů, ale můľeme pouľít operátorů, na které jsem zvyklí. Dejme si příklad. Představme si, ľe si definujeme operaci sčítání nad nějakými dvěma námi definovanými objekty z1, z2 (třeba komplexním hodnotami). Můľeme to učinit standardním způsobem tak, ľe napíąeme
z1.pricti(z2);
nebo
z2.pricti(z1);
To znamená, ľe poąleme zprávu "přičti hodnotu z2" objektu z1 nebo zprávu objektu z2 o "přičtení objektu z1. To je méně přehledné, neľ zápis
z1 + z2.
Operátor + můľeme tudíľ přetíľit o daląí typ na který je aplikovatelný. Můľeme samozřejmě definovat operátor * jako operátor sčítání; kompilátoru (a matematikům) to nevadí, ale normálním lidem ano, proto se takovéto transakce nedoporučují.
Neľ budeme pokračovat ve výkladu, osvětleme si stručně slovní symbol this. Tento slovní symbol (česky znamenající "tento, tato, toto") je v jazyku C++ definován jako ukazatel na objekt, který posílá zprávu sám sobě. Ve větąině případů se nemusí tento ukazatel explicitně zapisovat, ale někdy, jak v závěrečném příkladu tohoto článku uvidíme, ano.
Binární operátory (tj. operátory mající dva operandy) jako např. +, -, *, / atd. se mohou definovat jako metody s jedním parametrem uvnitř třídy (druhým parametrem je pak vľdy this nebo jako spřátelené funkce se dvěma parametry. Unární operátory (tj. operátory s jedním operandem) se mohou definovat jako metody bez parametru uvnitř třídy, nebo jako spřátelená funkce s jedním parametrem. Tedy výraz
operand_1 B operand_2můľe být interpretován jako
operand_1.operatorB(operand_2)nebo
operatorB(operand_1,operand_2).
Uvaľujme výraz vyjádřený unárním operátorem U
operandU
nebo
Uoperand.
Ten můľe být interpretován jako
operand.operatorU()nebo
operatorU(operand).
Přetěľujeme-li operátory ++ a - nelze odliąit prefixovou a postfixovou aplikaci. Někdy je pouľití spřátelené funkce nezbytné. Např. z+27 lze zapsat jako z.operator+(27) ovąem zápis 27+z zapsaný jako 27.operator(z) je nesmyslný, protoľe 27 není objekt definovaný uľivatelem. Uvedený příklad je natolik ilustrativní, ľe lze doporučit binární operace definovat výhradně jako spřátelené funkce.
Příklad 6.6. Zapiąme program z příkladu 6.1 tak, ľe počitadlo vylepąíme uľitím přetíľených operátorů ++ a -.
Řeąení:
/***********************************************************************
* Hlavickovy soubor pro lepsi popis tridy pocitadlo s vyuzitim preti- *
* zenych operatoru ++ a -- *
***********************************************************************/
//Soubor vlp_pctd.h
#include
class pocitadlo
{
private:
unsigned int hodnota;
public:
pocitadlo(){hodnota=0;} // Konstruktor s nulovanim data hodnota
// Prototypy operatoru
void operator++();
void operator--();
unsigned operator()();
};
//Implementace metod vylepsene tridy pocitadlo
//Soubor vlp_pctd.cpp
#include"vlp_pctd.h"
void pocitadlo::operator ++()
{
if (hodnota0)
hodnota--;
}
unsigned int pocitadlo::operator ()()
{
return hodnota;
}
//Test programu pro vylepsene pocitadlo
//File vlp_pctt.cpp
#include "vlp_pctd.cpp"
#include
void main()
{
pocitadlo me_nepostradatelne_pocitadlo;
for(int i=0;i