Namespaces
Variants

std:: is_heap

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(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
is_heap
(C++11)
(C++11)
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class RandomIt >
bool is_heap ( RandomIt first, RandomIt last ) ;
(1) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class RandomIt >

bool is_heap ( ExecutionPolicy && policy,

RandomIt first, RandomIt last ) ;
(2) (depuis C++17)
template < class RandomIt, class Compare >
bool is_heap ( RandomIt first, RandomIt last, Compare comp ) ;
(3) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class RandomIt, class Compare >

bool is_heap ( ExecutionPolicy && policy,

RandomIt first, RandomIt last, Compare comp ) ;
(4) (depuis C++17)

Vérifie si [ first , last ) est un heap .

1) La propriété de tas à vérifier est par rapport à operator < (jusqu'en C++20) std:: less { } (depuis C++20) .
3) La propriété de tas à vérifier est par rapport à comp .
2,4) Identique à (1,3) , mais exécuté selon la policy .
Ces surcharges participent à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> est true .

(jusqu'à C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> est true .

(depuis C++20)

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage d'éléments à vérifier
policy - la politique d'exécution à utiliser
comp - objet fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui retourne true si le premier argument est inférieur au second.

La signature de la fonction de comparaison doit être équivalente à ce qui suit :

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

Bien que la signature n'ait pas besoin d'avoir const & , la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1 & n'est pas autorisé , pas plus que Type1 sauf si pour Type1 un déplacement est équivalent à une copie (depuis C++11) ).
Les types Type1 et Type2 doivent être tels qu'un objet de type RandomIt puisse être déréférencé puis implicitement converti vers les deux.

Exigences de type
-
RandomIt doit satisfaire aux exigences de LegacyRandomAccessIterator .
-
Compare doit satisfaire aux exigences de Compare .

Valeur de retour

true si la plage est un tas par rapport au comparateur correspondant, false sinon.

Complexité

Étant donné N comme std:: distance ( first, last ) :

1,2) O(N) comparaisons en utilisant operator < (jusqu'en C++20) std:: less { } (depuis C++20) .
3,4) O(N) applications de la fonction de comparaison comp .

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

Exemple

Exécuter ce code 
#include <algorithm>
#include <bit>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9};
    std::cout << "initialement, v:\n";
    for (const auto& i : v)
        std::cout << i << ' ';
    std::cout << '\n';
    if (!std::is_heap(v.begin(), v.end()))
    {
        std::cout << "création du tas...\n";
        std::make_heap(v.begin(), v.end());
    }
    std::cout << "après make_heap, v:\n";
    for (auto t{1U}; const auto& i : v)
        std::cout << i << (std::has_single_bit(++t) ? " | " : " ");
    std::cout << '\n';
}

Sortie : 

initialement, v:
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
création du tas...
après make_heap, v:
9 | 6 9 | 5 5 9 7 | 1 1 3 5 8 3 4 2 |

Voir aussi

(C++11)
trouve le plus grand sous-intervalle qui est un tas max
(modèle de fonction)
crée un tas max à partir d'une plage d'éléments
(modèle de fonction)
ajoute un élément à un tas max
(modèle de fonction)
supprime le plus grand élément d'un tas max
(modèle de fonction)
transforme un tas max en une plage d'éléments triés par ordre croissant
(modèle de fonction)
(C++20)
vérifie si la plage donnée est un tas max
(objet fonction algorithme)