|
Introduction to Conditional Statements
|
|
When programming, you will ask the computer to check various
kinds of situations and to act accordingly. The computer performs various
comparisons of various kinds of statements. These statements come either from
you or from the computer itself, while it is processing internal assignments.
Let’s imagine you are writing an employment application
and one question would be, "Do you consider yourself a hot-tempered
individual?" The source file of such a program would look like this:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
cout << "Do you consider yourself a hot-tempered individual? ";
cin >> Answer;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Some of the answers a user would type are y, yes, Y,
Yes, YES, n, N, no, No, NO, I don’t know, Sometimes, Why are you
asking?, and What do you mean? The variety of these different answers
means that you should pay attention to how you structure your programs,
you should be clear to the users.
A better version of the line that asks the question
would be:
cout << "Do you consider yourself a hot-tempered individual? (y=Yes/n=No)";
This time, although the user can still type
anything, at least you have specified the expected answers.
|
 |
There are three entities that participate on a
traffic light: the lights, the human beings who interact with the light,
and the law. The road provides a platform on which these components come
together.
The Traffic Light
Everything taken into consideration, a traffic light is made of three
light colors: Green – Yellow/Orange – Red. When the light is green,
the road is clear for moving in. The red light signals to stop and wait.
A yellow light means, “Be careful, it is not safe to proceed right
now. Maybe you should wait.” When it is not blinking, the yellow light
usually serves as a transition period from green to red. There is no
transition from red to green.
The Drivers
There are two main categories of people who deal with the traffic light:
the drivers and the walkers. To make our discussion a little simpler, we
will consider only the driver. When the light is green, a driver can
drive through. When the light is red, the driver is required to stop and
wait.
The Law
Rules and regulations dictate that when a driver does not obey the law
by stopping to a red light, he is considered to have broken the law and
there is a consequence.
|
|
The most independent of the three entities is the
traffic light. It does not think, therefore it does not make mistakes.
It is programmed with a timer or counter that directs it when to act,
that is, when to change lights. The second entity, the driver, is a
human being who can think and make decisions based on circumstances that
are beyond human understanding. A driver can decide to stop at a green
light or drive through a red light…
A driver who proceeds through a red light can get a
ticket depending on one of two circumstances: either a police officer
caught her “hand-in-the-basket” or a special camera took a picture.
Worse, if an accident happens, this becomes another story.
The traffic light is sometimes equipped with a timer
or counter. We will call it Timer T. It is equipped with three lights:
Green, Yellow, and Red. Let’s suppose that the light stays green for
45 seconds, then its turns and stays yellow for 5 seconds, and finally
it turns and stays red for 1 minute = 60 seconds. At one moment in the
day, the timer is set at the beginning or is reset and the light is
green: T = 0. Since the timer is working fine, it starts counting the
seconds 1, 2, 3, 4, … 45. The light will stay green from T = 0 to T =
45. When the timer reaches 45, the timer is reset to 0 and starts
counting from 0 until it reaches 5; meanwhile, Color = Yellow.
|
|
Practical Learning: Introduction to Conditional Statements
|
|
- Create a new console application using the Console Wizard
- Save the project in a new folder named Traffic
Light1
- Save the unit as Main.cpp and
save the project as Traffic1
- To apply what we have learned, change the file as follows:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Light;
cout << "What is the current light color(g=Green/y=Yellow/r=Red)? ";
cin >> Light;
cout << "\nThe current color of the light is " << Light << "\n\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program and return to Bcb
|
|
In C++, comparisons are made from a statement.
Examples of statements are:
- "You are 12 years old"
- "It is raining outside"
- You live in Sydney"
When a driver comes to a traffic light, the first
thing she does is to examine the light's color. There are two values the
driver would put together: The current light of the traffic and the
desired light of the traffic.
Upon coming to the traffic light, the driver would
have to compare the traffic light variable with a color she desires the
traffic light to have, namely the green light (because if the light is
green, then the driver can drive through). The comparison is performed
by the driver making a statement such as "The light is green".
After making a statement, the driver evaluates it
and compares it to what must be true.
When a driver comes to a traffic light, she would
likely expect the light to be green. Therefore, if the light is green
(because that is what she is expecting), the result of her examination
would receive the Boolean value of TRUE. This produces the following
table:
| Color |
Statement |
Boolean
Value |
 |
The light is green |
true |
|
One of the comparisons the computer performs is to find out if a
statement is true (in reality, programmers (like you) write these
statements and the computer only follows your logic). If a statement is
true, the computer acts on a subsequent instruction.
The comparison using the if statement is used
to check whether a condition is true or false. The syntax to use it is:
if(Condition) Statement;
If the Condition is true, then the compiler
would execute the Statement. The compiler ignores anything else:
|
|
|
If the statement to execute is (very) short, you can
write it on the same line with the condition that is being checked.
Consider a program that is asking a user to answer
Yes or No to a question such as "Are you ready to provide your
credit card number?". A source file of such a program could look
like this:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
// Request the availability of a credit card from the user
cout << "Are you ready to provide your credit card number(1=Yes/0=No)? ";
cin >> Answer;
// Since the user is ready, let's process the credit card transaction
if(Answer == '1')cout << "\nNow we will need your credit card number.\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
You can write the if condition and the
statement on different lines; this makes your program easier to read.
The above code could be written as follows:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
// Request the availability of a credit card from the user
cout << "Are you ready to provide your credit card number(1=Yes/0=No)? ";
cin >> Answer;
// Since the user is ready, let's process the credit card transaction
if(Answer == '1')
cout << "\nNow we will get your credit card information.\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
You can also write the statement on its own line if
the statement is too long to fit on the same line with the condition.
Although the (simple) if statement is used to
check one condition, it can lead to executing multiple dependent
statements. If that is the case, enclose the group of statements between
an opening curly bracket “{“ and a closing curly bracket “}”.
Here is an example:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
string CreditCardNumber;
// Request the availability of a credit card from the user
cout << "Are you ready to provide your credit card number(1=Yes/0=No)? ";
cin >> Answer;
// Since the user is ready, let's process the credit card transaction
if(Answer == '1')
{
cout << "\nNow we will continue processing the transaction.";
cout << "\nPlease enter your credit card number without spaces: ";
cin >> CreditCardNumber;
}
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
If you omit the brackets, only the statement that
immediately follows the condition would be executed.
When studying logical operators, we found out that
if a comparison produces a true result, it in fact produces a non zero
integral result. When a comparison leads to false, its result is
equivalent to 0. You can use this property of logical operations and
omit the comparison if or when you expect the result of the comparison
to be true, that is, to bear a valid value. This is illustrated in the
following program:
|
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number;
cout << "Enter a non zero number: ";
cin >> Number;
if(Number)
cout << "\nYou entered " << Number << endl;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Practical Learning: The if Statement
|
|
- To apply the if condition to our traffic light study, click
on the right side of the cin>> Light line and press Enter
twice.
- Change the line to display:
if ( Light == 'g' ) cout << "You can proceed and drive through.";
|
- Test the program.
- When prompted, test the program by typing g and press
Enter. Notice the sentence that is displaying.
- Press any key to get back.
- Test the program again. This time, type anything else but g
and press Enter. Notice that nothing particular displays.
- Return to your programming environment.
- To send the statement to the next line, change the file as
follows:
if( Light == 'g' )
cout << "You can proceed and drive through.";
|
- Test the program and return to your programming environment.
- To process more than one statement for the if condition, change
the if section as follows:
if( Light == 'g' )
{
cout << "\nThe light is green";
cout << "\nYou can proceed and drive through.\n";
}
|
- Test the program and return to your programming environment.
- Save your project.
|
|
When a driver comes to a light that he expects to be
green, we saw that he would use a statement such as, "The light is
green". If in fact the light is green, we saw that the statement
would lead to a true result. If the light is not green, the "The
light is green" statement produces a false result. This is shown in
the following table:
| Color |
Statement |
Boolean
Value |
|
The light is green |
true |
 |
The light is green |
false |
|
As you may realize already, in Boolean algebra, the result of performing
a comparison depends on how the Condition is formulated. If the
driver is approaching a light that he is expecting to display any color
other than green, he would start from a statement such as "The
light is not green". If the light IS NOT green, the
expression "The light is not green" is true (very important).
This is illustrated in the following table:
| Color |
Statement |
Boolean
Value |
|
The light is green |
true |
 |
The light is not green |
true |
|
The "The light is not green" statement is expressed in Boolean
algebra as “Not the light is green”. Instead of writing “Not the
light is green", in C++, using the logical Not operator , you would
formulate the statement as, !"The light is green". Therefore,
if P means “The light is green”, you can express the negativity of P
as !P. The Boolean table produced is:
| Color |
Statement |
Boolean
Value |
Symbol |
|
The light is green |
true |
P |
|
The light is not green |
false |
!P |
|
When a statement is true, its Boolean value is
equivalent to a non-zero integer such as 1. Otherwise, if a statement
produces a false result, it is given a 0 value. Therefore, our table
would be:
| Color |
Statement |
Boolean
Value |
Integer
Value |
|
The light is green |
true |
1 |
|
The light is not green |
false |
0 |
|
|
|
The if condition is used to check one
possibility and ignore anything else. Usually, other conditions should
be considered. In this case, you can use more than one if statement. For
example, on a program that asks a user to answer Yes or No, although the
positive answer is the most expected, it is important to offer an
alternate statement in case the user provides another answer. Here is an
example:
|
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
cout << "Do you consider yourself a hot-tempered individual(y=Yes/n=No)? ";
cin >> Answer;
if( Answer == 'y' ) // First Condition
{
cout << "\nThis job involves a high level of self-control.";
cout << "\nWe will get back to you.\n";
}
if( Answer == 'n' ) // Second Condition
cout << "\nYou are hired!\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
The problem with the above program is that the
second if is not an alternative to the first, it is just another
condition that the program has to check and execute after executing the
first. On that program, if the user provides y as the answer to the
question, the compiler would execute the content of its statement and
the compiler would execute the second if condition.
You can also ask the compiler to check a condition;
if that condition is true, the compiler will execute the intended
statement. Otherwise, the compiler would execute alternate statement.
This is performed using the syntax:
if(Condition)
Statement1;
else
Statement2;
|
 |
|
The above program would better be written as:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
cout << "Do you consider yourself a hot-tempered individual(y=Yes/n=No)? ";
cin >> Answer;
if( Answer == 'y' ) // One answer
{
cout << "\nThis job involves a high level of self-control.";
cout << "\nWe will get back to you.\n";
}
else // Any other answer
cout << "\nYou are hired!\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Practical Learning: The if…else Statement
|
|
- To consider when the traffic light’s color is other than green,
change your program as follows:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Light;
cout << "What is the current light color(g=Green/y=Yellow/r=Red)? ";
cin >> Light;
if ( Light == 'g' )
{
cout << "\nThe light is green";
cout << "\nYou can proceed and drive through.\n";
}
else
cout << "\nPlease wait!\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program and return to your programming environment
- Save your project.
|
|
The Conditional Operator (?:)
|
|
|
The conditional operator behaves like a simple if…else
statement. Its syntax is:
Condition ? Statement1 : Statement2;
The compiler would first test the Condition.
If the Condition is true, then it would execute Statement1,
otherwise it would execute Statement2. When you request two
numbers from the user and would like to compare them, the following
program would do find out which one of both numbers is higher. The
comparison is performed using the conditional operator:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
signed Num1, Num2, Max;
cout << "Enter two numbers: ";
cin >> Num1 >> Num2;
Max = (Num1 < Num2) ? Num2 : Num1;
cout << "\nThe maximum of " << Num1
<< " and " << Num2 << " is " << Max;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Conditional Statements: if…else if and if…else
if…else
|
|
|
The previous conditional formula is used to execute
one of two alternatives. Sometimes, your program will need to check many
more than that. The syntax for such a situation is:
if(Condition1)
Statement1;
else if(Condition2)
Statement2;
An alternative syntax would add the last else as
follows:
if(Condition1)
Statement1;
else if(Condition2)
Statement2;
else
Statement-n;
|
|
|
if(Condition1)
Statement1;
else if(Condition2)
Statement2;
else if(Condition3)
Statement3;
else
Statement-n;
|
|
The compiler will check the first condition. If
Condition1 is true, it will execute Statement1. If Condition1 is false,
then the compiler will check the second condition. If Condition2 is
true, it will execute Statement2. When the compiler finds a Condition-n
to be true, it will execute its corresponding statement. It that
Condition-n is false, the compiler will check the subsequent condition.
This means you can include as many conditions as you see fit using the
else if statement. If after examining all the known possible conditions
you still think that there might be an unexpected condition, you can use
the optional single else.
A program we previously wrote was considering that any answer other than
y was negative. It would be more professional to consider a negative
answer because the program anticipated one. Therefore, here is a better
version of the program:
|
|
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Answer;
cout << "Do you consider yourself a hot-tempered individual(y=Yes/n=No)? ";
cin >> Answer;
if( Answer == 'y' ) // Unique Condition
{
cout << "\nThis job involves a high level of self-control.";
cout << "\nWe will get back to you.\n";
}
else if( Answer == 'n' ) // Alternative
cout << "\nYou are hired!\n";
else
cout << "\nThat's not a valid answer!\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Practical Learning: if…else if and if…else
if…else
|
|
- To consider various answers that the user could give, change your
program as follows:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Light;
cout << "What is the current light color(g=Green/y=Yellow/r=Red)? ";
cin >> Light;
if( Light == 'g' )
{
cout << "\nThe light is green";
cout << "\nYou can proceed and drive through.\n";
}
else if( Light == 'y' )
cout << "\nBe careful!\n";
else if( Light == 'r' )
cout << "\nPlease Stop!!!";
else
cout << endl << Light << " is not a valid color.\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program.
- Type a letter and press Enter. See the result.
- Test the program again and provide different answers, those that
are valid and those that are not.
- Return to your development environment and save your project.
|
|
When defining an expression whose result would lead
to a specific program execution, the switch statement considers that
result and executes a statement based on the possible outcome of that
expression, this possible outcome is called a case. The different
outcomes are listed in the body of the switch statement and each case
has its own execution, if necessary. The body of a switch statement is
delimited from an opening to a closing curly brackets: “{“ to
“}”. The syntax of the switch statement is:
|
switch(Expression)
{
case Choice1:
Statement1;
case Choice2:
Statement2;
case Choice-n:
Statement-n;
} |
|
The expression to examine is an integer. Since an
enumeration (enum) and the character (char) data types are just other
forms of integers, they can be used too. Here is an example of using the
switch statement:
|
|
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number;
cout << "Type a number between 1 and 3: ";
cin >> Number;
switch (Number)
{
case 1:
cout << "\nYou typed 1";
case 2:
cout << "\nYou typed 2";
case 3:
cout << "\nYou typed 3";
}
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
The program above would request a number from the
user. If the user types 1, it would execute the first, the second, and
the third cases. If she types 2, the program would execute the second
and third cases. If she supplies 3, only the third case would be
considered. If the user types any other number, no case would execute.
When establishing the possible outcomes that the switch
statement should consider, at times there will be other possibilities
other than those listed and you will be likely to consider them. This
special case is handled by the default keyword. The default
case would be considered if none of the listed cases matches the
supplied answer. The syntax of the switch statement that
considers the default case would be:
|
|
switch(Expression)
{
case Choice1:
Statement1;
case Choice2:
Statement2;
case Choice-n:
Statement-n;
default:
Other-Possibility;
} |
Therefore another version of the program above would be
|
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number;
cout << "Type a number between 1 and 3: ";
cin >> Number;
switch (Number)
{
case 1:
cout << "\nYou typed 1";
case 2:
cout << "\nYou typed 2";
case 3:
cout << "\nYou typed 3";
default:
cout << endl << Number << " is out of the requested range.";
}
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
|
Practical Learning: Switching Cases
|
|
- Change the file as follows:
//---------------------------------------------------------------------------
#include <iostream>
#include <conio>
using namespace std;
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char Light;
cout << "What is the current light "
<< "color(g=Green/y=Yellow/r=Red)? ";
cin >> Light;
switch( Light )
{
case 'g':
cout << "\nThe light is green";
cout << "\nYou can proceed and drive through...";
cout << "\nNow, passing from Green to Yellow...\n";
case 'y':
cout << "\nThe light has passed from Green to Yellow\n";
cout << "Timer = 0. Yellow Light - Be Careful!\n";
cout << "Timer = 1. Yellow Light - Be Careful!\n";
cout << "Timer = 2. Yellow Light - Be Careful!\n";
cout << "Timer = 3. Yellow Light - Be Careful!\n";
cout << "Timer = 4. Yellow Light - Be Careful!\n";
cout << "Timer = 5. Yellow Light - Be Careful!\n";
cout << "\nYellow light ended.\n";
case 'r':
cout << "\nRed Light - Please Stop!!!";
cout << "\nTimer:\t 1 2 3 4 5 6 7 8 9 10";
cout << "\n\t11 12 13 14 15 16 17 18 19 20";
cout << "\n\t21 22 23 24 25 26 27 28 29 30";
cout << "\n\t31 32 33 34 35 36 37 38 39 40";
cout << "\n\t41 42 43 44 45 46 47 48 49 50";
cout << "\n\t51 52 53 54 55 56 57 58 59 60";
cout << "\nEnd of Red Light.";
}
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program and return to your programming environment.
- Save your project
|
|
