Conditional And Iterative Data Types Essay Sign up now for a free trial. Date Smarter!
And Iterative Data Types
A programming language cannot be
a programming language with out its conditional and iterative structures.

Programming languages are built to accomplish the task of controlling computer
input and output. A programmer must use every tool available to complete
his/her given tasks, and conditional as well as iterative statements are
the most basic items of programming which must be mastered. Many
different programming languages can demonstrate conditional and iterative
statements including C++, Java, Pascal, Qbasic, COBOL, and Scheme.

We will write a custom essay sample on
Conditional And Iterative Data Types Essay
or any similar topic only for you
Order now

Most of these languages implement conditional and iterative statements
in a similar fashion; however, there are a few differences.

The conditional structure is easy
to understand and self-defining. The whole statement is base on a
condition and its veracity. When the statement or “test” is found
to be true, a statement is executed, and if it is false, another test is
given or the program continues to the next block. Conditional structures
include the simple, two-alternative, multi-alternative, and non-deterministic
conditional. The simple conditional is the easiest to understand
being the IF-THEN statement.

if <Boolean expression> then
<block of statements>
IF a condition is met THEN execute a statement.

The two-alternative conditional or IF-ELSE is also easy to understand.

if <Boolean expression> then
<block of statements>
<block of statements>
IF a condition is met execute a statement;
ELSE the condition was not met so execute a different statement.

The multi-alternative conditional is very close to the two-alternative

if <condition-1> then
elseif <condition-2> then

elseif <condition-n> then
[else <statement-block-(n+1)>]
end if
The IF question is asked about a statement,
and if it is not true, the next statement is examined. If statement
number two is not true, the next statement is examined; then the next statement
is examined and so forth until a condition is met, and the control is carried
out of the multi-alternative conditional. The non-deterministic conditional
is similar to the multi-alternative conditional, because it has multiple

if <condition-1> &#61614;
when <condition-2> &#61614;

when <condition-n> &#61614;
end if
The reason multi-alternative and non-deterministic
conditionals are different, stems from the release of program’s control
or flow. The non-deterministic conditional tests each statement to
see if its condition is met; whereas the multi-alternative conditional
only tests statements until one of the conditions is met. After one
of the conditions is met, the multi-alternative conditional releases the
program control and fails to check anymore statements.

The iterative structure is a bit
more complicated than the conditional structure, but it is easy to understand.

An iterative structure consists of a block of statements that are executed
repetitively. They might be executed once or a hundred times depending
on the controls placed on the structure. Iterative structures include
non-terminating, pretest, posttest, in-test, fixed-count, and non-deterministic
iteration. The non-terminating iterative structure is not very common,
because once it has program control, it does not release its control until
the whole program is terminated.

end loop
Once a non-terminating iterative structure
is activated it continues to run forever. The pretest iterative structure
tests a condition first, then if it is true, the following statements are
executed repeatedly – testing the statement each loop – until the
statement is false.

while ;condition; loop
end loop
Once the statement is found to be false,
control is returned to the program ending the pretest iterative statement.

The posttest iterative statement is the same as the pretest statement except
the condition is tested after the sequence of statements. With the
posttest iterative statement, the programmer is guaranteed to have the
sequence of statements executed at least once. The statements are
executed before the conditional statement has a chance to be tested.

With the in-test iterative statement, the conditional statement is tested
in the middle of the sequence of statements. It can be useful when
it is necessary to run a portion of the statement at least once regardless
of the outcome of the conditional. Fixed-count iteration is very
popular, because it allows a sequence of statements to be executed a finite
number of times instead of relying on a condition to be true or false.

The fixed-count iteration is simply do ;sequence-of-statements; x number
of times. The non-deterministic iterative statement is similar to
the non-deterministic conditional statement.

when ;condition-1; ;#61614;
when ;condition-1; ;#61614;

when ;condition-n; ;#61614;
end do
The iterative statement executes until
none of the conditions are found to be true. At that time, control
is release back to the program from the non-deterministic iterative statement.

C++ has every type of control structure
a programmer could ever need, and they are all easy to implement.

The three types of condition statements include the if, if/else, and the
switch. The simple conditional is implemented through the if statement.

The two-alternative conditional can be shown in C++ by using the if/else
statements, and the multi-alternative can be demonstrated by using the
switch statement. When it come to iterative structures C++ uses the
while, do while, and for statements. Pretest works closely with the
while statement. Posttest uses C++’s do while statement, and the
for statement is used in fixed count iteration. The code below
gives an example of each structure.

if (x < y)
while (x < y) {
cout << x;
cout << x;
if (x < y)
cout << x;
do {
cout << x;
if (y < x)
} while (x < y);
cout << y;
for (int i=0; i < 10; i++)
switch (fruit)
i = i + 1;
case ‘orange’:
cout << “yum”;
case ‘banana’:
cout << “yummy”;
case ‘apple’:
cout << “ooh yes”;
The simple conditional or “if” statement
simply asks if x is less than y and if it less than y x is printed to the
screen. The two-alternative/multi-alternative conditional using if/else
asks if x is less than y and if true prints x. If it is not less
than y then it asks if y is less than x. If this is true y is printed
to the screen. More statements can be added to this conditional to
lengthen the multiple alternatives. Another multi-alternative conditional
involves the case statement. The variable “fruit” is measured against’orange’. If fruit is orange the “yum” is printed. Next “fruit”
is checked to see if it is ‘banana’. If so “yummy” is printed.

Last ‘apple’ is compared.

Iterative statements start with
the while on the right. The pretest is initiated with the comparison
of x to y. If the statement is true the loop is started and lasts
until x is greater than y. Post test is exemplified by the do while.

It say print x then check to see if x is less than y. Next continue
the loop until x is greater than y. The for loop continues to add
one to i until is not less than ten; the for loop demonstrates fixed count

Java is very similar to C++.

As a matter of fact, Java control structures are almost exactly the same
as C++. When it comes to conditional statements, Java uses the if
and if/else statements. The else if statements can substituted for
the case statement, but case is permitted. Iterative structures are
seen throughout Java in the form of while, do while, and for statements.

Examples of each statement are in the examples below.

if (distance < r) return true;
while(i– > 0) {
Object o = get_object();
if (a == 2)
if (o != null) {
System.out.println(“My exception”);
do {…

} while(j != 0);
if (a < 25)
at fault pt”); }
switch ( i ) {
for (int i = 0; i < shapes.length; i++){
case 0:
c = a + 3;
throw new MyException(“too low”);
case 1:
throw new MySubException(“still
too low”);
return i*i;
After viewing the C++ code on the
previous page, it is easy to see the similarities between C++ and Java.

The first simple conditional or if statement compares distance to r returning
true if the condition is true. If distance is not less than r nothing
happens. The second if statement is part of a two-alternative conditional.

If the condition a == 2 is met statement one is executed. If the
condition is not met then the second alternative is asked and if found
true the second statement is executed. The switch statement or non-deterministic
conditional is just like the C++ implementation. The variable i is
compared with the first case (0) and if true then the too low exception
is executed. If not true the next case is examined and if true the
still too low exception is sent back to the calling block. If none
of the cases match then i * i is returned. The pretest iterative
statement while is seen on the right side. It simply states if i
minus one is greater than 0 perform all statements within its loop.

And while i minus one is still greater than 0 keep on looping. The
for loop or fixed count iterative statement allows all statements below
it to be performed while i is less than the shapes length. The integer
i is incremented every time the loop is performed as indicated by the i++
located in the actual for statement. Looking at the different aspects
of conditional and iterative structures C++ and Java are almost one in
the same. They both use the same statements to provide examples of
the different types of structures. It is easy to see that Java was
based on the syntax of the C and C++ programming languages.

Pascal is a versatile language with
control structures that almost match C and Java. The key difference
between Pascal and C++ is not the actual conditional or iterative structure,
but the difference is the syntax and key words. The key words used
by Pascal for conditional structures include if, if/else, and case.

Iterative structures use the key words repeat/until, while/do, and for.

The following examples display the usage of the key words.

repeat case Ch
i := 1; ‘a’ ..

‘z’: writeln(‘small’);
x := round(r) + 12; ‘A’ ..

‘Z’: writeln(‘big’);
while i < x do begin end;
write(‘ ‘); —————————————–
inc(i); if Ch = ‘Y’
then begin
end; goodmood
:= true;
writeln(‘*’); end else begin
y := y+1; goodmood
:= false;
until keypressed; end;
for i := 0 to 9 do
read(f, numbers[i]);
The repeat block is a perfect example
of the iterative control structure and it contains the while/do block.

The repeat block executes all the statements at least once then test to
see if a key has been pressed; this is the posttest operation of the iterative
control structure. The while/do in the middle of the repeat block
shows the pretest of the iterative control structures. It tests to
see if i is less than x before performing the statements that follow.

Fixed count iteration is pointed out by the for loop. The statements
under the for loop are executed ten times. Non-deterministic conditional
structure is found with the case block. The variable ‘Ch’ is examined
against lowercase letters then against uppercase letters. The simple
conditional and two-alternative conditional is cover in the one if/else
block of code. If ‘Ch’ equals ‘Y’ then ‘goodmood’ gets the value
of true. With the else statement on the end, the simple conditional
becomes the two-alternative conditional. ‘Goodmood’ gets the value
of false when ‘Ch’ does not equal ‘Y’. Pascal structures are very
similar to other languages but keywords and syntax are a little different.

Qbasic is a simple language, but
it still contains a wonderful assortment of conditional and iterative structures.

As for conditional structures, if, else/if, and case are the most popular
choices. When it comes to iterative structures, Qbasic is packed
full of them. Qbasic has for, do/while, while, do/until, and do/loop.

All of the previous control structures are the basic type found in C++,
Java, and Pascal. Again, Qbasic is similar to the previous languages,
but the key words are different. Qbasic contains and relies upon
the heavy use of conditional and iterative control structures such as the
if and do structures. To further illustrate the Qbasic control structures,
the following examples are referenced and explained.

if (yrs > 20) then for
ctr = 100 to 200
print “give a gold watch”
total = total + ctr
elseif ((yrs > 10) and (yrs <
20) then next ctr
print “give a paperweight” ——————————-
end if while
(A > 5)
print A, B
select case num
B = B – 1
case 1 wend
beep ——————————-
case 2 do while
(ans$ <> “Y”)
beep : beep print”you must type Y”
case 3
input “hello”; ans$
beep : beep : beep loop
end select ——————————–
do until (ans$ = “Y”)
print “type Y”
print “type Y”
input “answer”; ans$
input “answer”; ans$
loop while (ans$ <> “Y”)
There are many examples above, but most
of the examples are of iterative control structures. The simple conditional
and two-alternative conditional are shown with the if and else/if structures.

If yrs is greater than 20 then print the message. The else if added
to the end checks to see if the years are in-between 10 and 20. If
the years meet the criteria the next message is printed. The case
block demonstrates non-deterministic conditional structures just like C++,
Java, and Pascal. Based on the variable ‘num’ one to three beeps
are heard. The do/while loop is one of many iterative control structures.

The do/while is a posttest operation that checks the users input after
the loop runs once. The for loop indicates a fixed count structure;
it loops while the variable ‘ctr’ is incremented. The while loop
is a pretest iterative structure testing ‘A’ before the loop even begins.

The do/while loop is also a pretest iterative structure that checks the
users input before the loop starts. The do/until block is like a
in-test iterative structure. It tests each line as it is processed
to see if ‘ans$’ is equal to ‘Y’. When ‘ans$’ is equal to ‘Y’, the
loop releases control back to the main program. Qbasic can be compared
to the previous three languages, but Qbasic seems to be less streamlined
because it has so many possible iterative structures. The same programs
can be written in Java using only for or while loops.

Now for the mighty programming language
COBOL. COBOL is the older language with the ability to keep up with
today’s fast paced programming tasks. COBOL is not very comparable
to the previous four languages. Its is capable of performing the
same tasks with its conditional and iterative structures as C++, Java or
any of the other languages, but COBOL has its own special way of performing.

The syntax is quite different, but some of the key words are the same.

Also, COBOL has considerably less iterative structures compared to Qbasic.

COBOL has such conditional structures as if, if/else and evaluate/when.

Iterative structures are best described in one word “perform”; the perform/until
is COBOL’s definite solution to iteration. Exemplified by the following
code , COBOL’s conditional and iterative structures are easily understood.

if operation = ‘-‘
subtract field-1 from field-2 giving
if operation = ‘+’
add field-1 field-2 giving result
if operation = ‘/’
divide field-1 by field-2 giving
evaluate taxable-wages
when zero thru 200
multiply taxable-wages by
.15 giving federal-taxes
when 200 thru 300
multiply taxable-wages by
.22 giving federal-taxes

varying power-value from 1 by 1
until power-value > field-2
The example above lengthy for demonstrating
only four structures by COBOL is not designed to be easy to write; it is
designed to crunch numbers. The if statement shows a simple conditional.

If the question is evaluated to be true the subtraction is performed on
the two fields. The second block of code shows the use of if/else
or the two-alternative conditional. If the first condition is not
met the second condition is evaluated. If the second is found true
division is performed on the two fields and an answer is given. Evaluate
is the last conditional block of code; this is a non-deterministic conditional
structure. Each case is evaluated line by line, and “when” (just
like in the code) a condition is met the applicable statements are executed
such as finding an employees federal taxes for a company. The iterative
structures posttest, in-test, and fixed count can be performed using the”perform” keyword in COBOL. The example above displays the posttest.

The loop is performed then ‘power-value’ is tested against ‘field-2’; if
power-value is greater than field-2 then the loop is broken. COBOL
is a competitive language, but it is lengthy when writing. Then conditional
and iterative structures are easy to use but require much time during the
planning phase of writing a program.

Scheme is the last and most unusual
programming language of this paper. Scheme can implement both conditional
and iterative structures, but the syntax of scheme is totally different
from C++, Java, Pascal, Qbasic, or COBOL. The Scheme programming
language is designed in a recursive manner. All Scheme programs are
recursive and are actually iterative because the program iterates over
and over again. The recursive nature of Scheme is not however an
iterative structure. The conditional structures of Scheme us such
keywords as if, else, case, and cond. The iterative structure of
Scheme seems to only be seen with the keywords loop or do. Scheme
conditional and iterative structures are seen below.

(if (< n 0)
(case (+ x y)
(- 1 n))
((1 3 5 7 9) ‘odd)
2 4 6 8) ‘even)
(cond (loop
(eqv? msg ’empty?)
(if (= n 0) (break ls))
(eqv? msg ‘push!) (set!
ls (cons ‘a ls))
(else “oops”))
(set! n (- n 1)))
(cond (do
(( i 2 (+ i 1)))
(< x 0)
((>= i n))
(> x 0)
The syntax of the if block looks very different
from any other languages in this paper, but it behaves in a similar fashion
to other simple conditional structures. The if statement states that
if ‘n’ is less than zero then subtract one from ‘n’. The cond with
the else is a multi-alternative conditional structure. The first
line asks if the variable ‘msg’ contains the string ’empty?’. The
second line asks if the variable ‘msg’ contains the string ‘push!’, and
the else line says if neither of the previous two lines are true print’oops’. The cond block on the bottom is a two-alternative conditional
structure. The first condition is if x is less than zero, and the
second condition is if x is greater than zero. The case block is
another multi-alternative conditional structure. If x plus y is equal
to and odd number then ‘odd’ is printed, and if x plus y is equal to an
even number then ‘even’ is printed. The loop code is a pretest iterative
structure. ‘n’ is tested against zero for equality. If they
are equal then the loop is stopped. The do block corresponds to the
posttest iterative structure. The first line is executed until ‘i’
is greater than or equal to ‘n’, but the condition is not tested until
the first line is executed at least once. Scheme is an odd language,
but once it is mastered is can accomplish any programming task set forth.

Comparatively, the conditional and iterative
structures in all the languages previously mentioned are very similar to
one another. All of the simple conditional structures even use the
same key word ‘if’. The conditionals in the languages all accomplish
the same tasks only some languages use different methods. The iterative
structures allow similar tasks to be completed by all languages as well.

For the most part the iterative structures of all the languages use at
least the keyword ‘do’ or perhaps ‘while’. The key words may vary
but the function is all the same. The structures are used for iteration.

The blocks of statements in the iterative loop must be performed time and
time again. C++ and Java are the most similar languages when the
conditional and iterative structures are compared. The two languages
that are the most dissimilar are COBOL and Scheme. COBOL is lengthy
with a few control structures. Scheme is compact with many control
structures. When comparing the control structures of C++, Java, Pascal,
Qbasic, COBOL, and Scheme, no one language can be said to be better than
any of the others.


Hi there, would you like to get such a paper? How about receiving a customized one? Check it out