Różnice

Różnice między wybraną wersją a wersją aktualną.

--- unique_unique_copy [2009/04/30 00:12]
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.
-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:
@@ Linia 39: / Linia 39: @@
 </code>
-==== Parametry: ====
+==== 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.
+  * //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//.
-  * //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().
+  * //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: ====
+==== Wartość zwracana ====
 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 ).
+==== 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|}}

zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Różnice

Narzędzia strony