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/21 20:33] 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> | ||
| - | ==== L'operateur d'indexation [] ==== | + | ==== 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''. | 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''. | ||
| Ligne 363: | 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 381: | Ligne 383: | ||
| ==== Les fonctions test, set, reset et flip ==== | ==== Les fonctions test, set, reset et flip ==== | ||
| - | En complement de l'operateur d'indexation ''[]'', qui permet d'acceder aux bits d'un ''std::bitset'' en lecture ET en ecriture, la classe ''std::bitset'' propose egalement plusieurs fonctions plus specialisees, pour acceder aux bits en lecture OU en ecriture. | + | 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 difference importante est que ces fonctions verifient les acces 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. | + | <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 creation de bibliotheque, mais retenez que la verification systematique des acces est assimilee a de la programmation defensive, ce qui n'est pas forcement une bonne pratique.</note> | + | 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 : | Les fonctions sont les suivantes : | ||
| * ''test'' pour lire une valeur ; | * ''test'' pour lire une valeur ; | ||
| - | * ''set'' pour modifier une valeur (par defaut pour la mettre a ''true'') ; | + | * ''set'' pour modifier une valeur (par défaut pour la mettre à ''true'') ; |
| - | * ''reset'' pour mettre une valeur a ''false'' ; | + | * ''reset'' pour mettre une valeur à ''false'' ; |
| - | * ''flip'' pour inverser une valeur (c'est a dire que les bits valant ''true'' passent a ''false'' et vice-versa). | + | * ''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 a modifier. les fonctions ''set'', ''reset'' et ''flip'' peuvent egalement etre appelee 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 a modifier et la valeur booleene a definir. | + | 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> | <code cpp main.cpp> | ||
| Ligne 401: | Ligne 403: | ||
| int main() { | int main() { | ||
| - | std::bitset<8> b8; | + | std::bitset<8> b8 {}; |
| std::cout << b8 << std::endl; | std::cout << b8 << std::endl; | ||
| b8.set(3); | b8.set(3); | ||
| Ligne 478: | Ligne 480: | ||
| ===== Masquage et drapeau ===== | ===== Masquage et drapeau ===== | ||
| + | |||
| + | <note>Il est également possible d'utiliser les énumérations pour représenter des drapeaux.</note> | ||
| ==== Les drapeaux ==== | ==== Les drapeaux ==== | ||
| - | Qu'est ce que cela represente ? | + | 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. |
| + | |||
| + | 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> | ||
| + | |||
| + | <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. | ||
| + | |||
| + | <code cpp main.cpp> | ||
| + | #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> | ||
| - | forcer un bit : OU bit a bitque repr | ||
| ==== Le masquage ==== | ==== Le masquage ==== | ||
| - | Le masquage est un concept generique en informatique, qui consiste a definir un sous-ensemble sur lequel sera appliquer une modification (vous pouvez par exemple retrouver ce concept dans les masques de calque dans un logiciel de dessin telque Gimp). | + | 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 operations precedentes, vous obtiendrez : | + | 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 ^ | ^ Operation ^ Resultat ^ Commentaire ^ | ||
| Ligne 500: | Ligne 554: | ||
| | count | ''3'' | il y a 3 bits a 1 dans les quatres derniers bits | | | count | ''3'' | il y a 3 bits a 1 dans les quatres derniers bits | | ||
| - | Les bits sur les quels est applique ou non les modifications est appele le masque. En pratique, il est possible de definir n'importe quelle sequence de bits dans un masque, vous n'etes pas limites a definir une sequence continue comme dans l'exemple precedent. | + | 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. |
| - | Definir un masque est assez simple : il faut pouvoir definir pour chaque bit si celui-ci sera modifie (''true'') ou non (''false''). Un masque est donc en fait un ''std::bitset'', pour lequel vous affecter ''true'' aux bits qui seront pourront etre modifies. | + | 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 precedent, le masque est le ''std::bitset'' suivant : ''0b00001111''. | + | 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 operateurs logiques bit a bit que vous avez deja vu dans le chapitre [[logique_et_calcul_booleen|]] : | + | 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") ; | * "ET" ''&'' ("AND") ; | ||
| Ligne 513: | Ligne 567: | ||
| * "Negation" ''~'' ("NOT"). | * "Negation" ''~'' ("NOT"). | ||
| - | Pour rappel, voici le tableau recapitulatif de ces operateurs : | + | Pour rappel, voici le tableau récapitulatif de ces opérateurs : |
| ^ ''a'' ^ ''b'' ^ ''~a'' ^ ''a & b'' ^ ''a | b'' ^ ''a ^ b'' ^ | ^ ''a'' ^ ''b'' ^ ''~a'' ^ ''a & b'' ^ ''a | b'' ^ ''a ^ b'' ^ | ||
| Ligne 521: | Ligne 575: | ||
| | 1 | 1 | 0 | 1 | 1 | 0 | | | 1 | 1 | 0 | 1 | 1 | 0 | | ||
| - | |||
| - | |||
| - | |||
| - | |||
| - | |||
| - | tester un bit : mask, flag, opérateur ET bit à bit, test() | ||
| - | |||
| - | |||
| - | |||
| - | |||
| - | ===== Bit-shift ===== | ||
| ===== Exercices ===== | ===== Exercices ===== | ||
| Ligne 540: | 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 | ||
| - | Exercices avancees (necessite de connaitre les classes) : | + | Exercices avancés (nécessite de connaitre les classes) : |
| + | |||
| + | * créer une classe bitset_view | ||
| + | * créer une classe bitset_array_view | ||
| - | * creer une classe bitset_view | + | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[string_etendu|Chapitre suivant]] ^ |
| - | * creer une classe bitset_array_view | + | |
| - | ^ [[predicats|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[valarray|Chapitre suivant]] ^ | ||
bitset.1461263601.txt.gz · Dernière modification: 2016/04/21 20:33 par gbdivers
Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Noncommercial-Share Alike 3.0 Unported
