wtorek, 25 listopada 2014
poniedziałek, 15 września 2014
Algorytmy STL w C++
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm> // Dla for_each.
#include <cstdlib> // Dla funkcji abs.
#include <deque>
#include <functional> // Dla bind2nd.
#include <list>
#include <set>
#include <numeric>
template <typename type> inline void print_elements(const type &collection, const char *before = "") {
typename type::const_iterator position;
std::cout << before;
for (position = collection.begin(); position != collection.end(); ++position)
std::cout << *position << ' ';
std::cout << std::endl;
}
template <typename type> inline void insert_elements(type &collection, int first, int last) {
for (int iterator = first; iterator <= last; ++iterator)
collection.insert(collection.end(), iterator);
}
void print(int element) {
std::cout << element << ' ';
}
bool is_even(int element) {
return ((element % 2) == 0);
}
bool abs_less(int element_one, int element_two) {
return (abs(element_one) < abs(element_two)); // Funkcja abs zwraca wartość bezwzględną z podanego argumentu.
}
void print_collection(const std::list<int> &list_collection) {
print_elements(list_collection);
}
bool lest_for_collection(const std::list<int> &list_collection_one, const std::list<int> &list_collection_two) {
return std::lexicographical_compare(list_collection_one.begin(), list_collection_one.end(), list_collection_two.begin(), list_collection_two.end());
}
int main() {
// Algorytm for_each.
std::vector<int> vector_one;
insert_elements(vector_one, 1, 9);
std::for_each(vector_one.begin(), vector_one.end(), print); // Dla każdego elementu wektora wywołaj podaną funkcję.
std::cout << std::endl;
// Algorytmy niemodyfikujące.
int number;
number = std::count(vector_one.begin(), vector_one.end(), 4); // Zlicz elementy o wartości 4;
number = std::count_if(vector_one.begin(), vector_one.end(), is_even); // Zlicz elementy o wartościach parzystych.
std::cout << "Wartosc najmniejsza: " << *std::min_element(vector_one.begin(), vector_one.end()) << std::endl;
std::cout << "Najwieksza z wartosci bezwzglednych: " << *std::max_element(vector_one.begin(), vector_one.end(), abs_less) << std::endl;
std::vector<int>::iterator vector_pointer;
vector_pointer = std::find(vector_one.begin(), vector_one.end(), 4); // Znajdź pierwszy element o podanej wartości.
vector_pointer = std::find_if(vector_one.begin(), vector_one.end(), std::bind2nd(std::greater<int>(), 3)); // Znajdź pierwszy element większy od 3.
vector_pointer = std::search_n(vector_one.begin(), vector_one.end(), 2, 3); // Znajdź dwa kolejne elementy o wartości równej 3.
vector_pointer = std::search_n(vector_one.begin(), vector_one.end(), 2, 3, std::greater<int>()); // Znajdź dwa kolejne elementy o wartości większej niż 3.
std::deque<int> deque_one;
std::list<int> list_one;
insert_elements(deque_one, 1, 7);
insert_elements(list_one, 3, 6);
auto deque_pointer = std::search(deque_one.begin(), deque_one.end(), list_one.begin(), list_one.end()); // Szukaj pierwszego wystąpienia ciągu "list_one" w kolekcji "deque_one".
deque_pointer = std::find_end(deque_one.begin(), deque_one.end(), list_one.begin(), list_one.end()); // Szukaj ostatniego wystąpienia ciągu "list_one" w kolekcji "deque_one".
vector_pointer = std::find_first_of(vector_one.begin(), vector_one.end(), list_one.begin(), list_one.end()); // Szukaj pierwszego wystąpienia elementu kolekcji "list_one" w kolekcji "vector_one".
vector_pointer = std::adjacent_find(vector_one.begin(), vector_one.end()); // Szukaj pierwszych dwóch elementów o równej wartości.
if (std::equal(vector_one.begin(), vector_one.end(), list_one.begin()))
std::cout << "Kolekcja \"vector_one\" jest rowna kolekcji \"list_one\".\n";
else
std::cout << "Kolekcja \"vector_one\" nie jest rowna kolekcji \"list_one\".\n";
std::pair<std::vector<int>::iterator, std::list<int>::iterator> values;
values = std::mismatch(vector_one.begin(), vector_one.end(), list_one.begin()); // Znajdź pierwszą niezgodność.
if (values.first == vector_one.end())
std::cout << "Brak niezgodnosc pomiedzy \"vector_one\" a \"list_one\".\n";
else {
std::cout << "Pierwsza niezgodnosc pomiedzy \"vector_one\" a \"list_one\": " << *values.first << ".\n";
std::cout << "Druga niezgodnosc pomiedzy \"vector_one\" a \"list_one\": " << *values.second << ".\n";
}
std::list<int> list_two, list_three, list_four, list_five;
insert_elements(list_two, 1, 5);
list_five = list_four = list_three = list_two;
list_two.push_back(7);
list_three.push_back(2);
list_four.push_back(0);
list_five.push_back(2);
std::vector<std::list<int> > collection_of_collection;
collection_of_collection.push_back(list_two);
collection_of_collection.push_back(list_three);
collection_of_collection.push_back(list_four);
collection_of_collection.push_back(list_five);
collection_of_collection.push_back(list_four);
collection_of_collection.push_back(list_two);
collection_of_collection.push_back(list_five);
collection_of_collection.push_back(list_three);
std::sort(collection_of_collection.begin(), collection_of_collection.end(), lest_for_collection); // Posortuj kolekcje leksykograficznie.
// Algorytmy modyfikujące.
std::copy(vector_one.begin(), vector_one.end(), std::back_inserter(list_one)); // Kopiuj elementy kolekcji "vector_one" do "list_one" (kopiuje zakres na początek) i użyj wstawiacza końcowego aby elementy były wstawiane, a nie nadpisywane.
std::vector<int> vector_two(vector_one.begin(), vector_one.end());
std::copy_backward((vector_one.begin() + 2), (vector_one.begin() + 4), (vector_two.begin() + 5)); // Kopiuj zakres jak wyżej z tym, że na koniec.
std::transform(vector_one.begin(), vector_one.end(), vector_one.begin(), std::negate<int>()); // Wykonaj negację wszystkich elementów.
std::deque<int> deque_two;
std::deque<int>::iterator deque_int_pointer;
insert_elements(deque_two, 11, 23);
deque_int_pointer = std::swap_ranges(vector_one.begin(), vector_one.end(), deque_two.begin()); // Wymień elementy kolekcji "vector_one" z odpowiadającymi im elementami kolekcji "deque_one".
std::fill_n(std::ostream_iterator<float>(std::cout, " "), 10, 7.7); // Wypisz 10 razy wartość 7,7.
std::cout << std::endl;
std::fill(++list_one.begin(), --list_one.end(), 1); // Zastąp elementy od drugiego do przedostatniego wartością 1.
std::generate_n(std::back_inserter(list_one), 5, rand); // Wstaw 5 losowych liczb.
std::generate(list_one.begin(), list_one.end(), rand); // Nadpisz pięcioma liczbami losowymi.
std::replace(list_one.begin(), list_one.end(), 5, 33); // Zastąp wszystkie wartości równe 5 wartościami równymi 33.
std::replace_if(list_one.begin(), list_one.end(), std::bind2nd(std::less<int>(), 5), 0); // Zastąp wszystkie wartości spełniające podane kryterium wartościami równymi 0.
std::replace_copy(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " "), 5, 55); // Wypisz wszystkie elementy o wartości 5 zastąpione wartością 55.
std::cout << std::endl;
std::replace_copy_if(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " "), std::bind2nd(std::less<int>(), 5), 42); // Wypisz wszystkie elementy o wartości większej od 5 i zastąpione wartością 42.
std::cout << std::endl;
// Algorytmy usuwające.
vector_pointer = std::remove(vector_one.begin(), vector_one.end(), 5); // Usuń wszystkie elementy o wartości 5.
vector_one.erase(std::remove_if(vector_one.begin(), vector_one.end(), std::bind2nd(std::less<int>(), 4)), vector_one.end()); // Usuń wszystkie elementy mniejsze od 4.
std::remove_copy(list_one.begin(), list_one.end(), std::ostream_iterator<int>(std::cout, " "), 3); // Wypisz wszystkie elementy oprócz tych o wartości 3.
std::cout << std::endl;
std::remove_copy_if(list_one.begin(), list_one.end(), std::ostream_iterator<int>(std::cout, " "), std::bind2nd(std::greater<int>(), 4)); // Wypisz wszystkie elementy oprócz tych o wartościach większych od 4.
std::cout << std::endl;
std::list<int>::iterator list_pointer;
list_pointer = std::unique(list_one.begin(), list_one.end()); // Usuń kolejne powtórzenia.
std::unique_copy(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz elementy z usuniętymi kolejnymi powtórzeniami.
std::cout << std::endl;
// Algorytmy mutujące.
std::reverse(vector_one.begin(), vector_one.end()); // Odwróć kolejnośc elementów.
std::reverse_copy(vector_two.begin(), vector_two.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie elementy w odwrotnej kolejności.
std::cout << std::endl;
std::rotate(vector_one.begin(), (vector_one.begin() + 1), vector_one.end()); // Przesuń cyklicznie o jeden element w lewo.
std::set<int> set_one;
insert_elements(set_one, 1, 9);
std::set<int>::iterator set_int_pointer = set_one.begin();
std::advance(set_int_pointer, 1);
std::rotate_copy(set_one.begin(), set_int_pointer, set_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie elementy przesunięte cylicznie o jeden element w lewo.
std::cout << std::endl;
std::random_shuffle(vector_one.begin(), vector_one.end()); // Potasuj losowo wszystkie elementy.
// Algorytmy sortujące.
std::sort(deque_one.begin(), deque_one.end()); // Sortuj elementy rosnąco.
std::sort(deque_one.begin(), deque_one.end(), std::greater<int>()); // Sortuj w kolejności malejącej.
std::partial_sort(deque_one.begin(), (deque_one.begin() + 5), deque_one.end()); // Sortuj do momentu gdy posortowanych będzie 5 pierwszych elementów.
std::partial_sort_copy(deque_one.begin(), deque_one.end(), vector_one.begin(), vector_one.end()); // Kopiuje elementy kolekcji "deque_one" do "vector_one".
std::nth_element(deque_one.begin(), (deque_one.begin() + 4), deque_one.end()); // Wyłuskaj cztery najmniejsze elementy.
std::copy(deque_one.begin(), (deque_one.begin() + 4), std::ostream_iterator<int>(std::cout, " ")); // Wypisz te cztery najmniejsze elementy.
std::cout << std::endl;
// Algorytmy przeznaczonego dla zakresów posortowanych.
if (std::binary_search(list_one.begin(), list_one.end(), 5)) // Sprawdź czy istnieje element o wartości 5.
std::cout << "Element o wartosci 5 jest obecny w liscie \"list_one\".\n";
else
std::cout << "Element o wartosci 5 nie jest obecny w liscie \"list_one\".\n";
list_one.insert(std::lower_bound(list_one.begin(), list_one.end(), 3), 3); // Wstaw wartość 3 na pierwszej możliwej pozycji bez naruszania uporządkowania.
list_one.insert(std::upper_bound(list_one.begin(), list_one.end(), 7), 7); // Wstaw wartość 3 na ostatniej możliwej pozycji bez naruszania uporządkowania.
// Scalanie elementów.
int table_one[] = { 1, 2, 2, 4, 6, 7, 7, 9 };
int table_two[] = { 2, 2, 2, 3, 6, 6, 8, 9 };
int length_one = (sizeof(table_one) / sizeof(int));
int length_two = (sizeof(table_two) / sizeof(int));
std::merge(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Połącz zakresy.
std::cout << std::endl;
std::set_union(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Zsumuj zakresy.
std::cout << std::endl;
std::set_intersection(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Iloczyn zakresów.
std::cout << std::endl;
std::set_difference(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Wyznacz elementy pierwszego zakresu bez elementów drugiego zakresu.
std::cout << std::endl;
std::set_symmetric_difference(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Różnica symetryczna zakresów.
std::cout << std::endl;
// Algorytmy numeryczne.
std::cout << "Suma elementow \"vector_one\": " << std::accumulate(vector_one.begin(), vector_one.end(), 0) << std::endl; // Oblicz sumę elementów (argument trzeci to wartość początkowa).
std::cout << "Iloczyn skalarny dla \"list_one\": " << std::inner_product(vector_one.begin(), vector_one.end(), vector_one.begin(), 0) << std::endl;
std::partial_sum(vector_one.begin(), vector_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie sumy częściowe.
std::cout << std::endl;
std::adjacent_difference(deque_one.begin(), deque_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie różnice pomiędzy elementami.
std::cout << std::endl;
}
#include <iterator>
#include <vector>
#include <algorithm> // Dla for_each.
#include <cstdlib> // Dla funkcji abs.
#include <deque>
#include <functional> // Dla bind2nd.
#include <list>
#include <set>
#include <numeric>
template <typename type> inline void print_elements(const type &collection, const char *before = "") {
typename type::const_iterator position;
std::cout << before;
for (position = collection.begin(); position != collection.end(); ++position)
std::cout << *position << ' ';
std::cout << std::endl;
}
template <typename type> inline void insert_elements(type &collection, int first, int last) {
for (int iterator = first; iterator <= last; ++iterator)
collection.insert(collection.end(), iterator);
}
void print(int element) {
std::cout << element << ' ';
}
bool is_even(int element) {
return ((element % 2) == 0);
}
bool abs_less(int element_one, int element_two) {
return (abs(element_one) < abs(element_two)); // Funkcja abs zwraca wartość bezwzględną z podanego argumentu.
}
void print_collection(const std::list<int> &list_collection) {
print_elements(list_collection);
}
bool lest_for_collection(const std::list<int> &list_collection_one, const std::list<int> &list_collection_two) {
return std::lexicographical_compare(list_collection_one.begin(), list_collection_one.end(), list_collection_two.begin(), list_collection_two.end());
}
int main() {
// Algorytm for_each.
std::vector<int> vector_one;
insert_elements(vector_one, 1, 9);
std::for_each(vector_one.begin(), vector_one.end(), print); // Dla każdego elementu wektora wywołaj podaną funkcję.
std::cout << std::endl;
// Algorytmy niemodyfikujące.
int number;
number = std::count(vector_one.begin(), vector_one.end(), 4); // Zlicz elementy o wartości 4;
number = std::count_if(vector_one.begin(), vector_one.end(), is_even); // Zlicz elementy o wartościach parzystych.
std::cout << "Wartosc najmniejsza: " << *std::min_element(vector_one.begin(), vector_one.end()) << std::endl;
std::cout << "Najwieksza z wartosci bezwzglednych: " << *std::max_element(vector_one.begin(), vector_one.end(), abs_less) << std::endl;
std::vector<int>::iterator vector_pointer;
vector_pointer = std::find(vector_one.begin(), vector_one.end(), 4); // Znajdź pierwszy element o podanej wartości.
vector_pointer = std::find_if(vector_one.begin(), vector_one.end(), std::bind2nd(std::greater<int>(), 3)); // Znajdź pierwszy element większy od 3.
vector_pointer = std::search_n(vector_one.begin(), vector_one.end(), 2, 3); // Znajdź dwa kolejne elementy o wartości równej 3.
vector_pointer = std::search_n(vector_one.begin(), vector_one.end(), 2, 3, std::greater<int>()); // Znajdź dwa kolejne elementy o wartości większej niż 3.
std::deque<int> deque_one;
std::list<int> list_one;
insert_elements(deque_one, 1, 7);
insert_elements(list_one, 3, 6);
auto deque_pointer = std::search(deque_one.begin(), deque_one.end(), list_one.begin(), list_one.end()); // Szukaj pierwszego wystąpienia ciągu "list_one" w kolekcji "deque_one".
deque_pointer = std::find_end(deque_one.begin(), deque_one.end(), list_one.begin(), list_one.end()); // Szukaj ostatniego wystąpienia ciągu "list_one" w kolekcji "deque_one".
vector_pointer = std::find_first_of(vector_one.begin(), vector_one.end(), list_one.begin(), list_one.end()); // Szukaj pierwszego wystąpienia elementu kolekcji "list_one" w kolekcji "vector_one".
vector_pointer = std::adjacent_find(vector_one.begin(), vector_one.end()); // Szukaj pierwszych dwóch elementów o równej wartości.
if (std::equal(vector_one.begin(), vector_one.end(), list_one.begin()))
std::cout << "Kolekcja \"vector_one\" jest rowna kolekcji \"list_one\".\n";
else
std::cout << "Kolekcja \"vector_one\" nie jest rowna kolekcji \"list_one\".\n";
std::pair<std::vector<int>::iterator, std::list<int>::iterator> values;
values = std::mismatch(vector_one.begin(), vector_one.end(), list_one.begin()); // Znajdź pierwszą niezgodność.
if (values.first == vector_one.end())
std::cout << "Brak niezgodnosc pomiedzy \"vector_one\" a \"list_one\".\n";
else {
std::cout << "Pierwsza niezgodnosc pomiedzy \"vector_one\" a \"list_one\": " << *values.first << ".\n";
std::cout << "Druga niezgodnosc pomiedzy \"vector_one\" a \"list_one\": " << *values.second << ".\n";
}
std::list<int> list_two, list_three, list_four, list_five;
insert_elements(list_two, 1, 5);
list_five = list_four = list_three = list_two;
list_two.push_back(7);
list_three.push_back(2);
list_four.push_back(0);
list_five.push_back(2);
std::vector<std::list<int> > collection_of_collection;
collection_of_collection.push_back(list_two);
collection_of_collection.push_back(list_three);
collection_of_collection.push_back(list_four);
collection_of_collection.push_back(list_five);
collection_of_collection.push_back(list_four);
collection_of_collection.push_back(list_two);
collection_of_collection.push_back(list_five);
collection_of_collection.push_back(list_three);
std::sort(collection_of_collection.begin(), collection_of_collection.end(), lest_for_collection); // Posortuj kolekcje leksykograficznie.
// Algorytmy modyfikujące.
std::copy(vector_one.begin(), vector_one.end(), std::back_inserter(list_one)); // Kopiuj elementy kolekcji "vector_one" do "list_one" (kopiuje zakres na początek) i użyj wstawiacza końcowego aby elementy były wstawiane, a nie nadpisywane.
std::vector<int> vector_two(vector_one.begin(), vector_one.end());
std::copy_backward((vector_one.begin() + 2), (vector_one.begin() + 4), (vector_two.begin() + 5)); // Kopiuj zakres jak wyżej z tym, że na koniec.
std::transform(vector_one.begin(), vector_one.end(), vector_one.begin(), std::negate<int>()); // Wykonaj negację wszystkich elementów.
std::deque<int> deque_two;
std::deque<int>::iterator deque_int_pointer;
insert_elements(deque_two, 11, 23);
deque_int_pointer = std::swap_ranges(vector_one.begin(), vector_one.end(), deque_two.begin()); // Wymień elementy kolekcji "vector_one" z odpowiadającymi im elementami kolekcji "deque_one".
std::fill_n(std::ostream_iterator<float>(std::cout, " "), 10, 7.7); // Wypisz 10 razy wartość 7,7.
std::cout << std::endl;
std::fill(++list_one.begin(), --list_one.end(), 1); // Zastąp elementy od drugiego do przedostatniego wartością 1.
std::generate_n(std::back_inserter(list_one), 5, rand); // Wstaw 5 losowych liczb.
std::generate(list_one.begin(), list_one.end(), rand); // Nadpisz pięcioma liczbami losowymi.
std::replace(list_one.begin(), list_one.end(), 5, 33); // Zastąp wszystkie wartości równe 5 wartościami równymi 33.
std::replace_if(list_one.begin(), list_one.end(), std::bind2nd(std::less<int>(), 5), 0); // Zastąp wszystkie wartości spełniające podane kryterium wartościami równymi 0.
std::replace_copy(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " "), 5, 55); // Wypisz wszystkie elementy o wartości 5 zastąpione wartością 55.
std::cout << std::endl;
std::replace_copy_if(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " "), std::bind2nd(std::less<int>(), 5), 42); // Wypisz wszystkie elementy o wartości większej od 5 i zastąpione wartością 42.
std::cout << std::endl;
// Algorytmy usuwające.
vector_pointer = std::remove(vector_one.begin(), vector_one.end(), 5); // Usuń wszystkie elementy o wartości 5.
vector_one.erase(std::remove_if(vector_one.begin(), vector_one.end(), std::bind2nd(std::less<int>(), 4)), vector_one.end()); // Usuń wszystkie elementy mniejsze od 4.
std::remove_copy(list_one.begin(), list_one.end(), std::ostream_iterator<int>(std::cout, " "), 3); // Wypisz wszystkie elementy oprócz tych o wartości 3.
std::cout << std::endl;
std::remove_copy_if(list_one.begin(), list_one.end(), std::ostream_iterator<int>(std::cout, " "), std::bind2nd(std::greater<int>(), 4)); // Wypisz wszystkie elementy oprócz tych o wartościach większych od 4.
std::cout << std::endl;
std::list<int>::iterator list_pointer;
list_pointer = std::unique(list_one.begin(), list_one.end()); // Usuń kolejne powtórzenia.
std::unique_copy(list_two.begin(), list_two.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz elementy z usuniętymi kolejnymi powtórzeniami.
std::cout << std::endl;
// Algorytmy mutujące.
std::reverse(vector_one.begin(), vector_one.end()); // Odwróć kolejnośc elementów.
std::reverse_copy(vector_two.begin(), vector_two.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie elementy w odwrotnej kolejności.
std::cout << std::endl;
std::rotate(vector_one.begin(), (vector_one.begin() + 1), vector_one.end()); // Przesuń cyklicznie o jeden element w lewo.
std::set<int> set_one;
insert_elements(set_one, 1, 9);
std::set<int>::iterator set_int_pointer = set_one.begin();
std::advance(set_int_pointer, 1);
std::rotate_copy(set_one.begin(), set_int_pointer, set_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie elementy przesunięte cylicznie o jeden element w lewo.
std::cout << std::endl;
std::random_shuffle(vector_one.begin(), vector_one.end()); // Potasuj losowo wszystkie elementy.
// Algorytmy sortujące.
std::sort(deque_one.begin(), deque_one.end()); // Sortuj elementy rosnąco.
std::sort(deque_one.begin(), deque_one.end(), std::greater<int>()); // Sortuj w kolejności malejącej.
std::partial_sort(deque_one.begin(), (deque_one.begin() + 5), deque_one.end()); // Sortuj do momentu gdy posortowanych będzie 5 pierwszych elementów.
std::partial_sort_copy(deque_one.begin(), deque_one.end(), vector_one.begin(), vector_one.end()); // Kopiuje elementy kolekcji "deque_one" do "vector_one".
std::nth_element(deque_one.begin(), (deque_one.begin() + 4), deque_one.end()); // Wyłuskaj cztery najmniejsze elementy.
std::copy(deque_one.begin(), (deque_one.begin() + 4), std::ostream_iterator<int>(std::cout, " ")); // Wypisz te cztery najmniejsze elementy.
std::cout << std::endl;
// Algorytmy przeznaczonego dla zakresów posortowanych.
if (std::binary_search(list_one.begin(), list_one.end(), 5)) // Sprawdź czy istnieje element o wartości 5.
std::cout << "Element o wartosci 5 jest obecny w liscie \"list_one\".\n";
else
std::cout << "Element o wartosci 5 nie jest obecny w liscie \"list_one\".\n";
list_one.insert(std::lower_bound(list_one.begin(), list_one.end(), 3), 3); // Wstaw wartość 3 na pierwszej możliwej pozycji bez naruszania uporządkowania.
list_one.insert(std::upper_bound(list_one.begin(), list_one.end(), 7), 7); // Wstaw wartość 3 na ostatniej możliwej pozycji bez naruszania uporządkowania.
// Scalanie elementów.
int table_one[] = { 1, 2, 2, 4, 6, 7, 7, 9 };
int table_two[] = { 2, 2, 2, 3, 6, 6, 8, 9 };
int length_one = (sizeof(table_one) / sizeof(int));
int length_two = (sizeof(table_two) / sizeof(int));
std::merge(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Połącz zakresy.
std::cout << std::endl;
std::set_union(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Zsumuj zakresy.
std::cout << std::endl;
std::set_intersection(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Iloczyn zakresów.
std::cout << std::endl;
std::set_difference(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Wyznacz elementy pierwszego zakresu bez elementów drugiego zakresu.
std::cout << std::endl;
std::set_symmetric_difference(table_one, (table_one + length_one), table_two, (table_two + length_two), std::ostream_iterator<int>(std::cout, " ")); // Różnica symetryczna zakresów.
std::cout << std::endl;
// Algorytmy numeryczne.
std::cout << "Suma elementow \"vector_one\": " << std::accumulate(vector_one.begin(), vector_one.end(), 0) << std::endl; // Oblicz sumę elementów (argument trzeci to wartość początkowa).
std::cout << "Iloczyn skalarny dla \"list_one\": " << std::inner_product(vector_one.begin(), vector_one.end(), vector_one.begin(), 0) << std::endl;
std::partial_sum(vector_one.begin(), vector_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie sumy częściowe.
std::cout << std::endl;
std::adjacent_difference(deque_one.begin(), deque_one.end(), std::ostream_iterator<int>(std::cout, " ")); // Wypisz wszystkie różnice pomiędzy elementami.
std::cout << std::endl;
}
Źródło:
- Prata S., Język C++. Szkoła programowania. Wydanie VI, Helion SA, 2012,
- Josuttis N. M., C++. Biblioteka standardowa, Helion SA, 2003.
poniedziałek, 1 września 2014
Specjalne kontenery STL w C++
#include <iostream>
#include <stack>
#include <queue>
#include <string>
#include <exception>
#include <bitset>
#include <limits> // Dla numeric_limits (chociaż niekoniecznie w Microsoft Visual Studio 2013).
// Bezpieczniejsza klasa stosu.
template <class type> class safer_stack {
protected:
std::deque<type> elements;
public:
// Klasa wyjątku dla funkcji składowych pop oraz top wywoływanych w przypadku pustego stosu.
class read_empty_stack : public std::exception {
public:
virtual const char *what() const throw() {
return "proba odczytania pustego elementu";
}
};
// Liczba elementów.
typename std::deque<type>::size_type size() const {
return elements.size();
}
// Czy stos pusty.
bool empty() const {
return elements.empty();
}
// Umieść element na stosie.
void push(const type &element) {
elements.push_back(element);
}
// Zdejmij element ze stosu i zwróć jego wartość.
type pop() {
if (elements.empty())
throw read_empty_stack();
type element(elements.back());
elements.pop_back();
return element;
}
// Zwróć wartość kolejnego elementu.
type &top() {
if (elements.empty())
throw read_empty_stack();
return elements.back();
}
};
int main() {
// Stos.
std::stack<int> elements;
elements.push(1); // Umieść na stosie element.
elements.push(2);
elements.push(3);
std::cout << elements.top() << std::endl; // Pobierz ze stosu element ale go nie usuwaj.
elements.pop(); // Usuń element ze stosu.
elements.top() = 77; // Zmień kolejny element.
while (!elements.empty()) {
std::cout << elements.top() << std::endl;
elements.pop();
}
try {
safer_stack<int> safer_elements;
safer_elements.push(1);
safer_elements.push(2);
safer_elements.push(3);
safer_elements.pop();
safer_elements.pop();
safer_elements.top() = 77;
safer_elements.push(4);
safer_elements.push(5);
safer_elements.pop();
safer_elements.pop();
safer_elements.pop();
safer_elements.pop(); // O jeden za dużo.
}
catch (const std::exception &information) {
std::cerr << "Wyjatek: " << information.what() << ".\n";
}
// Kolejka.
std::queue<std::string> queue_elements;
queue_elements.push("String nr 1");
queue_elements.push("String nr 2");
queue_elements.push("String nr 3");
std::cout << queue_elements.front() << std::endl; // Pobierz z kolejki element.
queue_elements.pop(); // Zdejmij z kolejki element.
std::cout << "W kolejce jest " << queue_elements.size() << " elementow.\n";
// Kolejka priorytetowa.
std::priority_queue<float> priority_elements;
priority_elements.push(22.1);
// Pobierz i wypisz elementy.
while (!priority_elements.empty()) {
std::cout << priority_elements.top() << std::endl;
priority_elements.pop();
}
// Kontener bitset.
enum color { red, yellow, gree, blue, white, black, num_colors }; // Każdy bit reprezentuje kolor.
std::bitset<num_colors> used_colors;
used_colors.set(red); // Ustawianie bitu do koloru.
used_colors.set(blue);
std::cout << "Wartosci bitowe uzytych kolorow: " << used_colors << std::endl;
std::cout << "Liczba uzytych kolorow: " << used_colors.count() << std::endl;
std::cout << "Wartosci bitowe niewykorzystanych kolorow: " << ~used_colors << std::endl;
if (used_colors.any()) { // Jeżeli został wykorzystany jakiś kolor.
// Przejrzyj wszystkie kolory.
for (int iterator = 0; iterator < num_colors; ++iterator) {
if (used_colors[(color)iterator]) // Jeżeli został wykorzystany rzeczywisty kolor.
std::cout << "Kolor wykorzystany.\n";
used_colors[(color)iterator].flip(); // Zamiana wartości bitu.
}
}
std::cout << "267 w postaci binarnej liczby typu short: " << std::bitset<std::numeric_limits<unsigned short>::digits>(267) << std::endl;
std::cout << "10000000 w postaci binarnej liczby 24 bitowej: " << std::bitset<24>(1e7) << std::endl;
std::cout << "1000101011 binarnie to " << std::bitset<100>(std::string("1000101011")).to_ulong() << " dziesiatkowo.\n";
}
#include <stack>
#include <queue>
#include <string>
#include <exception>
#include <bitset>
#include <limits> // Dla numeric_limits (chociaż niekoniecznie w Microsoft Visual Studio 2013).
// Bezpieczniejsza klasa stosu.
template <class type> class safer_stack {
protected:
std::deque<type> elements;
public:
// Klasa wyjątku dla funkcji składowych pop oraz top wywoływanych w przypadku pustego stosu.
class read_empty_stack : public std::exception {
public:
virtual const char *what() const throw() {
return "proba odczytania pustego elementu";
}
};
// Liczba elementów.
typename std::deque<type>::size_type size() const {
return elements.size();
}
// Czy stos pusty.
bool empty() const {
return elements.empty();
}
// Umieść element na stosie.
void push(const type &element) {
elements.push_back(element);
}
// Zdejmij element ze stosu i zwróć jego wartość.
type pop() {
if (elements.empty())
throw read_empty_stack();
type element(elements.back());
elements.pop_back();
return element;
}
// Zwróć wartość kolejnego elementu.
type &top() {
if (elements.empty())
throw read_empty_stack();
return elements.back();
}
};
int main() {
// Stos.
std::stack<int> elements;
elements.push(1); // Umieść na stosie element.
elements.push(2);
elements.push(3);
std::cout << elements.top() << std::endl; // Pobierz ze stosu element ale go nie usuwaj.
elements.pop(); // Usuń element ze stosu.
elements.top() = 77; // Zmień kolejny element.
while (!elements.empty()) {
std::cout << elements.top() << std::endl;
elements.pop();
}
try {
safer_stack<int> safer_elements;
safer_elements.push(1);
safer_elements.push(2);
safer_elements.push(3);
safer_elements.pop();
safer_elements.pop();
safer_elements.top() = 77;
safer_elements.push(4);
safer_elements.push(5);
safer_elements.pop();
safer_elements.pop();
safer_elements.pop();
safer_elements.pop(); // O jeden za dużo.
}
catch (const std::exception &information) {
std::cerr << "Wyjatek: " << information.what() << ".\n";
}
// Kolejka.
std::queue<std::string> queue_elements;
queue_elements.push("String nr 1");
queue_elements.push("String nr 2");
queue_elements.push("String nr 3");
std::cout << queue_elements.front() << std::endl; // Pobierz z kolejki element.
queue_elements.pop(); // Zdejmij z kolejki element.
std::cout << "W kolejce jest " << queue_elements.size() << " elementow.\n";
// Kolejka priorytetowa.
std::priority_queue<float> priority_elements;
priority_elements.push(22.1);
// Pobierz i wypisz elementy.
while (!priority_elements.empty()) {
std::cout << priority_elements.top() << std::endl;
priority_elements.pop();
}
// Kontener bitset.
enum color { red, yellow, gree, blue, white, black, num_colors }; // Każdy bit reprezentuje kolor.
std::bitset<num_colors> used_colors;
used_colors.set(red); // Ustawianie bitu do koloru.
used_colors.set(blue);
std::cout << "Wartosci bitowe uzytych kolorow: " << used_colors << std::endl;
std::cout << "Liczba uzytych kolorow: " << used_colors.count() << std::endl;
std::cout << "Wartosci bitowe niewykorzystanych kolorow: " << ~used_colors << std::endl;
if (used_colors.any()) { // Jeżeli został wykorzystany jakiś kolor.
// Przejrzyj wszystkie kolory.
for (int iterator = 0; iterator < num_colors; ++iterator) {
if (used_colors[(color)iterator]) // Jeżeli został wykorzystany rzeczywisty kolor.
std::cout << "Kolor wykorzystany.\n";
used_colors[(color)iterator].flip(); // Zamiana wartości bitu.
}
}
std::cout << "267 w postaci binarnej liczby typu short: " << std::bitset<std::numeric_limits<unsigned short>::digits>(267) << std::endl;
std::cout << "10000000 w postaci binarnej liczby 24 bitowej: " << std::bitset<24>(1e7) << std::endl;
std::cout << "1000101011 binarnie to " << std::bitset<100>(std::string("1000101011")).to_ulong() << " dziesiatkowo.\n";
}
Źródło:
- Prata S., Język C++. Szkoła programowania. Wydanie VI, Helion SA, 2012,
- Josuttis N. M., C++. Biblioteka standardowa, Helion SA, 2003.
niedziela, 31 sierpnia 2014
Kontenery STL w C++
#include <iostream>
#include <list>
#include <iterator>
#include <algorithm> // Dla for_each.
#include <set>
#include <string>
#include <map>
#include <deque>
#include <functional> // Dla obiektu funkcyjnego greater.
void out_int(int number);
template <class type> class runtime_cmp {
public:
enum cmp_mode { normal, reverse };
// Konstruktor dla kryterium sortowania.
runtime_cmp(cmp_mode mode_constructor = normal) : mode(mode_constructor) { }
// Porównanie elementów.
bool operator()(const type &element_one, const type &element_two) const {
return ((mode == normal) ? (element_one < element_two) : (element_two < element_one));
}
// Porównanie kryteriów sortowania.
bool operator==(const runtime_cmp &element) {
return (mode == element.mode);
}
private:
cmp_mode mode;
};
int main() {
// Kontenery sekwencyjne.
// Wektory.
// Kolejki o dwóch końcach.
std::deque<std::string> string_queue;
string_queue.assign(3, "String"); // Wstaw 3 kopie podanego łańcucha.
string_queue.push_back("Ostatni string"); // Dołącz na końcu podany element.
string_queue.push_front("Pierwszy string"); // Wstaw na początek.
std::copy(string_queue.begin(), string_queue.end(), std::ostream_iterator<std::string>(std::cout, "\n")); // Wypisz elementy w oddzielnych wierszach.
string_queue.pop_front(); // Usuń pierwszy.
string_queue.pop_back(); // Usuń ostatni element.
// Wstaw łańcuch "Other" do każdego elementu oprócz pierwszego.
for (unsigned iterator = 1; iterator < string_queue.size(); ++iterator)
string_queue[iterator] = "Other " + string_queue[iterator];
string_queue.resize(4, "String zmiany rozmiaru"); // Zmień rozmiar o ewentualnie brakujące elementy uzupełnij podanymi.
// Listy.
std::list<int> one(5, 2); // Lista pięciu wartości 2.
std::list<int> two, four, five;
int numbers[5] = { 1, 2, 3, 4, 5 };
two.insert(two.begin(), numbers, (numbers + 5)); // Wstawia kopie elementów z zakresu od drugiego do trzeciego argument przed miejscem podanym jako trzeci argument.
int more_numbers[6] = { 6, 7, 8, 9, 10, 11 };
std::list<int> three(two);
three.insert(three.end(), more_numbers, (more_numbers + 6));
std::cout << "Lista one: ";
std::for_each(one.begin(), one.end(), out_int);
std::cout << std::endl;
std::cout << "Lista two: ";
std::for_each(two.begin(), two.end(), out_int);
std::cout << std::endl;
std::cout << "Lista three: ";
std::for_each(three.begin(), three.end(), out_int);
std::cout << std::endl;
// Wypełnij listy elementami.
for (int iterator = 0; iterator < 6; iterator++) {
four.push_back(iterator);
five.push_front(iterator);
}
three.remove(2); // Usuwa z listy wszystkie wystąpienia wartości 2.
three.splice(three.begin(), one); // Wstawia zawartość listy podanej jako drugi argument (i usuwa jej zawartość) przed pozycję podaną jako pierwszy argument.
five.splice(std::find(five.begin(), five.end(), 3), four); // Wstaw wszystkie elementy kontenera podanego jako drugi argument przed pierwszym elementem, do którego iterator zwróciła funkcja find wprowadzona jako pierwszy argument.
five.splice(five.end(), five, five.begin()); // Pozycja docelowa, lista źródłowa, pozycja źródłowa (przenieś pierwszy element na koniec).
three.unique(); // Łączy grupę takich samych elementów występujących obok siebie w jeden element.
three.sort(); // Sortuje liste od wartości najmniejszej do największej.
three.merge(two); // Scala listę podaną jako argument (i usuwa jej zawartość) z listą wywołującą.
// Kontenery asocjacyjne.
// Zbiory i wielozbiory.
std::string words[] = { "Pierwszy", "Drugi", "Trzeci" };
std::string second_words[] = { "Czwarty", "Piaty" };
std::set<std::string> word_container(words, (words + 3)); // Zbiór obiektów typu string.
std::set<std::string> second_word_container(second_words, (second_words + 2));
std::set<std::string> third_word_container;
std::ostream_iterator<std::string, char> out(std::cout, " "); // Interfejs do wyświetlania typu string na strumień cout używający typu char i separatora " ".
std::copy(word_container.begin(), word_container.end(), out); // Kopiuj z do i posortuj.
std::cout << std::endl;
std::set_union(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Wysyła sumę zbiorów do strumienia podanego jako ostatni argument, sortuje i scala takie same wyrazy.
std::set_union(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), std::insert_iterator<std::set<std::string> >(third_word_container, third_word_container.begin()));
std::cout << std::endl;
std::set_intersection(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Przecięcie dwóch zbiorów.
std::cout << std::endl;
std::set_difference(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Różnica dwóch zbiorów.
std::cout << std::endl;
third_word_container.insert("Kolejny"); // Wstawiamy kolejną wartość do zbioru.
std::copy(third_word_container.lower_bound("Drugi"), third_word_container.upper_bound("Trzeci"), out); // Wyświetlanie zakresu: funkcja lower_bound przyjmuje jako argument wartość klucza i zwraca iterator, który wskazuje na pierwszy element zbioru nie mniejszy od podanego argumentu (funkcja upper_bound intuicyjnie odpowiednio).
std::cout << std::endl;
if (third_word_container.insert("Kolejny").second)
std::cout << "Wstawiono element \"Kolejny\" do kontenera \"third_word_container\".\n";
else
std::cout << "Element \"Kolejny\" w kontenerze \"third_word_container\" juz istnieje.\n";
int delete_numbers = third_word_container.erase("Kolejny"); // Usuń wszystkie elementy o podanej wartości.
std::cout << "Usuniet " << delete_numbers << " elementow \"Kolejny\".\n";
std::set <int, std::greater<int> > int_container; // Bez powtórzeń, elementy są wartościami całkowitymi, a porządek malejący.
std::set<int, std::greater<int> >::iterator position; // Iterator dla kolekcji.
int_container.insert(4);
int_container.insert(2);
int_container.insert(1);
// Iteruj po wszystkich elementach.
for (position = int_container.begin(); position != int_container.end(); ++position)
std::cout << * position << std::endl;
std::set<int> second_int_container(int_container.begin(), int_container.end()); // Przypisz elementy do innego zbioru w porządku rosnącym.
std::set<int, runtime_cmp<int> > third_int_container;
third_int_container.insert(5);
third_int_container.insert(2);
third_int_container.insert(1);
runtime_cmp<int> reverse_order(runtime_cmp<int>::reverse); // Kryterium sortowania o odwrotnej kolejności elementów.
std::set<int, runtime_cmp<int> > fourth_int_container(reverse_order);
third_int_container = fourth_int_container; // Przypisz elementy oraz kryterium sortowania.
if (third_int_container.value_comp() == fourth_int_container.value_comp())
std::cout << "Zbiory third_int_container oraz fourth_int_container posiadaja to samo kryterium sortowania.\n";
std::multiset<int, std::greater<int> > int_multicontainer; // Powtórzenia dozwolone, elementy są wartościami całkowitymi, porządek malejący.
int_multicontainer.insert(4);
int_multicontainer.insert(1);
int_multicontainer.insert(5);
std::multiset<int, std::greater<int> >::iterator multiset_pointer = int_multicontainer.insert(4); // Wstaw ponownie wartość 4.
std::cout << "Wartosc 4 wstawiono do kontenera \"int_multicontainer\" jako element nr " << std::distance(int_multicontainer.begin(), multiset_pointer) + 1 << ".\n";
// Mapy oraz multimapy.
std::map<std::string, float> map_collection;
map_collection.insert(std::map<std::string, float>::value_type("Jan", 22.3));
map_collection.insert(std::pair<std::string, float>("Bartlomiej", 26)); // Wykorzystanie konwersji niejawnej.
map_collection.insert(std::pair<const std::string, float>("Tomek", 26)); // Brak wykorzystania konwersji niejawnej.
if (map_collection.insert(std::make_pair("Michal", 0)).second)
std::cout << "Udalo sie wstawic pare Michal-0 do mapy.\n";
else
std::cout << "Nie udalo sie wstawic pary Michal-0 do mapy.\n";
for (auto map_iterator = map_collection.begin(); map_iterator != map_collection.end(); ++map_iterator)
std::cout << "Klucz: " << map_iterator->first << ", wartosc: " << map_iterator->second << std::endl;
map_collection.erase("Tomek"); // Usuń wszystkie elementy o podanym kluczu.
auto map_iterator = map_collection.find("Jan");
// Poniższe dwie instrukcje sprawiają, że podany klucz zmieni swoją nazwę.
map_collection["Jan"] = map_collection["Janek"];
map_collection.erase("Janek");
if (map_iterator != map_collection.end())
map_collection.erase(map_iterator); // Usuń pierwszy element o podanym kluczu.
map_collection["Bartek"] = map_collection["Bartlomiej"]; // Wstaw nowy element o wartości starego elementu.
map_collection["Bonifacy"] = 0;
for (auto map_iterator = map_collection.begin(); map_iterator != map_collection.end(); ++map_iterator)
map_iterator->second *= 2; // Podwajamy wartość każdego klucza.
typedef std::pair<const int, std::string> pair;
typedef std::multimap<int, std::string> map_code;
map_code codes;
codes.insert(pair(41, "Bytom"));
codes.insert(pair(81, "Bytom"));
codes.insert(pair(81, "Sopot"));
codes.insert(std::make_pair(33, "Krakow"));
std::cout << "Liczba miast o kodzie 81: " << codes.count(81) << std::endl;
std::cout << "Kod regioniu i miasto:\n";
for (auto pointer = codes.begin(); pointer != codes.end(); ++pointer)
std::cout << (* pointer).first << ", " << (* pointer).second << std::endl;
std::pair<map_code::iterator, map_code::iterator> range = codes.equal_range(81);
std::cout << "Miasta o kodzie 81:\n";
for (auto pointer = range.first; pointer != range.second; ++pointer)
std::cout << (* pointer).second << std::endl;
std::cout << "Wszystkie wartosci dla klucza 81:\n";
for (auto iterator = codes.begin(); iterator != codes.end(); ++iterator) {
if (iterator->first == 81)
std::cout << iterator->second << std::endl;
}
}
void out_int(int number) {
std::cout << number << " ";
}
#include <list>
#include <iterator>
#include <algorithm> // Dla for_each.
#include <set>
#include <string>
#include <map>
#include <deque>
#include <functional> // Dla obiektu funkcyjnego greater.
void out_int(int number);
template <class type> class runtime_cmp {
public:
enum cmp_mode { normal, reverse };
// Konstruktor dla kryterium sortowania.
runtime_cmp(cmp_mode mode_constructor = normal) : mode(mode_constructor) { }
// Porównanie elementów.
bool operator()(const type &element_one, const type &element_two) const {
return ((mode == normal) ? (element_one < element_two) : (element_two < element_one));
}
// Porównanie kryteriów sortowania.
bool operator==(const runtime_cmp &element) {
return (mode == element.mode);
}
private:
cmp_mode mode;
};
int main() {
// Kontenery sekwencyjne.
// Wektory.
// Kolejki o dwóch końcach.
std::deque<std::string> string_queue;
string_queue.assign(3, "String"); // Wstaw 3 kopie podanego łańcucha.
string_queue.push_back("Ostatni string"); // Dołącz na końcu podany element.
string_queue.push_front("Pierwszy string"); // Wstaw na początek.
std::copy(string_queue.begin(), string_queue.end(), std::ostream_iterator<std::string>(std::cout, "\n")); // Wypisz elementy w oddzielnych wierszach.
string_queue.pop_front(); // Usuń pierwszy.
string_queue.pop_back(); // Usuń ostatni element.
// Wstaw łańcuch "Other" do każdego elementu oprócz pierwszego.
for (unsigned iterator = 1; iterator < string_queue.size(); ++iterator)
string_queue[iterator] = "Other " + string_queue[iterator];
string_queue.resize(4, "String zmiany rozmiaru"); // Zmień rozmiar o ewentualnie brakujące elementy uzupełnij podanymi.
// Listy.
std::list<int> one(5, 2); // Lista pięciu wartości 2.
std::list<int> two, four, five;
int numbers[5] = { 1, 2, 3, 4, 5 };
two.insert(two.begin(), numbers, (numbers + 5)); // Wstawia kopie elementów z zakresu od drugiego do trzeciego argument przed miejscem podanym jako trzeci argument.
int more_numbers[6] = { 6, 7, 8, 9, 10, 11 };
std::list<int> three(two);
three.insert(three.end(), more_numbers, (more_numbers + 6));
std::cout << "Lista one: ";
std::for_each(one.begin(), one.end(), out_int);
std::cout << std::endl;
std::cout << "Lista two: ";
std::for_each(two.begin(), two.end(), out_int);
std::cout << std::endl;
std::cout << "Lista three: ";
std::for_each(three.begin(), three.end(), out_int);
std::cout << std::endl;
// Wypełnij listy elementami.
for (int iterator = 0; iterator < 6; iterator++) {
four.push_back(iterator);
five.push_front(iterator);
}
three.remove(2); // Usuwa z listy wszystkie wystąpienia wartości 2.
three.splice(three.begin(), one); // Wstawia zawartość listy podanej jako drugi argument (i usuwa jej zawartość) przed pozycję podaną jako pierwszy argument.
five.splice(std::find(five.begin(), five.end(), 3), four); // Wstaw wszystkie elementy kontenera podanego jako drugi argument przed pierwszym elementem, do którego iterator zwróciła funkcja find wprowadzona jako pierwszy argument.
five.splice(five.end(), five, five.begin()); // Pozycja docelowa, lista źródłowa, pozycja źródłowa (przenieś pierwszy element na koniec).
three.unique(); // Łączy grupę takich samych elementów występujących obok siebie w jeden element.
three.sort(); // Sortuje liste od wartości najmniejszej do największej.
three.merge(two); // Scala listę podaną jako argument (i usuwa jej zawartość) z listą wywołującą.
// Kontenery asocjacyjne.
// Zbiory i wielozbiory.
std::string words[] = { "Pierwszy", "Drugi", "Trzeci" };
std::string second_words[] = { "Czwarty", "Piaty" };
std::set<std::string> word_container(words, (words + 3)); // Zbiór obiektów typu string.
std::set<std::string> second_word_container(second_words, (second_words + 2));
std::set<std::string> third_word_container;
std::ostream_iterator<std::string, char> out(std::cout, " "); // Interfejs do wyświetlania typu string na strumień cout używający typu char i separatora " ".
std::copy(word_container.begin(), word_container.end(), out); // Kopiuj z do i posortuj.
std::cout << std::endl;
std::set_union(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Wysyła sumę zbiorów do strumienia podanego jako ostatni argument, sortuje i scala takie same wyrazy.
std::set_union(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), std::insert_iterator<std::set<std::string> >(third_word_container, third_word_container.begin()));
std::cout << std::endl;
std::set_intersection(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Przecięcie dwóch zbiorów.
std::cout << std::endl;
std::set_difference(word_container.begin(), word_container.end(), second_word_container.begin(), second_word_container.end(), out); // Różnica dwóch zbiorów.
std::cout << std::endl;
third_word_container.insert("Kolejny"); // Wstawiamy kolejną wartość do zbioru.
std::copy(third_word_container.lower_bound("Drugi"), third_word_container.upper_bound("Trzeci"), out); // Wyświetlanie zakresu: funkcja lower_bound przyjmuje jako argument wartość klucza i zwraca iterator, który wskazuje na pierwszy element zbioru nie mniejszy od podanego argumentu (funkcja upper_bound intuicyjnie odpowiednio).
std::cout << std::endl;
if (third_word_container.insert("Kolejny").second)
std::cout << "Wstawiono element \"Kolejny\" do kontenera \"third_word_container\".\n";
else
std::cout << "Element \"Kolejny\" w kontenerze \"third_word_container\" juz istnieje.\n";
int delete_numbers = third_word_container.erase("Kolejny"); // Usuń wszystkie elementy o podanej wartości.
std::cout << "Usuniet " << delete_numbers << " elementow \"Kolejny\".\n";
std::set <int, std::greater<int> > int_container; // Bez powtórzeń, elementy są wartościami całkowitymi, a porządek malejący.
std::set<int, std::greater<int> >::iterator position; // Iterator dla kolekcji.
int_container.insert(4);
int_container.insert(2);
int_container.insert(1);
// Iteruj po wszystkich elementach.
for (position = int_container.begin(); position != int_container.end(); ++position)
std::cout << * position << std::endl;
std::set<int> second_int_container(int_container.begin(), int_container.end()); // Przypisz elementy do innego zbioru w porządku rosnącym.
std::set<int, runtime_cmp<int> > third_int_container;
third_int_container.insert(5);
third_int_container.insert(2);
third_int_container.insert(1);
runtime_cmp<int> reverse_order(runtime_cmp<int>::reverse); // Kryterium sortowania o odwrotnej kolejności elementów.
std::set<int, runtime_cmp<int> > fourth_int_container(reverse_order);
third_int_container = fourth_int_container; // Przypisz elementy oraz kryterium sortowania.
if (third_int_container.value_comp() == fourth_int_container.value_comp())
std::cout << "Zbiory third_int_container oraz fourth_int_container posiadaja to samo kryterium sortowania.\n";
std::multiset<int, std::greater<int> > int_multicontainer; // Powtórzenia dozwolone, elementy są wartościami całkowitymi, porządek malejący.
int_multicontainer.insert(4);
int_multicontainer.insert(1);
int_multicontainer.insert(5);
std::multiset<int, std::greater<int> >::iterator multiset_pointer = int_multicontainer.insert(4); // Wstaw ponownie wartość 4.
std::cout << "Wartosc 4 wstawiono do kontenera \"int_multicontainer\" jako element nr " << std::distance(int_multicontainer.begin(), multiset_pointer) + 1 << ".\n";
// Mapy oraz multimapy.
std::map<std::string, float> map_collection;
map_collection.insert(std::map<std::string, float>::value_type("Jan", 22.3));
map_collection.insert(std::pair<std::string, float>("Bartlomiej", 26)); // Wykorzystanie konwersji niejawnej.
map_collection.insert(std::pair<const std::string, float>("Tomek", 26)); // Brak wykorzystania konwersji niejawnej.
if (map_collection.insert(std::make_pair("Michal", 0)).second)
std::cout << "Udalo sie wstawic pare Michal-0 do mapy.\n";
else
std::cout << "Nie udalo sie wstawic pary Michal-0 do mapy.\n";
for (auto map_iterator = map_collection.begin(); map_iterator != map_collection.end(); ++map_iterator)
std::cout << "Klucz: " << map_iterator->first << ", wartosc: " << map_iterator->second << std::endl;
map_collection.erase("Tomek"); // Usuń wszystkie elementy o podanym kluczu.
auto map_iterator = map_collection.find("Jan");
// Poniższe dwie instrukcje sprawiają, że podany klucz zmieni swoją nazwę.
map_collection["Jan"] = map_collection["Janek"];
map_collection.erase("Janek");
if (map_iterator != map_collection.end())
map_collection.erase(map_iterator); // Usuń pierwszy element o podanym kluczu.
map_collection["Bartek"] = map_collection["Bartlomiej"]; // Wstaw nowy element o wartości starego elementu.
map_collection["Bonifacy"] = 0;
for (auto map_iterator = map_collection.begin(); map_iterator != map_collection.end(); ++map_iterator)
map_iterator->second *= 2; // Podwajamy wartość każdego klucza.
typedef std::pair<const int, std::string> pair;
typedef std::multimap<int, std::string> map_code;
map_code codes;
codes.insert(pair(41, "Bytom"));
codes.insert(pair(81, "Bytom"));
codes.insert(pair(81, "Sopot"));
codes.insert(std::make_pair(33, "Krakow"));
std::cout << "Liczba miast o kodzie 81: " << codes.count(81) << std::endl;
std::cout << "Kod regioniu i miasto:\n";
for (auto pointer = codes.begin(); pointer != codes.end(); ++pointer)
std::cout << (* pointer).first << ", " << (* pointer).second << std::endl;
std::pair<map_code::iterator, map_code::iterator> range = codes.equal_range(81);
std::cout << "Miasta o kodzie 81:\n";
for (auto pointer = range.first; pointer != range.second; ++pointer)
std::cout << (* pointer).second << std::endl;
std::cout << "Wszystkie wartosci dla klucza 81:\n";
for (auto iterator = codes.begin(); iterator != codes.end(); ++iterator) {
if (iterator->first == 81)
std::cout << iterator->second << std::endl;
}
}
void out_int(int number) {
std::cout << number << " ";
}
Źródło:
- Prata S., Język C++. Szkoła programowania. Wydanie VI, Helion SA, 2012,
- Josuttis N. M., C++. Biblioteka standardowa, Helion SA, 2003.
Iteratory STL w C++
#include <iostream>
#include <vector>
#include <iterator>
#include <list>
#include <set>
// Definicja iteratora wstawiającego dla kontenerów asocjacyjnych.
template <class container> class associative_insert_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void> {
protected:
container & insert_container; // Kontener, do którego wstawiane są elementy.
public:
explicit associative_insert_iterator(container & constructor_container) : insert_container(constructor_container) { }
associative_insert_iterator<container> & operator=(const typename container::value_type & value) {
insert_container.insert(value);
return * this;
}
associative_insert_iterator<container> & operator*() {
return * this;
}
associative_insert_iterator<container> & operator++() {
return * this;
}
associative_insert_iterator<container> * operator++(int) {
return * this;
}
};
int main() {
std::vector<double> numbers(5);
double table[5] = { 1.204, 2.1, 3, 4, 5 };
std::vector<double>::iterator pointer;
// std::vector<double>::const_iterator const_pointer; // Do iterowania po elementach w trybie z odczytem i zapisem.
// Przypisuje wszystkim elementom kontera konkretną wartość.
for (pointer = numbers.begin(); pointer != numbers.end(); pointer++)
* pointer = 1.2;
std::advance(pointer, -1); // Przesuń iterator o 1 miejsce do tyłu.
std::cout << "Roznica pomiedzy poczatkiem a aktualna pozycja iteratora liczb calkowytych wynosi " << std::distance(numbers.begin(), pointer) << ".\n";
std::iter_swap(numbers.begin(), ++numbers.begin()); // Zamień miejscami.
// for (auto pointer = numbers.begin(); pointer != numbers.end(); pointer++)
// * pointer = 1.2;
// for (auto pointer : numbers)
// * pointer = 1.2;
std::ostream_iterator<double, char> out_iterator(std::cout, " ");
*out_iterator++ = 15; // Wyświetla liczbę 15 i oddziela ją spacją.
std::cout << std::endl;
std::istream_iterator<int> int_reader(std::cin); // Utwórz iterator strumieniowy wejściowy odczytujący dane ze strumienia cin.
std::istream_iterator<int> int_reader_off; // Iterator końca strumienia.
// Dopóki możliwy jest odczyt elementów z wykorzystaniem iteratora strumieniowego wejściowego to wypisuj je.
while (int_reader != int_reader_off) {
std::cout << "Podales: " << * int_reader << std::endl;
++int_reader;
}
std::copy(table, (table + 5), numbers.begin()); // Kopiuje tablicę do wektora.
std::copy(numbers.begin(), numbers.end(), out_iterator); // Kopiuje wektor do strumienia wyjścia.
std::cout << std::endl;
// std::copy(numbers.begin(), numbers.end(), std::ostream_iterator<int, char>(std::cout, " "));
std::copy(numbers.rbegin(), numbers.rend(), out_iterator); // Kopiuje wektor do strumienia wyjścia w odwrotnej kolejności.
std::cout << std::endl;
std::vector<double>::reverse_iterator reverse_pointer;
// std::vector<double>::reverse_iterator reverse_pointer(pointer); // Konwertuj iterator na iterator odwrotny.
// std::vector<double>::iterator reverse_reverse_pointer;
// reverse_reverse_pointer = reverse_pointer.base(); // Konwertuj z powrotem na iterator normalny.
// Wypisuje w odwrotnej kolejności.
for (reverse_pointer = numbers.rbegin(); reverse_pointer != numbers.rend(); reverse_pointer++)
std::cout << *reverse_pointer << std::endl;
std::string words[] = { "Pierwszy", "Drugi", "Trzeci", "Czwarty" };
std::vector<std::string> word_vector(4);
std::copy(words, (words + 4), word_vector.begin());
std::copy(words, (words + 2), std::back_insert_iterator<std::vector<std::string> >(word_vector)); // Wstawia dwa ciągi z tablicy stringów na koniec wektora zwiększając tym samym ilość jego elementów do 6.
numbers.clear(); // Wyczyść zawartość
std::list<int> lists;
std::set<int> sets;
std::back_insert_iterator<std::vector<double> > bi_iterator(numbers); // Utwórz wstawiacz końcowy dla wektora.
std::front_insert_iterator<std::list<int> > fi_iterator(lists); // Utwórz wstawiacz początkowy dla listy.
std::insert_iterator<std::set<int> > i_iterator(sets, sets.begin()); // Utwórz wstawiacz ogólny dla kontenera typu set.
* bi_iterator = 1; // Wstaw element.
++bi_iterator; // Przesuń iterator na kolejny element.
* bi_iterator = 2;
std::back_inserter(numbers) = 3; // Wstaw element.
std::back_inserter(numbers) = 4;
std::front_inserter(lists) = 1;
std::inserter(sets, sets.begin()) = 1;
std::copy(numbers.begin(), numbers.end(), out_iterator);
// Użycie iterator zdefiniowanego przez użytkownika.
std::set<int> collection;
associative_insert_iterator<std::set<int> > aii_iterator(collection);
* aii_iterator = 1;
aii_iterator++;
}
#include <vector>
#include <iterator>
#include <list>
#include <set>
// Definicja iteratora wstawiającego dla kontenerów asocjacyjnych.
template <class container> class associative_insert_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void> {
protected:
container & insert_container; // Kontener, do którego wstawiane są elementy.
public:
explicit associative_insert_iterator(container & constructor_container) : insert_container(constructor_container) { }
associative_insert_iterator<container> & operator=(const typename container::value_type & value) {
insert_container.insert(value);
return * this;
}
associative_insert_iterator<container> & operator*() {
return * this;
}
associative_insert_iterator<container> & operator++() {
return * this;
}
associative_insert_iterator<container> * operator++(int) {
return * this;
}
};
int main() {
std::vector<double> numbers(5);
double table[5] = { 1.204, 2.1, 3, 4, 5 };
std::vector<double>::iterator pointer;
// std::vector<double>::const_iterator const_pointer; // Do iterowania po elementach w trybie z odczytem i zapisem.
// Przypisuje wszystkim elementom kontera konkretną wartość.
for (pointer = numbers.begin(); pointer != numbers.end(); pointer++)
* pointer = 1.2;
std::advance(pointer, -1); // Przesuń iterator o 1 miejsce do tyłu.
std::cout << "Roznica pomiedzy poczatkiem a aktualna pozycja iteratora liczb calkowytych wynosi " << std::distance(numbers.begin(), pointer) << ".\n";
std::iter_swap(numbers.begin(), ++numbers.begin()); // Zamień miejscami.
// for (auto pointer = numbers.begin(); pointer != numbers.end(); pointer++)
// * pointer = 1.2;
// for (auto pointer : numbers)
// * pointer = 1.2;
std::ostream_iterator<double, char> out_iterator(std::cout, " ");
*out_iterator++ = 15; // Wyświetla liczbę 15 i oddziela ją spacją.
std::cout << std::endl;
std::istream_iterator<int> int_reader(std::cin); // Utwórz iterator strumieniowy wejściowy odczytujący dane ze strumienia cin.
std::istream_iterator<int> int_reader_off; // Iterator końca strumienia.
// Dopóki możliwy jest odczyt elementów z wykorzystaniem iteratora strumieniowego wejściowego to wypisuj je.
while (int_reader != int_reader_off) {
std::cout << "Podales: " << * int_reader << std::endl;
++int_reader;
}
std::copy(table, (table + 5), numbers.begin()); // Kopiuje tablicę do wektora.
std::copy(numbers.begin(), numbers.end(), out_iterator); // Kopiuje wektor do strumienia wyjścia.
std::cout << std::endl;
// std::copy(numbers.begin(), numbers.end(), std::ostream_iterator<int, char>(std::cout, " "));
std::copy(numbers.rbegin(), numbers.rend(), out_iterator); // Kopiuje wektor do strumienia wyjścia w odwrotnej kolejności.
std::cout << std::endl;
std::vector<double>::reverse_iterator reverse_pointer;
// std::vector<double>::reverse_iterator reverse_pointer(pointer); // Konwertuj iterator na iterator odwrotny.
// std::vector<double>::iterator reverse_reverse_pointer;
// reverse_reverse_pointer = reverse_pointer.base(); // Konwertuj z powrotem na iterator normalny.
// Wypisuje w odwrotnej kolejności.
for (reverse_pointer = numbers.rbegin(); reverse_pointer != numbers.rend(); reverse_pointer++)
std::cout << *reverse_pointer << std::endl;
std::string words[] = { "Pierwszy", "Drugi", "Trzeci", "Czwarty" };
std::vector<std::string> word_vector(4);
std::copy(words, (words + 4), word_vector.begin());
std::copy(words, (words + 2), std::back_insert_iterator<std::vector<std::string> >(word_vector)); // Wstawia dwa ciągi z tablicy stringów na koniec wektora zwiększając tym samym ilość jego elementów do 6.
numbers.clear(); // Wyczyść zawartość
std::list<int> lists;
std::set<int> sets;
std::back_insert_iterator<std::vector<double> > bi_iterator(numbers); // Utwórz wstawiacz końcowy dla wektora.
std::front_insert_iterator<std::list<int> > fi_iterator(lists); // Utwórz wstawiacz początkowy dla listy.
std::insert_iterator<std::set<int> > i_iterator(sets, sets.begin()); // Utwórz wstawiacz ogólny dla kontenera typu set.
* bi_iterator = 1; // Wstaw element.
++bi_iterator; // Przesuń iterator na kolejny element.
* bi_iterator = 2;
std::back_inserter(numbers) = 3; // Wstaw element.
std::back_inserter(numbers) = 4;
std::front_inserter(lists) = 1;
std::inserter(sets, sets.begin()) = 1;
std::copy(numbers.begin(), numbers.end(), out_iterator);
// Użycie iterator zdefiniowanego przez użytkownika.
std::set<int> collection;
associative_insert_iterator<std::set<int> > aii_iterator(collection);
* aii_iterator = 1;
aii_iterator++;
}
Źródło:
- Prata S., Język C++. Szkoła programowania. Wydanie VI, Helion SA, 2012,
- Josuttis N. M., C++. Biblioteka standardowa, Helion SA, 2003.
Wektory STL w C++
#include <iostream>
#include <vector>
#include <algorithm>
bool is_lower_than_3(double number);
int main() {
std::vector<int> numbers(5); // Wektor 5 liczb całkowitych.
// std::vector<int> numbers(5, 1); // Wektor pięciu liczb 1.
int elements;
std::cout << "Ile wektor lancuchow ma miec elementow: ";
std::cin >> elements;
std::vector<std::string> titles(elements);
// Przypisanie konkretnym elementom wektora danych wartości.
for (int iterator = 0; iterator < numbers.size(); iterator++)
numbers[iterator] = iterator; // Brak kontroli zakresu.
try {
numbers.at(5) = 6; // Kontrola zakresu.
} catch (std::out_of_range & extension) {
std::cout << "Blad kontroli zakresu: " << extension.what() << std::endl;
}
std::vector<int>::iterator pointer; // Deklaracja iteratora.
// auto pointer = numbers.begin();
pointer = numbers.begin(); // Iterator wskazuje na pierwszy element wektora.
*pointer = 1;
++pointer; // Przesuwamy iterator na kolejny element.
*pointer = 2;
numbers.back() = 0; // Przypisz ostatniemu elementowi wartość 0.
// Wypisanie wszystkich elementów wektora za pomocą iteratora.
for (pointer = numbers.begin(); pointer != numbers.end(); pointer++)
std::cout << * pointer << std::endl;
std::vector<double> scores;
std::cout << "Najwieksza mozliwa liczba elementor dla wektora zmiennych typu double to w tym wypadku " << scores.max_size() << " natomiast w aktualnym obszarze pamieci moze pomiescic " << scores.capacity() << " elementy.\n"; // Funkcja capacity zwróci wartość większa od zera dopiero jak w wektorze znajdą się jakieś wartości.
std::cout << "Ile chcesz wprowadzic wartosci punktow: ";
std::cin >> elements;
// scores.reserve(elements); // Zarezerwuj obszar pamięci na elements elementów.
double temporary;
for (int iterator = 0; iterator < elements; iterator++) {
std::cout << "Podaj wartosc: ";
std::cin >> temporary;
scores.push_back(temporary); // Dodaje element na koniec wektora. Z kolei funkcja pop_back usuwa ostatni element.
}
scores.erase(scores.begin(), (scores.begin() + 2)); // Usuwamy pierwszy i drugi element.
std::cout << "Podaj ktora wartosc chcesz usunac z kontenera liczb calkowitych: ";
std::cin >> elements;
pointer = std::find(numbers.begin(), numbers.end(), elements);
if (pointer != numbers.end())
numbers.erase(pointer);
std::vector<double> new_scores(scores); // Konstruktor kopiujący.
new_scores.insert(new_scores.begin(), scores.begin(), scores.end()); // Wstawia przed pierwszy element wektora (określany jako pierwszy argument) wartości wektora określane zakresem drugiego i trzeciego argumentu.
for_each(new_scores.begin(), new_scores.end(), is_lower_than_3); // Dla każdego elementu z zakresu podanego przez iteratory wywołujemy daną funkcję.
// for (auto iterator : new_scores)
// is_lower_than_3(iterator);
std::random_shuffle(new_scores.begin(), new_scores.end()); // Zamienia kolejność elementów w sposób losowy.
std::sort(new_scores.begin(), new_scores.end()); // Sortuje wartości w porzadku rosnącym (jeśli elementy kontenera nie są zdefiniowane przez użytkownika). Jeżeli chcemy sortować w porządku malejącym to musimy napisać funkcję, która porównuje dwa pierwsze argumenty funkcji sort, a jej nazwę podać jako trzeci argument.
std::vector<int> next_numbers(numbers.begin(), numbers.end());
new_scores.resize(0); // Ustawia liczbę elementów kontenera na 0.
new_scores.clear(); // Opróżnia kontener.
new_scores.~vector<double>(); // Niszczy wszystkie elementy i zwalnia pamięć.
}
bool is_lower_than_3(double number) {
if (number < 3)
return true;
else
return false;
}
#include <vector>
#include <algorithm>
bool is_lower_than_3(double number);
int main() {
std::vector<int> numbers(5); // Wektor 5 liczb całkowitych.
// std::vector<int> numbers(5, 1); // Wektor pięciu liczb 1.
int elements;
std::cout << "Ile wektor lancuchow ma miec elementow: ";
std::cin >> elements;
std::vector<std::string> titles(elements);
// Przypisanie konkretnym elementom wektora danych wartości.
for (int iterator = 0; iterator < numbers.size(); iterator++)
numbers[iterator] = iterator; // Brak kontroli zakresu.
try {
numbers.at(5) = 6; // Kontrola zakresu.
} catch (std::out_of_range & extension) {
std::cout << "Blad kontroli zakresu: " << extension.what() << std::endl;
}
std::vector<int>::iterator pointer; // Deklaracja iteratora.
// auto pointer = numbers.begin();
pointer = numbers.begin(); // Iterator wskazuje na pierwszy element wektora.
*pointer = 1;
++pointer; // Przesuwamy iterator na kolejny element.
*pointer = 2;
numbers.back() = 0; // Przypisz ostatniemu elementowi wartość 0.
// Wypisanie wszystkich elementów wektora za pomocą iteratora.
for (pointer = numbers.begin(); pointer != numbers.end(); pointer++)
std::cout << * pointer << std::endl;
std::vector<double> scores;
std::cout << "Najwieksza mozliwa liczba elementor dla wektora zmiennych typu double to w tym wypadku " << scores.max_size() << " natomiast w aktualnym obszarze pamieci moze pomiescic " << scores.capacity() << " elementy.\n"; // Funkcja capacity zwróci wartość większa od zera dopiero jak w wektorze znajdą się jakieś wartości.
std::cout << "Ile chcesz wprowadzic wartosci punktow: ";
std::cin >> elements;
// scores.reserve(elements); // Zarezerwuj obszar pamięci na elements elementów.
double temporary;
for (int iterator = 0; iterator < elements; iterator++) {
std::cout << "Podaj wartosc: ";
std::cin >> temporary;
scores.push_back(temporary); // Dodaje element na koniec wektora. Z kolei funkcja pop_back usuwa ostatni element.
}
scores.erase(scores.begin(), (scores.begin() + 2)); // Usuwamy pierwszy i drugi element.
std::cout << "Podaj ktora wartosc chcesz usunac z kontenera liczb calkowitych: ";
std::cin >> elements;
pointer = std::find(numbers.begin(), numbers.end(), elements);
if (pointer != numbers.end())
numbers.erase(pointer);
std::vector<double> new_scores(scores); // Konstruktor kopiujący.
new_scores.insert(new_scores.begin(), scores.begin(), scores.end()); // Wstawia przed pierwszy element wektora (określany jako pierwszy argument) wartości wektora określane zakresem drugiego i trzeciego argumentu.
for_each(new_scores.begin(), new_scores.end(), is_lower_than_3); // Dla każdego elementu z zakresu podanego przez iteratory wywołujemy daną funkcję.
// for (auto iterator : new_scores)
// is_lower_than_3(iterator);
std::random_shuffle(new_scores.begin(), new_scores.end()); // Zamienia kolejność elementów w sposób losowy.
std::sort(new_scores.begin(), new_scores.end()); // Sortuje wartości w porzadku rosnącym (jeśli elementy kontenera nie są zdefiniowane przez użytkownika). Jeżeli chcemy sortować w porządku malejącym to musimy napisać funkcję, która porównuje dwa pierwsze argumenty funkcji sort, a jej nazwę podać jako trzeci argument.
std::vector<int> next_numbers(numbers.begin(), numbers.end());
new_scores.resize(0); // Ustawia liczbę elementów kontenera na 0.
new_scores.clear(); // Opróżnia kontener.
new_scores.~vector<double>(); // Niszczy wszystkie elementy i zwalnia pamięć.
}
bool is_lower_than_3(double number) {
if (number < 3)
return true;
else
return false;
}
Źródło:
- Prata S., Język C++. Szkoła programowania. Wydanie VI, Helion SA, 2012,
- Josuttis N. M., C++. Biblioteka standardowa, Helion SA, 2003.
piątek, 27 czerwca 2014
Kod C++ - rekurencja
#include <iostream>
#include <ctime>
#include <cstdlib>
int exponentiation_recursion(int base, int index);
int exponentiation_iteration(int base, int index);
int fibonacci_recursion(int number);
int fibonacci_iteration(int number);
int factorial_recursion(int number);
int factorial_iteration(int number);
double execution_time(int (* pointer)(int), int argument, int & result); // Funkcja obliczająca czas wykonania danej funkcji.
double execution_time(int (* pointer)(int, int), int first_argument, int second_argument, int & result); // Funkcja obliczająca czas wykonania danej funkcji (przeładowanie).
int main() {
int result;
double recursion_time, iteration_time;
recursion_time = execution_time(fibonacci_recursion, 30, result);
iteration_time = execution_time(fibonacci_iteration, 30, result);
std::cout << "Funkcja obliczajaca rekurencyjnie ciag Fibonacciego dla liczby 30 wykonala sie w czasie " << recursion_time << " sekund.\n";
std::cout << "Funkcja obliczajaca iteracyjnie ciag Fibonacciego dla liczby 30 wykonala sie w czasie " << iteration_time << " sekund.\n";
recursion_time = execution_time(exponentiation_recursion, 2, 30, result);
iteration_time = execution_time(exponentiation_iteration, 2, 30, result);
std::cout << "Funkcja obliczajaca rekurencyjnie 2 do potegi 30 wykonala sie w czasie " << recursion_time << " sekund.\n";
std::cout << "Funkcja obliczajaca iteracyjnie 2 do potegi 30 wykonala sie w czasie " << iteration_time << " sekund.\n";
}
int exponentiation_recursion(int base, int index) {
if (index == 0) // Przypadek elementarny.
return 1;
else
return (base * exponentiation_recursion(base, (index - 1)));
}
int exponentiation_iteration(int base, int index) {
if (index == 0)
return 1;
else if (index == 1)
return base;
else {
int result = base;
for (int iterator = 2; iterator <= index; iterator++)
result *= base;
return result;
}
}
int fibonacci_recursion(int number) {
if ((number == 1) || (number == 2)) // Przypadek elementarny.
return 1;
else
return (fibonacci_recursion(number - 1) + fibonacci_recursion(number - 2));
}
int fibonacci_iteration(int number) {
if ((number == 1) || (number == 2))
return 1;
else {
int result;
int before = 1, after = 1;
for (int iterator = 3; iterator <= number; iterator++) {
result = (before + after);
before = after;
after = result;
}
return result;
}
}
int factorial_recursion(int number) {
if (number == 0) // Przypadek elementarny.
return 1;
else
return (number * factorial_recursion(number - 1));
}
int factorial_iteration(int number) {
if (number == 0)
return 1;
else {
int result = 1;
for (int iterator = 1; iterator <= number; iterator++)
result *= iterator;
return result;
}
}
double execution_time(int (* pointer)(int), int argument, int & result) {
clock_t start, stop;
double time;
start = clock();
result = pointer(argument);
stop = clock();
time = static_cast<double>(stop - start); // Wynikiem jest liczba cykli procesora.
time /= CLOCKS_PER_SEC; // Wynik w sekundach.
return time;
}
double execution_time(int (* pointer)(int, int), int first_argument, int second_argument, int & result) {
clock_t start, stop;
double time;
start = clock();
result = pointer(first_argument, second_argument);
stop = clock();
time = static_cast<double>(stop - start); // Wynikiem jest liczba cykli procesora.
time /= CLOCKS_PER_SEC; // Wynik w sekundach.
return time;
}
#include <ctime>
#include <cstdlib>
int exponentiation_recursion(int base, int index);
int exponentiation_iteration(int base, int index);
int fibonacci_recursion(int number);
int fibonacci_iteration(int number);
int factorial_recursion(int number);
int factorial_iteration(int number);
double execution_time(int (* pointer)(int), int argument, int & result); // Funkcja obliczająca czas wykonania danej funkcji.
double execution_time(int (* pointer)(int, int), int first_argument, int second_argument, int & result); // Funkcja obliczająca czas wykonania danej funkcji (przeładowanie).
int main() {
int result;
double recursion_time, iteration_time;
recursion_time = execution_time(fibonacci_recursion, 30, result);
iteration_time = execution_time(fibonacci_iteration, 30, result);
std::cout << "Funkcja obliczajaca rekurencyjnie ciag Fibonacciego dla liczby 30 wykonala sie w czasie " << recursion_time << " sekund.\n";
std::cout << "Funkcja obliczajaca iteracyjnie ciag Fibonacciego dla liczby 30 wykonala sie w czasie " << iteration_time << " sekund.\n";
recursion_time = execution_time(exponentiation_recursion, 2, 30, result);
iteration_time = execution_time(exponentiation_iteration, 2, 30, result);
std::cout << "Funkcja obliczajaca rekurencyjnie 2 do potegi 30 wykonala sie w czasie " << recursion_time << " sekund.\n";
std::cout << "Funkcja obliczajaca iteracyjnie 2 do potegi 30 wykonala sie w czasie " << iteration_time << " sekund.\n";
}
int exponentiation_recursion(int base, int index) {
if (index == 0) // Przypadek elementarny.
return 1;
else
return (base * exponentiation_recursion(base, (index - 1)));
}
int exponentiation_iteration(int base, int index) {
if (index == 0)
return 1;
else if (index == 1)
return base;
else {
int result = base;
for (int iterator = 2; iterator <= index; iterator++)
result *= base;
return result;
}
}
int fibonacci_recursion(int number) {
if ((number == 1) || (number == 2)) // Przypadek elementarny.
return 1;
else
return (fibonacci_recursion(number - 1) + fibonacci_recursion(number - 2));
}
int fibonacci_iteration(int number) {
if ((number == 1) || (number == 2))
return 1;
else {
int result;
int before = 1, after = 1;
for (int iterator = 3; iterator <= number; iterator++) {
result = (before + after);
before = after;
after = result;
}
return result;
}
}
int factorial_recursion(int number) {
if (number == 0) // Przypadek elementarny.
return 1;
else
return (number * factorial_recursion(number - 1));
}
int factorial_iteration(int number) {
if (number == 0)
return 1;
else {
int result = 1;
for (int iterator = 1; iterator <= number; iterator++)
result *= iterator;
return result;
}
}
double execution_time(int (* pointer)(int), int argument, int & result) {
clock_t start, stop;
double time;
start = clock();
result = pointer(argument);
stop = clock();
time = static_cast<double>(stop - start); // Wynikiem jest liczba cykli procesora.
time /= CLOCKS_PER_SEC; // Wynik w sekundach.
return time;
}
double execution_time(int (* pointer)(int, int), int first_argument, int second_argument, int & result) {
clock_t start, stop;
double time;
start = clock();
result = pointer(first_argument, second_argument);
stop = clock();
time = static_cast<double>(stop - start); // Wynikiem jest liczba cykli procesora.
time /= CLOCKS_PER_SEC; // Wynik w sekundach.
return time;
}
Subskrybuj:
Posty (Atom)