std::unique_copy – cppreference.com

Aus cppreference.com

definiert in Header `<algorithm>`

`template< class InputIt, class OutputIt > ForwardIt unique_copy( InputIt first, InputIt last, OutputIt d_first );`	(1)

`template< class InputIt, class OutputIt, class BinaryPredicate > ForwardIt unique_copy( InputIt first, InputIt last, OutputIt d_first, BinaryPredicate p );`	(2)

Kopiert die Elemente aus dem Bereich [first, last), in einen anderen Bereich beginnend bei d_first derart, dass es keine aufeinanderfolgenden gleichen Elemente. Nur das erste Element einer jeden Gruppe von gleichen Elementen kopiert wird. Die erste Version verwendet operator== um die Elemente zu vergleichen, verwendet die zweite Version des gegebenen binären Prädikats p .

Original:

Copies the elements from the range [first, last), to another range beginning at d_first in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied. The first version uses operator== to compare the elements, the second version uses the given binary predicate p.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parameter

first, last	-	der Bereich der Elemente zu verarbeiten Original: the range of elements to process The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
d_first	-	der Beginn des Zielbereichs Original: the beginning of the destination range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
p	-	binary predicate which returns `true` if the elements should be treated as equal. The signature of the predicate function should be equivalent to the following: `bool pred(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`, but the function must not modify the objects passed to it. The types `Type1` and `Type2` must be such that an object of type `ForwardIt` can be dereferenced and then implicitly converted to both of them.
Type requirements
-`InputIt` must meet the requirements of `InputIterator`.
-`OutputIt` must meet the requirements of `OutputIterator`.
-The type of dereferenced `InputIt` must meet the requirements of `CopyAssignable`.
-The type of dereferenced `InputIt` must meet the requirements of `CopyConstructible`. if neither `InputIt` nor `OutputIt` satisfies `ForwardIterator`

Rückgabewert

Output Iterator auf das Element nach dem letzten schriftlichen Element

Original:

Output iterator to the element past the last written element

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Mögliche Implementierung

First version
template<class ForwardIt, class OutputIt> ForwardIt unique_copy(ForwardIt first, ForwardIt last, OutputIt d_first) { if (first == last) return d_first; d_first = first; while (++first != last) { if (!(d_first == first)) { (++d_first) = first; } } return ++d_first; }
Second version
template<class ForwardIt, class OutputIt, class BinaryPredicate> ForwardIt unique_copy(ForwardIt first, ForwardIt last, OutputIt d_first, BinaryPredicate p) { if (first == last) return d_first; d_first = first; while (++first != last) { if (!p(result, first)) { (++d_first) = first; } } return ++d_first; }

First version

template<class ForwardIt, class OutputIt>
ForwardIt unique_copy(ForwardIt first, ForwardIt last,
                      OutputIt d_first)
{
 
    if (first == last)
        return d_first;

    *d_first = *first;
     while (++first != last) {
        if (!(*d_first == *first)) {
            *(++d_first) = *first;
        }
    }
    return ++d_first;
}

Second version

template<class ForwardIt, class OutputIt, class BinaryPredicate>
ForwardIt unique_copy(ForwardIt first, ForwardIt last,
                            OutputIt d_first, BinaryPredicate p)
{
 
    if (first == last)
        return d_first;

    *d_first = *first;
    while (++first != last) {
        if (!p(*result, *first)) {
            *(++d_first) = *first;
        }
    }
    return ++d_first;
}

Beispiel

Das folgende Programm trimmt alle mehrere aufeinander folgende Leerzeichen in einer const string und gibt das Ergebnis

Original:

The following program trims all multiple consecutive spaces in a const string and prints the result

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>

int main()
{
    std::string s1 = "The      string    with many       spaces!";
    std::cout << "before: " << s1 << '\n';

    std::string s2;
    std::unique_copy(s1.begin(), s1.end(), std::back_inserter(s2),
                     [](char c1, char c2){ return c1 == ' ' && c2 == ' '; });

    std::cout << "after:  " << s2 << '\n';
}

Output:

before: The      string    with many       spaces!
after:  The string with many spaces!

Komplexität

linear im Abstand first und last

Original:

linear in the distance between first and last

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Siehe auch


	findet zwei identischen (oder eine andere Beziehung) Elemente einander benachbart Original: finds two identical (or some other relationship) items adjacent to each other The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template) [edit]

	removes consecutive duplicate elements in a range (Funktions-Template) [edit]