Vítejte v šestém dílu malého seriálu o jazyku Object Pascal pro začátečníky. Počtvrté se budeme zabývat objektově orientovaným programováním. V předchozím dílu jsme po analýze a návrhu zkoušeli OOP na řešení kvadratické rovnice, ale nedošlo už na druhé vylepšení: použití jednotky (knihovny) v Delphi. To doplníme do programu dnes. Možná jste podle stručného návodu z minulého dílu totéž už naprogramovali (neboli implemetnovali), pak bude dnešní povídání a zdrojový text pro vás spíš opakováním. Přeji vám pohodu při čtení!

Úvod

V šestém dílu seriálu o jazyku Object Pascal pokračujeme v objektově orientovaném programování (OOP) a konečně dojde také na další pilíř efektivnějšího programování: knihovny neboli jednotky. V první kapitole tohoto dílu se vrátíme k jednotkám, o kterých se psalo krátce už v závěru páté části. Druhá kapitola je pak věnována verzi programu, který byl uveden v páté části, zde ale konečně s pomocí unit (jednotek, knihoven). Nakonec přijdou úkoly na příště.

O výhodách OOP jste už asi přesvědčeni (nebo vás postupně přesvědčí jeho další používání). Jde i o dobrou průpravu pro studium dalších jazyků: i když v Pascalu se dá programovat i postaru - procedurálně - v Javě a novějších jazycích už se bez OOP neobejdeme vůbec.

Nyní se podívejme na jednotky neboli knihovny či unity. I ty jsou velkými pomocníky a jistě je budete rádi používat, ať v Pascalu, nebo v jiném jazyku.

Knihovny v Object Pascalu

Zopakujme si, o co se jedná: K hlavnímu programu můžeme přiložit knihovnu neboli jednotku (unit), která bude obsahovat samostatnější část kódu - v našem případě definici třídy a jejích metod.

Jaké jsou výhody použití jednotky?

• Zpřehlední se zdrojový kód programu. Je snazší prohlédnout si kratší kód vlastního programu a kratší kód jednotky (v praxi spíše mnoha jednotek) než vše v jednom obrovském souboru.
• Snazší práce na programu. Je snazší upravovat kratší soubory než jeden obrovský a práce se dá snáze rozdělit mezi víc spolupracovníků.
• Znovupoužitelnost kódu. To je asi hlavní výhoda použití knihoven. Jakmile jednu užitečnou knihovnu napíšete, můžete ji později snadno přiložit k libovolnému jinému programu!

V dalším textu si uvedeme:

1. Jak jednotku vytvořit, popř. připojit hotovou jednotku k programu.
2. Jak jednotka vypadá - z jakých částí se skládá.

Nakonec naprogramujeme jednotku pro náš příklad řešení kvadratické rovnice.

ad 1. Vytvoření jednotky nebo její připojení k programu v Object Pascalu

Jednotku vytvoříme volbou File > New > Unit. Tím se otevře nejen nová záložka okna zdrojového kódu pro psaní textu nově vytvořené jednotky, ale zároveň se jednotka automaticky připojí ke konzolové (nebo formulářové) aplikaci. Přesvědčíme se o tom nahlédnutím do zdrojového kódu původní aplikace, ve kterém se v části uses, která obsahuje názvy připojených jednotek, objeví nový řádek s přednastaveným názvem jednotky Unit1:

uses
  SysUtils,
  Unit1 in 'Unit1.pas'; // automaticky byla pripojena jednotka Unit1

Všimněte si, že jednotky se v seznamu oddělují čárkami a na závěr popisu jednotek se samozřejmě napíše středník. Také vidíme, že jednotka v Object Pascalu je soubor s příponou .pas.

Otázka 1: Příponu .pas měly ve starších prostředích Pascalu i samotné programy. Jak už ale víte, v Object Pascalu byla hlavnímu programu (ať už v konzolové aplikaci, nebo v programu s formulářem - k tomu přejdete později) přiřazena přípona jiná. Vzpomenete si jaká? (Odpověď je na konci článku.)

Jestliže bychom chtěli připojit k programu už existující jednotku, použijeme tlačítko souboru s modrým plusem, u kterého se objevuje popisek Add file to project (Shift+F11), popř. odpovídající volbu z hlavní nabídky Project > Add to project... Tím se otevře dialogové okno, ve kterém vyhledáme jednotku (soubor s příponou .pas) a potvrdíme její vložení. Opět se pak otevře další záložka s připojenou knihovnou v okně zdrojových kódů a i v tomto případě se připojení hned projeví v kódu hlavního programu, např. takto:

uses
  SysUtils,
  Unit1 in 'Unit1.pas',
  U_matem_funkce in 'JS\řešení rovnice koresp. seminář\U_matem_funkce.pas';

Pokud je součástí projektu více jednotek, zobrazíme si jejich seznam snadno pomocí ikony zcela vlevo na panelu nástrojů View (zobrazuje se u ní pomocný text View Unit (Ctrl+F12)) nebo odpovídající volbou z horní nabídky View > Units...

Jestliže chcete naopak jednotku z projektu odstranit, použijete ikonu s červeným mínusem (pomocný text Remove file from project) nebo volbu Project > Remove from project...

Je dobře možné, že i připojená jednotka (označme ji yyy.pas) bude ke své činnosti potřebovat další knihovnu, např. zzz.pas. Jakmile ji přizvete ke spolupráci (tedy připojíte k programu), objeví se odkaz na ni v hlavním programu (např. xxx.dpr), ale do jednotky yyy.pas ji musíte příkazem uses už připojit sami! Uděláte to jednoduše jen napsáním názvu jednotky (bez slova in a označení cesty k jednotce). Ukazují to následující výpisy. Nejdřív hlavní program:

program xxx;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  yyy in 'yyy.pas',  // tyto jednotky byly automaticky pripojeny
  zzz in 'zzz.pas';  //   k hlavnimu programu prostredim Delphi

begin
  { TODO -oUser -cConsole Main : Insert code here }
end.

A potom jednotka yyy.pas, která ke své práci potřebuje jednotku zzz.pas:

unit yyy;

interface // Zde zacina rozhrani jednotky, ktere obsahuje definici trid 
           // s hlavickami metod, popr. hlavicky jinych verejnych procedur a funkci.

uses zzz.pas;  // V jednotce musime dalsi jednotku pripojit (napsat do uses) sami.

implementation  // Zde zacina implementacni cast jednotky. V ni nadeklarujeme (rozepiseme)
               // metody trid, popr. nadeklarujeme neverejne procedury a funkce.

end.        // Prikaz end. (end s teckou) konci celou jednotku.

Je pravděpodobné, že občas zapomenete do jednotky yyy.pas připsat potřebnou další knihovnu zzz.pas. Toto za vás ale Delphi opravdu udělat nemohou (leda že by připojily takovou knihovnu rovnou ke všem jednotkám projektu, ale neděje se to tak). Poznáte to ovšem hned tak, že Delphi budou hlásit, že metody z knihovny zzz.pas, které chcete v yyy.pas použít, jednotka yyy.pas nezná. Pak do její části uses knihovnu zzz.pas připíšete a bude vše v pořádku.

ad 2. Stavba jednotky

• Název jednotky.
• Část interface neboli rozhraní. Tato část obsahuje sekci uses pro připojení dalších knihoven, které jednotka ke své činnosti potřebuje. Hlavně ale sděluje, které třídy, popř. samotné procedury nebo funkce, jednotka obsahuje neboli co může okolí z jednotky použít. Je to tedy jakási dohoda nebo závazek pro program, ke kterému knihovnu přiložíme. Do části interface umístíme tedy popis třídy (její atributy - proměnné - a jen hlavičky jejích metod - procedur a funkcí), popř. hlavičky samostatných procedur nebo funkcí mimo jakoukoli třídu.
• Část implementation čili implementaci - naprogramování - metod tříd nebo samotných procedur a funkcí, deklarovaných v předchozí části interface.
  Pozor: Jde-li o implementaci metod třídy, musí se v části implementation objevit před názvem metody i název třídy, ke které metoda patří, ve stylu nazevTridy.nazevMetody(parametry), čili opět se setkáváme s tečkovou notací.

Program pro řešení kvadratické rovnice pomocí jednotky

Vraťme se tedy k programu z minulého dílu. Nyní ale vytvoříme k programu knihovnu, do které umístíme deklaraci třídy pro řešení rovnice. Zopakujme si, jaké to má výhody. První dvě jen připomínám, v našem krátkém prográmku se ještě neprojeví. Třetí je ale už i zde významná.

• Zpřehlední se zdrojový kód programu. Samotný program bude kratší, snáze se dá pochopit.
• Snazší práce na programu. Je snazší upravovat kratší soubor, práce se dá snáze rozdělit mezi víc spolupracovníků.
• Znovupoužitelnost kódu. Tato výhoda je vidět i v našem malém programu. Jakmile jednu knihovnu např. pro řešení kvadratické rovnice napíšete, můžete ji později snadno přiložit k libovolnému jinému programu, kde by se mohla hodit. O tom, jak bychom ji měli použít, nás informuje její rozhraní. Samozřejmě bychom měli důkladně používat komentáře, ať i ten, kdo knihovnu nezná, rychle pochopí, jak s ní pracovat.

Naším úkolem tedy je vyjmout z hlavního programu deklaraci třídy a vložit ji do samostatné jednotky. V programu už zbude samotný kód, využívající metody třídy z knihovny, čili jen vytvoření rovnice, žádost o její vyřešení a výpis kořenů.

Protože máme deklaraci třídy pěkně napsánu v hlavním programu, bude naše práce už velmi jednoduchá. Kroky postupu si očíslujme:

1. vytvoříme novou jednotku a vhodně ji pojmenujeme,
2. z původního programu vyjmeme nejdřív definici třídy s hlavičkami metod a vložíme ji do části interface nové jednotky,
3. z původního programu vyjmeme deklarace samotných metod třídy a vložíme je do části implementation nové jednotky.

Protože se při vytvoření jednotky automaticky vytvořil odkaz na ni v hlavním programu, bude tím už vše hotovo a program by měl fungovat.

Přikládám nejdřív výpis jednotky, kterou jsem při uložení pojmenoval podle třídy, v jednotce uložené: U_TKvadrRovnice.pas (U jako Unit. Doporučuji ukládat soubory hned při jejich vytvoření). Za výpisem bude poznámka ke změnám v kódu.

unit U_TKvadrRovnice;

interface

// sem by prisla cast uses

type
//**** definice třídy pro řešení kvadratické rovnice
  TKvadrRovnice = class
    private
      a: real;
      b: real;
      c: real;
      x1: real;
      x2: real;
      pocetKorenu: integer;
      procedure najdiKoreny();
    public
      constructor vytvorRovnici();
      procedure zadejKoeficienty(a, b, c: real);
      function vratKoefA(): real;
      function vratKoefB(): real;
      function vratKoefC(): real;
      function vratPocetKorenu(): integer;
      function vratKorenX1(): real;
      function vratKorenX2(): real;
  end;
//**** konec definice třídy, musí následovat ještě definice metod,
// zde ale az v casti implementation

implementation

//**** definice metod ke třídě (instancím třídy) TKvadrRovnice

//** soukromá metoda najdiKoreny, určí z koeficientů a, b, c kořeny rovnice,
  // pokud existují, a určí také počet kořenů a vloží ho do atributu
  // pocetKorenu dané instance
procedure TKvadrRovnice.najdiKoreny();
  // lokální proměnné této metody
  var D, odmD: real;
    x1, x2: real;
  begin
    // diskriminant
    D := self.b * self.b - 4 * self.a * self.c; // slovo "self" je odkazem
      // na instanci, která právě metodu používá.
      // Není zde nutné, ale doporučuji ho používat
    // určení počtu kořenů a jejich výpočet
    if D > 0
      then
        begin // budou dva kořeny
          self.pocetKorenu := 2;
          // připravíme si odmocninu z D, ať se nemusí opakovaně počítat
          odmD := sqrt(D);
          self.x1 := (-self.b - odmD) / (2 * self.a);
          self.x2 := (-self.b + odmD) / (2 * self.a);
        end // zde ještě nekončí podmíněný příkaz, nepíšeme tedy středník
      else if D = 0
        then
          begin // bude jeden kořen
            self.pocetKorenu := 1;
            self.x1 := -self.b / (2 * self.a);
          end
        else self.pocetKorenu := 0; // nebude žádný kořen
  end;

//** veřejný konstruktor, který vytvoří instanci (kdvadratickou rovnici)
  // s přednastavenými hodnotami koeficientů např. a = 1, b = 2, c = 1.
  // Tato rovnice by měla mít jediný kořen x = -1 a může posloužit jako
  // rychlý test programu
  // Konstruktor také hned rovnici vyřeší - určí počet kořenů a kořeny
  // privátní metodou najdiKoreny()
constructor TKvadrRovnice.vytvorRovnici();
  begin
    self.a := 1;
    self.b := 2;
    self.c := 1;
    self.najdiKoreny;
  end;

//** veřejná procedura zadejKoeficienty() pro možnost zadání koeficientů
  // instanci (kvadrat. rovnici, kterou chceme vyřešit)
  // Po zadání koeficientů se rovnice ihned vyřeší - určí počet kořenů a kořeny
  // privátní metodou najdiKoreny(), stejně jako u konstruktoru.
procedure TKvadrRovnice.zadejKoeficienty(a, b, c: real);
  begin
    self.a := a;
    self.b := b;
    self.c := c;
    self.najdiKoreny;
  end;

//** 3 veřejné funkce vratKoefA, B, C pro výpis koeficientů rovnice a, b, c
  // pouze hodnotu koeficientů vrátí do programu příkazem result.
function TKvadrRovnice.vratKoefA(): real;
  begin
    result := self.a;
  end;

function TKvadrRovnice.vratKoefB(): real;
  begin
    result := self.b;
  end;

function TKvadrRovnice.vratKoefC(): real;
  begin
    result := self.c;
  end;

//** veřejná funkce vratPocetKorenu() pro výpis počtu kořenů rovnice
  // pouze hodnotu počtu kořenů vrátí do programu příkazem result.
function TKvadrRovnice.vratPocetKorenu(): integer;
  begin
    result := self.pocetKorenu;
  end;

//** veřejná funkce vratKorenX1() pro výpis prvního kořene rovnice
  // pouze hodnotu kořene vrátí do programu příkazem result.
function TKvadrRovnice.vratKorenX1(): real;
  begin
    result := self.x1;
  end;

//** veřejná funkce vratKorenX2() pro výpis druhého kořene rovnice
  // pouze hodnotu kořene vrátí do programu příkazem result.
function TKvadrRovnice.vratKorenX2(): real;
  begin
    result := self.x2;
  end;

end.

Komentář k výpisu jednotky:

• Do této jednotky nebylo nutné přidávat další pomocnou knihovnu, ale naznačil jsem komentářem, kam by přišel příkaz uses: do části interface.
• Dál se v deklaraci třídy TKvadrRovnice v knihovně oproti původnímu programu nic nezměnilo. Dodávám jen, že konstruktor má v Delphi tradičně spíš název Create, čehož se v dalších ukázkách už budu držet. Náš název vytvorRovnici() je sice výmluvnější, ale pokud by později jednotku používal jiný programátor, bude hledat konstruktor spíše pod standardním názvem Create.
• Podobně názvy metod pro zadávání hodnot atributů nebo vracení jejich hodnot do programu nebudu už příště začínat slovy zadej a vrat, ale tradičními názvy set a get. Podle nich se někdy "zadávacím" procedurám říká "setry" a "vracejícím" procedurám či funkcím "getry".
• Jak už bylo napsáno v návrhu třídy v předchozím, pátém dílu seriálu, je diskutabilní, jestli je vhodný konstruktor, který zadá rovnou koeficienty rovnice (v našem případu a=1, b=2, c=1). Jako počáteční zadání pro rychlé vyzkoušení fungování programu to není špatné, ale při našem návrhu třídy má toto řešení jednu dost velkou nevýhodu. Toho se týká následující otázka 2 (a také úkol 1, který je na konci dílu).

Otázka 2: Zkuste z kódu jednotky přijít na to, jakou velkou nevýhodu má toto řešení. (Odpověď najdete na konci dílu.)

Nyní následuje výpis hlavního programu, který jednotku využívá. Jeho název je P_KvadrRovnice.dpr (P jako Project). Za výpisem bude opět poznámka ke změnám v kódu oproti verzi z páté části seriálu.

program P_kvadrRovnice;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  U_TKvadrRovnice in 'U_TKvadrRovnice.pas';

//**** deklarace proměnných programu
var instanceKvadrRov, rov2: TKvadrRovnice; // proměnná pro odkaz na instanci (objekt)
  a, b, c: real; // pomocné proměnné pro možnost zadání koeficientů

//**** vlastní program
begin
writeLn('Program na reseni kvadraticke rovnice, zkouska prace s objekty.');
//** První rovnice
// vytvoření odkazu na novou instanci - objekt - kvadratické rovnice:
instanceKvadrRov := TKvadrRovnice.vytvorRovnici;
// kontrolní výpis koeficientů, zadaných naším základním konstruktorem
write('Koeficienty první rovnice jsou a = ', instanceKvadrRov.vratKoefA:3:3);
  write(', b = ', instanceKvadrRov.vratKoefB:3:3);
  writeLn(', c = ', instanceKvadrRov.vratKoefC:3:3);
// řešení rovnice už proběhlo během volání konstruktoru
// dle hodnoty atributu PocetKorenu se vypíší kořeny
if instanceKvadrRov.vratPocetKorenu = 2
  then
    begin
      write('Rovnice ma dva koreny x1 = ', instanceKvadrRov.vratKorenX1:3:3);
      writeLn(', x2 = ', instanceKvadrRov.vratKorenX2:3:3);
    end
  else
    if instanceKvadrRov.vratPocetKorenu = 1
      then
        writeLn('Rovnice ma jeden koren x = ', instanceKvadrRov.vratKorenX1:3:3)
      else
        writeLn('Rovnice nema zadny koren');
instanceKvadrRov.Free; // zruseni objektu (instance) - uvolneni pameti RAM
//** První rovnice - konec reseni

//** Druhá rovnice, tentokrat pomoci noveho objektu tridy TKvadrRovnice.
writeLn; // vynechání řádku ve výpisu
// Vytvoreni noveho objektu konstruktorem
// rov2.vytvorRovnici; POZOR: Casta chyba zacatecnika, chybny zapis konstruktoru
  // protoze objekt rov2 jeste nebyl vytvoren, nemuze jeste volat nejakou metodu
rov2 := TKvadrRovnice.vytvorRovnici; // spravne
// Zadání a řešení nové rovnice
writeLn('Zadejte koeficienty a, b, c nove rovnice:');
write('a = '); readLn(a);
write('b = '); readLn(b);
write('c = '); readLn(c);
rov2.zadejKoeficienty(a, b, c);
// řešení rovnice už proběhlo během volání metody zadejKoeficienty(a, b, c)
// dle hodnoty atributu PocetKorenu se vypíší kořeny
if rov2.vratPocetKorenu = 2
  then
    begin
      write('Rovnice ma dva koreny x1 = ', rov2.vratKorenX1:3:3);
      writeLn(', x2 = ', rov2.vratKorenX2:3:3);
    end
  else
    if rov2.vratPocetKorenu = 1
      then
        writeLn('Rovnice ma jeden koren x = ', rov2.vratKorenX1:3:3)
      else
        writeLn('Rovnice nema zadny koren');
// sem by mel prijit jeste jeden prikaz - jaky?
//** Druha rovnice - konec reseni

readLn; // pozastaveni vypisu pred zavrenim konzoly

end.

Komentář k výpisu hlavního programu:

• Do programu bylo nutno přidat knihovnu, ale to udělalo při jejím vytvoření samotné IDE (Delphi).
• Program řeší dvě kvadratické rovnice: první je implicitně zadaná konstruktorem (a=1, b=2, c=1), koeficienty druhé zadá uživatel. V předchozí verzi programu se obě verze vyřešily pomocí stejné (jediné) instance třídy TKvadrRovnice s názvem instanceKvadrRov. V této verzi jsem vyzkoušel vytvoření dvou instancí: pro každou rovnici byla vytvořena jedna instance (objekt).

Otázka 3: Zjistěte z textu programu název druhé instance (odpověď je na konci dílu).

• Když programátor vytvoří objekt, je správné v okamžiku, kdy ho program přestane používat, objekt zase zrušit (uvolnit operační paměť). U našeho malého prográmku to není nutné: objekt zabírá zanedbatelné množství RAM a navíc po skončení tohoto krátkého programu se paměť uvolní automaticky. Snažme se ale dodržovat správná pravidla. Proto jsem v programu použil příkaz Free, který objekt z paměti vymaže (opak konstruktoru neboli destruktor, tento však nemusíme nijak deklarovat). Využil jsem ho ale jen pro první instanci programu, pro druhou ne. Toho se týká úkol 2 z konce dnešního dílu: doplňte do programu destruktor free i na druhé vhodné místo.
• V místě vytvoření druhé instance upozorňuji ve výpisu na častou chybu při zakládání nového objektu. Nabízí se napsat rovnou příkaz typu názevInstance.názevKonstruktoru. To ale není možné, protože instance ještě neexistuje (teprve ji vytváříme) a tak nemůžeme vyvolávat už nějakou její metodu. Navíc metoda konstruktor není jistě metodou jednotlivé instance, ale metodou třídy jako celku. Ke třídním metodám se ještě dostaneme, ale zatím intuitivně tento rozdíl snad chápete.

Otázka 4: Zkuste zapsat obecně správný tvar příkazu použití konstruktoru při vytváření nové instance (ve stylu v předchozím odstavci uvedeného nesprávného zápisu). Řešení je na konci článku.

Závěr

V dnešním dílu jste se seznámili s použitím jednotek (unit) neboli knihoven. Snažte se je v programech používat, ať si na ně rychle zvyknete, stejně jako na nástroje OOP.

Nějaké náměty na zkoušení najdete v úkolech. Nejdřív si ale můžete porovnat vaše odpovědi na otázky v textu s mojí představou.

Odpovědi na otázky z tohoto dílu

Otázka 1 zněla takto: V Object Pascalu byla hlavnímu programu (ať už v konzolové aplikaci nebo v programu s formulářem - k tomu přejdete později) přiřazena přípona jiná než původní .pas . Vzpomenete si jaká?

Odpověď: Jde o příponu .dpr (Delphi Project). Přípona .pas původně označovala pascalské programy, v Delphi se používá jen v názvech jednotek.

Otázka 2 zněla takto: Zkuste z kódu jednotky přijít na to, jakou velkou nevýhodu má toto řešení (současný tvar konstruktoru a dalších metod třídy).

Odpověď: Opravdu nešikovné je to, že součástí konstruktoru je hned i nalezení počtu kořenů a samotných kořenů privátní metodou objektů najdiKoreny(). Jestliže se uživatel rozhodne zadat jiné než implicitní hodnoty koeficientů, bude tato metoda vyvolána zbytečně dvakrát (poprvé hned v konstruktoru s implicitními hodnotami). Doufám, že jste nenašli nějaké další větší slabiny programu - už víme, že program může mít víc řešení, ale měli bychom usilovat o to, aby konečné řešení bylo co nejefektivnější. S dalšími vylepšeními přijďte v diskusi k článku.

Otázka 3 zněla takto: Zjistěte z textu programu název druhé instance.

Odpověď: Druhá instance má identifikátor rov2.

Otázka 4 zněla takto: Zkuste obecně zapsat příkaz správného použití konstruktoru při vytváření nové instance ve stylu v předchozím odstavci uvedeného nesprávného zápisu.

Odpověď: Obecný zápis by mohl vypadat takto: názevInstance := názevTřídy.názevKonstruktoru.

Úkoly na příště

Úkol 1: Zkuste změnit konstruktor ve třídě TKvadrRovnice tak, aby vytvořil rovnici přímo s koeficienty zadanými uživatelem. Provedeme to asi tak, že z hodnot koeficientů uděláme parametry konstruktoru, např. constructor vytvorRovnici(a, b, c: real), a v těle konstruktoru se hodnoty parametrů přiřadí atributům (koeficientům) rovnice, např. self.a := a;. V hlavním programu pak přemístíme příkazy pro zadání hodnot koeficientů uživatelem ještě před vytvoření třídy. Vyvolání konstruktoru by pak mohlo mít tvar vytvorRovnici(a, b, c) - při volání metody se už typ metody (constructor) ani typ parametrů (real) nepíše. Protože o práci s procedurami jsme si zatím řekli velmi málo, bude to pro vás možná těžší úkol.

Úkol 2: Doplňte na vhodné místo programu i druhé použití destruktoru free.

Úkol 3: Zkuste si rychle naprogramovat nový projekt na řešení lineární rovnice tak, že k němu vytvoříte jednotku pro řešení lineární rovnice (např. s názvem U_TLinearRovnice, v jednotce bude třída třeba s názvem TLinearRovnice). Opět bychom mohli využít už starší program, ale zkuste to spíš sami.

Bylo by dobré vyřešit víc úkolů, ale mám dojem, že by bylo užitečné říci ještě další věci jak k OOP, tak k základním pojmům z programování, aby se vám programovalo snáze. Příště se podíváme na cykly, konkrétně na cyklus for, mohli bychom vylepšit práci s objekty pomocí přetížených metod, bylo by ovšem taky dobré uvést důkladnější údaje o podprogramech (procedurách a funkcích) atd. Uvidíme, co se do dalšího dílu vejde. Přivítal bych také vaše náměty a připomínky.

Přeji vám vše dobré a ať se vám dobře programuje. A pro odpočinek ve volné chvíli byste si třeba mohli poslechnout Malostranské povídky ve skvělém přednesu Zdeňka Štěpánka nebo bezvadnou povídku Jaroslava Haška Šťastný domov, popř. jinou literaturu v .mp3 na stránkách Českého rozhlasu Čtenářský deník (http://www.rozhlas.cz/ctenarskydenik/portal/) [ http://www.rozhlas.cz/ctenarskydenik/portal/ ]. Je to dobré.