MCA

Object Oriented Concepts & Programming (2620002)

Prepared by : Niraj A. Mandaliya

:: KEY POINTS ::

CHAPTER : 3CLASSES & OBJECTS

This pointerThis pointer is known as a default pointer in any function.This pointer is basically work to receive the addresses or

references for passing to called function.We can call any function at that time calling function is

receive the address using this pointer.We can not pass any argument in function at that time this

pointer is get the address.

Chapter : 3

Reference variable is known as a alias name of actual variable. It is similar to the pointer.

Reference variable is known as we can call the any function at that time we can pass the reference of the actual variable, that time reference variable is receive the reference of the actual variable.

We can change the any value of variable in user define function(UDF) at that time this value is directly change in the actual variable in main function. ex.

Call by Reference in C++ Chapter : 3

C++ allows to declare any function as a inline. Inline function is one kind of function (UDF), this function is

eliminate the context switching process. Inline function is declare using inline keyword. When a function is defined inside a class declaration, it is

automatically made into an inline function. It declare before the function header. ex.

inline <return type> class_name :: function_name(); //function header.

inline void student :: getdata();

Inline function Chapter : 3

It is possible to grant a nonmember function access to the private members of a class by using a friend.

A friend function has access to all private or protected member of the class for which it is a friend.

To declare a friend function, include its prototype within the class, preceding it with the keyword friend.

It basically used with the nonmember function.class student

friend function Chapter : 3

In the default argument we can not pass any arguments in the calling function at that time this function automatically takes the default arguments.

The default argument always write after declare the normal arguments or parameters.

Its implicitly pass the arguments.Ex.

void getdata(int x,int y,float pi=3.14); // prototype PI is default argument

In main function how to call this function Simple si; // create class object

si.getdata(10,20);

Default argument Chapter : 3

In c language, we can pass built-in data type as a argument of any function.

The C++ provide the capability to pass whole object as a argument.

We can pass the object as a argument in any member function of the class.

We can not pass the object as a argument in any normal UDF.

Pass object as a parameterChapter : 3

Prototyping

Prototyping is mechanism by which that define name of function (UDF),number of arguments with datatype and return type of the function that is like to be class.

It is declare inside class as a member function.

Ex.return_type function_name(arguments,…);

Chapter : 3

CHAPTER : 4FUNCTIONS

Function OverloadingIn C++ we can use the function

overloading.Function overloading is known as a we can

declare same name of function in multiple time with different arguments, different datatype and order of arguments.

Ex.void sum(int x);void sum(float x);void sum(int x,int y);void sum(int x,float y,char ch);

Chapter : 4

Static memberStatic member is known as a one kind of

member, it can share common memory for all the class objects.

All the objects are access the common memory of static data member.

Static data member declare inside class using static keyword and it declare outside the class using scope resolution (:: ) operator.

Static data member always return the previous value.

Syntax: static <data type> variable name; //inside class

<return type> class_name :: variable name = value;

Chapter : 4

Static member functionStatic member function is known as similar

like a common member function but it always access the static data members.

It can not access the non static data members.

Static member function can’t use the this pointer.

Static member function can not be declare virtual.

Static member function directly call using class name.Class_name : : member function_name();It also call using the object.Object_name . member function_name();

Chapter : 4

Function pointerWhen a program contain a large number of

function to choose from, this feature become very useful.

If the switch case statement is used instead, it will have a longer code and is less efficient.

Such a check whether each and every function name exists.

This is done to find which function is called and then call that function.

Instead, if the function pointer is passed, it will automatically call the required function.

Ex. Book page no:158

Chapter : 4

Mutable data memberThe mutable keyword can only be applied

to non static and non constant data members of a class. If a data member is declare mutable then it is legal to assign a value to this data member from a const member function.

The mutable keyword can only be applied to non static data members of a class.

Chapter : 4

Whenever objects are passed in a function and return an object the following process is performed by compiler.

For example: Time3 = Difference (Time1, Time2); Here Time1, Time2 & Time3 are three objects and Difference is a non member function. The complier generated code does the following operations. (1) Construct temporary object (for example Temp) (2) Assign Temp the value returned by Difference function. [Time1, Time2, &Temp] (3) Time3 = Temp (4) delete (Temp) Using pass by value for such objects results in inefficient as the value argument results in

copying of the object to the allocated space (for the local variable) in the function and then calling the constructor to initialize, followed by a destructor call to destroy the object while returning.

This is inefficient in terms of space and time. In this case , the argument can be passed by reference to avoid unnecessary temporary copying of the object for calling the function.

Also, in this function, not how the object is returned . it is again copying of local object into the return object( a temporary object), which entails an unnecessary cost. The return can also be done by referece, so that such temporary object creation can be avoided.

If you still prefer copying the object it is fine : C++ compiler can automatically detect this and avoid this creation of temporary return object, which is know as Named Return Value optimization (NRV).

NRV is an optimization technique used by the compiler to avoid unnecessary temporary object creation and destruction while returning a struct / class object. The idea is to pass the object by address to make changes and avoid returning it as the object return requires an unnecessary object creation and destruction.

NRV optimization Chapter : 4

Mangling When a function call made in c++ compiler it self add

additional information to the function definition to differentiate function, this process is known as Mangling.

It is needed in c++ because function overloading.Compiler internally convert every overloaded function

with new name and it is known by compiler.

Linkage specification It is a process to specified link of c

language function with c++ program.C++ linkage is default so no need to

mention explicite specifications.

Chapter : 4

Volatile functionA member function declare as a volatile if it is

invoke by volatile object.A volatile object value can be changed by

external parameter or resource.An object taking an input from a LANCARD does

not take input from our program.As a when the hardware input the value related

to it. Change without our program knowledge.

Chapter : 4

CHAPTER : 7CONSTRUCTOR &

DESTRUCTOR

Constructor Constructor is a special member function which is having the same name of

the class. Constructor is used to initialize the member of the class. The constructor does not have any return type specification because it does

not return any value. Constructor must be declare public visibility scope. Constructor is automatically executed when any object of the class is define. Constructor can not be a virtual. Ex.

Class class_name{

data_members;public:class_name() //default constructor.{//constructor body;}

}; There are following types of constructors.

Chapter : 7

Empty constructorIn constructor declaration we can not give any

argument in constructor declaration or we not give any statements inside constructor this known as empty constructor.

E.xclass class_name{

---------public:

class_name() {}

};

Chapter : 7

Default constructorWe can not pass any arguments or parameters in constructor

declaration but we can give initialize statements inside the constructor is known as default constructor.class class_name{-------public:class_name(){// statements;}};

There are two type of default constructorsCompiler define default constructorUser define default constructor.

Chapter : 7

Compiler define default constructorWhen we are create object of any class and we

can not declare any default constructor in class at that time compiler call the automatically one default constructor implicitly is known as compiler define default constructor.

This constructor gives garbage values.void main(){

student s1; //s1 object call compiler default constructor automatically.

s1.disp();}

Chapter :7

User define default constructorUser can declare any constructor inside the class and

initialize the data member value is known as user define default constudtor, its call explicitly.class student{int rno,age;public:student(){rno=0;age=21;}};

Chapter : 7

Parameterized constructorThe parameterized constructor is the

constructor which access argument or parameters during the object creation.

We can pass arguments or parameters in constructor is known as parameterized constructor.

It always required the parameters.

Chapter :7

Copy constructorWhen we have a single argument containing an object

reference of the same type of object to a constructor, it is known as a copy constructor.

The copy constructor is a special kind of constructor which creates a new object which is a copy of an existing one, and does it efficiently.

The copy constructor receives an object of its own class as an argument, and allows creating a new object which is copy of another without building it from scratch.

There are 3 situations in which the copy constructor is called:When we make copy of an object.When we pass an object as an argument by value to a method.When we return an object from a method by value.

Chapter : 7

Declaration of copy constructor. class Test { string str; public : Test(); Test(const Test &s) { str = s.str; } }; The following are the different uses ; // create an object which is copy of another object Test s1("hello"); Test s2(s1); // copy constructor activated // create an object as a copy of a temporary object Test s3(Test("abc"));  string s4 = s1; // object s4 does not activate the constructor, but its copy constructor to

make only a copy of s1, rather than building a new object

Chapter : 7

You have to use const in the argument at the copy constructor to create an object as a copy of a temporary object: e.g. Test(const Test &s).

It is also possible to create a new object as copy of a different object without using a copy constructor.

For example :Test s4;s4.set(s1); This is an example of

inefficient code. Since s4 first call its constructor to build a new object and then it make a bit-wise copy of s1. The whole process of calling the constructor to build an object which next is being rewritten, is wasteful, takes time and resources. Copy constructor allows you to prevent this inefficiency. Chapter : 7

Default copy constructorIf the programmer does not declare the copy constructor for a

class, the compiler will add its own default copy constructor for the objects derived from that class.

Default copy constructor does a very simple operation, they will do a bit-wise (member-wise) copy of an object, which means that the object will be copied bit by bit.

Test s1("hello");Test s2(s1);Test s2 = s1; //the same as above

Private copy constructorIf a copy constructor is defined in a private section,

the objects of the class cannot call it.

Chapter : 7

MIL(member initialization list)First initialize all member of classThe MIL is only method to initialize constant

member, reference member and object which are data member of a class.

C++ does not allows to initialize constant variable(members) and reference member directly in declaration statements

Chapter : 7

Destructor Destructor are usually used to deallocate

memory and do other clean up for a class object ad its class members when the object is destroyed.

A destructor is called for a class object when that object passes out of scope or is explicitly deleted.

A destructor is a member function with the same name as its class prefixed bye ~ (tiled) sign.

Chapter : 7

Destructor takes no arguments and has no return type its address can not be taken.

Destructor can not be declare const, volatile, const volatile or static.

Destructor can be declared virtual or pure virtual.

Chapter : 6

Constructor Destructor Constructor is used to initialize the Object.

Destructor is used to destroy the object that are created in memory previously.

Constructor can takes arguments. Destructor can not take any arguments.

Constructor overloading can be possible means more than one constructor can be defined in same class.

Destructor overloading can not be possible.

Constructor has same name as class name.

Destructor has same name as class name with tiled operator.

Syntax of constructor:                class class_name                  {                     clas_sname(){}                     class_name(argulist){}                 } ;

Syntax of Destructor:                 class class_name                   {                       ~class-name(void){}                   };

 Constructor are of following:               1)Default Constructor.               2)Parameterized Constructor.               3)Copy Constructor.

Destructor has no any types.

Constructors can be used to dynamically initialize the memory.

Destructor can be used to deallocate the memory.

Constructor indirectly use the New operator to initialize the object.

Destructor indirectly use the Delete operator to destroy the object initialize by constructor.

Explicit constructor When a class contain a single parameterized constructor,

there are different method to invoke this constructor function for exampleStudent s1(“abc”);Student s1=“abc”;Student s1=student(“abc”);Student s1;

S1=“abc”; Without explicit constructor compiler will execute all three

statements and in second statement automatically type casting process and convert right side data into left an side type.

Suppose in same cases we don’t want to perform automatic type casting process while using ‘=‘ operator at that time a constructor is declare as a explicitly.

Chapter : 7

Chapter : 7

CHAPTER : 6OPERATOR OVERLOADING

Operator overloadingIt is the process which gives additional meaning

to an existing operator.To overloading any operator, we require to define

a overload function of an operator in a class.An operator function can be declared as a

member function or friend function of a class.An overload function can not be declared as a

non member function.An operator function declare with the “operator”

keyword.

Operator overloading is a process which implements an existing operator with new meaning in user define data type like class.

Operator are overloaded as a function.The main advantage of operator overloading concept in

C++ is to make program more readable.For implementing operator overloading concept, we can

be define operator function either as member function (non static) or friend function.

The different is that a friend function will have only one argument for unary operator(++,--) and two for binary operators (+,-,*,/,%).

While member function has no arguments for unary operator and only one for binary operator. This is because the object used to invoke the member function is passed implicitly and therefore is available for the member function using the pointer.

We can not overload this operatorsClass member access operator ( . .*);Scope resolution operator ( : : )Size of operator (sizeof)Condition operator ( ? : )Casting operator# and ## tokens for macro preprocessors.

Rules for operator overloadingOnly existing operator can be overloaded. New

operators cannot be overloaded e.g. **The overloaded operator must have at least one

operand that is of user defined type.We can not change the basic meaning of an

operator. That is to say, we can not redefine the plus(+) operator to subtract one value from the other.

Overloaded operator follow the syntax rules of the original operators. They can not be overridden.

we can not use friend function to overload certain operator like new & delete. Only member function is used to overload this type of operator.

Binary operators declared as member functions take one argument; if declared as friend functions, they take two arguments.

Overloaded operators cannot have default arguments.

All overloaded operators except assignment ( = operator) are inherited by derived class.

There are following operators can be overloaded

+ - * / % ^

~ ! , = < >

& <= >= | ++ --

<< >> == != && ||

+= -= *= /= %= ^=

&= |= <<= >>= [ ] ( )

-> ->* New New[ ] Delete Delete[ ]

User define conversion/type conversionwe know that when constants and variable of

different types are mixed in an expression, c language applies automatic type conversion to the operands as per certain rules.

Similarly as assignment operation also cause a the automatic type conversion.

The type of automatic converted to the type of the variable on the left side.

E.g. int m;float x=3.14;m=x;

Similarly in user define type or object, we can easily add two object of same class but if we want to add two different type of object then it is not directly possible.

Since the user-define data type are designed by us to suit our requirements, the compiler does not support automatic type conversion for such data types.

To solve this problem, we need to write our own conversion routine to guide the compiler what to do when such assignments are provided.

Type of conversions:

Built-in data type to object (UDT)Object (UDT) to built-in data typeWrapper classFrom one object to another type of

object.

Built-in data type to object (UDT)This is problem is solved with the help of

constructor.For example: student s1[10] takes an arguments

of built in data type and convert to a student type of an object.

Whenever we use constructor to initialize attribute, we convert the argument type to the native object type for the constructor.

Ex.

Object (UDT) to built-in data typeThe constructor did a good job in type conversion from

a basic type to class type.What about the conversion from a class to basic type ?

The constructor function do not support this operation. For that C++ allows us to define an overloaded casting operator that could be used to convert a class type to a basic type.

It is also know as conversion function.Syntax: this function converts a class type data to type

name. operator typename(){function statements;}

For example:The operator double () converts a class object to

type double, similar operator int () converts a class type to integer type and so on.

The casting operator function should satisfy the following conditions.It must be a class memberIt must not specify a return typeIt must not have any arguments.

Wrapper classSome of built in type are not objects, eg. Int, char etc. however,

for complete object orientation, they should be objects, for instance, if we want to have an integer class, we can specify functions for reading integer with proper validation checks.

If they are define as a class, we can inherits them to have our own class.

A class that provides a basic data type with some additional facilities is known as a wrapper classes.

Some times we may need to covert the wrapper class object into built in type objects and vice versa.

Converting from built in type to wrapper class is possible using constructors and the inverse is possible using conversion operators.

When we need to convert from a built in type object to a user defined object, we use constructors.

From one object to another type of objectIn some cases we would like to convert one class

type data to another class type.eg. Obj1 = Obje2Here obj1 is an object of class x and obj2 is an

object of class y. both are different classes objects.

Since conversion takes place from, class y to class x, class y is known as source class and class x is known as the destination class.

Such conversion between objects of different classes can be carried out by either a constructor or a conversion function (operator function).

Using constructor method.

Using conversion function.

CHAPTER : 9INHERITANCE

The mechanism of creating a new class from a base class or existing class is called a inheritance.

An existing class is known as a “base class” and new class is known as a “derived class”.

Derived class contains all features of base class and also contain a all feature of own class.

There are different type of inheritance.

Type of Inheritance1) single inheritance :

A class is derived from single base class is called single inheritance.

2)Multiple inheritance:A one base class derived from more than one derived class is

known as multiple inheritance.3)Hierarchical inheritance:

Many base classes are derived from one derived class is known as hierarchical inheritance.

4)Multi level inheritance.The mechanism of derived class from another derived class is

known as multilevel inheritance.5)Hybrid inheritance.

In this one base class is derived from more than one derive class and there many derived classes are derived from one derived class is known as hybrid inheritance.

How to inherit base class into derived class.<identifier> derived class_name : <access specifire> base class_name{}

Access specifires like, ………… private, public and protected

Ex.

class A{}class B:public A{}

Different form of Inheritance.

Derivations:Private:

Public:

Protected:

Effect of access specifier in further derivation. 1. If the access specifier is public:

1. The effective specifier in the derivation class is the same as base class(public remain public and protected remain protected in derived class).

2. if we inherit further as a public, they are again going to retain same access specifier. So public in base class is also public in derived class.

2. If access specifier is protected:1. The access specifier in derived class is protected in both for

public and protected members of base class.2. In further derivation as public then it doesn’t make public

members of base class as a public but instead it threaded as protected.

The most important difference between a member of the class derived as protected and as a private.if privately derived then member is not available for further inheritance, inheritance, in case of protected it is available for further inheritance.

Single inheritance.

Multiple inheritance

Hierarchical inheritance

Multilevel inheritance

Hybrid inheritance

Introduction of Access Control

The member function of the class, member function of the derived class, friend and object can access different part of the class.

Access for public, private and protected members is different for all entities.

Access control describe who can access what and in which form.

Available or accessible entities can be determined bye the access control. Three entities available for access are public, private and protected.

Introduction of Access Declaration

If we derived a class in private way, we will not be able to access data members of the base class members using derives class objects.

If we derived in a public way, all members will be accessed as public.

If we want to derive a class and want only a few and not all of the public members to be available to objects of the derived class, then we have to provide access declaration.

Using access declaration, we can provide public access to some of the base class members even after deriving them as private.

Ex.

Virtual Base ClassIf we think about hybrid inheritance. Suppose

there is a class base class A from which we derive two different classes B & C.

We may derive a new class D from B & C classes, then are two copies of base class A now copies in D class, one from B and second from C.

It is diagrammatically shown in figure.

We have two different copies of all members of base class elements. This has two distinct problems,The first problem is the code size increase, which

is very obvious.The second problem is how to access a member

class object from a further derived class,. We obviously need the scope resolution operator.

In such a case compiler would get confused between two base class members.

Having two different copies and need for qualifying with a base class name is a serious problem in some case.

To solve this problem we have to precede the first derivation by keyword virtual.

We can write virtual public or public virtual.The compiler would consider both the

definition the same way. Whenever compiler finds virtual keyword with derivation, it would ensure that two instance of the same base class are not inheritance into the class derived from the derived class of base.

We have a single instance in class D, this is the advantage of virtual base classes.

Abstract Base Class.The classes without any object are known

as abstract classes,A class that contains at least one pure

virtual function is said to be abstract.An abstract class contain one or more

function for which there is no definition ( that is, a pure virtual function) , no objects pointers and references to an abstract class, this allows abstract classes to support run-time polymorphism, which relies upon base-class pointers and references to select the proper virtual function.

Thank You…