Namespace
Varianti

cpp/algorithm/unique copy: differenze tra le versioni

Da cppreference.com.
< cpp‎ | algorithm
m (una revisione importata: Translate from the English version)
m (Use {{lc}}. Update links. Various fixes.)
 
(Una revisione intermedia di un utente non mostrata)
Riga 2: Riga 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|Copia gli elementi dal {{tt|[first, last)}} gamma, ad un altro inizio intervallo su {{tt|d_first}} in modo tale che non vi siano elementi consecutivi uguali. Solo il primo elemento di ciascun gruppo di elementi uguali viene copiato. La prima versione utilizza {{tt|operator{{==}}}} di confrontare gli elementi, la seconda versione utilizza il predicato binario dato {{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|Copia gli elementi dal {{tt|[first, last)}} gamma, ad un altro inizio intervallo su {{tt|d_first}} in modo tale che non vi siano elementi consecutivi uguali. Solo il primo elemento di ciascun gruppo di elementi uguali viene copiato. La prima versione utilizza {{tt|operator{{==}}}} di confrontare gli elementi, la seconda versione utilizza il predicato binario dato {{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}}.}}
  
 
===Parametri===
 
===Parametri===
−
{{param list begin}}
+
{{begin}}
−
{{param list item | first, last |{{tr| l'intervallo di elementi di processo| the range of elements to process}}}}
+
{{| first, last |{{tr| l'intervallo di elementi di processo| the range of elements to process}}}}
−
{{param list item | d_first |{{tr| l'inizio del campo di destinazione| the beginning of the destination range}}}}
+
{{| d_first |{{tr| l'inizio del campo di destinazione| 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}}
  
 
===Valore di ritorno===
 
===Valore di ritorno===
Riga 101: Riga 101:
  
 
===Vedi anche===
 
===Vedi anche===
−
{{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}}
  
 +
 +
 +
 +
 
[[ja:cpp/algorithm/unique copy]]
 
[[ja:cpp/algorithm/unique copy]]
 +
 
[[ru:cpp/algorithm/unique copy]]
 
[[ru:cpp/algorithm/unique copy]]
 +

Versione attuale delle 12:25, 2 lug 2013

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

 
C++
 
Algoritmo libreria
Funzioni
Original:
Functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Non modifica le operazioni di sequenza
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.
Modifica delle operazioni di sequenza
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.
Partizionamento operazioni
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.
Ordinamento delle operazioni (su intervalli ordinati)
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.
Binarie (le operazioni di ricerca sui campi ordinati)
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.
Impostare le operazioni (su intervalli ordinati)
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 operazioni
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.
Minimo / massimo le operazioni
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.
Operazioni numeriche
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.
Libreria C
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.
 
Elemento definito nell'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)
Copia gli elementi dal [first, last) gamma, ad un altro inizio intervallo su d_first in modo tale che non vi siano elementi consecutivi uguali. Solo il primo elemento di ciascun gruppo di elementi uguali viene copiato. La prima versione utilizza operator== di confrontare gli elementi, la seconda versione utilizza il predicato binario dato 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.

Indice

[modifica] Parametri

first, last -
l'intervallo di elementi di processo
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 -
l'inizio del campo di destinazione
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

[modifica] Valore di ritorno

Uscita iteratore all'elemento passato l'ultimo elemento scritto
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.

[modifica] Possibile implementazione

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;
}

[modifica] Esempio

Le finiture del programma seguenti tutti gli spazi multipli consecutivi in ​​una stringa const e stampa il risultato
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!

[modifica] Complessità

lineare la distanza tra first e 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.

[modifica] Vedi anche
trova due identici (o qualche altra relazione) elementi adiacenti l'uno all'altro
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.

(funzione di modello) [modifica]
removes consecutive duplicate elements in a range
(funzione di modello) [modifica]
Estratto da "https://it.cppreference.com/mwiki/index.php?title=cpp/algorithm/unique_copy&oldid=25000"