std::set_union — cppreference.com

De cppreference.com

Déclaré dans l'en-tête `<algorithm>`
`template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_union( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first );`	(1)
`template< class InputIt1, class InputIt2, class OutputIt, class Compare > OutputIt set_union( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Compare comp );`	(2)

Construit une gamme débutant triés à d_first composé de tous les éléments présents dans l'un ou les deux gammes triés [first1, last1) et [first2, last2). La première version prévoit à la fois d'entrée se situe à trier avec operator<, la deuxième version s'attend à ce qu'ils soient triés à la comp fonction de comparaison donnée. Si un élément est trouvé m fois en [first1, last1) et n fois dans [first2, last2), alors tous les éléments m seront copiées à partir [first1, last1) à d_first, maintien de l'ordre, et alors exactement éléments std::max(n-m, 0) seront copiées à partir [first2, last2) à d_first, aussi maintenir l'ordre. La gamme résultante ne peut pas faire double emploi avec l'une des plages d'entrée .

Original:

Constructs a sorted range beginning at d_first consisting of all elements present in one or both sorted ranges [first1, last1) and [first2, last2). The first version expects both input ranges to be sorted with operator<, the second version expects them to be sorted with the given comparison function comp. If some element is found m times in [first1, last1) and n times in [first2, last2), then all m elements will be copied from [first1, last1) to d_first, preserving order, and then exactly std::max(n-m, 0) elements will be copied from [first2, last2) to d_first, also preserving order. The resulting range cannot overlap with either of the input ranges.

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

Paramètres

first1, last1	-	la première entrée triés gamme Original: the first input sorted range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
first2, last2	-	la deuxième entrée triés gamme Original: the second input sorted range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
comp	-	comparison function which returns `true` if the first argument is less than the second. The signature of the comparison function should be equivalent to the following: `bool cmp(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 objects of types `InputIt1` and `InputIt2` can be dereferenced and then implicitly converted to `Type1` and `Type2` respectively.
Type requirements
-`InputIt1` must meet the requirements of `InputIterator`.
-`InputIt2` must meet the requirements of `InputIterator`.
-`OutputIt` must meet the requirements of `OutputIterator`.

Retourne la valeur

Iterator-delà de la fin de la gamme construit .

Original:

Iterator past the end of the constructed range.

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

Complexité

A comparaisons plupart 2·(N₁+N₂-1), où N₁ = std::distance(first1, last1) et N₂ = std::distance(first2, last2) .

Original:

At most 2·(N₁+N₂-1) comparisons, where N₁ = std::distance(first1, last1) and N₂ = std::distance(first2, last2).

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

Mise en œuvre possible

First version
template<class InputIt1, class InputIt2, class OutputIt> OutputIt set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first) { for (; first1 != last1; ++d_first) { if (first2 == last2) return std::copy(first1, last1, d_first); if (first2 < first1) { d_first = first2++; } else { d_first = first1; if (!(first1 < first2)) ++first2; ++first1; } } return std::copy(first2, last2, d_first); }
Second version
template<class InputIt1, class InputIt2, class OutputIt, class Compare> OutputIt set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Compare comp) { for (; first1 != last1; ++d_first) { if (first2 == last2) return std::copy(first1, last1, d_first); if (comp(first2, first1)) { d_first = first2++; } else { d_first = first1; if (!comp(first1, first2)) ++first2; ++first1; } } return std::copy(first2, last2, d_first); }

First version

template<class InputIt1, class InputIt2, class OutputIt>
OutputIt set_union(InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, InputIt2 last2,
                   OutputIt d_first)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2)
            return std::copy(first1, last1, d_first);
        if (*first2 < *first1) {
            *d_first = *first2++;
        } else {
            *d_first = *first1;
            if (!(*first1 < *first2))
                ++first2;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}

Second version

template<class InputIt1, class InputIt2,
         class OutputIt, class Compare>
OutputIt set_union(InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, InputIt2 last2,
                   OutputIt d_first, Compare comp)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2)
            return std::copy(first1, last1, d_first);
        if (comp(*first2, *first1)) {
            *d_first = *first2++;
        } else {
            *d_first = *first1;
            if (!comp(*first1, *first2))
                ++first2;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}

Exemple

Voir aussi


includes	retourne vrai si un ensemble est un sous-ensemble de l'autre Original: returns true if one set is a subset of another The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]

set_difference	calcule la différence entre deux ensembles Original: computes the difference between two sets The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]

set_intersection	calcule l'intersection des deux ensembles Original: computes the intersection of two sets The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]

set_symmetric_difference	calcule la différence symétrique entre deux ensembles Original: computes the symmetric difference between two sets The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]