C++ Booleaans type

C Booleaans Type



C++ is de OOP-taal op hoog niveau die wordt gebruikt om voor verschillende doeleinden te ontwerpen. Het maakt programmeren leuker voor de programmeurs. Wanneer we in C++ werken, hebben we soms een resultaat nodig in de vorm waar of onwaar, daarom gebruiken we het “Booleaanse gegevenstype”. In C++ is een Booleaanse waarde een soort gegevenstype dat zowel ware als valse resultaten kan vertegenwoordigen. Programmeurs gebruiken het vaak om de omstandigheden te analyseren, beslissingen te nemen of de programma-uitvoering te reguleren. Het Booleaanse datatype wordt vaak gebruikt om vast te stellen of een bepaalde voorwaarde waar of onwaar is. Voor dit ‘Booleaanse gegevenstype’ gebruiken we het trefwoord ‘Bool’ in C++. Hier zullen we het “Booleaanse gegevenstype” in detail bestuderen en controleren hoe dit Booleaanse gegevenstype werkt in C++.

Voorbeeld 1:

Laten we nu enkele voorbeelden geven waarin we dit “Booleaanse gegevenstype” gebruiken en laten zien dat het werkt in C++. We beginnen onze code door de headerbestanden toe te voegen die we nodig hebben. Het eerste headerbestand dat we hier toevoegen is de “ ” die helpt bij het invoeren of uitvoeren van de gegevens. Hierna hebben we de “std” naamruimte; dit is de standaardnaam.

Hierna hebben we een drivercode, wat betekent dat we hier de functie “main()” toevoegen. Nu declareren we de variabele “isBulbOn” met het Booleaanse datatype “bool” en passen we hier “true” aan. Hieronder hebben we nog een Booleaanse variabele genaamd “isBulbOff”, waarin we “false” toevoegen. Dit waar en onwaar resultaat zijn respectievelijk “1” en “0”.







Om de uitvoer van deze Booleaanse waarden te controleren, drukken we ze eenvoudigweg af met behulp van de “cout”-instructie. In deze “cout”-verklaring drukken we eerst het “isBulbOn”-resultaat af. Vervolgens drukken we in de volgende regel het resultaat van de variabele “isBulbOff” af. De “endl” wordt hier gebruikt, zodat onze aanwijzer naar de volgende regel wordt verplaatst.



Code1:



#include
namespace std; gebruiken ;
int voornaamst ( )
{
bool isBulbOn = WAAR ;
bool isBulbOff = vals ;
uit << 'Het lampje brandt hier' << isBulbOn << eindl ;
uit << 'Het lampje brandt hier niet' << isBulbOff ;
}

Uitgang:





De uitvoer van deze code vertegenwoordigt het resultaat in de vormen “0” en “1”, zoals hieronder wordt weergegeven. Hier geeft “1” het “ware” resultaat aan, terwijl “0” het “onwaar” resultaat aangeeft. We verkrijgen dit resultaat alleen vanwege het gegevenstype ‘bool’.



Voorbeeld 2:

Nu declareren we twee variabelen, “Pass” en “Fail”, van het datatype “bool” in de main, nadat we het headerbestand aan het begin van deze code hebben opgenomen. De variabele “Pass” wordt hier toegewezen als “true” en de variabele “Fail” wordt toegewezen als “false”. Nu retourneert “Pass” als resultaat “1” en “Fail” retourneert “0”.

Nu gebruiken we deze bool-variabelen in onze “cout”-instructie om het waar of onwaar resultaat te krijgen in de vorm van “1” en “0”. De “cout” waar we “Pass” plaatsen, retourneert “1”. Waar we “Fail” gebruiken, retourneert “0”. Hier voegen we vijf “cout”-instructies toe, die elk de Booleaanse variabele bevatten.

Code2:

#include
namespace std; gebruiken ;
int voornaamst ( )
{
bool Pass = WAAR ;
bool Mislukt = vals ;
uit << 'Het percentage is 60' << Doorgang << eindl ;
uit << 'Het percentage bedraagt ​​45' << Mislukking << eindl ;
uit << 'Het percentage is 90' << Doorgang << eindl ;
uit << 'Het percentage bedraagt ​​85' << Doorgang << eindl ;
uit << 'Het percentage is 33' << Mislukking << eindl ;
}

Uitgang:

In deze uitvoer vertegenwoordigt “1” het “ware” resultaat, dat wil zeggen “Pass” en “0” vertegenwoordigt het “onwaar” resultaat, dat in dit geval “Mislukt” is.

Voorbeeld 3:

In deze code initialiseren we drie integer-variabelen, namelijk 'num_01', 'num_02' en 'a' met respectievelijk de waarde '45', '62' en '3'. Hierna declareren we nog drie variabelen – “b_01”, “b_02” en “b_03” – en dit zijn het Booleaanse datatype “bool”. Nu initialiseren we “b_01” met de voorwaarde “num_01 == num_01”. Vervolgens initialiseren we “b_02” en “b_03” op dezelfde manier als “b_01”.

Nadat we alle variabelen hebben geïnitialiseerd, drukken we ze afzonderlijk af met behulp van “cout” om het resultaat van deze Booleaanse variabelen te controleren. Hierna initialiseren we de variabele “b_a” van het gegevenstype “bool” met “true”. Vervolgens gebruiken we hier de “if”-instructie, waarbij we “b_a” als voorwaarde plaatsen. Als deze “b_a”-voorwaarde nu waar is, wordt de instructie na “if” uitgevoerd. Anders wordt het “else”-gedeelte hier uitgevoerd. Hierna gaan we verder en initialiseren we de geheel getalvariabele 'num', waarin we enkele wiskundige bewerkingen toepassen en het resultaat 'num' weergeven.

Code 3:

#include
namespace std; gebruiken ;
int voornaamst ( )
{
int num_01 = Vier vijf , num_02 = 62 , A = 3 ;
bool b_01 , b_02 , b_03 ;
b_01 = num_01 == num_01 ;
b_02 = num_01 == num_02 ;
b_03 = num_02 > num_01 ;

uit << 'Het antwoord van de eerste Bool b_01 is = ' <<
b_01 << eindl ;
uit << 'Het antwoord van tweede Bool b_02 is = ' <<
b_02 << eindl ;
uit << 'Het antwoord van derde Bool b_03 is = ' <<
b_03 << eindl ;
bool b_a = WAAR ;
als ( b_a )
uit << 'Ja' << eindl ;
anders
uit << 'Nee' << eindl ;
int op een = vals + 7 * A - b_a + WAAR ;
uit << op een ;
opbrengst 0 ;
}

Uitgang:

Deze uitkomst toont de resultaten van de bewerkingen die we in onze code hebben uitgevoerd. Op deze manier gebruiken we dit “Booleaanse gegevenstype” in onze C++-codes.

Voorbeeld 4:

Hier typen we ‘isHotDay’ als een ‘bool’-variabele en initialiseren we deze met ‘false’. Nu gebruiken we de “if”-instructie en geven we “isHotDay” door als voorwaarde. De instructie die volgt op “if” wordt nu uitgevoerd als aan de voorwaarde “isHotDay” is voldaan. Anders wordt het gedeelte 'else' op dit punt uitgevoerd.

Nu hebben we de Booleaanse variabele 'DoTask' en stellen deze in op 'true'. Bovendien initialiseren we ook de “int” variabele met de naam “Task_count”. Hierna plaatsen we de lus “while()”. In deze “while()”-lus plaatsen we “DoTask” als voorwaarde. Binnen de while-lus schrijven we 'Task_count++', waardoor de waarde van 'Task_count' met 1 wordt verhoogd.

Wanneer deze instructie wordt uitgevoerd, wordt de waarde van “Task_count” met 1 verhoogd. Vervolgens wordt de volgende “cout”-instructie uitgevoerd. Hierna plaatsen we opnieuw een voorwaarde die “Task_count < 9” is en wijzen deze voorwaarde toe aan de variabele “DoTask”. Deze lus werkt totdat de “Task_count” kleiner is dan “9”.

Code 4:

#include
namespace std; gebruiken ;
int voornaamst ( ) {
bool isHotDay = vals ;
als ( isHotDay ) {
uit << 'Het is een hete dag!' << eindl ;
} anders {
uit << 'Het is geen warme dag' << eindl ;
}
bool DoTask = WAAR ;
int Taakaantal = 0 ;
terwijl ( Doe de taak ) {
Taakaantal ++;
uit << 'Taak is hier doorgaan' << Taakaantal << eindl ;
Doe de taak = ( Taakaantal < 9 ) ;
}
opbrengst 0 ;
}

Uitgang:

Deze uitvoer toont het resultaat van elke actie die we door onze code hebben uitgevoerd. Daarom gebruiken we dit “Booleaanse gegevenstype” ook op deze manier in onze C++-codes.

Voorbeeld 5:

Nu gaan we naar het laatste voorbeeld van deze tutorial. Hier nemen we drie unieke Booleaanse variabelen en drukken beide af. Hierna passen we de operatoren “AND”, “OR” en “NOT” toe op deze Booleaanse variabelen. Bovendien wordt het resultaat van alle bewerkingen in de Booleaanse vorm opgeslagen, omdat we “bool” hebben toegevoegd aan alle variabelen waarin het resultaat van deze bewerkingen is opgeslagen. Hierna drukken we de uitkomst van deze bewerkingen opnieuw af in Boolean.

Code 5:

#include
namespace std; gebruiken ;
int voornaamst ( )
{
boolwaarde_1 = WAAR ;
boolwaarde_2 = vals ;
boolwaarde_3 = WAAR ;

uit << 'waarde_1 is ' << waarde_1 << eindl ;
uit << 'waarde_2 is ' << waarde_2 << eindl ;
uit << 'waarde_3 is ' << waarde_3 << eindl << eindl ;

bool uitkomst_1 = ( waarde_1 || waarde_3 ) && waarde_1 ;
bool uitkomst_2 = waarde_1 && waarde_2 ;
bool uitkomst_3 = waarde_2 || waarde_3 ;
bool uitkomst_4 = ! waarde_3 ;
bool uitkomst_5 = ! waarde_2 ;
bool uitkomst_6 = ! waarde_1 ;

uit << 'Het resultaat 1 is = ' << uitkomst_1 << eindl ;
uit << 'Het resultaat 2 is = ' << uitkomst_2 << eindl ;
uit << 'Het resultaat 3 is = ' << uitkomst_3 << eindl ;
uit << 'Het resultaat 4 is = ' << uitkomst_4 << eindl ;
uit << 'Het resultaat 5 is = ' << uitkomst_5 << eindl ;
uit << 'Het resultaat 6 is = ' << uitkomst_6 << eindl ;
}

Uitgang:

Hier is de uitkomst. Het valt ons wellicht op dat het resultaat van elke bewerking wordt weergegeven in de vorm van “0” en “1”, omdat het gegevenstype “Bool” wordt gebruikt.

Conclusie

In deze tutorial hebben we laten zien hoe het Booleaanse gegevenstype wordt gebruikt in C++ en wat de uitkomst van het Booleaanse gegevenstype is. We hebben de voorbeelden onderzocht waarin we dit Booleaanse gegevenstype hebben gebruikt. We hebben gezien dat dit Booleaanse gegevenstype effectief en eenvoudig is, maar dat het essentieel is om het zorgvuldig te gebruiken om fouten te voorkomen.