DS Unit 6.ppt

Static Class Members,
this pointer,
Friend functions,
Dynamic memory management with operators new and delete,
Overloading: Function Overloading, Operator Overloading,
Restrictions on Operator Overloading, Overloading unary and
binary operators,
Type Conversion
Templates,
Inheritance.

Static Class Members
Characteristics of static data members:
 Static class variable is efficient when a single copy of data is enough.
 It is initialized to zero when the first object of its class is created.
 Only one copy of that member is created for the entire class and is shared by
all the objects of that class, no matter how many objects are created
 They exist when the program starts to execute and continue to exist
throughout the program's entire lifetime.
 It can be public, private or protected.
Accessing static class variables:
– public static variables
• Can also be accessed using scope resolution operator(::)
Employee::count;
– private static variables
• Can only be accessed via public member function.
Employee::getCount();

Static member function
Characteristics of static member function:
 A static function can be have access to only other static members (functions
or variables) declared in the same class.
 That is, it cannot access non-static data or functions.
 A static member function can be called using the class name (instead of its
objects) as follows:
class-name :: function-name;
 No this pointer for static functions.

#include<iostream.h>
#include<conio.h>
class SE{
public:
int i;
static int count;
};
int SE::count;
void main(){
SE s1,s2,s3;
clrscr();
s1.i=10;
s2.i=20;
s3.i=30;
s1.count=100;
s2.count=200;
s3.count=300;
cout<<s1.i<<" "<<s2.i<<" "<<s3.i<<"n";
cout<<s1.count<<" "<<s2.count<<" "<<s3.count;
getch();
}
Example program for Static Class Variable
Output:
10 20 30
300 300 300
30
S3
i
20
S2
i
10
S1
i
300
count
(Common to all three objects)

#include<conio.h>
class test {
int code;
static int count;
public:
void setcode(void) {
code=++count;
}
void showcode(void) {
cout<<"object number:"<<code<<"n";
}
static void showcount(void) {
cout<<"count:"<<count<<"n";
}
};
int test :: count;
int main()
{
test t1,t2;
t1.setcode();
t2.setcode();
test :: showcount();
test t3;
t3.setcode();
test ::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
getch();
return 0;
}
Example program for Static member function
count:2
count:3
object number:1
object number:2
object number:3

“this” Pointer
 Within a member function, the this keyword is a pointer to the current object,
i.e. the object through which the function was called.
 C++ passes a hidden this pointer whenever a member function is called.
 Within a member function definition, there is an implicit use of this pointer
for references to data members.
 The this pointer is a constant pointer.
 Every object has access to its own address through a pointer called this.
 A static member function does not have a this pointer.
 this pointer is not counted for calculating the size of the object. (sizeof)
 Member functions use the this pointer implicitly or explicitly
 Implicitly when accessing members directly
 Explicitly when using keyword this

/*Example program for this keyword*/
#include<conio.h>
class basic {
int i;
float f;
public:
basic getdata(int i,float f) {
this->i=i;
this->f=f;
return *this;
}
void display() {
cout<<"ni value is: "<<i;
cout<<"nf value is: "<<f<<"nn";
}
};
void main()
{
basic b,b1;
clrscr();
b1=b.getdata(100,1.6734);
b.display();
b1.display();
getch();
}
i value is: 100
f value is: 1.6734
i value is: 100
f value is: 1.6734

Friend Functions
 The functions that are declared with the keyword friend are known as friend
functions.
 The function declaration should be preceded by the keyword friend.
 A friend function, although not a member function of a class, has full
access rights to the private members of the class.
 The function definition should not use friend keyword.
Friend types:
 Friend non-member function
 Friend member function
 Friend class

 Friend non-member function: It is a function which does not belong to any
class. Non-member function can access private members of the class by
making this function as friend to the class.
 Member function of one class say X can access the private members of
another class say Y by making member function of class X as friend to
class Y.
 Friend class: Member functions (all) of one class say X can access the
private members of another class say Y by making class X as friend to
class Y.

To declare a function as a friend function, prefix its prototype with the
keyword friend.
Syntax:
class MyClass {
………. . .
friend void func1(MyClass c1, . . . ); //non-member function
friend void MyClass :: memfunc(. . .); //member function
friend class OtherClass; //class as a friend class
};

//non-member function as a friend
function
class ABC{
……
……
public:
……
……
friend void xyz(void);
//declaration
};
//member function as a
//friend function
class X{
……
……
public:
……
……
int fun1();
….....
};
class Y
……
……
friend int X :: fun1();
//fun1 of X is friend of Y
….....
};
//class as a friend class
class Z{
……
……
friend class X;
//all member functions of X
//are friends to Z.
….....
};

Characteristics of friend function:
 It is not in the scope of the class to which it has been declared as friend.
 Since it is not in the scope of the class, it cannot be called using the object
of that class.
 It can be invoked like a normal function without the help of any object.
 Unlike member functions, it cannot access the member names directly and
has to use an object name and dot membership operator with each
member name.
 It can be declared either in the public or the private part of a class without
affecting its meaning.
 Usually, it has the objects as arguments.

//Example program for friend
//function.
#include<conio.h>
class record {
int marks;
public:
void readmarks(){
cout<<endl<<"Enter marks:";
cin>>marks;
}
void writemarks() {
cout<<"Original marks "<<marks;
}
friend void modify(record);
//friend function declaration
// under public specifier
};
void modify(record r) {
// friend function definition
// friend function takes object as a
//parameter
r.marks=r.marks+20;
cout<<"Modified marks "<<r.marks;
}
void main()
{
record r;
clrscr();
r.readmarks();
r.writemarks();
modify(r);
getch();
}
Enter marks:40
Original marks 40
Modified marks 60

Dynamic Memory Allocation with Operators
new and delete
 new and delete
 Better dynamic memory allocation than C’s malloc and free.
 new: Automatically creates object of proper size, calls constructor, returns
pointer of the correct type.
 delete: Destroys object and frees space.
Example:
 typeName *typeNamePtr;
 Creates pointer to a typeName object
 typeNamePtr = new typeName;
 new creates typeName object, returns a pointer (typeNamePtr)
 delete typeNamePtr;
 Calls destructor for typeName object and frees memory.

//Example program for new and delete operators.
class basic{
int i;
float f;
public:
basic(){
i=100;
f=67.423;
}
~basic(){
cout<<"Destructor called";
}
void display()
{
cout<<"i and f values:"<<i<<" "<<f;
}
};
void main()
{
basic *ptr=new basic;
//default constructor is invoked
ptr->display();
delete ptr;
//destructor is invoked
}
i and f values: 100 67.423
Destructor called.

Function Overloading
 Overloading refers to the use of the same thing for different purposes.
 That is, creating several functions with the same name to perform different
tasks.
 The signature of a function consists of the function name and its formal
parameter list.
 Two functions have different signatures if they have either different names or
different formal parameter lists.
 Two functions are said to have different formal parameter lists if both
functions have:
 A different number of formal parameters, or
 If the number of formal parameters is same, then the data type of the
formal parameters, in the order you list them, must differ in at least one
position.

The following function functionabc() can be overloaded:
void functionabc();
void functionabc(int);
void functionabc(double);
void functionabc(int, int);
int functionabc(int, float);
The following function functionxyz() can’t be overloaded:
int functionxyz(int,float);
void functionxyzs(int,float);
 Both of these function headings have the same name and same formal
parameter list.
 Therefore, these function headings to overload the function functionxyz are
incorrect. In this case, the compiler will generate a syntax error.

//Function overloading example1
#include <iostream.h>
int myfunc(int i)
{
return i;
}////myfunc with one parameter
int myfunc(int i, int j)
{
return i*j;
} //myfunc with two parameters
void main()
{
cout <<myfunc(10) ;
cout <<myfunc(4, 5);
}
//Function overloading example2
int add(int x,int y)
{
return x+y;
}
float add(float x,float y)
{
return x+y;
}
void main()
{
cout<<add(100,200);
cout<<add(100.0,200.0);
}
Output:
10
20
Output:
300
300.0

Operator Overloading
 Operator overloading is one of the important features of C++ language. It is
called compile time polymorphism.
 Operator overloading is used to apply operators to operate on user defined
data. The operators are classified into unary and binary operators.
 Operator overloading is done with the help of a special function, called
operator function, which describes the special task to an operator.
 Operator functions must either be member functions (non-static) or friend
functions.

The general form of an operator function declaration and definition are:
Declaration:
return-type operator operatorsymbol(arglist);
Definition :
return-type class-name :: operator operatorsymbol(arglist)
{
//function body
}
Here arglist not required for unary operator overloading but it is required
for binary operator overloading.

The process of overloading involves the following steps:
1. Create a class that defines the data type that is to be used in the
overloading operation.
2. Declare the operator function operator op() in the public part of the class.
It may be either a member function or a friend function.
3. Define the operator function to implement the required operations.
Overloaded operator function can be invoked by expressions such as
op x or x op for unary operators and
x op y for binary operators
Here op is an operator, x and y are objects.

Rules for Overloading Operators
 Only existing operators can be overloaded. New operators cannot be
overloaded.
 The overloaded operator must have at least one operand that is user-defined
type.
 We cannot change the basic meaning of an operator.
 Overloaded operators follow the syntax rules of the original operators they
cannot be overridden.
 We cannot use friend functions to overload certain operators. However,
member functions can be used to overload them.

Unary Operator Overloading
 Unary operator takes only one operand.
 Unary operators are unary -, ++, - -, etc.,
 For example a minus operator takes one operand (-m).
 We know that this operator changes the sign of an operand when applied
to a basic data item.
Syntax: return-type class-name :: operator operatorsymbol()
{
//function body
}
 In unary operator overloading, function takes no arguments.

#include<conio.h>
class minus {
int i;
public:
void read() {
cout << "Enter number:";
cin >> i;
}
void write() {
cout << i;
}
void operator -()
{
i = - i;
}
};
void main()
{
clrscr();
minus m;
m.read();
cout << “Value before overloading is: ";
m.write();
-m;
cout << “Value after overloading is: ";
m.write();
}
//Example program for unary operator overloading
Enter number: 20
Value before overloading is: 20
Value before overloading is: -20

Binary Operator Overloading
 Binary operator takes two operands.
 Binary operators are + , -, *, etc.,
 For example a plus operator takes two operands (a + b).
Syntax: return-type class-name :: operator operatorsymbol(arglist)
{
//function body
}
 In binary operator overloading, function takes one parameter.
 The binary overloaded operator function takes the first object as an
implicit operand and the second operand must be passed explicitly.
 The data members of the first object are accessed without using the dot
operator whereas, the second argument members can be accessed using the
dot operator if the argument is an object.

class complex {
float x, y;
public:
complex(){ }
complex(float real,float imag) {
x = real;
y = imag;
}
complex operator + (complex c);
void display(void);
};
complex complex:: operator +
(complex c) {
complex temp;
temp.x = x + c.x;
temp.y = y + c.y;
return temp;
}
void complex :: display(void) {
cout << x “ +j ” << y << “n”;
}
void main() {
complex c1,c2,c3;
c1 = complex (2.5, 3.5);
c2 = complex (1.6, 2.7);
c3 = c1 + c2;
cout << “c1 = ”; c1.display();
}
Output:
c1 = 2.5 + j3.5
c2 = 1.6 + j2.7
c3 = 4.1 + j6.2
//Example program for binary operator overloading

 All operators can be overloaded except the following operators.
Operator category Operators
Membership operator .
Scope resolution operator ::
Conditional operator ?:
Pointer-to-member operator *
Sizeof operator sizeof()

C++ operators that can be overloaded:
C++ Operators that cannot be overloaded:
Operators that can be overloaded
+ - * / % ^ & |
~ ! = < > += -= *=
/= %= ^= &= |= << >> >>=
<<= == != <= >= && || ++
-- ->* , -> [] () new delete
new[] delete[]
Operators that cannot be overloaded
. .* :: ?: sizeof

Restrictions on Operator Overloading
Overloading restrictions:
– Precedence of an operator cannot be changed
– Associativity of an operator cannot be changed.
– Arity (number of operands) cannot be changed.
• Unary operators remain unary, and binary operators remain binary.
• Operators &, *, + and - each have unary and binary versions.
• Unary and Binary versions can be overloaded separately.
No new operators can be created.
– Use only existing operators
No overloading operators for built-in types.
– Cannot change how two integers are added.
– Produces a syntax error.
– Example:
int operator + ( int x, int y );

Type conversion
Converting one data type to another data type is called type conversion.
Example:
int a;
float b = 3.14;
a=b;
cout <<“a = “ << a;
a= 3
What happens when they are user defined data types?
Example:
obj1 = obj2 + obj3; // obj1, obj2, obj1 are class type objects.
There are three un-compatible types:
1. Conversion from basic data type to class type.
2. Conversion from class type to basic data type.
3. Conversion from one class type to another class type.

1. Conversion from basic data type to class type:
 To convert data from a basic type to a user defined type (class type),
the conversion function should be defined in the class in the form of
constructor.
 Constructor with one argument.
 This constructor function takes a single argument of basic data
type(int, float, double).
 In the constructor function, write the steps for converting basic to
object type.
2. Conversion from class type to basic data type:
 In this case, define an operator function also called as conversion
function in the class.
 Operator function is defined as an overloaded basic data- type which
takes no arguments.
 It converts object to basic types and returns a basic data item.
Syntax:
operator basic-data-type()
{
// steps to convert
}

class temperature {
float celsius;
public:
temperature() {
celsius=0.0;
}
temperature(float fahrenheit){
// fahrenheit to celsius
celsius=(fahrenheit-32)*5/9;
}
operator float() {
float f;
// celsius to fahrenheit
f=((celsius*9/5)+32);
return f;
}
void gettemp() {
cout<<"n Enter the temparature celsius: ";
cin>>celsius;
}
void showtemp() {
cout<<"n Temperature in celsius=“ << celsius;
}
};
void main() {
temperature t1,t2;
float fa;
cout<<“Enter the temparature in farhenheit: ";
cin>>fa;
t1 = fa; /*invokes constructor with argument*/
t1.showtemp();
float ce;
t2.gettemp();
ce = t2; /* invokes the operator function*/
cout<<"nTemparature in farhenheit:“ << ce;
}
/*Example program for converting basic to class type and class type to basic type*/

3. Conversion from one class type to another class type:
 There is a situation where we need to convert one class type to another
class type.
Example: ab = xy;
where ab is an object of class ABC and xy is an object of class XYZ.
XYZ is called source class and ABC are called destination class.
 For this type conversion also we can use any of the conversions
methods like constructor with one argument and operator conversion
function.
 Choice of these two methods depends on the whether the conversion
function should be used in source class or destination class.
 In source class implement the operator conversion function.
 In destination class define the constructor with one argument.

Conversion (operator function) function in source class:
class ABC //destination class
{
………members of class ABC
………
};
class XYZ // source class
{
public:
operator ABC()
{
}
};
Name of destination class.
Conversion operator function

class celsius {
float cels;
public:
celsius() {
cels=0.0;
}
celsius(float farh) {
cels=farh;
}
void show() {
cout<<“Celsius=“<<cels;
}
};
class farhenheit {
float f;
public:
farhenheit() {
f=0.0;
}
operator celsius() {
return ( celsius((f-32)*5/9) );
}
void gettemp() {
cout<<"n enter the temparature";
cin>>f;
}
};
void main() {
celsius c1;
farhenheit f1;
f1.gettemp();
// uses the operator function in source class farhenheit
c1=f1;
c1.show();
}
/*Example program for converting basic to class type and class type to basic type*/

Conversion function (constructor function) in destination class:
class ABC // destination class
{
public:
ABC(XYZ xy)
{
……..
………
}
};
class XYZ // source class
{
………
……….
};
Object of the source class.

Templates
 Templates support generic programming, which allows to develop reusable
software components such as functions, classes, etc., supporting different
types in a single framework.
 Templates are also called generics.
 Template can be used to create a family of classes and functions.
 Example, we can define a template for a function, say mul(),that would help
us create various versions of mul() for multiplying int, float and double type
values.
 Template is defined with a parameter that would be replaced by the
specified data type at the time of actual use of the class or function.

Function templates
 Function templates are used to create a group of related functions.
 Function template is also called generic function.
Syntax of function template:
template <class T, . . . >
return-type function-name (arguments of type T)
{
//body of template function
}
 A function template is prefixed with the keyword template and a list of
template type arguments. These template-type arguments are called generic
data types.
 One of the arguments must be template type.

//Example program for swapping any two elements using function template.
template <class T>
void swap(T &x, T &y) {
T temp;
temp=x;
x=y;
y=temp;
}
void main() {
int a=10,b=20;
cout<<endl<<"Before swapping a and b values are..."<<a<<" "<<b;
swap(a, b);
cout<<endl<<"After swapping a and b values are..."<<a<<" "<<b;
char c='A', d='B';
cout<<endl<<"Before swapping c and d values are..."<<c<<" "<<d;
swap(c, d);
cout<<endl<<"After swapping c and d values are..."<<c<<" "<<d;
}
Output:
Before swapping a and b values are... 10 20
After swapping a and b values are... 20 10
Before swapping c and d values are... A B
After swapping c and d values are... B A

Function with two generic types
We can define more than one generic data type in the template statement by
using a comma-separated list.
For example, the following program creates a template function that has two
generic types.
template <class T1, class T2>
void myfunc(T1 x, T2 y)
{
cout<<endl<< x <<” “<< y;
}
void main()
{
myfunc(10, "I like C++");
myunc(98.6, 19);
myfunc(“Hello”,”World”);
}
Output:
10 I like C++
98.6 19
Hello World

Class templates
 Class templates are used to create a group of related classes.
 Class template is also called generic class.
Syntax of class template declaration:
template <class T1, class T2, . . .>
class class-name
{
//data members of generic types T1, T2, . . .
//functions with arguments of type T1, T2, . . .
};
Here T1, T2, . . . are generic types.
 Once you have created a generic class, you create an object of that class using
the following general form:
class-name <char, int> obj;
Here obj is an object of type class-name.
char and int are substituted for generic types T1 and T2.

//Example program for class template
template<class T>
class sample {
T x;
T y;
public:
void read(){
cin>>x>>y;
}
void write(){
cout << "x and y: "<<x<<" "<<y;
}
};
void main()
{
sample <char> cs;
//char is substituted for generic type T
cout << "Enter two characters:";
cs.read();
cs.write();
sample <int> ci;
//int is substituted for generic type T
cout << "Enter two integers:";
ci.read();
ci.write();
} Enter two characters: A c
x and y: A c
Enter two integers: 10 100
x and y: 10 100

Using non-type arguments with template class:
 In template class, you may also specify non-type arguments. That is, in a
template class you can specify what you want.
 The following program contains template class which is having one generic
type T and one non-type integer argument.
template<class T,int n>
class data
{
T value;
public:
void read()
{
cin>>value;
}
void write()
{
cout<< "Values are:"<<value<<" "<<n;
}
};
void main()
{
data <char,10> dc;
//char is substituted for T
//and 10 is assigned to n
cout << "Enter character:";
dc.read();
dc.write();
data <int,5> di;
//int is substituted for T
//and 5 is assigned to n
cout << "Enter integer:";
di.read();
di.write();
}
Enter character: B
Values are: B 10
Enter integer: 22
Values are: 22 5

Inheritance
 Inheritance is the process of acquiring the properties from the base class to
derived class.
 That is, it is the process of creating new class from the existing class.
 pExisting class is known as base class or arent class or super class and new
class is known as derived class or child class or sub class.
 In inheritance base class members are inherited to derived class and also new
members can be added to derived class.
 Inheritance provides the reusability mechanism.

Syntax of derived class declaration:
class derived-class-name : [visibility mode] base-class-name
{
//members of derived class
//and they can access members of the base class
};
 The derivation of derived class from the base class is indicated by the colon (:).
 The default visibility mode is private. If the visibility mode is specified, it
must be either private or protected or public.
 Visibility mode specifies whether the features of the base class are privately or
protected or publicly inherited.

The following are the four possible styles of derivation:
1. class D : private B //private derivation
{
//members of D
};
2. class D : protected B //protected derivation
{
//members of D
};
3. class D : public B //public derivation
{
//members of D
};
4. class D : B //private derivation by default
{
//members of D
};

Types of Inheritance
 Single Inheritance
 Multiple Inheritance
 Multilevel Inheritance
 Hierarchical Inheritance
 Hybrid Inheritance

Single Inheritance
 Derivation of a class from only one base class is called single inheritance.
Syntax:
class A
{
//members of A
};
class B : public A
{
//members of B
};
A
B

/*Example program to demonstrate
Single Inheritance (public
derivation)*/
class B {
int a; /*private; not inheritable*/
public:
int b; /*public; inheritable*/
void get_ab(){
a = 5;
b = 10;
}
int get_a(){
return a;
}
void show_a(){
cout << "a = " << a << "n";
}
};
class D : public B {
int c;
public:
void mul(){
c = b * get_a();
}
void display(){
cout << "a = " << get_a() << "n";
cout << "b = " << b << "n";
cout << "c = " << c << "nn";
}
};
void main() {
D d;
d.get_ab();
d.mul();
d.show_a();
d.display();
d.b = 20;
d.mul();
d.display();
}
a = 5
a = 5
b = 10
c = 50
a = 5
b = 20
c = 100
Output:

 Derivation of a class from several (two or more) base classes is called
multiple inheritance.
Syntax:
class A {
//members of A
};
class B {
//members of B
};
class C : public A, public B
{
//members of C
};
Multiple Inheritance
A B
C

/*Example program to demonstrate Multiple Inheritance*/
class M {
protected:
int m;
public:
void get_m(int x){
m = x;
}
};
class N {
protected:
int n;
public:
void get_n(int y) {
n = y;
}
};
class P : public M, public N{
public:
void display(){
cout << “m = ” << m << “n”;
cout << “n = ” << n << “n”;
cout << “m * n= ” << m * n << “n”;
}
};
void main() {
P p;
p.get_m(10);
p.get_n(20);
p.display();
} Output:
m = 10
n = 20
m * n = 200

 Derivation of a class from another derived class is called multilevel
inheritance.
Syntax:
class A {
//members of A
};
class B : public A
{
//members of B
};
class C : public B
{
//members of C
};
A
B
C
Multilevel Inheritance

class student{
protected:
int roll_num;
public:
void get_number(int a){
roll_num = a;
}
void put_number(){
cout << “Roll Number:” << roll_num << “n”;
}
};
class test : public student{
protected:
float sub1,sub2;
public:
void get_marks(float x, float y) {
sub1 = x;
sub2 = y;
}
void put_marks() {
cout << “Marks in Sub1 = ” << sub1 << “n”;
cout << “Marks in Sub2 = ” << sub2 << “n”;
}
};
/*Example program to demonstrate Multilevel Inheritance*/
class result : public test {
float total;
public:
void display(){
total = sub1 + sub2;
put_number();
put_marks();
cout << “Total = ” << total ;
}
};
main() {
result student1;
student1.get_number(111);
student1.get_marks(75.0,59.5);
student1.display();
}
Output:
Roll Number: 111
Marks in Sub1 = 75
Marks in Sub2 = 59.5
Total = 134.5

 Derivation of several classes from a single base class is called hierarchical
inheritance.
Syntax:
class A {
//members of A
};
class B : public A
{
//members of B
};
class C : public A
{
//members of C
};
A
B C
Hierarchical Inheritance

 Derivation of a class involving more than one form of inheritance is known as
hybrid inheritance.
 Hybrid inheritance involves more than one form of inheritance namely
multilevel and multiple.
Hybrid Inheritance
A
B C
D

Constructors and Inheritance
C++ Construction Order:
1. Base class data members are constructed in order of declaration.
2. Base class constructor is called.
3. Derived class data members are constructed in order.
4. Derived class constructor is executed.
Destructor order (reverse of constructor order):
1. Derived class destructor is executed.
2. Derived class data members are destroyed.
3. The base class destructor is called.
4. Base class data members are destroyed.

DS Unit 6.ppt

More Related Content

Similar to DS Unit 6.ppt (20)

Recently uploaded (20)

DS Unit 6.ppt