OOPs Slides by Harish Kumar

Computer Programming
Harish Kumar, UIET, Panjab University, Chandigarh
Queries: harishk@pu.ac.in
Session I
Queries: harishk@pu.ac.in 2
Computer Fundamentals
Software
• A computer program is…

– A set of instructions for a computer to follow
• Computer software is …
– The collection of programs used by a computer
• Includes:
– Various System Software like Editors, Translators, Operating Systems etc.
– Various Application Software like Word Processor, Simulation Software etc.
Computer Organization
– Five main components
• Input devices --------- Allows communication to the computer
• Output devices ------- Allows communication to the user
• Processor (CPU) ----- Executing Instructions (Pentium, Sparc, PowerPc, K6)
• Main memory -------- Memory locations containing the running program (RAM)
• Secondary memory -- Permanent record of data often on a disk (e.g. Tape, Hard
Disk, Floppy Disk etc. )
Computer Memory
• Main Memory
– Long list of memory locations

• Each contains zeros and ones
• Can change during program execution
– Binary Digit or Bit
• A digit that can only be zero or one
– Byte
• Each memory location has eight bits
– Address
• Number that identifies a memory location
Larger Data Items
• Some data is too large for a single

byte
– Most integers and real numbers are
too large
– Address refers to the first byte
– Next few consecutive bytes can store

the additional bits for larger data
int sum(int[] x) {
int sum = 0; 00101010101010
n = 0; 10101011111010
while (n < x.length) {
sum += x[n];
11101010101110
} 00101010101010
return sum; ...
}
Data or Code?
• ‘A’ may look like 01000001
• 65 may look like 01000001
• An instruction may look like 01000001
• How does the computer know the meaning of 01000001?

– Interpretation depends on the current instruction
Secondary Memory
• Main memory stores instructions and data while a program is

running.
• Secondary memory
– Stores instructions and data between sessions
– A file stores data or instructions in secondary memory
Computer Input
• Computer input consists of
– A program
– Some data
High-level Languages
• Programming is the art of telling being what one wants the

computer to do
• Common programming languages include …
C C++ Java Pascal Visual Basic FORTRAN COBOL Lisp etc.
• There are approximately 150 Computer High Level Languages
• These high – level languages

– Resemble human languages
– Are designed to be easy to read and write
– Use more complicated instructions than the CPU can follow
– Must be translated to zeros and ones for the CPU to execute a program
Compilers
• Translate high-level language to

machine language
– Source code
• the original program in a high level
language
– Object code
• the translated version in machine
language
Incomplete list of C++ compliers
• Apple C++
• Bloodshed Dev – C++
• Borland C++
• Cygwin (GNU C++)
• Intel C++ for Linux
• GNU CC Source
• Borland C++
• HP C++
• IBM C++
• SUN C++
Linkers
• Some programs we use are already compiled
– Their object code is available for us to use
– For example: Input and output routines
• A Linker combines
– The object code for the programs we write
and
– The object code for the pre-compiled routines
into
The machine language program the CPU can run
Programming and Problem Solving
• Algorithm
– A sequence of precise instructions which leads to a solution
• Program
– An algorithm expressed in a language the computer can understand
– A Computer program is a set of instructions that directs a computer to
perform tasks. Computer programmers use program development tools that
generate these instructions automatically or use a programming language to
write these instructions themselves.
Program Design
• Programming is a creative process

– No complete set of rules for creating a program
• Program Design Process

– Problem Solving Phase
• Result is an algorithm that solves the problem
– Implementation Phase
• Result is the algorithm translated into a programming language
Problem Solving Phase
• Be certain the task is completely specified
– What is the input?

– What information is in the output?
– How is the output organized?
• Develop the algorithm before implementation
– Experience shows this saves time in getting your program to run.

– Test the algorithm for correctness
Implementation Phase
• Translate the algorithm into a programming language

– Easier as you gain experience with the language
• Compile the source code

– Locates errors in using the programming language
• Run the program on sample data

– Verify correctness of results
• Results may require modification of the algorithm and program
Session II
Object Oriented Programming
• Abbreviated OOP
• Used for many modern programs
• Program is viewed as interacting objects
– Each object contains algorithms to describe its behavior

– Program design phase involves designing objects and their algorithms
OOP Characteristics
• Encapsulation
– Information hiding
– Objects contain their own data and algorithms
• Inheritance
– Writing reusable code

– Objects can inherit characteristics from other objects
• Polymorphism
– A single name can have multiple meanings depending on its context
Introduction to C++
• Where did C++ come from?

– Derived from the C language
– C was derived from the B language
– B was derived from the BCPL language
• C developed by Dennis Ritchie at AT&T Bell Labs in the 1970s.
– Used to maintain UNIX systems
– Many commercial applications written in c
• C++ developed by Bjarne Stroustrup at AT&T Bell Labs in the 1980s.
– Overcame several shortcomings of C
– Incorporated object oriented programming
– C remains a subset of C++
A Sample C++ Program
• A simple C++ program begins this way
#include <iostream.h>
int main()
{
• And ends this way

return 0;
}
Program Layout (1/3)
• Compiler accepts almost any pattern of line breaks and indentation
• Programmers format programs so they are easy to read
– Place opening brace ‘{‘ and closing brace ‘}’ on a line by themselves
– Indent statements
– Use only one statement per line
• Variables are declared before they are used
– Typically variables are declared at the beginning of the program

– Statements (not always lines) end with a semi-colon
• Include Directives
#include <iostream.h>
– Tells compiler where to find information about items used in the program
– iostream is a library containing definitions of cin and cout
• To begin the main function of the program

int main()
{
• To end the main function
return 0;
}
– Main function ends with a return statement
C++ source code is written with a text editor
Program Errors
• Syntax errors
– Violation of the grammar rules of the language
– Discovered by the compiler
• Error messages may not always show correct location of errors
• Run-time errors
– Error conditions detected by the computer at run-time
• Logic errors
– Errors in the program’s algorithm
– Most difficult to diagnose
– Computer does not recognize an error
Program Style - Comments
• // is the symbol for a single line comment

– Comments are explanatory notes for the programmer
– All text on the line following // is ignored by the compiler
– Example: //calculate regular wages
gross_pay = rate * hours;
• /* and */ enclose multiple line comments

– Example: /* This is a comment that spans
multiple lines without a
comment symbol on the middle line
*/
C++ Basics
Overview
 Variables and Assignments
 Input and Output
 Data Types and Expressions
 Simple Flow of Control
 Program Style
Variables and Assignments
• Variables are like small blackboards

– We can write a number on them
– We can change the number
– We can erase the number
• C++ variables are names for memory locations

– We can write a value in them
– We can change the value stored there
– We cannot erase the memory location
• Some value is always there
Identifiers & Keywords
• Variables or function names are called identifiers

• Choosing variable names
– Use meaningful names that represent data to be stored
– First character must be
• a letter or underscore character
– Remaining characters must be
• Letters, numbers, underscore character
• Keywords (also called reserved words)

– Are used by the C++ language
– Must be used as they are defined in the programming language
– Cannot be used as identifiers
Declaring Variables
• Declaration syntax:
– Type_name Variable_1 , Variable_2, . . . ;
• Before use, variables must be declared
– Tells the compiler the type of data to store

Examples: int number_of_bars;
double one_weight, total_weight;
– int is an abbreviation for integer.
• could store 3, 102, 3211, -456, etc. Number_of_bars is of type integer
– double represents numbers with a fractional component
• could store 1.34, 4.0, -345.6, etc. one_weight and total_weight are both of type
double
Assignment Statement
• An assignment statement changes the value of a variable
– Assignment statements end with a semi-colon
– The single variable to be changed is always on the left of the
assignment operator ‘=‘
– On the right of the assignment operator can be
• Constants -- age = 21;
• Variables -- my_cost = your_cost;
• Expressions -- circumference = diameter * 3.14159;
• The ‘=‘ operator in C++ is not an equal sign

– Statement “bars = bars + 3;” cannot be true in algebra
Initializing Variables
• Declaring a variable does not give it a value

– Giving a variable its first value is initializing the variable
• Variables are initialized using assignment statements
double mpg; // declare the variable

mpg = 26.3; // initialize the variable
• Declaration and initialization can be combined:
double mpg = 26.3, area = 0.0 , volume;
Input and Output
• A data stream is a sequence of data

– Typically in the form of characters or numbers
• An input stream is data for the program to use

– Typically originates
• at the keyboard, mouse, some hardware circuit etc
• at a file
• An output stream is the program’s output

– Destination is typically
• the monitor, hardware circuit
• a file
Output using cout
• cout is an output stream sending data to the monitor
• The insertion operator "<<" inserts data into cout
• Example:
cout << number_of_bars << " candy bars\n";
– This line sends two items to the monitor
• The value of number_of_bars
• The quoted string of characters " candy bars\n"
– The ‘\n’ causes a new line to be started following the ‘s’ in bars
• A new insertion operator is used for each item of output
– Here arithmetic is performed in the cout statement

cout << "Total cost is $" << (price + tax);
Input Using cin
• cin is an input stream bringing data from the keyboard
• The extraction operator (>>) removes data to be used
• Example:
cin >> number_of_bars;
cin >> one_weight;
• This code prompts the user to enter data then reads two
data items from cin
– The first value read is stored in number_of_bars
– The second value read is stored in one_weight
Reading Data From cin
• Multiple data items are separated by spaces

• Data is not read until the enter key is pressed
– Allows user to make corrections
• Example:
cin >> v1 >> v2 >> v3;
– Requires three space separated values

– User might type
34 45 12 <enter key>
Designing Input and Output
• Prompt the user for input that is desired

– cout statements provide instructions
cout << "Enter your age: ";

cin >> age;
• Notice the absence of a new line before using cin
• Echo the input by displaying what was read

– Gives the user a chance to verify data
cout << age << " was entered." << endl;
Data Types and Expressions
• 2 and 2.0 are not the same number

– A whole number such as 2 is of type int
– A real number such as 2.0 is of type double
• Numbers of type int are stored as exact values
• Numbers of type double may be stored as approximate values due to limitations

on number of significant digits that can be represented
• Type int does not contain decimal points

• Examples: 34 45 1 89
Writing Double Constants
• Type double can be written in two ways
– Simple form must include a decimal point

• Examples: 34.1 23.0034 1.0 89.9
– Floating Point Notation (Scientific Notation)

• Examples: 3.41e1 means 34.1
3.67e17 means 367000000000000000.0
5.89e-6 means 0.00000589
– Number left of e does not require a decimal point
– Exponent cannot contain a decimal point
Session III
Type Casting
• Problem with integer division:
int total_candy = 9, number_of_people = 4;

double candy_per_person;
candy_per_person = total_candy / number_of_people;
– candy_per_person = 2, not 2.25
• A Type Cast produces a value of one type from another type

– double(total_candy) produces a double representing the integer value of
total_candy
Operators
• Arithmetic operators: • Bitwise:

--: + - * / % --: & | ~ ^
• Comparison: • Shortcuts:
--: == != < > >= <= --: += *= - = (etc.)
• Logical: • Other:
--: && || ! --: << >> ?: -> etc.
• Assignment:
--: =
Operators
• The unary operators ++ and -- :

--: ++ increment by 1
--: -- decrement by 1
• The language C++ got its name by this operator!
• i++ and ++i have different behaviour
Results of Operators
• Arithmetic operators can be used with any numeric type
• An operand is a number or variable used by the operator
• Result of an operator depends on the types of operands

– If both operands are int, the result is int
– If one or both operands are double, the result is double
Integer Remainders
• % operator gives the remainder from integer division
int dividend = 5, divisor = 3, remainder;

remainder = dividend % divisor;
The value of remainder is 2
Control Statements
Boolean Expressions
• Boolean expressions are expressions that are either true or false
• Boolean expressions can be combined using && (AND) and ||

(OR) operator
&& and ||
&&
• Syntax: (Comparison_1) && (Comparison_2)
• Example: if ( (2 < x) && (x < 7) )
||
• Syntax: (Comparison_1) || (Comparison_2)
• Example: if ( (x= =1) || (x= =y) )
NOT
• ! -- negates any boolean expression

– !( x < y)
• True if x is NOT less than y
– !(x = = y)
• True if x is NOT equal to y
• ! Operator can make expressions difficult to understand…use only

when appropriate
For loop
for (expression_1; expression_2; expression_3)

{ statements; }
Example: 1. for (int i=0; i < count; i++)

{ printf (“I=%d”, i); }
2. for (int i=0, j=count-1; i < count && j>ii; i++, j--)
{ statements; }
• Nested loops can also be used.
Break & Continue Statements
• Common need is to either break or continue with loop.
• Continue goes to next iteration of loop
• Break steps out of loop
Array
• A collection of elements of same type

• E.g. float a[100] -- Access 1st element using a[0]
float a[ ] = {1.2, 2.90, 3.4} -- Complier will calculate dim.
Multi – dimensional arrays:
float a[10][20]
• Elements appear row wise (In FORTRAN column wise)
• Run time array size: float *x = new float [n]
Session IV
Functions
Function Call Syntax
• Function_name (Argument_List)
– Argument_List is a comma separated list:
(Argument_1, Argument_2, … , Argument_Last)
• Example:
– side = sqrt(area);
– cout << “2.5 to the power 3.0 is “ << pow(2.5, 3.0);
Programmer-Defined Functions
• Two components of a function definition

– Function declaration (or function prototype)
• Shows how the function is called
• Must appear in the code before the function can be called
• Syntax:
Type_returned Function_Name(Parameter_List);
– Function definition
• Describes how the function does its task
;
• Can appear before or after the function is called
• Syntax:
Type_returned Function_Name(Parameter_List)
{
//code to make the function work
}
Function Declaration
• Tells the return type
• Tells the name of the function
• Tells how many arguments are needed
• Tells the types of the arguments
• Tells the formal parameter names (optional)
– Formal parameters are like placeholders for the actual
arguments used when the function is called
• Example:
double total_cost(int number_par, double price_par);

Function Definition
• Provides the same information as the declaration
• Describes how the function does its task
function header
• Example:
double total_cost(int number_par, double price_par)
{
const double TAX_RATE = 0.05;
double subtotal = price_par * number_par;
return (subtotal + subtotal * TAX_RATE);
}
function body
The Return Statement
• Ends the function call
• Returns the value calculated by the function
• Syntax:
return expression;
– expression performs the calculation
or
– expression is a variable containing the calculated value
• Example:
return (subtotal + subtotal * TAX_RATE);

The Function Call
• Tells the name of the function to use

• Lists the arguments
• Is used in a statement where the returned value makes sense
• Example:
double bill = total_cost(number, price);

Alternate Declarations
• Two forms for function declarations
1. List formal parameter names
2. List types of formal parmeters, but not names
– First aids description of the function in comments
• Examples:
double total_cost(int number_par, double price_par);
double total_cost(int, double);
• Function headers must always list formal parameter names!

Order of Arguments
• Compiler checks that the types of the arguments are correct and in the
correct sequence.
• Compiler cannot check that arguments are in the correct logical order
• Example: Given the function declaration:

char grade(int received_par, int min_score_par);
int received = 95, min_score = 60;

cout << grade( min_score, received);
– Produces a faulty result because the arguments are not in the

correct logical order.
Passing Arguments
• Pass by value
• Pass by address
• Pass by reference
• Arguments for pass by reference & pass by address must

be variables, not numbers

Call Comparisons Call By Reference vs Value
• Call-by-reference • Call-by-value
– The function call: – The function call:
f(age); Memory f(age);
Name Location Contents
age 1001 34
initial 1002 A
hours 1003 23.5
1004
void f(int var_par);

void f(int& ref_par);
Mixed Parameter Lists
• Call-by-value and call-by-reference parameters can be mixed in the

same function
• Example:
void good_stuff(int& par1, int par2, double& par3);
– par1 and par3 are call-by-reference formal parameters
• Changes in par1 and par3 change the argument variable
– par2 is a call-by-value formal parameter
• Changes in par2 do not change the argument variable

void-Functions
• A subtask might produce

– No value
– One value
– More than one value
• We have seen how to implement functions that return one or more

values
• A void-function implements a subtask that returns no value or more

than one value
Using a void-Function
• void-function calls are executable statements

– They do not need to be part of another statement
– They end with a semi-colon
• Example:
show_results(32.5, 0.3);
NOT: cout << show_results(32.5, 0.3);

The Main Function
• The main function in a program is used like a void function…do

you have to end the program with a return-statement?
– Because the main function is defined to return a value of type int, the return
is needed
– C++ standard says the return 0 can be omitted, but many compilers still
require it

Session V

Default Arguments
• When function is called with less parameters, defaults are used
• Variables lacking default must be written first.
• Also possible:
void abc ( int = input());

Overloading Function Names
• C++ allows more than one definition for the same function name
– Very convenient for situations in which the “same” function is needed for
different numbers or types of arguments
• Polymorphism???

Overloading Examples
• double avg(double n1, double n2)
{
return ((n1 + n2) / 2);
}
• double avg(double n1, double n2, double n3)
{
return (( n1 + n2 + n3) / 3);
}
– Compiler checks the number and types of arguments in the function call to decide which
function to use
cout << avg( 10, 20, 30);
uses the second definition

Overloading Details
• Overloaded functions
– Must have different numbers of formal parameters
AND / OR
Must have at least one different type of parameter

Functions Calling Functions
• A function body may contain a call to another function

– The called function declaration must still appear before it is called
• Functions cannot be defined in the body of another function
– Example: void order(int& n1, int& n2)
{
if (n1 > n2)
swap_values(n1, n2);
}
• swap_values called if n1 and n2 are not in ascending order
• After the call to order, n1 and n2 are in ascending order
A function can call to itself (Recursion)

Procedural Abstraction
• The Black Box Analogy

– A black box refers to something that we know how to use, but the method of
operation is unknown
– A person using a program needs to know what the program does, not how it does it
• Functions and the Black Box Analogy

– A programmer who uses a function needs to know what the function does, not how it
does it
– A programmer needs to know what will be produced if the proper arguments are put
into the box

Information Hiding
• Designing functions as black boxes is an example of information
hiding
– The function can be used without knowing how it is coded
– The function body can be “hidden from view”
• Also allows us
– To change or improve a function definition without forcing programmers
using the function to change what they have done
– To know how to use a function simply by reading the function declaration
and its comment

Classes & Objects
Queries: harishk@pu.ac.in
What is Object Oriented Programming?
• Identifying objects and assigning responsibilities to

these objects.
• Objects communicate to other objects by sending

messages.
• Messages are received by the methods of an object

What is Object?
• an object represents an individual,

identifiable item, unit, or entity with
a well-defined role in the problem
domain.
An object is like a
black box. • The two parts of an object
The internal details
are hidden. Object = Data + Methods

The two steps of Object Oriented
Programming
• Making Classes: Creating, extending or reusing

classes.
• Making Objects interact: Creating objects from

classes and defining their relationships.

Why Create Objects?
• Keeps all related info (i.e., data) together

• Refer to all the related info by one name
• Protect the information
• Hide methods that use or change the info
• Keep methods together with their related info

Three Roles Related to Classes
• Class Provider
– made or purchased
– need for documentation of the class -- API
• Class User
– programmer or development team
• Program User or End User

Creating a Simple Class
class Change
{ private:
int rupees, dollars, pounds;
public:
int getRupees() { return rupees; }
int getDollars() { return dollars; }
int getPounds() { return pounds; }
…...
void printChange()
{ cout << "\nRupees: " << rupees << " Dollars: " << dollars << “
Pounds: " << pounds << endl; }
};

Points of Care/Caution
• keyword class is in lower case
• no semicolon after the class name
• a semicolon after closing brace
• private extends until the next word public or till the

end of the class definition
Classes & Objects
• All the objects of a class may have different data

values, but their allowed behaviours are the same.
• Class is a blue print for objects
• A class is defined by a unique name, attributes and

methods
• An object is defined by identity, state and behaviour

Instantiating an Object
• The class definition does not create any objects
• Instantiating is done just like declaring a variable of a built in data

type
• Instantiating is done by a constructor

– If the "class provider" does not provide a constructor, then the
C++ compiler provides a default one automatically
– The default constructor does not provide values to the data
members

Defining the Member Function Outside
the Class
int main()
{
….
} //end of main function
//DEFINE MEMBER FUNCTION OUTSIDE THE CLASS
void Change::addChange(Change myChange) // scope resolution
{
rupees += myChange.rupees; //can refer to data members directly
dollars += myChange.dollars;
pounds += myChange.pounds;
}
…. //another member function definition here

Points to Note about Defining Member Functions
Outside the Class Definition
• Need to use the scope resolution operator to identify which class the
function is associated with
• Need to specify return type and formal parameters the same as given in
declaration
• Within the function you can refer to the data members of the receiving
object using the data member names

Session VI

Class with a user defined default constructor
The syntax for a constructor is similar as for a method, but:

• It has the same name as the class.
• It has no return value.
Example:
class Change
{
private:
…..
public:
Change ( )
{ rupees=0; dollars=0; pounds = 0; cout <<“Object created.”; }
…..
};

Class with a parameterized constructor.
class Change
{
private:
…..
public:
Change (int initvalue)
{ rupees=initvalue; dollars=initvalue; pounds = initvalue; cout <<“Object
created.”; } …..
};
This constructor can be used as follows:
– Change firstObject(10);

Class with a copy constructor.
class Change
{ private:
public:
{ rupees=initvalue; dollars=initvalue; pounds = initvalue; cout <<“Object
created.”;}
Change (Change& smobject)
{ rupees = smobject.get(); }
…..
};
This constructor can be used as follows:
Change firstObject (10);
Change secondObject (firstObject);

Private Constructor & Destructor
• Must be called explicitly.

• Use this operator.
class Change
{ private:
{ rupees=initvalue; dollars=initvalue; pounds = initvalue; }
public:
show (int i)
{ this -> Change :: Change (i) }
};

Encapsulation
• Encapsulation is the practice of including in an object everything it

needs hidden from other objects. The internal state is usually not
accessible by other objects.
• Preventing unauthorized access to some piece of information or

functionality.
• Encapsulation prevents mistakes, not espionage. It is not a security

device.

Breaking Encapsulation – Friends
• C++ provides a way to enable a class or function to access the private parts of
another class.
• This is done by using the friend key-word in the class declaration.
class Change
{ friend void xyz (Change& smobject);
friend class Change2;
private:
public:
{ rupees=initvalue; dollars=initvalue; pounds = initvalue;
cout <<“Object created.”;}
};

Friends of the Change Class
• The function xyz can now access the private attributes:

void xyz(Change& c)
{ c.rupees = c.rupees + 5; }
• The class Change2 can now access the private attributes rupees etc..:
class Change2
{
void convert(Change& c )
{ c.rupees = c.dollar * 45; }
};

Class with in class
• A::B::C xyz
• xyz is object of innermost class C.

Session VII

Inheritance

What is Inheritance?
• Classes can inherit attributes and methods from other classes
• Inheriting class can add extra attributes and / or methods of its

own
• Extends the functionality of an existing class

C++ Syntax
• A simple base class: with 1 private attribute & 2 public methods

class BaseClass
{
private:
int x;
public:
void setX ( int x_in );
int getX ( );
};

C++ Syntax: public inheritance
• Public inheritance means that objects of the derived class can

access the public methods and attributes of the base class
class DerivedClass : public BaseClass
{
private:
int y;
public:
void setY ( int y_in );
int getY ( );
};

C++ Syntax: public inheritance
• Object of the inheritance class can access methods of the derived

class and also methods of the base class
main ( )
{
BaseClass base_object;
DerivedClass derived_object;
base_object.setX(7);
derived_object.setX(12);
derived_object.setY(1);
}
C++ Syntax: private inheritance
• Private inheritance means that objects of the derived class can’t

access the public methods and attributes of the base class – but the
methods of the derived class can !!!!!
class DerivedClass : private BaseClass
{
private:
int y;
public:
void setY(int y_in);
int getY();
};

C++ Syntax: the ‘protected’ keyword
• An object of a publicly derived class can access the public methods

of the base class, but not the private attributes
• Changing the private keyword in the base class to protected makes

the attributes available to derived classes

Base Class Derived Class Access Mode
Access Mode private public protected
derivation derivation derivation
public private public protected
private Not Inherited Not Inherited Not Inherited
protected private protected protected

C++ Syntax: inheriting constructors
• A derived class always inherits the constructor of the base class.

The base class constructor is called first.
• If the base class constructor takes no parameters then the

inheritance is implicit - you don’t need to do anything.
• If the base class constructor takes parameters then each derived

class needs to declare a constructor with the same parameters. You
can pass the arguments given to the derived class constructor to the
constructor for the base class

• Base class declares a constructor that takes a char pointer parameter

class Customer
{
Customer (char * name_in);
};
• Derived class declares a constructor that takes the same char pointer parameter
Class AccountCustomer : public Customer
{
AccountCustomer(char * name_in);
};

• In the implementation of the constructor for the derived class, the

parameter passed to the derived class constructor is passed down to
the base class constructor.
AccountCustomer :: AccountCustomer(char * name_in) :
Customer(name_in)
{
//main body of constructor..
}

C++ Syntax: inheriting destructors
• A derived class always inherits the destructor of the base class. The
derived class destructor is called first. This is the reverse of the
sequence for constructors
• Because destructors never take an argument there is no issue with

inheritance of destructor parameters.

Polymorphism
• From the Greek:

– Polus + Morphe = Polumorphos
(many ) (shape/form)
• In object-oriented computing it means: different forms of data

being handled by the same type of process.
• Example: The operator + has a different meaning in the

expression 2 + 3 (add two integers) than in 1.7 + 3.3 (add two
floating point numbers)
Types of Polymorphism
Three types of polymorphism:

a) Function Overloading, with the special case of operator
overloading. It can also be applied in non-object oriented
contexts
b) Method Overriding
c) Run-time Polymorphism (Dynamic Binding)
 Method overriding and run-time polymorphism are specific to

inheritance hierarchies and object oriented programming

Operator Overloading
• Operators such as +, -, *, <<, =, etc. can be seen as “functions”.

That means we can overload operators.
• The C++ syntax uses “function names” prefixed with “operator” for
overloading operators.

Overloading Operators - Example
Return_Type operator operator_symbol (parameters)

{
statements;
}

Overloading Operators - Example
class Change
{ private:
public:
Change operator + (Change other)
{ change temp;
temp.rupees = rupee + other.rupees;
temp.dollar = dollar + other.dollar;
temp.pounds = pounds + other.pounds;
return temp;
}
};

Operator Overloading
• Change A, B, C;
C=A+B
A will invoke operator function + and B will be passed as
argument.
• Note that "=" has already a default behaviour. When

"overloaded" it will be in fact overridden.

Polymorphic Pointers
• A pointer of a parent class is allowed to point to an object of

the child class. E.g.
class Vehicle { ... };

class Car : public Vehicle { ... };
main()
{ Vehicle vp = new Car(); }

Overriding Methods
• Methods in the parent class can be redefined in the child class.
class Vehicle { void move(int i); };

class Car : public Vehicle { void move(int i); };
main()
{
Vehicle vp = new Car();
vp->move(100);
}

Overriding Methods
• Which of these two move() methods will be called?
1. Static type binding & also default behaviour.

2. As vp is of type pointer to a Vehicle, the method of the
Vehicle is called

Overriding Methods – Virtual Keyword
class Vehicle { virtual void move(int i); };

class Car : public Vehicle { virtual void move(int i); };
main()
{
Vehicle vp = new Car();
vp->move(100);
}
– Allows dynamic binding.
– As vp points to a Car object the method of the Car is called

Abstract Methods & Classes
• Methods without any implementation (pure virtual methods).
class Vehicle { virtual void move(int i) = 0; };

class Car : public Vehicle { virtual void move(int i); };
main()
{ Vehicle vp = new Car();
vp->move(100);
}
 Vehicle objects cannot be instantiated (but Car objects).

Vectors
• Vectors are like arrays that can change size as your program runs
• Vectors, like arrays, have a base type
• To declare an empty vector with base type int:
vector<int> v;
– <int> identifies vector as a template class
– You can use any base type in a template class:
vector<float> v;

Initializing vector Elements
• Elements are added to a vector using the member function

push_back
– push_back adds an element in the next available position

– Example: vector<double> sample;
sample.push_back(0.0);

The size Of A vector
• The member function size returns the number of elements in a

vector
– Example: To print each element of a vector given the previous vector

initialization:
for (int i= 0; i < sample.size( ); i++)
cout << sample[i] << endl;

The Type unsigned int
• The vector class member function size returns an unsigned int
– Unsigned int's are nonnegative integers

– Some compilers will give a warning if the previous for-loop is not changed
to:
for (unsigned int i= 0; i < sample.size( ); i++)

cout << sample[i] << endl;

Alternate vector Initialization
• A vector constructor exists that takes an integer argument and

initializes that number of elements
– Example: vector<int> v(10);
initializes the first 10 elements to 0 v.size( ) would return 10
• [ ]'s can now be used to assign elements 0 through 9

• push_back is used to assign elements greater than 9

The vector Library
• To use the vector class

– Include the vector library
#include <vector>
– Vector names are placed in the standard namespace so the usual using
directive is needed:
using namespace std;

vector Issues
• Attempting to use [ ] to set a value beyond the size of a vector may

not generate an error
– The program will probably misbehave
• The assignment operator with vectors does an element by element

copy of the right hand vector
– For class types, the assignment operator must make independent copies

vector Efficiency
• A vector's capacity is the number of elements allocated in memory

– Accessible using the capacity( ) member function
• Size is the number of elements initialized
• When a vector runs out of space, the capacity is automatically

increased
– A common scheme is to double the size of a vector
• More efficient than allocating smaller chunks of memory

Controlling vector Capacity
• When efficiency is an issue

– Member function reserve can increase the capacity of a vector
• Example: v.reserve(32); // at least 32 elements
v.reserve(v.size( ) + 10); // at least 10 more
– resize can be used to shrink a vector

• Example: v.resize(24); //elements beyond 24 are lost

OOPs Slides by Harish Kumar

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

OOPs Slides by Harish Kumar

Transféré par

Droits d'auteur :

Formats disponibles

Computer Programming

Harish Kumar, UIET, Panjab University, Chandigarh

• A computer program is…

– Five main components

• Input devices --------- Allows communication to the computer

• Output devices ------- Allows communication to the user

• Processor (CPU) ----- Executing Instructions (Pentium, Sparc, PowerPc, K6)

– Long list of memory locations

• Some data is too large for a single

– Address refers to the first byte

– Next few consecutive bytes can store

• 65 may look like 01000001

• An instruction may look like 01000001

• How does the computer know the meaning of 01000001?

• Main memory stores instructions and data while a program is

– A file stores data or instructions in secondary memory

• Programming is the art of telling being what one wants the

• There are approximately 150 Computer High Level Languages

• These high – level languages

• Translate high-level language to

• Programming is a creative process

• Program Design Process

• Be certain the task is completely specified

– What is the input?

• Develop the algorithm before implementation

– Experience shows this saves time in getting your program to run.

• Translate the algorithm into a programming language

• Compile the source code

• Run the program on sample data

• Results may require modification of the algorithm and program

• Used for many modern programs

• Program is viewed as interacting objects

– Each object contains algorithms to describe its behavior

– Writing reusable code

– A single name can have multiple meanings depending on its context

• Where did C++ come from?

• And ends this way

• Compiler accepts almost any pattern of line breaks and indentation

• Programmers format programs so they are easy to read

• Variables are declared before they are used

– Typically variables are declared at the beginning of the program

• To begin the main function of the program

C++ source code is written with a text editor

• // is the symbol for a single line comment

• /* and */ enclose multiple line comments

 Input and Output

 Data Types and Expressions

 Simple Flow of Control

• Variables are like small blackboards

• C++ variables are names for memory locations

• Variables or function names are called identifiers

• Keywords (also called reserved words)

• Before use, variables must be declared

– Tells the compiler the type of data to store

• The ‘=‘ operator in C++ is not an equal sign

• Declaring a variable does not give it a value

• Variables are initialized using assignment statements

double mpg; // declare the variable

• A data stream is a sequence of data

• An input stream is data for the program to use

• An output stream is the program’s output

– Here arithmetic is performed in the cout statement

• Multiple data items are separated by spaces