Bicol University

POLANGUI CAMPUS
Computer and Engineering Studies Department

Course Title : COMPUTER PROGRAMMING 1

Course No. : CC 101
Course Prerequisite(s) : NONE
Number of Credits : 5 units (2 units lecture, 3 unit laboratory)
Course Placement : Bachelor of Science in Information Technology–
FIRST YEAR
Semester/Term : 1st Semester A. Y. 2019-2020
Time/Room : 8:30-9:30/1:00-4:00 – M/W/F –SB13/LAB RM 2

Course Description :

The course covers the use of general purpose programming language to solve
problems. The emphasis is to train students to design, implement, test and debug
programs intended to solve computing problems using fundamental programming
constructs.

LEARNING MODULE CONTENTS:

I. Introduction to Programming. Algorithms and Flowchart.

II. Pseudo Coding.
III. History, Principles and Elements of Programming.
IV. Fundamentals of Programming.
V. Debugging and techniques.
MODULE I. INTRODUCTION TO PROGRAMMING. ALGORITHMS AND
FLOWCHART

What Is a Programming Algorithm?

So, what is a programming algorithm? You can think of a programming algorithm

as a recipe that describes the exact steps needed for the computer to solve a problem
or reach a goal. We've all seen food recipes - they list the ingredients needed and a set
of steps for how to make the described meal. Well, an algorithm is just like that. In
computer lingo, the word for a recipe is a procedure, and the ingredients are called
inputs. Your computer looks at your procedure, follows it to the letter, and you get to see
the results, which are called outputs. A programming algorithm describes how to do
something, and your computer will do it exactly that way every time. Well, it will once
you convert your algorithm into a language it understands!

However, it's important to note that a programming algorithm is not computer

code. It's written in simple English (or whatever the programmer speaks). It doesn't beat
around the bush--it has a start, a middle, and an end. In fact, you will probably label the
first step 'start' and the last step 'end.' It includes only what you need to carry out the
task. It does not include anything unclear, often called ambiguous in computer lingo,
that someone reading it might wonder about.

It always leads to a solution and tries to be the most efficient solution we can
think up. It's often a good idea to number the steps, but you don't have to. Instead of
numbered steps, some folks use indentation and write in pseudocode, which is a semi-
programming language used to describe the steps in an algorithm. But, we won't use
that here since simplicity is the main thing. Other folks just use a diagram called a
flowchart, which we will discuss soon.

Definition of Algorithm

To write a logical step-by-step method to solve the problem is called algorithm, in

other words, an algorithm is a procedure for solving problems. In order to solve a
mathematical or computer problem, this is the first step of the procedure. An algorithm
includes calculations, reasoning and data processing. Algorithms can be presented by
natural languages, pseudo code and flowcharts, etc.

Design and Analysis of Algorithms

• Analysis: predict the cost of an algorithm in terms of resources and performance

• Design: design algorithms which minimize the cost

Characteristics of an Algorithm

Not all procedures can be called an algorithm. An algorithm should have the following
characteristics −

Unambiguous − Algorithm should be clear and unambiguous. Each of its steps (or
phases), and their inputs/outputs should be clear and must lead to only one meaning.

Input − An algorithm should have 0 or more well-defined inputs.

 Output − An algorithm should have 1 or more well-defined outputs, and should match
the desired output.

Finiteness − Algorithms must terminate after a finite number of steps.

Feasibility − Should be feasible with the available resources.

Independent − An algorithm should have step-by-step directions, which should be

independent of any programming code.

Definition of Flowchart

A flowchart is the graphical or pictorial representation of an algorithm with the

help of different symbols, shapes and arrows in order to demonstrate a process or a

program. With algorithms, we can easily understand a program. The main purpose of a

flowchart is to analyze different processes. Several standard graphics are applied in a

flowchart:

 Terminal Box - Start / End

 Input / Output

 Process / Instruction

 Decision

 Connector / Arrow
The graphics above represent different part of a flowchart. The process in a flowchart

can be expressed through boxes and arrows with different sizes and colors. In a

flowchart, we can easily highlight a certain element and the relationships between each

part.

How to Use Flowcharts to Represent Algorithms

Now that we have the definitions of algorithm and flowchart, how do we use a flowchart

to represent an algorithm?

Algorithms are mainly used for mathematical and computer programs, whilst flowcharts

can be used to describe all sorts of processes: business, educational, personal and of

course algorithms. So flowcharts are often used as a program planning tool to visually

organize the step-by-step process of a program. Here are some examples:

Example 1: Print 1 to 20:

Algorithm:

Step 1: Initialize X as 0,

Step 2: Increment X by 1,

Step 3: Print X,

Step 4: If X is less than 20 then go back to step 2.

Flowchart:

Example 2: Convert Temperature from Fahrenheit (℉) to Celsius (℃)

Algorithm:
Step 1: Read temperature in Fahrenheit,

Step 2: Calculate temperature with formula C=5/9*(F-32),

Step 3: Print C,

Flowchart:

Benefits of Flowchart:

Simplify the Logic

As it provides the pictorial representation of the steps; therefore, it simplifies the logic

and subsequent steps.

Makes Communication Better

Because of having easily understandable pictorial logic and steps, it is a better and

simple way of representation.

Effective Analysis

Once the flow-chart is prepared, it becomes very simple to analyze the problem in an

effective way.

Useful in Coding

The flow-chart also helps in coding process efficiently, as it gives directions on what to

do, when to do, and where to do. It makes the work easier.
Proper Testing

Further, flowchart also helps in finding the error (if any) in program

Applicable Documentation

Last but not the least, a flowchart also helps in preparing the proper document (once the

codes are written).

Conclusion

From the above we can come to a conclusion that a flowchart is pictorial

representation of an algorithm, an algorithm can be expressed and analyzed through a

flowchart.

An algorithm shows you every step of reaching the final solution, while a flowchart

shows you how to carry out the process by connecting each step. An algorithm uses

mainly words to describe the steps while a flowchart uses the help of symbols, shapes

and arrows to make the process more logical.

ACTIVITY:

Materials: 1 Bond Paper and Pen.

I. Create your sample algorithm of the following scenarios (Limit to 15 steps):

A. From waking up in the morning to going to school.

 B. Making Fried Rice.
C. Booking a Flight to Manila.

II. Then try to summarize it into 6 Steps. The algorithm must still make sense.

III. Identify The Input, Process and Output of each Algorithm.

IV. Create your sample Flowchart for each Algorithm.

MODULE II. PSEUDO CODE

How to write a Pseudo Code?

Pseudo code is a term which is often used in programming and algorithm based
fields. It is a methodology that allows the programmer to represent the implementation
of an algorithm. Simply, we can say that it’s the cooked up representation of an
algorithm. Often at times, algorithms are represented with the help of pseudo codes as
they can be interpreted by programmers no matter what their programming background
or knowledge is. Pseudo code, as the name suggests, is a false code or a
representation of code which can be understood by even a layman with some school
level programming knowledge.

Algorithm: It’s an organized logical sequence of the actions or the approach

towards a particular problem. A programmer implements an algorithm to solve a
problem. Algorithms are expressed using natural verbal but somewhat technical
annotations.
Pseudo code: It’s simply an implementation of an algorithm in the form of
annotations and informative text written in plain English. It has no syntax like any of the
programming language and thus can’t be compiled or interpreted by the computer.

Advantages of Pseudocode
  Improves the readability of any approach. It’s one of the best approaches to start
implementation of an algorithm.
 Acts as a bridge between the program and the algorithm or flowchart. Also works
as a rough documentation, so the program of one developer can be understood
easily when a pseudo code is written out. In industries, the approach of
documentation is essential. And that’s where a pseudo-code proves vital.
 The main goal of a pseudo code is to explain what exactly each line of a program
should do, hence making the code construction phase easier for the programmer.

How to write a Pseudo-code?

1. Arrange the sequence of tasks and write the pseudocode accordingly.

2. Start with the statement of a pseudo code which establishes the main goal or the
aim.
Example:
This program will allow the user to check
the number whether it's even or odd.
3. The way the if-else, for, while loops are indented in a program, indent the
statements likewise, as it helps to comprehend the decision control and execution
mechanism. They also improve the readability to a great extent.
Example:

if "1"
print response
"I am case 1"

if "2"
print response
"I am case 2"
4. Use appropriate naming conventions. The human tendency follows the approach
to follow what we see. If a programmer goes through a pseudo code, his approach
will be the same as per it, so the naming must be simple and distinct.
5. Use appropriate sentence casings, such as CamelCase for methods, upper case
for constants and lower case for variables.
6. Elaborate everything which is going to happen in the actual code. Don’t make the
pseudo code abstract.
7. Use standard programming structures such as ‘if-then’, ‘for’, ‘while’, ‘cases’ the
way we use it in programming.
8. Check whether all the sections of a pseudo code is complete, finite and clear to
understand and comprehend.
9. Don’t write the pseudo code in a complete programmatic manner. It is necessary to
be simple to understand even for a layman or client, hence don’t incorporate too
many technical terms.

ACTIVITY:

Create the Algorithm in a pseudo code format for the following problems:
 A. How to solve for the sum of two numbers.
B. Converting Dollars to Philippine Pesos.
C. Process in Withdrawing money from the ATM
D. Deterring if the grade is a PASS or a FAIL

MODULE III. History, Principles and Elements of Programming.

Programmable devices have existed at least as far back as 1106 AD, when
the automata of Al-Jazari were programmable, via pegs and cams, to play various
rhythms and drum patterns;] and the 1801 Jacquard loom could produce entirely
different weaves by changing the "program" - a series of pasteboard cards with holes
punched in them.
However, the first computer program is generally dated to 1843, when
mathematician Ada Lovelace published an algorithm to calculate a sequence
of Bernoulli numbers, intended to be carried out by Charles Babbage's Analytical
Engine.

Ada Lovelace, whose notes added to the end of Luigi Menabrea's paper included the
first algorithm designed for processing by an Analytical Engine. She is often recognized
as history's first computer programmer.
Data and instructions were once stored on external punched cards, which were kept in
order and arranged in program decks.
In the 1880s Herman Hollerith invented the concept of storing data in machine-readable
form. Later a control panel (plugboard) added to his 1906 Type I Tabulator allowed it to
be programmed for different jobs, and by the late 1940s, unit record equipment such as
the IBM 602 and IBM 604, were programmed by control panels in a similar way; as
were the first electronic computers. However, with the concept of the stored-program
computers introduced in 1949, both programs and data were stored and manipulated in
the same way in computer memory.
Machine code was the language of early programs, written in the instruction set of the
particular machine, often in binary notation. Assembly languages were soon developed
that let the programmer specify instruction in a text format, (e.g., ADD X, TOTAL), with
abbreviations for each operation code and meaningful names for specifying addresses.
However, because an assembly language is little more than a different notation for a
machine language, any two machines with different instruction sets also have different
assembly languages.
High-level languages made the process of developing a program simpler and more
understandable, and less bound to the underlying hardware. FORTRAN, the first widely
used high-level language to have a functional implementation, came out in 1957[6] and
many other languages were soon developed – in particular, COBOL aimed at
commercial data processing, and Lisp for computer research.
Programs were mostly still entered using punched cards or paper tape. See computer
programming in the punch card era. By the late 1960s, data storage
devices and computer terminals became inexpensive enough that programs could be
created by typing directly into the computers. Text editors were developed that allowed
changes and corrections to be made much more easily than with punched cards.

Principles and Elements of Programming:

C++ is a statically typed, compiled, general-purpose, case-sensitive, free-form

programming language that supports procedural, object-oriented, and generic
programming.

C++ is regarded as a middle-level language, as it comprises a combination of both

high-level and low-level language features.

C++ was developed by Bjarne Stroustrup starting in 1979 at Bell Labs in Murray Hill,
New Jersey, as an enhancement to the C language and originally named C with
Classes but later it was renamed C++ in 1983.

C++ is a superset of C, and that virtually any legal C program is a legal C++ program.

Note − A programming language is said to use static typing when type checking is
performed during compile-time as opposed to run-time.

Learning C++

The most important thing while learning C++ is to focus on concepts.

The purpose of learning a programming language is to become a better programmer;
that is, to become more effective at designing and implementing new systems and at
maintaining old ones.

C++ supports a variety of programming styles. You can write in the style of Fortran, C,
Smalltalk, etc., in any language. Each style can achieve its aims effectively while
maintaining runtime and space efficiency.

Use of C++

C++ is used by hundreds of thousands of programmers in essentially every application

domain.

C++ is being highly used to write device drivers and other software that rely on direct
manipulation of hardware under realtime constraints.

C++ is widely used for teaching and research because it is clean enough for successful
teaching of basic concepts.

Anyone who has used either an Apple Macintosh or a PC running Windows has
indirectly used C++ because the primary user interfaces of these systems are written in
C++.

When we consider a C++ program, it can be defined as a collection of objects that

communicate via invoking each other's methods. Let us now briefly look into what a
class, object, methods, and instant variables mean.

 Object − Objects have states and behaviors. Example: A dog has states - color,
name, breed as well as behaviors - wagging, barking, eating. An object is an
instance of a class.

 Class − A class can be defined as a template/blueprint that describes the

behaviors/states that object of its type support.

 Methods − A method is basically a behavior. A class can contain many methods.

It is in methods where the logics are written, data is manipulated and all the
actions are executed.

 Instance Variables − Each object has its unique set of instance variables. An
object's state is created by the values assigned to these instance variables.

C++ Program Structure

Let us look at a simple code that would print the words Hello World.

Live Demo

#include <iostream>

using namespace std;

// main() is where program execution begins.

int main() {

cout << "Hello World"; // prints Hello World

return 0;

Let us look at the various parts of the above program −

 The C++ language defines several headers, which contain information that is
either necessary or useful to your program. For this program, the
header <iostream> is needed.

 The line using namespace std; tells the compiler to use the std namespace.
Namespaces are a relatively recent addition to C++.

 The next line '// main() is where program execution begins.' is a single-line
comment available in C++. Single-line comments begin with // and stop at the
end of the line.

 The line int main() is the main function where program execution begins.

 The next line cout << "Hello World"; causes the message "Hello World" to be
displayed on the screen.

 The next line return 0; terminates main( )function and causes it to return the
value 0 to the calling process.

Compile and Execute C++ Program

Let's look at how to save the file, compile and run the program. Please follow the steps
given below −

 Open a text editor and add the code as above.

 Save the file as: hello.cpp

 Open a command prompt and go to the directory where you saved the file.

 Type 'g++ hello.cpp' and press enter to compile your code. If there are no errors
in your code the command prompt will take you to the next line and would
generate a.out executable file.

 Now, type 'a.out' to run your program.

 You will be able to see ' Hello World ' printed on the window.

$ g++ hello.cpp
$ ./a.out
Hello World
Make sure that g++ is in your path and that you are running it in the directory
containing file hello.cpp.

You can compile C/C++ programs using makefile. For more details, you can check
our 'Makefile Tutorial'.

Semicolons and Blocks in C++

In C++, the semicolon is a statement terminator. That is, each individual statement
must be ended with a semicolon. It indicates the end of one logical entity.

For example, following are three different statements −

x = y;
y = y + 1;
add(x, y);
A block is a set of logically connected statements that are surrounded by opening and
closing braces. For example −

{
cout << "Hello World"; // prints Hello World
return 0;
}
C++ does not recognize the end of the line as a terminator. For this reason, it does not
matter where you put a statement in a line. For example −

x = y;
y = y + 1;
add(x, y);
is the same as

x = y; y = y + 1; add(x, y);

C++ Identifiers
A C++ identifier is a name used to identify a variable, function, class, module, or any
other user-defined item. An identifier starts with a letter A to Z or a to z or an
underscore (_) followed by zero or more letters, underscores, and digits (0 to 9).

C++ does not allow punctuation characters such as @, $, and % within identifiers. C++
is a case-sensitive programming language. Thus, Manpowerand manpower are two
different identifiers in C++.

Here are some examples of acceptable identifiers −

mohd zara abc move_name a_123

myname50 _temp j a23b9 retVal

DATA TYPES:

While writing program in any language, you need to use various variables to store
various information. Variables are nothing but reserved memory locations to store
values. This means that when you create a variable you reserve some space in
memory.

You may like to store information of various data types like character, wide character,
integer, floating point, double floating point, boolean etc. Based on the data type of a
variable, the operating system allocates memory and decides what can be stored in the
reserved memory.

Primitive Built-in Types

C++ offers the programmer a rich assortment of built-in as well as user defined data
types. Following table lists down seven basic C++ data types −

Type Keyword

Boolean bool

Character char

Integer int

Floating point float

Double floating point double

Valueless void

Wide character wchar_t

Several of the basic types can be modified using one or more of these type modifiers −

 signed
 unsigned
 short
 long
The following table shows the variable type, how much memory it takes to store the
value in memory, and what is maximum and minimum value which can be stored in
such type of variables.

Type Typical Bit Width Typical Range

char 1byte -127 to 127 or 0 to 255

 unsigned char 1byte 0 to 255

signed char 1byte -127 to 127

int 4bytes -2147483648 to 2147483647

unsigned int 4bytes 0 to 4294967295

signed int 4bytes -2147483648 to 2147483647

short int 2bytes -32768 to 32767

unsigned short int Range 0 to 65,535

signed short int Range -32768 to 32767

long int 4bytes -2,147,483,648 to 2,147,483,647

signed long int 4bytes same as long int

unsigned long int 4bytes 0 to 4,294,967,295

float 4bytes +/- 3.4e +/- 38 (~7 digits)

double 8bytes +/- 1.7e +/- 308 (~15 digits)

long double 8bytes +/- 1.7e +/- 308 (~15 digits)

wchar_t 2 or 4 bytes 1 wide character

The size of variables might be different from those shown in the above table,
depending on the compiler and the computer you are using.

VARIABLE TYPES:

A variable provides us with named storage that our programs can

manipulate. Each variable in C++ has a specific type, which determines the
size and layout of the variable's memory; the range of values that can be
stored within that memory; and the set of operations that can be applied to
the variable.

The name of a variable can be composed of letters, digits, and the

underscore character. It must begin with either a letter or an underscore.
Upper and lowercase letters are distinct because C++ is case-sensitive −

There are following basic types of variable in C++ as explained in last

chapter −

Sr.No Type & Description

1 bool

Stores either value true or false.

2 char

Typically a single octet (one byte). This is an integer type.

3 int

The most natural size of integer for the machine.

4 float

A single-precision floating point value.

5 double

A double-precision floating point value.

6 void

Represents the absence of type.

7 wchar_t

A wide character type.

C++ also allows to define various other types of variables, which we will
cover in subsequent chapters like Enumeration, Pointer, Array,
Reference, Data structures, and Classes.

Following section will cover how to define, declare and use various types of
variables.
Variable Definition in C++
A variable definition tells the compiler where and how much storage to
create for the variable. A variable definition specifies a data type, and
contains a list of one or more variables of that type as follows −
type variable_list;

Here, type must be a valid C++ data type including char, w_char, int, float,
double, bool or any user-defined object, etc., and variable_list may
consist of one or more identifier names separated by commas. Some valid
declarations are shown here −
int i, j, k;
char c, ch;
float f, salary;
double d;

The line int i, j, k; both declares and defines the variables i, j and k; which
instructs the compiler to create variables named i, j and k of type int.

Variables can be initialized (assigned an initial value) in their declaration.

The initializer consists of an equal sign followed by a constant expression as
follows −
type variable_name = value;

Some examples are −

extern int d = 3, f = 5; // declaration of d and f.
int d = 3, f = 5; // definition and initializing d and f.
byte z = 22; // definition and initializes z.
char x = 'x'; // the variable x has the value 'x'.

For definition without an initializer: variables with static storage duration

are implicitly initialized with NULL (all bytes have the value 0); the initial
value of all other variables is undefined.

Variable Declaration in C++

A variable declaration provides assurance to the compiler that there is one
variable existing with the given type and name so that compiler proceed for
further compilation without needing complete detail about the variable. A
variable declaration has its meaning at the time of compilation only,
compiler needs actual variable definition at the time of linking of the
program.

A variable declaration is useful when you are using multiple files and you
define your variable in one of the files which will be available at the time of
linking of the program. You will use extern keyword to declare a variable at
any place. Though you can declare a variable multiple times in your C++
program, but it can be defined only once in a file, a function or a block of
code.

Example
Try the following example where a variable has been declared at the top,
but it has been defined inside the main function −
Live Demo

#include <iostream>

using namespace std;

// Variable declaration:

extern int a, b;

extern int c;

extern float f;

int main () {

// Variable definition:

int a, b;

int c;

float f;

// actual initialization

a = 10;

b = 20;

c = a + b;

cout << c << endl ;

f = 70.0/3.0;

cout << f << endl ;

return 0;

When the above code is compiled and executed, it produces the following
result −
30
23.3333
Same concept applies on function declaration where you provide a function
name at the time of its declaration and its actual definition can be given
anywhere else. For example −
// function declaration
int func();
int main() {
// function call
int i = func();
}

// function definition
int func() {
return 0;
}

OPERATORS:

An operator is a symbol that tells the compiler to perform specific

mathematical or logical manipulations. C++ is rich in built-in operators and
provide the following types of operators −

 Arithmetic Operators

 Relational Operators

 Logical Operators

 Bitwise Operators

 Assignment Operators

 Misc Operators

This chapter will examine the arithmetic, relational, logical, bitwise,

assignment and other operators one by one.

Arithmetic Operators
There are following arithmetic operators supported by C++ language −

Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator Description Example

+ Adds two operands A + B will give 30

- Subtracts second operand from A - B will give -10

the first

* Multiplies both operands A * B will give 200

/ Divides numerator by de- B / A will give 2

 numerator

% Modulus Operator and remainder B % A will give 0

of after an integer division

++ Increment operator, increases A++ will give 11

integer value by one

-- Decrement operator, decreases A-- will give 9

integer value by one

Relational Operators
There are following relational operators supported by C++ language

Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator Description Example

== Checks if the values of two (A == B) is not true.

operands are equal or not, if yes
then condition becomes true.

!= Checks if the values of two (A != B) is true.

operands are equal or not, if
values are not equal then
condition becomes true.

> Checks if the value of left operand (A > B) is not true.

is greater than the value of right
operand, if yes then condition
becomes true.

< Checks if the value of left operand (A < B) is true.

is less than the value of right
operand, if yes then condition
becomes true.

>= Checks if the value of left operand (A >= B) is not true.

is greater than or equal to the
value of right operand, if yes then
condition becomes true.

<= Checks if the value of left operand (A <= B) is true.

is less than or equal to the value
of right operand, if yes then
 condition becomes true.

Logical Operators
There are following logical operators supported by C++ language.

Assume variable A holds 1 and variable B holds 0, then −

Show Examples

Operator Description Example

&& Called Logical AND operator. If (A && B) is false.

both the operands are non-zero,
then condition becomes true.

|| Called Logical OR Operator. If any (A || B) is true.

of the two operands is non-zero,
then condition becomes true.

! Called Logical NOT Operator. Use !(A && B) is true.

to reverses the logical state of its
operand. If a condition is true,
then Logical NOT operator will
make false.

Bitwise Operators
Bitwise operator works on bits and perform bit-by-bit operation. The truth
tables for &, |, and ^ are as follows −

p q p&q p|q p^q

0 0 0 0 0

0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Assume if A = 60; and B = 13; now in binary format they will be as follows
−

A = 0011 1100

B = 0000 1101
-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

The Bitwise operators supported by C++ language are listed in the following
table. Assume variable A holds 60 and variable B holds 13, then −

Show Examples

Operator Description Example

& Binary AND Operator copies a bit

(A & B) will give 12 which is 0000
to the result if it exists in both
1100
operands.

| Binary OR Operator copies a bit if (A | B) will give 61 which is 0011

it exists in either operand. 1101

^ Binary XOR Operator copies the

(A ^ B) will give 49 which is 0011
bit if it is set in one operand but
0001
not both.

~ Binary Ones Complement (~A ) will give -61 which is 1100

Operator is unary and has the 0011 in 2's complement form due
effect of 'flipping' bits. to a signed binary number.

<< Binary Left Shift Operator. The left

operands value is moved left by A << 2 will give 240 which is
the number of bits specified by 1111 0000
the right operand.

>> Binary Right Shift Operator. The

left operands value is moved right A >> 2 will give 15 which is 0000
by the number of bits specified by 1111
the right operand.

Assignment Operators
There are following assignment operators supported by C++ language −

Show Examples

Operator Description Example

= Simple assignment operator, Assigns
C = A + B will assign value of A
values from right side operands to
+ B into C
left side operand.

+= Add AND assignment operator, It

adds right operand to the left C += A is equivalent to C = C
operand and assign the result to left +A
operand.

-= Subtract AND assignment operator,

It subtracts right operand from the C -= A is equivalent to C = C -
left operand and assign the result to A
left operand.

*= Multiply AND assignment operator, It

multiplies right operand with the left C *= A is equivalent to C = C *
operand and assign the result to left A
operand.

/= Divide AND assignment operator, It

divides left operand with the right C /= A is equivalent to C = C /
operand and assign the result to left A
operand.

%= Modulus AND assignment operator,

It takes modulus using two C %= A is equivalent to C =
operands and assign the result to C%A
left operand.

<<= Left shift AND assignment operator. C <<= 2 is same as C = C <<

2

>>= Right shift AND assignment C >>= 2 is same as C = C >>

operator. 2

&= Bitwise AND assignment operator. C &= 2 is same as C = C & 2

^= Bitwise exclusive OR and

C ^= 2 is same as C = C ^ 2
assignment operator.

|= Bitwise inclusive OR and assignment

C |= 2 is same as C = C | 2
operator.

MODULE IV. Fundamentals of Programming.

CONDITIONAL STATEMENT:

Decision making structures require that the programmer specify one or

more conditions to be evaluated or tested by the program, along with a
statement or statements to be executed if the condition is determined to be
true, and optionally, other statements to be executed if the condition is
determined to be false.

Following is the general form of a typical decision making structure found in

most of the programming languages −

C++ programming language provides following types of decision making

statements.

Sr.No Statement & Description

1 if statement

An ‘if’ statement consists of a boolean expression followed by one or

more statements.

2 if...else statement
An ‘if’ statement can be followed by an optional ‘else’ statement, which
executes when the boolean expression is false.

3 switch statement
A ‘switch’ statement allows a variable to be tested for equality against a
list of values.

4 nested if statements
You can use one ‘if’ or ‘else if’ statement inside another ‘if’ or ‘else if’
 statement(s).

5 nested switch statements

You can use one ‘switch’ statement inside another ‘switch’ statement(s).

LOOPS/ ITERATIONS:

There may be a situation, when you need to execute a block of code several
number of times. In general, statements are executed sequentially: The
first statement in a function is executed first, followed by the second, and
so on.

Programming languages provide various control structures that allow for

more complicated execution paths.

A loop statement allows us to execute a statement or group of statements

multiple times and following is the general from of a loop statement in most
of the programming languages −

C++ programming language provides the following type of loops to handle

looping requirements.

Sr.No Loop Type & Description

1 while loop

Repeats a statement or group of statements while a given condition is

true. It tests the condition before executing the loop body.

2 for loop
Execute a sequence of statements multiple times and abbreviates the
 code that manages the loop variable.

3 do...while loop
Like a ‘while’ statement, except that it tests the condition at the end of
the loop body.

4 nested loops
You can use one or more loop inside any another ‘while’, ‘for’ or
‘do..while’ loop.

Loop Control Statements

Loop control statements change execution from its normal sequence. When
execution leaves a scope, all automatic objects that were created in that
scope are destroyed.

C++ supports the following control statements.

Sr.No Control Statement & Description

1 break statement

Terminates the loop or switch statement and transfers execution to the

statement immediately following the loop or switch.

2 continue statement
Causes the loop to skip the remainder of its body and immediately retest
its condition prior to reiterating.

3 goto statement
Transfers control to the labeled statement. Though it is not advised to
use goto statement in your program.

The Infinite Loop

A loop becomes infinite loop if a condition never becomes false.
The for loop is traditionally used for this purpose. Since none of the three
expressions that form the ‘for’ loop are required, you can make an endless
loop by leaving the conditional expression empty.

#include <iostream>

using namespace std;

int main () {

for( ; ; ) {
 printf("This loop will run forever.\n");

return 0;

When the conditional expression is absent, it is assumed to be true. You

may have an initialization and increment expression, but C++ programmers
more commonly use the ‘for (;;)’ construct to signify an infinite loop.

FUNCTIONS:

A function is a group of statements that together perform a task. Every

C++ program has at least one function, which is main(), and all the most
trivial programs can define additional functions.

You can divide up your code into separate functions. How you divide up
your code among different functions is up to you, but logically the division
usually is such that each function performs a specific task.

A function declaration tells the compiler about a function's name, return

type, and parameters. A function definition provides the actual body of the
function.

The C++ standard library provides numerous built-in functions that your
program can call. For example, function strcat() to concatenate two strings,
function memcpy() to copy one memory location to another location and
many more functions.

A function is known with various names like a method or a sub-routine or a

procedure etc.

Defining a Function
The general form of a C++ function definition is as follows −
return_type function_name( parameter list ) {
body of the function
}

A C++ function definition consists of a function header and a function body.

Here are all the parts of a function −

 Return Type − A function may return a value. The return_type is the data
type of the value the function returns. Some functions perform the desired
operations without returning a value. In this case, the return_type is the
keyword void.
  Function Name − This is the actual name of the function. The function name
and the parameter list together constitute the function signature.

 Parameters − A parameter is like a placeholder. When a function is invoked,

you pass a value to the parameter. This value is referred to as actual parameter
or argument. The parameter list refers to the type, order, and number of the
parameters of a function. Parameters are optional; that is, a function may
contain no parameters.

 Function Body − The function body contains a collection of statements that

define what the function does.

Example
Following is the source code for a function called max(). This function takes
two parameters num1 and num2 and return the biggest of both −
// function returning the max between two numbers

int max(int num1, int num2) {

// local variable declaration
int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}

Function Declarations
A function declaration tells the compiler about a function name and how to
call the function. The actual body of the function can be defined separately.

A function declaration has the following parts −

return_type function_name( parameter list );

For the above defined function max(), following is the function declaration −
int max(int num1, int num2);

Parameter names are not important in function declaration only their type is
required, so following is also valid declaration −
int max(int, int);

Function declaration is required when you define a function in one source

file and you call that function in another file. In such case, you should
declare the function at the top of the file calling the function.

Calling a Function
While creating a C++ function, you give a definition of what the function
has to do. To use a function, you will have to call or invoke that function.
When a program calls a function, program control is transferred to the
called function. A called function performs defined task and when it’s return
statement is executed or when its function-ending closing brace is reached,
it returns program control back to the main program.

To call a function, you simply need to pass the required parameters along
with function name, and if function returns a value, then you can store
returned value. For example −
Live Demo

#include <iostream>

using namespace std;

// function declaration

int max(int num1, int num2);

int main () {

// local variable declaration:

int a = 100;

int b = 200;

int ret;

// calling a function to get max value.

ret = max(a, b);

cout << "Max value is : " << ret << endl;

return 0;

// function returning the max between two numbers

int max(int num1, int num2) {

// local variable declaration

int result;

if (num1 > num2)

result = num1;

else
 result = num2;

return result;

I kept max() function along with main() function and compiled the source
code. While running final executable, it would produce the following result −
Max value is : 200

Function Arguments
If a function is to use arguments, it must declare variables that accept the
values of the arguments. These variables are called the formal
parametersof the function.

The formal parameters behave like other local variables inside the function
and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed
to a function −

Sr.No Call Type & Description

1 Call by Value

This method copies the actual value of an argument into the formal
parameter of the function. In this case, changes made to the parameter
inside the function have no effect on the argument.

2 Call by Pointer
This method copies the address of an argument into the formal
parameter. Inside the function, the address is used to access the actual
argument used in the call. This means that changes made to the
parameter affect the argument.

3 Call by Reference
This method copies the reference of an argument into the formal
parameter. Inside the function, the reference is used to access the actual
argument used in the call. This means that changes made to the
parameter affect the argument.

By default, C++ uses call by value to pass arguments. In general, this

means that code within a function cannot alter the arguments used to call
the function and above mentioned example while calling max() function
used the same method.
Default Values for Parameters
When you define a function, you can specify a default value for each of the
last parameters. This value will be used if the corresponding argument is
left blank when calling to the function.

This is done by using the assignment operator and assigning values for the
arguments in the function definition. If a value for that parameter is not
passed when the function is called, the default given value is used, but if a
value is specified, this default value is ignored and the passed value is used
instead. Consider the following example −
Live Demo

#include <iostream>

using namespace std;

int sum(int a, int b = 20) {

int result;

result = a + b;

return (result);

int main () {

// local variable declaration:

int a = 100;

int b = 200;

int result;

// calling a function to add the values.

result = sum(a, b);

cout << "Total value is :" << result << endl;

// calling a function again as follows.

result = sum(a);

cout << "Total value is :" << result << endl;

return 0;
}

When the above code is compiled and executed, it produces the following
result −
Total value is :300
Total value is :120

MIDTERM EXAMINATION

Instruction:
Create the C++ Code Syntax of the Following output (25 points each):
1. 3.

2. 4.

MODULE V. DEBUGGING: