Knihovna standardnφch Üablon III


	31. Knihovna standardnφch Üablon III

Nynφ se podrobn∞ji seznßmφme se vÜemi obecn²mi algoritmy poskytnut²mi standardnφ knihovnou. JmΘna a krßtk² popis t∞chto algoritm∙ je uveden v nßsledujφcφ tabulce. Tyto algoritmy m∙₧eme rozd∞lit do n∞kolika kategoriφ, a to na zßklad∞ jejich obvyklΘho pou₧itφ.

JmΘno	Popis
	Algoritmy pou₧φvanΘ k pln∞nφ sekvence
fill	Pln∞nφ sekvence poΦßteΦnφmi hodnotami.
fill_n	Pln∞nφ n pozic poΦßteΦnφ hodnotou.
copy	Kopφrovßnφ sekvence z jinΘ sekvence.
copy_backward	Kopφrovßnφ sekvence z jinΘ sekvence.
generate	Inicializuje sekvenci pomocφ generßtoru.
generate_n	Inicializuje n pozic pomocφ generßtoru.
swap_ranges	Zam∞≥uje hodnoty ve dvou paralelnφch sekvencφch.
	Vyhledßvacφ algoritmy
find	Hledßnφ prvku odpovφdajφcφmu parametru.
find_if	Hledßnφ prvku spl≥ujφcφho podmφnku.
adjacent_find	Hledßnφ prvku shodujφcφho se s nßsledujφcφm prvkem.
find_first_of	Hledßnφ prvnφho v²skytu jednΘ sekvence v jinΘ sekvenci.
find_end	Hledßnφ poslednφho v²skytu podsekvence v sekvenci.
search	Hledßnφ podsekvence v sekvenci.
max_element	Hledßnφ maximßlnφ hodnoty v sekvenci.
min_element	Hledßnφ minimßlnφ hodnoty v sekvenci.
mismatch	Nalezenφ prvnφ neshody v paralelnφch sekvencφch.
	Transformace na mφst∞
reverse	Obracφ prvky v sekvenci.
replace	Nahrazuje specifikovanΘ hodnoty novou hodnotou.
replace_if	Nahrazuje prvky vyhovujφcφ tvrzenφ.
rotate	Rotuje prvky v sekvenci okolo bodu.
partition	Rozd∞luje prvky do dvou skupin.
stable_partition	Rozd∞lovßnφ chrßnφcφ p∙vodnφ po°adφ.
next_permutation	Generuje permutaci v sekvenci.
prev_permutation	Generuje permutaci v reverznφ sekvenci.
inplace_merge	Spojuje dv∞ sousednφ sekvence v jednu.
random_shuffle	Nßhodn∞ p°eskupφ prvky v sekvenci.
	Odstra≥ovacφ algoritmy
remove	Odstra≥uje prvky spl≥ujφcφ podmφnku.
unique	Odstra≥uje vÜechny neprvnφ duplicitnφ hodnoty v sekvenci.
	Algoritmy generujφcφ skalßr
count	PoΦet prvk∙ s odpovφdajφcφ hodnotou.
count_if	PoΦet prvk∙ vyhovujφcφch tvrzenφ.
accumulate	Redukce sekvence na skalßrnφ hodnotu.
inner_product	Vnit°nφ produkt dvou paralelnφch sekvencφ.
equal	Test dvou sekvencφ na rovnost.
lexicographical_compare	Porovnßvßnφ dvou sekvencφ.
	Algoritmy generujφcφ sekvence
transform	Transformuje ka₧d² prvek.
partial_sum	Generuje sekvenci ΦßsteΦn²ch souΦt∙.
adjacent_difference	Generuje sekvenci sousednφch rozdφl∙.
	R∙znΘ operace
for_each	Aplikuje funkci na ka₧d² prvek kolekce.

Pro pou₧itφ v∞tÜiny obecn²ch algoritm∙ musφme vlo₧it p°φsluÜn² hlaviΦkov² soubor. Hlavnφ funkce jsou definovßny v hlaviΦkovΘm souboru algorithm. Funkce accumulate, inner_product, partial_sum a adjacent_difference jsou definovßny v hlaviΦkovΘm souboru numeric.
# include <algorithm>
# include <numeric>

Prvnφ skupinou algoritm∙, kter²mi se budeme zab²vat jsou algoritmy pou₧φvanΘ k inicializaci nov∞ vytvo°en²ch sekvencφ jist²mi hodnotami. Standardnφ knihovna poskytuje n∞kolik inicializaΦnφch algoritm∙.

fill

fill_n

void fill (ForwardIterator first, ForwardIterator last, const T&);

void fill_n (OutputIterator, Size, const T&);

void fill_example ()

{

// p°φklad 1, zapln∞nφ pole poΦßteΦnφmi hodnotami

char buffer[100], * bufferp = buffer;

fill (bufferp, bufferp + 100, '\0');

fill_n (bufferp, 10, 'x');

// p°φklad 2, inicializace seznamu

list<string> aList(5, "nothing");

fill_n (inserter(aList, aList.begin()), 10, "empty");

// p°φklad 3, p°epsßnφ hodnot v seznamu

fill (aList.begin(), aList.end(), "full");

// p°φklad 4, zapln∞nφ Φßsti kolekce

vector<int> iVec(10);

generate (iVec.begin(), iVec.end(), iotaGen(1));

vector<int>::iterator & seven = find(iVec.begin(), iVec.end(), 7);

fill (iVec.begin(), seven, 0);

}

fill

fill_n

fill

fill_n

nothing

fill_n

empty

fill

full

generate

iotaGen

find

fill

fill_n

copy

copy_backward

OutputIterator copy (InputIterator first, InputIterator last,

OutputIterator result);

BidirectionalIterator copy_backward (BidirectionalIterator first,

BidirectionalIterator last, BidirectionalIterator result);

copy

Duplikovßnφ celΘ sekvence kopφrovßnφm do novΘ sekvence.
Vytvß°enφ podsekvence existujφcφ sekvence.
P°idßvßnφ prvk∙ do sekvence.
Kopφrovßnφ sekvence ze vstupu na v²stup.
Konverze sekvence z jednΘ formy do jinΘ.

void copy_example()

{

char * source = "reprise";

char * surpass = "surpass";

char buffer[120], * bufferp = buffer;

// p°φklad 1, jednoduchß kopie

copy (source, source + strlen(source) + 1, bufferp);

// p°φklad 2, kopie do sebe sama

copy (bufferp + 2, bufferp + strlen(buffer) + 1, bufferp);

int buflen = strlen(buffer) + 1;

copy_backward (bufferp, bufferp + buflen, bufferp + buflen + 3);

copy (surpass, surpass + 3, bufferp);

// p°φklad 3, kopφrovßnφ na v²stup

copy (bufferp, bufferp + strlen(buffer),

ostream_iterator<char,char>(cout));

cout << endl;

// p°φklad 4, pou₧itφ kopφrovßnφ pro p°evod typu

list<char> char_list;

copy (bufferp, bufferp + strlen(buffer),

inserter(char_list, char_list.end()));

char * big = "big ";

copy (big, big + 4, inserter(char_list, char_list.begin()));

char buffer2 [120], * buffer2p = buffer2;

* copy (char_list.begin(), char_list.end(), buffer2p) = '\0';

cout << buffer2 << endl;

}

copy

source

buffer

copy

buffer

copy_backward

copy

buffer

copy

buffer

copy

ostream_iterator

cout

copy

list<string> words;

istream_iterator<string, char> in_stream(cin), eof;

copy(in_stream, eof, inserter(words, words.begin()));

copy

buffer

inserter

copy

surprice

copy

big surprise

copy

fill

fill_n

generate

generate_n

void generate (ForwardIterator, ForwardIterator, Generator);

void generate_n (OutputIterator, Size, Generator);

generate

string generateLabel () {

// generovßnφ popis∙ unikßtnφch °et∞zc∙ tvaru L_ddd

static int lastLabel = 0;

char labelBuffer[80];

ostrstream ost(labelBuffer, 80);

ost << "L_" << lastLabel++ << '\0';

return string(labelBuffer);

}

void generate_example ()

{

// p°φklad 1, generovßnφ seznamu popis∙

list<string> labelList;

generate_n (inserter(labelList, labelList.begin()), 4, generateLabel);

// p°φklad 2, generovßnφ Φφseln²ch hodnot

vector<int> iVec(10);

generate (iVec.begin(), iVec.end(), iotaGen(2));

generate_n (iVec.begin(), 5, iotaGen(7));

}

generateLabel

L_ddd

lastLabel

generate_n

iotaGen

generate_n

swap

template <class T> void swap (T& a, T& b)

{

T temp(a);

a = b;

b = temp;

}

iter_swap

swap_ranges

ForwardIterator swap_ranges (ForwardIterator first,

ForwardIterator last, ForwardIterator first2);

void swap_example ()

{

// nejprve vytvo°φme dv∞ paralelnφ sekvence

int data[] = {12, 27, 14, 64}, *datap = data;

vector<int> aVec(4);

generate(aVec.begin(), aVec.end(), iotaGen(1));

// pou₧itφ swap a iter_swap

swap(data[0], data[2]);

vector<int>::iterator last = aVec.end(); last--;

iter_swap(aVec.begin(), last);

// v²m∞na cel²ch sekvencφ

swap_ranges (aVec.begin(), aVec.end(), datap);

}

Vyhledßvacφ rutiny popsanΘ v tomto bod∞ vracφ iterßtor, kter² urΦuje prvnφ prvek odpovφdajφcφ vyhledßvacφ podmφnce. Tuto hodnotu obecn∞ uklßdßme do prom∞nnΘ iterßtoru takto:

list<int>::iterator where;

where = find(aList.begin(), aList.end(), 7);

adjacent_find

while ((where = adjacent_find(where, stop)) != stop) {

cout << "double " << *where << " in position "

<< where - start << endl;

++where;

}

find

find_if

InputIterator find_if(InputIterator first,InputIterator last,Predicate);

InputIterator find(InputIterator first,InputIterator last,const T&);

find_if

find

void find_test ()

{

int vintageYears[] = {1967, 1972, 1974, 1980, 1995};

int * start = vintageYears;

int * stop = start + 5;

int * where = find_if (start, stop, isLeapYear);

if (where != stop)

cout << "first vintage leap year is " << *where << endl;

else

cout << "no vintage leap years" << endl;

where = find(start, stop, 1995);

if (where != stop)

cout << "1995 is position " << where - start

<< " in sequence" << endl;

else cout "1995 does not occur in sequence" << endl;

}

adjacent_find

ForwardIterator adjacent_find (ForwardIterator first,

ForwardIterator last [, BinaryPredicate ] );

void adjacent_find_example ()

{

char * text = "The bookkeeper carefully opened the door.";

char * start = text;

char * stop = text + strlen(text);

char * where = start;

cout << "In the text: " << text << endl;

while ((where = adjacent_find(where, stop)) != stop) {

cout << "double " << *where

<< " in position " << where - start << endl;

++where;

}

find_first_of

ForwardIterator1 find_first_of (ForwardIterator1 first1,

ForwardIterator1 last1, ForwardIterator2 first2,

ForwardIterator2 last2 [, BinaryPredicate pred ] );

<first1,last1)

<first2,last2)

void find_test ()

{

int vintageYears[] = {1967, 1972, 1974, 1980, 1995};

int requestedYears[] = [1923, 1970, 1980, 1974 };

int * start = vintageYears;

int * stop = start + 5;

int * where = find_first_of (start, stop,

requestedyears,requestedyears+4 );

if (where != stop)

cout << "first requested vintage year is " << *where << endl;

else cout << "no requested vintage years" << endl;

}

find_first_of

equal

mismatch

search

search_n

ForwardIterator search (ForwardIterator first1,

ForwardIterator last1, ForwardIterator first2,

ForwardIterator last2 [, BinaryPredicate ]);

void search_example ()

{

char * base = "dreams and aspirations";

char * text = "ration";

char * where = search(base, base + strlen(base),

text, text + strlen(text));

if (*where != '\0')

cout << "substring position: " << where - base << endl;

else cout << "substring does not occur in text" << endl;

}

find_end

ForwardIterator find_end (ForwardIterator first1,

ForwardIterator last1, ForwardIterator first2,

ForwardIterator last2 [, BinaryPredicate ]);

void find_end_example ()

{

char * base = "The road less traveled";

char * text = "le";

char * where = find(base, base + strlen(base),

text, text + strlen(text));

if (*where != '\0')

cout << "substring position: " << where - base << endl;

else cout << "substring does not occur in text" << endl;

}

max

min

template <class T> const T& max(const T& a, const T& b[, Compare ]);

template <class T> const T& min(const T& a, const T& b[, Compare ]);

max_element

min_element

ForwardIterator max_element (ForwardIterator first,

ForwardIterator last [, Compare ] );

ForwardIterator min_element (ForwardIterator first,

ForwardIterator last [, Compare ] );

split

void max_min_example ()

{

// vytvo°enφ vektoru nßhodn²ch Φφsel mezi 0 a 99

vector<int> numbers(25);

for (int i = 0; i < 25; i++)

numbers[i] = randomInteger(100);

// v²pis maxima

vector<int>::iterator max =

max_element(numbers.begin(), numbers.end());

cout << "largest value was " << * max << endl;

// p°φklad pou₧φvajφcφ °et∞zce

string text="It was the best of times, it was the worst of times.";

list<string> words;

split (text, " .,!:;", words);

cout << "The smallest word is "

<< * min_element(words.begin(), words.end())

<< " and the largest word is "

<< * max_element(words.begin(), words.end()) << endl;

}

mismatch

equal

mismatch

pair<InputIterator, InputIterator> mismatch (InputIterator first1,

InputIterator last1, InputIterator first2 [, BinaryPredicate ] );

mismatch_test

mismatch

void mismatch_test (char * a, char * b)

{

pair<char *, char *> differPositions(0, 0);

char * aDiffPosition;

char * bDiffPosition;

if (strlen(a) < strlen(b)) {

// zajiÜt∞nφ, ₧e druh² parametr je delÜφ

differPositions = mismatch(a, a + strlen(a), b);

aDiffPosition = differPositions.first;

bDiffPosition = differPositions.second;

}

else {

differPositions = mismatch(b, b + strlen(b), a);

aDiffPosition = differPositions.second;

bDiffPosition = differPositions.first;

}

// porovnßnφ vrßcen²ch hodnot

cout << "string " << a;

if (*aDiffPosition == *bDiffPosition)

cout << " is equal to ";

else if (*aDiffPosition < *bDiffPosition)

cout << " is less than ";

else cout << " is greater than ";

cout << b << endl;

}

Nßsledujφcφ kategorie algoritm∙ je pou₧φvßna k modifikaci a transformaci sekvence bez jejφho p°esunu z jejφho p∙vodnφho mφsta ulo₧enφ. N∞kterΘ z nich, jako je replace, zahrnujφ takΘ kopφrovacφ verzi. Pro ostatnφ, pokud chceme zachrßnit originßl, si pak musφme vytvo°it kopii p°ed zahßjenφm transformace. Nap°. nßsleduje ukßzka otoΦenφ vektoru do nov∞ alokovanΘho vektoru.

vector<int> newVec(aVec.size());

copy (aVec.begin(), aVec.end(), newVec.begin()); // nejprve kopie

reverse (newVec.begin(), newVec.end()); // pak otoΦenφ

reverse

void reverse(BidirectionalIterator first,BidirectionalIterator last);

reverse

void reverse_example ()

{

// p°φklad 1, obracenφ °et∞zce

char * text = "Rats live on no evil star";

reverse (text, text + strlen(text));

cout << text << endl;

// p°φklad 2, obracenφ seznamu

list<int> iList;

generate_n (inserter(iList, iList.begin()), 10, iotaGen(2));

reverse (iList.begin(), iList.end());

}

replace

replace_if

replace_copy

replace_copy_if

void replace (ForwardIterator first, ForwardIterator last,

const T&, const T&);

void replace_if (ForwardIterator first, ForwardIterator last,

Predicate, const T&);

OutputIterator replace_copy (InputIterator, InputIterator,

OutputIterator, const T&, const T&);

OutputIterator replace_copy (InputIterator, InputIterator,

OutputIterator, Predicate, const T&);

replace

replace_if

void replace_example ()

{

// vytvo°enφ vektoru 0 1 2 3 4 5 4 3 2 1 0

vector<int> numbers(11);

for (int i = 0; i < 11; i++)

numbers[i] = i < 5 ? i : 10 - i;

// nahrazenφ 3 hodnotou 7

replace (numbers.begin(), numbers.end(), 3, 7);

// nahrazenφ sud²ch hodnot hodnotou 9

replace_if (numbers.begin(), numbers.end(), isEven, 9);

// pou₧itφ kopφrovacφ verze replace

int aList[] = {2, 1, 4, 3, 2, 5};

int bList[6], cList[6], j;

replace_copy (aList, aList+6, &bList[0], 2, 7);

replace_copy_if (bList, bList+6, &cList[0],

bind2nd(greater<int>(), 3), 8);

}

replace_copy

bind2nd

greater

1 2 3 4 5 6 7 8 9 10

7 8 9 10 1 2 3 4 5 6

rotate

void rotate (ForwardIterator first, ForwardIterator middle,

ForwardIterator last);

void rotate_example()

{

// vytvo°enφ seznamu 1 2 3 ... 10

list<int> iList;

generate_n(inserter(iList, iList.begin()), 10, iotaGen(1));

// nalezenφ mφsta 7

list<int>::iterator & middle=find(iList.begin(),iList.end(),7);

// rotace okolo tohoto mφsta

rotate (iList.begin(), middle, iList.end());

// op∞t rotace okolo stejnΘho mφsta

list<int> cList;

rotate_copy (iList.begin(), middle, iList.end(),

inserter(cList, cList.begin()));

}

rotate_copy

iList

BidirectionalIterator partition

(BidirectionalIterator, BidirectionalIterator, Predicate);

BidirectionalIterator stable_partition

(BidirectionalIterator, BidirectionalIterator, Predicate);

partition

void partition_example ()

{

// vytvo°enφ vektoru 1 2 3 ... 10

vector<int> numbers(10);

generate(numbers.begin(), numbers.end(), iotaGen(1));

// p°esun sud²ch dop°edu a lich²ch dozadu

vector<int>::iterator result =

partition(numbers.begin(), numbers.end(), isEven);

cout << "middle location " << result - numbers.begin() << endl;

// nßsleduje stabilnφ rozd∞lenφ

generate (numbers.begin(), numbers.end(), iotaGen(1));

stable_partition (numbers.begin(), numbers.end(), isEven);

}

stable_partition

bool next_permutation (BidirectionalIterator first,

BidirectionalIterator last, [ Compare ] );

bool prev_permutation (BidirectionalIterator first,

BidirectionalIterator last, [ Compare ] );

bool nameCompare (char * a, char * b) { return strcmp(a, b) <= 0; }

void permutation_example ()

{

// p°φklad 1, permutace hodnot 1 2 3

int start [] = { 1, 2, 3};

do

copy (start, start + 3,

ostream_iterator<int,char> (cout, " ")), cout << endl;

while (next_permutation(start, start + 3));

// p°φklad 2, permutace slov

char * words = {"Alpha", "Beta", "Gamma"};

do

copy (words, words + 3,

ostream_iterator<char *,char> (cout, " ")), cout << endl;

while (next_permutation(words, words + 3, nameCompare));

// p°φkladle 3, zp∞tnß permutace znak∙

char * word = "bela";

do

cout << word << ' ';

while (prev_permutation (word, &word[4]));

cout << endl;

}

inplace_merge

void inplace_merge (BidirectionalIterator first,

BidirectionalIterator middle,

BidirectionalIterator last [, BinaryFunction ] );

inplate_merge

find

inplace_merge

void inplace_merge_example ()

{

// generovßnφ sekvence 0 2 4 6 8 1 3 5 7 9

vector<int> numbers(10);

for (int i = 0; i < 10; i++)

numbers[i] = i < 5 ? 2 * i : 2 * (i - 5) + 1;

// hledßnφ 1

vector<int>::iterator midvec =

find(numbers.begin(), numbers.end(), 1);

// kopφrovßnφ do seznamu

list<int> numList;

copy (numbers.begin(), numbers.end(),

inserter (numList, numList.begin()));

list<int>::iterator midList =

find(numList.begin(), numList.end, 1);

// spojovßnφ seznam∙ do jednoho

inplace_merge (numbers.begin(), midvec, numbers.end());

inplace_merge (numList.begin(), midList, numList.end());

}

random_shuffle

deque

void random_shuffle (RandomAccessIterator first,

RandomAccessIterator last [, Generator ] );

m-1

generate

void random_shuffle_example ()

{

// vytvo°enφ vektoru 1 2 3 ... 10

vector<int> numbers;

generate(numbers.begin(), numbers.end(), iotaGen(1));

// nßhodnΘ p°ehßzenφ prvk∙

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

// zopakovßnφ s poskytnutφm generßtoru nßhodn²ch Φφsel

struct RandomInteger {

{

operator() (int m) { return rand() % m; }

} random;

random_shuffle (numbers.begin(), numbers.end(), random);

}

Nßsledujφcφ algoritmy odstra≥ujφ hodnoty ze sekvence. P°esouvajφ zb²vajφcφ hodnoty na zaΦßtek sekvence a vracejφ iterßtor urΦujφcφ, kde sekvence konΦφ. Hodnoty za iterßtorem mohou b²t zruÜeny (nap°. metodou erase). Podφvejme se na jednoduch² p°φklad. P°edpoklßdejme, ₧e chceme odstranit sudΘ prvky ze sekvence 1 2 3 4 5 6 7 8 9 10, a tedy pou₧ijeme algoritmus remove_if, kter² mßm dodß:

1 3 5 7 9 | 6 7 8 9 10

remove_if

remove

find

ForwardIterator remove

(ForwardIterator first, ForwardIterator last, const T &);

ForwardIterator remove_if

(ForwardIterator first, ForwardIterator last, Predicate);

remove

OutputIterator remove_copy(InputIterator first,InputIterator last,

OutputIterator result, const T &);

OutputIterator remove_copy_if(InputIterator first,InputIterator last,

OutputIterator result, Predicate);

remove

void remove_example ()

{

// vytvo°enφ seznamu Φφsel

int data[] = {1, 2, 4, 3, 1, 4, 2};

list<int> aList;

copy (data, data+7, inserter(aList, aList.begin()));

// odstran∞nφ 2, kopφrovßnφ do seznamu

list<int> newList;

remove_copy (aList.begin(), aList.end(),

back_inserter(newList), 2);

// odstran∞nφ 2 na mφst∞

list<int>::iterator where;

where = remove (aList.begin(), aList.end(), 2);

aList.erase(where, aList.end());

// odstran∞nφ vÜech sud²ch hodnot

where = remove_if (aList.begin(), aList.end(), isEven);

aList.erase(where, aList.end());

}

unique

ForwardIterator unique (ForwardIterator first,

ForwardIterator last [, BinaryPredicate ] );

OutputIterator unique_copy(InputIterator first,InputIterator last,

OutputIterator result [, BinaryPredicate ] );

void unique_example ()

{

int data[] = {1, 3, 3, 2, 2, 4};

list<int> aList;

set<int> aSet;

copy (data, data+6, inserter(aList, aList.begin()));

// kopφrovßnφ unikßtnφch prvk∙ do mno₧iny

unique_copy(aList.begin(),aList.end(),inserter(aSet,aSet.begin()));

// unikßtnφ prvky na mφst∞

list<int>::iterator where;

where = unique(aList.begin(), aList.end());

// odstran∞nφ zb²vajφcφch hodnot

aList.erase(where, aList.end());

}

Nßsledujφcφ kategorie algoritm∙ jsou ty, kterΘ redukujφ celou sekvenci na jednu skalßrnφ hodnotu. Nezapome≥te, ₧e algoritmy accumulate a inner_product jsou deklarovßny v hlaviΦkovΘm souboru numeric.

count

count_if

iterator_traits<InputIterator>::distance_type

count (InputIterator first, InputIterator last, const T& value);

iterator_traits<InputIterator>::distance_type

count_if (InputIterator first, InputIterator last, Predicate pred);

void count(InputIterator first,InputIterator last,const T&,Size &);

void count_if(InputIterator first,InputIterator last,Predicate,Size &);

count

count_if

void count_example ()

{

int eCount = 0;

int vowelCount = 0;

char * text = "Now is the time to begin";

count (text, text + strlen(text), 'e', eCount);

count_if (text, text + strlen(text), isVowel, vowelCount);

cout << "There are " << eCount << " letter e's " << endl

<< "and " << vowelCount << " vowels in the text:"

<< text << endl;

}

accumulate

ContainerType accumulate (InputIterator first, InputIterator last,

ContainerType initial [, BinaryFunction ] );

accumulate

void accumulate_example ()

{

int numbers[] = {1, 2, 3, 4, 5};

// P°φklad 1, pouh² souΦet

int sum = accumulate (numbers, numbers + 5, 0);

int product = accumulate (numbers, numbers + 5, 1, times<int>());

cout << "The sum of the first five integers is " << sum << endl;

cout << "The product is " << product << endl;

// P°φklad 2, s r∙zn²mi typy pro poΦßteΦnφ hodnotu

list<int> nums;

nums = accumulate (numbers, numbers+5, nums, intReplicate);

}

list<int>& intReplicate (list<int>& nums, int n)

// p°idßnφ sekvence od n k 1 na konec seznamu

{

while (n) nums.push_back(n--);

return nums;

}

ContainerType inner_product(InputIterator first1,InputIterator last1,

InputIterator first2, ContainerType initialValue

[ , BinaryFunction add, BinaryFunction times ] );

accumulate

true

false

equal

void inner_product_example ()

{

int a[] = {4, 3, -2};

int b[] = {7, 3, 2};

// p°φklad 1, jednoduch² vnit°nφ produkt

int in1 = inner_product(a, a+3, b, 0);

cout << "Inner product is " << in1 << endl;

// p°φklad 2, u₧ivatelem definovanΘ operace

bool anyequal = inner_product(a, a+3, b, true,

logical_or<bool>(), equal_to<int>());

cout << "any equal? " << anyequal << endl;

}

equal

bool equal (InputIterator first, InputIterator last,

InputIterator first2 [, BinaryPredicate] );

equal

true

greater_equal

true

void equal_example ()

{

int a[] = {4, 5, 3};

int b[] = {4, 3, 3};

int c[] = {4, 5, 3};

cout << "a = b is: " << equal(a, a+3, b) << endl;

cout << "a = c is: " << equal(a, a+3, c) << endl;

cout << "a pair-wise greater-equal b is: "

<< equal(a, a+3, b, greater_equal<int>()) << endl;

}

lexicographical_compare

true

false

bool lexicographical_compare(InputIterator first1,InputIterator last1,

InputIterator first2, InputIterator last2 [, BinaryFunction ] );

void lexicographical_compare_example()

{

char * wordOne = "everything";

char * wordTwo = "everybody";

cout << "compare everybody to everything " <<

lexicographical_compare(wordTwo, wordTwo + strlen(wordTwo),

wordOne, wordOne + strlen(wordOne)) << endl;

int a[] = {3, 4, 5, 2};

int b[] = {3, 4, 5};

int c[] = {3, 5};

cout << "compare a to b:" <<

lexicographical_compare(a, a+4, b, b+3) << endl;

cout << "compare a to c:" <<

lexicographical_compare(a, a+4, c, c+2) << endl;

}

Dßle se budeme zab²vat algoritmy pou₧iteln²mi pro generovßnφ novΘ sekvence z existujφcφ sekvence provedenφm n∞jakΘho typu transformace. V²stupnφ sekvence je v∞tÜinou popsßna v²stupnφm operßtorem. Jako alternativa m∙₧e b²t takΘ pou₧it vklßdacφ iterßtor. Algoritmy partial_sum a adjacent_difference jsou deklarovßny v hlaviΦkovΘm souboru numeric.

transform

OutputIterator transform (InputIterator first, InputIterator last,

OutputIterator result, UnaryFunction);

OutputIterator transform (InputIterator first1, InputIterator last1,

InputIterator first2, OutputIterator result, BinaryFunction);

int square(int n) { return n * n; }

void transform_example ()

{

// generovßnφ seznamu hodnot od 1 do 6

list<int> aList;

generate_n (inserter(aList, aList.begin()), 6, iotaGen(1));

// transformace prvk∙ umocn∞nφm, kopφrovßnφ do vektoru

vector<int> aVec(6);

transform (aList.begin(), aList.end(), aVec.begin(), square);

// transformace vektoru na mφst∞, op∞t pou₧ita mocnina

transform (aVec.begin(), aVec.end(), aVec.begin(), square);

// paralelnφ transformace

vector<int> cubes(6);

transform (aVec.begin(), aVec.end(), aList.begin(),

cubes.begin(), divides<int>());

}

OutputIterator partial_sum (InputIterator first, InputIterator last,

OutputIterator result [, BinaryFunction] );

void partial_sum_example ()

{

// generovßnφ hodnot od 1 do 5

vector<int> aVec(5);

generate (aVec.begin(), aVec.end(), iotaGen(1));

// v²stup ΦßsteΦn²ch souΦt∙

partial_sum (aVec.begin(), aVec.end(),

ostream_iterator<int> (cout, " ")), cout << endl;

// v²stup ΦßsteΦn²ch souΦin∙

partial_sum (aVec.begin(), aVec.end(),

ostream_iterator<int> (cout, " "), times<int>() );

}

OutputIterator adjacent_difference (InputIterator first,

InputIterator last, OutputIterator result [, BinaryFunction ]);

void adjacent_difference_example ()

{

vector<int> aVec(5);

generate (aVec.begin(), aVec.end(), iotaGen(1));

// v²stup sousednφch rozdφl∙

adjacent_difference (aVec.begin(), aVec.end(),

ostream_iterator<int,char> (cout, " ")), cout << endl;

// v²stup sousednφch souΦt∙

adjacent_difference (aVec.begin(), aVec.end(),

ostream_iterator<int,char> (cout, " "), plus<int>() );

}

Ve standardnφ knihovn∞ zb²vß jeÜt∞ n∞kolik algoritm∙. Algoritmus for_each p°ebφrß t°i parametry. Prvnφ dva jsou iterßtory popisujφcφ vyhodnocovanou sekvenci, t°etφ je unßrnφ funkce. Algoritmus aplikuje tuto funkci na ka₧dou hodnotu sekvence.

function for_each(InputIterator first, InputIterator last, Function);

print_if_leap

cout << "leap years between 1990 and 1997 are: ";

for_each (1990, 1997, print_if_leap);

cout << endl;

for_each

int vintageYears[] = {1947, 1955, 1960, 1967, 1994};

...

cout << "vintage years which were also leap years are: ";

for_each (vintageYears, vintageYears + 5, print_if_leap);

cout << endl;

countCaps

int capCount = 0;

void countCaps(char c) { if (isupper(c)) capCount++; }

string advice = "Never Trust Anybody Over 30!";

for_each(advice.begin(), advice.end(),countCaps);

cout << "upper-case letter count is " << capCount << endl;

Nynφ se zaΦneme zab²vat popisem obecn²ch algoritm∙ ze standardnφ knihovny, kterΘ jsou urΦenΘ pro °azenΘ kolekce. Jejich popis je uveden v nßsledujφcφ tabulce:

JmΘno	Popis
	╪adφcφ algoritmy
sort	╪azenφ sekvence.
stable_sort	╪azenφ sekvence se zachovßnφm po°adφ ekvivalentnφch prvk∙.
partial_sort	╪azenφ pouze Φßsti sekvence.
partial_sort_copy	╚ßsteΦnΘ °azenφ s kopφrovßnφm.
	Hledßnφ n-tΘho nejv∞tÜφho prvku
nth_element	Lokalizace n-tΘho nejv∞tÜφho prvku.
	Binßrnφ hledßnφ
binary_search	Vyhledßvßnφ, nßvrat logickΘ hodnoty.
lower_bound	Vyhledßvßnφ, nßvrat prvnφ pozice.
upper_bound	Vyhledßvßnφ, nßvrat poslednφ pozice.
equal_range	Vyhledßvßnφ, nßvrat obou pozic.
	SluΦovßnφ °azen²ch sekvencφ
merge	SlouΦenφ dvou se°azen²ch sekvencφ.
	Mno₧inovΘ operace
set_union	Sjednocenφ dvou mno₧in
set_intersection	Pr∙nik dvou mno₧in.
set_difference	Rozdφl dvou mno₧in.
set_symmetric_difference	Symetrick² rozdφl dvou mno₧in.
includes	ZjiÜt∞nφ, zda mno₧ina je podmno₧inou jinΘ mno₧iny.
	Operace s hromadou
make_heap	Zm∞na sekvence na hromadu.
push_heap	P°idßnφ novΘ hodnoty do hromady
pop_heap	Odstran∞nφ nejv∞tÜφ hodnoty z hromady
sort_heap	Zm∞na hromady na °azenou kolekci

╪azenΘ kolekce mohou b²t vytvß°eny pomocφ standardnφ knihovny r∙zn²mi zp∙soby. Nap°.

Kontejnery mno₧in a mapovßnφ jsou °azenΘ kolekce urΦenΘ definicφ.
Seznam m∙₧e b²t se°azen vyvolßnφm metody sort.
Vektor, deque nebo normßlnφ pole C++ mohou b²t °azeny pomocφ n∞kterΘho °adφcφho algoritmu popsanΘho dΘle.

Compare

algorithm

# include <algorithm>

Jsou dva zßkladnφ °adφcφ algoritmy poskytnutΘ standardnφ knihovnou:

void sort (RandomAccessIterator first,

RandomAccessIterator last [, Compare ] );

void stable_sort (RandomAccessIterator first,

RandomAccessIterator last [, Compare ] );

sort

stable_sort

deque

sort

void sort_example ()

{

// napln∞nφ vector a deque nßhodn²mi Φφsly

vector<int> aVec(15);

deque<int> aDec(15);

generate (aVec.begin(), aVec.end(), randomValue);

generate (aDec.begin(), aDec.end(), randomValue);

// vzestupnΘ °azenφ vektoru

sort (aVec.begin(), aVec.end());

// sestupnΘ °azanφ deque

sort (aDec.begin(), aDec.end(), greater<int>() );

// aternativnφ zp∙sob sestupnΘho °azenφ

sort (aVec.rbegin(), aVec.rend());

}

partial_sort

void partial_sort(RandomAccessIterator first,RandomAccessIterator middle,

RandomAccessIterator last [ , Compare ]);

RandomAccessIterator partial_sort_copy(InputIterator first,

InputIterator last, RandomAccessIterator result_first,

RandomAccessIterator result_last [, Compare ] );

partial_sort_copy

void partial_sort_example ()

{

// vytvo°enφ vektoru 15 cel²ch nßhodn²ch Φφsel

vector<int> aVec(15);

generate (aVec.begin(), aVec.end(), randomValue);

// ΦßsteΦnΘ se°azenφ prvnφch sedmi pozic

partial_sort (aVec.begin(), aVec.begin() + 7, aVec.end());

// vytvo°enφ seznamu nßhodn²ch Φφsel

list<int> aList(15, 0);

generate (aList.begin(), aList.end(), randomValue);

// se°azenφ pouze prvnφch sedmi prvk∙

vector<int> start(7);

partial_sort_copy (aList.begin(), aList.end(),

start.begin(), start.end(), greater<int>());

}

P°edpoklßdejme, ₧e mßme sekvenci 2 5 3 4 7 a pot°ebujeme zjistit prost°ednφ prvek (medißn). M∙₧eme to provΘst funkcφ nth_element. Jeden v²sledek m∙₧e b²t nßsledujφcφ sekvence:

3 2 | 4 | 7 5

nth_element

nth

void nth_element(RandomAccessIterator first,RandomAccessIterator nth,

RandomAccessIterator last [, Compare ] );

void nth_element_example ()

{

vector<int> aVec(10);

generate (aVec.begin(), aVec.end(), randomValue);

vector<int>::iterator nth = aVec.begin() + 4;

nth_element (aVec.begin(), nth, aVec.end());

cout << "fifth largest is " << *nth << endl;

}

Standardnφ knihovna poskytuje n∞kolik r∙zn²ch variant algoritmu binßrnφho vyhledßvßnφ. VÜechny provßd∞jφ pouze p°ibli₧n∞ log n porovnßvßnφ, kde n je poΦet prvk∙ v rozsahu popsanΘm parametry. Algoritmus pracuje dob°e s iterßtory nßhodnΘho p°φstupu, kterΘ poskytuje vektor nebo deque. Pracuje takΘ s iterßtory nenßhodnΘho p°φstupu, kterΘ jsou generovanΘ seznamy (v tomto p°φpad∞ je pou₧ito lineßrnφ vyhledßvßnφ). Binßrnφ vyhledßvßnφ nenφ nutno provßd∞t na mno₧inßch nebo multiset, nebo¥ tyto t°φdy kontejner∙ poskytujφ vlastnφ vyhledßvacφ algoritmy, kterΘ jsou mnohem efektivn∞jÜφ.

binary_search

true

Compare(value, arg)

Compare(arg, value)

false

bool binary_search (ForwardIterator first, ForwardIterator last,

const T & value [, Compare ] );

ForwardIterator lower_bound (ForwardIterator first,

ForwardIterator last, const T& value [ , Compare ] );

ForwardIterator upper_bound (ForwardIterator first,

ForwardIterator last, const T& value [, Compare ] );

pair<ForwardIterator,ForwardIterator> equal_range(ForwardIterator first,

ForwardIterator last, const T& value [, Compare ] );

lover_bound

upper_bound

equal_range

void binary_search_example ()

{

// vytvo°enφ se°azenΘho vektoru 15 nßhodn²ch Φφsel

vector<int> aVec(15);

generate (aVec.begin(), aVec.end(), randomValue);

sort (aVec.begin(), aVec.end());

// zjiÜt∞nφ zda kontejner obsahuje 11

if (binary_search (aVec.begin(), aVec.end(), 11))

cout << "contains an 11" << endl;

else

cout << "does not contain an 11" << endl;

// vlo₧enφ 11 a 14

vector<int>::iterator where;

where = lower_bound (aVec.begin(), aVec.end(), 11);

aVec.insert (where, 11);

where = upper_bound (aVec.begin(), aVec.end(), 14);

aVec.insert (where, 14);

}

Algoritmus merge kombinuje dv∞ se°azenΘ sekvence do tvaru novΘ se°azenΘ sekvence. Velikost v²sledku je souΦet velikostφ p°edan²ch sekvencφ. To je v kontrastu s operacφ set_union, kterß eliminuje prvky, kterΘ jsou opakovan∞ v obou mno₧inßch. Dv∞ sekvence jsou popsßny dvojicφ iterßtor∙, zatφmco v²sledek jednφm v²stupnφm iterßtorem.

OutputIterator merge (InputIterator first1, InputIterator last1,

InputIterator first2, InputIterator last2,

OutputIterator result [, Compare ]);

void merge_example ()

{

// vytvo°enφ seznamu a vektoru 10 nßhodn²ch Φφsel

vector<int> aVec(10);

list<int> aList(10, 0);

generate (aVec.begin(), aVec.end(), randomValue);

sort (aVec.begin(), aVec.end());

generate_n (aList.begin(), 10, randomValue);

aList.sort();

// slouΦenφ do vektoru

vector<int> vResult (aVec.size() + aList.size());

merge (aVec.begin(), aVec.end(), aList.begin(), aList.end(),

vResult.begin());

// slouΦenφ do seznamu

list<int> lResult;

merge (aVec.begin(), aVec.end(), aList.begin(), aList.end(),

inserter(lResult, lResult.begin()));

// slouΦenφ na v²stup

merge (aVec.begin(), aVec.end(), aList.begin(), aList.end(),

ostream_iterator<int,char> (cout, " "));

cout << endl;

}

S mno₧inov²mi operacemi pro t°φdu set jsme se ji₧ seznßmili. Algoritmy implementujφcφ tyto operace jsou obecnΘ a aplikovatelnΘ na libovolnΘ °azenΘ datovΘ struktury. Algoritmy p°edpoklßdajφ, ₧e vstupnφ rozsahy jsou °azenΘ kolekce, kterΘ reprezentujφ multiset; tj. prvky se mohou opakovat. Pokud vstupy jsou reprezentovanΘ mno₧inami, pak v²stup bude takΘ mno₧ina.

OutputIterator set_union(InputIterator first1,InputIterator last1,

InputIterator first2, InputIterator last2,

OutputIterator result [, Compare ] );

set_union

set_intersection

set_difference

set_symmetric_difference

merge

includes

true

false

void set_example ()

{

ostream_iterator<int> intOut (cout, " ");

// vytvo°enφ dvou °azen²ch seznam∙

list<int> listOne, listTwo;

generate_n (inserter(listOne, listOne.begin()), 5, iotaGen(1));

generate_n (inserter(listTwo, listTwo.begin()), 5, iotaGen(3));

// sjednocenφ

set_union (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end(), intOut), cout << endl;

// sluΦovßnφ

merge (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end(), intOut), cout << endl;

// pr∙nik

set_intersection (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end(), intOut), cout << endl;

// rozdφl

set_difference (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end(), intOut), cout << endl;

// symetrick² rozdφl

set_symmetric_difference (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end(), intOut), cout << endl;

if (includes (listOne.begin(), listOne.end(),

listTwo.begin(), listTwo.end()))

cout << "set is subset" << endl;

else

cout << "set is not subset" << endl;

}

2 * i + 1

2 * i + 2

priority_queue

make_heap

void make_heap (RandomAccessIterator first,

RandomAccessIterator last [, Compare ]);

push_back

push_heap

void push_heap (RandomAccessIterator first,

RandomAccessIterator last [, Compare ]);

pop_heap

void pop_heap (RandomAccessIterator first,

RandomAccessIterator last [, Compare ]);

sort_heap

void sort_heap (RandomAccessIterator first,

RandomAccessIterator last [, Compare ]);

void heap_example ()

{

// vytvo°enφ hromady 15 nßhodn²ch Φφsel

vector<int> aVec(15);

generate (aVec.begin(), aVec.end(), randomValue);

make_heap (aVec.begin(), aVec.end());

cout << "Largest value " << aVec.front() << endl;

// odstran∞nφ nejv∞tÜφho prvku

pop_heap (aVec.begin(), aVec.end());

aVec.pop_back();

// p°idßnφ 97 k hromad∞

aVec.push_back (97);

push_heap (aVec.begin(), aVec.end());

// p°evedenφ do °azenΘ kolekce

sort_heap (aVec.begin(), aVec.end());

}

Rozhranφ standardnφch alokßtor∙ zaobaluje typy a funkce pot°ebnΘ ke sprßv∞ uklßdßnφ dat obecn²m zp∙sobem. Rozhranφ poskytuje:

typy ukazatele a odkazu
typ rozdφlu mezi ukazateli
typ pro libovolnou velikost objektu
uklßdacφ alokace a dealokace
konstrukce a destrukce objektu

new

delete

my_allocator alloc<int>; // vytvo°enφ alokßtoru

vector<int,my_allocator<int> > v(alloc); // Pou₧itφ alokßtoru

allocator<T>

Allocator

template <class T> class my_alloc;

list <int, allocator<int> > my_list(my_alloc()); // Chyba!

list <int, my_alloc<int> > my_list(my_alloc());

Definovßnφ naÜich vlastnφch alokßtor∙ je relativn∞ jednoduch² proces. Standardnφ knihovna obsahuje jistΘ rozhranφ obsahujφcφ typy a funkce. Alokßtor, kter² vytvß°φme musφ syntakticky vyhovovat t∞mto metodßm a typ∙m. Standardnφ knihovna takΘ specifikuje Φßst sΘmantiky pro typ alokßtoru.

my_allocator

template <class T>

class my_allocator

{

typedef implementation_defined size_type;

typedef implementation_defined difference_type

typedef implementation_defined pointer;

typedef implementation_defined const_pointer;

typedef implementation_defined reference;

typedef implementation_defined const_reference;

typedef implementation_defined value_type;

template <class U>
struct rebind { typedef allocator other; };
Ka₧d² typ ukazatele v tomto rozhranφ musφ mφt konverzi na void*. Musφ b²t mo₧no pou₧φt v²sledek void* jako hodnotu this v konstruktoru a destruktoru a v p°evodech na B<void>::pointer (pro p°φsluÜnΘ B) pro pou₧itφ v B::deallocate().
Metoda rebind umo₧≥uje kontejneru vytvß°et alokßtor pro n∞kterΘ typy poskytnutΘ jako parametr Üablony. Nap°. kontejner seznamu zφskßvß implicitn∞ allocator<T>, ale seznam takΘ pot°ebuje alokovat list_nodes. Kontejner m∙₧e vytvo°it alokßtor pro list_nodes mimo alokßtor pro T takto:
Allocator::rebind<list_node>::other list_node_allocator;
Nßsleduje popis metod, kterΘ alokßtor standardnφ knihovny musφ poskytovat:
my_allocator();
template <class U>
my_allocator(const my_allocator&);
template <class U>
operator=(const my_allocator&);
~my_allocator();
 Konstruktory a destruktor.
pointer address(reference r) const;
 Vracφ adresu r jako typ pointer. Tato a nßsledujφcφ funkce jsou pou₧ity pro p°evod odkaz∙ na ukazatele.
const_pointer address(const_reference r) const;
 Vracφ adresu r jako typ const_pointer.
pointer allocate(size_type n);
 Alokuje mφsto pro n hodnot T.
template <class T, class U>
types<T>::pointer allocate(size_type n,
 typename my_allocator<void>::const_pointer hint = 0);
 Alokuje mφsto pro hint hodnot T.
void deallocate(pointer);
 Dealokace mφsta zφskanΘho volßnφm allocate.
size_type max_size();
 Vracφ nejv∞tÜφ mo₧nΘ mφsto dostupnΘ pro volßnφ allocate.
void construct(pointer p, const T& val);
 Vytvß°φ objekt typu T na mφst∞ p. Efekt je: new((void*)p) T(u);
void destroy(pointer p);
 Volß destruktor na hodnotu urΦenou p. Efekt je: ((T*)p)->~T()
Nßsleduje popis funkcφ (ne metod), kterΘ alokßtor standardnφ knihovny musφ poskytnout:
template <class T>
my_allocator::pointer
operator new(my_allocator::size_type, my_allocator&);
 Alokuje mφsto pro jeden objekt typu T pomocφ my_allocator::allocate. Efekt je: new((void*)x.template allocate<T>(1)) T;
template <class T, class U>
bool operator==(const my_allocator<T>& a, const my_allocator& b);
 Vracφ true, pokud alokßtory b a a mohou b²t ·sp∞Ün∞ zam∞n∞ny (tj. b m∙₧e b²t pou₧it k dealokaci a a naopak).
template <class T, class U>
bool operator!=(const my_allocator<T>& a, const my_allocator& b);
 Vracφ !(a == b).
Rogue Wave poskytuje alternativnφ rozhranφ alokßtoru pro ty p°ekladaΦe, kterΘ nepodporujφ Üablony t°φd a Üablony metod. Tφm se ale zab²vat nebudeme.

Standardnφ knihovna poskytuje mno₧inu t°φd pro oznamovßnφ chyb. Tyto t°φdy pou₧φvajφ slu₧by zpracovßnφ v²jimek. Knihovna implementuje jist² model chyb, ve kterΘm chyby d∞lφme do dvou kategoriφ: na logickΘ a b∞hovΘ chyby.

stdexcept

#include <stdexcept>

exception

logic_error

domain_error

invalid_argument

length_error

out_of_range

runtime_error

range_error

overflow_error

underflow_error

logic_error

runtime_error

exception

logic_error

runtime_error

insert

string s;

int n;

...

try

{

s.insert(n,"Howdy");

}

catch (const exception& e)

{

// prßce s v²jimkou

}

...

if (n > max)

throw out_of_range("Your past the end, bud");

exception

what

catch

exception

throw exception;

class bad_packet_error : public runtime_error

{

public:

bad_packet_error(const string& what);

};

if (bad_packet())

throw bad_packet_error("Packet size incorrect");

exceptn.cpp

#include <stdexcept>

#include <string>

static void f() { throw runtime_error("a runtime error"); }

int main ()

{

string s;

try

{

s.replace(100,1,1,'c');

}

catch (const exception& e)

{

cout << "Got an exception: " << e.what() << endl;

}

try

{

f();

}

catch (const exception& e)

{

cout << "Got an exception: " << e.what() << endl;

}

return 0;

}

T°φda auto_prt zaobaluje libovoln² ukazatel zφskan² pomocφ new a poskytuje automatickΘ zruÜenφ tohoto ukazatele. Ukazatel zaobalen² objektem auto_ptr je zruÜen, kdy₧ sßm auto_ptr je uvoln∞n. Pro p°φstup k tΘto t°φd∞ je nutno vlo₧it hlaviΦkov² soubor memory:

#include <memory>

auto_ptr

reset

auto_ptr

auto_ptr<string> a(new string);

auto_ptr

auto_ptr<string> b = a;

auto_ptr

operator*

operator->

get

*b = "What's up Doc";

*(b.get()) = "What's up Doc";

b->assign("What's up Doc");

auto_ptr

release

auto_ptr

release

auto_ptr

autoptr.cpp

#include <vector>

#include <memory>

#include <string>

int main()

{

// prvnφ chybn² zp∙sob

vector<string*> v;

v.insert(v.begin(), new string("Florence"));

v.insert(v.begin(), new string("Milan"));

v.insert(v.begin(), new string("Venice"));

// nynφ odstranφme prvnφ prvek

v.erase(v.begin());

// °et∞zec("Venice") je odstran∞n, ale nenφ zruÜen

}

{

// nynφ sprßvn² zp∙sob

vector<auto_ptr<string> > v;

v.insert(v.begin(), auto_ptr<string>(new string("Florence")));

v.insert(v.begin(), auto_ptr<string>(new string("Milan")));

v.insert(v.begin(), auto_ptr<string>(new string("Venice")));

// nynφ odstranφme prvnφ prvek

v.erase(v.begin());

// vÜe v po°ßdku

}

return 0;

}

31. Knihovna standardnφch Üablon III