Outils d'utilisateurs
bitset
Différences
Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.
|
bitset [2016/04/20 12:08] gbdivers |
bitset [2016/07/05 18:54] (Version actuelle) gbdivers |
||
|---|---|---|---|
| Ligne 1: | Ligne 1: | ||
| - | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[valarray|Chapitre suivant]] ^ | + | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[string_etendu|Chapitre suivant]] ^ |
| - | ====== Les tableaux de bits ====== | + | __ A rediger: cast vers d'autres types, bit shift__ |
| - | Vous avez déjà rencontrer la classe ''std::bitset'' dans le chapitre [[logique_et_calcul_booleen|]], pour afficher une séquence de bits. | + | ====== [Aller plus loin] Les tableaux de bits ====== |
| + | |||
| + | Vous avez déjà rencontré la classe ''std::bitset'' dans le chapitre [[logique_et_calcul_booleen|]], pour afficher une séquence de bits. | ||
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 25: | Ligne 27: | ||
| </code> | </code> | ||
| - | Ce chapitre détaille l'utilisation de cette classe ''std::bitset'' et les notions de //flag// et //mask//. Les notions vues dans les chapitres [[logique_et_calcul_booleen|]] et [[boole_et_morgan|]] seront utilisees, n'hesitez pas a les relire si nécessaire. | + | Ce chapitre détaille l'utilisation de cette classe ''std::bitset'' et les notions de //flag// et //mask//. Les notions vues dans les chapitres [[logique_et_calcul_booleen|]] et [[boole_et_morgan|]] seront utilisées, n’hésitez pas à les relire si nécessaire. |
| Ligne 40: | Ligne 42: | ||
| Il existe différentes méthodes pour initialiser un ''std::bitset'' : | Il existe différentes méthodes pour initialiser un ''std::bitset'' : | ||
| - | * avec une valeur entiere ; | + | * avec une valeur entière ; |
| * avec une chaîne de caractères. | * avec une chaîne de caractères. | ||
| Ligne 49: | Ligne 51: | ||
| int main() { | int main() { | ||
| - | const std::bitset<8> b; | + | const std::bitset<8> b {}; |
| const std::bitset<8> b8 { 0b101010 }; | const std::bitset<8> b8 { 0b101010 }; | ||
| const std::bitset<16> b16 { 0xA1B2 }; | const std::bitset<16> b16 { 0xA1B2 }; | ||
| Ligne 57: | Ligne 59: | ||
| Pour faciliter la création de ''std::bitset'' à partir d'une entrée utilisateur (flux standard, fichier, etc), il est également possible d'initialiser un ''std::bitset'' à partir d'une chaîne de caractères. La syntaxe peut etre différente selon si vous utiliser une littérale chaîne ou un type ''std::string''. | Pour faciliter la création de ''std::bitset'' à partir d'une entrée utilisateur (flux standard, fichier, etc), il est également possible d'initialiser un ''std::bitset'' à partir d'une chaîne de caractères. La syntaxe peut etre différente selon si vous utiliser une littérale chaîne ou un type ''std::string''. | ||
| - | Le cas le plus simple est d'initialiser un ''std::bitset'' a partir d'une chaîne complète, constituée des caractères ''0'' et ''1''. Dans ce cas, la syntaxe est identique pour une littérale et un ''std::string'' : | + | Le cas le plus simple est d'initialiser un ''std::bitset'' à partir d'une chaîne complète, constituée des caractères ''0'' et ''1''. Dans ce cas, la syntaxe est identique pour une littérale et un ''std::string'' : |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 73: | Ligne 75: | ||
| Notez bien qu'il ne faut pas ajouter de préfixe dans la chaîne de caractères. | Notez bien qu'il ne faut pas ajouter de préfixe dans la chaîne de caractères. | ||
| - | Un ''std::bitset'' peut également etre initialise a partir d'une sous-chaîne de caractères (c'est a dire une partie d'une chaîne de caractères). La syntaxe est différentes entre une littérale et un ''st::string'' : | + | Un ''std::bitset'' peut également être initialisé à partir d'une sous-chaîne de caractères (c'est-à-dire une partie d'une chaîne de caractères). La syntaxe est différentes entre une littérale et un ''std::string'' : |
| * pour une littérale, l'initialisation de ''std::bitset'' ne peut prendre qu'un seul argument optionnel supplémentaire : le nombre de caractères a conserver ; | * pour une littérale, l'initialisation de ''std::bitset'' ne peut prendre qu'un seul argument optionnel supplémentaire : le nombre de caractères a conserver ; | ||
| - | * pour un ''std::string'', ''std::bitset'' peut prendre deux arguments optionnels supplémentaires : la position du premier caractère et le nombre de caractères a conserver. | + | * pour un ''std::string'', ''std::bitset'' peut prendre deux arguments optionnels supplémentaires : la position du premier caractère et le nombre de caractères à conserver. |
| Un exemple concret avec une littérale chaîne : | Un exemple concret avec une littérale chaîne : | ||
| Ligne 110: | Ligne 112: | ||
| const std::string s { "1010101011" }; | const std::string s { "1010101011" }; | ||
| - | const std::bitset<8> b1 { s, 4 }; // commence a l'indice 4 = "101011" | + | const std::bitset<8> b1 { s, 4 }; // commence à l'indice 4 = "101011" |
| std::cout << b1 << std::endl; | std::cout << b1 << std::endl; | ||
| - | const std::bitset<8> b2 { s, 4, 2 }; // commence a l'indice 4 et conserve | + | const std::bitset<8> b2 { s, 4, 2 }; // commence à l'indice 4 et conserve |
| // 2 caractères = "10" | // 2 caractères = "10" | ||
| std::cout << b2 << std::endl; | std::cout << b2 << std::endl; | ||
| Ligne 126: | Ligne 128: | ||
| </code> | </code> | ||
| - | N'oubliez pas qu'en C++, les indices dans les tableaux (et donc dans les chaines de caractères, puisqu'elles peuvent être considérées comme des tableaux de caractères) commencent a l'indice 0. Donc l'indice 4 correspond au cinquième caractère : | + | N'oubliez pas qu'en C++, les indices dans les tableaux (et donc dans les chaines de caractères, puisqu'elles peuvent être considérées comme des tableaux de caractères) commencent à l'indice 0. Donc l'indice 4 correspond au cinquième caractère : |
| <code> | <code> | ||
| Ligne 135: | Ligne 137: | ||
| </code> | </code> | ||
| - | Pour terminer, il est possible d'utiliser d'autres caractères que ''0'' et ''1''. Pour cela, il faut fournir deux arguments supplémentaires, correspondent respectivement aux caractères a utiliser a la place de ''0'' et de ''1''. | + | Pour terminer, il est possible d'utiliser d'autres caractères que ''0'' et ''1''. Pour cela, il faut fournir deux arguments supplémentaires, correspondent respectivement aux caractères à utiliser à la place de ''0'' et de ''1''. |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 163: | Ligne 165: | ||
| <note>**Ordres des arguments et arguments optionnels** | <note>**Ordres des arguments et arguments optionnels** | ||
| - | En C++, les arguments sont identifies par leur position dans l'appel d'une fonction. Par exemple pour initialiser ''std::bitset'' (avec ''position'' qui représente la position du premier caractère et ''taille'' qui correspond au nombre de caractères a conserver : | + | En C++, les arguments sont identifiés par leur position dans l'appel d'une fonction. Par exemple pour initialiser ''std::bitset'' (avec ''position'' qui représente la position du premier caractère et ''taille'' qui correspond au nombre de caractères à conserver : |
| <code> | <code> | ||
| Ligne 177: | Ligne 179: | ||
| </code> | </code> | ||
| - | Dans ce code, le compilateur ne va pas utiliser ''taille'' pour le nombre de caractères et ''position'' pour la position du premier caractère (donc prendre 4 caractères a partir de la position 2), mais va prendre 2 caractères a partir de la position 4. | + | Dans ce code, le compilateur ne va pas utiliser ''taille'' pour le nombre de caractères et ''position'' pour la position du premier caractère (donc prendre 4 caractères à partir de la position 2), mais va prendre 2 caractères à partir de la position 4. |
| Pour la même raison, si on fournit un argument optionnel, les arguments optionnels qui le précédent ne sont plus optionnels. | Pour la même raison, si on fournit un argument optionnel, les arguments optionnels qui le précédent ne sont plus optionnels. | ||
| Ligne 193: | Ligne 195: | ||
| <code> | <code> | ||
| - | std::bitset<8> b; | + | std::bitset<8> b {}; |
| b = 0b110011; // ok | b = 0b110011; // ok | ||
| b = "110011"; // erreur | b = "110011"; // erreur | ||
| Ligne 205: | Ligne 207: | ||
| <code> | <code> | ||
| - | std::bitset<8> b1; | + | std::bitset<8> b1 {}; |
| - | std::bitset<8> b2; | + | std::bitset<8> b2 {}; |
| b2 = b1; // ok | b2 = b1; // ok | ||
| </code> | </code> | ||
| - | Dans le cas d'une valeur entière, le compilateur est autorisé à créer automatiquement et de façon transparente un ''std::bitset'' à partir de cette valeur. C'est à dire à remplacer : | + | Dans le cas d'une valeur entière, le compilateur est autorisé à créer automatiquement et de façon transparente un ''std::bitset'' à partir de cette valeur. C'est-à-dire à remplacer : |
| <code> | <code> | ||
| Ligne 256: | Ligne 258: | ||
| </code> | </code> | ||
| - | Dans ce cas, ''std::bitset'' sera affiche en utilisant les caractères ''0'' et ''1'', avec autant de caractères que définie dans l'argument template de ''std::bitset'' (donc en complétant avec ''0'' si nécessaire). | + | Dans ce cas, ''std::bitset'' sera affiche en utilisant les caractères ''0'' et ''1'', avec autant de caractères que définie dans l'argument //template// de ''std::bitset'' (donc en complétant avec ''0'' si nécessaire). |
| - | La fonction ''to_string'' permet de transformer un ''std::bitset'' en une chaîne de caractères, en utilisant par défaut les caractères ''0'' et ''1'' (c'est l’opération inverse de l'initialisation avec une chaîne). Cette fonction peut prendre deux arguments optionnels, correspondant aux caractères a utiliser respectivement pour ''0'' et ''1''. | + | La fonction ''to_string'' permet de transformer un ''std::bitset'' en une chaîne de caractères, en utilisant par défaut les caractères ''0'' et ''1'' (c'est l’opération inverse de l'initialisation avec une chaîne). Cette fonction peut prendre deux arguments optionnels, correspondant aux caractères à utiliser respectivement pour ''0'' et ''1''. |
| La chaîne de caractères produite peut être conservée dans une variable ou être directement affichée avec ''std::cout''. | La chaîne de caractères produite peut être conservée dans une variable ou être directement affichée avec ''std::cout''. | ||
| Ligne 287: | Ligne 289: | ||
| Conceptuellement, ''std::bitset'' est un tableau compact de booléens. Il est donc possible de manipuler directement chaque bit comme une valeur booléenne, de la lire ou de la modifier directement dans ''std::bitset''. | Conceptuellement, ''std::bitset'' est un tableau compact de booléens. Il est donc possible de manipuler directement chaque bit comme une valeur booléenne, de la lire ou de la modifier directement dans ''std::bitset''. | ||
| - | Pour connaitre la taille d'un ''std::bitset'' (c'est a dire connaitre la valeur de l'argument //template// ''TAILLE'' utilise pour initialiser le ''std::bitset''), vous pouvez utiliser la fonction ''size''. | + | Pour connaitre la taille d'un ''std::bitset'' (c'est-à-dire connaitre la valeur de l'argument //template// ''TAILLE'' utilise pour initialiser le ''std::bitset''), vous pouvez utiliser la fonction ''size''. |
| <note>Vous voyez ici l’intérêt d'avoir une interface cohérente : beaucoup de classe de la bibliothèque standard représentant un tableau proposent la fonction ''size'' pour connaitre la taille du tableau (''std::vector'', ''std::array'', ''std::string'', etc). Avoir un interface cohérente simplifie la mémorisation et évite les erreurs. Conservez cette idée en tête lorsque vous créerez vos propres interfaces.</note> | <note>Vous voyez ici l’intérêt d'avoir une interface cohérente : beaucoup de classe de la bibliothèque standard représentant un tableau proposent la fonction ''size'' pour connaitre la taille du tableau (''std::vector'', ''std::array'', ''std::string'', etc). Avoir un interface cohérente simplifie la mémorisation et évite les erreurs. Conservez cette idée en tête lorsque vous créerez vos propres interfaces.</note> | ||
| Ligne 296: | Ligne 298: | ||
| int main() { | int main() { | ||
| - | const std::bitset<8> b8{}; | + | const std::bitset<8> b8 {}; |
| std::cout << b8.size() << std::endl; | std::cout << b8.size() << std::endl; | ||
| const std::bitset<16> b16{}; | const std::bitset<16> b16{}; | ||
| Ligne 310: | Ligne 312: | ||
| </code> | </code> | ||
| - | Comme pour les autres tableaux de la bibliothèque standard (''std::array'', ''std::vector'', etc.), l'opérateur ''[]'' permet d'accéder aux élément d'un ''std::bitset''. Comme toujours, l'indice doit avoir une valeur comprise entre 0 et ''SIZE-1''. | + | ==== L’opérateur d'indexation ==== |
| + | |||
| + | Comme pour les autres tableaux de la bibliothèque standard (''std::array'', ''std::vector'', etc.), l'opérateur d'indexation ''[]'' permet d'accéder aux élément d'un ''std::bitset''. Comme toujours, l'indice doit avoir une valeur comprise entre 0 et ''SIZE-1''. | ||
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 354: | Ligne 358: | ||
| </code> | </code> | ||
| - | L'opérateur ''[]'' est également utilisé pour modifier la valeur d'un bit en particulier, utilisant simplement l'opérateur d'affectation ''='', comme vous le feriez avec n'importe quelle variable. | + | L'opérateur d'indexation ''[]'' est également utilisé pour modifier la valeur d'un bit en particulier, utilisant simplement l'opérateur d'affectation ''='', comme vous le feriez avec n'importe quelle variable. |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 361: | Ligne 365: | ||
| int main() { | int main() { | ||
| - | std::bitset<8> b8{}; | + | std::bitset<8> b8 {}; |
| std::cout << b8 << std::endl; | std::cout << b8 << std::endl; | ||
| b8[0] = true; | b8[0] = true; | ||
| Ligne 376: | Ligne 380: | ||
| </code> | </code> | ||
| - | <note>La fonction ''test'' | ||
| - | ''std::bitset'' propose également la fonction ''test'' pour accéder en lecture seule à un bit spécifique. La différence avec l’opérateur ''[]'' est que la fonction ''test'' vérifie si les accès en dehors du tableau. Comme pour la fonction ''std::vector::at'', cela est assimilé à de la programmation défensive et n'est pas recommandé.</note> | + | ==== Les fonctions test, set, reset et flip ==== |
| + | |||
| + | En complément de l’opérateur d'indexation ''[]'', qui permet d’accéder aux bits d'un ''std::bitset'' en lecture ET en écriture, la classe ''std::bitset'' propose également plusieurs fonctions plus spécialisées, pour accéder aux bits en lecture OU en écriture. | ||
| + | |||
| + | <note>Une seconde différence importante est que ces fonctions vérifient les accès en dehors des limites de ''std::bitset'' et lancer une exception de type ''std::out_of_range'' si vous essayez d'utiliser un index invalide. | ||
| + | |||
| + | La gestion des erreurs et les exceptions seront vu dans la partie sur la création de bibliothèque, mais retenez que la vérification systématique des accès est assimilée à de la programmation défensive, ce qui n'est pas forcément une bonne pratique.</note> | ||
| + | |||
| + | Les fonctions sont les suivantes : | ||
| + | |||
| + | * ''test'' pour lire une valeur ; | ||
| + | * ''set'' pour modifier une valeur (par défaut pour la mettre à ''true'') ; | ||
| + | * ''reset'' pour mettre une valeur à ''false'' ; | ||
| + | * ''flip'' pour inverser une valeur (c'est-à-dire que les bits valant ''true'' passent à ''false'' et vice-versa). | ||
| + | |||
| + | Ces fonctions prennent comme argument l'indice du bit à modifier. les fonctions ''set'', ''reset'' et ''flip'' peuvent également être appelée sans argument, ce qui a pour effet de modifier tous les bits. Pour terminer, la fonction ''set'' peut prendre deux arguments : l'indice du bit à modifier et la valeur booléenne à définir. | ||
| + | |||
| + | <code cpp main.cpp> | ||
| + | #include <iostream> | ||
| + | #include <bitset> | ||
| + | |||
| + | int main() { | ||
| + | std::bitset<8> b8 {}; | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.set(3); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.set(); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.set(5, false); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.reset(3); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.reset(); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.flip(3); | ||
| + | std::cout << b8 << std::endl; | ||
| + | b8.flip(); | ||
| + | std::cout << b8 << std::endl; | ||
| + | std::cout << b8.test(2) << std::endl; | ||
| + | std::cout << b8.test(3) << std::endl; | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | affiche : | ||
| + | |||
| + | <code> | ||
| + | 00000000 | ||
| + | 00001000 | ||
| + | 11111111 | ||
| + | 11011111 | ||
| + | 11010111 | ||
| + | 00000000 | ||
| + | 00001000 | ||
| + | 11110111 | ||
| + | 1 | ||
| + | 0 | ||
| + | </code> | ||
| Ligne 387: | Ligne 446: | ||
| * ''all'' permet de tester si tous les bits ont la valeur ''true'' ; | * ''all'' permet de tester si tous les bits ont la valeur ''true'' ; | ||
| * ''any'' permet de tester si au moins un bit à la valeur ''true'' ; | * ''any'' permet de tester si au moins un bit à la valeur ''true'' ; | ||
| - | * ''none'' permet de tester si aucun bit n'a la valeur ''true ; | + | * ''none'' permet de tester si aucun bit n'a la valeur ''true'' ; |
| * ''count'' permet de compter le nombre de bits qui ont la valeur ''true''. | * ''count'' permet de compter le nombre de bits qui ont la valeur ''true''. | ||
| Ligne 420: | Ligne 479: | ||
| - | ===== Mask et flag ===== | + | ===== Masquage et drapeau ===== |
| + | <note>Il est également possible d'utiliser les énumérations pour représenter des drapeaux.</note> | ||
| + | ==== Les drapeaux ==== | ||
| - | tester un bit : mask, flag, opérateur ET bit à bit, test() | + | Il arrive souvent de devoir représenter l'état d'un concept en utilisant un nombre important de valeurs booléennes. Par exemple, une fenêtre dans une interface graphique sera visible ou non, pourra être déplaçable ou non, pourra avoir une barre de titre ou non, etc. Un véhicule pourra avoir trois ou cinq portes, pourra avoir un coffre ou non, pourra avoir ses phares allumés ou non, etc. |
| - | forcer un bit : OU bit a bit | + | |
| - | tester plusieurs bit : count, all, any, none (cf algo) | + | Une première possibilité pour représenter cela est de créer autant de variables booléennes que vous avez d'états à représenter. |
| + | <code cpp> | ||
| + | // représentation de l'état d'une fenêtre | ||
| + | bool is_visible {}; | ||
| + | bool is_movable {}; | ||
| + | bool has_title {}; | ||
| + | </code> | ||
| - | Plusieurs fois des données de même type. Accès avec un indice, partant de 0. Taille fixé à la compilation ou à l'exécution : bitset à la compilation (vector<bool> à l'exécution). | + | <note>Il existe de nombreuses habitudes de programmation. Par exemple comme dans le code précédent, les préfixes "is" et "has" sont utilisés respectivement les états "est" ou "n'est pas" et les états "a" ou "n'a pas". Ainsi, ''is_visible'' signifie littéralement "est visible" et sera vraie quand la fenêtre est visible et fausse dans le cas contraire.</note> |
| + | Cependant, vous avez vu qu'un booléen en mémoire n'est pas représenté par un bit, mais par un octet en général (soit 8 bits). Cela signifie donc une consommation mémoire inutilement plus importante. | ||
| - | Validation taille : assert | + | <code cpp main.cpp> |
| - | connaitre la taille : size | + | #include <iostream> |
| + | |||
| + | int main() { | ||
| + | std::cout << sizeof(bool) << " octet(s)" << std::endl; | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | affiche : | ||
| + | |||
| + | <code> | ||
| + | 1 octet(s) | ||
| + | </code> | ||
| + | |||
| + | De plus, chaque variable est indépendante. Si vous voulez réinitialiser une fenêtre par exemple, il faudra modifier chaque booléen un par un, il n'est pas possible de les remettre tous à faux en une instruction. | ||
| + | |||
| + | Pour améliorer cela, vous l'aurez surement deviné, il est possible d'utiliser ''std::bitset'' pour représenter un ensemble d'états booléens de façon compact. Chaque variable booléenne est maintenant replacée par un bit en particulier dans le ''std::bitset''. | ||
| + | |||
| + | Par exemple, pour la fenêtre, il est possible d'utiliser un ''std::bitset<3>'', dans lequel le premier bit représente ''is_visible'', le second représente ''is_movable'' et le dernier ''has_title''. Il est alors possible d'utiliser les syntaxes vues précédemment pour manipuler l'état de la fenêtre. | ||
| + | |||
| + | <code cpp> | ||
| + | using window_state = std::bitset<3>; | ||
| + | |||
| + | const window_state ws1 { 0b001 }; // fenêtre visible, non déplaçable et sans barre de titre | ||
| + | const window_state ws2 { 0b110 }; // fenêtre masquée, déplaçable et avec une barre de titre | ||
| + | |||
| + | window_state ws3; | ||
| + | ws3.flip(0); // inverse is_visible, si la fenêtre était visible, | ||
| + | // elle devient invisible et réciproquement. | ||
| + | const bool is_visible = ws3.test(0); // teste si la fenêtre est visible ou non | ||
| + | </code> | ||
| + | |||
| + | <note> | ||
| + | Vous voyez ici un effet indésirable des optimisation : le code perd en lisibilité. Sans la documentation, il est impossible de savoir que ''0b001'' représente une fenêtre visible, non déplaçable et sans barre de titre, alors que ''is_visible'', ''is_movable'' et ''has_title'' sont suffisamment compréhensibles. | ||
| + | |||
| + | Et plus généralement, lorsque vous concevrez un code, vous devrez faire des compromis entre vos objectifs de qualité logicielle (lisibilité, évolutivité, fiabilité, etc) et vos contraintes (temps de développement, moyens humains, etc). | ||
| + | </note> | ||
| + | |||
| + | |||
| + | ==== Le masquage ==== | ||
| + | |||
| + | Le masquage est un concept générique en informatique, qui consiste à définir un sous-ensemble sur lequel sera appliqué une modification (vous pouvez par exemple retrouver ce concept dans les masques de calque dans un logiciel de dessin tel que Gimp). | ||
| + | |||
| + | Pour prendre un exemple concret, imaginez que vous avez la valeur ''0b11001110'' et que vous souhaitez modifier que les quatre premiers bits (en partant de la droite). En appliquant les opérations précédentes, vous obtiendrez : | ||
| + | |||
| + | ^ Operation ^ Resultat ^ Commentaire ^ | ||
| + | | set | ''0b11001111'' | les quatre derniers bits sont mit a 1 | | ||
| + | | reset | ''0b11000000'' | les quatre derniers bits sont mit a 0 | | ||
| + | | flip | ''0b11000001'' | les quatre derniers bits sont inverses | | ||
| + | | all | ''false'' | les quatre derniers bits ne valent pas tous 1 | | ||
| + | | any | ''true'' | les quatre derniers bits contiennent au moins 1 | | ||
| + | | none | ''false'' | les quatre derniers bits ne valent pas 0 | | ||
| + | | count | ''3'' | il y a 3 bits a 1 dans les quatres derniers bits | | ||
| + | |||
| + | Les bits sur les quels est appliqués ou non les modifications sont appelés le masque. En pratique, il est possible de définir n'importe quelle séquence de bits dans un masque, vous n’êtes pas limités à définir une séquence continue comme dans l'exemple précédent. | ||
| + | |||
| + | Définir un masque est assez simple : il faut pouvoir définir pour chaque bit si celui-ci sera modifié (''true'') ou non (''false''). Un masque est donc en fait un ''std::bitset'', pour lequel vous affectez ''true'' aux bits qui seront pourront être modifiés. | ||
| + | |||
| + | Par exemple, dans l'exemple précédent, le masque est le ''std::bitset'' suivant : ''0b00001111''. | ||
| + | |||
| + | Pour appliquer le masque sur un ''std::bitset'', vous utilisez ensuite les opérateurs logiques bit à bit que vous avez déjà vu dans le chapitre [[logique_et_calcul_booleen|]] (en particulier "ET" et "OU") : | ||
| + | |||
| + | * "ET" ''&'' ("AND") ; | ||
| + | * "OU" ''|'' ("OR") ; | ||
| + | * "OU Exclusif" ''^'' ("XOR") ; | ||
| + | * "Negation" ''~'' ("NOT"). | ||
| + | |||
| + | Pour rappel, voici le tableau récapitulatif de ces opérateurs : | ||
| + | |||
| + | ^ ''a'' ^ ''b'' ^ ''~a'' ^ ''a & b'' ^ ''a | b'' ^ ''a ^ b'' ^ | ||
| + | | 0 | 0 | 1 | 0 | 0 | 0 | | ||
| + | | 0 | 1 | 1 | 0 | 1 | 1 | | ||
| + | | 1 | 0 | 0 | 0 | 1 | 1 | | ||
| + | | 1 | 1 | 0 | 1 | 1 | 0 | | ||
| Ligne 444: | Ligne 583: | ||
| * trouver la plus longue chaîne de 1 dans la représentation | * trouver la plus longue chaîne de 1 dans la représentation | ||
| - | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[valarray|Chapitre suivant]] ^ | + | Exercices avancés (nécessite de connaitre les classes) : |
| + | |||
| + | * créer une classe bitset_view | ||
| + | * créer une classe bitset_array_view | ||
| + | |||
| + | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[string_etendu|Chapitre suivant]] ^ | ||
bitset.1461146919.txt.gz · Dernière modification: 2016/04/20 12:08 par gbdivers
Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Noncommercial-Share Alike 3.0 Unported
