Chapter Two

Basics of C++
The parts of a C++ Program
To understand the basic parts of a simple program in C++, let’s have a look at
the following code:

#include<iostream.h>
#include<conio.h>
void main()
{
cout<<”\n Hello World!”;
getch();
}
Any C++ program file should be saved with file name extension “ .CPP ”
Type the program directly into the editor, and save the file as hello.cpp,
compile it and then run it. It will print the words Hello World! on the computer
screen.
The first character is the #. This character is a signal to the preprocessor. Each
time you start your compiler, the preprocessor runs through the program and
looks for the pound (#) symbols and act on those lines before the compiler
runs.
The include instruction is a preprocessor instruction that directs the compiler to
include a copy of the file specified in the angle brackets in the source code.
If the path of the file is not specified, the preprocessor looks for the file under
c:\tc\include\ folder or in include folder of the location where the editor is
stored.
The effects of line 1, i.e. include<iostream.h> is to include the file iostream.h
into the program as if the programmer had actually typed it.
When the program starts, main() is called automatically.
Every C++ program has a main() function.
The return value type for main() here is void, which means main function will
not return a value to the caller (which is the operating system).
The main function can be made to return a value to the operating system.
The Left French brace “{“signals the beginning of the main function body and
the corresponding Right French Brace “}” signals the end of the main function
body. Every Left French Brace needs to have a corresponding Right French
Brace.
The lines we find between the braces are statements or said to be the body of
the function.
A statement is a computation step which may produce a value or interact with
input and output streams.
The end of a single statement ends with semicolon (;).

1
 The statement in the above example causes the sting “Hello World!” to be sent
to the “cout” stream which will display it on the computer screen.

Let us add an additional instruction to our first program:

1
2 // my second program in C++
3
4 #include <iostream.h>
5
6 int main ()
Hello World! I'm a C++ program
7 {
8 cout << "Hello World! ";
9 cout << "I'm a C++ program";
10 return 0;
11 }
12

In this case, we performed two insertions into cout in two different statements. Once again, the
separation in different lines of code has been done just to give greater readability to the program,
since main could have been perfectly valid defined this way:

int main () { cout << " Hello World! "; cout << " I'm a C++ program ";
return 0; }
We were also free to divide the code into more lines if we considered it more convenient:

1 int main ()
2{
3 cout <<
4 "Hello World!";
5 cout
6 << "I'm a C++ program";
7 return 0;
8}

And the result would again have been exactly the same as in the previous examples.

Preprocessor directives (those that begin by #) are out of this general rule since they are not
statements. They are lines read and processed by the preprocessor and do not produce any code
by themselves. Preprocessor directives must be specified in their own line and do not have to end
with a semicolon (;).

A brief look at cout and cin


Cout is an object used for printing data to the screen.
To print a value to the screen, write the word cout, followed by the insertion
operator also called output redirection operator (<<) and the object to be
printed on the screen.

2
Syntax: Cout<<Object;
The object at the right hand side can be:
• A literal string: “Hello World”
• A variable: a place holder in memory
Cin is an object used for taking input from the keyboard.
To take input from the keyboard, write the word cin, followed by the input
redirection operator (>>) and the object name to hold the input value.
Syntax: Cin>>Object
Cin will take value from the keyboard and store it in the memory. Thus the cin
statement needs a variable which is a reserved memory place holder.
Both << and >> return their right operand as their result, enabling multiple
input or multiple output operations to be combined into one statement. The
following example will illustrate how multiple input and output can be
performed:
E.g.:
Cin>>var1>>var2>>var3;
Here three different values will be entered for the three variables. The
input should be separated by a space, tan or newline for each variable.
Cout<<var1<<”, “<<var2<<” and “<<var3;
Here the values of the three variables will be printed where there is a “,”
(comma) between the first and the second variables and the “and” word
between the second and the third.

Putting Comments on C++ programs


A comment is a piece of descriptive text which explains some aspect of a
program.
Program comments are text totally ignored by the compiler and are only
intended to inform the reader how the source code is working at any particular
point in the program.
C++ provides two types of comment delimiters:
Single Line Comment: Anything after // {double forward slash} (until the
end of the line on which it appears) is considered a comment.
o Eg:
cout<<var1; //this line prints the value of var1
Multiple Line Comment: Anything enclosed by the pair /* and */ is
considered a comment.
o Eg:
/*this is a kind of comment where
Multiple lines can be enclosed in
one C++ program */

Comments should be used to enhance (not to hinder) the readability of a

program. The following two points, in particular, should be noted:
3
 A comment should be easier to read and understand than the code which
it tries to explain. A confusing or unnecessarily-complex comment is
worse than no comment at all.
Over-use of comments can lead to even less readability. A program which
contains so much comment that you can hardly see the code can by no
means be considered readable.
Use of descriptive names for variables and other entities in a program,
and proper indentation of the code can reduce the need for using
comments.
Variables and Constants

Variables
A variable is a reserved place in memory to store information in.
A variable will have three components:
Variables are used for holding data values so that they can be used in various
computations in a program.
All variables have three important properties:
• Data Type: a type which is established when the variable is defined.
(e.g. integer, real, character etc). Data type describes the property of
the data and the size of the reserved memory
• Name: a name which will be used to refer to the value in the variable.
A unique identifier for the reserved memory location
• Value: a value which can be changed by assigning a new value to the
variable.
Fundamental Variable types
Several other variable types are built into C++. They can be conveniently
classified as integer, floating-point or character variables.
Floating-point variable types can be expressed as fraction i.e. they are
“real numbers”.
Character variables hold a single byte. They are used to hold 256
different characters and symbols of the ASCII and extended ASCII
character sets.
The type of variables used in C++ program are described in the next
table, which lists the variable type, how much room

4
 Data Types

Name Description Size* Range*

char
signed: -128 to 127
Character or small integer. 1byte
unsigned: 0 to 255
short int signed: -32768 to 32767
(short) Short Integer. 2bytes
unsigned: 0 to 65535
signed: -2147483648 to
int Integer. 4bytes 2147483647
unsigned: 0 to 4294967295
long int
signed: -2147483648 to
(long) Long integer. 4bytes 2147483647
unsigned: 0 to 4294967295
bool
Boolean value. It can take one of two
1byte true or false
values: true or false.
float Floating point number. 4bytes +/- 3.4e +/- 38 (~7 digits)
double
+/- 1.7e +/- 308 (~15
Double precision floating point number. 8bytes
digits)
long double
Long double precision floating point +/- 1.7e +/- 308 (~15
8bytes
number. digits)
wchar_t
2 or 4
Wide character. 1 wide character
bytes

Identifiers
A valid identifier is a sequence of one or more letters, digits or underlined symbols.
The length of an identifier is not limited.
Neither space nor marked letters can be part of an identifier.
Only letters and underlined characters are valid.
Variable identifiers should always begin with a letter or an underscore. By any
means they should not begin with a digit.
Key words should not be used as names for identifiers.
C++ is case sensitive. Small letter and capital letters are different for C++. Eg:
variable Age is not identical with variable age
Another rule that you have to consider when inventing your own identifiers is that they cannot
match any keyword of the C++ language nor your compiler's specific ones, which are reserved
keywords. The standard reserved keywords are:

asm, auto, bool, break, case, catch, char, class, const, const_cast,
continue, default, delete, do, double, dynamic_cast, else, enum, explicit,
export, extern, false, float, for, friend, goto, if, inline, int, long,
mutable, namespace, new, operator, private, protected, public, register,
reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct,

5
switch, template, this, throw, true, try, typedef, typeid, typename, union,
unsigned, using, virtual, void, volatile, wchar_t, while

Additionally, alternative representations for some operators cannot be used as identifiers since
they are reserved words under some circumstances:

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Your compiler may also include some additional specific reserved keywords.

Very important: The C++ language is a "case sensitive" language. That means that an identifier
written in capital letters is not equivalent to another one with the same name but written in small
letters. Thus, for example, the RESULT variable is not the same as the result variable or the
Result variable. These are three different variable identifiers.

Declaration of variables

In order to use a variable in C++, we must first declare it specifying which data type we want it
to be. The syntax to declare a new variable is to write the specifier of the desired data type (like
int, bool, float...) followed by a valid variable identifier. For example:

1 int a;
2 float mynumber;

These are two valid declarations of variables. The first one declares a variable of type int with
the identifier a. The second one declares a variable of type float with the identifier mynumber.
Once declared, the variables a and mynumber can be used within the rest of their scope in the
program.

If you are going to declare more than one variable of the same type, you can declare all of them
in a single statement by separating their identifiers with commas. For example:

int a, b, c;

This declares three variables (a, b and c), all of them of type int, and has exactly the same
meaning as:

1 int a;
2 int b;
3 int c;
The integer data types char, short, long and int can be either signed or unsigned depending on
the range of numbers needed to be represented. Signed types can represent both positive and
negative values, whereas unsigned types can only represent positive values (and zero). This can
be specified by using either the specifier signed or the specifier unsigned before the type name.
For example:

6
1 unsigned short int NumberOfSisters;
2 signed int MyAccountBalance;

By default, if we do not specify either signed or unsigned most compiler settings will assume the
type to be signed, therefore instead of the second declaration above we could have written:

int MyAccountBalance;

with exactly the same meaning (with or without the keyword signed)

An exception to this general rule is the char type, which exists by itself and is considered a
different fundamental data type from signed char and unsigned char, thought to store characters.
You should use either signed or unsigned if you intend to store numerical values in a char-
sized variable.
short and long can be used alone as type specifiers. In this case, they refer to their respective
integer fundamental types: short is equivalent to short int and long is equivalent to long
int. The following two variable declarations are equivalent:

1 short Year;
2 short int Year;

Finally, signed and unsigned may also be used as standalone type specifiers, meaning the same
as signed int and unsigned int respectively. The following two declarations are equivalent:

1 unsigned NextYear;
2 unsigned int NextYear;

To see what variable declarations look like in action within a program, we are going to see the
C++ code of the example about your mental memory proposed at the beginning of this section:

1 // operating with variables

2
3 #include <iostream>
4 int main ()
5 {
6 // declaring variables:
7 int a, b;
8 int result;
9
10 // process: 4
11 a = 5;
12 b = 2;
13 a = a + 1;
14 result = a - b;
15
16 // print out the result:
17 cout << result;
18
19 // terminate the program:
7
20 return 0;
21 }
22
Initializing Variables
When a variable is assigned a value at the time of declaration, it is called
variable initialization.
This is identical with declaring a variable and then assigning a value to
the variable immediately after declaration.
The syntax: DataType variable name = initial value;
e.g. int a = 0;
or: int a;
a=0;
Scope of Variables
Scope of a variable is the boundary or block in a program where a
variable can be accessed. The boundary or block is identified by the left
and right French brackets.
In C++, we can declare variables anywhere in the source code. But we
should declare a variable before using it no matter where it is written.
Global variables: are variables that can be referred/accessed anywhere
in the code, within any function, as long as it is declared first. A variable
declared before any function immediately after the include statements
are global variables.
Local Variables: the scope of the local variable is limited to the code
level or block within which they are declared.
In the following example, the integer data type num1 is accessible
everywhere whereas z and is only accessible in the add function and
num2 is accessible in main function. This means cout<<z; or any
statement involving z is only valid in add function.
e.g:
#include<iostream.h>
int num1;
int add( int x, int y)
{
int z;
….
}
void main()
{
unsigned short age;
float num2;
cout<<”\n Enter your age:”;
…
}

8
 In C++ the scope of a local variable is given by the block in which it is
declared.
If it is declared within a function, it will be a variable with a function
scope. If it is declared in a loop, its scope will be only in the loop, etc.
Characters
Characters variables (type char) are typically one byte in size, enough to
hold 256 different values. A char can be represented as a small number
(0 - 255).
Char in C++ are represented as any value inside a single quote.
E.g.: ‘x’, ‘A’, ‘5’, ‘a’, etc.
When the compiler finds such values (characters), it translates back the
value to the ASCII values. E.g. ‘a’ has a value 97 in ASCII.

Special Printing characters

In C++, there are some special characters used for formatting. These are:
\n new line
\t tab
\b backspace
\” double quote
\’ single quote
\? Question mark
\\ backslash
Constants
A constant is any expression that has a fixed value.
Like variables, constants are data storage locations in the computer memory.
But, constants, unlike variables their content cannot be changed after the
declaration.
Constants must be initialized when they are created by the program, and the
programmer can’t assign a new value to a constant later.
C++ provides two types of constants: literal and symbolic constants.
Literal constant: is a value typed directly into the program wherever it is
needed.
E.g.: int num = 43;
43 is a literal constant in this statement:
Symbolic constant: is a constant that is represented by a name, similar to that
of a variable. But unlike a variable, its value can’t be changed after
initialization.
E.g.:
Int studentPerClass =15;
students = classes * studentPerClass;
studentPerClass is a symbolic constant having a value of 15.
And 15 is a literal constant directly typed in the program.
In C++, we have two ways to declare a symbolic constant. These are using the
#define and the const key word.
9
Defined constants (#define)

You can define your own names for constants that you use very often without having to resort to
memory-consuming variables, simply by using the #define preprocessor directive. Its format is:
#define identifier value
For example:

1 #define PI 3.14159
2 #define NEWLINE '\n'
This defines two new constants: PI and NEWLINE. Once they are defined, you can use them in
the rest of the code as if they were any other regular constant, for example:

1
// defined constants: calculate circumference
2
3
#include <iostream.h>
4
5
#define PI 3.14159
6
#define NEWLINE '\n'
7
8
int main ()
9
{
10 31.4159
double r=5.0; // radius
11
double circle;
12
13
circle = 2 * PI * r;
14
cout << circle;
15
cout << NEWLINE;
16
17
return 0;
18
}
19

In fact the only thing that the compiler preprocessor does when it encounters #define directives is
to literally replace any occurrence of their identifier (in the previous example, these were PI and
NEWLINE) by the code to which they have been defined (3.14159 and '\n' respectively).

The #define directive is not a C++ statement but a directive for the preprocessor; therefore it
assumes the entire line as the directive and does not require a semicolon (;) at its end. If you
append a semicolon character (;) at the end, it will also be appended in all occurrences of the
identifier within the body of the program that the preprocessor replaces.

10
Declared constants (const)

With the const prefix you can declare constants with a specific type in the same way as you
would do with a variable:

1 const int pathwidth = 100;

2 const char tabulator = '\t';

Expressions and Statements

In C++, a statement controls the sequence of execution, evaluates an
expression, or does nothing (the null statement).
All C++ statements end with a semicolon. E.g.: x = a + b;
The meaning is: assign the value of the sum of a and b to x.
White spaces: white spaces characters (spaces, tabs, new lines) can’t be seen
and generally ignored in statements. White spaces should be used to make
programs more readable and easier to maintain.
Blocks: a block begins with an opening French brace ({) and ends with a closing
French brace (}).
Expressions: an expression is a computation which yields a value. It can also be
viewed as any statement that evaluates to a value (returns a value).
E.g.: the statement 3+2; returns the value 5 and thus is an expression.
Some examples of an expression:
E.g.1:
3.2 returns the value 3.2
PI float constant that returns the value 3.14 if the constant is defined.
secondsPerMinute integer constant that returns 60 if the constant is declared

E.g.2: complicated expressions:

x = a + b;
y = x = a + b;
The second line is evaluated in the following order:
1. add a to b.
2. assign the result of the expression a + b to x.
3. assign the result of the assignment expression x = a + b to y.

Operators

An operator is a symbol that makes the machine to take an action.

Different Operators act on one or more operands and can also have different
kinds of operators.
C++ provides several categories of operators, including the following:
 Assignment operator
 Arithmetic operator

11
  Relational operator
 Logical operator
 Increment/decrement operator
 Conditional operator
 Comma operator
 The size of operator

Explicit type casting operators, etc

1. Assignment operator (=).

The assignment operator causes the operand on the left side of the
assignment statement to have its value changed to the value on the right side
of the statement.
Syntax: Operand1=Operand2;
Operand1 is always a variable
Operand2 can be one or combination of:
• A literal constant: Eg: x=12;
• A variable: Eg: x=y;
• An expression: Eg: x=y+2;
For example, let us have a look at the following code - I have included the evolution of the
content stored in the variables as comments:

1 // assignment operator
2
3 #include <iostream.h>
4
5 int main ()
6 {
7 int a, b; // a:?, b:?
8 a = 10; // a:10, b:?
9 b = 4; // a:10, b:4 a:4 b:7
10 a = b; // a:4, b:4
11 b = 7; // a:4, b:7
12 cout << "a:";
13 cout << a;
14 cout << " b:";
15 cout << b;
16 return 0;
17 }

This code will give us as result that the value contained in a is 4 and the one contained in b is 7.
Notice how a was not affected by the final modification of b, even though we declared a = b
earlier (that is because of the right-to-left rule).
A property that C++ has over other programming languages is that the assignment operation can
be used as the rvalue (or part of an rvalue) for another assignment operation. For example:

a = 2 + (b = 5);

12
is equivalent to:

1 b = 5;
2 a = 2 + b;
that means: first assign 5 to variable b and then assign to a the value 2 plus the result of the
previous assignment of b (i.e. 5), leaving a with a final value of 7.

The following expression is also valid in C++:

a = b = c = 5;

It assigns 5 to the all three variables: a, b and c.

2. Compound assignment operators (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=).
Compound assignment operator is the combination of the assignment
operator with other operators like arithmetic and bit wise operators.
The assignment operator has a number of variants, obtained by
combining it with other operators.
E.g.:
value += increase; is equivalent to value = value + increase;
a -= 5; is equivalent to a = a – 5;
a /= b; is equivalent to a = a / b;
price *= units + 1 is equivalent to price = price * (units + 1);
And the same is true for the rest.
For example:

1 // compound assignment operators

2
3 #include <iostream.h>
4
5 int main ()
6 {
5
7 int a, b=3;
8 a = b;
9 a+=2; // equivalent to a=a+2
10 cout << a;
11 return 0;
12 }

3. Arithmetic operators (+, -, *, /, %)

Except for remainder or modulo (%), all other arithmetic operators can accept a mix of
integers and real operands. Generally, if both operands are integers then, the result will be
an integer. However, if one or both operands are real then the result will be real.
When both operands of the division operator (/) are integers, then the division is
performed as an integer division and not the normal division we are used to.
Integer division always results in an integer outcome.
13
Division of integer by integer will not round off to the next integer
E.g.:
9/2 gives 4 not 4.5
-9/2 gives -4 not -4.5
To obtain a real division when both operands are integers, you should cast one of the
operands to be real.
E.g.:
int cost = 100;

Int volume = 80;

Double unitPrice = cost/(double)volume;
The module(%) is an operator that gives the remainder of a division of two integer
values. For instance, 13 % 3 is calculated by integer dividing 13 by 3 to give an outcome of
4 and a remainder of 1; the result is therefore 1.
E.g.:
a = 11 % 3

a is 2

4. Relational operator (==, !=, > , <, >=, <=).

In order to evaluate a comparison between two expressions, we can use the relational
operator.
The result of a relational operator is a bool value that can only be true or false according
to the result of the comparison.
E.g.:
(7 = = 5) would return false or returns 0
(5 > 4) would return true or returns 1
The operands of a relational operator must evaluate to a number. Characters are valid
operands since they are represented by numeric values. For E.g.:
‘A’ < ‘F’ would return true or 1. it is like (65 < 70)

5. Logical Operators (!, &&, ||):

Logical negation (!) is a unary operator, which negates the logical value of its operand. If
its operand is non zero, it produces 0, and if it is 0 it produce 1.
Logical AND (&&) produces 0 if one or both of its operands evaluate to 0 otherwise it
produces 1.
Logical OR (||) produces 0 if both of its operands evaluate to 0 otherwise, it produces 1.
E.g.:
!20 //gives 0
10 && 5 //gives 1
10 || 5.5 //gives 1
10 && 0 // gives 0
14
 N.B. In general, any non-zero value can be used to represent the logical true, whereas only
zero represents the logical false.

&& OPERATOR
a b a && b
true true True
true false False
false true False
false false False

The operator || corresponds with Boolean logical operation OR. This operation results true if
either one of its two operands is true, thus being false only when both operands are false
themselves. Here are the possible results of a || b:

|| OPERATOR
a b a || b
true true true
true false true
false true true
false false false

For example:

1 ( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ).

2 ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).

6. Increment/Decrement Operators: (++) and (--)

The auto increment (++) and auto decrement (--) operators provide a convenient way
of, respectively, adding and subtracting 1 from a numeric variable.
E.g.:
if a was 10 and if a++ is executed then a will automatically changed to 11.

6.1. Prefix and Postfix:

The prefix type is written before the variable. Eg (++ myAge), whereas the
postfix type appears after the variable name (myAge ++).
Prefix and postfix operators cannot be used at once on a single variable:
Eg: ++age-- or --age++ or ++age++ or - - age - - is invalid
In a simple statement, either type may be used. But in complex
statements, there will be a difference.
The prefix operator is evaluated before the assignment, and the postfix
operator is evaluated after the assignment.

15
 E.g.
int k = 5;
(auto increment prefix) y= ++k + 10; //gives 16 for y
(auto increment postfix) y= k++ + 10; //gives 15 for y
(auto decrement prefix) y= --k + 10; //gives 14 for y
(auto decrement postfix) y= k-- + 10; //gives 15 for y

7. Conditional Operator (?:)

The conditional operator takes three operands. It has the general form:
Syntax:
operand1? operand2: operand3
First operand1 is a relational expression and will be evaluated. If the result of the
evaluation is non zero (which means TRUE), then operand2 will be the final result.
Otherwise, operand3 is the final result.
E.g.: General Example
Z=(X<Y? X : Y)
This expression means that if X is less than Y the value of X will be assigned to Z otherwise (if
X>=Y) the value of Y will be assigned to Z.

E.g.:
int m=1,n=2,min;
min = (m < n ? m : n);
The value stored in min is 1.
E.g.: (7 = = 5 ? 4: 3) returns 3 since 7 is not equal to 5

8. Comma Operator (,).

Multiple expressions can be combined into one expression using the comma operator.
The comma operator takes two operands. Operand1, Operand2
The comma operator can be used during multiple declaration, for the condition
operator and for function declaration, etc
It the first evaluates the left operand and then the right operand, and returns the value
of the latter as the final outcome.
E.g.
int m,n,min;
int mCount = 0, nCount = 0;
min = (m < n ? (mCount++ , m) : (nCount++ , n));
Here, when m is less than n, mCount++ is evaluated and the value of m is stored in
min. otherwise, nCount++ is evaluated and the value of n is stored in min.

For example, the following code:

16
 a = (b=3, b+2);

Would first assign the value 3 to b, and then assign b+2 to variable a. So, at the end, variable a
would contain the value 5 while variable b would contain value 3.

9. The sizeof() Operator.

This operator is used for calculating the size of any data item or type.
It takes a single operand (e.g. 100) and returns the size of the specified entity in bytes.
The outcome is totally machine dependent.
E.g.:
a = sizeof(char)
b = sizeof(int)
c = sizeof(1.55) etc

Explicit type casting operators

Type casting operators allows you to convert a datum of a given type to another data
type.
E.g.
int i;
float f = 3.14;
i = (int)f;
equivalent to i = int(f);
Then variable i will have a value of 3 ignoring the decimal point

Operator Precedence

The order in which operators are evaluated in an expression is significant and

is determined by precedence rules. Operators in higher levels take precedence
over operators in lower levels.
Precedence Table:
Level Operator Order
Highest ++ -- (post fix) Right to left
sizeof() ++ -- (prefix) Right to left
*/% Left to right
+- Left to right
< <= > >= Left to right
== != Left to right
&& Left to right
|| Left to right
?: Left to right
= ,+=, -=, *=, /=,^= ,%=, &= ,|= ,<<= ,>>= Right to left
, Left to right
17
 E.g.
a==b+c*d
c * d is evaluated first because * has a higher precedence than + and = =.
The result is then added to b because + has a higher precedence than = =
And then == is evaluated.
Precedence rules can be overridden by using brackets.
E.g. rewriting the above expression as:
a = = (b + c) * d causes + to be evaluated before *.
Operators with the same precedence level are evaluated in the order specified by the
column on the table of precedence rule.
E.g. a = b += c the evaluation order is right to left, so the first b += c is evaluated
followed by a = b.

Worksheet
For each of the problems write a C++ code to perform the required task. Your program
should be based on the flow chart you drawn in the first worksheet.
1) Receive a number and determine whether it is odd or even.
2) Obtain two numbers from the keyboard, and determine and display which (if either)
is the larger of the two numbers.
3) Receive 3 numbers and display them in ascending order from smallest to largest
4) Add the numbers from 1 to 100 and display the sum
5) Add the even numbers between 0 and any positive integer number given by the user.
6) Find the average of two numbers given by the user.
7) Find the average, maximum, minimum, and sum of three numbers given by the user.
8) Find the area of a circle where the radius is provided by the user.
9) Swap the contents of two variables using a third variable.
10) Swap the content of two variables without using a third variable.
11) Read an integer value from the keyboard and display a message indicating if this
number is odd or even.
12) read 10 integers from the keyboard in the range 0 - 100, and count how many of
them are larger than 50, and display this result
13) Take an integer from the user and display the factorial of that number
14. A Program to accept radius of circle and produce area
15. A program to find area of triangle
16. A program to read temperature in Celsius & display in F

18