Różnice między wybraną wersją a wersją aktualną.
Both sides previous revision Previous revision Next revision | Previous revision | ||
unique_unique_copy [2009/04/30 00:08] pgrabowska |
unique_unique_copy [2009/04/30 02:01] (aktualna) pgrabowska |
||
---|---|---|---|
Linia 20: | Linia 20: | ||
**unique ** to algorytm służący usuwaniu następujących po sobie duplikatów elementów z zakresu [ //firstElement// , //lastElement// ). //firstElement// i //lastElement// są iteratorami wskazującymi na pozycję w kontenerze ( np. lista, wektor ). Algorytm jest realizowany poprzez usuwanie wszystkich elementów identycznych z elementem bezpośrednio poprzedzającym. | **unique ** to algorytm służący usuwaniu następujących po sobie duplikatów elementów z zakresu [ //firstElement// , //lastElement// ). //firstElement// i //lastElement// są iteratorami wskazującymi na pozycję w kontenerze ( np. lista, wektor ). Algorytm jest realizowany poprzez usuwanie wszystkich elementów identycznych z elementem bezpośrednio poprzedzającym. | ||
- | Porównywanie elementów odbywa się przy wykorzystaniu operatora ==. W przypadku, gdy nie jest zaimplementowany, należy podać jako trzeci argument funkcję, która porównuje elementy. Powinna ona zwracać //true// jeśli elementy są identyczne i //false// w przeciwnym przypadku. | + | Porównywanie elementów odbywa się przy wykorzystaniu operatora ==. W przypadku, gdy nie jest zaimplementowany, należy podać jako trzeci argument predykat, który porównuje elementy. Powinien on zwracać //true// jeśli elementy są identyczne i //false// w przeciwnym przypadku. |
Zachowanie algorytmu jest następujące: | Zachowanie algorytmu jest następujące: | ||
Linia 39: | Linia 39: | ||
</code> | </code> | ||
- | ==== Parametry: ==== | + | ==== Parametry ==== |
- | //firstElement, lastElement// | + | * //firstElement, lastElement// - iteratory wskazujące zakres elementów na którym będzie realizowany algorytm. Zakres ten zawiera wszystkie elementy od //firstElement// do elementu poprzedzającego //lastElement//. |
- | Iteratory wskazujące zakres elementów na którym będzie realizowany algorytm. Zakres ten zawiera wszystkie elementy od firstElement do elementu poprzedzającego lastElement. | + | * //comp// - binarny predykat przyjmujący 2 elemety jako argumenty i zwracający //true// jeśli oba są równe i //false// w przeciwnym przypadku. Może to być zarówno wskaźnik na funkcję, jak i wskaźnik na obiekt klasy przeciążającej //operator()//. |
- | //comp// | + | |
- | Binarny predykat przyjmujący 2 elemety jako argumenty i zwracający true jeśli oba są równe i false w przeciwnym przypadku. Może to być zarówno wskaźnik na funkcję, jak i wskaźnik na obiekt klasy przeładowującej operator(). | + | |
- | ==== Wartość zwracana: ==== | + | ==== Wartość zwracana ==== |
Iterator wskazujący na nowy koniec sekwencji z zadanego zakresu, która nie zawiera już powtarzających się po sobie elementów. | Iterator wskazujący na nowy koniec sekwencji z zadanego zakresu, która nie zawiera już powtarzających się po sobie elementów. | ||
- | ==== Uwaga: ==== | + | ==== Uwaga ==== |
Należy uwzględnić fakt, że algorytm **unique** nie zmienia wielkości kontenera, ani nie zmienia elementów położonych za nowym końcem ( ciągle są dostępne ). | Należy uwzględnić fakt, że algorytm **unique** nie zmienia wielkości kontenera, ani nie zmienia elementów położonych za nowym końcem ( ciągle są dostępne ). | ||
+ | |||
+ | ==== Przykład ==== | ||
+ | |||
+ | <code cpp> | ||
+ | #include <iostream> | ||
+ | #include <algorithm> | ||
+ | #include <vector> | ||
+ | using namespace std; | ||
+ | |||
+ | // implementacja funkcji porownujacej elementy | ||
+ | bool comp(int i, int j) | ||
+ | { | ||
+ | return (i==j); | ||
+ | } | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | // tworzy wektory z powtarzajacymi sie po sobie elementami | ||
+ | int myints[] = {10,20,20,20,30,30,20,20,10}; | ||
+ | vector<int> myvector (myints,myints+9); // 10 20 20 20 30 30 20 20 10 | ||
+ | vector<int>::iterator it; | ||
+ | |||
+ | // PRZYKLAD UZYCIA UNIQUE Z DOMYSLNYM OPERATOREM == | ||
+ | |||
+ | // użycie unique z domyslnym operatorem == | ||
+ | it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 30 20 20 10 | ||
+ | |||
+ | // dostosowanie wielkosci myvector do zaktualizowanej liczby elementow | ||
+ | myvector.resize( it - myvector.begin() ); // 10 20 30 20 10 | ||
+ | |||
+ | // wypisanie zawartosci myvector | ||
+ | // 10 20 30 20 10 | ||
+ | cout << "\nunique z domyslnym operatorem==\n"; | ||
+ | for (vector<int>::iterator iter=myvector.begin(); iter!=myvector.end(); ++iter) | ||
+ | cout << " " << *iter; | ||
+ | |||
+ | |||
+ | // PRZYKLAD UZYCIA UNIQUE ZE ZDEFINIOWANA FUNKCJA POROWNUJACA ELEMENTY | ||
+ | myvector.clear(); | ||
+ | myvector.insert(myvector.begin(), myints, myints + 9); // 10 20 20 20 30 30 20 20 10 | ||
+ | |||
+ | // uzycie unique ze zdediniowana funkcja porownujaca elementy | ||
+ | it = unique (myvector.begin(), myvector.end(), comp); // 10 20 30 20 10 30 20 20 10 | ||
+ | |||
+ | // dostosowanie wielkosci myvector do zaktualizowanej liczby elementow | ||
+ | myvector.resize( it - myvector.begin() ); // 10 20 30 20 10 | ||
+ | |||
+ | // wypisanie zawartosci myvector | ||
+ | // 10 20 30 20 10 | ||
+ | cout << "\n\nunique ze zdefiniowana funkcja porownujaca\n"; | ||
+ | for (vector<int>::iterator iter=myvector.begin(); iter!=myvector.end(); ++iter) | ||
+ | cout << " " << *iter; | ||
+ | |||
+ | cout << endl; | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | |||
+ | |||
+ | ===== unique_copy ===== | ||
+ | |||
+ | <code cpp> | ||
+ | template <class InputIterator, class OutputIterator> | ||
+ | OutputIterator unique_copy ( InputIterator firstElement, InputIterator lastElement, OutputIterator result ); | ||
+ | |||
+ | template <class InputIterator, class OutputIterator, class BinaryPredicate> | ||
+ | OutputIterator unique_copy ( InputIterator firstElement, InputIterator firstElement, OutputIterator result, BinaryPredicate comp ); | ||
+ | </code> | ||
+ | |||
+ | **unique_copy** kopiuje wartości elementów z zakresu [ //firstElement//, //lastElement// ) do zakresu, którego początek wskazuje iterator //result//, za wyjątkiem następujących po sobie duplikatów. | ||
+ | |||
+ | Algorytm pomija elementy o wartościach identycznych z elementem bezpośrednio je poprzedzającym ( kopiowany jest zawsze tylko pierwszy element ze zbioru elementów identycznych ). | ||
+ | |||
+ | Porównywanie elementów odbywa się przy wykorzystaniu operatora ==. W przypadku, gdy nie jest zaimplementowany, należy podać jako trzeci argument predykat, który porównuje elementy. Powinien on zwracać //true// jeśli elementy są identyczne i //false// w przeciwnym przypadku. | ||
+ | |||
+ | Zachowanie algorytmu jest następujące: | ||
+ | <code cpp> | ||
+ | template <class ForwardIterator> | ||
+ | ForwardIterator unique ( ForwardIterator firstElement, ForwardIterator lastElement ) | ||
+ | { | ||
+ | ForwardIterator result = first; | ||
+ | |||
+ | while ( ++first != last ) | ||
+ | { | ||
+ | if ( !( *result == *first ) ) | ||
+ | *(++result)=*first; | ||
+ | } | ||
+ | |||
+ | return ++result; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | ==== Parametry ==== | ||
+ | * //firstElement, lastElement// - iteratory wskazujące zakres elementów na którym będzie realizowany algorytm. Zakres ten zawiera wszystkie elementy od //firstElement// do elementu poprzedzającego //lastElement//. | ||
+ | * //result// - iterator wskazujący początek zakresu, do którego ma być zapisana sekwencja elementów wyznaczona przez algorytm. | ||
+ | * //comp// - binarny predykat przyjmujący 2 elemety jako argumenty i zwracający //true// jeśli oba są równe i //false// w przeciwnym przypadku. Może to być zarówno wskaźnik na funkcję, jak i wskaźnik na obiekt klasy przeciążającej //operator()//. | ||
+ | |||
+ | ==== Wartość zwracana ==== | ||
+ | Iterator wskazujący na koniec skopiowanego zakresu. | ||
+ | |||
+ | ==== Przykład ==== | ||
+ | |||
+ | <code cpp> | ||
+ | #include <iostream> | ||
+ | #include <algorithm> | ||
+ | #include <vector> | ||
+ | using namespace std; | ||
+ | |||
+ | // implementacja funkcji porownujacej elementy | ||
+ | bool comp(int i, int j) | ||
+ | { | ||
+ | return (i==j); | ||
+ | } | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | // tworzy wektory z powtarzajacymi sie po sobie elementami | ||
+ | int myints[] = {10,20,20,20,30,30,20,20,10}; | ||
+ | vector<int> myvector (9); // 0 0 0 0 0 0 0 0 0 | ||
+ | vector<int>::iterator it; | ||
+ | |||
+ | |||
+ | // użycie unique_copy z domyslnym operatorem == | ||
+ | it=unique_copy (myints,myints+9,myvector.begin()); // 10 20 30 20 10 0 0 0 0 | ||
+ | |||
+ | // sortowanie elementow | ||
+ | sort (myvector.begin(),it); // 10 10 20 20 30 0 0 0 0 | ||
+ | |||
+ | // uzycie unique_copy ze zdediniowana funkcja porownujaca elementy | ||
+ | it=unique_copy (myvector.begin(), it, myvector.begin(), comp); // 10 20 30 20 30 0 0 0 0 | ||
+ | |||
+ | // dostosowanie wielkosci myvector1 do zaktualizowanej liczby elementow | ||
+ | myvector.resize( it - myvector.begin() ); // 10 20 30 | ||
+ | |||
+ | // wypisanie zawartosci | ||
+ | // 10 20 30 | ||
+ | for (vector<int>::iterator iter=myvector.begin(); iter!=myvector.end(); ++iter) | ||
+ | cout << " " << *iter; | ||
+ | |||
+ | cout << endl; | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | |||
+ | ===== Przykładowy program ===== | ||
+ | {{:stl_algorytmy:unique_unique_copy.cpp|}} | ||
+ | |||
+ | |||
+ | |||