std::ranges:: minmax_element, std::ranges:: minmax_element_result

From cppreference.net

헤더에 정의됨 `<algorithm>`
호출 서명
template < std:: forward_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , std:: indirect_strict_weak_order < std :: projected < I, Proj >> Comp = ranges:: less > constexpr minmax_element_result < I > minmax_element ( I first, S last, Comp comp = { } , Proj proj = { } ) ;	(1)	(C++20부터)
template < ranges:: forward_range R, class Proj = std:: identity , std:: indirect_strict_weak_order < std :: projected < ranges:: iterator_t < R > , Proj >> Comp = ranges:: less > constexpr minmax_element_result < ranges:: borrowed_iterator_t < R >> minmax_element ( R && r, Comp comp = { } , Proj proj = { } ) ;	(2)	(C++20부터)
헬퍼 타입
template < class I > using minmax_element_result = ranges:: min_max_result < I > ;	(3)	(C++20부터)

1) 범위 내에서 가장 작은 요소와 가장 큰 요소를 찾습니다

first

last

2) (1) 와 동일하지만, r 을 소스 범위로 사용하며, 마치 ranges:: begin ( r ) 을 first 로, ranges:: end ( r ) 를 last 로 사용하는 것과 같습니다.

이 페이지에서 설명하는 함수형 개체들은 algorithm function objects (일반적으로 niebloids 로 알려진)입니다. 즉:

명시적 템플릿 인수 목록은 이들 중 어느 것을 호출할 때도 지정할 수 없습니다.
이들 중 어느 것도 인수 의존 이름 검색 에 보이지 않습니다.
이들 중 어느 것이 함수 호출 연산자의 왼쪽 이름으로 일반 비한정 이름 검색 에 의해 발견될 때, 인수 의존 이름 검색 이 억제됩니다.

첫 번째 요소로 가장 작은 요소에 대한 반복자, 두 번째 요소로 가장 큰 요소에 대한 반복자로 구성된 객체를 반환합니다. 범위가 비어 있는 경우 { first, first } 를 반환합니다. 가장 작은 요소와 동등한 여러 요소가 있는 경우, 첫 번째 해당 요소에 대한 반복자가 반환됩니다. 가장 큰 요소와 동등한 여러 요소가 있는 경우, 마지막 해당 요소에 대한 반복자가 반환됩니다.

복잡도

최대 std:: max ( std:: floor ( 1.5 * ( N − 1 ) ) , 0.0 ) 번의 비교 연산과 그 두 배 횟수의 프로젝션 연산이 적용됩니다. 여기서 N = ranges:: distance ( first, last ) 입니다.

가능한 구현

struct minmax_element_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_element_result<I>
        operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        auto min = first, max = first;
        if (first == last || ++first == last)
            return {min, max};
        if (std::invoke(comp, std::invoke(proj, *first),
                              std::invoke(proj, *min)))
            min = first;
        else
            max = first;
        while (++first != last)
        {
            auto i = first;
            if (++first == last)
            {
                if (std::invoke(comp, std::invoke(proj, *i),
                                      std::invoke(proj, *min)))
                    min = i;
                else if (!(std::invoke(comp, std::invoke(proj, *i),
                                             std::invoke(proj, *max))))
                    max = i;
                break;
            }
            else
            {
                if (std::invoke(comp, std::invoke(proj, *first),
                                      std::invoke(proj, *i)))
                {
                  if (std::invoke(comp, std::invoke(proj, *first),
                                        std::invoke(proj, *min)))
                      min = first;
                  if (!(std::invoke(comp, std::invoke(proj, *i),
                                          std::invoke(proj, *max))))
                      max = i;
                }
                else
                {
                    if (std::invoke(comp, std::invoke(proj, *i),
                                          std::invoke(proj, *min)))
                        min = i;
                    if (!(std::invoke(comp, std::invoke(proj, *first),
                                            std::invoke(proj, *max))))
                        max = first;
                }
            }
        }
        return {min, max};
    }
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_element_result<ranges::borrowed_iterator_t<R>>
        operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
    }
};
inline constexpr minmax_element_fn minmax_element;

예제

이 코드 실행

#include <algorithm>
#include <iostream>
#include <iterator>
namespace ranges = std::ranges;
int main()
{
    const auto v = {3, 9, 1, 4, 1, 2, 5, 9};
    const auto [min, max] = ranges::minmax_element(v);
    std::cout
        << "min = " << *min << ", at [" << ranges::distance(v.begin(), min) << "]\n"
        << "max = " << *max << ", at [" << ranges::distance(v.begin(), max) << "]\n";
}

출력:

min = 1, at [2]
max = 9, at [7]

참고 항목

ranges::min_element (C++20)	범위에서 가장 작은 요소를 반환합니다 (알고리즘 함수 객체)
ranges::max_element (C++20)	범위에서 가장 큰 요소를 반환합니다 (알고리즘 함수 객체)
ranges::minmax (C++20)	두 요소 중 더 작은 값과 더 큰 값을 반환합니다 (알고리즘 함수 객체)
minmax_element (C++11)	범위에서 가장 작은 요소와 가장 큰 요소를 반환합니다 (함수 템플릿)

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

first, last	-	검사할 요소들의 범위 를 정의하는 반복자-감시자 쌍
r	-	검사할 `range`
comp	-	투영된 요소들에 적용할 비교 연산
proj	-	요소들에 적용할 투영 연산

cppreference.net

Namespaces

Variants

std::ranges:: minmax_element, std::ranges:: minmax_element_result

목차

매개변수

반환값

복잡도

가능한 구현

예제

참고 항목