Kurz C++ (16.)

    Jak tohle "kouzlo" funguje? JednoduÜe, p°ekladaΦ nejprve zjistφ, ₧e takovΘto funkce neznß, ale vidφ, ₧e znß Üablonu pro funkci min(). Dosadφ tedy do ÜablonovΘ funkce za typov² parametr T v prvnφm p°φpad∞ int a ve druhΘm pak double. Vzniknou tak instance funkcφ int min(int, int) a double min(double, double), kterΘ pak p°ekladaΦ p°elo₧φ. Nynφ m∙₧eme pou₧φt libovoln² typ a dosadit ho jako parametr funkce min(). Libovoln²m typem m∙₧e b²t, krom∞ vestav∞n²ch datov²ch typ∙, i instance n∞jakΘho nßmi definovanΘho objektovΘho typu, kter² mß p°etφ₧en p°φsluÜn² operßtor (v naÜem p°φpad∞ operßtorovou funkci operator<()).

    Musφme si ale dßt pozor na nßsledujφcφ, nefungujφcφ k≤d:

int a = -5;
char c = 'a';

cout << min(a, c) << endl;

    P°ekladaΦ se toti₧ nem∙₧e rozhodnout, kter²m typem by m∞l nahradit typov² parametr T. M∙₧eme mu samoz°ejm∞ pomoci p°etypovßnφm jednoho z parametr∙ funkce na typ, pomocφ kterΘho chceme provΘst porovnßnφ, tedy nap°.:

cout << min(a, (int)c) << endl;

    Napov∞d∞t m∙₧eme i p°ipojenφm typu v zßvorkßch, jak je vid∞t v nßsledujφcφ ukßzce:

cout << min<int>(a, c) << endl;

    Pokud si vzpomeneme na makra, kde by se minimum dalo implementovat takto:

#define MIN(a, b) (((a) < (b)) ? (a) : (b))

    Pak m∙₧eme na Üablony pohlφ₧et jako na lepÜφ makra. èablony jsou zpracovßvßny p°ekladaΦem, kde₧to makra preprocesorem.

    Nynφ si ukß₧eme t°φdu, kterß implementuje tzv. lineßrnφ spojov² seznam, co₧ je velmi Φasto pou₧φvanß datovß struktura. Uzlem spojovΘho seznamu nazveme strukturu obsahujφcφ n∞jakΘ datovΘ prvky (v naÜem p°φpad∞ jednoduchou prom∞nnou typu int) a dßle ukazatel na dalÜφ uzel spojovΘho seznamu. Lineßrnφ spojov² seznam je pak °et∞zem takov²chto prvk∙. Zde se budeme zab²vat jen jednoduchou implementacφ spojovΘho seznamu, ale proto₧e ka₧d² program pracuje s daty, vyjde v blφzkΘ budoucnosti Φlßnek v∞novan² prßv∞ datov²m strukturßm. V n∞m se budeme zab²vat nap°φklad zßsobnφkem, frontami a takΘ stromy. Ale te∩ u₧ zp∞t k implementaci, kterß bude sestßvat ze dvou t°φd. Prvnφ t°φdou bude CUzel, co₧ bude uzel spojovΘho seznamu. Druhou t°φdou bude t°φda CSeznam, kterß bude zajiÜ¥ovat operace jako t°eba p°idßnφ prvku, vypuÜt∞nφ prvku a vyhledßnφ prvku. Nejprve si ukß₧eme k≤d pro t°φdu CUzel a °ekneme si n∞co o jejφm pou₧itφ:

Uzel.h:

// Uzel spojoveho seznamu

template<class T> class CUzel {
private:
    T m_Data;

    CUzel* m_lpDalsi;
public:
    CUzel(T _data) : m_Data(_data), m_lpDalsi(NULL) { ; }

    void NastavData(T _data) { m_Data = _data; } // ulozi data
    void NastavNasl(CUzel* _dalsi) { m_lpDalsi = _dalsi; } // ulozi ukazatel na dalsi prvek   
   
    T Data() { return m_Data; }       // vrati data
    CUzel* Nasl() { return m_lpDalsi; }        // vrati nasledovnika

    void Vypis() { cout << "Vypis :" << m_Data << endl; }
};

    Vytvo°ili jsme Üablonovou t°φdu, kterß je vzorem pro vytvß°enφ instancφ. Tyto instance vzniknou, podobn∞ jako u funkcφ, dosazenφm n∞jakΘho skuteΦnΘho parametru za typov² parametr T. Nßsleduje soubor main.cpp ukazujφcφ, jak s Üablonou pracovat:

#include <stdio.h>
#include <iostream.h>

#include "Uzel.h"

int main(int argc, char* argv[])
{
    CUzel<int> m_intUzel(4);
    CUzel<double> m_dblUzel(15.32f);
    CUzel m_obecnyUzel(); // Nekde se prelozi, ale potom prvni pristup znamena chybu

    cout << m_intUzel.Data() << " " << m_dblUzel.Data() << endl;

    char c;
    cin >> c;

    return 0;
}

    V programu nesmφ nikde b²t vytvo°ena prom∞nnß typu CUzel, v₧dy to musφ b²t CUzel a v lomen²ch zßvorkßch pak musφ nßsledovat skuteΦn² parametr. N∞kterΘ p°ekladaΦe se sice zßpisu CUzel m_obecnyUzel() nebrßnφ, tak₧e se program v po°ßdku p°elo₧φ. V tom p°φpad∞ vygeneruje p°ekladaΦ hned p°i prvnφm pou₧itφ tΘto prom∞nnΘ chybu.

    Vra¥me se ale k naÜφ t°φd∞ pro prßci s lineßrnφm spojov²m seznamem. Tato t°φda bude obsahovat jeden ukazatel na t°φdu CUzel. Tento prvek se v∞tÜinou naz²vß hlavou seznamu, v naÜem p°φpad∞ nebude hlava obsahovat data (v jejφm datovΘm prvku bychom mohli uchovßvat nap°φklad poΦet prvk∙ v seznamu) a jejφ ukazatel na dalÜφ prvek bude ukazovat na prvnφ datov² prvek obsahujφcφ data. Pro tento Φlßnek si implementujeme pouze vytvo°enφ seznamu, vlo₧enφ prvku na konec seznamu a samoz°ejm∞ uvoln∞nφ seznamu:

Seznam.h:

// Linearni spojovy seznam

template<class T> class CSeznam {
private:
  CUzel<T> *m_lpHlava;

public:
  CSeznam() : m_lpHlava(NULL)
  {
      m_lpHlava = new CUzel<T>(0); // Vytvorime prvni prvek
  }

  ~CSeznam()
  {
      Uvolni(); // Jen uvolnime vsechny prvky
  }

  bool JePrazdny() { return (m_lpHlava == NULL); }

  void VlozKonec(T _data)
  {
      // Overime platnost seznamu
      if(m_lpHlava)
      {
          // Vytvorime vkladany uzel
          CUzel<T> *lpVkladany = new CUzel<T>(_data);

          CUzel<T> *lpKonec; // Najdeme si konec zretezeneho seznamu
          lpKonec = m_lpHlava;

          // Dokud je dalsi prvek platnym prvkem
          while(lpKonec->Nasl() != NULL)
          {
              lpKonec = lpKonec->Nasl(); // Posun na dalsi prvek
          }
          cout << "Vkladam za : " << lpKonec->Data() << "(" << _data << ")" << endl;

          lpKonec->NastavNasl(lpVkladany);
      }
  }

  void Uvolni()
  {
      CUzel<T> *lpMazany = m_lpHlava;

      while(m_lpHlava)
      {
          m_lpHlava = m_lpHlava->Nasl();
          cout << "Mazu : " << lpMazany->Data() << endl;
          delete lpMazany;
          lpMazany = m_lpHlava;
      }
  }

  void Vypis()
  {
      // Nechceme vypisovat data v hlave ...
      CUzel<T> *lpVypisovany = m_lpHlava->Nasl();

      while(lpVypisovany)
      {
          lpVypisovany->Vypis();
          lpVypisovany = lpVypisovany->Nasl();
      }
  }
};

    Nßsleduje hlavnφ program tΘto Üablony:

#include <stdio.h>
#include <iostream.h>

#include "Uzel.h"
#include "Seznam.h"

int main(int argc, char* argv[])
{
    CSeznam<int> m_intSeznam;

    m_intSeznam.VlozKonec(5);
    m_intSeznam.VlozKonec(8);
    m_intSeznam.VlozKonec(-5);

    m_intSeznam.Vypis();

    char c;
    cin >> c;
    return 0;
}

    Program vytvo°φ lineßrnφ spojov² seznam, kde datov²mi prvky jednotliv²ch uzl∙ jsou prom∞nnΘ typu int. Potom vlo₧φme do seznamu pßr Φφsel a vypφÜeme je. Samoz°ejm∞ bychom mohli do seznamu uklßdat instance t°φdy CZivocich, kterou jsme vytvo°ili v minulΘm dφlu.

    V tomto p°φpad∞ jsme cel² seznam implementovali v hlaviΦkovΘm souboru. A tady je t°eba dßt pozor, Üablony toti₧ vy₧adujφ specißlnφ postup p°i p°ekladu, proto₧e p°ekladaΦ pot°ebuje znßt krom∞ deklarace Üablony i t∞la vÜech metod. Pokud bychom cht∞li odd∞lit v hlaviΦkovΘm souboru deklaraci Üablony a t∞la metod, museli bychom pro ka₧dou funkci vytvo°it Üablonu. P°edvedeme si to na metod∞ CSeznam::Uvolni(). U ostatnφch metod je to analogickΘ a zdrojov² k≤d naleznete v sekci Downloads (projekt Seznam1):

Seznam.h:

// Linearni spojovy seznam

template<class T> class CSeznam {
private:
    CUzel<T> *m_lpHlava;

public:
    CSeznam();
    ~CSeznam();

    bool JePrazdny();
    void VlozKonec(T _data);
    void Uvolni();

    void Vypis();
};

template<class T> void CSeznam<T>::Uvolni()
{
    CUzel<T> *lpMazany = m_lpHlava;

    while(m_lpHlava)
    {
        m_lpHlava = m_lpHlava->Nasl();
        cout << "Mazu : " << lpMazany->Data() << endl;
        delete lpMazany;
        lpMazany = m_lpHlava;
    }
};    // Tady je opravdu strednik

    Pokud bychom cht∞li klasickΘ rozd∞lenφ na hlaviΦkov² a zdrojov² soubor, nabφzφ n∞kterΘ p°ekladaΦe klφΦovΘ slovo export, kterΘ se ve zdrojovΘm souboru vklßdß p°ed ka₧dou Üablonu metody. N∞kterΘ p°ekladaΦe vÜak toto slovo nemajφ, n∞kterΘ ho neumo₧≥ujφ spojit s klφΦov²m slovem template. V∞tÜinou se Üablona prost∞ celß vlo₧φ do hlaviΦkovΘho souboru a ten se pak direktivou #include vklßdß do ostatnφch soubor∙.

16.2.2. Parametry deklarace Üablony

    Vid∞li jsme dva p°φklady na Üablony. Nynφ si up°esnφme, co jeÜt∞ m∙₧eme v deklaraci Üablony p°idat za parametry. Deklaraci Üablony provßdφme nßsledujφcφm zßpisem:

template<parametry> deklarace;

    Parametry mohou b²t

1)    hodnotovΘ - jako u deklarace funkce, mohou mφt implicitnφ hodnotu
2)    typovΘ - pokud nedeklarujeme Üablonovou funkci, pak m∙₧e mφt implicitnφ parametr

    Jako t°etφ druh parametru jsou uvßd∞ny ÜablonovΘ parametry, se kter²mi se setkßme jen v nejnov∞jÜφch p°ekladaΦφch.

    V naÜich p°φkladech jsme se setkali jen s typov²mi parametry. Podφvejme se tedy nejprve na n∞. Specifikujeme je pomocφ klφΦov²ch slov class nebo typename, p°iΦem₧ typename znajφ jen nov∞jÜφ p°ekladaΦe. Za klφΦov²m slovem pak nßsleduje identifikßtor, kter² pak pou₧ijeme vÜude tam, kde chceme v Üablon∞ oznaΦit typ. Zßpis implicitnφho parametru se provede nßsledovn∞:

template<class T = int> class CSeznam {
    // Stejne jako predtim
};

    V programu pak pro vyu₧itφ implicitnφho parametru musφme pro vytvo°enφ prom∞nnΘ napsat:

CSeznam<> m_intSeznam;

    HodnotovΘ parametry deklarujeme jako parametry funkcφ. Nßsleduje ukßzka deklarace:

template <class T, unsigned int hodnotovy_parametr /*= impl_hodnota*/> class Sablona { telo_sablony; };

    Pomocφ hodnotov²ch parametr∙ lze v²hodn∞ implementovat nap°. vektory, kde prvkem bude ukazatel, kter² bude ukazovat na dynamicky alokovanΘ pole prvk∙ typu T. Jen matematickß poznßmka pro ty, kte°φ jeÜt∞ nem∞li tu Φest setkat se s vektory, tak vektor je n-tice Φφsel. M∙₧e urΦovat nap°. sou°adnice v 2D nebo 3D prostoru. JeÜt∞ zd∙raz≥uji, ₧e hodnotovΘ parametry mohou mφt implicitnφ hodnotu.

16.3. Co bude p°φÜt∞?

    P°φÜt∞ doplnφme jeÜt∞ pßr v∞cφ k Üablonßm. Jako dalÜφ tΘma probereme v²jimky a v n∞kterΘm z dalÜφch dφl∙ se seznßmφme se standardnφ Üablonovou knihovnou, kterß je souΦßstφ C++. NaÜφ pozornosti ale neuniknou ani objektovΘ vstupn∞-v²stupnφ proudy.

PřφÜtě nashledanou.

Ond°ej BuriÜin