Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::is_heap — vérifier la propriété de tas

std::is_heap vérifie qu’une plage respecte la propriété de tas sans modifier ses éléments. Par défaut, la fonction reconnaît un tas-max ; un comparateur personnalisé permet de vérifier un autre ordre, comme celui d’un tas-min.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <algorithm>
std::is_heap(first, last)
std::is_heap(first, last, comp)

std::is_heap, déclarée dans <algorithm>, renvoie bool après avoir vérifié la plage [first, last). Elle exige une plage valide et des itérateurs à accès aléatoire, comme ceux de std::array ou de std::vector. Elle ne construit ni ne répare un tas et ne réorganise pas les éléments. Une plage vide ou ne contenant qu’un élément satisfait la condition.

Pour chaque indice d’enfant i > 0, l’indice du parent est (i - 1) / 2, avec une division entière. La condition de tas exige que comp(parent, child) soit false. La comparaison par défaut std::less{} donne un tas-max pour les nombres : un parent n’est pas plus petit que son enfant. std::greater<int>{} vérifie un tas-min. Le comparateur doit définir un ordre faible strict ; utilisez le même ordre que lors de la construction du tas.

Un tas n’a pas besoin d’être trié : aucun ordre relatif n’est imposé entre frères. La vérification a une complexité linéaire par rapport au nombre d’éléments. Le résultat équivaut à tester std::is_heap_until(first, last, comp) == last ; cette autre fonction aide à localiser la première violation. Utilisez std::make_heap pour construire un tas.

L’exemple reconnaît d’abord un tas-max, le rejette ensuite comme tas-min, puis détecte une violation par rapport au parent de valeur 5 après l’affectation values[3] = 10. Les surcharges présentées sans politique d’exécution sont constexpr ; il existe également des surcharges avec politique d’exécution. Cette entrée porte sur C++23. La source est un projet de norme en évolution, et l’option du compilateur dans le dépôt ne garantit pas l’environnement d’exécution de production.

Exemples

#include <algorithm>
#include <array>
#include <functional>
#include <iostream>

int main() {
    std::array<int, 5> values{9, 5, 8, 1, 3};
    std::cout << std::boolalpha;
    std::cout << std::is_heap(values.begin(), values.end()) << '\n';
    std::cout << std::is_heap(values.begin(), values.end(),
                              std::greater<int>{}) << '\n';
    values[3] = 10;
    std::cout << std::is_heap(values.begin(), values.end()) << '\n';
}

Résultat

true
false
false

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources