Vous avez vu dans les chapitres précédents comment utiliser les booléens et les opérations de base : ET, OU, NON et OU-EXCLUSIF. En fait, l'utilisation des booléens est plus riche et complexe que cela. Ils sont à la base d'une branche des mathématiques, appelée Algèbre de Boole, en l'honneur de son créateur, le mathématicien George Boole.

Avoir des bonnes bases avec cet algèbre est important pour tous les développeurs, et plus encore pour les développeurs C++, c'est pourquoi nous allons voir cela plus en détail.

Pour rappel, un booléen est une variable logique, qui peut prendre deux valeurs. Peu importe comment sont nommées ces valeurs, vous rencontrer parfois : “vrai” et “faux”, “oui” et “non”, “haut” et “bas”, “positif” et “négatif”, 0 et 1, “Titi” et “Grosminet”, etc.

Le C++ utilise les mots-clés true (vrai) et false (faux) pour représenter les booléens.

Certaines valeurs dans la liste ont un sens historique. En particulier, “vrai” et “faux” correspond au fait que les booléens représentent le résultat d'une proposition logique. Par exemple “la terre est plus grosse que le soleil”, “l'homme court plus vite que

En C++, une proposition logique (que l'on appelle aussi expression logique) sera écrite en utilisant les opérateurs logiques (que vous avez déjà vu) :

Pour rappel, voici la table de vérité de ces opérateurs (elle est redonnée pour vous éviter de retourner dans le chapitre Logique binaire et calcul booléen, mais il faudra la connaitre par cœur par la suite. Mais pas d’inquiétude, vous la connaîtrez à force de l'utiliser) :

L’algèbre de Boole définie un certains nombres de propriétés. Il est assez facile d’écrire un code C++ pour les vérifier. Un code d'exemple est donné pour la première propriété, vous devrais écrire les codes C++ correspondant aux autres propriétés comme exercices.

Commutativité

La commutativité signifie que l'on peut changer l'ordre des valeurs (opérandes) dans une expression, sans changer le résultat. Cette propriété est valide pour les opérateurs binaires (qui prennent deux opérandes, donc les opérateurs ET et OU), mais pas pour NON (opérateur unaire, qui prend qu'une opérande).

En utilisant une écriture plus formelle, on peut donc écrire :

$$ \text{A} ~ \text{ET} ~ \text{B} \iff \text{B} ~ \text{ET} ~ \text{A} $$ $$ \text{A} ~ \text{OU} ~ \text{B} \iff \text{B} ~ \text{OU} ~ \text{A} $$

On peut vérifier cela en écrivant la table de vérité correspondant aux deux expressions :

Vérifions cela avec un code C++ :

main.cpp

#include <iostream>
 
int main() {
    std::cout << "(A ET B) est équivalent à (B ET A), pour A faux et B faux ? " <<
        std::boolalpha << ((false && false) == (false && false)) << std::endl;
        //                    A   ET   B          B   ET   A
}

affiche :

(A ET B) est équivalent à (B ET A), pour A faux et B faux ? true

Exercice : écrire les trois autres lignes, correspondant a A vrai et B faux, a A faux et B vrai et a A vrai et B vrai.

Associativité

Propriétés :

• commutativité : a && b == b && a; a || b == b || a
• associativité : (a && b) && c == a && (b && c); (a || b) || c == a || (b || c)
• distributivité : (a && b) || c == (a || c) && (b || c); (a || b) && c == (a && c) || (b && c)
• idempotence : a && a && a == a; a || a || a == a
• éléments neutres : a && true == a; a || false == a
• absorption : a && false = false; a || true == true
• complémentarité : a == !!a; a && !a == false; a || !a == true

Permet de simplifier graphiquement des expressions booléennes

http://fr.wikipedia.org/wiki/Table_de_Karnaugh

Deux lois permettent de simplifier des expressions booléennes de façon formelle.

• !(a && b) == !a || !b
• !(a || b) == !a && !b

Autres fonctions logiques classiques

• NOR
• NAND
• XNOR
• OU exclusif : a XOR b == (a && !b) || (!a && b)

Il est possible d'écrire des opérations logiques complexes, à 2 ou plus arguments, avec les opérateurs de base NON, ET, OU et OU EXCLUSIF.

• Ecrire les séries suivantes : ???

• En particulier, NON-ET permet de réécrire tous les autres opérateurs. Le faire.

• multiplexer
• additionner
• soustracteur
• multiplicateur