Namensräume
Varianten

    cpp/algorithm/unique copy: Unterschied zwischen den Versionen

    Aus cppreference.com
    ← Zum vorherigen Versionsunterschied
    P12bot (Diskussion | Beiträge)
    Bots
    111.718 Bearbeitungen
    K r2.7.3) (Bot: Ergänze: en, es, fr, it, pt, zh
    P12bot (Diskussion | Beiträge)
    Bots
    111.718 Bearbeitungen
    K Use {{lc}}. Update links. Various fixes.
     
    Zeile 2: Zeile 2:
    {{cpp/title|unique_copy}}
    {{cpp/title|unique_copy}}
    {{cpp/algorithm/navbar}}
    {{cpp/algorithm/navbar}}
    {{ddcl list begin}}
    {{begin}}
    {{ddcl list header | algorithm}}
    {{header | algorithm}}
    {{ddcl list item | num=1 |
    {{| num=1 |
    template< class InputIt, class OutputIt >
    template< class InputIt, class OutputIt >
    ForwardIt unique_copy( InputIt first, InputIt last,
    ForwardIt unique_copy( InputIt first, InputIt last,
                           OutputIt d_first );
                           OutputIt d_first );
    }}
    }}
    {{ddcl list item | num=2 |
    {{| num=2 |
    template< class InputIt, class OutputIt, class BinaryPredicate >
    template< class InputIt, class OutputIt, class BinaryPredicate >
    ForwardIt unique_copy( InputIt first, InputIt last,
    ForwardIt unique_copy( InputIt first, InputIt last,
                           OutputIt d_first, BinaryPredicate p );
                           OutputIt d_first, BinaryPredicate p );
    }}
    }}
    {{ddcl list end}}
    {{end}}


    {{tr|Kopiert die Elemente aus dem Bereich {{tt|[first, last)}}, in einen anderen Bereich beginnend bei {{tt|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 {{tt|operator{{==}}}} um die Elemente zu vergleichen, verwendet die zweite Version des gegebenen binären Prädikats {{tt|p}} .|Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|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 {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.}}
    {{tr|Kopiert die Elemente aus dem Bereich {{tt|[first, last)}}, in einen anderen Bereich beginnend bei {{tt|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 {{tt|operator{{==}}}} um die Elemente zu vergleichen, verwendet die zweite Version des gegebenen binären Prädikats {{tt|p}} .|Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|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 {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.}}


    ===Parameter===
    ===Parameter===
    {{param list begin}}
    {{begin}}
    {{param list item | first, last |{{tr| der Bereich der Elemente zu verarbeiten| the range of elements to process}}}}
    {{| first, last |{{tr| der Bereich der Elemente zu verarbeiten| the range of elements to process}}}}
    {{param list item | d_first |{{tr| der Beginn des Zielbereichs| the beginning of the destination range}}}}
    {{| d_first |{{tr| der Beginn des Zielbereichs| the beginning of the destination range}}}}
    {{param list pred2 eq | p | p1=ForwardIt}}
    {{pred2 eq | p | p1=ForwardIt}}
    {{param list hreq}}
    {{hreq}}
    {{param list req concept | InputIt | InputIterator}}
    {{req concept | InputIt | InputIterator}}
    {{param list req concept | OutputIt | OutputIterator}}
    {{req concept | OutputIt | OutputIterator}}
    {{param list req concept deref | InputIt | CopyAssignable}}
    {{req concept deref | InputIt | CopyAssignable}}
    {{param list req concept deref | InputIt | CopyConstructible | notes=if neither {{c|InputIt}} nor {{c|OutputIt}} satisfies {{concept|ForwardIterator}}}}
    {{req concept deref | InputIt | CopyConstructible | notes=if neither {{c|InputIt}} nor {{c|OutputIt}} satisfies {{concept|ForwardIterator}}}}
    {{param list end}}
    {{end}}


    ===Rückgabewert===
    ===Rückgabewert===
    Zeile 101: Zeile 101:


    ===Siehe auch===
    ===Siehe auch===
    {{dcl list begin}}
    {{begin}}
    {{dcl list template | cpp/algorithm/dcl list adjacent_find}}
    {{| cpp/algorithm/adjacent_find}}
    {{dcl list template | cpp/algorithm/dcl list unique}}
    {{| cpp/algorithm/unique}}
    {{dcl list end}}
    {{end}}


    [[en:cpp/algorithm/unique copy]]
    [[en:cpp/algorithm/unique copy]]

    Aktuelle Version vom 2. Juli 2013, 02:43 Uhr

    This page has been machine-translated from the English version of the wiki using Google Translate.

    The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Algorithm Bibliothek
    Funktionen
    Original:
    Functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Nicht-modifizierende Sequenz Operationen
    Original:
    Non-modifying sequence operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Modifizierende Sequenz Operationen
    Original:
    Modifying sequence operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Partitionierungsoperationen
    Original:
    Partitioning operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Sortierung Operationen (auf sortierten Bereiche)
    Original:
    Sorting operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Binary Suchaktionen (auf sortierten Bereiche)
    Original:
    Binary search operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Set-Operationen (auf sortierten Bereiche)
    Original:
    Set operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Heap-Operationen
    Original:
    Heap operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Minimum / Maximum Operationen
    Original:
    Minimum/maximum operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Numerische Operationen
    Original:
    Numeric operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    C-Bibliothek
    Original:
    C library
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
     
    <tbody> </tbody>
    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;
}

    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]