std::ranges:: minmax, std::ranges:: minmax_result

From cppreference.net

Défini dans l'en-tête `<algorithm>`
Signature d'appel
template < class T, class Proj = std:: identity , std:: indirect_strict_weak_order < std :: projected < const T * , Proj >> Comp = ranges:: less > constexpr ranges :: minmax_result < const T & > minmax ( const T & a, const T & b, Comp comp = { } , Proj proj = { } ) ;	(1)	(depuis C++20)
template < std:: copyable T, class Proj = std:: identity , std:: indirect_strict_weak_order < std :: projected < const T * , Proj >> Comp = ranges:: less > constexpr ranges :: minmax_result < T > minmax ( std:: initializer_list < T > r, Comp comp = { } , Proj proj = { } ) ;	(2)	(depuis C++20)
template < ranges:: input_range R, class Proj = std:: identity , std:: indirect_strict_weak_order < std :: projected < ranges:: iterator_t < R > , Proj >> Comp = ranges:: less > requires std:: indirectly_copyable_storable < ranges:: iterator_t < R > , ranges:: range_value_t < R > * > constexpr ranges :: minmax_result < ranges:: range_value_t < R >> minmax ( R && r, Comp comp = { } , Proj proj = { } ) ;	(3)	(depuis C++20)
Types auxiliaires
template < class T > using minmax_result = ranges:: min_max_result < T > ;	(4)	(depuis C++20)

Retourne les plus petites et les plus grandes valeurs projetées données.

1) Retourne des références vers le plus petit et le plus grand de a et b .

2) Retourne les valeurs la plus petite et la plus grande dans la liste d'initialisation r .

3) Retourne les valeurs minimale et maximale dans la plage r .

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés niebloids ), c'est-à-dire :

Les listes d'arguments de template explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Table des matières

Paramètres

a, b	-	les valeurs à comparer
r	-	une plage non vide de valeurs à comparer
comp	-	comparaison à appliquer aux éléments projetés
proj	-	projection à appliquer aux éléments

Valeur de retour

1) { b, a } si, selon leurs valeurs projetées respectives, b est plus petit que a ; sinon cela retourne { a, b } .

2,3) { s, l } , où

sont respectivement les valeurs minimale et maximale dans r , selon leur valeur projetée. Si plusieurs valeurs sont équivalentes au minimum et au maximum, retourne la valeur minimale la plus à gauche, et la valeur maximale la plus à droite. Si la plage est vide (tel que déterminé par ranges:: distance ( r ) ), le comportement est indéfini.

Complexité

1) Exactement une comparaison et deux applications de la projection.

2,3) Au maximum 3 / 2 * ranges:: distance ( r ) comparaisons et deux fois plus d'applications de la projection.

Implémentation possible

struct minmax_fn
{
    template<class T, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<const T*, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_result<const T&>
         operator()(const T& a, const T& b, Comp comp = {}, Proj proj = {}) const
    {
        if (std::invoke(comp, std::invoke(proj, b), std::invoke(proj, a)))
            return {b, a};
        return {a, b};
    }
    template<std::copyable T, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<const T*, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_result<T>
        operator()(std::initializer_list<T> r, Comp comp = {}, Proj proj = {}) const
    {
        auto result = ranges::minmax_element(r, std::ref(comp), std::ref(proj));
        return {*result.min, *result.max};
    }
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    requires std::indirectly_copyable_storable<ranges::iterator_t<R>,
                                               ranges::range_value_t<R>*>
    constexpr ranges::minmax_result<ranges::range_value_t<R>>
        operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        auto result = ranges::minmax_element(r, std::ref(comp), std::ref(proj));
        return {std::move(*result.min), std::move(*result.max)};
    }
};
inline constexpr minmax_fn minmax;

Notes

Pour la surcharge (1) , si l'un des paramètres est un temporaire, la référence retournée devient une référence pendante à la fin de l'expression complète qui contient l'appel à minmax :

int n = 1;
auto p = std::ranges::minmax(n, n + 1);
int m = p.min; // correct
int x = p.max; // comportement indéfini
// Notez que les liaisons structurées présentent le même problème
auto [mm, xx] = std::ranges::minmax(n, n + 1);
xx; // comportement indéfini

Exemple

Exécuter ce code

#include <algorithm>
#include <array>
#include <iostream>
#include <random>
int main()
{
    namespace ranges = std::ranges;
    constexpr std::array v{3, 1, 4, 1, 5, 9, 2, 6, 5};
    std::random_device rd;
    std::mt19937_64 generator(rd());
    std::uniform_int_distribution<> distribution(0, ranges::distance(v)); // [0..9]
    // auto bounds = ranges::minmax(distribution(generator), distribution(generator));
    // UB: dangling references: bounds.min and bounds.max have the type `const int&`.
    const int x1 = distribution(generator);
    const int x2 = distribution(generator);
    auto bounds = ranges::minmax(x1, x2); // OK: got references to lvalues x1 and x2
    std::cout << "v[" << bounds.min << ":" << bounds.max << "]: ";
    for (int i = bounds.min; i < bounds.max; ++i)
        std::cout << v[i] << ' ';
    std::cout << '\n';
    auto [min, max] = ranges::minmax(v);
    std::cout << "smallest: " << min << ", " << "largest: " << max << '\n';
}

Sortie possible :

v[3:9]: 1 5 9 2 6 5 
smallest: 1, largest: 9

Voir aussi

ranges::min (C++20)	renvoie la plus petite des valeurs données (objet fonction algorithme)
ranges::max (C++20)	renvoie la plus grande des valeurs données (objet fonction algorithme)
ranges::minmax_element (C++20)	renvoie les éléments les plus petits et les plus grands dans une plage (objet fonction algorithme)
ranges::clamp (C++20)	limite une valeur entre une paire de valeurs limites (objet fonction algorithme)
minmax (C++11)	renvoie le plus petit et le plus grand de deux éléments (modèle de fonction)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants