Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::minmax

      From cppreference.com
      <cpp‎ |algorithm
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      minmax
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      Operations on uninitialized memory
       
      Defined in header<algorithm>
      template<class T>
      std::pair<const T&,const T&> minmax(const T& a,const T& b);
      (1)(since C++11)
      (constexpr since C++14)
      template<class T,class Compare>

      std::pair<const T&,const T&> minmax(const T& a,const T& b,

                                            Compare comp);
      (2)(since C++11)
      (constexpr since C++14)
      template<class T>
      std::pair<T, T> minmax(std::initializer_list<T> ilist);
      (3)(since C++11)
      (constexpr since C++14)
      template<class T,class Compare>

      std::pair<T, T> minmax(std::initializer_list<T> ilist,

                              Compare comp);
      (4)(since C++11)
      (constexpr since C++14)

      Returns the lowest and the greatest of the given values.

      1,2) Returns references to the smaller and the greater ofa andb.
      1) Usesoperator< to compare the values.
      IfT is notLessThanComparable, the behavior is undefined.
      2) Use the comparison functioncomp to compare the values.
      3,4) Returns the smallest and the greatest of the values in initializer listilist.
      Ifilist.size() is zero, orT is notCopyConstructible, the behavior is undefined.
      3) Usesoperator< to compare the values.
      IfT is notLessThanComparable, the behavior is undefined.
      4) Use the comparison functioncomp to compare the values.

      Contents

      [edit]Parameters

      a, b - the values to compare
      ilist - initializer list with the values to compare
      comp - comparison function object (i.e. an object that satisfies the requirements ofCompare) which returnstrue if the first argument isless than the second.

      The signature of the comparison function should be equivalent to the following:

      bool cmp(const Type1& a,const Type2& b);

      While the signature does not need to haveconst&, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const)Type1 andType2 regardless ofvalue category (thus,Type1& is not allowed, nor isType1 unless forType1 a move is equivalent to a copy(since C++11)).
      The typesType1 andType2 must be such that an object of typeT can be implicitly converted to both of them.

      [edit]Return value

      1,2) Returns the result ofstd::pair<const T&,const T&>(a, b) ifa< b or ifa is equivalent tob. Returns the result ofstd::pair<const T&,const T&>(b, a) ifb< a.
      3,4) A pair with the smallest value inilist as the first element and the greatest as the second. If several elements are equivalent to the smallest, the leftmost such element is returned. If several elements are equivalent to the largest, the rightmost such element is returned.

      [edit]Complexity

      1) Exactly one comparison usingoperator<.
      2) Exactly one application of the comparison functioncomp.
      3,4) Given\(\scriptsize N\)N asilist.size():
      3) At most\(\scriptsize \frac{3N}{2}\)
      3N
      2
      comparisons usingoperator<.
      4) At most\(\scriptsize \frac{3N}{2}\)
      3N
      2
      applications of the comparison functioncomp.

      [edit]Possible implementation

      minmax (1)
      template<class T>constexprstd::pair<const T&,const T&> minmax(const T& a,const T& b){return(b< a)?std::pair<const T&,const T&>(b, a):std::pair<const T&,const T&>(a, b);}
      minmax (2)
      template<class T,class Compare>constexprstd::pair<const T&,const T&> minmax(const T& a,const T& b, Compare comp){return comp(b, a)?std::pair<const T&,const T&>(b, a):std::pair<const T&,const T&>(a, b);}
      minmax (3)
      template<class T>constexprstd::pair<T, T> minmax(std::initializer_list<T> ilist){auto p=std::minmax_element(ilist.begin(), ilist.end());returnstd::pair(*p.first,*p.second);}
      minmax (4)
      template<class T,class Compare>constexprstd::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp){auto p=std::minmax_element(ilist.begin(), ilist.end(), comp);returnstd::pair(*p.first,*p.second);}

      [edit]Notes

      For overloads(1,2), if one of the parameters is a temporary, the reference returned becomes a dangling reference at the end of the full expression that contains the call tominmax:

      int n=1;auto p= std::minmax(n, n+1);int m= p.first;// okint x= p.second;// undefined behavior // Note that structured bindings have the same issueauto[mm, xx]= std::minmax(n, n+1);xx;// undefined behavior

      [edit]Example

      Run this code
      #include <algorithm>#include <cstdlib>#include <ctime>#include <iostream>#include <vector> int main(){std::vector<int> v{3,1,4,1,5,9,2,6};std::srand(std::time(0));std::pair<int,int> bounds= std::minmax(std::rand()% v.size(),std::rand()% v.size()); std::cout<<"v["<< bounds.first<<","<< bounds.second<<"]: ";for(int i= bounds.first; i< bounds.second;++i)std::cout<< v[i]<<' ';std::cout<<'\n';}

      Possible output:

      v[2,7]: 4 1 5 9 2

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2239C++11T was required to beLessThanComparable for overloads(2,4)not required

      [edit]See also

      returns the smaller of the given values
      (function template)[edit]
      returns the greater of the given values
      (function template)[edit]
      returns the smallest and the largest elements in a range
      (function template)[edit]
      returns the smaller and larger of two elements
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/minmax&oldid=178177"

      [8]ページ先頭

      ©2009-2025 Movatter.jp