std:: vector<bool>

std :: vector < bool > est une spécialisation potentiellement efficace en termes d'espace de std::vector pour le type bool .

La manière dont std :: vector < bool > est rendue efficace en termes d'espace (ainsi que le fait qu'elle soit optimisée ou non) est définie par l'implémentation. Une optimisation potentielle consiste à regrouper les éléments du vecteur de telle sorte que chaque élément occupe un seul bit au lieu de sizeof ( bool ) octets.

std :: vector < bool > se comporte de manière similaire à std::vector , mais pour être efficace en termes d'espace, il :

• Ne stocke pas nécessairement ses éléments sous forme de tableau contigu.
• Expose la classe std :: vector < bool > :: reference comme méthode d'accès aux bits individuels. En particulier, les objets de cette classe sont retournés par operator[] par valeur.
• N'utilise pas std :: allocator_traits :: construct pour construire les valeurs de bits.
• Ne garantit pas que différents éléments dans le même conteneur puissent être modifiés simultanément par différents threads.

Types membres

Fonctions membres

Fonctions non membres

Classes d'assistance

Guides de déduction (C++17)

Notes

Si la taille du bitset est connue à la compilation, std::bitset peut être utilisé, qui offre un ensemble plus riche de fonctions membres. De plus, boost::dynamic_bitset existe comme alternative à std :: vector < bool > .

Puisque sa représentation peut être optimisée, std :: vector < bool > ne satisfait pas nécessairement toutes les exigences Container ou SequenceContainer . Par exemple, parce que std :: vector < bool > :: iterator est défini par l'implémentation, il peut ne pas satisfaire l'exigence LegacyForwardIterator . L'utilisation d'algorithmes tels que std::search qui nécessitent des LegacyForwardIterator s peut entraîner des erreurs à la compilation ou à l'exécution .

La version Boost.Container de vector ne spécialise pas pour bool .

Exemple

#include <cassert>
#include <initializer_list>
#include <iostream>
#include <vector>
void println(auto rem, const std::vector<bool>& vb)
{
    std::cout << rem << " = [";
    for (std::size_t t{}; t != vb.size(); ++t)
        std::cout << (t ? ", " : "") << vb[t];
    std::cout << "]\n";
}
int main()
{
    std::vector<bool> v1; // crée un vecteur vide de valeurs booléennes
    println("1) v1", v1);
    std::vector<bool> v2{0, 1, 1, 0, 1}; // crée un vecteur rempli
    println("2) v2", v2);
    v1 = v2; // copie v2 vers v1
    println("3) v1", v1);
    assert(v1.size() == v2.size()); // vérifie que les tailles de v1 et v2 sont égales
    assert(v1.front() == false); // accède au premier élément, équivalent à :
    assert(v1[0] == false);
    assert(v1.back() == true); // accède au dernier élément, équivalent à :
    assert(v1[v1.size() - 1] == true);
    v1 = {true, true, false, false}; // assigne une liste d'initialisation
    println("4) v1", v1);
    v1.push_back(true); // ajoute un élément à la fin
    println("5) v1", v1);
    v1.pop_back(); // supprime un élément de la fin
    println("6) v1", v1);
    v1.flip(); // inverse tous les éléments
    println("7) v1", v1);
    v1.resize(8, true); // redimensionne v1 ; les nouveaux éléments sont définis sur « true »
    println("8) v1", v1);
    v1.clear(); // efface v1
    assert(v1.empty()); // vérifie que v1 est vide
}

1) v1 = []
2) v2 = [0, 1, 1, 0, 1]
3) v1 = [0, 1, 1, 0, 1]
4) v1 = [1, 1, 0, 0]
5) v1 = [1, 1, 0, 0, 1]
6) v1 = [1, 1, 0, 0]
7) v1 = [0, 0, 1, 1]
8) v1 = [0, 0, 1, 1, 1, 1, 1, 1]

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.