La classe vector<bool>

La vector<bool> classe est une spécialisation partielle des vector éléments de type bool. Elle possède un allocateur pour le type sous-jacent utilisé par la spécialisation, qui permet une optimisation de l'espace en stockant une valeur bool par bit.

Syntaxe

template <class Allocator = allocator<bool>>
class vector<bool, Allocator>

Notes

Cette spécialisation de modèle de classe se comporte comme vector, à l’exception des différences expliquées dans cet article.

Les opérations qui gèrent le type bool correspondent aux valeurs du conteneur de stockage. allocator_traits::construct n’est pas utilisé pour construire ces valeurs.

Typedefs

Nom de type	Description
const_pointer	Typedef d'un const_iterator qui peut servir de pointeur constant à un élément booléen du vector<bool>.
const_reference	Typedef pour bool. Après l’initialisation, elle n’observe pas les mises à jour de la valeur d’origine.
pointer	Typedef d'un iterator qui peut servir de pointeur à un élément booléen du vector<bool>.

Fonctions Membre

Fonction membre	Description
flip	Inverse tous les bits du vector<bool>.
swap	Échange les éléments de deux vector<bool>.
operator[]	Retourne une référence simulée à l'élément vector<bool> à un emplacement spécifié.
at	Fonctions identiques vectorà la fonction ::at non spécifiée, sauf qu’elle utilise la classe vector<bool>::referenceproxy . Voir aussi operator[].
front	Fonctions identiques vectorà la fonction ::front non spécifiée, sauf qu’elle utilise la classe vector<bool>::referenceproxy . Voir aussi operator[].
back	Fonctionne de la même façon que la fonction ::back non spécifiée vector, sauf qu’elle utilise la classe vector<bool>::referenceproxy. Voir aussi operator[].

Classe proxy

Nom	Description
vector<bool>::reference Classe	Classe qui sert de proxy pour simuler le comportement bool&, et dont les objets peuvent fournir des références aux éléments (bits uniques) au sein d'un objet vector<bool>.

Spécifications

En-tête : <vector>

Espace de noms : std

vector<bool>::const_pointer

Type qui décrit un objet pouvant servir de pointeur de constante vers un élément booléen de la séquence contenue dans l'objet vector<bool>.

typedef const_iterator const_pointer;

vector<bool>::const_reference

Type qui décrit un objet pouvant servir de référence de constante à un élément booléen de la séquence contenue dans l'objet vector<bool>.

typedef bool const_reference;

Notes

Pour plus d’informations et des exemples de code, consultez vector<bool>::reference::operator=.

vector<bool>::flip

Inverse tous les bits d'un vector<bool>.

void flip();

Exemple

// vector_bool_flip.cpp
// compile with: /EHsc /W4
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    cout << boolalpha; // format output for subsequent code

    vector<bool> vb = { true, false, false, true, true };
    cout << "The vector is:" << endl << "    ";
    for (const auto& b : vb) {
        cout << b << " ";
    }
    cout << endl;

    vb.flip();

    cout << "The flipped vector is:" << endl << "    ";
    for (const auto& b : vb) {
        cout << b << " ";
    }
    cout << endl;
}

vector<bool>::operator[]

Retourne une référence simulée à l'élément vector<bool> à un emplacement spécifié.

vector<bool>::reference operator[](size_type Pos);

vector&<bool&>::const_reference operator[](size_type Pos) const;

Paramètres

Pos
Position de l'élément vector<bool>.

Valeur de retour

Objet vector<bool>::reference ou vector<bool>::const_reference qui contient la valeur de l’élément indexé.

Si la position spécifiée est supérieure ou égale à la taille du conteneur, le résultat est non défini.

Notes

Si vous compilez en ayant défini _ITERATOR_DEBUG_LEVEL, une erreur d'exécution se produira lorsque vous tenterez d'accéder à un élément situé en dehors des limites du vecteur. Pour plus d'informations, consultez Checked Iterators.

Exemple

Cet exemple de code montre l’utilisation correcte et vector<bool>::operator[] deux erreurs de codage courantes, qui sont commentées. Ces erreurs provoquent des erreurs, car l’adresse de l’objet vector<bool>::reference qui vector<bool>::operator[] retourne ne peut pas être prise.

// cl.exe /EHsc /nologo /W4 /MTd
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    cout << boolalpha;
    vector<bool> vb;

    vb.push_back(true);
    vb.push_back(false);

    //    bool* pb = &vb[1]; // conversion error - do not use
    //    bool& refb = vb[1];   // conversion error - do not use
    bool hold = vb[1];
    cout << "The second element of vb is " << vb[1] << endl;
    cout << "The held value from the second element of vb is " << hold << endl;

    // Note this doesn't modify hold.
    vb[1] = true;
    cout << "The second element of vb is " << vb[1] << endl;
    cout << "The held value from the second element of vb is " << hold << endl;
}

The second element of vb is false
The held value from the second element of vb is false
The second element of vb is true
The held value from the second element of vb is false

vector<bool>::pointer

Type qui décrit un objet pouvant servir de pointeur pour un élément booléen de la séquence contenue dans l'objet vector<bool>.

typedef iterator pointer;

La classe vector<bool>::reference

La vector<bool>::reference classe est une classe proxy fournie par la vector<bool> classe pour simuler bool&.

Notes

Une référence simulée est requise, car C++ n’autorise pas en mode natif les références directes aux bits. vector<bool> utilise un seul bit par élément, lequel peut être référencé à l'aide de cette classe proxy. Toutefois, la simulation de référence n’est pas terminée, car certaines affectations ne sont pas valides. Par exemple, étant donné que l’adresse de l’objet vector<bool>::reference ne peut pas être prise, le code suivant qui utilise vector<bool>::operator[] n’est pas correct :

vector<bool> vb;
//...
bool* pb = &vb[1]; // conversion error - do not use
bool& refb = vb[1];   // conversion error - do not use

vector<bool>::reference::flip

Inverse la valeur booléenne d’un élément référencé vector<bool> .

void flip();

Exemple

// vector_bool_ref_flip.cpp
// compile with: /EHsc /W4
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    cout << boolalpha;

    vector<bool> vb = { true, false, false, true, true };

    cout << "The vector is: " << endl << "    ";
    for (const auto& b : vb) {
        cout << b << " ";
    }
    cout << endl;

    vector<bool>::reference vbref = vb.front();
    vbref.flip();

    cout << "The vector with first element flipped is: " << endl << "    ";
    for (const auto& b : vb) {
        cout << b << " ";
    }
    cout << endl;
}

The vector is:
    true false false true true
The vector with first element flipped is:
    false false false true true

vector<bool>::reference::operator bool

Fournit une conversion implicite de vector<bool>::reference en bool.

operator bool() const;

Valeur de retour

Valeur booléenne de l’élément de l’objet vector<bool> .

Notes

L’objet vector<bool> ne peut pas être modifié par cet opérateur.

vector<bool>::reference::operator=

Assigne une valeur booléenne à un bit, ou la valeur détenue par un élément référencé à un bit.

reference& operator=(const reference& Right);
reference& operator=(bool Val);

Paramètres

Right
Référence d'élément dont la valeur doit être assignée au bit.

Val
Valeur booléenne à assigner au bit.

Exemple

// vector_bool_ref_op_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }

    cout << endl;
}

int main()
{
    cout << boolalpha;

    vector<bool> vb = { true, false, false, true, true };

    print("The vector is: ", vb);

    // Invoke vector<bool>::reference::operator=()
    vector<bool>::reference refelem1 = vb[0];
    vector<bool>::reference refelem2 = vb[1];
    vector<bool>::reference refelem3 = vb[2];

    bool b1 = refelem1;
    bool b2 = refelem2;
    bool b3 = refelem3;
    cout << "The original value of the 1st element stored in a bool: " << b1 << endl;
    cout << "The original value of the 2nd element stored in a bool: " << b2 << endl;
    cout << "The original value of the 3rd element stored in a bool: " << b3 << endl;
    cout << endl;

    refelem2 = refelem1;

    print("The vector after assigning refelem1 to refelem2 is now: ", vb);

    refelem3 = true;

    print("The vector after assigning false to refelem1 is now: ", vb);

    // The initial values are still stored in the bool variables and remained unchanged
    cout << "The original value of the 1st element still stored in a bool: " << b1 << endl;
    cout << "The original value of the 2nd element still stored in a bool: " << b2 << endl;
    cout << "The original value of the 3rd element still stored in a bool: " << b3 << endl;
    cout << endl;
}

The vector is: true false false true true
The original value of the 1st element stored in a bool: true
The original value of the 2nd element stored in a bool: false
The original value of the 3rd element stored in a bool: false

The vector after assigning refelem1 to refelem2 is now: true true false true true
The vector after assigning false to refelem1 is now: true true true true true
The original value of the 1st element still stored in a bool: true
The original value of the 2nd element still stored in a bool: false
The original value of the 3rd element still stored in a bool: false

vector<bool>::swap

Fonction membre statique qui échange deux éléments de vecteurs booléens ( vector<bool>) à l’aide de la classe vector<bool>::referenceproxy .

static void swap(
    reference Left,
    reference Right);

Paramètres

Left
Élément à échanger avec l'élément Right.

Right
Élément à échanger avec l'élément Left.

Notes

Cette surcharge prend en charge les spécifications spéciales de proxy de vector<bool>. vector::swap a la même fonctionnalité que la surcharge d’argument unique de vector<bool>::swap().

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
Informations de référence sur la bibliothèque standard C++