Programovanie

59 

Loading....

Loading....

Loading....

Loading....

Loading....

Full text

(1)

Programovanie 3.

2012 – 2013

11. Prednáška

STL – II.

Ing. František Gyárfáš, PhD.

(2)
(3)

Ako to dátovo reprezentovať?

class PESNICKA {

string

nazov

;

string

textPlusAkordy

;

};

Výhody:

Jednoduchá a jasná reprezentácia.

Nevýhody:

(4)

Predspracovanie:

Oddelenie akordov od textu

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Vložíme do textu oddeľovače:

(5)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Ukladanie po riadkoch

Zlepšenie:

Ideálne pre načítavanie. (

getline

)

Problémy:

Nebezpečná manipulácia s polom.

class PESNICKA {

string nazov;

string riadky[100];

(6)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Náhrada poľa – čím?

Zlepšenie:

Problémy:

Nutnosť analyzovať pri každom čítaní.

class PESNICKA {

string nazov;

vector<string> riadky;

};

(7)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Ukladanie po frázach

Zlepšenie:

Zjednodušené čítanie.

Problémy:

Nutnosť oddeľovať akordy od textu pri čítaní.

class PESNICKA {

string nazov;

vector<string> frazy;

(8)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Oddelenie akordov od textu

Zlepšenie:

Oddelenie akordov od textu sa vykoná iba raz.

Problémy:

Ak verš nemá akord, mám problém.

class PESNICKA {

string nazov;

vector<string> akordy;

vector<string> texty;

(9)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Spojenie akordov s textami

Zlepšenie:

Akordy s textami sú bezpečne spárované.

Problémy:

Chýba informácia o riadkoch.

class

FRAZA

{

string

text

;

string

akord

;

};

class PESNICKA {

string nazov;

vector<FRAZA> frazy;

};

(10)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Verše a frázy

Zlepšenie:

Dátová štruktúra odráža štruktúru textu.

Problémy:

Neviem, aký zoznam akordov pieseň obsahuje.

class

FRAZA

{

string

text

;

string

akord

;

};

class

VERS

{

vector<

FRAZA

>

frazy

;

};

class PESNICKA {

string nazov;

vector<

VERS

>

verse

;

};

(11)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Pridanie zoznamu akordov

Zlepšenie:

Samostatný zoznam akordov.

Problémy:

Zoznam akordov môže obsahuje duplikáty.

class FRAZA {

string text;

string akord;

};

class VERS {

vector<FRAZA> frazy;

};

class PESNICKA {

string nazov;

vector<VERS> verse;

vector<string> akordy;

};

Zoznam akordov nie je utriedený.

Potrebujem:

(12)

Sekvenčné kontajnery a adaptéry

vector

– je lineárna sekvencia objektov.

deque

– je to fronta s dvoma koncami.

list

– je to obojstranný zreťazený zoznam.

Adaptér

stack

sa správa ako zásobník

LIFO

(last in, first out).

Adaptér

queue

sa správa ako fronta

FIFO

(first in, first out).

Zoznam, ktorý

nepovoľuje duplikáty

.

(13)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Môžem použiť

priority_queue

?

Zlepšenie:

Usporiadaný zoznam akordov.

Problémy:

Dostanem sa iba k vrchnému akordu.

class FRAZA {

string text;

string akord;

};

class VERS {

vector<FRAZA> frazy;

};

class PESNICKA {

string nazov;

vector<VERS> verse;

priority_queue<string> akordy;

};

(14)

Asociatívne kontajnery

set

– kľúč je samotná hodnota. Obsahuje

max. 1 prvok

tej istej hodnoty.

multiset

– kľúč je samotná hodnota. Môže obsahovať

viacero

prvkov

tej istej hodnoty.

map

– obsahuje dvojice hodnôt: unikátny

kľúč a hodnota

. Obsahuje

max. 1 prvok

s tým istým

kľúčom

.

multimap

– obsahuje dvojice hodnôt. Umožňuje

viac hodnôt

s tým

istým kľúčom.

Asociatívne

kontajnery

– používajú

kľúče

a umožňujú ich prostredníctvom

rýchly prístup k jednotlivým položkám.

Položky v asociatívnych kontajneroch sú

usporiadané

, preto je vždy

definovaný spôsob usporiadania, ktorý si vyžaduje porovnávaciu funkciu

(predikát).

(15)

Ami$Spatřil jsem kometu, oblohou letěla,#

chtěl jsem ji zaspívat, ona mi zmizela# Dmi$zmizela jako laň #G7$u lesa v remízku# C$v očích mi zbylo jen #E7$pár žlutých penízkú.# Ami$Penízky ukryl jsem do hlíny pod dubem,#

až příště přiletí, my už tu nebudem,#

Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#

spatřil jsem kometu, chtěl jsem jí zaspívat.# Ami$O vodě, o trávě, #Dmi$o lese,#

G7$o smrti, se kterou smířit #C$nejde se,# Ami$o lásce, o zradě, #Dmi$o světe#

E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.# Ami$Na hvězdném nádraží cinkají vagóny,#

pan Kepler rozepsal nebeské zákony#

Dmi$hledal, až nalezl #G7$v hvězdářských triedrech# C$tajemství, která teď #E7$neseme na bedrech.#

Zoznam akordov ako množina

class FRAZA {

string text;

string akord;

};

class VERS {

vector<FRAZA> frazy;

};

class PESNICKA {

string nazov;

vector<VERS> verse;

set<string> akordy;

};

Zlepšenie:

Problémy:

Množina

set

akordov nepovoľuje duplikáty.

Množina

set

sa automaticky usporiadava.

(16)

Ako vytvoriť spevník ?

Problémy:

Náročné vyhľadávanie pesničiek.

Chýba ochrana pred duplikátmi pesničiek.

Spevník by mal obsahovať

zoznam pesničiek

a

množinu akordov

, ktoré je potrebné

ovládať na zahranie všetkých pesničiek v spevníku.

class SPEVNIK {

vector<PESNICKA> zoznam;

set<string> akordy;

(17)

Čo si vybrať pre pesničky?

set

– kľúč je samotná hodnota. Obsahuje

max. 1 prvok

tej istej hodnoty.

multiset

– kľúč je samotná hodnota. Môže obsahovať

viacero prvkov

tej

istej hodnoty.

map

– obsahuje dvojice hodnôt: unikátny

kľúč a hodnota

. Obsahuje max. 1

prvok s tým istým kľúčom .

multimap

– obsahuje dvojice hodnôt. Umožňuje

viac hodnôt

s tým istým

kľúčom.

class SPEVNIK {

vector<PESNICKA> zoznam;

set<string> akordy;

(18)

Mapa pesničiek

Problémy:

Nie je možné mať dve rôzne piesne s rovnakým názvom.

class SPEVNIK {

map<string, PESNICKA> spevnik;

set<string> akordy;

};

class SPEVNIK {

multimap<string, PESNICKA> spevnik;

set<string> akordy;

(19)

Asociatívne kontajnery

Asociatívne

kontajnery

– používajú

kľúče

a umožňujú ich prostredníctvom

rýchly prístup k jednotlivým položkám.

Položky v asociatívnych kontajneroch sú

usporiadané

, preto je vždy

definovaný spôsob usporiadania, ktorý si vyžaduje porovnávaciu funkciu

(predikát).

(20)

Asociatívny kontajner

set

Syntax:

template

<class Kluc, class Predikat> class set

;

Preddefinovaný predikát:

template <class

Key

, class

Compare =

less<Key>

>

class set;

kľúč

usporiadanie

(21)

Konštruktory kontajnera

set

set<type, predicate>

name

;

Vytvorí prázdnu množinu

set

.

set<type, predicate>

name(sourceSet);

Vytvorí kópiu množiny

sourceSet

.

set<type, predicate>

name(prvy,

posl);

Skopíruje elementy zdrojovej množiny od

iterátora

prvy

po iterátor

posl

.

(22)

Vkladanie položiek do množiny

Metóda

insert

vkladá novú hodnotu do množiny na miesto určené predikátom.

intSet.insert(10);

V prípade

existencie položky

s danou hodnotou

insert

novú položku

ignoruje

.

intSet.insert(10);

intSet.insert(10);

(23)

Návratová hodnota

insert

Metóda

insert

vracia dvojicu

pair< set<int>::iterator, bool >

.

#include <iostream> #include <set> using namespace std; int main () { set<int> myset; set<int>::iterator it;

pair< set<int>::iterator, bool > ret;

ret = myset.insert(10);

string vlozenie = (ret.second == true) ? "Prve = " : "Druhe = "; cout << vlozenie << *ret.first << endl;

ret = myset.insert(10); it = ret.first;

Druhá položka

(

second

)

vracia

true

, ak bol vložený nový prvok a

false

, ak už sa

daný prvok v množine nachádza.

Prvá položka

(

first

)

je

iterátor na nový prvok

, príp.

iterátor na už existujúci

prvok

s danou hodnotou.

(24)

Predikát

template<class T> class mensi{ public: bool operator()(T x, T y) { return x < y; } }; int main(){

set<int, mensi<int> > intSet; intSet.insert(10); intSet.insert(15); intSet.insert(0); intSet.insert(30); intSet.insert(10); intSet.insert(60);

set<int, mensi<int> >::iterator it; for (it = intSet.begin()

; it!=intSet.end(); it++){ cout << *it << " ";

} }

template<class T> class vacsi{ public: bool operator()(T x, T y) { return x > y; } }; int main(){

set<int, vacsi<int> > intSet; intSet.insert(10); intSet.insert(15); intSet.insert(0); intSet.insert(30); intSet.insert(10); intSet.insert(60);

set<int, vacsi<int> >::iterator it; for (it = intSet.begin()

; it!=intSet.end(); it++){ cout << *it << " ";

} }

(25)

Hádanka: aký predikát pre

LIFO

template<class T> class LIFO{ public: bool operator()(T x, T y) { return ???????????; } }; int main(){

set<int, LIFO<int> > intSet; intSet.insert(10); intSet.insert(15); intSet.insert(0); intSet.insert(30); intSet.insert(10); intSet.insert(60);

set<int, LIFO<int> >::iterator it; for (it = intSet.begin()

; it!=intSet.end(); it++){ cout << *it << " ";

} }

(26)

Kontajner

multiset

#include <iostream>

#include <set>

using namespace std;

int main(){

multiset<char> multiSet;

multiSet.insert('A');

multiSet.insert('g');

multiSet.insert('0');

multiSet.insert('%');

multiSet.insert('w');

multiSet.insert('W');

multiSet.insert('A');

multiSet.insert('0');

multiset<char>::iterator iter;

cout << "Mnozina multiset: " << endl;

for (iter = multiSet.begin(); iter!=multiSet.end(); iter++){

multiset

–množina, ktorá môže obsahovať viac elementov s tou

istou hodnotou.

(27)

Mapy ako asociatívne polia

Normálne

polia

spájajú dve veličiny:

index

a

objekt hodnoty

.

Mapy sú

asociatívne polia

. Tiež spájajú dve veličiny:

objekt kľúča

a

objekt

hodnoty

. Mapy sú vždy usporiadané podľa predikátu usporiadania.

template <class

Key

, class

Val

, class

Predikat

=

less<Key>

class

mapa

;

(28)

Konštruktory kontajnera

map

map<Kluc, Hod, predikat>

name

;

Prázdny kontajner

map

.

map<Kluc, Hod, predikat>

name(source)

;

Kópia kontajnera

source

.

map<Kluc, Hod, predikat>

name(prvy, posl)

;

Skopíruje elementy

zdrojového kontajnera od

iterátora

prvy

po iterátor

posl

.

Iterátory do kontajnera map obsahujú dvojicu hodnôt (kľúč a hodnota) :

map<Kluc, Hod>::iterator

iter

;

Kluc k =

(*iter).first

; //

iter->first

(29)

Vkladanie do mapy s

insert

Do mapy vkladáme nový objekt pomocou metódy

insert

.

charMap.insert(

pair<int, char>(6,'V')

);

Metóda

insert

má jeden vstupný parameter:

pair<kluc,hodnota>()

alebo

(30)

Návratová hodnota

insert

Ak

mapa už obsahuje

položku s daným kľúčom,

insert

novú hodnotu

nevloží

, vráti iterátor na už existujúci prvok s daným kľúčom a

false

.

Metóda

insert

vracia

objekt

, obsahujúci dvojicu hodnôt:

iterátor

ukazujúci na vloženú položku a

informáciu

, či bol objekt vložený.

pair<

map<kluc,hodnota>::iterator, bool

>

pair<map<int,char>::iterator, bool>

ret;

ret = charMap.insert(

pair<int, char>(6,'V')

);

(31)

map - operator[]

Asociatívny kontajner

map

má definovaný

operator[]

.

Parameter tohto operátora je kľúč.

Ak element s daným kľúčom sa v kontajneri už nachádza, operátor vracia

referenciu na tento element

.

Ak hodnota s daným kľúčom

už existuje,

táto hodnota

sa prepíše.

Ak hodnota s daným kľúčom

ešte neexistuje

, do kontajnera

sa vloží nový

element

s danými hodnotami.

mnozina[3]

mnozina[3] =

'A';

(32)

Kontajner

multimap

multimap

– je mapa, ktorá môže obsahovať

viac elementov

s rovnakým kľúčom

.

#include <iostream> #include <map>

using namespace std; const int MAX = 6; int main() {

multimap<int, char> charMap;

charMap.insert(multimap<int, char>::value_type(1,'A')); charMap.insert(multimap<int, char>::value_type(2,'X')); charMap.insert(multimap<int, char>::value_type(1,'Y')); charMap.insert(multimap<int, char>::value_type(22,'X')); charMap.insert(multimap<int, char>::value_type(2,'B')); charMap.insert(multimap<int, char>::value_type(4,'B')); multimap<int, char>::iterator iter;

for (unsigned int i = 0; i < MAX; i++){ iter = charMap.find(i);

if (iter == charMap.end()){

cout << "Polozka " << i << " nie je." << endl; }

else{

while(iter->first == i) {

cout << "Polozka s klucom " << i << "-" << iter->second << endl; iter++;

(33)

Algoritmy pre kontajnery

Pravidlo rozumného sebapodceňovania

Pravidlo rozumného sebapodceňovania

U algoritmov hovoríme

transformuj

namiesto

vykonaj pre všetky prvky

v definovanom rozsahu.

Algoritmy

zvyšujú objektovosť

programovania.

Algoritmy zvyčajne očakávajú

iterátory ukazujúce na prvý a posledný

prvok

spracovávaného úseku kontajnera.

Šanca, že algoritmus je naprogramovaný správne a neobsahuje chyby, je

podstatne vyššia, ako u priameho použitia cyklov

for

,

while

a pod.

(34)

Generické algoritmy

Všetky algoritmy sa nachádzajú v

namespace

std

a ich hlavičky sa

nachádzajú v:

#include <algorithm>

Nemodifikujúce

algoritmy

Usporadúvajúce

algoritmy

Meniace

algoritmy

Numerické

algoritmy

Odstraňujúce

algoritmy

(35)

Nemodifikujúce algoritmy

iter =

find

(first, last,

val

);

Vráti

iterátor

na

prvý element

s hodnotou

val

alebo podľa predikátu

pred

medzi

iterátormi

first

a

last.

iter =

find_if

(first,last,

pred

);

iter =

min

(first, last);

iter =

max

(first, last);

Vráti iterátor na

najväčší

(

max

) element.

najmenší

(

min

) alebo

Ďalšie algoritmy vracajú iterátor prvého nájdeného elementu podľa zvoleného

kritéria:

int

count

(first, last,

val

);

Spočíta

výskyt vyhovujúcich elementov

od iterátora

first

po

last

podľa

hodnoty

alebo

predikátu

.

#include <

algorithm

>

int

count_if

(first, last,

pred

);

Vykoná funkciu pre každý element:

(36)

Meniace algoritmy

fill

(first, last, val);

Vloží hodnotou

val

od

first

po

last.

fill_n

(first, n, val);

Vloží hodnotou

val

do

n

prvkov

počínajúc

first

.

generate

(first, last, gen);

Vloží hodnotou

od

first

po

last

generovanú funkciou

gen.

generate_n

(first, n, gen);

Vloží hodnotou

do

n

prvkov počínajúc

first

generovanú funkciou

gen.

copy

(first, last, target);

Skopíruje hodnoty

od iterátora

first

po

last

do novej pozície od iterátora

target.

Iterátor

target

môže byť v

tom istom kontajneri, alebo aj v inom.

(37)

Meniace algoritmy II.

replace

(first,last,val1,val2);

Nahradí

hodnotu

val1

s

val2

reverse

(first, second);

Vymení

hodnoty

(38)

Odstraňujúce algoritmy

remove

(first, last, val);

Odstráni elementy s hodnotou

val,

ale

nezmenší kontajner.

remove_if

(first, last, pred);

Odstráni elementy vyhovujúce predikátu

pred,

ale nezmenší kontajner.

remove_copy

(first, last,

target, val);

Skopíruje obsah s odstránením kópií

elementu s

val,

ale nezmenší kontajner.

remove_copy_if

(first, last,

target, pred);

Odstráni kópie elementu vyhovujúce

predikátu

pred,

ale nezmenší kontajner.

new_last

= remove(first,last,val);

new_last

je iterátor ukazujúci za nový

Všetky algoritmy

remove_X

vracajú iterátor na nový posledný prvok.

(39)

Úplné odstránenie položiek

vector<int>::iterator last_iter;

last_iter =

remove

(vect.begin(), vect.end(), 10);

vect.

erase

(last_iter, vect.end());

Je možné privolať metódu kontajnerov

erase

, ktorá

úplne odstráni

prvky

odstránené algoritmom

remove

a

zmení veľkosť

kontajnera.

(40)

Usporadúvajúce algoritmy

sort

(first, last);

Usporiada podľa hodnôt.

merge

(first1, last1, first2,

last2, result);

Spojí dva usporiadané kontajnery do

usporiadaného kontajneru

result

.

nth_element

(first, n_ty, last);

Všetky pred

n_ty

sú menšie ako

n_ty

a

ostatné väčšie alebo rovne.

sort

(first,last,

greater

<int>())

Usporiada s explicitným predikátom.

Väčšina usporadúvajúcich algoritmov má aj verziu s predikátom.

partial_sort

(first, n_ty,last);

Usporiada toľko elementov, koľko sa ich

zmestí po

n_ty

element.

(41)

Numerické algoritmy

accumulate

(first,last,result);

Pripočíta do hodnoty

result

hodnoty

prvkov od

first

po

last

.

partial_sum

(first,last,vystup);

Vkladá do kontajnera

vystup

postupné

sumy.

adjacent_difference

(first,last,

vystup);

Vkladá do kontajnera

susedných hodnôt, pričom prvá hodnota sa

vystup

rozdiely

nemení.

#include <numeric>

accumulate

(first,last,result,

(42)

Skúška

Úspešné získanie

min. 80 bodov

z cvičení (do termínu skúšky). Po

vykonaní úspešnej skúšky už nie je dovolené odovzdávať cvičenia.

Úspešné spravenie skúšky:

Úspešné vyriešenie písomnej skúšky (

min. 60 % úspešných testov

)

Úspešné okamžité

ústne obhájenie písomky

Odovzdanie a ohodnotenie

semestrálneho projektu.

Projekt je dovolené

odovzdať aj po úspešnej skúške (do 23.1.2010).

(43)

Hodnotenie na skúške

Skúška sa koná vo forme písomnej skúšky za počítačom. Obsahom skúšky je

vypracovanie riešenia zadanej úlohy. Forma zadania je podobná forme, akou

boli zadané všetky úlohy na cvičeniach. Rozdiel bude v tom, že súčasťou

zadanie nebude návod na riešenie úlohy.

Minimum na úspešné zvládnutie skúšky bude úspešné zvládnutie 60 %

všetkých testov z úlohy (tri skupiny testov).

Pri dosiahnutí menej ako 60 %

úspešných testov je skúška neúspešná.

(44)

Termíny skúšok

Termíny skúšok budú počas skúšobného obdoba vždy v stredu popoludní od

13.00. Prihlasovanie sa na skúšku sa bude diať na stránke predmetu a počet

účastníkov skúšky bude cca. 25 študentov.

(45)
(46)

Kontajner

set

- príklad

#include <iostream> #include <set> using namespace std; int main(){ set<int> intSet; intSet.insert(10); intSet.insert(15); intSet.insert(0); intSet.insert(30); intSet.insert(10); intSet.insert(60); set<int>::iterator iter;

cout << "Prvky mnoziny: " << endl;

for (iter=intSet.begin(); iter!=intSet.end(); iter++){ cout << *iter << endl;

}

getchar(); }

(47)

Usporiadanie podľa vloženia

#include <iostream> #include <set>

using namespace std;

template<class T> class Porovnaj{ public: bool operator()(T x, T y) { return false; } }; int main(){

multiset<char, Porovnaj<char> > multiSet; multiSet.insert('A'); multiSet.insert('g'); multiSet.insert('0'); multiSet.insert('&'); multiSet.insert('A'); multiSet.insert('W'); multiSet.insert('&'); multiSet.insert('0');

multiset<char, Porovnaj<char> >::iterator iter; cout << "Prvky mnoziny multiset: " << endl;

for (iter = multiSet.begin(); iter!=multiSet.end(); iter++){ cout << *iter << endl;

(48)

Príklad na

insert

#include <iostream> #include <map>

using namespace std;

void vypis(pair<map<char,int>::iterator,bool> ret){ if (ret.second) {

cout << "Vlozil hodnotu " << ret.first->second; cout << " s klucom " << ret.first->first << endl; }

else {

cout << "Hodnota " << ret.first->second;

cout << " sa uz nachadza s klucom " << ret.first->first << endl; }

}

int main () {

map<char,int> mapa;

pair<map<char,int>::iterator,bool> ret;

ret = mapa.insert(pair<char, int>('a', 10) ); vypis(ret);

ret = mapa.insert(pair<char, int>('b', 20) ); vypis(ret);

ret = mapa.insert(pair<char, int>('b', 40) ); vypis(ret);

(49)

Pozor na

operator[]

#include <iostream> #include <map>

using namespace std; int main() {

map<int, string> mapa;

mapa.insert(pair<int, string>(0, "prva")); mapa.insert(pair<int, string>(2, "druha")); mapa.insert(pair<int, string>(4, "tretia"));

cout << "Velkost mapy = " << mapa.size() << endl; map<int, string>::iterator iter;

for (iter = mapa.begin(); iter != mapa.end(); iter++) { cout << " [" << iter->first << "] = " << iter->second; cout << endl;

}

cout << endl << "Velkost mapy = " << mapa.size() << endl; unsigned int SIZE = mapa.size();

for (unsigned int i = 0; i < SIZE; i++){

cout << " [" << i << "] = " << mapa[i] << endl; }

cout << endl << "Velkost mapy = " << mapa.size() << endl; for (iter = mapa.begin(); iter != mapa.end(); iter++) { cout << " [" << iter->first << "] = " << iter->second; cout << endl;

(50)

Príklad používania mapy

#include <iostream>

#include <map>

using namespace std;

int main() {

map<string, int> charMap;

charMap["prva"]

= 1

;

charMap["druha"]

= 2

;

charMap.

insert

(map<string, int>::value_type(

"prva", 11

));

charMap["druha"]

= 22

;

charMap["druha"]

++

;

cout << "Obsah mapy: " << endl;

map<string, int>::iterator iter;

for (

iter = charMap.begin(); iter != charMap.end(); iter++

) {

cout << iter->first << " --> ";

cout << iter->second << endl;

}

(51)

Kontajner

multimap

#include <iostream> #include <map>

using namespace std; const int MAX = 6; int main() {

multimap<int, char> charMap;

charMap.insert(multimap<int, char>::value_type(1,'A')); charMap.insert(multimap<int, char>::value_type(2,'X')); charMap.insert(multimap<int, char>::value_type(1,'Y')); charMap.insert(multimap<int, char>::value_type(22,'X')); charMap.insert(multimap<int, char>::value_type(2,'B')); charMap.insert(multimap<int, char>::value_type(4,'B')); multimap<int, char>::iterator iter;

for (unsigned int i = 0; i < MAX; i++){ iter = charMap.find(i);

if (iter == charMap.end()){

cout << "Polozka " << i << " nie je." << endl; }

else{

while(iter->first == i) {

cout << "Polozka s klucom " << i << "-" << iter->second << endl; iter++;

} }

(52)

Príklad:

count,find,for_each

#include <iostream> #include <set>

#include <algorithm> using namespace std;

template<class T> void vypis(T iter){ cout << iter << " ";

}

const int MAX = 5; int main(){

multiset<int> kopa;

for(unsigned int i = 0; i < MAX; i++){ kopa.insert(i * 10);

kopa.insert(i * 20); }

for_each(kopa.begin(), kopa.end(), vypis<int>);

cout << endl<< "Pocet = 0: " << count(kopa.begin(), kopa.end(), 0) << endl; cout << "Pocet = 30: " << count(kopa.begin(), kopa.end(), 30) << endl;

cout << "Pocet < 30: "

<< count_if(kopa.begin(), kopa.end(), bind2nd(less<int>(),30)) << endl; set<int>::iterator iter;

iter = find(kopa.begin(), kopa.end(), 30);

cout << "Dalsi element za 30:" << *(++iter) << endl;

(53)

Príklad meniacich algoritmov

#include <iostream> #include <set>

#include <algorithm> using namespace std; const int MAX = 5;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main(){

multiset<int> kopa;

for(unsigned int i = 0; i < MAX; i++){ kopa.insert(0);

}

multiset<int> kopa2(kopa);

fill(kopa.begin(), kopa.end(), 1);

for_each(kopa.begin(), kopa.end(), vypis<int>); cout << endl;

fill_n(kopa.begin(), 3, 2);

for_each(kopa.begin(), kopa.end(), vypis<int>); cout << endl;

generate(kopa.begin(), kopa.end(), std::rand); for_each(kopa.begin(), kopa.end(), vypis<int>); cout << endl;

(54)

Príklad meniacich algoritmov

#include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX = 10;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int nextI() {

static int element = -5; return element++;

}

int main() {

vector<int> vect(MAX, 0);

generate(vect.begin(), vect.end(), nextI); cout << "Zoznam: ";

for_each(vect.begin(), vect.end(), vypis<int>); reverse(vect.begin(), vect.end());

cout << endl << "Opacne: ";

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << "Nahoda: ";

random_shuffle(vect.begin(), vect.end());

(55)

Príklad odstraňovania

#include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX = 8;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main () {

int myints[] = {10,20,30,30,20,10,40,20}; vector<int> vystup(MAX);

remove(myints, myints + MAX, 30); vector<int>::iterator it;

remove_copy(myints, myints + MAX, vystup.begin(), 20); cout << "Vystup obsahuje: " << endl;

for (it = vystup.begin(); it != vystup.end(); ++it) { cout << *it << " ";

}

getchar(); }

(56)

Príklad úplného odstránenia

#include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX = 5;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main() {

vector<int> vect(MAX);

for(int i = 0; i < MAX; i++){ vect[i] = i;

}

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << endl;

vector<int>::iterator last_iter;

last_iter = remove(vect.begin(), vect.end(), 3); for_each(vect.begin(), last_iter, vypis<int>); cout << endl << endl;

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << endl;

vect.erase(last_iter, vect.end());

(57)

Príklad pre usporiadania

#include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX = 10;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main() {

vector<int> vect(MAX);

for(int i = 0; i < MAX; i++){ vect[i] = i;

}

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << "Nahoda: ";

random_shuffle(vect.begin(), vect.end());

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << "Po 5 mensie: ";

nth_element(vect.begin(), vect.begin() + 5, vect.end()); for_each(vect.begin(), vect.end(), vypis<int>);

cout << endl << "Cast usporiadana: ";

partial_sort(vect.begin(), vect.begin() + 5, vect.end()); for_each(vect.begin(), vect.end(), vypis<int>);

cout << endl << "Cele usporiadane: "; sort(vect.begin(), vect.end());

(58)

Príklad pre spájanie

#include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX = 10;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main() {

vector<int> vect(MAX), vect2(MAX), vystup(MAX*2); for(int i = 0; i < MAX; i++){

vect[i] = i * 2; vect2[i] = i * 2 + 1; }

cout << "Prvy: ";

for_each(vect.begin(), vect.end(), vypis<int>); cout << endl << "Druhy: ";

for_each(vect2.begin(), vect2.end(), vypis<int>);

merge(vect.begin(), vect.end(), vect2.begin(), vect2.end(),vystup.begin()); cout << endl << "Spolu: ";

for_each(vystup.begin(), vystup.end(), vypis<int>); random_shuffle(vect.begin(), vect.end());

cout << endl << "Mix: ";

for_each(vect.begin(), vect.end(), vypis<int>);

(59)

Príklad pre numerické algoritmy

#include <iostream> #include <vector> #include <numeric> using namespace std; const int MAX = 10;

template<class T> void vypis(T iter){ cout << iter << " ";

}

int main() {

vector<int> vect(MAX), vystup(MAX); for(int i = 0; i < MAX; i++){

vect[i] = i; }

cout << "Zoznam: ";

for_each(vect.begin(), vect.end(), vypis<int>); int suma = accumulate(vect.begin(), vect.end(), 0); cout << endl << "Suma: " << suma;

partial_sum(vect.begin(), vect.end(), vystup.begin()); cout << endl << "Ciastocne sumy: ";

for_each(vystup.begin(), vystup.end(), vypis<int>);

adjacent_difference(vect.begin(), vect.end(), vystup.begin()); cout << endl << "Rozdiely: ";

Figure

Updating...

References

Updating...

Related subjects :