Type booléen C++

Type Booleen C



C++ est le langage POO de haut niveau utilisé pour concevoir à diverses fins. Cela rend la programmation plus agréable pour les programmeurs. Lorsque nous travaillons en C++, nous avons parfois besoin d'un résultat sous forme vraie ou fausse, nous utilisons donc le « type de données booléen ». En C++, un booléen est une sorte de type de données qui peut représenter des résultats vrais ou faux. Les programmeurs l'utilisent fréquemment pour analyser les conditions, prendre des décisions ou réguler l'exécution du programme. Le type de données booléen est fréquemment utilisé pour déterminer si une condition donnée est vraie ou fausse. Pour ce « type de données booléen », nous utilisons le mot-clé « Bool » en C++. Ici, nous étudierons en détail le « type de données booléen » et vérifierons comment ce type de données booléen fonctionne en C++.

Exemple 1:

Maintenant, réalisons quelques exemples dans lesquels nous utilisons ce « type de données booléen » et montrons qu'il fonctionne en C++. Nous commençons notre code en ajoutant les fichiers d'en-tête dont nous avons besoin. Le premier fichier d'en-tête que nous ajoutons ici est le «   » qui facilite la saisie ou la sortie des données. Après cela, nous avons l'espace de noms « std » ; c'est le nom standard.

Après cela, nous avons un code de pilote ce qui signifie que nous ajoutons ici la fonction « main() ». Maintenant, nous déclarons la variable « isBulbOn » avec le type de données booléen « bool » et ajustons « true » ici. En dessous, nous avons une autre variable booléenne nommée « isBulbOff » dans laquelle nous ajoutons « false ». Ces résultats vrai et faux sont respectivement « 1 » et « 0 ».







Pour vérifier la sortie de ces valeurs booléennes, nous les imprimons simplement à l'aide de l'instruction « cout ». Dans cette instruction « cout », nous imprimons d'abord le résultat « isBulbOn ». Ensuite, dans la ligne suivante, nous imprimons le résultat de la variable « isBulbOff ». Le « endl » est utilisé ici pour déplacer notre pointeur vers la ligne suivante.



Codage 1 :



#include
en utilisant l'espace de noms std ;
int principal ( )
{
bool isBulbOn = vrai ;
bool estBulbOff = FAUX ;
cout << 'L'ampoule est allumée ici' << estBulbOn << fin ;
cout << 'L'ampoule n'est pas allumée ici' << estBulbOff ;
}

Sortir:





La sortie de ce code représente le résultat sous les formes « 0 » et « 1 », comme indiqué ci-dessous. Ici, « 1 » indique le « vrai » résultat tandis que « 0 » indique le « faux » résultat. Nous obtenons ce résultat uniquement grâce au type de données « bool ».



Exemple 2 :

Maintenant, nous déclarons deux variables, « Pass » et « Fail », du type de données « bool » à l'intérieur du main après avoir inclus le fichier d'en-tête au début de ce code. La variable « Réussite » est ici affectée à « vrai » et la variable « Échec » est affectée à « faux ». Désormais, « Pass » renvoie « 1 » et « Fail » renvoie « 0 ».

Maintenant, nous utilisons ces variables booléennes dans notre instruction « cout » pour obtenir le résultat vrai ou faux sous la forme de « 1 » et « 0 ». Le « cout » où l’on met « Pass » renvoie « 1 ». Là où nous utilisons « Échec », renvoie « 0 ». Ici, nous ajoutons cinq instructions « cout », chacune contenant la variable booléenne.

Code 2 :

#include
en utilisant l'espace de noms std ;
int principal ( )
{
booléen Passe = vrai ;
booléen Échec = FAUX ;
cout << 'Le pourcentage est de 60' << Passer << fin ;
cout << 'Le pourcentage est de 45' << Échouer << fin ;
cout << 'Le pourcentage est de 90' << Passer << fin ;
cout << 'Le pourcentage est de 85' << Passer << fin ;
cout << 'Le pourcentage est de 33' << Échouer << fin ;
}

Sortir:

Dans cette sortie, « 1 » représente le « vrai » résultat qui est « Réussite » et « 0 » représente le résultat « faux » qui est « Échec » dans ce cas.

Exemple 3 :

Dans ce code, nous initialisons trois variables entières qui sont « num_01 », « num_02 » et « a » avec la valeur de « 45 », « 62 » et « 3 », respectivement. Après cela, nous déclarons trois autres variables – « b_01 », « b_02 » et « b_03 » – et ce sont le type de données booléen « bool ». Maintenant, nous initialisons « b_01 » avec la condition « num_01 == num_01 ». Ensuite, nous initialisons « b_02 » et « b_03 » de la même manière que « b_01 ».

Après avoir initialisé toutes les variables, nous les imprimons séparément en utilisant « cout » pour vérifier le résultat de ces variables booléennes. Après cela, nous initialisons la variable « b_a » du type de données « bool » avec « true ». Ensuite, nous utilisons ici l'instruction « if » où nous plaçons « b_a » comme condition. Maintenant, si cette condition « b_a » est vraie, l'instruction après « if » est exécutée. Sinon, la partie « else » s'exécutera ici. Après cela, nous procédons et initialisons la variable entière « num » dans laquelle nous appliquons certaines opérations mathématiques et affichons le résultat « num ».

Code 3 :

#include
en utilisant l'espace de noms std ;
int principal ( )
{
int num_01 = Quatre cinq , num_02 = 62 , un = 3 ;
booléen b_01 , b_02 , b_03 ;
b_01 = num_01 == num_01 ;
b_02 = num_01 == num_02 ;
b_03 = num_02 > num_01 ;

cout << 'La réponse du premier Bool b_01 est = ' <<
b_01 << fin ;
cout << 'La réponse du deuxième Bool b_02 est = ' <<
b_02 << fin ;
cout << 'La réponse du troisième Bool b_03 est = ' <<
b_03 << fin ;
boo b_a = vrai ;
si ( b_a )
cout << 'Oui' << fin ;
autre
cout << 'Non' << fin ;
int sur une = FAUX + 7 * un - b_a + vrai ;
cout << sur une ;
retour 0 ;
}

Sortir:

Ce résultat montre les résultats des opérations que nous avons exécutées dans notre code. Ainsi, nous utilisons ce « type de données booléen » dans nos codes C++.

Exemple 4 :

Ici, nous tapons « isHotDay » comme variable « bool » et l'initialisons avec « false ». Maintenant, nous utilisons l'instruction « if » et passons « isHotDay » comme condition. L'instruction qui suit « if » est désormais exécutée si la condition « isHotDay » est satisfaite. Sinon, la partie « else » s'exécutera à ce stade.

Maintenant, nous avons la variable booléenne « DoTask » et la définissons sur « true ». De plus, nous initialisons également la variable « int » nommée « Task_count ». Après cela, nous plaçons la boucle « while() ». Dans cette boucle « while() », nous mettons « DoTask » comme condition. Dans la boucle while, nous écrivons « Task_count++ » qui incrémente la valeur de « Task_count » de 1.

Lorsque cette instruction est exécutée, la valeur de « Task_count » augmente de 1. Ensuite, l'instruction « cout » suivante est exécutée. Après cela, nous plaçons à nouveau une condition qui est « Task_count < 9 » et attribuons cette condition à la variable « DoTask ». Cette boucle fonctionne jusqu'à ce que « Task_count » soit inférieur à « 9 ».

Code 4 :

#include
en utilisant l'espace de noms std ;
int principal ( ) {
bool estHotDay = FAUX ;
si ( estHotDay ) {
cout << 'C'est une chaude jounée!' << fin ;
} autre {
cout << 'Ce n'est pas une journée chaude' << fin ;
}
booléen DoTask = vrai ;
int Nombre_de tâches = 0 ;
alors que ( Faire une tâche ) {
Nombre_de tâches ++ ;
cout << 'La tâche continue ici' << Nombre_de tâches << fin ;
Faire une tâche = ( Nombre_de tâches < 9 ) ;
}
retour 0 ;
}

Sortir:

Cette sortie affiche le résultat de chaque action que nous avons exécutée dans notre code. Ainsi, nous utilisons également ce « type de données booléen » dans nos codes C++ de cette manière.

Exemple 5 :

Passons maintenant au dernier exemple de ce tutoriel. Ici, nous prenons trois variables booléennes uniques et imprimons les deux. Après cela, nous appliquons les opérateurs « ET », « OU » et « NON » sur ces variables booléennes. De plus, le résultat de toutes les opérations est stocké sous forme booléenne car nous avons ajouté « bool » avec toutes les variables dans lesquelles le résultat de ces opérations est stocké. Après cela, nous imprimons à nouveau le résultat de ces opérations en booléen.

Code 5 :

#include
en utilisant l'espace de noms std ;
int principal ( )
{
valeur booléenne_1 = vrai ;
valeur booléenne_2 = FAUX ;
valeur booléenne_3 = vrai ;

cout << 'la valeur_1 est' << valeur_1 << fin ;
cout << 'la valeur_2 est' << valeur_2 << fin ;
cout << 'la valeur_3 est' << valeur_3 << fin << fin ;

résultat booléen_1 = ( valeur_1 || valeur_3 ) && valeur_1 ;
résultat booléen_2 = valeur_1 && valeur_2 ;
résultat booléen_3 = valeur_2 || valeur_3 ;
résultat booléen_4 = ! valeur_3 ;
résultat booléen_5 = ! valeur_2 ;
résultat booléen_6 = ! valeur_1 ;

cout << 'Le résultat 1 est = ' << résultat_1 << fin ;
cout << 'Le résultat 2 est = ' << résultat_2 << fin ;
cout << 'Le résultat 3 est = ' << résultat_3 << fin ;
cout << 'Le résultat 4 est = ' << résultat_4 << fin ;
cout << 'Le résultat 5 est = ' << résultat_5 << fin ;
cout << 'Le résultat 6 est = ' << résultat_6 << fin ;
}

Sortir:

Voici le résultat. Nous pourrions remarquer que le résultat de chaque opération est affiché sous la forme de « 0 » et « 1 » car le type de données « bool » est utilisé.

Conclusion

Dans ce didacticiel, nous avons démontré comment le type de données booléen est utilisé en C++ et quel est le résultat du type de données booléen. Nous avons exploré les exemples dans lesquels nous avons utilisé ce type de données booléen. Nous avons vu que ce type de données booléen est efficace et simple, mais il est essentiel de l'utiliser avec précaution pour éviter les erreurs.