Government Arts College(Autonomous)

Coimbatore – 641018
Re-Accredited with ‘A’ grade by NAAC

Object Oriented Programmimg with C++

Dr. S. Chitra
Associate Professor
Post Graduate & Research Department of Computer Science
Government Arts College(Autonomous)
Coimbatore – 641 018.
 Year Subject Title Sem. Sub Code

2018 -19
OBJECT ORIENTED PROGRAMMING WITH C++ III 18BCS33C
Onwards

Objective:
•Learn the fundamentals of input and output using the C++ library
•Design a class that serves as a program module or package.
•Understand and demonstrate the concepts of Functions, Constructor and inheritance.

UNIT – I
Principles of Object Oriented Programming: Software Crisis - Software Evolution - Procedure
Oriented Programming - Object Oriented Programming Paradigm - Basic concepts and benefits of
OOP - Object Oriented Languages - Structure of C++ Program - Tokens, Keywords, Identifiers,
Constants, Basic data type, User-defined Data type, Derived Data type – Symbolic Constants –
Declaration of Variables – Dynamic Initialization - Reference Variable – Operators in C++ - Scope
resolution operator – Memory management Operators – Manipulators – Type Cast operators –
Expressions and their types – Conversions – Operator Precedence - Control Structures
UNIT – II

Functions in C++: Function Prototyping - Call by reference - Return by reference - Inline functions -
Default, const arguments - Function Overloading – Classes and Objects - Member functions - Nesting
of member functions - Private member functions - Memory Allocation for Objects - Static Data
Members - Static Member functions - Array of Objects - Objects as function arguments - Returning
objects - friend functions – Const Member functions .

UNIT – III

Constructors: Parameterized Constructors - Multiple Constructors in a class - Constructors with

default arguments - Dynamic initialization of objects - Copy and Dynamic Constructors - Destructors
- Operator Overloading - Overloading unary and binary operators – Overloading Using Friend
functions – manipulation of Strings using Operators.
UNIT – IV

Inheritance: Defining derived classes - Single Inheritance - Making a private member inheritable – Multilevel,
Multiple inheritance - Hierarchical inheritance - Hybrid inheritance - Virtual base classes - Abstract classes -
Constructors in derived classes - Member classes - Nesting of classes.

UNIT – V

Pointers, Virtual Functions and Polymorphism: Pointer to objects – this pointer- Pointer to derived Class -
Virtual functions – Pure Virtual Functions – C++ Streams –Unformatted I/O- Formated Console I/O – Opening
and Closing File – File modes - File pointers and their manipulations – Sequential I/O – updating a file :Random
access –Error Handling during File operations – Command line Arguments.

TEXT BOOKS

1.E. Balagurusamy, “Object Oriented Programming with C++”, Fourth edition, TMH, 2008.
Unit V : Pointers, Virtual Functions & Polymorphism

Polymorphism
Pointers

A pointer is an address variable. i.e., a variable that stores the address of another variable

Declaring a Pointer Variable:

Pointers to Objects
An object of a class behaves identically as any other variable. Just as pointers can be
defined in case of base C++ variables so also pointers can be defined for an object
type. To create a pointer variable for the following class

class employee
{
int code;
char name [20] ;
public:
inline void getdata ( )= 0 ;
inline void display ( )= 0 ;
};

The following codes is written

employee *abc;

This declaration creates a pointer variable abc that can point to any object of
employee type.
this Pointer
C++ uses a unique keyword called "this" to represent an object that invokes a member function. 'this' is a
pointer that points to the object for which this function was called. This unique pointer is called and it passes
to the member function automatically. The pointer this acts as an implicit argument to all the member
function,
for e.g.

class ABC
{
int a ;
-----
-----
};

The private variable ‘a’ can be used directly inside a member function, like a=123;

We can also use the following statement to do the same job.

this → a = 123
e.g.
class stud
{
int a;
public:
void set (int a1)
{
this->a = a1; //here this point is used to assign a class level ‘a’ with the argument ‘a’
}

void show ( )
{
cout << a<<“\n”;
}
};

main ( )
{
stud S1, S2;
S1.set (5) ; S2.set(100);
S1.show( );S2.show ( );
}
o/p
5
100
Pointers to Derived Classes
Polymorphism is also accomplished using pointers in C++. It allows a pointer in a base class to point to
either a base class object or to any derived class object. We can have the following Program segment
show how we can assign a pointer to point to the object of the derived class.
class base
{
//Data Members
//Member Functions
};
class derived : public base
{
//Data Members
//Member functions
};
void main ( ) {
base *ptr; //pointer to class base
derived obj ;
ptr = &obj ; //indirect reference obj to the pointer
//Other Program statements
}
The pointer ptr points to an object of the derived class obj. But, a pointer to a derived class object may
not point to a base class object without explicit casting.
For example, the following assignment statements are not valid
void main ( )
{
base obja;
derived *ptr;
ptr = &obja; //invalid.... .explicit casting required
//Other Program statements
}
A derived class pointer cannot point to base class objects. But, it is possible by using explicit casting.
void main ( )
{
base obj ;
derived *ptr; // pointer of the derived class ptr = (derived *) & obj; //correct reference //Other Program
statements
}
Streams & Console I/O
C++ accomplishes input/output operations using concept of stream.

A stream is a series of bytes whose value depends on the variable in which it is stored.

This way, C++ is able to treat all the input and output operations in a uniform manner.

Thus, whether it is reading from a file or from the keyboard, for a C++ program it is simply a stream.

Objects cin and cout (pre-defined in the iostream.h file) are used for the input and output of data of various types.

This has been made possible by overloading the operators >> and << to recognize all the basic C++ types.

The >> operator is overloaded in the istream class and « is overloaded in the ostream class.

The following is the general format for reading data from the keyboard:

cin >> variable1 >> variable2 >>… …>> variableN;

Where variable1, variable2,.... are valid C++ variable names that have been declared already.

This statement will cause the computer to halt the execution and look for input data from the
keyboard.
The input data for this statement would be:

data1 data2......dataN
The input data are separated by white spaces and should match the type of variable in the cin list.

Spaces, newlines and tabs will be skipped.

The operator >> reads the data character by character and assigns it to the indicated location.

The reading for a variable will be terminated at the encounter of a white space or a character that does not
match the destination type.

For example, consider the following code:

int code;
cin >> code;

Suppose the following data is given as input:

1267E

The operator will read the characters up to 7 and the value 1267 is assigned to code. The
character E remains in the input stream and will be input to the next cin statement.
The general format of outputting data:

cout << iteml <<item2 << .. ..<< itemN;

The items, item1 through itemN may be variables or constants of any basic types.
Formatted Console I/O Operations
C++ supports a number of features that could be used for formatting the output. These
features include:
 ios class functions and flags.
 Manipulators.
 User-defined output functions.
The ios class contains a large number of member functions that could be used to format the
output in a number of ways. The most important ones among them are listed below.
The put() and get() Functions
The classes istream and ostream define two member functions get() and put() respectively to handle the single character
input/output operations.
There are two types of get() functions.

Both get(char*) and get(void) prototypes can be used to fetch a character including the blank space, tab and
the newline character.
The get(char*) version assigns the input character to its argument and the get(void) version returns the input character.
Since these functions are members of the input/output stream classes, these must invoked by using an appropriate
object.
For instance, look at the code snippet given below:
char c;
cin.get (c); //get a character from keyboard and assign it to c
while (c!= '\n')
{
cout << c; //display the character on screen cin.get (c);
} //get another character
This code reads and displays a line of text (terminated by a newline character).
Remember, the operator> >can also be used to read a character but it will skip the white spaces and newline character.
The above while loop will not work properly if the statement
cin >> c;
is used in place of
cin.get (c);
The get(void) version is used as follows:
char c;
c = cin.get(); //cin.get (c) replaced
The value returned by the function get() is assigned to the variable c.
The function put(), a member of ostream class, can be used to output a line of text, character by character. For
example,

cout << put (‘x’);

displays the character x and
cout << put (ch) ;
displays the value of variable ch.
The variable ch must contain a character value. We can also use a number as an argument to the function put (). For
example,

cout << put (68) ;

displays the character D. This statement will convert the int value 68 to a char value and display the character whose
ASCII value is 68,

The following segment of a program reads a line of text from the keyboard and displays it on the screen.
char c; .
cin.get (c) //read a character
while (c!= ‘\n’)
{
cout<< put(c); //display the character on screen cin.get (c ) ;
}
The getline () and write () Functions
We can read and display a line of text more efficiently using the line-oriented input/output functions getline() and write().
The getline() function reads a whole line of text that ends with a newline character. This function can be invoked by using
the object cin as follows:
cin.getline(line, size);
This function call invokes the function which reads character input into the variable line. The reading is terminated as soon
as either the newline character '\n' is encountered or size number of characters are read (whichever occurs first). The
newline. character is read but not saved. Instead, it is replaced by the null character.
For example; consider the following code:
char name [20] ;
cin.getline(name, 20);
Assume that we have given the following input through the keyboard:
Neeraj good
This input will be read correctly and assigned to the character array name. Let us suppose the input is as follows:
Object Oriented Programming
In this case, the input will be terminated after reading the following 19 characters:
Object Oriented Pro
After reading the string/ cin automatically adds the terminating null character to the character array.
Remember, the two blank spaces contained in the string are also taken into account, i.e.
between Objects and Oriented and Pro.
We can also read strings using the operator >> as follows:
cin >> name;
But remember cin can read strings that do not contain white space. This means that cin can read just one word and not a
series of words such as “Neeraj good”
Random Access Files
Command Line Arguments
REFERENCES:

1.E. Balagurusamy, “Object Oriented Programming with C++”, Fourth edition, TMH,
2008.

2. LECTURE NOTES ON Object Oriented Programming Using C++ by Dr. Subasish Mohapatra,
Department of Computer Science and Application College of Engineering and Technology, Bhubaneswar
Biju Patnaik University of Technology, Odisha

3. K.R. Venugopal, Rajkumar, T. Ravishankar, “Mastering C++”, Tata McGraw-Hill

Publishing Company Limited

4. Object Oriented Programming With C++ - PowerPoint Presentation by Alok Kumar

5. OOPs Programming Paradigm – PowerPoint Presentation by an Anonymous Author