HOWTO · C++

Impression de valeurs booléennes en C++

Cet article parle de l'impression d'une représentation textuelle des valeurs booléennes en C++.

Sur cette page

Par défaut, C++ imprime une valeur booléenne sous la forme 1 pour true et 0 pour false. Cela convient aux machines, mais lorsque vous parcourez des journaux ou une sortie de débogage, un 1 ou un 0 isolé est facile à mal interpréter, tandis que true et false indiquent au lecteur exactement ce que le programme voulait dire.

Cet article présente trois façons d’imprimer des valeurs booléennes sous forme de texte en C++ : une expression conditionnelle avec printf, le manipulateur de flux std::boolalpha, et une facette std::numpunct personnalisée pour des mots autres que true et false.

Pourquoi C++ imprime les valeurs booléennes sous la forme 0 et 1

std::cout formate un bool avec le même mécanisme numérique que celui qu’il utilise pour les entiers. Tant que vous ne modifiez pas les drapeaux de formatage du flux, true s’écrit 1 et false s’écrit 0. La famille printf se comporte de manière similaire : un bool est promu en int lorsqu’il est passé via ..., de sorte que %d imprime également 1 ou 0.

La sortie numérique est compacte, mais un chiffre isolé disparaît facilement dans une mer de nombres et de lignes de journaux. Imprimer les mots true et false rend l’état du programme auto-descriptif, c’est pourquoi chaque méthode ci-dessous vise un texte lisible.

Imprimer du texte booléen avec printf et une expression conditionnelle

printf n’a pas de spécificateur de format booléen, et l’argument est promu en int, donc %d ne peut produire que 1 ou 0. La solution standard consiste à passer au spécificateur %s et à sélectionner le texte vous-même avec une expression conditionnelle (ternaire) : value ? "true" : "false".

Le programme suivant imprime la même valeur des deux façons :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <cstdio>

int main() {
  bool ready = true;

  std::printf("numeric: %d\n", ready);
  std::printf("text: %s\n", ready ? "true" : "false");
  std::printf("text: %s\n", false ? "true" : "false");

  return 0;
}
numeric: 1
text: true
text: false

Cela fonctionne partout où printf est utilisé et ne nécessite aucun état de flux, mais répéter la conditionnelle à chaque site d’appel ajoute du bruit dans un fichier source volumineux, et rien ne garantit que les chaînes choisies restent cohérentes d’un appel à l’autre.

Utiliser std::boolalpha avec les flux C++

std::boolalpha est un manipulateur de flux qui active le drapeau de formatage booléen du flux afin que les valeurs bool s’impriment comme true et false au lieu de 1 et 0. Il fonctionne sur les flux d’entrée et de sortie et est déclaré dans <ios>, que <iostream> inclut déjà.

Deux propriétés comptent en pratique :

  • Le drapeau persiste. Une fois std::boolalpha inséré, chaque bool inséré ensuite dans ce flux s’imprime sous forme de texte jusqu’à ce que vous reveniez en arrière.
  • std::noboolalpha est le manipulateur correspondant qui restaure la représentation numérique.

Le programme suivant montre les deux états :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iostream>

int main() {
  std::cout << "default: " << true << " / " << false << "\n";

  std::cout << std::boolalpha;
  std::cout << "boolalpha: " << true << " / " << false << "\n";

  std::cout << std::noboolalpha;
  std::cout << "restored: " << true << " / " << false << "\n";

  return 0;
}
default: 1 / 0
boolalpha: true / false
restored: 1 / 0

Parce que le drapeau persiste sur le flux, n’oubliez pas qu’il s’applique à chaque bool imprimé ensuite — insérez std::noboolalpha lorsque la sortie suivante doit rester numérique. Notez également que std::boolalpha ne produit que les noms de la locale pour les deux valeurs, par défaut true et false. Pour des mots différents, il faut l’approche par facette de la section suivante.

Personnaliser le texte booléen avec une facette std::numpunct

Les mots qu’un flux utilise pour true et false proviennent de la facette std::numpunct de la locale du flux. Les opérations de sortie de flux passent par std::numput, qui demande à cette facette les noms booléens via ses membres do_truename() et do_falsename(). Dériver votre propre facette et imprégner le flux d’une locale qui la contient remplace ces noms tant que std::boolalpha est actif.

Le programme suivant installe une facette qui fournit ses propres mots :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iostream>
#include <locale>
#include <string>

class named_bool : public std::numpunct<char> {
 protected:
  std::string do_truename() const override { return "Hai"; }
  std::string do_falsename() const override { return "NAI"; }
};

int main() {
  std::cout.imbue(std::locale(std::locale(), new named_bool));
  std::cout << std::boolalpha;

  std::cout << "custom true: " << true << "\n";
  std::cout << "custom false: " << false << "\n";

  return 0;
}
custom true: Hai
custom false: NAI

Les chaînes Hai et NAI sont des littéraux fournis par la facette elle-même — rien n’est traduit automatiquement ; le flux imprime simplement ce que do_truename() et do_falsename() renvoient. L’allocation new named_bool ne fuit pas non plus : les objets facettes sont comptés par référence et sont détruits lorsque le dernier std::locale qui les référence sort de portée.

Cette approche ne prend effet que tant que std::boolalpha est activé ; sans lui, le flux imprime toujours 1 et 0. C’est aussi celle qui demande le plus de machinerie des trois — une classe dérivée, deux surcharges et un appel à imbue — réservez-la donc aux cas où un libellé personnalisé est réellement nécessaire.

Choisir la bonne approche

  • Pour une ou deux valeurs dans du code de style C, printf avec value ? "true" : "false" est le plus petit changement, mais il répète la logique de sélection à chaque site d’appel.
  • Pour la sortie iostream, std::boolalpha est la correction idiomatique ; associez-le à std::noboolalpha lorsque la sortie bool suivante doit revenir à 1/0.
  • Lorsque les mots eux-mêmes doivent changer — une capitalisation comme True/False ou une paire personnalisée telle que Hai/NAI — une facette std::numpunct associée à une locale imprégnée est la seule option des trois, puisqu’elle redéfinit ce que std::boolalpha imprime.

Choisissez l’outil le plus simple qui couvre votre besoin de formatage : une expression conditionnelle pour une valeur unique, std::boolalpha pour la sortie en flux, et une facette uniquement lorsque des noms booléens personnalisés sont requis.