3. This pointer
 This 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

5.  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

6.  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

7.  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

8.  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

9.  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 parameter Chapter : 3

11. 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

13. Function Overloading
 In 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

14. Static member
 Static 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 =
Chapter : 4

15. Static member function
 Static 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

16. Function pointer
 When 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

17. Mutable data member
 The 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

18.  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
NRV optimization Chapter : 4

19. 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

20. Volatile function
 A 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

22. 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

23. Empty constructor
 In 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.x
class class_name
{
---------
public:
class_name()
{}
};
Chapter : 7

24. Default constructor
 We 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 constructors
 Compiler define default constructor
 User define default constructor.
Chapter : 7

25. Compiler define default
constructor
 When 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

26. User define default constructor
 User 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

27. Parameterized constructor
 The 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

28. Copy constructor
 When 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
Chapter : 7

29.  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

30.  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

31. Default copy constructor
 If 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 constructor
 If a copy constructor is defined in a private section, the
objects of the class cannot call it.
Chapter : 7

32. MIL(member initialization list)
 First initialize all member of class
 The 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

33. 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

34.  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

35. 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.

36. Explicit constructor
 When a class contain a single parameterized
constructor, there are different method to invoke this
constructor function for example
 Student 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

37. Chapter : 7

39. Operator overloading
 It 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.

40.  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

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

42. Rules for operator overloading
 Only 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.

43.  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.

44. There are following operators can be
overloaded
+ - * / % ^
~ ! , = < >
& <= >= | ++ --
<< >> == != && ||
+= -= *= /= %= ^=
&= |= <<= >>= [ ] ( )
-> ->* New New[ ] Delete Delete[ ]

45. User define conversion/type
conversion
 we 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;

46.  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.

47. Type of conversions:
 Built-in data type to object (UDT)
 Object (UDT) to built-in data type
 Wrapper class
 From one object to another type of object.

48. 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.

49. Object (UDT) to built-in data type
 The 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;
}

51.  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 member
 It must not specify a return type
 It must not have any arguments.

52. Wrapper class
 Some 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.

54. From one object to another type of object
 In some cases we would like to convert one class type
data to another class type.eg. Obj1 = Obje2
 Here 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).

55. Using constructor method.

57. Using conversion function.

60.  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.

61. Type of Inheritance
 1) 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.

62.  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
{
}

63. Different form of Inheritance.

64. Derivations:
 Private:
 Public:
 Protected:

65. 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

66. Single inheritance.

69. Multiple inheritance

73. Hierarchical inheritance

75. Multilevel inheritance

77. Hybrid inheritance

79. 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.

80. 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.

83. Virtual Base Class
 If 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.

84.  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.

85.  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.

86. 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.