14.3. Les types numériques

14.3.1. Les complexes

Les types de base du langage C++ fournissent une approximation relativement fiable des différents domaines de nombres mathématiques. Par exemple, le type int permet de représenter une plage de valeurs limitée des entiers relatifs, mais suffisamment large toutefois pour permettre d'effectuer la plupart des calculs intervenant dans la vie réelle. De même, les types des nombres à virgule flottante fournissent une approximation relativement satisfaisante des nombres réels des mathématiques. L'approximation cette fois porte non seulement sur la plage de valeur accessible, mais également sur la précision des nombres.

Il existe en mathématiques un autre type de nombres, qui n'ont pas de représentation physique immédiate pour le commun des mortels, mais qui permettent souvent de simplifier beaucoup certains calculs : les nombres complexes. Ces nombres étendent en effet le domaine des nombres accessibles et permettent de poursuivre les calculs qui n'étaient pas réalisables avec les nombres réels seulement, en s'affranchissant des contraintes imposées sur les solutions des équations algébriques. Les nombres complexes sont donc d'une très grande utilité dans toute l'algèbre, et en particulier dans les calculs matriciels où ils prennent une place prédominante. Les nombres complexes permettent également de simplifier sérieusement les calculs trigonométriques, les calculs de signaux en électricité et les calculs en mécanique quantique. Le plus intéressant avec ces nombres est sans doute le fait que même si les résultats intermédiaires que l'on trouve avec eux n'ont pas de signification réelle, les résultats finaux, eux, peuvent en avoir une et n'auraient pas été trouvés aussi facilement en conservant toutes les contraintes imposées par les nombres réels.

Afin de simplifier la vie des programmeurs qui ont besoin de manipuler des nombres complexes, la bibliothèque standard C++ définit la classe template complex, qui permet de les représenter et d'effectuer les principales opérations mathématiques dessus. Si l'utilisation de la classe complex en soi ne pose aucun problème particulier, il peut être utile de donner une description sommaire de ce qu'est un nombre complexe pour les néophytes en mathématiques. Toutefois, cette description n'est pas destinée aux personnes n'ayant aucune connaissance en mathématiques (si tant est qu'un programmeur puisse être dans ce cas...). Si vous ne la comprenez pas, c'est sans doute que vous n'avez aucunement besoin des nombres complexes et vous pouvez donc passer cette section sans crainte.

(réelle, imaginaire)

réelle + imaginaire i

7.56
3i
5+7i

(a,b) * (c,d) = (ac - bd, ad + bc)

1/(a,b) = (a / (a² + b²), -b / (a² + b²))

 #include <iostream>
#include <complex>

using namespace std;

int main(void)
{
    complex<double> c(2,3);
    cout << c << endl;
    return 0;
}

#include <iostream>
#include <complex>

using namespace std;

int main(void)
{
    complex<double> c;
    cin >> c;
    cout << "Vous avez saisi : " << c << endl;
    return 0;
}

#include <iostream>
#include <complex>

using namespace std;

int main(void)
{
    complex<double> c1(2.23, 3.56);
    complex<double> c2(5, 5);
    complex<double> c = c1+c2;
    c = c/(c1-c2);
    cout << c << endl;
    return 0;
}

#include <iostream>
#include <complex>

using namespace std;

int main(void)
{
    // Crée un nombre complexe :
    complex<double> c(2,3);
    // Détermine son argument et sa norme :
    double Arg = arg(c);
    double Norm = abs(c);
    // Construit le nombre complexe conjugué :
    complex<double> co = polar(Norm, -Arg);
    // Affiche le carré de la norme du conjugué :
    cout << norm(co) << endl;
    // Calcule le carré ce cette norme par le produit
    // du complexe et de son conjugué :
    cout << real(c * conj(c)) << endl;
    return 0;
}

14.3.2. Les tableaux de valeurs

Comme il l'a été expliqué dans le Chapitre 1, les programmes classiques fonctionnent toujours sur le même principe : ils travaillent sur des données qu'ils reçoivent en entrée et produisent des résultats en sortie. Ce mode de fonctionnement convient dans la grande majorité des cas, et en fait les programmes que l'on appelle couramment les « filtres » en sont une des applications principales. Un filtre n'est rien d'autre qu'un programme permettant, comme son nom l'indique, de filtrer les données reçues en entrée selon un critère particulier et de ne fournir en sortie que les données qui satisfont ce critère. Certains filtres plus évolués peuvent même modifier les données à la volée ou les traduire dans un autre format. Les filtres sont très souvent utilisés avec les mécanismes de redirection des systèmes qui les supportent afin d'exécuter des traitements complexes sur les flux de données à partir de filtres simples, en injectant les résultats des uns dans le flux d'entrée des autres.

Cependant, ce modèle a une limite pratique en terme de performances, car il nécessite un traitement séquentiel des données. La vitesse d'exécution d'un programme conçu selon ce modèle est donc directement lié à la vitesse d'exécution des instructions, donc à la vitesse du processeur de la machine utilisée. Lorsqu'un haut niveau de performance doit être atteint, plusieurs solutions sont disponibles. Dans la pratique, on distingue trois solutions classiques.

La première solution consiste simplement, pour augmenter la puissance d'une machine, à augmenter celle du processeur. Cela se traduit souvent par une augmentation de la fréquence de ce processeur, technique que tout le monde connaît. Les avantages de cette solution sont évidents : tous les programmes bénéficient directement de l'augmentation de la puissance du processeur et n'ont pas à être modifiés. En revanche, cette technique atteindra un jour ou un autre ses limites en termes de coûts de fabrication et de moyens techniques à mettre en oeuvre pour produire les processeurs.

La deuxième solution est d'augmenter le nombre de processeurs de la machine. Cette solution est très simple, mais suppose que les programmes soient capables d'effectuer plusieurs calculs indépendants simultanément. En particulier, les traitements à effectuer doivent être suffisamment indépendants et ne pas à avoir à attendre les données produites par les autres afin de pouvoir réellement être exécutés en parallèle. On quitte donc le modèle séquentiel, pour entrer dans un modèle de traitement où chaque processeur travaille en parallèle (modèle « MIMD », abréviation de l'anglais « Multiple Instruction Multiple Data »). Cette technique est également souvent appelée le parallélisme de traitement. Malheureusement, pour un unique processus purement séquentiel, cette technique ne convient pas, puisque de toutes façons, les opérations à exécuter ne le seront que par un seul processeur.

Enfin, il existe une technique mixte, qui consiste à paralléliser les données. Les mêmes opérations d'un programme séquentiel sont alors exécutées sur un grand nombre de données similaires. Les données sont donc traitées par blocs, par un unique algorithme : il s'agit du parallélisme de données (« SIMD » en anglais, abréviation de « Single Instruction Multiple Data »). Cette solution est celle mise en oeuvre dans les processeurs modernes qui disposent de jeux d'instructions spécialisées permettant d'effectuer des calculs sur plusieurs données simultanément (MMX, 3DNow et SSE pour les processeurs de type x86 par exemple). Bien entendu, cette technique suppose que le programme ait effectivement à traiter des données semblables de manière similaire. Cette contrainte peut paraître très forte, mais, en pratique, les situations les plus consommatrices de ressources sont justement celles qui nécessite la répétition d'un même calcul sur plusieurs données. On citera par exemple tous les algorithmes de traitement de données multimédia, dont les algorithmes de compression, de transformation et de combinaison.

Si l'augmentation des performances des processeurs apporte un gain directement observable sur tous les programmes, ce n'est pas le cas pour les techniques de parallélisation. Le parallélisme de traitement est généralement accessible au niveau système, par l'intermédiaire du multitâche et de la programmation multithreadée. Il faut donc écrire les programmes de telle sorte à bénéficier de ce parallélisme de traitement, à l'aide des fonctions spécifique au système d'exploitation. De même, le parallélisme de données nécessite la définition de types de données complexes, capables de représenter les blocs de données sur lesquels le programme doit travailler. Ces blocs de données sont couramment gérés comme des vecteurs ou des matrices, c'est-à-dire, en général, comme des tableaux de nombres. Le programme doit donc utiliser ces types spécifiques pour accéder à toutes les ressources de la machine. Cela nécessite un support de la part du langage de programmation.

Chaque environnement de développement est susceptible de fournir les types de données permettant d'effectuer des traitements SIMD. Cependant, ces types dépendent de l'environnement utilisé et encore plus de la plate-forme utilisée. La bibliothèque standard C++ permet d'éviter ces écueils, car elle définit un type de donnée permettant de traiter des tableaux unidimensionnels d'objets, en assurant que les mécanismes d'optimisation propre aux plates-formes matérielles et aux compilateurs seront effectivement utilisés : les valarray.

// Déclaration des classes de sélection de sous-tableau :
class slice;
class gslice;

// Déclaration de la classe valarray :
template <class T>
class valarray
{
public:
    // Types des données :
    typedef T value_type;

    // Constructeurs et destructeurs :
    valarray();
    explicit valarray(size_t taille);
    valarray(const T &valeur, size_t taille);
    valarray(const T *tableau, size_t taille);
    valarray(const valarray &source);
    valarray(const mask_array<T> &source);
    valarray(const indirect_array<T> &source);
    valarray(const slice_array<T> &source);
    valarray(const gslice_array<T> &source);
    ~valarray();

    // Opérateurs d'affectation :
    valarray<T> &operator=(const T &valeur);
    valarray<T> &operator=(const valarray<T> &source);
    valarray<T> &operator=(const mask_array<T> &source);
    valarray<T> &operator=(const indirect_array<T> &source);
    valarray<T> &operator=(const slice_array<T> &source);
    valarray<T> &operator=(const gslice_array<T> &source);

    // Opérateurs d'accès aux éléments :
    T operator[](size_t indice) const;
    T &operator[](size_t indice);

    // Opérateurs de sélection de sous-ensemble du tableau :
    valarray<T>       operator[](const valarray<bool> &masque) const;
    mask_array<T>     operator[](const valarray<bool> &masque);
    valarray<T>       operator[](const valarray<size_t> &indices) const;
    indirect_array<T> operator[](const valarray<size_t> &indices);
    valarray<T>       operator[](slice selecteur) const;
    slice_array<T>    operator[](slice selecteur);
    valarray<T>       operator[](const gslice &selecteur) const;
    gslice_array<T>   operator[](const gslice &selecteur);

    // Opérateurs unaires :
    valarray<T> operator+() const;
    valarray<T> operator-() const;
    valarray<T> operator~() const;
    valarray<T> operator!() const;

    // Opérateurs d'affectation composée :
    valarray<T> &operator*=(const T &valeur);
    valarray<T> &operator*=(const valarray<T> &tableau);
    valarray<T> &operator/=(const T &valeur);
    valarray<T> &operator/=(const valarray<T> &tableau);
    valarray<T> &operator%=(const T &valeur);
    valarray<T> &operator%=(const valarray<T> &tableau);
    valarray<T> &operator+=(const T &valeur);
    valarray<T> &operator+=(const valarray<T> &tableau);
    valarray<T> &operator-=(const T &valeur);
    valarray<T> &operator-=(const valarray<T> &tableau);
    valarray<T> &operator^=(const T &valeur);
    valarray<T> &operator^=(const valarray<T> &tableau);
    valarray<T> &operator&=(const T &valeur);
    valarray<T> &operator&=(const valarray<T> &tableau);
    valarray<T> &operator|=(const T &valeur);
    valarray<T> &operator|=(const valarray<T> &tableau);
    valarray<T> &operator<<=(const T &valeur);
    valarray<T> &operator<<=(const valarray<T> &tableau);
    valarray<T> &operator>>=(const T &valeur);
    valarray<T> &operator>>=(const valarray<T> &tableau);

    // Opérations spécifiques :
    size_t size() const;
    T sum() const;
    T min() const;
    T max() const;
    valarray<T> shift(int) const;
    valarray<T> cshift(int) const;
    valarray<T> apply(T fonction(T)) const;
    valarray<T> apply(T fonction(const T &)) const;
    void resize(size_t taille, T initial=T());
};

// Construit un valarray de doubles :
valarray<double> v1;

// Initialise un valarray de doubles explicitement :
double valeurs[] = {1.2, 3.14, 2.78, 1.414, 1.732};
valarray<double> v2(valeurs,
    sizeof(valeurs) / sizeof(double));

// Construit un valarray de 10 entiers initialisés à 3 :
valarray<int> v3(3, 10);
						

#include <iostream>
#include <valarray>

using namespace std;

int main(void)
{
    // Création d'un valarray :
    valarray<double> v;
    cout << v.size() << endl;
    // Redimensionnement du valarray :
    v.resize(5, 3.14);
    cout << v.size() << endl;
    return 0;
}

#include <iostream>
#include <valarray>

using namespace std;

void affiche(const valarray<double> &v)
{
    size_t i;
    for (i=0; i<v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
}

int main(void)
{
    // Construit deux valarray de doubles :
    double v1[] = {1.1, 2.2, 3.3};
    double v2[] = {5.3, 4.4, 3.5};
    valarray<double> vect1(v1, 3);
    valarray<double> vect2(v2, 3);
    valarray<double> res(3);
    // Effectue une somme membre à membre :
    res = vect1 + vect2;
    affiche(res);
    // Calcule le sinus des membres du premier valarray :
    res = sin(vect1);
    affiche(res);
    return 0;
}

#include <iostream>
#include <valarray>

using namespace std;

void affiche(const valarray<double> &v)
{
    size_t i;
    for (i=0; i<v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
}

int main(void)
{
    // Construit un valarray de doubles :
    double v1[] = {1.1, 2.2, 3.3, 4.4, 5.5};
    valarray<double> vect1(v1, 5);
    valarray<double> res(5);
    // Effectue un décalage à gauche de deux positions :
    res = vect1.shift(2);
    affiche(res);
    // Effectue une rotation de 2 positions vers la droite :
    res = vect1.cshift(-2);
    affiche(res);
    return 0;
}

#include <iostream>
#include <valarray>

using namespace std;

void affiche(const valarray<int> &v)
{
    size_t i;
    for (i=0; i<v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
}

int main(void)
{
    // Construit un valarray d'entier :
    int valeurs[] = { 1, 5, 9, 4, 3, 7, 21, 32 };
    valarray<int> vi(valeurs,
        sizeof(valeurs) / sizeof(int));
    affiche(vi);
    // Multiplie par 2 tous les multiples de 3 :
    vi[(vi % 3)==0] *= valarray<int>(2, vi.size());
    affiche(vi);
    return 0;
}

#include <iostream>
#include <valarray>

using namespace std;

void affiche(const valarray<int> &v)
{
    size_t i;
    for (i=0; i<v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
}

int main(void)
{
    // Construit un valarray d'entier :
    int valeurs[] = { 1, 5, 9, 4, 3, 7, 21, 32 };
    valarray<int> vi(valeurs,
        sizeof(valeurs) / sizeof(int));
    affiche(vi);
    // Multiplie par 2 les éléments d'indices 2, 5 et 7 :
    size_t indices[] = {2, 5, 7};
    valarray<size_t> ind(indices,
        sizeof(indices) / sizeof(size_t));
    vi[ind] *= valarray<int>(2, ind.size());
    affiche(vi);
    return 0;
}

class slice
{
public:
    slice();
    slice(size_t debut, size_t nombre, size_t pas);

    // Accesseurs :
    size_t start() const;
    size_t size() const;
    size_t stride() const;
};

#include <iostream>
#include <valarray>

using namespace std;

void affiche(const valarray<int> &v)
{
    size_t i;
    for (i=0; i<v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
}

int main(void)
{
    // Construit un valarray d'entier :
    int valeurs[] = { 1, 5, 9, 4, 3, 7, 21, 32 };
    valarray<int> vi(valeurs, 8);
    affiche(vi);
    // Multiplie par 2 un élément sur 3 à partir du deuxième :
    slice sel(1, 3, 3);
    vi[sel] *= valarray<int>(2, vi.size());
    affiche(vi);
    // Multiplie par 2 un élément sur 3 à partir du deuxième :
    slice sel(1, 3, 3);
    vi[sel] *= valarray<int>(2, vi.size());
    affiche(vi);
    return 0;
}

class gslice
{
public:
    gslice();
    gslice(size_t debut,
        const valarray<size_t> nombres,
        const valarray<size_t> pas);

    // Accesseurs :
    size_t start() const;
    valarray<size_t> size() const;
    valarray<size_t> stride() const;
};

2, 4, 6, 8, 10,
3, 5, 7, 9, 11,
4, 6, 8, 10, 12,

5, 7, 9, 11, 13,
6, 8, 10, 12, 14,
7, 9, 11, 13, 15

template <class T>
class mask_array
{
public:
    typedef T value_type;
    ~mask_array();

    // Opérateurs d'affectation et d'affectation composées :
    void operator=(const valarray<T> &) const;
    void operator*=(const valarray<T> &) const;
    void operator/=(const valarray<T> &) const;
    void operator%=(const valarray<T> &) const;
    void operator+=(const valarray<T> &) const;
    void operator-=(const valarray<T> &) const;
    void operator^=(const valarray<T> &) const;
    void operator&=(const valarray<T> &) const;
    void operator|=(const valarray<T> &) const;
    void operator<<=(const valarray<T> &) const;
    void operator>>=(const valarray<T> &) const;
    void operator=(const T &valeur);
};

14.3.3. Les champs de bits

De tous les types de données qu'un programme peut avoir besoin de stocker, les booléens sont certainement l'un des plus importants. En effet, les programmes doivent souvent représenter des propriétés qui sont soit vraies, soit fausses. Après tout, la base du traitement de l'information telle qu'il est réalisé par les ordinateurs est le bit, ou chiffre binaire...

Il existe plusieurs manières de stocker des booléens dans un programme. La technique la plus simple est bien entendu d'utiliser le type C++ natif bool, qui ne peut prendre que les valeurs true et false. Les programmes plus vieux utilisaient généralement des entiers et des constantes prédéfinies ou encore une énumération. Malheureusement, toutes ces techniques souffrent du gros inconvénient que chaque information est stockée dans le type sous-jacent au type utilisé pour représenter les booléens et, dans la plupart des cas, ce type est un entier. Cela signifie que pour stocker un bit, il faut réserver un mot mémoire complet. Même en tenant compte du fait que la plupart des compilateurs C++ stockent les variables de type bool dans de simples octets, la déperdition reste dans un facteur 8. Bien entendu, cela n'est pas grave si l'on n'a que quelques bits à stocker, mais si le programme doit manipuler un grand nombre d'informations booléennes, cette technique est à proscrire.

Nous avons vu dans la Section 3.1.4 qu'il est possible de définir des champs de bits en attribuant un nombre de bits fixe à plusieurs identificateurs de type entier. Cette solution peut permettre d'économiser de la mémoire, mais reste malgré tout relativement limitée si un grand nombre de bits doit être manipulé. Afin de résoudre ce problème, la bibliothèque standard C++ fournit la classe template bitset qui, comme son nom l'indique, encapsule des champs de bits de tailles arbitraires. Le paramètre template est de type size_t et indique le nombre de bits que le champ de bits encapsulé contient.

La classe bitset est déclarée comme suit dans l'en-tête bitset :

template <size_t N>
class bitset
{
public:
    class reference;    // Classe permettant de manipuler les bits.

    // Les constructeurs :
    bitset();
    bitset(unsigned long val);
    template<class charT, class traits, class Allocator>
    explicit bitset(
        const basic_string<charT, traits, Allocator> &chaine,
        typename basic_string<charT, traits, Allocator>::size_type debut = 0,
        typename basic_string<charT, traits, Allocator>::size_type taille =
            basic_string<charT, traits, Allocator>::npos);

    // Les fonctions de conversion :
    unsigned long to_ulong() const;
    template <class charT, class traits, class Allocator>
        basic_string<charT, traits, Allocator> to_string() const;

    // Les opérateurs de manipulation :
    bitset<N> &operator&=(const bitset<N> &);
    bitset<N> &operator|=(const bitset<N> &);
    bitset<N> &operator^=(const bitset<N> &);
    bitset<N> &operator<<=(size_t pos);
    bitset<N> &operator>>=(size_t pos);
    bitset<N> operator<<(size_t pos) const;
    bitset<N> operator>>(size_t pos) const;
    bitset<N>  operator~() const;
    bitset<N> &set();
    bitset<N> &set(size_t pos, bool val = true);
    bitset<N> &reset();
    bitset<N> &reset(size_t pos);
    bitset<N> &flip();
    bitset<N> &flip(size_t pos);
    bool test(size_t pos) const;
    reference operator[](size_t pos);   // for b[i];

    // Les opérateurs de comparaison :
    bool operator==(const bitset<N> &rhs) const;
    bool operator!=(const bitset<N> &rhs) const;

    // Les fonctions de test :
    size_t count() const;
    size_t size() const;
    bool any() const;
    bool none() const;
};

La construction d'un champ de bits nécessite de connaître le nombre de bits que ce champ doit contenir afin d'instancier la classe template bitset. Les différents constructeurs permettent d'initialiser le champ de bits en affectant la valeur nulle à tous ses bits ou en les initialisant en fonction des paramètres du constructeur. Le deuxième constructeur affectera aux premiers bits du champ de bits les bits correspondant de l'entier de type unsigned long fourni en paramètre, et initialisera les autres bits du champ de bits à la valeur 0 si celui-ci contient plus de bits qu'un unsigned long. Le troisième constructeur initialise le champ de bits à partir de sa représentation sous forme de chaîne de caractères ne contenant que des '0' ou des '1'. Cette représentation doit être stockée dans la basic_string fournie en premier paramètre, à partir de la position debut et sur une longueur de taille caractères. Cette taille peut être inférieure à la taille du champ de bits. Dans ce cas, le constructeur considérera que les bits de poids fort sont tous nuls et initialisera les premiers bits du champ avec les valeurs lues dans la chaîne. Notez bien que les premiers caractères de la chaîne de caractères représentent les bits de poids fort, cette chaîne est donc parcourue en sens inverse lors de l'initialisation. Ce constructeur est susceptible de lancer une exception out_of_range si le paramètre debut est supérieur à la taille de la chaîne ou une exception invalid_argument si l'un des caractères utilisés est différent des caractères '0' ou '1'.

Comme vous pouvez le constater d'après la déclaration, la classe bitset fournit également des méthodes permettant d'effectuer les conversions inverses de celles effectuées par les constructeurs. La méthode to_ulong renvoie donc un entier de type unsigned long correspondant à la valeur des premiers bits du champ de bits, et la méthode template to_string renvoie une chaîne de caractères contenant la représentation du champ de bits sous la forme d'une suite de caractères '0' et '1'. La classe bitset fournit également des surcharges des opérateurs operator<< et operator>> pour les flux d'entrée / sortie de la bibliothèque standard.

#include <iostream>
#include <bitset>
#include <string>

using namespace std;

int main(void)
{
    // Construit un champ de bits :
    string s("100110101");
    bitset<32> bs(s);
    // Affiche la valeur en hexadécimal de l'entier associé :
    cout << hex << showbase << bs.to_ulong() << endl;
    // Affiche la valeur sous forme de chaîne de caractères :
    string t;
    t = bs.to_string<string::value_type, string::traits_type,
        string::allocator_type>();
    cout << t << endl;
    // Utilise directement << sur le flux de sortie :
    cout << bs << endl;
    return 0;
}

Les opérateurs de manipulation des champs de bits ne posent pas de problème particulier puisqu'ils ont la même sémantique que les opérateurs standards du langage, à ceci près qu'ils travaillent sur l'ensemble des bits du champ en même temps. Le seul opérateur qui demande quelques explications est l'opérateur d'accès unitaire aux bits du champ, à savoir l'opérateur operator[]. En effet, cet opérateur ne peut pas retourner une référence sur le bit désigné par son argument puisqu'il n'y a pas de type pour représenter les bits en C++. Par conséquent, la valeur retournée est en réalité une instance de la sous-classe reference de la classe bitset. Cette sous-classe encapsule l'accès individuel aux bits d'un champ de bits et permet de les utiliser exactement comme un booléen. En particulier, il est possible de faire des tests directement sur cette valeur ainsi que de lui affectuer une valeur booléenne. Enfin, la sous-classe reference dispose d'une méthode flip dont le rôle est d'inverser la valeur du bit auquel l'objet reference donne accès.

La classe template bitset dispose également de méthodes spécifiques permettant de manipuler les bits sans avoir recours à l'opérateur operator[]. Il s'agit des méthodes test, set, reset et flip. La première méthode permet de récupérer la valeur courante d'un des bits du champ de bits. Elle prend en paramètre le numéro de ce bit et renvoie un booléen valant true si le bit est à 1 et false sinon. La méthode set permet de réinitialiser le champ de bits complet en positionnant tous ses bits à 1 ou de fixer manuellement la valeur d'un bit particulier. La troisième méthode permet de réinitialiser le champ de bits en annulant tous ses bits ou d'annuler un bit spécifique. Enfin, la méthode flip permet d'inverser la valeur de tous les bits du champ ou d'inverser la valeur d'un bit spécifique. Les surcharges des méthodes qui travaillent sur un seul bit prennent toutes en premier paramètre la position du bit dans le champ de bits.

#include <iostream>
#include <string>
#include <bitset>

using namespace std;

int main(void)
{
    // Construit un champ de bits :
    string s("10011010");
    bitset<8> bs(s);
    cout << bs << endl;
    // Inverse le champ de bits :
    bs.flip();
    cout << bs << endl;
    // Fixe le bit de poids fort :
    bs.set(7, true);
    cout << bs << endl;
    // Annule le 7ème bit à l'aide d'une référence de bit :
    bs[6] = false;
    cout << bs << endl;
    // Anule le bit de poids faibe :
    bs.reset(0);
    cout << bs << endl;
    return 0;
}

Enfin, la classe bitset fournit quelques méthodes permettant d'effectuer des tests sur les champs de bits. Outre les opérateurs de comparaison classiques, elle fournit les méthodes count, size, any et none. La méthode count renvoie le nombre de bits positionnés à 1 dans le champ de bits. La méthode size renvoie quant à elle la taille du champ de bits, c'est-à-dire la valeur du paramètre template utilisée pour instancier la classe bitset. Enfin, les méthodes any et none renvoient true si un bit au moins du champ de bits est positionné ou s'ils sont tous nuls.