�ݺ�ߣ

POINTERS
 Pointer is a derived data type that refers to the address of another variable.
A pointer variable tells that where to get the data instead of telling the
actual data.
 The declaration of the pointer is based on the data type of the variable it
points to.
data-type *pointer-variable
 At any point of time a pointer variable can point to only one data type.
int *ptr;
 Here ptr contains the memory location of any integer variable.
e.g. int *ptr , a; //Declaration
ptr=&a; //Initialization

int a = 25;
int *p;
p = &a;
cout<<"&a:"<<&a;
cout<<"p:"<<p;
cout<<"&p:"<<&p;
cout<<"*p:"<<*p;
cout<<"*(&a):"<<*(&a);
(*p)++;
cout<<"*p:"<<*p;
cout<<"a:"<<a;a
25 1000
p
a
1000 2000

int a = 25;
int *p,**s;
p = &a;
s = &p;
cout<<"n*p:"<<*p;
cout<<"n*s:"<<*s;
cout<<"n**s:"<<**s;
cout<<"n*(*(&p)):"<<*(*(&p));
cout<<"n***(&s):"<<***(&s);

POINTERS WITH ARRAYS
 Pointers are associated with arrays as:
 Pointers are useful to allocate arrays dynamically
 Efficient tools to access the elements of an array.
 We can declare pointers to arrays as ;
int *ptr;
ptr = number[0]; OR ptr = number;
 An array of Pointer is an array of addresses i.e all the elements of the Pointer
array points to an item of the data array. An array of Pointer is declared as
int *abc[10];
 It is an array of ten pointers ie. Addresses all of them points to an integer.
Before initializing they point to some unknown values in the memory space.

int main ()
{
int arr[5] = {10,20,30,40,50};
int *ptr;
ptr = &arr[0];
for ( int i = 0; i < 5; i++ )
{
cout <<"*(ptr+" << i <<"):";
cout <<*(ptr + i) << endl;
}
return 0;
}

POINTERS TO OBJECTS
 Just like pointers to normal variables and functions, we can
have pointers to class members (variables and methods).
class ABC
{
public:
int a=50;
};
int main()
{
ABC ob1;
ABC *ptr;
ptr = &ob1;
cout << ob1.a;
cout << ptr->a; //
Accessing members of
class with pointer
}

class demo{
int i;
public:
demo(int x){
i=x; }
int getdata(){
return i;}
};
int main()
{
demo d[3]={55,66,77};
demo *ptr=d; //similar to *ptr=&d[0]
for(int i=0;i<3;i++)
{
cout<<ptr->getdata()<<endl;
ptr++;
}
}

Practice Program
 Create a class student having private members marks,
name and public members rollno, getdata(),
printdata(). Demonstrate concept of pointer to class
members for array of 3 objects.

THIS POINTER
 ‘this’ pointer represent an object that invoke or call a member
function.
 It will point to the object for which member function is called.
 It is automatically passed to a member function when it is
called.
 It is also called as implicit argument to all member function.
 Friend functions can not be accessed using this pointer,
because friends are not members of a class.
 Only member functions have a this pointer.
 A static member function does not have this pointer.

THIS POINTER
 Following are the situations where this pointer is used.
 When local variable’s name is same as member’s name
 To return reference to the calling object

class sample
{
int a,b;
public:
void input(int a,int b){
this->a = a + b;
this->b = a - b;
}
void output(){
cout<<"a = "<<a;
cout<<"b = "<<b;
}
};
int main()
{
sample ob1;
int a=5,b=8;
ob1.input(a,b);
ob1.output();
}

class Test
{
int x; int y;
public:
Test& setX(int a) { x = a; return *this; } //Reference to the calling object can be returned
Test& setY(int b) { y = b; return *this; }
void print() {
cout << "x = " << x ;
cout << " y = " << y;
}
};
int main()
{
Test obj1;
obj1.setX(10).setY(20); // chain function calls
obj1.print();
}

POINTERS TO DERIVED CLASS
 We can use pointers not only to the base objects but also to the objects of
derived classes.
 Pointers to the base classes are type-compatible to the objects of the derived
classes. Hence, A single pointer variable of base type can be made to point to
objects belonging to base as well as derived classes.
E.g. Here B is a base class, D is Derived class.
B *cptr;
B b;
D d;
cptr=&b;
we can also make the cptr to point to object d also.
cptr=&d;
As d is an object derived from the class B

POINTERS TO DERIVED CLASS
 We can access those members of derived class which are
inherited from base class by base class pointer.
 But we cannot access original member of derived class which
are not inherited from base class using base class pointer.
 We can access original member of derived class using pointer of
derived class.

VIRTUAL FUNCTIONS
 A virtual function is a member function that is declared within a base class
and redefined by a derived class.
 To create a virtual function, precede the function's declaration in the base
class with the keyword virtual.
 When virtual function accessed "normally," it behave just like any other type
of class member function. But when it is accessed via a pointer it supports
run time polymorphism.
 Base class and derived class have same function name and base class
pointer is assigned address of derived class object then also pointer will
execute base class function.
 After making virtual function, the compiler will determine which function to
execute at run time on the basis of assigned address to pointer of base class.

RULES FOR VIRTUAL FUNCTIONS
 The virtual functions must be member of any class.
 They cannot be static members.
 They are accessed by using object pointers.
 A virtual function can be a friend of another class.
 A virtual function in a base class must be defined, even though it may not be used.
 We cannot have virtual constructors, but we can have virtual destructors.
 The derived class pointer cannot point to the object of base class.
 When a base pointer points to a derived class, then also it is incremented or
decremented only relative to its base type. Therefore we should not use this method
to move the pointer to the next object.
 If a virtual function is defined in base class, it need not be necessarily redefined in
the derived class. In such cases, call will invoke the base class.

PURE VIRTUAL FUNCTIONS
 A pure virtual function is virtual function that has no definition within the base
class.
 A pure virtual function means ‘do nothing’ function.
 We can say empty function. A pure virtual function has no definition relative
to the base class.
 Programmers have to redefine pure virtual function in derived class, because
it has no definition in base class.
 A class containing pure virtual function cannot be used to create any direct
objects of its own.
 This type of class is also called as abstract class.

PURE VIRTUAL FUNCTIONS
 Syntax:
virtual void display() = 0;
OR
virtual void display() {}

ABSTRACT CLASS
 A class that contains at least one pure virtual function is
called abstract class.
 You can not create objects of an abstract class, you can
create pointers and references to an abstract class.

VIRUTAL DESTRUCTOR
 Deleting a derived class object using a pointer of base class
type that has a non-virtual destructor results in undefined
behavior. To correct this situation, the base class should be
defined with a virtual destructor.
 Making base class destructor virtual guarantees that the
object of derived class is destructed properly, i.e., both base
class and derived class destructors are called.

INTRODUCTION
 C++ templates are a powerful mechanism for code reuse,
as they enable the programmer to write code that
behaves the same for any data type.
 By template we can define generic classes and functions.
 In simple terms, you can create a single function or a class
to work with different data types using templates.
 It can be considered as a kind of macro. When an object
of a specific type is defined for actual use, the template
definition for that class is substituted with the required data
type.

TEMPLATES
TEMPLATES
FUNCTION TEMPLATE CLASS TEMPLATE

FUNCTION TEMPLATE
 A function template specifies how an individual function can
be constructed.
 We write a generic function that can be used for different data
types.
 Syntax:
template <class T>
T functionname(T arg1,T arg2)
{
function body;
}

• A generic function defines a general set of operations that will be applied to
various types of data.
• A generic function has the type of data that it will operate upon passed to
it as a parameter.
• Using this mechanism, the same general procedure can be applied to a
wide range of data.
• For example the Quicksort algorithm is the same whether it is applied to an
array of integers or an array of floats. It is just that the type of data being
sorted is different.
• By creating a generic function, you can define, independent of any data,
the nature of the algorithm.
• Once this is done, the compiler automatically generates the correct code
for the type of data that is actually used when you execute the function.
• In essence, when you create a generic function you are creating a function
that can automatically overload itself.
• A generic function is also called a template function. When the compiler
creates a specific version of the function, it is said to have created a
generated function.
• Generic functions may be overloaded.

Suppose you write a function printData:
void printData(int value){
cout<<"The value is "<<value;
}
Now if you want to print double values or string values, then you have to
overload the function:
void printData(float value){
}
void printData(char *value) {
cout<<"The value is "<<*value;
}
To perform same operation with different data type, we have to write same
code multiple time.

C++ provides templates to reduce this type of duplication of code.
template<class T>
void printData(T value){
}
We can now use printData for any data type. Here T is a template parameter
that identifies a type.
Then, anywhere in the function where T appears, it is replaced with whatever
type the function is instantiated.
int i=3;
float d=4.75;
char *s="hello";
printData(i); // T is int
printData(d); // T is float
printData(s); // T is string

OVERLOADED FUNCTION TEMPLATE
 Like ordinary functions, function templates can be overloaded.
 We can have different function definitions with the same function name so that when
that name is used in a function call, a C++ compiler must decide which one of the
various functions to call.
 The rules for this decision may become rather complicated, even without templates.
 Generic functions perform the same operation for all the versions of a function except
the data type differs.
 The overloading resolution is accomplished as follows:
 Call an ordinary function that has an exact match.
 Call a template function could be created with an exact match.
 Try normal overloading resolution to ordinary functions and call the one that matches.
 An error is generated if no match is found. Note that no automatic conversions are
applied to arguments on the template functions.

CLASS TEMPLATE
 Sometimes, you need a class implementation that is same for all classes, only the data
types used are different.
 Normally, you would need to create a different class for each data type OR create
different member variables and functions within a single class.
 Syntax:
template <class type>
class classname
{
type member1;
public:
type fun();
};

CLASS TEMPLATE
 The object of template class is created as follows
class name <data type> object name;

template<class Ttype>
class sample
{
Ttype a,b;
public:
void getdata()
{
cin>>a>>b;
}
void sum();
};
int main()
{
sample <int>s1;
sample <float>s2;
s1.getdata();
s1.sum();
s2.getdata();
s2.sum();
}

• Generic classes are useful when a class contains generalizable
logic.
• For example, the same algorithm that maintains a queue of
integers will also work for a queue of characters. Also, the same
mechanism that maintains a linked list of mailing addresses will
also maintain a linked of auto part information.
• By using a generic class, you can create a class that will
maintain a queue, a linked list, and so on for any type of data.
• The compiler will automatically generate the correct type of
object based upon the type you specify when the object is
created.
• C++ provides a library that is built upon template classes. This
library is usually referred to as the Standard Template Library, or
STL for short.
• It provides generic versions of the most commonly used
algorithms and data structures.

CLASS TEMPLATE INHERITANCE
 The template class can also act as base class.
 There are 3 cases:-
 Derive a template class and add new member to it, the base class must be
of template type.
 Derive a class from non-template class add new template type members
to derive class.
 Derive a class from a template base class and omit the template features
in the derive class.
 This can be done by declaring the type while deriving the class.
 All the template based variables are substituted with basic data type.

SUMMARY
 C++ supports a mechanism known as template to implement the concept of generic
programming.
 Template allows us to generate a family of classes or a family of functions to handle different
data types.
 Template classes and functions eliminate code duplication for different types and thus make
the program development easier and more manageable.
 We can use multiple parameters in both the class templates and function templates.
 A specific class created from a class template is called a template class and the process of
creating a template class is known as instantiation.
 Like other functions, template functions can be overloaded.
 Member function of a class template must be defined as function templates using the
parameters of the class template.
 We may also use non type parameters such basic or derived data types as arguments
templates.

CONTAINERSHIP
 We can create an object of one class into another and that
object will be a member of the class. This type of relationship
between classes is known as containership or has_a relationship
as one class contain the object of another class.
 And the class which contains the object and members of
another class in this kind of relationship is called a container class.
 The object that is part of another object is called contained
object, whereas object that contains another object as its part or
attribute is called container object.

CONTAINERSHIP
 Syntax:
Class a //contained class
{
..
..
}
Class b //container class
{
..
a A;
…
}

�ݺ�ߣ

6be10b153306cc41e65403247a14a4dba5f9186aCHAPTER 2_POINTERS, VIRTUAL FUNCTIONS.pptx

Recommended

More Related Content

Similar to 6be10b153306cc41e65403247a14a4dba5f9186aCHAPTER 2_POINTERS, VIRTUAL FUNCTIONS.pptx (20)

Recently uploaded (20)

6be10b153306cc41e65403247a14a4dba5f9186aCHAPTER 2_POINTERS, VIRTUAL FUNCTIONS.pptx

Editor's Notes