ZeePedia Add to Favourites   |   Contact us


Introduction to Programming

<<< Previous Bitwise Manipulation and Assignment Operator, Programming Constructs Next >>>
 
img
CS201 ­ Introduction to Programming
Lecture Handout
Introduction to Programming
Lecture No. 22
Reading Material
Deitel & Deitel - C++ How to Program
Review previous lectures
Summary
Bitwise Manipulation and Assignment Operator
Design Recipes
Variables
Data Types
Operators
-  Arithmetic operators
-  Logical operators
-  Bitwise operators
Programming Constructs
Decisions
-  if statement
-  Nested if statement
Loops
-  while loop
-  do-while loop
-  for loop
switch, break and continue Statements
Functions
-  Function Calling
-  Top-Down Methodology
Arrays
Pointers
File I/O
Page 269
img
CS201 ­ Introduction to Programming
Bitwise Manipulation and Assignment Operator
Last time we discussed bitwise operators, we will continue with the elaboration of bitwise
manipulation and assignment operator.
C/C++ are well constructed languages, at start we used to write:
a = a + 1;
This is used to increment the variable. Then we came to know of doing it in a different
manner:
a += 1;
This is addition and assignment operation using single operator +=.
The same thing applies to bitwise operators; we have compound assignment operators for
& (bitwise AND), | (bitwise OR) and ^ (bitwise exclusive OR). It is written in the same
way as for the above mentioned arithmetic operators . Suppose we want to write:
a = a & b;
It can be written as:
a &= b;
Similarly for | and ^ operations we can write the statement in the following fashion.
a |= b;
and
a ^= b;
Remember, the ~ (NOT) operator is unary as it requires only one operand. Not of a
variable a is written as: ~a. There is no compound assignment operator available for it.
Now we will recap topics covered in the previous lectures one by one.
Design Recipe
Our problems, typically, are of real world nature, e.g., Payroll of a company. These
problems are expressed in words. As a programmer we use those words to understand the
problem and to come up with its possible solution.
To begin with the comprehension and resolution process, we analyze the problem and
express the problem in words in reduced and brief manner. Once we have reduced it into
its essence, we put some examples to formulate it. For example, if the problem is to
Page 270
img
CS201 ­ Introduction to Programming
calculate the annual net salary of employees, we can take an example for a particular
employee X. Later we will refine the problem, write program and test it. Finally we
review it if it has met objectives. We have discussed all these steps in Design Recipe.
There was a main heading in the topic, "Pay attention to the detail". Never forget this as
our computers are very dump machines. They perform exactly whatever we tell them.
It is important to keep in mind that we are using C/C++ as a vehicle to understand
programming concepts.
Variables
The computer memory can be thought of as pigeon holes each with an address. To store
numbers or characters in computer memory, we need a mechanism to manipulate it and
data types are required for different types of data. Instead of using hard coded memory
addresses with data types, symbolic names are used. These symbolic names are called
variables because they can contain different values at different times. For example,
int i;
double interest;
i and interest are symbolic names or variables with types of int and double respectively.
Data Types
int type is used to store whole numbers. There are some varieties of data types to store
whole numbers e.g., short and long. unsigned qualifier is used for non-negative
numbers. To represent real numbers we use float data type. For bigger-sized real
numbers double data type is used. char data type is used to store one character.
Generally, the size of the int type on our machines is 4 bytes and char is 1 byte. chars
are enclosed in single quotation mark. ASCII table contains the numeric values for chars.
We further discussed a bit later stage about the aggregations or collections of basic data
types (int, float and char etc) called arrays. Arrays are used to aggregate variables of
same data type.
Operators
We discussed three types of operators:
-  Arithmetic Operators
-  Logical Operators
-  Bitwise Operators
Page 271
img
CS201 ­ Introduction to Programming
Arithmetic Operators
+ operator is used to add two numbers, - is used to subtract one number from the other, *
is used to multiply two numbers, / is used to divide numbers. We also have a modulus
operator % , used to get the remainder. For example, in the following statement:
c = 7 % 2;
7 will be divided by 2 and the remainder 1 will be the stored in the variable c. We also
used this operator in our programs where we wanted to determine evenness or oddness of
a number. There are also compound arithmetic operators +=, -=, *=, /= and also %= for
our short hand. It is pertinent to note that there is no space between these compound
operators.
Logical Operators
The result for logical operators is always true or false. && (AND operator) and || (OR
operator). Logical Comparison operators are used to compare two numbers. These
operators are: <, <=, ==, >, >=. Don't confuse the == operator of equality with = operator
of assignment.
It is important for us to remember the difference between these two operators of equality
(==) and assignment (=) . However, C/C++ creates a little problem for us here. When we
write a statement as:
a = b;
The assignment statement itself has a value, which is the same as that of the expression
on the right hand side of the assignment operator. We can recall from our last lecture that
we only wrote a number inside the if statement. We also know that if the resultant inside
the if statement is non-zero then its code block is executed. In case, the result is zero, the
control is transferred to the else part.
If we want to compare two variables a and b inside if statement but wrongly write as:
if ( a = b )
{
// if code block
// do something
}
else
{
// do something else
}
Page 272
img
CS201 ­ Introduction to Programming
In this case, if the value of the variable b is non-zero (and hence value of the statement a
= b is non-zero) then if code block will be executed. But this was not required, it is a
logical fault and compiler was unable to detect it. Our objective was to compare two
variables. For that purpose, we should have used assignment operator == for that as:
if ( a == b )
One should be very careful while using comparison operators. You should not miss any
case of it and be sure about what you want to do and what will be the output of a
comparison statement.
You should keep in mind straight line of Calculus for the sake of completeness, you
should always divide your domain into two regions. If we take >= as one region then the
other region is <. Similarly if we say < as a region, the other region is >=. Depending on
the problem requirements, these regions should be very clear.
Bitwise Operators
& is bitwise AND operator, | is bitwise OR operator, ^ is bitwise Exclusive OR operator
and ~ is bitwise inversion or NOT operator. ~ (NOT operator) is unary operator as it
requires one operator and the remaining operators &, | and ^ are binary operators because
they require two operands.
Programming Constructs
For us, it is not necessary to know who is the one to devise or decide about these
constructs to be part of the program logic. The important thing is the concept of
programming constructs, required to write a program. We have earlier discussed three
constructs.
1. The sequential execution of statements of a program. Execution of statements begins
from very first statement and goes on to the last statement.
2. Secondly we need decisions that if something is true then we need to do something
otherwise we will do something else. We use if statement for this.
3. The third construct is loops. Loops are employed for repetitive structures.
Decisions
Normally, if statement is used where decisions are required.
Page 273
img
CS201 ­ Introduction to Programming
If statement
The syntax of if statement is fairly simple i.e.
if (condition)
{
// if code block
}
else
{
// else code block
}
The result of the condition can be either true or false. If the condition is true, if code
block is executed. Braces of the if code block are mandatory but if there is only one
statement in the if code block then the braces can be omitted or are optional. Now if the
condition is false, the if code block is skipped and the control is transferred to the else
part and else code block is executed. Else part is optional to associate with the if part.
So without else the statement looks like the following:
if (condition)
{
// if code block
// Do something here
}
Use of braces is again mandatory. Again, however, if there is only statement inside the
else part then brace is optional.
As a programming practice, use of braces all the time is recommended. It makes your
program more readable and logically sound.
What happens when the condition is complex?
Nested if statement
For complex conditions, we use logical connectives like &&, ||. For example:
if ( a > b && a < c)
If there are nested decisions structure that we want to do something based on some
condition and further we want to do something more based on an additional condition.
Then we use nested if-statements as under:
if ( a > b && a < c )
{
// Do something
if ( a == 100 )
Page 274
img
CS201 ­ Introduction to Programming
{
// Do something more
}
else
{
// Do something else more
}
}
else
{
// Do something else
}
From stylistic and readability perspective, we properly indent the statements inside if-
statements as shown above.
We discussed pictorial representation of if-statement. By using flowchart of if statement
that was a bit different than normally we see inside books, we introduced structured
flowcharting.
In structured flowcharting, we never go to the left of the straight line that joins Start
and Stop buttons. There is a logical reason for it as while writing code, we can't move to
the left outside the left margin. Left margin is the boundary of the screen and indentation
is made towards the right side. So we follow the construct that is equivalent to the
program being written. The major advantage of this approach is achieved when we draw
a flowchart of solution of a complex problem. The flowchart is the logical depiction of
the solution to the problem. One can write code easily with the help of the flowchart.
There will be one to one correspondence between the segments of the flowcharts and the
code.
Loops
Going on from the decision structures we discussed about loops. In our program if we
have to do something repeatedly then we can think of applying loop structure there.
There are few variants of loops in C language. However, other languages might have
lesser number of loop variants but a programming language always has loops constructs.
While Loop
The syntax of the while loop is as follows:
while ( condition )
{
// while code block
// Do something
}
Page 275
img
CS201 ­ Introduction to Programming
The condition is a logical expression like a == b that returns true or false. Braces are
mandatory to for while loop when there are multiple lines of code inside the while code
block. If there is only single line inside the while code block, the braces become optional.
It is good practice to use braces. The statements inside the while code block are never
executed, if the while condition results in false for very first time it is entered. In other
words, statements inside the while code block executes 0 to n times.
Page 276
img
CS201 ­ Introduction to Programming
The flowchart for the while loop is as follows:
while
False
condition
Exit
True
Process
Do-While Loop
Next loop variant is Do-while. It syntax is as under
do
{
// do-while code block
// Do something
}
while ( condition )
The important difference of this loop from the rest ones is that it is executed once before
the condition is evaluated. That means the statements of do-while code block execute at
least once.
Page 277
img
CS201 ­ Introduction to Programming
The flowchart for do-while loop is given below:
do while
Process
False
condition
Exit
True
For Loop
The for loop becomes bread and butter for us as it gathers three things together. The
syntax for the for loop is as follows:
for ( initialization statements; condition; incremental statements)
{
//for code block
// Do something
}
E.g.,
for ( int i = 0; i < 10; i ++)
{
}
The for loop is executed until the condition returns true otherwise it is terminated.
Page 278
img
CS201 ­ Introduction to Programming
The braces are not mandatory if there is single statement in the for code block. But for
sake of good programming practice, the single statement is also enclosed in braces. Some
people write the for loop in the following manner:
for ( initialization statements; condition; incremental statements){
//for code block
// Do something
}
Both the methods for writing of for loop are perfectly correct. You can use anyone of
these. If you indent your code properly, the process will become easier.
The flowchart for for loop is as under:
for
Initialization
Statements
for
False
condition
True
Process
for
Incre/Decre
Statements
Page 279
img
CS201 ­ Introduction to Programming
switch, break and continue Statements
For multi-way decisions, we can use nested if-statements or separate if-statements or
switch statement. There are few limitations of switch statement but it is necessary to use
break statements in every case inside the switch statement. If a case results in true when
there is no break statement inside it, all the statements below this case statement are
executed. break statement causes to jump out of the switch statement. We use break at
the end of every case statement. By using break, the jumping out from switch statement
is in a way bit different from the rules of structured programming. But break statement is
so elegant and useful that you can use it inside switch statement and inside loops. If we
use break inside a loop, it causes that loop to terminate. Similarly continue statement is
very useful inside loops. continue statement is used, when at a certain stage, you don't
want to execute the remaining statements inside your loop and want to go to the start of
the loop.
Functions
In C/C++, functions are a way of modularizing the code. A bigger problem is broken
down into smaller and more manageable parts. There is no rule of thumb for the length of
each part but normally one function's length is not more than one screen.
Page 280
img
CS201 ­ Introduction to Programming
Function Calling
We covered Functions Calling by value and by reference. The default of C language is
call by value. Call by value means that when we call a function and pass some parameter
to it, the calling function gets the copy of the value and the original value remains
unchanged. On the other hand, sometimes, we want to call a function and want to see the
changed value after the function call then call by reference mechanism is employed. We
achieved call by reference by using Pointers. Remember while calling functions, call by
value and call by reference are different techniques and default for ordinary variables is
call by value.
Top-Down Methodology
We discussed top-down design methodology. How do we see a problem at a high level
and identify major portions of it. Then by looking at each portion we identify smaller
parts inside it to write them as functions.
Arrays
After discussing functions and playing little bit with function calling, we had elaborated
the concept of Arrays. As discussed previously in this lecture, arrays are used to
aggregate variables of same data type. We wrote little functions about it and did some
exercises e.g., when we wanted to store age of students of our class. Then instead of
using a separate variable for each student, an array was employed to store the ages of the
students. Then to manipulate or to access individual array elements, a technique array
indexing was used. One important point to remember is that array indexes start from 0.
Let's say our array name is a of 10 ints, its first element will be a[0] while the last one
will be a[9]. Other languages like Fortran carry out 1-based indexing. Due to this 0 based
indexing for arrays in C language, programmers prefer to start loops from 0.
Arrays can also be multi-dimensional. In C language, arrays are stored in row major order
that a row is stored at the end of the previous row. Because of this storage methodology,
if we want to access the first element of the second row then we have to jump as many
numbers as the number of columns in the first row. This fact becomes important when we
are passing arrays to functions. In the receiving function parameters, we have to write all
the dimensions of the array except the extreme-left one. When passing arrays to
functions, it is always call by reference by default, it is not call by value as in the default
behavior of ordinary variables. Therefore, if the called function changes something in the
array, that change is actually made in the original array of the calling function. When we
pass ordinary variables to functions, they are passed by value because of the default
behavior. But when an array is passed to a function, the default behavior changes and
Page 281
img
CS201 ­ Introduction to Programming
array is passed by reference. We also did some examples of arrays by using Matrices and
did some exercises by transposing and reversing a squared matrix. Arrays are not just
used in Mathematics or Linear Algebra but are employed in a number of other problems
like when we store ages, names, and grades or want to calculate grade point of average.
This is very useful construct especially when used with loops. Normally it is very rare
that you see an array in a program and loop is not being used to manipulate it.
Like nested if-statements, we have nested loops, used with multi-dimensional arrays. A
while loop can have an inner while loop. Similarly a for loop can have a for loop inside.
It is also not necessary that a while loop should have only a while loop but it can be a for
loop also or any other construct like if-statement.
Pointers
It is very important topic of C/C++ . Pointers are different types of variables that contain
memory address of a variable instead of a value.
The very first example we discussed for pointers was for implementing function calling
by reference. Suppose we want to interchange (swap) two numbers by making a function
call. If we pass two variables to the function, these will be passed as ordinary variables by
value. Therefore, it will be ineffective as swapping of variables inside the function will
only be on the copies and not on the original variables. So instead of passing variables we
pass their addresses. In the called function, these addresses are taken into pointer
variables and pointers start pointing the original variables. Therefore, the swapping
operation done inside the function is actually carried out on the original variables.
We also saw that Pointers and Arrays are inter-linked. The array name itself is a pointer
to the first element. It is a constant pointer that cannot be incremented like normal pointer
variables. In case of two-dimensional arrays, it points to the first row and first column. In
three-dimensional array, you can imagine it pointing to the front corner of the cube.
File I/O
We discussed about Files and File I/O for sequential and random files. We used a mixture
of C/C++ for file handling and how the sequential and random files are accessed. We saw
Page 282
img
CS201 ­ Introduction to Programming
several modes of opening files. The important functions were seek and tell functions.
Seek functions (seekg and seekp ) used to move into the file and tell functions (tellg and
tellp) provided us the location inside the file.
You are required to go with very clear head, try to understand concepts and assess how
much you have learned so far to prepare for the mid-term examination.
Page 283
Table of Contents:
  1. What is programming
  2. System Software, Application Software, C language
  3. C language: Variables, Data Types, Arithmetic Operators, Precedence of Operators
  4. C++: Examples of Expressions, Use of Operators
  5. Flow Charting, if/else structure, Logical Operators
  6. Repetition Structure (Loop), Overflow Condition, Infinite Loop, Properties of While loop, Flow Chart
  7. Do-While Statement, for Statement, Increment/decrement Operators
  8. Switch Statement, Break Statement, Continue Statement, Rules for structured Programming/Flow Charting
  9. Functions in C: Structure of a Function, Declaration and Definition of a Function
  10. Header Files, Scope of Identifiers, Functions, Call by Value, Call by Reference
  11. Arrays: Initialization of Arrays, Copying Arrays, Linear Search
  12. Character Arrays: Arrays Comparisonm, Sorting Arrays Searching arrays, Functions arrays, Multidimensional Arrays
  13. Array Manipulation, Real World Problem and Design Recipe
  14. Pointers: Declaration of Pointers, Bubble Sort Example, Pointers and Call By Reference
  15. Introduction, Relationship between Pointers and Arrays, Pointer Expressions and Arithmetic, Pointers Comparison, Pointer, String and Arrays
  16. Multi-dimensional Arrays, Pointers to Pointers, Command-line Arguments
  17. String Handling, String Manipulation Functions, Character Handling Functions, String Conversion Functions
  18. Files: Text File Handling, Output File Handling
  19. Sequential Access Files, Random Access Files, Setting the Position in a File, seekg() and tellg() Functions
  20. Structures, Declaration of a Structure, Initializing Structures, Functions and structures, Arrays of structures, sizeof operator
  21. Bit Manipulation Operators, AND Operator, OR Operator, Exclusive OR Operator, NOT Operator Bit Flags Masking Unsigned Integers
  22. Bitwise Manipulation and Assignment Operator, Programming Constructs
  23. Pre-processor, include directive, define directive, Other Preprocessor Directives, Macros
  24. Dynamic Memory Allocation, calloc, malloc, realloc Function, Dangling Pointers
  25. History of C/C++, Structured Programming, Default Function Arguments
  26. Classes and Objects, Structure of a class, Constructor
  27. Classes And Objects, Types of Constructors, Utility Functions, Destructors
  28. Memory Allocation in C++, Operator and Classes, Structures, Function in C++,
  29. Declaration of Friend Functions, Friend Classes
  30. Difference Between References and Pointers, Dangling References
  31. Operator Overloading, Non-member Operator Functions
  32. Overloading Minus Operator, Operators with Date Class, Unary Operators
  33. Assignment Operator, Self Assignmentm, Pointer, Conversions
  34. Dynamic Arrays of Objects, Overloading new and delete Operators
  35. Source and Destination of streams, Formatted Input and Output, Buffered Input/Output
  36. Stream Manipulations, Manipulators, Non Parameterized Manipulators, Formatting Manipulation
  37. Overloading Insertion and Extraction Operators
  38. User Defined Manipulator, Static keyword, Static Objects
  39. Pointers, References, Call by Value, Call by Reference, Dynamic Memory Allocation
  40. Advantages of Objects as Class Members, Structures as Class Members
  41. Overloading Template Functions, Template Functions and Objects
  42. Class Templates and Nontype Parameters, Templates and Static Members
  43. Matrices, Design Recipe, Problem Analysis, Design Issues and Class Interface
  44. Matrix Constructor, Matrix Class, Utility Functions of Matrix, Input, Transpose Function
  45. Operator Functions: Assignment, Addition, Plus-equal, Overloaded Plus, Minus, Multiplication, Insertion and Extraction